Skip to content

Play your Steam library's Windows games on a jailbroken PS5.

C++
43.4 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
#include "web/file_store.h"

#include "runtime/artifact_hash.h"

#include <atomic>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h>
#include <filesystem>
#include <fstream>
#include <mutex>
#include <set>
#include <string>
#include <sys/stat.h>
#include <thread>
#include <unistd.h>
#include <vector>

using namespace playden::web;
namespace fs = std::filesystem;
using playden::platform::SetOwnershipProbeForTesting;

#define CHECK(condition)                                                                  \
  do {                                                                                    \
    if (!(condition)) {                                                                   \
      std::fprintf(stderr, "%s:%d: CHECK failed: %s\n", __FILE__, __LINE__, #condition); \
      std::exit(1);                                                                       \
    }                                                                                     \
  } while (false)

namespace {

void Put(const fs::path& path, const std::string& text) {
  fs::create_directories(path.parent_path());
  std::ofstream(path, std::ios::binary) << text;
}

std::string Text(const fs::path& path) {
  std::ifstream in(path, std::ios::binary);
  return std::string(std::istreambuf_iterator<char>(in), {});
}

UploadReader Reader(const std::string& text) {
  auto offset = std::make_shared<std::size_t>(0);
  return [text, offset](char* data, std::size_t size) -> std::ptrdiff_t {
    const auto count = std::min(size, text.size() - *offset);
    std::copy_n(text.data() + *offset, count, data);
    *offset += count;
    return static_cast<std::ptrdiff_t>(count);
  };
}

FileError Send(FileStore& store, const FileRoot& root, const std::string& path, const std::string& text, bool overwrite = false, bool* replaced = nullptr,
               std::optional<std::string> hash = std::nullopt) {
  UploadOptions options;
  options.length = text.size();
  options.overwrite = overwrite;
  options.if_sha256 = std::move(hash);
  return store.Upload(root, path, options, Reader(text), replaced);
}

std::vector<std::string> Names(const fs::path& folder) {
  std::vector<std::string> names;
  for (const auto& entry : fs::directory_iterator(folder)) names.push_back(entry.path().filename().string());
  std::sort(names.begin(), names.end());
  return names;
}

FileRoot Root(const fs::path& path) {
  FileRoot root;
  root.path = path.string();
  return root;
}

const FileEntry* Entry(const FileListing& listing, const std::string& name) {
  for (const auto& entry : listing.entries)
    if (entry.name == name) return &entry;
  return nullptr;
}

}  // namespace

int main() {
  const auto base = fs::canonical(fs::temp_directory_path()) / ("playden-web-files-" + std::to_string(::getpid()));
  fs::remove_all(base);
  fs::create_directories(base);
  const auto folder = base / "root";
  fs::create_directories(folder);
  FileRoot root = Root(folder);
  std::vector<std::string> steps;
  FileStore::Options options;
  std::string fail_at;
  // Uploads race later on, and each calls this with no lock of the store's held.
  std::mutex steps_mutex;
  options.fault = [&](const std::string& step) {
    std::lock_guard<std::mutex> lock(steps_mutex);
    steps.push_back(step);
    return step != fail_at;
  };
  FileStore store(options);

  // Listing: folders first, hidden names and links out, unusable names counted.
  Put(folder / "b.sav", "bb");
  Put(folder / "A.sav", "a");
  Put(folder / "Sub/inner.txt", "inner");
  Put(folder / ".playden-install.json", "{}");
  Put(folder / "playden_online.txt", "token");
  Put(folder / "steam_settings/configs.user.ini", "name");
  Put(base / "outside.txt", "secret");
  fs::create_symlink(base / "outside.txt", folder / "link.txt");
  fs::create_directory_symlink(base, folder / "linkdir");
  FileListing listing;
  CHECK(store.List(root, "", &listing).ok() && listing.exists && !listing.read_only);
  CHECK(listing.entries.size() == 4);
  CHECK(listing.entries[0].directory && listing.entries[2].name == "A.sav" && listing.entries[3].name == "b.sav" && listing.entries[3].size == 2);
  CHECK(Entry(listing, "steam_settings")->read_only && !Entry(listing, "Sub")->read_only);
  CHECK(!Entry(listing, "link.txt") && !Entry(listing, "linkdir") && !Entry(listing, "playden_online.txt"));

  // A request can't reach out of the root, into a link, or a hidden name.
  OpenedFile opened;
  for (const char* path : {"../outside.txt", "link.txt", "linkdir/outside.txt", ".playden-install.json", "playden_online.txt", "PLAYDEN_ONLINE.TXT", "/etc/hosts", "Sub/../../outside.txt"})
    CHECK(store.OpenForRead(root, path, false, &opened).status != 0);
  FileListing refused;
  CHECK(store.List(root, "linkdir", &refused).status != 0 && store.List(root, "..", &refused).status != 0);
  CHECK(!Send(store, root, "../escape.txt", "x").ok() && !fs::exists(base / "escape.txt"));
  CHECK(!Send(store, root, "linkdir/escape.txt", "x").ok() && !fs::exists(base / "escape.txt"));
  CHECK(!Send(store, root, "link.txt", "x", true).ok() && Text(base / "outside.txt") == "secret");
  CHECK(!store.Delete(root, "link.txt").ok() && fs::is_symlink(folder / "link.txt"));
  CHECK(!store.MakeFolder(root, "../made").ok() && !fs::exists(base / "made"));
  fs::remove(folder / "link.txt");
  fs::remove(folder / "linkdir");

  // A file with another hard link can hold a secret under an innocent name: hidden everywhere.
  fs::create_hard_link(base / "outside.txt", folder / "innocent.txt");
  CHECK(store.List(root, "", &listing).ok() && !Entry(listing, "innocent.txt") && listing.unshown == 1);
  CHECK(store.OpenForRead(root, "innocent.txt", false, &opened).status == 404);
  FileText text;
  CHECK(store.ReadText(root, "innocent.txt", &text).status == 404);
  CHECK(store.Delete(root, "innocent.txt").status == 404);
  fs::remove(folder / "innocent.txt");

  // A download.
  CHECK(store.OpenForRead(root, "Sub/inner.txt", false, &opened).ok() && opened.size == 5 && opened.name == "inner.txt");
  ::close(opened.fd);
  // The descriptor reads as blocking from here on.
  CHECK(store.OpenForRead(root, "Sub/inner.txt", false, &opened).ok() && (::fcntl(opened.fd, F_GETFL) & O_NONBLOCK) == 0);
  ::close(opened.fd);
  CHECK(store.OpenForRead(root, "Sub", false, &opened).status == 404);

  // Private paths are hidden, too.
  {
    FileRoot secret = root;
    secret.private_paths = {"Sub"};
    CHECK(store.List(secret, "", &listing).ok() && !Entry(listing, "Sub"));
    CHECK(store.List(secret, "Sub", &listing).status == 404 && store.OpenForRead(secret, "Sub/inner.txt", false, &opened).status == 404);
    CHECK(!Send(store, secret, "Sub/new.txt", "x").ok() && !store.Delete(secret, "Sub/inner.txt").ok());
    bool started = false;
    std::string zip;
    CHECK(store.WriteZip(secret, "", 0, [&](const char* d, std::size_t n) { zip.append(d, n); return true; }, [] { return true; }, &started).ok());
    CHECK(zip.find("inner.txt") == std::string::npos);
  }

  // A new file: no previous version, and no temporary left.
  bool replaced = true;
  CHECK(Send(store, root, "new.sav", "first", false, &replaced).ok() && !replaced);
  CHECK(Text(folder / "new.sav") == "first");
  for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-upload-", 0) != 0 && name.rfind(".playden-bak", 0) != 0);
  CHECK((fs::status(folder / "new.sav").permissions() & fs::perms::all) == (fs::perms::owner_read | fs::perms::owner_write));

  // Taken: refused unless asked to replace; a folder is never replaced.
  CHECK(Send(store, root, "new.sav", "x").status == 409 && Text(folder / "new.sav") == "first");
  CHECK(Send(store, root, "Sub", "x", true).status == 409 && fs::is_directory(folder / "Sub"));

  // Replacing keeps one previous version, listed on the file's row.
  CHECK(Send(store, root, "new.sav", "second", true, &replaced).ok() && replaced);
  CHECK(Text(folder / "new.sav") == "second" && Text(folder / ".playden-bak.new.sav") == "first");
  CHECK(Send(store, root, "new.sav", "third", true).ok());
  CHECK(Text(folder / "new.sav") == "third" && Text(folder / ".playden-bak.new.sav") == "second");
  CHECK(store.List(root, "", &listing).ok());
  CHECK(Entry(listing, "new.sav")->previous && Entry(listing, "new.sav")->previous->size == 6 && !Entry(listing, "new.sav")->recoverable);
  CHECK(!Entry(listing, ".playden-bak.new.sav"));
  CHECK(store.OpenForRead(root, "new.sav", true, &opened).ok() && opened.size == 6);
  ::close(opened.fd);

  // Restore swaps the two, and again.
  CHECK(store.Restore(root, "new.sav").ok());
  CHECK(Text(folder / "new.sav") == "second" && Text(folder / ".playden-bak.new.sav") == "third");
  CHECK(store.Restore(root, "new.sav").ok());
  CHECK(Text(folder / "new.sav") == "third" && Text(folder / ".playden-bak.new.sav") == "second");
  CHECK(store.Restore(root, "b.sav").status == 404);

  // Read-only folders.
  CHECK(Send(store, root, "steam_settings/x", "x").status == 403 && Send(store, root, "Steam_Settings/configs.user.ini", "x", true).status == 403);
  CHECK(store.Delete(root, "steam_settings/configs.user.ini").status == 403 && store.Delete(root, "steam_settings").status == 403);
  CHECK(store.MakeFolder(root, "steam_settings/x").status == 403 && store.Restore(root, "steam_settings/x").status == 403);
  CHECK(store.List(root, "steam_settings", &listing).ok() && listing.read_only && Entry(listing, "configs.user.ini")->read_only);
  CHECK(store.OpenForRead(root, "steam_settings/configs.user.ini", false, &opened).ok());
  ::close(opened.fd);

  // Each step of a replace failing: the file or its previous version always remains, named by a state.
  for (const char* step : {"sync-temporary", "remove-backup", "move-current", "sync-backup", "publish", "sync-publish"}) {
    Put(folder / "fault.sav", "old");
    Put(folder / ".playden-bak.fault.sav", "older");
    fail_at = step;
    const auto error = Send(store, root, "fault.sav", "new", true);
    fail_at.clear();
    CHECK(!error.ok());
    const bool current = fs::exists(folder / "fault.sav");
    const bool backup = fs::exists(folder / ".playden-bak.fault.sav");
    CHECK(current || backup);
    const std::string kept = current ? Text(folder / "fault.sav") : Text(folder / ".playden-bak.fault.sav");
    CHECK(kept == "old" || kept == "new");
    // Everything visible after the failure can be listed, and whatever the state, a retry succeeds.
    CHECK(store.List(root, "", &listing).ok() && Entry(listing, "fault.sav"));
    CHECK(Send(store, root, "fault.sav", "again", true).ok() && Text(folder / "fault.sav") == "again");
    fs::remove(folder / "fault.sav");
    fs::remove(folder / ".playden-bak.fault.sav");
    for (const auto& name : Names(folder))
      if (name.rfind(".playden-upload-", 0) == 0) fs::remove(folder / name);
  }

  // Crash states, as a fresh store finds them on disk.
  {
    FileStore fresh{FileStore::Options{}};
    // Only the previous version: Recoverable, downloadable, restorable.
    Put(folder / ".playden-bak.crash.sav", "saved");
    CHECK(fresh.List(root, "", &listing).ok());
    CHECK(Entry(listing, "crash.sav") && Entry(listing, "crash.sav")->recoverable && Entry(listing, "crash.sav")->size == 5);
    CHECK(fresh.OpenForRead(root, "crash.sav", true, &opened).ok());
    ::close(opened.fd);
    CHECK(fresh.Restore(root, "crash.sav").ok() && Text(folder / "crash.sav") == "saved" && !fs::exists(folder / ".playden-bak.crash.sav"));
    fs::remove(folder / "crash.sav");
    // Delete of only a previous version.
    Put(folder / ".playden-bak.crash.sav", "saved");
    CHECK(fresh.Delete(root, "crash.sav").ok() && !fs::exists(folder / ".playden-bak.crash.sav"));
    // A restore's leftovers stay hidden until old; a previous version with them is still restorable.
    Put(folder / ".playden-restore-abc", "aside");
    Put(folder / ".playden-bak.crash.sav", "saved");
    CHECK(fresh.List(root, "", &listing).ok() && !Entry(listing, ".playden-restore-abc") && Entry(listing, "crash.sav")->recoverable);
    CHECK(fresh.Restore(root, "crash.sav").ok() && Text(folder / "crash.sav") == "saved");
    fs::remove(folder / "crash.sav");
    fs::remove(folder / ".playden-restore-abc");
  }

  // A restore failing at each step keeps the data, under a name a later request finds or the sweep puts back.
  for (const char* step : {"restore-aside", "restore-back", "restore-sync", "restore-keep"}) {
    Put(folder / "swap.sav", "cur");
    Put(folder / ".playden-bak.swap.sav", "bak");
    fail_at = step;
    CHECK(!store.Restore(root, "swap.sav").ok());
    fail_at.clear();
    std::set<std::string> texts;
    for (const auto& name : Names(folder))
      if (name.find("swap.sav") != std::string::npos || name.rfind(".playden-restore-", 0) == 0) texts.insert(Text(folder / name));
    CHECK(texts.count("bak") == 1 && texts.count("cur") == 1);
    fs::remove(folder / "swap.sav");
    fs::remove(folder / ".playden-bak.swap.sav");
    for (const auto& name : Names(folder))
      if (name.rfind(".playden-restore-", 0) == 0) fs::remove(folder / name);
  }

  // Leftovers: old ones go at the next upload; a new one stays, and so does an upload's own temporary.
  {
    std::int64_t now = 100000;
    FileStore::Options timed;
    timed.now = [&] { return now; };
    FileStore clock(timed);
    now = ::time(nullptr) + 7200;
    Put(folder / ".playden-upload-old", "x");
    Put(folder / ".playden-restore-old", "x");
    CHECK(Send(clock, root, "sweep.sav", "x").ok());
    CHECK(!fs::exists(folder / ".playden-upload-old") && !fs::exists(folder / ".playden-restore-old"));
    now = ::time(nullptr);
    Put(folder / ".playden-upload-new", "x");
    CHECK(Send(clock, root, "sweep.sav", "y", true).ok() && fs::exists(folder / ".playden-upload-new"));
    fs::remove(folder / ".playden-upload-new");
    // Opening a folder removes what a cut-off upload left, and it doesn't keep a folder that looks empty from going.
    now = ::time(nullptr) + 7200;
    Put(folder / ".playden-upload-cut", "x");
    {
      FileListing swept;
      CHECK(clock.List(root, "", &swept).ok() && !fs::exists(folder / ".playden-upload-cut"));
    }
    Put(folder / "looks-empty/.playden-upload-cut", "x");
    CHECK(clock.Delete(root, "looks-empty").ok() && !fs::exists(folder / "looks-empty"));
    fs::create_directories(folder / "not-empty");
    Put(folder / "not-empty/.playden-bak.keep", "x");
    CHECK(clock.Delete(root, "not-empty").status == 409 && fs::exists(folder / "not-empty/.playden-bak.keep"));
    fs::remove_all(folder / "not-empty");
    now = ::time(nullptr);
    // An active upload is never swept, however old: the clock jumps while it streams, and another upload sweeps.
    now = ::time(nullptr) + 7200;
    std::atomic<int> phase{0};
    UploadOptions slow;
    slow.length = 4;
    std::thread uploading([&] {
      std::size_t sent = 0;
      const auto error = clock.Upload(root, "slow.sav", slow, [&](char* data, std::size_t) -> std::ptrdiff_t {
        if (sent++ == 1) {
          phase = 1;
          while (phase != 2) std::this_thread::sleep_for(std::chrono::milliseconds(5));
        }
        if (sent > 4) return 0;
        data[0] = 'z';
        return 1;
      }, nullptr);
      CHECK(error.ok());
    });
    while (phase != 1) std::this_thread::sleep_for(std::chrono::milliseconds(5));
    CHECK(Send(clock, root, "other.sav", "x").ok());
    phase = 2;
    uploading.join();
    CHECK(Text(folder / "slow.sav") == "zzzz");
    fs::remove(folder / "slow.sav");
    fs::remove(folder / "other.sav");
    fs::remove(folder / "sweep.sav");
    fs::remove(folder / ".playden-bak.sweep.sav");
  }

  // A restore that stopped, on a save last changed long ago: its temporary is the player's file, and stays until
  // the temporary itself is old. Then it goes back where it belongs.
  {
    std::int64_t later = ::time(nullptr);
    std::string stop_at = "restore-back";
    FileStore::Options timed;
    timed.now = [&] { return later; };
    timed.fault = [&](const std::string& step) { return step != stop_at; };
    FileStore clock(timed);
    Put(folder / "old.sav", "newest");
    Put(folder / ".playden-bak.old.sav", "older");
    fs::last_write_time(folder / "old.sav", fs::file_time_type::clock::now() - std::chrono::hours(48));
    CHECK(!clock.Restore(root, "old.sav").ok());
    std::string aside;
    for (const auto& name : Names(folder))
      if (name.rfind(".playden-restore-", 0) == 0) aside = name;
    CHECK(!aside.empty() && Text(folder / aside) == "newest");
    stop_at.clear();
    CHECK(Send(clock, root, "other.sav", "x").ok());
    CHECK(fs::exists(folder / aside));
    later += 7200;
    CHECK(Send(clock, root, "other.sav", "y", true).ok());
    CHECK(!fs::exists(folder / aside) && Text(folder / "old.sav") == "newest" && Text(folder / ".playden-bak.old.sav") == "older");
    // Stopped after the previous version came back: the swap finishes.
    stop_at = "restore-keep";
    CHECK(!clock.Restore(root, "old.sav").ok());
    stop_at.clear();
    CHECK(Text(folder / "old.sav") == "older" && !fs::exists(folder / ".playden-bak.old.sav"));
    later += 7200;
    {
      FileListing swept;
      CHECK(clock.List(root, "", &swept).ok());
    }
    CHECK(Text(folder / "old.sav") == "older" && Text(folder / ".playden-bak.old.sav") == "newest");
    // The file and its previous version are both back: the temporary was replaced as usual.
    Put(folder / ".playden-restore-1-x.old.sav", "oldest");
    CHECK(Send(clock, root, "other.sav", "z", true).ok());
    CHECK(!fs::exists(folder / ".playden-restore-1-x.old.sav") && Text(folder / "old.sav") == "older" && Text(folder / ".playden-bak.old.sav") == "newest");
    fs::remove(folder / "old.sav");
    fs::remove(folder / "other.sav");
    fs::remove(folder / ".playden-bak.other.sav");
    fs::remove(folder / ".playden-bak.old.sav");
  }

  // A cut upload: the old file stays, and its temporary goes.
  {
    Put(folder / "cut.sav", "old");
    UploadOptions cut;
    cut.length = 100;
    cut.overwrite = true;
    int reads = 0;
    CHECK(store.Upload(root, "cut.sav", cut, [&](char* data, std::size_t) -> std::ptrdiff_t {
      if (reads++ > 0) return -1;
      data[0] = 'n';
      return 1;
    }, nullptr).status == 408);
    CHECK(Text(folder / "cut.sav") == "old");
    for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-upload-", 0) != 0);
    CHECK(!fs::exists(folder / ".playden-bak.cut.sav"));
    fs::remove(folder / "cut.sav");
  }

  // The path lock: never held while bytes move; busy answers 503; a failed upload's cleanup waits for it.
  {
    std::atomic<bool> busy{false};
    std::atomic<int> holds_live{0};
    FileStore::Options locked;
    locked.hold_tries = 2;
    locked.hold_retry_ms = 1;
    locked.try_hold = [&]() -> std::shared_ptr<void> {
      if (busy) return nullptr;
      ++holds_live;
      return std::shared_ptr<void>(new int(0), [&](void* held) { delete static_cast<int*>(held); --holds_live; });
    };
    FileStore guarded(locked);
    busy = true;
    CHECK(guarded.List(root, "", &listing).status == 503);
    CHECK(guarded.OpenForRead(root, "b.sav", false, &opened).status == 503);
    CHECK(Send(guarded, root, "held.sav", "x").status == 503);
    CHECK(guarded.Delete(root, "b.sav").status == 503 && guarded.MakeFolder(root, "held").status == 503 && guarded.Restore(root, "b.sav").status == 503);
    busy = false;
    CHECK(guarded.OpenForRead(root, "b.sav", false, &opened).ok() && holds_live == 0);
    ::close(opened.fd);
    UploadOptions watched;
    watched.length = 4;
    int reads = 0;
    CHECK(guarded.Upload(root, "held.sav", watched, [&](char* data, std::size_t) -> std::ptrdiff_t {
      CHECK(holds_live == 0);
      if (++reads > 4) return 0;
      data[0] = 'h';
      return 1;
    }, nullptr).ok());
    CHECK(Text(folder / "held.sav") == "hhhh" && holds_live == 0);
    fs::remove(folder / "held.sav");
    // The lock taken during the upload, and the client goes away: the temporary waits, then goes.
    watched.overwrite = false;
    reads = 0;
    CHECK(guarded.Upload(root, "held.sav", watched, [&](char* data, std::size_t) -> std::ptrdiff_t {
      if (reads++ == 1) { busy = true; return -1; }
      data[0] = 'h';
      return 1;
    }, nullptr).status == 408);
    CHECK(guarded.DeferredCleanups() == 1);
    bool left = false;
    for (const auto& name : Names(folder)) left = left || name.rfind(".playden-upload-", 0) == 0;
    CHECK(left);
    busy = false;
    CHECK(guarded.List(root, "", &listing).ok() && guarded.DeferredCleanups() == 0);
    for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-upload-", 0) != 0);
    // Busy at the commit, after the bytes arrived: the old file stays, and the upload says busy.
    Put(folder / "late.sav", "old");
    watched.overwrite = true;
    reads = 0;
    CHECK(guarded.Upload(root, "late.sav", watched, [&](char* data, std::size_t) -> std::ptrdiff_t {
      if (++reads > 4) return 0;
      if (reads == 4) busy = true;
      data[0] = 'n';
      return 1;
    }, nullptr).status == 503);
    CHECK(Text(folder / "late.sav") == "old");
    busy = false;
    CHECK(guarded.List(root, "", &listing).ok());
    fs::remove(folder / "late.sav");
  }

  // Two uploads racing for a free name: one wins, one gets 409, and the winner's bytes are whole.
  {
    for (int round = 0; round < 20; ++round) {
      const auto name = "race" + std::to_string(round) + ".sav";
      std::atomic<int> ready{0};
      FileError results[2];
      std::thread racers[2];
      for (int i = 0; i < 2; ++i)
        racers[i] = std::thread([&, i] {
          const std::string body(1024, static_cast<char>('a' + i));
          UploadOptions race;
          race.length = body.size();
          auto next = Reader(body);
          bool waited = false;
          results[i] = store.Upload(root, name, race, [&](char* data, std::size_t size) -> std::ptrdiff_t {
            if (!waited) {
              waited = true;
              ++ready;
              while (ready != 2) std::this_thread::yield();
            }
            return next(data, size);
          }, nullptr);
        });
      for (auto& racer : racers) racer.join();
      CHECK(results[0].ok() != results[1].ok());
      CHECK((results[0].ok() ? results[1] : results[0]).status == 409);
      const auto saved = Text(folder / name);
      CHECK(saved == std::string(1024, results[0].ok() ? 'a' : 'b'));
      fs::remove(folder / name);
    }
    for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-upload-", 0) != 0);
  }
  // Restore and delete racing: at the end the data is either gone by request or whole, never half swapped.
  {
    for (int round = 0; round < 20; ++round) {
      Put(folder / "both.sav", "cur");
      Put(folder / ".playden-bak.both.sav", "bak");
      std::thread restoring([&] { store.Restore(root, "both.sav"); });
      std::thread deleting([&] { store.Delete(root, "both.sav"); });
      restoring.join();
      deleting.join();
      CHECK(!fs::exists(folder / "both.sav") && !fs::exists(folder / ".playden-bak.both.sav"));
      for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-restore-", 0) != 0);
    }
  }

  // The hash an editor saw: refused once the file changed, with the same size and time too.
  {
    Put(folder / "conf.ini", "a=1\n");
    CHECK(store.ReadText(root, "conf.ini", &text).ok() && text.text == "a=1\n");
    const auto hash = text.sha256;
    CHECK(Send(store, root, "conf.ini", "a=2\n", true, nullptr, hash).ok() && Text(folder / "conf.ini") == "a=2\n");
    const auto written = fs::last_write_time(folder / "conf.ini");
    Put(folder / "conf.ini", "a=3\n");
    fs::last_write_time(folder / "conf.ini", written);
    CHECK(Send(store, root, "conf.ini", "a=4\n", true, nullptr, hash).status == 409 && Text(folder / "conf.ini") == "a=3\n");
    // Changed while the upload was on its way: refused at the commit, and no lock held for the read.
    CHECK(store.ReadText(root, "conf.ini", &text).ok());
    {
      UploadOptions during;
      during.length = 4;
      during.overwrite = true;
      during.if_sha256 = text.sha256;
      const std::string payload = "a=5\n";
      std::size_t sent = 0;
      CHECK(store.Upload(root, "conf.ini", during, [&](char* data, std::size_t) -> std::ptrdiff_t {
        if (sent == 0) Put(folder / "conf.ini", "a=9\n");
        if (sent >= payload.size()) return 0;
        data[0] = payload[sent++];
        return 1;
      }, nullptr).status == 409);
      CHECK(Text(folder / "conf.ini") == "a=9\n");
    }
    fs::remove(folder / ".playden-bak.conf.ini");
    fs::remove(folder / "conf.ini");
    CHECK(Send(store, root, "conf.ini", "a=4\n", true, nullptr, hash).status == 409 && !fs::exists(folder / "conf.ini"));
    Put(folder / "binary.dat", std::string("\xff\xfe\0", 3));
    CHECK(store.ReadText(root, "binary.dat", &text).status == 415);
    // Encodings: the text comes back as UTF-8, and the hash is still of the bytes on disk.
    const auto reads_as = [&](const std::string& bytes, const std::string& expected, const std::string& encoding, bool bom) {
      Put(folder / "coded.txt", bytes);
      FileText coded;
      return store.ReadText(root, "coded.txt", &coded).ok() && coded.text == expected && coded.encoding == encoding && coded.bom == bom &&
             coded.sha256 == *playden::runtime::HashArtifactBytes(bytes);
    };
    const auto refused = [&](const std::string& bytes) {
      Put(folder / "coded.txt", bytes);
      FileText coded;
      return store.ReadText(root, "coded.txt", &coded).status == 415;
    };
    CHECK(reads_as("plain\r\n", "plain\r\n", "utf-8", false));
    CHECK(reads_as("\xef\xbb\xbf" "caf\xc3\xa9", "caf\xc3\xa9", "utf-8", true));
    CHECK(reads_as(std::string("\xff\xfe" "1\0.\0" "\xe9\0" "\x20\x20", 10), "1.\xc3\xa9\xe2\x80\xa0", "utf-16le", true));
    CHECK(reads_as(std::string("\xfe\xff\0" "1\0" "\xe9", 6), "1\xc3\xa9", "utf-16be", true));
    CHECK(reads_as(std::string("\xff\xfe\x3d\xd8\x00\xde", 6), "\xf0\x9f\x98\x80", "utf-16le", true));
    CHECK(reads_as("\xff\xfe", "", "utf-16le", true));
    CHECK(refused(std::string("\xff\xfe" "a", 3)));                   // odd length
    CHECK(refused(std::string("\xff\xfe\x3d\xd8", 4)));              // a surrogate cut off
    CHECK(refused(std::string("\xff\xfe\x00\xde" "a\0", 6)));        // a low surrogate alone
    CHECK(refused(std::string("\xff\xfe\x3d\xd8" "a\0", 6)));        // a high surrogate alone
    CHECK(refused(std::string("\xff\xfe\0\0" "a\0", 6)));            // UTF-32, or a NUL
    CHECK(refused("caf\xe9"));                                       // Windows-1252
    CHECK(refused(std::string("a\0b\0", 4)));                         // UTF-16 with no mark
    // The save's check on a UTF-16 file compares the bytes on disk.
    {
      const std::string utf16("\xff\xfe" "a\0=\0" "1\0", 8);
      Put(folder / "coded.txt", utf16);
      FileText coded;
      CHECK(store.ReadText(root, "coded.txt", &coded).ok() && coded.text == "a=1");
      const std::string saved("\xff\xfe" "a\0=\0" "2\0", 8);
      CHECK(Send(store, root, "coded.txt", saved, true, nullptr, coded.sha256).ok() && Text(folder / "coded.txt") == saved);
      CHECK(Send(store, root, "coded.txt", utf16, true, nullptr, coded.sha256).status == 409 && Text(folder / "coded.txt") == saved);
      fs::remove(folder / "coded.txt");
      fs::remove(folder / ".playden-bak.coded.txt");
    }
    Put(folder / "large.txt", std::string(kMaxTextBytes + 1, 'a'));
    CHECK(store.ReadText(root, "large.txt", &text).status == 413);
    fs::remove(folder / "binary.dat");
    fs::remove(folder / "large.txt");
  }

  // A file larger than the transfer buffer, in the odd sizes a network gives: every byte, in order. Cut off part way
  // through a buffer, nothing is published.
  {
    std::string large(3 * 1024 * 1024 + 123, '\0');
    for (std::size_t i = 0; i < large.size(); ++i) large[i] = static_cast<char>((i * 31) ^ (i >> 8));
    const auto pieces = [&](std::size_t stop_at) {
      auto offset = std::make_shared<std::size_t>(0);
      auto turn = std::make_shared<std::size_t>(0);
      return UploadReader([&large, offset, turn, stop_at](char* data, std::size_t size) -> std::ptrdiff_t {
        if (*offset >= stop_at) return -1;
        const std::size_t sizes[] = {1, 4096, 70001, 13, 1460};
        const auto count = std::min({size, sizes[(*turn)++ % 5], large.size() - *offset});
        std::copy_n(large.data() + *offset, count, data);
        *offset += count;
        return static_cast<std::ptrdiff_t>(count);
      });
    };
    UploadOptions whole;
    whole.length = large.size();
    CHECK(store.Upload(root, "large.bin", whole, pieces(large.size()), nullptr).ok() && Text(folder / "large.bin") == large);
    CHECK(store.Upload(root, "cut.bin", whole, pieces(1500 * 1024), nullptr).status == 408 && !fs::exists(folder / "cut.bin"));
    for (const auto& name : Names(folder)) CHECK(name.rfind(".playden-upload-", 0) != 0);
    fs::remove(folder / "large.bin");
  }

  // New folders and deletes.
  CHECK(store.MakeFolder(root, "made").ok() && fs::is_directory(folder / "made"));
  CHECK(store.MakeFolder(root, "made").status == 409 && store.MakeFolder(root, "a/b").status == 404);
  CHECK(store.MakeFolder(root, ".playden-x").status == 400 && store.MakeFolder(root, "bad\\name").status == 400);
  // A whole path at once, for a folder upload: what's there stays, a file in the way says so.
  {
    CHECK(store.MakeFolder(root, "tree/a/b", true).ok() && fs::is_directory(folder / "tree/a/b"));
    Put(folder / "tree/a/keep.txt", "kept");
    CHECK(store.MakeFolder(root, "tree/a/b", true).ok() && Text(folder / "tree/a/keep.txt") == "kept");
    CHECK(store.MakeFolder(root, "tree/a/c", true).ok() && fs::is_directory(folder / "tree/a/c"));
    const auto blocked = store.MakeFolder(root, "tree/a/keep.txt/d", true);
    CHECK(blocked.status == 409 && blocked.message.find("keep.txt") != std::string::npos && Text(folder / "tree/a/keep.txt") == "kept");
    CHECK(store.MakeFolder(root, "tree/a/keep.txt", true).status == 409);
    CHECK(store.MakeFolder(root, "tree/.playden-x/d", true).status == 400 && !fs::exists(folder / "tree/.playden-x"));
    CHECK(store.MakeFolder(root, "tree/playden_online.txt", true).status == 400);
    CHECK(store.MakeFolder(root, "tree/steam_settings/d", true).status == 403 && !fs::exists(folder / "tree/steam_settings"));
    CHECK(store.MakeFolder(root, "", true).status == 400);
    const std::string too_long(kMaxNewNameBytes + 1, 'n');
    CHECK(store.MakeFolder(root, "tree/" + too_long, true).status == 400);
    fs::create_directories(base / "elsewhere");
    fs::create_symlink(base / "elsewhere", folder / "tree/link");
    CHECK(!store.MakeFolder(root, "tree/link/d", true).ok() && !fs::exists(base / "elsewhere/d"));
    fs::remove_all(folder / "tree");
    fs::remove_all(base / "elsewhere");
  }
  CHECK(Send(store, root, "made/f.txt", "x").ok());
  CHECK(store.Delete(root, "made").status == 409 && fs::exists(folder / "made/f.txt"));
  CHECK(Send(store, root, "made/f.txt", "y", true).ok() && fs::exists(folder / "made/.playden-bak.f.txt"));
  CHECK(store.Delete(root, "made/f.txt").ok() && !fs::exists(folder / "made/f.txt") && !fs::exists(folder / "made/.playden-bak.f.txt"));
  CHECK(store.Delete(root, "made").ok() && !fs::exists(folder / "made"));
  CHECK(store.Delete(root, "made").status == 404);

  // A folder with what's in it: gone, except what Playden protects and the folders that hold it.
  {
    const auto tree = folder / "tree";
    Put(tree / "a.txt", "aaa");
    Put(tree / ".playden-bak.a.txt", "bb");
    Put(tree / ".playden-bak.lost.txt", "c");
    Put(tree / "sub/deep/d.txt", "dddd");
    fs::create_directories(tree / "sub/empty");
    TreeSummary summary;
    CHECK(store.SummarizeTree(root, "tree", &summary).ok());
    CHECK(summary.files == 3 && summary.folders == 4 && summary.bytes == 10 && summary.left == 0 && fs::exists(tree / "a.txt"));
    TreeSummary done;
    CHECK(store.DeleteTree(root, "tree", &done).ok() && !fs::exists(tree));
    CHECK(done.files == summary.files && done.folders == summary.folders && done.bytes == summary.bytes && done.left == 0);
    CHECK(store.DeleteTree(root, "tree", &done).status == 404);

    // Each protected kind keeps its parents, and the rest goes around it.
    Put(tree / "go.txt", "x");
    Put(tree / "secret/playden_online.txt", "token");
    Put(tree / "secret/go.txt", "x");
    Put(tree / "hidden/.playden-install.json", "{}");
    Put(tree / "settings/steam_settings/configs.user.ini", "x");
    Put(tree / "hiddendir/.playden-x/f", "x");
    Put(tree / "linked/one", "x");
    fs::create_hard_link(tree / "linked/one", base / "elsewhere-hard");
    Put(tree / "kept-going/deep/deeper/go.txt", "x");
    Put(base / "outside/target.txt", "outside");
    fs::create_directories(tree / "withlink");
    fs::create_symlink(base / "outside", tree / "withlink/out");
    fs::create_symlink(base / "outside/target.txt", tree / "withlink/out.txt");
    Put(tree / "busy/.playden-upload-new", "part");
    CHECK(store.SummarizeTree(root, "tree", &summary).ok() && summary.left == 8 && fs::exists(tree / "go.txt"));
    CHECK(store.DeleteTree(root, "tree", &done).ok());
    CHECK(done.left == 8 && done.files == summary.files);
    CHECK(!fs::exists(tree / "go.txt") && !fs::exists(tree / "secret/go.txt") && !fs::exists(tree / "kept-going"));
    CHECK(Text(tree / "secret/playden_online.txt") == "token" && fs::exists(tree / "hidden/.playden-install.json"));
    CHECK(fs::exists(tree / "settings/steam_settings/configs.user.ini") && fs::exists(tree / "hiddendir/.playden-x/f"));
    CHECK(fs::exists(tree / "linked/one") && fs::exists(tree / "busy/.playden-upload-new"));
    CHECK(fs::is_symlink(tree / "withlink/out") && fs::is_symlink(tree / "withlink/out.txt") && Text(base / "outside/target.txt") == "outside");
    fs::remove_all(tree);
    fs::remove_all(base / "outside");
    fs::remove(base / "elsewhere-hard");

    // A folder below that can't be opened stays, with its parents, and everything around it still goes.
    Put(tree / "go.txt", "x");
    Put(tree / "open/go.txt", "x");
    Put(tree / "parent/locked/inside.txt", "kept");
    Put(tree / "parent/go.txt", "x");
    fs::permissions(tree / "parent/locked", fs::perms::none);
    CHECK(store.SummarizeTree(root, "tree", &summary).ok() && summary.left == 1 && summary.files == 3);
    CHECK(store.DeleteTree(root, "tree", &done).ok() && done.left == 1 && done.files == 3);
    CHECK(!fs::exists(tree / "go.txt") && !fs::exists(tree / "open") && !fs::exists(tree / "parent/go.txt"));
    fs::permissions(tree / "parent/locked", fs::perms::owner_all);
    CHECK(Text(tree / "parent/locked/inside.txt") == "kept");
    fs::remove_all(tree);

    // Never the top of a root, a read-only or hidden folder, a path out of the root, or a link.
    CHECK(store.DeleteTree(root, "", &done).status == 404 && store.SummarizeTree(root, "", &done).status == 404);
    CHECK(store.DeleteTree(root, "../x", &done).status == 404 && store.DeleteTree(root, ".playden-x", &done).status == 404);
    Put(folder / "steam_settings/k.ini", "x");
    CHECK(store.DeleteTree(root, "steam_settings", &done).status == 403 && store.DeleteTree(root, "steam_settings/in", &done).status == 403);
    CHECK(fs::exists(folder / "steam_settings/k.ini"));
    Put(base / "outside/target.txt", "outside");
    fs::create_symlink(base / "outside", folder / "linktop");
    CHECK(!store.DeleteTree(root, "linktop", &done).ok() && Text(base / "outside/target.txt") == "outside");
    fs::remove(folder / "linktop");
    fs::remove_all(base / "outside");

    // Deep enough to break anything recursive, and more files in a folder than one batch.
    std::string deep = "tree";
    for (int level = 0; level < 40; ++level) deep += "/d";
    Put(folder / deep / "f.txt", "x");
    for (int index = 0; index < 200; ++index) Put(tree / ("many" + std::to_string(index)), "x");
    CHECK(store.DeleteTree(root, "tree", &done).ok() && !fs::exists(tree) && done.files == 201 && done.folders == 41);

    // Stopped part way by a disk error or a busy lock: nothing is lost by running it again.
    int allowed = 3;
    auto faulty_options = options;
    faulty_options.fault = [&](const std::string& step) { return step != "tree-file" || allowed-- > 0; };
    FileStore faulty(faulty_options);
    for (int index = 0; index < 10; ++index) Put(tree / ("f" + std::to_string(index)), "x");
    CHECK(faulty.DeleteTree(root, "tree", &done).status == 500 && fs::exists(tree));
    allowed = 1000;
    CHECK(faulty.DeleteTree(root, "tree", &done).ok() && !fs::exists(tree));
    auto busy_options = options;
    busy_options.hold_tries = 1;
    busy_options.hold_retry_ms = 1;
    std::atomic<int> holds{4};
    busy_options.try_hold = [&]() -> std::shared_ptr<void> { return holds-- > 0 ? std::make_shared<int>(0) : nullptr; };
    FileStore busy(busy_options);
    for (int index = 0; index < 3; ++index) Put(tree / ("sub" + std::to_string(index)) / "f", "x");
    CHECK(busy.DeleteTree(root, "tree", &done).status == 503);
    holds = 1000;
    CHECK(busy.DeleteTree(root, "tree", &done).ok() && !fs::exists(tree));
  }

  // A root not made yet: empty to read, made by the first write, from an existing folder only.
  {
    const auto bottle = base / "bottle";
    fs::create_directories(bottle / "drive_c");
    FileRoot steam;
    steam.path = (bottle / "drive_c/Program Files (x86)/Steam/userdata/0").string();
    steam.create_from = bottle.string();
    CHECK(store.List(steam, "", &listing).ok() && !listing.exists && listing.entries.empty());
    CHECK(Send(store, steam, "sub/x.sav", "x").status == 404);
    CHECK(Send(store, steam, "x.sav", "x").ok() && Text(steam.path + "/x.sav") == "x");
    CHECK((fs::status(steam.path).permissions() & fs::perms::all) == fs::perms::owner_all);
    FileRoot never = steam;
    never.path = (base / "nothing/here").string();
    never.create_from.clear();
    CHECK(Send(store, never, "x.sav", "x").status == 404 && !fs::exists(base / "nothing"));
    // Bottle modes: a shared profile and a private one both work.
    for (const auto mode : {fs::perms::owner_all, fs::perms::all}) {
      const auto profile = bottle / "drive_c/users/prospero";
      fs::create_directories(profile);
      fs::permissions(profile, mode);
      fs::permissions(bottle / "drive_c/users", fs::perms::owner_all | fs::perms::group_exec | fs::perms::others_exec);
      CHECK(store.List(Root(profile), "", &listing).ok());
      CHECK(Send(store, Root(profile), "m.sav", "x", true).ok());
    }
  }

  // A game folder with no owners (exFAT): the write asks once; a reader never makes it ask.
  {
    static int probes = 0;
    SetOwnershipProbeForTesting([](const fs::path&) -> std::optional<bool> { ++probes; return false; });
    FileStore game_store{FileStore::Options{}};
    const auto game = base / "game";
    Put(game / "bin/game.exe", "exe");
    Put(game / "empty.dat", "");
    FileRoot game_root = Root(game);
    game_root.game_folder = true;
    game_root.file_mode = 0666;
    game_root.folder_mode = 0777;
    CHECK(game_store.List(game_root, "", &listing).ok() && Entry(listing, "empty.dat")->size == 0);
    CHECK(game_store.OpenForRead(game_root, "empty.dat", false, &opened).ok());
    ::close(opened.fd);
    CHECK(probes == 0);
    CHECK(Send(game_store, game_root, "bin/mod.dll", "m").ok() && probes == 1);
    CHECK(Send(game_store, game_root, "bin/mod.dll", "n", true).ok() && probes == 1);
    CHECK(Text(game / "bin/mod.dll") == "n" && Text(game / "bin/.playden-bak.mod.dll") == "m");
    CHECK(game_store.Restore(game_root, "bin/mod.dll").ok() && Text(game / "bin/mod.dll") == "m");
    CHECK(game_store.MakeFolder(game_root, "_Redist").ok());
    SetOwnershipProbeForTesting(nullptr);
    // Keeping owners: the modes of a game folder.
    FileStore owned{FileStore::Options{}};
    CHECK(Send(owned, game_root, "bin/own.dll", "o").ok());
    CHECK((fs::status(game / "bin/own.dll").permissions() & fs::perms::all) ==
          (fs::perms::owner_read | fs::perms::owner_write | fs::perms::group_read | fs::perms::group_write | fs::perms::others_read | fs::perms::others_write));
    CHECK(owned.MakeFolder(game_root, "owned").ok());
    CHECK((fs::status(game / "owned").permissions() & fs::perms::all) == fs::perms::all);

    // Redistributable folders, by Play's rules: at the top and one level down.
    Put(game / "_Redist/PhysX_9.09.msi", "p");
    Put(game / "Inner/DirectX/DXSETUP.exe", "d");
    Put(game / "Inner/Bin/PhysX_9.exe", "not in a redist folder");
    Put(game / "Inner/Other/Support/deep.txt", "too far down");
    std::vector<RedistFolderInfo> redist;
    CHECK(owned.RedistFolders(game_root, &redist).ok() && redist.size() == 2);
    CHECK(redist[0].path == "_Redist" && redist[0].physx_installer == "_Redist/PhysX_9.09.msi" && redist[0].entries == 1);
    CHECK(redist[1].path == "Inner/DirectX" && redist[1].physx_installer.empty() && redist[1].sample[0] == "DXSETUP.exe");
  }

  // A file another user owns can't be replaced or deleted, in plain words. Only root can arrange it.
  if (::geteuid() == 0) {
    Put(folder / "theirs.sav", "x");
    CHECK(::chown((folder / "theirs.sav").c_str(), 12345, 12345) == 0);
    CHECK(Send(store, root, "theirs.sav", "y", true).status == 403);
    CHECK(store.Delete(root, "theirs.sav").status == 403);
  }

  // A folder as a zip.
  {
    const auto zipped = base / "zipped";
    Put(zipped / "a.txt", "alpha");
    Put(zipped / "deep/er/b.txt", "bravo");
    Put(zipped / ".playden-bak.a.txt", "hidden");
    Put(zipped / "playden_online.txt", "token");
    Put(base / "outside2.txt", "secret");
    fs::create_symlink(base / "outside2.txt", zipped / "link.txt");
    fs::create_hard_link(base / "outside2.txt", zipped / "hard.txt");
    std::string zip;
    bool started = false, began = false;
    const auto error = store.WriteZip(Root(zipped), "", 1700000000, [&](const char* data, std::size_t size) { zip.append(data, size); return true; },
                                      [&] { began = true; return true; }, &started);
    CHECK(error.ok() && began && started);
    CHECK(zip.find("zipped/a.txt") != std::string::npos && zip.find("zipped/deep/er/b.txt") != std::string::npos);
    CHECK(zip.find("alpha") != std::string::npos && zip.find("bravo") != std::string::npos);
    for (const char* absent : {"hidden", "token", "secret", "link.txt", "hard.txt", ".playden"}) CHECK(zip.find(absent) == std::string::npos);
    const auto archive = base / "out.zip";
    std::ofstream(archive, std::ios::binary) << zip;
    const auto check = "python3 -I -c \"import zipfile,sys; z=zipfile.ZipFile(sys.argv[1]); assert z.testzip() is None; assert sorted(z.namelist())==['zipped/a.txt','zipped/deep/er/b.txt']; "
                       "assert z.read('zipped/a.txt')==b'alpha'; assert all(i.flag_bits & 8 for i in z.infolist())\" '" + archive.string() + "'";
    CHECK(std::system(check.c_str()) == 0);
    // A subfolder is named from itself.
    zip.clear();
    CHECK(store.WriteZip(Root(zipped), "deep", 0, [&](const char* data, std::size_t size) { zip.append(data, size); return true; }, [] { return true; }, &started).ok());
    CHECK(zip.find("deep/er/b.txt") != std::string::npos && zip.find("zipped/") == std::string::npos);
    // A folder deeper than a zip goes is refused before the first byte, not left out.
    {
      auto deep = base / "deep";
      for (int i = 0; i < 40; ++i) deep /= "d";
      Put(deep / "lost.txt", "x");
      began = false;
      CHECK(store.WriteZip(Root(base / "deep"), "", 0, [&](const char*, std::size_t) { return true; }, [&] { began = true; return true; }, &started).status == 413);
      CHECK(!began && !started);
    }
    // Nothing goes out when it won't fit: a sparse file past the limit is 413 before the first byte.
    const auto large = base / "large";
    fs::create_directories(large);
    { std::ofstream(large / "big.bin"); }
    fs::resize_file(large / "big.bin", 0x80000000ull);
    began = false;
    CHECK(store.WriteZip(Root(large), "", 0, [&](const char*, std::size_t) { return true; }, [&] { began = true; return true; }, &started).status == 413);
    CHECK(!began && !started);
  }

  fs::remove_all(base);
  std::puts("web_file_store: ok");
}