NUM_AFT_COLUMNS
};
-/**
- * Compare two osl objects pointing to hash values.
- *
- * \param obj1 Pointer to the first hash object.
- * \param obj2 Pointer to the second hash object.
- *
- * \return The values required for an osl compare function.
- *
- * \sa osl_compare_func, uint32_compare().
- */
-static int aft_hash_compare(const struct osl_object *obj1, const struct osl_object *obj2)
+/* compare function for the hash column */
+static int aft_hash_compare(const struct osl_object *obj1,
+ const struct osl_object *obj2)
{
- return hash_compare((unsigned char *)obj1->data, (unsigned char *)obj2->data);
+ return hash_compare((unsigned char *)obj1->data,
+ (unsigned char *)obj2->data);
}
static struct osl_column_description aft_cols[] = {
.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;
}
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;
}
return ret;
ret = mmap_full_file(d->path, O_RDONLY, &map.data, &map.size, &afd->fd);
if (ret < 0)
- goto err;
+ goto out;
hash_function(map.data, map.size, file_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 = d->afsi;
new_afsi.num_played++;
*/
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) {
i++;
break;
}
+ /*
+ * Compatibility: Prior to 0.5.5 it was necessary to specify
+ * the listing mode without the '=' character as in -lv, for
+ * example. Now the variant with '=' is preferred and
+ * documented but we still accept the old way to specify the
+ * listing mode.
+ *
+ * Support for the legacy syntax can be dropped at 0.6.0
+ * or later.
+ */
if (!strncmp(arg, "-l", 2)) {
- if (!*(arg + 2)) {
- mode = LS_MODE_LONG;
- continue;
- }
- if (*(arg + 3))
- return -E_AFT_SYNTAX;
- switch(*(arg + 2)) {
+ arg += 2;
+ if (*arg == '=')
+ arg++;
+ switch (*arg) {
case 's':
mode = LS_MODE_SHORT;
continue;
case 'l':
+ case '\0':
mode = LS_MODE_LONG;
continue;
case 'v':
flags |= LS_FLAG_UNIXDATE;
continue;
}
+ /* The compatibility remark above applies also to -s. */
if (!strncmp(arg, "-s", 2)) {
- if (!*(arg + 2) || *(arg + 3))
- return -E_AFT_SYNTAX;
- switch(*(arg + 2)) {
+ arg += 2;
+ if (*arg == '=')
+ arg++;
+ switch (*arg) {
case 'p':
sort = LS_SORT_BY_PATH;
continue;
/** The format of the data stored by save_audio_file_data(). */
enum com_add_buffer_offsets {
- /** afhi (if present) starts here. */
+ /* afhi (if present) starts at this offset. */
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,
+ CAB_CHUNKS_OFFSET_POS = 4,
/** Flags given to the add command. */
- CAB_FLAGS_OFFSET = 5,
+ CAB_FLAGS_OFFSET = 8,
+ /** Audio format id. */
+ CAB_AUDIO_FORMAT_ID_OFFSET = 12,
/** The hash of the audio file being added. */
- CAB_HASH_OFFSET = 9,
+ CAB_HASH_OFFSET = 13,
/** Start of the path of the audio file. */
CAB_PATH_OFFSET = (CAB_HASH_OFFSET + HASH_SIZE),
};
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 + CAB_AUDIO_FORMAT_OFFSET, audio_format_num);
- write_u32(buf + CAB_FLAGS_OFFSET, flags);
-
- memcpy(buf + CAB_HASH_OFFSET, hash, HASH_SIZE);
- strcpy(buf + CAB_PATH_OFFSET, path);
+ uint32_t pos;
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 + CAB_AFHI_OFFSET_POS, pos);
+ write_u32(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 + CAB_CHUNKS_OFFSET_POS, pos);
+
+ write_u32(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);
+
+ write_u32(buf + CAB_FLAGS_OFFSET, flags);
+ write_u8(buf + CAB_AUDIO_FORMAT_ID_OFFSET, audio_format_num);
+
+ memcpy(buf + CAB_HASH_OFFSET, hash, HASH_SIZE);
+ strcpy(buf + CAB_PATH_OFFSET, path);
+
obj->data = buf;
obj->size = size;
}
goto out;
}
/* no hs or force mode, child must have sent afhi */
- afhi_offset = read_u16(buf + CAB_AFHI_OFFSET_POS);
- chunks_offset = read_u16(buf + CAB_CHUNKS_OFFSET_POS);
+ afhi_offset = read_u32(buf + CAB_AFHI_OFFSET_POS);
+ chunks_offset = read_u32(buf + CAB_CHUNKS_OFFSET_POS);
objs[AFTCOL_AFHI].data = buf + afhi_offset;
objs[AFTCOL_AFHI].size = chunks_offset - afhi_offset;
goto out;
}
default_afsi.last_played = time(NULL) - 365 * 24 * 60 * 60;
- default_afsi.audio_format_id = read_u8(buf + CAB_AUDIO_FORMAT_OFFSET);
+ default_afsi.audio_format_id = read_u8(buf + CAB_AUDIO_FORMAT_ID_OFFSET);
objs[AFTCOL_AFSI].data = &afsi_buf;
objs[AFTCOL_AFSI].size = AFSI_SIZE;
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,
{
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];
return ret;
continue;
}
- ret = stat(path, &statbuf);
- if (ret < 0) {
- ret = send_sb_va(&cc->scc, SBD_ERROR_LOG,
- "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) {
send_sb_va(&cc->scc, SBD_OUTPUT, "%s: %s\n", path,
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
}
};
break;
p[len - 1] = '\0';
ret = get_attribute_bitnum_by_name(p, &bitnum);
- if (ret < 0)
+ if (ret < 0) {
+ para_printf(&cad.pb, "attribute not found: %s\n", p);
goto out;
+ }
if (c == '+')
cad.add_mask |= (1UL << bitnum);
else
if (!cad.add_mask && !cad.del_mask)
goto out;
pmd.patterns.data = p;
- assert(p < (char *)query->data + query->size);
+ if (p >= (char *)query->data + query->size)
+ goto out;
pmd.patterns.size = (char *)query->data + query->size - p;
ret = for_each_matching_row(&pmd);
if (ret < 0)
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;
}
projects / paraslash.git / blobdiff