Trace Carl lifecycle and add read-only original state observer
This commit is contained in:
1 parent
c642b69849
commit
4cd62d3627
28 files changed
+2387
-5
No files matched your search
@@ -0,0 +1,407 @@
|
||||
/* Read-only, sampled original-state observer. It never patches target memory.
|
||||
Launch only a generated game copy, with an explicitly attested path.
|
||||
Build: i686-w64-mingw32-gcc -std=c11 -O2 -Wall -Wextra -Werror
|
||||
tools/recon/original_state_observer.c -lbcrypt -o observer.exe
|
||||
See docs/gameplay/original-state-observer.md for source identity and limits. */
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#define _WIN32_WINNT 0x0601
|
||||
#include <windows.h>
|
||||
#include <bcrypt.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <math.h>
|
||||
#include <errno.h>
|
||||
|
||||
#define MAX_NODES 1024
|
||||
#define GAME_BYTES 0x1d44
|
||||
#define CANONICAL_SHA "f5281076e1a2492f2d61f87aae3f4544b6d0f535ebe33f9fbb6f78710fe1aea8"
|
||||
#define HD_SHA "b6675b7e7f3fc37512185ddb4d6ce1fbe9a36c8b83f3b4b3ed6979a56db3d2d4"
|
||||
#define HD_NOCD_SHA "8cd5d21997835a40978b8b83e344c97c92217bf6cd6858f7458b76935d64dedb"
|
||||
|
||||
typedef struct {
|
||||
const char *name, *sha;
|
||||
uint32_t owner, registry, dt, current, skip, input, modal, suppression;
|
||||
} Profile;
|
||||
static const Profile profiles[] = {
|
||||
{"canonical",CANONICAL_SHA,0x5099e4,0x50999c,0x696030,0x509948,0x4f83e4,0x4f8430,0x4f8198,0x4f8182},
|
||||
{"hd-resolution",HD_SHA,0x5099e4,0x50999c,0x696030,0x509948,0x4f83e4,0x4f8430,0x4f8198,0x4f8182},
|
||||
{"hd-nocd",HD_NOCD_SHA,0x509a04,0x5099bc,0x696050,0x509968,0x4f8404,0x4f8450,0x4f81b8,0x4f81a2}
|
||||
};
|
||||
|
||||
typedef struct { uint32_t payload, vtable; } Node;
|
||||
typedef struct {
|
||||
uint32_t sentinel, current, owner, jimmy, count;
|
||||
int current_index, jimmy_index, registry_complete;
|
||||
Node nodes[MAX_NODES];
|
||||
} Registry;
|
||||
|
||||
static int read_memory(HANDLE process, uint32_t address, void *dest, SIZE_T length) {
|
||||
SIZE_T got = 0;
|
||||
return address >= 0x10000 &&
|
||||
ReadProcessMemory(process, (const void *)(uintptr_t)address, dest, length, &got) &&
|
||||
got == length;
|
||||
}
|
||||
|
||||
static uint32_t u32(const unsigned char *p) {
|
||||
return (uint32_t)p[0] | (uint32_t)p[1]<<8 | (uint32_t)p[2]<<16 | (uint32_t)p[3]<<24;
|
||||
}
|
||||
|
||||
static float f32(const unsigned char *p) {
|
||||
uint32_t bits = u32(p);
|
||||
float value;
|
||||
memcpy(&value, &bits, sizeof(value));
|
||||
return value;
|
||||
}
|
||||
|
||||
static void json_float(float value) {
|
||||
if (isfinite(value)) printf("%.9g", (double)value);
|
||||
else fputs("null", stdout);
|
||||
}
|
||||
|
||||
static void json_string(const char *s) {
|
||||
putchar('"');
|
||||
for (; *s; ++s) {
|
||||
unsigned char c = (unsigned char)*s;
|
||||
if (c == '\\' || c == '"') printf("\\%c", c);
|
||||
else if (c < 32 || c >= 127) printf("\\u%04x", (unsigned)c);
|
||||
else putchar(c);
|
||||
}
|
||||
putchar('"');
|
||||
}
|
||||
|
||||
static int original_component(const char *path) {
|
||||
while (*path) {
|
||||
const char *begin;
|
||||
size_t length;
|
||||
while (*path == '\\' || *path == '/') ++path;
|
||||
begin = path;
|
||||
while (*path && *path != '\\' && *path != '/') ++path;
|
||||
length = (size_t)(path-begin);
|
||||
if (length == 8 && !_strnicmp(begin, "Original", 8)) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int sha256(HANDLE file, char hex[65]) {
|
||||
BCRYPT_ALG_HANDLE alg = NULL;
|
||||
BCRYPT_HASH_HANDLE hash = NULL;
|
||||
unsigned char buffer[16384], digest[32];
|
||||
DWORD got;
|
||||
LARGE_INTEGER zero;
|
||||
int ok = 0;
|
||||
zero.QuadPart = 0;
|
||||
if (!SetFilePointerEx(file, zero, NULL, FILE_BEGIN) ||
|
||||
BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, NULL, 0) < 0 ||
|
||||
BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0) < 0) goto done;
|
||||
for (;;) {
|
||||
if (!ReadFile(file, buffer, sizeof(buffer), &got, NULL)) goto done;
|
||||
if (!got) break;
|
||||
if (BCryptHashData(hash, buffer, got, 0) < 0) goto done;
|
||||
}
|
||||
if (BCryptFinishHash(hash, digest, sizeof(digest), 0) < 0) goto done;
|
||||
for (unsigned i = 0; i < sizeof(digest); ++i) sprintf(hex+2*i, "%02x", digest[i]);
|
||||
hex[64] = 0;
|
||||
ok = 1;
|
||||
done:
|
||||
if (hash) BCryptDestroyHash(hash);
|
||||
if (alg) BCryptCloseAlgorithmProvider(alg, 0);
|
||||
return ok;
|
||||
}
|
||||
|
||||
/* The allow-listed hashes authenticate these anchors and all source offsets.
|
||||
Retain an independent anchor check to detect an incorrectly mapped image. */
|
||||
static int operand_guard(HANDLE process, uint32_t pc, const unsigned char *expected,
|
||||
size_t length, unsigned operand, uint32_t address) {
|
||||
unsigned char actual[16], guarded[16];
|
||||
if (length > sizeof(actual) || operand+4 > length) return 0;
|
||||
memcpy(guarded, expected, length);
|
||||
for (unsigned i = 0; i < 4; ++i) guarded[operand+i] = (unsigned char)(address>>(8*i));
|
||||
return read_memory(process, pc, actual, length) && !memcmp(actual, guarded, length);
|
||||
}
|
||||
|
||||
static int runtime_identity(HANDLE process, const Profile *p) {
|
||||
static const unsigned char setter[] = {0x8b,0x44,0x24,0x04,0xa3,0,0,0,0,0xc2,0x04,0x00};
|
||||
static const unsigned char registry[] = {0xa1,0,0,0,0,0x56,0x8b,0x30};
|
||||
static const unsigned char dt[] = {0x8b,0x15,0,0,0,0};
|
||||
static const unsigned char current[] = {0xa3,0,0,0,0};
|
||||
static const unsigned char skip[] = {0xc6,0x05,0,0,0,0,1};
|
||||
static const unsigned char input[] = {0xa0,0,0,0,0};
|
||||
static const unsigned char suppression[] = {0x38,0x1d,0,0,0,0};
|
||||
return operand_guard(process,0x475a40,setter,sizeof(setter),5,p->owner) &&
|
||||
operand_guard(process,0x473740,registry,sizeof(registry),1,p->registry) &&
|
||||
operand_guard(process,0x47374f,dt,sizeof(dt),2,p->dt) &&
|
||||
operand_guard(process,0x46e360,current,sizeof(current),1,p->current) &&
|
||||
operand_guard(process,0x430f3e,skip,sizeof(skip),2,p->skip) &&
|
||||
operand_guard(process,0x426062,input,sizeof(input),1,p->input) &&
|
||||
operand_guard(process,0x407060,input,sizeof(input),1,p->modal) &&
|
||||
operand_guard(process,0x430f11,suppression,sizeof(suppression),2,p->suppression);
|
||||
}
|
||||
|
||||
static void registry_snapshot(HANDLE process, const Profile *profile, Registry *r) {
|
||||
uint32_t next, node[3];
|
||||
memset(r, 0, sizeof(*r));
|
||||
r->current_index = r->jimmy_index = -1;
|
||||
if (!read_memory(process, profile->current, &r->current, 4) ||
|
||||
!read_memory(process, profile->owner, &r->owner, 4) ||
|
||||
!read_memory(process, profile->registry, &r->sentinel, 4) ||
|
||||
!read_memory(process, r->sentinel, &next, 4)) return;
|
||||
while (next != r->sentinel && r->count < MAX_NODES) {
|
||||
if (!read_memory(process, next, node, sizeof(node))) return;
|
||||
for (uint32_t i = 0; i < r->count; ++i)
|
||||
if (r->nodes[i].payload == node[2]) return; /* concurrent mutation/cycle */
|
||||
r->nodes[r->count].payload = node[2];
|
||||
if (!read_memory(process, node[2], &r->nodes[r->count].vtable, 4)) return;
|
||||
if (node[2] == r->current+0x8c) r->current_index = (int)r->count;
|
||||
if (r->nodes[r->count].vtable == 0x4a373c) {
|
||||
r->jimmy = node[2];
|
||||
r->jimmy_index = (int)r->count;
|
||||
}
|
||||
++r->count;
|
||||
next = node[0];
|
||||
}
|
||||
r->registry_complete = next == r->sentinel;
|
||||
}
|
||||
|
||||
static void print_registry(const Registry *r, ULONGLONG elapsed) {
|
||||
printf("{\"kind\":\"registry\",\"elapsed_ms\":%llu,\"complete\":%s,\"sentinel\":%lu,"
|
||||
"\"current_game\":%lu,\"raw_owner\":%lu,\"jimmy\":%lu,\"game_index\":%d,\"jimmy_index\":%d,\"nodes\":[",
|
||||
(unsigned long long)elapsed, r->registry_complete ? "true" : "false",
|
||||
(unsigned long)r->sentinel, (unsigned long)r->current, (unsigned long)r->owner,
|
||||
(unsigned long)r->jimmy, r->current_index, r->jimmy_index);
|
||||
for (uint32_t i = 0; i < r->count; ++i)
|
||||
printf("%s[%lu,%lu]", i ? "," : "", (unsigned long)r->nodes[i].payload,
|
||||
(unsigned long)r->nodes[i].vtable);
|
||||
puts("]}");
|
||||
}
|
||||
|
||||
static void vector(const unsigned char *p) {
|
||||
putchar('[');
|
||||
for (unsigned i = 0; i < 4; ++i) { if (i) putchar(','); json_float(f32(p+4*i)); }
|
||||
putchar(']');
|
||||
}
|
||||
|
||||
static void print_sample(HANDLE process, const Profile *profile, const Registry *r, ULONGLONG elapsed) {
|
||||
unsigned char actor[GAME_BYTES], flags[4], dt[4];
|
||||
const uint32_t addresses[] = {profile->skip,profile->input,profile->modal,profile->suppression};
|
||||
unsigned valid = 0;
|
||||
memset(actor, 0, sizeof(actor));
|
||||
memset(flags, 0, sizeof(flags));
|
||||
memset(dt, 0, sizeof(dt));
|
||||
for (unsigned i = 0; i < 4; ++i)
|
||||
if (read_memory(process, addresses[i], flags+i, 1)) valid |= 1u<<i;
|
||||
if (read_memory(process, profile->dt, dt, 4)) valid |= 16;
|
||||
if (r->jimmy && read_memory(process, r->jimmy, actor, sizeof(actor))) valid |= 32;
|
||||
printf("{\"kind\":\"sample\",\"elapsed_ms\":%llu,\"valid_mask\":%u,\"raw_owner\":%lu,\"current_game\":%lu,\"jimmy\":%lu,\"dt\":",
|
||||
(unsigned long long)elapsed, valid, (unsigned long)r->owner,
|
||||
(unsigned long)r->current, (unsigned long)r->jimmy);
|
||||
json_float(f32(dt));
|
||||
printf(",\"shared_skip\":%u,\"input_block\":%u,\"modal_gate\":%u,\"skip_suppression\":%u",
|
||||
flags[0],flags[1],flags[2],flags[3]);
|
||||
if (valid & 32) {
|
||||
printf(",\"mode\":%d,\"turn\":", (int)(int16_t)(actor[0x704] | actor[0x705]<<8));
|
||||
json_float(f32(actor+0x614));
|
||||
printf(",\"dirty\":%u,\"action_latch\":%u,\"cached_support\":%u,\"force_support\":%u,\"current_euler\":",
|
||||
actor[0xa], actor[0x1d40], actor[0x13f], actor[0x4a0]);
|
||||
vector(actor+0x224);
|
||||
fputs(",\"destination_euler\":", stdout); vector(actor+0x274);
|
||||
}
|
||||
puts("}");
|
||||
}
|
||||
|
||||
static BOOL CALLBACK owned_window(HWND window, LPARAM parameter) {
|
||||
DWORD pid;
|
||||
DWORD *search = (DWORD *)parameter;
|
||||
GetWindowThreadProcessId(window, &pid);
|
||||
if (pid == search[0] && IsWindowVisible(window) && !GetWindow(window, GW_OWNER)) {
|
||||
search[1] = (DWORD)(uintptr_t)window;
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static HWND find_window(DWORD pid) {
|
||||
DWORD search[2] = {pid, 0};
|
||||
EnumWindows(owned_window, (LPARAM)search);
|
||||
return (HWND)(uintptr_t)search[1];
|
||||
}
|
||||
|
||||
static void menu_key(DWORD pid, ULONGLONG elapsed, int release) {
|
||||
HWND window = find_window(pid);
|
||||
HWND foreground;
|
||||
INPUT event;
|
||||
char title[256];
|
||||
DWORD thread = window ? GetWindowThreadProcessId(window,NULL) : 0;
|
||||
unsigned sent = 0;
|
||||
memset(&event, 0, sizeof(event));
|
||||
memset(title,0,sizeof(title));
|
||||
if (window) GetWindowTextA(window,title,sizeof(title));
|
||||
if (window && !release) {
|
||||
int attached = thread != GetCurrentThreadId() && AttachThreadInput(GetCurrentThreadId(),thread,TRUE);
|
||||
BringWindowToTop(window); SetForegroundWindow(window); SetActiveWindow(window); SetFocus(window);
|
||||
if (attached) AttachThreadInput(GetCurrentThreadId(),thread,FALSE);
|
||||
}
|
||||
foreground = GetForegroundWindow();
|
||||
if (release || (window && foreground == window)) {
|
||||
event.type = INPUT_KEYBOARD; event.ki.wVk = VK_RETURN;
|
||||
event.ki.dwFlags = release ? KEYEVENTF_KEYUP : 0;
|
||||
sent = SendInput(1, &event, sizeof(INPUT));
|
||||
}
|
||||
printf("{\"kind\":\"normal_input\",\"elapsed_ms\":%llu,\"key\":\"Return\",\"release\":%s,\"events_sent\":%u,\"window\":%lu,\"foreground\":%lu,\"title\":",
|
||||
(unsigned long long)elapsed, release?"true":"false",sent,
|
||||
(unsigned long)(uintptr_t)window,(unsigned long)(uintptr_t)foreground);
|
||||
json_string(title); puts("}");
|
||||
}
|
||||
|
||||
static void usage(FILE *stream) {
|
||||
fputs("Usage: observer.exe --copied-game=<generated-copy.exe> [--seconds=1..120] [--menu-keys]\n"
|
||||
" observer.exe --copied-game-menu=<generated-copy.exe> (single-argument menu-input opt-in)\n"
|
||||
" observer.exe --attach-copied-pid=<PID> [--seconds=1..120] (read-only, no input/close)\n"
|
||||
"Each copied option explicitly attests that the selected executable is a generated copy outside Original.\n",stream);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char path[32768], final[32768], directory[32768], hash[65], command[32772];
|
||||
HANDLE file;
|
||||
STARTUPINFOA start;
|
||||
PROCESS_INFORMATION child;
|
||||
Registry previous, current;
|
||||
unsigned seconds = 15, key_index = 0, samples = 0;
|
||||
int keys = 0, previous_valid = 0, identified = 0;
|
||||
DWORD attach_pid = 0;
|
||||
int key_down = 0;
|
||||
ULONGLONG key_began = 0;
|
||||
const Profile *profile = NULL;
|
||||
ULONGLONG began, elapsed;
|
||||
DWORD exit_code = STILL_ACTIVE;
|
||||
const char *target = NULL;
|
||||
memset(&child,0,sizeof(child));
|
||||
if (argc == 2 && !strcmp(argv[1],"--help")) { usage(stdout); return 0; }
|
||||
if (argc >= 2 && !strncmp(argv[1], "--copied-game=", 14)) target=argv[1]+14;
|
||||
else if (argc >= 2 && !strncmp(argv[1], "--copied-game-menu=", 19)) { target=argv[1]+19; keys=1; }
|
||||
else if (argc >= 2 && !strncmp(argv[1], "--attach-copied-pid=", 20)) {
|
||||
char *end;
|
||||
const char *number=argv[1]+20;
|
||||
errno=0;
|
||||
unsigned long pid=strtoul(number,&end,10);
|
||||
if (!isdigit((unsigned char)*number) || *end || errno || !pid) return 2;
|
||||
attach_pid=(DWORD)pid;
|
||||
}
|
||||
if ((!target || !*target) && !attach_pid) {
|
||||
usage(stderr);
|
||||
return 2;
|
||||
}
|
||||
for (int i = 2; i < argc; ++i) {
|
||||
char *end;
|
||||
if (!strncmp(argv[i], "--seconds=", 10)) {
|
||||
unsigned long n = strtoul(argv[i]+10, &end, 10);
|
||||
if (*end || n < 1 || n > 120) return 2;
|
||||
seconds = (unsigned)n;
|
||||
} else if (!strcmp(argv[i], "--menu-keys")) keys = 1;
|
||||
else return 2;
|
||||
}
|
||||
if (attach_pid && keys) {
|
||||
fputs("Attach mode never sends input; remove --menu-keys.\n",stderr);
|
||||
return 2;
|
||||
}
|
||||
setbuf(stdout, NULL);
|
||||
DWORD length;
|
||||
if (attach_pid) {
|
||||
child.hProcess=OpenProcess(PROCESS_VM_READ|PROCESS_QUERY_LIMITED_INFORMATION|SYNCHRONIZE,FALSE,attach_pid);
|
||||
if (!child.hProcess) { fprintf(stderr,"OpenProcess failed: %lu\n",GetLastError()); return 2; }
|
||||
child.dwProcessId=attach_pid;
|
||||
length=sizeof(path);
|
||||
if (!QueryFullProcessImageNameA(child.hProcess,0,path,&length) || !length || length>=sizeof(path)) {
|
||||
fprintf(stderr,"QueryFullProcessImageName failed: %lu\n",GetLastError());
|
||||
CloseHandle(child.hProcess); return 2;
|
||||
}
|
||||
} else length=GetFullPathNameA(target, sizeof(path), path, NULL);
|
||||
if (!length || length >= sizeof(path) || original_component(path)) {
|
||||
fputs("Rejected target path: use an explicitly attested generated copy outside Original.\n", stderr);
|
||||
if (child.hProcess) CloseHandle(child.hProcess);
|
||||
return 2;
|
||||
}
|
||||
file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (file == INVALID_HANDLE_VALUE) {
|
||||
fprintf(stderr,"Cannot open copied game: %lu\n",GetLastError());
|
||||
if (child.hProcess) CloseHandle(child.hProcess);
|
||||
return 2;
|
||||
}
|
||||
LARGE_INTEGER size;
|
||||
if (!GetFileSizeEx(file,&size) || size.QuadPart != 1019904) {
|
||||
fputs("Rejected target size.\n",stderr); CloseHandle(file);
|
||||
if (child.hProcess) CloseHandle(child.hProcess);
|
||||
return 2;
|
||||
}
|
||||
length = GetFinalPathNameByHandleA(file, final, sizeof(final), FILE_NAME_NORMALIZED);
|
||||
if (sha256(file, hash))
|
||||
for (unsigned i = 0; i < sizeof(profiles)/sizeof(profiles[0]); ++i)
|
||||
if (!strcmp(hash,profiles[i].sha)) profile = profiles+i;
|
||||
if (!length || length >= sizeof(final) || original_component(final) || !profile) {
|
||||
fputs("Rejected target identity/path; only explicitly supported verified source profiles are accepted.\n", stderr);
|
||||
CloseHandle(file);
|
||||
if (child.hProcess) CloseHandle(child.hProcess);
|
||||
return 2;
|
||||
}
|
||||
/* Keep the authenticated file handle open without FILE_SHARE_WRITE/DELETE
|
||||
through process creation, preventing target-file replacement after hashing. */
|
||||
if (!attach_pid) {
|
||||
strcpy(directory, path);
|
||||
char *slash = strrchr(directory, '\\');
|
||||
if (!slash) { CloseHandle(file); return 2; }
|
||||
*slash = 0;
|
||||
snprintf(command, sizeof(command), "\"%s\"", path);
|
||||
memset(&start, 0, sizeof(start)); start.cb = sizeof(start);
|
||||
if (!CreateProcessA(path, command, NULL, NULL, FALSE, 0, NULL, directory, &start, &child)) {
|
||||
fprintf(stderr,"CreateProcess failed: %lu\n",GetLastError()); CloseHandle(file); return 2;
|
||||
}
|
||||
CloseHandle(child.hThread);
|
||||
}
|
||||
CloseHandle(file);
|
||||
fputs("{\"kind\":\"identity\",\"target\":", stdout); json_string(path);
|
||||
printf(",\"sha256\":\"%s\",\"profile\":\"%s\",\"pid\":%lu,\"attached\":%s,\"interval_ms\":10,\"duration_ms\":%u,\"scope\":\"read-only sampled process state; no callback-order or whole-frame guarantee\"}\n",
|
||||
hash, profile->name, child.dwProcessId, attach_pid?"true":"false",seconds*1000);
|
||||
began = GetTickCount64();
|
||||
do {
|
||||
elapsed = GetTickCount64()-began;
|
||||
if (WaitForSingleObject(child.hProcess, 0) == WAIT_OBJECT_0) break;
|
||||
if (!identified) {
|
||||
identified = runtime_identity(child.hProcess,profile);
|
||||
if (!identified && elapsed > 5000) {
|
||||
fputs("{\"kind\":\"error\",\"reason\":\"runtime source anchors unavailable after 5s; sampling refused\"}\n",stdout);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (identified) {
|
||||
registry_snapshot(child.hProcess,profile,¤t);
|
||||
if (!previous_valid || memcmp(¤t, &previous, sizeof(current))) {
|
||||
print_registry(¤t, elapsed); previous = current; previous_valid = 1;
|
||||
}
|
||||
print_sample(child.hProcess,profile,¤t,elapsed); ++samples;
|
||||
}
|
||||
if (!attach_pid && key_down && elapsed-key_began >= 100) {
|
||||
menu_key(child.dwProcessId,elapsed,1); key_down=0;
|
||||
}
|
||||
if (!attach_pid && keys && !key_down && key_index < 3 && elapsed >= (ULONGLONG)(key_index+1)*3000) {
|
||||
menu_key(child.dwProcessId,elapsed,0); ++key_index; key_began=elapsed; key_down=1;
|
||||
}
|
||||
Sleep(10);
|
||||
} while (elapsed < seconds*1000);
|
||||
if (!attach_pid && key_down) menu_key(child.dwProcessId,GetTickCount64()-began,1);
|
||||
GetExitCodeProcess(child.hProcess, &exit_code);
|
||||
printf("{\"kind\":\"finish\",\"elapsed_ms\":%llu,\"samples\":%u,\"identified\":%s,\"game_exit\":%lu,\"left_running\":%s}\n",
|
||||
(unsigned long long)(GetTickCount64()-began), samples, identified?"true":"false",
|
||||
exit_code, exit_code == STILL_ACTIVE ? "true" : "false");
|
||||
/* Request ordinary shutdown only for this launcher-owned process. Do not
|
||||
terminate it or enumerate/kill unrelated game or Wine processes. */
|
||||
if (!attach_pid && exit_code == STILL_ACTIVE) {
|
||||
HWND window = find_window(child.dwProcessId);
|
||||
if (window) PostMessageA(window, WM_CLOSE, 0, 0);
|
||||
}
|
||||
CloseHandle(child.hProcess);
|
||||
if (!identified || !samples) return 3;
|
||||
puts("{\"kind\":\"complete\",\"marker\":\"ORIGINAL_STATE_OBSERVER_COMPLETE\"}");
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user