2019-05-24 18:27:18 -04:00
|
|
|
|
2021-10-04 23:47:27 -07:00
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-01-17 00:22:13 -06:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
2020-03-27 14:28:48 -05:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
2021-10-29 00:37:25 +01:00
|
|
|
|
2024-05-02 20:20:41 -07:00
|
|
|
|
2020-03-28 00:12:40 -05:00
|
|
|
|
2024-05-02 20:20:41 -07:00
|
|
|
|
2020-03-28 00:12:40 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-07-04 13:44:28 +02:00
|
|
|
|
2020-05-29 16:39:47 -04:00
|
|
|
|
2020-03-28 00:12:40 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-05-29 16:39:47 -04:00
|
|
|
|
2020-03-28 00:12:40 -05:00
|
|
|
|
|
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
|
|
|
|
|
2023-10-06 21:29:08 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
Add/fix missing WASI functionality to pass libstd tests
This rather large commit adds/fixes missing WASI functionality
in `libstd` needed to pass the `libstd` tests. As such, now by
default tests targeting `wasm32-wasi` target are enabled in
`test/tests.zig` module. However, they can be disabled by passing
the `-Dskip-wasi=true` flag when invoking the `zig build test`
command. When the flag is set to `false`, i.e., when WASI tests are
included, `wasmtime` with `--dir=.` is used as the default testing
command.
Since the majority of `libstd` tests were relying on `fs.cwd()`
call to get current working directory handle wrapped in `Dir`
struct, in order to make the tests WASI-friendly, `fs.cwd()`
call was replaced with `testing.getTestDir()` function which
resolved to either `fs.cwd()` for non-WASI targets, or tries to
fetch the preopen list from the WASI runtime and extract a
preopen for '.' path.
The summary of changes introduced by this commit:
* implement `Dir.makeDir` and `Dir.openDir` targeting WASI
* implement `Dir.deleteFile` and `Dir.deleteDir` targeting WASI
* fix `os.close` and map errors in `unlinkat`
* move WASI-specific `mkdirat` and `unlinkat` from `std.fs.wasi`
to `std.os` module
* implement `lseek_{SET, CUR, END}` targeting WASI
* implement `futimens` targeting WASI
* implement `ftruncate` targeting WASI
* implement `readv`, `writev`, `pread{v}`, `pwrite{v}` targeting WASI
* make sure ANSI escape codes are _not_ used in stderr or stdout
in WASI, as WASI always sanitizes stderr, and sanitizes stdout if
fd is a TTY
* fix specifying WASI rights when opening/creating files/dirs
* tweak `AtomicFile` to be WASI-compatible
* implement `os.renameatWasi` for WASI-compliant `os.renameat` function
* implement sleep() targeting WASI
* fix `process.getEnvMap` targeting WASI
2020-05-05 17:23:49 +02:00
|
|
|
|
2020-01-31 19:06:50 -06:00
|
|
|
|
|
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 23:42:10 -07:00
|
|
|
|
|
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-02-04 23:42:10 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-06-22 18:46:56 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
|
|
|
|
|
2022-02-04 22:36:24 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-06 23:30:06 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 12:08:38 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
2024-03-13 15:56:09 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 23:42:10 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-06 23:30:06 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-02-06 23:30:06 -07:00
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-06 23:30:06 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2024-02-06 21:54:20 -05:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-02-22 17:35:36 -05:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 23:35:22 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2022-02-04 23:35:22 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2022-02-04 23:35:22 -07:00
|
|
|
|
|
|
|
|
|
2020-02-22 17:35:36 -05:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-08-23 17:06:56 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2023-01-19 13:50:23 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-08-23 17:06:56 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-11-30 00:13:07 -07:00
|
|
|
|
2023-05-04 18:15:50 -07:00
|
|
|
|
2022-07-25 21:04:30 +02:00
|
|
|
|
2022-12-29 17:38:19 -08:00
|
|
|
|
2021-06-03 15:39:26 -05:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-02-22 15:59:13 -05:00
|
|
|
|
|
|
|
|
|
2022-06-30 17:22:16 +03:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2020-02-22 15:59:13 -05:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-02-22 15:59:13 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-06-03 15:39:26 -05:00
|
|
|
|
2020-02-22 15:59:13 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-02-22 15:59:13 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2021-06-03 15:39:26 -05:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-13 15:56:09 -07:00
|
|
|
|
2022-01-16 20:11:08 -08:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-02-22 17:35:36 -05:00
|
|
|
|
2024-02-09 19:28:57 -08:00
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-02-09 19:28:57 -08:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-02-22 17:35:36 -05:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-01-06 08:40:16 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-07-04 13:44:28 +02:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2023-01-06 08:40:16 -08:00
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2025-02-04 21:19:02 -08:00
|
|
|
|
|
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2025-02-04 21:19:02 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
2025-03-17 17:24:00 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2024-05-26 07:07:44 -04:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2023-01-06 08:40:16 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-06-21 13:47:38 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-02-04 21:19:02 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2025-03-16 17:37:31 -07:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2021-11-30 00:13:07 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-08-23 17:06:56 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2023-01-19 13:50:23 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2021-08-23 17:06:56 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2021-11-30 00:13:07 -07:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-06-15 13:14:16 +06:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2023-06-15 13:14:16 +06:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
2024-07-13 17:29:18 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
|
|
|
|
|
2024-07-13 17:29:18 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
2024-07-13 15:03:55 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 17:29:18 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-12 00:38:10 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2024-07-13 16:54:00 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-11-10 05:27:17 +00:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2021-07-27 08:59:34 +09:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2024-07-13 17:25:06 -07:00
|
|
|
|
2024-07-13 17:29:18 -07:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
|
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2023-04-06 22:57:25 +02:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2024-02-13 16:56:50 -08:00
|
|
|
|
|
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2020-05-29 08:40:32 +02:00
|
|
|
|
2020-05-20 19:42:15 +02:00
|
|
|
|
2020-02-11 23:01:30 +11:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2019-05-26 23:35:26 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-11-06 18:54:08 +00:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2022-01-28 10:40:03 +01:00
|
|
|
|
2025-04-11 17:55:25 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2023-04-26 13:57:08 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2023-02-18 09:02:57 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-10-22 17:52:48 -04:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2023-06-22 18:46:56 +01:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-13 15:56:09 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ArgIteratorWindows: Match post-2008 C runtime rather than CommandLineToArgvW
On Windows, the command line arguments of a program are a single WTF-16 encoded string and it's up to the program to split it into an array of strings. In C/C++, the entry point of the C runtime takes care of splitting the command line and passing argc/argv to the main function.
https://github.com/ziglang/zig/pull/18309 updated ArgIteratorWindows to match the behavior of CommandLineToArgvW, but it turns out that CommandLineToArgvW's behavior does not match the behavior of the C runtime post-2008. In 2008, the C runtime argv splitting changed how it handles consecutive double quotes within a quoted argument (it's now considered an escaped quote, e.g. `"foo""bar"` post-2008 would get parsed into `foo"bar`), and the rules around argv[0] were also changed.
This commit makes ArgIteratorWindows match the behavior of the post-2008 C runtime, and adds a standalone test that verifies the behavior matches both the MSVC and MinGW argv splitting exactly in all cases (it checks that randomly generated command line strings get split the same way).
The motivation here is roughly the same as when the same change was made in Rust (https://github.com/rust-lang/rust/pull/87580), that is (paraphrased):
- Consistent behavior between Zig and modern C/C++ programs
- Allows users to escape double quotes in a way that can be more straightforward
Additionally, the suggested mitigation for BatBadBut (https://flatt.tech/research/posts/batbadbut-you-cant-securely-execute-commands-on-windows/) relies on the post-2008 argv splitting behavior for roundtripping of the arguments given to `cmd.exe`. Note: it's not necessary for the suggested mitigation to work, but it is necessary for the suggested escaping to be parsed back into the intended argv by ArgIteratorWindows after being run through a `.bat` file.
2024-04-15 02:09:19 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2023-12-18 22:55:46 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
2021-05-04 20:47:26 +03:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-02-04 19:55:32 +02:00
|
|
|
|
2022-01-30 11:27:52 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-10-01 23:09:14 +11:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-09 15:04:13 +02:00
|
|
|
|
2023-10-01 23:09:14 +11:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-10 22:48:21 +00:00
|
|
|
|
2023-10-01 23:09:14 +11:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-09-10 13:36:34 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-01-29 14:16:25 -08:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
2020-06-08 22:34:50 -06:00
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-12-21 16:40:30 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2022-12-21 16:40:30 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-24 18:27:18 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
2025-03-26 18:26:48 +01:00
|
|
|
|
|
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-26 18:26:48 +01:00
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
|
|
|
|
|
2025-03-26 18:28:21 +01:00
|
|
|
|
2023-06-15 13:14:16 +06:00
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2019-05-26 13:17:34 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-02-17 15:23:59 -05:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-02-03 15:27:01 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-02 20:20:41 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2024-05-09 15:04:13 +02:00
|
|
|
|
2021-05-22 00:56:30 -05:00
|
|
|
|
|
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2022-11-10 14:00:55 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2022-02-06 23:52:08 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2021-10-29 02:08:41 +01:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2023-06-01 21:03:33 -04:00
|
|
|
|
2023-02-18 09:02:57 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2021-10-04 23:47:27 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2021-10-04 23:47:27 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2020-12-26 13:50:26 -07:00
|
|
|
|
2023-03-06 00:19:32 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-01-21 22:16:22 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-03-06 00:19:32 -07:00
|
|
|
|
2025-04-11 13:28:22 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-03-06 00:19:32 -07:00
|
|
|
|
2023-07-31 11:20:21 -07:00
|
|
|
|
2023-04-21 23:23:14 +01:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-04-21 23:23:14 +01:00
|
|
|
|
2023-07-31 22:10:42 -07:00
|
|
|
|
2023-04-21 23:23:14 +01:00
|
|
|
|
2023-06-22 18:46:56 +01:00
|
|
|
|
2023-04-21 23:23:14 +01:00
|
|
|
|
2023-06-15 14:48:20 -04:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2023-06-15 14:48:20 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-06-15 14:48:20 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-01-21 22:16:22 -08:00
|
|
|
|
2023-06-15 14:48:20 -04:00
|
|
|
|
2023-03-06 00:19:32 -07:00
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
|
|
|
|
|
2023-04-12 18:22:07 -05:00
|
|
|
|
|
|
|
|
|
2024-03-18 22:39:59 -07:00
|
|
|
|
2023-04-12 18:22:07 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-04-04 18:08:02 +02:00
|
|
|
|
2023-04-12 18:22:07 -05:00
|
|
|
|
2024-01-21 22:16:22 -08:00
|
|
|
|
2023-03-06 00:19:32 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-03-12 00:34:11 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-27 10:49:26 -07:00
|
|
|
|
2023-03-12 00:34:11 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-03 18:10:33 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-18 23:35:19 -07:00
|
|
|
|
2024-05-03 18:10:33 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
2024-07-10 00:25:42 +03:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2024-05-26 12:08:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-07-10 00:25:42 +03:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-26 12:08:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-06-27 20:05:22 -07:00
|
|
|
|
2024-05-23 20:22:58 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 14:10:03 -07:00
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-17 17:53:12 -07:00
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2025-03-17 17:53:12 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2024-05-23 11:25:41 -07:00
|
|
|
|
|
|
|
|
|
2024-07-19 17:38:15 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|