Merge branch 'refs/heads/t/command_handler_cleanups'
authorAndre Noll <maan@tuebingen.mpg.de>
Sun, 25 Oct 2015 15:06:43 +0000 (16:06 +0100)
committerAndre Noll <maan@tuebingen.mpg.de>
Sun, 25 Oct 2015 15:11:14 +0000 (16:11 +0100)
Cooking for about two months.

* refs/heads/t/command_handler_cleanups: (39 commits)
  com_addatt(): Return negative on errors
  com_rm(): In force mode, don't complain if no paths matched.
  aft: Unify handling of hash and path duplicates.
  afs: Provide pbout para_buffer for each callback.
  afs: Make afs callbacks more flexible.
  afs: Rename callback_function to afs_callback.
  com_check(): Add attribute checking.
  Let afs_event() return int.
  playlist_check_callback(): Return negative on errors
  mood_check_callback(): Return negative on errors
  com_mvblob(): Return negative on errors
  com_addblob(): Return negative on errors
  com_rmblob(): Return negative on errors, cleanup
  com_catblob(): Return negative on errors
  com_lsblob(): Return negative on errors
  rmatt: Cleanup callback.
  com_rmatt(): Return negative on errors
  com_mvatt(): Return negative on errors
  com_lsatt(): Return negative on errors
  com_init(): Return negative on errors
  ...

15 files changed:
NEWS
afs.c
afs.cmd
afs.h
aft.c
attribute.c
audiod_command.c
blob.c
command.c
error.h
mood.c
mood.h
playlist.c
sideband.h
string.h

diff --git a/NEWS b/NEWS
index f1940d3..7faa0dd 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -7,6 +7,11 @@ current master branch "cascading gradient"
 
        - para_afh learned to modify meta tags of mp3 wma ogg spx
          opus flac aac files.
+       - afs commands propagate error codes to the client.
+       - The check command now also checks the attribute table for
+         inconsistencies.
+       - New -v flag for the version command (print verbose version string)
+
 
 --------------------------------------
 0.5.5 (2015-09-20) "magnetic momentum"
diff --git a/afs.c b/afs.c
index 299d65e..bd70505 100644 (file)
--- a/afs.c
+++ b/afs.c
@@ -130,7 +130,7 @@ extern uint32_t afs_socket_cookie;
  */
 struct callback_query {
        /** The function to be called. */
-       callback_function *handler;
+       afs_callback *handler;
        /** The number of bytes of the query */
        size_t query_size;
 };
@@ -166,13 +166,8 @@ static int dispatch_result(int result_shmid, callback_result_handler *handler,
        }
        result.size = cr->result_size;
        result.data = result_shm + sizeof(*cr);
-       if (result.size) {
-               assert(handler);
-               ret = handler(&result, cr->band, private_result_data);
-               if (ret < 0)
-                       PARA_NOTICE_LOG("result handler error: %s\n",
-                               para_strerror(-ret));
-       }
+       assert(handler);
+       ret = handler(&result, cr->band, private_result_data);
        ret2 = shm_detach(result_shm);
        if (ret2 < 0) {
                PARA_ERROR_LOG("detach failed: %s\n", para_strerror(-ret2));
@@ -206,7 +201,7 @@ static int dispatch_result(int result_shmid, callback_result_handler *handler,
  *
  * \sa send_option_arg_callback_request(), send_standard_callback_request().
  */
-int send_callback_request(callback_function *f, struct osl_object *query,
+int send_callback_request(afs_callback *f, struct osl_object *query,
                callback_result_handler *result_handler,
                void *private_result_data)
 {
@@ -261,12 +256,10 @@ int send_callback_request(callback_function *f, struct osl_object *query,
                ret = *(int *) buf;
                assert(ret > 0);
                result_shmid = ret;
-               if (!dispatch_error) {
-                       ret = dispatch_result(result_shmid, result_handler,
-                               private_result_data);
-                       if (ret < 0)
-                               dispatch_error = 1;
-               }
+               ret = dispatch_result(result_shmid, result_handler,
+                       private_result_data);
+               if (ret < 0 && dispatch_error >= 0)
+                       dispatch_error = ret;
                ret = shm_destroy(result_shmid);
                if (ret < 0)
                        PARA_CRIT_LOG("destroy result failed: %s\n",
@@ -278,8 +271,11 @@ out:
                PARA_CRIT_LOG("shm destroy error\n");
        if (fd >= 0)
                close(fd);
-//     PARA_DEBUG_LOG("callback_ret: %d\n", ret);
-       return ret < 0? ret : num_dispatched;
+       if (dispatch_error < 0)
+               return dispatch_error;
+       if (ret < 0)
+               return ret;
+       return num_dispatched;
 }
 
 /**
@@ -303,7 +299,7 @@ out:
  * \sa send_standard_callback_request(), send_callback_request().
  */
 int send_option_arg_callback_request(struct osl_object *options,
-               int argc,  char * const * const argv, callback_function *f,
+               int argc,  char * const * const argv, afs_callback *f,
                callback_result_handler *result_handler,
                void *private_result_data)
 {
@@ -345,7 +341,7 @@ int send_option_arg_callback_request(struct osl_object *options,
  * send_option_arg_callback_request().
  */
 int send_standard_callback_request(int argc,  char * const * const argv,
-               callback_function *f, callback_result_handler *result_handler,
+               afs_callback *f, callback_result_handler *result_handler,
                void *private_result_data)
 {
        return send_option_arg_callback_request(NULL, argc, argv, f, result_handler,
@@ -505,6 +501,7 @@ static int activate_mood_or_playlist(char *arg, int *num_admissible)
        enum play_mode mode;
        int ret;
 
+       PARA_INFO_LOG("new playlist: %s\n", arg);
        if (!arg) {
                ret = change_current_mood(NULL); /* always successful */
                mode = PLAY_MODE_MOOD;
@@ -559,52 +556,70 @@ int afs_cb_result_handler(struct osl_object *result, uint8_t band,
        struct command_context *cc = private;
 
        assert(cc);
-       if (!result->size)
-               return 1;
-       return send_sb(&cc->scc, result->data, result->size, band, true);
+       switch (band) {
+       case SBD_OUTPUT:
+       case SBD_DEBUG_LOG:
+       case SBD_INFO_LOG:
+       case SBD_NOTICE_LOG:
+       case SBD_WARNING_LOG:
+       case SBD_ERROR_LOG:
+       case SBD_CRIT_LOG:
+       case SBD_EMERG_LOG:
+               assert(result->size > 0);
+               return send_sb(&cc->scc, result->data, result->size, band, true);
+       case SBD_AFS_CB_FAILURE:
+               return *(int *)(result->data);
+       default:
+               return -E_BAD_BAND;
+       }
 }
 
-static void com_select_callback(int fd, const struct osl_object *query)
+static void flush_and_free_pb(struct para_buffer *pb)
 {
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .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;
+       int ret;
+       struct afs_max_size_handler_data *amshd = pb->private_data;
+
+       if (pb->buf && pb->size > 0) {
+               ret = pass_buffer_as_shm(amshd->fd, amshd->band, pb->buf,
+                       pb->offset);
+               if (ret < 0)
+                       PARA_ERROR_LOG("%s\n", para_strerror(-ret));
+       }
+       free(pb->buf);
+}
+
+static int com_select_callback(struct afs_callback_arg *aca)
+{
+       char *arg = aca->query.data;
+       int num_admissible, ret;
 
        ret = clear_score_table();
        if (ret < 0) {
-               ret2 = para_printf(&pb, "%s\n", para_strerror(-ret));
-               goto out;
+               para_printf(&aca->pbout, "could not clear score table: %s\n",
+                       para_strerror(-ret));
+               return ret;
        }
        if (current_play_mode == PLAY_MODE_MOOD)
                close_current_mood();
        else
                playlist_close();
        ret = activate_mood_or_playlist(arg, &num_admissible);
-       if (ret < 0) {
-               ret2 = para_printf(&pb, "%s\nswitching back to %s\n",
-                       para_strerror(-ret), current_mop?
-                       current_mop : "dummy");
-               ret = activate_mood_or_playlist(current_mop, &num_admissible);
-               if (ret < 0) {
-                       if (ret2 >= 0)
-                               ret2 = para_printf(&pb, "failed, switching to dummy\n");
-                       activate_mood_or_playlist(NULL, &num_admissible);
-               }
-       } else
-               ret2 = para_printf(&pb, "activated %s (%d admissible files)\n",
-                       current_mop?  current_mop : "dummy mood",
-                       num_admissible);
+       if (ret >= 0)
+               goto out;
+       /* ignore subsequent errors (but log them) */
+       para_printf(&aca->pbout, "could not activate %s: %s\n"
+               "switching back to %s\n",
+               arg, para_strerror(-ret), current_mop? current_mop : "dummy");
+       ret = activate_mood_or_playlist(current_mop, &num_admissible);
+       if (ret >= 0)
+               goto out;
+       para_printf(&aca->pbout, "could not activate %s: %s\nswitching to dummy\n",
+               current_mop, para_strerror(-ret));
+       activate_mood_or_playlist(NULL, &num_admissible);
 out:
-       if (ret2 >= 0 && pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+       para_printf(&aca->pbout, "activated %s (%d admissible files)\n",
+               current_mop? current_mop : "dummy mood", num_admissible);
+       return ret;
 }
 
 int com_select(struct command_context *cc)
@@ -795,8 +810,8 @@ int pass_buffer_as_shm(int fd, uint8_t band, const char *buf, size_t size)
        void *shm;
        struct callback_result *cr;
 
-       if (!buf || !size)
-               return 0;
+       if (size == 0)
+               assert(band != SBD_OUTPUT);
        ret = shm_new(size + sizeof(*cr));
        if (ret < 0)
                return ret;
@@ -807,7 +822,8 @@ int pass_buffer_as_shm(int fd, uint8_t band, const char *buf, size_t size)
        cr = shm;
        cr->result_size = size;
        cr->band = band;
-       memcpy(shm + sizeof(*cr), buf, size);
+       if (size > 0)
+               memcpy(shm + sizeof(*cr), buf, size);
        ret = shm_detach(shm);
        if (ret < 0)
                goto err;
@@ -820,26 +836,43 @@ err:
        return ret;
 }
 
-/*
- * 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;
        struct callback_query *cq;
-       struct osl_object query;
-       int ret;
+       int ret, ret2;
+       struct afs_callback_arg aca = {.fd = fd};
 
        ret = shm_attach(query_shmid, ATTACH_RW, &query_shm);
        if (ret < 0)
                return ret;
        cq = query_shm;
-       query.data = (char *)query_shm + sizeof(*cq);
-       query.size = cq->query_size;
-       cq->handler(fd, &query);
-       return shm_detach(query_shm);
+       aca.query.data = (char *)query_shm + sizeof(*cq);
+       aca.query.size = cq->query_size;
+       aca.pbout.max_size = shm_get_shmmax();
+       aca.pbout.max_size_handler = afs_max_size_handler;
+       aca.pbout.private_data = &(struct afs_max_size_handler_data) {
+               .fd = fd,
+               .band = SBD_OUTPUT
+       };
+       ret = cq->handler(&aca);
+       ret2 = shm_detach(query_shm);
+       if (ret2 < 0) {
+               if (ret < 0) /* ignore (but log) detach error */
+                       PARA_ERROR_LOG("could not detach sma: %s\n",
+                               para_strerror(-ret2));
+               else
+                       ret = ret2;
+       }
+       flush_and_free_pb(&aca.pbout);
+       if (ret < 0) {
+               ret2 = pass_buffer_as_shm(fd, SBD_AFS_CB_FAILURE,
+                       (const char *)&ret, sizeof(ret));
+               if (ret2 < 0)
+                       PARA_ERROR_LOG("could not pass cb failure packet: %s\n",
+                               para_strerror(-ret));
+       }
+       return ret;
 }
 
 static int execute_server_command(fd_set *rfds)
@@ -998,17 +1031,10 @@ out:
        exit(EXIT_FAILURE);
 }
 
-static void create_tables_callback(int fd, const struct osl_object *query)
+static int com_init_callback(struct afs_callback_arg *aca)
 {
-       uint32_t table_mask = *(uint32_t *)query->data;
+       uint32_t table_mask = *(uint32_t *)aca->query.data;
        int i, ret;
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               }
-       };
 
        close_afs_tables();
        for (i = 0; i < NUM_AFS_TABLES; i++) {
@@ -1019,17 +1045,19 @@ static void create_tables_callback(int fd, const struct osl_object *query)
                if (!t->create)
                        continue;
                ret = t->create(database_dir);
-               if (ret < 0)
+               if (ret < 0) {
+                       para_printf(&aca->pbout, "cannot create table %s\n",
+                               t->name);
                        goto out;
-               para_printf(&pb, "successfully created %s table\n", t->name);
+               }
+               para_printf(&aca->pbout, "successfully created %s table\n",
+                       t->name);
        }
        ret = open_afs_tables();
-out:
        if (ret < 0)
-               para_printf(&pb, "%s\n", para_strerror(-ret));
-       if (pb.buf)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+               para_printf(&aca->pbout, "cannot open afs tables\n");
+out:
+       return ret;
 }
 
 int com_init(struct command_context *cc)
@@ -1057,9 +1085,8 @@ int com_init(struct command_context *cc)
                                return -E_BAD_TABLE_NAME;
                }
        }
-       ret = send_callback_request(create_tables_callback, &query,
+       return send_callback_request(com_init_callback, &query,
                afs_cb_result_handler, cc);
-       return ret;
 }
 
 /**
@@ -1073,7 +1100,9 @@ enum com_check_flags {
        /** Check the mood table. */
        CHECK_MOODS = 2,
        /** Check the playlist table. */
-       CHECK_PLAYLISTS = 4
+       CHECK_PLAYLISTS = 4,
+       /** Check the attribute table against the audio file table. */
+       CHECK_ATTS = 8
 };
 
 int com_check(struct command_context *cc)
@@ -1093,6 +1122,10 @@ int com_check(struct command_context *cc)
                        flags |= CHECK_AFT;
                        continue;
                }
+               if (!strcmp(arg, "-A")) {
+                       flags |= CHECK_ATTS;
+                       continue;
+               }
                if (!strcmp(arg, "-p")) {
                        flags |= CHECK_PLAYLISTS;
                        continue;
@@ -1113,6 +1146,12 @@ int com_check(struct command_context *cc)
                if (ret < 0)
                        return ret;
        }
+       if (flags & CHECK_ATTS) {
+               ret = send_callback_request(attribute_check_callback, NULL,
+                       afs_cb_result_handler, cc);
+               if (ret < 0)
+                       return ret;
+       }
        if (flags & CHECK_PLAYLISTS) {
                ret = send_callback_request(playlist_check_callback,
                        NULL, afs_cb_result_handler, cc);
@@ -1135,10 +1174,14 @@ int com_check(struct command_context *cc)
  * \param pb May be \p NULL.
  * \param data Type depends on \a event.
  *
- * This function calls the table handlers of all tables and passes \a pb and \a
- * data verbatim. It's up to the handlers to interpret the \a data pointer.
+ * This function calls each table event handler, passing \a pb and \a data
+ * verbatim. It's up to the handlers to interpret the \a data pointer. If a
+ * handler returns negative, the loop is aborted.
+ *
+ * \return The (negative) error code of the first handler that failed, or non-negative
+ * if all handlers succeeded.
  */
-void afs_event(enum afs_events event, struct para_buffer *pb,
+__must_check int afs_event(enum afs_events event, struct para_buffer *pb,
                void *data)
 {
        int i, ret;
@@ -1148,10 +1191,13 @@ void afs_event(enum afs_events event, struct para_buffer *pb,
                if (!t->event_handler)
                        continue;
                ret = t->event_handler(event, pb, data);
-               if (ret < 0)
+               if (ret < 0) {
                        PARA_CRIT_LOG("table %s, event %d: %s\n", t->name,
                                event, para_strerror(-ret));
+                       return ret;
+               }
        }
+       return 1;
 }
 
 /**
diff --git a/afs.cmd b/afs.cmd
index 07db3cc..584ba80 100644 (file)
--- a/afs.cmd
+++ b/afs.cmd
@@ -120,9 +120,9 @@ H: Rename attribute old to new.
 N: check
 P: AFS_READ
 D: Run integrity checks against osl tables.
-U: check [-a] [-m] [-p]
-H: Check the audio file table, the mood definitions and all
-H: defined playlists and report any inconsistencies found.
+U: check [-a] [-A] [-m] [-p]
+H: Check the audio file table, the attribute table, the mood definitions
+H: and all defined playlists. Report any inconsistencies.
 H:
 H: Options:
 H:
@@ -131,12 +131,17 @@ H:        table which are not present in the file system. Moreover, it checks
 H:     whether the lyrics id and all entries in the audio file table are
 H:     valid.
 H:
+H: -A  Check the attribute table against the afs attribute bitmask of
+H:     each audio file in the audio file table. Reports audio files
+H:     whose attribute bitmask is invalid, i.e., has a bit set which
+H:     does not correspond to any attribute of the attribute table.
+H:
 H: -m  Run syntax checks on all defined moods in the mood table.
 H:
 H: -p  Check all playlists for lines that correspond to files not contained
 H:     in the audio file table.
 H:
-H: If called without arguments, all three checks are run.
+H: If called without arguments, all checks are run.
 ---
 N: rmatt
 P: AFS_READ | AFS_WRITE
diff --git a/afs.h b/afs.h
index cccb143..e77cdf0 100644 (file)
--- a/afs.h
+++ b/afs.h
@@ -157,6 +157,15 @@ struct pattern_match_data {
        int (*action)(struct osl_table *table, struct osl_row *row, const char *name, void *data);
 };
 
+/** Arguments passed to each afs callback. */
+struct afs_callback_arg {
+       /** The local socket connecting afs and the command handler. */
+       int fd;
+       /** Callback-specific data. */
+       struct osl_object query;
+       /** Will be written on band SBD_OUTPUT, fully buffered. */
+       struct para_buffer pbout;
+};
 
 /**
  * Afs command handlers run as a process which is not related to the afs
@@ -166,7 +175,7 @@ struct pattern_match_data {
  *
  * \sa send_callback_request().
  */
-typedef void callback_function(int fd, const struct osl_object *);
+typedef int afs_callback(struct afs_callback_arg *aca);
 
 /**
  * Callbacks send chunks to data back to the command handler. Pointers to
@@ -209,17 +218,17 @@ _static_inline_ int afs_max_size_handler(char *buf, size_t size, void *private)
 }
 
 __noreturn void afs_init(uint32_t cookie, int socket_fd);
-void afs_event(enum afs_events event, struct para_buffer *pb,
+__must_check int afs_event(enum afs_events event, struct para_buffer *pb,
        void *data);
-int send_callback_request(callback_function *f, struct osl_object *query,
+int send_callback_request(afs_callback *f, struct osl_object *query,
                callback_result_handler *result_handler,
                void *private_result_data);
 int send_option_arg_callback_request(struct osl_object *options,
-               int argc,  char * const * const argv, callback_function *f,
+               int argc,  char * const * const argv, afs_callback *f,
                callback_result_handler *result_handler,
                void *private_result_data);
 int send_standard_callback_request(int argc,  char * const * const argv,
-               callback_function *f, callback_result_handler *result_handler,
+               afs_callback *f, callback_result_handler *result_handler,
                void *private_result_data);
 int string_compare(const struct osl_object *obj1, const struct osl_object *obj2);
 int for_each_matching_row(struct pattern_match_data *pmd);
@@ -241,22 +250,24 @@ void attribute_init(struct afs_table *t);
 void get_attribute_bitmap(const uint64_t *atts, char *buf); /* needed by com_ls() */
 int get_attribute_bitnum_by_name(const char *att_name, unsigned char *bitnum);
 int get_attribute_text(uint64_t *atts, const char *delim, char **text);
+int attribute_check_callback(struct afs_callback_arg *aca);
 
 /* aft */
 void aft_init(struct afs_table *t);
 int aft_get_row_of_path(const char *path, struct osl_row **row);
+int aft_check_attributes(uint64_t att_mask, struct para_buffer *pb);
 int open_and_update_audio_file(struct audio_file_data *afd);
 int load_afd(int shmid, struct audio_file_data *afd);
 int get_afsi_of_row(const struct osl_row *row, struct afs_info *afsi);
 int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi);
 int get_audio_file_path_of_row(const struct osl_row *row, char **path);
 int audio_file_loop(void *private_data, osl_rbtree_loop_func *func);
-void aft_check_callback(int fd, __a_unused const struct osl_object *query);
+int aft_check_callback(struct afs_callback_arg *aca);
 
 /* playlist */
 int playlist_open(char *name);
 void playlist_close(void);
-void playlist_check_callback(int fd, __a_unused const struct osl_object *query);
+int playlist_check_callback(struct afs_callback_arg *aca);
 
 /** evaluates to 1 if x < y, to -1 if x > y and to 0 if x == y */
 #define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y)))
diff --git a/aft.c b/aft.c
index f2c1eda..8a8e528 100644 (file)
--- a/aft.c
+++ b/aft.c
@@ -741,62 +741,50 @@ static int write_attribute_items(struct para_buffer *b,
        char *att_text;
        int ret;
 
-       ret = WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_BITMAP, "%s\n", att_bitmap);
-       if (ret < 0)
-               return ret;
+       WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_BITMAP, "%s\n", att_bitmap);
        ret = get_attribute_text(&afsi->attributes, " ", &att_text);
        if (ret < 0)
                return ret;
-       ret = WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_TXT, "%s\n", att_text);
+       WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_TXT, "%s\n", att_text);
        free(att_text);
        return ret;
 }
 
