X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=aft.c;h=423731f6b70e770f4b84924bbf9e3640b8e8ba51;hp=aaeab8a39f22abd9e2855eb1d354939c46431111;hb=a8509af9116e9a045ace70ff312e40569c5ace16;hpb=f6f50d03a09d6bc423324206d274336e9905bbb4;ds=inline diff --git a/aft.c b/aft.c index aaeab8a3..423731f6 100644 --- a/aft.c +++ b/aft.c @@ -2,18 +2,18 @@ #include "error.h" #include #include +#include "afh.h" #include "afs.h" +#include "net.h" #include "string.h" - -int mp3_get_file_info(char *map, size_t numbytes, - struct audio_format_info *afi); /* FXIME */ +#include "vss.h" #define AFS_AUDIO_FILE_DIR "/home/mp3" -static void *audio_file_table; +static struct osl_table *audio_file_table; /** - * Describes the structure of the mmapped-afs info struct. + * Describes the layout of the mmapped-afs info struct. * * \sa struct afs_info. */ @@ -44,19 +44,8 @@ enum afsi_offsets { */ void save_afsi(struct afs_info *afsi, struct osl_object *obj) { - struct afs_info default_afs_info = { - .last_played = time(NULL) - 365 * 24 * 60 * 60, - .attributes = 0, - .num_played = 0, - .image_id = 0, - .lyrics_id = 0, - .audio_format_id = 5, /* FIXME */ - }; char *buf = obj->data; - if (!afsi) - afsi = &default_afs_info; - write_u64(buf + AFSI_LAST_PLAYED_OFFSET, afsi->last_played); write_u64(buf + AFSI_ATTRIBUTES_OFFSET, afsi->attributes); write_u32(buf + AFSI_NUM_PLAYED_OFFSET, afsi->num_played); @@ -80,7 +69,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); @@ -137,8 +126,7 @@ static struct osl_column_description aft_cols[] = { } }; -static const struct osl_table_description audio_file_table_desc = { - .dir = DATABASE_DIR, +static struct osl_table_description audio_file_table_desc = { .name = "audio_files", .num_columns = NUM_AFT_COLUMNS, .flags = OSL_LARGE_TABLE, @@ -217,40 +205,38 @@ static int verify_dotfile(const char *rest) return 1; } -static int verify_path(const char *path, char **resolved_path) +static int verify_path(const char *orig_path, char **resolved_path) { - const char *orig_path = path; char c; const char prefix[] = AFS_AUDIO_FILE_DIR "/"; + const char *path = orig_path; const size_t prefix_len = strlen(prefix); - PARA_DEBUG_LOG("path: %s\n", path); c = *path++; if (!c) - return -E_BAD_PATH; + goto bad_path; while (c) { if (c == '/') { c = *path++; switch (c) { default: continue; - case '/': case '\0': - break; + case '/': /* double slash */ + goto bad_path; case '.': - if (verify_dotfile(path) > 0) - continue; + if (verify_dotfile(path) < 0) + goto bad_path; } - *resolved_path = NULL; - return -E_BAD_PATH; } c = *path++; } - if (*orig_path == '/') - *resolved_path = prefix_path("", 0, orig_path); - else + if (*orig_path != '/') *resolved_path = prefix_path(prefix, prefix_len, orig_path); - PARA_DEBUG_LOG("resolved: %s\n", *resolved_path); - return *resolved_path? 1: -E_BAD_PATH; + else + *resolved_path = para_strdup(orig_path); + return 1; +bad_path: + return -E_BAD_PATH; } enum afhi_offsets { @@ -300,7 +286,7 @@ static unsigned sizeof_chunk_info_buf(struct audio_format_info *afhi) } /** The offsets of the data contained in the AFTCOL_CHUNKS column. */ -enum chunk_info_offsets { +enum chunk_info_offsets{ /** The total number of chunks (4 bytes). */ CHUNKS_TOTAL_OFFSET = 0, /** The length of the audio file header (4 bytes). */ @@ -364,6 +350,7 @@ static int load_chunk_info(struct osl_object *obj, struct audio_format_info *afh int aft_get_row_of_path(char *path, struct osl_row **row) { struct osl_object obj = {.data = path, .size = strlen(path) + 1}; + return osl_get_row(audio_file_table, AFTCOL_PATH, &obj, row); } @@ -389,7 +376,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); } @@ -458,7 +445,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); } @@ -474,7 +461,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); @@ -495,7 +482,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) +static int get_afhi_of_row(const struct osl_row *row, struct audio_format_info *afhi) { struct osl_object obj; int ret = osl_get_object(audio_file_table, row, AFTCOL_AFHI, @@ -516,7 +503,7 @@ int get_afhi_of_row(const void *row, struct audio_format_info *afhi) * * \sa get_afhi_of_row(). */ -int get_chunk_table_of_row(const void *row, struct audio_format_info *afhi) +static int get_chunk_table_of_row(const struct osl_row *row, struct audio_format_info *afhi) { struct osl_object obj; int ret = osl_open_disk_object(audio_file_table, row, AFTCOL_CHUNKS, @@ -585,15 +572,14 @@ err: 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) { struct tm t; if (!localtime_r((time_t *)seconds, &t)) return -E_LOCALTIME; - if (*seconds + 6 * 30 * 24 * 3600 > now) { + if (*seconds + 6 * 30 * 24 * 3600 > current_time) { if (!strftime(buf, size, "%b %e %k:%M", &t)) return -E_STRFTIME; return 1; @@ -613,25 +599,27 @@ 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, short unsigned max_width) +{ + unsigned hours = seconds / 3600, mins = (seconds % 3600) / 60; + + if (!hours) /* m:ss or mm:ss */ + sprintf(buf, "%*u:%02u", max_width - 3, mins, seconds % 60); + else /* more than one hour => h:mm:ss, hh:mm:ss, hhh:mm:ss, ... */ + 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) @@ -665,7 +653,7 @@ static char *make_image_line(struct afs_info *afsi) } 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]; @@ -683,10 +671,10 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, } 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); if (ret < 0) return ret; - get_duration(afhi->seconds_total, duration_buf, w->duration_width); + get_duration_buf(afhi->seconds_total, duration_buf, w->duration_width); if (have_score) { if (opts->mode == LS_MODE_LONG) sprintf(score_buf, "%*li ", w->score_width, d->score); @@ -694,6 +682,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, sprintf(score_buf, "%li ", d->score); } + PARA_NOTICE_LOG("id: %s, %d\n", d->path, afsi->audio_format_id); if (opts->mode == LS_MODE_LONG) { para_printf(b, "%s" /* score */ @@ -713,7 +702,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, w->image_id_width, afsi->image_id, w->lyrics_id_width, afsi->lyrics_id, w->bitrate_width, afhi->bitrate, - "mp3", /* FIXME */ + audio_format_name(afsi->audio_format_id), w->frequency_width, afhi->frequency, afhi->channels, duration_buf, @@ -724,7 +713,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, return 1; } if (opts->mode == LS_MODE_VERBOSE) { - HASH_TYPE asc_hash[2 * HASH_SIZE + 1]; + char asc_hash[2 * HASH_SIZE + 1]; char *att_line, *lyrics_line, *image_line; hash_to_asc(d->hash, asc_hash); @@ -754,7 +743,7 @@ static int print_list_item(struct ls_data *d, struct ls_options *opts, image_line, lyrics_line, afhi->bitrate, - "mp3", /* FIXME */ + audio_format_name(afsi->audio_format_id), afhi->frequency, afhi->channels, duration_buf, @@ -838,7 +827,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; @@ -954,8 +943,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); @@ -973,6 +962,8 @@ 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) { @@ -991,7 +982,7 @@ static int com_ls_callback(const struct osl_object *query, prepare_ls_row); if (ret < 0) goto out; - ret = opts->num_patterns? -E_NO_MATCH : 1; + ret = opts->num_patterns? -E_NO_MATCH : 0; if (!opts->num_matching_paths) { PARA_NOTICE_LOG("no match, ret: %d\n", ret); goto out; @@ -999,21 +990,23 @@ static int com_ls_callback(const struct osl_object *query, 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); @@ -1022,13 +1015,13 @@ out: } /* - * TODO: flags -h (sort by hash) + * TODO: flags -h (sort by hash) -lm (list in mbox format) * * 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(__a_unused int fd, int argc, const char **argv) +int com_afs_ls(int fd, int argc, char * const * const argv) { int i, ret; unsigned flags = 0; @@ -1126,15 +1119,14 @@ int com_afs_ls(__a_unused int fd, int argc, const char **argv) } return -E_AFT_SYNTAX; } - time(&now); opts.flags = flags; opts.sorting = sort; opts.mode = mode; opts.num_patterns = argc - i; ret = send_option_arg_callback_request(&query, opts.num_patterns, argv + i, com_ls_callback, &ls_output); - if (ret >= 0 && ls_output.data) { - printf("%s\n", (char *)ls_output.data); + if (ret > 0) { + ret = send_buffer(fd, (char *)ls_output.data); free(ls_output.data); } return ret; @@ -1154,7 +1146,7 @@ int audio_file_loop(void *private_data, osl_rbtree_loop_func *func) func); } -static void *find_hash_sister(HASH_TYPE *hash) +static struct osl_row *find_hash_sister(HASH_TYPE *hash) { const struct osl_object obj = {.data = hash, .size = HASH_SIZE}; struct osl_row *row; @@ -1163,21 +1155,20 @@ static void *find_hash_sister(HASH_TYPE *hash) return row; } -#define AFTROW_HEADER_SIZE 4 - enum aft_row_offsets { AFTROW_AFHI_OFFSET_POS = 0, AFTROW_CHUNKS_OFFSET_POS = 2, - AFTROW_HASH_OFFSET = AFTROW_HEADER_SIZE, - AFTROW_FLAGS_OFFSET = (AFTROW_HASH_OFFSET + HASH_SIZE), - AFTROW_PATH_OFFSET = (AFTROW_FLAGS_OFFSET + 4) + AFTROW_AUDIO_FORMAT_OFFSET = 4, + AFTROW_FLAGS_OFFSET = 5, + AFTROW_HASH_OFFSET = 9, + AFTROW_PATH_OFFSET = (AFTROW_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, struct osl_object *obj) + struct audio_format_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); @@ -1186,13 +1177,15 @@ static void save_audio_file_info(HASH_TYPE *hash, const char *path, char *buf = para_malloc(size); uint16_t pos; - memcpy(buf + AFTROW_HASH_OFFSET, hash, HASH_SIZE); + write_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET, audio_format_num); write_u32(buf + AFTROW_FLAGS_OFFSET, flags); + + memcpy(buf + AFTROW_HASH_OFFSET, hash, HASH_SIZE); strcpy(buf + AFTROW_PATH_OFFSET, path); pos = AFTROW_PATH_OFFSET + path_len; PARA_DEBUG_LOG("size: %zu, afhi starts at %d\n", size, pos); - PARA_DEBUG_LOG("last afhi byte: %p, pos %d\n", buf + pos + afhi_size - 1, + 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); save_afhi(afhi, buf + pos); @@ -1252,6 +1245,8 @@ afhi <=> force or no HS #define ADD_FLAG_FORCE 2 #define ADD_FLAG_VERBOSE 4 +/* TODO: change log messages so that they get written to the result buffer */ + static int com_add_callback(const struct osl_object *query, __a_unused struct osl_object *result) { @@ -1264,8 +1259,9 @@ static int com_add_callback(const struct osl_object *query, int ret; char afsi_buf[AFSI_SIZE]; uint32_t flags = read_u32(buf + AFTROW_FLAGS_OFFSET); + struct afs_info default_afsi = {.last_played = 0}; - hash = buf + AFTROW_HASH_OFFSET; + hash = (HASH_TYPE *)buf + AFTROW_HASH_OFFSET; hash_to_asc(hash, asc);; objs[AFTCOL_HASH].data = buf + AFTROW_HASH_OFFSET; objs[AFTCOL_HASH].size = HASH_SIZE; @@ -1274,7 +1270,7 @@ static int com_add_callback(const struct osl_object *query, 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) @@ -1331,31 +1327,30 @@ static int com_add_callback(const struct osl_object *query, return ret; } if (hs || pb) { /* (hs != NULL and pb != NULL) implies hs == pb */ - const void *row = pb? pb : hs; + const 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", + PARA_DEBUG_LOG("updating audio format handler info (%zd bytes)\n", objs[AFTCOL_AFHI].size); 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"); + PARA_DEBUG_LOG("updating chunk table\n"); 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; + return mood_update_audio_file(row, NULL); } /* new entry, use default afsi */ - if (flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("adding %s\n", path); + default_afsi.last_played = time(NULL) - 365 * 24 * 60 * 60; + default_afsi.audio_format_id = read_u8(buf + AFTROW_AUDIO_FORMAT_OFFSET); + objs[AFTCOL_AFSI].data = &afsi_buf; objs[AFTCOL_AFSI].size = AFSI_SIZE; - save_afsi(NULL, &objs[AFTCOL_AFSI]); + save_afsi(&default_afsi, &objs[AFTCOL_AFSI]); ret = osl_add_and_get_row(audio_file_table, objs, &aft_row); if (ret < 0) return ret; @@ -1367,43 +1362,88 @@ struct private_add_data { uint32_t flags; }; +static int path_brother_callback(const struct osl_object *query, + struct osl_object *result) +{ + char *path = query->data; + struct osl_row *path_brother; + int ret = aft_get_row_of_path(path, &path_brother); + if (ret < 0) + return ret; + result->data = para_malloc(sizeof(path_brother)); + result->size = sizeof(path_brother); + *(struct osl_row **)(result->data) = path_brother; + return 1; +} + +static int hash_sister_callback(const struct osl_object *query, + struct osl_object *result) +{ + HASH_TYPE *hash = query->data; + struct osl_row *hash_sister; + + hash_sister = find_hash_sister(hash); + if (!hash_sister) + return -E_RB_KEY_NOT_FOUND; + result->data = para_malloc(sizeof(hash_sister)); + result->size = sizeof(hash_sister); + *(struct osl_row **)(result->data) = hash_sister; + return 1; +} + static int add_one_audio_file(const char *arg, const void *private_data) { int ret; + uint8_t format_num = -1; const struct private_add_data *pad = private_data; struct audio_format_info afhi, *afhi_ptr = NULL; - struct osl_row *pb, *hs; /* path brother/hash sister */ - struct osl_object map, obj = {.data = NULL}; - char *path; + struct osl_row *pb = NULL, *hs = NULL; /* path brother/hash sister */ + struct osl_object map, obj = {.data = NULL}, query, result; + char *path = NULL; HASH_TYPE hash[HASH_SIZE]; afhi.header_offset = 0; afhi.header_len = 0; ret = verify_path(arg, &path); if (ret < 0) - return ret; - ret = aft_get_row_of_path(path, &pb); + goto out_free; + query.data = path; + query.size = strlen(path) + 1; + ret = send_callback_request(path_brother_callback, &query, &result); if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) goto out_free; + if (ret >= 0) { + pb = *(struct osl_row **)result.data; + free(result.data); + } ret = 1; if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */ if (pad->flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("lazy-ignore: %s\n", path); + ret = send_va_buffer(pad->fd, "lazy-ignore: %s\n", path); goto out_free; } - /* we still want to add this file. Compute its hash and look it up */ + /* We still want to add this file. Compute its hash. */ ret = mmap_full_file(path, O_RDONLY, &map); if (ret < 0) goto out_free; hash_function(map.data, map.size, hash); - hs = find_hash_sister(hash); - /* - * return success if we're pretty sure that we already know this file - */ + + /* Check whether database contains file with the same hash. */ + query.data = hash; + query.size = HASH_SIZE; + ret = send_callback_request(hash_sister_callback, &query, &result); + if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) + goto out_free; + if (ret >= 0) { + hs = *(struct osl_row **)result.data; + free(result.data); + } + /* Return success if we already know this file. */ ret = 1; if (pb && hs && hs == pb && (!(pad->flags & ADD_FLAG_FORCE))) { if (pad->flags & ADD_FLAG_VERBOSE) - PARA_NOTICE_LOG("not forcing update: %s\n", path); + ret = send_va_buffer(pad->fd, + "not forcing update: %s\n", path); goto out_unmap; } /* @@ -1411,31 +1451,34 @@ static int add_one_audio_file(const char *arg, const void *private_data) * there is a hash sister unless in FORCE mode. */ if (!hs || (pad->flags & ADD_FLAG_FORCE)) { - ret = mp3_get_file_info(map.data, map.size, &afhi); - if (ret < 0) { - PARA_WARNING_LOG("audio format of %s not recognized, skipping\n", path); - ret = 1; + ret = compute_afhi(path, map.data, map.size, &afhi); + if (ret < 0) goto out_unmap; - } + 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, &obj); - /* ask parent to consider this entry for adding */ + save_audio_file_info(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); 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)); free(obj.data); free(path); if (afhi_ptr) free(afhi_ptr->chunk_table); - return ret; + return 1; /* it's not an error if not all files could be added */ } -int com_add(int fd, int argc, const char **argv) +int com_add(int fd, int argc, char * const * const argv) { int i, ret; struct private_add_data pad = {.fd = fd, .flags = 0}; @@ -1465,22 +1508,23 @@ int com_add(int fd, int argc, const char **argv) if (argc <= i) return -E_AFT_SYNTAX; for (; i < argc; i++) { - ret = stat(argv[i], &statbuf); + char *path = para_strdup(argv[i]); + size_t len = strlen(path); + while (len > 1 && path[--len] == '/') + path[len] = '\0'; + ret = stat(path, &statbuf); if (ret < 0) - return -E_AFS_STAT; - if (S_ISDIR(statbuf.st_mode)) { - ret = for_each_file_in_dir(argv[i], - add_one_audio_file, &pad); - if (ret < 0) - return ret; - continue; - } - ret = add_one_audio_file(argv[i], &pad); - if (ret < 0) - goto out; + PARA_NOTICE_LOG("failed to stat %s (%s)", path, + strerror(errno)); + 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); + free(path); } ret = 1; -out: return ret; } @@ -1538,7 +1582,7 @@ static int com_touch_callback(const struct osl_object *query, return 1; } -int com_touch(__a_unused int fd, int argc, const char **argv) +int com_touch(__a_unused int fd, int argc, char * const * const argv) { struct com_touch_options cto = { .num_played = -1, @@ -1627,7 +1671,7 @@ static int com_rm_callback(const struct osl_object *query, * * */ -int com_afs_rm(__a_unused int fd, int argc, const char **argv) +int com_afs_rm(__a_unused int fd, int argc, char * const * const argv) { struct com_rm_options cro = {.flags = 0}; struct osl_object options = {.data = &cro, .size = sizeof(cro)}; @@ -1661,21 +1705,24 @@ err: void aft_shutdown(enum osl_close_flags flags) { osl_close_table(audio_file_table, flags); + audio_file_table = NULL; } /** * Open the audio file table. * - * \param ti Gets initialized by this function + * \param ti Gets initialized by this function. + * \param db The database directory. * * \return Positive on success, negative on errors. * * \sa osl_open_table(). */ -int aft_init(struct table_info *ti) +int aft_init(struct table_info *ti, const char *db) { int ret; + audio_file_table_desc.dir = db; ti->desc = &audio_file_table_desc; ret = osl_open_table(ti->desc, &ti->table); if (ret >= 0) { @@ -1685,6 +1732,7 @@ int aft_init(struct table_info *ti) 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; }