fios.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "3rdparty/md5/md5.h"
#include "fileio_func.h"
#include "fios.h"
#include "network/network_content.h"
#include "screenshot.h"
#include "string_func.h"
#include "tar_type.h"
#include <sys/stat.h>
#include <functional>
#include <optional>
 
#ifndef _WIN32
# include <unistd.h>
#endif /* _WIN32 */
 
#include "table/strings.h"
 
#include "safeguards.h"
 
/* Variables to display file lists */
static std::string *_fios_path = nullptr;
SortingBits _savegame_sort_order = SORT_BY_DATE | SORT_DESCENDING;
 
/* OS-specific functions are taken from their respective files (win32/unix/os2 .c) */
extern bool FiosIsRoot(const char *path);
extern bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb);
extern bool FiosIsHiddenFile(const struct dirent *ent);
extern void FiosGetDrives(FileList &file_list);
extern bool FiosGetDiskFreeSpace(const char *path, uint64 *tot);
 
/* get the name of an oldstyle savegame */
extern void GetOldSaveGameName(const std::string &file, char *title, const char *last);
 
bool FiosItem::operator< (const FiosItem &other) const
{
  int r = false;
 
  if ((_savegame_sort_order & SORT_BY_NAME) == 0 && (*this).mtime != other.mtime) {
    r = (*this).mtime - other.mtime;
  } else {
    r = strnatcmp((*this).title, other.title);
  }
  if (r == 0) return false;
  return (_savegame_sort_order & SORT_DESCENDING) ? r > 0 : r < 0;
}
 
FileList::~FileList()
{
  this->Clear();
}
 
void FileList::BuildFileList(AbstractFileType abstract_filetype, SaveLoadOperation fop)
{
  this->Clear();
 
  assert(fop == SLO_LOAD || fop == SLO_SAVE);
  switch (abstract_filetype) {
    case FT_NONE:
      break;
 
    case FT_SAVEGAME:
      FiosGetSavegameList(fop, *this);
      break;
 
    case FT_SCENARIO:
      FiosGetScenarioList(fop, *this);
      break;
 
    case FT_HEIGHTMAP:
      FiosGetHeightmapList(fop, *this);
      break;
 
    default:
      NOT_REACHED();
  }
}
 
const FiosItem *FileList::FindItem(const char *file)
{
  for (const FiosItem *item = this->Begin(); item != this->End(); item++) {
    if (strcmp(file, item->name) == 0) return item;
    if (strcmp(file, item->title) == 0) return item;
  }
 
  /* If no name matches, try to parse it as number */
  char *endptr;
  int i = strtol(file, &endptr, 10);
  if (file == endptr || *endptr != '\0') i = -1;
 
  if (IsInsideMM(i, 0, this->Length())) return this->Get(i);
 
  /* As a last effort assume it is an OpenTTD savegame and
   * that the ".sav" part was not given. */
  char long_file[MAX_PATH];
  seprintf(long_file, lastof(long_file), "%s.sav", file);
  for (const FiosItem *item = this->Begin(); item != this->End(); item++) {
    if (strcmp(long_file, item->name) == 0) return item;
    if (strcmp(long_file, item->title) == 0) return item;
  }
 
  return nullptr;
}
 
StringID FiosGetDescText(const char **path, uint64 *total_free)
{
  *path = _fios_path->c_str();
  return FiosGetDiskFreeSpace(*path, total_free) ? STR_SAVELOAD_BYTES_FREE : STR_ERROR_UNABLE_TO_READ_DRIVE;
}
 
