X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=0efd285c2eb716df2aeeb47e4dfd06aa1d293e5f;hp=04846a7658e34979f6bdcab62669b2c1c826a1a6;hb=7ab176a3b0771cfcdd8ee103cd5452e971d12e26;hpb=4a262fc2d915538dd5ebaa58fa5ec7403de650cd diff --git a/aft.c b/aft.c index 04846a76..0efd285c 100644 --- a/aft.c +++ b/aft.c @@ -1,17 +1,127 @@ +/* + * Copyright (C) 2007-2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file aft.c Audio file table functions. */ + +#include /* readdir() */ #include "para.h" #include "error.h" +#include "string.h" #include #include #include "afh.h" #include "afs.h" #include "net.h" -#include "string.h" #include "vss.h" - -#define AFS_AUDIO_FILE_DIR "/home/mp3" +#include "fd.h" +#include "ipc.h" static struct osl_table *audio_file_table; +/** The different sorting methods of the ls command. */ +enum ls_sorting_method { + /** -sp (default) */ + LS_SORT_BY_PATH, + /** -ss */ + LS_SORT_BY_SCORE, + /** -sl */ + LS_SORT_BY_LAST_PLAYED, + /** -sn */ + LS_SORT_BY_NUM_PLAYED, + /** -sf */ + LS_SORT_BY_FREQUENCY, + /** -sc */ + LS_SORT_BY_CHANNELS, + /** -si */ + LS_SORT_BY_IMAGE_ID, + /** -sy */ + LS_SORT_BY_LYRICS_ID, + /** -sb */ + LS_SORT_BY_BITRATE, + /** -sd */ + LS_SORT_BY_DURATION, + /** -sa */ + LS_SORT_BY_AUDIO_FORMAT, + /** -sh */ + LS_SORT_BY_HASH, +}; + +/** The different listing modes of the ls command. */ +enum ls_listing_mode { + /** Default listing mode. */ + LS_MODE_SHORT, + /** -l or -ll */ + LS_MODE_LONG, + /** -lv */ + LS_MODE_VERBOSE, + /** -lm */ + LS_MODE_MBOX, + /** -lc */ + LS_MODE_CHUNKS +}; + +/** The flags accepted by the ls command. */ +enum ls_flags { + /** -p */ + LS_FLAG_FULL_PATH = 1, + /** -a */ + LS_FLAG_ADMISSIBLE_ONLY = 2, + /** -r */ + LS_FLAG_REVERSE = 4, +}; + +/** + * The size of the individual output fields of the ls command. + * + * These depend on the actual content being listed. If, for instance only files + * with duration less than an hour are being listed, then the duration with is + * made smaller because then the duration is listed as mm:ss rather than + * hh:mm:ss. + */ +struct ls_widths { + /** size of the score field. */ + unsigned short score_width; + /** size of the image id field. */ + unsigned short image_id_width; + /** size of the lyrics id field. */ + unsigned short lyrics_id_width; + /** size of the bitrate field. */ + unsigned short bitrate_width; + /** size of the frequency field. */ + unsigned short frequency_width; + /** size of the duration field. */ + unsigned short duration_width; + /** size of the num played field. */ + unsigned short num_played_width; +}; + +/** Data passed from the ls command handler to its callback function. */ +struct ls_options { + /** The given command line flags. */ + unsigned flags; + /** The sorting method given at the command line. */ + enum ls_sorting_method sorting; + /** The given listing mode (short, long, verbose, mbox). */ + enum ls_listing_mode mode; + /** The arguments passed to the ls command. */ + char **patterns; + /** Number of non-option arguments. */ + int num_patterns; + /** Used for long listing mode to align the output fields. */ + struct ls_widths widths; + /** Size of the \a data array. */ + uint32_t array_size; + /** Number of used entries in the data array. */ + uint32_t num_matching_paths; + /** Array of matching entries. */ + struct ls_data *data; + /** Used to sort the array. */ + struct ls_data **data_ptr; +}; + /** * Describes the layout of the mmapped-afs info struct. * @@ -30,8 +140,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, /** On-disk storage space needed. */ - AFSI_SIZE = 29 + AFSI_SIZE = 32 }; /** @@ -53,6 +165,7 @@ 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); } /** @@ -69,7 +182,7 @@ int load_afsi(struct afs_info *afsi, struct osl_object *obj) { char *buf = obj->data; if (obj->size < AFSI_SIZE) - return -E_BAD_AFS; + return -E_BAD_AFSI; afsi->last_played = read_u64(buf + AFSI_LAST_PLAYED_OFFSET); afsi->attributes = read_u64(buf + AFSI_ATTRIBUTES_OFFSET); afsi->num_played = read_u32(buf + AFSI_NUM_PLAYED_OFFSET); @@ -133,60 +246,7 @@ static struct osl_table_description audio_file_table_desc = { .column_descriptions = aft_cols }; -static char *prefix_path(const char *prefix, int len, const char *path) -{ - int speclen; - char *n; - - for (;;) { - char c; - if (*path != '.') - break; - c = path[1]; - /* "." */ - if (!c) { - path++; - break; - } - /* "./" */ - if (c == '/') { - path += 2; - continue; - } - if (c != '.') - break; - c = path[2]; - if (!c) - path += 2; - else if (c == '/') - path += 3; - else - break; - /* ".." and "../" */ - /* Remove last component of the prefix */ - do { - if (!len) - return NULL; - len--; - } while (len && prefix[len-1] != '/'); - continue; - } - if (!len) - return para_strdup(path); - speclen = strlen(path); - n = para_malloc(speclen + len + 1); - memcpy(n, prefix, len); - memcpy(n + len, path, speclen+1); - return n; -} - -/* - * We fundamentally don't like some paths: we don't want - * dot or dot-dot anywhere. - * - * Also, we don't want double slashes or slashes at the - * end that can make pathnames ambiguous. - */ +/* We don't want * dot or dot-dot anywhere. */ static int verify_dotfile(const char *rest) { /* @@ -194,149 +254,152 @@ static int verify_dotfile(const char *rest) * now test the rest. */ switch (*rest) { - /* "." is not allowed */ - case '\0': case '/': - return 1; - - case '.': + case '\0': case '/': /* /foo/. and /foo/./bar are not ok */ + return -1; + case '.': /* path start with /foo/.. */ if (rest[1] == '\0' || rest[1] == '/') - return -1; + return -1; /* /foo/.. or /foo/../bar are not ok */ + /* /foo/..bar is ok */ } return 1; } +/* + * We fundamentally don't like some paths: We don't want double slashes or + * slashes at the end that can make pathnames ambiguous. + */ static int verify_path(const char *orig_path, char **resolved_path) { char c; - const char prefix[] = AFS_AUDIO_FILE_DIR "/"; - const char *path = orig_path; - const size_t prefix_len = strlen(prefix); + size_t len; + char *path; + if (*orig_path != '/') /* we only accept absolute paths */ + return -E_BAD_PATH; + len = strlen(orig_path); + *resolved_path = para_strdup(orig_path); + path = *resolved_path; + while (len > 1 && path[--len] == '/') + path[len] = '\0'; /* remove slash at the end */ c = *path++; - if (!c) - goto bad_path; while (c) { if (c == '/') { c = *path++; switch (c) { - default: - continue; case '/': /* double slash */ goto bad_path; case '.': if (verify_dotfile(path) < 0) goto bad_path; + default: + continue; } } c = *path++; } - if (*orig_path != '/') - *resolved_path = prefix_path(prefix, prefix_len, orig_path); - else - *resolved_path = para_strdup(orig_path); return 1; bad_path: + free(*resolved_path); return -E_BAD_PATH; } +/** The on-disk layout of a afhi struct. */ enum afhi_offsets { + /** Where the number of seconds is stored. */ AFHI_SECONDS_TOTAL_OFFSET = 0, + /** Position of the bitrate. */ AFHI_BITRATE_OFFSET = 4, + /** Position of the frequency. */ AFHI_FREQUENCY_OFFSET = 8, - AFHI_CHANNELS_OFFSET = 12, - AFHI_INFO_STRING_OFFSET = 13, - MIN_AFHI_SIZE = 14 + /** Location of the audio file header. */ + AFHI_HEADER_OFFSET_OFFSET = 12, + /* Length of the audio file header. Zero means: No header. */ + AFHI_HEADER_LEN_OFFSET = 16, + /** The total number of chunks (4 bytes). */ + CHUNKS_TOTAL_OFFSET = 20, + /** The length of the audio file header (4 bytes). */ + HEADER_LEN_OFFSET = 24, + /** The start of the audio file header (4 bytes). */ + HEADER_OFFSET_OFFSET = 28, + /** 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, + /** EOF timeout in ms. (2 byte) */ + AFHI_EOF_OFFSET = 41, + /** The tag info position. */ + AFHI_INFO_STRING_OFFSET = 43, + /** Minimal on-disk size of a valid afhi struct. */ + MIN_AFHI_SIZE = 44 }; -static unsigned sizeof_afhi_buf(const struct audio_format_info *afhi) +static unsigned sizeof_afhi_buf(const struct afh_info *afhi) { if (!afhi) return 0; return strlen(afhi->info_string) + MIN_AFHI_SIZE; } -static void save_afhi(struct audio_format_info *afhi, char *buf) +static void save_afhi(struct afh_info *afhi, char *buf) { 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_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); + 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)); } -static void load_afhi(const char *buf, struct audio_format_info *afhi) +static void load_afhi(const char *buf, struct afh_info *afhi) { afhi->seconds_total = read_u32(buf + AFHI_SECONDS_TOTAL_OFFSET); afhi->bitrate = read_u32(buf + AFHI_BITRATE_OFFSET); afhi->frequency = read_u32(buf + AFHI_FREQUENCY_OFFSET); + afhi->header_offset = read_u32(buf + AFHI_HEADER_OFFSET_OFFSET); + afhi->header_len = read_u32(buf + AFHI_HEADER_LEN_OFFSET); afhi->channels = read_u8(buf + AFHI_CHANNELS_OFFSET); + afhi->chunks_total = read_u32(buf + CHUNKS_TOTAL_OFFSET); + afhi->header_len = read_u32(buf + HEADER_LEN_OFFSET); + afhi->header_offset = read_u32(buf + HEADER_OFFSET_OFFSET); + afhi->chunk_tv.tv_sec = read_u32(buf + CHUNK_TV_TV_SEC_OFFSET); + afhi->chunk_tv.tv_usec = read_u32(buf + CHUNK_TV_TV_USEC_OFFSET); + ms2tv(read_u16(buf + AFHI_EOF_OFFSET), &afhi->eof_tv); strcpy(afhi->info_string, buf + AFHI_INFO_STRING_OFFSET); } -static unsigned sizeof_chunk_info_buf(struct audio_format_info *afhi) +static unsigned sizeof_chunk_table(struct afh_info *afhi) { if (!afhi) return 0; - return 4 * afhi->chunks_total + 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, -}; - -/* TODO: audio format handlers could just produce this */ -static void save_chunk_info(struct audio_format_info *afhi, char *buf) +static void save_chunk_table(struct afh_info *afhi, char *buf) { int i; - 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); - for (i = 0; i < afhi->chunks_total; i++) - write_u32(buf + CHUNK_TABLE_OFFSET + 4 * i, afhi->chunk_table[i]); + for (i = 0; i <= afhi->chunks_total; i++) + write_u32(buf + 4 * i, afhi->chunk_table[i]); } -static int load_chunk_info(struct osl_object *obj, struct audio_format_info *afhi) +static void load_chunk_table(struct afh_info *afhi, char *buf) { - char *buf = obj->data; int i; - 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 * 4 + CHUNK_TABLE_OFFSET > obj->size) - return -E_BAD_DATA_SIZE; - afhi->chunk_table = para_malloc(afhi->chunks_total * sizeof(size_t)); - for (i = 0; i < afhi->chunks_total; i++) - afhi->chunk_table[i] = read_u32(buf + CHUNK_TABLE_OFFSET + 4 * i); - return 1; + 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); } /** @@ -347,9 +410,9 @@ static int load_chunk_info(struct osl_object *obj, struct audio_format_info *afh * * \return The return value of the underlying call to osl_get_row(). */ -int aft_get_row_of_path(char *path, struct osl_row **row) +int aft_get_row_of_path(const char *path, struct osl_row **row) { - struct osl_object obj = {.data = path, .size = strlen(path) + 1}; + struct osl_object obj = {.data = (char *)path, .size = strlen(path) + 1}; return osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row); } @@ -376,7 +439,7 @@ int aft_get_row_of_hash(HASH_TYPE *hash, struct osl_row **row) * * \return The return value of the underlying call to osl_get_object(). */ -int get_afsi_object_of_row(const void *row, struct osl_object *obj) +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); } @@ -390,7 +453,7 @@ int get_afsi_object_of_row(const void *row, struct osl_object *obj) * * \return Positive on success, negative on errors. */ -int get_afsi_object_of_path(char *path, struct osl_object *obj) +int get_afsi_object_of_path(const char *path, struct osl_object *obj) { struct osl_row *row; int ret = aft_get_row_of_path(path, &row); @@ -416,13 +479,33 @@ int get_afsi_of_row(const struct osl_row *row, struct afs_info *afsi) return load_afsi(afsi, &obj); } +/** + * Get the audio file selector info, given the path of an audio table. + * + * \param path The full path of the audio file. + * \param afsi Result pointer. + * + * \return Positive on success, negative on errors. + */ +int get_afsi_of_path(const char *path, struct afs_info *afsi) +{ + struct osl_object obj; + int ret = get_afsi_object_of_path(path, &obj); + if (ret < 0) + return ret; + return load_afsi(afsi, &obj); +} + /** * Get the path of an audio file, given a row of the audio file table. * * \param row Pointer to a row in the audio file table. * \param path Result pointer. * - * \return Positive on success, negative on errors. + * The result is a pointer to mmapped data. The caller must not attempt + * to free it. + * + * \return Standard. */ int get_audio_file_path_of_row(const struct osl_row *row, char **path) { @@ -445,7 +528,7 @@ int get_audio_file_path_of_row(const struct osl_row *row, char **path) * * \sa get_hash_of_row(). */ -int get_hash_object_of_aft_row(const void *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); } @@ -461,7 +544,7 @@ int get_hash_object_of_aft_row(const void *row, struct osl_object *obj) * \return The return value of the underlying call to * get_hash_object_of_aft_row(). */ -static int get_hash_of_row(const void *row, HASH_TYPE **hash) +static int get_hash_of_row(const struct osl_row *row, HASH_TYPE **hash) { struct osl_object obj; int ret = get_hash_object_of_aft_row(row, &obj); @@ -482,7 +565,7 @@ static int get_hash_of_row(const void *row, HASH_TYPE **hash) * * \sa get_chunk_table_of_row(). */ -int get_afhi_of_row(const void *row, struct audio_format_info *afhi) +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, @@ -493,94 +576,149 @@ int get_afhi_of_row(const void *row, struct audio_format_info *afhi) return 1; } -/** - * Get the chunk table of an audio file, given a row of the audio file table. - * - * \param row Pointer to a row of the audio file table. - * \param afhi Result pointer. - * - * \return The return value of the underlying call to osl_open_disk_object(). - * - * \sa get_afhi_of_row(). - */ -int get_chunk_table_of_row(const void *row, struct audio_format_info *afhi) +/* returns shmid on success */ +static int save_afd(struct audio_file_data *afd) { - struct osl_object obj; - int ret = osl_open_disk_object(audio_file_table, row, AFTCOL_CHUNKS, - &obj); + 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; + if (ret < 0) return ret; - ret = load_chunk_info(&obj, afhi); - osl_close_disk_object(&obj); + shmid = ret; + ret = shm_attach(shmid, ATTACH_RW, &shm_afd); + if (ret < 0) + goto err; + *(struct audio_file_data *)shm_afd = *afd; + buf = shm_afd; + buf += sizeof(*afd); + save_chunk_table(&afd->afhi, buf); + shm_detach(shm_afd); + return shmid; +err: + shm_destroy(shmid); return ret; } +int load_afd(int shmid, struct audio_file_data *afd) +{ + void *shm_afd; + char *buf; + int ret; + + ret = shm_attach(shmid, ATTACH_RO, &shm_afd); + if (ret < 0) + return ret; + *afd = *(struct audio_file_data *)shm_afd; + buf = shm_afd; + buf += sizeof(*afd); + 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 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 on success, negative on errors. + * \return Positive shmid on success, negative on errors. */ -int open_and_update_audio_file(struct osl_row *aft_row, struct audio_file_data *afd) +int open_and_update_audio_file(struct osl_row *aft_row, long score, + struct audio_file_data *afd) { HASH_TYPE *aft_hash, file_hash[HASH_SIZE]; struct osl_object afsi_obj; - struct afs_info new_afsi; + 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, &afd->path); + 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(&afd->afsi, &afsi_obj); + 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 = get_chunk_table_of_row(aft_row, &afd->afhi); + ret = osl_open_disk_object(audio_file_table, aft_row, + AFTCOL_CHUNKS, &chunk_table_obj); if (ret < 0) return ret; - ret = mmap_full_file(afd->path, O_RDONLY, &afd->map); + afd->afhi.chunk_table = NULL; + ret = mmap_full_file(path, O_RDONLY, &map.data, + &map.size, &afd->fd); if (ret < 0) goto err; - hash_function(afd->map.data, afd->map.size, file_hash); - ret = -E_HASH_MISMATCH; - if (hash_compare(file_hash, aft_hash)) + 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 = afd->afsi; + } + new_afsi = old_afsi; new_afsi.num_played++; new_afsi.last_played = time(NULL); save_afsi(&new_afsi, &afsi_obj); /* in-place update */ - if (afd->current_play_mode == PLAY_MODE_PLAYLIST) - ret = playlist_update_audio_file(aft_row); - else - ret = mood_update_audio_file(aft_row, &afd->afsi); - return ret; + + load_chunk_table(&afd->afhi, chunk_table_obj.data); + { + 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); err: free(afd->afhi.chunk_table); + osl_close_disk_object(&chunk_table_obj); return ret; } -time_t now; - -static int get_local_time(uint64_t *seconds, char *buf, size_t size) +static int get_local_time(uint64_t *seconds, char *buf, size_t size, + time_t current_time, enum ls_listing_mode lm) { struct tm t; if (!localtime_r((time_t *)seconds, &t)) return -E_LOCALTIME; - if (*seconds + 6 * 30 * 24 * 3600 > now) { + if (lm == LS_MODE_MBOX) { + if (!strftime(buf, size, "%c", &t)) + return -E_STRFTIME; + return 1; + } + if (*seconds + 6 * 30 * 24 * 3600 > current_time) { if (!strftime(buf, size, "%b %e %k:%M", &t)) return -E_STRFTIME; return 1; @@ -590,6 +728,7 @@ static int get_local_time(uint64_t *seconds, char *buf, size_t size) return 1; } +/** Compute the number of (decimal) digits of a number. */ #define GET_NUM_DIGITS(x, num) { \ typeof((x)) _tmp = PARA_ABS(x); \ *num = 1; \ @@ -600,59 +739,119 @@ static int get_local_time(uint64_t *seconds, char *buf, size_t size) } \ } -static short unsigned get_duration(int seconds_total, char *buf, short unsigned max_width) +static short unsigned get_duration_width(int seconds) { short unsigned width; - int s = seconds_total; - unsigned hours = s / 3600, mins = (s % 3600) / 60, secs = s % 60; - - if (s < 3600) { /* less than one hour => m:ss or mm:ss */ - GET_NUM_DIGITS(mins, &width); /* 1 or 2 */ - width += 3; /* 4 or 5 */ - if (buf) - sprintf(buf, "%*u:%02u", max_width - width + 1, mins, secs); - return width; - } + unsigned hours = seconds / 3600, mins = (seconds % 3600) / 60; + + if (!hours) /* less than one hour => m:ss or mm:ss => 4 or 5 digits */ + return 4 + (mins > 9); /* more than one hour => h:mm:ss, hh:mm:ss, hhh:mm:ss, ... */ GET_NUM_DIGITS(hours, &width); - width += 6; - if (buf) - sprintf(buf, "%*u:%02u:%02u", max_width - width + 1, hours, mins, secs); - return width; + return width + 6; +} + +static void get_duration_buf(int seconds, char *buf, struct ls_options *opts) +{ + unsigned hours = seconds / 3600, mins = (seconds % 3600) / 60; + short unsigned max_width; + + if (!hours) { /* m:ss or mm:ss */ + max_width = opts->mode == LS_MODE_LONG? + opts->widths.duration_width : 4; + sprintf(buf, "%*u:%02u", max_width - 3, mins, seconds % 60); + } else { /* more than one hour => h:mm:ss, hh:mm:ss, hhh:mm:ss, ... */ + max_width = opts->mode == LS_MODE_LONG? + opts->widths.duration_width : 7; + sprintf(buf, "%*u:%02u:%02u", max_width - 6, hours, mins, + seconds % 60); + } } -static char *make_attribute_line(const char *att_bitmap, struct afs_info *afsi) +static char *make_attribute_lines(const char *att_bitmap, struct afs_info *afsi) { - char *att_text, *att_line; + char *att_text, *att_lines; get_attribute_text(&afsi->attributes, " ", &att_text); if (!att_text) return para_strdup(att_bitmap); - att_line = make_message("%s (%s)", att_bitmap, att_text); + att_lines = make_message("%s: %s\n%s: %s", + status_item_list[SI_ATTRIBUTES_BITMAP], att_bitmap, + status_item_list[SI_ATTRIBUTES_TXT], att_text); free(att_text); - return att_line; + return att_lines; } -static char *make_lyrics_line(struct afs_info *afsi) +static char *make_lyrics_lines(struct afs_info *afsi) { char *lyrics_name; + lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name); - if (!lyrics_name) - return make_message("%u", afsi->lyrics_id); - return make_message("%u (%s)", afsi->lyrics_id, lyrics_name); + return make_message("%s: %u\n%s: %s\n", + status_item_list[SI_LYRICS_ID], afsi->lyrics_id, + status_item_list[SI_LYRICS_NAME], lyrics_name? + lyrics_name : "(none)"); } -static char *make_image_line(struct afs_info *afsi) +static char *make_image_lines(struct afs_info *afsi) { char *image_name; img_get_name_by_id(afsi->image_id, &image_name); - if (!image_name) - return make_message("%u", afsi->image_id); - return make_message("%u (%s)", afsi->image_id, image_name); + return make_message("%s: %u\n%s: %s\n", + status_item_list[SI_IMAGE_ID], afsi->image_id, + status_item_list[SI_IMAGE_NAME], image_name? + image_name : "(none)"); +} + +static char *make_filename_lines(const char *path, unsigned flags) +{ + char *dirname, *ret; + const char *basename; + + if (!(flags & LS_FLAG_FULL_PATH)) + return make_message("%s: %s\n", + status_item_list[SI_BASENAME], path); + basename = para_basename(path), + dirname = para_dirname(path); + ret = make_message("%s: %s\n%s: %s\n%s: %s\n", + status_item_list[SI_PATH], path, + status_item_list[SI_DIRECTORY], dirname? dirname : "?", + status_item_list[SI_BASENAME], basename? basename : "?"); + free(dirname); + 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; + buf = chunk_table_obj.data; + 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 + ); + for (i = 0; i <= d->afhi.chunks_total; i++) + para_printf(b, "%u ", + (unsigned) read_u32(buf + 4 * i)); + osl_close_disk_object(&chunk_table_obj); + para_printf(b, "\n"); + return 1; } static int print_list_item(struct ls_data *d, struct ls_options *opts, - struct para_buffer *b) + struct para_buffer *b, time_t current_time) { int ret; char att_buf[65]; @@ -660,20 +859,24 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, 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 audio_format_info *afhi = &d->afhi; + 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; } + if (opts->mode == LS_MODE_CHUNKS) + return print_chunk_table(d, b); get_attribute_bitmap(&afsi->attributes, att_buf); ret = get_local_time(&afsi->last_played, last_played_time, - sizeof(last_played_time)); + sizeof(last_played_time), current_time, opts->mode); if (ret < 0) return ret; - get_duration(afhi->seconds_total, duration_buf, w->duration_width); + 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); @@ -710,52 +913,133 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, ); return 1; } - if (opts->mode == LS_MODE_VERBOSE) { - char asc_hash[2 * HASH_SIZE + 1]; - char *att_line, *lyrics_line, *image_line; - - hash_to_asc(d->hash, asc_hash); - att_line = make_attribute_line(att_buf, afsi); - lyrics_line = make_lyrics_line(afsi); - image_line = make_image_line(afsi); + 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_MBOX) { + const char *bn = para_basename(d->path); para_printf(b, - "%s: %s\n" /* path */ - "%s%s%s" /* score */ - "attributes: %s\n" - "hash: %s\n" - "image_id: %s\n" - "lyrics_id: %s\n" - "bitrate: %dkbit/s\n" - "format: %s\n" - "frequency: %dHz\n" - "channels: %d\n" - "duration: %s\n" - "num_played: %d\n" - "last_played: %s\n\n", - (opts->flags & LS_FLAG_FULL_PATH)? - "path" : "file", d->path, - have_score? "score: " : "", score_buf, - have_score? "\n" : "", - att_line, - asc_hash, - image_line, - lyrics_line, - afhi->bitrate, - audio_format_name(afsi->audio_format_id), - afhi->frequency, - afhi->channels, - duration_buf, - afsi->num_played, - last_played_time - ); - free(att_line); - free(lyrics_line); - free(image_line); - return 1; + "From foo@localhost %s\n" + "Received: from\nTo: bar\nFrom: a\n" + "Subject: %s\n\n", + last_played_time, + bn? bn : "?"); + } + para_printf(b, + "%s" /* filename stuff */ + "%s%s%s%s" /* score */ + "%s\n" /* attributes */ + "%s: %s\n" /* hash */ + "%s" /* image id, image name */ + "%s" /* lyrics */ + "%s: %dkbit/s\n" /* bitrate */ + "%s: %s\n" /* format */ + "%s: %dHz\n" /* frequency */ + "%s: %d\n" /* channels */ + "%s: %s\n" /* duration */ + "%s: %lu\n" /* seconds total */ + "%s: %s\n" /* last played time */ + "%s: %d\n" /* num_played */ + "%s" /* tag info */ + "%s: %lu\n" /* chunk time */ + "%s: %lu\n", /* num chunks */ + filename_lines, + have_score? status_item_list[SI_SCORE] : "", + have_score? ": " : "", + score_buf, + have_score? "\n" : "", + att_lines, + status_item_list[SI_HASH], asc_hash, + image_lines, + lyrics_lines, + status_item_list[SI_BITRATE], afhi->bitrate, + status_item_list[SI_FORMAT], audio_format_name(afsi->audio_format_id), + status_item_list[SI_FREQUENCY], afhi->frequency, + status_item_list[SI_CHANNELS], afhi->channels, + status_item_list[SI_DURATION], duration_buf, + status_item_list[SI_SECONDS_TOTAL], afhi->seconds_total, + status_item_list[SI_LAST_PLAYED], last_played_time, + status_item_list[SI_NUM_PLAYED], afsi->num_played, + afhi->info_string, + status_item_list[SI_CHUNK_TIME], tv2ms(&afhi->chunk_tv), + status_item_list[SI_NUM_CHUNKS], afhi->chunks_total + ); + 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) { + para_printf(b, "Lyrics:\n~~~~~~~\n%s", + (char *)lyrics_def.data); + osl_close_disk_object(&lyrics_def); + } } + free(att_lines); + free(lyrics_lines); + free(image_lines); + free(filename_lines); return 1; } +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) +{ + struct ls_options opts = { + .flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY, + .mode = LS_MODE_VERBOSE, + }; + time_t current_time; + + time(¤t_time); + return print_list_item(d, &opts, pb, current_time); +} + + static int ls_audio_format_compare(const void *a, const void *b) { struct ls_data *d1 = *(struct ls_data **)a, *d2 = *(struct ls_data **)b; @@ -825,7 +1109,7 @@ static int ls_path_compare(const void *a, const void *b) static int sort_matching_paths(struct ls_options *options) { size_t nmemb = options->num_matching_paths; - size_t size = sizeof(uint32_t); + size_t size = sizeof(*options->data_ptr); int (*compar)(const void *, const void *); int i; @@ -902,7 +1186,7 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) } if (options->num_patterns) { for (i = 0; i < options->num_patterns; i++) { - ret = fnmatch(options->patterns[i], path, FNM_PATHNAME); + ret = fnmatch(options->patterns[i], path, 0); if (!ret) break; if (ret == FNM_NOMATCH) @@ -941,8 +1225,8 @@ static int prepare_ls_row(struct osl_row *row, void *ls_opts) w->frequency_width = PARA_MAX(w->frequency_width, num_digits); GET_NUM_DIGITS(d->afsi.num_played, &num_digits); w->num_played_width = PARA_MAX(w->num_played_width, num_digits); - /* just get the number of chars to print this amount of time */ - tmp = get_duration(d->afhi.seconds_total, NULL, 0); + /* 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); if (options->flags & LS_FLAG_ADMISSIBLE_ONLY) { GET_NUM_DIGITS(score, &num_digits); @@ -960,14 +1244,14 @@ static int com_ls_callback(const struct osl_object *query, char *p, *pattern_start = (char *)query->data + sizeof(*opts); struct para_buffer b = {.buf = NULL, .size = 0}; int i = 0, ret; + time_t current_time; + - PARA_NOTICE_LOG("%d patterns\n", opts->num_patterns); if (opts->num_patterns) { opts->patterns = para_malloc(opts->num_patterns * sizeof(char *)); for (i = 0, p = pattern_start; i < opts->num_patterns; i++) { opts->patterns[i] = p; p += strlen(p) + 1; - PARA_NOTICE_LOG("pattern %d: %s\n", i, opts->patterns[i]); } } else opts->patterns = NULL; @@ -979,29 +1263,27 @@ static int com_ls_callback(const struct osl_object *query, if (ret < 0) goto out; ret = opts->num_patterns? -E_NO_MATCH : 0; - if (!opts->num_matching_paths) { - PARA_NOTICE_LOG("no match, ret: %d\n", ret); + if (!opts->num_matching_paths) goto out; - } ret = sort_matching_paths(opts); if (ret < 0) goto out; + time(¤t_time); if (opts->flags & LS_FLAG_REVERSE) for (i = opts->num_matching_paths - 1; i >= 0; i--) { - ret = print_list_item(opts->data_ptr[i], opts, &b); + ret = print_list_item(opts->data_ptr[i], opts, &b, current_time); if (ret < 0) break; } else for (i = 0; i < opts->num_matching_paths; i++) { - ret = print_list_item(opts->data_ptr[i], opts, &b); + ret = print_list_item(opts->data_ptr[i], opts, &b, current_time); if (ret < 0) break; } ret = 1; out: ls_output->data = b.buf; - PARA_NOTICE_LOG("ls_outoute.data: %p\n", ls_output->data); ls_output->size = b.size; free(opts->data); free(opts->data_ptr); @@ -1011,12 +1293,8 @@ out: /* * TODO: flags -h (sort by hash) - * - * long list: list hash, attributes as (xx--x-x-), file size, lastplayed - * full list: list everything, including afsi, afhi, atts as clear text - * - * */ -int com_afs_ls(int fd, int argc, char * const * const argv) + */ +int com_ls(int fd, int argc, char * const * const argv) { int i, ret; unsigned flags = 0; @@ -1054,6 +1332,9 @@ int com_afs_ls(int fd, int argc, char * const * const argv) case 'm': mode = LS_MODE_MBOX; continue; + case 'c': + mode = LS_MODE_CHUNKS; + continue; default: return -E_AFT_SYNTAX; } @@ -1114,7 +1395,6 @@ int com_afs_ls(int fd, int argc, char * const * const argv) } return -E_AFT_SYNTAX; } - time(&now); opts.flags = flags; opts.sorting = sort; opts.mode = mode; @@ -1151,160 +1431,196 @@ 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, - struct audio_format_info *afhi, uint32_t flags, +/* + * 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. -output: -~~~~~~~ -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 +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: Action performed by the callback. +~~~~~~~ +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 -#define ADD_FLAG_LAZY 1 -#define ADD_FLAG_FORCE 2 -#define ADD_FLAG_VERBOSE 4 +*/ -/* TODO: change log messages so that they get written to the result buffer */ +/** Flags passed to the add command. */ +enum com_add_flags { + /** Skip paths that exist already. */ + ADD_FLAG_LAZY = 1, + /** Force adding. */ + ADD_FLAG_FORCE = 2, + /** Print what is being done. */ + ADD_FLAG_VERBOSE = 4, + /** Try to add files with unknown suffixes. */ + ADD_FLAG_ALL = 8, +}; static int com_add_callback(const struct osl_object *query, - __a_unused struct osl_object *result) + struct osl_object *result) { char *buf = query->data, *path; struct osl_row *pb, *aft_row; - const struct osl_row *hs; + struct osl_row *hs; struct osl_object objs[NUM_AFT_COLUMNS]; HASH_TYPE *hash; 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}; - 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_DEBUG_LOG("request to add %s with hash %s\n", path, asc); + 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 (hs && pb && hs == pb && !(flags & ADD_FLAG_FORCE)) { if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("ignoring duplicate %p\n", path); - return 1; + para_printf(&msg, "ignoring duplicate\n"); + ret = 1; + goto out; } if (hs && hs != pb) { struct osl_object obj; if (pb) { /* hs trumps pb, remove pb */ if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("removing path brother\n"); + para_printf(&msg, "removing path brother\n"); ret = osl_del_row(audio_file_table, pb); if (ret < 0) - return ret; + goto out; pb = NULL; } /* file rename, update hs' path */ - ret = osl_get_object(audio_file_table, hs, AFTCOL_PATH, &obj); - if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("rename %s -> %s\n", (char *)obj.data, path); + if (flags & ADD_FLAG_VERBOSE) { + ret = osl_get_object(audio_file_table, hs, + AFTCOL_PATH, &obj); + 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]); if (ret < 0) - return ret; + goto out; + afs_event(AUDIO_FILE_RENAME, &msg, hs); if (!(flags & ADD_FLAG_FORCE)) - return ret; + 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); + uint16_t afhi_offset = read_u16(buf + CAB_AFHI_OFFSET_POS); + uint16_t chunks_offset = read_u16(buf + CAB_CHUNKS_OFFSET_POS); objs[AFTCOL_AFHI].data = buf + afhi_offset; objs[AFTCOL_AFHI].size = chunks_offset - afhi_offset; + ret = -E_NO_AFHI; if (!objs[AFTCOL_AFHI].size) /* "impossible" */ - return -E_NO_AFHI; + goto out; objs[AFTCOL_CHUNKS].data = buf + chunks_offset; objs[AFTCOL_CHUNKS].size = query->size - chunks_offset; if (pb && !hs) { /* update pb's hash */ @@ -1312,51 +1628,58 @@ static int com_add_callback(const struct osl_object *query, HASH_TYPE *old_hash; ret = get_hash_of_row(pb, &old_hash); if (ret < 0) - return ret; + goto out; hash_to_asc(old_hash, old_asc); if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("file change: %s %s -> %s\n", path, + para_printf(&msg, "file change: %s -> %s\n", old_asc, asc); ret = osl_update_object(audio_file_table, pb, AFTCOL_HASH, &objs[AFTCOL_HASH]); if (ret < 0) - return ret; + goto out; } if (hs || pb) { /* (hs != NULL and pb != NULL) implies hs == pb */ - const void *row = pb? pb : hs; + struct osl_row *row = pb? pb : hs; /* update afhi and chunk_table */ if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("updating audio format handler info (%zd bytes)\n", - objs[AFTCOL_AFHI].size); + para_printf(&msg, "updating afhi and chunk table\n"); ret = osl_update_object(audio_file_table, row, AFTCOL_AFHI, &objs[AFTCOL_AFHI]); if (ret < 0) - return ret; - if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("updating chunk table\n"); + goto out; ret = osl_update_object(audio_file_table, row, AFTCOL_CHUNKS, &objs[AFTCOL_CHUNKS]); if (ret < 0) - return ret; - ret = mood_update_audio_file(row, NULL); - if (ret < 0) - return ret; + 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"); 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); + afs_event(AUDIO_FILE_ADD, &msg, aft_row); +out: if (ret < 0) - return ret; - return mood_update_audio_file(aft_row, NULL); + para_printf(&msg, "%s\n", para_strerror(-ret)); + if (!msg.buf) + return 0; + result->data = msg.buf; + result->size = msg.size; + return 1; } +/** Used by com_add(). */ struct private_add_data { + /** The socket file descriptor. */ int fd; + /** The given add flags. */ uint32_t flags; }; @@ -1389,23 +1712,22 @@ static int hash_sister_callback(const struct osl_object *query, return 1; } -static int add_one_audio_file(const char *arg, const void *private_data) +static int add_one_audio_file(const char *path, const void *private_data) { - int ret; + int ret, send_ret = 1; uint8_t format_num = -1; const struct private_add_data *pad = private_data; - struct audio_format_info afhi, *afhi_ptr = NULL; + 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; - char *path = NULL; + struct osl_object map, obj = {.data = NULL}, query, result = {.data = NULL}; HASH_TYPE hash[HASH_SIZE]; afhi.header_offset = 0; afhi.header_len = 0; - ret = verify_path(arg, &path); - if (ret < 0) + ret = guess_audio_format(path); + if (ret < 0 && !(pad->flags & ADD_FLAG_ALL)) goto out_free; - query.data = path; + 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) @@ -1417,36 +1739,36 @@ static int add_one_audio_file(const char *arg, const void *private_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 = send_va_buffer(pad->fd, "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); + ret = mmap_full_file(path, O_RDONLY, &map.data, &map.size, NULL); 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; + goto out_unmap; if (ret >= 0) { hs = *(struct osl_row **)result.data; free(result.data); } /* 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, - "not forcing update: %s\n", path); + send_ret = send_va_buffer(pad->fd, + "%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); @@ -1455,25 +1777,32 @@ static int add_one_audio_file(const char *arg, const void *private_data) format_num = ret; afhi_ptr = &afhi; } - if (pad->flags & ADD_FLAG_VERBOSE) - send_va_buffer(pad->fd, "adding %s\n", path); munmap(map.data, map.size); - save_audio_file_info(hash, path, afhi_ptr, pad->flags, format_num, &obj); + if (pad->flags & ADD_FLAG_VERBOSE) { + send_ret = send_va_buffer(pad->fd, "adding %s\n", path); + if (send_ret < 0) + goto out_free; + } + save_add_callback_buffer(hash, path, afhi_ptr, pad->flags, format_num, &obj); /* Ask afs to consider this entry for adding. */ - ret = send_callback_request(com_add_callback, &obj, NULL); + ret = send_callback_request(com_add_callback, &obj, &result); + if (ret > 0) { + send_ret = send_va_buffer(pad->fd, "%s", (char *)result.data); + free(result.data); + } goto out_free; out_unmap: munmap(map.data, map.size); out_free: - if (ret < 0) - send_va_buffer(pad->fd, "failed to add %s (%s)\n", path? - path : arg, PARA_STRERROR(-ret)); + if (ret < 0 && send_ret >= 0) + send_ret = send_va_buffer(pad->fd, "failed to add %s (%s)\n", path, + para_strerror(-ret)); free(obj.data); - free(path); if (afhi_ptr) free(afhi_ptr->chunk_table); - return 1; /* it's not an error if not all files could be added */ + /* Stop adding files only on send errors. */ + return send_ret; } int com_add(int fd, int argc, char * const * const argv) @@ -1490,6 +1819,10 @@ int com_add(int fd, int argc, char * const * const argv) i++; break; } + if (!strcmp(arg, "-a")) { + pad.flags |= ADD_FLAG_ALL; + continue; + } if (!strcmp(arg, "-l")) { pad.flags |= ADD_FLAG_LAZY; continue; @@ -1506,81 +1839,155 @@ int com_add(int fd, int argc, char * const * const argv) if (argc <= i) return -E_AFT_SYNTAX; for (; i < argc; i++) { - char *path = para_strdup(argv[i]); - size_t len = strlen(path); - while (len > 1 && path[--len] == '/') - path[len] = '\0'; + char *path; + ret = verify_path(argv[i], &path); + if (ret < 0) { + ret = send_va_buffer(fd, "%s: %s\n", argv[i], + para_strerror(-ret)); + if (ret < 0) + return ret; + continue; + } ret = stat(path, &statbuf); - if (ret < 0) - PARA_NOTICE_LOG("failed to stat %s (%s)", path, + if (ret < 0) { + ret = send_va_buffer(fd, "failed to stat %s (%s)\n", path, strerror(errno)); + free(path); + if (ret < 0) + return ret; + continue; + } + if (S_ISDIR(statbuf.st_mode)) + ret = for_each_file_in_dir(path, add_one_audio_file, + &pad); else - if (S_ISDIR(statbuf.st_mode)) - for_each_file_in_dir(path, add_one_audio_file, - &pad); - else - add_one_audio_file(path, &pad); + ret = add_one_audio_file(path, &pad); + if (ret < 0) { + send_va_buffer(fd, "%s: %s\n", path, para_strerror(-ret)); + free(path); + return ret; + } free(path); } - ret = 1; - return ret; + return 1; } -struct com_touch_options { - long num_played; - long last_played; - long lyrics_id; - long image_id; +/** + * Flags used by the touch command. + * + * \sa com_touch(). + */ +enum touch_flags { + /** Whether the \p FNM_PATHNAME flag should be passed to fnmatch(). */ + TOUCH_FLAG_FNM_PATHNAME = 1, + /** Activates verbose mode. */ + TOUCH_FLAG_VERBOSE = 2 }; -static int com_touch_callback(const struct osl_object *query, - __a_unused struct osl_object *result) -{ - struct com_touch_options *cto = query->data; - char *p = (char *)query->data + sizeof(*cto); - size_t len; - int ret, no_options = cto->num_played < 0 && cto->last_played < 0 && - cto->lyrics_id < 0 && cto->image_id < 0; +/** Options used by com_touch(). */ +struct com_touch_options { + /** New num_played value. */ + int32_t num_played; + /** New last played count. */ + int64_t last_played; + /** new lyrics id. */ + int32_t lyrics_id; + /** new image id. */ + int32_t image_id; + /** command line flags (see \ref touch_flags). */ + unsigned flags; +}; - for (;p < (char *)query->data + query->size; p += len + 1) { - struct afs_info old_afsi, new_afsi; - struct osl_object obj; - struct osl_row *row; +/** Data passed to the action handler of com_touch(). */ +struct touch_action_data { + /** Command line options (see \ref com_touch_options). */ + struct com_touch_options *cto; + /** Message buffer. */ + struct para_buffer pb; + /** How many audio files matched the given pattern. */ + unsigned num_matches; +}; - len = strlen(p); - ret = aft_get_row_of_path(p, &row); - if (ret < 0) - return ret; - ret = get_afsi_object_of_row(row, &obj); - if (ret < 0) - return ret; - ret = load_afsi(&old_afsi, &obj); - if (ret < 0) - return ret; - new_afsi = old_afsi; - if (no_options) { - new_afsi.num_played++; - new_afsi.last_played = time(NULL); - } else { - if (cto->lyrics_id >= 0) - new_afsi.lyrics_id = cto->lyrics_id; - if (cto->image_id >= 0) - new_afsi.image_id = cto->image_id; - if (cto->num_played >= 0) - new_afsi.num_played = cto->num_played; - if (cto->last_played >= 0) - new_afsi.last_played = cto->last_played; - } - save_afsi(&new_afsi, &obj); /* in-place update */ - ret = mood_update_audio_file(row, &old_afsi); - if (ret < 0) - return ret; +static int touch_audio_file(__a_unused struct osl_table *table, + struct osl_row *row, const char *name, void *data) +{ + struct touch_action_data *tad = data; + struct 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; + 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; + } + ret = load_afsi(&old_afsi, &obj); + if (ret < 0) { + para_printf(&tad->pb, "%s: %s\n", name, para_strerror(-ret)); + return 1; } + 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, " + "last_played = now()\n", name, + new_afsi.num_played); + } else { + if (tad->cto->flags & TOUCH_FLAG_VERBOSE) + para_printf(&tad->pb, "touching %s\n", name); + if (tad->cto->lyrics_id >= 0) + new_afsi.lyrics_id = tad->cto->lyrics_id; + if (tad->cto->image_id >= 0) + new_afsi.image_id = tad->cto->image_id; + if (tad->cto->num_played >= 0) + new_afsi.num_played = tad->cto->num_played; + if (tad->cto->last_played >= 0) + new_afsi.last_played = tad->cto->last_played; + } + tad->num_matches++; + save_afsi(&new_afsi, &obj); /* in-place update */ + aced.aft_row = row; + aced.old_afsi = &old_afsi; + afs_event(AFSI_CHANGE, &tad->pb, &aced); return 1; } -int com_touch(__a_unused int fd, int argc, char * const * const argv) +static int com_touch_callback(const struct osl_object *query, + struct osl_object *result) +{ + struct touch_action_data tad = {.cto = query->data}; + int ret; + struct pattern_match_data pmd = { + .table = audio_file_table, + .loop_col_num = AFTCOL_HASH, + .match_col_num = AFTCOL_PATH, + .patterns = {.data = (char *)query->data + sizeof(*tad.cto), + .size = query->size - sizeof(*tad.cto)}, + .data = &tad, + .action = touch_audio_file + }; + if (tad.cto->flags & TOUCH_FLAG_FNM_PATHNAME) + pmd.fnmatch_flags |= FNM_PATHNAME; + ret = for_each_matching_row(&pmd); + if (ret < 0) + para_printf(&tad.pb, "%s\n", para_strerror(-ret)); + else + if (!tad.num_matches) + para_printf(&tad.pb, "no matches\n"); + if (tad.pb.buf) { + result->data = tad.pb.buf; + result->size = tad.pb.size; + return 1; + } + return ret < 0? ret : 0; +} + +int com_touch(int fd, int argc, char * const * const argv) { struct com_touch_options cto = { .num_played = -1, @@ -1588,7 +1995,8 @@ int com_touch(__a_unused int fd, int argc, char * const * const argv) .lyrics_id = -1, .image_id = -1 }; - struct osl_object options = {.data = &cto, .size = sizeof(cto)}; + struct osl_object query = {.data = &cto, .size = sizeof(cto)}, + result; int i, ret; @@ -1601,79 +2009,281 @@ int com_touch(__a_unused int fd, int argc, char * const * const argv) break; } if (!strncmp(arg, "-n", 2)) { - ret = para_atol(arg + 2, &cto.num_played); + ret = para_atoi32(arg + 2, &cto.num_played); if (ret < 0) - goto err; + return ret; continue; } if (!strncmp(arg, "-l", 2)) { - ret = para_atol(arg + 2, &cto.last_played); + ret = para_atoi64(arg + 2, &cto.last_played); if (ret < 0) - goto err; + return ret; continue; } if (!strncmp(arg, "-y", 2)) { - ret = para_atol(arg + 2, &cto.lyrics_id); + ret = para_atoi32(arg + 2, &cto.lyrics_id); if (ret < 0) - goto err; + return ret; continue; } if (!strncmp(arg, "-i", 2)) { - ret = para_atol(arg + 2, &cto.image_id); + ret = para_atoi32(arg + 2, &cto.image_id); if (ret < 0) - goto err; + return ret; + continue; + } + if (!strcmp(arg, "-p")) { + cto.flags |= TOUCH_FLAG_FNM_PATHNAME; + continue; + } + if (!strcmp(arg, "-v")) { + cto.flags |= TOUCH_FLAG_VERBOSE; continue; } + break; /* non-option starting with dash */ } - ret = -E_AFT_SYNTAX; if (i >= argc) - goto err; - return send_option_arg_callback_request(&options, argc - i, - argv + i, com_touch_callback, NULL); -err: + return -E_AFT_SYNTAX; + ret = send_option_arg_callback_request(&query, argc - i, + argv + i, com_touch_callback, &result); + if (!ret) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); return ret; } -struct com_rm_options { +/** Flags for com_rm(). */ +enum rm_flags { + /** -v */ + RM_FLAG_VERBOSE = 1, + /** -f */ + RM_FLAG_FORCE = 2, + /** -p */ + RM_FLAG_FNM_PATHNAME = 4 +}; + +/** Data passed to the action handler of com_rm(). */ +struct com_rm_action_data { + /** Command line flags ((see \ref rm_flags). */ uint32_t flags; + /** Message buffer. */ + struct para_buffer pb; + /** Number of audio files removed. */ + unsigned num_removed; }; +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; + + if (crd->flags & RM_FLAG_VERBOSE) + para_printf(&crd->pb, "removing %s\n", name); + afs_event(AUDIO_FILE_REMOVE, &crd->pb, row); + ret = osl_del_row(audio_file_table, row); + if (ret < 0) + para_printf(&crd->pb, "%s: %s\n", name, para_strerror(-ret)); + else + crd->num_removed++; + return 1; +} + static int com_rm_callback(const struct osl_object *query, __a_unused struct osl_object *result) { - struct com_rm_options *cro = query->data; - char *p = (char *)query->data + sizeof(*cro); - size_t len; + struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data}; int ret; + struct pattern_match_data pmd = { + .table = audio_file_table, + .loop_col_num = AFTCOL_HASH, + .match_col_num = AFTCOL_PATH, + .patterns = {.data = (char *)query->data + sizeof(uint32_t), + .size = query->size - sizeof(uint32_t)}, + .data = &crd, + .action = remove_audio_file + }; + 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 (!crd.num_removed && !(crd.flags & RM_FLAG_FORCE)) + 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); + } + if (crd.pb.buf) { + result->data = crd.pb.buf; + result->size = crd.pb.size; + return 1; + } + return ret < 0? ret : 0; +} - for (;p < (char *)query->data + query->size; p += len + 1) { - struct osl_row *row; +/* TODO options: -r (recursive) */ +int com_rm(int fd, int argc, char * const * const argv) +{ + uint32_t flags = 0; + struct osl_object query = {.data = &flags, .size = sizeof(flags)}, + result; + int i, ret; - len = strlen(p); - ret = aft_get_row_of_path(p, &row); - if (ret < 0) - return ret; - ret = mood_delete_audio_file(row); - if (ret < 0) - return ret; - ret = osl_del_row(audio_file_table, row); - if (ret < 0) - return ret; + for (i = 1; i < argc; i++) { + const char *arg = argv[i]; + if (arg[0] != '-') + break; + if (!strcmp(arg, "--")) { + i++; + break; + } + if (!strcmp(arg, "-f")) { + flags |= RM_FLAG_FORCE; + continue; + } + if (!strcmp(arg, "-p")) { + flags |= RM_FLAG_FNM_PATHNAME; + continue; + } + if (!strcmp(arg, "-v")) { + flags |= RM_FLAG_VERBOSE; + continue; + } + break; } - return 1; + if (i >= argc) + return -E_AFT_SYNTAX; + ret = send_option_arg_callback_request(&query, argc - i, argv + i, + com_rm_callback, &result); + if (!ret) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); + return ret; } -/* - * TODO options: -v verbose, -f dont stop if file not found - * -h remove by hash, use fnmatch +/** + * Flags used by the cpsi command. * - * */ + * \sa com_cpsi(). + */ +enum cpsi_flags { + /** Whether the lyrics id should be copied. */ + CPSI_FLAG_COPY_LYRICS_ID = 1, + /** Whether the image id should be copied. */ + CPSI_FLAG_COPY_IMAGE_ID = 2, + /** Whether the lastplayed time should be copied. */ + CPSI_FLAG_COPY_LASTPLAYED = 4, + /** Whether the numplayed count should be copied. */ + CPSI_FLAG_COPY_NUMPLAYED = 8, + /** Whether the attributes should be copied. */ + CPSI_FLAG_COPY_ATTRIBUTES = 16, + /** Activates verbose mode. */ + CPSI_FLAG_VERBOSE = 32, +}; + +/** Data passed to the action handler of com_cpsi(). */ +struct cpsi_action_data { + /** command line flags (see \ref cpsi_flags). */ + unsigned flags; + /** Number of audio files changed. */ + unsigned num_copied; + /** Message buffer. */ + struct para_buffer pb; + /** Values are copied from here. */ + struct afs_info source_afsi; +}; + +static int copy_selector_info(__a_unused struct osl_table *table, + struct osl_row *row, const char *name, void *data) +{ + struct cpsi_action_data *cad = data; + struct osl_object target_afsi_obj; + int ret; + struct afs_info old_afsi, target_afsi; + struct afsi_change_event_data aced; + + ret = get_afsi_object_of_row(row, &target_afsi_obj); + if (ret < 0) + return ret; + load_afsi(&target_afsi, &target_afsi_obj); + old_afsi = target_afsi; + if (cad->flags & CPSI_FLAG_COPY_LYRICS_ID) + target_afsi.lyrics_id = cad->source_afsi.lyrics_id; + if (cad->flags & CPSI_FLAG_COPY_IMAGE_ID) + target_afsi.image_id = cad->source_afsi.image_id; + if (cad->flags & CPSI_FLAG_COPY_LASTPLAYED) + target_afsi.last_played = cad->source_afsi.last_played; + if (cad->flags & CPSI_FLAG_COPY_NUMPLAYED) + target_afsi.num_played = cad->source_afsi.num_played; + if (cad->flags & CPSI_FLAG_COPY_ATTRIBUTES) + 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); + 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) +{ + struct cpsi_action_data cad = {.flags = *(unsigned *)query->data}; + 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, + .match_col_num = AFTCOL_PATH, + .patterns = {.data = source_path + strlen(source_path) + 1, + .size = query->size - sizeof(cad.flags) + - strlen(source_path) - 1}, + .data = &cad, + .action = copy_selector_info + }; + 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) { + if (cad.num_copied) + para_printf(&cad.pb, "copied requested afsi from %s " + "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; +} -int com_afs_rm(__a_unused int fd, int argc, char * const * const argv) +int com_cpsi(int fd, int argc, char * const * const argv) { - struct com_rm_options cro = {.flags = 0}; - struct osl_object options = {.data = &cro, .size = sizeof(cro)}; + unsigned flags = 0; int i, ret; + struct osl_object options = {.data = &flags, .size = sizeof(flags)}, + result; for (i = 1; i < argc; i++) { const char *arg = argv[i]; @@ -1683,53 +2293,193 @@ int com_afs_rm(__a_unused int fd, int argc, char * const * const argv) i++; break; } + if (!strcmp(arg, "-y")) { + flags |= CPSI_FLAG_COPY_LYRICS_ID; + continue; + } + if (!strcmp(arg, "-i")) { + flags |= CPSI_FLAG_COPY_IMAGE_ID; + continue; + } + if (!strcmp(arg, "-l")) { + flags |= CPSI_FLAG_COPY_LASTPLAYED; + continue; + } + if (!strcmp(arg, "-n")) { + flags |= CPSI_FLAG_COPY_NUMPLAYED; + continue; + } + if (!strcmp(arg, "-a")) { + flags |= CPSI_FLAG_COPY_ATTRIBUTES; + continue; + } + if (!strcmp(arg, "-v")) { + flags |= CPSI_FLAG_VERBOSE; + continue; + } + break; } - ret = -E_AFT_SYNTAX; - if (i >= argc) - goto err; - return send_option_arg_callback_request(&options, argc - i, - argv + i, com_rm_callback, NULL); -err: + if (i + 1 >= argc) /* need at least souce 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) + return 0; + if (ret < 0) { + send_va_buffer(fd, "%s\n", para_strerror(-ret)); + return ret; + } + ret = send_buffer(fd, (char *)result.data); + free(result.data); return ret; } +/* TODO: optionally fix problems by removing offending rows */ +static int check_audio_file(struct osl_row *row, void *data) +{ + char *path; + struct para_buffer *pb = data; + struct stat statbuf; + int ret = get_audio_file_path_of_row(row, &path); + 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); + } + ret = get_afsi_of_row(row, &afsi); + if (ret < 0) { + para_printf(pb, "%s: %s\n", path, para_strerror(-ret)); + return 1; + } + ret = lyr_get_name_by_id(afsi.lyrics_id, &blob_name); + if (ret < 0) + para_printf(pb, "%s lyrics id %u: %s\n", path, afsi.lyrics_id, + para_strerror(-ret)); + ret = img_get_name_by_id(afsi.image_id, &blob_name); + if (ret < 0) + para_printf(pb, "%s image id %u: %s\n", path, afsi.image_id, + para_strerror(-ret)); + return 1; +} + +/** + * Check the audio file table for inconsistencies. + * + * \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) +{ + struct para_buffer pb = {.buf = NULL}; + + para_printf(&pb, "checking audio file table...\n"); + audio_file_loop(&pb, check_audio_file); + result->data = pb.buf; + result->size = pb.size; + return 1; + +} + /** * Close the audio file table. * - * \param flags Ususal flags that are passed to osl_close_table(). + * \param flags Usual flags that are passed to osl_close_table(). * * \sa osl_close_table(). */ -void aft_shutdown(enum osl_close_flags flags) +static void aft_close(void) { - osl_close_table(audio_file_table, flags); + osl_close_table(audio_file_table, OSL_MARK_CLEAN); + audio_file_table = NULL; } /** * Open the audio file table. * - * \param ti Gets initialized by this function. - * \param db The database directory. + * \param dir The database directory. * - * \return Positive on success, negative on errors. + * \return Standard. * * \sa osl_open_table(). */ -int aft_init(struct table_info *ti, const char *db) +static int aft_open(const char *dir) { int ret; - audio_file_table_desc.dir = db; - ti->desc = &audio_file_table_desc; - ret = osl_open_table(ti->desc, &ti->table); + audio_file_table_desc.dir = dir; + ret = osl_open_table(&audio_file_table_desc, &audio_file_table); if (ret >= 0) { unsigned num; - audio_file_table = ti->table; osl_get_num_rows(audio_file_table, &num); PARA_INFO_LOG("audio file table contains %d files\n", num); return ret; } PARA_INFO_LOG("failed to open audio file table\n"); audio_file_table = NULL; - return ret == -E_NOENT? 1 : ret; + if (ret >= 0 || is_errno(-ret, ENOENT)) + return 1; + return ret; +} + +static int aft_create(const char *dir) +{ + audio_file_table_desc.dir = dir; + return osl_create_table(&audio_file_table_desc); +} + +static int clear_attribute(struct osl_row *row, void *data) +{ + struct rmatt_event_data *red = data; + struct afs_info afsi; + struct osl_object obj; + int ret = get_afsi_object_of_row(row, &obj); + uint64_t mask = ~(1ULL << red->bitnum); + + if (ret < 0) + return ret; + ret = load_afsi(&afsi, &obj); + if (ret < 0) + return ret; + afsi.attributes &= mask; + save_afsi(&afsi, &obj); + return 1; +} + +static int aft_event_handler(enum afs_events event, struct para_buffer *pb, + void *data) +{ + switch(event) { + case ATTRIBUTE_REMOVE: { + const struct rmatt_event_data *red = data; + para_printf(pb, "clearing attribute %s (bit %u) from all " + "entries in the audio file table\n", red->name, + red->bitnum); + return audio_file_loop(data, clear_attribute); + } + default: + return 1; + } +} + +void aft_init(struct afs_table *t) +{ + t->name = audio_file_table_desc.name; + t->open = aft_open; + t->close = aft_close; + t->create = aft_create; + t->event_handler = aft_event_handler; }