-/*
- * Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
/** \file aft.c Audio file table functions. */
#include "sideband.h"
#include "command.h"
-static struct osl_table *audio_file_table;
-static char *status_items;
-static char *parser_friendly_status_items;
-
-/** The different sorting methods of the ls command. */
-enum ls_sorting_method {
- /** -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,
- /** -lp */
- LS_MODE_PARSER,
-};
-
/* Data about one audio file. Needed for ls and stat output. */
struct ls_data {
/* Usual audio format handler information. */
unsigned char *hash;
};
+/*
+ * The internal state of the audio file table is described by the following
+ * variables which are private to aft.c.
+ */
+static struct osl_table *audio_file_table; /* NULL if table not open */
+static struct osl_row *current_aft_row; /* NULL if no audio file open */
+static unsigned char current_hash[HASH2_SIZE]; /* only used on sighup */
+
+static char *status_items;
+static char *parser_friendly_status_items;
+static struct ls_data status_item_ls_data;
+
+/** The different sorting methods of the ls command. */
+enum ls_sorting_method {
+ LS_SORT_BY_PATH, /**< -s=p (default) */
+ LS_SORT_BY_SCORE, /**< -s=s */
+ LS_SORT_BY_LAST_PLAYED, /**< -s=l */
+ LS_SORT_BY_NUM_PLAYED, /**< -s=n */
+ LS_SORT_BY_FREQUENCY, /**< -s=f */
+ LS_SORT_BY_CHANNELS, /**< -s=c */
+ LS_SORT_BY_IMAGE_ID, /**< -s=i */
+ LS_SORT_BY_LYRICS_ID, /**< -s=y */
+ LS_SORT_BY_BITRATE, /**< -s=b */
+ LS_SORT_BY_DURATION, /**< -s=d */
+ LS_SORT_BY_AUDIO_FORMAT, /**< -s=a */
+ LS_SORT_BY_HASH, /**< -s=h */
+};
+
+/** The different listing modes of the ls command. */
+enum ls_listing_mode {
+ LS_MODE_SHORT, /**< Default listing mode. */
+ LS_MODE_LONG, /**< -l or -l=l */
+ LS_MODE_VERBOSE, /** -l=v */
+ LS_MODE_MBOX, /** -l=m */
+ LS_MODE_CHUNKS, /** -l=c */
+ LS_MODE_PARSER, /** -l=p */
+};
+
/**
* The size of the individual output fields of the ls command.
*
.storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE,
.name = "hash",
.compare_function = aft_hash_compare,
- .data_size = HASH_SIZE
+ .data_size = HASH2_SIZE
},
[AFTCOL_PATH] = {
.storage_type = OSL_MAPPED_STORAGE,
};
static struct osl_table_description audio_file_table_desc = {
- .name = "audio_files",
+ .name = "audio-files",
.num_columns = NUM_AFT_COLUMNS,
.flags = OSL_LARGE_TABLE,
.column_descriptions = aft_cols
{
uint32_t n;
- if (!afhi->chunk_table)
+ if (!afhi->chunk_table || afhi->chunks_total == 0)
return;
for (n = 0; n <= afhi->chunks_total; n++)
write_u32(buf + 4 * n, afhi->chunk_table[n]);
int i;
size_t sz;
- if (!ct->data || ct->size < 4) {
+ if (!ct->data || ct->size < 4 * (afhi->chunks_total + 1)) {
afhi->chunk_table = NULL;
return;
}
*/
static int aft_get_row_of_hash(unsigned char *hash, struct osl_row **row)
{
- const struct osl_object obj = {.data = hash, .size = HASH_SIZE};
+ const struct osl_object obj = {.data = hash, .size = HASH2_SIZE};
return osl(osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row));
}
struct osl_object path_obj;
int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_PATH,
&path_obj));
+
if (ret < 0)
- return ret;
- *path = path_obj.data;
- return 1;
+ *path = NULL;
+ else
+ *path = path_obj.data;
+ return ret;
}
/**
int get_afhi_of_row(const struct osl_row *row, struct afh_info *afhi)
{
struct osl_object obj;
- int ret = osl(osl_get_object(audio_file_table, row, AFTCOL_AFHI,
- &obj));
+ int ret;
+
+ assert(row);
+ ret = osl(osl_get_object(audio_file_table, row, AFTCOL_AFHI, &obj));
if (ret < 0)
return ret;
load_afhi(obj.data, afhi);
return width + 6;
}
-static void get_duration_buf(int seconds, char *buf, struct ls_options *opts)
+static void get_duration_buf(int seconds, char *buf, size_t bufsize,
+ 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;
+ assert(max_width < bufsize - 1);
sprintf(buf, "%*u:%02d", 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;
+ assert(max_width < bufsize - 1);
sprintf(buf, "%*u:%02u:%02d", max_width - 6, hours, mins,
seconds % 60);
}
char *att_text;
int ret;
- WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_BITMAP, "%s\n", att_bitmap);
+ WRITE_STATUS_ITEM(b, SI_attributes_bitmap, "%s\n", att_bitmap);
ret = get_attribute_text(&afsi->attributes, " ", &att_text);
if (ret < 0)
return ret;
- WRITE_STATUS_ITEM(b, SI_ATTRIBUTES_TXT, "%s\n", att_text);
+ WRITE_STATUS_ITEM(b, SI_attributes_txt, "%s\n", att_text);
free(att_text);
return ret;
}
{
char *lyrics_name;
- WRITE_STATUS_ITEM(b, SI_LYRICS_ID, "%u\n", afsi->lyrics_id);
+ WRITE_STATUS_ITEM(b, SI_lyrics_id, "%u\n", afsi->lyrics_id);
lyr_get_name_by_id(afsi->lyrics_id, &lyrics_name);
- WRITE_STATUS_ITEM(b, SI_LYRICS_NAME, "%s\n", lyrics_name?
+ WRITE_STATUS_ITEM(b, SI_lyrics_name, "%s\n", lyrics_name?
lyrics_name : "(none)");
}
{
char *image_name;
- WRITE_STATUS_ITEM(b, SI_IMAGE_ID, "%u\n", afsi->image_id);
+ WRITE_STATUS_ITEM(b, SI_image_id, "%u\n", afsi->image_id);
img_get_name_by_id(afsi->image_id, &image_name);
- WRITE_STATUS_ITEM(b, SI_IMAGE_NAME, "%s\n", image_name?
+ WRITE_STATUS_ITEM(b, SI_image_name, "%s\n", image_name?
image_name : "(none)");
}
char *val;
if (basename) {
- WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", path);
+ WRITE_STATUS_ITEM(b, SI_basename, "%s\n", path);
return;
}
- WRITE_STATUS_ITEM(b, SI_PATH, "%s\n", path);
+ WRITE_STATUS_ITEM(b, SI_path, "%s\n", path);
val = para_basename(path);
- WRITE_STATUS_ITEM(b, SI_BASENAME, "%s\n", val? val : "");
+ WRITE_STATUS_ITEM(b, SI_basename, "%s\n", val? val : "");
val = para_dirname(path);
- WRITE_STATUS_ITEM(b, SI_DIRECTORY, "%s\n", val? val : "");
+ WRITE_STATUS_ITEM(b, SI_directory, "%s\n", val? val : "");
free(val);
}
char duration_buf[30]; /* nobody has an audio file long enough to overflow this */
struct afs_info *afsi = &d->afsi;
struct afh_info *afhi = &d->afhi;
- char asc_hash[2 * HASH_SIZE + 1];
+ char asc_hash[2 * HASH2_SIZE + 1];
if (opts->mode == LS_MODE_SHORT) {
para_printf(b, "%s\n", d->path);
if (ret < 0)
goto out;
}
- get_duration_buf(afhi->seconds_total, duration_buf, opts);
+ get_duration_buf(afhi->seconds_total, duration_buf,
+ sizeof(duration_buf), opts);
if (opts->mode == LS_MODE_LONG) {
struct ls_widths *w = &opts->widths;
if (lls_opt_given(r_a))
}
write_filename_items(b, d->path, lls_opt_given(r_b));
if (lls_opt_given(r_a))
- WRITE_STATUS_ITEM(b, SI_SCORE, "%li\n", d->score);
+ WRITE_STATUS_ITEM(b, SI_score, "%li\n", d->score);
ret = write_attribute_items(b, att_buf, afsi);
if (ret < 0)
goto out;
write_image_items(b, afsi);
write_lyrics_items(b, afsi);
hash_to_asc(d->hash, asc_hash);
- WRITE_STATUS_ITEM(b, SI_HASH, "%s\n", asc_hash);
- WRITE_STATUS_ITEM(b, SI_BITRATE, "%dkbit/s\n", afhi->bitrate);
- WRITE_STATUS_ITEM(b, SI_FORMAT, "%s\n",
+ WRITE_STATUS_ITEM(b, SI_hash, "%s\n", asc_hash);
+ WRITE_STATUS_ITEM(b, SI_bitrate, "%dkbit/s\n", afhi->bitrate);
+ WRITE_STATUS_ITEM(b, SI_format, "%s\n",
audio_format_name(afsi->audio_format_id));
- WRITE_STATUS_ITEM(b, SI_FREQUENCY, "%dHz\n", afhi->frequency);
- WRITE_STATUS_ITEM(b, SI_CHANNELS, "%d\n", afhi->channels);
- WRITE_STATUS_ITEM(b, SI_DURATION, "%s\n", duration_buf);
- WRITE_STATUS_ITEM(b, SI_SECONDS_TOTAL, "%" PRIu32 "\n",
+ WRITE_STATUS_ITEM(b, SI_frequency, "%dHz\n", afhi->frequency);
+ WRITE_STATUS_ITEM(b, SI_channels, "%d\n", afhi->channels);
+ WRITE_STATUS_ITEM(b, SI_duration, "%s\n", duration_buf);
+ WRITE_STATUS_ITEM(b, SI_seconds_total, "%" PRIu32 "\n",
afhi->seconds_total);
- WRITE_STATUS_ITEM(b, SI_LAST_PLAYED, "%s\n", last_played_time);
- WRITE_STATUS_ITEM(b, SI_NUM_PLAYED, "%u\n", afsi->num_played);
- WRITE_STATUS_ITEM(b, SI_AMPLIFICATION, "%u\n", afsi->amp);
- WRITE_STATUS_ITEM(b, SI_CHUNK_TIME, "%lu\n", tv2ms(&afhi->chunk_tv));
- WRITE_STATUS_ITEM(b, SI_NUM_CHUNKS, "%" PRIu32 "\n",
+ WRITE_STATUS_ITEM(b, SI_last_played, "%s\n", last_played_time);
+ WRITE_STATUS_ITEM(b, SI_num_played, "%u\n", afsi->num_played);
+ WRITE_STATUS_ITEM(b, SI_amplification, "%u\n", afsi->amp);
+ WRITE_STATUS_ITEM(b, SI_chunk_time, "%lu\n", tv2ms(&afhi->chunk_tv));
+ WRITE_STATUS_ITEM(b, SI_num_chunks, "%" PRIu32 "\n",
afhi->chunks_total);
- WRITE_STATUS_ITEM(b, SI_MAX_CHUNK_SIZE, "%" PRIu32 "\n",
+ WRITE_STATUS_ITEM(b, SI_max_chunk_size, "%" PRIu32 "\n",
afhi->max_chunk_size);
- WRITE_STATUS_ITEM(b, SI_TECHINFO, "%s\n", afhi->techinfo);
- WRITE_STATUS_ITEM(b, SI_ARTIST, "%s\n", afhi->tags.artist);
- WRITE_STATUS_ITEM(b, SI_TITLE, "%s\n", afhi->tags.title);
- WRITE_STATUS_ITEM(b, SI_YEAR, "%s\n", afhi->tags.year);
- WRITE_STATUS_ITEM(b, SI_ALBUM, "%s\n", afhi->tags.album);
- WRITE_STATUS_ITEM(b, SI_COMMENT, "%s\n", afhi->tags.comment);
+ WRITE_STATUS_ITEM(b, SI_techinfo, "%s\n", afhi->techinfo);
+ WRITE_STATUS_ITEM(b, SI_artist, "%s\n", afhi->tags.artist);
+ WRITE_STATUS_ITEM(b, SI_title, "%s\n", afhi->tags.title);
+ WRITE_STATUS_ITEM(b, SI_year, "%s\n", afhi->tags.year);
+ WRITE_STATUS_ITEM(b, SI_album, "%s\n", afhi->tags.album);
+ WRITE_STATUS_ITEM(b, SI_comment, "%s\n", afhi->tags.comment);
if (opts->mode == LS_MODE_MBOX) {
struct osl_object lyrics_def;
lyr_get_def_by_id(afsi->lyrics_id, &lyrics_def);
return ret;
}
-static struct ls_data status_item_ls_data;
-static struct osl_row *current_aft_row;
-
static void make_inode_status_items(struct para_buffer *pb)
{
struct stat statbuf = {.st_size = 0};
ret = strftime(mtime_str, 29, "%b %d %Y", &mtime_tm);
assert(ret > 0); /* number of bytes placed in mtime_str */
out:
- WRITE_STATUS_ITEM(pb, SI_MTIME, "%s\n", mtime_str);
- WRITE_STATUS_ITEM(pb, SI_FILE_SIZE, "%ld\n", statbuf.st_size / 1024);
+ WRITE_STATUS_ITEM(pb, SI_mtime, "%s\n", mtime_str);
+ WRITE_STATUS_ITEM(pb, SI_file_size, "%ld\n", statbuf.st_size / 1024);
+}
+
+/**
+ * Deallocate and invalidate the status item strings.
+ *
+ * This needs to be a public function so that afs.c can call it on shutdown.
+ */
+void free_status_items(void)
+{
+ freep(&status_items);
+ freep(&parser_friendly_status_items);
}
-static int make_status_items(void)
+static void make_status_items(void)
{
const struct lls_command *cmd = SERVER_CMD_CMD_PTR(LS);
char *argv[] = {"ls", "--admissible", "--listing-mode=verbose"};
time_t current_time;
int ret;
+ free_status_items();
+ if (!status_item_ls_data.path) /* no audio file open */
+ return;
ret = lls_parse(ARRAY_SIZE(argv), argv, cmd, &opts.lpr, NULL);
assert(ret >= 0);
time(¤t_time);
if (ret < 0)
goto out;
make_inode_status_items(&pb);
- free(status_items);
status_items = pb.buf;
memset(&pb, 0, sizeof(pb));
pb.max_size = shm_get_shmmax() - 1;
pb.flags = PBF_SIZE_PREFIX;
ret = print_list_item(&status_item_ls_data, &opts, &pb, current_time);
- if (ret < 0) {
- free(status_items);
- status_items = NULL;
- return ret;
- }
+ if (ret < 0)
+ goto out;
make_inode_status_items(&pb);
- free(parser_friendly_status_items);
parser_friendly_status_items = pb.buf;
ret = 1;
out:
+ if (ret < 0) {
+ PARA_WARNING_LOG("could not create status items: %s\n",
+ para_strerror(-ret));
+ free_status_items();
+ }
lls_free_parse_result(opts.lpr, cmd);
- return ret;
}
/**
* Open the audio file with highest score and set up an afd structure.
*
- * \param afd Result pointer.
+ * This determines and opens the next audio file, verifies that it did not
+ * change by comparing the recomputed the hash value of the file contents
+ * against the value stored in the audio file table. If all goes well, it
+ * creates a shared memory area containing the serialized version of the afd
+ * structure, including the chunk table, if any. The caller can then send the
+ * ID of this area and the open fd to the server process.
+ *
+ * \param fd Result pointer for the file descriptor of the audio file.
*
* 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
*
* \return Positive shmid on success, negative on errors.
*/
-int open_and_update_audio_file(struct audio_file_data *afd)
+int open_and_update_audio_file(int *fd)
{
- unsigned char file_hash[HASH_SIZE];
+ unsigned char file_hash[HASH2_SIZE];
struct osl_object afsi_obj;
struct afs_info new_afsi;
int ret;
struct afsi_change_event_data aced;
struct osl_object map, chunk_table_obj;
struct ls_data *d = &status_item_ls_data;
+ unsigned char *tmp_hash;
+ struct audio_file_data afd;
again:
ret = score_get_best(¤t_aft_row, &d->score);
if (ret < 0)
return ret;
- ret = get_hash_of_row(current_aft_row, &d->hash);
+ /*
+ * get_hash_of_row() and get_audio_file_path_of_row() initialize
+ * their pointer argument to point to memory-mapped files. These pointers
+ * become stale after a new audio file has been added or after the
+ * server process received SIGHUP. For in both cases libosl unmaps and
+ * remaps the underlying database files, and this remapping may well
+ * change the starting address of the mapping. To avoid stale pointer
+ * references we create copies on the heap.
+ */
+ ret = get_hash_of_row(current_aft_row, &tmp_hash);
if (ret < 0)
return ret;
+ if (!d->hash)
+ d->hash = para_malloc(HASH_SIZE);
+ memcpy(d->hash, tmp_hash, HASH_SIZE);
+ free(d->path);
ret = get_audio_file_path_of_row(current_aft_row, &d->path);
if (ret < 0)
return ret;
PARA_NOTICE_LOG("%s\n", d->path);
+ d->path = para_strdup(d->path);
+
ret = get_afsi_object_of_row(current_aft_row, &afsi_obj);
if (ret < 0)
return ret;
ret = load_afsi(&d->afsi, &afsi_obj);
if (ret < 0)
return ret;
- ret = get_afhi_of_row(current_aft_row, &afd->afhi);
+ ret = get_afhi_of_row(current_aft_row, &afd.afhi);
if (ret < 0)
return ret;
- d->afhi = afd->afhi;
- d->afhi.chunk_table = afd->afhi.chunk_table = NULL;
+ d->afhi = afd.afhi;
+ d->afhi.chunk_table = afd.afhi.chunk_table = NULL;
ret = osl(osl_open_disk_object(audio_file_table, current_aft_row,
AFTCOL_CHUNKS, &chunk_table_obj));
if (ret < 0) {
} else {
PARA_INFO_LOG("chunk table: %zu bytes\n", chunk_table_obj.size);
}
- ret = mmap_full_file(d->path, O_RDONLY, &map.data, &map.size, &afd->fd);
+ ret = mmap_full_file(d->path, O_RDONLY, &map.data, &map.size, fd);
if (ret < 0)
goto out;
- hash_function(map.data, map.size, file_hash);
+ hash2_function(map.data, map.size, file_hash);
ret = hash_compare(file_hash, d->hash);
para_munmap(map.data, map.size);
if (ret) {
new_afsi.last_played = time(NULL);
save_afsi(&new_afsi, &afsi_obj); /* in-place update */
- afd->audio_format_id = d->afsi.audio_format_id;
- load_chunk_table(&afd->afhi, &chunk_table_obj);
+ afd.audio_format_id = d->afsi.audio_format_id;
+ load_chunk_table(&afd.afhi, &chunk_table_obj);
aced.aft_row = current_aft_row;
aced.old_afsi = &d->afsi;
/*
ret = afs_event(AFSI_CHANGE, NULL, &aced);
if (ret < 0)
goto out;
- ret = save_afd(afd);
+ ret = save_afd(&afd);
out:
- free(afd->afhi.chunk_table);
+ free(afd.afhi.chunk_table);
if (chunk_table_obj.data)
osl_close_disk_object(&chunk_table_obj);
if (ret < 0) {
static int ls_hash_compare(const void *a, const void *b)
{
struct ls_data *d1 = *(struct ls_data **)a, *d2 = *(struct ls_data **)b;
- return memcmp(d1->hash, d2->hash, HASH_SIZE);
+ return memcmp(d1->hash, d2->hash, HASH2_SIZE);
}
static int ls_audio_format_compare(const void *a, const void *b)
/** The hash of the audio file being added. */
CAB_HASH_OFFSET = 13,
/** Start of the path of the audio file. */
- CAB_PATH_OFFSET = (CAB_HASH_OFFSET + HASH_SIZE),
+ CAB_PATH_OFFSET = (CAB_HASH_OFFSET + HASH2_SIZE),
};
/*
assert(size <= ~(uint32_t)0);
write_u8(buf + CAB_AUDIO_FORMAT_ID_OFFSET, audio_format_num);
- memcpy(buf + CAB_HASH_OFFSET, hash, HASH_SIZE);
+ memcpy(buf + CAB_HASH_OFFSET, hash, HASH2_SIZE);
strcpy(buf + CAB_PATH_OFFSET, path);
pos = CAB_PATH_OFFSET + path_len;
write_u32(buf + CAB_AFHI_OFFSET_POS, pos);
+----+----+---+------+---------------------------------------------------+
| N | N | Y | Y | (new file) create new entry (force has no effect)
+----+----+---+------+---------------------------------------------------+
-| N | N | N | Y | (new file) create new entry
+| N | N | N | Y | (new file) create new entry
+----+----+---+------+---------------------------------------------------+
Notes:
struct osl_row *hs;
struct osl_object objs[NUM_AFT_COLUMNS];
unsigned char *hash;
- char asc[2 * HASH_SIZE + 1];
+ char asc[2 * HASH2_SIZE + 1];
int ret;
char afsi_buf[AFSI_SIZE];
char *slpr = buf + read_u32(buf + CAB_LPR_OFFSET);
hash = (unsigned char *)buf + CAB_HASH_OFFSET;
hash_to_asc(hash, asc);
objs[AFTCOL_HASH].data = buf + CAB_HASH_OFFSET;
- objs[AFTCOL_HASH].size = HASH_SIZE;
+ objs[AFTCOL_HASH].size = HASH2_SIZE;
path = buf + CAB_PATH_OFFSET;
objs[AFTCOL_PATH].data = path;
objs[AFTCOL_CHUNKS].data = buf + chunks_offset;
objs[AFTCOL_CHUNKS].size = aca->query.size - chunks_offset;
if (pb && !hs) { /* update pb's hash */
- char old_asc[2 * HASH_SIZE + 1];
+ char old_asc[2 * HASH2_SIZE + 1];
unsigned char *old_hash;
ret = get_hash_of_row(pb, &old_hash);
if (ret < 0)
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;
- unsigned char hash[HASH_SIZE];
+ unsigned char hash[HASH2_SIZE];
bool a_given = SERVER_CMD_OPT_GIVEN(ADD, ALL, pad->lpr);
bool f_given = SERVER_CMD_OPT_GIVEN(ADD, FORCE, pad->lpr);
bool l_given = SERVER_CMD_OPT_GIVEN(ADD, LAZY, pad->lpr);
ret = mmap_full_file(path, O_RDONLY, &map.data, &map.size, &fd);
if (ret < 0)
goto out_free;
- hash_function(map.data, map.size, hash);
+ hash2_function(map.data, map.size, hash);
/* Check whether the database contains a file with the same hash. */
query.data = hash;
- query.size = HASH_SIZE;
+ query.size = HASH2_SIZE;
ret = send_callback_request(hash_sister_callback, &query,
get_row_pointer_from_result, &hs);
if (ret < 0)
return audio_file_loop(&acad, check_atts_of_audio_file);
}
-/**
- * Close the audio file table.
- *
- * \param flags Usual flags that are passed to osl_close_table().
- *
- * \sa \ref osl_close_table().
+/*
+ * This sets audio_file_table to NULL, but leaves current_aft_row unmodified,
+ * though stale (pointing to unmapped memory). If the table is being closed
+ * because we received SIGHUP, the table will be reopened after the config file
+ * has been reloaded. We remember the hash of the current audio file here so
+ * that aft_open() can initialize current_aft_row by looking up the saved hash.
*/
static void aft_close(void)
{
+ int ret;
+ unsigned char *p;
+
+ if (current_aft_row) {
+ ret = get_hash_of_row(current_aft_row, &p);
+ if (ret < 0) {
+ PARA_WARNING_LOG("hash lookup failure\n");
+ current_aft_row = NULL;
+ } else
+ memcpy(current_hash, p, HASH2_SIZE);
+ }
osl_close_table(audio_file_table, OSL_MARK_CLEAN);
audio_file_table = NULL;
}
-/**
- * Open the audio file table.
- *
- * \param dir The database directory.
- *
- * \return Standard.
- *
- * \sa \ref osl_open_table().
- */
static int aft_open(const char *dir)
{
int ret;
unsigned num;
osl_get_num_rows(audio_file_table, &num);
PARA_INFO_LOG("audio file table contains %u files\n", num);
- return ret;
+ if (!current_aft_row) {
+ PARA_DEBUG_LOG("no current aft row\n");
+ return 1;
+ }
+ /* SIGHUP case, update current_aft_row */
+ ret = aft_get_row_of_hash(current_hash, ¤t_aft_row);
+ if (ret < 0) { /* not fatal */
+ PARA_WARNING_LOG("current hash lookup failure: %s\n",
+ para_strerror(-ret));
+ current_aft_row = NULL;
+ return 1;
+ }
+ PARA_NOTICE_LOG("current audio file hash lookup: success\n");
+ return 1;
}
- PARA_NOTICE_LOG("failed to open audio file table\n");
audio_file_table = NULL;
- if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
+ if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT)) {
+ PARA_WARNING_LOG("no audio file table\n");
return 1;
+ }
+ PARA_NOTICE_LOG("failed to open audio file table\n");
return ret;
}
status_item_ls_data.afsi.last_played = old_last_played;
make_status_items();
return 1;
+ } case AUDIO_FILE_RENAME: {
+ char *path;
+ if (data != current_aft_row)
+ return 0;
+ ret = get_audio_file_path_of_row(current_aft_row, &path);
+ if (ret < 0)
+ return ret;
+ free(status_item_ls_data.path);
+ status_item_ls_data.path = para_strdup(path);
+ make_status_items();
+ return 1;
} case AFHI_CHANGE: {
if (data != current_aft_row)
return 0;
return ret;
make_status_items();
return 1;
+ } case AUDIO_FILE_REMOVE: {
+ if (data == current_aft_row)
+ current_aft_row = NULL;
+ return 0;
+ }
+ case BLOB_RENAME:
+ case BLOB_REMOVE:
+ case BLOB_ADD: {
+ /*
+ * These events are rare. We don't bother to check whether the
+ * current status items are affected and simply recreate them
+ * whenever an audio file is open.
+ */
+ if (!current_aft_row)
+ return 0;
+ ret = get_afhi_of_row(current_aft_row,
+ &status_item_ls_data.afhi);
+ if (ret < 0)
+ return ret;
+ make_status_items();
+ return 0;
} default:
return 0;
}