src/filesys.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "filesys.h"
  21 #include "strfnd.h"
  22 #include <iostream>
  23 #include <string.h>
  24 #include "log.h"
  25
  26 namespace fs
  27 {
  28
  29 #ifdef _WIN32 // WINDOWS
  30
  31 #define _WIN32_WINNT 0x0501
  32 #include <windows.h>
  33 #include <stdio.h>
  34 #include <malloc.h>
  35 #include <tchar.h>
  36 #include <wchar.h>
  37 #include <stdio.h>
  38
  39 #define BUFSIZE MAX_PATH
  40
  41 std::vector<DirListNode> GetDirListing(std::string pathstring)
  42 {
  43         std::vector<DirListNode> listing;
  44
  45         WIN32_FIND_DATA FindFileData;
  46         HANDLE hFind = INVALID_HANDLE_VALUE;
  47         DWORD dwError;
  48         LPTSTR DirSpec;
  49         INT retval;
  50
  51         DirSpec = (LPTSTR) malloc (BUFSIZE);
  52
  53         if( DirSpec == NULL )
  54         {
  55           errorstream<<"GetDirListing: Insufficient memory available"<<std::endl;
  56           retval = 1;
  57           goto Cleanup;
  58         }
  59
  60         // Check that the input is not larger than allowed.
  61         if (pathstring.size() > (BUFSIZE - 2))
  62         {
  63           errorstream<<"GetDirListing: Input directory is too large."<<std::endl;
  64           retval = 3;
  65           goto Cleanup;
  66         }
  67
  68         //_tprintf (TEXT("Target directory is %s.\n"), pathstring.c_str());
  69
  70         sprintf(DirSpec, "%s", (pathstring + "\\*").c_str());
  71
  72         // Find the first file in the directory.
  73         hFind = FindFirstFile(DirSpec, &FindFileData);
  74
  75         if (hFind == INVALID_HANDLE_VALUE)
  76         {
  77                 retval = (-1);
  78                 goto Cleanup;
  79         }
  80         else
  81         {
  82                 // NOTE:
  83                 // Be very sure to not include '..' in the results, it will
  84                 // result in an epic failure when deleting stuff.
  85
  86                 DirListNode node;
  87                 node.name = FindFileData.cFileName;
  88                 node.dir = FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
  89                 if(node.name != "." && node.name != "..")
  90                         listing.push_back(node);
  91
  92                 // List all the other files in the directory.
  93                 while (FindNextFile(hFind, &FindFileData) != 0)
  94                 {
  95                         DirListNode node;
  96                         node.name = FindFileData.cFileName;
  97                         node.dir = FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
  98                         if(node.name != "." && node.name != "..")
  99                                 listing.push_back(node);
 100                 }
 101
 102                 dwError = GetLastError();
 103                 FindClose(hFind);
 104                 if (dwError != ERROR_NO_MORE_FILES)
 105                 {
 106                         errorstream<<"GetDirListing: FindNextFile error. Error is "
 107                                         <<dwError<<std::endl;
 108                         retval = (-1);
 109                         goto Cleanup;
 110                 }
 111         }
 112         retval  = 0;
 113
 114 Cleanup:
 115         free(DirSpec);
 116
 117         if(retval != 0) listing.clear();
 118
 119         //for(unsigned int i=0; i<listing.size(); i++){
 120         //      infostream<<listing[i].name<<(listing[i].dir?" (dir)":" (file)")<<std::endl;
 121         //}
 122
 123         return listing;
 124 }
 125
 126 bool CreateDir(std::string path)
 127 {
 128         bool r = CreateDirectory(path.c_str(), NULL);
 129         if(r == true)
 130                 return true;
 131         if(GetLastError() == ERROR_ALREADY_EXISTS)
 132                 return true;
 133         return false;
 134 }
 135
 136 bool PathExists(std::string path)
 137 {
 138         return (GetFileAttributes(path.c_str()) != INVALID_FILE_ATTRIBUTES);
 139 }
 140
 141 bool IsDir(std::string path)
 142 {
 143         DWORD attr = GetFileAttributes(path.c_str());
 144         return (attr != INVALID_FILE_ATTRIBUTES &&
 145                         (attr & FILE_ATTRIBUTE_DIRECTORY));
 146 }
 147
 148 bool RecursiveDelete(std::string path)
 149 {
 150         infostream<<"Recursively deleting \""<<path<<"\""<<std::endl;
 151
 152         DWORD attr = GetFileAttributes(path.c_str());
 153         bool is_directory = (attr != INVALID_FILE_ATTRIBUTES &&
 154                         (attr & FILE_ATTRIBUTE_DIRECTORY));
 155         if(!is_directory)
 156         {
 157                 infostream<<"RecursiveDelete: Deleting file "<<path<<std::endl;
 158                 //bool did = DeleteFile(path.c_str());
 159                 bool did = true;
 160                 if(!did){
 161                         errorstream<<"RecursiveDelete: Failed to delete file "
 162                                         <<path<<std::endl;
 163                         return false;
 164                 }
 165         }
 166         else
 167         {
 168                 infostream<<"RecursiveDelete: Deleting content of directory "
 169                                 <<path<<std::endl;
 170                 std::vector<DirListNode> content = GetDirListing(path);
 171                 for(int i=0; i<content.size(); i++){
 172                         const DirListNode &n = content[i];
 173                         std::string fullpath = path + DIR_DELIM + n.name;
 174                         bool did = RecursiveDelete(fullpath);
 175                         if(!did){
 176                                 errorstream<<"RecursiveDelete: Failed to recurse to "
 177                                                 <<fullpath<<std::endl;
 178                                 return false;
 179                         }
 180                 }
 181                 infostream<<"RecursiveDelete: Deleting directory "<<path<<std::endl;
 182                 //bool did = RemoveDirectory(path.c_str();
 183                 bool did = true;
 184                 if(!did){
 185                         errorstream<<"Failed to recursively delete directory "
 186                                         <<path<<std::endl;
 187                         return false;
 188                 }
 189         }
 190         return true;
 191 }
 192
 193 bool DeleteSingleFileOrEmptyDirectory(std::string path)
 194 {
 195         DWORD attr = GetFileAttributes(path.c_str());
 196         bool is_directory = (attr != INVALID_FILE_ATTRIBUTES &&
 197                         (attr & FILE_ATTRIBUTE_DIRECTORY));
 198         if(!is_directory)
 199         {
 200                 bool did = DeleteFile(path.c_str());
 201                 return did;
 202         }
 203         else
 204         {
 205                 bool did = RemoveDirectory(path.c_str());
 206                 return did;
 207         }
 208 }
 209
 210 #else // POSIX
 211
 212 #include <sys/types.h>
 213 #include <dirent.h>
 214 #include <errno.h>
 215 #include <sys/stat.h>
 216 #include <sys/wait.h>
 217 #include <unistd.h>
 218
 219 std::vector<DirListNode> GetDirListing(std::string pathstring)
 220 {
 221         std::vector<DirListNode> listing;
 222
 223     DIR *dp;
 224     struct dirent *dirp;
 225     if((dp  = opendir(pathstring.c_str())) == NULL) {
 226                 //infostream<<"Error("<<errno<<") opening "<<pathstring<<std::endl;
 227         return listing;
 228     }
 229
 230     while ((dirp = readdir(dp)) != NULL) {
 231                 // NOTE:
 232                 // Be very sure to not include '..' in the results, it will
 233                 // result in an epic failure when deleting stuff.
 234                 if(dirp->d_name[0]!='.'){
 235                         DirListNode node;
 236                         node.name = dirp->d_name;
 237                         if(node.name == "." || node.name == "..")
 238                                 continue;
 239
 240                         int isdir = -1; // -1 means unknown
 241
 242                         /*
 243                                 POSIX doesn't define d_type member of struct dirent and
 244                                 certain filesystems on glibc/Linux will only return
 245                                 DT_UNKNOWN for the d_type member.
 246
 247                                 Also we don't know whether symlinks are directories or not.
 248                         */
 249 #ifdef _DIRENT_HAVE_D_TYPE
 250                         if(dirp->d_type != DT_UNKNOWN && dirp->d_type != DT_LNK)
 251                                 isdir = (dirp->d_type == DT_DIR);
 252 #endif /* _DIRENT_HAVE_D_TYPE */
 253
 254                         /*
 255                                 Was d_type DT_UNKNOWN, DT_LNK or nonexistent?
 256                                 If so, try stat().
 257                         */
 258                         if(isdir == -1)
 259                         {
 260                                 struct stat statbuf;
 261                                 if (stat((pathstring + "/" + node.name).c_str(), &statbuf))
 262                                         continue;
 263                                 isdir = ((statbuf.st_mode & S_IFDIR) == S_IFDIR);
 264                         }
 265                         node.dir = isdir;
 266                         listing.push_back(node);
 267                 }
 268     }
 269     closedir(dp);
 270
 271         return listing;
 272 }
 273
 274 bool CreateDir(std::string path)
 275 {
 276         int r = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
 277         if(r == 0)
 278         {
 279                 return true;
 280         }
 281         else
 282         {
 283                 // If already exists, return true
 284                 if(errno == EEXIST)
 285                         return true;
 286                 return false;
 287         }
 288 }
 289
 290 bool PathExists(std::string path)
 291 {
 292         struct stat st;
 293         return (stat(path.c_str(),&st) == 0);
 294 }
 295
 296 bool IsDir(std::string path)
 297 {
 298         struct stat statbuf;
 299         if(stat(path.c_str(), &statbuf))
 300                 return false; // Actually error; but certainly not a directory
 301         return ((statbuf.st_mode & S_IFDIR) == S_IFDIR);
 302 }
 303
 304 bool RecursiveDelete(std::string path)
 305 {
 306         /*
 307                 Execute the 'rm' command directly, by fork() and execve()
 308         */
 309
 310         infostream<<"Removing \""<<path<<"\""<<std::endl;
 311
 312         //return false;
 313
 314         pid_t child_pid = fork();
 315
 316         if(child_pid == 0)
 317         {
 318                 // Child
 319                 char argv_data[3][10000];
 320                 strcpy(argv_data[0], "/bin/rm");
 321                 strcpy(argv_data[1], "-rf");
 322                 strncpy(argv_data[2], path.c_str(), 10000);
 323                 char *argv[4];
 324                 argv[0] = argv_data[0];
 325                 argv[1] = argv_data[1];
 326                 argv[2] = argv_data[2];
 327                 argv[3] = NULL;
 328
 329                 verbosestream<<"Executing '"<<argv[0]<<"' '"<<argv[1]<<"' '"
 330                                 <<argv[2]<<"'"<<std::endl;
 331
 332                 execv(argv[0], argv);
 333
 334                 // Execv shouldn't return. Failed.
 335                 _exit(1);
 336         }
 337         else
 338         {
 339                 // Parent
 340                 int child_status;
 341                 pid_t tpid;
 342                 do{
 343                         tpid = wait(&child_status);
 344                         //if(tpid != child_pid) process_terminated(tpid);
 345                 }while(tpid != child_pid);
 346                 return (child_status == 0);
 347         }
 348 }
 349
 350 bool DeleteSingleFileOrEmptyDirectory(std::string path)
 351 {
 352         if(IsDir(path)){
 353                 bool did = (rmdir(path.c_str()) == 0);
 354                 if(!did)
 355                         errorstream<<"rmdir errno: "<<errno<<": "<<strerror(errno)
 356                                         <<std::endl;
 357                 return did;
 358         } else {
 359                 bool did = (unlink(path.c_str()) == 0);
 360                 if(!did)
 361                         errorstream<<"unlink errno: "<<errno<<": "<<strerror(errno)
 362                                         <<std::endl;
 363                 return did;
 364         }
 365 }
 366
 367 #endif
 368
 369 void GetRecursiveSubPaths(std::string path, std::vector<std::string> &dst)
 370 {
 371         std::vector<DirListNode> content = GetDirListing(path);
 372         for(unsigned int  i=0; i<content.size(); i++){
 373                 const DirListNode &n = content[i];
 374                 std::string fullpath = path + DIR_DELIM + n.name;
 375                 dst.push_back(fullpath);
 376                 GetRecursiveSubPaths(fullpath, dst);
 377         }
 378 }
 379
 380 bool DeletePaths(const std::vector<std::string> &paths)
 381 {
 382         bool success = true;
 383         // Go backwards to succesfully delete the output of GetRecursiveSubPaths
 384         for(int i=paths.size()-1; i>=0; i--){
 385                 const std::string &path = paths[i];
 386                 bool did = DeleteSingleFileOrEmptyDirectory(path);
 387                 if(!did){
 388                         errorstream<<"Failed to delete "<<path<<std::endl;
 389                         success = false;
 390                 }
 391         }
 392         return success;
 393 }
 394
 395 bool RecursiveDeleteContent(std::string path)
 396 {
 397         infostream<<"Removing content of \""<<path<<"\""<<std::endl;
 398         std::vector<DirListNode> list = GetDirListing(path);
 399         for(unsigned int i=0; i<list.size(); i++)
 400         {
 401                 if(trim(list[i].name) == "." || trim(list[i].name) == "..")
 402                         continue;
 403                 std::string childpath = path + DIR_DELIM + list[i].name;
 404                 bool r = RecursiveDelete(childpath);
 405                 if(r == false)
 406                 {
 407                         errorstream<<"Removing \""<<childpath<<"\" failed"<<std::endl;
 408                         return false;
 409                 }
 410         }
 411         return true;
 412 }
 413
 414 bool CreateAllDirs(std::string path)
 415 {
 416
 417         size_t pos;
 418         std::vector<std::string> tocreate;
 419         std::string basepath = path;
 420         while(!PathExists(basepath))
 421         {
 422                 tocreate.push_back(basepath);
 423                 pos = basepath.rfind(DIR_DELIM_C);
 424                 if(pos == std::string::npos)
 425                         break;
 426                 basepath = basepath.substr(0,pos);
 427         }
 428         for(int i=tocreate.size()-1;i>=0;i--)
 429                 if(!CreateDir(tocreate[i]))
 430                         return false;
 431         return true;
 432 }
 433
 434 } // namespace fs
 435