X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ffilesys.cpp;h=bd8b94aff98ff86ebf2ca6a0a5383c4625fd8717;hb=3955f512538ca7c6f2d2187f22d5a696da8e84d3;hp=bd82a4c7d3760f546d860ef580984848e9e9ae9a;hpb=a67540807a051c39d79203832383e8fc8829b5d6;p=oweals%2Fminetest.git diff --git a/src/filesys.cpp b/src/filesys.cpp index bd82a4c7d..bd8b94aff 100644 --- a/src/filesys.cpp +++ b/src/filesys.cpp @@ -1,27 +1,32 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola This program 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 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program 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. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "filesys.h" -#include "strfnd.h" +#include "util/string.h" #include +#include #include +#include +#include #include "log.h" +#include "config.h" +#include "porting.h" namespace fs { @@ -30,55 +35,28 @@ namespace fs #define _WIN32_WINNT 0x0501 #include -#include -#include -#include -#include -#include - -#define BUFSIZE MAX_PATH +#include -std::vector GetDirListing(std::string pathstring) +std::vector GetDirListing(const std::string &pathstring) { std::vector 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"< (BUFSIZE - 2)) - { - errorstream<<"GetDirListing: Input directory is too large."< GetDirListing(std::string pathstring) 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; @@ -101,29 +78,17 @@ std::vector GetDirListing(std::string pathstring) dwError = GetLastError(); FindClose(hFind); - if (dwError != ERROR_NO_MORE_FILES) - { - errorstream<<"GetDirListing: FindNextFile error. Error is " - < content = GetDirListing(path); - for(int i=0; i buf(bufsize); + DWORD len = GetTempPath(bufsize, &buf[0]); + if(len == 0 || len > bufsize){ + errorstream<<"GetTempPath failed, error = "< #include -#include #include #include #include -std::vector GetDirListing(std::string pathstring) +std::vector GetDirListing(const std::string &pathstring) { std::vector 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("<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; - int isdir = -1; // -1 means unknown + DirListNode node; + node.name = dirp->d_name; + + 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) @@ -287,13 +275,18 @@ bool CreateDir(std::string path) } } -bool PathExists(std::string path) +bool PathExists(const std::string &path) { struct stat st; return (stat(path.c_str(),&st) == 0); } -bool IsDir(std::string path) +bool IsPathAbsolute(const std::string &path) +{ + return path[0] == '/'; +} + +bool IsDir(const std::string &path) { struct stat statbuf; if(stat(path.c_str(), &statbuf)) @@ -301,16 +294,21 @@ bool IsDir(std::string path) return ((statbuf.st_mode & S_IFDIR) == S_IFDIR); } -bool RecursiveDelete(std::string path) +bool IsDirDelimiter(char c) +{ + return c == '/'; +} + +bool RecursiveDelete(const std::string &path) { /* Execute the 'rm' command directly, by fork() and execve() */ - + infostream<<"Removing \""< &dst) +#endif + +void GetRecursiveSubPaths(const std::string &path, std::vector &dst) { std::vector content = GetDirListing(path); for(unsigned int i=0; i &paths) return success; } -bool RecursiveDeleteContent(std::string path) +bool RecursiveDeleteContent(const std::string &path) { infostream<<"Removing content of \""< list = GetDirListing(path); @@ -411,19 +429,17 @@ bool RecursiveDeleteContent(std::string path) return true; } -bool CreateAllDirs(std::string path) +bool CreateAllDirs(const std::string &path) { - size_t pos; std::vector tocreate; std::string basepath = path; while(!PathExists(basepath)) { tocreate.push_back(basepath); - pos = basepath.rfind(DIR_DELIM_C); - if(pos == std::string::npos) + basepath = RemoveLastPathComponent(basepath); + if(basepath.empty()) break; - basepath = basepath.substr(0,pos); } for(int i=tocreate.size()-1;i>=0;i--) if(!CreateDir(tocreate[i])) @@ -431,5 +447,298 @@ bool CreateAllDirs(std::string path) return true; } +bool CopyFileContents(const std::string &source, const std::string &target) +{ + FILE *sourcefile = fopen(source.c_str(), "rb"); + if(sourcefile == NULL){ + errorstream< 0){ + fwrite(readbuffer, 1, readbytes, targetfile); + } + if(feof(sourcefile) || ferror(sourcefile)){ + // flush destination file to catch write errors + // (e.g. disk full) + fflush(targetfile); + done = true; + } + if(ferror(targetfile)){ + errorstream< 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){ + if(!fs::CopyDir(sourcechild, targetchild)){ + retval = false; + } + } + else { + if(!fs::CopyFileContents(sourcechild, targetchild)){ + retval = false; + } + } + } + return retval; + } + else { + return false; + } +} + +bool PathStartsWith(const std::string &path, const std::string &prefix) +{ + size_t pathsize = path.size(); + size_t pathpos = 0; + size_t prefixsize = prefix.size(); + size_t prefixpos = 0; + for(;;){ + bool delim1 = pathpos == pathsize + || IsDirDelimiter(path[pathpos]); + bool delim2 = prefixpos == prefixsize + || IsDirDelimiter(prefix[prefixpos]); + + if(delim1 != delim2) + return false; + + if(delim1){ + while(pathpos < pathsize && + IsDirDelimiter(path[pathpos])) + ++pathpos; + while(prefixpos < prefixsize && + IsDirDelimiter(prefix[prefixpos])) + ++prefixpos; + if(prefixpos == prefixsize) + return true; + if(pathpos == pathsize) + return false; + } + else{ + size_t len = 0; + do{ + char pathchar = path[pathpos+len]; + char prefixchar = prefix[prefixpos+len]; + if(FILESYS_CASE_INSENSITIVE){ + pathchar = tolower(pathchar); + prefixchar = tolower(prefixchar); + } + if(pathchar != prefixchar) + return false; + ++len; + } while(pathpos+len < pathsize + && !IsDirDelimiter(path[pathpos+len]) + && prefixpos+len < prefixsize + && !IsDirDelimiter( + prefix[prefixpos+len])); + pathpos += len; + prefixpos += len; + } + } +} + +std::string RemoveLastPathComponent(const std::string &path, + std::string *removed, int count) +{ + if(removed) + *removed = ""; + + size_t remaining = path.size(); + + for(int i = 0; i < count; ++i){ + // strip a dir delimiter + while(remaining != 0 && IsDirDelimiter(path[remaining-1])) + remaining--; + // strip a path component + size_t component_end = remaining; + while(remaining != 0 && !IsDirDelimiter(path[remaining-1])) + remaining--; + size_t component_start = remaining; + // strip a dir delimiter + while(remaining != 0 && IsDirDelimiter(path[remaining-1])) + remaining--; + if(removed){ + std::string component = path.substr(component_start, + component_end - component_start); + if(i) + *removed = component + DIR_DELIM + *removed; + else + *removed = component; + } + } + return path.substr(0, remaining); +} + +std::string RemoveRelativePathComponents(std::string path) +{ + size_t pos = path.size(); + size_t dotdot_count = 0; + while (pos != 0) { + size_t component_with_delim_end = pos; + // skip a dir delimiter + while (pos != 0 && IsDirDelimiter(path[pos-1])) + pos--; + // strip a path component + size_t component_end = pos; + 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 == ".") { + remove_this_component = true; + } else if (component == "..") { + remove_this_component = true; + dotdot_count += 1; + } else if (dotdot_count != 0) { + remove_this_component = true; + dotdot_count -= 1; + } + + if (remove_this_component) { + while (pos != 0 && IsDirDelimiter(path[pos-1])) + 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) + return ""; + + // remove trailing dir delimiters + pos = path.size(); + 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