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;
}
