X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=afs.c;h=33bc6e277ea2c3fb8a2b1efe30df775905890c9d;hp=71a9f1ce6fc2d2d1b481b688e1b060a430158c94;hb=db8b9c608ae1c0eaf1afd257a1c4af2654fbeaee;hpb=c252837b853b35f06fffe637b2a6bf16419da954 diff --git a/afs.c b/afs.c index 71a9f1ce..33bc6e27 100644 --- a/afs.c +++ b/afs.c @@ -1,11 +1,21 @@ +/* + * Copyright (C) 2007 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file afs.c Paraslash's audio file selector. */ + +#include +#include +#include "server.cmdline.h" #include "para.h" #include "afh.h" +#include "server.h" #include "error.h" #include /* readdir() */ #include #include - - #include "net.h" #include "afs.h" #include "ipc.h" @@ -15,33 +25,7 @@ #include "signal.h" #include "fd.h" -/** \file afs.c Paraslash's audio file selector. */ - -static uint32_t socket_cookie; - -/** - * Compare two osl objects of string type. - * - * \param obj1 Pointer to the first object. - * \param obj2 Pointer to the second object. - * - * In any case, only \p MIN(obj1->size, obj2->size) characters of each string - * are taken into account. - * - * \return It returns an integer less than, equal to, or greater than zero if - * \a obj1 is found, respectively, to be less than, to match, or be greater than - * obj2. - * - * \sa strcmp(3), strncmp(3), osl_compare_func. - */ -int string_compare(const struct osl_object *obj1, const struct osl_object *obj2) -{ - const char *str1 = (const char *)obj1->data; - const char *str2 = (const char *)obj2->data; - return strncmp(str1, str2, PARA_MIN(obj1->size, obj2->size)); -} - -/** The osl tables used by afs. \sa blob.c */ +/** The osl tables used by afs. \sa blob.c. */ enum afs_table_num { /** Contains audio file information. See aft.c. */ TBLNUM_AUDIO_FILES, @@ -71,73 +55,72 @@ enum afs_table_num { static struct table_info afs_tables[NUM_AFS_TABLES]; +struct command_task { + /** The file descriptor for the local socket. */ + int fd; + /** + * Value sent by the command handlers to identify themselves as + * children of the running para_server. + */ + uint32_t cookie; + /** The associated task structure. */ + struct task task; +}; /** - * A wrapper for strtol(3). - * - * \param str The string to be converted to a long integer. - * \param result The converted value is stored here. + * A random number used to "authenticate" the connection. * - * \return Positive on success, -E_ATOL on errors. - * - * \sa strtol(3), atoi(3). + * para_server picks this number by random before forking the afs process. The + * command handlers write this number together with the id of the shared memory + * area containing the query. This way, a malicious local user has to know this + * number to be able to cause the afs process to crash by sending fake queries. */ -int para_atol(const char *str, long *result) -{ - char *endptr; - long val; - int ret, base = 10; - - errno = 0; /* To distinguish success/failure after call */ - val = strtol(str, &endptr, base); - ret = -E_ATOL; - if (errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) - goto out; /* overflow */ - if (errno != 0 && val == 0) - goto out; /* other error */ - if (endptr == str) - goto out; /* No digits were found */ - if (*endptr != '\0') - goto out; /* Further characters after number */ - *result = val; - ret = 1; -out: - return ret; -} +extern uint32_t afs_socket_cookie; /** - * Struct to let para_server call a function specified from child context. + * Struct to let command handlers execute a callback in afs context. + * + * Commands that need to change the state of afs can't change the relevant data + * structures directly because commands are executed in a child process, i.e. + * they get their own virtual address space. + * + * This structure is used by \p send_callback_request() (executed from handler + * context) in order to let the afs process call the specified function. An + * instance of that structure is written to a shared memory area together with + * the arguments to the callback function. The identifier of the shared memory + * area is written to the command socket. * - * Commands that need to change the state of para_server can't - * change the relevant data structures directly because commands - * are executed in a child process, i.e. they get their own - * virtual address space. This structure must be used to let - * para_server (i.e. the parent process) call a function specified - * by the child (the command handler). + * The afs process accepts connections on the command socket and reads the + * shared memory id, attaches the corresponing area, calls the given handler to + * perform the desired action and to optionally compute a result. * - * \sa fork(2), ipc.c. + * The result and a \p callback_result structure is then written to another + * shared memory area. The identifier for that area is written to the handler's + * command socket, so that the handler process can read the id, attach the + * shared memory area and use the result. + * + * \sa struct callback_result. */ -struct callback_data { +struct callback_query { /** The function to be called. */ callback_function *handler; - /** The sma for the parameters of the callback function. */ - int query_shmid; - /** The size of the query sma. */ + /** The number of bytes of the query */ size_t query_size; - /** If the callback produced a result, it is stored in this sma. */ - int result_shmid; - /** The size of the result sma. */ - size_t result_size; - /** The return value of the callback function. */ - int callback_ret; - /** The return value of the callback() procedure. */ - int sma_ret; }; -static struct callback_data *shm_callback_data; -static int callback_mutex; -static int child_mutex; -static int result_mutex; +/** + * Structure embedded in the result of a callback. + * + * If the callback produced a result, an instance of that structure is embeeded + * into the shared memory area holding the result, mainly to let the command + * handler know the size of the result. + * + * \sa struct callback_query. + */ +struct callback_result { + /** The number of bytes of the result. */ + size_t result_size; +}; /** * Ask the parent process to call a given function. @@ -147,90 +130,92 @@ static int result_mutex; * \param result Callback result will be stored here. * * This function creates a shared memory area, copies the buffer pointed to by - * \a buf to that area and notifies the parent process that \a f should be - * called ASAP. It provides proper locking via semaphores to protect against - * concurent access to the shared memory area and against concurrent access by - * another child process that asks to call the same function. + * \a buf to that area and notifies the afs process that \a f should be + * called ASAP. * - * \return Negative, if the shared memory area could not be set up. The return - * value of the callback function otherwise. + * \return Negative, on errors, the return value of the callback function + * otherwise. * - * \sa shm_new(), shm_attach(), shm_detach(), mutex_lock(), mutex_unlock(), - * shm_destroy(), struct callback_data, send_option_arg_callback_request(), - * send_standard_callback_request(). + * \sa send_option_arg_callback_request(), send_standard_callback_request(). */ int send_callback_request(callback_function *f, struct osl_object *query, struct osl_object *result) { - struct callback_data cbd = {.handler = f}; - int ret; - void *query_sma; + struct callback_query *cq; + struct callback_result *cr; + int ret, fd = -1, query_shmid, result_shmid; + void *query_shm, *result_shm; + char buf[sizeof(afs_socket_cookie) + sizeof(int)]; + struct sockaddr_un unix_addr; + size_t query_shm_size = sizeof(*cq); - assert(query->data && query->size); - ret = shm_new(query->size); + if (query) + query_shm_size += query->size; + ret = shm_new(query_shm_size); if (ret < 0) return ret; - cbd.query_shmid = ret; - cbd.query_size = query->size; - ret = shm_attach(cbd.query_shmid, ATTACH_RW, &query_sma); + query_shmid = ret; + ret = shm_attach(query_shmid, ATTACH_RW, &query_shm); if (ret < 0) goto out; - memcpy(query_sma, query->data, query->size); - ret = shm_detach(query_sma); + cq = query_shm; + cq->handler = f; + cq->query_size = query_shm_size - sizeof(*cq); + + if (query) + memcpy(query_shm + sizeof(*cq), query->data, query->size); + ret = shm_detach(query_shm); if (ret < 0) goto out; - /* prevent other children from interacting */ - mutex_lock(child_mutex); - /* prevent parent from messing with shm_callback_data. */ - mutex_lock(callback_mutex); - /* all three mutexes are locked, set parameters for callback */ - *shm_callback_data = cbd; - /* unblock parent */ - mutex_unlock(callback_mutex); - kill(getppid(), SIGUSR1); /* wake up parent */ - /* - * At this time only the parent can run. It will execute our callback - * and unlock the result_mutex when ready to indicate that the child - * may use the result. So let's sleep on this mutex. - */ - mutex_lock(result_mutex); - /* No need to aquire the callback mutex again */ - ret = shm_callback_data->sma_ret; - if (ret < 0) /* sma problem, callback might not have been executed */ - goto unlock_child_mutex; - if (shm_callback_data->result_shmid >= 0) { /* parent provided a result */ - void *sma; - ret = shm_attach(shm_callback_data->result_shmid, ATTACH_RO, - &sma); - if (ret >= 0) { - if (result) { /* copy result */ - result->size = shm_callback_data->result_size; - result->data = para_malloc(result->size); - memcpy(result->data, sma, result->size); - ret = shm_detach(sma); - if (ret < 0) - PARA_ERROR_LOG("can not detach result\n"); - } else - PARA_WARNING_LOG("no result pointer\n"); - } else - PARA_ERROR_LOG("attach result failed: %d\n", ret); - if (shm_destroy(shm_callback_data->result_shmid) < 0) - PARA_ERROR_LOG("destroy result failed\n"); - } else { /* no result from callback */ - if (result) { - PARA_WARNING_LOG("callback has no result\n"); - result->data = NULL; - result->size = 0; - } + + *(uint32_t *) buf = afs_socket_cookie; + *(int *) (buf + sizeof(afs_socket_cookie)) = query_shmid; + + ret = get_stream_socket(PF_UNIX); + if (ret < 0) + goto out; + fd = ret; + ret = init_unix_addr(&unix_addr, conf.afs_socket_arg); + if (ret < 0) + goto out; + ret = PARA_CONNECT(fd, &unix_addr); + if (ret < 0) + goto out; + ret = send_bin_buffer(fd, buf, sizeof(buf)); + if (ret < 0) + goto out; + ret = recv_bin_buffer(fd, buf, sizeof(buf)); + if (ret < 0) + goto out; + if (ret != sizeof(int)) { + ret = -E_RECV; + goto out; } - ret = shm_callback_data->callback_ret; -unlock_child_mutex: - /* give other children a chance */ - mutex_unlock(child_mutex); + ret = *(int *) buf; + if (ret <= 0) + goto out; + result_shmid = ret; + ret = shm_attach(result_shmid, ATTACH_RO, &result_shm); + if (ret >= 0) { + assert(result); + cr = result_shm; + result->size = cr->result_size; + result->data = para_malloc(result->size); + memcpy(result->data, result_shm + sizeof(*cr), result->size); + ret = shm_detach(result_shm); + if (ret < 0) + PARA_ERROR_LOG("can not detach result\n"); + } else + PARA_ERROR_LOG("attach result failed: %d\n", ret); + if (shm_destroy(result_shmid) < 0) + PARA_ERROR_LOG("destroy result failed\n"); + ret = 1; out: - if (shm_destroy(cbd.query_shmid) < 0) + if (shm_destroy(query_shmid) < 0) PARA_ERROR_LOG("%s\n", "shm destroy error"); - PARA_DEBUG_LOG("callback_ret: %d\n", ret); + if (fd >= 0) + close(fd); +// PARA_DEBUG_LOG("callback_ret: %d\n", ret); return ret; } @@ -251,7 +236,7 @@ out: * \sa send_standard_callback_request(), send_callback_request(). */ int send_option_arg_callback_request(struct osl_object *options, - int argc, const char **argv, callback_function *f, + int argc, char * const * const argv, callback_function *f, struct osl_object *result) { char *p; @@ -289,54 +274,105 @@ int send_option_arg_callback_request(struct osl_object *options, * \return The return value of the underlying call to * send_option_arg_callback_request(). */ -int send_standard_callback_request(int argc, const char **argv, +int send_standard_callback_request(int argc, char * const * const argv, callback_function *f, struct osl_object *result) { return send_option_arg_callback_request(NULL, argc, argv, f, result); } +static int action_if_pattern_matches(struct osl_row *row, void *data) +{ + struct pattern_match_data *pmd = data; + struct osl_object name_obj; + const char *p, *name; + int ret = osl_get_object(pmd->table, row, pmd->match_col_num, &name_obj); + const char *pattern_txt = (const char *)pmd->patterns.data; + + if (ret < 0) + return ret; + name = (char *)name_obj.data; + if ((!name || !*name) && (pmd->pm_flags & PM_SKIP_EMPTY_NAME)) + return 1; + if (!pmd->patterns.size && (pmd->pm_flags & PM_NO_PATTERN_MATCHES_EVERYTHING)) + return pmd->action(pmd->table, row, name, pmd->data); + for (p = pattern_txt; p < pattern_txt + pmd->patterns.size; + p += strlen(p) + 1) { + ret = fnmatch(p, name, pmd->fnmatch_flags); + if (ret == FNM_NOMATCH) + continue; + if (ret) + return -E_FNMATCH; + return pmd->action(pmd->table, row, name, pmd->data); + } + return 1; +} + +int for_each_matching_row(struct pattern_match_data *pmd) +{ + if (pmd->pm_flags & PM_REVERSE_LOOP) + return osl_rbtree_loop_reverse(pmd->table, pmd->loop_col_num, pmd, + action_if_pattern_matches); + return osl_rbtree_loop(pmd->table, pmd->loop_col_num, pmd, + action_if_pattern_matches); +} + +/** + * Compare two osl objects of string type. + * + * \param obj1 Pointer to the first object. + * \param obj2 Pointer to the second object. + * + * In any case, only \p MIN(obj1->size, obj2->size) characters of each string + * are taken into account. + * + * \return It returns an integer less than, equal to, or greater than zero if + * \a obj1 is found, respectively, to be less than, to match, or be greater than + * obj2. + * + * \sa strcmp(3), strncmp(3), osl_compare_func. + */ +int string_compare(const struct osl_object *obj1, const struct osl_object *obj2) +{ + const char *str1 = (const char *)obj1->data; + const char *str2 = (const char *)obj2->data; + return strncmp(str1, str2, PARA_MIN(obj1->size, obj2->size)); +} + /* - * write input from fd to dynamically allocated char array, - * but maximal max_size byte. Return size. + * write input from fd to dynamically allocated buffer, + * but maximal max_size byte. */ -static int fd2buf(int fd, char **buf, int max_size) +static int fd2buf(int fd, unsigned max_size, struct osl_object *obj) { const size_t chunk_size = 1024; - size_t size = 2048; - char *p; + size_t size = 2048, received = 0; int ret; + char *buf = para_malloc(size); - *buf = para_malloc(size * sizeof(char)); - p = *buf; - while ((ret = read(fd, p, chunk_size)) > 0) { - p += ret; - if ((p - *buf) + chunk_size >= size) { - char *tmp; - + for (;;) { + ret = recv_bin_buffer(fd, buf + received, chunk_size); + if (ret <= 0) + break; + received += ret; + if (received + chunk_size >= size) { size *= 2; - if (size > max_size) { - ret = -E_INPUT_TOO_LARGE; - goto out; - } - tmp = para_realloc(*buf, size); - p = (p - *buf) + tmp; - *buf = tmp; + ret = -E_INPUT_TOO_LARGE; + if (size > max_size) + break; + buf = para_realloc(buf, size); } } - if (ret < 0) { - ret = -E_READ; - goto out; - } - ret = p - *buf; -out: - if (ret < 0 && *buf) - free(*buf); + obj->data = buf; + obj->size = received; + if (ret < 0) + free(buf); return ret; } /** - * Read from stdin, and send the result to the parent process. + * Read data from a file descriptor, and send it to the afs process. * + * \param fd File descriptor to read data from. * \param arg_obj Pointer to the arguments to \a f. * \param f The callback function. * \param max_len Don't read more than that many bytes from stdin. @@ -344,29 +380,30 @@ out: * * This function is used by commands that wish to let para_server store * arbitrary data specified by the user (for instance the add_blob family of - * commands). First, at most \a max_len bytes are read from stdin, the result + * commands). First, at most \a max_len bytes are read from \a fd, the result * is concatenated with the buffer given by \a arg_obj, and the combined buffer * is made available to the parent process via shared memory. * * \return Negative on errors, the return value of the underlying call to * send_callback_request() otherwise. */ -int stdin_command(struct osl_object *arg_obj, callback_function *f, +int stdin_command(int fd, struct osl_object *arg_obj, callback_function *f, unsigned max_len, struct osl_object *result) { - char *stdin_buf; - size_t stdin_len; - struct osl_object query; - int ret = fd2buf(STDIN_FILENO, &stdin_buf, max_len); + struct osl_object query, stdin_obj; + int ret; + ret = send_buffer(fd, AWAITING_DATA_MSG); if (ret < 0) return ret; - stdin_len = ret; - query.size = arg_obj->size + stdin_len; + ret = fd2buf(fd, max_len, &stdin_obj); + if (ret < 0) + return ret; + query.size = arg_obj->size + stdin_obj.size; query.data = para_malloc(query.size); memcpy(query.data, arg_obj->data, arg_obj->size); - memcpy((char *)query.data + arg_obj->size, stdin_buf, stdin_len); - free(stdin_buf); + memcpy((char *)query.data + arg_obj->size, stdin_obj.data, stdin_obj.size); + free(stdin_obj.data); ret = send_callback_request(f, &query, result); free(query.data); return ret; @@ -437,68 +474,66 @@ static void play_loop(enum play_mode current_play_mode) static enum play_mode init_admissible_files(void) { int ret; - char *given_mood, *given_playlist; - - given_mood = "mood_that_was_given_at_the_command_line"; - given_playlist = "given_playlist"; - if (given_mood) { - ret = mood_open(given_mood); + if (conf.mood_given) { + ret = change_current_mood(conf.mood_arg); if (ret >= 0) { - if (given_playlist) + if (conf.playlist_given) PARA_WARNING_LOG("ignoring playlist %s\n", - given_playlist); + conf.playlist_arg); return PLAY_MODE_MOOD; } } - if (given_playlist) { - ret = playlist_open(given_playlist); + if (conf.playlist_given) { + ret = playlist_open(conf.playlist_arg); if (ret >= 0) return PLAY_MODE_PLAYLIST; } - ret = mood_open(NULL); /* open first available mood */ + ret = change_current_mood(NULL); /* open first available mood */ if (ret >= 0) return PLAY_MODE_MOOD; - mood_open(""); /* open dummy mood, always successful */ + change_current_mood(""); /* open dummy mood, always successful */ return PLAY_MODE_MOOD; } -int command_socket; - -static void setup_command_socket(void) +static int setup_command_socket_or_die(void) { int ret; - char *socket_name = "/tmp/afs_command_socket"; + char *socket_name = conf.afs_socket_arg; struct sockaddr_un unix_addr; unlink(socket_name); ret = create_local_socket(socket_name, &unix_addr, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH); - if (ret < 0) + if (ret < 0) { + PARA_EMERG_LOG("%s: %s\n", PARA_STRERROR(-ret), socket_name); exit(EXIT_FAILURE); - command_socket = ret; - if (listen(command_socket , 5) < 0) { + } + if (listen(ret , 5) < 0) { PARA_EMERG_LOG("%s", "can not listen on socket\n"); exit(EXIT_FAILURE); } PARA_INFO_LOG("listening on command socket %s (fd %d)\n", socket_name, - command_socket); + ret); + return ret; } static int server_socket; +static struct command_task command_task_struct; +static struct signal_task signal_task_struct; -void loop(void) +static void unregister_tasks(void) { - for (;;) - sleep(1); + unregister_task(&command_task_struct.task); + unregister_task(&signal_task_struct.task); } -static void afs_shutdown(enum osl_close_flags flags) +static void close_afs_tables(enum osl_close_flags flags) { - PARA_NOTICE_LOG("cleaning up\n"); + PARA_NOTICE_LOG("closing afs_tables\n"); score_shutdown(flags); attribute_shutdown(flags); - mood_close(); + close_current_mood(); playlist_close(); moods_shutdown(flags); playlists_shutdown(flags); @@ -521,17 +556,16 @@ static void signal_post_select(struct sched *s, struct task *t) if (!FD_ISSET(st->fd, &s->rfds)) return; st->signum = para_next_signal(); - PARA_NOTICE_LOG("caught signal %d\n", st->signum); t->ret = 1; if (st->signum == SIGUSR1) return; /* ignore SIGUSR1 */ - afs_shutdown(OSL_MARK_CLEAN); + PARA_NOTICE_LOG("caught signal %d\n", st->signum); t->ret = -E_SIGNAL_CAUGHT; + unregister_tasks(); } static void register_signal_task(void) { - static struct signal_task signal_task_struct; struct signal_task *st = &signal_task_struct; st->fd = para_signal_init(); PARA_INFO_LOG("signal pipe: fd %d\n", st->fd); @@ -546,75 +580,224 @@ static void register_signal_task(void) register_task(&st->task); } -void register_tasks(void) +static struct list_head afs_client_list; + +struct afs_client { + struct list_head node; + int fd; + struct timeval connect_time; +}; + +static void command_pre_select(struct sched *s, struct task *t) +{ + struct command_task *ct = t->private_data; + struct afs_client *client; + + para_fd_set(ct->fd, &s->rfds, &s->max_fileno); + list_for_each_entry(client, &afs_client_list, node) + para_fd_set(client->fd, &s->rfds, &s->max_fileno); + t->ret = 1; +} + +/* + * On errors, negative value is written to fd. + * On success: If query produced a result, the result_shmid is written to fd. + * Otherwise, zero is written. + */ +static int call_callback(int fd, int query_shmid) +{ + void *query_shm, *result_shm; + struct callback_query *cq; + struct callback_result *cr; + struct osl_object query, result = {.data = NULL}; + int result_shmid = -1, ret, ret2; + + ret = shm_attach(query_shmid, ATTACH_RW, &query_shm); + if (ret < 0) + goto out; + cq = query_shm; + query.data = (char *)query_shm + sizeof(*cq); + query.size = cq->query_size; + ret = cq->handler(&query, &result); + ret2 = shm_detach(query_shm); + if (ret2 < 0 && ret >= 0) + ret = ret2; + if (ret < 0) + goto out; + ret = 0; + if (!result.data || !result.size) + goto out; + ret = shm_new(result.size + sizeof(struct callback_result)); + if (ret < 0) + goto out; + result_shmid = ret; + ret = shm_attach(result_shmid, ATTACH_RW, &result_shm); + if (ret < 0) + goto out; + cr = result_shm; + cr->result_size = result.size; + memcpy(result_shm + sizeof(*cr), result.data, result.size); + ret = shm_detach(result_shm); + if (ret < 0) + goto out; + ret = result_shmid; +out: + free(result.data); + ret2 = send_bin_buffer(fd, (char *)&ret, sizeof(int)); + if (ret < 0 || ret2 < 0) { + if (result_shmid >= 0) + if (shm_destroy(result_shmid) < 0) + PARA_ERROR_LOG("destroy result failed\n"); + if (ret >= 0) + ret = ret2; + } + return ret; +} + +static void execute_afs_command(int fd, uint32_t expected_cookie) +{ + uint32_t cookie; + int query_shmid; + char buf[sizeof(cookie) + sizeof(query_shmid)]; + int ret = recv_bin_buffer(fd, buf, sizeof(buf)); + + if (ret < 0) { + PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-ret)); + return; + } + if (ret != sizeof(buf)) { + PARA_NOTICE_LOG("short read (%d bytes, expected %lu)\n", + ret, (long unsigned) sizeof(buf)); + return; + } + cookie = *(uint32_t *)buf; + if (cookie != expected_cookie) { + PARA_NOTICE_LOG("received invalid cookie(got %u, expected %u)\n", + (unsigned)cookie, (unsigned)expected_cookie); + return; + } + query_shmid = *(int *)(buf + sizeof(cookie)); + if (query_shmid < 0) { + PARA_WARNING_LOG("received invalid query shmid %d)\n", + query_shmid); + return; + } + /* Ignore return value: Errors might be ok here. */ + call_callback(fd, query_shmid); +} + +#define AFS_CLIENT_TIMEOUT 3 + +static void command_post_select(struct sched *s, struct task *t) +{ + struct command_task *ct = t->private_data; + struct sockaddr_un unix_addr; + struct afs_client *client, *tmp; + + /* First, check the list of connected clients. */ + list_for_each_entry_safe(client, tmp, &afs_client_list, node) { + if (FD_ISSET(client->fd, &s->rfds)) + execute_afs_command(client->fd, ct->cookie); + else { /* prevent bogus connection flodding */ + struct timeval diff; + tv_diff(now, &client->connect_time, &diff); + if (diff.tv_sec < AFS_CLIENT_TIMEOUT) + continue; + PARA_WARNING_LOG("connection timeout\n"); + } + close(client->fd); + list_del(&client->node); + free(client); + } + /* Next, accept connections on the local socket. */ + if (!FD_ISSET(ct->fd, &s->rfds)) + goto out; + t->ret = para_accept(ct->fd, &unix_addr, sizeof(unix_addr)); + if (t->ret < 0) { + PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret)); + goto out; + } + client = para_malloc(sizeof(*client)); + client->fd = t->ret; + client->connect_time = *now; + para_list_add(&client->node, &afs_client_list); +out: + t->ret = 1; +} + +static void register_command_task(uint32_t cookie) +{ + struct command_task *ct = &command_task_struct; + ct->fd = setup_command_socket_or_die(); + ct->cookie = cookie; + + ct->task.pre_select = command_pre_select; + ct->task.post_select = command_post_select; + ct->task.private_data = ct; + sprintf(ct->task.status, "command task"); + register_task(&ct->task); +} + +void register_tasks(uint32_t cookie) { register_signal_task(); + register_command_task(cookie); } -__noreturn int afs_init(uint32_t cookie, int socket_fd) +static char *database_dir; + +static int make_database_dir(void) { int ret; -// void *shm_area; - enum play_mode current_play_mode; - struct sched s; - server_socket = socket_fd; - socket_cookie = cookie; - PARA_INFO_LOG("server_socket: %d, afs_socket_cookie: %u\n", - server_socket, (unsigned) cookie); - setup_command_socket(); + if (!database_dir) { + if (conf.afs_database_dir_given) + database_dir = para_strdup(conf.afs_database_dir_arg); + else { + char *home = para_homedir(); + database_dir = make_message( + "%s/.paraslash/afs_database", home); + free(home); + } + } + PARA_INFO_LOG("afs_database dir %s\n", database_dir); + ret = para_mkdir(database_dir, 0777); + if (ret >= 0 || ret == -E_EXIST) + return 1; + free(database_dir); + database_dir = NULL; + return ret; +} + +static int open_afs_tables(void) +{ + int ret = make_database_dir(); - ret = attribute_init(&afs_tables[TBLNUM_ATTRIBUTES]); if (ret < 0) - goto attribute_init_error; - ret = moods_init(&afs_tables[TBLNUM_MOODS]); + return ret; + ret = attribute_init(&afs_tables[TBLNUM_ATTRIBUTES], database_dir); + if (ret < 0) + return ret; + ret = moods_init(&afs_tables[TBLNUM_MOODS], database_dir); if (ret < 0) goto moods_init_error; - ret = playlists_init(&afs_tables[TBLNUM_PLAYLIST]); + ret = playlists_init(&afs_tables[TBLNUM_PLAYLIST], database_dir); if (ret < 0) goto playlists_init_error; - ret = lyrics_init(&afs_tables[TBLNUM_LYRICS]); + ret = lyrics_init(&afs_tables[TBLNUM_LYRICS], database_dir); if (ret < 0) goto lyrics_init_error; - ret = images_init(&afs_tables[TBLNUM_IMAGES]); + ret = images_init(&afs_tables[TBLNUM_IMAGES], database_dir); if (ret < 0) goto images_init_error; - ret = score_init(&afs_tables[TBLNUM_SCORES]); + ret = score_init(&afs_tables[TBLNUM_SCORES], database_dir); if (ret < 0) goto score_init_error; - ret = aft_init(&afs_tables[TBLNUM_AUDIO_FILES]); + ret = aft_init(&afs_tables[TBLNUM_AUDIO_FILES], database_dir); if (ret < 0) goto aft_init_error; + return 1; - current_play_mode = init_admissible_files(); - register_tasks(); - s.default_timeout.tv_sec = 0; - s.default_timeout.tv_usec = 99 * 1000; - sched(&s); - -#if 0 - ret = shm_new(sizeof(struct callback_data)); - if (ret < 0) - return ret; - shmid = ret; - ret = shm_attach(shmid, ATTACH_RW, &shm_area); - if (ret < 0) - return ret; - shm_callback_data = shm_area; - ret = mutex_new(); - if (ret < 0) - return ret; - callback_mutex = ret; - ret = mutex_new(); - if (ret < 0) - return ret; - child_mutex = ret; - ret = mutex_new(); - if (ret < 0) - return ret; - result_mutex = ret; - mutex_lock(result_mutex); -#endif aft_init_error: score_shutdown(OSL_MARK_CLEAN); score_init_error: @@ -627,293 +810,161 @@ playlists_init_error: moods_shutdown(OSL_MARK_CLEAN); moods_init_error: attribute_shutdown(OSL_MARK_CLEAN); -attribute_init_error: + return ret; +} + +__noreturn int afs_init(uint32_t cookie, int socket_fd) +{ + enum play_mode current_play_mode; + struct sched s; + int ret; + + INIT_LIST_HEAD(&afs_client_list); + ret = open_afs_tables(); + + if (ret < 0) { + PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); + exit(EXIT_FAILURE); + } + server_socket = socket_fd; + ret = mark_fd_nonblock(server_socket); + if (ret < 0) + exit(EXIT_FAILURE); + PARA_INFO_LOG("server_socket: %d, afs_socket_cookie: %u\n", + server_socket, (unsigned) cookie); + current_play_mode = init_admissible_files(); + register_tasks(cookie); + s.default_timeout.tv_sec = 0; + s.default_timeout.tv_usec = 99 * 1000; + ret = sched(&s); + if (ret < 0) + PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); + close_afs_tables(OSL_MARK_CLEAN); exit(EXIT_FAILURE); } -static int create_all_tables(void) +static int create_tables_callback(const struct osl_object *query, + __a_unused struct osl_object *result) { + uint32_t table_mask = *(uint32_t *)query->data; int i, ret; + close_afs_tables(OSL_MARK_CLEAN); for (i = 0; i < NUM_AFS_TABLES; i++) { struct table_info *ti = afs_tables + i; if (ti->flags & TBLFLAG_SKIP_CREATE) continue; + if (!(table_mask & (1 << i))) + continue; ret = osl_create_table(ti->desc); if (ret < 0) return ret; } - return 1; + ret = open_afs_tables(); + return ret < 0? ret: 0; } -/* TODO load tables after init */ -static int com_init(__a_unused int fd, int argc, const char **argv) +int com_init(int fd, int argc, char * const * const argv) { int i, j, ret; - if (argc == 1) - return create_all_tables(); - for (i = 1; i < argc; i++) { - for (j = 0; j < NUM_AFS_TABLES; j++) { - struct table_info *ti = afs_tables + j; - - if (ti->flags & TBLFLAG_SKIP_CREATE) - continue; - if (strcmp(argv[i], ti->desc->name)) - continue; - PARA_NOTICE_LOG("creating table %s\n", argv[i]); - ret = osl_create_table(ti->desc); - if (ret < 0) - return ret; - break; + uint32_t table_mask = (1 << (NUM_AFS_TABLES + 1)) - 1; + struct osl_object query = {.data = &table_mask, + .size = sizeof(table_mask)}; + + if (argc != 1) { + table_mask = 0; + for (i = 1; i < argc; i++) { + for (j = 0; j < NUM_AFS_TABLES; j++) { + struct table_info *ti = afs_tables + j; + + if (ti->flags & TBLFLAG_SKIP_CREATE) + continue; + if (strcmp(argv[i], ti->desc->name)) + continue; + table_mask |= (1 << j); + break; + } + if (j == NUM_AFS_TABLES) + return -E_BAD_TABLE_NAME; } - if (j == NUM_AFS_TABLES) - return -E_BAD_TABLE_NAME; } - return 1; + ret = send_callback_request(create_tables_callback, &query, NULL); + if (ret < 0) + return ret; + return send_va_buffer(fd, "successfully created afs table(s)\n"); } -/** Describes a command of para_server. */ -struct command { - /** The name of the command. */ - const char *name; - /** The handler function. */ - int (*handler)(int fd, int argc, const char **argv); -}; -static struct command cmd[] = { -{ - .name = "add", - .handler = com_add, -}, -{ - .name = "addlyr", - .handler = com_addlyr, -}, -{ - .name = "addimg", - .handler = com_addimg, -}, -{ - .name = "addmood", - .handler = com_addmood, -}, -{ - .name = "addpl", - .handler = com_addpl, -}, -{ - .name = "catlyr", - .handler = com_catlyr, -}, -{ - .name = "catimg", - .handler = com_catimg, -}, -{ - .name = "mvimg", - .handler = com_mvimg, -}, -{ - .name = "mvlyr", - .handler = com_mvlyr, -}, -{ - .name = "mvmood", - .handler = com_mvmood, -}, -{ - .name = "mvpl", - .handler = com_mvpl, -}, -{ - .name = "catmood", - .handler = com_catmood, -}, -{ - .name = "catpl", - .handler = com_catpl, -}, -{ - .name = "rmatt", - .handler = com_rmatt, -}, -{ - .name = "init", - .handler = com_init, -}, -{ - .name = "lsatt", - .handler = com_lsatt, -}, -{ - .name = "ls", - .handler = com_afs_ls, -}, -{ - .name = "lslyr", - .handler = com_lslyr, -}, -{ - .name = "lsimg", - .handler = com_lsimg, -}, -{ - .name = "lsmood", - .handler = com_lsmood, -}, -{ - .name = "lspl", - .handler = com_lspl, -}, -{ - .name = "setatt", - .handler = com_setatt, -}, -{ - .name = "addatt", - .handler = com_addatt, -}, -{ - .name = "rm", - .handler = com_afs_rm, -}, -{ - .name = "rmlyr", - .handler = com_rmlyr, -}, -{ - .name = "rmimg", - .handler = com_rmimg, -}, -{ - .name = "rmmood", - .handler = com_rmmood, -}, -{ - .name = "rmpl", - .handler = com_rmpl, -}, -{ - .name = "touch", - .handler = com_touch, -}, -{ - .name = NULL, -} +enum com_check_flags { + CHECK_AFT = 1, + CHECK_MOODS = 2, + CHECK_PLAYLISTS = 4 }; -static void call_callback(void) +int com_check(int fd, int argc, char * const * const argv) { - struct osl_object query, result = {.data = NULL}; - int ret, ret2; + unsigned flags = 0; + int i, ret; + struct osl_object result; - shm_callback_data->result_shmid = -1; /* no result */ - ret = shm_attach(shm_callback_data->query_shmid, ATTACH_RW, - &query.data); - if (ret < 0) - goto out; - query.size = shm_callback_data->query_size; - shm_callback_data->callback_ret = shm_callback_data->handler(&query, - &result); - if (result.data && result.size) { - void *sma; - ret = shm_new(result.size); - if (ret < 0) - goto detach_query; - shm_callback_data->result_shmid = ret; - shm_callback_data->result_size = result.size; - ret = shm_attach(shm_callback_data->result_shmid, ATTACH_RW, &sma); - if (ret < 0) - goto destroy_result; - memcpy(sma, result.data, result.size); - ret = shm_detach(sma); - if (ret < 0) { - PARA_ERROR_LOG("detach result failed\n"); - goto destroy_result; + for (i = 1; i < argc; i++) { + const char *arg = argv[i]; + if (arg[0] != '-') + break; + if (!strcmp(arg, "--")) { + i++; + break; } - } - ret = 1; - goto detach_query; -destroy_result: - if (shm_destroy(shm_callback_data->result_shmid) < 0) - PARA_ERROR_LOG("destroy result failed\n"); - shm_callback_data->result_shmid = -1; -detach_query: - free(result.data); - ret2 = shm_detach(query.data); - if (ret2 < 0) { - PARA_ERROR_LOG("detach query failed\n"); - if (ret >= 0) - ret = ret2; - } -out: - if (ret < 0) - PARA_ERROR_LOG("sma error %d\n", ret); - shm_callback_data->sma_ret = ret; - shm_callback_data->handler = NULL; - mutex_unlock(result_mutex); /* wake up child */ -} - -#if 0 -static int got_sigchld; -static void server_loop(int child_pid) -{ -// int status; - - PARA_DEBUG_LOG("server pid: %d, child pid: %d\n", - getpid(), child_pid); - for (;;) { - mutex_lock(callback_mutex); - if (shm_callback_data->handler) - call_callback(); - mutex_unlock(callback_mutex); - usleep(100); - if (!got_sigchld) + if (!strcmp(arg, "-a")) { + flags |= CHECK_AFT; + continue; + } + if (!strcmp(arg, "-p")) { + flags |= CHECK_PLAYLISTS; + continue; + } + if (!strcmp(arg, "-m")) { + flags |= CHECK_MOODS; continue; - mutex_destroy(result_mutex); - mutex_destroy(callback_mutex); - mutex_destroy(child_mutex); - afs_shutdown(OSL_MARK_CLEAN); - exit(EXIT_SUCCESS); + } + return -E_AFS_SYNTAX; } -} - -int main(int argc, const char **argv) -{ - int i, ret = -E_AFS_SYNTAX; - - signal(SIGUSR1, dummy); - signal(SIGCHLD, sigchld_handler); - if (argc < 2) - goto out; - ret = setup(); -// ret = afs_init(); - if (ret < 0) { - PARA_EMERG_LOG("afs_init returned %d\n", ret); - exit(EXIT_FAILURE); + if (i < argc) + return -E_AFS_SYNTAX; + if (!flags) + flags = ~0U; + if (flags & CHECK_AFT) { + ret = send_callback_request(aft_check_callback, NULL, &result); + if (ret < 0) + return ret; + if (ret > 0) { + ret = send_buffer(fd, (char *) result.data); + free(result.data); + if (ret < 0) + return ret; + } } - ret = fork(); - if (ret < 0) { - ret = -E_FORK; - goto out; + if (flags & CHECK_PLAYLISTS) { + ret = send_callback_request(playlist_check_callback, NULL, &result); + if (ret < 0) + return ret; + if (ret > 0) { + ret = send_buffer(fd, (char *) result.data); + free(result.data); + if (ret < 0) + return ret; + } } - if (ret) - server_loop(ret); - for (i = 0; cmd[i].name; i++) { - if (strcmp(cmd[i].name, argv[1])) - continue; - ret = cmd[i].handler(1, argc - 1 , argv + 1); - goto out; - + if (flags & CHECK_MOODS) { + ret = send_callback_request(mood_check_callback, NULL, &result); + if (ret < 0) + return ret; + if (ret > 0) { + ret = send_buffer(fd, (char *) result.data); + free(result.data); + if (ret < 0) + return ret; + } } - PARA_ERROR_LOG("unknown command: %s\n", argv[1]); - ret = -1; -out: - if (ret < 0) - PARA_ERROR_LOG("error %d\n", ret); - else - PARA_DEBUG_LOG("%s", "success\n"); - afs_shutdown(0); - return ret < 0? EXIT_FAILURE : EXIT_SUCCESS; + return 1; } -#endif