static void rarch_get_environment_console(void) { #if defined(RARCH_CONSOLE) || defined(__QNX__) path_mkdir(default_paths.port_dir); path_mkdir(default_paths.system_dir); path_mkdir(default_paths.savestate_dir); path_mkdir(default_paths.sram_dir); #endif }
void set_paths_redirect(const char *path) { global_t *global = global_get_ptr(); settings_t *settings = config_get_ptr(); /* per-core saves: append the library_name to the save location */ if(global->system.info.library_name && strcmp(global->system.info.library_name,"No Core") && settings->sort_savefiles_enable) { strlcpy(orig_savefile_dir,global->savefile_dir,sizeof(global->savefile_dir)); fill_pathname_dir(global->savefile_dir,global->savefile_dir,global->system.info.library_name,sizeof(global->savefile_dir)); // if path doesn't exist try to create it, if everything fails revert to the original path if(!path_is_directory(global->savefile_dir)) if(!path_mkdir(global->savefile_dir)) strlcpy(global->savefile_dir,orig_savefile_dir,sizeof(global->savefile_dir)); } /* per-core states: append the library_name to the save location */ if (global->system.info.library_name && strcmp(global->system.info.library_name,"No Core") && settings->sort_savestates_enable) { strlcpy(orig_savestate_dir,global->savestate_dir,sizeof(global->savestate_dir)); fill_pathname_dir(global->savestate_dir,global->savestate_dir,global->system.info.library_name,sizeof(global->savestate_dir)); // if path doesn't exist try to create it, if everything fails revert to the original path if(!path_is_directory(global->savestate_dir)) if(!path_mkdir(global->savestate_dir)) strlcpy(global->savestate_dir,orig_savestate_dir,sizeof(global->savestate_dir)); } if(path_is_directory(global->savefile_dir)) strlcpy(global->savefile_name,global->savefile_dir,sizeof(global->savefile_dir)); if(path_is_directory(global->savestate_dir)) strlcpy(global->savestate_name,global->savestate_dir,sizeof(global->savestate_dir)); if (path_is_directory(global->savefile_name)) { fill_pathname_dir(global->savefile_name, global->basename, ".srm", sizeof(global->savefile_name)); RARCH_LOG("Redirecting save file to \"%s\".\n", global->savefile_name); } if (path_is_directory(global->savestate_name)) { fill_pathname_dir(global->savestate_name, global->basename, ".state", sizeof(global->savestate_name)); RARCH_LOG("Redirecting save state to \"%s\".\n", global->savestate_name); } if (path_is_directory(global->cheatfile_name)) { fill_pathname_dir(global->cheatfile_name, global->basename, ".state", sizeof(global->cheatfile_name)); RARCH_LOG("Redirecting cheat file to \"%s\".\n", global->cheatfile_name); } }
static void rarch_get_environment_console(void) { path_mkdir(default_paths.port_dir); path_mkdir(default_paths.system_dir); path_mkdir(default_paths.savestate_dir); path_mkdir(default_paths.sram_dir); config_load(); init_libretro_sym(false); rarch_init_system_info(); global_init_drivers(); }
static int action_ok_remap_file_save_game(const char *path, const char *label, unsigned type, size_t idx) { global_t *global = global_get_ptr(); settings_t *settings = config_get_ptr(); const char *core_name; core_name = global->system.info.library_name; const char *game_name; game_name = path_basename(global->basename); char directory[PATH_MAX_LENGTH]; char file[PATH_MAX_LENGTH]; fill_pathname_join(directory,settings->input_remapping_directory,core_name,PATH_MAX_LENGTH); fill_pathname_join(file,core_name,game_name,PATH_MAX_LENGTH); if(!path_file_exists(directory)) path_mkdir(directory); if(input_remapping_save_file(file)) rarch_main_msg_queue_push("Remap file saved successfully", 1, 100, true); else rarch_main_msg_queue_push("Error saving remap file", 1, 100, true); return 0; }
static char* bufprint_temp_dir(char* buff, char* end) { #ifdef _WIN32 char path[MAX_PATH]; DWORD retval; retval = GetTempPath( sizeof(path), path ); if (retval > sizeof(path) || retval == 0) { D( "can't locate TEMP directory" ); strncpy(path, "C:\\Temp", sizeof(path) ); } strncat( path, "\\AndroidEmulator", sizeof(path)-1 ); path_mkdir(path, 0744); return bufprint(buff, end, "%s", path); #else char path[MAX_PATH]; const char* tmppath = getenv("ANDROID_TMP"); if (!tmppath) { const char* user = getenv("USER"); if (user == NULL || user[0] == '\0') user = "******"; snprintf(path, sizeof path, "/tmp/android-%s", user); tmppath = path; } mkdir(tmppath, 0744); return bufprint(buff, end, "%s", tmppath ); #endif }
static int file_decompressed(const char *name, const char *valid_exts, const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size, uint32_t crc32, void *userdata) { char path[PATH_MAX_LENGTH]; decompress_state_t *dec = (decompress_state_t*)userdata; /* Ignore directories. */ if (name[strlen(name) - 1] == '/' || name[strlen(name) - 1] == '\\') goto next_file; /* Make directory */ fill_pathname_join(path, dec->target_dir, name, sizeof(path)); path_basedir(path); if (!path_mkdir(path)) goto error; fill_pathname_join(path, dec->target_dir, name, sizeof(path)); if (!zlib_perform_mode(path, valid_exts, cdata, cmode, csize, size, crc32, userdata)) goto error; RARCH_LOG("[deflate] Path: %s, CRC32: 0x%x\n", name, crc32); next_file: return 1; error: dec->callback_error = (char*)malloc(PATH_MAX_LENGTH); snprintf(dec->callback_error, PATH_MAX_LENGTH, "Failed to deflate %s.\n", path); return 0; }
static bool connmanctl_connect_ssid(unsigned i, const char* passphrase) { char ln[512] = {0}; char name[20] = {0}; char service[128] = {0}; char command[256] = {0}; char settings_dir[PATH_MAX_LENGTH] = {0}; char settings_path[PATH_MAX_LENGTH] = {0}; FILE *command_file = NULL; FILE *settings_file = NULL; FILE *serv_file = NULL; union string_list_elem_attr attr; const char *line = lines->elems[i].data; strlcpy(name, line+4, sizeof(name)); strlcpy(name, string_trim_whitespace(name), sizeof(name)); strlcpy(service, line+25, sizeof(service)); strlcat(settings_dir, LAKKA_CONNMAN_DIR, sizeof(settings_dir)); strlcat(settings_dir, service, sizeof(settings_dir)); path_mkdir(settings_dir); strlcat(settings_path, settings_dir, sizeof(settings_path)); strlcat(settings_path, "/settings", sizeof(settings_path)); settings_file = fopen(settings_path, "w"); fprintf(settings_file, "[%s]\n", service); fprintf(settings_file, "Name=%s\n", name); fprintf(settings_file, "SSID="); for (int i=0; i < strlen(name); i++) fprintf(settings_file, "%02x", (unsigned int) name[i]); fprintf(settings_file, "\n"); fprintf(settings_file, "Favorite=%s\n", "true"); fprintf(settings_file, "AutoConnect=%s\n", "true"); fprintf(settings_file, "Passphrase=%s\n", passphrase); fprintf(settings_file, "IPv4.method=%s\n", "dhcp"); fclose(settings_file); pclose(popen("systemctl restart connman", "r")); strlcat(command, "connmanctl connect ", sizeof(command)); strlcat(command, service, sizeof(command)); strlcat(command, " 2>&1", sizeof(command)); command_file = popen(command, "r"); while (fgets (ln, 512, command_file) != NULL) { runloop_msg_queue_push(ln, 1, 180, true); } pclose(command_file); return true; }
static void check_defaults_dir_create_dir(const char *path) { char new_path[PATH_MAX_LENGTH]; fill_pathname_expand_special(new_path, path, sizeof(new_path)); if (path_is_directory(new_path)) return; path_mkdir(new_path); }
static int cb_update_shaders_glsl(void *data, size_t len) { char shaderdir[PATH_MAX_LENGTH]; settings_t *settings = config_get_ptr(); fill_pathname_join(shaderdir, settings->video.shader_dir, "shaders_glsl", sizeof(shaderdir)); if (!path_file_exists(shaderdir)) if (!path_mkdir(shaderdir)) return -1; return cb_generic_download(data, len, shaderdir); }
static bool zlib_cb(const char *name, const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size, uint32_t crc32, void *userdata) { struct userdata *user = userdata; const char *subdir = user->subdir; const char *dest = user->dest; if (strstr(name, subdir) != name) return true; name += strlen(subdir) + 1; char path[PATH_MAX]; char path_dir[PATH_MAX]; fill_pathname_join(path, dest, name, sizeof(path)); fill_pathname_basedir(path_dir, path, sizeof(path_dir)); if (!path_mkdir(path_dir)) { RARCH_ERR("Failed to create dir: %s.\n", path_dir); return false; } RARCH_LOG("Extracting %s -> %s ...\n", name, path); switch (cmode) { case 0: // Uncompressed if (!write_file(path, cdata, size)) { RARCH_ERR("Failed to write file: %s.\n", path); return false; } break; case 8: // Deflate if (!zlib_inflate_data_to_file(path, cdata, csize, size, crc32)) { RARCH_ERR("Failed to deflate to: %s.\n", path); return false; } break; default: return false; } return true; }
bool test_permissions(const char *path) { char buf[PATH_MAX_LENGTH]; bool ret; RARCH_LOG("Testing permissions for %s\n",path); fill_pathname_join(buf, path, ".retroarch", sizeof(buf)); ret = path_mkdir(buf); RARCH_LOG("Create %s %s\n", buf, ret ? "true" : "false"); if(ret) rmdir(buf); return ret; }
static APosixStatus path_mkdir_recursive( char* path, unsigned len, int mode ) { char old_c; int ret; unsigned len2; /* get rid of trailing separators */ while (len > 0 && ispathsep(path[len-1])) len -= 1; if (len == 0) { errno = ENOENT; return -1; } /* check that the parent exists, 'len2' is the length of * the parent part of the path */ len2 = len-1; while (len2 > 0 && !ispathsep(path[len2-1])) len2 -= 1; if (len2 > 0) { old_c = path[len2]; path[len2] = 0; ret = 0; if ( !path_exists(path) ) { /* the parent doesn't exist, so try to create it */ ret = path_mkdir_recursive( path, len2, mode ); } path[len2] = old_c; if (ret < 0) return ret; } /* at this point, we now the parent exists */ old_c = path[len]; path[len] = 0; ret = path_mkdir( path, mode ); path[len] = old_c; return ret; }
static void frontend_wiiu_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { unsigned i; (void)args; fill_pathname_basedir(g_defaults.dirs[DEFAULT_DIR_PORT], elf_path_cst, sizeof(g_defaults.dirs[DEFAULT_DIR_PORT])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT], "downloads", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_ASSETS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT], "media", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE], g_defaults.dirs[DEFAULT_DIR_PORT], "cores", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_CORE], "info", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SAVESTATE], g_defaults.dirs[DEFAULT_DIR_CORE], "savestates", sizeof(g_defaults.dirs[DEFAULT_DIR_SAVESTATE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SRAM], g_defaults.dirs[DEFAULT_DIR_CORE], "savefiles", sizeof(g_defaults.dirs[DEFAULT_DIR_SRAM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_SYSTEM], g_defaults.dirs[DEFAULT_DIR_CORE], "system", sizeof(g_defaults.dirs[DEFAULT_DIR_SYSTEM])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_PLAYLIST], g_defaults.dirs[DEFAULT_DIR_CORE], "playlists", sizeof(g_defaults.dirs[DEFAULT_DIR_PLAYLIST])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], g_defaults.dirs[DEFAULT_DIR_PORT], "config", sizeof(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_REMAP], g_defaults.dirs[DEFAULT_DIR_PORT], "config/remaps", sizeof(g_defaults.dirs[DEFAULT_DIR_REMAP])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER], g_defaults.dirs[DEFAULT_DIR_PORT], "filters", sizeof(g_defaults.dirs[DEFAULT_DIR_VIDEO_FILTER])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_DATABASE], g_defaults.dirs[DEFAULT_DIR_PORT], "database/rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE])); fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CURSOR], g_defaults.dirs[DEFAULT_DIR_PORT], "database/cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR])); fill_pathname_join(g_defaults.path.config, g_defaults.dirs[DEFAULT_DIR_PORT], file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); for (i = 0; i < DEFAULT_DIR_LAST; i++) { const char *dir_path = g_defaults.dirs[i]; if (!string_is_empty(dir_path)) path_mkdir(dir_path); } }
static void frontend_ps2_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { create_path_names(); #ifndef IS_SALAMANDER if (!string_is_empty(argv[1])) { static char path[PATH_MAX_LENGTH] = {0}; struct rarch_main_wrap *args = (struct rarch_main_wrap*)params_data; if (args) { strlcpy(path, argv[1], sizeof(path)); args->touched = true; args->no_content = false; args->verbose = false; args->config_path = NULL; args->sram_path = NULL; args->state_path = NULL; args->content_path = path; args->libretro_path = NULL; RARCH_LOG("argv[0]: %s\n", argv[0]); RARCH_LOG("argv[1]: %s\n", argv[1]); RARCH_LOG("argv[2]: %s\n", argv[2]); RARCH_LOG("Auto-start game %s.\n", argv[1]); } } #endif int i; for (i = 0; i < DEFAULT_DIR_LAST; i++) { const char *dir_path = g_defaults.dirs[i]; if (!string_is_empty(dir_path)) path_mkdir(dir_path); } }
static int zlib_extract_core_callback(const char *name, const char *valid_exts, const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size, uint32_t crc32, void *userdata) { char path[PATH_MAX_LENGTH]; /* Make directory */ fill_pathname_join(path, (const char*)userdata, name, sizeof(path)); path_basedir(path); if (!path_mkdir(path)) { RARCH_ERR("Failed to create directory: %s.\n", path); return 0; } /* Ignore directories. */ if (name[strlen(name) - 1] == '/' || name[strlen(name) - 1] == '\\') return 1; fill_pathname_join(path, (const char*)userdata, name, sizeof(path)); RARCH_LOG("path is: %s, CRC32: 0x%x\n", path, crc32); if (!zlib_perform_mode(path, valid_exts, cdata, cmode, csize, size, crc32, userdata)) { if (cmode == 0) { RARCH_ERR("Failed to write file: %s.\n", path); return 0; } goto error; } return 1; error: RARCH_ERR("Failed to deflate to: %s.\n", path); return 0; }
char* bufprint_temp_dir(char* buff, char* end) { #ifdef _WIN32 char path[MAX_PATH]; DWORD retval; retval = GetTempPath( sizeof(path), path ); if (retval > sizeof(path) || retval == 0) { D( "can't locate TEMP directory" ); strncpy(path, "C:\\Temp", sizeof(path) ); } strncat( path, "\\AndroidEmulator", sizeof(path)-1 ); path_mkdir(path, 0744); return bufprint(buff, end, "%s", path); #else const char* tmppath = "/tmp/android"; mkdir(tmppath, 0744); return bufprint(buff, end, "%s", tmppath ); #endif }
bool path_mkdir(const char *dir) { const char *target = NULL; /* Use heap. Real chance of stack overflow if we recurse too hard. */ char *basedir = strdup(dir); bool ret = true; if (!basedir) return false; path_parent_dir(basedir); if (!*basedir || !strcmp(basedir, dir)) { ret = false; goto end; } if (path_is_directory(basedir)) { target = dir; ret = path_mkdir_norecurse(dir); } else { target = basedir; ret = path_mkdir(basedir); if (ret) { target = dir; ret = path_mkdir_norecurse(dir); } } end: if (target && !ret) RARCH_ERR("Failed to create directory: \"%s\".\n", target); free(basedir); return ret; }
static int zlib_extract_core_callback(const char *name, const char *valid_exts, const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size, uint32_t crc32, void *userdata) { char path[PATH_MAX_LENGTH]; /* Make directory */ fill_pathname_join(path, (const char*)userdata, name, sizeof(path)); path_basedir(path); if (!path_mkdir(path)) { RARCH_ERR("Failed to create directory: %s.\n", path); return 0; } /* Ignore directories. */ if (name[strlen(name) - 1] == '/' || name[strlen(name) - 1] == '\\') return 1; fill_pathname_join(path, (const char*)userdata, name, sizeof(path)); RARCH_LOG("path is: %s, CRC32: 0x%x\n", path, crc32); switch (cmode) { case 0: /* Uncompressed */ write_file(path, cdata, size); break; case 8: /* Deflate */ zlib_inflate_data_to_file(path, valid_exts, cdata, csize, size, crc32); break; } return 1; }
/* ensure that a given directory exists, create it if not, 0 on success, -1 on failure (error code in errno) */ APosixStatus path_mkdir_if_needed( const char* path, int mode ) { int ret = 0; if (!path_exists(path)) { ret = path_mkdir(path, mode); if (ret < 0 && errno == ENOENT) { char temp[MAX_PATH]; unsigned len = (unsigned)strlen(path); if (len > sizeof(temp)-1) { errno = EINVAL; return -1; } memcpy( temp, path, len ); temp[len] = 0; return path_mkdir_recursive(temp, len, mode); } } return ret; }
static void frontend_android_get_environment_settings(int *argc, char *argv[], void *data, void *params_data) { int32_t major, minor, rel; int perms = 0; char device_model[PROP_VALUE_MAX] = {0}; char device_id[PROP_VALUE_MAX] = {0}; struct rarch_main_wrap *args = NULL; JNIEnv *env = NULL; jobject obj = NULL; jstring jstr = NULL; struct android_app *android_app = (struct android_app*)data; char buf[PATH_MAX_LENGTH] = {0}; if (!android_app) return; env = jni_thread_getenv(); if (!env) return; args = (struct rarch_main_wrap*)params_data; if (args) { args->touched = true; args->no_content = false; args->verbose = false; args->sram_path = NULL; args->state_path = NULL; } frontend_android_get_version(&major, &minor, &rel); RARCH_LOG("Android OS version (major : %d, minor : %d, rel : %d)\n", major, minor, rel); CALL_OBJ_METHOD(env, obj, android_app->activity->clazz, android_app->getIntent); RARCH_LOG("Checking arguments passed from intent ...\n"); /* Config file. */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "CONFIGFILE")); if (android_app->getStringExtra && jstr) { static char config_path[PATH_MAX_LENGTH] = {0}; const char *argv = NULL; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(config_path, argv, sizeof(config_path)); (*env)->ReleaseStringUTFChars(env, jstr, argv); RARCH_LOG("Config file: [%s].\n", config_path); if (args && *config_path) args->config_path = config_path; } /* Current IME. */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "IME")); if (android_app->getStringExtra && jstr) { const char *argv = (*env)->GetStringUTFChars(env, jstr, 0); strlcpy(android_app->current_ime, argv, sizeof(android_app->current_ime)); (*env)->ReleaseStringUTFChars(env, jstr, argv); RARCH_LOG("Current IME: [%s].\n", android_app->current_ime); } CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "USED")); if (android_app->getStringExtra && jstr) { const char *argv = (*env)->GetStringUTFChars(env, jstr, 0); bool used = (!strcmp(argv, "false")) ? false : true; (*env)->ReleaseStringUTFChars(env, jstr, argv); RARCH_LOG("USED: [%s].\n", used ? "true" : "false"); } /* LIBRETRO. */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "LIBRETRO")); if (android_app->getStringExtra && jstr) { static char core_path[PATH_MAX_LENGTH]; const char *argv = NULL; *core_path = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(core_path, argv, sizeof(core_path)); (*env)->ReleaseStringUTFChars(env, jstr, argv); RARCH_LOG("Libretro path: [%s]\n", core_path); if (args && *core_path) args->libretro_path = core_path; } /* Content. */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "ROM")); if (android_app->getStringExtra && jstr) { static char path[PATH_MAX_LENGTH]; const char *argv = NULL; *path = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(path, argv, sizeof(path)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*path) { RARCH_LOG("Auto-start game %s.\n", path); if (args && *path) args->content_path = path; } } /* External Storage */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "SDCARD")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *sdcard_dir = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(sdcard_dir, argv, sizeof(sdcard_dir)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*sdcard_dir) { RARCH_LOG("External storage location [%s]\n", sdcard_dir); /* TODO base dir handler */ } } /* Screenshots */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "SCREENSHOTS")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *screenshot_dir = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(screenshot_dir, argv, sizeof(screenshot_dir)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*screenshot_dir) { RARCH_LOG("Picture folder location [%s]\n", screenshot_dir); /* TODO: screenshot handler */ } } /* Downloads */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "DOWNLOADS")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *downloads_dir = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(downloads_dir, argv, sizeof(downloads_dir)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*downloads_dir) { RARCH_LOG("Download folder location [%s].\n", downloads_dir); /* TODO: downloads handler */ } } CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "APK")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *apk_path = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(apk_path, argv, sizeof(apk_path)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*apk_path) { RARCH_LOG("APK location [%s].\n", apk_path); } } CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "EXTERNAL")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *ext_dir = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(ext_dir, argv, sizeof(ext_dir)); (*env)->ReleaseStringUTFChars(env, jstr, argv); if (*ext_dir) { RARCH_LOG("External files location [%s]\n", ext_dir); } } /* Content. */ CALL_OBJ_METHOD_PARAM(env, jstr, obj, android_app->getStringExtra, (*env)->NewStringUTF(env, "DATADIR")); if (android_app->getStringExtra && jstr) { const char *argv = NULL; *app_dir = '\0'; argv = (*env)->GetStringUTFChars(env, jstr, 0); if (argv && *argv) strlcpy(app_dir, argv, sizeof(app_dir)); (*env)->ReleaseStringUTFChars(env, jstr, argv); //set paths depending on the ability to write to sdcard_dir if(*sdcard_dir) { if(test_permissions(sdcard_dir)) perms = SDCARD_ROOT_WRITABLE; } else if(*ext_dir) { if(test_permissions(ext_dir)) perms = SDCARD_EXT_DIR_WRITABLE; } else perms = SDCARD_NOT_WRITABLE; RARCH_LOG("SD permissions: %d",perms); if (*app_dir) { RARCH_LOG("Application location: [%s].\n", app_dir); if (args && *app_dir) { fill_pathname_join(g_defaults.dir.assets, app_dir, "assets", sizeof(g_defaults.dir.assets)); fill_pathname_join(g_defaults.dir.extraction, app_dir, "tmp", sizeof(g_defaults.dir.extraction)); fill_pathname_join(g_defaults.dir.shader, app_dir, "shaders", sizeof(g_defaults.dir.shader)); fill_pathname_join(g_defaults.dir.overlay, app_dir, "overlays", sizeof(g_defaults.dir.overlay)); fill_pathname_join(g_defaults.dir.core, app_dir, "cores", sizeof(g_defaults.dir.core)); fill_pathname_join(g_defaults.dir.core_info, app_dir, "info", sizeof(g_defaults.dir.core_info)); fill_pathname_join(g_defaults.dir.autoconfig, app_dir, "autoconfig", sizeof(g_defaults.dir.autoconfig)); fill_pathname_join(g_defaults.dir.audio_filter, app_dir, "audio_filters", sizeof(g_defaults.dir.audio_filter)); fill_pathname_join(g_defaults.dir.video_filter, app_dir, "video_filters", sizeof(g_defaults.dir.video_filter)); strlcpy(g_defaults.dir.content_history, app_dir, sizeof(g_defaults.dir.content_history)); fill_pathname_join(g_defaults.dir.database, app_dir, "database/rdb", sizeof(g_defaults.dir.database)); fill_pathname_join(g_defaults.dir.cursor, app_dir, "database/cursors", sizeof(g_defaults.dir.cursor)); fill_pathname_join(g_defaults.dir.cheats, app_dir, "cheats", sizeof(g_defaults.dir.cheats)); fill_pathname_join(g_defaults.dir.playlist, app_dir, "playlists", sizeof(g_defaults.dir.playlist)); fill_pathname_join(g_defaults.dir.remap, app_dir, "remaps", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.wallpapers, app_dir, "wallpapers", sizeof(g_defaults.dir.wallpapers)); if(*downloads_dir && test_permissions(downloads_dir)) { fill_pathname_join(g_defaults.dir.core_assets, downloads_dir, "", sizeof(g_defaults.dir.core_assets)); } else { fill_pathname_join(g_defaults.dir.core_assets, app_dir, "downloads", sizeof(g_defaults.dir.core_assets)); path_mkdir(g_defaults.dir.core_assets); } RARCH_LOG("Default download folder: [%s]", g_defaults.dir.core_assets); if(*screenshot_dir && test_permissions(screenshot_dir)) { fill_pathname_join(g_defaults.dir.screenshot, screenshot_dir, "", sizeof(g_defaults.dir.screenshot)); } else { fill_pathname_join(g_defaults.dir.screenshot, app_dir, "screenshots", sizeof(g_defaults.dir.screenshot)); path_mkdir(g_defaults.dir.screenshot); } RARCH_LOG("Default screenshot folder: [%s]", g_defaults.dir.screenshot); switch (perms) { case SDCARD_EXT_DIR_WRITABLE: fill_pathname_join(g_defaults.dir.sram, ext_dir, "saves", sizeof(g_defaults.dir.sram)); path_mkdir(g_defaults.dir.sram); fill_pathname_join(g_defaults.dir.savestate, ext_dir, "states", sizeof(g_defaults.dir.savestate)); path_mkdir(g_defaults.dir.savestate); fill_pathname_join(g_defaults.dir.system, ext_dir, "system", sizeof(g_defaults.dir.system)); path_mkdir(g_defaults.dir.system); break; case SDCARD_NOT_WRITABLE: fill_pathname_join(g_defaults.dir.sram, app_dir, "saves", sizeof(g_defaults.dir.sram)); path_mkdir(g_defaults.dir.sram); fill_pathname_join(g_defaults.dir.savestate, app_dir, "states", sizeof(g_defaults.dir.savestate)); path_mkdir(g_defaults.dir.savestate); fill_pathname_join(g_defaults.dir.system, app_dir, "system", sizeof(g_defaults.dir.system)); path_mkdir(g_defaults.dir.system); break; case SDCARD_ROOT_WRITABLE: default: break; } /* create save and system directories in the internal dir too */ fill_pathname_join(buf, app_dir, "saves", sizeof(buf)); path_mkdir(buf); fill_pathname_join(buf, app_dir, "states", sizeof(buf)); path_mkdir(buf); fill_pathname_join(buf, app_dir, "system", sizeof(buf)); path_mkdir(buf); /* create save and system directories in the internal sd too */ fill_pathname_join(buf, ext_dir, "saves", sizeof(buf)); path_mkdir(buf); fill_pathname_join(buf, ext_dir, "states", sizeof(buf)); path_mkdir(buf); fill_pathname_join(buf, ext_dir, "system", sizeof(buf)); path_mkdir(buf); RARCH_LOG("Default savefile folder: [%s]", g_defaults.dir.sram); RARCH_LOG("Default savestate folder: [%s]", g_defaults.dir.savestate); RARCH_LOG("Default system folder: [%s]", g_defaults.dir.system); } } } frontend_android_get_name(device_model, sizeof(device_model)); system_property_get("ro.product.id", device_id); g_defaults.settings.video_threaded_enable = true; /* Set automatic default values per device */ if (device_is_xperia_play(device_model)) { g_defaults.settings.out_latency = 128; g_defaults.settings.video_refresh_rate = 59.19132938771038; g_defaults.settings.video_threaded_enable = false; } else if (!strcmp(device_model, "GAMEMID_BT")) g_defaults.settings.out_latency = 160; else if (!strcmp(device_model, "SHIELD")) g_defaults.settings.video_refresh_rate = 60.0; else if (!strcmp(device_model, "JSS15J")) g_defaults.settings.video_refresh_rate = 59.65; #if 0 /* Explicitly disable input overlay by default * for gamepad-like/console devices. */ if (device_is_game_console(device_model)) g_defaults.settings.input_overlay_enable = false; #endif }
static void check_defaults_dirs(void) { if (*g_defaults.core_assets_dir) path_mkdir(g_defaults.core_assets_dir); if (*g_defaults.remap_dir) path_mkdir(g_defaults.remap_dir); if (*g_defaults.autoconfig_dir) path_mkdir(g_defaults.autoconfig_dir); if (*g_defaults.audio_filter_dir) path_mkdir(g_defaults.audio_filter_dir); if (*g_defaults.video_filter_dir) path_mkdir(g_defaults.video_filter_dir); if (*g_defaults.assets_dir) path_mkdir(g_defaults.assets_dir); if (*g_defaults.playlist_dir) path_mkdir(g_defaults.playlist_dir); if (*g_defaults.core_dir) path_mkdir(g_defaults.core_dir); if (*g_defaults.core_info_dir) path_mkdir(g_defaults.core_info_dir); if (*g_defaults.overlay_dir) path_mkdir(g_defaults.overlay_dir); if (*g_defaults.port_dir) path_mkdir(g_defaults.port_dir); if (*g_defaults.shader_dir) path_mkdir(g_defaults.shader_dir); if (*g_defaults.savestate_dir) path_mkdir(g_defaults.savestate_dir); if (*g_defaults.sram_dir) path_mkdir(g_defaults.sram_dir); if (*g_defaults.system_dir) path_mkdir(g_defaults.system_dir); if (*g_defaults.resampler_dir) path_mkdir(g_defaults.resampler_dir); if (*g_defaults.menu_config_dir) path_mkdir(g_defaults.menu_config_dir); if (*g_defaults.content_history_dir) path_mkdir(g_defaults.content_history_dir); if (*g_defaults.extraction_dir) path_mkdir(g_defaults.extraction_dir); if (*g_defaults.database_dir) path_mkdir(g_defaults.database_dir); if (*g_defaults.cursor_dir) path_mkdir(g_defaults.cursor_dir); if (*g_defaults.cheats_dir) path_mkdir(g_defaults.cheats_dir); }
static void check_defaults_dir_create_dir(const char *path) { if (path_is_directory(path)) return; path_mkdir(path); }
static void frontend_psp_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { struct rarch_main_wrap *params = NULL; (void)args; #ifndef IS_SALAMANDER #if defined(HAVE_LOGGER) logger_init(); #elif defined(HAVE_FILE_LOGGER) #ifndef VITA retro_main_log_file_init("ms0:/temp/retroarch-log.txt"); #else retro_main_log_file_init("ux0:/temp/retroarch-log.txt"); #endif #endif #endif #ifdef VITA strlcpy(eboot_path, "app0:/", sizeof(eboot_path)); strlcpy(g_defaults.dir.port, eboot_path, sizeof(g_defaults.dir.port)); strlcpy(user_path, "ux0:/data/retroarch/", sizeof(user_path)); #else strlcpy(eboot_path, argv[0], sizeof(eboot_path)); /* for PSP, use uppercase directories, and no trailing slashes otherwise mkdir fails */ strlcpy(user_path, "ms0:/PSP/RETROARCH", sizeof(user_path)); fill_pathname_basedir(g_defaults.dir.port, argv[0], sizeof(g_defaults.dir.port)); #endif RARCH_LOG("port dir: [%s]\n", g_defaults.dir.port); #ifdef VITA /* bundle data*/ fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port, "", sizeof(g_defaults.dir.core)); fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port, "assets", sizeof(g_defaults.dir.assets)); fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.core, "info", sizeof(g_defaults.dir.core_info)); fill_pathname_join(g_defaults.dir.database, g_defaults.dir.port, "database/rdb", sizeof(g_defaults.dir.database)); fill_pathname_join(g_defaults.dir.cursor, g_defaults.dir.port, "database/cursors", sizeof(g_defaults.dir.cursor)); /* user data*/ fill_pathname_join(g_defaults.dir.cheats, user_path, "cheats", sizeof(g_defaults.dir.cheats)); fill_pathname_join(g_defaults.dir.menu_config, user_path, "config", sizeof(g_defaults.dir.menu_config)); fill_pathname_join(g_defaults.dir.core_assets, user_path, "downloads", sizeof(g_defaults.dir.core_assets)); fill_pathname_join(g_defaults.dir.playlist, user_path, "playlists", sizeof(g_defaults.dir.playlist)); fill_pathname_join(g_defaults.dir.remap, user_path, "remaps", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.sram, user_path, "savefiles", sizeof(g_defaults.dir.sram)); fill_pathname_join(g_defaults.dir.savestate, user_path, "savestates", sizeof(g_defaults.dir.savestate)); fill_pathname_join(g_defaults.dir.system, user_path, "system", sizeof(g_defaults.dir.system)); fill_pathname_join(g_defaults.dir.cache, user_path, "temp", sizeof(g_defaults.dir.cache)); fill_pathname_join(g_defaults.dir.overlay, user_path, "overlays", sizeof(g_defaults.dir.overlay)); fill_pathname_join(g_defaults.dir.thumbnails, user_path, "thumbnails", sizeof(g_defaults.dir.thumbnails)); strlcpy(g_defaults.dir.content_history, user_path, sizeof(g_defaults.dir.content_history)); fill_pathname_join(g_defaults.path.config, user_path, file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); #else fill_pathname_join(g_defaults.dir.core, g_defaults.dir.port, "CORES", sizeof(g_defaults.dir.core)); fill_pathname_join(g_defaults.dir.core_info, g_defaults.dir.port, "INFO", sizeof(g_defaults.dir.core_info)); /* bundle data */ /* fill_pathname_join(g_defaults.dir.assets, g_defaults.dir.port, "BUNDLE/ASSETS", sizeof(g_defaults.dir.assets)); fill_pathname_join(g_defaults.dir.autoconfig, g_defaults.dir.port, "BUNDLE/AUTOCONFIG", sizeof(g_defaults.dir.autoconfig)); fill_pathname_join(g_defaults.dir.cursor, base_path, "BUNDLE/DATABASE/CURSORS", sizeof(g_defaults.dir.cursor)); fill_pathname_join(g_defaults.dir.database, base_path, "BUNDLE/DATABASE/RDB", sizeof(g_defaults.dir.database)); fill_pathname_join(g_defaults.dir.overlay, base_path, "BUNDLE/OVERLAYS", sizeof(g_defaults.dir.overlay)); fill_pathname_join(g_defaults.dir.shader, base_path, "BUNDLE/SHADERS", sizeof(g_defaults.dir.shader)); */ /* user data */ fill_pathname_join(g_defaults.dir.cheats, user_path, "CHEATS", sizeof(g_defaults.dir.cheats)); fill_pathname_join(g_defaults.dir.menu_config, user_path, "CONFIG", sizeof(g_defaults.dir.menu_config)); fill_pathname_join(g_defaults.dir.core_assets, user_path, "DOWNLOADS", sizeof(g_defaults.dir.core_assets)); fill_pathname_join(g_defaults.dir.playlist, user_path, "PLAYLISTS", sizeof(g_defaults.dir.playlist)); fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.menu_config, "REMAPS", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.sram, user_path, "SAVEFILES", sizeof(g_defaults.dir.sram)); fill_pathname_join(g_defaults.dir.savestate, user_path, "SAVESTATES", sizeof(g_defaults.dir.savestate)); fill_pathname_join(g_defaults.dir.screenshot, user_path, "SCREENSHOTS", sizeof(g_defaults.dir.screenshot)); fill_pathname_join(g_defaults.dir.system, user_path, "SYSTEM", sizeof(g_defaults.dir.system)); /* fill_pathname_join(g_defaults.dir.thumbnails, user_path, "THUMBNAILS", sizeof(g_defaults.dir.thumbnails)); */ /* cache dir */ fill_pathname_join(g_defaults.dir.cache, user_path, "TEMP", sizeof(g_defaults.dir.cache)); /* history and main config */ strlcpy(g_defaults.dir.content_history, user_path, sizeof(g_defaults.dir.content_history)); fill_pathname_join(g_defaults.path.config, user_path, file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); #endif /* create user data dirs */ path_mkdir(g_defaults.dir.cheats); path_mkdir(g_defaults.dir.core_assets); path_mkdir(g_defaults.dir.playlist); path_mkdir(g_defaults.dir.menu_config); path_mkdir(g_defaults.dir.playlist); path_mkdir(g_defaults.dir.remap); path_mkdir(g_defaults.dir.savestate); path_mkdir(g_defaults.dir.screenshot); path_mkdir(g_defaults.dir.sram); path_mkdir(g_defaults.dir.system); #ifdef VITA path_mkdir(g_defaults.dir.thumbnails); #endif /* create cache dir */ path_mkdir(g_defaults.dir.cache); #ifndef IS_SALAMANDER #ifdef VITA params = (struct rarch_main_wrap*)params_data; params->verbose = true; #endif if (!string_is_empty(argv[1])) { static char path[PATH_MAX_LENGTH] = {0}; struct rarch_main_wrap *args = (struct rarch_main_wrap*)params_data; if (args) { strlcpy(path, argv[1], sizeof(path)); args->touched = true; args->no_content = false; args->verbose = false; args->config_path = NULL; args->sram_path = NULL; args->state_path = NULL; args->content_path = path; args->libretro_path = NULL; RARCH_LOG("argv[0]: %s\n", argv[0]); RARCH_LOG("argv[1]: %s\n", argv[1]); RARCH_LOG("argv[2]: %s\n", argv[2]); RARCH_LOG("Auto-start game %s.\n", argv[1]); } } #endif }
static void frontend_emscripten_get_env(int *argc, char *argv[], void *args, void *params_data) { (void)args; char base_path[PATH_MAX] = {0}; char user_path[PATH_MAX] = {0}; const char *home = getenv("HOME"); if (home) { snprintf(base_path, sizeof(base_path), "%s/retroarch", home); snprintf(user_path, sizeof(user_path), "%s/retroarch/userdata", home); } else { snprintf(base_path, sizeof(base_path), "retroarch"); snprintf(user_path, sizeof(user_path), "retroarch/userdata"); } fill_pathname_join(g_defaults.dir.core, base_path, "cores", sizeof(g_defaults.dir.core)); /* bundle data */ fill_pathname_join(g_defaults.dir.assets, base_path, "bundle/assets", sizeof(g_defaults.dir.assets)); fill_pathname_join(g_defaults.dir.autoconfig, base_path, "bundle/autoconfig", sizeof(g_defaults.dir.autoconfig)); fill_pathname_join(g_defaults.dir.cursor, base_path, "bundle/database/cursors", sizeof(g_defaults.dir.cursor)); fill_pathname_join(g_defaults.dir.database, base_path, "bundle/database/rdb", sizeof(g_defaults.dir.database)); fill_pathname_join(g_defaults.dir.core_info, base_path, "bundle/info", sizeof(g_defaults.dir.core_info)); fill_pathname_join(g_defaults.dir.overlay, base_path, "bundle/overlays", sizeof(g_defaults.dir.overlay)); fill_pathname_join(g_defaults.dir.shader, base_path, "bundle/shaders", sizeof(g_defaults.dir.shader)); /* user data dirs */ fill_pathname_join(g_defaults.dir.cheats, user_path, "cheats", sizeof(g_defaults.dir.cheats)); fill_pathname_join(g_defaults.dir.menu_config, user_path, "config", sizeof(g_defaults.dir.menu_config)); fill_pathname_join(g_defaults.dir.menu_content, user_path, "content", sizeof(g_defaults.dir.menu_content)); fill_pathname_join(g_defaults.dir.core_assets, user_path, "content/downloads", sizeof(g_defaults.dir.core_assets)); fill_pathname_join(g_defaults.dir.playlist, user_path, "playlists", sizeof(g_defaults.dir.playlist)); fill_pathname_join(g_defaults.dir.remap, g_defaults.dir.menu_config, "remaps", sizeof(g_defaults.dir.remap)); fill_pathname_join(g_defaults.dir.sram, user_path, "saves", sizeof(g_defaults.dir.sram)); fill_pathname_join(g_defaults.dir.screenshot, user_path, "screenshots", sizeof(g_defaults.dir.screenshot)); fill_pathname_join(g_defaults.dir.savestate, user_path, "states", sizeof(g_defaults.dir.savestate)); fill_pathname_join(g_defaults.dir.system, user_path, "system", sizeof(g_defaults.dir.system)); fill_pathname_join(g_defaults.dir.thumbnails, user_path, "thumbnails", sizeof(g_defaults.dir.thumbnails)); /* cache dir */ fill_pathname_join(g_defaults.dir.cache, "/tmp/", "retroarch", sizeof(g_defaults.dir.cache)); /* history and main config */ strlcpy(g_defaults.dir.content_history, user_path, sizeof(g_defaults.dir.content_history)); fill_pathname_join(g_defaults.path.config, user_path, file_path_str(FILE_PATH_MAIN_CONFIG), sizeof(g_defaults.path.config)); /* create user data dirs */ path_mkdir(g_defaults.dir.cheats); path_mkdir(g_defaults.dir.core_assets); path_mkdir(g_defaults.dir.menu_config); path_mkdir(g_defaults.dir.menu_content); path_mkdir(g_defaults.dir.playlist); path_mkdir(g_defaults.dir.remap); path_mkdir(g_defaults.dir.savestate); path_mkdir(g_defaults.dir.screenshot); path_mkdir(g_defaults.dir.sram); path_mkdir(g_defaults.dir.system); path_mkdir(g_defaults.dir.thumbnails); /* create cache dir */ path_mkdir(g_defaults.dir.cache); snprintf(g_defaults.settings.menu, sizeof(g_defaults.settings.menu), "rgui"); }
/** * path_mkdir: * @dir : directory * * Create directory on filesystem. * * Returns: true (1) if directory could be created, otherwise false (0). **/ bool path_mkdir(const char *dir) { /* Use heap. Real chance of stack overflow if we recurse too hard. */ const char *target = NULL; bool sret = false; bool norecurse = false; char *basedir = NULL; if (dir && *dir) basedir = strdup(dir); if (!basedir) return false; path_parent_dir(basedir); if (!*basedir || !strcmp(basedir, dir)) goto end; if (path_is_directory(basedir)) { target = dir; norecurse = true; } else { target = basedir; sret = path_mkdir(basedir); if (sret) { target = dir; norecurse = true; } } if (norecurse) { #if defined(_WIN32) #ifdef LEGACY_WIN32 int ret = _mkdir(dir); #else wchar_t *dirW = utf8_to_utf16_string_alloc(dir); int ret = -1; if (dirW) { ret = _wmkdir(dirW); free(dirW); } #endif #elif defined(IOS) int ret = mkdir(dir, 0755); #elif defined(VITA) || defined(PSP) int ret = sceIoMkdir(dir, 0777); #elif defined(__QNX__) int ret = mkdir(dir, 0777); #else int ret = mkdir(dir, 0750); #endif /* Don't treat this as an error. */ if (path_mkdir_error(ret) && path_is_directory(dir)) ret = 0; if (ret < 0) printf("mkdir(%s) error: %s.\n", dir, strerror(errno)); sret = (ret == 0); } end: if (target && !sret) printf("Failed to create directory: \"%s\".\n", target); free(basedir); return sret; }
static void frontend_apple_get_environment_settings(int *argc, char *argv[], void *args, void *params_data) { char bundle_path_buf[PATH_MAX_LENGTH], home_dir_buf[PATH_MAX_LENGTH], support_path_buf[PATH_MAX_LENGTH]; CFURLRef bundle_url; CFStringRef bundle_path; CFBundleRef bundle = CFBundleGetMainBundle(); (void)support_path_buf; if (!bundle) return; bundle_url = CFBundleCopyBundleURL(bundle); bundle_path = CFURLCopyPath(bundle_url); CFStringGetCString(bundle_path, bundle_path_buf, sizeof(bundle_path_buf), kCFStringEncodingUTF8); (void)home_dir_buf; #ifdef IOS CFSearchPathForDirectoriesInDomains(CFDocumentDirectory, CFUserDomainMask, 1, home_dir_buf, sizeof(home_dir_buf)); fill_pathname_join(g_defaults.system_dir, home_dir_buf, ".RetroArch", sizeof(g_defaults.system_dir)); fill_pathname_join(g_defaults.core_dir, bundle_path_buf, "modules", sizeof(g_defaults.core_dir)); fill_pathname_join(g_defaults.core_info_dir, bundle_path_buf, "info", sizeof(g_defaults.core_info_dir)); fill_pathname_join(g_defaults.shader_dir, bundle_path_buf, "shaders_glsl", sizeof(g_defaults.shader_dir)); fill_pathname_join(g_defaults.overlay_dir, bundle_path_buf, "overlays", sizeof(g_defaults.overlay_dir)); strlcpy(g_defaults.menu_config_dir, g_defaults.system_dir, sizeof(g_defaults.menu_config_dir)); fill_pathname_join(g_defaults.config_path, g_defaults.menu_config_dir, "retroarch.cfg", sizeof(g_defaults.config_path)); strlcpy(g_defaults.sram_dir, g_defaults.system_dir, sizeof(g_defaults.sram_dir)); strlcpy(g_defaults.savestate_dir, g_defaults.system_dir, sizeof(g_defaults.savestate_dir)); path_mkdir(bundle_path_buf); if (access(bundle_path_buf, 0755) != 0) RARCH_ERR("Failed to create or access base directory: %s\n", bundle_path_buf); else { path_mkdir(g_defaults.system_dir); if (access(g_defaults.system_dir, 0755) != 0) RARCH_ERR("Failed to create or access system directory: %s.\n", g_defaults.system_dir); } #elif defined(OSX) CFSearchPathForDirectoriesInDomains(CFApplicationSupportDirectory, CFUserDomainMask, 1, support_path_buf, sizeof(support_path_buf)); fill_pathname_join(g_defaults.core_dir, "~/Library/Application Support/RetroArch", "cores", sizeof(g_defaults.core_dir)); fill_pathname_join(g_defaults.core_info_dir, "~/Library/Application Support/RetroArch", "info", sizeof(g_defaults.core_info_dir)); /* TODO/FIXME - we might need to update all these paths too and put them all in ~/Library/Application Support, but that would * require copying all the resource files that are bundled in the app bundle over first to this new directory. * * Ideas: There's some overlap here with how the Android APK has to extract all its resource files over to the actual sandboxed * app dir, maybe try to create something standardized for both platforms (OSX/Android) */ fill_pathname_join(g_defaults.overlay_dir, bundle_path_buf, "Contents/Resources/overlays", sizeof(g_defaults.overlay_dir)); fill_pathname_join(g_defaults.autoconfig_dir, bundle_path_buf, "Contents/Resources/autoconfig/apple", sizeof(g_defaults.autoconfig_dir)); fill_pathname_join(g_defaults.assets_dir, bundle_path_buf, "Contents/Resources/assets", sizeof(g_defaults.assets_dir)); fill_pathname_join(g_defaults.shader_dir, bundle_path_buf, "Contents/Resources/shaders", sizeof(g_defaults.shader_dir)); fill_pathname_join(g_defaults.audio_filter_dir, bundle_path_buf, "Contents/Resources/audio_filters", sizeof(g_defaults.audio_filter_dir)); fill_pathname_join(g_defaults.video_filter_dir, bundle_path_buf, "Contents/Resources/video_filters", sizeof(g_defaults.video_filter_dir)); fill_pathname_join(g_defaults.menu_config_dir, support_path_buf, "RetroArch", sizeof(g_defaults.menu_config_dir)); fill_pathname_join(g_defaults.config_path, g_defaults.menu_config_dir, "retroarch.cfg", sizeof(g_defaults.config_path)); #endif CFRelease(bundle_path); CFRelease(bundle_url); }
static void check_defaults_dirs(void) { if (*g_defaults.dir.core_assets) path_mkdir(g_defaults.dir.core_assets); if (*g_defaults.dir.remap) path_mkdir(g_defaults.dir.remap); if (*g_defaults.dir.screenshot) path_mkdir(g_defaults.dir.screenshot); if (*g_defaults.dir.core) path_mkdir(g_defaults.dir.core); if (*g_defaults.dir.autoconfig) path_mkdir(g_defaults.dir.autoconfig); if (*g_defaults.dir.audio_filter) path_mkdir(g_defaults.dir.audio_filter); if (*g_defaults.dir.video_filter) path_mkdir(g_defaults.dir.video_filter); if (*g_defaults.dir.assets) path_mkdir(g_defaults.dir.assets); if (*g_defaults.dir.playlist) path_mkdir(g_defaults.dir.playlist); if (*g_defaults.dir.core) path_mkdir(g_defaults.dir.core); if (*g_defaults.dir.core_info) path_mkdir(g_defaults.dir.core_info); if (*g_defaults.dir.overlay) path_mkdir(g_defaults.dir.overlay); if (*g_defaults.dir.port) path_mkdir(g_defaults.dir.port); if (*g_defaults.dir.shader) path_mkdir(g_defaults.dir.shader); if (*g_defaults.dir.savestate) path_mkdir(g_defaults.dir.savestate); if (*g_defaults.dir.sram) path_mkdir(g_defaults.dir.sram); if (*g_defaults.dir.system) path_mkdir(g_defaults.dir.system); if (*g_defaults.dir.resampler) path_mkdir(g_defaults.dir.resampler); if (*g_defaults.dir.menu_config) path_mkdir(g_defaults.dir.menu_config); if (*g_defaults.dir.content_history) path_mkdir(g_defaults.dir.content_history); if (*g_defaults.dir.cache) path_mkdir(g_defaults.dir.cache); if (*g_defaults.dir.database) path_mkdir(g_defaults.dir.database); if (*g_defaults.dir.cursor) path_mkdir(g_defaults.dir.cursor); if (*g_defaults.dir.cheats) path_mkdir(g_defaults.dir.cheats); }
static config_file_t *open_default_config_file(void) { config_file_t *conf = NULL; #if defined(_WIN32) && !defined(_XBOX) char conf_path[PATH_MAX]; char app_path[PATH_MAX]; fill_pathname_application_path(app_path, sizeof(app_path)); fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path)); conf = config_file_new(conf_path); if (!conf) { const char *appdata = getenv("APPDATA"); if (appdata) { fill_pathname_join(conf_path, appdata, "retroarch.cfg", sizeof(conf_path)); conf = config_file_new(conf_path); } } // Try to create a new config file. if (!conf) { conf = config_file_new(NULL); bool saved = false; if (conf) // Since this is a clean config file, we can safely use config_save_on_exit. { fill_pathname_resolve_relative(conf_path, app_path, "retroarch.cfg", sizeof(conf_path)); config_set_bool(conf, "config_save_on_exit", true); saved = config_file_write(conf, conf_path); } if (saved) RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it. else { RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path); config_file_free(conf); conf = NULL; } } if (conf) strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path)); #elif !defined(__CELLOS_LV2__) && !defined(_XBOX) char conf_path[PATH_MAX]; const char *xdg = getenv("XDG_CONFIG_HOME"); const char *home = getenv("HOME"); // XDG_CONFIG_HOME falls back to $HOME/.config. if (xdg) fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path)); else if (home) fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path)); if (xdg || home) { RARCH_LOG("Looking for config in: \"%s\".\n", conf_path); conf = config_file_new(conf_path); } // Fallback to $HOME/.retroarch.cfg. if (!conf && home) { fill_pathname_join(conf_path, home, ".retroarch.cfg", sizeof(conf_path)); RARCH_LOG("Looking for config in: \"%s\".\n", conf_path); conf = config_file_new(conf_path); } // Try to create a new config file. if (!conf && (home || xdg)) { // XDG_CONFIG_HOME falls back to $HOME/.config. if (xdg) fill_pathname_join(conf_path, xdg, "retroarch/retroarch.cfg", sizeof(conf_path)); else if (home) fill_pathname_join(conf_path, home, ".config/retroarch/retroarch.cfg", sizeof(conf_path)); char basedir[PATH_MAX]; fill_pathname_basedir(basedir, conf_path, sizeof(basedir)); if (path_mkdir(basedir)) { #ifndef GLOBAL_CONFIG_DIR #define GLOBAL_CONFIG_DIR "/etc" #endif char skeleton_conf[PATH_MAX]; fill_pathname_join(skeleton_conf, GLOBAL_CONFIG_DIR, "retroarch.cfg", sizeof(skeleton_conf)); conf = config_file_new(skeleton_conf); if (conf) RARCH_WARN("Using skeleton config \"%s\" as base for a new config file.\n", skeleton_conf); else conf = config_file_new(NULL); bool saved = false; if (conf) { config_set_bool(conf, "config_save_on_exit", true); // Since this is a clean config file, we can safely use config_save_on_exit. saved = config_file_write(conf, conf_path); } if (saved) RARCH_WARN("Created new config file in: \"%s\".\n", conf_path); // WARN here to make sure user has a good chance of seeing it. else { RARCH_ERR("Failed to create new config file in: \"%s\".\n", conf_path); config_file_free(conf); conf = NULL; } } } if (conf) strlcpy(g_extern.config_path, conf_path, sizeof(g_extern.config_path)); #endif return conf; }
int lutro_unzip(const char *path, const char *extraction_directory) { path_mkdir(extraction_directory); unzFile *zipfile = unzOpen(path); if ( zipfile == NULL ) { printf("%s: not found\n", path); return -1; } unz_global_info global_info; if (unzGetGlobalInfo(zipfile, &global_info) != UNZ_OK) { printf("could not read file global info\n"); unzClose(zipfile); return -1; } char read_buffer[8192]; uLong i; for (i = 0; i < global_info.number_entry; ++i) { unz_file_info file_info; char filename[PATH_MAX_LENGTH]; if (unzGetCurrentFileInfo(zipfile, &file_info, filename, PATH_MAX_LENGTH, NULL, 0, NULL, 0 ) != UNZ_OK) { printf( "could not read file info\n" ); unzClose( zipfile ); return -1; } const size_t filename_length = strlen(filename); if (filename[filename_length-1] == '/') { printf("dir:%s\n", filename); char abs_path[PATH_MAX_LENGTH]; fill_pathname_join(abs_path, extraction_directory, filename, sizeof(abs_path)); path_mkdir(abs_path); } else { printf("file:%s\n", filename); if (unzOpenCurrentFile(zipfile) != UNZ_OK) { printf("could not open file\n"); unzClose(zipfile); return -1; } char abs_path[PATH_MAX_LENGTH]; fill_pathname_join(abs_path, extraction_directory, filename, sizeof(abs_path)); FILE *out = fopen(abs_path, "wb"); if (out == NULL) { printf("could not open destination file\n"); unzCloseCurrentFile(zipfile); unzClose(zipfile); return -1; } int error = UNZ_OK; do { error = unzReadCurrentFile(zipfile, read_buffer, 8192); if (error < 0) { printf("error %d\n", error); unzCloseCurrentFile(zipfile); unzClose(zipfile); return -1; } if (error > 0) fwrite(read_buffer, error, 1, out); } while (error > 0); fclose(out); } unzCloseCurrentFile(zipfile); if (i + 1 < global_info.number_entry) { if (unzGoToNextFile(zipfile) != UNZ_OK) { printf("cound not read next file\n"); unzClose(zipfile); return -1; } } } unzClose(zipfile); return 0; }
/* Initialise runtime log, loading current parameters * if log file exists. Returned object must be free()'d. * Returns NULL if content_path and/or core_path are invalid */ runtime_log_t *runtime_log_init(const char *content_path, const char *core_path, bool log_per_core) { settings_t *settings = config_get_ptr(); core_info_list_t *core_info = NULL; runtime_log_t *runtime_log = NULL; const char *core_path_basename = path_basename(core_path); char content_name[PATH_MAX_LENGTH]; char core_name[PATH_MAX_LENGTH]; char log_file_dir[PATH_MAX_LENGTH]; char log_file_path[PATH_MAX_LENGTH]; char tmp_buf[PATH_MAX_LENGTH]; unsigned i; content_name[0] = '\0'; core_name[0] = '\0'; log_file_dir[0] = '\0'; log_file_path[0] = '\0'; tmp_buf[0] = '\0'; /* Error checking */ if (!settings) return NULL; if (string_is_empty(settings->paths.directory_playlist)) { RARCH_ERR("Playlist directory is undefined - cannot save runtime logs.\n"); return NULL; } if (string_is_empty(content_path) || string_is_empty(core_path_basename)) return NULL; if (string_is_equal(core_path, "builtin") || string_is_equal(core_path, file_path_str(FILE_PATH_DETECT))) return NULL; /* Get core name * Note: An annoyance - this is required even when * we are performing aggregate (not per core) logging, * since content name is sometimes dependent upon core * (e.g. see TyrQuake below) */ core_info_get_list(&core_info); if (!core_info) return NULL; for (i = 0; i < core_info->count; i++) { if (string_is_equal(path_basename(core_info->list[i].path), core_path_basename)) { strlcpy(core_name, core_info->list[i].core_name, sizeof(core_name)); break; } } if (string_is_empty(core_name)) return NULL; /* Get runtime log directory */ fill_pathname_join( tmp_buf, settings->paths.directory_playlist, "logs", sizeof(tmp_buf)); if (log_per_core) { fill_pathname_join( log_file_dir, tmp_buf, core_name, sizeof(log_file_dir)); } else { strlcpy(log_file_dir, tmp_buf, sizeof(log_file_dir)); } if (string_is_empty(log_file_dir)) return NULL; /* Create directory, if required */ if (!path_is_directory(log_file_dir)) { path_mkdir(log_file_dir); if(!path_is_directory(log_file_dir)) { RARCH_ERR("Failed to create directory for runtime log: %s.\n", log_file_dir); return NULL; } } /* Get content name * Note: TyrQuake requires a specific hack, since all * content has the same name... */ if (string_is_equal(core_name, "TyrQuake")) { const char *last_slash = find_last_slash(content_path); if (last_slash) { size_t path_length = last_slash + 1 - content_path; if (path_length < PATH_MAX_LENGTH) { memset(tmp_buf, 0, sizeof(tmp_buf)); strlcpy(tmp_buf, content_path, path_length * sizeof(char)); strlcpy(content_name, path_basename(tmp_buf), sizeof(content_name)); } } } else { /* path_remove_extension() requires a char * (not const) * so have to use a temporary buffer... */ tmp_buf[0] = '\0'; strlcpy(tmp_buf, path_basename(content_path), sizeof(tmp_buf)); strlcpy(content_name, path_remove_extension(tmp_buf), sizeof(content_name)); } if (string_is_empty(content_name)) return NULL; /* Build final log file path */ fill_pathname_join(log_file_path, log_file_dir, content_name, sizeof(log_file_path)); strlcat(log_file_path, file_path_str(FILE_PATH_RUNTIME_EXTENSION), sizeof(log_file_path)); if (string_is_empty(log_file_path)) return NULL; /* Phew... If we get this far then all is well. * > Create 'runtime_log' object */ runtime_log = (runtime_log_t*)calloc(1, sizeof(*runtime_log)); if (!runtime_log) return NULL; /* > Populate default values */ runtime_log->runtime.hours = 0; runtime_log->runtime.minutes = 0; runtime_log->runtime.seconds = 0; runtime_log->last_played.year = 0; runtime_log->last_played.month = 0; runtime_log->last_played.day = 0; runtime_log->last_played.hour = 0; runtime_log->last_played.minute = 0; runtime_log->last_played.second = 0; strlcpy(runtime_log->path, log_file_path, sizeof(runtime_log->path)); /* Load existing log file, if it exists */ runtime_log_read_file(runtime_log); return runtime_log; }