*/
#include "filesys.h"
-#include "strfnd.h"
+#include "util/string.h"
#include <iostream>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
+#include <cstdio>
+#include <cstring>
+#include <cerrno>
+#include <fstream>
#include "log.h"
+#include "config.h"
+#include "porting.h"
+#ifdef __ANDROID__
+#include "settings.h" // For g_settings
+#endif
namespace fs
{
#define _WIN32_WINNT 0x0501
#include <windows.h>
-#include <malloc.h>
-#include <tchar.h>
-#include <wchar.h>
-
-#define BUFSIZE MAX_PATH
+#include <shlwapi.h>
-std::vector<DirListNode> GetDirListing(std::string pathstring)
+std::vector<DirListNode> GetDirListing(const std::string &pathstring)
{
std::vector<DirListNode> listing;
WIN32_FIND_DATA FindFileData;
HANDLE hFind = INVALID_HANDLE_VALUE;
DWORD dwError;
- LPTSTR DirSpec;
- INT retval;
-
- DirSpec = (LPTSTR) malloc (BUFSIZE);
-
- if( DirSpec == NULL )
- {
- errorstream<<"GetDirListing: Insufficient memory available"<<std::endl;
- retval = 1;
- goto Cleanup;
- }
-
- // Check that the input is not larger than allowed.
- if (pathstring.size() > (BUFSIZE - 2))
- {
- errorstream<<"GetDirListing: Input directory is too large."<<std::endl;
- retval = 3;
- goto Cleanup;
- }
- //_tprintf (TEXT("Target directory is %s.\n"), pathstring.c_str());
-
- sprintf(DirSpec, "%s", (pathstring + "\\*").c_str());
+ std::string dirSpec = pathstring + "\\*";
// Find the first file in the directory.
- hFind = FindFirstFile(DirSpec, &FindFileData);
+ hFind = FindFirstFile(dirSpec.c_str(), &FindFileData);
- if (hFind == INVALID_HANDLE_VALUE)
- {
- retval = (-1);
- goto Cleanup;
- }
- else
- {
+ if (hFind == INVALID_HANDLE_VALUE) {
+ dwError = GetLastError();
+ if (dwError != ERROR_FILE_NOT_FOUND && dwError != ERROR_PATH_NOT_FOUND) {
+ errorstream << "GetDirListing: FindFirstFile error."
+ << " Error is " << dwError << std::endl;
+ }
+ } else {
// NOTE:
// Be very sure to not include '..' in the results, it will
// result in an epic failure when deleting stuff.
DirListNode node;
node.name = FindFileData.cFileName;
node.dir = FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
- if(node.name != "." && node.name != "..")
+ if (node.name != "." && node.name != "..")
listing.push_back(node);
// List all the other files in the directory.
- while (FindNextFile(hFind, &FindFileData) != 0)
- {
+ while (FindNextFile(hFind, &FindFileData) != 0) {
DirListNode node;
node.name = FindFileData.cFileName;
node.dir = FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
dwError = GetLastError();
FindClose(hFind);
- if (dwError != ERROR_NO_MORE_FILES)
- {
- errorstream<<"GetDirListing: FindNextFile error. Error is "
- <<dwError<<std::endl;
- retval = (-1);
- goto Cleanup;
- }
+ if (dwError != ERROR_NO_MORE_FILES) {
+ errorstream << "GetDirListing: FindNextFile error."
+ << " Error is " << dwError << std::endl;
+ listing.clear();
+ return listing;
+ }
}
- retval = 0;
-
-Cleanup:
- free(DirSpec);
-
- if(retval != 0) listing.clear();
-
- //for(unsigned int i=0; i<listing.size(); i++){
- // infostream<<listing[i].name<<(listing[i].dir?" (dir)":" (file)")<<std::endl;
- //}
-
return listing;
}
-bool CreateDir(std::string path)
+bool CreateDir(const std::string &path)
{
bool r = CreateDirectory(path.c_str(), NULL);
if(r == true)
return false;
}
-bool PathExists(std::string path)
+bool PathExists(const std::string &path)
{
return (GetFileAttributes(path.c_str()) != INVALID_FILE_ATTRIBUTES);
}
-bool IsDir(std::string path)
+bool IsPathAbsolute(const std::string &path)
+{
+ return !PathIsRelative(path.c_str());
+}
+
+bool IsDir(const std::string &path)
{
DWORD attr = GetFileAttributes(path.c_str());
return (attr != INVALID_FILE_ATTRIBUTES &&
return c == '/' || c == '\\';
}
-bool RecursiveDelete(std::string path)
+bool RecursiveDelete(const std::string &path)
{
- infostream<<"Recursively deleting \""<<path<<"\""<<std::endl;
-
- DWORD attr = GetFileAttributes(path.c_str());
- bool is_directory = (attr != INVALID_FILE_ATTRIBUTES &&
- (attr & FILE_ATTRIBUTE_DIRECTORY));
- if(!is_directory)
- {
- infostream<<"RecursiveDelete: Deleting file "<<path<<std::endl;
- //bool did = DeleteFile(path.c_str());
- bool did = true;
- if(!did){
- errorstream<<"RecursiveDelete: Failed to delete file "
- <<path<<std::endl;
+ infostream << "Recursively deleting \"" << path << "\"" << std::endl;
+ if (!IsDir(path)) {
+ infostream << "RecursiveDelete: Deleting file " << path << std::endl;
+ if (!DeleteFile(path.c_str())) {
+ errorstream << "RecursiveDelete: Failed to delete file "
+ << path << std::endl;
return false;
}
+ return true;
}
- else
- {
- infostream<<"RecursiveDelete: Deleting content of directory "
- <<path<<std::endl;
- std::vector<DirListNode> content = GetDirListing(path);
- for(int i=0; i<content.size(); i++){
- const DirListNode &n = content[i];
- std::string fullpath = path + DIR_DELIM + n.name;
- bool did = RecursiveDelete(fullpath);
- if(!did){
- errorstream<<"RecursiveDelete: Failed to recurse to "
- <<fullpath<<std::endl;
- return false;
- }
- }
- infostream<<"RecursiveDelete: Deleting directory "<<path<<std::endl;
- //bool did = RemoveDirectory(path.c_str();
- bool did = true;
- if(!did){
- errorstream<<"Failed to recursively delete directory "
- <<path<<std::endl;
+ infostream << "RecursiveDelete: Deleting content of directory "
+ << path << std::endl;
+ std::vector<DirListNode> content = GetDirListing(path);
+ for (const DirListNode &n: content) {
+ std::string fullpath = path + DIR_DELIM + n.name;
+ if (!RecursiveDelete(fullpath)) {
+ errorstream << "RecursiveDelete: Failed to recurse to "
+ << fullpath << std::endl;
return false;
}
}
+ infostream << "RecursiveDelete: Deleting directory " << path << std::endl;
+ if (!RemoveDirectory(path.c_str())) {
+ errorstream << "Failed to recursively delete directory "
+ << path << std::endl;
+ return false;
+ }
return true;
}
-bool DeleteSingleFileOrEmptyDirectory(std::string path)
+bool DeleteSingleFileOrEmptyDirectory(const std::string &path)
{
DWORD attr = GetFileAttributes(path.c_str());
bool is_directory = (attr != INVALID_FILE_ATTRIBUTES &&
std::string TempPath()
{
- DWORD bufsize = GetTempPath(0, "");
+ DWORD bufsize = GetTempPath(0, NULL);
if(bufsize == 0){
errorstream<<"GetTempPath failed, error = "<<GetLastError()<<std::endl;
return "";
#include <sys/wait.h>
#include <unistd.h>
-std::vector<DirListNode> GetDirListing(std::string pathstring)
+std::vector<DirListNode> GetDirListing(const std::string &pathstring)
{
std::vector<DirListNode> listing;
- DIR *dp;
- struct dirent *dirp;
- if((dp = opendir(pathstring.c_str())) == NULL) {
+ DIR *dp;
+ struct dirent *dirp;
+ if((dp = opendir(pathstring.c_str())) == NULL) {
//infostream<<"Error("<<errno<<") opening "<<pathstring<<std::endl;
- return listing;
- }
+ return listing;
+ }
- while ((dirp = readdir(dp)) != NULL) {
+ while ((dirp = readdir(dp)) != NULL) {
// NOTE:
// Be very sure to not include '..' in the results, it will
// result in an epic failure when deleting stuff.
- if(dirp->d_name[0]!='.'){
- DirListNode node;
- node.name = dirp->d_name;
- if(node.name == "." || node.name == "..")
- continue;
+ if(strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0)
+ continue;
+
+ DirListNode node;
+ node.name = dirp->d_name;
- int isdir = -1; // -1 means unknown
+ int isdir = -1; // -1 means unknown
- /*
- POSIX doesn't define d_type member of struct dirent and
- certain filesystems on glibc/Linux will only return
- DT_UNKNOWN for the d_type member.
+ /*
+ POSIX doesn't define d_type member of struct dirent and
+ certain filesystems on glibc/Linux will only return
+ DT_UNKNOWN for the d_type member.
- Also we don't know whether symlinks are directories or not.
- */
+ Also we don't know whether symlinks are directories or not.
+ */
#ifdef _DIRENT_HAVE_D_TYPE
- if(dirp->d_type != DT_UNKNOWN && dirp->d_type != DT_LNK)
- isdir = (dirp->d_type == DT_DIR);
+ if(dirp->d_type != DT_UNKNOWN && dirp->d_type != DT_LNK)
+ isdir = (dirp->d_type == DT_DIR);
#endif /* _DIRENT_HAVE_D_TYPE */
- /*
- Was d_type DT_UNKNOWN, DT_LNK or nonexistent?
- If so, try stat().
- */
- if(isdir == -1)
- {
- struct stat statbuf;
- if (stat((pathstring + "/" + node.name).c_str(), &statbuf))
- continue;
- isdir = ((statbuf.st_mode & S_IFDIR) == S_IFDIR);
- }
- node.dir = isdir;
- listing.push_back(node);
+ /*
+ Was d_type DT_UNKNOWN, DT_LNK or nonexistent?
+ If so, try stat().
+ */
+ if(isdir == -1) {
+ struct stat statbuf{};
+ if (stat((pathstring + "/" + node.name).c_str(), &statbuf))
+ continue;
+ isdir = ((statbuf.st_mode & S_IFDIR) == S_IFDIR);
}
- }
- closedir(dp);
+ node.dir = isdir;
+ listing.push_back(node);
+ }
+ closedir(dp);
return listing;
}
-bool CreateDir(std::string path)
+bool CreateDir(const std::string &path)
{
int r = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
- if(r == 0)
- {
+ if (r == 0) {
return true;
}
- else
- {
- // If already exists, return true
- if(errno == EEXIST)
- return true;
- return false;
- }
+
+ // If already exists, return true
+ if (errno == EEXIST)
+ return true;
+ return false;
+
}
-bool PathExists(std::string path)
+bool PathExists(const std::string &path)
{
- struct stat st;
+ struct stat st{};
return (stat(path.c_str(),&st) == 0);
}
-bool IsDir(std::string path)
+bool IsPathAbsolute(const std::string &path)
{
- struct stat statbuf;
+ return path[0] == '/';
+}
+
+bool IsDir(const std::string &path)
+{
+ struct stat statbuf{};
if(stat(path.c_str(), &statbuf))
return false; // Actually error; but certainly not a directory
return ((statbuf.st_mode & S_IFDIR) == S_IFDIR);
return c == '/';
}
-bool RecursiveDelete(std::string path)
+bool RecursiveDelete(const std::string &path)
{
/*
Execute the 'rm' command directly, by fork() and execve()
*/
-
+
infostream<<"Removing \""<<path<<"\""<<std::endl;
//return false;
-
+
pid_t child_pid = fork();
if(child_pid == 0)
{
// Child
char argv_data[3][10000];
+#ifdef __ANDROID__
+ strcpy(argv_data[0], "/system/bin/rm");
+#else
strcpy(argv_data[0], "/bin/rm");
+#endif
strcpy(argv_data[1], "-rf");
- strncpy(argv_data[2], path.c_str(), 10000);
+ strncpy(argv_data[2], path.c_str(), sizeof(argv_data[2]) - 1);
char *argv[4];
argv[0] = argv_data[0];
argv[1] = argv_data[1];
verbosestream<<"Executing '"<<argv[0]<<"' '"<<argv[1]<<"' '"
<<argv[2]<<"'"<<std::endl;
-
+
execv(argv[0], argv);
-
+
// Execv shouldn't return. Failed.
_exit(1);
}
}
}
-bool DeleteSingleFileOrEmptyDirectory(std::string path)
+bool DeleteSingleFileOrEmptyDirectory(const std::string &path)
{
- if(IsDir(path)){
+ if (IsDir(path)) {
bool did = (rmdir(path.c_str()) == 0);
- if(!did)
- errorstream<<"rmdir errno: "<<errno<<": "<<strerror(errno)
- <<std::endl;
- return did;
- } else {
- bool did = (unlink(path.c_str()) == 0);
- if(!did)
- errorstream<<"unlink errno: "<<errno<<": "<<strerror(errno)
- <<std::endl;
+ if (!did)
+ errorstream << "rmdir errno: " << errno << ": " << strerror(errno)
+ << std::endl;
return did;
}
+
+ bool did = (unlink(path.c_str()) == 0);
+ if (!did)
+ errorstream << "unlink errno: " << errno << ": " << strerror(errno)
+ << std::endl;
+ return did;
}
std::string TempPath()
compatible with lua's os.tmpname which under the default
configuration hardcodes mkstemp("/tmp/lua_XXXXXX").
*/
- return std::string(DIR_DELIM) + "tmp";
+#ifdef __ANDROID__
+ return g_settings->get("TMPFolder");
+#else
+ return DIR_DELIM "tmp";
+#endif
}
#endif
-void GetRecursiveSubPaths(std::string path, std::vector<std::string> &dst)
+void GetRecursiveDirs(std::vector<std::string> &dirs, const std::string &dir)
+{
+ static const std::set<char> chars_to_ignore = { '_', '.' };
+ if (dir.empty() || !IsDir(dir))
+ return;
+ dirs.push_back(dir);
+ fs::GetRecursiveSubPaths(dir, dirs, false, chars_to_ignore);
+}
+
+std::vector<std::string> GetRecursiveDirs(const std::string &dir)
+{
+ std::vector<std::string> result;
+ GetRecursiveDirs(result, dir);
+ return result;
+}
+
+void GetRecursiveSubPaths(const std::string &path,
+ std::vector<std::string> &dst,
+ bool list_files,
+ const std::set<char> &ignore)
{
std::vector<DirListNode> content = GetDirListing(path);
- for(unsigned int i=0; i<content.size(); i++){
- const DirListNode &n = content[i];
+ for (const auto &n : content) {
std::string fullpath = path + DIR_DELIM + n.name;
- dst.push_back(fullpath);
- GetRecursiveSubPaths(fullpath, dst);
+ if (ignore.count(n.name[0]))
+ continue;
+ if (list_files || n.dir)
+ dst.push_back(fullpath);
+ if (n.dir)
+ GetRecursiveSubPaths(fullpath, dst, list_files, ignore);
}
}
return success;
}
-bool RecursiveDeleteContent(std::string path)
+bool RecursiveDeleteContent(const std::string &path)
{
infostream<<"Removing content of \""<<path<<"\""<<std::endl;
std::vector<DirListNode> list = GetDirListing(path);
- for(unsigned int i=0; i<list.size(); i++)
- {
- if(trim(list[i].name) == "." || trim(list[i].name) == "..")
+ for (const DirListNode &dln : list) {
+ if(trim(dln.name) == "." || trim(dln.name) == "..")
continue;
- std::string childpath = path + DIR_DELIM + list[i].name;
+ std::string childpath = path + DIR_DELIM + dln.name;
bool r = RecursiveDelete(childpath);
- if(r == false)
- {
- errorstream<<"Removing \""<<childpath<<"\" failed"<<std::endl;
+ if(!r) {
+ errorstream << "Removing \"" << childpath << "\" failed" << std::endl;
return false;
}
}
return true;
}
-bool CreateAllDirs(std::string path)
+bool CreateAllDirs(const std::string &path)
{
std::vector<std::string> tocreate;
return true;
}
-bool CopyFileContents(std::string source, std::string target)
+bool CopyFileContents(const std::string &source, const std::string &target)
{
FILE *sourcefile = fopen(source.c_str(), "rb");
if(sourcefile == NULL){
return retval;
}
-bool CopyDir(std::string source, std::string target)
+bool CopyDir(const std::string &source, const std::string &target)
{
if(PathExists(source)){
if(!PathExists(target)){
bool retval = true;
std::vector<DirListNode> content = fs::GetDirListing(source);
- for(unsigned int i=0; i < content.size(); i++){
- std::string sourcechild = source + DIR_DELIM + content[i].name;
- std::string targetchild = target + DIR_DELIM + content[i].name;
- if(content[i].dir){
+ for (const auto &dln : content) {
+ std::string sourcechild = source + DIR_DELIM + dln.name;
+ std::string targetchild = target + DIR_DELIM + dln.name;
+ if(dln.dir){
if(!fs::CopyDir(sourcechild, targetchild)){
retval = false;
}
}
return retval;
}
- else {
- return false;
- }
+
+ return false;
}
-bool PathStartsWith(std::string path, std::string prefix)
+bool PathStartsWith(const std::string &path, const std::string &prefix)
{
size_t pathsize = path.size();
size_t pathpos = 0;
&& !IsDirDelimiter(path[pathpos+len])
&& prefixpos+len < prefixsize
&& !IsDirDelimiter(
- prefix[prefixsize+len]));
+ prefix[prefixpos+len]));
pathpos += len;
prefixpos += len;
}
}
}
-std::string RemoveLastPathComponent(std::string path,
+std::string RemoveLastPathComponent(const std::string &path,
std::string *removed, int count)
{
if(removed)
{
size_t pos = path.size();
size_t dotdot_count = 0;
- while(pos != 0){
+ while (pos != 0) {
size_t component_with_delim_end = pos;
// skip a dir delimiter
- while(pos != 0 && IsDirDelimiter(path[pos-1]))
+ while (pos != 0 && IsDirDelimiter(path[pos-1]))
pos--;
// strip a path component
size_t component_end = pos;
- while(pos != 0 && !IsDirDelimiter(path[pos-1]))
+ while (pos != 0 && !IsDirDelimiter(path[pos-1]))
pos--;
size_t component_start = pos;
std::string component = path.substr(component_start,
component_end - component_start);
bool remove_this_component = false;
- if(component == "."){
+ if (component == ".") {
remove_this_component = true;
- }
- else if(component == ".."){
+ } else if (component == "..") {
remove_this_component = true;
dotdot_count += 1;
- }
- else if(dotdot_count != 0){
+ } else if (dotdot_count != 0) {
remove_this_component = true;
dotdot_count -= 1;
}
- if(remove_this_component){
- while(pos != 0 && IsDirDelimiter(path[pos-1]))
+ if (remove_this_component) {
+ while (pos != 0 && IsDirDelimiter(path[pos-1]))
pos--;
- path = path.substr(0, pos) + DIR_DELIM +
- path.substr(component_with_delim_end,
- std::string::npos);
- pos++;
+ if (component_start == 0) {
+ // We need to remove the delemiter too
+ path = path.substr(component_with_delim_end, std::string::npos);
+ } else {
+ path = path.substr(0, pos) + DIR_DELIM +
+ path.substr(component_with_delim_end, std::string::npos);
+ }
+ if (pos > 0)
+ pos++;
}
}
- if(dotdot_count > 0)
+ if (dotdot_count > 0)
return "";
// remove trailing dir delimiters
pos = path.size();
- while(pos != 0 && IsDirDelimiter(path[pos-1]))
+ while (pos != 0 && IsDirDelimiter(path[pos-1]))
pos--;
return path.substr(0, pos);
}
+std::string AbsolutePath(const std::string &path)
+{
+#ifdef _WIN32
+ char *abs_path = _fullpath(NULL, path.c_str(), MAX_PATH);
+#else
+ char *abs_path = realpath(path.c_str(), NULL);
+#endif
+ if (!abs_path) return "";
+ std::string abs_path_str(abs_path);
+ free(abs_path);
+ return abs_path_str;
+}
+
+const char *GetFilenameFromPath(const char *path)
+{
+ const char *filename = strrchr(path, DIR_DELIM_CHAR);
+ return filename ? filename + 1 : path;
+}
+
+bool safeWriteToFile(const std::string &path, const std::string &content)
+{
+ std::string tmp_file = path + ".~mt";
+
+ // Write to a tmp file
+ std::ofstream os(tmp_file.c_str(), std::ios::binary);
+ if (!os.good())
+ return false;
+ os << content;
+ os.flush();
+ os.close();
+ if (os.fail()) {
+ // Remove the temporary file because writing it failed and it's useless.
+ remove(tmp_file.c_str());
+ return false;
+ }
+
+ bool rename_success = false;
+
+ // Move the finished temporary file over the real file
+#ifdef _WIN32
+ // When creating the file, it can cause Windows Search indexer, virus scanners and other apps
+ // to query the file. This can make the move file call below fail.
+ // We retry up to 5 times, with a 1ms sleep between, before we consider the whole operation failed
+ int number_attempts = 0;
+ while (number_attempts < 5) {
+ rename_success = MoveFileEx(tmp_file.c_str(), path.c_str(),
+ MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
+ if (rename_success)
+ break;
+ sleep_ms(1);
+ ++number_attempts;
+ }
+#else
+ // On POSIX compliant systems rename() is specified to be able to swap the
+ // file in place of the destination file, making this a truly error-proof
+ // transaction.
+ rename_success = rename(tmp_file.c_str(), path.c_str()) == 0;
+#endif
+ if (!rename_success) {
+ warningstream << "Failed to write to file: " << path.c_str() << std::endl;
+ // Remove the temporary file because moving it over the target file
+ // failed.
+ remove(tmp_file.c_str());
+ return false;
+ }
+
+ return true;
+}
+
+bool Rename(const std::string &from, const std::string &to)
+{
+ return rename(from.c_str(), to.c_str()) == 0;
+}
+
} // namespace fs