X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=client.c;h=f72719f27df46b012165a9e8c8bde3586d602a95;hb=71386e2530fa351d22f942ce3cf9d18eee99ce78;hp=ce66ea7b7159c101d77896b09c77f433d1f05c54;hpb=adbf9f09c9bf2a680c61b1ef3541c04f1cde97cf;p=paraslash.git diff --git a/client.c b/client.c index ce66ea7b..f72719f2 100644 --- a/client.c +++ b/client.c @@ -1,318 +1,681 @@ -/* - * Copyright (C) 1997-2006 Andre Noll - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ +/* 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 "client.lsg.h" #include "para.h" -#include "config.h" -#include -#include -#include "client.cmdline.h" +#include "list.h" +#include "sched.h" #include "crypt.h" -#include "rc4.h" -#include -#include "net.h" #include "string.h" +#include "stdin.h" +#include "stdout.h" +#include "client.h" +#include "buffer_tree.h" +#include "error.h" +#include "version.h" -/* A static variable for holding the line. */ -static char *line_read; +/** Array of error strings. */ +DEFINE_PARA_ERRLIST; -struct gengetopt_args_info args_info; +static struct sched sched; +static struct client_task *ct; +static struct stdin_task sit; +static struct stdout_task sot; -/* - * client log function - */ -void para_log(int ll, const char* fmt,...) +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) { - va_list argp; - FILE *outfd; + struct exec_task *et = context; + int ret = btr_node_status(et->btrn, 0, BTR_NT_LEAF); - /* ignore log message if loglevel is not high enough */ - if (ll < args_info.loglevel_arg) - return; - if (ll < WARNING) - outfd = stdout; - else - outfd = stderr; - va_start(argp, fmt); - vfprintf(stdout, fmt, argp); - va_end(argp); + if (ret != 0) + sched_min_delay(s); } -/* - * Read a string, and return a pointer to it. Returns NULL on EOF. - */ -static char *rl_gets(void) +static int exec_post_select(__a_unused struct sched *s, void *context) { - free(line_read); - /* Get a line from the user. */ - line_read = readline("para_client> "); - /* If the line has any text in it, save it on the history. */ - if (line_read && *line_read) - add_history(line_read); - return line_read; + 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; } -/* - * do several cleanups on sigint - */ -static void sigint_handler(__unused int i) +/* Called from the line handler and the completers. This overwrites ct->lpr. */ +static int create_merged_lpr(const char *line) { - rl_cleanup_after_signal(); - rl_reset_after_signal(); + 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; } -void get_options(int argc, char *argv[], - char **config_file, char **key_file) +/* called from completers */ +static int execute_client_command(const char *cmd, char **result) { - char *home; - static char default_key_file[_POSIX_PATH_MAX] = ""; - static char default_config_file[_POSIX_PATH_MAX] = ""; - struct stat statbuf; 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; - cmdline_parser(argc, argv, &args_info); - if (!args_info.user_given) - args_info.user_arg = para_logname(); - if (!args_info.key_file_given) { - home = para_homedir(); - sprintf(default_key_file, "%s/.paraslash/key.%s", home, - args_info.user_arg); - free(home); - } - if (!args_info.config_file_given) { - home = para_homedir(); - sprintf(default_config_file, "%s/.paraslash/client.conf", - home); - free(home); + *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) +{ + 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 (!args_info.config_file_given) - *config_file = default_config_file; - else - *config_file = args_info.config_file_arg; - ret = stat(*config_file, &statbuf); - if (ret && args_info.config_file_given) { - fprintf(stderr, "can not stat config file %s\n", - args_info.config_file_arg); - exit(EXIT_FAILURE); + 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 (!ret) - cmdline_parser_configfile(*config_file, &args_info, 0, 0, 0); - if (!args_info.key_file_given) - *key_file = default_key_file; + 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 - *key_file = args_info.key_file_arg; + return; + i9e_extract_completions(ci->word, cmds, &cr->matches); } -static RC4_KEY rc4_recv_key; -static RC4_KEY rc4_send_key; -static unsigned char rc4_buf[2 * RC4_KEY_LEN]; +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 rc4_send(unsigned long len, const unsigned char *indata, unsigned char *outdata) +static void ls_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) { - RC4(&rc4_send_key, len, indata, outdata); + 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 rc4_recv(unsigned long len, const unsigned char *indata, unsigned char *outdata) +static void setatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) { - RC4(&rc4_recv_key, len, indata, outdata); + 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); } -void (*crypt_function_recv)(unsigned long len, const unsigned char *indata, unsigned char *outdata); -void (*crypt_function_send)(unsigned long len, const unsigned char *indata, unsigned char *outdata); +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 append_str(char **data, const char* append) +static void mvatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) { - if (*data) { - char *tmp = make_message("%s\n%s", *data, append); - free(*data); - *data = tmp; - } else - *data = para_strdup(append); + complete_attributes(ci->word, &cr->matches); } -/* - * MAIN - */ -int main(int argc, char *argv[]) +static void rmatt_completer(struct i9e_completion_info *ci, + struct i9e_completion_result *cr) { + complete_attributes(ci->word, &cr->matches); +} - int sockfd, numbytes, i, interactive, received, ret; - struct hostent *he; - struct sockaddr_in their_addr; - char *command = NULL; - char buf[8192]; - char *auth_str; - char *key_file, *config_file; - long unsigned challenge_nr; - char *line; - - get_options(argc, argv, &config_file, &key_file); - if (args_info.loglevel_arg <= NOTICE) - cmdline_parser_print_version(); - PARA_INFO_LOG( - "current loglevel: %d\n" - "using config_file: %s\n" - "using key_file: %s\n" - "connecting to %s:%d\n", - args_info.loglevel_arg, - config_file, - key_file, - args_info.hostname_arg, - args_info.server_port_arg - ); - interactive = args_info.inputs_num == 0? 1 : 0; - if (interactive) { - PARA_NOTICE_LOG("%s", "no command, entering interactive mode\n"); - signal(SIGINT, sigint_handler); - } else { - /* not interactive, concat args */ - for (i = 0; i < args_info.inputs_num; i++) - append_str(&command, args_info.inputs[i]); - } -interactive_loop: - crypt_function_recv = NULL; - crypt_function_send = NULL; - if (interactive) { - int i = 0; - char *p; - - rl_save_prompt(); - rl_message("\n"); - rl_kill_full_line(0, 0); - rl_free_line_state(); - /* read a line via readline */ - line = rl_gets(); - if (!line) - return 0; - if (!line[0]) - goto interactive_loop; - p = line; - while (sscanf(p, "%200s%n", buf, &i) == 1) { - append_str(&command, buf); - p += i; - } - } - /* get the host info */ - PARA_NOTICE_LOG("getting host info of %s\n", - args_info.hostname_arg); - if (!(he = get_host_info(args_info.hostname_arg))) - exit(EXIT_FAILURE); - /* get new socket */ - if ((sockfd = get_socket()) < 0) - exit(EXIT_FAILURE); - /* init their_addr */ - init_sockaddr(&their_addr, args_info.server_port_arg, he); - /* Connect */ - PARA_NOTICE_LOG("connecting to %s...\n", - args_info.hostname_arg); - if (para_connect(sockfd, &their_addr) < 0) - exit(EXIT_FAILURE); - /* Receive Welcome message */ - if ((numbytes = recv_buffer(sockfd, buf, sizeof(buf))) < 0) - exit(EXIT_FAILURE); - /* send auth command */ - auth_str = make_message("auth %s%s", args_info.plain_given? "" : "rc4 ", - args_info.user_arg); - PARA_INFO_LOG("<-- %s--> %s\n", buf, auth_str); - if (send_buffer(sockfd, auth_str) < 0) - exit(EXIT_FAILURE); - /* receive challenge number */ - if ((numbytes = recv_buffer(sockfd, buf, sizeof(buf))) < 0) - exit(EXIT_FAILURE); - if (numbytes != 64) { - PARA_EMERG_LOG("did not receive valid challenge (got %i bytes)\n", - numbytes); - buf[numbytes] = '\0'; - PARA_ERROR_LOG("received the following instead: %s\n", buf); - goto write_out; +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; } - PARA_INFO_LOG("<-- [challenge (%i bytes)]\n", numbytes); - /* decrypt challenge number */ - ret = para_decrypt_challenge(key_file, &challenge_nr, (unsigned char *) buf, - numbytes); - if (ret < 0) { - PARA_EMERG_LOG("decrypt error (%d). Bad secret key?\n", ret); - exit(EXIT_FAILURE); + cr->filename_completion_desired = true; +} + +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); } - /* send decrypted challenge */ - PARA_INFO_LOG("--> %lu\n", challenge_nr); - if (send_va_buffer(sockfd, "%s%lu", CHALLENGE_RESPONSE_MSG, challenge_nr) < 0) - exit(EXIT_FAILURE); - /* Wait for approval */ - PARA_NOTICE_LOG("%s", "waiting for approval from server\n"); - if ((numbytes = recv_buffer(sockfd, buf, sizeof(buf))) < 0) - exit(EXIT_FAILURE); - PARA_INFO_LOG("++++ server info ++++\n%s\n++++ end of server " - "info ++++\n", buf); - /* Check if server has sent "Proceed" message */ - if (!strstr(buf, PROCEED_MSG)) { - PARA_EMERG_LOG("%s", "authentication failed\n"); - exit(EXIT_FAILURE); + 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 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 (numbytes >= PROCEED_MSG_LEN + 32) { - PARA_INFO_LOG("%s", "decrypting session key\n"); - if (para_decrypt_buffer(key_file, rc4_buf, - (unsigned char *)buf + PROCEED_MSG_LEN + 1, - numbytes - PROCEED_MSG_LEN - 1) < 0) { - PARA_EMERG_LOG("%s", "error receiving rc4 key\n"); - exit(EXIT_FAILURE); - } - RC4_set_key(&rc4_send_key, RC4_KEY_LEN, rc4_buf); - RC4_set_key(&rc4_recv_key, RC4_KEY_LEN, rc4_buf + RC4_KEY_LEN); - PARA_INFO_LOG("rc4 encrytion activated: %x:%x:%x:%x\n", - rc4_buf[0], rc4_buf[1], rc4_buf[2], rc4_buf[3]); - crypt_function_recv = rc4_recv; - crypt_function_send = rc4_send; + if (ct->status == CL_SENDING) { + stdin_task_register(&sit, s); + return -E_TASK_STARTED; } - /* send command */ - PARA_INFO_LOG("--> %s\n", command); - if (send_buffer(sockfd, command) < 0) - exit(EXIT_FAILURE); - free(command); - command = NULL; - if (send_buffer(sockfd, EOC_MSG "\n") < 0) - exit(EXIT_FAILURE); - PARA_NOTICE_LOG("%s", "command sent.\n"); -write_out: - received = 0; - /* write server output to stdout */ - while ((numbytes = recv_bin_buffer(sockfd, buf, sizeof(buf))) > 0) { - int ret; - - if (!received && strstr(buf, AWAITING_DATA_MSG)) { - PARA_NOTICE_LOG("%s", "<-- awaiting data\n"); - PARA_NOTICE_LOG("%s", "--> sending stdin\n"); - while ((ret = read(STDIN_FILENO, buf, - sizeof(buf))) > 0) - send_bin_buffer(sockfd, buf, ret); - PARA_NOTICE_LOG("%s", "closing connection\n"); - numbytes = 1; - break; + return 0; +} + +static struct supervisor_task supervisor_task; + +/** + * The client program to connect to para_server. + * + * \param argc Usual argument count. + * \param argv Usual argument vector. + * + * 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 + * task is set up to replace the supervisor task. + * + * \return EXIT_SUCCESS or EXIT_FAILURE + * + * \sa \ref client_open(), \ref stdin.c, \ref stdout.c, para_client(1), + * para_server(1). + */ +int main(int argc, char *argv[]) +{ + int ret; + + 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 + * a bit wrt. to the buffer tree setup. + */ + sit.btrn = btr_new_node(&(struct btr_node_description) + EMBRACE(.name = "stdin")); + 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[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; + } } - received = 1; - if (write(STDOUT_FILENO, buf, numbytes) != numbytes) - break; } - if (!numbytes) - PARA_NOTICE_LOG("%s", "connection closed by peer\n"); - close(sockfd); - if (interactive) - goto interactive_loop; - return 0; + sched_shutdown(&sched); + crypt_shutdown(); +out: + if (ret < 0) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + client_close(ct); + btr_remove_node(&sit.btrn); + btr_remove_node(&sot.btrn); + return ret < 0? EXIT_FAILURE : EXIT_SUCCESS; }