/*
- * Copyright (C) 2007-2012 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
LS_MODE_PARSER,
};
+/* Data about one audio file. Needed for ls and stat output. */
+struct ls_data {
+ /* Usual audio format handler information. */
+ struct afh_info afhi;
+ /* Audio file selector information. */
+ struct afs_info afsi;
+ /* The full path of the audio file. */
+ char *path;
+ /* The score value (if -a was given). */
+ long score;
+ /* The hash value of the audio file data. */
+ unsigned char *hash;
+};
+
/** The flags accepted by the ls command. */
enum ls_flags {
/** -p */
/**
* 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.
+ * These depend on the content being listed. For example, if each listed file
+ * is shorter than an hour, the duration format is set to mm:ss. Otherwise it
+ * is set to hh:mm:ss.
*/
struct ls_widths {
/** size of the score field. */
AFSI_SIZE = 32
};
-/**
+/*
* Convert a struct afs_info to an osl object.
*
* \param afsi Pointer to the audio file info to be converted.
*
* \sa load_afsi().
*/
-void save_afsi(struct afs_info *afsi, struct osl_object *obj)
+static void save_afsi(struct afs_info *afsi, struct osl_object *obj)
{
char *buf = obj->data;
memset(buf + AFSI_AUDIO_FORMAT_UNUSED_OFFSET, 0, 2);
}
-/**
- * Get the audio file selector info struct stored in an osl object.
+/*
+ * Get the audio file selector info struct stored in an osl object.
*
* \param afsi Points to the audio_file info structure to be filled in.
* \param obj The osl object holding the data.
*
- * \return Positive on success, negative on errors. Possible errors: \p E_BAD_AFS.
+ * \return Standard.
*
* \sa save_afsi().
*/
-int load_afsi(struct afs_info *afsi, struct osl_object *obj)
+static int load_afsi(struct afs_info *afsi, struct osl_object *obj)
{
char *buf = obj->data;
if (obj->size < AFSI_SIZE)
.column_descriptions = aft_cols
};
-/* We don't want * dot or dot-dot anywhere. */
-static int verify_dotfile(const char *rest)
-{
- /*
- * The first character was '.', but that has already been discarded, we
- * now test the rest.
- */
- switch (*rest) {
- 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; /* /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.
+ * Produce a canonicalized absolute pathname.
+ *
+ * Returns one if the resolved path a directory, zero if it is a regular file,
+ * negative on errors.
*/
static int verify_path(const char *orig_path, char **resolved_path)
{
- char c;
- size_t len;
- char *path;
+ int ret;
+ char *path = NULL;
+ struct stat statbuf;
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++;
- while (c) {
- if (c == '/') {
- c = *path++;
- switch (c) {
- case '/': /* double slash */
- goto bad_path;
- case '.':
- if (verify_dotfile(path) < 0)
- goto bad_path;
- default:
- continue;
- }
- }
- c = *path++;
- }
- return 1;
-bad_path:
- free(*resolved_path);
+ goto fail;
+ path = realpath(orig_path, NULL);
+ if (!path)
+ goto fail;
+ if (stat(path, &statbuf) < 0)
+ goto fail;
+ if (S_ISREG(statbuf.st_mode))
+ ret = 0;
+ else if (S_ISDIR(statbuf.st_mode))
+ ret = 1;
+ else
+ goto fail;
+ *resolved_path = path;
+ return ret;
+fail:
+ *resolved_path = NULL;
+ free(path);
return -E_BAD_PATH;
}
return osl(osl_get_row(audio_file_table, AFTCOL_HASH, &obj, row));
}
-/**
- * Get the osl object holding the audio file selector info of a row.
+/*
+ * Get the audio file selector info object of a row.
*
* \param row Pointer to a row in the audio file table.
* \param obj Result pointer.
*
* \return Standard.
*/
-int get_afsi_object_of_row(const struct osl_row *row, struct osl_object *obj)
+static int get_afsi_object_of_row(const struct osl_row *row,
+ struct osl_object *obj)
{
return osl(osl_get_object(audio_file_table, row, AFTCOL_AFSI, obj));
}
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.
+ * \return Standard.
*/
-int get_afsi_of_path(const char *path, struct afs_info *afsi)
+static 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);
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);
+ load_chunk_table(&afd->afhi, shm_afd + sizeof(*afd));
shm_detach(shm_afd);
return 1;
}
}
}
-
static int write_attribute_items(struct para_buffer *b,
const char *att_bitmap, struct afs_info *afsi)
{
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);
+ ret = osl(osl_open_disk_object(audio_file_table, aft_row,
+ AFTCOL_CHUNKS, &chunk_table_obj));
if (ret < 0)
return ret;
ret = para_printf(b, "%s\n"
return ret;
}
-static int make_status_items(struct audio_file_data *afd,
- struct afs_info *afsi, char *path, long score,
- unsigned char *hash)
+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};
+ char *path, mtime_str[30] = "\0";
+ struct tm mtime_tm;
+ int ret;
+
+ ret = get_audio_file_path_of_row(current_aft_row, &path);
+ if (ret < 0)
+ goto out;
+ ret = stat(path, &statbuf);
+ if (ret < 0)
+ goto out;
+ localtime_r(&statbuf.st_mtime, &mtime_tm);
+ ret = strftime(mtime_str, 29, "%b %d %Y", &mtime_tm);
+ assert(ret > 0); /* number of bytes placed in mtime_str */
+out:
+ /* We don't care too much about errors here */
+ (void)WRITE_STATUS_ITEM(pb, SI_MTIME, "%s\n", mtime_str);
+ (void)WRITE_STATUS_ITEM(pb, SI_FILE_SIZE, "%ld\n", statbuf.st_size / 1024);
+}
+
+static int make_status_items(void)
{
- struct ls_data d = {
- .afhi = afd->afhi,
- .afsi = *afsi,
- .path = path,
- .score = score,
- .hash = hash
- };
struct ls_options opts = {
.flags = LS_FLAG_FULL_PATH | LS_FLAG_ADMISSIBLE_ONLY,
.mode = LS_MODE_VERBOSE,
int ret;
time(¤t_time);
- ret = print_list_item(&d, &opts, &pb, current_time);
+ ret = print_list_item(&status_item_ls_data, &opts, &pb, current_time);
if (ret < 0)
return ret;
+ 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(&d, &opts, &pb, current_time);
+ ret = print_list_item(&status_item_ls_data, &opts, &pb, current_time);
if (ret < 0) {
free(status_items);
status_items = NULL;
return ret;
}
+ make_inode_status_items(&pb);
free(parser_friendly_status_items);
parser_friendly_status_items = pb.buf;
return 1;
}
/**
- * Mmap the given audio file and update statistics.
+ * Open the audio file with highest score and set up an afd structure.
*
- * \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
*
* \return Positive shmid on success, negative on errors.
*/
-int open_and_update_audio_file(struct osl_row *aft_row, long score,
- struct audio_file_data *afd)
+int open_and_update_audio_file(struct audio_file_data *afd)
{
- unsigned char *aft_hash, file_hash[HASH_SIZE];
+ unsigned char file_hash[HASH_SIZE];
struct osl_object afsi_obj;
- struct afs_info old_afsi, new_afsi;
- int ret = get_hash_of_row(aft_row, &aft_hash);
+ struct afs_info new_afsi;
+ int ret;
struct afsi_change_event_data aced;
struct osl_object map, chunk_table_obj;
- char *path;
-
+ struct ls_data *d = &status_item_ls_data;
+again:
+ ret = score_get_best(¤t_aft_row, &d->score);
if (ret < 0)
return ret;
- ret = get_audio_file_path_of_row(aft_row, &path);
+ ret = get_hash_of_row(current_aft_row, &d->hash);
if (ret < 0)
return ret;
- PARA_NOTICE_LOG("%s\n", path);
- ret = get_afsi_object_of_row(aft_row, &afsi_obj);
+ ret = get_audio_file_path_of_row(current_aft_row, &d->path);
if (ret < 0)
return ret;
- ret = load_afsi(&old_afsi, &afsi_obj);
+ PARA_NOTICE_LOG("%s\n", d->path);
+ ret = get_afsi_object_of_row(current_aft_row, &afsi_obj);
if (ret < 0)
return ret;
- ret = get_afhi_of_row(aft_row, &afd->afhi);
+ ret = load_afsi(&d->afsi, &afsi_obj);
if (ret < 0)
return ret;
- afd->afhi.chunk_table = NULL;
- ret = osl_open_disk_object(audio_file_table, aft_row,
- AFTCOL_CHUNKS, &chunk_table_obj);
+ ret = get_afhi_of_row(current_aft_row, &afd->afhi);
if (ret < 0)
- goto err;
- ret = mmap_full_file(path, O_RDONLY, &map.data,
- &map.size, &afd->fd);
+ return ret;
+ 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)
- goto err;
+ return ret;
+ ret = mmap_full_file(d->path, O_RDONLY, &map.data, &map.size, &afd->fd);
+ if (ret < 0)
+ goto out;
hash_function(map.data, map.size, file_hash);
- ret = hash_compare(file_hash, aft_hash);
+ ret = hash_compare(file_hash, d->hash);
para_munmap(map.data, map.size);
if (ret) {
ret = -E_HASH_MISMATCH;
- goto err;
+ goto out;
}
- new_afsi = old_afsi;
+ new_afsi = d->afsi;
new_afsi.num_played++;
new_afsi.last_played = time(NULL);
save_afsi(&new_afsi, &afsi_obj); /* in-place update */
- afd->audio_format_id = old_afsi.audio_format_id;
+ afd->audio_format_id = d->afsi.audio_format_id;
load_chunk_table(&afd->afhi, chunk_table_obj.data);
- ret = make_status_items(afd, &old_afsi, path, score, file_hash);
- if (ret < 0)
- goto err;
- aced.aft_row = aft_row;
- aced.old_afsi = &old_afsi;
+ aced.aft_row = current_aft_row;
+ aced.old_afsi = &d->afsi;
+ /*
+ * No need to update the status items as the AFSI_CHANGE event will
+ * recreate them.
+ */
afs_event(AFSI_CHANGE, NULL, &aced);
ret = save_afd(afd);
-err:
+out:
free(afd->afhi.chunk_table);
osl_close_disk_object(&chunk_table_obj);
- if (ret < 0)
- PARA_ERROR_LOG("%s: %s\n", path, para_strerror(-ret));
+ if (ret < 0) {
+ PARA_ERROR_LOG("%s: %s\n", d->path, para_strerror(-ret));
+ ret = score_delete(current_aft_row);
+ if (ret >= 0)
+ goto again;
+ }
return ret;
}
uint16_t afhi_offset, chunks_offset;
hash = (unsigned char *)buf + CAB_HASH_OFFSET;
- hash_to_asc(hash, asc);;
+ hash_to_asc(hash, asc);
objs[AFTCOL_HASH].data = buf + CAB_HASH_OFFSET;
objs[AFTCOL_HASH].size = HASH_SIZE;
struct osl_object obj;
if (pb) { /* hs trumps pb, remove pb */
if (flags & ADD_FLAG_VERBOSE) {
- ret = para_printf(&msg, "removing path brother\n");
+ ret = para_printf(&msg, "removing %s\n", path);
if (ret < 0)
goto out;
}
+ afs_event(AUDIO_FILE_REMOVE, &msg, pb);
ret = osl(osl_del_row(audio_file_table, pb));
if (ret < 0)
goto out;
unsigned char hash[HASH_SIZE];
ret = guess_audio_format(path);
- if (ret < 0 && !(pad->flags & ADD_FLAG_ALL))
+ if (ret < 0 && !(pad->flags & ADD_FLAG_ALL)) {
+ ret = 0;
goto out_free;
+ }
query.data = (char *)path;
query.size = strlen(path) + 1;
ret = send_callback_request(path_brother_callback, &query,
ret = 1;
if (pb && (pad->flags & ADD_FLAG_LAZY)) { /* lazy is really cheap */
if (pad->flags & ADD_FLAG_VERBOSE)
- send_ret = pad->cc->use_sideband?
- send_sb_va(&pad->cc->scc, SBD_OUTPUT,
- "lazy-ignore: %s\n", path)
- :
- sc_send_va_buffer(&pad->cc->scc,
- "lazy-ignore: %s\n", path);
+ send_ret = send_sb_va(&pad->cc->scc, SBD_OUTPUT,
+ "lazy-ignore: %s\n", path);
goto out_free;
}
/* We still want to add this file. Compute its hash. */
ret = 1;
if (pb && hs && hs == pb && !(pad->flags & ADD_FLAG_FORCE)) {
if (pad->flags & ADD_FLAG_VERBOSE)
- send_ret = pad->cc->use_sideband?
- send_sb_va(&pad->cc->scc, SBD_OUTPUT,
- "%s exists, not forcing update\n", path)
- :
- sc_send_va_buffer(&pad->cc->scc,
- "%s exists, not forcing update\n", path);
+ send_ret = send_sb_va(&pad->cc->scc, SBD_OUTPUT,
+ "%s exists, not forcing update\n", path);
goto out_unmap;
}
/*
munmap(map.data, map.size);
close(fd);
if (pad->flags & ADD_FLAG_VERBOSE) {
- send_ret = pad->cc->use_sideband?
- send_sb_va(&pad->cc->scc, SBD_OUTPUT,
- "adding %s\n", path)
- :
- sc_send_va_buffer(&pad->cc->scc,
- "adding %s\n", path);
+ send_ret = send_sb_va(&pad->cc->scc, SBD_OUTPUT,
+ "adding %s\n", path);
if (send_ret < 0)
goto out_free;
}
munmap(map.data, map.size);
out_free:
if (ret < 0 && send_ret >= 0)
- send_ret = pad->cc->use_sideband?
- send_sb_va(&pad->cc->scc, SBD_ERROR_LOG,
- "failed to add %s (%s)\n", path,
- para_strerror(-ret))
- :
- sc_send_va_buffer(&pad->cc->scc,
- "failed to add %s (%s)\n", path,
- para_strerror(-ret));
+ send_ret = send_sb_va(&pad->cc->scc, SBD_ERROR_LOG,
+ "failed to add %s (%s)\n", path, para_strerror(-ret));
free(obj.data);
clear_afhi(afhi_ptr);
/* Stop adding files only on send errors. */
{
int i, ret;
struct private_add_data pad = {.cc = cc, .flags = 0};
- struct stat statbuf;
for (i = 1; i < cc->argc; i++) {
const char *arg = cc->argv[i];
char *path;
ret = verify_path(cc->argv[i], &path);
if (ret < 0) {
- ret = cc->use_sideband?
- send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s: %s\n",
- cc->argv[i], para_strerror(-ret))
- :
- sc_send_va_buffer(&cc->scc, "%s: %s\n",
+ ret = send_sb_va(&cc->scc, SBD_ERROR_LOG, "%s: %s\n",
cc->argv[i], para_strerror(-ret));
if (ret < 0)
return ret;
continue;
}
- ret = stat(path, &statbuf);
- if (ret < 0) {
- ret = cc->use_sideband?
- send_sb_va(&cc->scc, SBD_ERROR_LOG,
- "failed to stat %s (%s)\n", path,
- strerror(errno))
- :
- sc_send_va_buffer(&cc->scc,
- "failed to stat %s (%s)\n", path,
- strerror(errno));
- free(path);
- if (ret < 0)
- return ret;
- continue;
- }
- if (S_ISDIR(statbuf.st_mode))
+ if (ret == 1) /* directory */
ret = for_each_file_in_dir(path, add_one_audio_file,
&pad);
- else
+ else /* regular file */
ret = add_one_audio_file(path, &pad);
if (ret < 0) {
- if (cc->use_sideband)
- send_sb_va(&cc->scc, SBD_OUTPUT, "%s: %s\n", path,
- para_strerror(-ret));
- else
- sc_send_va_buffer(&cc->scc, "%s: %s\n", path,
- para_strerror(-ret));
+ send_sb_va(&cc->scc, SBD_OUTPUT, "%s: %s\n", path,
+ para_strerror(-ret));
free(path);
return ret;
}
free(path);
}
return 1;
-
}
/**
struct touch_action_data tad = {.cto = query->data,
.pb = {
.max_size = shm_get_shmmax(),
- .private_data = &fd,
+ .private_data = &(struct afs_max_size_handler_data) {
+ .fd = fd,
+ .band = SBD_OUTPUT
+ },
.max_size_handler = afs_max_size_handler
}
};
struct com_rm_action_data crd = {.flags = *(uint32_t *)query->data,
.pb = {
.max_size = shm_get_shmmax(),
- .private_data = &fd,
+ .private_data = &(struct afs_max_size_handler_data) {
+ .fd = fd,
+ .band = SBD_OUTPUT
+ },
.max_size_handler = afs_max_size_handler
}
};
.flags = *(unsigned *)query->data,
.pb = {
.max_size = shm_get_shmmax(),
- .private_data = &fd,
+ .private_data = &(struct afs_max_size_handler_data) {
+ .fd = fd,
+ .band = SBD_OUTPUT
+ },
.max_size_handler = afs_max_size_handler
}
};
out:
if (ret < 0)
para_printf(&cad.pb, "%s\n", para_strerror(-ret));
- else if (cad.flags & CPSI_FLAG_VERBOSE) {
- if (pmd.num_matches > 0)
+ else if (pmd.num_matches > 0) {
+ if (cad.flags & CPSI_FLAG_VERBOSE)
para_printf(&cad.pb, "copied requested afsi from %s "
"to %u files\n", source_path, pmd.num_matches);
- else
- para_printf(&cad.pb, "nothing copied\n");
- }
+ } else
+ para_printf(&cad.pb, "no matches - nothing copied\n");
if (cad.pb.offset)
pass_buffer_as_shm(fd, SBD_OUTPUT, cad.pb.buf, cad.pb.offset);
free(cad.pb.buf);
return ret;
}
+struct change_atts_data {
+ uint64_t add_mask, del_mask;
+ struct para_buffer pb;
+};
+
+static int change_atts(__a_unused struct osl_table *table,
+ struct osl_row *row, __a_unused const char *name, void *data)
+{
+ int ret;
+ struct osl_object obj;
+ struct afs_info old_afsi, new_afsi;
+ struct afsi_change_event_data aced = {
+ .aft_row = row,
+ .old_afsi = &old_afsi
+ };
+ struct change_atts_data *cad = data;
+
+ 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;
+ new_afsi.attributes |= cad->add_mask;
+ new_afsi.attributes &= ~cad->del_mask;
+ save_afsi(&new_afsi, &obj); /* in-place update */
+ afs_event(AFSI_CHANGE, &cad->pb, &aced);
+ return 1;
+}
+
+static void com_setatt_callback(int fd, const struct osl_object *query)
+{
+ char *p;
+ int ret;
+ size_t len;
+ struct change_atts_data cad = {
+ .pb = {
+ .max_size = shm_get_shmmax(),
+ .max_size_handler = afs_max_size_handler,
+ .private_data = &(struct afs_max_size_handler_data) {
+ .fd = fd,
+ .band = SBD_OUTPUT
+ }
+ }
+ };
+ struct pattern_match_data pmd = {
+ .table = audio_file_table,
+ .loop_col_num = AFTCOL_HASH,
+ .match_col_num = AFTCOL_PATH,
+ .pm_flags = PM_SKIP_EMPTY_NAME,
+ .data = &cad,
+ .action = change_atts
+ };
+
+ for (p = query->data; p < (char *)query->data + query->size; p += len + 1) {
+ char c;
+ unsigned char bitnum;
+
+ len = strlen(p);
+ ret = -E_ATTR_SYNTAX;
+ if (len == 0)
+ goto out;
+ c = p[len - 1];
+ if (c != '+' && c != '-')
+ break;
+ p[len - 1] = '\0';
+ ret = get_attribute_bitnum_by_name(p, &bitnum);
+ if (ret < 0)
+ goto out;
+ if (c == '+')
+ cad.add_mask |= (1UL << bitnum);
+ else
+ cad.del_mask |= (1UL << bitnum);
+ }
+ ret = -E_ATTR_SYNTAX;
+ if (!cad.add_mask && !cad.del_mask)
+ goto out;
+ pmd.patterns.data = p;
+ assert(p < (char *)query->data + query->size);
+ pmd.patterns.size = (char *)query->data + query->size - p;
+ ret = for_each_matching_row(&pmd);
+ if (ret < 0)
+ goto out;
+ if (pmd.num_matches == 0)
+ para_printf(&cad.pb, "no matches\n");
+out:
+ if (ret < 0)
+ para_printf(&cad.pb, "%s\n", para_strerror(-ret));
+ if (cad.pb.offset)
+ pass_buffer_as_shm(fd, SBD_OUTPUT, cad.pb.buf, cad.pb.offset);
+ free(cad.pb.buf);
+}
+
+int com_setatt(struct command_context *cc)
+{
+ if (cc->argc < 3)
+ return -E_ATTR_SYNTAX;
+ return send_standard_callback_request(cc->argc - 1, cc->argv + 1,
+ com_setatt_callback, afs_cb_result_handler, cc);
+}
+
static void afs_stat_callback(int fd, const struct osl_object *query)
{
int *parser_friendly = query->data;
* is used to pass the status items from the afs process to the command handler
* via a shared memory area and a pipe.
*
- * \return The return value of the underyling call to \ref send_callback_request().
+ * \return The return value of the underlying call to \ref send_callback_request().
*/
int send_afs_status(struct command_context *cc, int parser_friendly)
{
PARA_INFO_LOG("audio file table contains %d files\n", num);
return ret;
}
- PARA_INFO_LOG("failed to open audio file table\n");
+ PARA_NOTICE_LOG("failed to open audio file table\n");
audio_file_table = NULL;
- if (ret >= 0 || ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
+ if (ret == -OSL_ERRNO_TO_PARA_ERROR(E_OSL_NOENT))
return 1;
return ret;
}
{
int ret;
- switch(event) {
+ switch (event) {
case ATTRIBUTE_REMOVE: {
const struct rmatt_event_data *red = data;
ret = para_printf(pb, "clearing attribute %s (bit %u) from all "
if (ret < 0)
return ret;
return audio_file_loop(data, clear_attribute);
- }
- default:
+ } case AFSI_CHANGE: {
+ struct afsi_change_event_data *aced = data;
+ uint64_t old_last_played = status_item_ls_data.afsi.last_played;
+ if (aced->aft_row != current_aft_row)
+ return 0;
+ ret = get_afsi_of_row(aced->aft_row, &status_item_ls_data.afsi);
+ if (ret < 0)
+ return ret;
+ status_item_ls_data.afsi.last_played = old_last_played;
+ make_status_items();
return 1;
+ } case AFHI_CHANGE: {
+ if (data != current_aft_row)
+ return 0;
+ ret = get_afhi_of_row(data, &status_item_ls_data.afhi);
+ if (ret < 0)
+ return ret;
+ make_status_items();
+ return 1;
+ } default:
+ return 0;
}
}
projects / paraslash.git / blobdiff