-static int write_lyrics_items(struct para_buffer *b, struct afs_info *afsi)
+static void write_lyrics_items(struct para_buffer *b, struct afs_info *afsi)
 {
        char *lyrics_name;
-       int ret;
 
-       ret = WRITE_STATUS_ITEM(b, SI_LYRICS_ID, "%u\n", afsi->lyrics_id);
-       if (ret < 0)
-               return ret;
+       WRITE_STATUS_ITEM(b, SI_LYRICS_ID, "%u\n", afsi->lyrics_id);
        lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name);
-       return WRITE_STATUS_ITEM(b, SI_LYRICS_NAME, "%s\n", lyrics_name?
+       WRITE_STATUS_ITEM(b, SI_LYRICS_NAME, "%s\n", lyrics_name?
                lyrics_name : "(none)");
 }
 
-static int write_image_items(struct para_buffer *b, struct afs_info *afsi)
+static void write_image_items(struct para_buffer *b, struct afs_info *afsi)
 {
        char *image_name;
-       int ret;
 
-       ret = WRITE_STATUS_ITEM(b, SI_IMAGE_ID, "%u\n", afsi->image_id);
-       if (ret < 0)
-               return ret;
+       WRITE_STATUS_ITEM(b, SI_IMAGE_ID, "%u\n", afsi->image_id);
        img_get_name_by_id(afsi->image_id, &image_name);
-       return WRITE_STATUS_ITEM(b, SI_IMAGE_NAME, "%s\n", image_name?
+       WRITE_STATUS_ITEM(b, SI_IMAGE_NAME, "%s\n", image_name?
                image_name : "(none)");
 }
 
-static int write_filename_items(struct para_buffer *b, const char *path,
+static void write_filename_items(struct para_buffer *b, const char *path,
                unsigned flags)
 {
        char *val;
-       int ret;
 
-       if (!(flags & LS_FLAG_FULL_PATH))
-               return WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", path);
-       ret = WRITE_STATUS_ITEM(b, SI_PATH, "%s\n", path);
-       if (ret < 0)
-               return ret;
+       if (!(flags & LS_FLAG_FULL_PATH)) {
+               WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", path);
+               return;
+       }
+       WRITE_STATUS_ITEM(b, SI_PATH, "%s\n", path);
        val = para_basename(path);
-       ret = WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", val? val : "");
-       if (ret < 0)
-               return ret;
+       WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", val? val : "");
        val = para_dirname(path);
-       ret = WRITE_STATUS_ITEM(b, SI_DIRECTORY, "%s\n", val? val : "");
+       WRITE_STATUS_ITEM(b, SI_DIRECTORY, "%s\n", val? val : "");
        free(val);
-       return ret;
 }
 
 static int print_chunk_table(struct ls_data *d, struct para_buffer *b)
@@ -813,32 +801,27 @@ static int print_chunk_table(struct ls_data *d, struct para_buffer *b)
                AFTCOL_CHUNKS, &chunk_table_obj));
        if (ret < 0)
                return ret;
-       ret = para_printf(b, "%s\n"
+       para_printf(b, "%s\n"
                "chunk_time: %lu:%lu\nchunk_offsets: ",
                d->path,
                (long unsigned) d->afhi.chunk_tv.tv_sec,
                (long unsigned) d->afhi.chunk_tv.tv_usec
        );
-       if (ret < 0)
-               goto out;
        buf = chunk_table_obj.data;
-       for (i = 0; i <= d->afhi.chunks_total; i++) {
-               ret = para_printf(b, "%u ", (unsigned) read_u32(buf + 4 * i));
-               if (ret < 0)
-                       goto out;
-       }
-       ret = para_printf(b, "\n");
-out:
+       for (i = 0; i <= d->afhi.chunks_total; i++)
+               para_printf(b, "%u ", (unsigned) read_u32(buf + 4 * i));
+       para_printf(b, "\n");
+       ret = 1;
        osl_close_disk_object(&chunk_table_obj);
        return ret;
 }
 
