detail.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <exception>
#include <format>
#include <optional>
#include <span>
#include <string>
#include <utility>
 
#include <wowlib/audit/roundtrip.hpp>
#include <wowlib/core/buffer.hpp>
#include <wowlib/core/client_version.hpp>
#include <wowlib/formats/common/chunked_file.hpp>
#include <wowlib/formats/common/fourcc.hpp>
#include <wowlib/fs/filesystem.hpp>
 
namespace wowlib::audit::detail {
  inline RoundtripReport failed(std::string stage, std::string error) {
    RoundtripReport report;
    report.ok = false;
    report.stage = std::move(stage);
    report.error = std::move(error);
    return report;
  }

  inline RoundtripReport skipped(std::string_view reason) {
    RoundtripReport report;
    report.stage = std::format("skipped:{}", reason);
    return report;
  }

  inline RoundtripReport failWith(RoundtripReport& report, std::string stage, std::string error) {
    report.ok = false;
    report.stage = std::move(stage);
    report.error = std::move(error);
    return std::move(report);
  }

  inline std::optional<RoundtripReport> classifyRead(RoundtripReport& report,
                                                      std::string stage,
                                                      const Result<FileBuffer>& result) {
    if (!result) {
      if (result.error().code == ErrorCode::EncryptedContent) return skipped("encrypted");
      return failWith(report, std::move(stage), result.error().message);
    }
    if (result->empty()) return skipped("empty-file");
    return std::nullopt;
  }

  inline void tallyUnknown(RoundtripReport& report,
                            const formats::ChunkExtras& extras,
                            formats::FourCCEndian endian = formats::FourCCEndian::Reversed) {
    for (const formats::UnknownChunk& unknown : extras.unknown)
      report.unknownChunks.push_back(formats::fourccToString(unknown.fourcc, endian));
  }

  template <typename F>
  RoundtripReport guarded(F&& f) {
    try {
      return f();
    }
    catch (const std::exception& e) {
      return failed("exception", e.what());
    }
    catch (...) {
      return failed("exception", "unknown exception");
    }
  }

  inline std::optional<std::string> firstDivergence(const FileBuffer& original, const FileBuffer& rewritten) {
    if (original == rewritten) return std::nullopt;
 
    const std::size_t common = std::min(original.size(), rewritten.size());
    std::size_t at = 0;
    while (at < common && original[at] == rewritten[at]) ++at;
    return std::format("first divergence at {:#x} (sizes {} vs {})", at, original.size(), rewritten.size());
  }

  inline std::optional<std::string> firstDivergenceChunked(const FileBuffer& original, const FileBuffer& rewritten) {
    if (original == rewritten) return std::nullopt;
 
    const std::size_t common = std::min(original.size(), rewritten.size());
    std::size_t at = 0;
    while (at < common && original[at] == rewritten[at]) ++at;
 
    // locate the chunk of the original stream the divergence falls into
    std::string inside = "<no chunk>";
    for (std::size_t pos = 0; pos + 8 <= original.size();) {
      std::uint32_t fourcc = 0;
      std::uint32_t size = 0;
      std::memcpy(&fourcc, original.data() + pos, 4);
      std::memcpy(&size, original.data() + pos + 4, 4);
      if (at < pos + 8 + size) {
        inside = formats::fourccToString(fourcc);
        break;
      }
      pos += 8 + size;
    }
    return std::format("first divergence at {:#x} inside chunk {} (sizes {} vs {})", at, inside, original.size(),
                       rewritten.size());
  }

  template <typename F>
  bool withVersion(const ClientVersion v, F&& f) {
    bool matched = false;
    const auto tryOne = [&]<ClientVersion V>() {
      if (!matched && v == V) {
        matched = true;
        f.template operator()<V>();
      }
    };
    tryOne.template operator()<versions::Vanilla>();
    tryOne.template operator()<versions::Tbc>();
    tryOne.template operator()<versions::Wotlk>();
    tryOne.template operator()<versions::Cata>();
    tryOne.template operator()<versions::Mop>();
    tryOne.template operator()<versions::Wod>();
    tryOne.template operator()<versions::Legion>();
    tryOne.template operator()<versions::Bfa>();
    tryOne.template operator()<versions::Shadowlands>();
    tryOne.template operator()<versions::Dragonflight>();
    tryOne.template operator()<versions::Tww>();
    return matched;
  }

  constexpr bool versionSupported(std::span<const ClientVersion> grid, const ClientVersion v) {
    for (const ClientVersion& g : grid)
      if (g == v) return true;
    return false;
  }

  inline RoundtripReport unrecognizedVersion(const ClientVersion v) {
    return failed("dispatch", std::format(
                    "unrecognized client version {}.{}.{} (build {}) — not one of " "the targeted releases", v.major,
                    v.minor, v.patch, v.build));
  }

  class FormatDrivers {
  public:
    static RoundtripReport wmo(fs::FileSystem& fs, const std::string& path, ClientVersion version);

    static RoundtripReport m2(fs::FileSystem& fs, const std::string& path, ClientVersion version);

    static RoundtripReport adt(fs::FileSystem& fs, const std::string& path, ClientVersion version);

    static RoundtripReport wdt(fs::FileSystem& fs, const std::string& path, ClientVersion version);

    static RoundtripReport wdl(fs::FileSystem& fs, const std::string& path, ClientVersion version);

    static RoundtripReport blp(fs::FileSystem& fs, const std::string& path);
  };
}