common/platform/default/quiche_platform_impl/quiche_file_utils_impl.cc

// Copyright 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "quiche_platform_impl/quiche_file_utils_impl.h"

#if defined(_WIN32)
#include <windows.h>
#else
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#endif  // defined(_WIN32)

#include <fstream>
#include <ios>
#include <iostream>

#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/strings/strip.h"
#include "absl/types/optional.h"

namespace quiche {

#if defined(_WIN32)
std::string JoinPathImpl(absl::string_view a, absl::string_view b) {
  if (a.empty()) {
    return std::string(b);
  }
  if (b.empty()) {
    return std::string(a);
  }
  // Win32 actually provides two different APIs for combining paths; one of them
  // has issues that could potentially lead to buffer overflow, and another is
  // not supported in Windows 7, which is why we're doing it manually.
  a = absl::StripSuffix(a, "/");
  a = absl::StripSuffix(a, "\\");
  return absl::StrCat(a, "\\", b);
}
#else
std::string JoinPathImpl(absl::string_view a, absl::string_view b) {
  if (a.empty()) {
    return std::string(b);
  }
  if (b.empty()) {
    return std::string(a);
  }
  return absl::StrCat(absl::StripSuffix(a, "/"), "/", b);
}
#endif  // defined(_WIN32)

absl::optional<std::string> ReadFileContentsImpl(absl::string_view file) {
  std::ifstream input_file(std::string{file}, std::ios::binary);
  if (!input_file || !input_file.is_open()) {
    return absl::nullopt;
  }

  input_file.seekg(0, std::ios_base::end);
  auto file_size = input_file.tellg();
  if (!input_file) {
    return absl::nullopt;
  }
  input_file.seekg(0, std::ios_base::beg);

  std::string output;
  output.resize(file_size);
  input_file.read(&output[0], file_size);
  if (!input_file) {
    return absl::nullopt;
  }

  return output;
}

#if defined(_WIN32)

class ScopedDir {
 public:
  ScopedDir(HANDLE dir) : dir_(dir) {}
  ~ScopedDir() {
    if (dir_ != INVALID_HANDLE_VALUE) {
      // The API documentation explicitly says that CloseHandle() should not be
      // used on directory search handles.
      FindClose(dir_);
      dir_ = INVALID_HANDLE_VALUE;
    }
  }

  HANDLE get() { return dir_; }

 private:
  HANDLE dir_;
};

bool EnumerateDirectoryImpl(absl::string_view path,
                            std::vector<std::string>& directories,
                            std::vector<std::string>& files) {
  std::string path_owned(path);

  // Explicitly check that the directory we are trying to search is in fact a
  // directory.
  DWORD attributes = GetFileAttributesA(path_owned.c_str());
  if (attributes == INVALID_FILE_ATTRIBUTES) {
    return false;
  }
  if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
    return false;
  }

  std::string search_path = JoinPathImpl(path, "*");
  WIN32_FIND_DATAA file_data;
  ScopedDir dir(FindFirstFileA(search_path.c_str(), &file_data));
  if (dir.get() == INVALID_HANDLE_VALUE) {
    return GetLastError() == ERROR_FILE_NOT_FOUND;
  }
  do {
    std::string filename(file_data.cFileName);
    if (filename == "." || filename == "..") {
      continue;
    }
    if ((file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
      directories.push_back(std::move(filename));
    } else {
      files.push_back(std::move(filename));
    }
  } while (FindNextFileA(dir.get(), &file_data));
  return GetLastError() == ERROR_NO_MORE_FILES;
}

#else  // defined(_WIN32)

class ScopedDir {
 public:
  ScopedDir(DIR* dir) : dir_(dir) {}
  ~ScopedDir() {
    if (dir_ != nullptr) {
      closedir(dir_);
      dir_ = nullptr;
    }
  }

  DIR* get() { return dir_; }

 private:
  DIR* dir_;
};

bool EnumerateDirectoryImpl(absl::string_view path,
                            std::vector<std::string>& directories,
                            std::vector<std::string>& files) {
  std::string path_owned(path);
  ScopedDir dir(opendir(path_owned.c_str()));
  if (dir.get() == nullptr) {
    return false;
  }

  dirent* entry;
  while ((entry = readdir(dir.get()))) {
    const std::string filename(entry->d_name);
    if (filename == "." || filename == "..") {
      continue;
    }

    const std::string entry_path = JoinPathImpl(path, filename);
    struct stat stat_entry;
    if (stat(entry_path.c_str(), &stat_entry) != 0) {
      return false;
    }
    if (S_ISREG(stat_entry.st_mode)) {
      files.push_back(std::move(filename));
    } else if (S_ISDIR(stat_entry.st_mode)) {
      directories.push_back(std::move(filename));
    }
  }
  return true;
}

#endif  // defined(_WIN32)

}  // namespace quiche