const char *FiosBrowseTo(const FiosItem *item)
{
  switch (item->type) {
    case FIOS_TYPE_DRIVE:
#if defined(_WIN32) || defined(__OS2__)
      assert(_fios_path != nullptr);
      *_fios_path = std::string{ item->title[0] } + ":" PATHSEP;
#endif
      break;
 
    case FIOS_TYPE_INVALID:
      break;
 
    case FIOS_TYPE_PARENT: {
      assert(_fios_path != nullptr);
      auto s = _fios_path->find_last_of(PATHSEPCHAR);
      if (s != std::string::npos && s != 0) {
        _fios_path->erase(s); // Remove last path separator character, so we can go up one level.
      }
 
      s = _fios_path->find_last_of(PATHSEPCHAR);
      if (s != std::string::npos) {
        _fios_path->erase(s + 1); // go up a directory
      }
      break;
    }
 
    case FIOS_TYPE_DIR:
      assert(_fios_path != nullptr);
      *_fios_path += item->name;
      *_fios_path += PATHSEP;
      break;
 
    case FIOS_TYPE_DIRECT:
      assert(_fios_path != nullptr);
      *_fios_path = item->name;
      break;
 
    case FIOS_TYPE_FILE:
    case FIOS_TYPE_OLDFILE:
    case FIOS_TYPE_SCENARIO:
    case FIOS_TYPE_OLD_SCENARIO:
    case FIOS_TYPE_PNG:
    case FIOS_TYPE_BMP:
      return item->name;
  }
 
  return nullptr;
}
 
static std::string FiosMakeFilename(const std::string *path, const char *name, const char *ext)
{
  std::string buf;
 
  if (path != nullptr) {
    buf = *path;
    /* Remove trailing path separator, if present */
    if (!buf.empty() && buf.back() == PATHSEPCHAR) buf.pop_back();
  }
 
  /* Don't append the extension if it is already there */
  const char *period = strrchr(name, '.');
  if (period != nullptr && strcasecmp(period, ext) == 0) ext = "";
 
  return buf + PATHSEP + name + ext;
}
 
std::string FiosMakeSavegameName(const char *name)
{
  const char *extension = (_game_mode == GM_EDITOR) ? ".scn" : ".sav";
 
  return FiosMakeFilename(_fios_path, name, extension);
}
 
std::string FiosMakeHeightmapName(const char *name)
{
  std::string ext(".");
  ext += GetCurrentScreenshotExtension();
 
  return FiosMakeFilename(_fios_path, name, ext.c_str());
}
 
bool FiosDelete(const char *name)
{
  std::string filename = FiosMakeSavegameName(name);
  return unlink(filename.c_str()) == 0;
}
 
typedef FiosType fios_getlist_callback_proc(SaveLoadOperation fop, const std::string &filename, const char *ext, char *title, const char *last);
 
class FiosFileScanner : public FileScanner {
  SaveLoadOperation fop;   
  fios_getlist_callback_proc *callback_proc; 
  FileList &file_list;     
public:
  FiosFileScanner(SaveLoadOperation fop, fios_getlist_callback_proc *callback_proc, FileList &file_list) :
      fop(fop), callback_proc(callback_proc), file_list(file_list)
  {}
 
  bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename) override;
};
 
