mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
371 lines
15 KiB
C++
371 lines
15 KiB
C++
// 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 <https://www.gnu.org/licenses/>.
|
||
|
||
// 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 <cstdint>
|
||
#include <cstdio>
|
||
#include <cstring>
|
||
|
||
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<char>(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<const char *>(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<const char *>(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<SMemFree_t>(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<SMemAlloc_t>(
|
||
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<uint8_t *>(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<uintptr_t *>(VAR_ADDON_LIST_HEAD);
|
||
const int linkOffset = *reinterpret_cast<const int *>(
|
||
static_cast<uintptr_t>(Offsets::VAR_ADDON_LIST_CTRL));
|
||
while ((entry & 1) == 0 && entry != 0) {
|
||
const char *name = *reinterpret_cast<const char *const *>(
|
||
entry + OFF_ADDON_ENTRY_NAME_PTR);
|
||
if (name != nullptr && std::strcmp(name, kAddonName) == 0) {
|
||
auto fn = reinterpret_cast<ListInsert_t>(
|
||
Offsets::FUN_INTRUSIVE_LIST_INSERT);
|
||
fn(reinterpret_cast<void *>(
|
||
static_cast<uintptr_t>(Offsets::VAR_ADDON_LIST_CTRL)),
|
||
reinterpret_cast<void *>(entry),
|
||
/*position=*/ 1, /*anchor=*/ 0);
|
||
return;
|
||
}
|
||
entry = *reinterpret_cast<const uintptr_t *>(
|
||
entry + linkOffset + 4);
|
||
}
|
||
}
|
||
|
||
void __fastcall AddonInit_h(const char *accountName) {
|
||
AddonInit_o(accountName);
|
||
auto TocParser = reinterpret_cast<TocParser_t>(Offsets::FUN_TOC_PARSER);
|
||
TocParser(kAddonName);
|
||
MoveEmbeddedToListHead();
|
||
}
|
||
|
||
const Game::HookAutoRegister _hookFileRead{
|
||
Offsets::FUN_FILE_READ,
|
||
reinterpret_cast<void *>(&FileRead_h),
|
||
reinterpret_cast<void **>(&FileRead_o)};
|
||
|
||
const Game::HookAutoRegister _hookAddonInit{
|
||
Offsets::FUN_ADDON_INIT,
|
||
reinterpret_cast<void *>(&AddonInit_h),
|
||
reinterpret_cast<void **>(&AddonInit_o)};
|
||
|
||
} // namespace
|
||
|
||
} // namespace Addons::Embedded
|