/**
* Compute and store the search paths
* Copyright (C) 2007, 2008, 2009, 2014, 2015 Sylvain Beucler
* This file is part of GNU FreeDink
* GNU FreeDink is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 3 of the
* License, or (at your option) any later version.
* GNU FreeDink is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see
* .
*/
#ifdef HAVE_CONFIG_H
#include
#endif
#include
#include /* strdup */
#include /* getcwd */
#include
#include "io_util.h"
#include "paths.h"
#include "log.h"
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
#define WIN32_LEAN_AND_MEAN
#define _WIN32_IE 0x0401
#include
#include
#endif
/* mkdir */
#include
#include
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
#include
#define mkdir(name,mode) mkdir(name)
#endif
#include "str_util.h" /* asprintf_append */
#ifdef __ANDROID__
#include /* chdir */
#include
#include "SDL.h"
#endif
/* Pleases gnulib's error module */
char* program_name = PACKAGE;
static char* pkgdatadir = NULL;
static char* fallbackdir = NULL;
static char* dmoddir = NULL;
static char* dmodname = NULL;
static char* userappdir = NULL;
/**
* getcwd without size restriction
* aka get_current_dir_name(3)
*/
char* paths_getcwd()
{
char* cwd = NULL;
int cwd_size = PATH_MAX;
do {
cwd = (char*)realloc(cwd, cwd_size);
getcwd(cwd, cwd_size);
cwd_size *= 2;
} while (errno == ERANGE);
return cwd;
}
static char * br_strcat (const char *str1, const char *str2)
{
char *result;
size_t len1, len2;
if (str1 == NULL)
str1 = "";
if (str2 == NULL)
str2 = "";
len1 = strlen (str1);
len2 = strlen (str2);
result = (char *) malloc (len1 + len2 + 1);
memcpy (result, str1, len1);
memcpy (result + len1, str2, len2);
result[len1 + len2] = '\0';
return result;
}
static char* br_build_path (const char *dir, const char *file)
{
char *dir2, *result;
size_t len;
int must_free = 0;
len = strlen (dir);
if (len > 0 && dir[len - 1] != '/') {
dir2 = br_strcat (dir, "/");
must_free = 1;
} else
dir2 = (char *) dir;
result = br_strcat (dir2, file);
if (must_free)
free (dir2);
return result;
}
/**
* Allow using paths in test suite until we implement in-memory mocked
* filesystem, using std::stream rather than hard-to-mock FILE*
*/
#ifdef _WIN32
#include
#else
#include
#include
#include
#endif
void ts_paths_init() {
char* cwd = paths_getcwd();
pkgdatadir = br_build_path(cwd, "tmp_ts/pkgdatadir");
fallbackdir = br_build_path(cwd, "tmp_ts/fallbackdir");
dmoddir = br_build_path(cwd, "tmp_ts/dmoddir");
dmodname = br_build_path(cwd, "dmoddir");
userappdir = br_build_path(cwd, "tmp_ts/useradddir");
#ifdef _WIN32
SHFILEOPSTRUCT fileop;
fileop.hwnd = NULL;
fileop.wFunc = FO_DELETE;
fileop.pFrom = br_build_path(cwd, "tmp_ts\0");
fileop.pTo = NULL;
fileop.fFlags = FOF_NOCONFIRMATION|FOF_SILENT; // do not prompt the user
fileop.lpszProgressTitle = NULL;
fileop.hNameMappings = NULL;
SHFileOperation(&fileop);
#else
{
pid_t pid = 0;
if ((pid = fork()) < 0) {
perror("fork");
} else if (pid == 0) {
if (execlp("rm", "rm", "-rf", "tmp_ts/", NULL) < 0)
perror("execlp");
exit(EXIT_FAILURE);
} else {
int status = 0;
waitpid(pid, &status, 0);
}
}
#endif
free(cwd);
if (mkdir("tmp_ts", 0777) < 0) perror("mkdir");
if (mkdir(pkgdatadir, 0777) < 0) perror("mkdir");
if (mkdir(fallbackdir, 0777) < 0) perror("mkdir");
if (mkdir(dmoddir, 0777) < 0) perror("mkdir");
if (mkdir(dmoddir, 0777) < 0) perror("mkdir");
if (mkdir(userappdir, 0777) < 0) perror("mkdir");
// map.dat is always opened in "r" or "r+b", pre-create it:
FILE* in = paths_dmodfile_fopen("map.dat", "w");
fclose(in);
}
bool paths_init(char *argv0, char *refdir_opt, char *dmoddir_opt)
{
char *refdir = NULL;
/** pkgdatadir **/
{
#if defined __ANDROID__ || defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
/* "./freedink" */
pkgdatadir = strdup("./" PACKAGE);
#else
/* (e.g. "/usr/share/freedink") */
pkgdatadir = br_build_path(BUILD_DATA_DIR, PACKAGE);
#endif
}
/** refdir (e.g. "/usr/share/dink") **/
{
/** => refdir **/
char* match = NULL;
int nb_dirs = 7;
char* lookup[nb_dirs];
int i = 0;
if (refdir_opt == NULL)
lookup[0] = NULL;
else
lookup[0] = refdir_opt;
/* Use absolute filename, otherwise SDL_rwops fails on Android (java.io.FileNotFoundException) */
lookup[1] = paths_getcwd();
/* FHS mentions optional 'share/games' which some Debian packagers
seem to be found of */
/* PACKAGERS: don't alter these paths. FreeDink must run in a
_consistent_ way across platforms. If you need an alternate
path, consider using ./configure --prefix=..., or contact
bug-freedink@gnu.org to discuss it. */
lookup[2] = br_build_path(BUILD_DATA_DIR, "dink");
lookup[3] = "/usr/local/share/games/dink";
lookup[4] = "/usr/local/share/dink";
lookup[5] = "/usr/share/games/dink";
lookup[6] = "/usr/share/dink";
for (; i < nb_dirs; i++)
{
char *dir_graphics_ci = NULL, *dir_tiles_ci = NULL;
if (lookup[i] == NULL)
continue;
dir_graphics_ci = br_build_path(lookup[i], "dink/graphics");
dir_tiles_ci = br_build_path(lookup[i], "dink/tiles");
ciconvert(dir_graphics_ci);
ciconvert(dir_tiles_ci);
if (is_directory(dir_graphics_ci) && is_directory(dir_tiles_ci))
{
match = lookup[i];
}
if (match == NULL && i == 0)
{
log_error("Invalid --refdir option: %s and/or %s are not accessible.",
dir_graphics_ci, dir_tiles_ci);
return false;
}
free(dir_graphics_ci);
free(dir_tiles_ci);
if (match != NULL)
break;
}
refdir = match;
if (refdir != NULL)
{
refdir = strdup(refdir);
}
else
{
log_error("Error: cannot find reference directory (--refdir). I looked in:\n"
// lookup[0] already treated above
"- %s [current dir]\n"
"- %s [build prefix]\n"
"- %s [hard-coded prefix]\n"
"- %s [hard-coded prefix]\n"
"- %s [hard-coded prefix]\n"
"- %s [hard-coded prefix]\n"
"The reference directory contains among others the "
"'dink/graphics/' and 'dink/tiles/' directories (as well as D-Mods)."
, lookup[1], lookup[2], lookup[3], lookup[4], lookup[5], lookup[6]);
return false;
}
free(lookup[1]); // paths_getcwd
free(lookup[2]); // br_build_path
}
/** fallbackdir (e.g. "/usr/share/dink/dink") **/
/* (directory used when a file cannot be found in a D-Mod) */
{
fallbackdir = br_strcat(refdir, "/dink");
}
/** dmoddir (e.g. "/usr/share/dink/island") **/
{
if (dmoddir_opt != NULL && is_directory(dmoddir_opt))
{
/* Use path given on the command line, either a full path or a
path relative to the current directory. */
/* Note: don't search for "dink" in the default dir if no
'-game' option was given */
dmoddir = strdup(dmoddir_opt);
}
else
{
/* Use path given on the command line, relative to $refdir */
char *subdir = dmoddir_opt;
if (subdir == NULL || strlen(subdir) == 0) /* no opt, or -g '' */
subdir = "dink";
dmoddir = (char*)malloc(strlen(refdir) + 1 + strlen(subdir) + 1);
strcpy(dmoddir, refdir);
strcat(dmoddir, "/");
strcat(dmoddir, subdir);
if (!is_directory(dmoddir))
{
char *msg = NULL;
asprintf_append(&msg, "Error: D-Mod directory '%s' doesn't exist. I looked in:\n", subdir);
if (dmoddir_opt != NULL)
asprintf_append(&msg, "- ./%s\n", dmoddir_opt);
asprintf_append(&msg, "- %s (refdir is '%s')", dmoddir, refdir);
log_error("%s", msg);
free(msg);
return false;
}
}
/* Strip slashes */
while (strlen(dmoddir) > 0 && dmoddir[strlen(dmoddir) - 1] == '/')
dmoddir[strlen(dmoddir) - 1] = '\0';
}
/** dmodname (e.g. "island") **/
/* Used to save games in ~/.dink//... */
{
/* Don't accept '.' or '' or '/..' (nameless) but accept 'island' (relative path) */
int len = strlen(dmoddir);
char* start = dmoddir + len;
for (; start >= dmoddir; start--) /* basename(1) */
if (*start == '\\' || *start == '/')
break;
start++; // we're either -1 or at the last slash, start is right after
if (strcmp(start, ".") == 0 || strcmp(start, "..") == 0
|| strcmp(start, "") == 0)
{
log_error("Error: not loading nameless D-Mod '%s'", start);
return false;
}
int dmodname_len = start - dmoddir;
dmodname = (char*)malloc(dmodname_len+1);
strncpy(dmodname, start, dmodname_len);
dmodname[dmodname_len] = '\0';
}
/** userappdir (e.g. "~/.dink") **/
{
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
userappdir = (char*)malloc(MAX_PATH);
/* C:\Documents and Settings\name\Application Data */
SHGetSpecialFolderPath(NULL, userappdir, CSIDL_APPDATA, 1);
#else
char* envhome = getenv("HOME");
if (envhome != NULL)
userappdir = strdup(getenv("HOME"));
#endif
if (userappdir != NULL)
{
userappdir = (char*)realloc(userappdir, strlen(userappdir) + 1 + 1 + strlen(PACKAGE) + 1);
strcat(userappdir, "/");
#if defined _WIN32 || defined __WIN32__ || defined __CYGWIN__
#else
strcat(userappdir, ".");
#endif
strcat(userappdir, "dink");
}
else
{
// No detected home directory - saving in the reference
// directory
userappdir = strdup(refdir);
}
}
log_info("datadir = %s", BUILD_DATA_DIR);
log_info("pkgdatadir = %s", pkgdatadir);
log_info("refdir = %s", refdir);
log_info("fallbackdir = %s", fallbackdir);
log_info("dmoddir = %s", dmoddir);
log_info("dmodname = %s", dmodname);
log_info("userappdir = %s", userappdir);
free(refdir);
return true;
}
const char *paths_getpkgdatadir(void)
{
return pkgdatadir;
}
const char *paths_getdmoddir(void)
{
return dmoddir;
}
const char *paths_getdmodname(void)
{
return dmodname;
}
const char *paths_getfallbackdir(void)
{
return fallbackdir;
}
char* paths_dmodfile(const char *file)
{
char *fullpath = br_build_path(dmoddir, file);
ciconvert(fullpath);
return fullpath;
}
FILE* paths_dmodfile_fopen(const char *file, const char *mode)
{
char *fullpath = paths_dmodfile(file);
FILE *result = fopen(fullpath, mode);
free(fullpath);
return result;
}
char* paths_fallbackfile(const char *file)
{
char *fullpath = br_build_path(fallbackdir, file);
ciconvert(fullpath);
return fullpath;
}
FILE* paths_fallbackfile_fopen(const char *file, const char *mode)
{
char *fullpath = paths_fallbackfile(file);
FILE *result = fopen(fullpath, mode);
free(fullpath);
return result;
}
char* paths_pkgdatafile(const char *file)
{
char *fullpath = br_build_path(pkgdatadir, file);
ciconvert(fullpath);
return fullpath;
}
FILE* paths_pkgdatafile_fopen(const char *file, const char *mode)
{
char *fullpath = paths_pkgdatafile(file);
FILE *result = fopen(fullpath, mode);
free(fullpath);
return result;
}
FILE *paths_savegame_fopen(int num, const char *mode)
{
char *fullpath_in_dmoddir = NULL;
char *fullpath_in_userappdir = NULL;
FILE *fp = NULL;
/* 20 decimal digits max for 64bit integer - should be enough :) */
char file[4 + 20 + 4 + 1];
sprintf(file, "save%d.dat", num);
/** fullpath_in_userappdir **/
char *savedir = strdup(userappdir);
savedir = (char*)realloc(savedir, strlen(userappdir) + 1 + strlen(dmodname) + 1);
strcat(savedir, "/");
strcat(savedir, dmodname);
/* Create directories if needed */
if (strchr(mode, 'w') != NULL || strchr(mode, 'a') != NULL)
/* Note: 0777 & umask => 0755 in common case */
if ((!is_directory(userappdir) && (mkdir(userappdir, 0777) < 0))
|| (!is_directory(savedir) && (mkdir(savedir, 0777) < 0)))
{
free(savedir);
return NULL;
}
fullpath_in_userappdir = br_build_path(savedir, file);
ciconvert(fullpath_in_userappdir);
free(savedir);
/** fullpath_in_dmoddir **/
fullpath_in_dmoddir = paths_dmodfile(file);
ciconvert(fullpath_in_dmoddir);
/* Try ~/.dink (if present) when reading - but don't try that first
when writing - except in Emscripten where we need a stable,
exclusive mount point. */
#ifndef __EMSCRIPTEN__
if (strchr(mode, 'r') != NULL)
#endif
fp = fopen(fullpath_in_userappdir, mode);
/* Try in the D-Mod dir */
if (fp == NULL)
fp = fopen(fullpath_in_dmoddir, mode);
/* Then try in ~/.dink */
if (fp == NULL)
fp = fopen(fullpath_in_userappdir, mode);
free(fullpath_in_dmoddir);
free(fullpath_in_userappdir);
return fp;
}
void paths_quit(void)
{
free(pkgdatadir);
free(fallbackdir);
free(dmoddir);
free(dmodname);
free(userappdir);
pkgdatadir = NULL;
fallbackdir = NULL;
dmoddir = NULL;
dmodname = NULL;
userappdir = NULL;
}