steam-frame/spoopyghosty0--frameport
1
0 Fork 0
mirror of https://github.com/spoopyghosty0/frameport.git synced 2026-10-17 12:01:23 +02:00
Code Issues Packages Projects Releases 32 Wiki Activity
Files
927dae5ff899574ff6a39fee5065d1663e51dfb3
spoopyghosty0--frameport/native/langpack/langpack.c
T

1067 lines
42 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-3.0-only
//
// FramePort language packs: answers the Meta Platform SDK's language-pack calls from `*.lang` files that already
// sit in the game's data (OBB / app files), without any download.
//
// Why: OVRPort's libovrplatformloader.so is a dispatcher in front of Meta's own loader (…_meta.so). It answers
// ovr_LanguagePack_GetCurrent / ovr_LanguagePack_SetCurrent with `return 0` (request id 0, no message ever comes
// back), so a game that asks for its language pack waits for an answer that never arrives.
//
// How it is wired (patch frame.langpacks):
// * this library becomes the first DT_NEEDED of the dispatcher;
// * the dispatcher's own exports of the functions defined here are marked STB_LOCAL in its .dynsym, so symbol
// lookups (the game's imports and dlsym on the dispatcher's handle) continue to this library;
// * everything we do not answer ourselves is forwarded to the dispatcher's original function, found at run time by
// reading the dispatcher's in-memory .dynsym (the entries are still there, only no longer visible to lookups).
//
// What it implements (see https://developers.meta.com/vr/documentation/native/ps-language-packs/):
// ovr_LanguagePack_GetCurrent / SetCurrent answered here
// ovr_AssetFile_GetList the dispatcher's list + our packs (type "language_pack")
// ovr_AssetFile_StatusById answered here for our packs (always "installed")
// ovr_PopMessage, ovr_FreeMessage, ovr_Message_*, ovr_AssetDetails*_*, ovr_LanguagePackInfo_*,
// ovr_AssetFileDownloadResult_*, ovr_Error_* wrappers: our messages/handles are served here, any other
// handle goes to the dispatcher unchanged
//
// Where the packs are looked for (first file per tag wins; depth <= 3):
// $FRAMEPORT_LANGPACK_DIRS (':'-separated), otherwise
// /sdcard/Android/obb/<pkg>, /sdcard/Android/data/<pkg>/files, the same under /storage/emulated/0, and
// /data/steam_app/obb (where Lepton mounts the host's obb folder)
// A pack is a regular file named <BCP47 tag>.lang (de.lang -> tag "de").
//
// Which pack is "current": the one the game applied with SetCurrent; else $FRAMEPORT_LANGPACK (a tag); else the only
// pack if there is exactly one.
//
// Content files (patch frame.asset_files, which sets the marker byte g_assets_slot; or FRAMEPORT_ASSET_FILES=1):
// every *.pak next to the game's OBB is also listed as an installed asset file of type "default" (Meta's type for
// content that comes with the game, IAP status "free"), named after the file. ovr_AssetFile_DownloadById on one of
// them answers at once with a completed download update and a result carrying the file's path (nothing is copied).
// E.g. Star Wars: Tales from the Galaxy's Edge, whose seasons and sound banks are such files (ETacoDLC::Season1...).
#define _GNU_SOURCE
#include <ctype.h>
#include <dirent.h>
#include <dlfcn.h>
#include <elf.h>
#include <link.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#ifdef __ANDROID__
#include <android/log.h>
#endif
#define EXPORT __attribute__((visibility("default")))
typedef uint64_t u64;
typedef uint32_t u32;
// Log line (logcat tag "fp_langpack" on Android, so it lands in the game's launch.log; on other systems stderr, only
// when $FRAMEPORT_LANGPACK_DEBUG is set).
static void fplog(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
static void fplog(const char *fmt, ...) {
char line[512];
va_list ap;
va_start(ap, fmt);
vsnprintf(line, sizeof line, fmt, ap);
va_end(ap);
#ifdef __ANDROID__
__android_log_print(ANDROID_LOG_INFO, "fp_langpack", "%s", line);
#else
if (getenv("FRAMEPORT_LANGPACK_DEBUG")) fprintf(stderr, "fp_langpack: %s\n", line);
#endif
}
// accessor calls can repeat every frame: only the first FP_TRACE_MAX are logged
#define FP_TRACE_MAX 400
static int g_traced;
#define fptrace(...) \
do { \
if (__atomic_fetch_add(&g_traced, 1, __ATOMIC_RELAXED) < FP_TRACE_MAX) fplog(__VA_ARGS__); \
} while (0)
// how long the dispatcher gets to answer AssetFile_GetList before we answer with our packs alone
#ifndef FP_LIST_TIMEOUT_MS
#define FP_LIST_TIMEOUT_MS 1500
#endif
#ifndef FP_LOADER_BASENAME
#define FP_LOADER_BASENAME "libovrplatformloader.so"
#endif
// ovrMessageType values (same table as native/platformcompat/message_type.cpp)
#define MSG_ASSETFILE_GETLIST 0x4AFC6F74u
#define MSG_ASSETFILE_STATUSBYID 0x5D955D38u
#define MSG_LANGUAGEPACK_GETCURRENT 0x1F90F0D5u
#define MSG_LANGUAGEPACK_SETCURRENT 0x5B4FBBE0u
#define MSG_ASSETFILE_DOWNLOADBYID 0x2D008992u
#define MSG_NOTIFICATION_DOWNLOADUPDATE 0x2FDD0CCDu
#define MAXP 32
#define PATHLEN 1024
#define MAX_DEPTH 3
/* ---------------------------------------------------------------------------------------------------------------
* Finding the dispatcher's original functions
* ------------------------------------------------------------------------------------------------------------- */
typedef struct {
const char *name;
void *addr;
} find_t;
static uintptr_t fixptr(uintptr_t base, uintptr_t v) {
// bionic leaves d_ptr as a link-time address, glibc adds the load bias in place
return v < base ? base + v : v;
}
static size_t count_syms(uintptr_t base, const ElfW(Dyn) *dyn) {
const uint32_t *gnu = NULL, *sysv = NULL;
for (const ElfW(Dyn) *d = dyn; d->d_tag != DT_NULL; d++) {
if (d->d_tag == DT_GNU_HASH) gnu = (const uint32_t *)fixptr(base, d->d_un.d_ptr);
if (d->d_tag == DT_HASH) sysv = (const uint32_t *)fixptr(base, d->d_un.d_ptr);
}
if (sysv) return sysv[1]; // nchain
if (!gnu) return 0;
uint32_t nbuckets = gnu[0], symoffset = gnu[1], bloom_size = gnu[2];
const uint32_t *buckets = gnu + 4 + bloom_size * (sizeof(ElfW(Addr)) / 4);
const uint32_t *chains = buckets + nbuckets;
uint32_t max = 0;
for (uint32_t i = 0; i < nbuckets; i++)
if (buckets[i] > max) max = buckets[i];
if (max < symoffset) return symoffset;
while (!(chains[max - symoffset] & 1)) max++;
return (size_t)max + 1;
}
static int find_cb(struct dl_phdr_info *info, size_t size, void *data) {
(void)size;
find_t *f = (find_t *)data;
const char *n = info->dlpi_name ? info->dlpi_name : "";
const char *slash = strrchr(n, '/');
if (strcmp(slash ? slash + 1 : n, FP_LOADER_BASENAME) != 0) return 0;
uintptr_t base = info->dlpi_addr;
const ElfW(Dyn) *dyn = NULL;
for (int i = 0; i < info->dlpi_phnum; i++)
if (info->dlpi_phdr[i].p_type == PT_DYNAMIC) dyn = (const ElfW(Dyn) *)(base + info->dlpi_phdr[i].p_vaddr);
if (!dyn) return 1;
const ElfW(Sym) *symtab = NULL;
const char *strtab = NULL;
for (const ElfW(Dyn) *d = dyn; d->d_tag != DT_NULL; d++) {
if (d->d_tag == DT_SYMTAB) symtab = (const ElfW(Sym) *)fixptr(base, d->d_un.d_ptr);
if (d->d_tag == DT_STRTAB) strtab = (const char *)fixptr(base, d->d_un.d_ptr);
}
size_t n_syms = count_syms(base, dyn);
if (!symtab || !strtab || !n_syms) return 1;
for (size_t i = 1; i < n_syms; i++) {
const ElfW(Sym) *s = &symtab[i];
if (s->st_shndx == SHN_UNDEF || s->st_value == 0) continue;
if (ELF64_ST_TYPE(s->st_info) != STT_FUNC) continue;
if (strcmp(strtab + s->st_name, f->name) == 0) {
f->addr = (void *)(base + s->st_value);
break;
}
}
return 1;
}
static void *orig_sym(const char *name) {
find_t f = {name, NULL};
dl_iterate_phdr(find_cb, &f);
return f.addr;
}
// o_<Name>(...) calls the dispatcher's original ovr_<Name>; 0/NULL when it has none
#define DEFORIG(RET, NAME, PARAMS, ARGS) \
static RET o_##NAME PARAMS { \
typedef RET(*fn_t) PARAMS; \
static fn_t f; \
static int tried; \
if (!tried) { \
f = (fn_t)orig_sym("ovr_" #NAME); \
tried = 1; \
} \
return f ? f ARGS : (RET)0; \
}
DEFORIG(void *, PopMessage, (void), ())
DEFORIG(void, FreeMessage, (void *m), (m))
DEFORIG(u32, Message_GetType, (const void *m), (m))
DEFORIG(u64, Message_GetRequestID, (const void *m), (m))
DEFORIG(_Bool, Message_IsError, (const void *m), (m))
DEFORIG(void *, Message_GetError, (const void *m), (m))
DEFORIG(void *, Message_GetAssetDetails, (const void *m), (m))
DEFORIG(void *, Message_GetAssetDetailsArray, (const void *m), (m))
DEFORIG(void *, Message_GetAssetFileDownloadResult, (const void *m), (m))
DEFORIG(size_t, AssetDetailsArray_GetSize, (const void *a), (a))
DEFORIG(void *, AssetDetailsArray_GetElement, (const void *a, size_t i), (a, i))
DEFORIG(u64, AssetDetails_GetAssetId, (const void *d), (d))
DEFORIG(const char *, AssetDetails_GetAssetType, (const void *d), (d))
DEFORIG(const char *, AssetDetails_GetDownloadStatus, (const void *d), (d))
DEFORIG(const char *, AssetDetails_GetFilepath, (const void *d), (d))
DEFORIG(const char *, AssetDetails_GetIapStatus, (const void *d), (d))
DEFORIG(void *, AssetDetails_GetLanguage, (const void *d), (d))
DEFORIG(const char *, AssetDetails_GetMetadata, (const void *d), (d))
DEFORIG(const char *, LanguagePackInfo_GetTag, (const void *l), (l))
DEFORIG(const char *, LanguagePackInfo_GetEnglishName, (const void *l), (l))
DEFORIG(const char *, LanguagePackInfo_GetNativeName, (const void *l), (l))
DEFORIG(u64, AssetFileDownloadResult_GetAssetId, (const void *r), (r))
DEFORIG(const char *, AssetFileDownloadResult_GetFilepath, (const void *r), (r))
DEFORIG(u64, AssetFile_GetList, (void), ())
DEFORIG(u64, AssetFile_StatusById, (u64 id), (id))
DEFORIG(u64, AssetFile_DownloadById, (u64 id), (id))
DEFORIG(void *, Message_GetAssetFileDownloadUpdate, (const void *m), (m))
DEFORIG(u64, AssetFileDownloadUpdate_GetAssetFileId, (const void *u), (u))
DEFORIG(u64, AssetFileDownloadUpdate_GetBytesTotal, (const void *u), (u))
DEFORIG(long long, AssetFileDownloadUpdate_GetBytesTransferred, (const void *u), (u))
DEFORIG(_Bool, AssetFileDownloadUpdate_GetCompleted, (const void *u), (u))
DEFORIG(int, Error_GetCode, (const void *e), (e))
DEFORIG(int, Error_GetHttpCode, (const void *e), (e))
DEFORIG(const char *, Error_GetMessage, (const void *e), (e))
DEFORIG(const char *, Error_GetDisplayableMessage, (const void *e), (e))
/* ---------------------------------------------------------------------------------------------------------------
* Finding the packs
* ------------------------------------------------------------------------------------------------------------- */
typedef struct {
char tag[48]; // language packs: the BCP47 tag; content files: empty
char name[128]; // content files: the file name (the asset's name)
char path[PATHLEN];
u64 id;
long long size;
int content;
} pack_t;
static const struct {
const char *tag, *en, *native;
} NAMES[] = {
{"en", "English", "English"}, {"de", "German", "Deutsch"}, {"fr", "French", "Français"},
{"es", "Spanish", "Español"}, {"it", "Italian", "Italiano"}, {"pt", "Portuguese", "Português"},
{"nl", "Dutch", "Nederlands"}, {"pl", "Polish", "Polski"}, {"ru", "Russian", "Русский"},
{"tr", "Turkish", "Türkçe"}, {"ja", "Japanese", "日本語"}, {"ko", "Korean", "한국어"},
{"zh", "Chinese", "中文"}, {"ar", "Arabic", "العربية"}, {"cs", "Czech", "Čeština"},
{"sv", "Swedish", "Svenska"}, {"da", "Danish", "Dansk"}, {"fi", "Finnish", "Suomi"},
{"nb", "Norwegian", "Norsk"}, {"hu", "Hungarian", "Magyar"}, {"uk", "Ukrainian", "Українська"},
{"el", "Greek", "Ελληνικά"}, {"he", "Hebrew", "עברית"}, {"th", "Thai", "ไทย"},
{"id", "Indonesian", "Indonesia"}, {"vi", "Vietnamese", "Tiếng Việt"}, {"ro", "Romanian", "Română"},
};
static u64 hash_tag(const char *tag) {
u64 h = 1469598103934665603ULL; // FNV-1a over the lower-case tag
for (const char *p = tag; *p; p++) {
h ^= (unsigned char)((*p >= 'A' && *p <= 'Z') ? *p + 32 : *p);
h *= 1099511628211ULL;
}
return 0x4650000000000000ULL | (h & 0x0000FFFFFFFFFFFFULL); // 'FP' prefix: never a store asset id
}
static int tag_eq(const char *a, const char *b) { return strcasecmp(a, b) == 0; }
static int base_len(const char *tag) {
int n = 0;
while (tag[n] && tag[n] != '-' && tag[n] != '_') n++;
return n;
}
static int valid_tag(const char *t) {
if (!*t) return 0;
for (; *t; t++)
if (!((*t >= 'a' && *t <= 'z') || (*t >= 'A' && *t <= 'Z') || (*t >= '0' && *t <= '9') || *t == '-' ||
*t == '_'))
return 0;
return 1;
}
static void add_pack(pack_t *out, int *n, const char *tag, const char *path) {
for (int i = 0; i < *n; i++)
if (!out[i].content && tag_eq(out[i].tag, tag)) return; // first one wins
pack_t *p = &out[(*n)++];
memset(p, 0, sizeof *p);
snprintf(p->tag, sizeof p->tag, "%s", tag);
snprintf(p->path, sizeof p->path, "%s", path);
p->id = hash_tag(tag);
}
static int g_logged_dirs;
// frame.asset_files sets the byte after the marker to '1' (frameport.patches.frame.langpack.with_assets)
#define ASSETS_MARK "@FPASSETS@"
__attribute__((used)) static char g_assets_slot[sizeof ASSETS_MARK + 1] = ASSETS_MARK "0";
static int assets_enabled(void) {
const char *env = getenv("FRAMEPORT_ASSET_FILES");
if (env && *env) return *env == '1';
return ((const volatile char *)g_assets_slot)[sizeof ASSETS_MARK - 1] == '1';
}
// Triage-only bypass for games blocked on Meta's unavailable asset-file service. No file paths are invented.
#define STUB_MARK "@FPASSETSTUB@"
__attribute__((used)) static char g_stub_slot[sizeof STUB_MARK + 1] = STUB_MARK "0";
static int stub_enabled(void) {
const char *env = getenv("FRAMEPORT_ASSET_FILES_STUB");
if (env && *env) return *env == '1';
return ((const volatile char *)g_stub_slot)[sizeof STUB_MARK - 1] == '1';
}
static u64 hash_name(const char *name) {
u64 h = 1469598103934665603ULL ^ 0x66; // FNV-1a, seeded apart from the tags
for (const char *p = name; *p; p++) {
h ^= (unsigned char)((*p >= 'A' && *p <= 'Z') ? *p + 32 : *p);
h *= 1099511628211ULL;
}
return 0x4650000000000000ULL | (h & 0x0000FFFFFFFFFFFFULL);
}
static void add_content(pack_t *out, int *n, const char *name, const char *path, long long size) {
for (int i = 0; i < *n; i++)
if (out[i].content && strcasecmp(out[i].name, name) == 0) return; // first one wins
pack_t *p = &out[(*n)++];
memset(p, 0, sizeof *p);
p->content = 1;
snprintf(p->name, sizeof p->name, "%.127s", name); // (callers pass names shorter than 128)
snprintf(p->path, sizeof p->path, "%s", path);
p->size = size;
p->id = hash_name(name);
}
// Tags to leave out of the list (comma separated, case-insensitive): env FRAMEPORT_LANGPACK_SKIP, plus the lines
// of a file "fp_langpack_skip" in any scanned folder. For finding out which pack a game needs reported: e.g. a game
// whose built-in language works without being a "pack".
static __thread char g_skip[160]; // per thread: scans may run on several game threads at once
static void read_skip_file(const char *dir) {
char path[PATHLEN], line[160];
if (snprintf(path, sizeof path, "%s/fp_langpack_skip", dir) >= (int)sizeof path) return;
FILE *f = fopen(path, "r");
if (!f) return;
size_t n = fread(line, 1, sizeof line - 1, f);
fclose(f);
line[n] = 0;
for (char *c = line; *c; c++)
if (*c == '\n' || *c == '\r' || *c == ' ') *c = ',';
size_t have = strlen(g_skip), room = sizeof g_skip - have;
if (room > 3) snprintf(g_skip + have, room, ",%.*s,", (int)room - 3, line);
}
static int skipped(const char *tag) {
char want[64], have[sizeof g_skip + 2];
snprintf(want, sizeof want, ",%s,", tag);
snprintf(have, sizeof have, ",%s,%s", getenv("FRAMEPORT_LANGPACK_SKIP") ? getenv("FRAMEPORT_LANGPACK_SKIP") : "",
g_skip);
for (char *c = want; *c; c++) *c = (char)tolower((unsigned char)*c);
for (char *c = have; *c; c++) *c = (char)tolower((unsigned char)*c);
return strstr(have, want) != NULL;
}
static void scan_dir(const char *dir, int depth, pack_t *out, int *n) {
DIR *d = opendir(dir);
if (d && depth == 0) read_skip_file(dir);
if (!g_logged_dirs && depth == 0) fplog("looking in %s: %s", dir, d ? "found" : "not readable");
if (!d) return;
struct dirent *e;
while (*n < MAXP && (e = readdir(d)) != NULL) {
if (e->d_name[0] == '.') continue;
char path[PATHLEN];
if (snprintf(path, sizeof path, "%s/%s", dir, e->d_name) >= (int)sizeof path) continue;
struct stat st;
if (stat(path, &st) != 0) continue;
if (S_ISDIR(st.st_mode)) {
if (depth < MAX_DEPTH) scan_dir(path, depth + 1, out, n);
} else if (S_ISREG(st.st_mode)) {
size_t len = strlen(e->d_name);
if (len > 5 && strcasecmp(e->d_name + len - 5, ".lang") == 0) {
char tag[48];
if (len - 5 >= sizeof tag) continue;
memcpy(tag, e->d_name, len - 5);
tag[len - 5] = 0;
if (valid_tag(tag) && !skipped(tag)) add_pack(out, n, tag, path);
} else if (len > 4 && strcasecmp(e->d_name + len - 4, ".pak") == 0 && assets_enabled() &&
strlen(e->d_name) < sizeof out[0].name) {
add_content(out, n, e->d_name, path, (long long)st.st_size);
}
}
}
closedir(d);
}
static void package_name(char *out, size_t cap) {
out[0] = 0;
FILE *f = fopen("/proc/self/cmdline", "r");
if (!f) return;
size_t n = fread(out, 1, cap - 1, f);
fclose(f);
out[n] = 0; // argv[0] ends at the first NUL: the package (or package:process)
char *colon = strchr(out, ':');
if (colon) *colon = 0;
}
static int scan_dirs(pack_t *out);
static int scan(pack_t *out) {
int n = scan_dirs(out);
static int last = -1;
if (n != last) {
last = n;
fplog("%d language pack(s) and content file(s) found", n);
for (int i = 0; i < n; i++)
fplog(" %s %s -> %s", out[i].content ? "content" : "pack", out[i].content ? out[i].name : out[i].tag,
out[i].path);
}
g_logged_dirs = 1;
return n;
}
static int scan_dirs(pack_t *out) {
int n = 0;
g_skip[0] = 0; // read again from the folders below
const char *dirs = getenv("FRAMEPORT_LANGPACK_DIRS");
if (dirs && *dirs) {
char buf[PATHLEN * 2];
snprintf(buf, sizeof buf, "%s", dirs);
for (char *save = NULL, *p = strtok_r(buf, ":", &save); p; p = strtok_r(NULL, ":", &save)) scan_dir(p, 0, out, &n);
return n;
}
char pkg[256];
package_name(pkg, sizeof pkg);
if (!g_logged_dirs) fplog("package \"%s\"", pkg);
if (!pkg[0] || strchr(pkg, '/')) return 0;
// Unreal names the files of an Android game by their /storage/emulated/0 path (its own OBB mount does), so that
// spelling comes first: a pack found in both gets the path the engine would use itself.
static const char *const FORMATS[] = {"/storage/emulated/0/Android/obb/%s",
"/storage/emulated/0/Android/data/%s/files", "/sdcard/Android/obb/%s",
"/sdcard/Android/data/%s/files"};
for (size_t i = 0; i < sizeof FORMATS / sizeof *FORMATS; i++) {
char dir[PATHLEN];
snprintf(dir, sizeof dir, FORMATS[i], pkg);
scan_dir(dir, 0, out, &n);
}
// Lepton mounts the host's <app>/lepton-app/obb here (read-only) and only links /sdcard/Android/obb/<pkg> to it
// at boot (liblepton/mounting.sh: podman_mount_entry "$LEPTON_MOUNT_OBB_DIR" "/$APP_MOUNT_TARGET/obb", default
// APP_MOUNT_TARGET=data/steam_app), so look there too.
scan_dir("/data/steam_app/obb", 0, out, &n);
return n;
}
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
static char g_current[48]; // tag the game applied with SetCurrent
static int find_tag(const pack_t *p, int n, const char *tag) {
for (int i = 0; i < n; i++)
if (!p[i].content && tag_eq(p[i].tag, tag)) return i;
int bl = base_len(tag); // "de-DE" -> "de" (and the reverse: "de" asked, "de-de" present)
for (int i = 0; i < n; i++)
if (!p[i].content && base_len(p[i].tag) == bl && strncasecmp(p[i].tag, tag, (size_t)bl) == 0) return i;
return -1;
}
static int pick_current(const pack_t *p, int n) {
char want[48] = "";
pthread_mutex_lock(&g_lock);
snprintf(want, sizeof want, "%s", g_current);
pthread_mutex_unlock(&g_lock);
if (want[0]) {
int i = find_tag(p, n, want);
if (i >= 0) return i;
}
const char *env = getenv("FRAMEPORT_LANGPACK");
if (env && *env) {
int i = find_tag(p, n, env);
if (i >= 0) return i;
}
int only = -1, langs = 0;
for (int i = 0; i < n; i++)
if (!p[i].content) only = i, langs++;
return langs == 1 ? only : -1;
}
/* ---------------------------------------------------------------------------------------------------------------
* Messages and handles. Every object we hand out lives inside one msg_t, so "is this handle ours" is an address
* range check against the live messages.
* ------------------------------------------------------------------------------------------------------------- */
// The asset's Metadata. Deadpool VR (Unreal) only accepts a language pack whose Metadata equals its own version string
// ("1.0.40.356975.Quest", built from five parts with "%s.%s.%s.%s.%s"), which Meta's store sets at upload. The
// patch writes the game's versionName behind the marker below (frame.langpacks, frameport.patches.frame.langpack);
// FRAMEPORT_LANGPACK_META overrides it. Without either the Metadata stays empty, as before.
#define META_LEN 96
#define META_MARK "@FPMETA@"
__attribute__((used)) static char g_meta_slot[sizeof META_MARK + META_LEN] = META_MARK;
static void pack_meta(char *out) {
const char *env = getenv("FRAMEPORT_LANGPACK_META");
const volatile char *slot = g_meta_slot + sizeof META_MARK;
out[0] = 0;
if (env && *env) snprintf(out, META_LEN, "%s", env);
else {
int i = 0;
for (; i < META_LEN - 1 && slot[i]; i++) out[i] = slot[i];
out[i] = 0;
}
}
typedef struct {
char tag[48], en[64], nat[64];
} lang_t;
typedef struct {
u64 id;
char type[16], status[16], iap[8], meta[META_LEN];
char path[PATHLEN];
lang_t *lang;
} details_t;
typedef struct {
u64 id;
char path[PATHLEN];
} result_t;
typedef struct {
int code, http;
char msg[128];
} err_t;
typedef struct {
u64 id;
long long total, done;
int completed;
} update_t;
typedef struct msg {
struct msg *all_next, *q_next;
u32 type;
u64 req;
int is_error, has_det, has_res, has_upd;
err_t err;
update_t upd;
details_t det;
lang_t lng;
result_t res;
u32 arr; // its address is the handle of the details array
int n;
details_t dets[MAXP];
lang_t langs[MAXP];
void *orig_msg, *orig_arr;
size_t orig_n;
} msg_t;
static msg_t *g_all, *g_qhead, *g_qtail;
static u64 g_next_req = 0x4650000000000001ULL;
#define MAX_PENDING 16
static u64 g_pending[MAX_PENDING];
static u64 g_pending_ms[MAX_PENDING];
static u64 g_expired[MAX_PENDING]; // requests we answered ourselves after the timeout: their late answer is dropped
static int g_expired_next; // when each one was asked // dispatcher requests whose AssetFile_GetList answer we extend
static msg_t *owner(const void *p) {
msg_t *found = NULL;
pthread_mutex_lock(&g_lock);
for (msg_t *m = g_all; m; m = m->all_next)
if ((const char *)p >= (const char *)m && (const char *)p < (const char *)m + sizeof *m) {
found = m;
break;
}
pthread_mutex_unlock(&g_lock);
return found;
}
static msg_t *new_msg(u32 type, u64 req) {
msg_t *m = (msg_t *)calloc(1, sizeof *m);
if (!m) return NULL;
m->type = type;
m->req = req ? req : __atomic_fetch_add(&g_next_req, 1, __ATOMIC_RELAXED);
pthread_mutex_lock(&g_lock);
m->all_next = g_all;
g_all = m;
pthread_mutex_unlock(&g_lock);
return m;
}
static void post(msg_t *m) {
pthread_mutex_lock(&g_lock);
m->q_next = NULL;
if (g_qtail) g_qtail->q_next = m;
else g_qhead = m;
g_qtail = m;
pthread_mutex_unlock(&g_lock);
}
static void fail(msg_t *m, int code, const char *text) {
m->is_error = 1;
m->err.code = code;
snprintf(m->err.msg, sizeof m->err.msg, "%s", text);
}
static void fill_details(details_t *d, lang_t *l, const pack_t *p) {
if (p->content) { // content that comes with the game: Meta's "default" asset type, nothing to buy
d->id = p->id;
snprintf(d->type, sizeof d->type, "default");
snprintf(d->status, sizeof d->status, "installed");
snprintf(d->iap, sizeof d->iap, "free");
snprintf(d->path, sizeof d->path, "%s", p->path);
d->meta[0] = 0;
d->lang = NULL;
return;
}
d->id = p->id;
snprintf(d->type, sizeof d->type, "language_pack");
snprintf(d->status, sizeof d->status, "installed");
snprintf(d->iap, sizeof d->iap, "free");
snprintf(d->path, sizeof d->path, "%s", p->path);
pack_meta(d->meta);
snprintf(l->tag, sizeof l->tag, "%s", p->tag);
snprintf(l->en, sizeof l->en, "%s", p->tag);
snprintf(l->nat, sizeof l->nat, "%s", p->tag);
int bl = base_len(p->tag);
for (size_t i = 0; i < sizeof NAMES / sizeof *NAMES; i++)
if ((int)strlen(NAMES[i].tag) == bl && strncasecmp(NAMES[i].tag, p->tag, (size_t)bl) == 0) {
snprintf(l->en, sizeof l->en, "%s", NAMES[i].en);
snprintf(l->nat, sizeof l->nat, "%s", NAMES[i].native);
break;
}
d->lang = l;
}
static u64 now_ms(void) {
struct timespec t;
clock_gettime(CLOCK_MONOTONIC, &t);
return (u64)t.tv_sec * 1000u + (u64)t.tv_nsec / 1000000u;
}
static int take_pending(u64 req) {
int hit = 0;
pthread_mutex_lock(&g_lock);
for (int i = 0; i < MAX_PENDING; i++)
if (g_pending[i] == req) {
g_pending[i] = 0;
hit = 1;
break;
}
pthread_mutex_unlock(&g_lock);
return hit;
}
static int take_expired(u64 req) {
int hit = 0;
pthread_mutex_lock(&g_lock);
for (int i = 0; i < MAX_PENDING; i++)
if (req && g_expired[i] == req) {
g_expired[i] = 0;
hit = 1;
break;
}
pthread_mutex_unlock(&g_lock);
return hit;
}
static void add_pending(u64 req) {
pthread_mutex_lock(&g_lock);
for (int i = 0; i < MAX_PENDING; i++)
if (!g_pending[i]) {
g_pending[i] = req;
g_pending_ms[i] = now_ms();
break;
}
pthread_mutex_unlock(&g_lock);
}
static void fill_list(msg_t *m, const pack_t *p, int n) {
for (int i = 0; i < n && i < MAXP; i++) fill_details(&m->dets[i], &m->langs[i], &p[i]);
m->n = n < MAXP ? n : MAXP;
}
// The dispatcher's AssetFile_GetList answer arrived: ours + theirs in one array.
static void *wrap_list(void *orig) {
pack_t packs[MAXP];
int n = scan(packs);
if (n == 0) return orig;
msg_t *m = new_msg(MSG_ASSETFILE_GETLIST, o_Message_GetRequestID(orig));
if (!m) return orig;
fill_list(m, packs, n);
m->orig_msg = orig;
if (!o_Message_IsError(orig)) {
m->orig_arr = o_Message_GetAssetDetailsArray(orig);
if (m->orig_arr) m->orig_n = o_AssetDetailsArray_GetSize(m->orig_arr);
}
return m;
}
// A GetList the dispatcher has not answered within FP_LIST_TIMEOUT_MS: answer with our packs alone (request id kept).
// Returns NULL if nothing is overdue or no pack exists (then a late answer from the dispatcher still reaches the
// game); once we answered, the dispatcher's late answer is dropped (ovr_PopMessage), so the game gets one answer.
static msg_t *expire_pending(void) {
u64 req = 0, now = now_ms();
pthread_mutex_lock(&g_lock);
for (int i = 0; i < MAX_PENDING; i++)
if (g_pending[i] && now - g_pending_ms[i] >= FP_LIST_TIMEOUT_MS) {
req = g_pending[i];
g_pending[i] = 0;
break;
}
pthread_mutex_unlock(&g_lock);
if (!req) return NULL;
pack_t packs[MAXP];
int n = scan(packs);
fplog("AssetFile_GetList %llu: no answer after %d ms, answering with %d pack(s)", (unsigned long long)req,
FP_LIST_TIMEOUT_MS, n);
if (n == 0) return NULL;
msg_t *m = new_msg(MSG_ASSETFILE_GETLIST, req);
if (!m) return NULL;
fill_list(m, packs, n);
pthread_mutex_lock(&g_lock);
g_expired[g_expired_next] = req;
g_expired_next = (g_expired_next + 1) % MAX_PENDING;
pthread_mutex_unlock(&g_lock);
return m;
}
/* ---------------------------------------------------------------------------------------------------------------
* Requests
* ------------------------------------------------------------------------------------------------------------- */
EXPORT u64 ovr_LanguagePack_GetCurrent(void) {
pack_t packs[MAXP];
int n = scan(packs), i = pick_current(packs, n);
fplog("LanguagePack_GetCurrent -> %s", i >= 0 ? packs[i].tag : "none applied");
msg_t *m = new_msg(MSG_LANGUAGEPACK_GETCURRENT, 0);
if (!m) return 0;
u64 req = m->req;
if (i < 0) {
fail(m, 404, "no language pack is applied");
} else {
fill_details(&m->det, &m->lng, &packs[i]);
m->has_det = 1;
}
post(m);
return req;
}
EXPORT u64 ovr_LanguagePack_SetCurrent(const char *tag) {
pack_t packs[MAXP];
int n = scan(packs), i = (tag && *tag) ? find_tag(packs, n, tag) : -1;
fplog("LanguagePack_SetCurrent(\"%s\") -> %s", tag ? tag : "(null)", i >= 0 ? packs[i].path : "not available");
msg_t *m = new_msg(MSG_LANGUAGEPACK_SETCURRENT, 0);
if (!m) return 0;
u64 req = m->req;
if (i < 0) {
fail(m, 404, "language pack not available on this device");
} else {
pthread_mutex_lock(&g_lock);
snprintf(g_current, sizeof g_current, "%s", packs[i].tag);
pthread_mutex_unlock(&g_lock);
m->res.id = packs[i].id;
snprintf(m->res.path, sizeof m->res.path, "%s", packs[i].path);
m->has_res = 1;
}
post(m);
return req;
}
EXPORT u64 ovr_AssetFile_GetList(void) {
if (stub_enabled()) {
msg_t *m = new_msg(MSG_ASSETFILE_GETLIST, 0);
if (!m) return 0;
u64 req = m->req;
fplog("AssetFile_GetList: stub, empty list");
post(m);
return req;
}
u64 req = o_AssetFile_GetList();
fplog("AssetFile_GetList (dispatcher request %llu)", (unsigned long long)req);
if (req) {
add_pending(req);
return req;
}
// no dispatcher function behind us: answer with our packs alone
pack_t packs[MAXP];
int n = scan(packs);
msg_t *m = new_msg(MSG_ASSETFILE_GETLIST, 0);
if (!m) return 0;
req = m->req;
fill_list(m, packs, n);
post(m);
return req;
}
EXPORT u64 ovr_AssetFile_StatusById(u64 id) {
if (stub_enabled()) {
msg_t *m = new_msg(MSG_ASSETFILE_STATUSBYID, 0);
if (!m) return 0;
u64 req = m->req;
m->has_det = 1;
m->det.id = id;
snprintf(m->det.type, sizeof m->det.type, "default");
snprintf(m->det.status, sizeof m->det.status, "installed");
snprintf(m->det.iap, sizeof m->det.iap, "free");
fplog("AssetFile_StatusById(%llu): stub, installed without a file", (unsigned long long)id);
post(m);
return req;
}
fplog("AssetFile_StatusById(%llu)%s", (unsigned long long)id, (id >> 48) == 0x4650 ? " (ours)" : "");
if ((id >> 48) == 0x4650) {
pack_t packs[MAXP];
int n = scan(packs);
for (int i = 0; i < n; i++)
if (packs[i].id == id) {
msg_t *m = new_msg(MSG_ASSETFILE_STATUSBYID, 0);
if (!m) return 0;
u64 req = m->req;
fill_details(&m->det, &m->lng, &packs[i]);
m->has_det = 1;
post(m);
return req;
}
msg_t *m = new_msg(MSG_ASSETFILE_STATUSBYID, 0);
if (!m) return 0;
u64 req = m->req;
fail(m, 404, "asset file not found");
post(m);
return req;
}
return o_AssetFile_StatusById(id);
}
EXPORT u64 ovr_AssetFile_DownloadById(u64 id) {
fplog("AssetFile_DownloadById(%llu)%s", (unsigned long long)id, (id >> 48) == 0x4650 ? " (ours)" : "");
if ((id >> 48) != 0x4650) return o_AssetFile_DownloadById(id);
pack_t packs[MAXP];
int n = scan(packs), i = 0;
while (i < n && packs[i].id != id) i++;
msg_t *m = new_msg(MSG_ASSETFILE_DOWNLOADBYID, 0);
if (!m) return 0;
u64 req = m->req;
if (i == n) {
fail(m, 404, "asset file not found");
post(m);
return req;
}
// already on the device: a finished download update, then the result with the file's path
msg_t *u = new_msg(MSG_NOTIFICATION_DOWNLOADUPDATE, 0);
if (u) {
u->req = 0; // notifications carry no request id
u->upd = (update_t){packs[i].id, packs[i].size, packs[i].size, 1};
u->has_upd = 1;
post(u);
}
m->res.id = packs[i].id;
snprintf(m->res.path, sizeof m->res.path, "%s", packs[i].path);
m->has_res = 1;
post(m);
return req;
}
/* ---------------------------------------------------------------------------------------------------------------
* Message loop
* ------------------------------------------------------------------------------------------------------------- */
EXPORT void *ovr_PopMessage(void) {
pthread_mutex_lock(&g_lock);
msg_t *m = g_qhead;
if (m) {
g_qhead = m->q_next;
if (!g_qhead) g_qtail = NULL;
m->q_next = NULL;
}
pthread_mutex_unlock(&g_lock);
if (m) return m;
void *o = o_PopMessage();
while (o && o_Message_GetType(o) == MSG_ASSETFILE_GETLIST && take_expired(o_Message_GetRequestID(o))) {
// we already answered this request (timeout): a second answer for the same request would reach the game twice
fplog("AssetFile_GetList %llu: late answer from the dispatcher dropped", (unsigned long long)o_Message_GetRequestID(o));
o_FreeMessage(o);
o = o_PopMessage();
}
if (o && o_Message_GetType(o) == MSG_ASSETFILE_GETLIST) {
u64 r = o_Message_GetRequestID(o);
if (take_pending(r)) {
fplog("AssetFile_GetList %llu answered by the dispatcher", (unsigned long long)r);
return wrap_list(o);
}
}
if (o) return o;
return expire_pending();
}
EXPORT void ovr_FreeMessage(void *h) {
msg_t *m = h ? owner(h) : NULL;
if (!m || (void *)m != h) {
o_FreeMessage(h);
return;
}
pthread_mutex_lock(&g_lock);
for (msg_t **pp = &g_all; *pp; pp = &(*pp)->all_next)
if (*pp == m) {
*pp = m->all_next;
break;
}
for (msg_t **pp = &g_qhead; *pp; pp = &(*pp)->q_next) // freed unpopped: leave the queue too
if (*pp == m) {
*pp = m->q_next;
break;
}
g_qtail = NULL;
for (msg_t *q = g_qhead; q; q = q->q_next) g_qtail = q;
pthread_mutex_unlock(&g_lock);
if (m->orig_msg) o_FreeMessage(m->orig_msg);
free(m);
}
EXPORT u32 ovr_Message_GetType(const void *h) {
msg_t *m = owner(h);
u32 t = m ? m->type : o_Message_GetType(h);
if (m) fptrace("Message_GetType(ours) = 0x%08X", t);
return t;
}
EXPORT u64 ovr_Message_GetRequestID(const void *h) {
msg_t *m = owner(h);
return m ? m->req : o_Message_GetRequestID(h);
}
EXPORT _Bool ovr_Message_IsError(const void *h) {
msg_t *m = owner(h);
return m ? (_Bool)m->is_error : o_Message_IsError(h);
}
EXPORT void *ovr_Message_GetError(const void *h) {
msg_t *m = owner(h);
if (!m) return o_Message_GetError(h);
return m->is_error ? (void *)&m->err : NULL;
}
EXPORT void *ovr_Message_GetAssetDetails(const void *h) {
msg_t *m = owner(h);
if (!m) return o_Message_GetAssetDetails(h);
return m->has_det ? (void *)&m->det : NULL;
}
EXPORT void *ovr_Message_GetAssetFileDownloadResult(const void *h) {
msg_t *m = owner(h);
if (!m) return o_Message_GetAssetFileDownloadResult(h);
return m->has_res ? (void *)&m->res : NULL;
}
EXPORT void *ovr_Message_GetAssetFileDownloadUpdate(const void *h) {
msg_t *m = owner(h);
if (!m) return o_Message_GetAssetFileDownloadUpdate(h);
return m->has_upd ? (void *)&m->upd : NULL;
}
EXPORT void *ovr_Message_GetAssetDetailsArray(const void *h) {
msg_t *m = owner(h);
if (!m) return o_Message_GetAssetDetailsArray(h);
fptrace("Message_GetAssetDetailsArray(ours)");
return m->type == MSG_ASSETFILE_GETLIST && !m->is_error ? (void *)&m->arr : NULL;
}
EXPORT size_t ovr_AssetDetailsArray_GetSize(const void *h) {
msg_t *m = owner(h);
size_t n = m ? (size_t)m->n + m->orig_n : o_AssetDetailsArray_GetSize(h);
if (m) fptrace("AssetDetailsArray_GetSize = %zu (%d ours + %zu dispatcher)", n, m->n, (size_t)m->orig_n);
return n;
}
EXPORT void *ovr_AssetDetailsArray_GetElement(const void *h, size_t i) {
msg_t *m = owner(h);
if (!m) return o_AssetDetailsArray_GetElement(h, i);
if (i < (size_t)m->n) {
fptrace("AssetDetailsArray_GetElement(%zu) = our pack %s", i, m->dets[i].lang ? m->dets[i].lang->tag : "?");
return &m->dets[i];
}
fptrace("AssetDetailsArray_GetElement(%zu) = dispatcher entry", i);
return m->orig_arr ? o_AssetDetailsArray_GetElement(m->orig_arr, i - (size_t)m->n) : NULL;
}
/* ---------------------------------------------------------------------------------------------------------------
* Accessors on our own objects (anything else goes to the dispatcher)
* ------------------------------------------------------------------------------------------------------------- */
#define IS_OURS(h) (owner(h) != NULL)
EXPORT u64 ovr_AssetDetails_GetAssetId(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetAssetId(h);
fptrace("AssetDetails_GetAssetId(ours) = %llu", (unsigned long long)((const details_t *)h)->id);
return ((const details_t *)h)->id;
}
EXPORT const char *ovr_AssetDetails_GetAssetType(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetAssetType(h);
fptrace("AssetDetails_GetAssetType(ours) = \"%s\"", ((const details_t *)h)->type);
return ((const details_t *)h)->type;
}
EXPORT const char *ovr_AssetDetails_GetDownloadStatus(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetDownloadStatus(h);
fptrace("AssetDetails_GetDownloadStatus(ours) = \"%s\"", ((const details_t *)h)->status);
return ((const details_t *)h)->status;
}
EXPORT const char *ovr_AssetDetails_GetFilepath(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetFilepath(h);
fptrace("AssetDetails_GetFilepath(ours) = \"%s\"", ((const details_t *)h)->path);
return ((const details_t *)h)->path;
}
EXPORT const char *ovr_AssetDetails_GetIapStatus(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetIapStatus(h);
fptrace("AssetDetails_GetIapStatus(ours) = \"%s\"", ((const details_t *)h)->iap);
return ((const details_t *)h)->iap;
}
EXPORT void *ovr_AssetDetails_GetLanguage(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetLanguage(h);
fptrace("AssetDetails_GetLanguage(ours)");
return (void *)((const details_t *)h)->lang;
}
EXPORT const char *ovr_AssetDetails_GetMetadata(const void *h) {
if (!IS_OURS(h)) return o_AssetDetails_GetMetadata(h);
fptrace("AssetDetails_GetMetadata(ours) = \"%s\"", ((const details_t *)h)->meta);
return ((const details_t *)h)->meta;
}
EXPORT const char *ovr_LanguagePackInfo_GetTag(const void *h) {
if (!IS_OURS(h)) return o_LanguagePackInfo_GetTag(h);
fptrace("LanguagePackInfo_GetTag(ours) = \"%s\"", ((const lang_t *)h)->tag);
return ((const lang_t *)h)->tag;
}
EXPORT const char *ovr_LanguagePackInfo_GetEnglishName(const void *h) {
if (!IS_OURS(h)) return o_LanguagePackInfo_GetEnglishName(h);
fptrace("LanguagePackInfo_GetEnglishName(ours) = \"%s\"", ((const lang_t *)h)->en);
return ((const lang_t *)h)->en;
}
EXPORT const char *ovr_LanguagePackInfo_GetNativeName(const void *h) {
if (!IS_OURS(h)) return o_LanguagePackInfo_GetNativeName(h);
fptrace("LanguagePackInfo_GetNativeName(ours) = \"%s\"", ((const lang_t *)h)->nat);
return ((const lang_t *)h)->nat;
}
EXPORT u64 ovr_AssetFileDownloadResult_GetAssetId(const void *h) {
return IS_OURS(h) ? ((const result_t *)h)->id : o_AssetFileDownloadResult_GetAssetId(h);
}
EXPORT const char *ovr_AssetFileDownloadResult_GetFilepath(const void *h) {
return IS_OURS(h) ? ((const result_t *)h)->path : o_AssetFileDownloadResult_GetFilepath(h);
}
EXPORT u64 ovr_AssetFileDownloadUpdate_GetAssetFileId(const void *h) {
return IS_OURS(h) ? ((const update_t *)h)->id : o_AssetFileDownloadUpdate_GetAssetFileId(h);
}
EXPORT u64 ovr_AssetFileDownloadUpdate_GetBytesTotal(const void *h) {
return IS_OURS(h) ? (u64)((const update_t *)h)->total : o_AssetFileDownloadUpdate_GetBytesTotal(h);
}
EXPORT long long ovr_AssetFileDownloadUpdate_GetBytesTransferred(const void *h) {
return IS_OURS(h) ? ((const update_t *)h)->done : o_AssetFileDownloadUpdate_GetBytesTransferred(h);
}
EXPORT _Bool ovr_AssetFileDownloadUpdate_GetCompleted(const void *h) {
return IS_OURS(h) ? (_Bool)((const update_t *)h)->completed : o_AssetFileDownloadUpdate_GetCompleted(h);
}
EXPORT int ovr_Error_GetCode(const void *h) { return IS_OURS(h) ? ((const err_t *)h)->code : o_Error_GetCode(h); }
EXPORT int ovr_Error_GetHttpCode(const void *h) { return IS_OURS(h) ? ((const err_t *)h)->http : o_Error_GetHttpCode(h); }
EXPORT const char *ovr_Error_GetMessage(const void *h) {
return IS_OURS(h) ? ((const err_t *)h)->msg : o_Error_GetMessage(h);
}
EXPORT const char *ovr_Error_GetDisplayableMessage(const void *h) {
return IS_OURS(h) ? ((const err_t *)h)->msg : o_Error_GetDisplayableMessage(h);
}
Reference in new issue View Git Blame Copy Permalink