crogram-pythub 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1310 @@
1
+ /*
2
+ * bootex.c — Pythub 自研单文件引导器
3
+ *
4
+ * 一套源码,两种编译目标:
5
+ * Windows : x86_64-w64-mingw32-gcc -O2 -s -Wall -mconsole -lshell32 -o bootex.exe bootex.c
6
+ * (windowed 应用换 -mwindows -DGUI_APP=1: 无控制台,致命错误走消息框)
7
+ * POSIX : cc -O2 -Wall -o bootex bootex.c
8
+ * (POSIX 分支用于 mac/linux 本机全流程自测,也可产出原生 ELF/Mach-O 单文件)
9
+ *
10
+ * 归档文件结构(由 pythub.exe_archive.make_exe 生成,全部自研,无第三方格式依赖):
11
+ * [ 引导器本体 ][ 文件数据区 ][ TOC ][ 96 字节 cookie ]
12
+ *
13
+ * cookie 布局(小端):
14
+ * 0..7 magic "PYTHEX3\0"
15
+ * 8..15 payload_offset 文件数据区起始(绝对偏移)
16
+ * 16..23 toc_offset TOC 起始(绝对偏移)
17
+ * 24..31 toc_size TOC 长度
18
+ * 32..63 md5hex (数据区 + TOC) 的 MD5,用作解压缓存目录键
19
+ * 64..95 app[32] 应用名(净化后的缓存安全名),运行时缓存按应用分组:
20
+ * <缓存>/exe/<app>/<md5>,供同应用旧版本 LRU 清理识别
21
+ *
22
+ * TOC 布局:
23
+ * u32 条目数;每条目: u32 path_len, u32 stored_size, u32 raw_size,
24
+ * u64 data_offset(绝对), u8 flags, path(UTF-8, POSIX 分隔符)
25
+ * flags: 0 = 原样存储, 1 = zlib(DEFLATE) 压缩 —— C 端用内嵌的 miniz(tinfl)
26
+ * 解压(Python 端 zlib.compress 输出即 zlib 包装的 DEFLATE 流)。
27
+ *
28
+ * 运行逻辑(参考 PyInstaller CArchive/bootloader 的思路独立实现):
29
+ * 读取自身 → 校验尾部 cookie → 归档体 MD5 完整性校验(防篡改/截断)
30
+ * → 解压到持久缓存目录(已解压则校验缓存启动器 MD5,被篡改自动重新解压)
31
+ * → 调起内嵌解释器执行 app.pyz(透传命令行参数、返回退出码)
32
+ *
33
+ * 解压可靠性:
34
+ * - 原子解压: 先解压到 <缓存>.part 临时目录,校验启动器存在后原子改名就位,
35
+ * 中途中断不会留下半成品缓存目录;
36
+ * - 并发互斥: 首次解压前获取进程级锁(Windows 命名互斥体 / POSIX flock),
37
+ * 拿到锁后双重检查缓存,避免多实例并发解压互相踩踏。
38
+ */
39
+ #include <stdio.h>
40
+ #include <stdlib.h>
41
+ #include <stdarg.h>
42
+ #include <string.h>
43
+ #include <stdint.h>
44
+ #include <sys/stat.h>
45
+ #include <sys/types.h>
46
+
47
+ #include "miniz_tinfl.h" /* 内嵌 miniz tinfl(vendored, MIT): 仅用 inflate 解压 zlib(DEFLATE) 条目 */
48
+
49
+ #ifdef _WIN32
50
+ #define WIN32_LEAN_AND_MEAN
51
+ #include <windows.h>
52
+ #include <shellapi.h>
53
+ #else
54
+ #include <unistd.h>
55
+ #include <limits.h>
56
+ #include <dirent.h>
57
+ #include <sys/file.h>
58
+ #include <sys/wait.h>
59
+ #endif
60
+
61
+ #define COOKIE_SIZE 96
62
+ #define APP_FIELD_SIZE 32
63
+ #define PYZ_REL "app.pyz"
64
+ #define FLAG_DEFLATE 1 /* 条目经 zlib 压缩 */
65
+ #define FLAG_SYMLINK 2 /* 条目为符号链接,内容为链接目标串(POSIX 重建) */
66
+ /* TOC 内路径统一 POSIX 分隔符(校验用);ENTRY_REL 是文件系统相对路径(平台分隔符) */
67
+ #ifdef _WIN32
68
+ #define ENTRY_REL_TOC "runtime/python.exe"
69
+ #else
70
+ #define ENTRY_REL_TOC "runtime/bin/python3"
71
+ #endif
72
+ #ifdef _WIN32
73
+ static const wchar_t ENTRY_REL[] = L"runtime\\python.exe";
74
+ #else
75
+ static const char ENTRY_REL[] = "runtime/bin/python3";
76
+ #endif
77
+
78
+ static const char MAGIC[8] = { 'P', 'Y', 'T', 'H', 'E', 'X', '3', '\0' };
79
+
80
+ /* ---------------- 缓存清理(P2)公共定义 ----------------
81
+ * 同应用旧 md5 目录 LRU 清理 + 缓存大小上限驱逐(默认 4GB),
82
+ * 上限可用环境变量 PYTHUB_CACHE_MAX_MB(MB)覆盖。 */
83
+ #ifndef CACHE_MAX_BYTES
84
+ #define CACHE_MAX_BYTES ((uint64_t)4 << 30)
85
+ #endif
86
+
87
+ static uint64_t cache_cap_bytes(void)
88
+ {
89
+ const char *env = getenv("PYTHUB_CACHE_MAX_MB");
90
+ if (env && *env) {
91
+ char *end = NULL;
92
+ unsigned long long v = strtoull(env, &end, 10);
93
+ if (end && *end == 0 && v > 0)
94
+ return (uint64_t)v << 20;
95
+ }
96
+ return CACHE_MAX_BYTES;
97
+ }
98
+
99
+ /* cookie 中的应用名字段防御性净化(归档可能被构造):
100
+ * 仅保留 [A-Za-z0-9._-],其余替换 '_',空则 "_app"。 */
101
+ static void sanitize_app(char *app /* APP_FIELD_SIZE + 1 字节 */)
102
+ {
103
+ for (int i = 0; app[i]; i++) {
104
+ char c = app[i];
105
+ int ok = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z')
106
+ || (c >= 'A' && c <= 'Z') || c == '.' || c == '-' || c == '_';
107
+ if (!ok)
108
+ app[i] = '_';
109
+ }
110
+ if (!app[0])
111
+ memcpy(app, "_app", 4);
112
+ }
113
+
114
+ /* 运行状态输出(窗口子系统无控制台,静默) */
115
+ static void boot_log(const char *msg)
116
+ {
117
+ #ifndef GUI_APP
118
+ puts(msg);
119
+ #else
120
+ (void)msg;
121
+ #endif
122
+ }
123
+
124
+ static void die(const char *fmt, ...)
125
+ {
126
+ char msg[1024];
127
+ va_list ap;
128
+ va_start(ap, fmt);
129
+ vsnprintf(msg, sizeof(msg), fmt, ap);
130
+ va_end(ap);
131
+ #ifdef _WIN32
132
+ #ifdef GUI_APP
133
+ /* 窗口子系统没有控制台,致命错误用消息框呈现 */
134
+ int n = MultiByteToWideChar(CP_UTF8, 0, msg, -1, NULL, 0);
135
+ wchar_t wmsg[1024];
136
+ MultiByteToWideChar(CP_UTF8, 0, msg, -1, wmsg, n);
137
+ MessageBoxW(NULL, wmsg, L"Pythub", MB_OK | MB_ICONERROR);
138
+ #else
139
+ fprintf(stderr, "[bootex] %s\n", msg);
140
+ #endif
141
+ #else
142
+ fprintf(stderr, "[bootex] %s\n", msg);
143
+ #endif
144
+ exit(1);
145
+ }
146
+
147
+ static uint32_t rd32(const uint8_t *p)
148
+ {
149
+ uint32_t v;
150
+ memcpy(&v, p, 4);
151
+ return v;
152
+ }
153
+
154
+ static uint64_t rd64(const uint8_t *p)
155
+ {
156
+ uint64_t v;
157
+ memcpy(&v, p, 8);
158
+ return v;
159
+ }
160
+
161
+ /* 取出条目内容(按需 zlib 解压)。返回 malloc 缓冲(调用方负责 free),
162
+ * 未压缩条目返回 NULL(调用方直接引用归档缓冲)。
163
+ * 直接用 tinfl 解压 zlib 流(PARSE_ZLIB_HEADER 时 tinfl 自带 adler-32 校验)。 */
164
+ static uint8_t *entry_payload(const uint8_t *src, uint32_t stored, uint32_t raw, uint8_t flags)
165
+ {
166
+ if (flags & ~((uint8_t)(FLAG_DEFLATE | FLAG_SYMLINK)))
167
+ die("未知归档条目标志: %u", flags);
168
+ if (!(flags & FLAG_DEFLATE))
169
+ return NULL;
170
+ uint8_t *out = (uint8_t *)malloc(raw ? raw : 1);
171
+ if (!out)
172
+ die("内存不足");
173
+ size_t n = tinfl_decompress_mem_to_mem(out, raw, src, stored,
174
+ TINFL_FLAG_PARSE_ZLIB_HEADER |
175
+ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
176
+ if (n == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED || n != raw)
177
+ die("条目解压失败,归档可能已损坏");
178
+ return out;
179
+ }
180
+
181
+ /* 防路径穿越(zip-slip): 归档可能被篡改,解压前校验每个条目路径。
182
+ * 拒绝: 绝对路径、Windows 盘符、任何位置的 ".." 路径段。 */
183
+ static int unsafe_path(const char *path)
184
+ {
185
+ size_t n = strlen(path);
186
+ if (n == 0)
187
+ return 1;
188
+ if (path[0] == '/' || path[0] == '\\')
189
+ return 1;
190
+ if (n >= 2 && path[1] == ':'
191
+ && ((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z')))
192
+ return 1;
193
+ for (size_t i = 0; i + 1 < n; i++) {
194
+ if (path[i] == '.' && path[i + 1] == '.') {
195
+ int start_ok = (i == 0) || path[i - 1] == '/' || path[i - 1] == '\\';
196
+ char end = path[i + 2] == 0 ? 0 : path[i + 2];
197
+ int end_ok = (end == '/' || end == '\\' || (i + 2 == n));
198
+ if (start_ok && end_ok)
199
+ return 1;
200
+ }
201
+ }
202
+ return 0;
203
+ }
204
+
205
+ /* ---------------- MD5(公开域实现,标准 RFC 1321 算法)---------------- */
206
+ static const uint32_t MD5_K[64] = {
207
+ 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
208
+ 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
209
+ 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
210
+ 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
211
+ 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
212
+ 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
213
+ 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
214
+ 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
215
+ 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
216
+ 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
217
+ 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
218
+ 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
219
+ 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
220
+ 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
221
+ 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
222
+ 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
223
+ };
224
+ static const uint8_t MD5_S[64] = {
225
+ 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
226
+ 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
227
+ 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
228
+ 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
229
+ };
230
+
231
+ static void md5_transform(uint32_t st[4], const uint8_t block[64])
232
+ {
233
+ uint32_t w[16];
234
+ memcpy(w, block, 64); /* 目标平台均为小端 */
235
+ uint32_t a = st[0], b = st[1], c = st[2], d = st[3];
236
+ for (int i = 0; i < 64; i++) {
237
+ uint32_t f, g;
238
+ if (i < 16) { f = (b & c) | (~b & d); g = i; }
239
+ else if (i < 32) { f = (d & b) | (~d & c); g = (5 * i + 1) % 16; }
240
+ else if (i < 48) { f = b ^ c ^ d; g = (3 * i + 5) % 16; }
241
+ else { f = c ^ (b | ~d); g = (7 * i) % 16; }
242
+ f += a + MD5_K[i] + w[g];
243
+ uint32_t tmp = d;
244
+ d = c; c = b;
245
+ b = b + ((f << MD5_S[i]) | (f >> (32 - MD5_S[i])));
246
+ a = tmp;
247
+ }
248
+ st[0] += a; st[1] += b; st[2] += c; st[3] += d;
249
+ }
250
+
251
+ static void md5_1(const void *data, size_t len, uint8_t out[16])
252
+ {
253
+ static const uint32_t init[4] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
254
+ uint32_t st[4];
255
+ memcpy(st, init, sizeof(st));
256
+ const uint8_t *p = (const uint8_t *)data;
257
+ size_t full = len & ~(size_t)63;
258
+ for (size_t i = 0; i < full; i += 64)
259
+ md5_transform(st, p + i);
260
+ uint8_t tail[128];
261
+ size_t rem = len - full;
262
+ memcpy(tail, p + full, rem);
263
+ tail[rem] = 0x80;
264
+ size_t total = (rem + 1 <= 56) ? 64 : 128;
265
+ memset(tail + rem + 1, 0, total - rem - 1);
266
+ uint64_t bits = (uint64_t)len * 8;
267
+ memcpy(tail + total - 8, &bits, 8);
268
+ md5_transform(st, tail);
269
+ if (total == 128)
270
+ md5_transform(st, tail + 64);
271
+ memcpy(out, st, 16);
272
+ }
273
+
274
+ static void md5_hex(const void *data, size_t len, char hex[33])
275
+ {
276
+ uint8_t d[16];
277
+ md5_1(data, len, d);
278
+ static const char HEX[] = "0123456789abcdef";
279
+ for (int i = 0; i < 16; i++) {
280
+ hex[i * 2] = HEX[d[i] >> 4];
281
+ hex[i * 2 + 1] = HEX[d[i] & 15];
282
+ }
283
+ hex[32] = 0;
284
+ }
285
+
286
+ /* ---------------- 归档/缓存完整性校验(P2) ---------------- */
287
+
288
+ /* 归档体完整性校验: (数据区+TOC) 的 MD5 必须与 cookie 记录一致,
289
+ * 防止单文件本体被截断、篡改或拼接损坏。 */
290
+ static void verify_body(const uint8_t *buf, const char *md5hex,
291
+ uint64_t payload_offset, uint64_t toc_offset, uint64_t toc_size)
292
+ {
293
+ if (toc_offset + toc_size < payload_offset || toc_offset + toc_size > SIZE_MAX)
294
+ die("归档偏移非法");
295
+ char got[33];
296
+ md5_hex(buf + payload_offset, (size_t)(toc_offset + toc_size - payload_offset), got);
297
+ if (memcmp(got, md5hex, 32) != 0)
298
+ die("归档完整性校验失败,文件已被修改或损坏");
299
+ }
300
+
301
+ /* 在 TOC 中按路径查找条目(TOC 路径为 POSIX 分隔符)。找到返回 1。 */
302
+ static int toc_find(const uint8_t *buf, uint64_t toc_offset, const char *rel,
303
+ uint64_t *doff, uint32_t *stored, uint32_t *raw, uint8_t *flags)
304
+ {
305
+ const uint8_t *p = buf + toc_offset;
306
+ uint32_t count = rd32(p);
307
+ p += 4;
308
+ size_t n = strlen(rel);
309
+ for (uint32_t i = 0; i < count; i++) {
310
+ uint32_t plen = rd32(p); p += 4;
311
+ uint32_t s = rd32(p); p += 4;
312
+ uint32_t r = rd32(p); p += 4;
313
+ uint64_t d = rd64(p); p += 8;
314
+ uint8_t f = *p; p += 1;
315
+ if (plen == n && memcmp(p, rel, n) == 0) {
316
+ *doff = d; *stored = s; *raw = r; *flags = f;
317
+ return 1;
318
+ }
319
+ p += plen;
320
+ }
321
+ return 0;
322
+ }
323
+
324
+ /* 归档内启动器条目的原始内容 MD5(必要时解压)。
325
+ * Windows 启动器永远不是符号链接,直接用 MD5 比对即可;
326
+ * POSIX 的符号链接感知校验见 launcher_cache_ok_n。 */
327
+ #ifdef _WIN32
328
+ static void entry_md5(const uint8_t *buf, uint64_t toc_offset, uint8_t digest[16])
329
+ {
330
+ uint64_t doff;
331
+ uint32_t stored, raw;
332
+ uint8_t flags;
333
+ if (!toc_find(buf, toc_offset, ENTRY_REL_TOC, &doff, &stored, &raw, &flags))
334
+ die("归档缺少启动器条目: %s", ENTRY_REL_TOC);
335
+ uint8_t *infl = entry_payload(buf + doff, stored, raw, flags);
336
+ md5_1(infl ? infl : buf + doff, infl ? raw : stored, digest);
337
+ free(infl);
338
+ }
339
+ #endif
340
+
341
+ #ifdef _WIN32
342
+ /* ---------------------------------------------------------- Windows 分支 */
343
+
344
+ static wchar_t *utf8w(const char *s)
345
+ {
346
+ int n = MultiByteToWideChar(CP_UTF8, 0, s, -1, NULL, 0);
347
+ wchar_t *w = (wchar_t *)malloc((size_t)n * sizeof(wchar_t));
348
+ if (!w)
349
+ die("内存不足");
350
+ MultiByteToWideChar(CP_UTF8, 0, s, -1, w, n);
351
+ return w;
352
+ }
353
+
354
+ static uint8_t *read_self(size_t *out_len)
355
+ {
356
+ wchar_t self[32768];
357
+ if (!GetModuleFileNameW(NULL, self, 32768))
358
+ die("无法获取自身路径");
359
+ FILE *f = _wfopen(self, L"rb");
360
+ if (!f)
361
+ die("无法读取自身文件");
362
+ fseek(f, 0, SEEK_END);
363
+ long size = ftell(f);
364
+ rewind(f);
365
+ if (size <= 0)
366
+ die("自身文件为空");
367
+ uint8_t *buf = (uint8_t *)malloc((size_t)size);
368
+ if (!buf)
369
+ die("内存不足");
370
+ if (fread(buf, 1, (size_t)size, f) != (size_t)size)
371
+ die("读取不完整");
372
+ fclose(f);
373
+ *out_len = (size_t)size;
374
+ return buf;
375
+ }
376
+
377
+ /* 逐段创建目录(忽略已存在的报错;需要临时改写分隔符,调用方传入可写缓冲) */
378
+ static void mkdir_parents_w(wchar_t *full)
379
+ {
380
+ for (wchar_t *p = full; *p; p++) {
381
+ if (*p == L'\\') {
382
+ *p = 0;
383
+ CreateDirectoryW(full, NULL); /* 已存在则失败,忽略 */
384
+ *p = L'\\';
385
+ }
386
+ }
387
+ }
388
+
389
+ static void write_file_w(const wchar_t *full, const uint8_t *data, size_t size)
390
+ {
391
+ FILE *f = _wfopen(full, L"wb");
392
+ if (!f)
393
+ die("写入文件失败");
394
+ if (fwrite(data, 1, size, f) != size)
395
+ die("写入不完整");
396
+ fclose(f);
397
+ }
398
+
399
+ static int exists_w(const wchar_t *path)
400
+ {
401
+ return GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES;
402
+ }
403
+
404
+ static void extract_w(const uint8_t *buf, uint64_t toc_offset, const wchar_t *cache)
405
+ {
406
+ const uint8_t *p = buf + toc_offset;
407
+ uint32_t count = rd32(p);
408
+ p += 4;
409
+ wchar_t full[32768];
410
+ for (uint32_t i = 0; i < count; i++) {
411
+ uint32_t plen = rd32(p); p += 4;
412
+ uint32_t stored = rd32(p); p += 4;
413
+ uint32_t raw = rd32(p); p += 4;
414
+ uint64_t doff = rd64(p); p += 8;
415
+ uint8_t flags = *p; p += 1;
416
+ char path[1024];
417
+ if (plen >= sizeof(path))
418
+ die("归档内路径过长");
419
+ memcpy(path, p, plen);
420
+ path[plen] = 0;
421
+ p += plen;
422
+ if (unsafe_path(path))
423
+ die("归档条目包含不安全路径,已中止解压: %s", path);
424
+ wchar_t *wpath = utf8w(path);
425
+ for (wchar_t *q = wpath; *q; q++)
426
+ if (*q == L'/')
427
+ *q = L'\\';
428
+ _snwprintf_s(full, 32768, _TRUNCATE, L"%ls\\%ls", cache, wpath);
429
+ mkdir_parents_w(full);
430
+ uint8_t *infl = entry_payload(buf + doff, stored, raw, flags);
431
+ write_file_w(full, infl ? infl : buf + doff, infl ? raw : stored);
432
+ free(infl);
433
+ free(wpath);
434
+ }
435
+ }
436
+
437
+ /* 递归删除目录树 */
438
+ static void rmrf_w(const wchar_t *path)
439
+ {
440
+ wchar_t pattern[32768];
441
+ _snwprintf_s(pattern, 32768, _TRUNCATE, L"%ls\\*", path);
442
+ WIN32_FIND_DATAW fd;
443
+ HANDLE h = FindFirstFileW(pattern, &fd);
444
+ if (h == INVALID_HANDLE_VALUE) {
445
+ DeleteFileW(path);
446
+ RemoveDirectoryW(path);
447
+ return;
448
+ }
449
+ do {
450
+ if (wcscmp(fd.cFileName, L".") == 0 || wcscmp(fd.cFileName, L"..") == 0)
451
+ continue;
452
+ wchar_t child[32768];
453
+ _snwprintf_s(child, 32768, _TRUNCATE, L"%ls\\%ls", path, fd.cFileName);
454
+ if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
455
+ rmrf_w(child);
456
+ else
457
+ DeleteFileW(child);
458
+ } while (FindNextFileW(h, &fd));
459
+ FindClose(h);
460
+ RemoveDirectoryW(path);
461
+ }
462
+
463
+ /* ---------------- 缓存清理(P2, Windows 分支) ---------------- */
464
+
465
+ /* 刷新 LRU 时间戳(每次运行都写,保证"最近使用"判断准确) */
466
+ static void touch_stamp_w(const wchar_t *cache)
467
+ {
468
+ wchar_t stamp[32768];
469
+ _snwprintf_s(stamp, 32768, _TRUNCATE, L"%ls\\.stamp", cache);
470
+ FILE *f = _wfopen(stamp, L"wb");
471
+ if (f)
472
+ fclose(f);
473
+ }
474
+
475
+ /* 目录占用大小(递归) */
476
+ static uint64_t du_w(const wchar_t *path)
477
+ {
478
+ wchar_t pattern[32768];
479
+ _snwprintf_s(pattern, 32768, _TRUNCATE, L"%ls\\*", path);
480
+ WIN32_FIND_DATAW fd;
481
+ HANDLE h = FindFirstFileW(pattern, &fd);
482
+ if (h == INVALID_HANDLE_VALUE)
483
+ return 0;
484
+ uint64_t total = 0;
485
+ do {
486
+ if (wcscmp(fd.cFileName, L".") == 0 || wcscmp(fd.cFileName, L"..") == 0)
487
+ continue;
488
+ wchar_t child[32768];
489
+ _snwprintf_s(child, 32768, _TRUNCATE, L"%ls\\%ls", path, fd.cFileName);
490
+ if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
491
+ total += du_w(child);
492
+ else
493
+ total += ((uint64_t)fd.nFileSizeHigh << 32) | fd.nFileSizeLow;
494
+ } while (FindNextFileW(h, &fd));
495
+ FindClose(h);
496
+ return total;
497
+ }
498
+
499
+ /* LRU 时间: 优先 .stamp 的修改时间,回退目录修改时间(FILETIME, 100ns) */
500
+ static uint64_t lru_time_w(const wchar_t *dir)
501
+ {
502
+ wchar_t stamp[32768];
503
+ _snwprintf_s(stamp, 32768, _TRUNCATE, L"%ls\\.stamp", dir);
504
+ WIN32_FILE_ATTRIBUTE_DATA fa;
505
+ if (GetFileAttributesExW(stamp, GetFileExInfoStandard, &fa))
506
+ return ((uint64_t)fa.ftLastWriteTime.dwHighDateTime << 32)
507
+ | fa.ftLastWriteTime.dwLowDateTime;
508
+ if (GetFileAttributesExW(dir, GetFileExInfoStandard, &fa))
509
+ return ((uint64_t)fa.ftLastWriteTime.dwHighDateTime << 32)
510
+ | fa.ftLastWriteTime.dwLowDateTime;
511
+ return 0;
512
+ }
513
+
514
+ static int hex32_w(const wchar_t *s)
515
+ {
516
+ size_t n = wcslen(s);
517
+ if (n != 32)
518
+ return 0;
519
+ for (size_t i = 0; i < n; i++) {
520
+ wchar_t c = s[i];
521
+ if (!((c >= L'0' && c <= L'9') || (c >= L'a' && c <= L'f')))
522
+ return 0;
523
+ }
524
+ return 1;
525
+ }
526
+
527
+ /* 同应用旧 md5 目录清理: 删除应用组目录下除当前版本外的所有 md5 目录、
528
+ * 残留 .part 临时目录(当前版本的除外)。尽力而为,失败忽略。 */
529
+ static void cleanup_app_w(const wchar_t *appdir, const wchar_t *cur_md5)
530
+ {
531
+ wchar_t pattern[32768];
532
+ _snwprintf_s(pattern, 32768, _TRUNCATE, L"%ls\\*", appdir);
533
+ WIN32_FIND_DATAW fd;
534
+ HANDLE h = FindFirstFileW(pattern, &fd);
535
+ if (h == INVALID_HANDLE_VALUE)
536
+ return;
537
+ do {
538
+ if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
539
+ size_t n = wcslen(fd.cFileName);
540
+ int is_md5 = hex32_w(fd.cFileName);
541
+ int stale_part = n > 5 && wcscmp(fd.cFileName + n - 5, L".part") == 0;
542
+ int cur_part = n == 37 && wcsncmp(fd.cFileName, cur_md5, 32) == 0;
543
+ if (((is_md5 && wcscmp(fd.cFileName, cur_md5) != 0) || stale_part)
544
+ && !cur_part) {
545
+ wchar_t child[32768];
546
+ _snwprintf_s(child, 32768, _TRUNCATE, L"%ls\\%ls", appdir, fd.cFileName);
547
+ rmrf_w(child);
548
+ }
549
+ }
550
+ } while (FindNextFileW(h, &fd));
551
+ FindClose(h);
552
+ }
553
+
554
+ /* 缓存大小上限: exe 缓存总占用超限时,从最久未用的应用组开始驱逐
555
+ * (永不删除当前应用组)。应用组列表动态分配,数量无硬编码上限。
556
+ * 尽力而为,失败忽略。 */
557
+ static void enforce_cap_w(const wchar_t *exe_root, const wchar_t *cur_app)
558
+ {
559
+ wchar_t pattern[32768];
560
+ _snwprintf_s(pattern, 32768, _TRUNCATE, L"%ls\\*", exe_root);
561
+ WIN32_FIND_DATAW fd;
562
+ HANDLE h = FindFirstFileW(pattern, &fd);
563
+ if (h == INVALID_HANDLE_VALUE)
564
+ return;
565
+ size_t capacity = 64;
566
+ wchar_t (*names)[64] = malloc(capacity * sizeof(*names));
567
+ uint64_t *sizes = malloc(capacity * sizeof(*sizes));
568
+ uint64_t *times = malloc(capacity * sizeof(*times));
569
+ if (!names || !sizes || !times) {
570
+ free(names);
571
+ free(sizes);
572
+ free(times);
573
+ FindClose(h);
574
+ return;
575
+ }
576
+ int n = 0;
577
+ uint64_t total = 0;
578
+ do {
579
+ if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
580
+ continue;
581
+ if (wcscmp(fd.cFileName, L".") == 0 || wcscmp(fd.cFileName, L"..") == 0)
582
+ continue;
583
+ if ((size_t)n >= capacity) {
584
+ size_t ncap = capacity * 2;
585
+ wchar_t (*nn)[64] = realloc(names, ncap * sizeof(*nn));
586
+ uint64_t *ns = realloc(sizes, ncap * sizeof(*ns));
587
+ uint64_t *nt = realloc(times, ncap * sizeof(*nt));
588
+ if (nn)
589
+ names = nn;
590
+ if (ns)
591
+ sizes = ns;
592
+ if (nt)
593
+ times = nt;
594
+ if (!nn || !ns || !nt)
595
+ break; /* 内存不足: 用已收集的部分尽力清理 */
596
+ capacity = ncap;
597
+ }
598
+ wchar_t child[32768];
599
+ _snwprintf_s(child, 32768, _TRUNCATE, L"%ls\\%ls", exe_root, fd.cFileName);
600
+ _snwprintf_s(names[n], 64, _TRUNCATE, L"%ls", fd.cFileName);
601
+ sizes[n] = du_w(child);
602
+ times[n] = lru_time_w(child);
603
+ total += sizes[n];
604
+ n++;
605
+ } while (FindNextFileW(h, &fd));
606
+ FindClose(h);
607
+
608
+ uint64_t cap = cache_cap_bytes();
609
+ while (total > cap) {
610
+ int victim = -1;
611
+ for (int i = 0; i < n; i++) {
612
+ if (sizes[i] == 0 || wcscmp(names[i], cur_app) == 0)
613
+ continue;
614
+ if (victim < 0 || times[i] < times[victim])
615
+ victim = i;
616
+ }
617
+ if (victim < 0)
618
+ break;
619
+ wchar_t child[32768];
620
+ _snwprintf_s(child, 32768, _TRUNCATE, L"%ls\\%ls", exe_root, names[victim]);
621
+ rmrf_w(child);
622
+ total -= sizes[victim];
623
+ sizes[victim] = 0;
624
+ }
625
+ free(names);
626
+ free(sizes);
627
+ free(times);
628
+ }
629
+
630
+ /* 进程级互斥(Windows 命名互斥体),保证并发首解压串行 */
631
+ static HANDLE g_lock = NULL;
632
+
633
+ static void lock_acquire_w(const char *app, const char *md5)
634
+ {
635
+ wchar_t name[128];
636
+ wchar_t *wapp = utf8w(app);
637
+ wchar_t *wmd5 = utf8w(md5);
638
+ _snwprintf_s(name, 128, _TRUNCATE, L"Local\\pythub-exe-%ls-%ls", wapp, wmd5);
639
+ free(wapp);
640
+ free(wmd5);
641
+ g_lock = CreateMutexW(NULL, FALSE, name);
642
+ if (g_lock)
643
+ WaitForSingleObject(g_lock, INFINITE);
644
+ }
645
+
646
+ static void lock_release_w(void)
647
+ {
648
+ if (g_lock) {
649
+ ReleaseMutex(g_lock);
650
+ CloseHandle(g_lock);
651
+ g_lock = NULL;
652
+ }
653
+ }
654
+
655
+ /* 原子解压: 解压到 <缓存>.part,校验启动器后原子改名就位 */
656
+ static void extract_atomic_w(const uint8_t *buf, uint64_t toc_offset, const wchar_t *cache)
657
+ {
658
+ wchar_t part[32768];
659
+ wchar_t entry[32768];
660
+ _snwprintf_s(part, 32768, _TRUNCATE, L"%ls.part", cache);
661
+ if (exists_w(part))
662
+ rmrf_w(part); /* 清理上次中断留下的临时目录 */
663
+ extract_w(buf, toc_offset, part);
664
+ _snwprintf_s(entry, 32768, _TRUNCATE, L"%ls\\%ls", part, ENTRY_REL);
665
+ if (!exists_w(entry)) {
666
+ rmrf_w(part);
667
+ die("解压失败:启动器未生成,归档可能已损坏");
668
+ }
669
+ if (exists_w(cache))
670
+ rmrf_w(cache); /* 清理异常残留(完整缓存不存在但目录在) */
671
+ if (!MoveFileExW(part, cache, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)) {
672
+ rmrf_w(part);
673
+ die("解压目录就位失败 (GetLastError=%lu)", GetLastError());
674
+ }
675
+ }
676
+
677
+ /* 缓存启动器完整性校验: 与归档内启动器条目 MD5 比对,防缓存目录被篡改 */
678
+ static int launcher_md5_ok_w(const wchar_t *cache, const uint8_t expect[16])
679
+ {
680
+ wchar_t full[32768];
681
+ _snwprintf_s(full, 32768, _TRUNCATE, L"%ls\\%ls", cache, ENTRY_REL);
682
+ FILE *f = _wfopen(full, L"rb");
683
+ if (!f)
684
+ return 0;
685
+ fseek(f, 0, SEEK_END);
686
+ long size = ftell(f);
687
+ rewind(f);
688
+ if (size <= 0) {
689
+ fclose(f);
690
+ return 0;
691
+ }
692
+ uint8_t *data = (uint8_t *)malloc((size_t)size);
693
+ if (!data) {
694
+ fclose(f);
695
+ die("内存不足");
696
+ }
697
+ if (fread(data, 1, (size_t)size, f) != (size_t)size) {
698
+ fclose(f);
699
+ free(data);
700
+ return 0;
701
+ }
702
+ fclose(f);
703
+ uint8_t got[16];
704
+ md5_1(data, (size_t)size, got);
705
+ free(data);
706
+ return memcmp(got, expect, 16) == 0;
707
+ }
708
+
709
+ static int spawn_w(const wchar_t *cache, int argc, char **argv)
710
+ {
711
+ wchar_t cmd[65536];
712
+ int pos = _snwprintf_s(cmd, 65536, _TRUNCATE, L"\"%ls\\%ls\" \"%ls\\%hs\"",
713
+ cache, ENTRY_REL, cache, PYZ_REL);
714
+ if (pos < 0 || pos >= 65536)
715
+ die("命令行过长");
716
+ int nArgs = 0;
717
+ wchar_t **cl = CommandLineToArgvW(GetCommandLineW(), &nArgs);
718
+ if (!cl)
719
+ die("命令行解析失败");
720
+ for (int i = 1; i < nArgs && pos < 65530; i++) {
721
+ int w = _snwprintf_s(cmd + pos, 65536 - pos, _TRUNCATE, L" \"%ls\"", cl[i]);
722
+ if (w < 0)
723
+ break;
724
+ pos += w;
725
+ }
726
+ LocalFree(cl);
727
+ STARTUPINFOW si;
728
+ PROCESS_INFORMATION pi;
729
+ memset(&si, 0, sizeof(si));
730
+ memset(&pi, 0, sizeof(pi));
731
+ si.cb = sizeof(si);
732
+ /* GUI 模式: 本程序是窗口子系统(无控制台),但 python.exe 是控制台
733
+ * 子系统程序,不加 CREATE_NO_WINDOW 会为它新开一个可见控制台黑框 */
734
+ #ifdef GUI_APP
735
+ const DWORD cflags = CREATE_NO_WINDOW;
736
+ #else
737
+ const DWORD cflags = 0;
738
+ #endif
739
+ if (!CreateProcessW(NULL, cmd, NULL, NULL, TRUE, cflags, NULL, cache, &si, &pi))
740
+ die("无法启动应用 (GetLastError=%lu)", GetLastError());
741
+ WaitForSingleObject(pi.hProcess, INFINITE);
742
+ DWORD code = 1;
743
+ GetExitCodeProcess(pi.hProcess, &code);
744
+ CloseHandle(pi.hThread);
745
+ CloseHandle(pi.hProcess);
746
+ return (int)code;
747
+ }
748
+
749
+ #if defined(GUI_APP) && defined(_WIN32)
750
+ int main(int argc, char **argv);
751
+ /* -mwindows 使 PE 入口为 WinMainCRTStartup,需提供 WinMain 符号。
752
+ * 引导器的参数实际通过 GetCommandLineW/CommandLineToArgvW 获取,
753
+ * Windows 分支不依赖 main 的 argc/argv,这里直接转发即可。 */
754
+ int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmd, int show)
755
+ {
756
+ (void)inst; (void)prev; (void)cmd; (void)show;
757
+ return main(0, NULL);
758
+ }
759
+ #endif
760
+
761
+ int main(int argc, char **argv)
762
+ {
763
+ size_t len;
764
+ uint8_t *buf = read_self(&len);
765
+ if (len < COOKIE_SIZE)
766
+ die("文件过小,归档不完整");
767
+ const uint8_t *tail = buf + len - COOKIE_SIZE;
768
+ if (memcmp(tail, MAGIC, 8) != 0)
769
+ die("cookie 校验失败,不是 Pythub 自研单文件归档");
770
+ uint64_t payload_offset = rd64(tail + 8);
771
+ uint64_t toc_offset = rd64(tail + 16);
772
+ uint64_t toc_size = rd64(tail + 24);
773
+ char md5[33];
774
+ memcpy(md5, tail + 32, 32);
775
+ md5[32] = 0;
776
+ char app[APP_FIELD_SIZE + 1];
777
+ memcpy(app, tail + 64, APP_FIELD_SIZE);
778
+ app[APP_FIELD_SIZE] = 0;
779
+ sanitize_app(app);
780
+
781
+ verify_body(buf, md5, payload_offset, toc_offset, toc_size);
782
+ uint8_t expect[16];
783
+ entry_md5(buf, toc_offset, expect);
784
+
785
+ const wchar_t *base = _wgetenv(L"LOCALAPPDATA");
786
+ if (!base || !*base)
787
+ base = _wgetenv(L"TEMP");
788
+ if (!base || !*base)
789
+ base = L".";
790
+ wchar_t *wmd5 = utf8w(md5);
791
+ wchar_t *wapp = utf8w(app);
792
+ wchar_t exe_root[32768];
793
+ wchar_t appdir[32768];
794
+ wchar_t cache[32768];
795
+ _snwprintf_s(exe_root, 32768, _TRUNCATE, L"%ls\\pythub\\exe", base);
796
+ _snwprintf_s(appdir, 32768, _TRUNCATE, L"%ls\\%ls", exe_root, wapp);
797
+ _snwprintf_s(cache, 32768, _TRUNCATE, L"%ls\\%ls", appdir, wmd5);
798
+
799
+ wchar_t entry[32768];
800
+ _snwprintf_s(entry, 32768, _TRUNCATE, L"%ls\\%ls", cache, ENTRY_REL);
801
+ int re_extract = 0;
802
+ if (!exists_w(entry)) {
803
+ boot_log("首次运行,正在解压...");
804
+ re_extract = 1;
805
+ } else if (!launcher_md5_ok_w(cache, expect)) {
806
+ boot_log("缓存完整性校验失败,正在重新解压...");
807
+ re_extract = 1;
808
+ }
809
+ if (re_extract) {
810
+ lock_acquire_w(app, md5);
811
+ /* 双重检查:并发实例可能已完成/修复解压 */
812
+ if (!exists_w(entry) || !launcher_md5_ok_w(cache, expect))
813
+ extract_atomic_w(buf, toc_offset, cache);
814
+ lock_release_w();
815
+ if (!exists_w(entry))
816
+ die("解压失败:启动器未生成,归档可能已损坏");
817
+ }
818
+ /* P2 缓存清理: 每次运行刷新 LRU 时间戳;新版本首解压后清理同应用旧
819
+ * md5 目录,并按缓存总大小上限驱逐最久未用的应用组(尽力而为) */
820
+ touch_stamp_w(cache);
821
+ if (re_extract) {
822
+ cleanup_app_w(appdir, wmd5);
823
+ enforce_cap_w(exe_root, wapp);
824
+ }
825
+ free(wapp);
826
+ free(wmd5);
827
+ free(buf);
828
+ return spawn_w(cache, argc, argv);
829
+ }
830
+
831
+ #else
832
+ /* ---------------------------------------------------------- POSIX 分支 */
833
+
834
+ static uint8_t *read_self(const char *argv0, size_t *out_len)
835
+ {
836
+ char self[PATH_MAX];
837
+ ssize_t n = readlink("/proc/self/exe", self, sizeof(self) - 1);
838
+ if (n > 0)
839
+ self[n] = 0;
840
+ else if (!realpath(argv0, self))
841
+ die("无法定位自身路径");
842
+ FILE *f = fopen(self, "rb");
843
+ if (!f)
844
+ die("无法读取自身文件");
845
+ fseek(f, 0, SEEK_END);
846
+ long size = ftell(f);
847
+ rewind(f);
848
+ if (size <= 0)
849
+ die("自身文件为空");
850
+ uint8_t *buf = (uint8_t *)malloc((size_t)size);
851
+ if (!buf)
852
+ die("内存不足");
853
+ if (fread(buf, 1, (size_t)size, f) != (size_t)size)
854
+ die("读取不完整");
855
+ fclose(f);
856
+ *out_len = (size_t)size;
857
+ return buf;
858
+ }
859
+
860
+ /* 逐段创建目录(忽略已存在的报错) */
861
+ static void mkdir_parents_n(char *full)
862
+ {
863
+ for (char *p = full + 1; *p; p++) {
864
+ if (*p == '/') {
865
+ *p = 0;
866
+ mkdir(full, 0777); /* 已存在则失败,忽略 */
867
+ *p = '/';
868
+ }
869
+ }
870
+ }
871
+
872
+ static void write_file_n(const char *full, const uint8_t *data, size_t size)
873
+ {
874
+ FILE *f = fopen(full, "wb");
875
+ if (!f)
876
+ die("写入文件失败: %s", full);
877
+ if (fwrite(data, 1, size, f) != size)
878
+ die("写入不完整");
879
+ fclose(f);
880
+ chmod(full, 0755);
881
+ }
882
+
883
+ static void extract_n(const uint8_t *buf, uint64_t toc_offset, const char *cache)
884
+ {
885
+ const uint8_t *p = buf + toc_offset;
886
+ uint32_t count = rd32(p);
887
+ p += 4;
888
+ char full[PATH_MAX * 2];
889
+ for (uint32_t i = 0; i < count; i++) {
890
+ uint32_t plen = rd32(p); p += 4;
891
+ uint32_t stored = rd32(p); p += 4;
892
+ uint32_t raw = rd32(p); p += 4;
893
+ uint64_t doff = rd64(p); p += 8;
894
+ uint8_t flags = *p; p += 1;
895
+ char path[1024];
896
+ if (plen >= sizeof(path))
897
+ die("归档内路径过长");
898
+ memcpy(path, p, plen);
899
+ path[plen] = 0;
900
+ p += plen;
901
+ if (unsafe_path(path))
902
+ die("归档条目包含不安全路径,已中止解压: %s", path);
903
+ snprintf(full, sizeof(full), "%s/%s", cache, path);
904
+ mkdir_parents_n(full);
905
+ uint8_t *infl = entry_payload(buf + doff, stored, raw, flags);
906
+ if (flags & FLAG_SYMLINK) {
907
+ /* 符号链接条目: 内容为目标串。重建 symlink 而非复制目标文件
908
+ * (bin/python3 -> python3.12 等,避免归档体积膨胀 ~15MB)。 */
909
+ const uint8_t *data = infl ? infl : buf + doff;
910
+ size_t dlen = infl ? raw : stored;
911
+ char tgt[1024];
912
+ if (dlen >= sizeof(tgt))
913
+ die("符号链接目标过长: %s", path);
914
+ memcpy(tgt, data, dlen);
915
+ tgt[dlen] = 0;
916
+ if (unsafe_path(tgt))
917
+ die("归档条目包含不安全符号链接目标: %s -> %s", path, tgt);
918
+ unlink(full);
919
+ if (symlink(tgt, full) != 0)
920
+ die("创建符号链接失败: %s -> %s", full, tgt);
921
+ free(infl);
922
+ continue;
923
+ }
924
+ write_file_n(full, infl ? infl : buf + doff, infl ? raw : stored);
925
+ free(infl);
926
+ }
927
+ }
928
+
929
+ /* 递归删除目录树 */
930
+ static void rmrf_n(const char *path)
931
+ {
932
+ DIR *d = opendir(path);
933
+ if (!d) {
934
+ unlink(path);
935
+ return;
936
+ }
937
+ struct dirent *e;
938
+ while ((e = readdir(d)) != NULL) {
939
+ if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0)
940
+ continue;
941
+ char child[PATH_MAX * 2];
942
+ snprintf(child, sizeof(child), "%s/%s", path, e->d_name);
943
+ struct stat st;
944
+ if (lstat(child, &st) == 0 && S_ISDIR(st.st_mode))
945
+ rmrf_n(child);
946
+ else
947
+ unlink(child);
948
+ }
949
+ closedir(d);
950
+ rmdir(path);
951
+ }
952
+
953
+ /* ---------------- 缓存清理(P2, POSIX 分支) ---------------- */
954
+
955
+ /* 刷新 LRU 时间戳(每次运行都写,保证"最近使用"判断准确) */
956
+ static void touch_stamp_n(const char *cache)
957
+ {
958
+ char stamp[PATH_MAX * 2];
959
+ snprintf(stamp, sizeof(stamp), "%s/.stamp", cache);
960
+ FILE *f = fopen(stamp, "wb");
961
+ if (f)
962
+ fclose(f);
963
+ }
964
+
965
+ /* 目录占用大小(递归) */
966
+ static uint64_t du_n(const char *path)
967
+ {
968
+ DIR *d = opendir(path);
969
+ if (!d)
970
+ return 0;
971
+ uint64_t total = 0;
972
+ struct dirent *e;
973
+ while ((e = readdir(d)) != NULL) {
974
+ if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0)
975
+ continue;
976
+ char child[PATH_MAX * 2];
977
+ snprintf(child, sizeof(child), "%s/%s", path, e->d_name);
978
+ struct stat st;
979
+ if (lstat(child, &st) == 0) {
980
+ if (S_ISDIR(st.st_mode))
981
+ total += du_n(child);
982
+ else
983
+ total += (uint64_t)st.st_size;
984
+ }
985
+ }
986
+ closedir(d);
987
+ return total;
988
+ }
989
+
990
+ /* LRU 时间: 优先 .stamp 的修改时间,回退目录修改时间(秒) */
991
+ static uint64_t lru_time_n(const char *dir)
992
+ {
993
+ char stamp[PATH_MAX * 2];
994
+ snprintf(stamp, sizeof(stamp), "%s/.stamp", dir);
995
+ struct stat st;
996
+ if (stat(stamp, &st) == 0)
997
+ return (uint64_t)st.st_mtime;
998
+ if (stat(dir, &st) == 0)
999
+ return (uint64_t)st.st_mtime;
1000
+ return 0;
1001
+ }
1002
+
1003
+ static int hex32_n(const char *s)
1004
+ {
1005
+ size_t n = strlen(s);
1006
+ if (n != 32)
1007
+ return 0;
1008
+ for (size_t i = 0; i < n; i++) {
1009
+ char c = s[i];
1010
+ if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')))
1011
+ return 0;
1012
+ }
1013
+ return 1;
1014
+ }
1015
+
1016
+ /* 同应用旧 md5 目录清理: 删除应用组目录下除当前版本外的所有 md5 目录、
1017
+ * 残留 .part 临时目录(当前版本的除外)与旧版本锁文件。尽力而为,失败忽略。 */
1018
+ static void cleanup_app_n(const char *appdir, const char *cur_md5)
1019
+ {
1020
+ DIR *d = opendir(appdir);
1021
+ if (!d)
1022
+ return;
1023
+ struct dirent *e;
1024
+ while ((e = readdir(d)) != NULL) {
1025
+ size_t n = strlen(e->d_name);
1026
+ int is_md5 = hex32_n(e->d_name);
1027
+ int stale_part = n > 5 && strcmp(e->d_name + n - 5, ".part") == 0;
1028
+ int cur_part = n == 37 && strncmp(e->d_name, cur_md5, 32) == 0;
1029
+ int old_lock = n == 37 && memcmp(e->d_name + 32, ".lock", 5) == 0
1030
+ && memcmp(e->d_name, cur_md5, 32) != 0;
1031
+ if (((is_md5 && strcmp(e->d_name, cur_md5) != 0) || stale_part) && !cur_part) {
1032
+ char child[PATH_MAX * 2];
1033
+ snprintf(child, sizeof(child), "%s/%s", appdir, e->d_name);
1034
+ struct stat st;
1035
+ if (lstat(child, &st) == 0 && S_ISDIR(st.st_mode))
1036
+ rmrf_n(child);
1037
+ } else if (old_lock) {
1038
+ char child[PATH_MAX * 2];
1039
+ snprintf(child, sizeof(child), "%s/%s", appdir, e->d_name);
1040
+ unlink(child);
1041
+ }
1042
+ }
1043
+ closedir(d);
1044
+ }
1045
+
1046
+ /* 缓存大小上限: exe 缓存总占用超限时,从最久未用的应用组开始驱逐
1047
+ * (永不删除当前应用组)。应用组列表动态分配,数量无硬编码上限。
1048
+ * 尽力而为,失败忽略。 */
1049
+ static void enforce_cap_n(const char *exe_root, const char *cur_app)
1050
+ {
1051
+ DIR *d = opendir(exe_root);
1052
+ if (!d)
1053
+ return;
1054
+ size_t capacity = 64;
1055
+ char (*names)[64] = malloc(capacity * sizeof(*names));
1056
+ uint64_t *sizes = malloc(capacity * sizeof(*sizes));
1057
+ uint64_t *times = malloc(capacity * sizeof(*times));
1058
+ if (!names || !sizes || !times) {
1059
+ free(names);
1060
+ free(sizes);
1061
+ free(times);
1062
+ closedir(d);
1063
+ return;
1064
+ }
1065
+ int n = 0;
1066
+ uint64_t total = 0;
1067
+ struct dirent *e;
1068
+ while ((e = readdir(d)) != NULL) {
1069
+ if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0)
1070
+ continue;
1071
+ char child[PATH_MAX * 2];
1072
+ snprintf(child, sizeof(child), "%s/%s", exe_root, e->d_name);
1073
+ struct stat st;
1074
+ if (lstat(child, &st) != 0 || !S_ISDIR(st.st_mode))
1075
+ continue;
1076
+ if ((size_t)n >= capacity) {
1077
+ size_t ncap = capacity * 2;
1078
+ char (*nn)[64] = realloc(names, ncap * sizeof(*nn));
1079
+ uint64_t *ns = realloc(sizes, ncap * sizeof(*ns));
1080
+ uint64_t *nt = realloc(times, ncap * sizeof(*nt));
1081
+ if (nn)
1082
+ names = nn;
1083
+ if (ns)
1084
+ sizes = ns;
1085
+ if (nt)
1086
+ times = nt;
1087
+ if (!nn || !ns || !nt)
1088
+ break; /* 内存不足: 用已收集的部分尽力清理 */
1089
+ capacity = ncap;
1090
+ }
1091
+ snprintf(names[n], sizeof(names[n]), "%s", e->d_name);
1092
+ sizes[n] = du_n(child);
1093
+ times[n] = lru_time_n(child);
1094
+ total += sizes[n];
1095
+ n++;
1096
+ }
1097
+ closedir(d);
1098
+
1099
+ uint64_t cap = cache_cap_bytes();
1100
+ while (total > cap) {
1101
+ int victim = -1;
1102
+ for (int i = 0; i < n; i++) {
1103
+ if (sizes[i] == 0 || strcmp(names[i], cur_app) == 0)
1104
+ continue;
1105
+ if (victim < 0 || times[i] < times[victim])
1106
+ victim = i;
1107
+ }
1108
+ if (victim < 0)
1109
+ break;
1110
+ char child[PATH_MAX * 2];
1111
+ snprintf(child, sizeof(child), "%s/%s", exe_root, names[victim]);
1112
+ rmrf_n(child);
1113
+ total -= sizes[victim];
1114
+ sizes[victim] = 0;
1115
+ }
1116
+ free(names);
1117
+ free(sizes);
1118
+ free(times);
1119
+ }
1120
+
1121
+ /* 进程级互斥(flock 锁文件),保证并发首解压串行 */
1122
+ static int g_lockfd = -1;
1123
+
1124
+ static void lock_acquire_n(const char *app, const char *md5)
1125
+ {
1126
+ const char *home = getenv("HOME");
1127
+ if (!home)
1128
+ home = "/tmp";
1129
+ char lockpath[PATH_MAX * 2];
1130
+ snprintf(lockpath, sizeof(lockpath), "%s/.cache/pythub/exe/%s/%s.lock",
1131
+ home, app, md5);
1132
+ mkdir_parents_n(lockpath);
1133
+ g_lockfd = open(lockpath, O_RDWR | O_CREAT, 0666);
1134
+ if (g_lockfd >= 0)
1135
+ flock(g_lockfd, LOCK_EX);
1136
+ }
1137
+
1138
+ static void lock_release_n(void)
1139
+ {
1140
+ if (g_lockfd >= 0) {
1141
+ flock(g_lockfd, LOCK_UN);
1142
+ close(g_lockfd);
1143
+ g_lockfd = -1;
1144
+ }
1145
+ }
1146
+
1147
+ /* 原子解压: 解压到 <缓存>.part,校验启动器后原子改名就位 */
1148
+ static void extract_atomic_n(const uint8_t *buf, uint64_t toc_offset, const char *cache)
1149
+ {
1150
+ char part[PATH_MAX * 2];
1151
+ char entry[PATH_MAX];
1152
+ snprintf(part, sizeof(part), "%s.part", cache);
1153
+ if (access(part, F_OK) == 0)
1154
+ rmrf_n(part); /* 清理上次中断留下的临时目录 */
1155
+ extract_n(buf, toc_offset, part);
1156
+ snprintf(entry, sizeof(entry), "%s/%s", part, ENTRY_REL);
1157
+ if (access(entry, F_OK) != 0) {
1158
+ rmrf_n(part);
1159
+ die("解压失败:启动器未生成,归档可能已损坏");
1160
+ }
1161
+ if (access(cache, F_OK) == 0)
1162
+ rmrf_n(cache); /* 清理异常残留(完整缓存不存在但目录在) */
1163
+ if (rename(part, cache) != 0) {
1164
+ rmrf_n(part);
1165
+ die("解压目录就位失败");
1166
+ }
1167
+ }
1168
+
1169
+ /* 缓存启动器完整性校验(符号链接感知),防缓存目录被篡改:
1170
+ * - 启动器条目为符号链接: 比较缓存 symlink 的目标串与归档条目内容;
1171
+ * - 普通条目: 比较缓存文件内容 MD5 与条目内容 MD5。 */
1172
+ static int launcher_cache_ok_n(const char *cache, const uint8_t *buf, uint64_t toc_offset)
1173
+ {
1174
+ uint64_t doff;
1175
+ uint32_t stored, raw;
1176
+ uint8_t flags;
1177
+ if (!toc_find(buf, toc_offset, ENTRY_REL_TOC, &doff, &stored, &raw, &flags))
1178
+ die("归档缺少启动器条目: %s", ENTRY_REL_TOC);
1179
+ uint8_t *infl = entry_payload(buf + doff, stored, raw, flags);
1180
+ const uint8_t *data = infl ? infl : buf + doff;
1181
+ size_t dlen = infl ? raw : stored;
1182
+
1183
+ char full[PATH_MAX * 2];
1184
+ snprintf(full, sizeof(full), "%s/%s", cache, ENTRY_REL);
1185
+ int ok = 0;
1186
+ if (flags & FLAG_SYMLINK) {
1187
+ char tgt[1024];
1188
+ ssize_t n = readlink(full, tgt, sizeof(tgt) - 1);
1189
+ if (n > 0) {
1190
+ tgt[n] = 0;
1191
+ size_t want = dlen < sizeof(tgt) - 1 ? dlen : sizeof(tgt) - 1;
1192
+ ok = (strlen(tgt) == want) && memcmp(tgt, data, want) == 0;
1193
+ }
1194
+ } else {
1195
+ FILE *f = fopen(full, "rb");
1196
+ if (f) {
1197
+ fseek(f, 0, SEEK_END);
1198
+ long size = ftell(f);
1199
+ rewind(f);
1200
+ if (size > 0) {
1201
+ uint8_t *fdata = (uint8_t *)malloc((size_t)size);
1202
+ if (!fdata)
1203
+ die("内存不足");
1204
+ if (fread(fdata, 1, (size_t)size, f) == (size_t)size) {
1205
+ uint8_t got[16];
1206
+ md5_1(fdata, (size_t)size, got);
1207
+ uint8_t expect[16];
1208
+ md5_1(data, dlen, expect);
1209
+ ok = memcmp(got, expect, 16) == 0;
1210
+ }
1211
+ free(fdata);
1212
+ }
1213
+ fclose(f);
1214
+ }
1215
+ }
1216
+ free(infl);
1217
+ return ok;
1218
+ }
1219
+
1220
+ static int spawn_n(const char *cache, int argc, char **argv)
1221
+ {
1222
+ char entry[PATH_MAX];
1223
+ char pyz[PATH_MAX];
1224
+ snprintf(entry, sizeof(entry), "%s/%s", cache, ENTRY_REL);
1225
+ snprintf(pyz, sizeof(pyz), "%s/%s", cache, PYZ_REL);
1226
+ if (chdir(cache) != 0)
1227
+ die("无法进入缓存目录");
1228
+
1229
+ char **child = (char **)malloc((size_t)(argc + 2) * sizeof(char *));
1230
+ child[0] = entry;
1231
+ child[1] = pyz;
1232
+ for (int i = 1; i < argc; i++)
1233
+ child[i + 1] = argv[i];
1234
+ child[argc + 1] = NULL;
1235
+
1236
+ pid_t pid = fork();
1237
+ if (pid < 0)
1238
+ die("fork 失败");
1239
+ if (pid == 0) {
1240
+ execv(entry, child);
1241
+ _exit(127);
1242
+ }
1243
+ int st = 0;
1244
+ waitpid(pid, &st, 0);
1245
+ free(child);
1246
+ return WIFEXITED(st) ? WEXITSTATUS(st) : 1;
1247
+ }
1248
+
1249
+ int main(int argc, char **argv)
1250
+ {
1251
+ size_t len;
1252
+ uint8_t *buf = read_self(argc > 0 ? argv[0] : ".", &len);
1253
+ if (len < COOKIE_SIZE)
1254
+ die("文件过小,归档不完整");
1255
+ const uint8_t *tail = buf + len - COOKIE_SIZE;
1256
+ if (memcmp(tail, MAGIC, 8) != 0)
1257
+ die("cookie 校验失败,不是 Pythub 自研单文件归档");
1258
+ uint64_t payload_offset = rd64(tail + 8);
1259
+ uint64_t toc_offset = rd64(tail + 16);
1260
+ uint64_t toc_size = rd64(tail + 24);
1261
+ char md5[33];
1262
+ memcpy(md5, tail + 32, 32);
1263
+ md5[32] = 0;
1264
+ char app[APP_FIELD_SIZE + 1];
1265
+ memcpy(app, tail + 64, APP_FIELD_SIZE);
1266
+ app[APP_FIELD_SIZE] = 0;
1267
+ sanitize_app(app);
1268
+
1269
+ verify_body(buf, md5, payload_offset, toc_offset, toc_size);
1270
+
1271
+ const char *home = getenv("HOME");
1272
+ if (!home)
1273
+ home = "/tmp";
1274
+ char exe_root[PATH_MAX * 2];
1275
+ char appdir[PATH_MAX * 2];
1276
+ char cache[PATH_MAX * 2];
1277
+ snprintf(exe_root, sizeof(exe_root), "%s/.cache/pythub/exe", home);
1278
+ snprintf(appdir, sizeof(appdir), "%s/%s", exe_root, app);
1279
+ snprintf(cache, sizeof(cache), "%s/%s", appdir, md5);
1280
+
1281
+ char entry[PATH_MAX];
1282
+ snprintf(entry, sizeof(entry), "%s/%s", cache, ENTRY_REL);
1283
+ int re_extract = 0;
1284
+ if (access(entry, F_OK) != 0) {
1285
+ boot_log("首次运行,正在解压...");
1286
+ re_extract = 1;
1287
+ } else if (!launcher_cache_ok_n(cache, buf, toc_offset)) {
1288
+ boot_log("缓存完整性校验失败,正在重新解压...");
1289
+ re_extract = 1;
1290
+ }
1291
+ if (re_extract) {
1292
+ lock_acquire_n(app, md5);
1293
+ /* 双重检查:并发实例可能已完成/修复解压 */
1294
+ if (access(entry, F_OK) != 0 || !launcher_cache_ok_n(cache, buf, toc_offset))
1295
+ extract_atomic_n(buf, toc_offset, cache);
1296
+ lock_release_n();
1297
+ if (access(entry, F_OK) != 0)
1298
+ die("解压失败:启动器未生成,归档可能已损坏");
1299
+ }
1300
+ /* P2 缓存清理: 每次运行刷新 LRU 时间戳;新版本首解压后清理同应用旧
1301
+ * md5 目录,并按缓存总大小上限驱逐最久未用的应用组(尽力而为) */
1302
+ touch_stamp_n(cache);
1303
+ if (re_extract) {
1304
+ cleanup_app_n(appdir, md5);
1305
+ enforce_cap_n(exe_root, app);
1306
+ }
1307
+ free(buf);
1308
+ return spawn_n(cache, argc, argv);
1309
+ }
1310
+ #endif