bool FiosFileScanner::AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename)
{
  auto sep = filename.rfind('.');
  if (sep == std::string::npos) return false;
  std::string ext = filename.substr(sep);
 
  char fios_title[64];
  fios_title[0] = '\0'; // reset the title;
 
  FiosType type = this->callback_proc(this->fop, filename, ext.c_str(), fios_title, lastof(fios_title));
  if (type == FIOS_TYPE_INVALID) return false;
 
  for (const FiosItem *fios = file_list.Begin(); fios != file_list.End(); fios++) {
    if (filename == fios->name) return false;
  }
 
  FiosItem *fios = file_list.Append();
#ifdef _WIN32
  // Retrieve the file modified date using GetFileTime rather than stat to work around an obscure MSVC bug that affects Windows XP
  HANDLE fh = CreateFile(OTTD2FS(filename.c_str()), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, 0, nullptr);
 
  if (fh != INVALID_HANDLE_VALUE) {
    FILETIME ft;
    ULARGE_INTEGER ft_int64;
 
    if (GetFileTime(fh, nullptr, nullptr, &ft) != 0) {
      ft_int64.HighPart = ft.dwHighDateTime;
      ft_int64.LowPart = ft.dwLowDateTime;
 
      // Convert from hectonanoseconds since 01/01/1601 to seconds since 01/01/1970
      fios->mtime = ft_int64.QuadPart / 10000000ULL - 11644473600ULL;
    } else {
      fios->mtime = 0;
    }
 
    CloseHandle(fh);
#else
  struct stat sb;
  if (stat(filename.c_str(), &sb) == 0) {
    fios->mtime = sb.st_mtime;
#endif
  } else {
    fios->mtime = 0;
  }
 
  fios->type = type;
  strecpy(fios->name, filename.c_str(), lastof(fios->name));
 
  /* If the file doesn't have a title, use its filename */
  const char *t = fios_title;
  if (StrEmpty(fios_title)) {
    auto ps = filename.rfind(PATHSEPCHAR);
    t = filename.c_str() + (ps == std::string::npos ? 0 : ps + 1);
  }
  strecpy(fios->title, t, lastof(fios->title));
  str_validate(fios->title, lastof(fios->title));
 
  return true;
}
 
 
static void FiosGetFileList(SaveLoadOperation fop, fios_getlist_callback_proc *callback_proc, Subdirectory subdir, FileList &file_list)
{
  struct stat sb;
  struct dirent *dirent;
  DIR *dir;
  FiosItem *fios;
  size_t sort_start;
  char d_name[sizeof(fios->name)];
 
  file_list.Clear();
 
  assert(_fios_path != nullptr);
 
  /* A parent directory link exists if we are not in the root directory */
  if (!FiosIsRoot(_fios_path->c_str())) {
    fios = file_list.Append();
    fios->type = FIOS_TYPE_PARENT;
    fios->mtime = 0;
    strecpy(fios->name, "..", lastof(fios->name));
    strecpy(fios->title, ".. (Parent directory)", lastof(fios->title));
  }
 
  /* Show subdirectories */
  if ((dir = ttd_opendir(_fios_path->c_str())) != nullptr) {
    while ((dirent = readdir(dir)) != nullptr) {
      strecpy(d_name, FS2OTTD(dirent->d_name), lastof(d_name));
 
      /* found file must be directory, but not '.' or '..' */
      if (FiosIsValidFile(_fios_path->c_str(), dirent, &sb) && S_ISDIR(sb.st_mode) &&
          (!FiosIsHiddenFile(dirent) || strncasecmp(d_name, PERSONAL_DIR, strlen(d_name)) == 0) &&
          strcmp(d_name, ".") != 0 && strcmp(d_name, "..") != 0) {
        fios = file_list.Append();
        fios->type = FIOS_TYPE_DIR;
        fios->mtime = 0;
        strecpy(fios->name, d_name, lastof(fios->name));
        seprintf(fios->title, lastof(fios->title), "%s" PATHSEP " (Directory)", d_name);
        str_validate(fios->title, lastof(fios->title));
      }
    }
    closedir(dir);
  }
 
  /* Sort the subdirs always by name, ascending, remember user-sorting order */
  {
    SortingBits order = _savegame_sort_order;
    _savegame_sort_order = SORT_BY_NAME | SORT_ASCENDING;
    std::sort(file_list.files.begin(), file_list.files.end());
    _savegame_sort_order = order;
  }
 
  /* This is where to start sorting for the filenames */
  sort_start = file_list.Length();
 
  /* Show files */
  FiosFileScanner scanner(fop, callback_proc, file_list);
  if (subdir == NO_DIRECTORY) {
    scanner.Scan(nullptr, _fios_path->c_str(), false);
  } else {
    scanner.Scan(nullptr, subdir, true, true);
  }
 
  std::sort(file_list.files.begin() + sort_start, file_list.files.end());
 
  /* Show drives */
  FiosGetDrives(file_list);
 
  file_list.Compact();
}
 
static void GetFileTitle(const std::string &file, char *title, const char *last, Subdirectory subdir)
{
  std::string buf = file;
  buf += ".title";
 
  FILE *f = FioFOpenFile(buf, "r", subdir);
  if (f == nullptr) return;
 
  size_t read = fread(title, 1, last - title, f);
  assert(title + read <= last);
  title[read] = '\0';
  str_validate(title, last);
  FioFCloseFile(f);
}
 
FiosType FiosGetSavegameListCallback(SaveLoadOperation fop, const std::string &file, const char *ext, char *title, const char *last)
{
  /* Show savegame files
   * .SAV OpenTTD saved game
   * .SS1 Transport Tycoon Deluxe preset game
   * .SV1 Transport Tycoon Deluxe (Patch) saved game
   * .SV2 Transport Tycoon Deluxe (Patch) saved 2-player game */
 
  /* Don't crash if we supply no extension */
  if (ext == nullptr) return FIOS_TYPE_INVALID;
 
  if (strcasecmp(ext, ".sav") == 0) {
    GetFileTitle(file, title, last, SAVE_DIR);
    return FIOS_TYPE_FILE;
  }
 
  if (fop == SLO_LOAD) {
    if (strcasecmp(ext, ".ss1") == 0 || strcasecmp(ext, ".sv1") == 0 ||
        strcasecmp(ext, ".sv2") == 0) {
      if (title != nullptr) GetOldSaveGameName(file, title, last);
      return FIOS_TYPE_OLDFILE;
    }
  }
 
  return FIOS_TYPE_INVALID;
}
 
void FiosGetSavegameList(SaveLoadOperation fop, FileList &file_list)
{
  static std::optional<std::string> fios_save_path;
 
  if (!fios_save_path) fios_save_path = FioFindDirectory(SAVE_DIR);
 
  _fios_path = &(*fios_save_path);
 
  FiosGetFileList(fop, &FiosGetSavegameListCallback, NO_DIRECTORY, file_list);
}
 
static FiosType FiosGetScenarioListCallback(SaveLoadOperation fop, const std::string &file, const char *ext, char *title, const char *last)
{
  /* Show scenario files
   * .SCN OpenTTD style scenario file
   * .SV0 Transport Tycoon Deluxe (Patch) scenario
   * .SS0 Transport Tycoon Deluxe preset scenario */
  if (strcasecmp(ext, ".scn") == 0) {
    GetFileTitle(file, title, last, SCENARIO_DIR);
    return FIOS_TYPE_SCENARIO;
  }
 
  if (fop == SLO_LOAD) {
    if (strcasecmp(ext, ".sv0") == 0 || strcasecmp(ext, ".ss0") == 0 ) {
      GetOldSaveGameName(file, title, last);
      return FIOS_TYPE_OLD_SCENARIO;
    }
  }
 
  return FIOS_TYPE_INVALID;
}
 
void FiosGetScenarioList(SaveLoadOperation fop, FileList &file_list)
{
  static std::optional<std::string> fios_scn_path;
 
  /* Copy the default path on first run or on 'New Game' */
  if (!fios_scn_path) fios_scn_path = FioFindDirectory(SCENARIO_DIR);
 
  _fios_path = &(*fios_scn_path);
 
  std::string base_path = FioFindDirectory(SCENARIO_DIR);
  Subdirectory subdir = (fop == SLO_LOAD && base_path == *_fios_path) ? SCENARIO_DIR : NO_DIRECTORY;
  FiosGetFileList(fop, &FiosGetScenarioListCallback, subdir, file_list);
}
 
static FiosType FiosGetHeightmapListCallback(SaveLoadOperation fop, const std::string &file, const char *ext, char *title, const char *last)
{
  /* Show heightmap files
   * .PNG PNG Based heightmap files
   * .BMP BMP Based heightmap files
   */
 
  FiosType type = FIOS_TYPE_INVALID;
 
#ifdef WITH_PNG
  if (strcasecmp(ext, ".png") == 0) type = FIOS_TYPE_PNG;
#endif /* WITH_PNG */
 
  if (strcasecmp(ext, ".bmp") == 0) type = FIOS_TYPE_BMP;
 
  if (type == FIOS_TYPE_INVALID) return FIOS_TYPE_INVALID;
 
  TarFileList::iterator it = _tar_filelist[SCENARIO_DIR].find(file);
  if (it != _tar_filelist[SCENARIO_DIR].end()) {
    /* If the file is in a tar and that tar is not in a heightmap
     * directory we are for sure not supposed to see it.
     * Examples of this are pngs part of documentation within
     * collections of NewGRFs or 32 bpp graphics replacement PNGs.
     */
    bool match = false;
    Searchpath sp;
    FOR_ALL_SEARCHPATHS(sp) {
      std::string buf = FioGetDirectory(sp, HEIGHTMAP_DIR);
 
      if (buf.compare(0, buf.size(), it->second.tar_filename, 0, buf.size()) == 0) {
        match = true;
        break;
      }
    }
 
    if (!match) return FIOS_TYPE_INVALID;
  }
 
  GetFileTitle(file, title, last, HEIGHTMAP_DIR);
 
  return type;
}
 
void FiosGetHeightmapList(SaveLoadOperation fop, FileList &file_list)
{
  static std::optional<std::string> fios_hmap_path;
 
  if (!fios_hmap_path) fios_hmap_path = FioFindDirectory(HEIGHTMAP_DIR);
 
  _fios_path = &(*fios_hmap_path);
 
  std::string base_path = FioFindDirectory(HEIGHTMAP_DIR);
  Subdirectory subdir = base_path == *_fios_path ? HEIGHTMAP_DIR : NO_DIRECTORY;
  FiosGetFileList(fop, &FiosGetHeightmapListCallback, subdir, file_list);
}
 
const char *FiosGetScreenshotDir()
{
  static std::optional<std::string> fios_screenshot_path;
 
  if (!fios_screenshot_path) fios_screenshot_path = FioFindDirectory(SCREENSHOT_DIR);
 
  return fios_screenshot_path->c_str();
}
 
struct ScenarioIdentifier {
  uint32 scenid;           
  uint8 md5sum[16];        
  char filename[MAX_PATH]; 
 
  bool operator == (const ScenarioIdentifier &other) const
  {
    return this->scenid == other.scenid &&
        memcmp(this->md5sum, other.md5sum, sizeof(this->md5sum)) == 0;
  }
 
  bool operator != (const ScenarioIdentifier &other) const
  {
    return !(*this == other);
  }
};
 
class ScenarioScanner : protected FileScanner, public std::vector<ScenarioIdentifier> {
  bool scanned; 
public:
  ScenarioScanner() : scanned(false) {}
 
  void Scan(bool rescan)
  {
    if (this->scanned && !rescan) return;
 
    this->FileScanner::Scan(".id", SCENARIO_DIR, true, true);
    this->scanned = true;
  }
 
  bool AddFile(const std::string &filename, size_t basepath_length, const std::string &tar_filename) override
  {
    FILE *f = FioFOpenFile(filename, "r", SCENARIO_DIR);
    if (f == nullptr) return false;
 
    ScenarioIdentifier id;
    int fret = fscanf(f, "%u", &id.scenid);
    FioFCloseFile(f);
    if (fret != 1) return false;
    strecpy(id.filename, filename.c_str(), lastof(id.filename));
 
    Md5 checksum;
    uint8 buffer[1024];
    size_t len, size;
 
    /* open the scenario file, but first get the name.
     * This is safe as we check on extension which
     * must always exist. */
    f = FioFOpenFile(filename.substr(0, filename.rfind('.')), "rb", SCENARIO_DIR, &size);
    if (f == nullptr) return false;
 
    /* calculate md5sum */
    while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
      size -= len;
      checksum.Append(buffer, len);
    }
    checksum.Finish(id.md5sum);
 
    FioFCloseFile(f);
 
    include(*this, id);
    return true;
  }
};
 
static ScenarioScanner _scanner;
 
const char *FindScenario(const ContentInfo *ci, bool md5sum)
{
  _scanner.Scan(false);
 
  for (ScenarioIdentifier &id : _scanner) {
    if (md5sum ? (memcmp(id.md5sum, ci->md5sum, sizeof(id.md5sum)) == 0)
               : (id.scenid == ci->unique_id)) {
      return id.filename;
    }
  }
 
  return nullptr;
}
 
bool HasScenario(const ContentInfo *ci, bool md5sum)
{
  return (FindScenario(ci, md5sum) != nullptr);
}
 
void ScanScenarios()
{
  _scanner.Scan(true);
}