static bool fs_sis_try_link(struct sis_fs_file *file)
{
const char *path = fs_file_path(&file->file);
const struct stat *st;
struct stat st2;
st = i_stream_stat(file->hash_input, FALSE);
/* we can use the existing file */
if (fs_link(file->super->fs, file->hash_path, path) < 0) {
if (errno != ENOENT && errno != EMLINK)
i_error("fs-sis: %s", fs_last_error(file->super->fs));
/* failed to use link(), continue as if it hadn't been equal */
return FALSE;
}
if (fs_stat(file->super->fs, path, &st2) < 0) {
i_error("fs-sis: %s", fs_last_error(file->super->fs));
if (fs_unlink(file->super->fs, path) < 0)
i_error("fs-sis: %s", fs_last_error(file->super->fs));
return FALSE;
}
if (st->st_ino != st2.st_ino) {
/* the hashes/ file was already replaced with something else */
if (fs_unlink(file->super->fs, path) < 0)
i_error("fs-sis: %s", fs_last_error(file->super->fs));
return FALSE;
}
return TRUE;
}
void unlink_device(char *sym_name, enum FS_STO_TYPE type)
{
char mount_name[16]; // like "/mnt/uda1"
struct stat st;
if(fs_stat(sym_name, &st) == 0)
{
fs_readlink(sym_name, mount_name, 16);
switch(type)
{
case MNT_TYPE_IDE:
if(mount_name[5] == 'h')
fs_unlink(sym_name);
break;
case MNT_TYPE_SD:
if((mount_name[5] == 's') && (mount_name[6] == 'd'))
fs_unlink(sym_name);
break;
case MNT_TYPE_USB:
if(mount_name[5] == 'u')
fs_unlink(sym_name);
break;
case MNT_TYPE_SATA:
if((mount_name[5] == 's') && (mount_name[6] == 'h'))
fs_unlink(sym_name);
break;
default:
break;
}
}
}
static void fs_sis_replace_hash_file(struct sis_fs_file *file)
{
const char *hash_fname, *path = fs_file_path(&file->file);
struct fs *super_fs = file->super->fs;
string_t *temp_path;
int ret;
if (file->hash_input == NULL) {
/* hash file didn't exist previously. we should be able to
create it with link() */
if (fs_link(super_fs, path, file->hash_path) < 0) {
if (errno == EEXIST) {
/* the file was just created. it's probably
a duplicate, but it's too much trouble
trying to deduplicate it anymore */
} else {
i_error("fs-sis: %s", fs_last_error(super_fs));
}
}
return;
}
temp_path = t_str_new(256);
hash_fname = strrchr(file->hash_path, '/');
if (hash_fname == NULL)
hash_fname = file->hash_path;
else {
str_append_n(temp_path, file->hash_path,
(hash_fname-file->hash_path) + 1);
hash_fname++;
}
str_printfa(temp_path, "%s%s.tmp",
super_fs->set.temp_file_prefix, hash_fname);
/* replace existing hash file atomically */
ret = fs_link(super_fs, path, str_c(temp_path));
if (ret < 0 && errno == EEXIST) {
/* either someone's racing us or it's a stale file.
try to continue. */
if (fs_unlink(super_fs, str_c(temp_path)) < 0 &&
errno != ENOENT)
i_error("fs-sis: %s", fs_last_error(super_fs));
ret = fs_link(super_fs, path, str_c(temp_path));
}
if (ret < 0) {
i_error("fs-sis: %s", fs_last_error(super_fs));
return;
}
if (fs_rename(super_fs, str_c(temp_path), file->hash_path) < 0) {
if (errno == ENOENT) {
/* apparently someone else just renamed it. ignore. */
} else {
i_error("fs-sis: %s", fs_last_error(super_fs));
}
(void)fs_unlink(super_fs, str_c(temp_path));
}
}
static int unlink_recursive(char path[STORAGE_PATH_MAX])
{
size_t path_len;
fs_dir_t dir;
int err;
err = fs_opendir(&dir, path);
if (err) {
return err;
}
/* We calculate this up-front so we can keep reusing the same
* buffer for the path when recursing.
*/
path_len = strlen(path);
while (1) {
struct fs_dirent entry;
err = fs_readdir(&dir, &entry);
if (err) {
break;
}
if (entry.name[0] == '\0') {
break;
}
snprintk(path + path_len, STORAGE_PATH_MAX - path_len, "/%s",
entry.name);
if (entry.type == FS_DIR_ENTRY_DIR) {
err = unlink_recursive(path);
} else {
err = fs_unlink(path);
}
if (err) {
break;
}
}
fs_closedir(&dir);
/* Return to the original value */
path[path_len] = '\0';
fs_unlink(path);
return err;
}
void fs_sis_try_unlink_hash_file(struct fs *fs, struct fs *super,
const char *path)
{
struct stat st1, st2;
const char *dir, *hash, *hash_path, *hash_dir;
if (fs_sis_path_parse(fs, path, &dir, &hash) == 0 &&
fs_stat(super, path, &st1) == 0 && st1.st_nlink == 2) {
/* this may be the last link. if hashes/ file is the same,
delete it. */
hash_path = t_strdup_printf("%s/"HASH_DIR_NAME"/%s", dir, hash);
if (fs_stat(super, hash_path, &st2) == 0 &&
st1.st_ino == st2.st_ino &&
CMP_DEV_T(st1.st_dev, st2.st_dev)) {
if (fs_unlink(super, hash_path) < 0)
i_error("%s", fs_last_error(super));
else {
/* try to rmdir the hashes/ directory */
hash_dir = t_strdup_printf("%s/"HASH_DIR_NAME,
dir);
(void)fs_rmdir(super, hash_dir);
}
}
}
}
/**
* Deletes the main image version number from the boot vector.
*
* @return 0 on success; nonzero on failure.
*/
int
boot_vect_delete_main(void)
{
int rc;
rc = fs_unlink(BOOT_PATH_MAIN);
return rc;
}
/**
* Deletes the test image version number from the boot vector.
*
* @return 0 on success; nonzero on failure.
*/
int
boot_vect_delete_test(void)
{
int rc;
rc = fs_unlink(BOOT_PATH_TEST);
return rc;
}
int do_unlink(const char *filename,uint64_t lv,uint32_t ts,char *ptr) {
uint32_t inode,parent;
uint8_t name[256];
EAT(ptr,filename,lv,'(');
GETU32(parent,ptr);
EAT(ptr,filename,lv,',');
GETNAME(name,ptr,filename,lv,')');
EAT(ptr,filename,lv,')');
EAT(ptr,filename,lv,':');
GETU32(inode,ptr);
return fs_unlink(ts,parent,strlen((char*)name),name,inode);
}
/*
rm command
*/
LOCAL void cmd_rm(INT ac, B *av[])
{
ER er;
if (ac < 2) return;
er = fs_unlink(av[1]);
if (er >= E_OK) {
P("file '%s' removed\n", av[1]);
} else {
P("fs_unlink(%s) ERR [%#x]\n", av[1], er);
}
}
void WriteConfig(void)
{
char configpath[300];
#ifdef _arch_dreamcast
fs_unlink(configname);
#endif
if(configdir[0])
snprintf(configpath, sizeof(configpath), "%s/%s", configdir, configname);
else
strcpy(configpath, configname);
const int file = open(configpath, O_CREAT | O_WRONLY | O_BINARY, 0644);
if (file != -1)
{
word tmp=0xfefa;
write(file,&tmp,sizeof(tmp));
write(file,Scores,sizeof(HighScore) * MaxScores);
write(file,&SoundMode,sizeof(SoundMode));
write(file,&MusicMode,sizeof(MusicMode));
write(file,&DigiMode,sizeof(DigiMode));
write(file,&mouseenabled,sizeof(mouseenabled));
write(file,&joystickenabled,sizeof(joystickenabled));
boolean dummyJoypadEnabled = false;
write(file,&dummyJoypadEnabled,sizeof(dummyJoypadEnabled));
boolean dummyJoystickProgressive = false;
write(file,&dummyJoystickProgressive,sizeof(dummyJoystickProgressive));
int dummyJoystickPort = 0;
write(file,&dummyJoystickPort,sizeof(dummyJoystickPort));
write(file,dirscan,sizeof(dirscan));
write(file,buttonscan,sizeof(buttonscan));
write(file,buttonmouse,sizeof(buttonmouse));
write(file,buttonjoy,sizeof(buttonjoy));
write(file,&viewsize,sizeof(viewsize));
write(file,&mouseadjustment,sizeof(mouseadjustment));
close(file);
}
#ifdef _arch_dreamcast
DC_SaveToVMU(configname, NULL);
#endif
}
static efi_status_t EFIAPI efi_file_delete(struct efi_file_handle *file)
{
struct file_handle *fh = to_fh(file);
efi_status_t ret = EFI_SUCCESS;
EFI_ENTRY("%p", file);
if (set_blk_dev(fh)) {
ret = EFI_DEVICE_ERROR;
goto error;
}
if (fs_unlink(fh->path))
ret = EFI_DEVICE_ERROR;
file_close(fh);
error:
return EFI_EXIT(ret);
}
int savegame_simple ()
{
char home[MAX_PATH], path[MAX_PATH];
#ifdef DREAMCAST
uint8 addr, port, unit;
addr = maple_first_vmu();
if(addr) {
maple_create_port(addr, &port, &unit);
sprintf(g_vmu_port, "%c%d", port + 'a', unit);
} else {
message_box("No VMU found.");
return err_OK;
}
sprintf(path, VMU_PATH, g_vmu_port, game.id, slot);
fs_unlink(path);
#else
if (get_app_dir (home, MAX_PATH) < 0) {
message_box ("Couldn't save game.");
return err_BadFileOpen;
}
sprintf (path, "%s/" DATA_DIR "/", home);
MKDIR (path, 0755);
sprintf (path, "%s/" DATA_DIR "/%05X.%s/", home, game.crc, game.id);
MKDIR (path, 0711);
sprintf (path, "%s/" DATA_DIR "/%05X.%s/%08d.sav",
home, game.crc, game.id, 0);
#endif
printf("here?\n");
save_game (path, "Default savegame");
return err_OK;
}
void __elf_clear()
{
fs_unlink(__elf_logfile);
}
/**
* Prepares the booting process. Based on the information provided in the
* request object, this function moves images around in flash as appropriate,
* and tells you what address to boot from.
*
* @param req Contains information about the flash layout.
* @param rsp On success, indicates how booting should occur.
*
* @return 0 on success; nonzero on failure.
*/
int
boot_go(const struct boot_req *req, struct boot_rsp *rsp)
{
struct boot_image_location image_addrs[BOOT_NUM_SLOTS];
int slot;
int rc;
int i;
/* Set the global boot request object. The remainder of the boot process
* will reference the global.
*/
boot_req = req;
/* Initialize the flash hardware and the file system. */
rc = boot_init_flash();
if (rc != 0) {
return rc;
}
/* Read the boot status to determine if an image copy operation was
* interrupted (i.e., the system was reset before the boot loader could
* finish its task last time).
*/
boot_status_entries =
malloc(req->br_num_image_areas * sizeof *boot_status_entries);
if (boot_status_entries == NULL) {
return BOOT_ENOMEM;
}
rc = boot_read_status(&boot_status, boot_status_entries,
boot_req->br_num_image_areas);
if (rc == 0) {
/* We are resuming an interrupted image copy. */
rc = boot_copy_image(boot_status.bs_img1_length,
boot_status.bs_img2_length);
if (rc != 0) {
/* We failed to put the images back together; there is really no
* solution here.
*/
return rc;
}
}
/* Cache the flash address of each image slot. */
for (i = 0; i < BOOT_NUM_SLOTS; i++) {
boot_slot_addr(i, &image_addrs[i].bil_flash_id,
&image_addrs[i].bil_address);
}
/* Attempt to read an image header from each slot. */
boot_read_image_headers(boot_img_hdrs, image_addrs, BOOT_NUM_SLOTS);
/* Build a boot status structure indicating the flash location of each
* image part. This structure will need to be used if an image copy
* operation is required.
*/
boot_build_status();
/* Determine which image the user wants to run, and where it is located. */
slot = boot_select_image_slot();
if (slot == -1) {
/* Either there is no image vector, or none of the requested images are
* present. Just try booting from the first image slot.
*/
if (boot_img_hdrs[0].ih_magic != IMAGE_MAGIC_NONE) {
slot = 0;
} else if (boot_img_hdrs[1].ih_magic != IMAGE_MAGIC_NONE) {
slot = 1;
} else {
/* No images present. */
return BOOT_EBADIMAGE;
}
}
switch (slot) {
case 0:
rsp->br_hdr = &boot_img_hdrs[0];
break;
case 1:
/* The user wants to run the image in the secondary slot. The contents
* of this slot need to moved to the primary slot.
*/
rc = boot_copy_image(boot_status.bs_img1_length,
boot_status.bs_img2_length);
if (rc != 0) {
/* We failed to put the images back together; there is really no
* solution here.
*/
return rc;
}
rsp->br_hdr = &boot_img_hdrs[1];
break;
default:
assert(0);
break;
}
/* Always boot from the primary slot. */
rsp->br_flash_id = image_addrs[0].bil_flash_id;
rsp->br_image_addr = image_addrs[0].bil_address;
/* After successful boot, there should not be a status file. */
fs_unlink(BOOT_PATH_STATUS);
/* If an image is being tested, it should only be booted into once. */
boot_vect_delete_test();
return 0;
}
int coleco_save_state(const char *filename) {
char tmpfn[4096];
int rv;
uint32 crc, adler;
uint8 *buf, *buf2;
FILE *fp;
long len;
uLong clen;
vmu_pkg_t pkg;
uint8 *pkg_out;
int pkg_size;
maple_device_t *vmu;
file_t f;
int blocks_freed = 0;
/* Make sure there's a VMU in port A1. */
if(!(vmu = maple_enum_dev(0, 1))) {
return -100;
}
if(!vmu->valid || !(vmu->info.functions & MAPLE_FUNC_MEMCARD)) {
return -100;
}
sprintf(tmpfn, "/ram/%s", filename);
rv = coleco_save_state_int(tmpfn);
if(rv)
return rv;
/* Read in the uncompressed save state */
fp = fopen(tmpfn, "rb");
if(!fp) {
fs_unlink(tmpfn);
return -1;
}
fseek(fp, 0, SEEK_END);
len = ftell(fp);
fseek(fp, 0, SEEK_SET);
if(!(buf = (uint8 *)malloc(len))) {
fclose(fp);
fs_unlink(tmpfn);
return -1;
}
fread(buf, 1, len, fp);
fclose(fp);
fs_unlink(tmpfn);
/* Create a compressed version */
clen = len * 2;
if(!(buf2 = (uint8 *)malloc(clen + 8))) {
free(buf);
return -1;
}
if(compress2(buf2 + 8, &clen, buf, len, 9) != Z_OK) {
free(buf2);
free(buf);
return -1;
}
/* Clean up the old buffer and save the length of the uncompressed data into
the new buffer */
free(buf);
*((uint32 *)buf2) = (uint32)len;
*(((uint32 *)buf2) + 1) = (uint32)clen;
/* Make the VMU save */
coleco_get_checksums(&crc, &adler);
sprintf(tmpfn, "/vmu/a1/ss-%08" PRIX32, (uint32_t)crc);
if(filename != NULL) {
strncpy(pkg.desc_long, filename, 32);
pkg.desc_long[31] = 0;
}
else {
sprintf(pkg.desc_long, "CRC: %08" PRIX32 " Adler: %08" PRIX32,
(uint32_t)crc, (uint32_t)adler);
}
strcpy(pkg.desc_short, "CrabEmu State");
strcpy(pkg.app_id, "CrabEmu");
pkg.icon_cnt = 1;
pkg.icon_anim_speed = 0;
memcpy(pkg.icon_pal, icon_pal, 32);
pkg.icon_data = icon_img;
pkg.eyecatch_type = VMUPKG_EC_NONE;
pkg.data_len = clen + 4;
pkg.data = buf2;
vmu_pkg_build(&pkg, &pkg_out, &pkg_size);
/* See if a file exists with that name, since we'll overwrite it. */
f = fs_open(tmpfn, O_RDONLY);
if(f != FILEHND_INVALID) {
blocks_freed = fs_total(f) >> 9;
fs_close(f);
}
int process_request(const char *line, FILE *fp, FileSystem *fs) {
char command[4096];
#ifdef DEBUG
fprintf(stderr, "process request `%s`\n", line);
#endif
sscanf(line, "%s", command);
#ifdef DEBUG
fprintf(stderr, "command is `%s`\n", command);
#endif
if (0 == strcmp("f", command)) {
fs_format(fs);
return RESULT_DONE;
} else if (0 == strcmp("mk", command)) {
char f[4096];
char parent_path[4096];
sscanf(line + 2, "%s", f);
#ifdef DEBUG
fprintf(stderr, "> mk `%s`\n", f);
#endif
if (fs_exists(fs, f)) {
#ifdef DEBUG
fprintf(stderr, "> `%s` already exists\n", f);
#endif
return RESULT_NO;
} else {
#ifdef DEBUG
fprintf(stderr, "> going to create `%s`\n", f);
#endif
}
fs_split_path(f, parent_path, NULL);
if (fs_isdir(fs, parent_path)) {
if (fs_create(fs, f)) {
#ifdef DEBUG
fprintf(stderr, "> failed to create `%s`\n", f);
#endif
return RESULT_NO;
}
return RESULT_YES;
}
#ifdef DEBUG
fprintf(stderr, "> parent path `%s` is not a directory\n", parent_path);
#endif
return RESULT_NO;
} else if (0 == strcmp("mkdir", command)) {
char d[4096];
char parent_path[4096];
sscanf(line + 5, "%s", d);
if (fs_exists(fs, d)) {
return RESULT_NO;
}
fs_split_path(d, parent_path, NULL);
if (fs_isdir(fs, parent_path)) {
if (fs_mkdir(fs, d)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("rm", command)) {
char f[4096];
sscanf(line + 2, "%s", f);
if (fs_isfile(fs, f)) {
if (fs_unlink(fs, f)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("cd", command)) {
char path[4096];
sscanf(line + 2, "%s", path);
if (fs_isdir(fs, path)) {
if (fs_chdir(fs, path)) {
return RESULT_NO;
}
return RESULT_YES;
}
#ifdef DEBUG
fprintf(stderr, "`%s` is not a directory\n", path);
#endif
return RESULT_NO;
} else if (0 == strcmp("rmdir", command)) {
char d[4096];
sscanf(line + 5, "%s", d);
if (fs_isdir(fs, d)) {
if (fs_rmdir(fs, d)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("ls", command)) {
fs_ls(fs, fp);
return RESULT_ELSE;
} else if (0 == strcmp("cat", command)) {
char f[4096];
sscanf(line + 3, "%s", f);
if (fs_isfile(fs, f)) {
fs_cat(fs, f, fp);
return RESULT_ELSE;
}
return RESULT_NO;
} else if (0 == strcmp("w", command)) {
char f[4096];
int l;
char data[4096];
sscanf(line + 1, "%s %d %[^\n]", f, &l, data);
if (fs_isfile(fs, f)) {
if (fs_write(fs, f, l, data)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("i", command)) {
char f[4096];
int pos;
int l;
char data[4096];
sscanf(line + 1, "%s %d %d %[^\n]", f, &pos, &l, data);
if (fs_isfile(fs, f)) {
if (fs_insert(fs, f, pos, l, data)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("d", command)) {
char f[4096];
int pos;
int l;
sscanf(line + 1, "%s %d %d", f, &pos, &l);
if (fs_isfile(fs, f)) {
if (fs_delete(fs, f, pos, l)) {
return RESULT_NO;
}
return RESULT_YES;
}
return RESULT_NO;
} else if (0 == strcmp("e", command)) {
return RESULT_EXIT;
}
return RESULT_ELSE;
}
int _unlink_r(void * reent, const char * fn) {
(void)reent;
return fs_unlink(fn);
}
int savegame_dialog ()
{
#ifndef PALMOS /* FIXME */
char home[MAX_PATH], path[MAX_PATH];
char *desc;
char *buttons[] = { "Do as I say!", "I regret", NULL };
char dstr[200];
int rc, slot = 0;
int hm, vm, hp, vp; /* box margins */
int w;
hm = 2; vm = 3;
hp = hm * CHAR_COLS; vp = vm * CHAR_LINES;
w = (40 - 2 * hm) - 1;
#ifdef DREAMCAST
uint8 addr, port, unit;
addr = maple_first_vmu();
if(addr) {
maple_create_port(addr, &port, &unit);
sprintf(g_vmu_port, "%c%d", port + 'a', unit);
} else {
message_box("No VMU found.");
return err_OK;
}
#else
if (get_app_dir (home, MAX_PATH) < 0) {
message_box ("Couldn't save game.");
return err_BadFileOpen;
}
# ifdef CIBYL
sprintf (path, "recordstore://%05X.%s:",
game.crc, game.id);
# else
/* DATADIR conflicts with ObjIdl.h in win32 SDK, renamed to DATA_DIR */
sprintf (path, "%s/" DATA_DIR "/", home);
MKDIR (path, 0755);
sprintf (path, "%s/" DATA_DIR "/%05X.%s/", home, game.crc, game.id);
MKDIR (path, 0711);
# endif
#endif
erase_both ();
draw_window (hp, vp, GFX_WIDTH - hp, GFX_HEIGHT - vp);
print_text ("Select a slot in which you wish to save the game:",
0, hm + 1, vm + 1, w, MSG_BOX_TEXT, MSG_BOX_COLOUR);
print_text ("Press ENTER to select, ESC cancels",
0, hm + 1, vm + 17, w, MSG_BOX_TEXT, MSG_BOX_COLOUR);
slot = select_slot (path);
if (slot < 0) /* ESC pressed */
return err_OK;
/* Get savegame description */
draw_window (hp, vp + 5 * CHAR_LINES, GFX_WIDTH - hp,
GFX_HEIGHT - vp - 9 * CHAR_LINES);
print_text ("Enter a description for this game:",
0, hm + 1, vm + 6, w, MSG_BOX_TEXT, MSG_BOX_COLOUR);
draw_rectangle (3 * CHAR_COLS, 11 * CHAR_LINES - 1,
37 * CHAR_COLS, 12 * CHAR_LINES, MSG_BOX_TEXT);
flush_block (3 * CHAR_COLS, 11 * CHAR_LINES - 1,
37 * CHAR_COLS, 12 * CHAR_LINES);
get_string (2, 11, 33, MAX_STRINGS);
print_character (3, 11, game.cursor_char, MSG_BOX_COLOUR, MSG_BOX_TEXT);
do { main_cycle (); } while (game.input_mode == INPUT_GETSTRING);
close_window ();
desc = game.strings[MAX_STRINGS];
sprintf (dstr, "Are you sure you want to save the game "
"described as:\n\n%s\n\nin slot %d?\n\n\n",
desc, slot);
rc = selection_box (dstr, buttons);
if (rc != 0) {
message_box ("Game NOT saved.");
return err_OK;
}
#ifdef DREAMCAST
sprintf(path, VMU_PATH, g_vmu_port, game.id, slot);
fs_unlink(path);
#elif CIBYL
sprintf (path, "recordstore://%05X.%s:%d",
game.crc, game.id, slot+1);
printf("path: %s\n", path);
#else
sprintf (path, "%s/" DATA_DIR "/%05X.%s/%08d.sav",
home, game.crc, game.id, slot);
#endif
_D (_D_WARN "file is [%s]", path);
save_game (path, desc);
message_box ("Game saved.");
#endif /* PALMOS */
return err_OK;
}
void Speedtest_Run(GUI_Widget *widget) {
uint8 *buff = (uint8*)0x8c400000;
size_t buff_size = 0x10000;
int size = 0x800000, cnt = 0, rs;
int64 time_before, time_after;
uint32 t;
double speed;
file_t fd;
int read_only = 0;
char name[64];
char result[128];
const char *wname = GUI_ObjectGetName((GUI_Object *)widget);
if(!strncasecmp(wname, "/cd", 3)) {
read_only = 1;
snprintf(name, sizeof(name), "%s/1DS_CORE.BIN", wname);
if(FileExists(name)) {
goto readtest;
} else {
snprintf(name, sizeof(name), "%s/1ST_READ.BIN", wname);
goto readtest;
}
}
show_status_ok("Testing WRITE speed...");
GUI_LabelSetText(self.speedwr, "...");
GUI_LabelSetText(self.speedrd, " ");
snprintf(name, sizeof(name), "%s/%s.tst", wname, lib_get_name());
if(FileExists(name)) {
fs_unlink(name);
}
/* WRITE TEST */
fd = fs_open(name, O_CREAT | O_WRONLY);
if (fd == FILEHND_INVALID) {
ds_printf("DS_ERROR: Can't open %s for write: %d\n", name, errno);
show_status_error("Can't open file for write");
return;
}
ShutdownVideoThread();
time_before = timer_ms_gettime64();
while(cnt < size) {
rs = fs_write(fd, buff, buff_size);
if(rs <= 0) {
fs_close(fd);
InitVideoThread();
ds_printf("DS_ERROR: Can't write to file: %d\n", errno);
show_status_error("Can't write to file");
return;
}
buff += rs;
cnt += rs;
}
time_after = timer_ms_gettime64();
InitVideoThread();
t = (uint32)(time_after - time_before);
speed = size / ((float)t / 1000);
fs_close(fd);
snprintf(result, sizeof(result),
"Write speed %.2f Kbytes/s (%.2f Mbit/s) Time: %ld ms",
speed / 1024, ((speed / 1024) / 1024) * 8, t);
GUI_LabelSetText(self.speedwr, result);
show_status_ok("Complete!");
ds_printf("DS_OK: Complete!\n"
" Test: write\n Time: %ld ms\n"
" Speed: %.2f Kbytes/s (%.2f Mbit/s)\n"
" Size: %d Kb\n Buff: %d Kb\n",
t, speed / 1024,
((speed / 1024) / 1024) * 8,
size / 1024, buff_size / 1024);
readtest:
show_status_ok("Testing READ speed...");
GUI_LabelSetText(self.speedrd, "...");
/* READ TEST */
fd = fs_open(name, O_RDONLY);
if (fd == FILEHND_INVALID) {
ds_printf("DS_ERROR: Can't open %s for read: %d\n", name, errno);
show_status_error("Can't open file for read");
return;
}
if(read_only) {
GUI_LabelSetText(self.speedwr, "Write test passed");
/* Reset ISO9660 filesystem cache */
fs_ioctl(fd, NULL, 0);
fs_close(fd);
fd = fs_open(name, O_RDONLY);
}
time_before = time_after = t = cnt = 0;
speed = 0.0f;
size = fs_total(fd);
buff = rd_buff;
ShutdownVideoThread();
time_before = timer_ms_gettime64();
while(cnt < size) {
rs = fs_read(fd, buff, buff_size);
if(rs <= 0) {
fs_close(fd);
InitVideoThread();
ds_printf("DS_ERROR: Can't read file: %d\n", errno);
show_status_error("Can't read file");
return;
}
cnt += rs;
}
time_after = timer_ms_gettime64();
t = (uint32)(time_after - time_before);
speed = size / ((float)t / 1000);
fs_close(fd);
if(!read_only) {
fs_unlink(name);
} else {
cdrom_spin_down();
}
snprintf(result, sizeof(result),
"Read speed %.2f Kbytes/s (%.2f Mbit/s) Time: %ld ms",
speed / 1024, ((speed / 1024) / 1024) * 8, t);
InitVideoThread();
ds_printf("DS_OK: Complete!\n"
" Test: read\n Time: %ld ms\n"
" Speed: %.2f Kbytes/s (%.2f Mbit/s)\n"
" Size: %d Kb\n Buff: %d Kb\n",
t, speed / 1024,
((speed / 1024) / 1024) * 8,
size / 1024, buff_size / 1024);
GUI_LabelSetText(self.speedrd, result);
show_status_ok("Complete!");
}
/**
* Erases the boot status from the flash file system. The boot status
* contains the current state of an in-progress image copy operation. By
* erasing the boot status, it is implied that there is no copy operation in
* progress.
*/
void
boot_clear_status(void)
{
fs_unlink(BOOT_PATH_STATUS);
}
void gd_ripper_StartRip() {
file_t fd;
CDROM_TOC toc ;
int status, disc_type ,cdcr ,start ,s_end ,nsec ,type ,tn ,session,terr=0;
char dst_folder[MAX_FN_LEN];
char dst_file[MAX_FN_LEN];
char riplabel[64];
char text[MAX_FN_LEN];
uint64 stoptimer , starttimer , riptime;
starttimer = timer_ms_gettime64 (); // timer
cdrom_reinit();
snprintf(text ,MAX_FN_LEN,"%s", GUI_TextEntryGetText(self.gname));
if(GUI_WidgetGetState(self.sd_c)) {
snprintf(dst_folder, MAX_FN_LEN, "/sd/%s", text);
}else if(GUI_WidgetGetState(self.hdd_c)) {
snprintf(dst_folder, MAX_FN_LEN, "/ide/%s", text);
}else if(GUI_WidgetGetState(self.net_c)) {
snprintf(dst_folder, MAX_FN_LEN, "/net/%s", text);
}
//ds_printf("Dst file1 %s\n" ,dst_folder);
getstatus:
if((cdcr = cdrom_get_status(&status, &disc_type)) != ERR_OK) {
switch (cdcr){
case ERR_NO_DISC :
ds_printf("DS_ERROR: Disk not inserted\n");
return;
case ERR_DISC_CHG :
cdrom_reinit();
goto getstatus;
case CD_STATUS_BUSY :
thd_sleep(200);
goto getstatus;
case CD_STATUS_SEEKING :
thd_sleep(200);
goto getstatus;
case CD_STATUS_SCANNING :
thd_sleep(200);
goto getstatus;
default:
ds_printf("DS_ERROR: GD-rom error\n");
return;
}
}
if (disc_type == CD_CDROM_XA){
rname:
snprintf(dst_file,MAX_FN_LEN, "%s.iso", dst_folder);
if ((fd=fs_open(dst_file , O_RDONLY)) != FILEHND_INVALID) {
fs_close(fd); strcpy(dst_file,"\0");
strcat(dst_folder , "0");
goto rname ;
} else disc_type = 1;
} else if (disc_type == CD_GDROM){
rname1:
if ((fd=fs_open (dst_folder , O_DIR)) != FILEHND_INVALID) {
fs_close(fd);
strcat(dst_folder , "0");
goto rname1 ;
} else {strcpy(dst_file,"\0");
snprintf(dst_file,MAX_FN_LEN,"%s", dst_folder);
disc_type = 2;
fs_mkdir(dst_file);
}
while(cdrom_read_toc(&toc, 1) != CMD_OK) {
terr++;
cdrom_reinit();
if (terr > 100){
ds_printf("DS_ERROR: Toc read error for gdlast\n");
fs_rmdir(dst_folder);
return;
}
}
terr=0;
self.lastgdtrack = TOC_TRACK(toc.last);
} else {
ds_printf("DS_ERROR: This is not game disk\nInserted %d disk\n",disc_type);
return;
}
//ds_printf("Dst file %s\n" ,dst_file);
for (session=0; session < disc_type; session++) {
cdrom_set_sector_size(2048);
while(cdrom_read_toc(&toc, session) != CMD_OK) {
terr++;
if(terr==5) cdrom_reinit();
thd_sleep(500);
if (terr > 10) {
ds_printf("DS_ERROR: Toc read error\n");
if (disc_type == 1) {
if(fs_unlink(dst_file) != 0)
ds_printf("Error delete file: %s\n" ,dst_file);
}else {
if ((fd=fs_open (dst_folder , O_DIR)) == FILEHND_INVALID) {
ds_printf("Error folder '%s' not found\n" ,dst_folder);
return;
}
dirent_t *dir;
while ((dir = fs_readdir(fd))){
if (!strcmp(dir->name,".") || !strcmp(dir->name,"..")) continue;
strcpy(dst_file,"\0");
snprintf(dst_file, MAX_FN_LEN, "%s/%s", dst_folder, dir->name);
fs_unlink(dst_file);
}
fs_close(fd);
fs_rmdir(dst_folder);
}
return;
}
}
terr = 0;
int first = TOC_TRACK(toc.first);
int last = TOC_TRACK(toc.last);
for (tn=first; tn <= last; tn++ ) {
if (disc_type == 1) tn = last;
type = TOC_CTRL(toc.entry[tn-1]);
if (disc_type == 2) {
strcpy(dst_file,"\0");
snprintf(dst_file,MAX_FN_LEN,"%s/track%02d.%s", dst_folder, tn, (type == 4 ? "iso" : "raw"));
}
start = TOC_LBA(toc.entry[tn-1]);
s_end = TOC_LBA((tn == last ? toc.leadout_sector : toc.entry[tn]));
nsec = s_end - start;
if (disc_type == 1 && type == 4) nsec -= 2 ;
else if (session==1 && tn != last && type != TOC_CTRL(toc.entry[tn])) nsec -= 150;
else if (session==0 && type == 4) nsec -= 150;
if (disc_type == 2 && session == 0) {
strcpy(riplabel,"\0");
sprintf(riplabel,"Track %d of %d\n",tn ,self.lastgdtrack );
} else if (disc_type == 2 && session == 1 && tn != self.lastgdtrack) {
strcpy(riplabel,"\0");
sprintf(riplabel,"Track %d of %d\n",tn ,self.lastgdtrack );
} else {
strcpy(riplabel,"\0");
sprintf(riplabel,"Last track\n");
}
GUI_LabelSetText(self.track_label, riplabel);
if (rip_sec(tn, start, nsec, type, dst_file, disc_type) != CMD_OK) {
GUI_LabelSetText(self.track_label, " ");
stoptimer = timer_ms_gettime64 (); // timer
GUI_ProgressBarSetPosition(self.pbar, 0.0);
cdrom_spin_down();
if (disc_type == 1) {
if(fs_unlink(dst_file) != 0) ds_printf("Error delete file: %s\n" ,dst_file);
} else {
if ((fd=fs_open (dst_folder , O_DIR)) == FILEHND_INVALID) {
ds_printf("Error folder '%s' not found\n" ,dst_folder);
return;
}
dirent_t *dir;
while ((dir = fs_readdir(fd))){
if (!strcmp(dir->name,".") || !strcmp(dir->name,"..")) continue;
strcpy(dst_file,"\0");
snprintf(dst_file, MAX_FN_LEN, "%s/%s", dst_folder, dir->name);
fs_unlink(dst_file);
}
fs_close(fd);
fs_rmdir(dst_folder);
}
return ;
}
GUI_LabelSetText(self.track_label, " ");
GUI_ProgressBarSetPosition(self.pbar, 0.0);
}
}
GUI_LabelSetText(self.track_label, " ");
GUI_WidgetMarkChanged(self.app->body);
if (disc_type == 2){
if (gdfiles(dst_folder, dst_file, text) != CMD_OK){
cdrom_spin_down();
if ((fd=fs_open (dst_folder , O_DIR)) == FILEHND_INVALID) {
ds_printf("Error folder '%s' not found\n" ,dst_folder);
return;
}
dirent_t *dir;
while ((dir = fs_readdir(fd))){
if (!strcmp(dir->name,".") || !strcmp(dir->name,"..")) continue;
strcpy(dst_file,"\0");
snprintf(dst_file, MAX_FN_LEN, "%s/%s", dst_folder, dir->name);
fs_unlink(dst_file);
}
fs_close(fd);
fs_rmdir(dst_folder);
return;
}
}
GUI_ProgressBarSetPosition(self.pbar, 0.0);
cdrom_spin_down();
stoptimer = timer_ms_gettime64 (); // timer
riptime = stoptimer - starttimer;
int ripmin = riptime / 60000 ;
int ripsec = riptime % 60 ;
ds_printf("DS_OK: End ripping. Save at %d:%d\n",ripmin,ripsec);
}
