+ 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;
+ }
+ }
+ ret = shm_callback_data->callback_ret;
+unlock_child_mutex:
+ /* give other children a chance */
+ mutex_unlock(child_mutex);
+out:
+ if (shm_destroy(cbd.query_shmid) < 0)
+ PARA_ERROR_LOG("%s\n", "shm destroy error");
+ PARA_DEBUG_LOG("callback_ret: %d\n", ret);
+ return ret;
+}
+
+/**
+ * Send a callback request passing an options structure and an argument vector.
+ *
+ * \param options pointer to an arbitrary data structure.
+ * \param argc Argument count.
+ * \param argv Standard argument vector.
+ * \param f The callback function.
+ * \param result The result of the query is stored here.
+ *
+ * Some commands have a couple of options that are parsed in child context for
+ * syntactic correctness and are stored in a special options structure for that
+ * command. This function allows to pass such a structure together with a list
+ * of further arguments (often a list of audio files) to the parent process.
+ *
+ * \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,
+ struct osl_object *result)
+{
+ char *p;
+ int i, ret;
+ struct osl_object query = {.size = options? options->size : 0};
+
+ for (i = 0; i < argc; i++)
+ query.size += strlen(argv[i]) + 1;
+ query.data = para_malloc(query.size);
+ p = query.data;
+ if (options) {
+ memcpy(query.data, options->data, options->size);
+ p += options->size;
+ }
+ for (i = 0; i < argc; i++) {
+ strcpy(p, argv[i]); /* OK */
+ p += strlen(argv[i]) + 1;
+ }
+ ret = send_callback_request(f, &query, result);
+ free(query.data);
+ return ret;
+}
+
+/**
+ * Send a callback request with an argument vector only.
+ *
+ * \param argc The same meaning as in send_option_arg_callback_request().
+ * \param argv The same meaning as in send_option_arg_callback_request().
+ * \param f The same meaning as in send_option_arg_callback_request().
+ * \param result The same meaning as in send_option_arg_callback_request().
+ *
+ * This is similar to send_option_arg_callback_request(), but no options buffer
+ * is passed to the parent process.
+ *
+ * \return The return value of the underlying call to
+ * send_option_arg_callback_request().
+ */
+int send_standard_callback_request(int argc, const char **argv,
+ callback_function *f, struct osl_object *result)
+{
+ return send_option_arg_callback_request(NULL, argc, argv, f, result);
+}
+
+/*
+ * write input from fd to dynamically allocated char array,
+ * but maximal max_size byte. Return size.
+ */
+static int fd2buf(int fd, char **buf, int max_size)
+{
+ const size_t chunk_size = 1024;
+ size_t size = 2048;
+ char *p;
+ int ret;
+
+ *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;
+
+ size *= 2;
+ if (size > max_size) {
+ ret = -E_INPUT_TOO_LARGE;
+ goto out;
+ }
+ tmp = para_realloc(*buf, size);
+ p = (p - *buf) + tmp;
+ *buf = tmp;
+ }
+ }
+ if (ret < 0) {
+ ret = -E_READ;
+ goto out;
+ }
+ ret = p - *buf;
+out:
+ if (ret < 0 && *buf)
+ free(*buf);
+ return ret;
+}
+
+/**
+ * Read from stdin, and send the result to the parent process.
+ *
+ * \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.
+ * \param result The result of the query is stored here.
+ *
+ * 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
+ * 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,
+ 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);
+
+ if (ret < 0)
+ return ret;
+ stdin_len = ret;
+ query.size = arg_obj->size + stdin_len;
+ 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);
+ ret = send_callback_request(f, &query, result);
+ free(query.data);
+ return ret;
+}
+
+/**
+ * Open the audio file with highest score.
+ *
+ * \param afd Audio file data is returned here.
+ *
+ * This stores all information for streaming the "best" audio file
+ * in the \a afd structure.
+ *
+ * \return Positive on success, negative on errors.
+ *
+ * \sa close_audio_file(), open_and_update_audio_file().
+ */
+int open_next_audio_file(struct audio_file_data *afd)
+{
+ struct osl_row *aft_row;