-static int write_score(struct para_buffer *b, struct ls_data *d,
+static void write_score(struct para_buffer *b, struct ls_data *d,
                struct ls_options *opts)
 {
        if (!(opts->flags & LS_FLAG_ADMISSIBLE_ONLY)) /* no score*/
-               return 0;
-       return WRITE_STATUS_ITEM(b, SI_SCORE, "%li\n", d->score);
+               return;
+       WRITE_STATUS_ITEM(b, SI_SCORE, "%li\n", d->score);
 }
 
 static int print_list_item(struct ls_data *d, struct ls_options *opts,
@@ -853,7 +836,8 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
        char asc_hash[2 * HASH_SIZE + 1];
 
        if (opts->mode == LS_MODE_SHORT) {
-               ret = para_printf(b, "%s\n", d->path);
+               para_printf(b, "%s\n", d->path);
+               ret = 1;
                goto out;
        }
        if (opts->mode == LS_MODE_CHUNKS) {
@@ -874,12 +858,10 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
        if (opts->mode == LS_MODE_LONG) {
                struct ls_widths *w = &opts->widths;
                if (opts->flags & LS_FLAG_ADMISSIBLE_ONLY) {
-                       ret = para_printf(b, "%*li ",
-                               opts->widths.score_width, d->score);
-                       if (ret < 0)
-                               goto out;
+                       para_printf(b, "%*li ", opts->widths.score_width,
+                               d->score);
                }
-               ret = para_printf(b,
+               para_printf(b,
                        "%s "   /* attributes */
                        "%*u "  /* amp */
                        "%*d "  /* image_id  */
@@ -906,98 +888,50 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts,
                        last_played_time,
                        d->path
                );
+               ret = 1;
                goto out;
        }
        if (opts->mode == LS_MODE_MBOX) {
                const char *bn = para_basename(d->path);
-               ret = para_printf(b,
+               para_printf(b,
                        "From foo@localhost %s\n"
                        "Received: from\nTo: bar\nFrom: a\n"
                        "Subject: %s\n\n",
                        last_played_time,
                        bn? bn : "?");
-               if (ret < 0)
-                       goto out;
        }
-       ret = write_filename_items(b, d->path, opts->flags);
-       if (ret < 0)
-               goto out;
-       ret = write_score(b, d, opts);
-       if (ret < 0)
-               goto out;
+       write_filename_items(b, d->path, opts->flags);
+       write_score(b, d, opts);
        ret = write_attribute_items(b, att_buf, afsi);
        if (ret < 0)
                goto out;
-       ret = write_image_items(b, afsi);
-       if (ret < 0)
-               goto out;
-       ret = write_lyrics_items(b, afsi);
-       if (ret < 0)
-               goto out;
+       write_image_items(b, afsi);
+       write_lyrics_items(b, afsi);
        hash_to_asc(d->hash, asc_hash);
-       ret = WRITE_STATUS_ITEM(b, SI_HASH, "%s\n", asc_hash);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_BITRATE, "%dkbit/s\n", afhi->bitrate);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_FORMAT, "%s\n",
+       WRITE_STATUS_ITEM(b, SI_HASH, "%s\n", asc_hash);
+       WRITE_STATUS_ITEM(b, SI_BITRATE, "%dkbit/s\n", afhi->bitrate);
+       WRITE_STATUS_ITEM(b, SI_FORMAT, "%s\n",
                audio_format_name(afsi->audio_format_id));
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_FREQUENCY, "%dHz\n", afhi->frequency);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_CHANNELS, "%d\n", afhi->channels);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_DURATION, "%s\n", duration_buf);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_SECONDS_TOTAL, "%lu\n",
-               afhi->seconds_total);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_LAST_PLAYED, "%s\n", last_played_time);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_NUM_PLAYED, "%d\n", afsi->num_played);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_AMPLIFICATION, "%u\n", afsi->amp);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_CHUNK_TIME, "%lu\n",
-               tv2ms(&afhi->chunk_tv));
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_NUM_CHUNKS, "%lu\n",
-               afhi->chunks_total);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_TECHINFO, "%s\n", afhi->techinfo);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_ARTIST, "%s\n", afhi->tags.artist);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_TITLE, "%s\n", afhi->tags.title);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_YEAR, "%s\n", afhi->tags.year);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_ALBUM, "%s\n", afhi->tags.album);
-       if (ret < 0)
-               goto out;
-       ret = WRITE_STATUS_ITEM(b, SI_COMMENT, "%s\n", afhi->tags.comment);
-       if (ret < 0)
-               goto out;
+       WRITE_STATUS_ITEM(b, SI_FREQUENCY, "%dHz\n", afhi->frequency);
+       WRITE_STATUS_ITEM(b, SI_CHANNELS, "%d\n", afhi->channels);
+       WRITE_STATUS_ITEM(b, SI_DURATION, "%s\n", duration_buf);
+       WRITE_STATUS_ITEM(b, SI_SECONDS_TOTAL, "%lu\n", afhi->seconds_total);
+       WRITE_STATUS_ITEM(b, SI_LAST_PLAYED, "%s\n", last_played_time);
+       WRITE_STATUS_ITEM(b, SI_NUM_PLAYED, "%d\n", afsi->num_played);
+       WRITE_STATUS_ITEM(b, SI_AMPLIFICATION, "%u\n", afsi->amp);
+       WRITE_STATUS_ITEM(b, SI_CHUNK_TIME, "%lu\n", tv2ms(&afhi->chunk_tv));
+       WRITE_STATUS_ITEM(b, SI_NUM_CHUNKS, "%lu\n", afhi->chunks_total);
+       WRITE_STATUS_ITEM(b, SI_TECHINFO, "%s\n", afhi->techinfo);
+       WRITE_STATUS_ITEM(b, SI_ARTIST, "%s\n", afhi->tags.artist);
+       WRITE_STATUS_ITEM(b, SI_TITLE, "%s\n", afhi->tags.title);
+       WRITE_STATUS_ITEM(b, SI_YEAR, "%s\n", afhi->tags.year);
+       WRITE_STATUS_ITEM(b, SI_ALBUM, "%s\n", afhi->tags.album);
+       WRITE_STATUS_ITEM(b, SI_COMMENT, "%s\n", afhi->tags.comment);
        if (opts->mode == LS_MODE_MBOX) {
                struct osl_object lyrics_def;
                lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def);
                if (lyrics_def.data) {
-                       ret = para_printf(b, "Lyrics:\n~~~~~~~\n%s",
+                       para_printf(b, "Lyrics:\n~~~~~~~\n%s",
                                (char *)lyrics_def.data);
                        osl_close_disk_object(&lyrics_def);
                }
@@ -1026,9 +960,8 @@ static void make_inode_status_items(struct para_buffer *pb)
        ret = strftime(mtime_str, 29, "%b %d %Y", &mtime_tm);
        assert(ret > 0); /* number of bytes placed in mtime_str */
 out:
-       /* We don't care too much about errors here */
-       (void)WRITE_STATUS_ITEM(pb, SI_MTIME, "%s\n", mtime_str);
-       (void)WRITE_STATUS_ITEM(pb, SI_FILE_SIZE, "%ld\n", statbuf.st_size / 1024);
+       WRITE_STATUS_ITEM(pb, SI_MTIME, "%s\n", mtime_str);
+       WRITE_STATUS_ITEM(pb, SI_FILE_SIZE, "%ld\n", statbuf.st_size / 1024);
 }
 
 static int make_status_items(void)
@@ -1132,7 +1065,9 @@ again:
         * No need to update the status items as the AFSI_CHANGE event will
         * recreate them.
         */
-       afs_event(AFSI_CHANGE, NULL, &aced);
+       ret = afs_event(AFSI_CHANGE, NULL, &aced);
+       if (ret < 0)
+               goto out;
        ret = save_afd(afd);
 out:
        free(afd->afhi.chunk_table);
@@ -1351,22 +1286,14 @@ err:
        return ret;
 }
 
-static void com_ls_callback(int fd, const struct osl_object *query)
+static int com_ls_callback(struct afs_callback_arg *aca)
 {
-       struct ls_options *opts = query->data;
-       char *p, *pattern_start = (char *)query->data + sizeof(*opts);
-       struct para_buffer b = {
-               .max_size = shm_get_shmmax(),
-               .flags = (opts->mode == LS_MODE_PARSER)? PBF_SIZE_PREFIX : 0,
-               .max_size_handler = afs_max_size_handler,
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               }
-       };
+       struct ls_options *opts = aca->query.data;
+       char *p, *pattern_start = (char *)aca->query.data + sizeof(*opts);
        int i = 0, ret;
        time_t current_time;
 
+       aca->pbout.flags = (opts->mode == LS_MODE_PARSER)? PBF_SIZE_PREFIX : 0;
        if (opts->num_patterns) {
                opts->patterns = para_malloc(opts->num_patterns * sizeof(char *));
                for (i = 0, p = pattern_start; i < opts->num_patterns; i++) {
@@ -1383,8 +1310,7 @@ static void com_ls_callback(int fd, const struct osl_object *query)
        if (ret < 0)
                goto out;
        if (opts->num_matching_paths == 0) {
-               if (opts->num_patterns > 0)
-                       para_printf(&b, "no matches\n");
+               ret = opts->num_patterns > 0? -E_NO_MATCH : 0;
                goto out;
        }
        ret = sort_matching_paths(opts);
@@ -1393,23 +1319,23 @@ static void com_ls_callback(int fd, const struct osl_object *query)
        time(&current_time);
        if (opts->flags & LS_FLAG_REVERSE)
                for (i = opts->num_matching_paths - 1; i >= 0; i--) {
-                       ret = print_list_item(opts->data_ptr[i], opts, &b, current_time);
+                       ret = print_list_item(opts->data_ptr[i], opts,
+                               &aca->pbout, current_time);
                        if (ret < 0)
                                goto out;
                }
        else
                for (i = 0; i < opts->num_matching_paths; i++) {
-                       ret = print_list_item(opts->data_ptr[i], opts, &b, current_time);
+                       ret = print_list_item(opts->data_ptr[i], opts,
+                               &aca->pbout, current_time);
                        if (ret < 0)
                                goto out;
                }
 out:
-       if (b.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, b.buf, b.offset);
-       free(b.buf);
        free(opts->data);
        free(opts->data_ptr);
        free(opts->patterns);
+       return ret;
 }
 
 /*
@@ -1417,7 +1343,7 @@ out:
  */
 int com_ls(struct command_context *cc)
 {
-       int i, ret;
+       int i;
        unsigned flags = 0;
        enum ls_sorting_method sort = LS_SORT_BY_PATH;
        enum ls_listing_mode mode = LS_MODE_SHORT;
@@ -1536,9 +1462,8 @@ int com_ls(struct command_context *cc)
        opts.sorting = sort;
        opts.mode = mode;
        opts.num_patterns = cc->argc - i;
-       ret = send_option_arg_callback_request(&query, opts.num_patterns,
+       return send_option_arg_callback_request(&query, opts.num_patterns,
                cc->argv + i, com_ls_callback, afs_cb_result_handler, cc);
-       return ret;
 }
 
 /**
@@ -1555,13 +1480,22 @@ int audio_file_loop(void *private_data, osl_rbtree_loop_func *func)
                func));
 }
 
-static struct osl_row *find_hash_sister(unsigned char *hash)
+static int find_hash_sister(unsigned char *hash, struct osl_row **result)
 {
-       const struct osl_object obj = {.data = hash, .size = HASH_SIZE};
-       struct osl_row *row;
+       int ret = aft_get_row_of_hash(hash, result);
+
+       if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
+               return 0;
+       return ret;
+}
+
+static int find_path_brother(const char *path, struct osl_row **result)
+{
+       int ret = aft_get_row_of_path(path, result);
 
-       osl_get_row(audio_file_table, AFTCOL_HASH, &obj, &row);
-       return row;
+       if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
+               return 0;
+       return ret;
 }
 
 /** The format of the data stored by save_audio_file_data(). */
@@ -1680,9 +1614,9 @@ enum com_add_flags {
        ADD_FLAG_ALL = 8,
 };
 
-static void com_add_callback(int fd, const struct osl_object *query)
+static int com_add_callback(struct afs_callback_arg *aca)
 {
-       char *buf = query->data, *path;
+       char *buf = aca->query.data, *path;
        struct osl_row *pb, *aft_row;
        struct osl_row *hs;
        struct osl_object objs[NUM_AFT_COLUMNS];
@@ -1692,14 +1626,6 @@ static void com_add_callback(int fd, const struct osl_object *query)
        char afsi_buf[AFSI_SIZE];
        uint32_t flags = read_u32(buf + CAB_FLAGS_OFFSET);
        struct afs_info default_afsi = {.last_played = 0};
-       struct para_buffer msg = {
-               .max_size = shm_get_shmmax(),
-               .max_size_handler = afs_max_size_handler,
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               }
-       };
        uint16_t afhi_offset, chunks_offset;
 
        hash = (unsigned char *)buf + CAB_HASH_OFFSET;
@@ -1712,26 +1638,26 @@ static void com_add_callback(int fd, const struct osl_object *query)
        objs[AFTCOL_PATH].size = strlen(path) + 1;
 
        PARA_INFO_LOG("request to add %s\n", path);
-       hs = find_hash_sister(hash);
-       ret = aft_get_row_of_path(path, &pb);
-       if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND))
+       ret = find_hash_sister(hash, &hs);
+       if (ret < 0)
+               goto out;
+       ret = find_path_brother(path, &pb);
+       if (ret < 0)
                goto out;
        if (hs && pb && hs == pb && !(flags & ADD_FLAG_FORCE)) {
                if (flags & ADD_FLAG_VERBOSE)
-                       ret = para_printf(&msg, "ignoring duplicate\n");
-               else
-                       ret = 1;
+                       para_printf(&aca->pbout, "ignoring duplicate\n");
+               ret = 1;
                goto out;
        }
        if (hs && hs != pb) {
                struct osl_object obj;
                if (pb) { /* hs trumps pb, remove pb */
-                       if (flags & ADD_FLAG_VERBOSE) {
-                               ret = para_printf(&msg, "removing %s\n", path);
-                               if (ret < 0)
-                                       goto out;
-                       }
-                       afs_event(AUDIO_FILE_REMOVE, &msg, pb);
+                       if (flags & ADD_FLAG_VERBOSE)
+                               para_printf(&aca->pbout, "removing %s\n", path);
+                       ret = afs_event(AUDIO_FILE_REMOVE, &aca->pbout, pb);
+                       if (ret < 0)
+                               goto out;
                        ret = osl(osl_del_row(audio_file_table, pb));
                        if (ret < 0)
                                goto out;
@@ -1743,15 +1669,16 @@ static void com_add_callback(int fd, const struct osl_object *query)
                                AFTCOL_PATH, &obj));
                        if (ret < 0)
                                goto out;
-                       ret = para_printf(&msg, "renamed from %s\n", (char *)obj.data);
-                       if (ret < 0)
-                               goto out;
+                       para_printf(&aca->pbout, "renamed from %s\n",
+                               (char *)obj.data);
                }
                ret = osl(osl_update_object(audio_file_table, hs, AFTCOL_PATH,
                        &objs[AFTCOL_PATH]));
                if (ret < 0)
                        goto out;
-               afs_event(AUDIO_FILE_RENAME, &msg, hs);
+               ret = afs_event(AUDIO_FILE_RENAME, &aca->pbout, hs);
+               if (ret < 0)
+                       goto out;
                if (!(flags & ADD_FLAG_FORCE))
                        goto out;
        }
