X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=6b74b0ae499b1c2fc60e0757d5876b7d90c6f693;hp=2a35e8ac09b35bcb7493d6218dd69effe51f23e4;hb=c00d7e25de7006d6f88aafb2b485057377a70324;hpb=5174c20cc16261b499a016c388163b3930d929b8 diff --git a/aft.c b/aft.c index 2a35e8ac..6b74b0ae 100644 --- a/aft.c +++ b/aft.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007 Andre Noll + * Copyright (C) 2007-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -7,19 +7,28 @@ /** \file aft.c Audio file table functions. */ #include /* readdir() */ +#include + +#include #include "para.h" #include "error.h" +#include "crypt.h" #include "string.h" #include #include +#include + #include "afh.h" #include "afs.h" #include "net.h" #include "vss.h" #include "fd.h" #include "ipc.h" +#include "portable_io.h" static struct osl_table *audio_file_table; +static char *status_items; +static char *parser_friendly_status_items; /** The different sorting methods of the ls command. */ enum ls_sorting_method { @@ -58,7 +67,11 @@ enum ls_listing_mode { /** -lv */ LS_MODE_VERBOSE, /** -lm */ - LS_MODE_MBOX + LS_MODE_MBOX, + /** -lc */ + LS_MODE_CHUNKS, + /** -lp */ + LS_MODE_PARSER, }; /** The flags accepted by the ls command. */ @@ -69,6 +82,8 @@ enum ls_flags { LS_FLAG_ADMISSIBLE_ONLY = 2, /** -r */ LS_FLAG_REVERSE = 4, + /** -d */ + LS_FLAG_UNIXDATE = 8, }; /** @@ -94,6 +109,8 @@ struct ls_widths { unsigned short duration_width; /** size of the num played field. */ unsigned short num_played_width; + /** size of the amp field. */ + unsigned short amp_width; }; /** Data passed from the ls command handler to its callback function. */ @@ -138,8 +155,10 @@ enum afsi_offsets { AFSI_LYRICS_ID_OFFSET = 24, /** Storage position of the .audio_format_id field. */ AFSI_AUDIO_FORMAT_ID_OFFSET = 28, - /** 3 bytes reserved space for future usage. */ - AFSI_AUDIO_FORMAT_UNUSED_OFFSET = 29, + /** Storage position of the amplification field. */ + AFSI_AMP_OFFSET = 29, + /** 2 bytes reserved space for future usage. */ + AFSI_AUDIO_FORMAT_UNUSED_OFFSET = 30, /** On-disk storage space needed. */ AFSI_SIZE = 32 }; @@ -163,7 +182,8 @@ void save_afsi(struct afs_info *afsi, struct osl_object *obj) write_u32(buf + AFSI_LYRICS_ID_OFFSET, afsi->lyrics_id); write_u8(buf + AFSI_AUDIO_FORMAT_ID_OFFSET, afsi->audio_format_id); - memset(buf + AFSI_AUDIO_FORMAT_UNUSED_OFFSET, 0, 3); + write_u8(buf + AFSI_AMP_OFFSET, afsi->amp); + memset(buf + AFSI_AUDIO_FORMAT_UNUSED_OFFSET, 0, 2); } /** @@ -188,6 +208,7 @@ int load_afsi(struct afs_info *afsi, struct osl_object *obj) afsi->lyrics_id = read_u32(buf + AFSI_LYRICS_ID_OFFSET); afsi->audio_format_id = read_u8(buf + AFSI_AUDIO_FORMAT_ID_OFFSET); + afsi->amp = read_u8(buf + AFSI_AMP_OFFSET); return 1; } @@ -207,12 +228,27 @@ enum audio_file_table_columns { NUM_AFT_COLUMNS }; +/** + * Compare two osl objects pointing to hash values. + * + * \param obj1 Pointer to the first hash object. + * \param obj2 Pointer to the second hash object. + * + * \return The values required for an osl compare function. + * + * \sa osl_compare_func, uint32_compare(). + */ +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); +} + static struct osl_column_description aft_cols[] = { [AFTCOL_HASH] = { .storage_type = OSL_MAPPED_STORAGE, .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, .name = "hash", - .compare_function = osl_hash_compare, + .compare_function = aft_hash_compare, .data_size = HASH_SIZE }, [AFTCOL_PATH] = { @@ -313,37 +349,62 @@ enum afhi_offsets { AFHI_HEADER_OFFSET_OFFSET = 12, /* Length of the audio file header. Zero means: No header. */ AFHI_HEADER_LEN_OFFSET = 16, - /** Number of channels is stored here. */ - AFHI_CHANNELS_OFFSET = 20, - /** EOF timeout in ms. */ - AFHI_EOF_OFFSET = 21, + /** 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, + /** The seconds part of the chunk time (4 bytes). */ + CHUNK_TV_TV_SEC_OFFSET = 32, + /** The microseconds part of the chunk time (4 bytes). */ + CHUNK_TV_TV_USEC_OFFSET = 36, + /** Number of channels is stored here. (1 byte) */ + AFHI_CHANNELS_OFFSET = 40, /** The tag info position. */ - AFHI_INFO_STRING_OFFSET = 23, + AFHI_INFO_STRING_OFFSET = 41, /** Minimal on-disk size of a valid afhi struct. */ - MIN_AFHI_SIZE = 24 + MIN_AFHI_SIZE = 47, /* at least 6 null bytes for techinfo/tags */ }; static unsigned sizeof_afhi_buf(const struct afh_info *afhi) { if (!afhi) return 0; - return strlen(afhi->info_string) + MIN_AFHI_SIZE; + return MIN_AFHI_SIZE + + strlen(afhi->techinfo) + + strlen(afhi->tags.artist) + + strlen(afhi->tags.title) + + strlen(afhi->tags.year) + + strlen(afhi->tags.album) + + strlen(afhi->tags.comment); } static void save_afhi(struct afh_info *afhi, char *buf) { + char *p; + if (!afhi) return; - write_u32(buf + AFHI_SECONDS_TOTAL_OFFSET, - afhi->seconds_total); + 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_HEADER_LEN_OFFSET, afhi->header_len); write_u8(buf + AFHI_CHANNELS_OFFSET, afhi->channels); - write_u16(buf + AFHI_EOF_OFFSET, tv2ms(&afhi->eof_tv)); - strcpy(buf + AFHI_INFO_STRING_OFFSET, afhi->info_string); /* OK */ - PARA_DEBUG_LOG("last byte written: %p\n", buf + AFHI_INFO_STRING_OFFSET + strlen(afhi->info_string)); + 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 + 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; + /* The sprintf's below are OK as our caller made sure that buf is large enough */ + p += sprintf(p, "%s", afhi->techinfo) + 1; + p += sprintf(p, "%s", afhi->tags.artist) + 1; + p += sprintf(p, "%s", afhi->tags.title) + 1; + p += sprintf(p, "%s", afhi->tags.year) + 1; + p += sprintf(p, "%s", afhi->tags.album) + 1; + sprintf(p, "%s", afhi->tags.comment); } static void load_afhi(const char *buf, struct afh_info *afhi) @@ -354,41 +415,30 @@ static void load_afhi(const char *buf, struct afh_info *afhi) 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); - ms2tv(read_u16(buf + AFHI_EOF_OFFSET), &afhi->eof_tv); - strcpy(afhi->info_string, buf + AFHI_INFO_STRING_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; + afhi->tags.artist = afhi->techinfo + strlen(afhi->techinfo) + 1; + afhi->tags.title = afhi->tags.artist + strlen(afhi->tags.artist) + 1; + afhi->tags.year = afhi->tags.title + strlen(afhi->tags.title) + 1; + afhi->tags.album = afhi->tags.year + strlen(afhi->tags.year) + 1; + afhi->tags.comment = afhi->tags.album + strlen(afhi->tags.album) + 1; } -//#define SIZEOF_CHUNK_TABLE(afhi) (((afhi)->chunks_total + 1) * sizeof(uint32_t)) - -static unsigned sizeof_chunk_info_buf(struct afh_info *afhi) +static unsigned sizeof_chunk_table(struct afh_info *afhi) { if (!afhi) return 0; - return 4 * (afhi->chunks_total + 1) + 20; - + return 4 * (afhi->chunks_total + 1); } -/** The offsets of the data contained in the AFTCOL_CHUNKS column. */ -enum chunk_info_offsets{ - /** The total number of chunks (4 bytes). */ - CHUNKS_TOTAL_OFFSET = 0, - /** The length of the audio file header (4 bytes). */ - HEADER_LEN_OFFSET = 4, - /** The start of the audio file header (4 bytes). */ - HEADER_OFFSET_OFFSET = 8, - /** The seconds part of the chunk time (4 bytes). */ - CHUNK_TV_TV_SEC_OFFSET = 12, - /** The microseconds part of the chunk time (4 bytes). */ - CHUNK_TV_TV_USEC = 16, - /** Chunk table entries start here. */ - CHUNK_TABLE_OFFSET = 20, -}; - static void save_chunk_table(struct afh_info *afhi, char *buf) { int i; - PARA_DEBUG_LOG("%lu chunks\n", afhi->chunks_total); for (i = 0; i <= afhi->chunks_total; i++) write_u32(buf + 4 * i, afhi->chunk_table[i]); } @@ -396,70 +446,39 @@ static void save_chunk_table(struct afh_info *afhi, char *buf) static void load_chunk_table(struct afh_info *afhi, char *buf) { int i; + + afhi->chunk_table = para_malloc(sizeof_chunk_table(afhi)); for (i = 0; i <= afhi->chunks_total; i++) afhi->chunk_table[i] = read_u32(buf + 4 * i); } -/* TODO: audio format handlers could just produce this */ -static void save_chunk_info(struct afh_info *afhi, char *buf) -{ - if (!afhi) - return; - 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 + CHUNK_TV_TV_SEC_OFFSET, afhi->chunk_tv.tv_sec); - write_u32(buf + CHUNK_TV_TV_USEC, afhi->chunk_tv.tv_usec); - save_chunk_table(afhi, buf + CHUNK_TABLE_OFFSET); -} - -static int load_chunk_info(struct osl_object *obj, struct afh_info *afhi) -{ - char *buf = obj->data; - - if (obj->size < CHUNK_TABLE_OFFSET) - return -E_BAD_DATA_SIZE; - - 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); - - if ((afhi->chunks_total + 1) * 4 + CHUNK_TABLE_OFFSET > obj->size) - return -E_BAD_DATA_SIZE; - afhi->chunk_table = para_malloc((afhi->chunks_total + 1) * 4); - load_chunk_table(afhi, buf + CHUNK_TABLE_OFFSET); - return 1; -} - /** * Get the row of the audio file table corresponding to the given path. * * \param path The full path of the audio file. * \param row Result pointer. * - * \return The return value of the underlying call to osl_get_row(). + * \return Standard. */ int aft_get_row_of_path(const char *path, struct osl_row **row) { struct osl_object obj = {.data = (char *)path, .size = strlen(path) + 1}; - return osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row); + return osl(osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row)); } /** * Get the row of the audio file table corresponding to the given hash value. * * \param hash The hash value of the desired audio file. - * \param row resul pointer. + * \param row Result pointer. * - * \return The return value of the underlying call to osl_get_row(). + * \return Standard. */ int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row) { const struct osl_object obj = {.data = hash, .size = HASH_SIZE}; - return osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row); + return osl(osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row)); } /** @@ -468,11 +487,11 @@ int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row) * \param row Pointer to a row in the audio file table. * \param obj Result pointer. * - * \return The return value of the underlying call to osl_get_object(). + * \return Standard. */ int get_afsi_object_of_row(const struct osl_row *row, struct osl_object *obj) { - return osl_get_object(audio_file_table, row, AFTCOL_AFSI, obj); + return osl(osl_get_object(audio_file_table, row, AFTCOL_AFSI, obj)); } /** @@ -541,8 +560,8 @@ int get_afsi_of_path(const char *path, struct afs_info *afsi) int get_audio_file_path_of_row(const struct osl_row *row, char **path) { struct osl_object path_obj; - int ret = osl_get_object(audio_file_table, row, AFTCOL_PATH, - &path_obj); + int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_PATH, + &path_obj)); if (ret < 0) return ret; *path = path_obj.data; @@ -559,9 +578,10 @@ int get_audio_file_path_of_row(const struct osl_row *row, char **path) * * \sa get_hash_of_row(). */ -static int get_hash_object_of_aft_row(const struct osl_row *row, struct osl_object *obj) +static int get_hash_object_of_aft_row(const struct osl_row *row, + struct osl_object *obj) { - return osl_get_object(audio_file_table, row, AFTCOL_HASH, obj); + return osl(osl_get_object(audio_file_table, row, AFTCOL_HASH, obj)); } /** @@ -599,8 +619,8 @@ static int get_hash_of_row(const struct osl_row *row, HASH_TYPE **hash) int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi) { struct osl_object obj; - int ret = osl_get_object(audio_file_table, row, AFTCOL_AFHI, - &obj); + int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_AFHI, + &obj)); if (ret < 0) return ret; load_afhi(obj.data, afhi); @@ -610,10 +630,7 @@ int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi) /* returns shmid on success */ static int save_afd(struct audio_file_data *afd) { - size_t size = sizeof(*afd) - + 4 * (afd->afhi.chunks_total + 1); - - PARA_DEBUG_LOG("size: %zu\n", size); + size_t size = sizeof(*afd) + sizeof_chunk_table(&afd->afhi); int shmid, ret = shm_new(size); void *shm_afd; char *buf; @@ -647,100 +664,11 @@ int load_afd(int shmid, struct audio_file_data *afd) *afd = *(struct audio_file_data *)shm_afd; buf = shm_afd; buf += sizeof(*afd); - afd->afhi.chunk_table = para_malloc((afd->afhi.chunks_total + 1) * 4); load_chunk_table(&afd->afhi, buf); shm_detach(shm_afd); return 1; } -/** - * Mmap the given audio file and update statistics. - * - * \param aft_row Determines the audio file to be opened and updated. - * \param afd Result pointer. - * - * On success, the numplayed field of the audio file selector info is increased - * and the lastplayed time is set to the current time. Finally, the score of - * the audio file is updated. - * - * \return Positive shmid on success, negative on errors. - */ -int open_and_update_audio_file(struct osl_row *aft_row, - struct audio_file_data *afd, long score) -{ - HASH_TYPE *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); - struct afsi_change_event_data aced; - struct osl_object map, chunk_table_obj; - char *path; - - if (ret < 0) - return ret; - ret = get_audio_file_path_of_row(aft_row, &path); - if (ret < 0) - return ret; - ret = get_afsi_object_of_row(aft_row, &afsi_obj); - if (ret < 0) - return ret; - ret = load_afsi(&old_afsi, &afsi_obj); - if (ret < 0) - return ret; - ret = get_afhi_of_row(aft_row, &afd->afhi); - if (ret < 0) - return ret; - ret = osl_open_disk_object(audio_file_table, aft_row, - AFTCOL_CHUNKS, &chunk_table_obj); - if (ret < 0) - return ret; - ret = mmap_full_file(path, O_RDONLY, &map.data, - &map.size, &afd->fd); - if (ret < 0) - goto err; - hash_function(map.data, map.size, file_hash); - ret = hash_compare(file_hash, aft_hash); - para_munmap(map.data, map.size); - if (ret) { - ret = -E_HASH_MISMATCH; - goto err; - } - new_afsi = old_afsi; - new_afsi.num_played++; - new_afsi.last_played = time(NULL); - save_afsi(&new_afsi, &afsi_obj); /* in-place update */ - - ret = load_chunk_info(&chunk_table_obj, &afd->afhi); - if (ret < 0) - goto err; - { - struct ls_data d = { - .afhi = afd->afhi, - .afsi = old_afsi, - .path = path, - .score = score, - .hash = file_hash - }; - struct para_buffer pb = {.buf = NULL}; - ret = make_status_items(&d, &pb); - if (ret < 0) - goto err; - strncpy(afd->verbose_ls_output, pb.buf, VERBOSE_LS_OUTPUT_SIZE); - afd->verbose_ls_output[VERBOSE_LS_OUTPUT_SIZE - 1] = '\0'; - free(pb.buf); - } - aced.aft_row = aft_row; - aced.old_afsi = &old_afsi; - afs_event(AFSI_CHANGE, NULL, &aced); - ret = save_afd(afd); - if (ret < 0) - goto err; - free(afd->afhi.chunk_table); -err: - osl_close_disk_object(&chunk_table_obj); - return ret; -} - static int get_local_time(uint64_t *seconds, char *buf, size_t size, time_t current_time, enum ls_listing_mode lm) { @@ -767,7 +695,7 @@ static int get_local_time(uint64_t *seconds, char *buf, size_t size, #define GET_NUM_DIGITS(x, num) { \ typeof((x)) _tmp = PARA_ABS(x); \ *num = 1; \ - if ((x)) \ + if ((_tmp)) \ while ((_tmp) > 9) { \ (_tmp) /= 10; \ (*num)++; \ @@ -803,53 +731,113 @@ static void get_duration_buf(int seconds, char *buf, struct ls_options *opts) } } -static char *make_attribute_lines(const char *att_bitmap, struct afs_info *afsi) + +static int write_attribute_items(struct para_buffer *b, + const char *att_bitmap, struct afs_info *afsi) { - char *att_text, *att_lines; + char *att_text; + int ret; - get_attribute_text(&afsi->attributes, " ", &att_text); - if (!att_text) - return para_strdup(att_bitmap); - att_lines = make_message("attributes: %s\nattributes_txt: %s", - att_bitmap, att_text); + ret = WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_BITMAP, "%s\n", att_bitmap); + if (ret < 0) + return ret; + 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); free(att_text); - return att_lines; + return ret; } -static char *make_lyrics_lines(struct afs_info *afsi) +static int 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; lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name); - return make_message("lyrics_id: %u\nlyrics_name: %s\n", - afsi->lyrics_id, lyrics_name? lyrics_name : "(none)"); + return WRITE_STATUS_ITEM(b, SI_LYRICS_NAME, "%s\n", lyrics_name? + lyrics_name : "(none)"); } -static char *make_image_lines(struct afs_info *afsi) +static int 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; img_get_name_by_id(afsi->image_id, &image_name); - return make_message("image_id: %u\nimage_name: %s\n", - afsi->image_id, image_name? image_name : "(none)"); + return WRITE_STATUS_ITEM(b, SI_IMAGE_NAME, "%s\n", image_name? + image_name : "(none)"); } -static char *make_filename_lines(const char *path, unsigned flags) +static int write_filename_items(struct para_buffer *b, const char *path, + unsigned flags) { - char *basename, *dirname; - char *ret; + char *val; + int ret; if (!(flags & LS_FLAG_FULL_PATH)) - return make_message("%s: %s\n%s:\n", "basename", path, - "dir"); - basename = para_basename(path), - dirname = para_dirname(path); - ret = make_message("%s: %s\n%s: %s\n%s: %s\n", "path", path, - "dir", dirname, "basename", basename); - free(basename); - free(dirname); + 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; + val = para_basename(path); + ret = WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", val? val : ""); + if (ret < 0) + return ret; + val = para_dirname(path); + ret = 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) +{ + struct osl_object chunk_table_obj; + struct osl_row *aft_row; + int ret, i; + char *buf; + + ret = aft_get_row_of_hash(d->hash, &aft_row); + if (ret < 0) + return ret; + ret = osl_open_disk_object(audio_file_table, aft_row, + AFTCOL_CHUNKS, &chunk_table_obj); + if (ret < 0) + return ret; + ret = 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: + osl_close_disk_object(&chunk_table_obj); + return ret; +} + +static int 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); +} + static int print_list_item(struct ls_data *d, struct ls_options *opts, struct para_buffer *b, time_t current_time) { @@ -857,35 +845,40 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, char att_buf[65]; char last_played_time[30]; char duration_buf[30]; /* nobody has an audio file long enough to overflow this */ - char score_buf[30] = ""; struct afs_info *afsi = &d->afsi; struct afh_info *afhi = &d->afhi; - struct ls_widths *w = &opts->widths; - int have_score = opts->flags & LS_FLAG_ADMISSIBLE_ONLY; char asc_hash[2 * HASH_SIZE + 1]; - char *att_lines, *lyrics_lines, *image_lines, *filename_lines; if (opts->mode == LS_MODE_SHORT) { - para_printf(b, "%s\n", d->path); - return 1; + ret = para_printf(b, "%s\n", d->path); + goto out; + } + if (opts->mode == LS_MODE_CHUNKS) { + ret = print_chunk_table(d, b); + goto out; } get_attribute_bitmap(&afsi->attributes, att_buf); - ret = get_local_time(&afsi->last_played, last_played_time, - sizeof(last_played_time), current_time, opts->mode); - if (ret < 0) - return ret; - get_duration_buf(afhi->seconds_total, duration_buf, opts); - if (have_score) { - if (opts->mode == LS_MODE_LONG) - sprintf(score_buf, "%*li ", w->score_width, d->score); - else - sprintf(score_buf, "%li ", d->score); + if (opts->flags & LS_FLAG_UNIXDATE) + sprintf(last_played_time, "%llu", + (long long unsigned)afsi->last_played); + else { + ret = get_local_time(&afsi->last_played, last_played_time, + sizeof(last_played_time), current_time, opts->mode); + if (ret < 0) + goto out; } - + get_duration_buf(afhi->seconds_total, duration_buf, opts); if (opts->mode == LS_MODE_LONG) { - para_printf(b, - "%s" /* score */ + 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; + } + ret = para_printf(b, "%s " /* attributes */ + "%*u " /* amp */ "%*d " /* image_id */ "%*d " /* lyrics_id */ "%*d " /* bitrate */ @@ -896,8 +889,8 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, "%*d " /* num_played */ "%s " /* last_played */ "%s\n", /* path */ - score_buf, att_buf, + w->amp_width, afsi->amp, w->image_id_width, afsi->image_id, w->lyrics_id_width, afsi->lyrics_id, w->bitrate_width, afhi->bitrate, @@ -909,107 +902,217 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, last_played_time, d->path ); - return 1; + goto out; } - hash_to_asc(d->hash, asc_hash); - att_lines = make_attribute_lines(att_buf, afsi); - lyrics_lines = make_lyrics_lines(afsi); - image_lines = make_image_lines(afsi); - filename_lines = make_filename_lines(d->path, opts->flags); - if (opts->mode == LS_MODE_VERBOSE) { - para_printf(b, - "%s" /* filename stuff */ - "%s%s%s" /* score */ - "%s\n" /* attributes */ - "hash: %s\n" - "%s" /* image id, image name */ - "%s" /* lyrics */ - "bitrate: %dkbit/s\n" - "format: %s\n" - "frequency: %dHz\n" - "channels: %d\n" - "duration: %s\n" - "seconds_total: %lu\n" - "num_played: %d\n" - "last_played: %s\n" - "tag info: %s\n", - filename_lines, - have_score? "score: " : "", score_buf, - have_score? "\n" : "", - att_lines, - asc_hash, - image_lines, - lyrics_lines, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afhi->seconds_total, - afsi->num_played, - last_played_time, - afhi->info_string - ); - } else { /* mbox mode */ - struct osl_object lyrics_def; - lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def); - para_printf(b, + if (opts->mode == LS_MODE_MBOX) { + const char *bn = para_basename(d->path); + ret = para_printf(b, "From foo@localhost %s\n" "Received: from\nTo: bar\nFrom: a\n" - "Subject: %s\n\n" /* path */ - "%s%s%s" /* score */ - "%s\n" /* attributes */ - "hash: %s\n" - "%s\n" /* image id, image name */ - "lyrics_id: %s\n" - "bitrate: %dkbit/s\n" - "format: %s\n" - "frequency: %dHz\n" - "channels: %d\n" - "duration: %s\n" - "num_played: %d\n" - "tag info: %s\n" - "%s%s\n", + "Subject: %s\n\n", last_played_time, - d->path, - have_score? "score: " : "", score_buf, - have_score? "\n" : "", - att_lines, - asc_hash, - image_lines, - lyrics_lines, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afsi->num_played, - afhi->info_string, - lyrics_def.data? "Lyrics:\n~~~~~~~\n" : "", - lyrics_def.data? (char *)lyrics_def.data : "" - ); - if (lyrics_def.data) - osl_close_disk_object(lyrics_def.data); + bn? bn : "?"); + if (ret < 0) + goto out; } - free(att_lines); - free(lyrics_lines); - free(image_lines); - free(filename_lines); - return 1; + 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; + 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; + 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", + 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; + 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", + (char *)lyrics_def.data); + osl_close_disk_object(&lyrics_def); + } + } +out: + return ret; } -int make_status_items(struct ls_data *d, struct para_buffer *pb) +static int make_status_items(struct audio_file_data *afd, + struct afs_info *afsi, char *path, long score, + HASH_TYPE *hash) { + struct ls_data d = { + .afhi = afd->afhi, + .afsi = *afsi, + .path = path, + .score = score, + .hash = hash + }; struct ls_options opts = { .flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY, .mode = LS_MODE_VERBOSE, }; + struct para_buffer pb = {.max_size = SHMMAX - 1}; time_t current_time; + int ret; time(¤t_time); - return print_list_item(d, &opts, pb, current_time); + ret = print_list_item(&d, &opts, &pb, current_time); + if (ret < 0) + return ret; + free(status_items); + status_items = pb.buf; + memset(&pb, 0, sizeof(pb)); + pb.max_size = SHMMAX - 1; + pb.flags = PBF_SIZE_PREFIX; + ret = print_list_item(&d, &opts, &pb, current_time); + if (ret < 0) { + free(status_items); + status_items = NULL; + return ret; + } + free(parser_friendly_status_items); + parser_friendly_status_items = pb.buf; + return 1; } +/** + * Mmap the given audio file and update statistics. + * + * \param aft_row Determines the audio file to be opened and updated. + * \param score The score of the audio file. + * \param afd Result pointer. + * + * On success, the numplayed field of the audio file selector info is increased + * and the lastplayed time is set to the current time. Finally, the score of + * the audio file is updated. + * + * \return Positive shmid on success, negative on errors. + */ +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]; + struct osl_object afsi_obj; + struct afs_info old_afsi, new_afsi; + int ret = get_hash_of_row(aft_row, &aft_hash); + struct afsi_change_event_data aced; + struct osl_object map, chunk_table_obj; + char *path; + + if (ret < 0) + return ret; + ret = get_audio_file_path_of_row(aft_row, &path); + if (ret < 0) + return ret; + ret = get_afsi_object_of_row(aft_row, &afsi_obj); + if (ret < 0) + return ret; + ret = load_afsi(&old_afsi, &afsi_obj); + if (ret < 0) + return ret; + ret = get_afhi_of_row(aft_row, &afd->afhi); + if (ret < 0) + return ret; + afd->afhi.chunk_table = NULL; + ret = osl_open_disk_object(audio_file_table, aft_row, + AFTCOL_CHUNKS, &chunk_table_obj); + if (ret < 0) + goto err; + ret = mmap_full_file(path, O_RDONLY, &map.data, + &map.size, &afd->fd); + if (ret < 0) + goto err; + hash_function(map.data, map.size, file_hash); + ret = hash_compare(file_hash, aft_hash); + para_munmap(map.data, map.size); + if (ret) { + ret = -E_HASH_MISMATCH; + goto err; + } + new_afsi = old_afsi; + new_afsi.num_played++; + new_afsi.last_played = time(NULL); + save_afsi(&new_afsi, &afsi_obj); /* in-place update */ + + load_chunk_table(&afd->afhi, chunk_table_obj.data); + ret = make_status_items(afd, &old_afsi, path, score, file_hash); + if (ret < 0) + goto err; + aced.aft_row = aft_row; + aced.old_afsi = &old_afsi; + afs_event(AFSI_CHANGE, NULL, &aced); + ret = save_afd(afd); +err: + free(afd->afhi.chunk_table); + osl_close_disk_object(&chunk_table_obj); + return ret; +} static int ls_audio_format_compare(const void *a, const void *b) { @@ -1184,7 +1287,7 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) d->path = path; ret = get_hash_of_row(aft_row, &d->hash); if (ret < 0) - return ret; + goto err; w = &options->widths; GET_NUM_DIGITS(d->afsi.image_id, &num_digits); w->image_id_width = PARA_MAX(w->image_id_width, num_digits); @@ -1197,8 +1300,10 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) GET_NUM_DIGITS(d->afsi.num_played, &num_digits); w->num_played_width = PARA_MAX(w->num_played_width, num_digits); /* get the number of chars to print this amount of time */ - tmp = get_duration_width(d->afhi.seconds_total); - w->duration_width = PARA_MAX(w->duration_width, tmp); + num_digits = get_duration_width(d->afhi.seconds_total); + w->duration_width = PARA_MAX(w->duration_width, num_digits); + GET_NUM_DIGITS(d->afsi.amp, &num_digits); + w->amp_width = PARA_MAX(w->amp_width, num_digits); if (options->flags & LS_FLAG_ADMISSIBLE_ONLY) { GET_NUM_DIGITS(score, &num_digits); num_digits++; /* add one for the sign (space or "-") */ @@ -1206,18 +1311,20 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) d->score = score; } return 1; +err: + return ret; } -static int com_ls_callback(const struct osl_object *query, - struct osl_object *ls_output) +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 = {.buf = NULL, .size = 0}; + struct para_buffer b = {.max_size = 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; time_t current_time; - if (opts->num_patterns) { opts->patterns = para_malloc(opts->num_patterns * sizeof(char *)); for (i = 0, p = pattern_start; i < opts->num_patterns; i++) { @@ -1229,11 +1336,10 @@ static int com_ls_callback(const struct osl_object *query, if (opts->flags & LS_FLAG_ADMISSIBLE_ONLY) ret = admissible_file_loop(opts, prepare_ls_row); else - ret = osl_rbtree_loop(audio_file_table, AFTCOL_PATH, opts, - prepare_ls_row); + ret = osl(osl_rbtree_loop(audio_file_table, AFTCOL_PATH, opts, + prepare_ls_row)); if (ret < 0) goto out; - ret = opts->num_patterns? -E_NO_MATCH : 0; if (!opts->num_matching_paths) goto out; ret = sort_matching_paths(opts); @@ -1244,36 +1350,34 @@ static int com_ls_callback(const struct osl_object *query, for (i = opts->num_matching_paths - 1; i >= 0; i--) { ret = print_list_item(opts->data_ptr[i], opts, &b, current_time); if (ret < 0) - break; + goto out; } else for (i = 0; i < opts->num_matching_paths; i++) { ret = print_list_item(opts->data_ptr[i], opts, &b, current_time); if (ret < 0) - break; + goto out; } - ret = 1; out: - ls_output->data = b.buf; - ls_output->size = b.size; + if (b.offset) + pass_buffer_as_shm(b.buf, b.offset, &fd); + free(b.buf); free(opts->data); free(opts->data_ptr); free(opts->patterns); - return ret; } /* * TODO: flags -h (sort by hash) */ -int com_ls(int fd, int argc, char * const * const argv) +int com_ls(struct rc4_context *rc4c, int argc, char * const * const argv) { int i, ret; unsigned flags = 0; enum ls_sorting_method sort = LS_SORT_BY_PATH; enum ls_listing_mode mode = LS_MODE_SHORT; struct ls_options opts = {.patterns = NULL}; - struct osl_object query = {.data = &opts, .size = sizeof(opts)}, - ls_output; + struct osl_object query = {.data = &opts, .size = sizeof(opts)}; for (i = 1; i < argc; i++) { const char *arg = argv[i]; @@ -1303,6 +1407,12 @@ int com_ls(int fd, int argc, char * const * const argv) case 'm': mode = LS_MODE_MBOX; continue; + case 'c': + mode = LS_MODE_CHUNKS; + continue; + case 'p': + mode = LS_MODE_PARSER; + continue; default: return -E_AFT_SYNTAX; } @@ -1319,6 +1429,10 @@ int com_ls(int fd, int argc, char * const * const argv) flags |= LS_FLAG_REVERSE; continue; } + if (!strcmp(arg, "-d")) { + flags |= LS_FLAG_UNIXDATE; + continue; + } if (!strncmp(arg, "-s", 2)) { if (!*(arg + 2) || *(arg + 3)) return -E_AFT_SYNTAX; @@ -1368,11 +1482,7 @@ int com_ls(int fd, 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, &ls_output); - if (ret > 0) { - ret = send_buffer(fd, (char *)ls_output.data); - free(ls_output.data); - } + argv + i, com_ls_callback, rc4_send_result, rc4c); return ret; } @@ -1382,12 +1492,12 @@ int com_ls(int fd, int argc, char * const * const argv) * \param private_data An arbitrary data pointer, passed to \a func. * \param func The custom function to be called. * - * \return The return value of the underlying call to osl_rbtree_loop(). + * \return Standard. */ int audio_file_loop(void *private_data, osl_rbtree_loop_func *func) { - return osl_rbtree_loop(audio_file_table, AFTCOL_HASH, private_data, - func); + return osl(osl_rbtree_loop(audio_file_table, AFTCOL_HASH, private_data, + func)); } static struct osl_row *find_hash_sister(HASH_TYPE *hash) @@ -1399,88 +1509,111 @@ static struct osl_row *find_hash_sister(HASH_TYPE *hash) return row; } -enum aft_row_offsets { - AFTROW_AFHI_OFFSET_POS = 0, - AFTROW_CHUNKS_OFFSET_POS = 2, - AFTROW_AUDIO_FORMAT_OFFSET = 4, - AFTROW_FLAGS_OFFSET = 5, - AFTROW_HASH_OFFSET = 9, - AFTROW_PATH_OFFSET = (AFTROW_HASH_OFFSET + HASH_SIZE), +/** The format of the data stored by save_audio_file_data(). */ +enum com_add_buffer_offsets { + /** afhi (if present) starts here. */ + CAB_AFHI_OFFSET_POS = 0, + /** Start of the chunk table (if present). */ + CAB_CHUNKS_OFFSET_POS = 2, + /** Audio format id. */ + CAB_AUDIO_FORMAT_OFFSET = 4, + /** Flags given to the add command. */ + CAB_FLAGS_OFFSET = 5, + /** The hash of the audio file being added. */ + CAB_HASH_OFFSET = 9, + /** Start of the path of the audio file. */ + CAB_PATH_OFFSET = (CAB_HASH_OFFSET + HASH_SIZE), }; -/* never save the afsi, as the server knows it too. Note that afhi might be NULL. - * In this case, afhi won't be stored in the buffer */ -static void save_audio_file_info(HASH_TYPE *hash, const char *path, +/* + * Store the given data to a single buffer. Doesn't need the audio file selector + * info struct as the server knows it as well. + * + * 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, struct afh_info *afhi, uint32_t flags, uint8_t audio_format_num, struct osl_object *obj) { size_t path_len = strlen(path) + 1; size_t afhi_size = sizeof_afhi_buf(afhi); - size_t size = AFTROW_PATH_OFFSET + path_len + afhi_size - + sizeof_chunk_info_buf(afhi); + size_t size = CAB_PATH_OFFSET + path_len + afhi_size + + sizeof_chunk_table(afhi); char *buf = para_malloc(size); uint16_t pos; - write_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET, audio_format_num); - write_u32(buf + AFTROW_FLAGS_OFFSET, flags); + write_u8(buf + CAB_AUDIO_FORMAT_OFFSET, audio_format_num); + write_u32(buf + CAB_FLAGS_OFFSET, flags); - memcpy(buf + AFTROW_HASH_OFFSET, hash, HASH_SIZE); - strcpy(buf + AFTROW_PATH_OFFSET, path); + memcpy(buf + CAB_HASH_OFFSET, hash, HASH_SIZE); + strcpy(buf + CAB_PATH_OFFSET, path); - pos = AFTROW_PATH_OFFSET + path_len; + pos = CAB_PATH_OFFSET + path_len; PARA_DEBUG_LOG("size: %zu, afhi starts at %d\n", size, pos); PARA_DEBUG_LOG("last afhi byte: %p, pos %zu\n", buf + pos + afhi_size - 1, pos + afhi_size - 1); - write_u16(buf + AFTROW_AFHI_OFFSET_POS, pos); + write_u16(buf + CAB_AFHI_OFFSET_POS, pos); save_afhi(afhi, buf + pos); pos += afhi_size; PARA_DEBUG_LOG("size: %zu, chunks start at %d\n", size, pos); - write_u16(buf + AFTROW_CHUNKS_OFFSET_POS, pos); - save_chunk_info(afhi, buf + pos); + write_u16(buf + CAB_CHUNKS_OFFSET_POS, pos); + if (afhi) + save_chunk_table(afhi, buf + pos); PARA_DEBUG_LOG("last byte in buf: %p\n", buf + size - 1); obj->data = buf; obj->size = size; } /* -input: + +Overview of the add command. + +Input: What was passed to the callback by the command handler. ~~~~~~ -HS: hash sister -PB: path brother -F: force flag given +HS: Hash sister. Whether an audio file with identical hash + already exists in the osl database. + +PB: Path brother. Whether a file with the given path exists + in the table. + +F: Force flag given. Whether add was called with -f. -output: +output: Action performed by the callback. ~~~~~~~ -AFHI: whether afhi and chunk table are computed and sent -ACTION: table modifications to be performed - -+---+----+-----+------+---------------------------------------------------+ -| HS | PB | F | AFHI | ACTION -+---+----+-----+------+---------------------------------------------------+ -| Y | Y | Y | Y | if HS != PB: remove PB. HS: force afhi update, -| | update path, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| Y | Y | N | N | if HS == PB: do not send callback request at all. -| | otherwise: remove PB, HS: update path, keep afhi, -| | afsi. -+---+----+-----+------+---------------------------------------------------+ -| Y | N | Y | Y | (rename) force afhi update of HS, update path of -| | HS, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| Y | N | N | N | (file rename) update path of HS, keep afsi, afhi -+---+----+-----+------+---------------------------------------------------+ -| N | Y | Y | Y | (file change) update afhi, hash, of PB, keep afsi -| | (force has no effect) -+---+----+-----+------+---------------------------------------------------+ -| N | Y | N | Y | (file change) update afhi, hash of PB, keep afsi -+---+----+-----+------+---------------------------------------------------+ -| N | N | Y | Y | (new file) create new entry (force has no effect) -+---+----+-----+------+---------------------------------------------------+ -| N | N | N | Y | (new file) create new entry -+---+----+-----+------+---------------------------------------------------+ - -afhi <=> force or no HS +AFHI: Whether afhi and chunk table are computed and sent. +ACTION: Table modifications to be done by the callback. + ++----+----+---+------+---------------------------------------------------+ +| HS | PB | F | AFHI | ACTION ++----+----+---+------+---------------------------------------------------+ +| Y | Y | Y | Y | if HS != PB: remove PB. HS: force afhi update, +| | update path, keep afsi ++----+----+---+------+---------------------------------------------------+ +| Y | Y | N | N | if HS == PB: do not send callback request at all. +| | otherwise: remove PB, HS: update path, keep afhi, +| | afsi. ++----+----+---+------+---------------------------------------------------+ +| Y | N | Y | Y | (rename) force afhi update of HS, update path of +| | HS, keep afsi ++----+----+---+------+---------------------------------------------------+ +| Y | N | N | N | (file rename) update path of HS, keep afsi, afhi ++----+----+---+------+---------------------------------------------------+ +| N | Y | Y | Y | (file change) update afhi, hash, of PB, keep afsi +| | (force has no effect) ++----+----+---+------+---------------------------------------------------+ +| N | Y | N | Y | (file change) update afhi, hash of PB, keep afsi ++----+----+---+------+---------------------------------------------------+ +| N | N | Y | Y | (new file) create new entry (force has no effect) ++----+----+---+------+---------------------------------------------------+ +| N | N | N | Y | (new file) create new entry ++----+----+---+------+---------------------------------------------------+ + +Notes: + + afhi <=> force or no HS + F => AFHI */ @@ -1496,8 +1629,7 @@ enum com_add_flags { ADD_FLAG_ALL = 8, }; -static int com_add_callback(const struct osl_object *query, - struct osl_object *result) +static void com_add_callback(int fd, const struct osl_object *query) { char *buf = query->data, *path; struct osl_row *pb, *aft_row; @@ -1507,50 +1639,58 @@ static int com_add_callback(const struct osl_object *query, char asc[2 * HASH_SIZE + 1]; int ret; char afsi_buf[AFSI_SIZE]; - uint32_t flags = read_u32(buf + AFTROW_FLAGS_OFFSET); + uint32_t flags = read_u32(buf + CAB_FLAGS_OFFSET); struct afs_info default_afsi = {.last_played = 0}; - struct para_buffer msg = {.buf = NULL}; + struct para_buffer msg = {.max_size = SHMMAX, + .max_size_handler = pass_buffer_as_shm, .private_data = &fd}; + uint16_t afhi_offset, chunks_offset; - hash = (HASH_TYPE *)buf + AFTROW_HASH_OFFSET; + hash = (HASH_TYPE *)buf + CAB_HASH_OFFSET; hash_to_asc(hash, asc);; - objs[AFTCOL_HASH].data = buf + AFTROW_HASH_OFFSET; + objs[AFTCOL_HASH].data = buf + CAB_HASH_OFFSET; objs[AFTCOL_HASH].size = HASH_SIZE; - path = buf + AFTROW_PATH_OFFSET; + path = buf + CAB_PATH_OFFSET; objs[AFTCOL_PATH].data = path; 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 != -E_RB_KEY_NOT_FOUND) - return ret; + if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) + goto out; if (hs && pb && hs == pb && !(flags & ADD_FLAG_FORCE)) { if (flags & ADD_FLAG_VERBOSE) - para_printf(&msg, "ignoring duplicate\n"); - ret = 1; + ret = para_printf(&msg, "ignoring duplicate\n"); + else + ret = 1; goto out; } if (hs && hs != pb) { struct osl_object obj; if (pb) { /* hs trumps pb, remove pb */ - if (flags & ADD_FLAG_VERBOSE) - para_printf(&msg, "removing path brother\n"); - ret = osl_del_row(audio_file_table, pb); + if (flags & ADD_FLAG_VERBOSE) { + ret = para_printf(&msg, "removing path brother\n"); + if (ret < 0) + goto out; + } + ret = osl(osl_del_row(audio_file_table, pb)); if (ret < 0) goto out; pb = NULL; } /* file rename, update hs' path */ if (flags & ADD_FLAG_VERBOSE) { - ret = osl_get_object(audio_file_table, hs, - AFTCOL_PATH, &obj); + ret = osl(osl_get_object(audio_file_table, hs, + 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(&msg, "renamed from %s\n", (char *)obj.data); } - ret = osl_update_object(audio_file_table, hs, AFTCOL_PATH, - &objs[AFTCOL_PATH]); + 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); @@ -1558,8 +1698,8 @@ static int com_add_callback(const struct osl_object *query, goto out; } /* no hs or force mode, child must have sent afhi */ - uint16_t afhi_offset = read_u16(buf + AFTROW_AFHI_OFFSET_POS); - uint16_t chunks_offset = read_u16(buf + AFTROW_CHUNKS_OFFSET_POS); + afhi_offset = read_u16(buf + CAB_AFHI_OFFSET_POS); + chunks_offset = read_u16(buf + CAB_CHUNKS_OFFSET_POS); objs[AFTCOL_AFHI].data = buf + afhi_offset; objs[AFTCOL_AFHI].size = chunks_offset - afhi_offset; @@ -1575,9 +1715,12 @@ static int com_add_callback(const struct osl_object *query, if (ret < 0) goto out; hash_to_asc(old_hash, old_asc); - if (flags & ADD_FLAG_VERBOSE) - para_printf(&msg, "file change: %s -> %s\n", + if (flags & ADD_FLAG_VERBOSE) { + ret = para_printf(&msg, "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) @@ -1586,176 +1729,175 @@ static int com_add_callback(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) - para_printf(&msg, "updating afhi and chunk table\n"); - ret = osl_update_object(audio_file_table, row, AFTCOL_AFHI, - &objs[AFTCOL_AFHI]); + if (flags & ADD_FLAG_VERBOSE) { + ret = para_printf(&msg, "updating afhi and chunk table\n"); + if (ret < 0) + goto out; + } + ret = osl(osl_update_object(audio_file_table, row, AFTCOL_AFHI, + &objs[AFTCOL_AFHI])); if (ret < 0) goto out; - ret = osl_update_object(audio_file_table, row, AFTCOL_CHUNKS, - &objs[AFTCOL_CHUNKS]); + ret = osl(osl_update_object(audio_file_table, row, AFTCOL_CHUNKS, + &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) - para_printf(&msg, "new file\n"); + if (flags & ADD_FLAG_VERBOSE) { + ret = para_printf(&msg, "new file\n"); + if (ret < 0) + goto out; + } default_afsi.last_played = time(NULL) - 365 * 24 * 60 * 60; - default_afsi.audio_format_id = read_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET); + default_afsi.audio_format_id = read_u8(buf + CAB_AUDIO_FORMAT_OFFSET); objs[AFTCOL_AFSI].data = &afsi_buf; objs[AFTCOL_AFSI].size = AFSI_SIZE; save_afsi(&default_afsi, &objs[AFTCOL_AFSI]); - ret = osl_add_and_get_row(audio_file_table, objs, &aft_row); + ret = osl(osl_add_and_get_row(audio_file_table, objs, &aft_row)); afs_event(AUDIO_FILE_ADD, &msg, aft_row); out: if (ret < 0) - para_printf(&msg, "%s\n", PARA_STRERROR(-ret)); - if (!msg.buf) - return 0; - result->data = msg.buf; - result->size = msg.size; - return 1; + para_printf(&msg, "%s\n", para_strerror(-ret)); + if (msg.offset) + pass_buffer_as_shm(msg.buf, msg.offset, &fd); + free(msg.buf); } /** Used by com_add(). */ struct private_add_data { - /** The socket file descriptor. */ - int fd; + /** The socket file descriptor, including rc4 keys. */ + struct rc4_context *rc4c; /** The given add flags. */ uint32_t flags; }; -static int path_brother_callback(const struct osl_object *query, - struct osl_object *result) +static void path_brother_callback(int fd, const struct osl_object *query) { char *path = query->data; struct osl_row *path_brother; int ret = aft_get_row_of_path(path, &path_brother); if (ret < 0) - return ret; - result->data = para_malloc(sizeof(path_brother)); - result->size = sizeof(path_brother); - *(struct osl_row **)(result->data) = path_brother; - return 1; + return; + pass_buffer_as_shm((char *)&path_brother, sizeof(path_brother), &fd); } -static int hash_sister_callback(const struct osl_object *query, - struct osl_object *result) +static void hash_sister_callback(int fd, const struct osl_object *query) { HASH_TYPE *hash = query->data; struct osl_row *hash_sister; hash_sister = find_hash_sister(hash); if (!hash_sister) - return -E_RB_KEY_NOT_FOUND; - result->data = para_malloc(sizeof(hash_sister)); - result->size = sizeof(hash_sister); - *(struct osl_row **)(result->data) = hash_sister; + return; + pass_buffer_as_shm((char *)&hash_sister, sizeof(hash_sister), &fd); +} + +static int get_row_pointer_from_result(struct osl_object *result, void *private) +{ + struct osl_row **row = private; + *row = result->data; return 1; } -static int add_one_audio_file(const char *path, const void *private_data) +static int add_one_audio_file(const char *path, void *private_data) { - int ret, ret2; + int ret, send_ret = 1, fd; uint8_t format_num = -1; - const struct private_add_data *pad = private_data; + struct private_add_data *pad = 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, result = {.data = NULL}; + struct osl_object map, obj = {.data = NULL}, query; HASH_TYPE hash[HASH_SIZE]; - afhi.header_offset = 0; - afhi.header_len = 0; ret = guess_audio_format(path); if (ret < 0 && !(pad->flags & ADD_FLAG_ALL)) goto out_free; query.data = (char *)path; query.size = strlen(path) + 1; - ret = send_callback_request(path_brother_callback, &query, &result); - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) + ret = send_callback_request(path_brother_callback, &query, + get_row_pointer_from_result, &pb); + if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) goto out_free; - if (ret >= 0) { - pb = *(struct osl_row **)result.data; - free(result.data); - } ret = 1; if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */ if (pad->flags & ADD_FLAG_VERBOSE) - ret = send_va_buffer(pad->fd, "lazy-ignore: %s\n", path); + send_ret = rc4_send_va_buffer(pad->rc4c, + "lazy-ignore: %s\n", path); goto out_free; } /* We still want to add this file. Compute its hash. */ - ret = mmap_full_file(path, O_RDONLY, &map.data, &map.size, NULL); + ret = mmap_full_file(path, O_RDONLY, &map.data, &map.size, &fd); if (ret < 0) goto out_free; hash_function(map.data, map.size, hash); - /* Check whether database contains file with the same hash. */ + /* Check whether the database contains a file with the same hash. */ query.data = hash; query.size = HASH_SIZE; - ret = send_callback_request(hash_sister_callback, &query, &result); - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) - goto out_free; - if (ret >= 0) { - hs = *(struct osl_row **)result.data; - free(result.data); - } + ret = send_callback_request(hash_sister_callback, &query, + get_row_pointer_from_result, &hs); + if (ret < 0) + goto out_unmap; /* Return success if we already know this file. */ ret = 1; - if (pb && hs && hs == pb && (!(pad->flags & ADD_FLAG_FORCE))) { + if (pb && hs && hs == pb && !(pad->flags & ADD_FLAG_FORCE)) { if (pad->flags & ADD_FLAG_VERBOSE) - ret = send_va_buffer(pad->fd, + send_ret = rc4_send_va_buffer(pad->rc4c, "%s exists, not forcing update\n", path); goto out_unmap; } /* - * we won't recalculate the audio format info and the chunk table if - * there is a hash sister unless in FORCE mode. + * We won't recalculate the audio format info and the chunk table if + * there is a hash sister and FORCE was not given. */ if (!hs || (pad->flags & ADD_FLAG_FORCE)) { - ret = compute_afhi(path, map.data, map.size, &afhi); + ret = compute_afhi(path, map.data, map.size, fd, &afhi); if (ret < 0) goto out_unmap; format_num = ret; afhi_ptr = &afhi; } + munmap(map.data, map.size); + close(fd); if (pad->flags & ADD_FLAG_VERBOSE) { - ret = send_va_buffer(pad->fd, "adding %s\n", path); - if (ret < 0) - goto out_unmap; + send_ret = rc4_send_va_buffer(pad->rc4c, "adding %s\n", path); + if (send_ret < 0) + goto out_free; } - munmap(map.data, map.size); - save_audio_file_info(hash, path, afhi_ptr, pad->flags, format_num, &obj); + 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, &result); - if (ret > 0) { - ret2 = send_va_buffer(pad->fd, "%s", (char *)result.data); - free(result.data); - if (ret >= 0 && ret2 < 0) - ret = ret2; - } + ret = send_callback_request(com_add_callback, &obj, rc4_send_result, pad->rc4c); goto out_free; out_unmap: + close(fd); munmap(map.data, map.size); out_free: - if (ret < 0 && ret != -E_SEND) - send_va_buffer(pad->fd, "failed to add %s (%s)\n", path, - PARA_STRERROR(-ret)); + if (ret < 0 && send_ret >= 0) + send_ret = rc4_send_va_buffer(pad->rc4c, + "failed to add %s (%s)\n", path, para_strerror(-ret)); free(obj.data); - if (afhi_ptr) + if (afhi_ptr) { free(afhi_ptr->chunk_table); - /* it's not an error if not all files could be added */ - return ret == -E_SEND? ret : 1; + free(afhi_ptr->techinfo); + free(afhi_ptr->tags.artist); + free(afhi_ptr->tags.title); + free(afhi_ptr->tags.year); + free(afhi_ptr->tags.album); + free(afhi_ptr->tags.comment); + } + /* Stop adding files only on send errors. */ + return send_ret; } -int com_add(int fd, int argc, char * const * const argv) +int com_add(struct rc4_context *rc4c, int argc, char * const * const argv) { int i, ret; - struct private_add_data pad = {.fd = fd, .flags = 0}; + struct private_add_data pad = {.rc4c = rc4c, .flags = 0}; struct stat statbuf; for (i = 1; i < argc; i++) { @@ -1789,14 +1931,15 @@ int com_add(int fd, int argc, char * const * const argv) char *path; ret = verify_path(argv[i], &path); if (ret < 0) { - ret = send_va_buffer(fd, "%s: %s\n", argv[i], PARA_STRERROR(-ret)); + ret = rc4_send_va_buffer(rc4c, "%s: %s\n", argv[i], + para_strerror(-ret)); if (ret < 0) return ret; continue; } ret = stat(path, &statbuf); if (ret < 0) { - ret = send_va_buffer(fd, "failed to stat %s (%s)\n", path, + ret = rc4_send_va_buffer(rc4c, "failed to stat %s (%s)\n", path, strerror(errno)); free(path); if (ret < 0) @@ -1809,7 +1952,7 @@ int com_add(int fd, int argc, char * const * const argv) else ret = add_one_audio_file(path, &pad); if (ret < 0) { - send_va_buffer(fd, "%s: %s\n", path, PARA_STRERROR(-ret)); + rc4_send_va_buffer(rc4c, "%s: %s\n", path, para_strerror(-ret)); free(path); return ret; } @@ -1837,11 +1980,13 @@ struct com_touch_options { int32_t num_played; /** New last played count. */ int64_t last_played; - /** new lyrics id. */ + /** New lyrics id. */ int32_t lyrics_id; - /** new image id. */ + /** New image id. */ int32_t image_id; - /** command line flags (see \ref touch_flags). */ + /** New amplification value. */ + int32_t amp; + /** Command line flags (see \ref touch_flags). */ unsigned flags; }; @@ -1851,6 +1996,8 @@ struct touch_action_data { struct com_touch_options *cto; /** Message buffer. */ struct para_buffer pb; + /** How many audio files matched the given pattern. */ + unsigned num_matches; }; static int touch_audio_file(__a_unused struct osl_table *table, @@ -1860,30 +2007,32 @@ static int touch_audio_file(__a_unused struct osl_table *table, 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->lyrics_id < 0 && tad->cto->image_id < 0 && tad->cto->amp < 0; struct afsi_change_event_data aced; ret = get_afsi_object_of_row(row, &obj); - if (ret < 0) { - para_printf(&tad->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); - return 1; - } + if (ret < 0) + return para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret)); ret = load_afsi(&old_afsi, &obj); - if (ret < 0) { - para_printf(&tad->pb, "%s: %s\n", name, PARA_STRERROR(-ret)); - return 1; - } + if (ret < 0) + return para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-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) - para_printf(&tad->pb, "%s: num_played = %u, " + if (tad->cto->flags & TOUCH_FLAG_VERBOSE) { + ret = para_printf(&tad->pb, "%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) - para_printf(&tad->pb, "touching %s\n", name); + 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) @@ -1892,7 +2041,10 @@ static int touch_audio_file(__a_unused struct osl_table *table, 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; } + tad->num_matches++; save_afsi(&new_afsi, &obj); /* in-place update */ aced.aft_row = row; aced.old_afsi = &old_afsi; @@ -1900,11 +2052,16 @@ static int touch_audio_file(__a_unused struct osl_table *table, return 1; } -static int com_touch_callback(const struct osl_object *query, - struct osl_object *result) +static void com_touch_callback(int fd, const struct osl_object *query) { - struct touch_action_data tad = {.cto = query->data}; - int ret; + struct touch_action_data tad = {.cto = query->data, + .pb = { + .max_size = SHMMAX, + .private_data = &fd, + .max_size_handler = pass_buffer_as_shm + } + }; + int ret, ret2 = 0; struct pattern_match_data pmd = { .table = audio_file_table, .loop_col_num = AFTCOL_HASH, @@ -1918,25 +2075,25 @@ static int com_touch_callback(const struct osl_object *query, pmd.fnmatch_flags |= FNM_PATHNAME; ret = for_each_matching_row(&pmd); if (ret < 0) - para_printf(&tad.pb, "%s\n", PARA_STRERROR(-ret)); - if (tad.pb.buf) { - result->data = tad.pb.buf; - result->size = tad.pb.size; - return 1; - } - return ret < 0? ret : 0; + ret2 = para_printf(&tad.pb, "%s\n", para_strerror(-ret)); + else + if (!tad.num_matches) + ret2 = para_printf(&tad.pb, "no matches\n"); + if (ret2 >= 0 && tad.pb.offset) + pass_buffer_as_shm(tad.pb.buf, tad.pb.offset, &fd); + free(tad.pb.buf); } -int com_touch(int fd, int argc, char * const * const argv) +int com_touch(struct rc4_context *rc4c, int argc, char * const * const argv) { struct com_touch_options cto = { .num_played = -1, .last_played = -1, .lyrics_id = -1, - .image_id = -1 + .image_id = -1, + .amp = -1, }; - struct osl_object query = {.data = &cto, .size = sizeof(cto)}, - result; + struct osl_object query = {.data = &cto, .size = sizeof(cto)}; int i, ret; @@ -1948,28 +2105,38 @@ int com_touch(int fd, int argc, char * const * const argv) i++; break; } - if (!strncmp(arg, "-n", 2)) { - ret = para_atoi32(arg + 2, &cto.num_played); + if (!strncmp(arg, "-n=", 3)) { + ret = para_atoi32(arg + 3, &cto.num_played); if (ret < 0) return ret; continue; } - if (!strncmp(arg, "-l", 2)) { - ret = para_atoi64(arg + 2, &cto.last_played); + if (!strncmp(arg, "-l=", 3)) { + ret = para_atoi64(arg + 3, &cto.last_played); + if (ret < 0) + return ret; + continue; + } + if (!strncmp(arg, "-y=", 3)) { + ret = para_atoi32(arg + 3, &cto.lyrics_id); if (ret < 0) return ret; continue; } - if (!strncmp(arg, "-y", 2)) { - ret = para_atoi32(arg + 2, &cto.lyrics_id); + if (!strncmp(arg, "-i=", 3)) { + ret = para_atoi32(arg + 3, &cto.image_id); if (ret < 0) return ret; continue; } - if (!strncmp(arg, "-i", 2)) { - ret = para_atoi32(arg + 2, &cto.image_id); + if (!strncmp(arg, "-a=", 3)) { + int32_t val; + ret = para_atoi32(arg + 3, &val); if (ret < 0) return ret; + if (val < 0 || val > 255) + return -ERRNO_TO_PARA_ERROR(EINVAL); + cto.amp = val; continue; } if (!strcmp(arg, "-p")) { @@ -1985,12 +2152,9 @@ int com_touch(int fd, 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, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else if (ret < 0) - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + argv + i, com_touch_callback, rc4_send_result, rc4c); + if (ret < 0) + rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret)); return ret; } @@ -2020,21 +2184,29 @@ static int remove_audio_file(__a_unused struct osl_table *table, struct com_rm_action_data *crd = data; int ret; - if (crd->flags & RM_FLAG_VERBOSE) - para_printf(&crd->pb, "removing %s\n", name); + 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); - ret = osl_del_row(audio_file_table, row); + 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(&crd->pb, "%s: %s\n", name, para_strerror(-ret)); else crd->num_removed++; - return 1; + return ret; } -static int com_rm_callback(const struct osl_object *query, - __a_unused struct osl_object *result) +static void com_rm_callback(int fd, const struct osl_object *query) { - struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data}; + struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data, + .pb = { + .max_size = SHMMAX, + .private_data = &fd, + .max_size_handler = pass_buffer_as_shm + } + }; int ret; struct pattern_match_data pmd = { .table = audio_file_table, @@ -2048,28 +2220,26 @@ static int com_rm_callback(const struct osl_object *query, if (crd.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)); + if (ret < 0) { + para_printf(&crd.pb, "%s\n", para_strerror(-ret)); + return; + } if (!crd.num_removed && !(crd.flags & RM_FLAG_FORCE)) - para_printf(&crd.pb, "no matches -- nothing removed\n"); + ret = para_printf(&crd.pb, "no matches -- nothing removed\n"); else { if (crd.flags & RM_FLAG_VERBOSE) - para_printf(&crd.pb, "removed %u files\n", crd.num_removed); + ret = para_printf(&crd.pb, "removed %u files\n", crd.num_removed); } - if (crd.pb.buf) { - result->data = crd.pb.buf; - result->size = crd.pb.size; - return 1; - } - return ret < 0? ret : 0; + if (ret >= 0 && crd.pb.offset) + pass_buffer_as_shm(crd.pb.buf, crd.pb.offset, &fd); + free(crd.pb.buf); } /* TODO options: -r (recursive) */ -int com_rm(int fd, int argc, char * const * const argv) +int com_rm(struct rc4_context *rc4c, int argc, char * const * const argv) { uint32_t flags = 0; - struct osl_object query = {.data = &flags, .size = sizeof(flags)}, - result; + struct osl_object query = {.data = &flags, .size = sizeof(flags)}; int i, ret; for (i = 1; i < argc; i++) { @@ -2097,12 +2267,9 @@ int com_rm(int fd, 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, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else if (ret < 0) - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + com_rm_callback, rc4_send_result, rc4c); + if (ret < 0) + rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret)); return ret; } @@ -2164,24 +2331,29 @@ static int copy_selector_info(__a_unused struct osl_table *table, target_afsi.attributes = cad->source_afsi.attributes; save_afsi(&target_afsi, &target_afsi_obj); /* in-place update */ cad->num_copied++; - if (cad->flags & CPSI_FLAG_VERBOSE) - para_printf(&cad->pb, "copied afsi to %s\n", name); + if (cad->flags & CPSI_FLAG_VERBOSE) { + ret = para_printf(&cad->pb, "copied afsi to %s\n", name); + if (ret < 0) + return ret; + } aced.aft_row = row; aced.old_afsi = &old_afsi; afs_event(AFSI_CHANGE, &cad->pb, &aced); return 1; } -static int com_cpsi_callback(const struct osl_object *query, - struct osl_object *result) +static void com_cpsi_callback(int fd, const struct osl_object *query) { - struct cpsi_action_data cad = {.flags = *(unsigned *)query->data}; + struct cpsi_action_data cad = { + .flags = *(unsigned *)query->data, + .pb = { + .max_size = SHMMAX, + .private_data = &fd, + .max_size_handler = pass_buffer_as_shm + } + }; int ret; char *source_path = (char *)query->data + sizeof(cad.flags); - - ret = get_afsi_of_path(source_path, &cad.source_afsi); - if (ret < 0) - goto out; struct pattern_match_data pmd = { .table = audio_file_table, .loop_col_num = AFTCOL_HASH, @@ -2192,32 +2364,31 @@ static int com_cpsi_callback(const struct osl_object *query, .data = &cad, .action = copy_selector_info }; + + ret = get_afsi_of_path(source_path, &cad.source_afsi); + if (ret < 0) + goto out; ret = for_each_matching_row(&pmd); out: if (ret < 0) - para_printf(&cad.pb, "%s\n", PARA_STRERROR(-ret)); - if (cad.flags & CPSI_FLAG_VERBOSE) { + para_printf(&cad.pb, "%s\n", para_strerror(-ret)); + else if (cad.flags & CPSI_FLAG_VERBOSE) { if (cad.num_copied) para_printf(&cad.pb, "copied requested afsi from %s " - "to %u files\n", - source_path, cad.num_copied); + "to %u files\n", source_path, cad.num_copied); else para_printf(&cad.pb, "nothing copied\n"); } - if (cad.pb.buf) { - result->data = cad.pb.buf; - result->size = cad.pb.size; - return 1; - } - return ret < 0? ret : 0; + if (cad.pb.offset) + pass_buffer_as_shm(cad.pb.buf, cad.pb.offset, &fd); + free(cad.pb.buf); } -int com_cpsi(int fd, int argc, char * const * const argv) +int com_cpsi(struct rc4_context *rc4c, int argc, char * const * const argv) { unsigned flags = 0; int i, ret; - struct osl_object options = {.data = &flags, .size = sizeof(flags)}, - result; + struct osl_object options = {.data = &flags, .size = sizeof(flags)}; for (i = 1; i < argc; i++) { const char *arg = argv[i]; @@ -2253,20 +2424,36 @@ int com_cpsi(int fd, int argc, char * const * const argv) } break; } - if (i + 1 >= argc) /* need at least souce file and pattern */ + if (i + 1 >= argc) /* need at least source file and pattern */ 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, argc - i, argv + i, - com_cpsi_callback, &result); - if (ret > 0) { - send_buffer(fd, (char *)result.data); - free(result.data); - } else - send_va_buffer(fd, "%s\n", PARA_STRERROR(-ret)); + com_cpsi_callback, rc4_send_result, rc4c); + if (ret < 0) + rc4_send_va_buffer(rc4c, "%s\n", para_strerror(-ret)); return ret; } +void afs_stat_callback(int fd, const struct osl_object *query) +{ + int *parser_friendly = query->data; + char *buf = *parser_friendly? + parser_friendly_status_items : status_items; + + if (!buf) + return; + pass_buffer_as_shm(buf, strlen(buf), &fd); +} + +int send_afs_status(struct rc4_context *rc4c, 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); +} + /* TODO: optionally fix problems by removing offending rows */ static int check_audio_file(struct osl_row *row, void *data) { @@ -2277,52 +2464,61 @@ static int check_audio_file(struct osl_row *row, void *data) struct afs_info afsi; char *blob_name; - if (ret < 0) { - para_printf(pb, "%s\n", PARA_STRERROR(-ret)); - return 1; - } - 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); + 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; + } } 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) { - para_printf(pb, "%s: %s\n", path, PARA_STRERROR(-ret)); - return 1; + ret = para_printf(pb, "%s lyrics id %u: %s\n", path, afsi.lyrics_id, + para_strerror(-ret)); + if (ret < 0) + return ret; } - 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) - para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id, - PARA_STRERROR(-ret)); - return 1; + ret = para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id, + para_strerror(-ret)); + return ret; } /** * Check the audio file table for inconsistencies. * + * \param fd The afs socket. * \param query Unused. - * \param result Contains message string upon return. * * This function always succeeds. * * \sa com_check(). */ -int aft_check_callback(__a_unused const struct osl_object *query, struct osl_object *result) +void aft_check_callback(int fd, __a_unused const struct osl_object *query) { - struct para_buffer pb = {.buf = NULL}; + struct para_buffer pb = { + .max_size = SHMMAX, + .private_data = &fd, + .max_size_handler = pass_buffer_as_shm + }; + int ret = para_printf(&pb, "checking audio file table...\n"); - para_printf(&pb, "checking audio file table...\n"); + if (ret < 0) + return; audio_file_loop(&pb, check_audio_file); - result->data = pb.buf; - result->size = pb.size; - return 1; - + if (pb.offset) + pass_buffer_as_shm(pb.buf, pb.offset, &fd); + free(pb.buf); } /** @@ -2336,6 +2532,10 @@ 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; } /** @@ -2352,7 +2552,7 @@ static int aft_open(const char *dir) int ret; audio_file_table_desc.dir = dir; - ret = osl_open_table(&audio_file_table_desc, &audio_file_table); + ret = osl(osl_open_table(&audio_file_table_desc, &audio_file_table)); if (ret >= 0) { unsigned num; osl_get_num_rows(audio_file_table, &num); @@ -2361,7 +2561,7 @@ static int aft_open(const char *dir) } PARA_INFO_LOG("failed to open audio file table\n"); audio_file_table = NULL; - if (ret >= 0 || is_errno(-ret, ENOENT)) + if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT)) return 1; return ret; } @@ -2369,7 +2569,7 @@ static int aft_open(const char *dir) static int aft_create(const char *dir) { audio_file_table_desc.dir = dir; - return osl_create_table(&audio_file_table_desc); + return osl(osl_create_table(&audio_file_table_desc)); } static int clear_attribute(struct osl_row *row, void *data) @@ -2393,12 +2593,16 @@ static int clear_attribute(struct osl_row *row, void *data) static int aft_event_handler(enum afs_events event, struct para_buffer *pb, void *data) { + int ret; + switch(event) { case ATTRIBUTE_REMOVE: { const struct rmatt_event_data *red = data; - para_printf(pb, "clearing attribute %s (bit %u) from all " + ret = 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); } default: