testsuite: Introduce a new test for para_server.
[paraslash.git] / aft.c
diff --git a/aft.c b/aft.c
index 1033734..3d22e24 100644 (file)
--- a/aft.c
+++ b/aft.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2007-2009 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2007-2011 Andre Noll <maan@systemlinux.org>
  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
@@ -7,8 +7,6 @@
 /** \file aft.c Audio file table functions. */
 
 #include <regex.h>
-#include <dirent.h> /* readdir() */
-#include <openssl/rc4.h>
 #include <sys/mman.h>
 #include <fnmatch.h>
 #include <sys/shm.h>
@@ -20,8 +18,6 @@
 #include "string.h"
 #include "afh.h"
 #include "afs.h"
-#include "net.h"
-#include "vss.h"
 #include "fd.h"
 #include "ipc.h"
 #include "portable_io.h"
@@ -240,7 +236,7 @@ enum audio_file_table_columns {
  */
 static int aft_hash_compare(const struct osl_object *obj1, const struct osl_object *obj2)
 {
-       return hash_compare((HASH_TYPE *)obj1->data, (HASH_TYPE *)obj2->data);
+       return hash_compare((unsigned char *)obj1->data, (unsigned char *)obj2->data);
 }
 
 static struct osl_column_description aft_cols[] = {
@@ -345,16 +341,16 @@ enum afhi_offsets {
        AFHI_BITRATE_OFFSET = 4,
        /** Position of the frequency. */
        AFHI_FREQUENCY_OFFSET = 8,
-       /** Location of the audio file header. */
-       AFHI_HEADER_OFFSET_OFFSET = 12,
+       /** Was: Location of the audio file header. */
+       AFHI_UNUSED1_OFFSET = 12,
        /* Length of the audio file header. Zero means: No header. */
        AFHI_HEADER_LEN_OFFSET = 16,
        /** The total number of chunks (4 bytes). */
        CHUNKS_TOTAL_OFFSET = 20,
        /** The length of the audio file header (4 bytes). */
        HEADER_LEN_OFFSET = 24,
-       /** The start of the audio file header (4 bytes). */
-       HEADER_OFFSET_OFFSET = 28,
+       /** Was: The start of the audio file header (4 bytes). */
+       AFHI_UNUSED2_OFFSET = 28,
        /** The seconds part of the chunk time (4 bytes). */
        CHUNK_TV_TV_SEC_OFFSET = 32,
        /** The microseconds part of the chunk time (4 bytes). */
@@ -389,12 +385,12 @@ static void save_afhi(struct afh_info *afhi, char *buf)
        write_u32(buf + AFHI_SECONDS_TOTAL_OFFSET, afhi->seconds_total);
        write_u32(buf + AFHI_BITRATE_OFFSET, afhi->bitrate);
        write_u32(buf + AFHI_FREQUENCY_OFFSET, afhi->frequency);
-       write_u32(buf + AFHI_HEADER_OFFSET_OFFSET, afhi->header_offset);
+       write_u32(buf + AFHI_UNUSED1_OFFSET, 0);
        write_u32(buf + AFHI_HEADER_LEN_OFFSET, afhi->header_len);
        write_u8(buf + AFHI_CHANNELS_OFFSET, afhi->channels);
        write_u32(buf + CHUNKS_TOTAL_OFFSET, afhi->chunks_total);
        write_u32(buf + HEADER_LEN_OFFSET, afhi->header_len);
-       write_u32(buf + HEADER_OFFSET_OFFSET, afhi->header_offset);
+       write_u32(buf + AFHI_UNUSED2_OFFSET, 0);
        write_u32(buf + CHUNK_TV_TV_SEC_OFFSET, afhi->chunk_tv.tv_sec);
        write_u32(buf + CHUNK_TV_TV_USEC_OFFSET, afhi->chunk_tv.tv_usec);
        p = buf + AFHI_INFO_STRING_OFFSET;
@@ -412,12 +408,10 @@ static void load_afhi(const char *buf, struct afh_info *afhi)
        afhi->seconds_total = read_u32(buf + AFHI_SECONDS_TOTAL_OFFSET);
        afhi->bitrate = read_u32(buf + AFHI_BITRATE_OFFSET);
        afhi->frequency = read_u32(buf + AFHI_FREQUENCY_OFFSET);
-       afhi->header_offset = read_u32(buf + AFHI_HEADER_OFFSET_OFFSET);
        afhi->header_len = read_u32(buf + AFHI_HEADER_LEN_OFFSET);
        afhi->channels = read_u8(buf + AFHI_CHANNELS_OFFSET);
        afhi->chunks_total = read_u32(buf + CHUNKS_TOTAL_OFFSET);
        afhi->header_len = read_u32(buf + HEADER_LEN_OFFSET);
-       afhi->header_offset = read_u32(buf + HEADER_OFFSET_OFFSET);
        afhi->chunk_tv.tv_sec = read_u32(buf + CHUNK_TV_TV_SEC_OFFSET);
        afhi->chunk_tv.tv_usec = read_u32(buf + CHUNK_TV_TV_USEC_OFFSET);
        afhi->techinfo = (char *)buf + AFHI_INFO_STRING_OFFSET;
@@ -435,12 +429,26 @@ static unsigned sizeof_chunk_table(struct afh_info *afhi)
        return 4 * (afhi->chunks_total + 1);
 }
 
-static void save_chunk_table(struct afh_info *afhi, char *buf)
+static uint32_t save_chunk_table(struct afh_info *afhi, char *buf)
 {
        int i;
-
-       for (i = 0; i <= afhi->chunks_total; i++)
-               write_u32(buf + 4 * i, afhi->chunk_table[i]);
+       uint32_t max = 0, old = 0;
+
+       for (i = 0; i <= afhi->chunks_total; i++) {
+               uint32_t val = afhi->chunk_table[i];
+               write_u32(buf + 4 * i, val);
+               /*
+                * If the first chunk is the header, do not consider it for the
+                * calculation of the largest chunk size.
+                */
+               if (i == 0 || (i == 1 && afhi->header_len > 0)) {
+                       old = val;
+                       continue;
+               }
+               max = PARA_MAX(max, val - old);
+               old = val;
+       }
+       return max;
 }
 
 static void load_chunk_table(struct afh_info *afhi, char *buf)
@@ -475,7 +483,7 @@ int aft_get_row_of_path(const char *path, struct osl_row **row)
  *
  * \return Standard.
  */
-static int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row)
+static int aft_get_row_of_hash(unsigned char *hash, struct osl_row **row)
 {
        const struct osl_object obj = {.data = hash, .size = HASH_SIZE};
        return osl(osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row));
@@ -595,7 +603,7 @@ static int get_hash_object_of_aft_row(const struct osl_row *row,
  * \return The return value of the underlying call to
  * get_hash_object_of_aft_row().
  */
-static int get_hash_of_row(const struct osl_row *row, HASH_TYPE **hash)
+static int get_hash_of_row(const struct osl_row *row, unsigned char **hash)
 {
        struct osl_object obj;
        int ret = get_hash_object_of_aft_row(row, &obj);
@@ -641,10 +649,10 @@ static int save_afd(struct audio_file_data *afd)
        ret = shm_attach(shmid, ATTACH_RW, &shm_afd);
        if (ret < 0)
                goto err;
-       *(struct audio_file_data *)shm_afd = *afd;
        buf = shm_afd;
        buf += sizeof(*afd);
-       save_chunk_table(&afd->afhi, buf);
+       afd->max_chunk_size = save_chunk_table(&afd->afhi, buf);
+       *(struct audio_file_data *)shm_afd = *afd;
        shm_detach(shm_afd);
        return shmid;
 err:
@@ -714,7 +722,7 @@ static int get_local_time(uint64_t *seconds, char *buf, size_t size,
                } \
        }
 
-static short unsigned get_duration_width(int seconds)
+__a_const static short unsigned get_duration_width(int seconds)
 {
        short unsigned width;
        unsigned hours = seconds / 3600, mins = (seconds % 3600) / 60;
@@ -1016,7 +1024,7 @@ out:
 
 static int make_status_items(struct audio_file_data *afd,
                struct afs_info *afsi, char *path, long score,
-               HASH_TYPE *hash)
+               unsigned char *hash)
 {
        struct ls_data d = {
                .afhi = afd->afhi,
@@ -1029,7 +1037,7 @@ static int make_status_items(struct audio_file_data *afd,
                .flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY,
                .mode = LS_MODE_VERBOSE,
        };
-       struct para_buffer pb = {.max_size = SHMMAX - 1};
+       struct para_buffer pb = {.max_size = shm_get_shmmax() - 1};
        time_t current_time;
        int ret;
 
@@ -1040,7 +1048,7 @@ static int make_status_items(struct audio_file_data *afd,
        free(status_items);
        status_items = pb.buf;
        memset(&pb, 0, sizeof(pb));
-       pb.max_size = SHMMAX - 1;
+       pb.max_size = shm_get_shmmax() - 1;
        pb.flags = PBF_SIZE_PREFIX;
        ret = print_list_item(&d, &opts, &pb, current_time);
        if (ret < 0) {
@@ -1069,7 +1077,7 @@ static int make_status_items(struct audio_file_data *afd,
 int open_and_update_audio_file(struct osl_row *aft_row, long score,
        struct audio_file_data *afd)
 {
-       HASH_TYPE *aft_hash, file_hash[HASH_SIZE];
+       unsigned char *aft_hash, file_hash[HASH_SIZE];
        struct osl_object afsi_obj;
        struct afs_info old_afsi, new_afsi;
        int ret = get_hash_of_row(aft_row, &aft_hash);
@@ -1082,6 +1090,7 @@ int open_and_update_audio_file(struct osl_row *aft_row, long score,
        ret = get_audio_file_path_of_row(aft_row, &path);
        if (ret < 0)
                return ret;
+       PARA_NOTICE_LOG("%s\n", path);
        ret = get_afsi_object_of_row(aft_row, &afsi_obj);
        if (ret < 0)
                return ret;
@@ -1112,6 +1121,7 @@ int open_and_update_audio_file(struct osl_row *aft_row, long score,
        new_afsi.last_played = time(NULL);
        save_afsi(&new_afsi, &afsi_obj); /* in-place update */
 
+       afd->audio_format_id = old_afsi.audio_format_id;
        load_chunk_table(&afd->afhi, chunk_table_obj.data);
        ret = make_status_items(afd, &old_afsi, path, score, file_hash);
        if (ret < 0)
@@ -1123,6 +1133,8 @@ int open_and_update_audio_file(struct osl_row *aft_row, long score,
 err:
        free(afd->afhi.chunk_table);
        osl_close_disk_object(&chunk_table_obj);
+       if (ret < 0)
+               PARA_ERROR_LOG("%s: %s\n", path, para_strerror(-ret));
        return ret;
 }
 
@@ -1331,7 +1343,7 @@ static void com_ls_callback(int fd, const struct osl_object *query)
 {
        struct ls_options *opts = query->data;
        char *p, *pattern_start = (char *)query->data + sizeof(*opts);
-       struct para_buffer b = {.max_size = SHMMAX,
+       struct para_buffer b = {.max_size = shm_get_shmmax(),
                .flags = (opts->mode == LS_MODE_PARSER)? PBF_SIZE_PREFIX : 0,
                .max_size_handler = pass_buffer_as_shm, .private_data = &fd};
        int i = 0, ret;
@@ -1382,7 +1394,7 @@ out:
 /*
  * TODO: flags -h (sort by hash)
  */
-int com_ls(struct rc4_context *rc4c, int argc, char * const * const argv)
+int com_ls(struct stream_cipher_context *scc, int argc, char * const * const argv)
 {
        int i, ret;
        unsigned flags = 0;
@@ -1494,7 +1506,7 @@ int com_ls(struct rc4_context *rc4c, int argc, char * const * const argv)
        opts.mode = mode;
        opts.num_patterns = argc - i;
        ret = send_option_arg_callback_request(&query, opts.num_patterns,
-               argv + i, com_ls_callback, rc4_send_result, rc4c);
+               argv + i, com_ls_callback, sc_send_result, scc);
        return ret;
 }
 
@@ -1512,7 +1524,7 @@ int audio_file_loop(void *private_data, osl_rbtree_loop_func *func)
                func));
 }
 
-static struct osl_row *find_hash_sister(HASH_TYPE *hash)
+static struct osl_row *find_hash_sister(unsigned char *hash)
 {
        const struct osl_object obj = {.data = hash, .size = HASH_SIZE};
        struct osl_row *row;
@@ -1544,7 +1556,7 @@ enum com_add_buffer_offsets {
  * It's OK to call this with afhi == NULL. In this case, the audio format
  * handler info won't be stored in the buffer.
  */
-static void save_add_callback_buffer(HASH_TYPE *hash, const char *path,
+static void save_add_callback_buffer(unsigned char *hash, const char *path,
                struct afh_info *afhi, uint32_t flags,
                uint8_t audio_format_num, struct osl_object *obj)
 {
@@ -1647,17 +1659,17 @@ static void com_add_callback(int fd, const struct osl_object *query)
        struct osl_row *pb, *aft_row;
        struct osl_row *hs;
        struct osl_object objs[NUM_AFT_COLUMNS];
-       HASH_TYPE *hash;
+       unsigned char *hash;
        char asc[2 * HASH_SIZE + 1];
        int ret;
        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 = SHMMAX,
+       struct para_buffer msg = {.max_size = shm_get_shmmax(),
                .max_size_handler = pass_buffer_as_shm, .private_data = &fd};
        uint16_t afhi_offset, chunks_offset;
 
-       hash = (HASH_TYPE *)buf + CAB_HASH_OFFSET;
+       hash = (unsigned char *)buf + CAB_HASH_OFFSET;
        hash_to_asc(hash, asc);;
        objs[AFTCOL_HASH].data = buf + CAB_HASH_OFFSET;
        objs[AFTCOL_HASH].size = HASH_SIZE;
@@ -1722,7 +1734,7 @@ static void com_add_callback(int fd, const struct osl_object *query)
        objs[AFTCOL_CHUNKS].size = query->size - chunks_offset;
        if (pb && !hs) { /* update pb's hash */
                char old_asc[2 * HASH_SIZE + 1];
-               HASH_TYPE *old_hash;
+               unsigned char *old_hash;
                ret = get_hash_of_row(pb, &old_hash);
                if (ret < 0)
                        goto out;
@@ -1781,8 +1793,8 @@ out:
 
 /** Used by com_add(). */
 struct private_add_data {
-       /** The socket file descriptor, including rc4 keys. */
-       struct rc4_context *rc4c;
+       /** The socket file descriptor, including stream cipher keys. */
+       struct stream_cipher_context *scc;
        /** The given add flags. */
        uint32_t flags;
 };
@@ -1799,7 +1811,7 @@ static void path_brother_callback(int fd, const struct osl_object *query)
 
 static void hash_sister_callback(int fd, const struct osl_object *query)
 {
-       HASH_TYPE *hash = query->data;
+       unsigned char *hash = query->data;
        struct osl_row *hash_sister;
 
        hash_sister = find_hash_sister(hash);
@@ -1811,7 +1823,7 @@ static void hash_sister_callback(int fd, const struct osl_object *query)
 static int get_row_pointer_from_result(struct osl_object *result, void *private)
 {
        struct osl_row **row = private;
-       *row = result->data;
+       *row = *(struct osl_row **)(result->data);
        return 1;
 }
 
@@ -1823,7 +1835,7 @@ static int add_one_audio_file(const char *path, void *private_data)
        struct afh_info afhi, *afhi_ptr = NULL;
        struct osl_row *pb = NULL, *hs = NULL; /* path brother/hash sister */
        struct osl_object map, obj = {.data = NULL}, query;
-       HASH_TYPE hash[HASH_SIZE];
+       unsigned char hash[HASH_SIZE];
 
        ret = guess_audio_format(path);
        if (ret < 0 && !(pad->flags & ADD_FLAG_ALL))
@@ -1837,7 +1849,7 @@ static int add_one_audio_file(const char *path, void *private_data)
        ret = 1;
        if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */
                if (pad->flags & ADD_FLAG_VERBOSE)
-                       send_ret = rc4_send_va_buffer(pad->rc4c,
+                       send_ret = sc_send_va_buffer(pad->scc,
                                "lazy-ignore: %s\n", path);
                goto out_free;
        }
@@ -1858,7 +1870,7 @@ static int add_one_audio_file(const char *path, void *private_data)
        ret = 1;
        if (pb && hs && hs == pb && !(pad->flags & ADD_FLAG_FORCE)) {
                if (pad->flags & ADD_FLAG_VERBOSE)
-                       send_ret = rc4_send_va_buffer(pad->rc4c,
+                       send_ret = sc_send_va_buffer(pad->scc,
                                "%s exists, not forcing update\n", path);
                goto out_unmap;
        }
@@ -1876,13 +1888,13 @@ static int add_one_audio_file(const char *path, void *private_data)
        munmap(map.data, map.size);
        close(fd);
        if (pad->flags & ADD_FLAG_VERBOSE) {
-               send_ret = rc4_send_va_buffer(pad->rc4c, "adding %s\n", path);
+               send_ret = sc_send_va_buffer(pad->scc, "adding %s\n", path);
                if (send_ret < 0)
                        goto out_free;
        }
        save_add_callback_buffer(hash, path, afhi_ptr, pad->flags, format_num, &obj);
        /* Ask afs to consider this entry for adding. */
-       ret = send_callback_request(com_add_callback, &obj, rc4_send_result, pad->rc4c);
+       ret = send_callback_request(com_add_callback, &obj, sc_send_result, pad->scc);
        goto out_free;
 
 out_unmap:
@@ -1890,7 +1902,7 @@ out_unmap:
        munmap(map.data, map.size);
 out_free:
        if (ret < 0 && send_ret >= 0)
-               send_ret = rc4_send_va_buffer(pad->rc4c,
+               send_ret = sc_send_va_buffer(pad->scc,
                        "failed to add %s (%s)\n", path, para_strerror(-ret));
        free(obj.data);
        if (afhi_ptr) {
@@ -1906,10 +1918,10 @@ out_free:
        return send_ret;
 }
 
-int com_add(struct rc4_context *rc4c, int argc, char * const * const argv)
+int com_add(struct stream_cipher_context *scc, int argc, char * const * const argv)
 {
        int i, ret;
-       struct private_add_data pad = {.rc4c = rc4c, .flags = 0};
+       struct private_add_data pad = {.scc = scc, .flags = 0};
        struct stat statbuf;
 
        for (i = 1; i < argc; i++) {
@@ -1943,7 +1955,7 @@ int com_add(struct rc4_context *rc4c, int argc, char * const * const argv)
                char *path;
                ret = verify_path(argv[i], &path);
                if (ret < 0) {
-                       ret = rc4_send_va_buffer(rc4c, "%s: %s\n", argv[i],
+                       ret = sc_send_va_buffer(scc, "%s: %s\n", argv[i],
                                para_strerror(-ret));
                        if (ret < 0)
                                return ret;
@@ -1951,7 +1963,7 @@ int com_add(struct rc4_context *rc4c, int argc, char * const * const argv)
                }
                ret = stat(path, &statbuf);
                if (ret < 0) {
-                       ret = rc4_send_va_buffer(rc4c, "failed to stat %s (%s)\n", path,
+                       ret = sc_send_va_buffer(scc, "failed to stat %s (%s)\n", path,
                                strerror(errno));
                        free(path);
                        if (ret < 0)
@@ -1964,7 +1976,7 @@ int com_add(struct rc4_context *rc4c, int argc, char * const * const argv)
                else
                        ret = add_one_audio_file(path, &pad);
                if (ret < 0) {
-                       rc4_send_va_buffer(rc4c, "%s: %s\n", path, para_strerror(-ret));
+                       sc_send_va_buffer(scc, "%s: %s\n", path, para_strerror(-ret));
                        free(path);
                        return ret;
                }
@@ -2068,7 +2080,7 @@ static void com_touch_callback(int fd, const struct osl_object *query)
 {
        struct touch_action_data tad = {.cto = query->data,
                .pb = {
-                       .max_size = SHMMAX,
+                       .max_size = shm_get_shmmax(),
                        .private_data = &fd,
                        .max_size_handler = pass_buffer_as_shm
                }
@@ -2096,7 +2108,7 @@ static void com_touch_callback(int fd, const struct osl_object *query)
        free(tad.pb.buf);
 }
 
-int com_touch(struct rc4_context *rc4c, int argc, char * const * const argv)
+int com_touch(struct stream_cipher_context *scc, int argc, char * const * const argv)
 {
        struct com_touch_options cto = {
                .num_played = -1,
@@ -2164,9 +2176,9 @@ int com_touch(struct rc4_context *rc4c, int argc, char * const * const argv)
        if (i >= argc)
                return -E_AFT_SYNTAX;
        ret = send_option_arg_callback_request(&query, argc - i,
-               argv + i, com_touch_callback, rc4_send_result, rc4c);
+               argv + i, com_touch_callback, sc_send_result, scc);
        if (ret < 0)
-               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
+               sc_send_va_buffer(scc, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -2214,7 +2226,7 @@ static void com_rm_callback(int fd, const struct osl_object *query)
 {
        struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data,
                .pb = {
-                       .max_size = SHMMAX,
+                       .max_size = shm_get_shmmax(),
                        .private_data = &fd,
                        .max_size_handler = pass_buffer_as_shm
                }
@@ -2248,7 +2260,7 @@ static void com_rm_callback(int fd, const struct osl_object *query)
 }
 
 /* TODO options: -r (recursive) */
-int com_rm(struct rc4_context *rc4c, int argc,  char * const * const argv)
+int com_rm(struct stream_cipher_context *scc, int argc,  char * const * const argv)
 {
        uint32_t flags = 0;
        struct osl_object query = {.data = &flags, .size = sizeof(flags)};
@@ -2279,9 +2291,9 @@ int com_rm(struct rc4_context *rc4c, int argc,  char * const * const argv)
        if (i >= argc)
                return -E_AFT_SYNTAX;
        ret = send_option_arg_callback_request(&query, argc - i, argv + i,
-               com_rm_callback, rc4_send_result, rc4c);
+               com_rm_callback, sc_send_result, scc);
        if (ret < 0)
-               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
+               sc_send_va_buffer(scc, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -2359,7 +2371,7 @@ static void com_cpsi_callback(int fd, const struct osl_object *query)
        struct cpsi_action_data cad = {
                .flags = *(unsigned *)query->data,
                .pb = {
-                       .max_size = SHMMAX,
+                       .max_size = shm_get_shmmax(),
                        .private_data = &fd,
                        .max_size_handler = pass_buffer_as_shm
                }
@@ -2396,7 +2408,7 @@ out:
        free(cad.pb.buf);
 }
 
-int com_cpsi(struct rc4_context *rc4c, int argc,  char * const * const argv)
+int com_cpsi(struct stream_cipher_context *scc, int argc,  char * const * const argv)
 {
        unsigned flags = 0;
        int i, ret;
@@ -2441,9 +2453,9 @@ int com_cpsi(struct rc4_context *rc4c, int argc,  char * const * const argv)
        if (!(flags & ~CPSI_FLAG_VERBOSE)) /* no copy flags given */
                flags = ~(unsigned)CPSI_FLAG_VERBOSE | flags;
        ret = send_option_arg_callback_request(&options, argc - i, argv + i,
-               com_cpsi_callback, rc4_send_result, rc4c);
+               com_cpsi_callback, sc_send_result, scc);
        if (ret < 0)
-               rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret));
+               sc_send_va_buffer(scc, "%s\n", para_strerror(-ret));
        return ret;
 }
 
@@ -2458,12 +2470,26 @@ static void afs_stat_callback(int fd, const struct osl_object *query)
        pass_buffer_as_shm(buf, strlen(buf), &fd);
 }
 
-int send_afs_status(struct rc4_context *rc4c, int parser_friendly)
+/**
+ * Get the current afs status items from the afs process and send it.
+ *
+ * \param scc The stream cipher context for data encryption.
+ * \param parser_friendly Whether parser-friendly output format should be used.
+ *
+ * As the contents of the afs status items change in time and the command
+ * handler only has a COW version created at fork time, it can not send
+ * up-to-date afs status items directly. Therefore the usual callback mechanism
+ * is used to pass the status items from the afs process to the command handler
+ * via a shared memory area and a pipe.
+ *
+ * \return The return value of the underyling call to \ref send_callback_request().
+ */
+int send_afs_status(struct stream_cipher_context *scc, int parser_friendly)
 {
        struct osl_object query = {.data = &parser_friendly,
                .size = sizeof(parser_friendly)};
 
-       return send_callback_request(afs_stat_callback, &query, rc4_send_result, rc4c);
+       return send_callback_request(afs_stat_callback, &query, sc_send_result, scc);
 }
 
 /* TODO: optionally fix problems by removing offending rows */
@@ -2519,7 +2545,7 @@ static int check_audio_file(struct osl_row *row, void *data)
 void aft_check_callback(int fd, __a_unused const struct osl_object *query)
 {
        struct para_buffer pb = {
-               .max_size = SHMMAX,
+               .max_size = shm_get_shmmax(),
                .private_data = &fd,
                .max_size_handler = pass_buffer_as_shm
        };
@@ -2544,10 +2570,6 @@ static void aft_close(void)
 {
        osl_close_table(audio_file_table, OSL_MARK_CLEAN);
        audio_file_table = NULL;
-       free(status_items);
-       status_items = NULL;
-       free(parser_friendly_status_items);
-       parser_friendly_status_items = NULL;
 }
 
 /**