@@ -1765,7 +1692,7 @@ static void com_add_callback(int fd, const struct osl_object *query)
        if (!objs[AFTCOL_AFHI].size) /* "impossible" */
                goto out;
        objs[AFTCOL_CHUNKS].data = buf + chunks_offset;
-       objs[AFTCOL_CHUNKS].size = query->size - chunks_offset;
+       objs[AFTCOL_CHUNKS].size = aca->query.size - chunks_offset;
        if (pb && !hs) { /* update pb's hash */
                char old_asc[2 * HASH_SIZE + 1];
                unsigned char *old_hash;
@@ -1773,12 +1700,9 @@ static void com_add_callback(int fd, const struct osl_object *query)
                if (ret < 0)
                        goto out;
                hash_to_asc(old_hash, old_asc);
-               if (flags & ADD_FLAG_VERBOSE) {
-                       ret = para_printf(&msg, "file change: %s -> %s\n",
+               if (flags & ADD_FLAG_VERBOSE)
+                       para_printf(&aca->pbout, "file change: %s -> %s\n",
                                old_asc, asc);
-                       if (ret < 0)
-                               goto out;
-               }
                ret = osl_update_object(audio_file_table, pb, AFTCOL_HASH,
                        &objs[AFTCOL_HASH]);
                if (ret < 0)
@@ -1787,11 +1711,9 @@ static void com_add_callback(int fd, const struct osl_object *query)
        if (hs || pb) { /* (hs != NULL and pb != NULL) implies hs == pb */
                struct osl_row *row = pb? pb : hs;
                /* update afhi and chunk_table */
-               if (flags & ADD_FLAG_VERBOSE) {
-                       ret = para_printf(&msg, "updating afhi and chunk table\n");
-                       if (ret < 0)
-                               goto out;
-               }
+               if (flags & ADD_FLAG_VERBOSE)
+                       para_printf(&aca->pbout,
+                               "updating afhi and chunk table\n");
                ret = osl(osl_update_object(audio_file_table, row, AFTCOL_AFHI,
                        &objs[AFTCOL_AFHI]));
                if (ret < 0)
@@ -1800,15 +1722,14 @@ static void com_add_callback(int fd, const struct osl_object *query)
                        &objs[AFTCOL_CHUNKS]));
                if (ret < 0)
                        goto out;
-               afs_event(AFHI_CHANGE, &msg, row);
-               goto out;
-       }
-       /* new entry, use default afsi */
-       if (flags & ADD_FLAG_VERBOSE) {
-               ret = para_printf(&msg, "new file\n");
+               ret = afs_event(AFHI_CHANGE, &aca->pbout, row);
                if (ret < 0)
                        goto out;
+               goto out;
        }
+       /* new entry, use default afsi */
+       if (flags & ADD_FLAG_VERBOSE)
+               para_printf(&aca->pbout, "new file\n");
        default_afsi.last_played = time(NULL) - 365 * 24 * 60 * 60;
        default_afsi.audio_format_id = read_u8(buf + CAB_AUDIO_FORMAT_ID_OFFSET);
 
@@ -1816,13 +1737,11 @@ static void com_add_callback(int fd, const struct osl_object *query)
        objs[AFTCOL_AFSI].size = AFSI_SIZE;
        save_afsi(&default_afsi, &objs[AFTCOL_AFSI]);
        ret = osl(osl_add_and_get_row(audio_file_table, objs, &aft_row));
-       afs_event(AUDIO_FILE_ADD, &msg, aft_row);
+       ret = afs_event(AUDIO_FILE_ADD, &aca->pbout, aft_row);
 out:
        if (ret < 0)
-               para_printf(&msg, "%s\n", para_strerror(-ret));
-       if (msg.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, msg.buf, msg.offset);
-       free(msg.buf);
+               para_printf(&aca->pbout, "could not add %s\n", path);
+       return ret;
 }
 
 /** Used by com_add(). */
@@ -1833,26 +1752,26 @@ struct private_add_data {
        uint32_t flags;
 };
 
-static void path_brother_callback(int fd, const struct osl_object *query)
+static int path_brother_callback(struct afs_callback_arg *aca)
 {
-       char *path = query->data;
+       char *path = aca->query.data;
        struct osl_row *path_brother;
-       int ret = aft_get_row_of_path(path, &path_brother);
-       if (ret < 0)
-               return;
-       pass_buffer_as_shm(fd, SBD_OUTPUT, (char *)&path_brother,
+       int ret = find_path_brother(path, &path_brother);
+       if (ret <= 0)
+               return ret;
+       return pass_buffer_as_shm(aca->fd, SBD_OUTPUT, (char *)&path_brother,
                sizeof(path_brother));
 }
 
-static void hash_sister_callback(int fd, const struct osl_object *query)
+static int hash_sister_callback(struct afs_callback_arg *aca)
 {
-       unsigned char *hash = query->data;
+       unsigned char *hash = aca->query.data;
        struct osl_row *hash_sister;
+       int ret = find_hash_sister(hash, &hash_sister);
 
-       hash_sister = find_hash_sister(hash);
-       if (!hash_sister)
-               return;
-       pass_buffer_as_shm(fd, SBD_OUTPUT, (char *)&hash_sister,
+       if (ret <= 0)
+               return ret;
+       return pass_buffer_as_shm(aca->fd, SBD_OUTPUT, (char *)&hash_sister,
                sizeof(hash_sister));
 }
 
@@ -1860,7 +1779,9 @@ static int get_row_pointer_from_result(struct osl_object *result,
                __a_unused uint8_t band, void *private)
 {
        struct osl_row **row = private;
-       *row = *(struct osl_row **)(result->data);
+
+       if (band == SBD_OUTPUT)
+               *row = *(struct osl_row **)(result->data);
        return 1;
 }
 
@@ -2037,97 +1958,78 @@ struct com_touch_options {
        unsigned flags;
 };
 
-/** Data passed to the action handler of com_touch(). */
-struct touch_action_data {
-       /** Command line options (see \ref com_touch_options). */
-       struct com_touch_options *cto;
-       /** Message buffer. */
-       struct para_buffer pb;
-};
-
 static int touch_audio_file(__a_unused struct osl_table *table,
                struct osl_row *row, const char *name, void *data)
 {
-       struct touch_action_data *tad = data;
+       struct afs_callback_arg *aca = data;
+       struct com_touch_options *cto = aca->query.data;
        struct osl_object obj;
        struct afs_info old_afsi, new_afsi;
-       int ret, no_options = tad->cto->num_played < 0 && tad->cto->last_played < 0 &&
-               tad->cto->lyrics_id < 0 && tad->cto->image_id < 0 && tad->cto->amp < 0;
+       int ret, no_options = cto->num_played < 0 && cto->last_played < 0 &&
+               cto->lyrics_id < 0 && cto->image_id < 0 && cto->amp < 0;
        struct afsi_change_event_data aced;
 
        ret = get_afsi_object_of_row(row, &obj);
-       if (ret < 0)
-               return para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret));
+       if (ret < 0) {
+               para_printf(&aca->pbout, "cannot touch %s\n", name);
+               return ret;
+       }
        ret = load_afsi(&old_afsi, &obj);
-       if (ret < 0)
-               return para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret));
+       if (ret < 0) {
+               para_printf(&aca->pbout, "cannot touch %s\n", name);
+               return ret;
+       }
        new_afsi = old_afsi;
        if (no_options) {
                new_afsi.num_played++;
                new_afsi.last_played = time(NULL);
-               if (tad->cto->flags & TOUCH_FLAG_VERBOSE) {
-                       ret = para_printf(&tad->pb, "%s: num_played = %u, "
+               if (cto->flags & TOUCH_FLAG_VERBOSE)
+                       para_printf(&aca->pbout, "%s: num_played = %u, "
                                "last_played = now()\n", name,
                                new_afsi.num_played);
-                       if (ret < 0)
-                               return ret;
-               }
        } else {
-               if (tad->cto->flags & TOUCH_FLAG_VERBOSE) {
-                       ret = para_printf(&tad->pb, "touching %s\n", name);
-                       if (ret < 0)
-                               return ret;
-               }
-               if (tad->cto->lyrics_id >= 0)
-                       new_afsi.lyrics_id = tad->cto->lyrics_id;
-               if (tad->cto->image_id >= 0)
-                       new_afsi.image_id = tad->cto->image_id;
-               if (tad->cto->num_played >= 0)
-                       new_afsi.num_played = tad->cto->num_played;
-               if (tad->cto->last_played >= 0)
-                       new_afsi.last_played = tad->cto->last_played;
-               if (tad->cto->amp >= 0)
-                       new_afsi.amp = tad->cto->amp;
+               if (cto->flags & TOUCH_FLAG_VERBOSE)
+                       para_printf(&aca->pbout, "touching %s\n", name);
+               if (cto->lyrics_id >= 0)
+                       new_afsi.lyrics_id = cto->lyrics_id;
+               if (cto->image_id >= 0)
+                       new_afsi.image_id = cto->image_id;
+               if (cto->num_played >= 0)
+                       new_afsi.num_played = cto->num_played;
+               if (cto->last_played >= 0)
+                       new_afsi.last_played = cto->last_played;
+               if (cto->amp >= 0)
+                       new_afsi.amp = cto->amp;
        }
        save_afsi(&new_afsi, &obj); /* in-place update */
        aced.aft_row = row;
        aced.old_afsi = &old_afsi;
-       afs_event(AFSI_CHANGE, &tad->pb, &aced);
-       return 1;
+       return afs_event(AFSI_CHANGE, &aca->pbout, &aced);
 }
 
-static void com_touch_callback(int fd, const struct osl_object *query)
+static int com_touch_callback(struct afs_callback_arg *aca)
 {
-       struct touch_action_data tad = {.cto = query->data,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler
-               }
-       };
-       int ret, ret2 = 0;
+       int ret;
+       struct com_touch_options *cto = aca->query.data;
        struct pattern_match_data pmd = {
                .table = audio_file_table,
                .loop_col_num = AFTCOL_HASH,
                .match_col_num = AFTCOL_PATH,
-               .patterns = {.data = (char *)query->data + sizeof(*tad.cto),
-                       .size = query->size - sizeof(*tad.cto)},
-               .data = &tad,
+               .patterns = {
+                       .data = (char *)aca->query.data
+                               + sizeof(struct com_touch_options),
+                       .size = aca->query.size
+                               - sizeof(struct com_touch_options)
+               },
+               .data = aca,
                .action = touch_audio_file
        };
-       if (tad.cto->flags & TOUCH_FLAG_FNM_PATHNAME)
+       if (cto->flags & TOUCH_FLAG_FNM_PATHNAME)
                pmd.fnmatch_flags |= FNM_PATHNAME;
        ret = for_each_matching_row(&pmd);
-       if (ret < 0)
-               ret2 = para_printf(&tad.pb, "%s\n", para_strerror(-ret));
-       else if (pmd.num_matches == 0)
-               ret2 = para_printf(&tad.pb, "no matches\n");
-       if (ret2 >= 0 && tad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, tad.pb.buf, tad.pb.offset);
-       free(tad.pb.buf);
+       if (ret >= 0 && pmd.num_matches == 0)
+               ret = -E_NO_MATCH;
+       return ret;
 }
 
 int com_touch(struct command_context *cc)
@@ -2197,11 +2099,8 @@ int com_touch(struct command_context *cc)
        }
        if (i >= cc->argc)
                return -E_AFT_SYNTAX;
