src/filesystem.cc

   1 /*
   2  * For information about this file see fsal.hh
   3  *
   4  * Copyright (C) 2009 David Kolossa
   5  *
   6  * This file is part of OpenStranded.
   7  *
   8  * OpenStranded is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * OpenStranded is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <iostream>
  23 #include <string>
  24 #include <vector>
  25 #include <map>
  26 #include <cstdlib>
  27 #include <cstring>
  28
  29 #ifndef WIN32
  30         #include <sys/types.h>
  31         #include <sys/stat.h>
  32         #include <dirent.h>
  33         #include <fcntl.h>
  34         #include <errno.h>
  35 #endif
  36
  37 #include "filesystem.hh"
  38 #include "s2string.hh"
  39 #include "eal/engine.hh"
  40
  41
  42
  43 //
  44 // Class FileSystem
  45 //
  46
  47 std::string FileSystem::modName = "";
  48
  49 void
  50 FileSystem::setModName(std::string name)
  51 {
  52         modName = name;
  53 }
  54
  55 std::vector<std::string> *
  56 FileSystem::getDirectoryVector(std::string dirPath)
  57 {
  58         std::vector<std::string> *fileNames = new std::vector<std::string>();
  59         #ifndef WIN32
  60                 DIR *dir = opendir(dirPath.c_str());
  61                 if(dir == NULL)
  62                 {
  63                         std::cerr << "Directory " << dirPath << "could not be opened";
  64                         return NULL;
  65                 }
  66                 dirent *file;
  67                 while((file = readdir(dir)) != NULL)
  68                 {
  69                         if(std::strcmp(file->d_name, ".")  != 0 &&
  70                            std::strcmp(file->d_name, "..") != 0)
  71                         {
  72                                 fileNames->push_back(std::string(file->d_name));
  73                         }
  74                 }
  75                 closedir(dir);
  76                 return fileNames;
  77
  78         #else
  79                 // TODO: Have fun, Windows porters!
  80                 return NULL;
  81         #endif
  82 }
  83
  84 std::string
  85 FileSystem::getFileNameFromDirectoryVector(std::vector<std::string> *dirVector, const std::vector<std::string> &extensions, std::string name)
  86 {
  87         for(std::vector<std::string>::iterator f = dirVector->begin(); f != dirVector->end(); f++)
  88         {
  89                 // Split filename into extension and actual filename
  90                 std::string extension = f->substr(f->find_last_of('.')+1);
  91                 std::string cutFileName = f->substr(0, f->find_last_of('.'));
  92
  93                 // Check whether a file with a matching extension fits
  94                 for(std::vector<std::string>::const_iterator e = extensions.begin(); e != extensions.end(); e++)
  95                 {
  96                         #ifndef WIN32
  97                                 // case-sensitive
  98                                 if((cutFileName + "." + s2str::toLowercase(extension)) == (name + "." + *e))
  99                         #else
 100                                 // case-insensitive
 101                                 if((s2str::toLowercase(cutFileName) + "." + s2str::toLowercase(extension)) == (s2str::toLowercase(name) + "." + s2str::lowercase(*e)))
 102                         #endif
 103                         {
 104                                 return *f;
 105                         }
 106                 }
 107         }
 108         return "";
 109 }
 110
 111
 112
 113
 114 //
 115 // Directories
 116 //
 117 DirectoryInfo*
 118 FileSystem::getUserDirectoryInfo()
 119 {
 120         std::string path = "";
 121
 122         #ifndef WIN32
 123                 path += std::getenv("HOME");
 124                 path += "/.openstranded/";
 125                 if(opendir(path.c_str()) == NULL)
 126                 {
 127                         int dirCreated = mkdir(path.c_str(), S_IRWXU);
 128                         if(dirCreated != 0)
 129                         {
 130                                 // This might be called before the error stream
 131                                 // is created, therefore no Out::error but
 132                                 // std::cerr
 133                                 std::cerr << "FATAL: OpenStranded user directory couldn't be created" << std::endl;
 134                                 return NULL;
 135                         }
 136                 }
 137                 return new DirectoryInfo(path);
 138         #else
 139                 // TODO: Windows stuff
 140                 return NULL;
 141         #endif
 142 }
 143
 144 DirectoryInfo*
 145 FileSystem::getGameDirectoryInfo()
 146 {
 147         // FIXME: I don't want this hardcoded but I can't get CMake to
 148         // deliver me the install path...
 149         return new DirectoryInfo("/usr/share/games/openstranded/");
 150 }
 151
 152 DirectoryInfo*
 153 FileSystem::getModDirectoryInfo()
 154 {
 155         // FIXME: Same as in getGameDirectoryInfo()
 156         return new DirectoryInfo("/usr/share/games/openstranded/mods/" + modName + "/");
 157 }
 158
 159
 160
 161 //
 162 // General Files
 163 //
 164 FileInfo*
 165 FileSystem::getSaveFileInfo(std::string name)
 166 {
 167         std::string path;
 168
 169         path = getUserDirectoryInfo()->path + "saves/" + name;
 170
 171         FILE *f;
 172         if((f = std::fopen((path+".sav").c_str(), "r+")) != NULL)
 173         {
 174                 fclose(f);
 175                 return new FileInfo(path, 0);
 176         }
 177         else
 178         {
 179                 return new FileInfo(path, errno);
 180         }
 181 }
 182
 183
 184
 185 //
 186 // GFX files
 187 //
 188 FileInfo*
 189 FileSystem::getTextureFileInfo(std::string name)
 190 {
 191         std::string path = "";
 192         const std::vector<std::string> &allowedExtensions = eal::Engine::get()->getTextureExtensions();
 193
 194
 195         // TODO: Map specific lookup
 196
 197
 198         // Global lookup
 199         DirectoryInfo* modDir = getModDirectoryInfo();
 200         std::string dirPath = modDir->path + "gfx/textures/";
 201         delete modDir;
 202         modDir = NULL;
 203
 204
 205         // Get file name
 206         std::vector<std::string> *dirVector = getDirectoryVector(dirPath);
 207         std::string fileName = getFileNameFromDirectoryVector(dirVector, allowedExtensions, name);
 208         delete dirVector;
 209         dirVector = NULL;
 210         path = dirPath + fileName;
 211
 212         // Does our file actually exist?
 213         if(fileName == "")
 214         {
 215                 std::cerr << "WARNING: Texture " << fileName << " not found" << std::endl;
 216                 return new FileInfo(path, ENOENT);
 217         }
 218
 219         // Do we have read access to the file?
 220         FILE *f;
 221         if((f = std::fopen(path.c_str(), "r+")) != NULL)
 222         {
 223                 fclose(f);
 224                 return new FileInfo(path, 0);
 225         }
 226         else
 227         {
 228                 return new FileInfo(path, errno);
 229         }
 230 }
 231
 232
 233
 234 //
 235 // Class DirectoryInfo
 236 //
 237 DirectoryInfo::DirectoryInfo(std::string path)
 238         : path(path)
 239 { }
 240
 241
 242
 243 //
 244 // Class FileInfo
 245 //
 246 FileInfo::FileInfo(std::string path, int error)
 247         : path(path), error(error)
 248 { }
 249
 250 bool
 251 FileInfo::exists()
 252 {
 253         return this->error != ENOENT;
 254 }
 255