git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7039 a1c6a512-1295-4272-9138-f99709370657
269 lines
6.3 KiB
C
269 lines
6.3 KiB
C
#include "malloc.h" // realloc() and free()
|
|
#include <string.h> // strncasecmp()
|
|
|
|
#include "file.h"
|
|
|
|
// how is our flag organized?
|
|
#define FLAG ( 0xBF )
|
|
#define FLAG_VALID(flag) (flag == 0xBF)
|
|
|
|
static int do_resize(struct file_entry *e, const uint32_t name_len, const int zero_fill);
|
|
|
|
struct file_entry* new_file_entry(const uint32_t name_len) {
|
|
// Start my allocating memory
|
|
struct file_entry *e = (struct file_entry*)malloc(sizeof(struct file_entry));
|
|
if( e == NULL ) {
|
|
DEBUGF("new_file_entry: could not allocate memory\n");
|
|
return NULL;
|
|
}
|
|
|
|
// We begin empty
|
|
e->name = NULL;
|
|
e->size.name_len = 0;
|
|
|
|
e->hash = 0;
|
|
e->song = 0;
|
|
e->rundb = 0;
|
|
|
|
e->flag = FLAG;
|
|
|
|
// and resize to the requested size
|
|
if( do_resize(e, name_len, 1) ) {
|
|
free(e);
|
|
return NULL;
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
int file_entry_destruct(struct file_entry *e) {
|
|
assert(e != NULL);
|
|
assert(FLAG_VALID(e->flag));
|
|
|
|
free(e->name);
|
|
|
|
free(e);
|
|
|
|
return ERR_NONE;
|
|
}
|
|
|
|
static int do_resize(struct file_entry *e, const uint32_t name_len, const int zero_fill) {
|
|
void* temp;
|
|
|
|
assert(e != NULL);
|
|
assert(FLAG_VALID(e->flag));
|
|
|
|
if( name_len != e->size.name_len ) {
|
|
temp = realloc(e->name, name_len);
|
|
if(temp == NULL) {
|
|
DEBUGF("file_entry_resize: out of memory to resize name\n");
|
|
return ERR_MALLOC;
|
|
}
|
|
e->name = (char*)temp;
|
|
|
|
// if asked, fill it with zero's
|
|
if( zero_fill ) {
|
|
uint32_t i;
|
|
for(i=e->size.name_len; i<name_len; i++)
|
|
e->name[i] = (char)0x00;
|
|
}
|
|
|
|
e->size.name_len = name_len;
|
|
}
|
|
|
|
return ERR_NONE;
|
|
}
|
|
|
|
inline int file_entry_resize(struct file_entry *e, const uint32_t name_len) {
|
|
return do_resize(e, name_len, 1);
|
|
}
|
|
|
|
int file_entry_serialize(FILE *fd, const struct file_entry *e) {
|
|
assert(fd != NULL);
|
|
assert(e != NULL);
|
|
assert(FLAG_VALID(e->flag));
|
|
|
|
// First byte we write is a flag-byte to indicate this is a valid record
|
|
if( fwrite(&e->flag, 1, 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_serialize: failed to write flag-byte\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// First we write the length of the name field
|
|
if( fwrite(&e->size.name_len, sizeof(e->size.name_len), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_serialize: failed to write name_len\n");
|
|
return ERR_FILE;
|
|
}
|
|
// now the name field itself
|
|
if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
|
|
DEBUGF("file_entry_serialize: failed to write name\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// hash field
|
|
if( fwrite(&e->hash, sizeof(e->hash), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_serialize: failed to write hash\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// song field
|
|
if( fwrite(&e->song, sizeof(e->song), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_serialize: failed to write song\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// rundb field
|
|
if( fwrite(&e->rundb, sizeof(e->rundb), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_serialize: failed to write rundb\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
return ERR_NONE;
|
|
}
|
|
|
|
int file_entry_unserialize(struct file_entry **dest, FILE *fd) {
|
|
uint32_t length;
|
|
struct file_entry *e;
|
|
|
|
assert(dest != NULL);
|
|
assert(fd != NULL);
|
|
|
|
// Allocate memory
|
|
e = new_file_entry(0);
|
|
if( e == NULL ) {
|
|
DEBUGF("file_entry_unserialize: could not create new file_entry\n");
|
|
return ERR_MALLOC;
|
|
}
|
|
|
|
// First we read the length of the name field
|
|
if( fread(&length, sizeof(length), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_unserialize: failed to read name_len\n");
|
|
file_entry_destruct(e);
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// allocate memory for the upcomming name-field
|
|
if( do_resize(e, length, 0) ) {
|
|
DEBUGF("file_entry_unserialize: failed to allocate memory for name\n");
|
|
file_entry_destruct(e);
|
|
return ERR_MALLOC;
|
|
}
|
|
|
|
// read it in
|
|
if( fread(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
|
|
DEBUGF("file_entry_unserialize: failed to read name\n");
|
|
file_entry_destruct(e);
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// hash field
|
|
if( fread(&e->hash, sizeof(e->hash), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_unserialize: failed to read hash\n");
|
|
file_entry_destruct(e);
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// song field
|
|
if( fread(&e->song, sizeof(e->song), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_unserialize: failed to read song\n");
|
|
file_entry_destruct(e);
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// rundb field
|
|
if( fread(&e->rundb, sizeof(e->rundb), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_unserialize: failed to read rundb\n");
|
|
file_entry_destruct(e);
|
|
return ERR_FILE;
|
|
}
|
|
|
|
*dest = e;
|
|
return ERR_NONE;
|
|
}
|
|
|
|
int file_entry_write(FILE *fd, struct file_entry *e, struct file_size *s) {
|
|
uint32_t be32;
|
|
char pad = 0x00;
|
|
|
|
assert(fd != NULL);
|
|
assert(e != NULL);
|
|
assert(FLAG_VALID(e->flag));
|
|
|
|
// file name
|
|
if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
|
|
DEBUGF("file_entry_write: failed to write name\n");
|
|
return ERR_FILE;
|
|
}
|
|
// pad the rest
|
|
be32 = e->size.name_len; // abuse be32 as counter
|
|
while( s != NULL && s->name_len > be32) {
|
|
if( fwrite(&pad, 1, 1, fd) == 1 ) {
|
|
be32++;
|
|
} else {
|
|
DEBUGF("file_entry_write: failed to pad name\n");
|
|
return ERR_FILE;
|
|
}
|
|
}
|
|
|
|
// hash
|
|
be32 = BE32(e->hash);
|
|
if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_write: failed to write hash\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// song
|
|
be32 = BE32(e->song);
|
|
if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_write: failed to write song\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
// rundb
|
|
be32 = BE32(e->rundb);
|
|
if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
|
|
DEBUGF("file_entry_write: failed to write rundb\n");
|
|
return ERR_FILE;
|
|
}
|
|
|
|
return ERR_NONE;
|
|
}
|
|
|
|
inline int file_entry_compare(const struct file_entry *a, const struct file_entry *b) {
|
|
assert(a != NULL);
|
|
assert(b != NULL);
|
|
return strncasecmp(a->name, b->name, (a->size.name_len <= b->size.name_len ? a->size.name_len : b->size.name_len) );
|
|
}
|
|
|
|
struct file_size* new_file_size() {
|
|
struct file_size *s;
|
|
s = (struct file_size*)malloc(sizeof(struct file_size));
|
|
if( s == NULL ) {
|
|
DEBUGF("new_file_size: failed to allocate memory\n");
|
|
return NULL;
|
|
}
|
|
s->name_len = 0;
|
|
|
|
return s;
|
|
}
|
|
|
|
inline uint32_t file_size_get_length(const struct file_size *size) {
|
|
assert(size != NULL);
|
|
return size->name_len + 12;
|
|
}
|
|
|
|
inline int file_size_max(struct file_size *s, const struct file_entry *e) {
|
|
assert(s != NULL);
|
|
assert(e != NULL);
|
|
assert(FLAG_VALID(e->flag));
|
|
s->name_len = ( s->name_len >= e->size.name_len ? s->name_len : e->size.name_len );
|
|
return ERR_NONE;
|
|
}
|
|
|
|
int file_size_destruct(struct file_size *s) {
|
|
assert(s != NULL);
|
|
// nothing to do...
|
|
free(s);
|
|
return ERR_NONE;
|
|
}
|