-       ret = send_option_arg_callback_request(&query, cc->argc - i,
+       return send_option_arg_callback_request(&query, cc->argc - i,
                cc->argv + i, com_touch_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
 /** Flags for com_rm(). */
@@ -2214,70 +2113,50 @@ enum rm_flags {
        RM_FLAG_FNM_PATHNAME = 4
 };
 
-/** Data passed to the action handler of com_rm(). */
-struct com_rm_action_data {
-       /** Command line flags ((see \ref rm_flags). */
-       uint32_t flags;
-       /** Message buffer. */
-       struct para_buffer pb;
-};
-
 static int remove_audio_file(__a_unused struct osl_table *table,
                struct osl_row *row, const char *name, void *data)
 {
-       struct com_rm_action_data *crd = data;
+       struct afs_callback_arg *aca = data;
+       uint32_t flags =*(uint32_t *)aca->query.data;
        int ret;
 
-       if (crd->flags & RM_FLAG_VERBOSE) {
-               ret = para_printf(&crd->pb, "removing %s\n", name);
-               if (ret < 0)
-                       return ret;
-       }
-       afs_event(AUDIO_FILE_REMOVE, &crd->pb, row);
+       if (flags & RM_FLAG_VERBOSE)
+               para_printf(&aca->pbout, "removing %s\n", name);
+       ret = afs_event(AUDIO_FILE_REMOVE, &aca->pbout, row);
+       if (ret < 0)
+               return ret;
        ret = osl(osl_del_row(audio_file_table, row));
        if (ret < 0)
-               para_printf(&crd->pb, "%s: %s\n", name, para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot remove %s\n", name);
        return ret;
 }
 
-static void com_rm_callback(int fd, const struct osl_object *query)
+static int com_rm_callback(struct afs_callback_arg *aca)
 {
-       struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler
-               }
-       };
        int ret;
+       uint32_t flags = *(uint32_t *)aca->query.data;
        struct pattern_match_data pmd = {
                .table = audio_file_table,
                .loop_col_num = AFTCOL_HASH,
                .match_col_num = AFTCOL_PATH,
-               .patterns = {.data = (char *)query->data + sizeof(uint32_t),
-                       .size = query->size - sizeof(uint32_t)},
-               .data = &crd,
+               .patterns = {.data = (char *)aca->query.data + sizeof(uint32_t),
+                       .size = aca->query.size - sizeof(uint32_t)},
+               .data = aca,
                .action = remove_audio_file
        };
-       if (crd.flags & RM_FLAG_FNM_PATHNAME)
+       if (flags & RM_FLAG_FNM_PATHNAME)
                pmd.fnmatch_flags |= FNM_PATHNAME;
        ret = for_each_matching_row(&pmd);
-       if (ret < 0) {
-               para_printf(&crd.pb, "%s\n", para_strerror(-ret));
-               return;
-       }
-       if ((pmd.num_matches == 0) && !(crd.flags & RM_FLAG_FORCE))
-               ret = para_printf(&crd.pb, "no matches -- nothing removed\n");
-       else if (crd.flags & RM_FLAG_VERBOSE) {
-               ret = para_printf(&crd.pb, "removed %u files\n",
+       if (ret < 0)
+               goto out;
+       if (pmd.num_matches == 0) {
+               if (!(flags & RM_FLAG_FORCE))
+                       ret = -E_NO_MATCH;
+       } else if (flags & RM_FLAG_VERBOSE)
+               para_printf(&aca->pbout, "removed %u file(s)\n",
                        pmd.num_matches);
-       }
-       if (ret >= 0 && crd.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, crd.pb.buf, crd.pb.offset);
-       free(crd.pb.buf);
+out:
+       return ret;
 }
 
 /* TODO options: -r (recursive) */
@@ -2285,7 +2164,7 @@ int com_rm(struct command_context *cc)
 {
        uint32_t flags = 0;
        struct osl_object query = {.data = &flags, .size = sizeof(flags)};
-       int i, ret;
+       int i;
 
        for (i = 1; i < cc->argc; i++) {
                const char *arg = cc->argv[i];
@@ -2311,11 +2190,8 @@ int com_rm(struct command_context *cc)
        }
        if (i >= cc->argc)
                return -E_AFT_SYNTAX;
-       ret = send_option_arg_callback_request(&query, cc->argc - i,
+       return send_option_arg_callback_request(&query, cc->argc - i,
                cc->argv + i, com_rm_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
 /**
@@ -2342,10 +2218,10 @@ enum cpsi_flags {
 struct cpsi_action_data {
        /** command line flags (see \ref cpsi_flags). */
        unsigned flags;
-       /** Message buffer. */
-       struct para_buffer pb;
        /** Values are copied from here. */
        struct afs_info source_afsi;
+       /** What was passed to com_cpsi_callback(). */
+       struct afs_callback_arg *aca;
 };
 
 static int copy_selector_info(__a_unused struct osl_table *table,
@@ -2373,38 +2249,27 @@ static int copy_selector_info(__a_unused struct osl_table *table,
        if (cad->flags & CPSI_FLAG_COPY_ATTRIBUTES)
                target_afsi.attributes = cad->source_afsi.attributes;
        save_afsi(&target_afsi, &target_afsi_obj); /* in-place update */
-       if (cad->flags & CPSI_FLAG_VERBOSE) {
-               ret = para_printf(&cad->pb, "copied afsi to %s\n", name);
-               if (ret < 0)
-                       return ret;
-       }
+       if (cad->flags & CPSI_FLAG_VERBOSE)
+               para_printf(&cad->aca->pbout, "copied afsi to %s\n", name);
        aced.aft_row = row;
        aced.old_afsi = &old_afsi;
-       afs_event(AFSI_CHANGE, &cad->pb, &aced);
-       return 1;
+       return afs_event(AFSI_CHANGE, &cad->aca->pbout, &aced);
 }
 
-static void com_cpsi_callback(int fd, const struct osl_object *query)
+static int com_cpsi_callback(struct afs_callback_arg *aca)
 {
        struct cpsi_action_data cad = {
-               .flags = *(unsigned *)query->data,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler
-               }
+               .flags = *(unsigned *)aca->query.data,
+               .aca = aca
        };
        int ret;
-       char *source_path = (char *)query->data + sizeof(cad.flags);
+       char *source_path = (char *)aca->query.data + sizeof(cad.flags);
        struct pattern_match_data pmd = {
                .table = audio_file_table,
                .loop_col_num = AFTCOL_HASH,
                .match_col_num = AFTCOL_PATH,
                .patterns = {.data = source_path + strlen(source_path) + 1,
-                       .size = query->size - sizeof(cad.flags)
+                       .size = aca->query.size - sizeof(cad.flags)
                                - strlen(source_path) - 1},
                .data = &cad,
                .action = copy_selector_info
@@ -2414,24 +2279,22 @@ static void com_cpsi_callback(int fd, const struct osl_object *query)
        if (ret < 0)
                goto out;
        ret = for_each_matching_row(&pmd);
-out:
        if (ret < 0)
-               para_printf(&cad.pb, "%s\n", para_strerror(-ret));
-       else if (pmd.num_matches > 0) {
+               goto out;
+       if (pmd.num_matches > 0) {
                if (cad.flags & CPSI_FLAG_VERBOSE)
-                       para_printf(&cad.pb, "copied requested afsi from %s "
-                               "to %u files\n", source_path, pmd.num_matches);
+                       para_printf(&aca->pbout, "updated afsi of %u file(s)\n",
+                               pmd.num_matches);
        } else
-               para_printf(&cad.pb, "no matches - nothing copied\n");
-       if (cad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, cad.pb.buf, cad.pb.offset);
-       free(cad.pb.buf);
+               ret = -E_NO_MATCH;
+out:
+       return ret;
 }
 
 int com_cpsi(struct command_context *cc)
 {
        unsigned flags = 0;
-       int i, ret;
+       int i;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
 
        for (i = 1; i < cc->argc; i++) {
@@ -2472,16 +2335,13 @@ int com_cpsi(struct command_context *cc)
                return -E_AFT_SYNTAX;
        if (!(flags & ~CPSI_FLAG_VERBOSE)) /* no copy flags given */
                flags = ~(unsigned)CPSI_FLAG_VERBOSE | flags;
-       ret = send_option_arg_callback_request(&options, cc->argc - i,
+       return send_option_arg_callback_request(&options, cc->argc - i,
                cc->argv + i, com_cpsi_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
 struct change_atts_data {
        uint64_t add_mask, del_mask;
-       struct para_buffer pb;
+       struct afs_callback_arg *aca;
 };
 
 static int change_atts(__a_unused struct osl_table *table,
@@ -2506,25 +2366,15 @@ static int change_atts(__a_unused struct osl_table *table,
        new_afsi.attributes |= cad->add_mask;
        new_afsi.attributes &= ~cad->del_mask;
        save_afsi(&new_afsi, &obj); /* in-place update */
-       afs_event(AFSI_CHANGE, &cad->pb, &aced);
-       return 1;
+       return afs_event(AFSI_CHANGE, &cad->aca->pbout, &aced);
 }
 
-static void com_setatt_callback(int fd, const struct osl_object *query)
+static int com_setatt_callback(struct afs_callback_arg *aca)
 {
        char *p;
        int ret;
        size_t len;
-       struct change_atts_data cad = {
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .max_size_handler = afs_max_size_handler,
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       }
-               }
-       };
+       struct change_atts_data cad = {.aca = aca};
        struct pattern_match_data pmd = {
                .table = audio_file_table,
                .loop_col_num = AFTCOL_HASH,
@@ -2534,7 +2384,11 @@ static void com_setatt_callback(int fd, const struct osl_object *query)
                .action = change_atts
        };
 
-       for (p = query->data; p < (char *)query->data + query->size; p += len + 1) {
+       for (
+               p = aca->query.data;
+               p < (char *)aca->query.data + aca->query.size;
+               p += len + 1
+       ) {
                char c;
                unsigned char bitnum;
 
@@ -2548,7 +2402,7 @@ static void com_setatt_callback(int fd, const struct osl_object *query)
                p[len - 1] = '\0';
                ret = get_attribute_bitnum_by_name(p, &bitnum);
                if (ret < 0) {
-                       para_printf(&cad.pb, "attribute not found: %s\n", p);
+                       para_printf(&aca->pbout, "attribute not found: %s\n", p);
                        goto out;
                }
                if (c == '+')
@@ -2560,20 +2414,16 @@ static void com_setatt_callback(int fd, const struct osl_object *query)
        if (!cad.add_mask && !cad.del_mask)
                goto out;
        pmd.patterns.data = p;
-       if (p >= (char *)query->data + query->size)
+       if (p >= (char *)aca->query.data + aca->query.size)
                goto out;
-       pmd.patterns.size = (char *)query->data + query->size - p;
+       pmd.patterns.size = (char *)aca->query.data + aca->query.size - p;
        ret = for_each_matching_row(&pmd);
        if (ret < 0)
                goto out;
        if (pmd.num_matches == 0)
-               para_printf(&cad.pb, "no matches\n");
+               ret = -E_NO_MATCH;
 out:
-       if (ret < 0)
-               para_printf(&cad.pb, "%s\n", para_strerror(-ret));
-       if (cad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, cad.pb.buf, cad.pb.offset);
-       free(cad.pb.buf);
+       return ret;
 }
 
 int com_setatt(struct command_context *cc)
@@ -2584,15 +2434,15 @@ int com_setatt(struct command_context *cc)
                com_setatt_callback, afs_cb_result_handler, cc);
 }
 
-static void afs_stat_callback(int fd, const struct osl_object *query)
+static int afs_stat_callback(struct afs_callback_arg *aca)
 {
-       int *parser_friendly = query->data;
+       int *parser_friendly = aca->query.data;
        char *buf = *parser_friendly?
                parser_friendly_status_items : status_items;
 
        if (!buf)
-               return;
-       pass_buffer_as_shm(fd, SBD_OUTPUT, buf, strlen(buf));
+               return 0;
+       return pass_buffer_as_shm(aca->fd, SBD_OUTPUT, buf, strlen(buf));
 }
 
 /**
@@ -2618,7 +2468,7 @@ int send_afs_status(struct command_context *cc, int parser_friendly)
                afs_cb_result_handler, cc);
 }
 
-/* TODO: optionally fix problems by removing offending rows */
+/* returns success on non-fatal errors to keep the loop going */
 static int check_audio_file(struct osl_row *row, void *data)
 {
        char *path;
@@ -2628,64 +2478,99 @@ static int check_audio_file(struct osl_row *row, void *data)
        struct afs_info afsi;
        char *blob_name;
 
-       if (ret < 0)
-               return para_printf(pb, "%s\n", para_strerror(-ret));
-       if (stat(path, &statbuf) < 0) {
-               ret = para_printf(pb, "%s: stat error (%s)\n", path, strerror(errno));
-               if (ret < 0)
-                       return ret;
-       } else {
-               if (!S_ISREG(statbuf.st_mode)) {
-                       ret = para_printf(pb, "%s: not a regular file\n", path);
-                       if (ret < 0)
-                               return ret;
-               }
+       if (ret < 0) {
+               para_printf(pb, "%s\n", para_strerror(-ret));
+               return ret;
        }
+       if (stat(path, &statbuf) < 0)
+               para_printf(pb, "%s: stat error (%s)\n", path, strerror(errno));
+       else if (!S_ISREG(statbuf.st_mode))
+               para_printf(pb, "%s: not a regular file\n", path);
        ret = get_afsi_of_row(row, &afsi);
-       if (ret < 0)
-               return para_printf(pb, "%s: %s\n", path, para_strerror(-ret));
-       ret = lyr_get_name_by_id(afsi.lyrics_id, &blob_name);
        if (ret < 0) {
-               ret = para_printf(pb, "%s lyrics id %u: %s\n", path, afsi.lyrics_id,
-                       para_strerror(-ret));
-               if (ret < 0)
-                       return ret;
+               para_printf(pb, "%s: %s\n", path, para_strerror(-ret));
+               return 1;
        }
+       ret = lyr_get_name_by_id(afsi.lyrics_id, &blob_name);
+       if (ret < 0)
+               para_printf(pb, "%s lyrics id %u: %s\n", path, afsi.lyrics_id,
+                       para_strerror(-ret));
        ret = img_get_name_by_id(afsi.image_id, &blob_name);
        if (ret < 0)
-               ret = para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id,
+               para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id,
                        para_strerror(-ret));
-       return ret;
+       return 0;
 }
 
 /**
  * Check the audio file table for inconsistencies.
  *
- * \param fd The afs socket.
- * \param query Unused.
+ * \param aca Only ->pbout is used for diagnostics.
  *
- * This function always succeeds.
+ * \return Standard. Inconsistencies are reported but not regarded as an error.
  *
  * \sa com_check().
  */
-void aft_check_callback(int fd, __a_unused const struct osl_object *query)
+int aft_check_callback(struct afs_callback_arg *aca)
 {
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               },
-               .max_size_handler = afs_max_size_handler
-       };
-       int ret = para_printf(&pb, "checking audio file table...\n");
+       para_printf(&aca->pbout, "checking audio file table...\n");
+       return audio_file_loop(&aca->pbout, check_audio_file);
+}
 
-       if (ret < 0)
-               return;
-       audio_file_loop(&pb, check_audio_file);
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+struct aft_check_atts_data {
+       uint64_t att_mask;
+       struct para_buffer *pb;
+};
+
+static int check_atts_of_audio_file(struct osl_row *row, void *data)
+{
+       struct aft_check_atts_data *acad = data;
+       int ret;
+       struct afs_info afsi;
+       char *path;
+       uint64_t bad_bits;
+
+       ret = get_afsi_of_row(row, &afsi);
+       if (ret < 0) {
+               para_printf(acad->pb, "cannot get afsi\n");
+               return ret;
+       }
+       bad_bits = afsi.attributes & ~acad->att_mask;
+       if (bad_bits == 0) /* OK */
+               return 0;
+       ret = get_audio_file_path_of_row(row, &path);
+       if (ret < 0) {
+               para_printf(acad->pb, "cannot get path\n");
+               return ret;
+       }
+       para_printf(acad->pb, "invalid attribute bits (%" PRIu64 "): %s\n",
+               bad_bits, path);
+       /* return success to keep looping */
+       return 1;
+}
+
+/**
+ * Iterate over all audio files and check the attribute bit mask.
+ *
+ * \param att_mask The mask of all valid attributes.
+ * \param pb Used for reporting inconsistencies.
+ *
+ * This reads the attribute bit mask of each audio file from the afs info
+ * structure stored in the audio file table and verifies that all set bits are
+ * also turned on in \a att_mask, i.e., correspond to an attribute of the
+ * attribute table. Audio files for which this is not the case are reported via
+ * \a pb.
+ *
+ * \return Standard. Inconsistencies are not regarded as errors.
+ *
+ * \sa \ref attribute_check_callback().
+ */
+int aft_check_attributes(uint64_t att_mask, struct para_buffer *pb)
+{
+       struct aft_check_atts_data acad = {.att_mask = att_mask, .pb = pb};
+
+       para_printf(pb, "checking attributes, mask: %" PRIx64 "\n", att_mask);
+       return audio_file_loop(&acad, check_atts_of_audio_file);
 }
 
 /**
@@ -2761,11 +2646,9 @@ static int aft_event_handler(enum afs_events event, struct para_buffer *pb,
        switch (event) {
        case ATTRIBUTE_REMOVE: {
                const struct rmatt_event_data *red = data;
-               ret = para_printf(pb, "clearing attribute %s (bit %u) from all "
+               para_printf(pb, "clearing attribute %s (bit %u) from all "
                        "entries in the audio file table\n", red->name,
                        red->bitnum);
-               if (ret < 0)
-                       return ret;
                return audio_file_loop(data, clear_attribute);
        } case AFSI_CHANGE: {
                struct afsi_change_event_data *aced = data;
index d74ec92..f3f8ea7 100644 (file)
@@ -121,70 +121,60 @@ enum lsatt_flags {
 };
 
 /** Data passed to the action function of lsatt */
-struct lsatt_action_data {
-       /** The result buffer. */
-       struct para_buffer pb;
-       /** The given flags for the lsatt command. */
-       unsigned flags;
-};
-
 static int print_attribute(struct osl_table *table, struct osl_row *row,
                const char *name, void *data)
 {
-       struct lsatt_action_data *laad = data;
+       struct afs_callback_arg *aca = data;
+       unsigned flags = *(unsigned *)aca->query.data;
        struct osl_object bitnum_obj;
        int ret;
 
-       if (!(laad->flags & LSATT_FLAG_LONG))
-               return para_printf(&laad->pb, "%s\n", name);
+       if (!(flags & LSATT_FLAG_LONG)) {
+               para_printf(&aca->pbout, "%s\n", name);
+               return 1;
+       }
        ret = osl(osl_get_object(table, row, ATTCOL_BITNUM, &bitnum_obj));
        if (ret < 0) {
-               para_printf(&laad->pb, "%s: %s\n", name, para_strerror(-ret));
+               para_printf(&aca->pbout, "%s: %s\n", name, para_strerror(-ret));
                return ret;
        }
-       return para_printf(&laad->pb, "%u\t%s\n", *(unsigned char*)bitnum_obj.data,
+       para_printf(&aca->pbout, "%u\t%s\n", *(unsigned char*)bitnum_obj.data,
                name);
+       return 1;
 }
 
-static void com_lsatt_callback(int fd, const struct osl_object *query)
+static int com_lsatt_callback(struct afs_callback_arg *aca)
 {
-       struct lsatt_action_data laad = {
-               .flags = *(unsigned *) query->data,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler
-               }
-
-       };
+       unsigned flags = *(unsigned *)aca->query.data;
+       int ret;
        struct pattern_match_data pmd = {
                .table = attribute_table,
                .loop_col_num = ATTCOL_NAME,
                .match_col_num = ATTCOL_NAME,
-               .patterns = {.data = (char *)query->data + sizeof(laad.flags),
-                       .size = query->size - sizeof(laad.flags)},
+               .patterns = {.data = (char *)aca->query.data + sizeof(flags),
+                       .size = aca->query.size - sizeof(flags)},
                .pm_flags = PM_NO_PATTERN_MATCHES_EVERYTHING,
-               .data = &laad,
+               .data = aca,
                .action = print_attribute
        };
-       if (laad.flags & LSATT_FLAG_SORT_BY_ID)
+       if (flags & LSATT_FLAG_SORT_BY_ID)
                pmd.loop_col_num = ATTCOL_BITNUM;
-       if (laad.flags & LSATT_FLAG_REVERSE)
+       if (flags & LSATT_FLAG_REVERSE)
                pmd.pm_flags |= PM_REVERSE_LOOP;
-       for_each_matching_row(&pmd);
-       if (laad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, laad.pb.buf, laad.pb.offset);
-       free(laad.pb.buf);
+       ret = for_each_matching_row(&pmd);
+       if (ret < 0)
+               goto out;
+       if (pmd.num_matches == 0)
+               ret = -E_NO_MATCH;
+out:
+       return ret;
 }
 
 int com_lsatt(struct command_context *cc)
 {
        unsigned flags = 0;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
-       int ret, i;
+       int i;
 
        for (i = 1; i < cc->argc; i++) {
                const char *arg = cc->argv[i];
@@ -207,13 +197,8 @@ int com_lsatt(struct command_context *cc)
                        continue;
                }
        }
-       ret = send_option_arg_callback_request(&options, cc->argc - i, cc->argv + i,
+       return send_option_arg_callback_request(&options, cc->argc - i, cc->argv + i,
                com_lsatt_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       else if (ret == 0 && cc->argc > 1)
-               ret = send_sb_va(&cc->scc, SBD_ERROR_LOG, "no matches\n");
-       return ret;
 }
 
 struct addatt_event_data {
@@ -222,21 +207,17 @@ struct addatt_event_data {
 };
 
 
-static void com_addatt_callback(int fd, const struct osl_object *query)
+static int com_addatt_callback(struct afs_callback_arg *aca)
 {
        char *p;
-       int ret = 1, ret2 = 0;
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               },
-               .max_size_handler = afs_max_size_handler
-       };
+       int ret = 1;
        size_t len;
 
-       for (p = query->data; p < (char *)query->data + query->size; p += len + 1) {
+       for (
+               p = aca->query.data;
+               p < (char *)aca->query.data + aca->query.size;
+               p += len + 1
+       ) {
                struct osl_object objs[NUM_ATT_COLUMNS];
                struct osl_row *row;
                unsigned char bitnum;
@@ -244,16 +225,12 @@ static void com_addatt_callback(int fd, const struct osl_object *query)
 
                len = strlen(p);
                if (!len || p[len - 1] == '-' || p[len - 1] == '+') {
-                       ret2 = para_printf(&pb, "invalid attribute name: %s\n", p);
-                       if (ret2 < 0)
-                               goto out;
+                       para_printf(&aca->pbout, "invalid attribute name: %s\n", p);
                        continue;
                }
                ret = get_attribute_bitnum_by_name(p, &bitnum);
                if (ret >= 0) {
-                       ret2 = para_printf(&pb, "attribute \"%s\" already exists\n", p);
-                       if (ret2 < 0)
-                               goto out;
+                       para_printf(&aca->pbout, "attribute \"%s\" already exists\n", p);
                        continue;
                }
                if (ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) /* error */
@@ -281,15 +258,15 @@ static void com_addatt_callback(int fd, const struct osl_object *query)
                        goto out;
                aed.name = p;
                aed.bitnum = bitnum;
-               afs_event(ATTRIBUTE_ADD, &pb, &aed);
+               ret = afs_event(ATTRIBUTE_ADD, &aca->pbout, &aed);
+               if (ret < 0)
+                       goto out;
                greatest_att_bitnum = PARA_MAX(greatest_att_bitnum, (int)bitnum);
        }
 out:
-       if (ret < 0 && ret2 >= 0)
-               para_printf(&pb, "%s: %s\n", p, para_strerror(-ret));
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+       if (ret < 0)
+               para_printf(&aca->pbout, "%s: %s\n", p, para_strerror(-ret));
+       return ret;
 }
 
 int com_addatt(struct command_context *cc)
@@ -305,21 +282,13 @@ int com_addatt(struct command_context *cc)
        return ret;
 }
 
-static void com_mvatt_callback(int fd, const struct osl_object *query)
+static int com_mvatt_callback(struct afs_callback_arg *aca)
 {
-       char *old = query->data;
+       char *old = aca->query.data;
        size_t size = strlen(old) + 1;
        char *new = old + size;
        struct osl_object obj = {.data = old, .size = size};
        struct osl_row *row;
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               },
-               .max_size_handler = afs_max_size_handler,
-       };
        int ret;
 
        ret = osl(osl_get_row(attribute_table, ATTCOL_NAME, &obj, &row));
@@ -330,100 +299,67 @@ static void com_mvatt_callback(int fd, const struct osl_object *query)
        ret = osl(osl_update_object(attribute_table, row, ATTCOL_NAME, &obj));
 out:
        if (ret < 0)
-               para_printf(&pb, "%s\n", para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot rename %s to %s\n", old, new);
        else
-               afs_event(ATTRIBUTE_RENAME, &pb, NULL);
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+               ret = afs_event(ATTRIBUTE_RENAME, &aca->pbout, NULL);
+       return ret;
 }
 
 int com_mvatt(struct command_context *cc)
 {
-       int ret;
-
        if (cc->argc != 3)
                return -E_ATTR_SYNTAX;
-       ret = send_standard_callback_request(cc->argc - 1, cc->argv + 1,
+       return send_standard_callback_request(cc->argc - 1, cc->argv + 1,
                com_mvatt_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
-/** Data passed to the action handler of com_rmatt(). */
-struct remove_attribute_action_data {
-       /** Message buffer. */
-       struct para_buffer pb;
-       /** Number of attributes removed. */
-       int num_removed;
-       /** Bitwise "or" of the removed attributes. */
-       uint64_t mask_of_removed_atts;
-};
-
 static int remove_attribute(struct osl_table *table, struct osl_row *row,
                const char *name, void *data)
 {
-       struct remove_attribute_action_data *raad = data;
+       struct afs_callback_arg *aca = data;
        int ret;
        struct rmatt_event_data red = {.name = name};
 
        ret = get_attribute_bitnum_by_name(name, &red.bitnum);
-       if (ret < 0)
-               return para_printf(&raad->pb, "%s: %s\n", name, para_strerror(-ret));
+       if (ret < 0) {
+               para_printf(&aca->pbout, "cannot remove %s\n", name);
+               return ret;
+       }
+       para_printf(&aca->pbout, "removing attribute %s\n", name);
        ret = osl(osl_del_row(table, row));
-       if (ret < 0)
-               return para_printf(&raad->pb, "%s: %s\n", name, para_strerror(-ret));
-       ret = para_printf(&raad->pb, "removed attribute %s\n", name);
-       raad->num_removed++;
-       raad->mask_of_removed_atts |= (1 << red.bitnum);
-       afs_event(ATTRIBUTE_REMOVE, &raad->pb, &red);
-       return ret;
+       if (ret < 0) {
+               para_printf(&aca->pbout, "cannot remove %s\n", name);
+               return ret;
+       }
+       return afs_event(ATTRIBUTE_REMOVE, &aca->pbout, &red);
 }
 
-static void com_rmatt_callback(int fd, const struct osl_object *query)
+static int com_rmatt_callback(struct afs_callback_arg *aca)
 {
-       struct remove_attribute_action_data raad = {
-               .num_removed = 0,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler,
-               }
-       };
-       int ret, ret2 = 0;
+       int ret;
        struct pattern_match_data pmd = {
                .table = attribute_table,
-               .patterns = *query,
+               .patterns = aca->query,
                .loop_col_num = ATTCOL_BITNUM,
                .match_col_num = ATTCOL_NAME,
-               .data = &raad,
+               .data = aca,
                .action = remove_attribute
        };
        ret = for_each_matching_row(&pmd);
        if (ret < 0)
-               ret2 = para_printf(&raad.pb, "%s\n", para_strerror(-ret));
-       else if (!raad.num_removed)
-               ret2 = para_printf(&raad.pb, "no match -- nothing removed\n");
-       if (ret2 >= 0 && raad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, raad.pb.buf, raad.pb.offset);
-       free(raad.pb.buf);
+               goto out;
+       if (pmd.num_matches == 0)
+               ret = -E_NO_MATCH;
+out:
+       return ret;
 }
 
 int com_rmatt(struct command_context *cc)
 {
-       int ret;
-
        if (cc->argc < 2)
                return -E_ATTR_SYNTAX;
-       ret = send_standard_callback_request(cc->argc - 1, cc->argv + 1,
+       return send_standard_callback_request(cc->argc - 1, cc->argv + 1,
                com_rmatt_callback, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
 /**
@@ -499,6 +435,47 @@ err:
        return ret;
 }
 
+static int att_logical_or(struct osl_row *row, void *data)
+{
+       uint64_t *att_mask = data;
+       struct osl_object bitnum_obj;
+       int ret = osl_get_object(attribute_table, row, ATTCOL_BITNUM, &bitnum_obj);
+
+       if (ret < 0)
+               return ret;
+       *att_mask |= 1 << *(unsigned char *)bitnum_obj.data;
+       return 0;
+}
+
+/**
+ * Compute the attribute bit mask and check each afs info bitmap.
+ *
+ * \param aca The query field of \a aca is ignored.
+ *
+ * This iterates over all attributes in the attribute table and computes the
+ * logical or of 1 << b where b is the bit number of the attribute. The
+ * resulting bit mask is passed to aft_check_attributes() which performs the
+ * actual check.
+ *
+ * \return Standard.
+ *
+ * \sa \ref aft_check_attributes().
+ */
+int attribute_check_callback(struct afs_callback_arg *aca)
+{
+       int ret;
+       uint64_t att_mask = 0; /* bits corresponding to a attributes */
+
+       ret = osl_rbtree_loop(attribute_table, ATTCOL_BITNUM, &att_mask,
+               att_logical_or);
+       if (ret < 0) {
+               PARA_ERROR_LOG("attribute table loop failed: %s\n",
+                       para_strerror(-ret));
+               return ret;
+       }
+       return aft_check_attributes(att_mask, &aca->pbout);
+}
+
 /**
  * Close the attribute table.
  *
index 22b47cf..278e6ef 100644 (file)
@@ -42,6 +42,12 @@ static audiod_command_handler_t AUDIOD_COMMAND_HANDLERS;
 struct audiod_command {
        const char *name;
        /* Pointer to the function that handles the command. */
+       /*
+        * Command handlers must never never close their file descriptor. A
+        * positive return value tells audiod that the status items have
+        * changed. In this case audiod will send an updated version of all
+        * status items to to each connected stat client.
+        */
        audiod_command_handler_t *handler;
        /* One-line description. */
        const char *description;
@@ -183,8 +189,7 @@ void stat_client_write_item(int item_num)
                        continue;
                b = (sc->flags & SCF_PARSER_FRIENDLY)? &pfpb : &pb;
                if (!b->buf)
-                       (void)WRITE_STATUS_ITEM(b, item_num, "%s\n",
-                               msg? msg : "");
+                       WRITE_STATUS_ITEM(b, item_num, "%s\n", msg? msg : "");
                ret = write(sc->fd, b->buf, b->offset);
                if (ret == b->offset)
                        continue;
@@ -256,10 +261,11 @@ static int com_help(int fd, int argc, char **argv)
 {
        int i, ret;
        char *buf;
-       const char *dflt = "No such command. Available commands:\n";
 
-       if (argc < 2)
-               return dump_commands(fd);
+       if (argc < 2) {
+               ret = dump_commands(fd);
+               goto out;
+       }
        FOR_EACH_COMMAND(i) {
                if (strcmp(audiod_cmds[i].name, argv[1]))
                        continue;
@@ -274,12 +280,13 @@ static int com_help(int fd, int argc, char **argv)
                );
                ret = client_write(fd, buf);
                free(buf);
-               return ret;
+               goto out;
        }
-       ret = client_write(fd, dflt);
+       ret = client_write(fd, "No such command. Available commands:\n");
        if (ret > 0)
                ret = dump_commands(fd);
-       return ret;
+out:
+       return ret < 0? ret : 0;
 }
 
 static int com_tasks(int fd, __a_unused int argc, __a_unused char **argv)
@@ -290,7 +297,7 @@ static int com_tasks(int fd, __a_unused int argc, __a_unused char **argv)
        if (tl)
                ret = client_write(fd, tl);
        free(tl);
-       return ret;
+       return ret < 0? ret : 0;
 }
 
 static int com_stat(int fd, int argc, char **argv)
@@ -329,18 +336,19 @@ static int com_stat(int fd, int argc, char **argv)
                char *item = stat_item_values[i];
                if (!((one << i) & mask))
                        continue;
-               (void)WRITE_STATUS_ITEM(&b, i, "%s\n", item? item : "");
+               WRITE_STATUS_ITEM(&b, i, "%s\n", item? item : "");
        }
        ret = client_write(fd, b.buf);
        if (ret >= 0)
                ret = stat_client_add(fd, mask, parser_friendly);
        free(b.buf);
-       return ret;
+       return ret < 0? ret : 0;
 }
 
 static int com_grab(int fd, int argc, char **argv)
 {
-       return grab_client_new(fd, argc, argv, &sched);
+       int ret = grab_client_new(fd, argc, argv, &sched);
+       return ret < 0? ret : 0;
 }
 
 static int com_term(__a_unused int fd, __a_unused int argc, __a_unused char **argv)
@@ -393,7 +401,7 @@ static int com_version(int fd, int argc, char **argv)
                msg = make_message("%s\n", version_single_line("audiod"));
        ret = client_write(fd, msg);
        free(msg);
-       return ret;
+       return ret < 0? ret : 0;
 }
 
 static int check_perms(uid_t uid, uid_t *whitelist)
diff --git a/blob.c b/blob.c
index adfdb1a..2e0a476 100644 (file)
--- a/blob.c
+++ b/blob.c
@@ -100,75 +100,60 @@ enum blob_ls_flags {
        BLOB_LS_FLAG_SORT_BY_ID = 4,
 };
 
-/** Structure passed to the \p print_blob function. */
-struct lsblob_action_data {
-       /** The flags given at the command line. */
-       uint32_t flags;
-       /** Message buffer. */
-       struct para_buffer pb;
-};
-
 static int print_blob(struct osl_table *table, struct osl_row *row,
                const char *name, void *data)
 {
-       struct lsblob_action_data *lbad = data;
+       struct afs_callback_arg *aca = data;
+       uint32_t flags = *(uint32_t *)aca->query.data;
        struct osl_object obj;
        uint32_t id;
        int ret;
 
-       if (!(lbad->flags & BLOB_LS_FLAG_LONG))
-               return para_printf(&lbad->pb, "%s\n", name);
+       if (!(flags & BLOB_LS_FLAG_LONG)) {
+               para_printf(&aca->pbout, "%s\n", name);
+               return 0;
+       }
        ret = osl(osl_get_object(table, row, BLOBCOL_ID, &obj));
        if (ret < 0) {
-               para_printf(&lbad->pb, "%s: %s\n", name, para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot list %s\n", name);
                return ret;
        }
        id = *(uint32_t *)obj.data;
-       return para_printf(&lbad->pb, "%u\t%s\n", id, name);
+       para_printf(&aca->pbout, "%u\t%s\n", id, name);
+       return 1;
 }
 
-static void com_lsblob_callback(struct osl_table *table,
-               int fd, const struct osl_object *query)
+static int com_lsblob_callback(struct osl_table *table,
+               struct afs_callback_arg *aca)
 {
-       struct lsblob_action_data lbad = {
-               .flags = *(uint32_t *)query->data,
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler,
-               }
-       };
+       uint32_t flags = *(uint32_t *)aca->query.data;
        struct pattern_match_data pmd = {
                .table = table,
-               .patterns = {.data = (char *)query->data + sizeof(uint32_t),
-                       .size = query->size - sizeof(uint32_t)},
+               .patterns = {.data = (char *)aca->query.data + sizeof(uint32_t),
+                       .size = aca->query.size - sizeof(uint32_t)},
                .pm_flags = PM_NO_PATTERN_MATCHES_EVERYTHING | PM_SKIP_EMPTY_NAME,
                .match_col_num = BLOBCOL_NAME,
-               .data = &lbad,
+               .data = aca,
                .action = print_blob,
        };
        int ret;
 
-       if (lbad.flags & BLOB_LS_FLAG_REVERSE)
+       if (flags & BLOB_LS_FLAG_REVERSE)
                pmd.pm_flags |= PM_REVERSE_LOOP;
-       if (!(lbad.flags & BLOB_LS_FLAG_SORT_BY_ID))
+       if (!(flags & BLOB_LS_FLAG_SORT_BY_ID))
                pmd.loop_col_num = BLOBCOL_NAME;
        else
                pmd.loop_col_num = BLOBCOL_ID;
        ret = for_each_matching_row(&pmd);
        if (ret < 0)
-               para_printf(&lbad.pb, "%s\n", para_strerror(-ret));
-       else if (pmd.num_matches == 0 && pmd.patterns.size > 0)
-               para_printf(&lbad.pb, "no matches\n");
-       if (lbad.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, lbad.pb.buf, lbad.pb.offset);
-       free(lbad.pb.buf);
+               goto out;
+       if (pmd.num_matches == 0 && pmd.patterns.size > 0)
+               ret = -E_NO_MATCH;
+out:
+       return ret;
 }
 
-static int com_lsblob(callback_function *f, struct command_context *cc)
+static int com_lsblob(afs_callback *f, struct command_context *cc)
 {
        uint32_t flags = 0;
        struct osl_object options = {.data = &flags, .size = sizeof(flags)};
@@ -217,26 +202,28 @@ static int cat_blob(struct osl_table *table, struct osl_row *row,
        return (ret < 0)? ret : ret2;
 }
 
-static void com_catblob_callback(struct osl_table *table, int fd,
-               const struct osl_object *query)
+static int com_catblob_callback(struct osl_table *table,
+               struct afs_callback_arg *aca)
 {
+       int ret;
        struct pattern_match_data pmd = {
                .table = table,
-               .patterns = *query,
+               .patterns = aca->query,
                .loop_col_num = BLOBCOL_NAME,
                .match_col_num = BLOBCOL_NAME,
                .pm_flags = PM_SKIP_EMPTY_NAME,
-               .data = &fd,
+               .data = &aca->fd,
                .action = cat_blob
        };
-       for_each_matching_row(&pmd);
-       if (pmd.num_matches == 0) {
-               char err_msg[] = "no matches\n";
-               pass_buffer_as_shm(fd, SBD_OUTPUT, err_msg, sizeof(err_msg));
-       }
+       ret = for_each_matching_row(&pmd);
+       if (ret < 0)
+               return ret;
+       if (pmd.num_matches == 0)
+               ret = -E_NO_MATCH;
+       return ret;
 }
 
-static int com_catblob(callback_function *f, struct command_context *cc)
+static int com_catblob(afs_callback *f, struct command_context *cc)
 {
        if (cc->argc < 2)
                return -E_BLOB_SYNTAX;
@@ -244,66 +231,46 @@ static int com_catblob(callback_function *f, struct command_context *cc)
                afs_cb_result_handler, cc);
 }
 
-/** Used for removing rows from a blob table. */
-struct rmblob_data {
-       /** Message buffer. */
-       struct para_buffer pb;
-};
-
 static int remove_blob(struct osl_table *table, struct osl_row *row,
                const char *name, void *data)
 {
-       struct rmblob_data *rmbd = data;
+       struct afs_callback_arg *aca = data;
        int ret = osl(osl_del_row(table, row));
        if (ret < 0) {
-               para_printf(&rmbd->pb, "%s: %s\n", name, para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot remove %s\n", name);
                return ret;
        }
        return 1;
 }
 
-static void com_rmblob_callback(struct osl_table *table, int fd,
-               const struct osl_object *query)
+static int com_rmblob_callback(struct osl_table *table,
+               struct afs_callback_arg *aca)
 {
-       int ret, ret2 = 0;
-       struct rmblob_data rmbd = {
-               .pb = {
-                       .max_size = shm_get_shmmax(),
-                       .private_data = &(struct afs_max_size_handler_data) {
-                               .fd = fd,
-                               .band = SBD_OUTPUT
-                       },
-                       .max_size_handler = afs_max_size_handler,
-               }
-       };
+       int ret;
        struct pattern_match_data pmd = {
                .table = table,
-               .patterns = *query,
+               .patterns = aca->query,
                .loop_col_num = BLOBCOL_NAME,
                .match_col_num = BLOBCOL_NAME,
                .pm_flags = PM_SKIP_EMPTY_NAME,
-               .data = &rmbd,
+               .data = aca,
                .action = remove_blob
        };
        ret = for_each_matching_row(&pmd);
-       if (ret < 0) {
-               ret2 = para_printf(&rmbd.pb, "%s\n", para_strerror(-ret));
-               if (ret2 < 0)
-                       goto out;
-       }
+       if (ret < 0)
+               goto out;
        if (pmd.num_matches == 0)
-               ret2 = para_printf(&rmbd.pb, "no matches, nothing removed\n");
+               ret = -E_NO_MATCH;
        else {
-               ret2 = para_printf(&rmbd.pb, "removed %d blobs\n", pmd.num_matches);
-               afs_event(BLOB_REMOVE, NULL, table);
+               para_printf(&aca->pbout, "removed %d blob(s)\n",
+                       pmd.num_matches);
+               ret = afs_event(BLOB_REMOVE, NULL, table);
        }
 out:
-       if (ret2 >= 0 && rmbd.pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, rmbd.pb.buf, rmbd.pb.offset);
-       free(rmbd.pb.buf);
+       return ret;
 }
 
-static int com_rmblob(callback_function *f, struct command_context *cc)
+static int com_rmblob(afs_callback *f, struct command_context *cc)
 {
        if (cc->argc < 2)
                return -E_MOOD_SYNTAX;
@@ -311,12 +278,12 @@ static int com_rmblob(callback_function *f, struct command_context *cc)
                afs_cb_result_handler, cc);
 }
 
-static void com_addblob_callback(struct osl_table *table, int fd,
-               const struct osl_object *query)
+static int com_addblob_callback(struct osl_table *table,
+               struct afs_callback_arg *aca)
 {
        struct osl_object objs[NUM_BLOB_COLUMNS];
-       char *name = query->data, *msg;
-       size_t name_len = strlen(name) + 1, msg_len;
+       char *name = aca->query.data;
+       size_t name_len = strlen(name) + 1;
        uint32_t id;
        unsigned num_rows;
        int ret;
@@ -349,7 +316,7 @@ static void com_addblob_callback(struct osl_table *table, int fd,
                                goto out;
                        id = *(uint32_t *)obj.data;
                        obj.data = name + name_len;
-                       obj.size = query->size - name_len;
+                       obj.size = aca->query.size - name_len;
                        ret = osl(osl_update_object(table, row, BLOBCOL_DEF, &obj));
                        goto out;
                }
@@ -374,19 +341,17 @@ static void com_addblob_callback(struct osl_table *table, int fd,
        objs[BLOBCOL_NAME].data = name;
        objs[BLOBCOL_NAME].size = name_len;
        objs[BLOBCOL_DEF].data = name + name_len;
-       objs[BLOBCOL_DEF].size = query->size - name_len;
+       objs[BLOBCOL_DEF].size = aca->query.size - name_len;
        ret = osl(osl_add_row(table, objs));
        if (ret < 0)
                goto out;
-       afs_event(BLOB_ADD, NULL, table);
+       ret = afs_event(BLOB_ADD, NULL, table);
 out:
        if (ret < 0)
-               msg_len = xasprintf(&msg, "could not add %s: %s\n", name,
-                       para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot add %s\n", name);
        else
-               msg_len = xasprintf(&msg, "added %s as id %u\n", name, id);
-       pass_buffer_as_shm(fd, SBD_OUTPUT, msg, msg_len);
-       free(msg);
+               para_printf(&aca->pbout, "added %s as id %u\n", name, id);
+       return ret;
 }
 
 /* Write input from fd to dynamically allocated buffer, but maximal 10M. */
@@ -426,27 +391,16 @@ again:
 }
 
 /*
- * Read data from a file descriptor, and send it to the afs process.
- *
- * \param cc Contains the file descriptor to read data from.
- * \param arg_obj Pointer to the arguments to \a f.
- * \param f The callback function.
- * \param result_handler See \ref send_callback_request.
- * \param private_result_data See \ref send_callback_request.
- *
- * This function is used by the addblob commands that instruct para_server to
- * store arbitrary data in a blob table. Input data is read and decrypted from
- * the file descriptor given by \a cc. This data is concatenated with the
- * buffer given by \a arg_obj, and the combined buffer is made available to the
- * afs process via the callback method. See \ref send_callback_request for
- * details.
+ * Read blob from a file descriptor and send it to afs.
  *
- * \return Negative on errors, the return value of the underlying call to
- * send_callback_request() otherwise.
+ * This function is called from the addblob command handlers to instruct the
+ * afs process to store the input in a blob table. Input is read and decrypted
+ * from the file descriptor given by cc and appended to arg_obj, which contains
+ * the name of the blob to create. The combined buffer is made available to the
+ * afs process via the callback method.
  */
 static int stdin_command(struct command_context *cc, struct osl_object *arg_obj,
-               callback_function *f, callback_result_handler *result_handler,
-               void *private_result_data)
+               afs_callback *f)
 {
        struct osl_object query, stdin_obj;
        int ret;
@@ -464,12 +418,12 @@ static int stdin_command(struct command_context *cc, struct osl_object *arg_obj,
                memcpy((char *)query.data + arg_obj->size, stdin_obj.data,
                        stdin_obj.size);
        free(stdin_obj.data);
-       ret = send_callback_request(f, &query, result_handler, private_result_data);
+       ret = send_callback_request(f, &query, afs_cb_result_handler, cc);
        free(query.data);
        return ret;
 }
 
-static int com_addblob(callback_function *f, struct command_context *cc)
+static int com_addblob(afs_callback *f, struct command_context *cc)
 {
        struct osl_object arg_obj;
 
@@ -479,60 +433,47 @@ static int com_addblob(callback_function *f, struct command_context *cc)
                return -E_BLOB_SYNTAX;
        arg_obj.size = strlen(cc->argv[1]) + 1;
        arg_obj.data = (char *)cc->argv[1];
-       return stdin_command(cc, &arg_obj, f, afs_cb_result_handler, cc);
+       return stdin_command(cc, &arg_obj, f);
 }
 
-static void com_mvblob_callback(struct osl_table *table, int fd,
-               const struct osl_object *query)
+static int com_mvblob_callback(struct osl_table *table,
+               struct afs_callback_arg *aca)
 {
-       char *src = (char *) query->data;
+       char *src = (char *)aca->query.data;
        struct osl_object obj = {.data = src, .size = strlen(src) + 1};
        char *dest = src + obj.size;
        struct osl_row *row;
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &fd,
-               .max_size_handler = afs_max_size_handler
-       };
        int ret = osl(osl_get_row(table, BLOBCOL_NAME, &obj, &row));
 
        if (ret < 0) {
-               para_printf(&pb, "could not locate %s: %s\n", src,
-                       para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot find source blob %s\n", src);
                goto out;
        }
        obj.data = dest;
        obj.size = strlen(dest) + 1;
        ret = osl(osl_update_object(table, row, BLOBCOL_NAME, &obj));
        if (ret < 0) {
-               para_printf(&pb, "failed to update object %s: %s\n", dest,
-                       para_strerror(-ret));
+               para_printf(&aca->pbout, "cannot rename blob %s to %s\n",
+                       src, dest);
                goto out;
        }
-       afs_event(BLOB_RENAME, NULL, table);
+       ret = afs_event(BLOB_RENAME, NULL, table);
 out:
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+       return ret;
 }
 
-static int com_mvblob(callback_function *f, struct command_context *cc)
+static int com_mvblob(afs_callback *f, struct command_context *cc)
 {
-       int ret;
-
        if (cc->argc != 3)
                return -E_MOOD_SYNTAX;
-       ret = send_option_arg_callback_request(NULL, cc->argc - 1,
+       return send_option_arg_callback_request(NULL, cc->argc - 1,
                cc->argv + 1, f, afs_cb_result_handler, cc);
-       if (ret < 0)
-               send_strerror(cc, -ret);
-       return ret;
 }
 
 #define DEFINE_BLOB_COMMAND(cmd_name, table_name, cmd_prefix) \
-       static void com_ ## cmd_name ## cmd_prefix ## _callback(int fd, const struct osl_object *query) \
+       static int com_ ## cmd_name ## cmd_prefix ## _callback(struct afs_callback_arg *aca) \
        { \
-               return com_ ## cmd_name ## blob_callback(table_name ## _table, fd, query); \
+               return com_ ## cmd_name ## blob_callback(table_name ## _table, aca); \
        } \
        int com_ ## cmd_name ## cmd_prefix(struct command_context *cc) \
        { \
index c378563..e8f6948 100644 (file)
--- a/command.c
+++ b/command.c
@@ -425,9 +425,10 @@ static int com_version(struct command_context *cc)
        char *msg;
        size_t len;
 
-       if (cc->argc != 1)
-               return -E_COMMAND_SYNTAX;
-       len = xasprintf(&msg, "%s", version_text("server"));
+       if (cc->argc > 1 && strcmp(cc->argv[1], "-v") == 0)
+               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);
 }
 
diff --git a/error.h b/error.h
index 3818b11..5d5666c 100644 (file)
--- a/error.h
+++ b/error.h
@@ -279,6 +279,7 @@ extern const char **para_errlist[];
        PARA_ERROR(NO_AFHI, "audio format handler info required"), \
        PARA_ERROR(AFT_SYNTAX, "audio file table syntax error"), \
        PARA_ERROR(HASH_MISMATCH, "hash mismatch, consider re-add"), \
+       PARA_ERROR(NO_MATCH, "no matches"), \
 
 
 #define USER_LIST_ERRORS \
diff --git a/mood.c b/mood.c
index 94deff4..d29c62c 100644 (file)
--- a/mood.c
+++ b/mood.c
@@ -410,20 +410,18 @@ static int check_mood(struct osl_row *mood_row, void *data)
        int ret = mood_get_name_and_def_by_row(mood_row, &mood_name, &mood_def);
 
        if (ret < 0) {
-               para_printf(pb, "failed to get mood definition: %s\n",
-                       para_strerror(-ret));
+               para_printf(pb, "cannot read mood\n");
                return ret;
        }
        if (!*mood_name) /* ignore dummy row */
                goto out;
-       ret = para_printf(pb, "checking mood %s...\n", mood_name);
-       if (ret < 0)
-               goto out;
+       para_printf(pb, "checking mood %s...\n", mood_name);
        ret = for_each_line(FELF_READ_ONLY, mood_def.data, mood_def.size,
                parse_mood_line, &mlpd);
        if (ret < 0)
-               para_printf(pb, "%s line %u: %s\n", mood_name, mlpd.line_num,
-                       para_strerror(-ret));
+               para_printf(pb, "mood %s: error in line %u: %s\n", mood_name,
+                       mlpd.line_num, para_strerror(-ret));
+       ret = 1; /* don't fail the loop on invalid mood definitions */
 out:
        osl_close_disk_object(&mood_def);
        return ret;
@@ -432,28 +430,16 @@ out:
 /**
  * Check all moods for syntax errors.
  *
- * \param fd The afs socket.
- * \param query Unused.
+ * \param aca Only ->pbout is used for diagnostics.
+ *
+ * \return Negative on fatal errors. Inconsistent mood definitions are not
+ * considered an error.
  */
-void mood_check_callback(int fd, __a_unused const struct osl_object *query)
+int mood_check_callback(struct afs_callback_arg *aca)
 {
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               },
-               .max_size_handler = afs_max_size_handler
-       };
-
-       int ret = para_printf(&pb, "checking moods...\n");
-       if (ret < 0)
-               return;
-       osl_rbtree_loop(moods_table, BLOBCOL_ID, &pb,
-               check_mood);
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+       para_printf(&aca->pbout, "checking moods...\n");
+       return osl(osl_rbtree_loop(moods_table, BLOBCOL_ID, &aca->pbout,
+               check_mood));
 }
 
 static int64_t normalized_value(int64_t x, int64_t n, int64_t sum, int64_t qd)
diff --git a/mood.h b/mood.h
index bf7d955..10e9319 100644 (file)
--- a/mood.h
+++ b/mood.h
@@ -4,8 +4,8 @@
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
 
-/** \file mood.h Functions exported by mood.h. */
+/** \file mood.h Public functions of mood.c. */
 
 int change_current_mood(char *mood_name);
 void close_current_mood(void);
-void mood_check_callback(int fd, __a_unused const struct osl_object *query);
+int mood_check_callback(struct afs_callback_arg *aca);
index c84a479..9616ed0 100644 (file)
@@ -95,9 +95,9 @@ static int check_playlist_path(char *path, void *data)
        struct osl_row *aft_row;
        int ret = aft_get_row_of_path(path, &aft_row);
 
-       if (ret >= 0)
-               return 1;
-       return para_printf(pb, "%s: %s\n", path, para_strerror(-ret));
+       if (ret < 0)
+               para_printf(pb, "%s: %s\n", path, para_strerror(-ret));
+       return 1; /* do not fail the loop on bad paths */
 }
 
 static int check_playlist(struct osl_row *row, void *data)
@@ -107,47 +107,33 @@ static int check_playlist(struct osl_row *row, void *data)
        char *playlist_name;
        int ret = pl_get_name_and_def_by_row(row, &playlist_name, &playlist_def);
 
-       if (ret < 0)
-               return para_printf(pb, "failed to get playlist data: %s\n",
+       if (ret < 0) { /* log error, but continue */
+               para_printf(pb, "failed to get playlist data: %s\n",
                        para_strerror(-ret));
+               return 1;
+       }
        if (*playlist_name) { /* skip dummy row */
-               ret = para_printf(pb, "checking playlist %s...\n", playlist_name);
-               if (ret < 0)
-                       return ret;
-               ret = for_each_line(FELF_READ_ONLY, playlist_def.data,
+               para_printf(pb, "checking playlist %s...\n", playlist_name);
+               for_each_line(FELF_READ_ONLY, playlist_def.data,
                        playlist_def.size, check_playlist_path, pb);
        }
        osl_close_disk_object(&playlist_def);
-       return ret;
+       return 1;
 }
 
 /**
  * Check the playlist table for inconsistencies.
  *
- * \param fd The afs socket.
- * \param query Unused.
+ * \param aca This callback ignores ->query.
  *
- * \return The return value of the underlying call to osl_rbtree_loop().
+ * \return Standard. Invalid paths are reported, but are not considered an
+ * error.
  */
-void playlist_check_callback(int fd, __a_unused const struct osl_object *query)
+int playlist_check_callback(struct afs_callback_arg *aca)
 {
-       struct para_buffer pb = {
-               .max_size = shm_get_shmmax(),
-               .private_data = &(struct afs_max_size_handler_data) {
-                       .fd = fd,
-                       .band = SBD_OUTPUT
-               },
-               .max_size_handler = afs_max_size_handler,
-       };
-       int ret = para_printf(&pb, "checking playlists...\n");
-
-       if (ret < 0)
-               return;
-       osl_rbtree_loop(playlists_table, BLOBCOL_ID, &pb,
-               check_playlist);
-       if (pb.offset)
-               pass_buffer_as_shm(fd, SBD_OUTPUT, pb.buf, pb.offset);
-       free(pb.buf);
+       para_printf(&aca->pbout, "checking playlists...\n");
+       return osl(osl_rbtree_loop(playlists_table, BLOBCOL_ID, &aca->pbout,
+               check_playlist));
 }
 
 /**
index 9ce0bb6..c9b698f 100644 (file)
@@ -60,6 +60,8 @@
        DESIGNATOR(EXIT__FAILURE), \
        /* The next chunk of the blob (addblob commands only) */ \
        DESIGNATOR(BLOB_DATA), \
+       /* An afs callback failed. */ \
+       DESIGNATOR(AFS_CB_FAILURE), \
 
 /** Just prefix with \p SBD_. */
 #define DESIGNATOR(x) SBD_ ## x
index f3e935e..61bb7c2 100644 (file)
--- a/string.h
+++ b/string.h
@@ -62,14 +62,12 @@ int for_each_line(unsigned flags, char *buf, size_t size,
   */
 #define WRITE_STATUS_ITEM(b, n, f, ...) (\
 { \
-       int _ret; \
        if ((b)->flags & PBF_SIZE_PREFIX) { \
-               _ret = para_printf((b), "%02x:" f, n, ## __VA_ARGS__); \
+               para_printf((b), "%02x:" f, n, ## __VA_ARGS__); \
        } else { \
-               _ret = para_printf((b), "%s: " f, status_item_list[(n)], \
+               para_printf((b), "%s: " f, status_item_list[(n)], \
                        ## __VA_ARGS__); \
        } \
-       _ret; \
 } \
 )