X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=afs.c;h=135888a7fc632e6760d2aba4e1b4b2b4738af618;hp=73f2c65a3d87cdd4a2ab3861985d25047140e44a;hb=1cccf6fa93c251f8f2805aa5fb163741d851c051;hpb=2e2f91c92bbdd4107925bcaf521242c588afbfe4 diff --git a/afs.c b/afs.c index 73f2c65a..135888a7 100644 --- a/afs.c +++ b/afs.c @@ -1,15 +1,20 @@ /* - * Copyright (C) 2007-2012 Andre Noll + * Copyright (C) 2007-2013 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ /** \file afs.c Paraslash's audio file selector. */ +#include +#include #include #include #include #include +#include +#include +#include #include "server.cmdline.h" #include "para.h" @@ -26,6 +31,8 @@ #include "signal.h" #include "fd.h" #include "mood.h" +#include "sideband.h" +#include "command.h" /** The osl tables used by afs. \sa blob.c. */ enum afs_table_num { @@ -85,7 +92,7 @@ static struct command_task command_task_struct; static struct signal_task signal_task_struct; static enum play_mode current_play_mode; -static char *current_mop; /* mode or playlist specifier. NULL means dummy mooe */ +static char *current_mop; /* mode or playlist specifier. NULL means dummy mood */ /** * A random number used to "authenticate" the connection. @@ -111,7 +118,7 @@ extern uint32_t afs_socket_cookie; * area is written to the command socket. * * The afs process accepts connections on the command socket and reads the - * shared memory id, attaches the corresponing area, calls the given handler to + * shared memory id, attaches the corresponding area, calls the given handler to * perform the desired action and to optionally compute a result. * * The result and a \p callback_result structure is then written to another @@ -131,7 +138,7 @@ struct callback_query { /** * Structure embedded in the result of a callback. * - * If the callback produced a result, an instance of that structure is embeeded + * If the callback produced a result, an instance of that structure is embedded * into the shared memory area holding the result, mainly to let the command * handler know the size of the result. * @@ -140,6 +147,8 @@ struct callback_query { struct callback_result { /** The number of bytes of the result. */ size_t result_size; + /** The band designator (loglevel for the result). */ + uint8_t band; }; static int dispatch_result(int result_shmid, callback_result_handler *handler, @@ -147,7 +156,8 @@ static int dispatch_result(int result_shmid, callback_result_handler *handler, { struct osl_object result; void *result_shm; - int ret2, ret = shm_attach(result_shmid, ATTACH_RO, &result_shm); + /* must attach r/w as result.data might get encrypted in-place. */ + int ret2, ret = shm_attach(result_shmid, ATTACH_RW, &result_shm); struct callback_result *cr = result_shm; if (ret < 0) { @@ -158,7 +168,7 @@ static int dispatch_result(int result_shmid, callback_result_handler *handler, result.data = result_shm + sizeof(*cr); if (result.size) { assert(handler); - ret = handler(&result, private_result_data); + ret = handler(&result, cr->band, private_result_data); if (ret < 0) PARA_NOTICE_LOG("result handler error: %s\n", para_strerror(-ret)); @@ -541,12 +551,37 @@ static int activate_mood_or_playlist(char *arg, int *num_admissible) return 1; } +/** + * Result handler for sending data to the para_client process. + * + * \param result The data to be sent. + * \param band The band designator. + * \param private Pointer to the command context. + * + * \return The return value of the underlying call to \ref command.c::send_sb. + * + * \sa \ref callback_result_handler, \ref command.c::send_sb. + */ +int afs_cb_result_handler(struct osl_object *result, uint8_t band, + void *private) +{ + struct command_context *cc = private; + + assert(cc); + if (!result->size) + return 1; + return send_sb(&cc->scc, result->data, result->size, band, true); +} + static void com_select_callback(int fd, const struct osl_object *query) { struct para_buffer pb = { .max_size = shm_get_shmmax(), - .private_data = &fd, - .max_size_handler = pass_buffer_as_shm + .private_data = &(struct afs_max_size_handler_data) { + .fd = fd, + .band = SBD_OUTPUT + }, + .max_size_handler = afs_max_size_handler, }; char *arg = query->data; int num_admissible, ret, ret2; @@ -576,43 +611,20 @@ static void com_select_callback(int fd, const struct osl_object *query) current_mop : "dummy mood", num_admissible); out: if (ret2 >= 0 && pb.offset) - pass_buffer_as_shm(pb.buf, pb.offset, &fd); + pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset); free(pb.buf); } -/** - * Result handler for sending data to the para_client process. - * - * \param result The data to be sent. - * \param private Pointer to the context. - * - * \return The return value of the underlying call to sc_send_bin_buffer(). - * - * \sa \ref callback_result_handler, \ref sc_send_bin_buffer(). - */ -int sc_send_result(struct osl_object *result, void *private) -{ - struct stream_cipher_context *scc = private; - int ret; - - if (!result->size) - return 1; - ret = sc_send_bin_buffer(scc, result->data, result->size); - if (ret < 0 || ret == result->size) - return ret; - return -E_SHORT_WRITE; -} - -int com_select(struct stream_cipher_context *scc, int argc, char * const * const argv) +int com_select(struct command_context *cc) { struct osl_object query; - if (argc != 2) + if (cc->argc != 2) return -E_AFS_SYNTAX; - query.data = argv[1]; - query.size = strlen(argv[1]) + 1; + query.data = cc->argv[1]; + query.size = strlen(cc->argv[1]) + 1; return send_callback_request(com_select_callback, &query, - &sc_send_result, scc); + &afs_cb_result_handler, cc); } static void init_admissible_files(char *arg) @@ -713,9 +725,9 @@ static void signal_pre_select(struct sched *s, struct task *t) para_fd_set(st->fd, &s->rfds, &s->max_fileno); } -static void afs_signal_post_select(struct sched *s, struct task *t) +static int afs_signal_post_select(struct sched *s, __a_unused struct task *t) { - int signum; + int signum, ret; if (getppid() == 1) { PARA_EMERG_LOG("para_server died\n"); @@ -723,20 +735,20 @@ static void afs_signal_post_select(struct sched *s, struct task *t) } signum = para_next_signal(&s->rfds); if (signum == 0) - return; + return 0; if (signum == SIGHUP) { close_afs_tables(); parse_config_or_die(1); - t->error = open_afs_tables(); - if (t->error < 0) - return; + ret = open_afs_tables(); + if (ret < 0) + return ret; init_admissible_files(current_mop); - return; + return 0; } PARA_EMERG_LOG("terminating on signal %d\n", signum); shutdown: - sched_shutdown(s); - t->error = -E_AFS_SIGNAL; + task_notify_all(s, E_AFS_SIGNAL); + return -E_AFS_SIGNAL; } static void register_signal_task(struct sched *s) @@ -782,30 +794,30 @@ static void command_pre_select(struct sched *s, struct task *t) /** * Send data as shared memory to a file descriptor. * + * \param fd File descriptor to send the shmid to. + * \param band The band designator for this data. * \param buf The buffer holding the data to be sent. * \param size The size of \a buf. - * \param fd_ptr A pointer to the file descriptor. - * - * This function is used as the \a max_size handler in a \ref para_buffer - * structure. If used this way, it is called by \ref para_printf() whenever - * the buffer passed to para_printf() is about to exceed its maximal size. * * This function creates a shared memory area large enough to hold * the content given by \a buf and \a size and sends the identifier - * of this area to the file descriptor given by \a fd_ptr. + * of this area to the file descriptor \a fd. + * + * It is called by the AFS max_size handler as well as directly by the AFS + * command callbacks to send command output to the command handlers. * * \return Zero if \a buf is \p NULL or \a size is zero. Negative on errors, * and positive on success. */ -int pass_buffer_as_shm(char *buf, size_t size, void *fd_ptr) +int pass_buffer_as_shm(int fd, uint8_t band, const char *buf, size_t size) { - int ret, shmid, fd = *(int *)fd_ptr; + int ret, shmid; void *shm; struct callback_result *cr; if (!buf || !size) return 0; - ret = shm_new(size + sizeof(struct callback_result)); + ret = shm_new(size + sizeof(*cr)); if (ret < 0) return ret; shmid = ret; @@ -814,6 +826,7 @@ int pass_buffer_as_shm(char *buf, size_t size, void *fd_ptr) goto err; cr = shm; cr->result_size = size; + cr->band = band; memcpy(shm + sizeof(*cr), buf, size); ret = shm_detach(shm); if (ret < 0) @@ -904,18 +917,21 @@ err: /** Shutdown connection if query has not arrived until this many seconds. */ #define AFS_CLIENT_TIMEOUT 3 -static void command_post_select(struct sched *s, struct task *t) +static int command_post_select(struct sched *s, struct task *t) { struct command_task *ct = container_of(t, struct command_task, task); struct sockaddr_un unix_addr; struct afs_client *client, *tmp; int fd, ret; + ret = task_get_notification(t); + if (ret < 0) + return ret; ret = execute_server_command(&s->rfds); if (ret < 0) { PARA_EMERG_LOG("%s\n", para_strerror(-ret)); - sched_shutdown(s); - return; + task_notify_all(s, -ret); + return ret; } /* Check the list of connected clients. */ list_for_each_entry_safe(client, tmp, &afs_client_list, node) { @@ -936,17 +952,18 @@ static void command_post_select(struct sched *s, struct task *t) if (ret < 0) PARA_NOTICE_LOG("%s\n", para_strerror(-ret)); if (ret <= 0) - return; + return 0; ret = mark_fd_nonblocking(fd); if (ret < 0) { PARA_NOTICE_LOG("%s\n", para_strerror(-ret)); close(fd); - return; + return 0; } client = para_malloc(sizeof(*client)); client->fd = fd; client->connect_time = *now; para_list_add(&client->node, &afs_client_list); + return 0; } static void register_command_task(uint32_t cookie, struct sched *s) @@ -1022,11 +1039,11 @@ out: if (ret < 0) para_printf(&pb, "%s\n", para_strerror(-ret)); if (pb.buf) - pass_buffer_as_shm(pb.buf, pb.offset, &fd); + pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset); free(pb.buf); } -int com_init(struct stream_cipher_context *scc, int argc, char * const * const argv) +int com_init(struct command_context *cc) { int i, j, ret; uint32_t table_mask = (1 << (NUM_AFS_TABLES + 1)) - 1; @@ -1036,13 +1053,13 @@ int com_init(struct stream_cipher_context *scc, int argc, char * const * const a ret = make_database_dir(); if (ret < 0) return ret; - if (argc != 1) { + if (cc->argc != 1) { table_mask = 0; - for (i = 1; i < argc; i++) { + for (i = 1; i < cc->argc; i++) { for (j = 0; j < NUM_AFS_TABLES; j++) { struct afs_table *t = &afs_tables[j]; - if (strcmp(argv[i], t->name)) + if (strcmp(cc->argv[i], t->name)) continue; table_mask |= (1 << j); break; @@ -1052,10 +1069,7 @@ int com_init(struct stream_cipher_context *scc, int argc, char * const * const a } } ret = send_callback_request(create_tables_callback, &query, - sc_send_result, scc); - if (ret < 0) - /* ignore return value */ - sc_send_va_buffer(scc, "%s\n", para_strerror(-ret)); + afs_cb_result_handler, cc); return ret; } @@ -1073,13 +1087,13 @@ enum com_check_flags { CHECK_PLAYLISTS = 4 }; -int com_check(struct stream_cipher_context *scc, int argc, char * const * const argv) +int com_check(struct command_context *cc) { unsigned flags = 0; int i, ret; - for (i = 1; i < argc; i++) { - const char *arg = argv[i]; + for (i = 1; i < cc->argc; i++) { + const char *arg = cc->argv[i]; if (arg[0] != '-') break; if (!strcmp(arg, "--")) { @@ -1100,25 +1114,25 @@ int com_check(struct stream_cipher_context *scc, int argc, char * const * const } return -E_AFS_SYNTAX; } - if (i < argc) + if (i < cc->argc) return -E_AFS_SYNTAX; if (!flags) flags = ~0U; if (flags & CHECK_AFT) { ret = send_callback_request(aft_check_callback, NULL, - sc_send_result, scc); + afs_cb_result_handler, cc); if (ret < 0) return ret; } if (flags & CHECK_PLAYLISTS) { ret = send_callback_request(playlist_check_callback, - NULL, sc_send_result, scc); + NULL, afs_cb_result_handler, cc); if (ret < 0) return ret; } if (flags & CHECK_MOODS) { ret = send_callback_request(mood_check_callback, NULL, - sc_send_result, scc); + afs_cb_result_handler, cc); if (ret < 0) return ret; }