fileutils.cc

Go to the documentation of this file.

#include "ion/port/fileutils.h"

#if defined(ION_PLATFORM_IOS)
#include <Foundation/Foundation.h>
#endif
#if defined(ION_PLATFORM_WINDOWS)
#include <windows.h>
#else
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cstdlib>
#endif

#include <cassert>

#include "base/integral_types.h"
#include "ion/port/string.h"

namespace ion {
namespace port {

std::string GetCanonicalFilePath(const std::string& path) {
#if defined(ION_PLATFORM_WINDOWS)
  std::string canonical_path = path;
  const size_t length = canonical_path.length();
  for (size_t i = 0; i < length; ++i)
    if (canonical_path[i] == '\\')
      canonical_path[i] = '/';
  return canonical_path;

#else
  return path;
#endif
}

std::string GetCurrentWorkingDirectory() {
#if defined(ION_PLATFORM_WINDOWS)
  WCHAR pwd[MAX_PATH] = L"";
  const int result = ::GetCurrentDirectoryW(MAX_PATH, pwd);
  assert(0 < result && result < ARRAYSIZE(pwd));
  (void) result;  // for opt builds that elide the assert
  return GetCanonicalFilePath(WideToUtf8(pwd));
#else
  static const int kExpectedPathLength = 2048;
  std::vector<char> path(kExpectedPathLength);
  while (!getcwd(&path[0], static_cast<int>(path.size()))) {
    path.resize(path.size() * 2);
  }
  return &path[0];
#endif
}

bool GetFileModificationTime(const std::string& path,
                             std::chrono::system_clock::time_point* time) {
#if defined(ION_PLATFORM_WINDOWS)
  static const int64 kEpochOffset = 116444736000000000ULL;

  bool retval = false;
  const std::wstring wide = Utf8ToWide(path);
  HANDLE handle = ::CreateFileW(wide.c_str(), GENERIC_READ,
                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                OPEN_EXISTING, 0, NULL);
  FILETIME create_time, access_time, write_time;
  if (handle != INVALID_HANDLE_VALUE) {
    if (GetFileTime(handle, &create_time, &access_time, &write_time)) {
      const std::chrono::duration<int64, std::ratio<1, 10000000>> file_duration(
          (static_cast<int64>(write_time.dwHighDateTime) << 32) +
          write_time.dwLowDateTime - kEpochOffset);
      *time = std::chrono::system_clock::time_point(file_duration);
      retval = true;
    }
    CloseHandle(handle);
  }
  return retval;

#else
  struct stat info;
#  if defined(ION_PLATFORM_IOS) || defined(ION_PLATFORM_MAC)
#    define ION_STAT_SECONDS static_cast<uint64>(info.st_mtimespec.tv_sec)
#    define ION_STAT_NSECONDS static_cast<uint64>(info.st_mtimespec.tv_nsec)
#  elif defined(ION_PLATFORM_ANDROID) || defined(ION_PLATFORM_GENERIC_ARM)
#    define ION_STAT_SECONDS static_cast<uint64>(info.st_mtime)
#    define ION_STAT_NSECONDS static_cast<uint64>(info.st_mtime_nsec)
#  elif defined(ION_PLATFORM_ASMJS) || defined(ION_PLATFORM_QNX) || \
        defined(ION_PLATFORM_NACL)
#    define ION_STAT_SECONDS static_cast<uint64>(info.st_mtime)
#    define ION_STAT_NSECONDS 0
#  elif defined(ION_PLATFORM_LINUX)
#    define ION_STAT_SECONDS static_cast<uint64>(info.st_mtim.tv_sec)
#    define ION_STAT_NSECONDS static_cast<uint64>(info.st_mtim.tv_nsec)
#  else
#    error No valid platform defined!
#  endif

  if (!stat(path.c_str(), &info)) {
    *time = std::chrono::system_clock::time_point(
        std::chrono::duration_cast<std::chrono::system_clock::duration>(
            std::chrono::seconds(ION_STAT_SECONDS) +
            std::chrono::nanoseconds(ION_STAT_NSECONDS)));
    return true;
  }
  return false;

# undef ION_STAT_SECONDS
# undef ION_STAT_NSECONDS
#endif
}

std::string GetTemporaryDirectory() {
#if defined(ION_PLATFORM_ANDROID)
  return std::string("/data/local/tmp");
#elif defined(ION_PLATFORM_IOS)
  return std::string([NSTemporaryDirectory() fileSystemRepresentation]);
#elif defined(ION_PLATFORM_WINDOWS)
  WCHAR temp_path[MAX_PATH] = L"";
  int size = ::GetTempPathW(MAX_PATH, temp_path);
  assert(0 < size && size < ARRAYSIZE(temp_path));
  if (size > 0 && temp_path[size - 1] == L'\\') {
    temp_path[size - 1] = L'\0';
  }
  return GetCanonicalFilePath(WideToUtf8(temp_path));
#else
  return std::string("/tmp");
#endif
}

std::string GetTemporaryFilename() {
  std::string return_path;
#if defined(ION_PLATFORM_WINDOWS)
  WCHAR temp_path[MAX_PATH] = L"";
  int size = ::GetTempPathW(MAX_PATH, temp_path);
  assert(0 < size && size < ARRAYSIZE(temp_path));
  (void) size;
  WCHAR wide_path[MAX_PATH] = L"";
  const UINT unique = ::GetTempFileNameW(temp_path, L"ion", 0, wide_path);
  assert(unique != 0);
  (void) unique;
  return_path = GetCanonicalFilePath(WideToUtf8(wide_path));
#elif !defined(ION_PLATFORM_NACL)
  std::string path = GetTemporaryDirectory() + "/ionXXXXXX";
  const int fd = mkstemp(&path[0]);
  if (fd != -1) {
    close(fd);
    return_path = path;
  }
#endif
  return return_path;
}

FILE* OpenFile(const std::string& path, const std::string& mode) {
  const std::string canonical_path = GetCanonicalFilePath(path);
#if defined(ION_PLATFORM_WINDOWS)
  const std::wstring wide_path = Utf8ToWide(canonical_path);
  const std::wstring wide_mode = Utf8ToWide(mode);
  return _wfopen(wide_path.c_str(), wide_mode.c_str());
#else
  return fopen(path.c_str(), mode.c_str());
#endif
}

bool ReadDataFromFile(const std::string& path, std::string* out) {
  if (FILE* file = ion::port::OpenFile(path, "rb")) {
    fseek(file, 0, SEEK_END);
    const size_t length = ftell(file);
    rewind(file);

    out->resize(length);
    fseek(file, 0, SEEK_SET);
    fread(&out->at(0), sizeof(char), length, file);
    fclose(file);
    return true;
  }

  return false;
}

bool RemoveFile(const std::string& path) {
#if defined(ION_PLATFORM_NACL)
  return false;
#elif defined(ION_PLATFORM_WINDOWS)
  return ::DeleteFileW(Utf8ToWide(path).c_str()) != 0;
#else
  return unlink(path.c_str()) == 0;
#endif
}

std::vector<std::string> ListDirectory(const std::string& path) {
  std::vector<std::string> files;
#if defined(ION_PLATFORM_WINDOWS)
  std::wstring wild = ion::port::Utf8ToWide(path) + L"/*";
  WIN32_FIND_DATAW find_data;
  HANDLE find_handle = ::FindFirstFileW(wild.c_str(), &find_data);
  if (find_handle != INVALID_HANDLE_VALUE) {
    do {
      if (!lstrcmpW(find_data.cFileName, L".") ||
          !lstrcmpW(find_data.cFileName, L"..")) {
        continue;
      }
      files.push_back(ion::port::WideToUtf8(find_data.cFileName));
    } while (::FindNextFileW(find_handle, &find_data));
    ::FindClose(find_handle);
  }
#elif !defined(ION_PLATFORM_NACL)
  if (DIR* dir = opendir(path.c_str())) {
    struct dirent dent_buf;
    struct dirent* dent;
    while (readdir_r(dir, &dent_buf, &dent) == 0 && dent) {
      const std::string file = dent->d_name;
      if (file != "." && file != "..")
        files.push_back(file);
    }
    closedir(dir);
  }
#endif
  return files;
}

}  // namespace port
}  // namespace ion