// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU Lesser General Public License as published by the Free Software Foundation, either // version 3 of the License, or (at your option) any later version. // // ClassicAPI 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 Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License along with // ClassicAPI. If not, see . // Embedded `!!!ClassicAPI` addon fallback. When the user doesn't have // the addon installed on disk, this module makes the engine think it // does — without writing anything to the filesystem. // // How: // // 1. The CMake build embeds every file under `AddOns/!!!ClassicAPI/` // into a generated header (`embedded_classicapi.h`) as a byte // array per file plus a `{path, data, size}` manifest. // // 2. We hook the engine's file-read function at `FUN_FILE_READ`. // When the engine asks for a path under // `Interface\AddOns\!!!ClassicAPI\`, we allocate a Storm buffer // via the same allocator the engine itself uses, copy the // embedded content in, and hand it back. The caller's normal // `SMemFree` reclaims it on completion — no special lifetime. // // 3. We post-hook the engine's `FUN_ADDON_INIT`. After the engine's // own `Interface\AddOns\` scan finishes, we call the TOC parser // directly with `"!!!ClassicAPI"`. The parser opens its TOC via // our hooked read function and registers the addon as a normal // entry. The TOC parser is dedup-safe: if the user already has // the addon on disk, the engine's scan picked it up, the // hash-table lookup hits, and our call is a no-op. So the // conditional "only if not on disk" behavior is free. // // Same pattern WeirdUtils.dll uses (we reverse-engineered it from // `0x10015A74` while figuring this out). The addon load pass then // reads each `.lua` file through the same hooked read path — // `GlobalStrings.lua`, `Util\Print.lua`, etc. all surface from // embedded buffers. #include "embedded_classicapi.h" #include "Game.h" #include "Offsets.h" #include #include #include namespace Addons::Embedded { namespace { constexpr const char *kAddonName = "!!!ClassicAPI"; constexpr const char *kAddonTocFile = "!!!ClassicAPI.toc"; // `Interface\AddOns\!!!ClassicAPI\` — the prefix the engine // constructs for any of our addon's files. Comparing case- // insensitively because the TOC parser uses `Interface\AddOns\%s\…` // where %s comes from the on-disk directory name, and Windows file // paths are case-insensitive. constexpr const char *kAddonPathPrefix = "Interface\\AddOns\\!!!ClassicAPI\\"; constexpr size_t kAddonPathPrefixLen = 30; // length of the literal above char NormalizeChar(char c) { if (c == '/') return '\\'; if (c >= 'A' && c <= 'Z') return static_cast(c + 32); return c; } bool PathEqualsCI(const char *a, const char *b) { while (*a && *b) { if (NormalizeChar(*a) != NormalizeChar(*b)) return false; ++a; ++b; } return *a == *b; } // Strip the `Interface\AddOns\!!!ClassicAPI\` prefix and return the // suffix (e.g. `Util\Print.lua`) on a match, NULL otherwise. const char *StripAddonPrefix(const char *path) { if (path == nullptr) return nullptr; const char *p = path; const char *q = kAddonPathPrefix; while (*q) { if (*p == '\0') return nullptr; if (NormalizeChar(*p) != NormalizeChar(*q)) return nullptr; ++p; ++q; } return p; } const ClassicAPIFiles::File *LookupEmbedded(const char *suffix) { for (size_t i = 0; i < ClassicAPIFiles::kFileCount; ++i) { if (PathEqualsCI(suffix, ClassicAPIFiles::kFiles[i].path)) return &ClassicAPIFiles::kFiles[i]; } return nullptr; } // Storm allocator — same one `FUN_FILE_READ` uses internally. Buffer // allocated here is freed cleanly by the caller's standard `SMemFree` // (`FUN_STORM_SMEM_FREE`). `__stdcall` per the function's `RET 0x10` // (4 args × 4 bytes = 16) epilogue. // __stdcall void *SMemAlloc(size_t size, const char *file, int line, int flags) using SMemAlloc_t = void *(__stdcall *)(size_t size, const char *file, int line, int flags); // `FUN_FILE_READ` — same shape derived from the Octo decompile. // Calling convention is `__stdcall` (callee cleans 28 bytes via // `RET 0x1C`), not `__cdecl` — confirmed via the function epilogue. // Getting this wrong silently corrupts the caller's stack frame. // __stdcall int FileRead(int unused, const char *path, void **outBuf, // size_t *outSize, size_t extraBytes, // int flag1, int flag2) using FileRead_t = int(__stdcall *)(int unused, const char *path, void **outBuf, size_t *outSize, size_t extraBytes, int flag1, int flag2); FileRead_t FileRead_o = nullptr; // Storm-allocator free. Used to release the disk-TOC buffer after we // scrape its version line — same path the engine itself uses when // `FileRead_o` succeeded and the caller's done with the result. // __stdcall void SMemFree(void *buf, const char *file, int line, int flags) using SMemFree_t = void(__stdcall *)(void *buf, const char *file, int line, int flags); // Extracts the value of the `## Version: X` line from a TOC byte // buffer. Writes into `out` (size `outSize`) and returns true on // success. The TOC format is `## Key: Value`, one per line, case- // sensitive on the key. Returns false if no Version line is found. bool ExtractTocVersion(const char *content, size_t size, char *out, size_t outSize) { static const char kKey[] = "## Version:"; constexpr size_t kKeyLen = sizeof(kKey) - 1; for (size_t i = 0; i + kKeyLen <= size; ++i) { const bool atLineStart = (i == 0) || content[i - 1] == '\n'; if (!atLineStart) continue; if (std::memcmp(content + i, kKey, kKeyLen) != 0) continue; const char *p = content + i + kKeyLen; const char *end = content + size; while (p < end && (*p == ' ' || *p == '\t')) ++p; size_t j = 0; while (p < end && *p != '\r' && *p != '\n' && j + 1 < outSize) { out[j++] = *p++; } while (j > 0 && (out[j - 1] == ' ' || out[j - 1] == '\t')) --j; out[j] = '\0'; return j > 0; } if (outSize > 0) out[0] = '\0'; return false; } // Returns -1/0/+1 for `a < b` / `a == b` / `a > b`. "DEV" is a // sentinel meaning "newer than any real release" — local dev builds // always win against installed-on-disk versions. Otherwise the two // strings are walked as dot-separated numeric semver components // (`1.2` < `1.10`). int CompareVersions(const char *a, const char *b) { const bool aDev = std::strcmp(a, "DEV") == 0; const bool bDev = std::strcmp(b, "DEV") == 0; if (aDev && bDev) return 0; if (aDev) return 1; if (bDev) return -1; while (*a || *b) { int va = 0, vb = 0; while (*a >= '0' && *a <= '9') { va = va * 10 + (*a - '0'); ++a; } while (*b >= '0' && *b <= '9') { vb = vb * 10 + (*b - '0'); ++b; } if (va != vb) return va < vb ? -1 : 1; if (*a == '.') ++a; if (*b == '.') ++b; if (!*a && !*b) break; if (!*a) return -1; if (!*b) return 1; } return 0; } // Pre-extracted embedded TOC version, populated lazily on first // FileRead_h call under our prefix. Empty until populated. char g_embeddedVersion[64] = ""; // Which source wins the embed-vs-disk comparison, decided once on // first relevant file read. enum class Source { Undecided, Disk, Embedded }; Source g_source = Source::Undecided; void EnsureEmbeddedVersionExtracted() { if (g_embeddedVersion[0] != '\0') return; for (size_t i = 0; i < ClassicAPIFiles::kFileCount; ++i) { if (PathEqualsCI(kAddonTocFile, ClassicAPIFiles::kFiles[i].path)) { ExtractTocVersion( reinterpret_cast(ClassicAPIFiles::kFiles[i].data), ClassicAPIFiles::kFiles[i].size, g_embeddedVersion, sizeof(g_embeddedVersion)); return; } } } // Decide whether disk or embedded should serve all reads for this // addon. Called on the first FileRead_h call with a matching prefix. // Reads the on-disk TOC via the original `FUN_FILE_READ` (bypassing // our hook), parses its version, compares to the embedded version, // and caches the winner. If disk has no TOC at all, embedded wins by // default. void DecideSource() { if (g_source != Source::Undecided) return; EnsureEmbeddedVersionExtracted(); char fullPath[256]; std::snprintf(fullPath, sizeof(fullPath), "%s%s", kAddonPathPrefix, kAddonTocFile); void *diskBuf = nullptr; size_t diskSize = 0; const int ok = FileRead_o(0, fullPath, &diskBuf, &diskSize, 1, 1, 0); if (ok == 0 || diskBuf == nullptr) { g_source = Source::Embedded; return; } char diskVersion[64] = ""; ExtractTocVersion(static_cast(diskBuf), diskSize, diskVersion, sizeof(diskVersion)); // Free the disk buffer we just borrowed — we only needed it for // the version-line scrape. The actual content for the engine's // TOC read comes through the regular hook path below. auto SMemFree = reinterpret_cast(Offsets::FUN_STORM_SMEM_FREE); SMemFree(diskBuf, __FILE__, __LINE__, 0); // Missing or unparseable disk version → assume it's older than // anything we ship, embedded wins. if (diskVersion[0] == '\0') { g_source = Source::Embedded; return; } const int cmp = CompareVersions(g_embeddedVersion, diskVersion); g_source = (cmp > 0) ? Source::Embedded : Source::Disk; } int __stdcall FileRead_h(int unused, const char *path, void **outBuf, size_t *outSize, size_t extraBytes, int flag1, int flag2) { const char *suffix = StripAddonPrefix(path); if (suffix == nullptr) { // Path isn't under `Interface\AddOns\!!!ClassicAPI\` — straight // pass-through, we don't care. return FileRead_o(unused, path, outBuf, outSize, extraBytes, flag1, flag2); } DecideSource(); if (g_source == Source::Disk) { // Disk version is at least as new — serve disk. If disk // doesn't have this specific file (e.g. embedded has files // disk doesn't), fall through and try embedded. const int diskResult = FileRead_o(unused, path, outBuf, outSize, extraBytes, flag1, flag2); if (diskResult != 0) return diskResult; } // Source::Embedded path, OR Source::Disk-but-file-missing fallback. // Look up the embedded version and synthesize a Storm buffer the // caller can free normally. const auto *entry = LookupEmbedded(suffix); if (entry == nullptr) { // Not in our embedded set either — let the engine try disk // one more time (returns 0 if that also fails). Covers // pathological cases like an empty disk install + embedded // missing some file. return FileRead_o(unused, path, outBuf, outSize, extraBytes, flag1, flag2); } auto SMemAlloc = reinterpret_cast( Offsets::FUN_STORM_SMEM_ALLOC); const size_t totalSize = entry->size + extraBytes; void *buf = SMemAlloc(totalSize, __FILE__, __LINE__, 0); if (buf == nullptr) return 0; std::memcpy(buf, entry->data, entry->size); if (extraBytes > 0) { std::memset(static_cast(buf) + entry->size, 0, extraBytes); } if (outBuf != nullptr) *outBuf = buf; if (outSize != nullptr) *outSize = entry->size; return 1; } // `FUN_ADDON_INIT` — `__fastcall(accountName)`. We post-hook it: let // the engine's normal `Interface\AddOns\` scan run first, then call // the TOC parser with `"!!!ClassicAPI"`. Dedup-safe — see file header. using AddonInit_t = void(__fastcall *)(const char *accountName); AddonInit_t AddonInit_o = nullptr; using TocParser_t = void(__fastcall *)(const char *name); using ListInsert_t = void(__thiscall *)(void *listCtrl, void *entry, int position, int anchor); // `FUN_TOC_PARSER` appends new entries to the *tail* of the addon // registry's linked list, and the engine's addon-load pass at // `FUN_0051F600` walks that list in *insertion order* (NOT // alphabetical order — the alphabetical sort only applies to the // flat array `GetAddOnInfo(i)` reads from). So our post-hook // injection lands at the very end of the load order, after every // disk-scanned addon. Addons that consume our globals from their // main chunk (idTip's `FrameWatcher`, etc.) would see `nil` and // hard-error during their boot. // // Fix: walk the linked list, find our entry by name, and re-link // it to the head via `FUN_INTRUSIVE_LIST_INSERT(position=1)`. The // engine's own insert helper handles remove-then-insert atomically, // so it's safe to call on an entry that's already in the list. // // Entries are pointed to by `[VAR_ADDON_LIST_HEAD]` (`0x00BE1B6C`), // with the next-pointer field at `entry + 0x10` (computed as // `*(value-at-VAR_ADDON_LIST_CTRL) + entry + 4` = `0xC + entry + 4` // = `entry + 0x10`). Low-bit-1 means "sentinel" (end of list). // Name pointer lives at `entry + 0x14`. constexpr uintptr_t VAR_ADDON_LIST_HEAD = 0x00BE1B6C; constexpr int OFF_ADDON_ENTRY_NAME_PTR = 0x14; void MoveEmbeddedToListHead() { uintptr_t entry = *reinterpret_cast(VAR_ADDON_LIST_HEAD); const int linkOffset = *reinterpret_cast( static_cast(Offsets::VAR_ADDON_LIST_CTRL)); while ((entry & 1) == 0 && entry != 0) { const char *name = *reinterpret_cast( entry + OFF_ADDON_ENTRY_NAME_PTR); if (name != nullptr && std::strcmp(name, kAddonName) == 0) { auto fn = reinterpret_cast( Offsets::FUN_INTRUSIVE_LIST_INSERT); fn(reinterpret_cast( static_cast(Offsets::VAR_ADDON_LIST_CTRL)), reinterpret_cast(entry), /*position=*/ 1, /*anchor=*/ 0); return; } entry = *reinterpret_cast( entry + linkOffset + 4); } } void __fastcall AddonInit_h(const char *accountName) { AddonInit_o(accountName); auto TocParser = reinterpret_cast(Offsets::FUN_TOC_PARSER); TocParser(kAddonName); MoveEmbeddedToListHead(); } const Game::HookAutoRegister _hookFileRead{ Offsets::FUN_FILE_READ, reinterpret_cast(&FileRead_h), reinterpret_cast(&FileRead_o)}; const Game::HookAutoRegister _hookAddonInit{ Offsets::FUN_ADDON_INIT, reinterpret_cast(&AddonInit_h), reinterpret_cast(&AddonInit_o)}; } // namespace } // namespace Addons::Embedded