X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=7027e7f95d45104c559cd5720ebd377fc2d047a8;hp=e29c15a0d48afe17fa39f6c349f9fa1e8f7e7216;hb=e752cdeab213b329552e1eecd5687bca512217c5;hpb=cb1265c87fdb0e817923bf09c47162a7f894aafc diff --git a/aft.c b/aft.c index e29c15a0..7027e7f9 100644 --- a/aft.c +++ b/aft.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2007-2008 Andre Noll + * Copyright (C) 2007-2009 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ @@ -7,6 +7,7 @@ /** \file aft.c Audio file table functions. */ #include /* readdir() */ +#include #include "para.h" #include "error.h" #include "string.h" @@ -20,8 +21,10 @@ #include "vss.h" #include "fd.h" #include "ipc.h" +#include "portable_io.h" static struct osl_table *audio_file_table; +static char *current_status_items; /** The different sorting methods of the ls command. */ enum ls_sorting_method { @@ -217,12 +220,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] = { @@ -335,23 +353,29 @@ enum afhi_offsets { CHUNK_TV_TV_USEC_OFFSET = 36, /** Number of channels is stored here. (1 byte) */ AFHI_CHANNELS_OFFSET = 40, - /** EOF timeout in ms. (2 byte) */ - AFHI_EOF_OFFSET = 41, /** The tag info position. */ - AFHI_INFO_STRING_OFFSET = 43, + AFHI_INFO_STRING_OFFSET = 41, /** Minimal on-disk size of a valid afhi struct. */ - MIN_AFHI_SIZE = 44 + 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); @@ -365,8 +389,14 @@ static void save_afhi(struct afh_info *afhi, char *buf) 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); - write_u16(buf + AFHI_EOF_OFFSET, tv2ms(&afhi->eof_tv)); - strcpy(buf + AFHI_INFO_STRING_OFFSET, afhi->info_string); /* OK */ + 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) @@ -382,8 +412,12 @@ static void load_afhi(const char *buf, struct afh_info *afhi) 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); - ms2tv(read_u16(buf + AFHI_EOF_OFFSET), &afhi->eof_tv); - afhi->info_string = para_strdup(buf + AFHI_INFO_STRING_OFFSET); + afhi->techinfo = 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; } static unsigned sizeof_chunk_table(struct afh_info *afhi) @@ -416,27 +450,27 @@ static void load_chunk_table(struct afh_info *afhi, char *buf) * \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)); } /** @@ -445,11 +479,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)); } /** @@ -518,8 +552,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; @@ -536,9 +570,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)); } /** @@ -576,8 +611,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); @@ -588,8 +623,6 @@ int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi) static int save_afd(struct audio_file_data *afd) { size_t size = sizeof(*afd) + sizeof_chunk_table(&afd->afhi); - - PARA_DEBUG_LOG("size: %zu\n", size); int shmid, ret = shm_new(size); void *shm_afd; char *buf; @@ -628,94 +661,6 @@ int load_afd(int shmid, struct audio_file_data *afd) 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); - { - struct ls_data d = { - .afhi = afd->afhi, /* struct copy */ - .afsi = old_afsi, - .path = path, - .score = score, - .hash = file_hash - }; - struct para_buffer pb = {.max_size = VERBOSE_LS_OUTPUT_SIZE - 1}; - ret = make_status_items(&d, &pb); /* frees info string */ - afd->afhi.info_string = NULL; - 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); -err: - free(afd->afhi.chunk_table); - free(afd->afhi.info_string); - 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) { @@ -742,7 +687,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)++; \ @@ -963,10 +908,15 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, "%s: %lu\n" /* seconds total */ "%s: %s\n" /* last played time */ "%s: %d\n" /* num_played */ - "%s: %u\n" /* ampplification */ - "%s" /* tag info */ + "%s: %u\n" /* amplification */ "%s: %lu\n" /* chunk time */ - "%s: %lu\n", /* num chunks */ + "%s: %lu\n" /* num chunks */ + "%s: %s\n" /* techinfo */ + "%s: %s\n" /* artist */ + "%s: %s\n" /* title */ + "%s: %s\n" /* year */ + "%s: %s\n" /* album */ + "%s: %s\n", /* comment */ filename_lines, have_score? status_item_list[SI_SCORE] : "", have_score? ": " : "", @@ -985,9 +935,14 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, status_item_list[SI_LAST_PLAYED], last_played_time, status_item_list[SI_NUM_PLAYED], afsi->num_played, status_item_list[SI_AMPLIFICATION], afsi->amp, - afhi->info_string, status_item_list[SI_CHUNK_TIME], tv2ms(&afhi->chunk_tv), - status_item_list[SI_NUM_CHUNKS], afhi->chunks_total + status_item_list[SI_NUM_CHUNKS], afhi->chunks_total, + status_item_list[SI_TECHINFO], afhi->techinfo, + status_item_list[SI_ARTIST], afhi->tags.artist, + status_item_list[SI_TITLE], afhi->tags.title, + status_item_list[SI_YEAR], afhi->tags.year, + status_item_list[SI_ALBUM], afhi->tags.album, + status_item_list[SI_COMMENT], afhi->tags.comment ); if (ret < 0) goto out; @@ -1005,67 +960,109 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, free(image_lines); free(filename_lines); out: - free(afhi->info_string); return ret; } -void make_empty_status_items(char *buf) -{ - sprintf(buf, - "%s: \n" /* path */ - "%s: \n" /* dirname */ - "%s: \n" /* basename */ - "%s: \n" /* score */ - "%s: \n" /* attributes bitmap */ - "%s: \n" /* attributes txt */ - "%s: \n" /* hash */ - "%s: \n" /* image id */ - "%s: \n" /* image name */ - "%s: \n" /* lyrics id */ - "%s: \n" /* lyrics name */ - "%s: \n" /* bitrate */ - "%s: \n" /* format */ - "%s: \n" /* frequency */ - "%s: \n" /* channels */ - "%s: \n" /* duration */ - "%s: \n" /* seconds total */ - "%s: \n" /* num played */ - "%s: \n" /* last played */ - , - status_item_list[SI_PATH], - status_item_list[SI_DIRECTORY], - status_item_list[SI_BASENAME], - status_item_list[SI_SCORE], - status_item_list[SI_ATTRIBUTES_BITMAP], - status_item_list[SI_ATTRIBUTES_TXT], - status_item_list[SI_HASH], - status_item_list[SI_IMAGE_ID], - status_item_list[SI_IMAGE_NAME], - status_item_list[SI_LYRICS_ID], - status_item_list[SI_LYRICS_NAME], - status_item_list[SI_BITRATE], - status_item_list[SI_FORMAT], - status_item_list[SI_FREQUENCY], - status_item_list[SI_CHANNELS], - status_item_list[SI_DURATION], - status_item_list[SI_SECONDS_TOTAL], - status_item_list[SI_NUM_PLAYED], - status_item_list[SI_LAST_PLAYED] - ); -} - -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(current_status_items); + current_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) { @@ -1253,8 +1250,8 @@ 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) { @@ -1265,7 +1262,6 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) } return 1; err: - free(d->afhi.info_string); return ret; } @@ -1290,11 +1286,10 @@ static void com_ls_callback(int fd, 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); @@ -1440,12 +1435,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) @@ -1591,6 +1586,7 @@ static void com_add_callback(int fd, const struct osl_object *query) struct afs_info default_afsi = {.last_played = 0}; 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 + CAB_HASH_OFFSET; hash_to_asc(hash, asc);; @@ -1604,7 +1600,7 @@ static void com_add_callback(int fd, const struct osl_object *query) 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) + 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) @@ -1621,23 +1617,23 @@ static void com_add_callback(int fd, const struct osl_object *query) if (ret < 0) goto out; } - ret = osl_del_row(audio_file_table, pb); + 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; } - 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); @@ -1645,8 +1641,8 @@ static void com_add_callback(int fd, const struct osl_object *query) goto out; } /* no hs or force mode, child must have sent afhi */ - uint16_t afhi_offset = read_u16(buf + CAB_AFHI_OFFSET_POS); - uint16_t chunks_offset = read_u16(buf + CAB_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; @@ -1681,12 +1677,12 @@ static void com_add_callback(int fd, const struct osl_object *query) if (ret < 0) goto out; } - ret = osl_update_object(audio_file_table, row, AFTCOL_AFHI, - &objs[AFTCOL_AFHI]); + 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); @@ -1704,11 +1700,11 @@ static void com_add_callback(int fd, const struct osl_object *query) 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) - ret = para_printf(&msg, "%s\n", para_strerror(-ret)); + para_printf(&msg, "%s\n", para_strerror(-ret)); if (msg.offset) pass_buffer_as_shm(msg.buf, msg.offset, &fd); free(msg.buf); @@ -1767,7 +1763,7 @@ static int add_one_audio_file(const char *path, void *private_data) query.size = strlen(path) + 1; ret = send_callback_request(path_brother_callback, &query, get_row_pointer_from_result, &pb); - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) + if (ret < 0 && ret != -OSL_ERRNO_TO_PARA_ERROR(E_OSL_RB_KEY_NOT_FOUND)) goto out_free; ret = 1; if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */ @@ -1808,6 +1804,7 @@ static int add_one_audio_file(const char *path, void *private_data) afhi_ptr = &afhi; } munmap(map.data, map.size); + close(fd); if (pad->flags & ADD_FLAG_VERBOSE) { send_ret = send_va_buffer(pad->fd, "adding %s\n", path); if (send_ret < 0) @@ -1828,7 +1825,12 @@ out_free: free(obj.data); if (afhi_ptr) { free(afhi_ptr->chunk_table); - free(afhi_ptr->info_string); + 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; @@ -1981,7 +1983,8 @@ 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; - new_afsi.amp = tad->cto->amp; + if (tad->cto->amp >= 0) + new_afsi.amp = tad->cto->amp; } tad->num_matches++; save_afsi(&new_afsi, &obj); /* in-place update */ @@ -2121,7 +2124,7 @@ static int remove_audio_file(__a_unused struct osl_table *table, struct osl_row *row, const char *name, void *data) { struct com_rm_action_data *crd = data; - int ret, ret2; + int ret; if (crd->flags & RM_FLAG_VERBOSE) { ret = para_printf(&crd->pb, "removing %s\n", name); @@ -2129,10 +2132,9 @@ static int remove_audio_file(__a_unused struct osl_table *table, 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) - ret2 = 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 ret; @@ -2161,7 +2163,7 @@ static void com_rm_callback(int fd, const struct osl_object *query) pmd.fnmatch_flags |= FNM_PATHNAME; ret = for_each_matching_row(&pmd); if (ret < 0) { - ret = para_printf(&crd.pb, "%s\n", para_strerror(-ret)); + para_printf(&crd.pb, "%s\n", para_strerror(-ret)); return; } if (!crd.num_removed && !(crd.flags & RM_FLAG_FORCE)) @@ -2294,10 +2296,6 @@ static void com_cpsi_callback(int fd, const struct osl_object *query) }; 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, @@ -2308,17 +2306,20 @@ static void com_cpsi_callback(int fd, 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) - ret = para_printf(&cad.pb, "%s\n", para_strerror(-ret)); + para_printf(&cad.pb, "%s\n", para_strerror(-ret)); else if (cad.flags & CPSI_FLAG_VERBOSE) { if (cad.num_copied) - ret = para_printf(&cad.pb, "copied requested afsi from %s " - "to %u files\n", - source_path, cad.num_copied); + para_printf(&cad.pb, "copied requested afsi from %s " + "to %u files\n", source_path, cad.num_copied); else - ret = para_printf(&cad.pb, "nothing copied\n"); + para_printf(&cad.pb, "nothing copied\n"); } if (cad.pb.offset) pass_buffer_as_shm(cad.pb.buf, cad.pb.offset, &fd); @@ -2376,6 +2377,18 @@ int com_cpsi(int fd, int argc, char * const * const argv) return ret; } +void afs_stat_callback(int fd, __a_unused const struct osl_object *query) +{ + if (current_status_items) + pass_buffer_as_shm(current_status_items, + strlen(current_status_items), &fd); +} + +int send_afs_status(int fd) +{ + return send_callback_request(afs_stat_callback, NULL, send_result, &fd); +} + /* TODO: optionally fix problems by removing offending rows */ static int check_audio_file(struct osl_row *row, void *data) { @@ -2454,6 +2467,8 @@ static void aft_close(void) { osl_close_table(audio_file_table, OSL_MARK_CLEAN); audio_file_table = NULL; + free(current_status_items); + current_status_items = NULL; } /** @@ -2470,7 +2485,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); @@ -2479,7 +2494,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; } @@ -2487,7 +2502,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)