void read_super_blocks(char* device, file_system_info* fs_info)
{
struct exfat_super_block* sb;
uint64_t free_sectors, free_clusters;
fs_open(device);
free_clusters = exfat_count_free_clusters(&ef);
free_sectors = (uint64_t) free_clusters << ef.sb->spc_bits;
sb = ef.sb;
strncpy(fs_info->fs, exfat_MAGIC, FS_MAGIC_SIZE);
fs_info->block_size = EXFAT_SECTOR_SIZE(*sb);
fs_info->totalblock = le64_to_cpu(sb->sector_count);
fs_info->usedblocks = le64_to_cpu(sb->sector_count) - free_sectors;
fs_info->device_size = fs_info->totalblock * fs_info->block_size;
fs_close();
}
extern void initial_image_hdr(char* device, image_head* image_hdr)
{
fs_open(device);
strncpy(image_hdr->magic, IMAGE_MAGIC, IMAGE_MAGIC_SIZE);
strncpy(image_hdr->fs, xfs_MAGIC, FS_MAGIC_SIZE);
image_hdr->block_size = mp->m_sb.sb_blocksize;
image_hdr->totalblock = mp->m_sb.sb_dblocks;
image_hdr->usedblocks = mp->m_sb.sb_dblocks - mp->m_sb.sb_fdblocks;
image_hdr->device_size = (image_hdr->totalblock * image_hdr->block_size);
log_mesg(1, 0, 0, fs_opt.debug, "%s: blcos size= %i\n", __FILE__, mp->m_sb.sb_blocksize);
log_mesg(1, 0, 0, fs_opt.debug, "%s: total b= %lli\n", __FILE__, mp->m_sb.sb_dblocks);
log_mesg(1, 0, 0, fs_opt.debug, "%s: free block= %lli\n", __FILE__, mp->m_sb.sb_fdblocks);
log_mesg(1, 0, 0, fs_opt.debug, "%s: used block= %lli\n", __FILE__, (mp->m_sb.sb_dblocks - mp->m_sb.sb_fdblocks));
log_mesg(1, 0, 0, fs_opt.debug, "%s: device size= %lli\n", __FILE__, (mp->m_sb.sb_blocksize*mp->m_sb.sb_dblocks));
fs_close();
}
/// read super block and write to image head
extern void initial_image_hdr(char* device, image_head* image_hdr)
{
uint32_t alloc,total;
fs_open(device);
strncpy(image_hdr->magic, IMAGE_MAGIC, IMAGE_MAGIC_SIZE);
strncpy(image_hdr->fs, vmfs_MAGIC, FS_MAGIC_SIZE);
total = fs->fbb->bmh.total_items;
alloc = vmfs_bitmap_allocated_items(fs->fbb);
image_hdr->block_size = vmfs_fs_get_blocksize(fs);
image_hdr->totalblock = total;
image_hdr->usedblocks = alloc;
image_hdr->device_size = (vmfs_fs_get_blocksize(fs)*total);
fs_close();
}
/*..........................................................................*/
static void conn_err(void *arg, err_t err) {
struct http_state *hs;
LWIP_UNUSED_ARG(err);
if (arg) {
hs = arg;
if (hs->handle) {
fs_close(hs->handle);
hs->handle = NULL;
}
if (hs->buf) {
mem_free(hs->buf);
}
mem_free(hs);
}
}
/// read super block and write to image head
extern void initial_image_hdr(char* device, image_head* image_hdr)
{
reiser4_bitmap_t *fs_bitmap;
unsigned long long free_blocks=0;
fs_open(device);
fs_bitmap = reiser4_bitmap_create(reiser4_format_get_len(fs->format));
reiser4_alloc_extract(fs->alloc, fs_bitmap);
free_blocks = reiser4_format_get_free(fs->format);
memcpy(image_hdr->magic, IMAGE_MAGIC, IMAGE_MAGIC_SIZE);
memcpy(image_hdr->fs, reiser4_MAGIC, FS_MAGIC_SIZE);
image_hdr->block_size = (int)get_ms_blksize(SUPER(fs->master));
image_hdr->totalblock = (unsigned long long)reiser4_format_get_len(fs->format);
image_hdr->usedblocks = (unsigned long long)(reiser4_format_get_len(fs->format) - free_blocks);
image_hdr->device_size =(unsigned long long)(image_hdr->block_size * image_hdr->totalblock);
fs_close();
}
static int aux_close (lua_State *L) {
#if LUA_OPTIMIZE_MEMORY != 2
lua_getfenv(L, 1);
lua_getfield(L, -1, "__close");
return (lua_tocfunction(L, -1))(L);
#else
int *p = tofilep(L);
if(*p == c_stdin || *p == c_stdout || *p == c_stderr)
{
lua_pushnil(L);
lua_pushliteral(L, "cannot close standard file");
return 2;
}
int ok = (fs_close(*p) == 0);
*p = FS_OPEN_OK - 1;
return pushresult(L, ok, NULL);
#endif
}
/* This callback is called each time the sndstream driver needs
some more data. It will tell us how much it needs in bytes. */
static void* xing_callback(snd_stream_hnd_t hnd, int size, int * actual) {
static int frames = 0;
IN_OUT x;
/* Check for file not started or file finished */
if (mp3_fd == 0)
return NULL;
/* Dump the last PCM packet */
pcm_empty(pcm_discard);
/* Loop decoding until we have a full buffer */
while (pcm_count < size) {
/* Pull in some more data (and check for EOF) */
if (bs_fill() < 0 || bs_count < frame_bytes) {
printf("Decode completed\r\n");
goto errorout;
}
/* Decode a frame */
x = audio_decode(&mpeg, bs_ptr, (short*)pcm_ptr);
if (x.in_bytes <= 0) {
printf("Bad sync in MPEG file\r\n");
goto errorout;
}
bs_ptr += x.in_bytes; bs_count -= x.in_bytes;
pcm_ptr += x.out_bytes; pcm_count += x.out_bytes;
frames++;
/*if (!(frames % 64)) {
printf("Decoded %d frames \r", frames);
}*/
}
pcm_discard = *actual = size;
/* Got it successfully */
return pcm_buffer;
errorout:
fs_close(mp3_fd); mp3_fd = 0;
return NULL;
}
/// readbitmap - read bitmap
extern void readbitmap(char* device, image_head image_hdr, char* bitmap, int pui)
{
unsigned long long total_block, block, bused = 0, bfree = 0;
int done = 0, i = 0, start = 0, bit_size = 1;
char* p;
fs_open(device);
/// init progress
progress_bar bprog; /// progress_bar structure defined in progress.h
progress_init(&bprog, start, image_hdr.totalblock, bit_size);
total_block = 0;
/// read group
while ((i = cgread(&disk)) != 0) {
log_mesg(2, 0, 0, fs_opt.debug, "%s: \ncg = %d\n", __FILE__, disk.d_lcg);
log_mesg(2, 0, 0, fs_opt.debug, "%s: blocks = %i\n", __FILE__, acg.cg_ndblk);
p = cg_blksfree(&acg);
for (block = 0; block < acg.cg_ndblk; block++) {
if (isset(p, block)) {
bitmap[total_block] = 0;
bfree++;
log_mesg(3, 0, 0, fs_opt.debug, "%s: bitmap is free %lli\n", __FILE__, block);
} else {
bitmap[total_block] = 1;
bused++;
log_mesg(3, 0, 0, fs_opt.debug, "%s: bitmap is used %lli\n", __FILE__, block);
}
total_block++;
update_pui(&bprog, total_block ,done);
}
log_mesg(1, 0, 0, fs_opt.debug, "%s: read bitmap done\n", __FILE__);
}
fs_close();
log_mesg(1, 0, 0, fs_opt.debug, "%s: total used = %lli, total free = %lli\n", __FILE__, bused, bfree);
done = 1;
update_pui(&bprog, 1, done);
}
/* Common code for both dir_read and dir_write */
static int vmdfs_dir_read(const char *vmdfile, vmd_root_t * root, vmd_dir_t * dir_buf) {
uint16 dir_block, dir_size;
unsigned int i;
int needsop;//, rv;
int write = 0;
/* Find the directory starting block and length */
dir_block = root->dir_loc;
dir_size = root->dir_size;
/* The dir is stored backwards, so we start at the end and go back. */
while(dir_size > 0) {
if(write) {
/* Scan this block for changes */
for(i = 0, needsop = 0; i < 512 / sizeof(vmd_dir_t); i++) {
if(dir_buf[i].dirty) {
needsop = 1;
}
dir_buf[i].dirty = 0;
}
}
else
needsop = 1;
if(needsop) {
if(!write){
file_t f = fs_open(vmdfile,O_RDONLY);
fs_seek(f,dir_block*BLOCK_SIZE,SEEK_SET);
fs_read(f,(uint8 *)dir_buf,BLOCK_SIZE);
fs_close(f);
}
}
dir_block--;
dir_size--;
dir_buf += 512 / sizeof(vmd_dir_t); /* == 16 */
}
return 0;
}
void read_super_blocks(char* device, file_system_info* fs_info)
{
int fs_type = 0;
fs_type = test_extfs_type(device);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs version is %i\n", __FILE__, fs_type);
strncpy(fs_info->fs, extfs_MAGIC, FS_MAGIC_SIZE);
fs_open(device);
fs_info->block_size = block_size();
fs_info->totalblock = block_count();
fs_info->usedblocks = get_used_blocks();
fs_info->device_size = fs_info->block_size * fs_info->totalblock;
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs block_size %i\n", __FILE__, fs_info->block_size);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs total block %lli\n", __FILE__, fs_info->totalblock);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs used blocks %lli\n", __FILE__, fs_info->usedblocks);
log_mesg(1, 0, 0, fs_opt.debug, "%s: extfs device size %lli\n", __FILE__, fs_info->device_size);
fs_close();
}
int main(int argc, char *argv[])
{
DOS_FS fs;
rw = 0;
char *device = NULL;
char *label = NULL;
check_atari();
if (argc < 2 || argc > 3)
usage(1);
if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
usage(0);
else if (!strcmp(argv[1], "-V") || !strcmp(argv[1], "--version")) {
printf( "dosfslabel " VERSION ", " VERSION_DATE ", FAT32, LFN\n" );
exit(0);
}
device = argv[1];
if (argc == 3) {
label = argv[2];
if (strlen(label) > 11) {
fprintf(stderr,
"dosfslabel: labels can be no longer than 11 characters\n");
exit(1);
}
rw = 1;
}
fs_open(device, rw);
read_boot(&fs);
if (!rw) {
fprintf(stdout, "%s\n", fs.label);
exit(0);
}
write_label(&fs, label);
fs_close(rw);
return 0;
}
void read_bitmap(char* device, file_system_info fs_info, unsigned long* bitmap, int pui)
{
reiserfs_bitmap_t *fs_bitmap;
reiserfs_tree_t *tree;
unsigned long long blk = 0;
unsigned long long bused = 0, bfree = 0;
int start = 0;
int bit_size = 1;
int done = 0;
fs_open(device);
tree = reiserfs_fs_tree(fs);
fs_bitmap = tree->fs->bitmap;
/// init progress
progress_bar bprog; /// progress_bar structure defined in progress.h
progress_init(&bprog, start, fs->super->s_v1.sb_block_count, fs->super->s_v1.sb_block_count, BITMAP, bit_size);
for( blk = 0; blk < (unsigned long long)fs->super->s_v1.sb_block_count; blk++ ){
log_mesg(3, 0, 0, fs_opt.debug, "%s: block sb_block_count %llu\n", __FILE__, fs->super->s_v1.sb_block_count);
log_mesg(3, 0, 0, fs_opt.debug, "%s: block bitmap check %llu\n", __FILE__, blk);
if(reiserfs_tools_test_bit(blk, fs_bitmap->bm_map)){
bused++;
pc_set_bit(blk, bitmap);
}else{
bfree++;
pc_clear_bit(blk, bitmap);
}
/// update progress
update_pui(&bprog, blk, blk, done);
}
if(bfree != fs->super->s_v1.sb_free_blocks)
log_mesg(0, 1, 1, fs_opt.debug, "%s: bitmap free count err, free:%i\n", __FILE__, bfree);
fs_close();
/// update progress
update_pui(&bprog, 1, 1, 1);
}
/* Opens a file, allocates enough RAM to hold the whole thing,
reads it into RAM, and closes it. The caller owns the allocated
memory (and must free it). The file size is returned, or -1
on failure; on success, out_ptr is filled with the address
of the loaded buffer. */
ssize_t fs_load(const char * src, void ** out_ptr) {
file_t f;
void * data;
uint8 * out;
ssize_t total, left, r;
assert( out_ptr != NULL );
*out_ptr = NULL;
/* Try to open the file */
f = fs_open(src, O_RDONLY);
if (f == FILEHND_INVALID)
return -1;
/* Get the size and alloc a buffer */
left = fs_total(f);
total = 0;
data = malloc(left);
out = (uint8 *)data;
/* Load the data */
while (left > 0) {
r = fs_read(f, out, left);
if (r <= 0)
break;
left -= r;
total += r;
out += r;
}
/* Did we get it all? If not, realloc the buffer */
if (left > 0) {
*out_ptr = realloc(data, total);
if (*out_ptr == NULL)
*out_ptr = data;
} else
*out_ptr = data;
fs_close(f);
return total;
}
static int test_read_timeout(struct harness_t *harness_p)
{
struct fs_file_t file;
uint8_t byte;
uint8_t buf[516];
int i, j;
BTASSERT(fs_open(&file, "foo.txt", FS_WRITE | FS_CREAT | FS_TRUNC) == 0);
byte = 0;
for (i = 0; i < 130; i++) {
BTASSERT(fs_write(&file, &byte, 1) == 1);
byte++;
}
BTASSERT(fs_close(&file) == 0);
/* Input read request packet. */
socket_stub_input(0, "\x00""\x01""foo.txt""\x00""octet""\x00", 16);
/* Read the packet three times (first transmission + two
retransmissions). */
for (i = 0; i < 3; i++) {
socket_stub_output(&buf[0], 134);
BTASSERT(buf[0] == 0);
BTASSERT(buf[1] == 3);
BTASSERT(buf[2] == 0);
BTASSERT(buf[3] == 1);
byte = 0;
for (j = 0; j < 130; j++) {
BTASSERT(buf[4 + j] == byte);
byte++;
}
}
thrd_sleep_ms(10);
return (0);
}
/*..........................................................................*/
static void close_conn(struct tcp_pcb *pcb, struct http_state *hs) {
err_t err;
DEBUG_PRINT("Closing connection 0x%08x\n", pcb);
tcp_arg(pcb, NULL);
tcp_sent(pcb, NULL);
tcp_recv(pcb, NULL);
if (hs->handle) {
fs_close(hs->handle);
hs->handle = NULL;
}
if (hs->buf) {
mem_free(hs->buf);
}
mem_free(hs);
err = tcp_close(pcb);
if (err != ERR_OK) {
DEBUG_PRINT("Error %d closing 0x%08x\n", err, pcb);
}
}
/// readbitmap - read bitmap
extern void readbitmap(char* device, image_head image_hdr, char* bitmap, int pui)
{
reiserfs_bitmap_t *fs_bitmap;
reiserfs_tree_t *tree;
reiserfs_block_t *node;
blk_t blk;
unsigned long long bused = 0, bfree = 0;
int start = 0;
int bit_size = 1;
int done = 0;
fs_open(device);
tree = reiserfs_fs_tree(fs);
fs_bitmap = tree->fs->bitmap;
/// init progress
progress_bar bprog; /// progress_bar structure defined in progress.h
progress_init(&bprog, start, fs->super->s_v1.sb_block_count, bit_size);
for(blk = 0 ; (int)blk < fs->super->s_v1.sb_block_count; blk++){
if(reiserfs_tools_test_bit(blk, fs_bitmap->bm_map)){
bused++;
bitmap[blk] = 1;
}else{
bfree++;
bitmap[blk] = 0;
}
/// update progress
update_pui(&bprog, blk, done);
}
if(bfree != fs->super->s_v1.sb_free_blocks)
log_mesg(0, 1, 1, fs_opt.debug, "%s: bitmap free count err, free:%i\n", __FILE__, bfree);
fs_close();
/// update progress
done = 1;
update_pui(&bprog, 1, done);
}
void course_init()
{
fs_file fin;
char *line;
Array items;
int i;
if (course_state)
course_free();
count = 0;
if ((fin = fs_open(COURSE_FILE, "r")))
{
while (count < MAXCRS && read_line(&line, fin))
{
if (course_load(&course_v[count], line))
count++;
free(line);
}
fs_close(fin);
course_state = 1;
}
if ((items = fs_dir_scan("", is_unseen_course)))
{
array_sort(items, cmp_dir_items);
for (i = 0; i < array_len(items) && count < MAXCRS; i++)
if (course_load(&course_v[count], DIR_ITEM_GET(items, i)->path))
count++;
fs_dir_free(items);
course_state = 1;
}
}
GDI_track_t *gdi_get_track(GDI_header_t *hdr, uint32 lba) {
int i;
for(i = hdr->track_count - 1; i > -1; i--) {
if(hdr->tracks[i]->start_lba <= lba) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: %ld found in track #%d\n", __func__, lba, i + 1);
#endif
if(hdr->track_current != i) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Opening %s\n", __func__, hdr->tracks[i]->filename);
#endif
if(hdr->track_fd != FILEHND_INVALID) {
fs_close(hdr->track_fd);
}
hdr->track_fd = fs_open(hdr->tracks[i]->filename, O_RDONLY);
if(hdr->track_fd < 0) {
#ifdef DEBUG
dbglog(DBG_DEBUG, "%s: Can't open %s\n", __func__, hdr->tracks[i]->filename);
#endif
return NULL;
}
hdr->track_current = i;
}
return hdr->tracks[i];
}
}
return NULL;
}
/// readbitmap - read bitmap
extern void readbitmap(char* device, image_head image_hdr, char*bitmap, int pui)
{
reiser4_bitmap_t *fs_bitmap;
unsigned long long bit, block, bused = 0, bfree = 0;
int start = 0;
int bit_size = 1;
fs_open(device);
fs_bitmap = reiser4_bitmap_create(reiser4_format_get_len(fs->format));
reiser4_alloc_extract(fs->alloc, fs_bitmap);
/// init progress
progress_bar prog; /// progress_bar structure defined in progress.h
progress_init(&prog, start, image_hdr.totalblock, bit_size);
for(bit = 0; bit < reiser4_format_get_len(fs->format); bit++){
block = bit ;
if(reiser4_bitmap_test(fs_bitmap, bit)){
bused++;
bitmap[block] = 1;
log_mesg(3, 0, 0, fs_opt.debug, "%s: bitmap is used %lli", block, __FILE__);
} else {
bitmap[block] = 0;
bfree++;
log_mesg(3, 0, 0, fs_opt.debug, "%s: bitmap is free %lli", block, __FILE__);
}
/// update progress
update_pui(&prog, bit, 0);
}
if(bfree != reiser4_format_get_free(fs->format))
log_mesg(0, 1, 1, fs_opt.debug, "%s: bitmap free count err, bfree:%lli, sfree=%lli\n", __FILE__, bfree, reiser4_format_get_free(fs->format));
fs_close();
/// update progress
update_pui(&prog, bit, 1);
}
int
fsutil_write_file(const char *path, const void *data, uint32_t len)
{
struct fs_file *file;
int rc;
rc = fs_open(path, FS_ACCESS_WRITE, &file);
if (rc != 0) {
goto done;
}
rc = fs_write(file, data, len);
if (rc != 0) {
goto done;
}
rc = 0;
done:
fs_close(file);
return rc;
}
void Font::load(std::string filename)
{
uint8 *data;
file_t fd = fs_open(filename.c_str(), O_RDONLY);
data = new uint8[fs_total(fd)];
fs_read(fd, data, fs_total(fd));
fs_close(fd);
uint32 rofs;
memcpy(&header, data, sizeof(HeaderStruct));
assert_msg(Font::formatTag.compare(header.formatTag) == 0, "Wrong font format OR version");
/* Read characters */
rofs = header.characterDataOffset;
memcpy(&characterList.characterCount, &data[rofs], 4);
rofs += 4;
characterList.characters = new CharacterDataStruct[characterList.characterCount];
memcpy(characterList.characters, &data[rofs], (sizeof(CharacterDataStruct) * characterList.characterCount));
/* Read font texture */
rofs = header.fontTextureOffset;
int w = 0, h = 0, fmt = 0, byte_count = 0;
memcpy(&w, &data[rofs], 4);
memcpy(&h, &data[rofs + 0x4], 4);
memcpy(&fmt, &data[rofs + 0x8], 4);
memcpy(&byte_count, &data[rofs + 0xC], 4);
uint32 *tdata = new uint32[byte_count];
memcpy(tdata, &data[rofs + 0x10], byte_count);
texture = plx_txr_canvas(w, h, PVR_TXRFMT_ARGB4444);
pvr_txr_load_ex(tdata, texture->ptr, texture->w, texture->h, PVR_TXRLOAD_16BPP);
delete[] tdata;
delete[] data;
}
int gdi_close(GDI_header_t *hdr) {
if(!hdr) {
return -1;
}
int i;
for(i = 0; i < hdr->track_count; i++) {
if(hdr->tracks[i] != NULL) {
free(hdr->tracks[i]);
}
}
if(hdr->track_fd != FILEHND_INVALID) {
fs_close(hdr->track_fd);
}
free(hdr);
return 0;
}
/// readbitmap - read bitmap
extern void readbitmap(char* device, image_head image_hdr, unsigned long* bitmap, int pui)
{
uint32_t current = 0, used_block = 0, free_block = 0, err_block = 0, total = 0, alloc = 0;
int status = 0;
int start = 0;
int bit_size = 1;
fs_open(device);
/// init progress
progress_bar prog; /// progress_bar structure defined in progress.h
progress_init(&prog, start, image_hdr.totalblock, image_hdr.totalblock, BITMAP, bit_size);
total = fs->fbb->bmh.total_items;
alloc = vmfs_bitmap_allocated_items(fs->fbb);
for(current = 0; current < total; current++){
status = vmfs_block_get_status(fs, VMFS_BLK_FB_BUILD(current));
if (status == -1) {
err_block++;
pc_clear_bit(current, bitmap);
} else if (status == 1){
used_block++;
pc_set_bit(current, bitmap);
} else if (status == 0){
free_block++;
pc_clear_bit(current, bitmap);
}
log_mesg(2, 0, 0, fs_opt.debug, "%s: Block 0x%8.8x status: %i\n", __FILE__, current, status);
update_pui(&prog, current, current, 0);
}
fs_close();
update_pui(&prog, 1, 1, 1);
log_mesg(0, 0, 0, fs_opt.debug, "%s: Used:%lld, Free:%lld, Status err:%lld\n", __FILE__, used_block, free_block, err_block);
}
int
fsutil_read_file(const char *path, uint32_t offset, uint32_t len, void *dst,
uint32_t *out_len)
{
struct fs_file *file;
int rc;
rc = fs_open(path, FS_ACCESS_READ, &file);
if (rc != 0) {
goto done;
}
rc = fs_read(file, len, dst, out_len);
if (rc != 0) {
goto done;
}
rc = 0;
done:
fs_close(file);
return rc;
}
/// read super block and write to image head
extern void initial_image_hdr(char* device, image_head* image_hdr)
{
fs_open(device);
strncpy(image_hdr->magic, IMAGE_MAGIC, IMAGE_MAGIC_SIZE);
strncpy(image_hdr->fs, ufs_MAGIC, FS_MAGIC_SIZE);
image_hdr->block_size = afs.fs_fsize;
image_hdr->usedblocks = get_used_block();
switch (disk.d_ufs) {
case 2:
image_hdr->totalblock = (unsigned long long)afs.fs_size;
image_hdr->device_size = afs.fs_fsize*afs.fs_size;
break;
case 1:
image_hdr->totalblock = (unsigned long long)afs.fs_old_size;
image_hdr->device_size = afs.fs_fsize*afs.fs_old_size;
break;
default:
break;
}
fs_close();
}
// Lua: rename("oldname", "newname")
static int file_rename( lua_State* L )
{
size_t len;
if((FS_OPEN_OK - 1)!=file_fd){
fs_close(file_fd);
file_fd = FS_OPEN_OK - 1;
}
const char *oldname = luaL_checklstring( L, 1, &len );
if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long");
const char *newname = luaL_checklstring( L, 2, &len );
if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long");
if(SPIFFS_OK==myspiffs_rename( oldname, newname )){
lua_pushboolean(L, 1);
} else {
lua_pushboolean(L, 0);
}
return 1;
}
// Lua: open(filename, mode)
static int file_open( lua_State* L )
{
size_t len;
if((FS_OPEN_OK - 1)!=file_fd){
fs_close(file_fd);
file_fd = FS_OPEN_OK - 1;
}
const char *fname = luaL_checklstring( L, 1, &len );
if( len > FS_NAME_MAX_LENGTH )
return luaL_error(L, "filename too long");
const char *mode = luaL_optstring(L, 2, "r");
file_fd = fs_open(fname, fs_mode2flag(mode));
if(file_fd < FS_OPEN_OK){
file_fd = FS_OPEN_OK - 1;
lua_pushnil(L);
} else {
lua_pushboolean(L, 1);
}
return 1;
}
/** Load an EFI application.
* @param args Argument list.
* @return Whether successful. */
static bool config_cmd_efi(value_list_t *args) {
efi_loader_t *loader;
status_t ret;
if (args->count != 1 || args->values[0].type != VALUE_TYPE_STRING) {
config_error("Invalid arguments");
return false;
}
loader = malloc(sizeof(*loader));
loader->args.type = VALUE_TYPE_STRING;
split_cmdline(args->values[0].string, &loader->path, &loader->args.string);
ret = fs_open(loader->path, NULL, FILE_TYPE_REGULAR, 0, &loader->handle);
if (ret != STATUS_SUCCESS) {
config_error("Error opening '%s': %pS", loader->path, ret);
goto err_free;
}
loader->efi_path = convert_file_path(loader->handle, loader->path);
if (!loader->efi_path)
goto err_close;
environ_set_loader(current_environ, &efi_loader_ops, loader);
return true;
err_close:
fs_close(loader->handle);
err_free:
value_destroy(&loader->args);
free(loader->path);
free(loader);
return false;
}
uint32 camsensor_reg_file_read
(
const char *filename,
uint32 register_set_size,
camsensor_parser_register_t *register_set
)
{
//int i;
fs_rsp_msg_type rsp_msg;
fs_handle_type fhandle = 0;
unsigned char *param_file;
unsigned char *temp_ptr;
uint32 file_size;
uint32 register_index = 0;
//u_int16_t param_version;
u_int16_t reg_address;
u_int16_t reg_val;
fs_nametest(filename, FS_TEST_FILE, NULL, &rsp_msg);
if ( !rsp_msg.nametest.name_found )
{
MSG_FATAL(" File Not Found! ",0,0,0);
return 0;
}
else
{ //when SensorParamTable exists
fs_open(filename, FS_OA_READONLY, NULL, NULL, &rsp_msg);
MSG_FATAL(" File Open O.K ! ",0,0,0);
if (rsp_msg.open.handle == FS_NULL_HANDLE)
{
MSG_ERROR ("File was not opened!!!",0,0,0);
fs_close(fhandle,NULL,&rsp_msg);
return 0;
}
fhandle = rsp_msg.open.handle;
fs_file_size(filename, NULL, &rsp_msg);
if (rsp_msg.file_size.status != FS_OKAY_S)
{
MSG_ERROR ("File size read fail!!!",0,0,0);
rsp_msg.file_size.size = MAX_SENSORPARAM_SIZE;
fs_close(fhandle,NULL,&rsp_msg);
ERR_FATAL("ERR!",0,0,0);
return 0;
}
file_size = rsp_msg.file_size.size;
param_file = (unsigned char *)malloc(file_size+2);
if(param_file==NULL)
{
fs_close(fhandle,NULL,&rsp_msg);
ERR_FATAL("ERR!",0,0,0);
return 0;
}
*(param_file+file_size)= NULL;
*(param_file+file_size+1)=NULL;
fs_read ( fhandle, (void *)param_file, file_size, NULL, &rsp_msg );
if ( rsp_msg.read.status != FS_OKAY_S )
{
MSG_ERROR ("File read file header fail!!!",0,0,0);
free((void *)param_file);
fs_close(fhandle,NULL,&rsp_msg);
return 0;
}
else
{
fs_close(fhandle, NULL, &rsp_msg);
if ( rsp_msg.close.status != FS_OKAY_S )
{
MSG_ERROR ("File closing fail!!!",0,0,0);
}
temp_ptr = param_file;
while (temp_ptr)
{
//20070622_c@m_이창원_chg [
// if ((temp_ptr=find_next_address(temp_ptr, ®_address)))
if ((temp_ptr=find_next_address(temp_ptr, ®_address)) != NULL)
{
//20070622_c@m_이창원_chg [
// if ((temp_ptr=find_next_val(temp_ptr, ®_val)))
if ((temp_ptr=find_next_val(temp_ptr, ®_val)) != NULL)
{
register_set[register_index].address = reg_address;
register_set[register_index].value = reg_val;
register_index++;
if (register_index >= register_set_size)
{
ERR_FATAL("ERR!",0,0,0);
return 0;
}
}
}
}
}
free((void *)param_file);
}
return register_index;
}
int DC_CheckForMaps(char *path) {
file_t dir;
dirent_t *dirent;
char fpath[1024];
int disc_status;
for(;;) {
SDL_Delay(5);
disc_status = DC_CheckDrive();
#ifdef SPEAR
DC_DrawString(4, 1, "Sod4SDL\\DC");
#else
DC_DrawString(4, 1, "Wolf4SDL\\DC");
#endif
switch(disc_status) {
//case CD_STATUS_BUSY:
//case CD_STATUS_OPEN:
// DC_DrawString(4, 6, "Please insert your Wolfenstein 3D CD.");
// break;
default:
dir = fs_open(path, O_DIR);
while(dirent = fs_readdir(dir)) {
#ifdef SPEAR
#ifdef SPEARDEMO
if(!strcmp(dirent->name, "AUDIOHED.SDM")) {
fs_close(dir);
strcpy(dcwolf3dpath, path);
return 0;
}
#else
if(!strcmp(dirent->name, "AUDIOHED.SOD")) {
fs_close(dir);
strcpy(dcwolf3dpath, path);
param_mission = DC_SetMission(path);
return 0;
}
#endif
#else
#ifdef UPLOAD
if(!strcmp(dirent->name, "AUDIOHED.WL1")) {
fs_close(dir);
strcpy(dcwolf3dpath, path);
return 0;
}
#else
if(!strcmp(dirent->name, "AUDIOHED.WL6")) {
fs_close(dir);
strcpy(dcwolf3dpath, path);
return 0;
}
#endif
#endif
strcpy(fpath, path);
sprintf(fpath, "%s/%s", fpath, dirent->name);
DC_CheckForMaps(fpath);
}
fs_close(dir);
return -1;
}
DC_Flip();
}
}
