gemrb/core/VFS.cpp

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2003 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 // VFS.cpp : functions to access filesystem in os-independent way
  22 // and POSIX-like compatibility layer for win
  23
  24 #include "VFS.h"
  25
  26 #include "globals.h"
  27
  28 #include "Interface.h"
  29
  30 #include <cstdarg>
  31 #include <cstring>
  32 #include <sys/stat.h>
  33
  34 #ifdef WIN32
  35
  36 // buffer which readdir returns
  37 static dirent de;
  38
  39
  40 DIR* opendir(const char* filename)
  41 {
  42         DIR* dirp = ( DIR* ) malloc( sizeof( DIR ) );
  43         dirp->is_first = 1;
  44
  45         sprintf( dirp->path, "%s%s*.*", filename, SPathDelimiter );
  46         //if((hFile = (long)_findfirst(Path, &c_file)) == -1L) //If there is no file matching our search
  47
  48         return dirp;
  49 }
  50
  51 dirent* readdir(DIR* dirp)
  52 {
  53         struct _finddata_t c_file;
  54
  55         if (dirp->is_first) {
  56                 dirp->is_first = 0;
  57                 dirp->hFile = ( long ) _findfirst( dirp->path, &c_file );
  58                 if (dirp->hFile == -1L)
  59                         return NULL;
  60         } else {
  61                 if (( long ) _findnext( dirp->hFile, &c_file ) != 0) {
  62                         return NULL;
  63                 }
  64         }
  65
  66         strcpy( de.d_name, c_file.name );
  67
  68         return &de;
  69 }
  70
  71 void closedir(DIR* dirp)
  72 {
  73         _findclose( dirp->hFile );
  74         free( dirp );
  75 }
  76
  77
  78 _FILE* _fopen(const char* filename, const char* mode)
  79 {
  80         DWORD OpenFlags = 0;
  81         DWORD AccessFlags = 0;
  82         DWORD ShareFlags = 0;
  83
  84         while (*mode) {
  85                 if (( *mode == 'w' ) || ( *mode == 'W' )) {
  86                         OpenFlags |= OPEN_ALWAYS;
  87                         AccessFlags |= GENERIC_WRITE;
  88                         ShareFlags |= FILE_SHARE_READ;
  89                 } else if (( *mode == 'r' ) || ( *mode == 'R' )) {
  90                         OpenFlags |= OPEN_EXISTING;
  91                         AccessFlags |= GENERIC_READ;
  92                         ShareFlags |= FILE_SHARE_READ|FILE_SHARE_WRITE;
  93                 } else if (( *mode == 'a' ) || ( *mode == 'A' )) {
  94                         OpenFlags |= OPEN_ALWAYS;
  95                         AccessFlags |= GENERIC_READ|GENERIC_WRITE;
  96                         ShareFlags |= FILE_SHARE_READ|FILE_SHARE_WRITE;
  97                 } else if (*mode == '+') {
  98                         AccessFlags |= GENERIC_READ|GENERIC_WRITE;
  99                         ShareFlags |= FILE_SHARE_READ|FILE_SHARE_WRITE;
 100                 }
 101                 mode++;
 102         }
 103         HANDLE hFile = CreateFile( filename, AccessFlags, ShareFlags, NULL,
 104                                         OpenFlags, FILE_ATTRIBUTE_NORMAL, NULL );
 105         if (hFile == INVALID_HANDLE_VALUE) {
 106                 return NULL;
 107         }
 108         _FILE* ret = ( _FILE* ) malloc( sizeof( _FILE ) );
 109         ret->hFile = hFile;
 110         return ret;
 111 }
 112
 113 size_t _fread(void* ptr, size_t size, size_t n, _FILE* stream)
 114 {
 115         if (!stream) {
 116                 return ( size_t ) 0;
 117         }
 118         unsigned long read;
 119         if (!ReadFile( stream->hFile, ptr, ( unsigned long ) ( size * n ), &read,
 120                         NULL )) {
 121                 return ( size_t ) 0;
 122         }
 123         return ( size_t ) read;
 124 }
 125
 126 size_t _fwrite(const void* ptr, size_t size, size_t n, _FILE* stream)
 127 {
 128         if (!stream) {
 129                 return ( size_t ) 0;
 130         }
 131         unsigned long wrote;
 132         if (!WriteFile( stream->hFile, ptr, ( unsigned long ) ( size * n ),
 133                         &wrote, NULL )) {
 134                 return ( size_t ) 0;
 135         }
 136         return ( size_t ) wrote;
 137 }
 138
 139 size_t _fseek(_FILE* stream, long offset, int whence)
 140 {
 141         if (!stream) {
 142                 return ( size_t ) 1;
 143         }
 144         unsigned long method;
 145         switch (whence) {
 146                 case SEEK_SET:
 147                         method = FILE_BEGIN;
 148                         break;
 149                 case SEEK_CUR:
 150                         method = FILE_CURRENT;
 151                         break;
 152                 case SEEK_END:
 153                         method = FILE_END;
 154                         break;
 155                 default:
 156                         return ( size_t ) 1;
 157         }
 158         if (SetFilePointer( stream->hFile, offset, NULL, method ) == 0xffffffff) {
 159                 return ( size_t ) 1;
 160         }
 161         return ( size_t ) 0;
 162 }
 163
 164 int _fgetc(_FILE* stream)
 165 {
 166         if (!stream) {
 167                 return 0;
 168         }
 169         unsigned char tmp;
 170         unsigned long read;
 171         BOOL bResult = ReadFile( stream->hFile, &tmp, ( unsigned long ) 1, &read,
 172                                         NULL );
 173         if (bResult && read) {
 174                 return ( int ) tmp;
 175         }
 176         return EOF;
 177 }
 178
 179 long int _ftell(_FILE* stream)
 180 {
 181         if (!stream) {
 182                 return EOF;
 183         }
 184         unsigned long pos = SetFilePointer( stream->hFile, 0, NULL, FILE_CURRENT );
 185         if (pos == 0xffffffff) {
 186                 return -1L;
 187         }
 188         return ( long int ) pos;
 189 }
 190
 191 int _feof(_FILE* stream)
 192 {
 193         if (!stream) {
 194                 return 0;
 195         }
 196         unsigned char tmp;
 197         unsigned long read;
 198         BOOL bResult = ReadFile( stream->hFile, &tmp, ( unsigned long ) 1, &read,
 199                                         NULL );
 200         if (bResult && ( read == 0 )) {
 201                 return 1;
 202         } //EOF
 203         bResult = SetFilePointer( stream->hFile, -1, NULL, FILE_CURRENT );
 204         return 0;
 205 }
 206
 207 int _fclose(_FILE* stream)
 208 {
 209         if (!stream) {
 210                 return EOF;
 211         }
 212         if (!CloseHandle( stream->hFile )) {
 213                 return EOF;
 214         }
 215         free( stream );
 216         return 0;
 217 }
 218
 219 #endif // WIN32
 220
 221
 222 /** Returns true if path is an existing directory */
 223 bool dir_exists(const char* path)
 224 {
 225         struct stat buf;
 226
 227         buf.st_mode = 0;
 228         stat( path, &buf );
 229         return S_ISDIR( buf.st_mode ) != 0;
 230 }
 231
 232
 233
 234 /**
 235  * Appends dir 'dir' to path 'target' and returns 'target'.
 236  * It takes care of inserting PathDelimiter ('/' or '\\') if needed
 237  */
 238 char* PathAppend (char* target, const char* dir)
 239 {
 240         if (target[0] != 0 && target[strlen( target ) - 1] != PathDelimiter)
 241                 strncat( target, SPathDelimiter, _MAX_PATH );
 242         strncat( target, dir, _MAX_PATH );
 243
 244         return target;
 245 }
 246
 247
 248 bool FindInDir(const char* Dir, char *Filename)
 249 {
 250         // First test if there's a Filename with exactly same name
 251         // and if yes, return it and do not search in the Dir
 252         char TempFilePath[_MAX_PATH];
 253         strcpy(TempFilePath, Dir);
 254         PathAppend( TempFilePath, Filename );
 255
 256         if (!access( TempFilePath, R_OK )) {
 257                 return true;
 258         }
 259
 260         if (!core->CaseSensitive) {
 261                 return false;
 262         }
 263
 264         DIR* dir = opendir( Dir );
 265         if (dir == NULL) {
 266                 return false;
 267         }
 268
 269         // Exact match not found, so try to search for Filename
 270         // with different case
 271         struct dirent* de = readdir( dir );
 272         if (de == NULL) {
 273                 closedir( dir );
 274                 return false;
 275         }
 276         do {
 277                 if (stricmp( de->d_name, Filename ) == 0) {
 278                         strcpy( Filename, de->d_name );
 279                         closedir(dir);
 280                         return true;
 281                 }
 282         } while (( de = readdir( dir ) ) != NULL);
 283         closedir( dir ); //No other files in the directory, close it
 284         return false;
 285 }
 286
 287 bool PathJoin (char *target, const char *base, ...)
 288 {
 289         va_list ap;
 290         va_start(ap, base);
 291
 292         if (base == NULL) {
 293                 target[0] = '\0';
 294                 return false;
 295         }
 296
 297         strcpy(target, base);
 298
 299         while (char *source = va_arg(ap, char*)) {
 300                 char *slash;
 301                 do {
 302                         char filename[_MAX_PATH] = { '\0' };
 303                         slash = strchr(source, PathDelimiter);
 304                         if (slash == source) {
 305                                 ++source;
 306                                 continue;
 307                         } else if (slash) {
 308                                 strncat(filename, source, slash-source);
 309                         } else {
 310                                 strcpy(filename, source);
 311                         }
 312                         if (!FindInDir(target, filename)) {
 313                                 PathAppend(target, source);
 314                                 goto finish;
 315                         }
 316                         PathAppend(target, filename);
 317                         source = slash + 1;
 318                 } while (slash);
 319         }
 320         va_end( ap );
 321         return true;
 322 finish:
 323         while (char *source = va_arg(ap, char*)) {
 324                 PathAppend(target, source);
 325         }
 326         va_end( ap );
 327         return false;
 328 }
 329
 330 bool PathJoinExt (char* target, const char* dir, const char* base, const char* ext)
 331 {
 332         char file[_MAX_PATH];
 333         strcpy(file, base);
 334         strcat(file, ".");
 335         strcat(file, ext);
 336         return PathJoin(target, dir, file, NULL);
 337 }
 338
 339 /** Fixes path delimiter character (slash).
 340  * needslash = true : we add a slash
 341  * needslash = false: we remove the slash
 342  */
 343 void FixPath (char *path, bool needslash)
 344 {
 345         size_t i = strlen( path ) - 1;
 346
 347         if (needslash) {
 348                 if (path[i] == PathDelimiter) return;
 349
 350                 // if path is already too long, don't do anything
 351                 if (i >= _MAX_PATH - 2) return;
 352                 i++;
 353                 path[i++] = PathDelimiter;
 354         }
 355         else {
 356                 if (path[i] != PathDelimiter) return;
 357         }
 358         path[i] = 0;
 359 }
 360
 361 int strmatch(const char *string, const char *mask)
 362 {
 363         while(*mask) {
 364                 if (*mask!='?') {
 365                         if (tolower(*mask)!=tolower(*string)) {
 366                                 return 1;
 367                         }
 368                 }
 369                 mask++;
 370                 string++;
 371         }
 372         return 0;
 373 }
 374
 375 bool FileGlob(char* target, const char* Dir, const char *glob)
 376 {
 377         DIR* dir = opendir( Dir );
 378         if (dir == NULL) {
 379                 return false;
 380         }
 381
 382         struct dirent* de = readdir( dir );
 383         if (de == NULL) {
 384                 closedir( dir );
 385                 return false;
 386         }
 387         do {
 388                 if (strmatch( de->d_name, glob ) == 0) {
 389                         strcpy( target, de->d_name );
 390                         closedir(dir);
 391                         return true;
 392                 }
 393         } while (( de = readdir( dir ) ) != NULL);
 394         closedir( dir ); //No other files in the directory, close it
 395         return false;
 396 }
 397
 398
 399 #ifndef WIN32
 400
 401 void ResolveFilePath(char* FilePath)
 402 {
 403         char TempFilePath[_MAX_PATH];
 404
 405         if (FilePath[0]=='~') {
 406                 const char *home = getenv("HOME");
 407                 if (home) {
 408                         strcpy(TempFilePath, FilePath+1);
 409                         PathJoin(FilePath, home, TempFilePath, NULL);
 410                         return;
 411                 }
 412         }
 413
 414         if (core && !core->CaseSensitive) {
 415                 return;
 416         }
 417         strcpy(TempFilePath, FilePath);
 418         PathJoin(FilePath, TempFilePath[0]==PathDelimiter?SPathDelimiter:"", TempFilePath, NULL);
 419 }
 420
 421 #endif
 422
 423 void ExtractFileFromPath(char *file, const char *full_path)
 424 {
 425         const char *p;
 426         if ((p = strrchr (full_path, PathDelimiter)))
 427                 strcpy(file, p+1);
 428         else if ((p = strchr (full_path, ':')))
 429                 strcpy(file, p+1);
 430         else
 431                 strcpy(file, full_path);
 432 }