X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=command.c;h=077c159d571240815072a34c426f230f21a0c897;hp=a9f5aa697be2e3f7ab51819898b14afb7d0535c6;hb=6ba4caacaeb4ac2d8e5fc15699bf89f496d59901;hpb=32a81d7eecfa5c8585d7095631ff2cd8b7b1bf7a diff --git a/command.c b/command.c index a9f5aa69..077c159d 100644 --- a/command.c +++ b/command.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1997-2014 Andre Noll + * Copyright (C) 1997 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -15,13 +15,14 @@ #include #include #include +#include +#include "server.lsg.h" #include "para.h" #include "error.h" #include "crypt.h" #include "sideband.h" #include "command.h" -#include "server.cmdline.h" #include "string.h" #include "afh.h" #include "afs.h" @@ -34,14 +35,17 @@ #include "daemon.h" #include "fd.h" #include "ipc.h" +#include "server_cmd.lsg.h" #include "user_list.h" -#include "server.command_list.h" -#include "afs.command_list.h" #include "signal.h" #include "version.h" -static struct server_command afs_cmds[] = {DEFINE_AFS_CMD_ARRAY}; -static struct server_command server_cmds[] = {DEFINE_SERVER_CMD_ARRAY}; +#define SERVER_CMD_AUX_INFO(_arg) _arg, +static const unsigned server_command_perms[] = {LSG_SERVER_CMD_AUX_INFOS}; +#undef SERVER_CMD_AUX_INFO +#define SERVER_CMD_AUX_INFO(_arg) #_arg, +static const char * const server_command_perms_txt[] = {LSG_SERVER_CMD_AUX_INFOS}; +#undef SERVER_CMD_AUX_INFO /** Commands including options must be shorter than this. */ #define MAX_COMMAND_LEN 32768 @@ -55,20 +59,14 @@ static void dummy(__a_unused int s) { } -static void mmd_dup(struct misc_meta_data *new_mmd) -{ - mutex_lock(mmd_mutex); - *new_mmd = *mmd; - mutex_unlock(mmd_mutex); -} - /* - * Compute human readable string containing vss status for given integer value. + * Compute human readable vss status text. * - * We don't want to use vss_playing() and friends here because we take a - * snapshot of the mmd struct and use the copy for computing the state of the - * vss. If the real data were used, we would take the mmd lock for a rather - * long time or risk to get an inconsistent view. + * We can't call vss_playing() and friends here because those functions read + * the flags from the primary mmd structure, so calling them from command + * handler context would require to take the mmd lock. At the time the function + * is called we already took a copy of the mmd structure and want to use the + * flags value of the copy for computing the vss status text. */ static char *vss_status_tohuman(unsigned int flags) { @@ -79,21 +77,6 @@ static char *vss_status_tohuman(unsigned int flags) return para_strdup("paused"); } -/* - * return human readable permission string. Never returns NULL. - */ -static char *cmd_perms_itohuman(unsigned int perms) -{ - char *msg = para_malloc(5 * sizeof(char)); - - msg[0] = perms & AFS_READ? 'a' : '-'; - msg[1] = perms & AFS_WRITE? 'A' : '-'; - msg[2] = perms & VSS_READ? 'v' : '-'; - msg[3] = perms & VSS_WRITE? 'V' : '-'; - msg[4] = '\0'; - return msg; -} - /* * Never returns NULL. */ @@ -109,33 +92,25 @@ static char *vss_get_status_flags(unsigned int flags) return msg; } -static unsigned get_status(struct misc_meta_data *nmmd, int parser_friendly, +static unsigned get_status(struct misc_meta_data *nmmd, bool parser_friendly, char **result) { - char mtime[30] = ""; char *status, *flags; /* vss status info */ /* nobody updates our version of "now" */ long offset = (nmmd->offset + 500) / 1000; struct timeval current_time; - struct tm mtime_tm; struct para_buffer b = {.flags = parser_friendly? PBF_SIZE_PREFIX : 0}; /* report real status */ status = vss_status_tohuman(nmmd->vss_status_flags); flags = vss_get_status_flags(nmmd->vss_status_flags); - if (nmmd->size) { /* parent currently has an audio file open */ - localtime_r(&nmmd->mtime, &mtime_tm); - strftime(mtime, 29, "%b %d %Y", &mtime_tm); - } clock_get_realtime(¤t_time); /* * The calls to WRITE_STATUS_ITEM() below never fail because - * b->max_size is zero (unlimited), see para_printf(). However, clang - * is not smart enough to prove this and complains nevertheless. + * b->max_size is zero (unlimited), see \ref para_printf(). However, + * clang is not smart enough to prove this and complains nevertheless. * Casting the return value to void silences clang. */ - (void)WRITE_STATUS_ITEM(&b, SI_FILE_SIZE, "%zu\n", nmmd->size / 1024); - (void)WRITE_STATUS_ITEM(&b, SI_MTIME, "%s\n", mtime); (void)WRITE_STATUS_ITEM(&b, SI_STATUS, "%s\n", status); (void)WRITE_STATUS_ITEM(&b, SI_STATUS_FLAGS, "%s\n", flags); (void)WRITE_STATUS_ITEM(&b, SI_OFFSET, "%li\n", offset); @@ -152,53 +127,6 @@ static unsigned get_status(struct misc_meta_data *nmmd, int parser_friendly, return b.offset; } -static int check_sender_args(int argc, char * const * argv, struct sender_command_data *scd) -{ - int i; - /* this has to match sender.h */ - const char *subcmds[] = {"add", "delete", "allow", "deny", "on", "off", NULL}; - - scd->sender_num = -1; - if (argc < 2) - return -E_COMMAND_SYNTAX; - for (i = 0; senders[i].name; i++) - if (!strcmp(senders[i].name, argv[1])) - break; - PARA_DEBUG_LOG("%d:%s\n", argc, argv[1]); - if (!senders[i].name) - return -E_COMMAND_SYNTAX; - scd->sender_num = i; - for (i = 0; subcmds[i]; i++) - if (!strcmp(subcmds[i], argv[2])) - break; - if (!subcmds[i]) - return -E_COMMAND_SYNTAX; - scd->cmd_num = i; - if (!senders[scd->sender_num].client_cmds[scd->cmd_num]) - return -E_SENDER_CMD; - switch (scd->cmd_num) { - case SENDER_ON: - case SENDER_OFF: - if (argc != 3) - return -E_COMMAND_SYNTAX; - break; - case SENDER_DENY: - case SENDER_ALLOW: - if (argc != 4 || parse_cidr(argv[3], scd->host, - sizeof(scd->host), &scd->netmask) == NULL) - return -E_COMMAND_SYNTAX; - break; - case SENDER_ADD: - case SENDER_DELETE: - if (argc != 4) - return -E_COMMAND_SYNTAX; - return parse_fec_url(argv[3], scd); - default: - return -E_COMMAND_SYNTAX; - } - return 1; -} - /** * Send a sideband packet through a blocking file descriptor. * @@ -210,7 +138,7 @@ static int check_sender_args(int argc, char * const * argv, struct sender_comman * * The nonblock flag must be disabled for the file descriptor given by \a scc. * - * Stream cipher encryption is automatically activated if neccessary via the + * Stream cipher encryption is automatically activated if necessary via the * sideband transformation, depending on the value of \a band. * * \return Standard. @@ -274,6 +202,81 @@ int send_strerror(struct command_context *cc, int err) return send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s\n", para_strerror(err)); } +/** + * Send an error context to a client, + * + * \param cc Client info. + * \param errctx The error context string. + * + * \return The return value of the underlying call to send_sb_va(). + * + * This function frees the error context string after it was sent. + */ +int send_errctx(struct command_context *cc, char *errctx) +{ + int ret; + + if (!errctx) + return 0; + ret = send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s\n", errctx); + free(errctx); + return ret; +} + +static int check_sender_args(struct command_context *cc, + struct lls_parse_result *lpr, struct sender_command_data *scd) +{ + int i, ret; + const char * const subcmds[] = {SENDER_SUBCOMMANDS}; + const char *arg; + char *errctx; + unsigned num_inputs = lls_num_inputs(lpr); + + scd->sender_num = -1; + ret = lls(lls_check_arg_count(lpr, 2, INT_MAX, &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; + } + arg = lls_input(0, lpr); + for (i = 0; senders[i].name; i++) + if (!strcmp(senders[i].name, arg)) + break; + if (!senders[i].name) + return -E_COMMAND_SYNTAX; + scd->sender_num = i; + arg = lls_input(1, lpr); + for (i = 0; i < NUM_SENDER_CMDS; i++) + if (!strcmp(subcmds[i], arg)) + break; + if (i == NUM_SENDER_CMDS) + return -E_COMMAND_SYNTAX; + scd->cmd_num = i; + if (!senders[scd->sender_num].client_cmds[scd->cmd_num]) + return -E_SENDER_CMD; + switch (scd->cmd_num) { + case SENDER_on: + case SENDER_off: + if (num_inputs != 2) + return -E_COMMAND_SYNTAX; + break; + case SENDER_deny: + case SENDER_allow: + if (num_inputs != 3 || parse_cidr(lls_input(2, lpr), scd->host, + sizeof(scd->host), &scd->netmask) == NULL) + return -E_COMMAND_SYNTAX; + break; + case SENDER_add: + case SENDER_delete: + if (num_inputs != 3) + return -E_COMMAND_SYNTAX; + return parse_fec_url(lls_input(2, lpr), scd); + default: + return -E_COMMAND_SYNTAX; + } + return 1; +} + /** * Send a sideband packet through a blocking file descriptor. * @@ -324,13 +327,13 @@ fail: return ret; } -static int com_sender(struct command_context *cc) +static int com_sender(struct command_context *cc, struct lls_parse_result *lpr) { int i, ret = 0; char *msg = NULL; struct sender_command_data scd; - if (cc->argc < 2) { + if (lls_num_inputs(lpr) == 0) { for (i = 0; senders[i].name; i++) { char *tmp; ret = xasprintf(&tmp, "%s%s\n", msg? msg : "", @@ -340,11 +343,11 @@ static int com_sender(struct command_context *cc) } return send_sb(&cc->scc, msg, ret, SBD_OUTPUT, false); } - ret = check_sender_args(cc->argc, cc->argv, &scd); + ret = check_sender_args(cc, lpr, &scd); if (ret < 0) { if (scd.sender_num < 0) return ret; - if (strcmp(cc->argv[2], "status") == 0) + if (strcmp(lls_input(1, lpr), "status") == 0) msg = senders[scd.sender_num].status(); else msg = senders[scd.sender_num].help(); @@ -352,10 +355,11 @@ static int com_sender(struct command_context *cc) } switch (scd.cmd_num) { - case SENDER_ADD: - case SENDER_DELETE: + case SENDER_add: + case SENDER_delete: assert(senders[scd.sender_num].resolve_target); - ret = senders[scd.sender_num].resolve_target(cc->argv[3], &scd); + ret = senders[scd.sender_num].resolve_target(lls_input(2, lpr), + &scd); if (ret < 0) return ret; } @@ -375,17 +379,16 @@ static int com_sender(struct command_context *cc) } return (i < 10)? 1 : -E_LOCK; } +EXPORT_SERVER_CMD_HANDLER(sender); -/* server info */ -static int com_si(struct command_context *cc) +static int com_si(struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - int ret; char *msg, *ut; + int ret; - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; - mutex_lock(mmd_mutex); ut = daemon_get_uptime_str(now); + mutex_lock(mmd_mutex); ret = xasprintf(&msg, "up: %s\nplayed: %u\n" "server_pid: %d\n" @@ -399,26 +402,29 @@ static int com_si(struct command_context *cc) mmd->active_connections, mmd->num_commands, mmd->num_connects, - conf.loglevel_arg, + ENUM_STRING_VAL(LOGLEVEL), AUDIO_FORMAT_HANDLERS ); mutex_unlock(mmd_mutex); free(ut); return send_sb(&cc->scc, msg, ret, SBD_OUTPUT, false); } +EXPORT_SERVER_CMD_HANDLER(si); -/* version */ -static int com_version(struct command_context *cc) +static int com_version(struct command_context *cc, struct lls_parse_result *lpr) { char *msg; size_t len; - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; - len = xasprintf(&msg, "%s", version_text("server")); + if (SERVER_CMD_OPT_GIVEN(VERSION, VERBOSE, lpr)) + len = xasprintf(&msg, "%s", version_text("server")); + else + len = xasprintf(&msg, "%s\n", version_single_line("server")); return send_sb(&cc->scc, msg, len, SBD_OUTPUT, false); } +EXPORT_SERVER_CMD_HANDLER(version); +/** These status items are cleared if no audio file is currently open. */ #define EMPTY_STATUS_ITEMS \ ITEM(PATH) \ ITEM(DIRECTORY) \ @@ -445,14 +451,17 @@ static int com_version(struct command_context *cc) ITEM(YEAR) \ ITEM(ALBUM) \ ITEM(COMMENT) \ - ITEM(AMPLIFICATION) + ITEM(MTIME) \ + ITEM(FILE_SIZE) \ + ITEM(CHUNK_TIME) \ + ITEM(NUM_CHUNKS) \ + ITEM(AMPLIFICATION) \ -/** - * Write a list of audio-file related status items with empty values. - * - * This is used by vss when currently no audio file is open. +/* + * Create a set of audio-file related status items with empty values. These are + * written to stat clients when no audio file is open. */ -static unsigned empty_status_items(int parser_friendly, char **result) +static unsigned empty_status_items(bool parser_friendly, char **result) { char *esi; unsigned len; @@ -462,7 +471,7 @@ static unsigned empty_status_items(int parser_friendly, char **result) #define ITEM(x) "0004 %02x:\n" EMPTY_STATUS_ITEMS #undef ITEM - #define ITEM(x) , SI_ ## x + #define ITEM(x) , (unsigned) SI_ ## x EMPTY_STATUS_ITEMS #undef ITEM ); @@ -480,41 +489,24 @@ static unsigned empty_status_items(int parser_friendly, char **result) } #undef EMPTY_STATUS_ITEMS -/* stat */ -static int com_stat(struct command_context *cc) +static int com_stat(struct command_context *cc, struct lls_parse_result *lpr) { - int i, ret; + int ret; struct misc_meta_data tmp, *nmmd = &tmp; char *s; - int32_t num = 0; - int parser_friendly = 0; + bool parser_friendly = SERVER_CMD_OPT_GIVEN(STAT, PARSER_FRIENDLY, + lpr) > 0; + uint32_t num = SERVER_CMD_UINT32_VAL(STAT, NUM, lpr); para_sigaction(SIGUSR1, dummy); - - for (i = 1; i < cc->argc; i++) { - const char *arg = cc->argv[i]; - if (arg[0] != '-') - break; - if (!strcmp(arg, "--")) { - i++; - break; - } - if (!strncmp(arg, "-n=", 3)) { - ret = para_atoi32(arg + 3, &num); - if (ret < 0) - return ret; - continue; - } - if (!strcmp(arg, "-p")) { - parser_friendly = 1; - continue; - } - return -E_COMMAND_SYNTAX; - } - if (i != cc->argc) - return -E_COMMAND_SYNTAX; for (;;) { - mmd_dup(nmmd); + /* + * Copy the mmd structure to minimize the time we hold the mmd + * lock. + */ + mutex_lock(mmd_mutex); + *nmmd = *mmd; + mutex_unlock(mmd_mutex); ret = get_status(nmmd, parser_friendly, &s); ret = send_sb(&cc->scc, s, ret, SBD_OUTPUT, false); if (ret < 0) @@ -538,114 +530,98 @@ static int com_stat(struct command_context *cc) out: return ret; } +EXPORT_SERVER_CMD_HANDLER(stat); -static int send_list_of_commands(struct command_context *cc, struct server_command *cmd, - const char *handler) +/* fixed-length, human readable permission string */ +const char *server_cmd_perms_str(unsigned int perms) { - char *msg = NULL; + static char result[5]; - for (; cmd->name; cmd++) { - char *tmp, *perms = cmd_perms_itohuman(cmd->perms); - tmp = make_message("%s\t%s\t%s\t%s\n", cmd->name, handler, - perms, cmd->description); - free(perms); - msg = para_strcat(msg, tmp); - free(tmp); - } - assert(msg); - return send_sb(&cc->scc, msg, strlen(msg), SBD_OUTPUT, false); + result[0] = perms & AFS_READ? 'a' : '-'; + result[1] = perms & AFS_WRITE? 'A' : '-'; + result[2] = perms & VSS_READ? 'v' : '-'; + result[3] = perms & VSS_WRITE? 'V' : '-'; + result[4] = '\0'; + return result; } -/* returns string that must be freed by the caller */ -static struct server_command *get_cmd_ptr(const char *name, char **handler) +static int send_list_of_commands(struct command_context *cc) { - struct server_command *cmd; - - for (cmd = server_cmds; cmd->name; cmd++) - if (!strcmp(cmd->name, name)) { - if (handler) - *handler = para_strdup("server"); /* server commands */ - return cmd; - } - /* not found, look for commands supported by afs */ - for (cmd = afs_cmds; cmd->name; cmd++) - if (!strcmp(cmd->name, name)) { - if (handler) - *handler = para_strdup("afs"); - return cmd; - } - return NULL; + int i; + const struct lls_command *cmd; + char *msg = para_strdup(""); + + for (i = 1; (cmd = lls_cmd(i, server_cmd_suite)); i++) { + const char *perms = server_cmd_perms_str(server_command_perms[i]); + char *tmp = make_message("%s%s\t%s\t%s\n", msg, + lls_command_name(cmd), perms, lls_purpose(cmd)); + free(msg); + msg = tmp; + } + return send_sb(&cc->scc, msg, strlen(msg), SBD_OUTPUT, false); } -/* help */ -static int com_help(struct command_context *cc) +static int com_help(struct command_context *cc, struct lls_parse_result *lpr) { - struct server_command *cmd; - char *perms, *handler, *buf; + const char *perms; + char *long_help, *buf, *errctx; int ret; + const struct lls_command *cmd; - if (cc->argc < 2) { - /* no argument given, print list of commands */ - if ((ret = send_list_of_commands(cc, server_cmds, "server")) < 0) - return ret; - return send_list_of_commands(cc, afs_cmds, "afs"); + ret = lls(lls_check_arg_count(lpr, 0, 1, &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; } + if (lls_num_inputs(lpr) == 0) + return send_list_of_commands(cc); /* argument given for help */ - cmd = get_cmd_ptr(cc->argv[1], &handler); - if (!cmd) - return -E_BAD_CMD; - perms = cmd_perms_itohuman(cmd->perms); - ret = xasprintf(&buf, "%s - %s\n\n" - "handler: %s\n" - "permissions: %s\n" - "usage: %s\n\n" - "%s\n", - cc->argv[1], - cmd->description, - handler, - perms, - cmd->usage, - cmd->help - ); - free(perms); - free(handler); + ret = lls(lls_lookup_subcmd(lls_input(0, lpr), server_cmd_suite, + &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; + } + cmd = lls_cmd(ret, server_cmd_suite); + perms = server_command_perms_txt[ret]; + long_help = lls_long_help(cmd); + assert(long_help); + ret = xasprintf(&buf, "%spermissions: %s\n", long_help, perms); + free(long_help); return send_sb(&cc->scc, buf, ret, SBD_OUTPUT, false); } +EXPORT_SERVER_CMD_HANDLER(help); -/* hup */ -static int com_hup(struct command_context *cc) +static int com_hup(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; kill(getppid(), SIGHUP); return 1; } +EXPORT_SERVER_CMD_HANDLER(hup); -/* term */ -static int com_term(struct command_context *cc) +static int com_term(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; kill(getppid(), SIGTERM); return 1; } +EXPORT_SERVER_CMD_HANDLER(term); -static int com_play(struct command_context *cc) +static int com_play(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; mutex_lock(mmd_mutex); mmd->new_vss_status_flags |= VSS_PLAYING; mmd->new_vss_status_flags &= ~VSS_NOMORE; mutex_unlock(mmd_mutex); return 1; } +EXPORT_SERVER_CMD_HANDLER(play); -/* stop */ -static int com_stop(struct command_context *cc) +static int com_stop(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; mutex_lock(mmd_mutex); mmd->new_vss_status_flags &= ~VSS_PLAYING; mmd->new_vss_status_flags &= ~VSS_REPOS; @@ -653,12 +629,11 @@ static int com_stop(struct command_context *cc) mutex_unlock(mmd_mutex); return 1; } +EXPORT_SERVER_CMD_HANDLER(stop); -/* pause */ -static int com_pause(struct command_context *cc) +static int com_pause(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; mutex_lock(mmd_mutex); if (!vss_paused() && !vss_stopped()) { mmd->events++; @@ -668,42 +643,44 @@ static int com_pause(struct command_context *cc) mutex_unlock(mmd_mutex); return 1; } +EXPORT_SERVER_CMD_HANDLER(pause); -/* next */ -static int com_next(struct command_context *cc) +static int com_next(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; mutex_lock(mmd_mutex); mmd->events++; mmd->new_vss_status_flags |= VSS_NEXT; mutex_unlock(mmd_mutex); return 1; } +EXPORT_SERVER_CMD_HANDLER(next); -/* nomore */ -static int com_nomore(struct command_context *cc) +static int com_nomore(__a_unused struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { - if (cc->argc != 1) - return -E_COMMAND_SYNTAX; mutex_lock(mmd_mutex); if (vss_playing() || vss_paused()) mmd->new_vss_status_flags |= VSS_NOMORE; mutex_unlock(mmd_mutex); return 1; } +EXPORT_SERVER_CMD_HANDLER(nomore); -/* ff */ -static int com_ff(struct command_context *cc) +static int com_ff(__a_unused struct command_context *cc, + struct lls_parse_result *lpr) { long promille; int ret, backwards = 0; unsigned i; - char c; + char c, *errctx; - if (cc->argc != 2) - return -E_COMMAND_SYNTAX; - if (!(ret = sscanf(cc->argv[1], "%u%c", &i, &c))) + ret = lls(lls_check_arg_count(lpr, 1, 1, &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; + } + if (!(ret = sscanf(lls_input(0, lpr), "%u%c", &i, &c))) return -E_COMMAND_SYNTAX; if (ret > 1 && c == '-') backwards = 1; /* jmp backwards */ @@ -731,17 +708,22 @@ out: mutex_unlock(mmd_mutex); return ret; } +EXPORT_SERVER_CMD_HANDLER(ff); -/* jmp */ -static int com_jmp(struct command_context *cc) +static int com_jmp(__a_unused struct command_context *cc, + struct lls_parse_result *lpr) { long unsigned int i; int ret; + char *errctx; - if (cc->argc != 2) - return -E_COMMAND_SYNTAX; - if (sscanf(cc->argv[1], "%lu", &i) <= 0) - return -E_COMMAND_SYNTAX; + ret = lls(lls_check_arg_count(lpr, 1, 1, &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; + } + if (sscanf(lls_input(0, lpr), "%lu", &i) <= 0) + return -ERRNO_TO_PARA_ERROR(EINVAL); mutex_lock(mmd_mutex); ret = -E_NO_AUDIO_FILE; if (!mmd->afd.afhi.chunks_total) @@ -750,7 +732,7 @@ static int com_jmp(struct command_context *cc) i = 100; PARA_INFO_LOG("jumping to %lu%%\n", i); mmd->repos_request = (mmd->afd.afhi.chunks_total * i + 50) / 100; - PARA_INFO_LOG("sent: %lu, offset before jmp: %lu\n", + PARA_INFO_LOG("sent: %lu, offset before jmp: %li\n", mmd->chunks_sent, mmd->offset); mmd->new_vss_status_flags |= VSS_REPOS; mmd->new_vss_status_flags &= ~VSS_NEXT; @@ -760,26 +742,16 @@ out: mutex_unlock(mmd_mutex); return ret; } +EXPORT_SERVER_CMD_HANDLER(jmp); -static int com_tasks(struct command_context *cc) +static int com_tasks(struct command_context *cc, + __a_unused struct lls_parse_result *lpr) { char *tl = server_get_tasks(); - int ret = 1; - - if (tl) - ret = send_sb(&cc->scc, tl, strlen(tl), SBD_OUTPUT, false); - return ret; -} - -/* - * check if perms are sufficient to exec a command having perms cmd_perms. - * Returns 0 if perms are sufficient, -E_PERM otherwise. - */ -static int check_perms(unsigned int perms, struct server_command *cmd_ptr) -{ - PARA_DEBUG_LOG("checking permissions\n"); - return (cmd_ptr->perms & perms) < cmd_ptr->perms ? -E_PERM : 0; + assert(tl); + return send_sb(&cc->scc, tl, strlen(tl), SBD_OUTPUT, false); } +EXPORT_SERVER_CMD_HANDLER(tasks); static void reset_signals(void) { @@ -790,8 +762,7 @@ static void reset_signals(void) } struct connection_features { - bool sideband_requested; - bool aes_ctr128_requested; + int dummy; /* none at the moment */ }; static int parse_auth_request(char *buf, int len, struct user **u, @@ -818,9 +789,9 @@ static int parse_auth_request(char *buf, int len, struct user **u, create_argv(p, ",", &features); for (i = 0; features[i]; i++) { if (strcmp(features[i], "sideband") == 0) - cf->sideband_requested = true; - else if (strcmp(features[i], "aes_ctr128") == 0) - cf->aes_ctr128_requested = true; + continue; + if (strcmp(features[i], "aes_ctr128") == 0) + continue; else { ret = -E_BAD_FEATURE; goto out; @@ -837,35 +808,55 @@ out: #define HANDSHAKE_BUFSIZE 4096 -static int parse_sb_command(struct command_context *cc, struct iovec *iov) +static int run_command(struct command_context *cc, struct iovec *iov, + const char *peername) { - int ret, i; - char *p, *end; + int ret, i, argc; + char *p, *end, **argv; + const struct lls_command *lcmd = NULL; + unsigned perms; + struct lls_parse_result *lpr; + char *errctx; - ret = -E_BAD_CMD; if (iov->iov_base == NULL || iov->iov_len == 0) - goto out; + return -ERRNO_TO_PARA_ERROR(EINVAL); p = iov->iov_base; p[iov->iov_len - 1] = '\0'; /* just to be sure */ - cc->cmd = get_cmd_ptr(p, NULL); - if (!cc->cmd) - goto out; - ret = check_perms(cc->u->perms, cc->cmd); - if (ret < 0) - goto out; + + ret = lls(lls_lookup_subcmd(p, server_cmd_suite, &errctx)); + if (ret < 0) { + send_errctx(cc, errctx); + return ret; + } + perms = server_command_perms[ret]; + if ((perms & cc->u->perms) != perms) + return -E_PERM; + lcmd = lls_cmd(ret, server_cmd_suite); end = iov->iov_base + iov->iov_len; for (i = 0; p < end; i++) p += strlen(p) + 1; - cc->argc = i; - cc->argv = para_malloc((cc->argc + 1) * sizeof(char *)); + argc = i; + argv = para_malloc((argc + 1) * sizeof(char *)); for (i = 0, p = iov->iov_base; p < end; i++) { - cc->argv[i] = para_strdup(p); + argv[i] = para_strdup(p); p += strlen(p) + 1; } - cc->argv[cc->argc] = NULL; - ret = cc->argc; -out: - free(iov->iov_base); + argv[argc] = NULL; + PARA_NOTICE_LOG("calling com_%s() for %s@%s\n", lls_command_name(lcmd), + cc->u->name, peername); + ret = lls(lls_parse(argc, argv, lcmd, &lpr, &errctx)); + if (ret >= 0) { + const struct server_cmd_user_data *ud = lls_user_data(lcmd); + ret = ud->handler(cc, lpr); + lls_free_parse_result(lpr, lcmd); + } else + send_errctx(cc, errctx); + free_argv(argv); + mutex_lock(mmd_mutex); + mmd->num_commands++; + if (ret >= 0 && (perms & AFS_WRITE)) + mmd->events++; + mutex_unlock(mmd_mutex); return ret; } @@ -892,7 +883,7 @@ out: * the function if the connection was not authenticated when the timeout * expires. * - * \sa alarm(2), crypt.c, crypt.h + * \sa alarm(2), \ref crypt.c, \ref crypt.h. */ __noreturn void handle_connect(int fd, const char *peername) { @@ -901,7 +892,7 @@ __noreturn void handle_connect(int fd, const char *peername) unsigned char challenge_hash[HASH_SIZE]; char *command = NULL, *buf = para_malloc(HANDSHAKE_BUFSIZE) /* must be on the heap */; size_t numbytes; - struct command_context cc_struct = {.peer = peername}, *cc = &cc_struct; + struct command_context cc_struct = {.u = NULL}, *cc = &cc_struct; struct iovec iov; struct connection_features cf; @@ -925,11 +916,6 @@ __noreturn void handle_connect(int fd, const char *peername) ret = parse_auth_request(buf, ret, &cc->u, &cf); if (ret < 0) goto net_err; - if (!cf.sideband_requested) { /* sideband is mandatory */ - PARA_ERROR_LOG("client did not request sideband\n"); - ret = -E_BAD_FEATURE; - goto net_err; - } if (cc->u) { get_random_bytes_or_die(rand_buf, sizeof(rand_buf)); ret = pub_encrypt(cc->u->pubkey, rand_buf, sizeof(rand_buf), @@ -946,7 +932,7 @@ __noreturn void handle_connect(int fd, const char *peername) numbytes = 256; get_random_bytes_or_die((unsigned char *)buf, numbytes); } - PARA_DEBUG_LOG("sending %u byte challenge + session key (%zu bytes)\n", + PARA_DEBUG_LOG("sending %d byte challenge + session key (%zu bytes)\n", CHALLENGE_SIZE, numbytes); ret = send_sb(&cc->scc, buf, numbytes, SBD_CHALLENGE, false); buf = NULL; @@ -976,27 +962,19 @@ __noreturn void handle_connect(int fd, const char *peername) alarm(0); PARA_INFO_LOG("good auth for %s\n", cc->u->name); /* init stream cipher keys with the second part of the random buffer */ - cc->scc.recv = sc_new(rand_buf + CHALLENGE_SIZE, SESSION_KEY_LEN, - cf.aes_ctr128_requested); + cc->scc.recv = sc_new(rand_buf + CHALLENGE_SIZE, SESSION_KEY_LEN); cc->scc.send = sc_new(rand_buf + CHALLENGE_SIZE + SESSION_KEY_LEN, - SESSION_KEY_LEN, cf.aes_ctr128_requested); + SESSION_KEY_LEN); ret = send_sb(&cc->scc, NULL, 0, SBD_PROCEED, false); if (ret < 0) goto net_err; ret = recv_sb(&cc->scc, SBD_COMMAND, MAX_COMMAND_LEN, &iov); if (ret < 0) goto net_err; - ret = parse_sb_command(cc, &iov); + ret = run_command(cc, &iov, peername); + free(iov.iov_base); if (ret < 0) goto err_out; - cc->argc = ret; - PARA_NOTICE_LOG("calling com_%s() for %s@%s\n", cc->cmd->name, - cc->u->name, peername); - ret = cc->cmd->handler(cc); - free_argv(cc->argv); - mutex_lock(mmd_mutex); - mmd->num_commands++; - mutex_unlock(mmd_mutex); if (ret >= 0) goto out; err_out: @@ -1008,8 +986,6 @@ out: free(buf); free(command); mutex_lock(mmd_mutex); - if (cc->cmd && (cc->cmd->perms & AFS_WRITE) && ret >= 0) - mmd->events++; mmd->active_connections--; mutex_unlock(mmd_mutex); if (ret >= 0) {