feat(stores): Steam download engine in the Rust store crate

Adds src/steam: signs in with the Steam client's saved login, lists owned
games, picks the same depots the client would for a Proton game, downloads
them straight into the Steam library folder (no space reservation, no
staging folder, journal kept outside the game folder), installs shared
redistributables, and writes the app manifest and libraryfolders entries the
way the client does on completion. Uninstall matches the client: the game,
its manifest, depot cache and shader cache go; the Proton prefix stays;
shared depots go only when no other installed game needs them.

Derived from WinNative's wn-steam-client (GPL-3.0-or-later); see
src/steam/NOTICE.md. JNI contract in JNI.md.
This commit is contained in:
The412Banner committed 2026-11-07 06:11:07 +00:00
1 parent 18c7d56409
commit 2b87acff4b
48 files changed
+13436 -13

No files matched your search

+336 -6
View File
@@ -8,6 +8,17 @@ version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
[[package]]
name = "aes"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
dependencies = [
"cfg-if",
"cipher",
"cpufeatures",
]
[[package]]
name = "async-compression"
version = "0.4.42"
@@ -26,12 +37,24 @@ version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
[[package]]
name = "autocfg"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
[[package]]
name = "base64"
version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
[[package]]
name = "base64ct"
version = "1.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
[[package]]
name = "bitflags"
version = "2.11.1"
@@ -47,6 +70,15 @@ dependencies = [
"generic-array",
]
[[package]]
name = "block-padding"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
dependencies = [
"generic-array",
]
[[package]]
name = "bumpalo"
version = "3.20.3"
@@ -65,6 +97,15 @@ version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
[[package]]
name = "cbc"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
dependencies = [
"cipher",
]
[[package]]
name = "cc"
version = "1.2.62"
@@ -93,6 +134,16 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
[[package]]
name = "cipher"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
dependencies = [
"crypto-common",
"inout",
]
[[package]]
name = "combine"
version = "4.6.7"
@@ -120,6 +171,12 @@ version = "0.4.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789"
[[package]]
name = "const-oid"
version = "0.9.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
[[package]]
name = "cpufeatures"
version = "0.2.17"
@@ -163,6 +220,23 @@ dependencies = [
"typenum",
]
[[package]]
name = "data-encoding"
version = "2.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
[[package]]
name = "der"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
dependencies = [
"const-oid",
"pem-rfc7468",
"zeroize",
]
[[package]]
name = "digest"
version = "0.10.7"
@@ -170,7 +244,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"const-oid",
"crypto-common",
"subtle",
]
[[package]]
@@ -188,17 +264,26 @@ dependencies = [
name = "droiddeckstores"
version = "0.1.0"
dependencies = [
"aes",
"cbc",
"cc",
"crc32fast",
"flate2",
"futures-util",
"hmac",
"jni",
"libc",
"lzma-rs",
"rand 0.8.8",
"reqwest",
"rsa",
"ruzstd",
"serde_json",
"sha1",
"sha2",
"tokio",
"tungstenite",
"zeroize",
]
[[package]]
@@ -314,6 +399,15 @@ version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
[[package]]
name = "hmac"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
dependencies = [
"digest",
]
[[package]]
name = "http"
version = "1.4.1"
@@ -386,7 +480,7 @@ dependencies = [
"tokio",
"tokio-rustls",
"tower-service",
"webpki-roots",
"webpki-roots 1.0.7",
]
[[package]]
@@ -525,6 +619,16 @@ dependencies = [
"hashbrown",
]
[[package]]
name = "inout"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
dependencies = [
"block-padding",
"generic-array",
]
[[package]]
name = "ipnet"
version = "2.12.0"
@@ -593,12 +697,27 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "lazy_static"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb"
dependencies = [
"spin",
]
[[package]]
name = "libc"
version = "0.2.186"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
[[package]]
name = "libm"
version = "0.2.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
[[package]]
name = "litemap"
version = "0.8.2"
@@ -654,12 +773,66 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "num-bigint-dig"
version = "0.8.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
dependencies = [
"lazy_static",
"libm",
"num-integer",
"num-iter",
"num-traits",
"rand 0.8.8",
"smallvec",
"zeroize",
]
[[package]]
name = "num-integer"
version = "0.1.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b"
dependencies = [
"num-traits",
]
[[package]]
name = "num-iter"
version = "0.1.46"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b"
dependencies = [
"num-integer",
"num-traits",
]
[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
dependencies = [
"autocfg",
"libm",
]
[[package]]
name = "once_cell"
version = "1.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
[[package]]
name = "pem-rfc7468"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
dependencies = [
"base64ct",
]
[[package]]
name = "percent-encoding"
version = "2.3.2"
@@ -672,6 +845,27 @@ version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
[[package]]
name = "pkcs1"
version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
dependencies = [
"der",
"pkcs8",
"spki",
]
[[package]]
name = "pkcs8"
version = "0.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
dependencies = [
"der",
"spki",
]
[[package]]
name = "potential_utf"
version = "0.1.5"
@@ -728,7 +922,7 @@ dependencies = [
"bytes",
"getrandom 0.3.4",
"lru-slab",
"rand",
"rand 0.9.4",
"ring",
"rustc-hash",
"rustls",
@@ -769,14 +963,35 @@ version = "5.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
[[package]]
name = "rand"
version = "0.8.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c"
dependencies = [
"libc",
"rand_chacha 0.3.1",
"rand_core 0.6.4",
]
[[package]]
name = "rand"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
dependencies = [
"rand_chacha",
"rand_core",
"rand_chacha 0.9.0",
"rand_core 0.9.5",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core 0.6.4",
]
[[package]]
@@ -786,7 +1001,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
dependencies = [
"ppv-lite86",
"rand_core",
"rand_core 0.9.5",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
"getrandom 0.2.17",
]
[[package]]
@@ -833,7 +1057,7 @@ dependencies = [
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"webpki-roots",
"webpki-roots 1.0.7",
]
[[package]]
@@ -850,6 +1074,26 @@ dependencies = [
"windows-sys 0.52.0",
]
[[package]]
name = "rsa"
version = "0.9.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"
dependencies = [
"const-oid",
"digest",
"num-bigint-dig",
"num-integer",
"num-traits",
"pkcs1",
"pkcs8",
"rand_core 0.6.4",
"signature",
"spki",
"subtle",
"zeroize",
]
[[package]]
name = "rustc-hash"
version = "2.1.2"
@@ -897,6 +1141,15 @@ version = "1.0.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
[[package]]
name = "ruzstd"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fad02996bfc73da3e301efe90b1837be9ed8f4a462b6ed410aa35d00381de89f"
dependencies = [
"twox-hash",
]
[[package]]
name = "ryu"
version = "1.0.23"
@@ -995,6 +1248,16 @@ version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "signature"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
dependencies = [
"digest",
"rand_core 0.6.4",
]
[[package]]
name = "simd-adler32"
version = "0.3.9"
@@ -1023,12 +1286,34 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "spin"
version = "0.9.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
[[package]]
name = "spki"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
dependencies = [
"base64ct",
"der",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "subtle"
version = "2.6.1"
@@ -1243,6 +1528,36 @@ version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
[[package]]
name = "tungstenite"
version = "0.26.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
dependencies = [
"bytes",
"data-encoding",
"http",
"httparse",
"log",
"rand 0.9.4",
"rustls",
"rustls-pki-types",
"sha1",
"thiserror 2.0.18",
"utf-8",
"webpki-roots 0.26.11",
]
[[package]]
name = "twox-hash"
version = "1.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
dependencies = [
"cfg-if",
"static_assertions",
]
[[package]]
name = "typenum"
version = "1.20.0"
@@ -1273,6 +1588,12 @@ dependencies = [
"serde",
]
[[package]]
name = "utf-8"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
[[package]]
name = "utf8_iter"
version = "1.0.4"
@@ -1394,6 +1715,15 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "webpki-roots"
version = "0.26.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
dependencies = [
"webpki-roots 1.0.7",
]
[[package]]
name = "webpki-roots"
version = "1.0.7"
+10 -1
View File
@@ -10,16 +10,25 @@ name = "droiddeckstores"
crate-type = ["cdylib"]
[dependencies]
aes = "0.8"
cbc = { version = "0.1", features = ["alloc", "block-padding"] }
crc32fast = "1"
hmac = "0.12"
jni = "0.21"
libc = "0.2"
lzma-rs = { version = "0.3", default-features = false }
lzma-rs = { version = "0.3", default-features = false, features = ["raw_decoder"] }
flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
rand = "0.8"
reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip"] }
rsa = "0.9"
ruzstd = "0.7"
tokio = { version = "1", default-features = false, features = ["rt", "net", "time", "sync"] }
futures-util = { version = "0.3", default-features = false, features = ["std"] }
serde_json = { version = "1", features = ["preserve_order"] }
sha1 = "0.10"
sha2 = "0.10"
tungstenite = { version = "0.26", default-features = false, features = ["handshake", "rustls-tls-webpki-roots"] }
zeroize = "1"
[build-dependencies]
cc = "1"
+196 -5
View File
@@ -2,19 +2,19 @@
The Kotlin side of the store download engines mirrors this file exactly. Every symbol the library
exports is listed here with the class it binds to, the JNI signature, when it is called and on
which thread. The GOG engine and the shared fetch core came from Bannerlator's
`bl-steam-client` crate (method names and signatures match Bannerlator's `BlGogDownload`, only the
package and class names changed). The Epic module (`src/epic/`) and the Amazon module
which thread. The GOG engine, the shared fetch core and the Steam module (`src/steam/`, see its
`NOTICE.md`) are derived from WinNative's `wn-steam-client` crate (GPL-3.0-or-later,
https://github.com/WinNative-Emu/WinNative). The Epic module (`src/epic/`) and the Amazon module
(`src/amazon/`) are DroidDeck's own, each written from a functional spec (see
`docs/development/epic-cleanroom.md` and `docs/development/amazon-cleanroom.md`); their JNI
surfaces below are new.
surfaces below are new, as is the Steam one.
Load it once with `System.loadLibrary("droiddeckstores")`. The library is built by Gradle
(`buildRustStores`, see `app/build.gradle`) and is absent from a `-PskipRust=true` build, so every
call site must be ready for `UnsatisfiedLinkError` on `loadLibrary` or on the first `external`
call and degrade to "store unavailable".
## Conventions that hold for all three engines
## Conventions that hold for all engines
- The `external` functions are declared `@JvmStatic` in a Kotlin `object` (a `JClass` arrives as
the second JNI argument). Declaring them in a plain `object` without `@JvmStatic` also binds —
@@ -290,9 +290,200 @@ absent or that of empty input are created without a request. `.amazon_download_i
created when a run starts and removed when it succeeds, which also creates
`.amazon_download_complete`; nothing reads either marker.
## `com.droiddeck.launcher.stores.steam.SteamNative`
Steam store engine (`src/steam/`): signs in with the Linux Steam client's saved login, lists the
account's games, plans and downloads a game straight into the Steam library folder the client
uses, then writes what the client writes on completion, so the client sees the game as installed
and does not update or verify it. Kotlin runs downloads and uninstalls only while the Steam client
is closed.
```kotlin
package com.droiddeck.launcher.stores.steam
object SteamNative {
@JvmStatic external fun nativeSignIn(steamRootsJson: String, registryVdfPath: String, caBundlePath: String): String
@JvmStatic external fun nativeSignOut()
@JvmStatic external fun nativeLibrary(): String
@JvmStatic external fun nativePlan(appId: Int, language: String): String
@JvmStatic external fun nativeStart(appId: Int, language: String, steamRoot: String, gameLibraryHost: String, gameLibraryGuest: String, libraryRootsJson: String, journalDir: String, caBundlePath: String, maxWorkers: Int, processWorkers: Int, listener: Any): Long
@JvmStatic external fun nativeCancel(handle: Long)
@JvmStatic external fun nativeRelease(handle: Long)
@JvmStatic external fun nativeUninstall(appId: Int, steamRoot: String, gameLibraryHost: String, gameLibraryGuest: String, libraryRootsJson: String): String
}
```
| Method | JNI signature | Symbol suffix |
|---|---|---|
| `nativeSignIn(steamRootsJson, registryVdfPath, caBundlePath): String` | `(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;` | `nativeSignIn` |
| `nativeSignOut()` | `()V` | `nativeSignOut` |
| `nativeLibrary(): String` | `()Ljava/lang/String;` | `nativeLibrary` |
| `nativePlan(appId, language): String` | `(ILjava/lang/String;)Ljava/lang/String;` | `nativePlan` |
| `nativeStart(...)`: Long | `(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IILjava/lang/Object;)J` | `nativeStart` |
| `nativeCancel(handle: Long)` | `(J)V` | `nativeCancel` |
| `nativeRelease(handle: Long)` | `(J)V` | `nativeRelease` |
| `nativeUninstall(appId, steamRoot, gameLibraryHost, gameLibraryGuest, libraryRootsJson): String` | `(ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;` | `nativeUninstall` |
Full symbols are `Java_com_droiddeck_launcher_stores_steam_SteamNative_<suffix>`. Every `String`
answer is a UTF-8 JSON object with `"ok": true|false`; a failure carries `"error": "<short
reason>"`. `nativeSignIn`, `nativeLibrary`, `nativePlan` and `nativeUninstall` block on the
network or the disk: call them off the main thread. A Rust panic is caught at the boundary and
answers `{"ok":false,"error":"internal_error"}`.
Paths: "host" paths are Android paths the app can open; "guest" paths are what the Steam client
sees inside proot (what `libraryfolders.vdf` holds). `libraryRootsJson` is a JSON array of
`{"host": "...", "guest": "..."}`, one per library of the active client; it is used to find shared
app folders and `libraryfolders.vdf` entries, and the game library is added to it when missing.
### `nativeSignIn`
`steamRootsJson`: JSON array of host paths of Steam roots (arm64 and x86-64 clients), searched in
order. `registryVdfPath`: host path of `~/.steam/registry.vdf` (`""` = none). `caBundlePath`: see
conventions (used for the CM directory request).
Reads, never writes: `<root>/config/loginusers.vdf` (accounts), `<root>/local.vdf`
(`MachineUserConfigStore/Software/Valve/Steam/ConnectCache`, keys matched case-insensitively; the
entry whose key starts with the 8-hex-digit CRC32 of the lowercased account name), and
`registry.vdf` (`Registry/HKCU/Software/Valve/Steam/AutoLoginUser`). The account is
`AutoLoginUser` when it names a known account, else the one with `MostRecent` `"1"`, else the
newest `Timestamp`. The token is decrypted in memory (key = SHA-256 of the lowercased account
name; AES-256-ECB-wrapped IV, AES-256-CBC + PKCS#7), checked to be a Steam JWT for that
SteamID64, sent once in the CM logon and zeroized. It is never logged, written, renewed or
replaced.
Answers `{"ok":true,"account":"<AccountName>","steamId":"<SteamID64>"}` or
`{"ok":false,"error":…}` with `no_saved_login` (no account in any `loginusers.vdf`),
`remember_me_off` (`RememberPassword` `"0"`, or no ConnectCache entry: signed out),
`decrypt_failed` (the entry does not decrypt to this account's token), or `logon_failed: …`
(`logon_failed: eresult=<n> <name>` when Steam refused the logon, e.g. `eresult=5
InvalidPassword` for an expired token; otherwise a connection reason). One process-wide session:
a second call while it is logged on answers at once with the same account. After logon the
session sends no persona, friends or presence messages.
`nativeSignOut()` logs off and drops the session; it never touches the client's files.
### `nativeLibrary`
`{"ok":true,"games":[{"appId":291550,"name":"Brawlhalla","installDir":"Brawlhalla","type":"game","free":true}…]}`:
every app the account's licenses grant (package 0, the basic Steam license, is skipped) whose
PICS `common.type` is `game`, sorted by name. `free` = appinfo marks it free to play
(`common.freetogame` or `extended.isfreeapp` `"1"`). Loaded once per session (the first call
fetches PICS for every owned app and can take a while). `not_signed_in` without a session.
### `nativePlan`
What `nativeStart` would install for `appId` with `language` (Steam's language names, e.g.
`english`):
```json
{"ok":true,"appId":291550,"name":"Brawlhalla","installDir":"Brawlhalla","buildId":26465982,
"language":"english","downloadBytes":…,"installBytes":1594368732,
"depots":[{"depotId":291551,"manifestId":"4224536525702420323","size":1565156559,"dlcAppId":0}],
"shared":[{"depotId":228988,"fromAppId":228980,"manifestId":"6645201662696499616","size":29212173}]}
```
Selection (what the client picks for a Windows game run through Proton): `config.oslist` empty or
containing `windows`; `config.osarch` empty or `64` (`32` only when no `64` depot exists);
`config.language` empty or the language (english when the game has no depot for the requested
language but has english ones; the answer's `language` is the one used); no `lowviolence`
depots; DLC depots (`dlcappid`) only when the DLC is owned; `depotfromapp`/`sharedinstall`
depots are listed under `shared` with the owning app (e.g. 228980 Steamworks Common
Redistributables), whose public manifest they use. Manifest gids are the public branch's, sizes
come from PICS, `buildId` is the public branch's. `installBytes`/`downloadBytes` include the
shared depots (they are not checked against what is already installed here). Errors:
`not_signed_in`, `not_owned`, `appinfo unavailable`, `no installable Windows depot`. A free app
the account does not own yet is planned without asking for its license.
### `nativeStart`
Parameters: `appId`, `language`, `steamRoot` (host path of the active client's Steam root; its
`steamapps/` and `config/` hold the two `libraryfolders.vdf` copies, `depotcache/` its cached
manifests), `gameLibraryHost`/`gameLibraryGuest` (the library to install into), `libraryRootsJson`,
`journalDir` (app-private directory for resume journals), `caBundlePath`, `maxWorkers` (request
window ceiling; `0` = 16), `processWorkers` (decrypt/decompress/write threads; `0` = half the
cores, 2 to 6; on SD cards the card writes, not the network, tend to be the limit), `listener`.
Returns `0` without any callback when the listener is null, `appId <= 0`, the JavaVM or a global
ref cannot be obtained, `steamRoot`/`gameLibraryHost`/`gameLibraryGuest`/`journalDir` is empty,
or the worker thread cannot be spawned. Otherwise the run is on a thread named `steam-dl`
(background priority) and `onComplete` fires exactly once, last. `nativeCancel` is idempotent and
safe until `nativeRelease`; call `nativeRelease` exactly once per non-zero handle, after
`onComplete`.
| Listener method | JNI signature | When |
|---|---|---|
| `onProgress(doneBytes: Long, totalBytes: Long, phase: String)` | `(JJLjava/lang/String;)V` | `phase` is `preparing` (sign-in check, plan, takeover, keys, manifests; `0`/`0`), `downloading` (the game's depots), `shared` (shared depots) or `registering`. `doneBytes`/`totalBytes` count the depot files (decompressed) of everything this run installs, shared depots included; chunks already correct on disk count as done. At most every 250 ms, plus at every phase change and depot end. |
| `onComplete(ok: Boolean, result: String)` | `(ZLjava/lang/String;)V` | `{"ok":true,"alreadyInstalled":false}` after a download, `{"ok":true,"alreadyInstalled":true}` when the game was already fully installed at the current build (nothing downloaded or written), or `{"ok":false,"error":"…"}`: `cancelled`, `not_signed_in`, `already_running` (a run for the same app is active), `not_owned`, `free_license_refused`, `library_not_in_libraryfolders` (no `libraryfolders.vdf` entry has the guest path), `not_enough_space: need … MiB, have … MiB`, `access_denied: depot <id>`, or a short message for network and disk failures. |
What a run does, in order:
1. Plans as `nativePlan`; a free app the account does not own is first added to the account with
`CMsgClientRequestFreeLicense`.
2. Takeover check on `<gameLibraryHost>/steamapps/appmanifest_<appId>.acf`: absent → fresh
install; `StateFlags` has 4 and none of the update/download/validate bits and `buildid` is the
current build → `alreadyInstalled`; fully installed at another build → files are checked and
updated in place and the manifest is merged; otherwise (a half-finished client download) the
manifest, `steamapps/downloading/<appId>` and `steamapps/temp/<appId>` are deleted (and any
journal for the app) before downloading.
3. Downloads the game's depots in place into `<gameLibraryHost>/steamapps/common/<installdir>`:
no temp files, no space reservation, each file trimmed to its exact size when its last chunk
lands. A chunk used several times is fetched once. Files already on disk are read back chunk by
chunk and only wrong or missing chunks are fetched (resume, update, taking over a client's
partial files).
4. Shared depots go into the library that holds `appmanifest_<fromAppId>.acf` (else the Steam
root's own library), folder `steamapps/common/<that app's installdir>`; a shared depot already
installed at the planned manifest is skipped.
5. Registers: writes `appmanifest_<appId>.acf` (keys in the client's order: `appid`, `Universe`,
`name`, `StateFlags` 4, `installdir`, `LastUpdated`, `LastPlayed`, `SizeOnDisk` (the game's
depots), `StagingSize`, `buildid`, `LastOwner` (SteamID64), `DownloadType` 1, `UpdateResult`,
`BytesToDownload`/`BytesDownloaded` (compressed size of every installed depot, shared
included), `BytesToStage`/`BytesStaged` (installed size of the game's depots plus the shared
depots installed in this run), `TargetBuildID`, `AutoUpdateBehavior`,
`AllowOtherDownloadsWhileRunning`, `ScheduledAutoUpdate`, `InstalledDepots`
(`manifest`, `size`, plus `dlcappid` for DLC depots), `InstallScripts` when a game depot has
one, `SharedDepots`, `UserConfig`/`MountedConfig` `language`), merging into an existing file
(unknown keys, `LastPlayed` and the auto-update settings are kept). Updates the shared app's
manifest (`SizeOnDisk`, `InstalledDepots`, `InstallScripts` entry such as
`"228988" "_CommonRedist\\vcredist\\2019\\installscript.vdf"`; created when missing).
Adds `"<appId>" "0"` under `apps` of the matching entry in both
`<steamRoot>/steamapps/libraryfolders.vdf` and `<steamRoot>/config/libraryfolders.vdf` (the
client fills in the size later); nothing else there changes. All files are written through a
temp file + rename.
Never written: `config.vdf`, `localconfig.vdf`, `registry.vdf` (the client regenerates them) and
`depotcache/` (the client keeps manifests there with decrypted file names, not in the CDN form
this engine caches; it fetches them when it needs them).
On-disk protocol of the journal: `<journalDir>/<appId>/depot.config` (JSON: `buildId`, the
finished manifest per depot or an in-progress sentinel) and `<depot>_<manifest>.manifest` (raw
CDN manifests). A cancelled or failed run keeps it, and the next `nativeStart` for the same app
resumes (finished depots are skipped, the rest is checked on disk); a journal written for another
build is dropped. It is deleted after a successful registration. Nothing extra is ever left in
the game folder.
### `nativeUninstall`
Matches the client's own uninstall: deletes `<gameLibraryHost>/steamapps/common/<installdir>` and
the game's `appmanifest_<appId>.acf`, `<steamRoot>/depotcache/<depot>_<manifest>.manifest` for
the game's `InstalledDepots` and `<steamRoot>/steamapps/shadercache/<appId>`; keeps
`steamapps/compatdata/<appId>` (the Proton prefix, i.e. saves). For each of the game's
`SharedDepots` that no other installed game in any library lists, deletes that depot's files from
the shared app's folder (empty folders stay, as with the client) and removes its
`InstalledDepots` and `InstallScripts` entries and its size from the shared app's manifest. The
file list comes from the client's `depotcache` copy of that manifest, else from the CDN through
the live session; without either the shared depot is left installed and listed in `keptShared`.
Removes the app from `apps` in both `libraryfolders.vdf` copies.
Answers `{"ok":true,"removedShared":[228988],"keptShared":[]}`, or `{"ok":false,"error":…}`:
`not_installed` (no app manifest), `bad installdir in app manifest`, `bad arguments`, or a disk
error.
## Log tags
Lines go to logcat under `GogNative` and `EpicNative` (the Amazon module logs only through
`onLog`). Bannerlator used `BL_GOG_DL` for the GOG engine; the fetch core's line grammar
(`fetch-start`, `fetch-window`, `throughput`, `fetch-end`, `summary`) is unchanged, so its tuning
notes still read against a DroidDeck log.
The Steam module logs under `DroidDeckSteam` and never logs a token; its chunk downloads go
through the fetch core with the label `steam depot=<id>`.
+2 -1
View File
@@ -1,4 +1,4 @@
//! Ported from Bannerlator's bl-steam-client crate (GPL-3.0-or-later), itself derived from WinNative's wn-steam-client.
//! DroidDeck's store download engines. The Steam client and the shared fetch core are derived from WinNative's wn-steam-client (GPL-3.0-or-later, https://github.com/WinNative-Emu/WinNative).
#![allow(clippy::missing_safety_doc, clippy::result_large_err)]
@@ -9,4 +9,5 @@ pub mod fetch_tuning;
pub mod gog;
pub mod md5_small;
pub mod priority;
pub mod steam;
pub mod stores_jni;
@@ -0,0 +1,48 @@
# Steam store engine: provenance and license notice
The Steam module of `libdroiddeckstores.so` (`app/src/main/rust/stores/src/steam/`) is a
**derivative work of the `wn-steam-client` crate from the WinNative project**,
<https://github.com/WinNative-Emu/WinNative>, directory
`app/src/main/cpp/wn-steam-client/rust`, taken at upstream commit `a2020b7` (2026-09-01).
The upstream crate is published under **GPL-3.0-or-later**; this derivative is distributed under
the same license as part of DroidDeck. Copyright in the original code remains with the WinNative
authors and contributors, including maxjivi05.
The shared fetch core (`src/fetch_core.rs`, `src/fetch_tuning.rs`) and `src/md5_small.rs`, which
this module uses, come from the same upstream crate.
## Modifications made in DroidDeck (GPL-3.0 §5(a) statement of changes)
Date of modification: 2026-11-07.
- Ported into the `droiddeckstores` crate as the module `steam`; identifiers, log tag
(`DroidDeckSteam`) and thread name (`steam-dl`) follow DroidDeck naming.
- Kept, with import paths adapted: WebSocket transport (`ws_connection`, `transport`), channel
encryption and handshake (`encrypted_channel`, `handshake_messages`, `crypto`, `key_dictionary`),
CM server discovery (`cm_server`, `cm_server_list`, `steam_directory`), wire formats
(`emsg`, `cmsg_protobuf_header`, `proto_envelope`, `proto_wire`, `wire_format`, `base64`, `vdf`),
`heartbeat`, `job_manager`, `content_manifest`, `depot_chunk`, and the protobuf messages for
logon, licenses, PICS, depot keys, manifest request codes, CDN servers and free licenses.
- `cm_client` reduced to logon with a refresh token, heartbeat, log-off and the download-store
requests; the logon sends `machine_id` `DroidDeck-Steam`; logon and log-off EResults are kept
for error reporting.
- `cm_runtime`: no persona or friends traffic after logon, the C-ABI bridge (`cm_bridge`) is
removed, and outbound messages are cleared from memory once sent.
- Blocking HTTP replaced by a one-shot request helper (`http`); `cdn_client` reduced to `cdn`
(URLs, manifest and HTTP-delivered appinfo fetches); CDN servers are de-duplicated by host,
capped at 10 and filtered by `allowed_app_ids`.
- `depot_writer` rewritten on DroidDeck's shared fetch core: files are written in place without
`fallocate` or zero-fill and trimmed with `set_len`; the number of decode/write workers is a
parameter; a chunk used in several places is fetched once; on resume, chunks on disk are read
back and checked before anything is fetched.
- `depot_config` / `depot_downloader`: the resume journal moved out of the game folder into a
caller-given directory, keyed by app and build; the progress sidecar and clean-pause markers are
dropped.
- New: `signin` (reuse of the Linux Steam client's saved login), `session` (one process-wide CM
session), `library`, `plan` (depot selection), `register` (app manifests, shared depots,
`libraryfolders.vdf`, takeover of half-finished client downloads, uninstall), `kv` (Valve
KeyValues writer), `install` (download orchestration) and a new JNI layer (`jni`).
- Not ported: QR and password sign-in, auth sessions, friends, chat and chat images, persona,
lobbies, cloud, user stats, achievements, inventory, published files and workshop, app and
ownership tickets, playing-session control, the Wine bridge, the other stores' downloaders,
the version module and the original JNI layer.
@@ -0,0 +1,97 @@
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
pub fn encode(bytes: &[u8]) -> String {
if bytes.is_empty() {
return String::new();
}
let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
let (chunks, remainder) = bytes.as_chunks::<3>();
for chunk in chunks {
let v = ((chunk[0] as u32) << 16) | ((chunk[1] as u32) << 8) | chunk[2] as u32;
out.push(ALPHABET[((v >> 18) & 0x3f) as usize] as char);
out.push(ALPHABET[((v >> 12) & 0x3f) as usize] as char);
out.push(ALPHABET[((v >> 6) & 0x3f) as usize] as char);
out.push(ALPHABET[(v & 0x3f) as usize] as char);
}
match remainder {
[a] => {
let v = (*a as u32) << 16;
out.push(ALPHABET[((v >> 18) & 0x3f) as usize] as char);
out.push(ALPHABET[((v >> 12) & 0x3f) as usize] as char);
out.push('=');
out.push('=');
}
[a, b] => {
let v = ((*a as u32) << 16) | ((*b as u32) << 8);
out.push(ALPHABET[((v >> 18) & 0x3f) as usize] as char);
out.push(ALPHABET[((v >> 12) & 0x3f) as usize] as char);
out.push(ALPHABET[((v >> 6) & 0x3f) as usize] as char);
out.push('=');
}
[] => {}
_ => unreachable!(),
}
out
}
pub fn decode(s: &str) -> Option<Vec<u8>> {
let mut out = Vec::with_capacity((s.len() / 4) * 3 + 3);
let mut acc = 0u32;
let mut bits = 0u32;
for b in s.bytes() {
let v = value_of(b)?;
let Some(v) = v else {
continue;
};
acc = (acc << 6) | v as u32;
bits += 6;
if bits >= 8 {
bits -= 8;
out.push(((acc >> bits) & 0xff) as u8);
}
}
Some(out)
}
fn value_of(b: u8) -> Option<Option<u8>> {
match b {
b'A'..=b'Z' => Some(Some(b - b'A')),
b'a'..=b'z' => Some(Some(b - b'a' + 26)),
b'0'..=b'9' => Some(Some(b - b'0' + 52)),
b'+' | b'-' => Some(Some(62)),
b'/' | b'_' => Some(Some(63)),
b'=' | b' ' | b'\t' | b'\n' | b'\r' => Some(None),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encodes_rfc4648_padding() {
assert_eq!(encode(b""), "");
assert_eq!(encode(b"f"), "Zg==");
assert_eq!(encode(b"fo"), "Zm8=");
assert_eq!(encode(b"foo"), "Zm9v");
assert_eq!(encode(b"foobar"), "Zm9vYmFy");
}
#[test]
fn decodes_standard_urlsafe_and_whitespace() {
assert_eq!(decode("Zm9v YmFy"), Some(b"foobar".to_vec()));
assert_eq!(decode("SGVsbG8td29ybGQ_"), Some(b"Hello-world?".to_vec()));
assert_eq!(decode("Zg=="), Some(b"f".to_vec()));
}
#[test]
fn invalid_character_fails() {
assert_eq!(decode("Zm9v*"), None);
}
}
+439
View File
@@ -0,0 +1,439 @@
//! SteamPipe CDN: URL formation, manifest + HTTP-delivered appinfo fetches, and the zip/gzip
//! helpers they need. Chunk bodies are fetched by the shared fetch core (`crate::fetch_core`).
use crate::steam::pb::ccontentserverdirectory::CContentServerDirectoryServerInfo;
use flate2::read::{DeflateDecoder, GzDecoder};
use std::io::Read;
use std::time::Duration;
/// Distinct CDN hosts a depot run spreads over. Each chunk carries one URL per host, so this also
/// bounds the per-chunk URL memory.
pub const MAX_CDN_HOSTS: usize = 10;
pub const MAX_MANIFEST_FETCH_ATTEMPTS: usize = 5;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CdnManifestResult {
pub raw_manifest: Vec<u8>,
pub error: String,
pub http_status: i32,
}
impl CdnManifestResult {
pub fn ok(&self) -> bool {
self.error.is_empty() && !self.raw_manifest.is_empty()
}
}
pub fn default_timeout() -> Duration {
Duration::from_secs(30)
}
pub fn build_manifest_url(
server: &CContentServerDirectoryServerInfo,
depot_id: u32,
manifest_id: u64,
request_code: u64,
) -> Result<String, String> {
let host = preferred_host(server).ok_or_else(|| "cdn server has no host".to_string())?;
let mut url = format!(
"{}://{}:{}/depot/{}/manifest/{}/5",
if server.use_https() { "https" } else { "http" },
host,
server.port(),
depot_id,
manifest_id
);
if request_code != 0 {
url.push('/');
url.push_str(&request_code.to_string());
}
Ok(url)
}
pub fn build_chunk_url(
server: &CContentServerDirectoryServerInfo,
depot_id: u32,
chunk_sha: &[u8],
) -> Result<String, String> {
if chunk_sha.is_empty() {
return Err("empty chunk sha".to_string());
}
let host = preferred_host(server).ok_or_else(|| "cdn server has no host".to_string())?;
Ok(format!(
"{}://{}:{}/depot/{}/chunk/{}",
if server.use_https() { "https" } else { "http" },
host,
server.port(),
depot_id,
hex_encode(chunk_sha)
))
}
/// The per-host key the fetch core caps concurrency on (vhost when present, as the URL uses it).
pub fn host_key(server: &CContentServerDirectoryServerInfo) -> String {
preferred_host(server).unwrap_or_default().to_string()
}
/// Usable servers (not China-only, with a host), de-duplicated by host key, in directory order,
/// at most [`MAX_CDN_HOSTS`].
pub fn usable_servers(
servers: &[CContentServerDirectoryServerInfo],
) -> Vec<CContentServerDirectoryServerInfo> {
let mut out: Vec<CContentServerDirectoryServerInfo> = Vec::new();
for server in servers {
if server.steam_china_only || server.host.is_empty() {
continue;
}
let key = host_key(server);
if out.iter().any(|s| host_key(s) == key) {
continue;
}
out.push(server.clone());
if out.len() >= MAX_CDN_HOSTS {
break;
}
}
out
}
pub fn fetch_manifest(
server: &CContentServerDirectoryServerInfo,
depot_id: u32,
manifest_id: u64,
request_code: u64,
ca_bundle_path: &str,
timeout: Duration,
) -> CdnManifestResult {
let url = match build_manifest_url(server, depot_id, manifest_id, request_code) {
Ok(url) => url,
Err(error) => {
return CdnManifestResult {
error,
..Default::default()
}
}
};
match crate::steam::http::get(&url, timeout, ca_bundle_path) {
Ok(response) => validate_manifest_response(
response.status as i32,
response.body,
response.content_length,
),
Err(error) => CdnManifestResult {
error,
..Default::default()
},
}
}
/// Tries the servers in order (wrapping) with the shared back-off, up to
/// [`MAX_MANIFEST_FETCH_ATTEMPTS`] attempts.
pub fn fetch_manifest_with_retry(
servers: &[CContentServerDirectoryServerInfo],
depot_id: u32,
manifest_id: u64,
request_code: u64,
ca_bundle_path: &str,
cancel: &std::sync::atomic::AtomicBool,
) -> CdnManifestResult {
if servers.is_empty() {
return CdnManifestResult {
error: "no CDN servers available".to_string(),
..Default::default()
};
}
let mut last = CdnManifestResult::default();
for attempt in 0..MAX_MANIFEST_FETCH_ATTEMPTS {
if cancel.load(std::sync::atomic::Ordering::Relaxed) {
return CdnManifestResult {
error: "cancelled".to_string(),
..Default::default()
};
}
if attempt > 0 {
std::thread::sleep(Duration::from_millis(
crate::fetch_tuning::retry_backoff_millis(attempt as u32),
));
}
let server = &servers[attempt % servers.len()];
last = fetch_manifest(
server,
depot_id,
manifest_id,
request_code,
ca_bundle_path,
default_timeout(),
);
if last.ok() {
return last;
}
}
last
}
/// HTTP-delivered PICS appinfo URL (large appinfo the CM did not inline).
pub fn build_appinfo_url(http_host: &str, app_id: u32, sha: &[u8]) -> String {
format!(
"http://{}/appinfo/{}/sha/{}.txt.gz",
http_host,
app_id,
hex_encode(sha)
)
}
/// Fetch + gunzip an HTTP-delivered appinfo blob (same VDF as an inline `buffer`).
pub fn fetch_appinfo(
http_host: &str,
app_id: u32,
sha: &[u8],
ca_bundle_path: &str,
timeout: Duration,
) -> Option<Vec<u8>> {
if http_host.is_empty() || sha.is_empty() {
return None;
}
let url = build_appinfo_url(http_host, app_id, sha);
let response = crate::steam::http::get(&url, timeout, ca_bundle_path).ok()?;
if response.status != 200 || response.body.is_empty() {
return None;
}
Some(maybe_gunzip(response.body))
}
pub fn validate_manifest_response(
http_status: i32,
body: Vec<u8>,
content_length: Option<u64>,
) -> CdnManifestResult {
if http_status != 200 {
return CdnManifestResult {
http_status,
error: format!("HTTP status {http_status}"),
..Default::default()
};
}
if let Some(expected) = content_length {
if body.len() as u64 != expected {
return CdnManifestResult {
http_status,
error: "manifest body truncated (length mismatch)".to_string(),
..Default::default()
};
}
}
let Some(raw_manifest) = unzip_first_entry(&body) else {
return CdnManifestResult {
http_status,
error: "manifest unzip failed".to_string(),
..Default::default()
};
};
CdnManifestResult {
raw_manifest,
error: String::new(),
http_status,
}
}
pub fn unzip_first_entry(zip: &[u8]) -> Option<Vec<u8>> {
if zip.len() < 30 || read_u32(zip, 0)? != 0x0403_4b50 {
return None;
}
let flags = read_u16(zip, 6)?;
let method = read_u16(zip, 8)?;
let comp_size = read_u32(zip, 18)? as usize;
let uncomp_size = read_u32(zip, 22)? as usize;
let name_len = read_u16(zip, 26)? as usize;
let extra_len = read_u16(zip, 28)? as usize;
if (flags & 0x08) != 0 {
return None;
}
let data_off = 30usize.checked_add(name_len)?.checked_add(extra_len)?;
if data_off.checked_add(comp_size)? > zip.len() {
return None;
}
let data = &zip[data_off..data_off + comp_size];
match method {
0 => Some(data.to_vec()),
8 => {
let mut out = Vec::with_capacity(uncomp_size);
DeflateDecoder::new(data).read_to_end(&mut out).ok()?;
Some(out)
}
_ => None,
}
}
/// Gunzip; pass through already-inflated bytes (edge caches may decompress).
pub fn maybe_gunzip(body: Vec<u8>) -> Vec<u8> {
if body.len() >= 2 && body[0] == 0x1f && body[1] == 0x8b {
let mut out = Vec::new();
if GzDecoder::new(&body[..]).read_to_end(&mut out).is_ok() && !out.is_empty() {
return out;
}
}
body
}
pub fn hex_encode(bytes: &[u8]) -> String {
crate::gog::to_hex(bytes)
}
fn preferred_host(server: &CContentServerDirectoryServerInfo) -> Option<&str> {
if !server.vhost.is_empty() {
Some(&server.vhost)
} else if !server.host.is_empty() {
Some(&server.host)
} else {
None
}
}
fn read_u16(buf: &[u8], off: usize) -> Option<u16> {
Some(u16::from_le_bytes(buf.get(off..off + 2)?.try_into().ok()?))
}
fn read_u32(buf: &[u8], off: usize) -> Option<u32> {
Some(u32::from_le_bytes(buf.get(off..off + 4)?.try_into().ok()?))
}
#[cfg(test)]
mod tests {
use super::*;
use flate2::{write::DeflateEncoder, Compression};
use std::io::Write;
#[test]
fn extracts_stored_zip_entry() {
let zip = zip_with_entry(0, b"manifest bytes");
assert_eq!(unzip_first_entry(&zip), Some(b"manifest bytes".to_vec()));
}
#[test]
fn extracts_deflated_zip_entry() {
let mut encoder = DeflateEncoder::new(Vec::new(), Compression::default());
encoder.write_all(b"manifest bytes").unwrap();
let deflated = encoder.finish().unwrap();
let zip = zip_with_compressed_entry(8, &deflated, b"manifest bytes".len() as u32);
assert_eq!(unzip_first_entry(&zip), Some(b"manifest bytes".to_vec()));
}
#[test]
fn rejects_data_descriptor_zip_entry() {
let mut zip = zip_with_entry(0, b"x");
zip[6] = 0x08;
assert_eq!(unzip_first_entry(&zip), None);
}
#[test]
fn hex_encodes_lowercase() {
assert_eq!(hex_encode(&[0, 1, 0xab, 0xff]), "0001abff");
}
#[test]
fn builds_http_appinfo_url() {
assert_eq!(
build_appinfo_url("cache1.steamcontent.com", 601150, &[0xab, 0xcd, 0x01]),
"http://cache1.steamcontent.com/appinfo/601150/sha/abcd01.txt.gz"
);
}
#[test]
fn gunzips_gzip_and_passes_through_plain_vdf() {
use flate2::write::GzEncoder;
let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder.write_all(b"\"appinfo\"{}").unwrap();
let gz = encoder.finish().unwrap();
assert_eq!(maybe_gunzip(gz), b"\"appinfo\"{}");
assert_eq!(maybe_gunzip(b"\"appinfo\"{}".to_vec()), b"\"appinfo\"{}");
}
#[test]
fn builds_manifest_and_chunk_urls() {
let server = CContentServerDirectoryServerInfo {
host: "edge.steamcontent.com".into(),
vhost: "cdn.example".into(),
https_support: "mandatory".into(),
..Default::default()
};
assert_eq!(
build_manifest_url(&server, 100, 200, 300).unwrap(),
"https://cdn.example:443/depot/100/manifest/200/5/300"
);
assert_eq!(
build_chunk_url(&server, 100, &[0xab, 0xcd]).unwrap(),
"https://cdn.example:443/depot/100/chunk/abcd"
);
let plain = CContentServerDirectoryServerInfo {
host: "cache1.example".into(),
..Default::default()
};
assert_eq!(
build_manifest_url(&plain, 1, 2, 0).unwrap(),
"http://cache1.example:80/depot/1/manifest/2/5"
);
}
#[test]
fn usable_servers_drop_china_empty_and_duplicate_hosts() {
let server = |host: &str, vhost: &str, china: bool| CContentServerDirectoryServerInfo {
host: host.into(),
vhost: vhost.into(),
steam_china_only: china,
..Default::default()
};
let list = usable_servers(&[
server("a", "", false),
server("b", "", true),
server("", "", false),
server("c", "a", false),
server("d", "", false),
]);
let hosts: Vec<_> = list.iter().map(host_key).collect();
assert_eq!(hosts, vec!["a", "d"]);
let many: Vec<_> = (0..20)
.map(|i| server(&format!("h{i}"), "", false))
.collect();
assert_eq!(usable_servers(&many).len(), MAX_CDN_HOSTS);
}
#[test]
fn validates_http_status_lengths_and_manifest_zip() {
let zip = zip_with_entry(0, b"manifest bytes");
let ok = validate_manifest_response(200, zip.clone(), Some(zip.len() as u64));
assert!(ok.ok());
assert_eq!(ok.raw_manifest, b"manifest bytes");
let short = validate_manifest_response(200, zip, Some(999));
assert_eq!(short.error, "manifest body truncated (length mismatch)");
assert_eq!(
validate_manifest_response(404, vec![], None).error,
"HTTP status 404"
);
}
fn zip_with_entry(method: u16, data: &[u8]) -> Vec<u8> {
zip_with_compressed_entry(method, data, data.len() as u32)
}
fn zip_with_compressed_entry(method: u16, data: &[u8], uncomp_size: u32) -> Vec<u8> {
let mut out = Vec::new();
out.extend_from_slice(&0x0403_4b50u32.to_le_bytes());
out.extend_from_slice(&20u16.to_le_bytes());
out.extend_from_slice(&0u16.to_le_bytes());
out.extend_from_slice(&method.to_le_bytes());
out.extend_from_slice(&0u16.to_le_bytes());
out.extend_from_slice(&0u16.to_le_bytes());
out.extend_from_slice(&0u32.to_le_bytes());
out.extend_from_slice(&(data.len() as u32).to_le_bytes());
out.extend_from_slice(&uncomp_size.to_le_bytes());
out.extend_from_slice(&1u16.to_le_bytes());
out.extend_from_slice(&0u16.to_le_bytes());
out.extend_from_slice(b"x");
out.extend_from_slice(data);
out
}
}
@@ -0,0 +1,852 @@
//! CM session state and message builders: logon with a refresh token, heartbeat, log-off, and the
//! requests a download store needs (PICS, depot keys, manifest request codes, CDN server list,
//! free licenses). Social, stats, cloud, lobby and ticket messages are not part of this port.
use crate::steam::cmsg_protobuf_header::{CMsgProtoBufHeader, INVALID_JOB_ID};
use crate::steam::crypto::generate_session_key;
use crate::steam::emsg::EMsg;
use crate::steam::job_manager::JobResult;
use crate::steam::pb::ccontentserverdirectory::{
CContentServerDirectoryGetManifestRequestCodeRequest,
CContentServerDirectoryGetServersForSteamPipeRequest,
};
use crate::steam::pb::cmsg_client_get_depot_decryption_key::CMsgClientGetDepotDecryptionKey;
use crate::steam::pb::cmsg_client_license_list::{CMsgClientLicenseList, License};
use crate::steam::pb::cmsg_client_pics::{
CMsgClientPICSAccessTokenRequest, CMsgClientPICSProductInfoRequest, PicsAppInfoReq,
PicsPackageInfoReq,
};
use crate::steam::pb::cmsg_client_request_free_license::CMsgClientRequestFreeLicense;
use crate::steam::pb::cmsg_clientserver_login::{
CMsgClientHeartBeat, CMsgClientHello, CMsgClientLogOff, CMsgClientLogon,
CMsgClientLogonResponse,
};
use crate::steam::proto_envelope::encode_proto_envelope;
use flate2::read::{GzDecoder, ZlibDecoder};
use std::io::Read;
use std::sync::atomic::{AtomicI32, AtomicU32, AtomicU64, AtomicU8, Ordering};
use std::sync::Mutex;
/// Sent as `machine_id` in the logon.
pub const MACHINE_ID: &[u8] = b"DroidDeck-Steam";
const LOGON_PROTOCOL_VERSION: u32 = 65580;
const LOGON_CLIENT_OS_TYPE: u32 = 16;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum ClientState {
Disconnected,
Connecting,
Connected,
LoggedOn,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum InboundAction {
DeliverJob(JobResult),
Multi,
PicsProductInfo,
LogonOk,
LoggedOff,
LicenseList(usize),
ClientMessage,
Ignored,
ParseFailed(&'static str),
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgMultiBody {
pub size_unzipped: u32,
pub message_body: Vec<u8>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct OutboundProtoMessage {
pub emsg: EMsg,
pub routing_appid: u32,
pub body: Vec<u8>,
pub wire: Vec<u8>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct OutboundServiceCall {
pub method_name: String,
pub authed: bool,
pub job_id: u64,
pub request_body: Vec<u8>,
pub wire: Vec<u8>,
}
pub struct CMClientCore {
state: AtomicU8,
steam_id: AtomicU64,
session_id: AtomicI32,
cell_id: AtomicU32,
/// EResult of the last logon response or log-off (0 = none yet).
last_logon_eresult: AtomicI32,
license_list: Mutex<Option<Vec<License>>>,
outbound_wires: Mutex<Vec<Vec<u8>>>,
}
impl Default for CMClientCore {
fn default() -> Self {
Self {
state: AtomicU8::new(ClientState::Disconnected as u8),
steam_id: AtomicU64::new(0),
session_id: AtomicI32::new(0),
cell_id: AtomicU32::new(0),
last_logon_eresult: AtomicI32::new(0),
license_list: Mutex::new(None),
outbound_wires: Mutex::new(Vec::new()),
}
}
}
impl CMClientCore {
pub fn state(&self) -> ClientState {
match self.state.load(Ordering::Relaxed) {
1 => ClientState::Connecting,
2 => ClientState::Connected,
3 => ClientState::LoggedOn,
_ => ClientState::Disconnected,
}
}
pub fn set_state(&self, state: ClientState) {
self.state.store(state as u8, Ordering::Relaxed);
}
pub fn reset_session_identity(&self) {
self.steam_id.store(0, Ordering::Relaxed);
self.session_id.store(0, Ordering::Relaxed);
self.outbound_wires
.lock()
.expect("outbound queue poisoned")
.clear();
}
pub fn steam_id(&self) -> u64 {
self.steam_id.load(Ordering::Relaxed)
}
pub fn session_id(&self) -> i32 {
self.session_id.load(Ordering::Relaxed)
}
pub fn cell_id(&self) -> u32 {
self.cell_id.load(Ordering::Relaxed)
}
pub fn last_logon_eresult(&self) -> i32 {
self.last_logon_eresult.load(Ordering::Relaxed)
}
pub fn clear_last_logon_eresult(&self) {
self.last_logon_eresult.store(0, Ordering::Relaxed);
}
/// The license list Steam pushed after logon; `None` until it arrived.
pub fn license_list(&self) -> Option<Vec<License>> {
self.license_list
.lock()
.expect("license list poisoned")
.clone()
}
pub fn enqueue_proto_message(&self, message: Option<OutboundProtoMessage>) -> bool {
let Some(message) = message else {
return false;
};
self.enqueue_wire(message.wire)
}
pub fn enqueue_wire(&self, wire: Vec<u8>) -> bool {
if wire.is_empty() {
return false;
}
self.outbound_wires
.lock()
.expect("outbound queue poisoned")
.push(wire);
true
}
pub fn restore_outbound_wires_front(&self, mut wires: Vec<Vec<u8>>) {
if wires.is_empty() {
return;
}
let mut queue = self.outbound_wires.lock().expect("outbound queue poisoned");
if queue.is_empty() {
*queue = wires;
return;
}
let mut restored = Vec::with_capacity(wires.len() + queue.len());
restored.append(&mut wires);
restored.append(&mut queue);
*queue = restored;
}
pub fn take_outbound_wires(&self) -> Vec<Vec<u8>> {
std::mem::take(&mut *self.outbound_wires.lock().expect("outbound queue poisoned"))
}
pub fn build_proto_message(&self, emsg: EMsg, body: &[u8], routing_appid: u32) -> Vec<u8> {
let mut header = CMsgProtoBufHeader {
steamid: self.steam_id(),
client_sessionid: self.session_id(),
routing_appid,
..Default::default()
};
if emsg == EMsg::CLIENT_LOGON && header.steamid == 0 {
header.steamid = 0x0110_0001_0000_0000;
}
encode_proto_envelope(emsg, &header, body)
}
pub fn build_client_hello(&self) -> OutboundProtoMessage {
let body = CMsgClientHello::default().serialize();
let wire = self.build_proto_message(EMsg::CLIENT_HELLO, &body, 0);
OutboundProtoMessage {
emsg: EMsg::CLIENT_HELLO,
routing_appid: 0,
body,
wire,
}
}
pub fn build_heartbeat(&self) -> OutboundProtoMessage {
let body = CMsgClientHeartBeat::default().serialize();
let wire = self.build_proto_message(EMsg::CLIENT_HEART_BEAT, &body, 0);
OutboundProtoMessage {
emsg: EMsg::CLIENT_HEART_BEAT,
routing_appid: 0,
body,
wire,
}
}
pub fn build_logoff(&self) -> Option<OutboundProtoMessage> {
if self.state() != ClientState::LoggedOn {
return None;
}
self.build_outbound_proto_message(EMsg::CLIENT_LOG_OFF, CMsgClientLogOff.serialize(), 0)
}
/// `ClientLogon` carrying the saved refresh token as `access_token`. The returned wire holds
/// the token; drop it as soon as it is queued.
pub fn build_logon_with_refresh_token(
&self,
refresh_token: &str,
account_name: &str,
client_supplied_steam_id: u64,
) -> Option<OutboundProtoMessage> {
if self.state() != ClientState::Connected || refresh_token.is_empty() {
return None;
}
let mut msg = CMsgClientLogon {
access_token: refresh_token.to_string(),
account_name: account_name.to_string(),
client_supplied_steam_id,
machine_id: MACHINE_ID.to_vec(),
protocol_version: LOGON_PROTOCOL_VERSION,
client_os_type: LOGON_CLIENT_OS_TYPE,
supports_rate_limit_response: true,
..Default::default()
};
if let Some(key) = generate_session_key() {
let mut client_instance_id = 0u64;
for (idx, byte) in key.bytes.iter().take(8).enumerate() {
client_instance_id |= (*byte as u64) << (idx * 8);
}
msg.client_instance_id = client_instance_id.max(1);
let mut login_id = 0u32;
for (idx, byte) in key.bytes.iter().skip(8).take(4).enumerate() {
login_id |= (*byte as u32) << (idx * 8);
}
msg.obfuscated_private_ip = login_id.max(1);
}
let body = msg.serialize();
zeroize::Zeroize::zeroize(&mut msg.access_token);
let wire = self.build_proto_message(EMsg::CLIENT_LOGON, &body, 0);
let mut body = body;
zeroize::Zeroize::zeroize(&mut body);
Some(OutboundProtoMessage {
emsg: EMsg::CLIENT_LOGON,
routing_appid: 0,
body: Vec::new(),
wire,
})
}
pub fn build_service_method_call(
&self,
method_name: &str,
authed: bool,
job_id: u64,
request_body: &[u8],
) -> Vec<u8> {
let header = CMsgProtoBufHeader {
steamid: self.steam_id(),
client_sessionid: self.session_id(),
jobid_source: job_id,
jobid_target: INVALID_JOB_ID,
target_job_name: method_name.to_string(),
..Default::default()
};
let emsg = if authed {
EMsg::SERVICE_METHOD_CALL_FROM_CLIENT
} else {
EMsg::SERVICE_METHOD_CALL_FROM_CLIENT_NON_AUTHED
};
encode_proto_envelope(emsg, &header, request_body)
}
pub fn build_outbound_proto_message(
&self,
emsg: EMsg,
body: Vec<u8>,
routing_appid: u32,
) -> Option<OutboundProtoMessage> {
if self.state() != ClientState::LoggedOn {
return None;
}
let wire = self.build_proto_message(emsg, &body, routing_appid);
Some(OutboundProtoMessage {
emsg,
routing_appid,
body,
wire,
})
}
pub fn build_job_proto_message(
&self,
emsg: EMsg,
job_id: u64,
body: Vec<u8>,
routing_appid: u32,
) -> Option<OutboundProtoMessage> {
if self.state() != ClientState::LoggedOn {
return None;
}
let header = CMsgProtoBufHeader {
steamid: self.steam_id(),
client_sessionid: self.session_id(),
routing_appid,
jobid_source: job_id,
jobid_target: INVALID_JOB_ID,
..Default::default()
};
let wire = encode_proto_envelope(emsg, &header, &body);
Some(OutboundProtoMessage {
emsg,
routing_appid,
body,
wire,
})
}
pub fn build_authed_service_call(
&self,
method_name: &str,
job_id: u64,
request_body: Vec<u8>,
) -> Option<OutboundServiceCall> {
if self.state() != ClientState::LoggedOn {
return None;
}
let wire = self.build_service_method_call(method_name, true, job_id, &request_body);
Some(OutboundServiceCall {
method_name: method_name.to_string(),
authed: true,
job_id,
request_body,
wire,
})
}
pub fn build_get_depot_decryption_key(
&self,
depot_id: u32,
app_id: u32,
job_id: u64,
) -> Option<OutboundProtoMessage> {
if depot_id == 0 || app_id == 0 {
return None;
}
self.build_job_proto_message(
EMsg::CLIENT_GET_DEPOT_DECRYPTION_KEY,
job_id,
CMsgClientGetDepotDecryptionKey { depot_id, app_id }.serialize(),
0,
)
}
pub fn build_manifest_request_code_call(
&self,
app_id: u32,
depot_id: u32,
manifest_id: u64,
branch: &str,
job_id: u64,
) -> Option<OutboundServiceCall> {
if app_id == 0 || depot_id == 0 || manifest_id == 0 {
return None;
}
let lower = branch.to_ascii_lowercase();
let app_branch = if lower.is_empty() || lower == "public" {
String::new()
} else {
branch.to_string()
};
self.build_authed_service_call(
"ContentServerDirectory.GetManifestRequestCode#1",
job_id,
CContentServerDirectoryGetManifestRequestCodeRequest {
app_id,
depot_id,
manifest_id,
app_branch,
branch_password_hash: String::new(),
}
.serialize(),
)
}
pub fn build_get_cdn_servers_call(
&self,
cell_id: u32,
job_id: u64,
) -> Option<OutboundServiceCall> {
self.build_authed_service_call(
"ContentServerDirectory.GetServersForSteamPipe#1",
job_id,
CContentServerDirectoryGetServersForSteamPipeRequest {
cell_id,
..Default::default()
}
.serialize(),
)
}
pub fn build_pics_access_tokens(
&self,
packageids: Vec<u32>,
appids: Vec<u32>,
job_id: u64,
) -> Option<OutboundProtoMessage> {
self.build_job_proto_message(
EMsg::CLIENT_PICS_ACCESS_TOKEN_REQUEST,
job_id,
CMsgClientPICSAccessTokenRequest { packageids, appids }.serialize(),
0,
)
}
pub fn build_pics_product_info(
&self,
packages: Vec<PicsPackageInfoReq>,
apps: Vec<PicsAppInfoReq>,
meta_data_only: bool,
job_id: u64,
) -> Option<OutboundProtoMessage> {
self.build_job_proto_message(
EMsg::CLIENT_PICS_PRODUCT_INFO_REQUEST,
job_id,
CMsgClientPICSProductInfoRequest {
packages,
apps,
meta_data_only,
single_response: false,
..Default::default()
}
.serialize(),
0,
)
}
/// Succeeds only for apps Steam gives away; a paid unowned app comes back with a non-OK
/// EResult in the response body.
pub fn build_request_free_license(
&self,
app_ids: &[u32],
job_id: u64,
) -> Option<OutboundProtoMessage> {
if app_ids.is_empty() {
return None;
}
self.build_job_proto_message(
EMsg::CLIENT_REQUEST_FREE_LICENSE,
job_id,
CMsgClientRequestFreeLicense {
appids: app_ids.to_vec(),
}
.serialize(),
0,
)
}
pub fn route_inbound(
&self,
emsg: EMsg,
header: &CMsgProtoBufHeader,
body: &[u8],
) -> InboundAction {
match emsg {
EMsg::SERVICE_METHOD_RESPONSE
| EMsg::CLIENT_PICS_ACCESS_TOKEN_RESPONSE
| EMsg::CLIENT_GET_DEPOT_DECRYPTION_KEY_RESPONSE
// 5573 carries its own EResult in the body; the job only reports transport health.
| EMsg::CLIENT_REQUEST_FREE_LICENSE_RESPONSE => {
if header.jobid_target == INVALID_JOB_ID {
InboundAction::Ignored
} else {
let eresult = if header.eresult == -1 {
1
} else {
header.eresult
};
InboundAction::DeliverJob(JobResult {
eresult,
error_message: header.error_message.clone(),
body: body.to_vec(),
synthetic_failure: false,
})
}
}
EMsg::CLIENT_PICS_PRODUCT_INFO_RESPONSE => InboundAction::PicsProductInfo,
EMsg::MULTI => InboundAction::Multi,
EMsg::CLIENT_LOGON_RESPONSE => {
let Some(resp) = CMsgClientLogonResponse::deserialize(body) else {
return InboundAction::ParseFailed("ClientLogonResponse");
};
self.last_logon_eresult
.store(resp.eresult, Ordering::Relaxed);
if resp.eresult == 1 {
self.state
.store(ClientState::LoggedOn as u8, Ordering::Relaxed);
self.steam_id
.store(resp.client_supplied_steamid, Ordering::Relaxed);
self.session_id
.store(header.client_sessionid, Ordering::Relaxed);
self.cell_id.store(resp.cell_id, Ordering::Relaxed);
InboundAction::LogonOk
} else {
InboundAction::LoggedOff
}
}
EMsg::CLIENT_LOGGED_OFF | EMsg::CLIENT_SERVER_UNAVAILABLE => {
if self.state() == ClientState::LoggedOn {
self.state
.store(ClientState::Connected as u8, Ordering::Relaxed);
}
if emsg == EMsg::CLIENT_LOGGED_OFF {
let eresult = crate::steam::pb::cmsg_clientserver_login::CMsgClientLoggedOff::deserialize(body)
.map(|m| m.eresult)
.unwrap_or(2);
self.last_logon_eresult.store(eresult, Ordering::Relaxed);
}
self.steam_id.store(0, Ordering::Relaxed);
self.session_id.store(0, Ordering::Relaxed);
InboundAction::LoggedOff
}
EMsg::CLIENT_LICENSE_LIST => {
let Some(msg) = CMsgClientLicenseList::deserialize(body) else {
return InboundAction::ParseFailed("ClientLicenseList");
};
let count = msg.licenses.len();
*self.license_list.lock().expect("license list poisoned") = Some(msg.licenses);
InboundAction::LicenseList(count)
}
_ => InboundAction::ClientMessage,
}
}
}
pub fn parse_cmsg_multi(body: &[u8]) -> Option<CMsgMultiBody> {
let mut reader = crate::steam::proto_wire::Reader::new(body);
let mut multi = CMsgMultiBody::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(multi);
};
match tag.field_number {
1 => multi.size_unzipped = reader.u32()?,
2 => multi.message_body = reader.bytes()?.to_vec(),
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(multi)
}
pub fn decode_multi_records(body: &[u8]) -> Option<Vec<Vec<u8>>> {
let multi = parse_cmsg_multi(body)?;
let records = if multi.size_unzipped > 0 {
gunzip_or_zlib(&multi.message_body, multi.size_unzipped as usize)?
} else {
multi.message_body
};
let mut out = Vec::new();
let mut offset = 0usize;
while offset + 4 <= records.len() {
let inner_len = crate::steam::wire_format::read_u32_le(&records[offset..]) as usize;
offset += 4;
if inner_len == 0 || offset + inner_len > records.len() {
return None;
}
out.push(records[offset..offset + inner_len].to_vec());
offset += inner_len;
}
(offset == records.len()).then_some(out)
}
fn gunzip_or_zlib(compressed: &[u8], expected_size: usize) -> Option<Vec<u8>> {
let mut out = Vec::with_capacity(expected_size);
if GzDecoder::new(compressed).read_to_end(&mut out).is_ok() && !out.is_empty() {
return Some(out);
}
out.clear();
if ZlibDecoder::new(compressed).read_to_end(&mut out).is_ok() && !out.is_empty() {
return Some(out);
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::proto_envelope::decode_proto_envelope;
use crate::steam::proto_wire::{WireType, Writer};
use flate2::write::GzEncoder;
use flate2::Compression;
use std::io::Write;
#[test]
fn service_method_call_sets_authed_and_non_authed_emsgs() {
let core = CMClientCore::default();
core.steam_id.store(123, Ordering::Relaxed);
core.session_id.store(7, Ordering::Relaxed);
let authed = decode_proto_envelope(&core.build_service_method_call(
"ContentServerDirectory.GetServersForSteamPipe#1",
true,
55,
b"req",
))
.unwrap();
assert_eq!(authed.emsg, EMsg::SERVICE_METHOD_CALL_FROM_CLIENT);
assert_eq!(authed.header.steamid, 123);
assert_eq!(authed.header.client_sessionid, 7);
assert_eq!(authed.header.jobid_source, 55);
assert_eq!(authed.body, b"req");
let non = decode_proto_envelope(&core.build_service_method_call("X.Y#1", false, 56, b""))
.unwrap();
assert_eq!(non.emsg, EMsg::SERVICE_METHOD_CALL_FROM_CLIENT_NON_AUTHED);
}
#[test]
fn cmsg_multi_decodes_plain_and_gzip_records() {
let first = encode_proto_envelope(EMsg::CLIENT_HELLO, &CMsgProtoBufHeader::default(), b"a");
let second = encode_proto_envelope(
EMsg::CLIENT_LICENSE_LIST,
&CMsgProtoBufHeader::default(),
b"b",
);
let mut records = Vec::new();
records.extend_from_slice(&(first.len() as u32).to_le_bytes());
records.extend_from_slice(&first);
records.extend_from_slice(&(second.len() as u32).to_le_bytes());
records.extend_from_slice(&second);
let mut body = Vec::new();
Writer::new(&mut body).bytes_field(2, &records);
assert_eq!(
decode_multi_records(&body).unwrap(),
vec![first.clone(), second.clone()]
);
let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
encoder.write_all(&records).unwrap();
let zipped = encoder.finish().unwrap();
let mut zipped_body = Vec::new();
{
let mut writer = Writer::new(&mut zipped_body);
writer.uint32_field(1, records.len() as u32);
writer.bytes_field(2, &zipped);
}
assert_eq!(
decode_multi_records(&zipped_body).unwrap(),
vec![first, second]
);
}
#[test]
fn logon_needs_connected_state_and_carries_token_and_machine_id() {
let core = CMClientCore::default();
assert!(core
.build_logon_with_refresh_token("refresh", "ada", 0)
.is_none());
core.set_state(ClientState::Connected);
let logon = core
.build_logon_with_refresh_token("refresh", "ada", 123)
.unwrap();
assert_eq!(logon.emsg, EMsg::CLIENT_LOGON);
let decoded = decode_proto_envelope(&logon.wire).unwrap();
assert_eq!(decoded.header.steamid, 0x0110_0001_0000_0000);
assert!(decoded.body.windows(7).any(|w| w == b"refresh"));
assert!(decoded
.body
.windows(MACHINE_ID.len())
.any(|w| w == MACHINE_ID));
assert!(logon.body.is_empty());
assert!(core.build_logon_with_refresh_token("", "ada", 1).is_none());
assert!(core.build_logoff().is_none());
core.set_state(ClientState::LoggedOn);
assert_eq!(core.build_logoff().unwrap().emsg, EMsg::CLIENT_LOG_OFF);
}
#[test]
fn logon_response_updates_session_identity_and_eresult() {
let core = CMClientCore::default();
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.int32_field(1, 1);
w.tag(20, WireType::Fixed64);
w.raw_bytes(&765u64.to_le_bytes());
}
let header = CMsgProtoBufHeader {
client_sessionid: 42,
..Default::default()
};
assert_eq!(
core.route_inbound(EMsg::CLIENT_LOGON_RESPONSE, &header, &body),
InboundAction::LogonOk
);
assert_eq!(core.state(), ClientState::LoggedOn);
assert_eq!(core.steam_id(), 765);
assert_eq!(core.session_id(), 42);
assert_eq!(core.last_logon_eresult(), 1);
assert_eq!(
core.route_inbound(EMsg::CLIENT_LOGGED_OFF, &CMsgProtoBufHeader::default(), &[]),
InboundAction::LoggedOff
);
assert_eq!(core.state(), ClientState::Connected);
assert_eq!(core.steam_id(), 0);
let mut refused = Vec::new();
Writer::new(&mut refused).int32_field(1, 5);
let fresh = CMClientCore::default();
assert_eq!(
fresh.route_inbound(EMsg::CLIENT_LOGON_RESPONSE, &header, &refused),
InboundAction::LoggedOff
);
assert_eq!(fresh.last_logon_eresult(), 5);
assert_eq!(fresh.state(), ClientState::Disconnected);
}
#[test]
fn license_list_push_is_stored() {
let core = CMClientCore::default();
assert!(core.license_list().is_none());
assert_eq!(
core.route_inbound(
EMsg::CLIENT_LICENSE_LIST,
&CMsgProtoBufHeader::default(),
&[]
),
InboundAction::LicenseList(0)
);
assert_eq!(core.license_list(), Some(Vec::new()));
}
#[test]
fn downloader_builders_use_the_expected_messages() {
let core = logged_on_core();
let depot_key = core.build_get_depot_decryption_key(11, 22, 33).unwrap();
let decoded = decode_proto_envelope(&depot_key.wire).unwrap();
assert_eq!(decoded.emsg, EMsg::CLIENT_GET_DEPOT_DECRYPTION_KEY);
assert_eq!(decoded.header.jobid_source, 33);
let public = core
.build_manifest_request_code_call(480, 100, 555, "public", 44)
.unwrap();
assert_eq!(
public.method_name,
"ContentServerDirectory.GetManifestRequestCode#1"
);
assert!(!public.request_body.windows(6).any(|w| w == b"public"));
let beta = core
.build_manifest_request_code_call(480, 100, 555, "Beta", 45)
.unwrap();
assert!(beta.request_body.windows(4).any(|w| w == b"Beta"));
let servers = core.build_get_cdn_servers_call(7, 46).unwrap();
assert_eq!(
servers.method_name,
"ContentServerDirectory.GetServersForSteamPipe#1"
);
let product = core
.build_pics_product_info(
vec![PicsPackageInfoReq {
packageid: 100,
access_token: 7,
}],
vec![PicsAppInfoReq {
appid: 480,
access_token: 8,
only_public_obsolete: false,
}],
true,
3,
)
.unwrap();
assert_eq!(product.emsg, EMsg::CLIENT_PICS_PRODUCT_INFO_REQUEST);
assert!(product.body.windows(2).any(|w| w == [0x18, 1]));
let free = core.build_request_free_license(&[440], 50).unwrap();
assert_eq!(free.emsg, EMsg::CLIENT_REQUEST_FREE_LICENSE);
assert_eq!(free.body, [0x10, 0xb8, 0x03]);
assert!(core.build_request_free_license(&[], 51).is_none());
}
#[test]
fn job_responses_are_delivered_and_builders_need_logon() {
let core = logged_on_core();
let header = CMsgProtoBufHeader {
jobid_target: 50,
..Default::default()
};
assert!(matches!(
core.route_inbound(EMsg::CLIENT_REQUEST_FREE_LICENSE_RESPONSE, &header, &[]),
InboundAction::DeliverJob(_)
));
assert_eq!(
core.route_inbound(
EMsg::SERVICE_METHOD_RESPONSE,
&CMsgProtoBufHeader::default(),
&[]
),
InboundAction::Ignored
);
let offline = CMClientCore::default();
assert!(offline.build_get_depot_decryption_key(1, 2, 3).is_none());
assert!(offline.build_get_cdn_servers_call(0, 1).is_none());
}
fn logged_on_core() -> CMClientCore {
let core = CMClientCore::default();
core.state
.store(ClientState::LoggedOn as u8, Ordering::Relaxed);
core.steam_id.store(7656119, Ordering::Relaxed);
core.session_id.store(42, Ordering::Relaxed);
core
}
}
@@ -0,0 +1,569 @@
use crate::steam::cm_client::{decode_multi_records, CMClientCore, ClientState, InboundAction};
use crate::steam::cmsg_protobuf_header::{CMsgProtoBufHeader, INVALID_JOB_ID};
use crate::steam::emsg::{has_proto_flag, strip_proto_flag, EMsg};
use crate::steam::encrypted_channel::{ChannelDisconnectReason, ChannelState, EncryptedChannel};
use crate::steam::heartbeat::Heartbeat;
use crate::steam::job_manager::{JobManager, JobResult};
use crate::steam::pb::cmsg_client_pics::CMsgClientPICSProductInfoResponse;
use crate::steam::pb::cmsg_clientserver_login::CMsgClientLogonResponse;
use crate::steam::proto_envelope::decode_proto_envelope;
use crate::steam::transport::Transport;
use crate::steam::wire_format::read_u32_le;
use std::collections::HashMap;
use std::panic::{self, AssertUnwindSafe};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use zeroize::Zeroize;
type StateCallback = Box<dyn Fn(ClientState) + Send + Sync + 'static>;
type ClientMessageCallback = Box<dyn Fn(EMsg, &CMsgProtoBufHeader, &[u8]) + Send + Sync + 'static>;
pub struct CMClientRuntime {
core: Arc<CMClientCore>,
channel: EncryptedChannel,
jobs: JobManager,
heartbeat: Mutex<Heartbeat>,
pics_product_info: Mutex<HashMap<u64, CMsgClientPICSProductInfoResponse>>,
on_state: Mutex<Option<StateCallback>>,
on_client_message: Mutex<Option<ClientMessageCallback>>,
}
impl CMClientRuntime {
pub fn new(core: Arc<CMClientCore>, transport: Box<dyn Transport>) -> Arc<Self> {
let runtime = Arc::new(Self {
core,
channel: EncryptedChannel::new(transport),
jobs: JobManager::default(),
heartbeat: Mutex::new(Heartbeat::default()),
pics_product_info: Mutex::new(HashMap::new()),
on_state: Mutex::new(None),
on_client_message: Mutex::new(None),
});
let weak = Arc::downgrade(&runtime);
runtime.channel.set_on_connected(move || {
if let Some(runtime) = weak.upgrade() {
runtime.on_channel_connected();
}
});
let weak = Arc::downgrade(&runtime);
runtime.channel.set_on_disconnected(move |reason, detail| {
if let Some(runtime) = weak.upgrade() {
runtime.on_channel_disconnected(reason, detail);
}
});
let weak = Arc::downgrade(&runtime);
runtime.channel.set_on_message(move |bytes| {
if let Some(runtime) = weak.upgrade() {
runtime.handle_channel_message(bytes);
}
});
runtime
}
pub fn core(&self) -> &Arc<CMClientCore> {
&self.core
}
pub fn connect(&self, url: &str) -> bool {
self.core.set_state(ClientState::Connecting);
self.notify_state(ClientState::Connecting);
if self.channel.connect(url) {
true
} else {
self.core.set_state(ClientState::Disconnected);
self.notify_state(ClientState::Disconnected);
false
}
}
pub fn disconnect(&self) {
self.heartbeat.lock().expect("heartbeat poisoned").stop();
self.channel.disconnect();
self.jobs.fail_all("CMClient disconnected");
self.core.reset_session_identity();
self.core.set_state(ClientState::Disconnected);
self.notify_state(ClientState::Disconnected);
}
pub fn set_ca_bundle_path(&self, path: &str) {
self.channel.set_ca_bundle_path(path);
}
pub fn set_on_state<F>(&self, callback: F)
where
F: Fn(ClientState) + Send + Sync + 'static,
{
*self.on_state.lock().expect("runtime callback poisoned") = Some(Box::new(callback));
}
pub fn set_on_client_message<F>(&self, callback: F)
where
F: Fn(EMsg, &CMsgProtoBufHeader, &[u8]) + Send + Sync + 'static,
{
*self
.on_client_message
.lock()
.expect("runtime callback poisoned") = Some(Box::new(callback));
}
pub fn next_job_id(&self) -> u64 {
self.jobs.next_job_id()
}
pub fn track_job<F>(&self, job_id: u64, callback: F, timeout: Option<Duration>)
where
F: FnOnce(JobResult) + Send + 'static,
{
self.jobs.track(job_id, callback, timeout);
}
pub fn flush_outbound(&self) -> usize {
if self.channel.state() != ChannelState::Encrypted {
return 0;
}
let mut wires = self.core.take_outbound_wires();
let mut sent = 0usize;
for idx in 0..wires.len() {
if self.channel.send(&wires[idx]) {
// Outbound wires can hold the logon token; clear each one once it is sent.
wires[idx].zeroize();
sent += 1;
continue;
}
self.core.restore_outbound_wires_front(wires.split_off(idx));
break;
}
sent
}
pub fn handle_channel_message(self: &Arc<Self>, bytes: &[u8]) -> InboundAction {
let Some(envelope) = decode_proto_envelope(bytes) else {
return self.handle_non_proto_message(bytes);
};
self.process_envelope(envelope.emsg, &envelope.header, &envelope.body)
}
fn process_envelope(
self: &Arc<Self>,
emsg: EMsg,
header: &CMsgProtoBufHeader,
body: &[u8],
) -> InboundAction {
let action = self.core.route_inbound(emsg, header, body);
match &action {
InboundAction::Multi => {
if let Some(records) = decode_multi_records(body) {
for record in records {
self.handle_channel_message(&record);
}
}
}
InboundAction::DeliverJob(result) => {
self.jobs.deliver(
header.jobid_target,
result.eresult,
result.error_message.clone(),
&result.body,
);
}
InboundAction::LogonOk => {
// No persona or friends traffic: this session exists only to download.
self.start_heartbeat_from_logon(body);
self.notify_state(ClientState::LoggedOn);
self.notify_client_message(emsg, header, body);
}
InboundAction::LoggedOff => {
self.heartbeat.lock().expect("heartbeat poisoned").stop();
self.notify_state(self.core.state());
self.notify_client_message(emsg, header, body);
}
InboundAction::Ignored | InboundAction::ParseFailed(_) => {}
InboundAction::PicsProductInfo => self.handle_pics_product_info(header, body),
InboundAction::LicenseList(_) | InboundAction::ClientMessage => {
self.notify_client_message(emsg, header, body);
}
}
action
}
fn on_channel_connected(self: &Arc<Self>) {
self.core.set_state(ClientState::Connected);
self.notify_state(ClientState::Connected);
// Always send ClientHello first; pre-existing queued wires (e.g. a
// logon enqueued before the channel finished negotiating) must come
// after the Hello or Steam rejects the conversation as malformed.
// If a Hello was already prequeued, do not duplicate it.
let queued = self.core.take_outbound_wires();
let head_is_hello = queued
.first()
.and_then(|wire| decode_proto_envelope(wire))
.is_some_and(|env| env.emsg == EMsg::CLIENT_HELLO);
let combined = if head_is_hello {
queued
} else {
let hello = self.core.build_client_hello().wire;
let mut combined = Vec::with_capacity(queued.len() + 1);
combined.push(hello);
combined.extend(queued);
combined
};
self.core.restore_outbound_wires_front(combined);
self.flush_outbound();
}
fn on_channel_disconnected(self: &Arc<Self>, _reason: ChannelDisconnectReason, detail: &str) {
self.heartbeat.lock().expect("heartbeat poisoned").stop();
self.jobs
.fail_all(&format!("channel disconnected: {detail}"));
self.pics_product_info
.lock()
.expect("pics product info poisoned")
.clear();
self.core.reset_session_identity();
self.core.set_state(ClientState::Disconnected);
self.notify_state(ClientState::Disconnected);
}
fn handle_pics_product_info(&self, header: &CMsgProtoBufHeader, body: &[u8]) {
if header.jobid_target == INVALID_JOB_ID {
return;
}
let Some(response) = CMsgClientPICSProductInfoResponse::deserialize(body) else {
self.jobs.deliver(
header.jobid_target,
-1,
"PICS product-info parse failed".to_string(),
&[],
);
return;
};
let mut pending = self
.pics_product_info
.lock()
.expect("pics product info poisoned");
if response.response_pending {
let acc = pending.entry(header.jobid_target).or_default();
merge_pics_product_info(acc, response);
return;
}
let mut merged = pending.remove(&header.jobid_target).unwrap_or_default();
merge_pics_product_info(&mut merged, response);
let body = merged.serialize();
self.jobs
.deliver(header.jobid_target, 1, String::new(), &body);
}
fn start_heartbeat_from_logon(self: &Arc<Self>, body: &[u8]) {
let Some(resp) = CMsgClientLogonResponse::deserialize(body) else {
return;
};
if resp.heartbeat_seconds <= 0 {
return;
}
let weak = Arc::downgrade(self);
let interval = Duration::from_secs(resp.heartbeat_seconds as u64);
self.heartbeat
.lock()
.expect("heartbeat poisoned")
.start(interval, move || {
if let Some(runtime) = weak.upgrade() {
runtime
.core
.enqueue_wire(runtime.core.build_heartbeat().wire);
runtime.flush_outbound();
}
});
}
fn handle_non_proto_message(&self, bytes: &[u8]) -> InboundAction {
if bytes.len() >= 4 {
let raw = read_u32_le(bytes);
if !has_proto_flag(raw) {
let legacy = strip_proto_flag(raw);
if legacy == EMsg::CHANNEL_ENCRYPT_REQUEST
|| legacy == EMsg::CHANNEL_ENCRYPT_RESPONSE
|| legacy == EMsg::CHANNEL_ENCRYPT_RESULT
{
return InboundAction::Ignored;
}
}
}
InboundAction::ParseFailed("ProtoEnvelope")
}
fn notify_state(&self, state: ClientState) {
if let Some(callback) = self
.on_state
.lock()
.expect("runtime callback poisoned")
.as_ref()
{
let _ = panic::catch_unwind(AssertUnwindSafe(|| callback(state)));
}
}
fn notify_client_message(&self, emsg: EMsg, header: &CMsgProtoBufHeader, body: &[u8]) {
if let Some(callback) = self
.on_client_message
.lock()
.expect("runtime callback poisoned")
.as_ref()
{
let _ = panic::catch_unwind(AssertUnwindSafe(|| callback(emsg, header, body)));
}
}
}
fn merge_pics_product_info(
acc: &mut CMsgClientPICSProductInfoResponse,
mut next: CMsgClientPICSProductInfoResponse,
) {
acc.apps.append(&mut next.apps);
acc.packages.append(&mut next.packages);
acc.unknown_appids.append(&mut next.unknown_appids);
acc.unknown_packageids.append(&mut next.unknown_packageids);
if next.http_min_size > 0 {
acc.http_min_size = next.http_min_size;
}
if !next.http_host.is_empty() {
acc.http_host = next.http_host;
}
acc.meta_data_only = next.meta_data_only;
acc.response_pending = false;
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::proto_envelope::encode_proto_envelope;
use crate::steam::proto_wire::Writer as ProtoWriter;
use crate::steam::transport::{ConnectedCallback, DisconnectedCallback, MessageCallback};
use crate::steam::transport::{TransportDisconnectReason, TransportState};
use crate::steam::wire_format::Writer as WireWriter;
use std::sync::mpsc;
#[test]
fn connected_channel_sends_client_hello_and_reports_state() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(Arc::clone(&shared));
let states = Arc::new(Mutex::new(Vec::new()));
let states_cb = Arc::clone(&states);
runtime.set_on_state(move |state| states_cb.lock().unwrap().push(state));
assert!(runtime.connect("wss://cm.example.com:443/cmsocket/"));
shared.fire_connected();
assert_eq!(
states.lock().unwrap().as_slice(),
&[ClientState::Connecting, ClientState::Connected]
);
let sent = shared.take_sent();
assert_eq!(
decode_proto_envelope(&sent[0]).unwrap().emsg,
EMsg::CLIENT_HELLO
);
}
#[test]
fn connected_channel_flushes_prequeued_hello_without_duplicate() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(Arc::clone(&shared));
runtime
.core
.enqueue_wire(runtime.core.build_client_hello().wire);
assert!(runtime.connect("wss://cm.example.com:443/cmsocket/"));
shared.fire_connected();
let sent = shared.take_sent();
assert_eq!(sent.len(), 1);
assert_eq!(
decode_proto_envelope(&sent[0]).unwrap().emsg,
EMsg::CLIENT_HELLO
);
}
#[test]
fn flush_outbound_preserves_core_queue_order() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(Arc::clone(&shared));
assert!(runtime.connect("wss://cm.example.com:443/cmsocket/"));
shared.fire_connected();
shared.take_sent();
runtime.core.enqueue_wire(vec![1, 2, 3]);
runtime.core.enqueue_wire(vec![4, 5, 6]);
assert_eq!(runtime.flush_outbound(), 2);
assert_eq!(shared.take_sent(), vec![vec![1, 2, 3], vec![4, 5, 6]]);
}
#[test]
fn inbound_job_response_is_delivered() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(shared);
let job_id = runtime.next_job_id();
let (tx, rx) = mpsc::channel();
runtime.track_job(job_id, move |result| tx.send(result).unwrap(), None);
let header = CMsgProtoBufHeader {
jobid_target: job_id,
eresult: 1,
..Default::default()
};
let wire = encode_proto_envelope(EMsg::SERVICE_METHOD_RESPONSE, &header, b"reply");
assert_eq!(
runtime.handle_channel_message(&wire),
InboundAction::DeliverJob(JobResult {
eresult: 1,
error_message: String::new(),
body: b"reply".to_vec(),
synthetic_failure: false,
})
);
assert_eq!(rx.recv().unwrap().body, b"reply");
}
#[test]
fn multi_records_are_redispatched() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(shared);
let (tx, rx) = mpsc::channel();
runtime.set_on_client_message(move |emsg, _, body| {
tx.send((emsg, body.to_vec())).unwrap();
});
let inner = encode_proto_envelope(
EMsg::CLIENT_SESSION_TOKEN,
&CMsgProtoBufHeader::default(),
&account_info_body("Ada"),
);
let mut records = Vec::new();
WireWriter::new(&mut records).u32(inner.len() as u32);
records.extend_from_slice(&inner);
let mut multi_body = Vec::new();
ProtoWriter::new(&mut multi_body).bytes_field(2, &records);
let multi = encode_proto_envelope(EMsg::MULTI, &CMsgProtoBufHeader::default(), &multi_body);
assert_eq!(runtime.handle_channel_message(&multi), InboundAction::Multi);
assert_eq!(
rx.recv().unwrap(),
(EMsg::CLIENT_SESSION_TOKEN, account_info_body("Ada"))
);
}
#[test]
fn legacy_channel_encrypt_frames_are_ignored() {
let shared = Arc::new(MockTransportState::default());
let runtime = runtime_with_shared_transport(shared);
let mut legacy = Vec::new();
WireWriter::new(&mut legacy).u32(EMsg::CHANNEL_ENCRYPT_REQUEST.0);
assert_eq!(
runtime.handle_channel_message(&legacy),
InboundAction::Ignored
);
}
fn runtime_with_shared_transport(shared: Arc<MockTransportState>) -> Arc<CMClientRuntime> {
CMClientRuntime::new(
Arc::new(CMClientCore::default()),
Box::new(MockTransport { shared }),
)
}
fn account_info_body(name: &str) -> Vec<u8> {
let mut body = Vec::new();
ProtoWriter::new(&mut body).string_field(1, name);
body
}
struct MockTransportState {
state: Mutex<TransportState>,
connected: Mutex<Option<ConnectedCallback>>,
disconnected: Mutex<Option<DisconnectedCallback>>,
message: Mutex<Option<MessageCallback>>,
sent: Mutex<Vec<Vec<u8>>>,
}
impl Default for MockTransportState {
fn default() -> Self {
Self {
state: Mutex::new(TransportState::Disconnected),
connected: Mutex::new(None),
disconnected: Mutex::new(None),
message: Mutex::new(None),
sent: Mutex::new(Vec::new()),
}
}
}
impl MockTransportState {
fn fire_connected(&self) {
*self.state.lock().unwrap() = TransportState::Connected;
if let Some(callback) = self.connected.lock().unwrap().as_ref() {
callback();
}
}
#[allow(dead_code)]
fn fire_disconnected(&self, reason: TransportDisconnectReason, detail: &str) {
*self.state.lock().unwrap() = TransportState::Disconnected;
if let Some(callback) = self.disconnected.lock().unwrap().as_ref() {
callback(reason, detail);
}
}
#[allow(dead_code)]
fn fire_message(&self, bytes: &[u8]) {
if let Some(callback) = self.message.lock().unwrap().as_ref() {
callback(bytes);
}
}
fn take_sent(&self) -> Vec<Vec<u8>> {
std::mem::take(&mut *self.sent.lock().unwrap())
}
}
struct MockTransport {
shared: Arc<MockTransportState>,
}
impl Transport for MockTransport {
fn connect(&mut self, _url: &str) -> bool {
*self.shared.state.lock().unwrap() = TransportState::Connecting;
true
}
fn send(&mut self, data: &[u8]) -> bool {
if self.state() != TransportState::Connected {
return false;
}
self.shared.sent.lock().unwrap().push(data.to_vec());
true
}
fn disconnect(&mut self) {
*self.shared.state.lock().unwrap() = TransportState::Disconnected;
}
fn state(&self) -> TransportState {
*self.shared.state.lock().unwrap()
}
fn set_on_message(&mut self, cb: MessageCallback) {
*self.shared.message.lock().unwrap() = Some(cb);
}
fn set_on_connected(&mut self, cb: ConnectedCallback) {
*self.shared.connected.lock().unwrap() = Some(cb);
}
fn set_on_disconnected(&mut self, cb: DisconnectedCallback) {
*self.shared.disconnected.lock().unwrap() = Some(cb);
}
}
}
@@ -0,0 +1,81 @@
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
#[repr(u8)]
pub enum CmTransport {
#[default]
Unknown = 0,
WebSocket = 1,
Tcp = 2,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CmServer {
pub endpoint: String,
pub host: String,
pub port: u16,
pub transport: CmTransport,
pub realm: String,
pub datacenter: String,
pub load: i32,
pub weighted_load: f32,
}
impl CmServer {
pub fn websocket_url(&self) -> String {
if self.transport != CmTransport::WebSocket || self.host.is_empty() || self.port == 0 {
return String::new();
}
format!("wss://{}:{}/cmsocket/", self.host, self.port)
}
}
pub fn parse_endpoint(endpoint: &str) -> Option<(String, u16)> {
let colon = endpoint.rfind(':')?;
if colon == 0 || colon + 1 == endpoint.len() {
return None;
}
let mut host = &endpoint[..colon];
if host.len() >= 2 && host.starts_with('[') && host.ends_with(']') {
host = &host[1..host.len() - 1];
}
let port_text = &endpoint[colon + 1..];
if !port_text.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
let port = port_text.parse::<u32>().ok()?;
if port == 0 || port > u16::MAX as u32 {
return None;
}
Some((host.to_string(), port as u16))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_host_port_and_ipv6_brackets() {
assert_eq!(
parse_endpoint("cm.example.com:443"),
Some(("cm.example.com".to_string(), 443))
);
assert_eq!(
parse_endpoint("[2001:db8::1]:27017"),
Some(("2001:db8::1".to_string(), 27017))
);
assert_eq!(parse_endpoint("missing-port"), None);
assert_eq!(parse_endpoint("host:0"), None);
assert_eq!(parse_endpoint("host:+443"), None);
assert_eq!(parse_endpoint("host:70000"), None);
}
#[test]
fn websocket_url_requires_websocket_transport() {
let server = CmServer {
host: "cm.example.com".to_string(),
port: 443,
transport: CmTransport::WebSocket,
..Default::default()
};
assert_eq!(server.websocket_url(), "wss://cm.example.com:443/cmsocket/");
}
}
@@ -0,0 +1,205 @@
use crate::steam::cm_server::{CmServer, CmTransport};
use std::sync::Mutex;
use std::time::{Duration, Instant};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ServerQuality {
Good,
Bad,
}
pub const DEFAULT_BAD_MEMORY: Duration = Duration::from_secs(5 * 60);
pub struct CmServerList {
inner: Mutex<Inner>,
bad_memory: Duration,
}
#[derive(Default)]
struct Inner {
entries: Vec<Entry>,
next_index: usize,
}
struct Entry {
server: CmServer,
quality: ServerQuality,
marked_bad_at: Option<Instant>,
}
impl Default for CmServerList {
fn default() -> Self {
Self::new(DEFAULT_BAD_MEMORY)
}
}
impl CmServerList {
pub fn new(bad_memory: Duration) -> Self {
Self {
inner: Mutex::new(Inner::default()),
bad_memory,
}
}
pub fn replace_all(&self, servers: &[CmServer]) {
let mut inner = self.inner.lock().unwrap();
inner.entries = servers
.iter()
.cloned()
.map(|server| Entry {
server,
quality: ServerQuality::Good,
marked_bad_at: None,
})
.collect();
inner.next_index = 0;
}
pub fn add(&self, server: CmServer) {
self.inner.lock().unwrap().entries.push(Entry {
server,
quality: ServerQuality::Good,
marked_bad_at: None,
});
}
pub fn size(&self) -> usize {
self.inner.lock().unwrap().entries.len()
}
pub fn next_good(&self) -> Option<CmServer> {
let mut inner = self.inner.lock().unwrap();
if inner.entries.is_empty() {
return None;
}
promote_expired(&mut inner.entries, self.bad_memory);
let n = inner.entries.len();
for i in 0..n {
let idx = (inner.next_index + i) % n;
if inner.entries[idx].quality == ServerQuality::Good {
inner.next_index = (idx + 1) % n;
return Some(inner.entries[idx].server.clone());
}
}
None
}
pub fn mark_bad(&self, endpoint: &str) {
let mut inner = self.inner.lock().unwrap();
if let Some(entry) = inner
.entries
.iter_mut()
.find(|e| e.server.endpoint == endpoint)
{
entry.quality = ServerQuality::Bad;
entry.marked_bad_at = Some(Instant::now());
}
}
pub fn mark_good(&self, endpoint: &str) {
let mut inner = self.inner.lock().unwrap();
if let Some(entry) = inner
.entries
.iter_mut()
.find(|e| e.server.endpoint == endpoint)
{
entry.quality = ServerQuality::Good;
entry.marked_bad_at = None;
}
}
pub fn reset_quality(&self) {
let mut inner = self.inner.lock().unwrap();
for entry in &mut inner.entries {
entry.quality = ServerQuality::Good;
entry.marked_bad_at = None;
}
}
}
fn promote_expired(entries: &mut [Entry], bad_memory: Duration) {
let now = Instant::now();
for entry in entries {
if entry.quality == ServerQuality::Bad
&& entry
.marked_bad_at
.is_some_and(|t| now.duration_since(t) >= bad_memory)
{
entry.quality = ServerQuality::Good;
entry.marked_bad_at = None;
}
}
}
pub fn hardcoded_fallback_servers() -> Vec<CmServer> {
const FALLBACK: &[(&str, &str)] = &[
("ext1-sea1.steamserver.net", "sea1"),
("ext2-sea1.steamserver.net", "sea1"),
("ext1-iad1.steamserver.net", "iad1"),
("ext2-iad1.steamserver.net", "iad1"),
("ext1-fra1.steamserver.net", "fra1"),
("ext2-fra1.steamserver.net", "fra1"),
("ext1-lax1.steamserver.net", "lax1"),
("ext1-sgp1.steamserver.net", "sgp1"),
];
FALLBACK
.iter()
.map(|(host, dc)| CmServer {
endpoint: format!("{host}:443"),
host: (*host).to_string(),
port: 443,
transport: CmTransport::WebSocket,
realm: "steamglobal".to_string(),
datacenter: (*dc).to_string(),
load: 0,
weighted_load: 0.0,
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn next_good_round_robins_and_skips_bad() {
let list = CmServerList::default();
let a = server("a:443");
let b = server("b:443");
list.replace_all(&[a.clone(), b.clone()]);
assert_eq!(list.next_good().unwrap().endpoint, a.endpoint);
list.mark_bad(&b.endpoint);
assert_eq!(list.next_good().unwrap().endpoint, a.endpoint);
list.mark_good(&b.endpoint);
assert_eq!(list.next_good().unwrap().endpoint, b.endpoint);
}
#[test]
fn bad_servers_promote_after_memory_interval() {
let list = CmServerList::new(Duration::ZERO);
let a = server("a:443");
list.replace_all(std::slice::from_ref(&a));
list.mark_bad(&a.endpoint);
assert_eq!(list.next_good().unwrap().endpoint, a.endpoint);
}
#[test]
fn fallback_servers_are_websocket_urls() {
let servers = hardcoded_fallback_servers();
assert!(!servers.is_empty());
assert!(servers
.iter()
.all(|s| s.websocket_url().starts_with("wss://")));
}
fn server(endpoint: &str) -> CmServer {
let (host, port) = crate::steam::cm_server::parse_endpoint(endpoint).unwrap();
CmServer {
endpoint: endpoint.to_string(),
host,
port,
transport: CmTransport::WebSocket,
..Default::default()
}
}
}
@@ -0,0 +1,151 @@
use crate::steam::proto_wire::{Reader, WireType, Writer};
pub const INVALID_JOB_ID: u64 = u64::MAX;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgProtoBufHeader {
pub steamid: u64,
pub client_sessionid: i32,
pub routing_appid: u32,
pub jobid_source: u64,
pub jobid_target: u64,
pub target_job_name: String,
pub eresult: i32,
pub error_message: String,
pub realm: u32,
pub messageid: u64,
pub token_id: u64,
}
impl Default for CMsgProtoBufHeader {
fn default() -> Self {
Self {
steamid: 0,
client_sessionid: 0,
routing_appid: 0,
jobid_source: INVALID_JOB_ID,
jobid_target: INVALID_JOB_ID,
target_job_name: String::new(),
eresult: -1,
error_message: String::new(),
realm: 0,
messageid: 0,
token_id: 0,
}
}
}
impl CMsgProtoBufHeader {
pub fn serialize(&self, out: &mut Vec<u8>) {
let mut writer = Writer::new(out);
if self.steamid != 0 {
writer.tag(1, WireType::Fixed64);
writer.fixed64_field_force_body(self.steamid);
}
writer.int32_field(2, self.client_sessionid);
writer.uint32_field(3, self.routing_appid);
if self.jobid_source != INVALID_JOB_ID {
writer.tag(10, WireType::Fixed64);
writer.fixed64_field_force_body(self.jobid_source);
}
if self.jobid_target != INVALID_JOB_ID {
writer.tag(11, WireType::Fixed64);
writer.fixed64_field_force_body(self.jobid_target);
}
writer.string_field(12, &self.target_job_name);
if self.eresult >= 0 {
writer.tag(14, WireType::Varint);
writer.varint(self.eresult as i64 as u64);
}
writer.string_field(15, &self.error_message);
writer.uint32_field(29, self.realm);
writer.uint64_field(21, self.messageid);
writer.uint64_field(34, self.token_id);
}
pub fn deserialize(bytes: &[u8]) -> Option<Self> {
let mut reader = Reader::new(bytes);
let mut header = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(header);
};
match tag.field_number {
1 => {
if tag.wire_type != WireType::Fixed64 {
return None;
}
header.steamid = reader.fixed64()?;
}
2 => header.client_sessionid = reader.i32()?,
3 => header.routing_appid = reader.u32()?,
10 => {
if tag.wire_type != WireType::Fixed64 {
return None;
}
header.jobid_source = reader.fixed64()?;
}
11 => {
if tag.wire_type != WireType::Fixed64 {
return None;
}
header.jobid_target = reader.fixed64()?;
}
12 => header.target_job_name = reader.string()?,
14 => header.eresult = reader.i32()?,
15 => header.error_message = reader.string()?,
21 => header.messageid = reader.u64()?,
29 => header.realm = reader.u32()?,
34 => header.token_id = reader.u64()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(header)
}
}
trait WriterFixedBodies {
fn fixed64_field_force_body(&mut self, v: u64);
}
impl WriterFixedBodies for Writer<'_> {
fn fixed64_field_force_body(&mut self, v: u64) {
self.raw_bytes(&v.to_le_bytes());
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serializes_only_set_job_ids() {
let h = CMsgProtoBufHeader {
steamid: 0x1122_3344_5566_7788,
client_sessionid: 17,
routing_appid: 480,
target_job_name: "Authentication.BeginAuthSessionViaCredentials#1".to_string(),
..Default::default()
};
let mut bytes = Vec::new();
h.serialize(&mut bytes);
let parsed = CMsgProtoBufHeader::deserialize(&bytes).unwrap();
assert_eq!(parsed, h);
assert!(!bytes
.windows(2)
.any(|w| w == [0x51, 0xff] || w == [0x59, 0xff]));
}
#[test]
fn rejects_wrong_fixed_wire_type() {
let bytes = [0x08, 0x01];
assert_eq!(CMsgProtoBufHeader::deserialize(&bytes), None);
}
}
@@ -0,0 +1,353 @@
use crate::steam::base64;
use crate::steam::crypto::{
aes256_cbc_decrypt, aes256_ecb_decrypt_block, AesBlock, SessionKey, AES_BLOCK_BYTES,
SESSION_KEY_LENGTH,
};
use crate::steam::proto_wire::{Reader, WireType};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ChunkData {
pub sha: Vec<u8>,
pub crc: u32,
pub offset: u64,
pub cb_original: u32,
pub cb_compressed: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct FileMapping {
pub filename: String,
pub size: u64,
pub flags: u32,
pub sha_filename: Vec<u8>,
pub sha_content: Vec<u8>,
pub chunks: Vec<ChunkData>,
pub linktarget: String,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct Metadata {
pub depot_id: u32,
pub gid_manifest: u64,
pub creation_time: u32,
pub filenames_encrypted: bool,
pub cb_disk_original: u64,
pub cb_disk_compressed: u64,
pub unique_chunks: u32,
pub crc_encrypted: u32,
pub crc_clear: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct ContentManifest {
pub metadata: Metadata,
pub files: Vec<FileMapping>,
pub signature: Vec<u8>,
}
pub const PAYLOAD_MAGIC: u32 = 0x71f6_17d0;
pub const METADATA_MAGIC: u32 = 0x1f48_12be;
pub const SIGNATURE_MAGIC: u32 = 0x1b81_b817;
pub const END_OF_MANIFEST_MAGIC: u32 = 0x32c4_15ab;
impl ContentManifest {
pub fn parse(raw: &[u8]) -> Option<Self> {
let mut manifest = Self::default();
let mut have_payload = false;
let mut have_metadata = false;
let mut pos = 0usize;
loop {
let magic = read_u32_le(raw, &mut pos)?;
if magic == END_OF_MANIFEST_MAGIC {
break;
}
let len = read_u32_le(raw, &mut pos)? as usize;
if pos + len > raw.len() {
return None;
}
let section = &raw[pos..pos + len];
pos += len;
match magic {
PAYLOAD_MAGIC => {
parse_payload(section, &mut manifest.files)?;
have_payload = true;
}
METADATA_MAGIC => {
manifest.metadata = parse_metadata(section)?;
have_metadata = true;
}
SIGNATURE_MAGIC => {
manifest.signature = parse_signature(section)?;
}
_ => return None,
}
}
(have_payload && have_metadata).then_some(manifest)
}
pub fn decrypt_filenames(&mut self, depot_key: &[u8]) -> bool {
if self.metadata.filenames_encrypted {
if depot_key.len() != SESSION_KEY_LENGTH {
return false;
}
let mut key = [0u8; SESSION_KEY_LENGTH];
key.copy_from_slice(depot_key);
for file in &mut self.files {
let Some(clear) = decrypt_name(&key, &file.filename) else {
return false;
};
file.filename = clear;
if !file.linktarget.is_empty() {
let Some(clear) = decrypt_name(&key, &file.linktarget) else {
return false;
};
file.linktarget = clear;
}
}
self.metadata.filenames_encrypted = false;
}
for file in &mut self.files {
file.filename = file.filename.replace('\\', "/");
file.linktarget = file.linktarget.replace('\\', "/");
}
self.files.sort_by(|a, b| {
a.filename
.bytes()
.map(|c| c.to_ascii_lowercase())
.cmp(b.filename.bytes().map(|c| c.to_ascii_lowercase()))
});
true
}
}
fn decrypt_name(key: &SessionKey, enc: &str) -> Option<String> {
let blob = base64::decode(enc)?;
if blob.len() < AES_BLOCK_BYTES * 2 {
return None;
}
let mut wrapped = [0u8; AES_BLOCK_BYTES];
wrapped.copy_from_slice(&blob[..AES_BLOCK_BYTES]);
let iv: AesBlock = aes256_ecb_decrypt_block(key, &wrapped)?;
let plain = aes256_cbc_decrypt(key, &iv, &blob[AES_BLOCK_BYTES..])?;
let mut out = String::from_utf8_lossy(&plain).into_owned();
if out.ends_with('\0') {
out.pop();
}
Some(out)
}
fn read_u32_le(buf: &[u8], pos: &mut usize) -> Option<u32> {
if *pos + 4 > buf.len() {
return None;
}
let v = u32::from_le_bytes(buf[*pos..*pos + 4].try_into().ok()?);
*pos += 4;
Some(v)
}
fn parse_chunk(body: &[u8]) -> Option<ChunkData> {
let mut reader = Reader::new(body);
let mut chunk = ChunkData::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(chunk);
};
match tag.field_number {
1 => chunk.sha = reader.bytes()?.to_vec(),
2 => {
if tag.wire_type != WireType::Fixed32 {
return None;
}
chunk.crc = reader.fixed32()?;
}
3 => chunk.offset = reader.u64()?,
4 => chunk.cb_original = reader.u32()?,
5 => chunk.cb_compressed = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(chunk)
}
fn parse_file_mapping(body: &[u8]) -> Option<FileMapping> {
let mut reader = Reader::new(body);
let mut file = FileMapping::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(file);
};
match tag.field_number {
1 => file.filename = reader.string()?,
2 => file.size = reader.u64()?,
3 => file.flags = reader.u32()?,
4 => file.sha_filename = reader.bytes()?.to_vec(),
5 => file.sha_content = reader.bytes()?.to_vec(),
6 => file.chunks.push(parse_chunk(reader.bytes()?)?),
7 => file.linktarget = reader.string()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(file)
}
fn parse_payload(body: &[u8], out: &mut Vec<FileMapping>) -> Option<()> {
let mut reader = Reader::new(body);
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(());
};
if tag.field_number == 1 {
out.push(parse_file_mapping(reader.bytes()?)?);
} else if !reader.skip(tag.wire_type) {
return None;
}
}
Some(())
}
fn parse_metadata(body: &[u8]) -> Option<Metadata> {
let mut reader = Reader::new(body);
let mut metadata = Metadata::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(metadata);
};
match tag.field_number {
1 => metadata.depot_id = reader.u32()?,
2 => metadata.gid_manifest = reader.u64()?,
3 => metadata.creation_time = reader.u32()?,
4 => metadata.filenames_encrypted = reader.boolean()?,
5 => metadata.cb_disk_original = reader.u64()?,
6 => metadata.cb_disk_compressed = reader.u64()?,
7 => metadata.unique_chunks = reader.u32()?,
8 => metadata.crc_encrypted = reader.u32()?,
9 => metadata.crc_clear = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(metadata)
}
fn parse_signature(body: &[u8]) -> Option<Vec<u8>> {
let mut reader = Reader::new(body);
let mut signature = Vec::new();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(signature);
};
if tag.field_number == 1 {
signature = reader.bytes()?.to_vec();
} else if !reader.skip(tag.wire_type) {
return None;
}
}
Some(signature)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::crypto::{aes256_cbc_encrypt, aes256_ecb_encrypt_block};
use crate::steam::proto_wire::Writer;
#[test]
fn parses_manifest_sections() {
let mut chunk_body = Vec::new();
{
let mut w = Writer::new(&mut chunk_body);
w.bytes_field(1, &[1; 20]);
w.tag(2, WireType::Fixed32);
w.raw_bytes(&0x1234_5678u32.to_le_bytes());
w.uint64_field(3, 99);
w.uint32_field(4, 11);
w.uint32_field(5, 22);
}
let mut file_body = Vec::new();
{
let mut w = Writer::new(&mut file_body);
w.string_field(1, "bin\\game.exe");
w.uint64_field(2, 11);
w.uint32_field(3, 1);
w.submessage_field(6, &chunk_body);
}
let mut payload = Vec::new();
Writer::new(&mut payload).submessage_field(1, &file_body);
let mut metadata = Vec::new();
{
let mut w = Writer::new(&mut metadata);
w.uint32_field(1, 123);
w.uint64_field(2, 456);
w.uint32_field(3, 789);
w.bool_field_force(4, false);
}
let mut raw = Vec::new();
push_section(&mut raw, PAYLOAD_MAGIC, &payload);
push_section(&mut raw, METADATA_MAGIC, &metadata);
raw.extend_from_slice(&END_OF_MANIFEST_MAGIC.to_le_bytes());
let mut manifest = ContentManifest::parse(&raw).unwrap();
assert_eq!(manifest.metadata.depot_id, 123);
assert_eq!(manifest.files[0].filename, "bin\\game.exe");
assert!(manifest.decrypt_filenames(&[]));
assert_eq!(manifest.files[0].filename, "bin/game.exe");
assert_eq!(manifest.files[0].chunks[0].crc, 0x1234_5678);
}
#[test]
fn decrypts_encrypted_filenames() {
let key = [9u8; SESSION_KEY_LENGTH];
let name = encrypt_name(&key, "dir\\file.txt\0");
let mut manifest = ContentManifest {
metadata: Metadata {
filenames_encrypted: true,
..Default::default()
},
files: vec![FileMapping {
filename: name,
..Default::default()
}],
signature: Vec::new(),
};
assert!(manifest.decrypt_filenames(&key));
assert_eq!(manifest.files[0].filename, "dir/file.txt");
assert!(!manifest.metadata.filenames_encrypted);
}
fn push_section(out: &mut Vec<u8>, magic: u32, body: &[u8]) {
out.extend_from_slice(&magic.to_le_bytes());
out.extend_from_slice(&(body.len() as u32).to_le_bytes());
out.extend_from_slice(body);
}
fn encrypt_name(key: &SessionKey, name: &str) -> String {
let iv = [5u8; AES_BLOCK_BYTES];
let wrapped = aes256_ecb_encrypt_block(key, &iv).unwrap();
let body = aes256_cbc_encrypt(key, &iv, name.as_bytes()).unwrap();
let mut blob = wrapped.to_vec();
blob.extend_from_slice(&body);
base64::encode(&blob)
}
}
@@ -0,0 +1,150 @@
use aes::cipher::{
block_padding::Pkcs7, BlockDecrypt, BlockDecryptMut, BlockEncrypt, BlockEncryptMut, KeyInit,
KeyIvInit,
};
use aes::Aes256;
use hmac::{Hmac, Mac};
use rand::{rngs::OsRng, RngCore};
use rsa::pkcs8::DecodePublicKey;
use rsa::traits::PublicKeyParts;
use rsa::{Oaep, RsaPublicKey};
use sha1::{Digest as Sha1DigestTrait, Sha1};
use sha2::Sha256;
use zeroize::Zeroize;
pub const SESSION_KEY_LENGTH: usize = 32;
pub const AES_BLOCK_BYTES: usize = 16;
pub const SHA1_BYTES: usize = 20;
pub const SHA256_BYTES: usize = 32;
pub const HMAC_KEY_LENGTH: usize = 16;
pub type SessionKey = [u8; SESSION_KEY_LENGTH];
pub type Sha1Digest = [u8; SHA1_BYTES];
pub type Sha256Digest = [u8; SHA256_BYTES];
pub type AesBlock = [u8; AES_BLOCK_BYTES];
#[derive(Clone)]
pub struct SecureSessionKey {
pub bytes: SessionKey,
}
impl SecureSessionKey {
pub fn new(bytes: SessionKey) -> Self {
Self { bytes }
}
}
impl Drop for SecureSessionKey {
fn drop(&mut self) {
self.bytes.zeroize();
}
}
pub fn secure_random_bytes(out: &mut [u8]) -> bool {
OsRng.try_fill_bytes(out).is_ok()
}
pub fn generate_session_key() -> Option<SecureSessionKey> {
let mut bytes = [0u8; SESSION_KEY_LENGTH];
secure_random_bytes(&mut bytes).then_some(SecureSessionKey::new(bytes))
}
pub fn sha1(data: &[u8]) -> Sha1Digest {
Sha1::digest(data).into()
}
pub fn sha256(data: &[u8]) -> Sha256Digest {
Sha256::digest(data).into()
}
pub fn crc32(data: &[u8]) -> u32 {
crc32fast::hash(data)
}
pub fn hmac_sha1(key: &[u8], data: &[u8]) -> Option<Sha1Digest> {
let mut mac = <Hmac<Sha1> as Mac>::new_from_slice(key).ok()?;
mac.update(data);
Some(mac.finalize().into_bytes().into())
}
pub fn aes256_ecb_encrypt_block(key: &SessionKey, input: &AesBlock) -> Option<AesBlock> {
let cipher = Aes256::new_from_slice(key).ok()?;
let mut block = (*input).into();
cipher.encrypt_block(&mut block);
Some(block.into())
}
pub fn aes256_ecb_decrypt_block(key: &SessionKey, input: &AesBlock) -> Option<AesBlock> {
let cipher = Aes256::new_from_slice(key).ok()?;
let mut block = (*input).into();
cipher.decrypt_block(&mut block);
Some(block.into())
}
pub fn aes256_cbc_encrypt(key: &SessionKey, iv: &AesBlock, plaintext: &[u8]) -> Option<Vec<u8>> {
Some(
cbc::Encryptor::<Aes256>::new(key.into(), iv.into())
.encrypt_padded_vec_mut::<Pkcs7>(plaintext),
)
}
pub fn aes256_cbc_decrypt(key: &SessionKey, iv: &AesBlock, ciphertext: &[u8]) -> Option<Vec<u8>> {
if ciphertext.is_empty() || !ciphertext.len().is_multiple_of(AES_BLOCK_BYTES) {
return None;
}
cbc::Decryptor::<Aes256>::new(key.into(), iv.into())
.decrypt_padded_vec_mut::<Pkcs7>(ciphertext)
.ok()
}
pub fn rsa_oaep_sha1_encrypt(spki_der: &[u8], plaintext: &[u8]) -> Option<Vec<u8>> {
let public_key = RsaPublicKey::from_public_key_der(spki_der).ok()?;
let modulus = public_key.size();
if modulus < 2 + 2 * SHA1_BYTES || plaintext.len() > modulus - 2 - 2 * SHA1_BYTES {
return None;
}
public_key
.encrypt(&mut OsRng, Oaep::new::<Sha1>(), plaintext)
.ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hashes_match_known_values() {
assert_eq!(
hex(&sha1(b"abc")),
"a9993e364706816aba3e25717850c26c9cd0d89d"
);
assert_eq!(
hex(&sha256(b"abc")),
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
);
assert_eq!(crc32(b"123456789"), 0xcbf4_3926);
}
#[test]
fn aes_cbc_roundtrips_with_pkcs7() {
let key = [7u8; SESSION_KEY_LENGTH];
let iv = [3u8; AES_BLOCK_BYTES];
let plaintext = b"steam manifest filename";
let encrypted = aes256_cbc_encrypt(&key, &iv, plaintext).unwrap();
assert_ne!(encrypted, plaintext);
let decrypted = aes256_cbc_decrypt(&key, &iv, &encrypted).unwrap();
assert_eq!(decrypted, plaintext);
}
#[test]
fn hmac_sha1_known_value() {
assert_eq!(
hex(&hmac_sha1(b"key", b"The quick brown fox jumps over the lazy dog").unwrap()),
"de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9"
);
}
fn hex(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
}
@@ -0,0 +1,253 @@
use crate::steam::cdn;
use crate::steam::crypto::{
aes256_cbc_decrypt, aes256_ecb_decrypt_block, AesBlock, SessionKey, AES_BLOCK_BYTES,
SESSION_KEY_LENGTH,
};
use lzma_rs::decompress::raw::{LzmaDecoder, LzmaParams, LzmaProperties};
use std::io::{Cursor, Read};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct DepotChunkResult {
pub data: Vec<u8>,
pub error: String,
}
impl DepotChunkResult {
pub fn ok(&self) -> bool {
self.error.is_empty()
}
}
pub fn process_depot_chunk(
raw: &[u8],
depot_key: &[u8],
expected_crc: u32,
expected_size: u32,
) -> DepotChunkResult {
if depot_key.len() != SESSION_KEY_LENGTH {
return fail("chunk: bad depot key length");
}
if raw.is_empty() {
return fail("chunk: empty");
}
let mut key = [0u8; SESSION_KEY_LENGTH];
key.copy_from_slice(depot_key);
let Some(dec) = steam_symmetric_decrypt(&key, raw) else {
return fail("chunk: AES decrypt failed");
};
if dec.is_empty() {
return fail("chunk: AES decrypt failed");
}
let result = if dec.starts_with(b"VSZa") {
decompress_vzstd(&dec, expected_size)
} else if dec.starts_with(b"VZa") {
decompress_vzip(&dec, expected_size)
} else if dec.starts_with(b"PK\x03\x04") {
match cdn::unzip_first_entry(&dec) {
Some(data) => DepotChunkResult {
data,
error: String::new(),
},
None => fail("chunk: PKZip decompress failed"),
}
} else {
fail("chunk: unrecognised compression header")
};
if !result.ok() {
return result;
}
if result.data.len() != expected_size as usize {
return fail(format!(
"chunk: size mismatch ({} != {expected_size})",
result.data.len()
));
}
if steam_adler_hash(&result.data) != expected_crc {
return fail("chunk: Adler32 mismatch");
}
result
}
pub fn steam_symmetric_decrypt(key: &SessionKey, enc: &[u8]) -> Option<Vec<u8>> {
if enc.len() < AES_BLOCK_BYTES * 2 {
return None;
}
let mut wrapped = [0u8; AES_BLOCK_BYTES];
wrapped.copy_from_slice(&enc[..AES_BLOCK_BYTES]);
let iv: AesBlock = aes256_ecb_decrypt_block(key, &wrapped)?;
aes256_cbc_decrypt(key, &iv, &enc[AES_BLOCK_BYTES..])
}
fn decompress_vzstd(dec: &[u8], expected_size: u32) -> DepotChunkResult {
if dec.len() <= 8 {
return fail("vzstd: chunk too small");
}
let payload = &dec[8..];
let mut reader = match ruzstd::StreamingDecoder::new(Cursor::new(payload)) {
Ok(reader) => reader,
Err(_) => return fail("vzstd: bad zstd frame"),
};
let mut data = Vec::with_capacity(expected_size as usize);
if reader.read_to_end(&mut data).is_err() {
return fail("vzstd: decode failed");
}
DepotChunkResult {
data,
error: String::new(),
}
}
fn decompress_vzip(dec: &[u8], expected_size: u32) -> DepotChunkResult {
const HEADER: usize = 3 + 4;
const PROPS: usize = 5;
const FOOTER: usize = 10;
if dec.len() < HEADER + PROPS + FOOTER {
return fail("vzip: chunk too small");
}
if dec[dec.len() - 2] != b'z' || dec[dec.len() - 1] != b'v' {
return fail("vzip: bad footer");
}
let props = &dec[HEADER..HEADER + PROPS];
let comp = &dec[HEADER + PROPS..dec.len() - FOOTER];
let Some(params) = lzma_params_from_steam_props(props, expected_size as u64) else {
return fail("vzip: bad LZMA properties");
};
let mut decoder = match LzmaDecoder::new(params, None) {
Ok(decoder) => decoder,
Err(_) => return fail("vzip: raw decoder init failed"),
};
let mut output = Vec::with_capacity(expected_size as usize);
match decoder.decompress(&mut Cursor::new(comp), &mut output) {
Ok(()) => DepotChunkResult {
data: output,
error: String::new(),
},
Err(_) => fail("vzip: LZMA decode failed"),
}
}
fn lzma_params_from_steam_props(props: &[u8], expected_size: u64) -> Option<LzmaParams> {
if props.len() != 5 {
return None;
}
let mut packed = props[0] as u32;
if packed >= 225 {
return None;
}
let lc = packed % 9;
packed /= 9;
let lp = packed % 5;
let pb = packed / 5;
if lc > 8 || lp > 4 || pb > 4 {
return None;
}
let dict_size = u32::from_le_bytes(props[1..5].try_into().ok()?);
Some(LzmaParams::new(
LzmaProperties { lc, lp, pb },
dict_size,
Some(expected_size),
))
}
pub fn steam_adler_hash(data: &[u8]) -> u32 {
let mut a = 0u32;
let mut b = 0u32;
for byte in data {
a = (a + *byte as u32) % 65_521;
b = (b + a) % 65_521;
}
a | (b << 16)
}
fn fail(msg: impl Into<String>) -> DepotChunkResult {
DepotChunkResult {
data: Vec::new(),
error: msg.into(),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::crypto::{aes256_cbc_encrypt, aes256_ecb_encrypt_block};
#[test]
fn steam_adler_hash_uses_zero_seed() {
assert_eq!(steam_adler_hash(b""), 0);
assert_eq!(steam_adler_hash(b"abc"), 0x024a_0126);
}
#[test]
fn decrypts_and_processes_pkzip_chunk() {
let key = [4u8; SESSION_KEY_LENGTH];
let payload = b"chunk bytes";
let mut zip = Vec::new();
zip.extend_from_slice(&0x0403_4b50u32.to_le_bytes());
zip.extend_from_slice(&20u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.extend_from_slice(&0u32.to_le_bytes());
zip.extend_from_slice(&(payload.len() as u32).to_le_bytes());
zip.extend_from_slice(&(payload.len() as u32).to_le_bytes());
zip.extend_from_slice(&1u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.extend_from_slice(b"x");
zip.extend_from_slice(payload);
let raw = encrypt_steam_symmetric(&key, &zip);
let result =
process_depot_chunk(&raw, &key, steam_adler_hash(payload), payload.len() as u32);
assert_eq!(result.data, payload);
assert!(result.ok());
}
#[test]
fn decrypts_and_processes_vzip_raw_lzma_chunk() {
let key = [8u8; SESSION_KEY_LENGTH];
let payload = b"legacy lzma chunk bytes";
let mut lzma_alone = Vec::new();
lzma_rs::lzma_compress(&mut Cursor::new(payload), &mut lzma_alone).unwrap();
assert!(lzma_alone.len() > 13);
let mut vzip = Vec::new();
vzip.extend_from_slice(b"VZa");
vzip.extend_from_slice(&0u32.to_le_bytes());
vzip.extend_from_slice(&lzma_alone[..5]);
vzip.extend_from_slice(&lzma_alone[13..]);
vzip.extend_from_slice(&0u32.to_le_bytes());
vzip.extend_from_slice(&(payload.len() as u32).to_le_bytes());
vzip.extend_from_slice(b"zv");
let raw = encrypt_steam_symmetric(&key, &vzip);
let result =
process_depot_chunk(&raw, &key, steam_adler_hash(payload), payload.len() as u32);
assert_eq!(result.data, payload);
assert!(result.ok());
}
#[test]
fn vzip_rejects_bad_properties_before_raw_decode() {
let mut dec = Vec::new();
dec.extend_from_slice(b"VZa");
dec.extend_from_slice(&0u32.to_le_bytes());
dec.extend_from_slice(&[225, 0, 0, 0, 0]);
dec.extend_from_slice(b"payload");
dec.extend_from_slice(&0u32.to_le_bytes());
dec.extend_from_slice(&0u32.to_le_bytes());
dec.extend_from_slice(b"zv");
assert_eq!(decompress_vzip(&dec, 1).error, "vzip: bad LZMA properties");
}
fn encrypt_steam_symmetric(key: &SessionKey, plaintext: &[u8]) -> Vec<u8> {
let iv = [6u8; AES_BLOCK_BYTES];
let wrapped = aes256_ecb_encrypt_block(key, &iv).unwrap();
let body = aes256_cbc_encrypt(key, &iv, plaintext).unwrap();
let mut out = wrapped.to_vec();
out.extend_from_slice(&body);
out
}
}
@@ -0,0 +1,184 @@
//! Resume journal for one app's download, kept in a caller-given app-private directory (never in
//! the game folder, which must end up exactly like one the Steam client made).
//!
//! Layout of `<journal_root>/<appid>/`: `depot.config` (JSON: the build the journal belongs to and
//! the finished manifest per depot, or the in-progress sentinel while a depot is being written)
//! and `<depot>_<manifest>.manifest` (the raw CDN manifest, so a resumed run does not refetch it).
use serde_json::{json, Value};
use std::collections::BTreeMap;
use std::fs::{self, File};
use std::io::Write;
use std::path::{Path, PathBuf};
pub const INVALID_MANIFEST_ID: u64 = 0x7fff_ffff_ffff_ffff;
pub fn app_journal_dir(journal_root: impl AsRef<Path>, app_id: u32) -> PathBuf {
journal_root.as_ref().join(app_id.to_string())
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct DepotConfigStore {
dir: PathBuf,
build_id: u64,
installed: BTreeMap<u32, u64>,
}
impl DepotConfigStore {
/// Loads the journal; a journal written for another build is dropped (its depot records and
/// cached manifests no longer describe what this run installs).
pub fn load(dir: impl Into<PathBuf>, build_id: u64) -> Self {
let dir = dir.into();
let mut store = Self {
dir,
build_id,
installed: BTreeMap::new(),
};
let Ok(text) = fs::read_to_string(store.config_path()) else {
return store;
};
let Ok(value) = serde_json::from_str::<Value>(&text) else {
return store;
};
let journal_build = value.get("buildId").and_then(Value::as_u64).unwrap_or(0);
if journal_build != build_id {
store.discard();
return store;
}
if let Some(obj) = value.get("installedManifestIDs").and_then(Value::as_object) {
for (key, value) in obj {
if let (Ok(depot_id), Some(manifest_id)) = (key.parse::<u32>(), value.as_u64()) {
store.installed.insert(depot_id, manifest_id);
}
}
}
store
}
pub fn dir(&self) -> &Path {
&self.dir
}
pub fn manifest_cache_path(&self, depot_id: u32, manifest_id: u64) -> PathBuf {
self.dir.join(format!("{depot_id}_{manifest_id}.manifest"))
}
pub fn is_installed(&self, depot_id: u32, manifest_id: u64) -> bool {
self.installed
.get(&depot_id)
.is_some_and(|installed| *installed == manifest_id && *installed != INVALID_MANIFEST_ID)
}
pub fn begin_depot(&mut self, depot_id: u32) -> bool {
self.installed.insert(depot_id, INVALID_MANIFEST_ID);
self.save()
}
pub fn finish_depot(&mut self, depot_id: u32, manifest_id: u64) -> bool {
self.installed.insert(depot_id, manifest_id);
self.save()
}
pub fn read_cached_manifest(&self, depot_id: u32, manifest_id: u64) -> Option<Vec<u8>> {
let bytes = fs::read(self.manifest_cache_path(depot_id, manifest_id)).ok()?;
(!bytes.is_empty()).then_some(bytes)
}
pub fn write_cached_manifest(&self, depot_id: u32, manifest_id: u64, raw: &[u8]) -> bool {
atomic_write_synced(&self.manifest_cache_path(depot_id, manifest_id), raw)
}
/// Removes the whole journal directory (after a successful install, or when it is stale).
pub fn discard(&mut self) {
self.installed.clear();
let _ = fs::remove_dir_all(&self.dir);
}
fn config_path(&self) -> PathBuf {
self.dir.join("depot.config")
}
fn save(&self) -> bool {
let ids: serde_json::Map<String, Value> = self
.installed
.iter()
.map(|(depot, manifest)| (depot.to_string(), json!(manifest)))
.collect();
let Ok(bytes) = serde_json::to_string_pretty(&json!({
"buildId": self.build_id,
"installedManifestIDs": ids,
})) else {
return false;
};
atomic_write_synced(&self.config_path(), bytes.as_bytes())
}
}
pub fn atomic_write_synced(final_path: &Path, bytes: &[u8]) -> bool {
let Some(parent) = final_path.parent() else {
return false;
};
if fs::create_dir_all(parent).is_err() {
return false;
}
let mut tmp_name = final_path
.file_name()
.map(|n| n.to_os_string())
.unwrap_or_default();
tmp_name.push(".tmp");
let tmp_path = final_path.with_file_name(tmp_name);
let mut file = match File::create(&tmp_path) {
Ok(file) => file,
Err(_) => return false,
};
if file.write_all(bytes).is_err() || file.sync_all().is_err() {
let _ = fs::remove_file(&tmp_path);
return false;
}
drop(file);
if fs::rename(&tmp_path, final_path).is_err() {
let _ = fs::remove_file(&tmp_path);
return false;
}
if let Ok(dir) = File::open(parent) {
let _ = dir.sync_all();
}
true
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn journal_roundtrips_marks_in_progress_and_drops_other_builds() {
let root = temp_dir("journal");
let dir = app_journal_dir(&root, 291550);
let mut store = DepotConfigStore::load(&dir, 26465982);
assert!(!store.is_installed(291551, 1));
assert!(store.begin_depot(291551));
assert!(!DepotConfigStore::load(&dir, 26465982).is_installed(291551, INVALID_MANIFEST_ID));
assert!(store.finish_depot(291551, 4224536525702420323));
assert!(store.write_cached_manifest(291551, 4224536525702420323, b"raw"));
let loaded = DepotConfigStore::load(&dir, 26465982);
assert!(loaded.is_installed(291551, 4224536525702420323));
assert_eq!(
loaded.read_cached_manifest(291551, 4224536525702420323),
Some(b"raw".to_vec())
);
let other_build = DepotConfigStore::load(&dir, 1);
assert!(!other_build.is_installed(291551, 4224536525702420323));
assert!(!dir.exists());
let _ = fs::remove_dir_all(&root);
}
fn temp_dir(name: &str) -> PathBuf {
std::env::temp_dir().join(format!(
"droiddeck_steam_{name}_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
))
}
}
@@ -0,0 +1,152 @@
//! One depot from key to files: depot decryption key, manifest request code, the manifest (from
//! the journal when a cancelled run already fetched it), filename decryption, then the writer.
use crate::steam::cdn;
use crate::steam::content_manifest::ContentManifest;
use crate::steam::depot_config::DepotConfigStore;
use crate::steam::depot_writer::{write_depot, DepotWriteOutcome, DepotWriteRequest};
use crate::steam::pb::ccontentserverdirectory::CContentServerDirectoryServerInfo;
use crate::steam::session::{CodeResolution, KeyResolution, Session};
use std::path::Path;
use std::sync::atomic::AtomicBool;
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum DepotError {
Cancelled,
AccessDenied(u32),
Failed(String),
}
impl DepotError {
pub fn message(&self) -> String {
match self {
DepotError::Cancelled => "cancelled".to_string(),
DepotError::AccessDenied(depot) => format!("access_denied: depot {depot}"),
DepotError::Failed(msg) => msg.clone(),
}
}
}
pub struct PreparedDepot {
pub depot_id: u32,
pub manifest_id: u64,
pub key: Vec<u8>,
pub manifest: ContentManifest,
}
impl Drop for PreparedDepot {
fn drop(&mut self) {
zeroize::Zeroize::zeroize(&mut self.key);
}
}
/// Resolves the key and the manifest of `depot_id` (owned by `app_id`, the app the key and
/// request code are asked for).
#[allow(clippy::too_many_arguments)]
pub fn prepare_depot(
session: &Session,
servers: &[CContentServerDirectoryServerInfo],
journal: Option<&DepotConfigStore>,
ca_bundle_path: &str,
app_id: u32,
depot_id: u32,
manifest_id: u64,
cancel: &AtomicBool,
) -> Result<PreparedDepot, DepotError> {
let key = match session.depot_key(app_id, depot_id, cancel) {
KeyResolution::Granted(key) => key,
KeyResolution::AccessDenied => return Err(DepotError::AccessDenied(depot_id)),
KeyResolution::Cancelled => return Err(DepotError::Cancelled),
KeyResolution::Unavailable => {
return Err(DepotError::Failed(format!(
"depot key unavailable for depot {depot_id}"
)))
}
};
let raw = match journal.and_then(|j| j.read_cached_manifest(depot_id, manifest_id)) {
Some(raw) => raw,
None => {
let servers = cdn::usable_servers(servers);
let code = match session.manifest_code(app_id, depot_id, manifest_id, cancel) {
CodeResolution::Code(code) => code,
CodeResolution::AccessDenied => return Err(DepotError::AccessDenied(depot_id)),
CodeResolution::Cancelled => return Err(DepotError::Cancelled),
CodeResolution::Unavailable => {
return Err(DepotError::Failed(format!(
"manifest request code unavailable for depot {depot_id}"
)))
}
};
let ca = ca_bundle_path;
let mut fetched =
cdn::fetch_manifest_with_retry(&servers, depot_id, manifest_id, code, ca, cancel);
if !fetched.ok() && fetched.error != "cancelled" {
// Request codes rotate every few minutes: one more pass with a fresh one.
if let CodeResolution::Code(fresh) =
session.manifest_code(app_id, depot_id, manifest_id, cancel)
{
if fresh != code {
fetched = cdn::fetch_manifest_with_retry(
&servers,
depot_id,
manifest_id,
fresh,
ca,
cancel,
);
}
}
}
if fetched.error == "cancelled" {
return Err(DepotError::Cancelled);
}
if !fetched.ok() {
return Err(DepotError::Failed(format!(
"manifest fetch failed for depot {depot_id}: {}",
fetched.error
)));
}
if let Some(journal) = journal {
let _ = journal.write_cached_manifest(depot_id, manifest_id, &fetched.raw_manifest);
}
fetched.raw_manifest
}
};
let mut manifest = ContentManifest::parse(&raw)
.ok_or_else(|| DepotError::Failed(format!("manifest parse failed for depot {depot_id}")))?;
if !manifest.decrypt_filenames(&key) {
return Err(DepotError::Failed(format!(
"filename decryption failed for depot {depot_id}"
)));
}
Ok(PreparedDepot {
depot_id,
manifest_id,
key,
manifest,
})
}
#[allow(clippy::too_many_arguments)]
pub fn download_prepared(
prepared: &PreparedDepot,
servers: &[CContentServerDirectoryServerInfo],
target_dir: &Path,
ca_bundle_path: &str,
max_workers: usize,
process_workers: usize,
cancel: &AtomicBool,
progress: &(dyn Fn(u64) + Sync),
log: &(dyn Fn(&str) + Sync),
) -> DepotWriteOutcome {
let request = DepotWriteRequest {
manifest: &prepared.manifest,
depot_key: &prepared.key,
servers,
target_dir,
ca_bundle_path,
max_workers,
process_workers,
};
write_depot(&request, cancel, progress, log)
}
@@ -0,0 +1,844 @@
//! Writes one depot's files in place under the target folder, the way the Steam client lays them
//! out: no temp files, no space reservation (`fallocate`/zero-fill are slow on Android's FUSE
//! storage), each file trimmed to its exact size with `set_len` once its last chunk lands.
//!
//! Chunk bodies come from the shared fetch core (`crate::fetch_core`), which owns the adaptive
//! request window, host rotation and retries; this module is the sink (decrypt, decompress,
//! Adler-32 check, positioned write). A chunk that appears several times in the manifest is
//! fetched once and written to every place it belongs. On resume, chunks already on disk are
//! read back and checked before anything is fetched.
use crate::fetch_core::{run_fetch, FetchItem, FetchOptions, FetchSink, SinkError};
use crate::steam::cdn;
use crate::steam::content_manifest::{ChunkData, ContentManifest};
use crate::steam::depot_chunk::{process_depot_chunk, steam_adler_hash};
use crate::steam::pb::ccontentserverdirectory::CContentServerDirectoryServerInfo;
use std::collections::HashMap;
use std::fs::{self, File, OpenOptions};
use std::path::{Component, Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
pub const DEPOT_FILE_FLAG_EXECUTABLE: u32 = 32;
pub const DEPOT_FILE_FLAG_DIRECTORY: u32 = 64;
/// Chunks per fetch-core run. Every chunk carries one URL per CDN host, so batches bound memory on
/// very large depots.
pub const FETCH_BATCH_ITEMS: usize = 8192;
/// Above this many open files a written file's handle is closed and reopened on its next chunk.
pub const MAX_OPEN_FILES: usize = 256;
pub const CHUNK_TIMEOUT: Duration = Duration::from_secs(60);
const FREE_SPACE_MARGIN_BYTES: u64 = 64 * 1024 * 1024;
pub struct DepotWriteRequest<'a> {
/// Filenames already decrypted (see `ContentManifest::decrypt_filenames`).
pub manifest: &'a ContentManifest,
pub depot_key: &'a [u8],
pub servers: &'a [CContentServerDirectoryServerInfo],
pub target_dir: &'a Path,
pub ca_bundle_path: &'a str,
pub max_workers: usize,
pub process_workers: usize,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DepotWriteOutcome {
/// Bytes of the depot that are complete on disk (verified + written).
pub bytes_done: u64,
/// Of those, bytes that were already correct on disk.
pub bytes_verified: u64,
pub error: Option<String>,
pub cancelled: bool,
}
impl DepotWriteOutcome {
pub fn ok(&self) -> bool {
self.error.is_none() && !self.cancelled
}
fn fail(error: impl Into<String>) -> Self {
Self {
error: Some(error.into()),
..Default::default()
}
}
}
pub fn path_is_safe(rel: &str) -> bool {
if rel.is_empty() || rel.starts_with('/') || rel.starts_with('\\') {
return false;
}
let path = Path::new(rel);
!path.is_absolute()
&& path
.components()
.all(|c| matches!(c, Component::Normal(_) | Component::CurDir))
}
pub fn depot_total_bytes(manifest: &ContentManifest) -> u64 {
manifest
.files
.iter()
.filter(|f| is_regular(f.flags, &f.linktarget))
.map(|f| f.size)
.sum()
}
fn is_regular(flags: u32, linktarget: &str) -> bool {
linktarget.is_empty() && (flags & DEPOT_FILE_FLAG_DIRECTORY) == 0
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct Target {
file_idx: u32,
offset: u64,
}
#[derive(Clone, Debug)]
struct UniqueChunk {
sha: Vec<u8>,
crc: u32,
cb_original: u32,
cb_compressed: u32,
targets: Vec<Target>,
}
struct FileSlot {
handle: Mutex<Option<Arc<File>>>,
remaining: AtomicUsize,
size: u64,
path: PathBuf,
mode: u32,
}
struct DepotFiles {
slots: Vec<FileSlot>,
open_count: AtomicUsize,
}
impl DepotFiles {
fn acquire(&self, file_idx: usize) -> Result<Arc<File>, String> {
let slot = &self.slots[file_idx];
let mut handle = slot.handle.lock().expect("file slot poisoned");
if let Some(file) = handle.as_ref() {
return Ok(Arc::clone(file));
}
make_parent_dirs(&slot.path)?;
let file = OpenOptions::new()
.create(true)
.write(true)
.read(true)
.truncate(false)
.open(&slot.path)
.map_err(|err| format!("open '{}': {err}", slot.path.display()))?;
set_file_mode(&slot.path, slot.mode)?;
let file = Arc::new(file);
*handle = Some(Arc::clone(&file));
self.open_count.fetch_add(1, Ordering::Relaxed);
Ok(file)
}
fn release(&self, file_idx: usize) {
let slot = &self.slots[file_idx];
if slot
.handle
.lock()
.expect("file slot poisoned")
.take()
.is_some()
{
self.open_count.fetch_sub(1, Ordering::Relaxed);
}
}
fn write(&self, file_idx: usize, offset: u64, data: &[u8]) -> Result<(), String> {
let file = self.acquire(file_idx)?;
pwrite_all_at(&file, offset, data).map_err(|err| {
format!(
"write '{}' at {offset}: {err}",
self.slots[file_idx].path.display()
)
})?;
let slot = &self.slots[file_idx];
if slot.remaining.fetch_sub(1, Ordering::AcqRel) == 1 {
finalize(&file, slot)?;
drop(file);
self.release(file_idx);
} else if self.open_count.load(Ordering::Relaxed) > MAX_OPEN_FILES {
drop(file);
self.release(file_idx);
}
Ok(())
}
/// Files with nothing left to fetch (zero chunks, or every chunk already correct on disk).
fn finalize_untouched(&self, idx: usize) -> Result<(), String> {
let slot = &self.slots[idx];
make_parent_dirs(&slot.path)?;
let file = OpenOptions::new()
.create(true)
.write(true)
.truncate(false)
.open(&slot.path)
.map_err(|err| format!("open '{}': {err}", slot.path.display()))?;
set_file_mode(&slot.path, slot.mode)?;
let current = file.metadata().map(|m| m.len()).unwrap_or(u64::MAX);
if current != slot.size {
file.set_len(slot.size)
.map_err(|err| format!("set_len '{}': {err}", slot.path.display()))?;
}
Ok(())
}
}
fn finalize(file: &File, slot: &FileSlot) -> Result<(), String> {
file.set_len(slot.size)
.map_err(|err| format!("set_len '{}': {err}", slot.path.display()))?;
file.sync_all()
.map_err(|err| format!("sync '{}': {err}", slot.path.display()))
}
struct ChunkSink<'a> {
chunks: &'a [UniqueChunk],
files: &'a DepotFiles,
depot_key: &'a [u8],
}
impl FetchSink for ChunkSink<'_> {
fn process(&self, item: &FetchItem, body: Vec<u8>) -> Result<u64, SinkError> {
let Some(chunk) = self.chunks.get(item.id as usize) else {
return Err(SinkError::Fatal("bad chunk index".to_string()));
};
let processed = process_depot_chunk(&body, self.depot_key, chunk.crc, chunk.cb_original);
if !processed.ok() {
return Err(SinkError::Retry(processed.error));
}
let mut credited = 0u64;
for target in &chunk.targets {
self.files
.write(target.file_idx as usize, target.offset, &processed.data)
.map_err(SinkError::Fatal)?;
credited += processed.data.len() as u64;
}
Ok(credited)
}
}
struct Prepared {
files: DepotFiles,
chunks: Vec<UniqueChunk>,
bytes_verified: u64,
total: u64,
}
/// Layout, free-space check, resume verify pass, and the de-duplicated chunk list still to fetch.
fn prepare(
request: &DepotWriteRequest<'_>,
cancel: &AtomicBool,
) -> Result<Prepared, DepotWriteOutcome> {
let manifest = request.manifest;
if manifest.metadata.filenames_encrypted {
return Err(DepotWriteOutcome::fail(
"manifest filenames are still encrypted",
));
}
if request.depot_key.len() != 32 {
return Err(DepotWriteOutcome::fail("bad depot key length"));
}
if let Some(bad) = manifest.files.iter().find(|f| !path_is_safe(&f.filename)) {
return Err(DepotWriteOutcome::fail(format!(
"unsafe path '{}'",
bad.filename
)));
}
if let Err(err) = fs::create_dir_all(request.target_dir) {
return Err(DepotWriteOutcome::fail(format!(
"mkdir '{}': {err}",
request.target_dir.display()
)));
}
let mut slots = Vec::with_capacity(manifest.files.len());
let mut existing = Vec::with_capacity(manifest.files.len());
for file in &manifest.files {
let path = request.target_dir.join(&file.filename);
let regular = is_regular(file.flags, &file.linktarget);
let len = if regular {
fs::metadata(&path).map(|m| m.len()).unwrap_or(0)
} else {
0
};
existing.push(len);
slots.push(FileSlot {
handle: Mutex::new(None),
remaining: AtomicUsize::new(0),
size: file.size,
path,
mode: if (file.flags & DEPOT_FILE_FLAG_EXECUTABLE) != 0 {
0o755
} else {
0o644
},
});
}
let total = depot_total_bytes(manifest);
let present: u64 = manifest
.files
.iter()
.zip(&existing)
.map(|(f, len)| (*len).min(f.size))
.sum();
let needed = total.saturating_sub(present);
if let Some(available) = available_space_bytes(request.target_dir) {
if available > 0 && available.saturating_add(FREE_SPACE_MARGIN_BYTES) < needed {
return Err(DepotWriteOutcome::fail(format!(
"not_enough_space: need {} MiB, have {} MiB",
needed / (1024 * 1024),
available / (1024 * 1024)
)));
}
}
for file in &manifest.files {
let path = request.target_dir.join(&file.filename);
let result = if !file.linktarget.is_empty() {
create_symlink(&path, &file.linktarget)
} else if (file.flags & DEPOT_FILE_FLAG_DIRECTORY) != 0 {
fs::create_dir_all(&path).map_err(|err| format!("mkdir '{}': {err}", path.display()))
} else {
Ok(())
};
if let Err(err) = result {
return Err(DepotWriteOutcome::fail(err));
}
}
let verified = verify_existing(manifest, &slots, &existing, request.process_workers, cancel);
if cancel.load(Ordering::Relaxed) {
return Err(DepotWriteOutcome {
cancelled: true,
..Default::default()
});
}
let mut bytes_verified = 0u64;
let mut chunks: Vec<UniqueChunk> = Vec::new();
let mut by_sha: HashMap<Vec<u8>, usize> = HashMap::new();
for (file_idx, file) in manifest.files.iter().enumerate() {
if !is_regular(file.flags, &file.linktarget) {
continue;
}
let mut remaining = 0usize;
for (chunk_idx, chunk) in file.chunks.iter().enumerate() {
if verified[file_idx].get(chunk_idx).copied().unwrap_or(false) {
bytes_verified += chunk.cb_original as u64;
continue;
}
remaining += 1;
let target = Target {
file_idx: file_idx as u32,
offset: chunk.offset,
};
match by_sha.get(&chunk.sha) {
Some(&idx) => chunks[idx].targets.push(target),
None => {
by_sha.insert(chunk.sha.clone(), chunks.len());
chunks.push(UniqueChunk {
sha: chunk.sha.clone(),
crc: chunk.crc,
cb_original: chunk.cb_original,
cb_compressed: chunk.cb_compressed,
targets: vec![target],
});
}
}
}
slots[file_idx]
.remaining
.store(remaining, Ordering::Relaxed);
}
drop(by_sha);
let files = DepotFiles {
slots,
open_count: AtomicUsize::new(0),
};
for (idx, file) in manifest.files.iter().enumerate() {
if is_regular(file.flags, &file.linktarget)
&& files.slots[idx].remaining.load(Ordering::Relaxed) == 0
{
if let Err(err) = files.finalize_untouched(idx) {
return Err(DepotWriteOutcome::fail(err));
}
}
}
Ok(Prepared {
files,
chunks,
bytes_verified,
total,
})
}
/// Writes (or resumes) one depot. `progress` gets the depot's completed bytes; `log` gets the
/// fetch core's lines.
pub fn write_depot(
request: &DepotWriteRequest<'_>,
cancel: &AtomicBool,
progress: &(dyn Fn(u64) + Sync),
log: &(dyn Fn(&str) + Sync),
) -> DepotWriteOutcome {
let manifest = request.manifest;
let servers = cdn::usable_servers(request.servers);
if servers.is_empty() {
return DepotWriteOutcome::fail("no usable CDN server");
}
let Prepared {
files,
chunks,
bytes_verified,
total,
} = match prepare(request, cancel) {
Ok(prepared) => prepared,
Err(outcome) => return outcome,
};
progress(bytes_verified);
log(&format!(
"depot={} files={} unique_chunks={} verified_bytes={bytes_verified} total_bytes={total}",
manifest.metadata.depot_id,
manifest.files.len(),
chunks.len()
));
let hosts: Vec<String> = servers.iter().map(cdn::host_key).collect();
let opts = FetchOptions {
max_workers: request.max_workers.max(1),
timeout: CHUNK_TIMEOUT,
ca_bundle_path: request.ca_bundle_path.to_string(),
process_workers: request.process_workers.max(1),
label: format!("steam depot={}", manifest.metadata.depot_id),
..Default::default()
};
let sink = ChunkSink {
chunks: &chunks,
files: &files,
depot_key: request.depot_key,
};
let depot_id = manifest.metadata.depot_id;
let done_before = AtomicU64::new(bytes_verified);
let mut start = 0usize;
while start < chunks.len() {
if cancel.load(Ordering::Relaxed) {
return DepotWriteOutcome {
bytes_done: done_before.load(Ordering::Relaxed),
bytes_verified,
cancelled: true,
error: None,
};
}
let end = (start + FETCH_BATCH_ITEMS).min(chunks.len());
let mut items = Vec::with_capacity(end - start);
for (idx, chunk) in chunks.iter().enumerate().take(end).skip(start) {
let mut urls = Vec::with_capacity(servers.len());
for server in &servers {
match cdn::build_chunk_url(server, depot_id, &chunk.sha) {
Ok(url) => urls.push(url),
Err(err) => return DepotWriteOutcome::fail(err),
}
}
items.push(FetchItem {
id: idx as u64,
urls,
reserve: chunk.cb_compressed as u64,
range: None,
});
}
let base = done_before.load(Ordering::Relaxed);
let batch_progress = |credited: u64, _items: u64| progress(base + credited);
let outcome = run_fetch(items, &hosts, &opts, &sink, cancel, &batch_progress, log);
done_before.fetch_add(outcome.bytes_credited, Ordering::Relaxed);
if outcome.cancelled {
return DepotWriteOutcome {
bytes_done: done_before.load(Ordering::Relaxed),
bytes_verified,
cancelled: true,
error: None,
};
}
if let Some(error) = outcome.error {
return DepotWriteOutcome {
bytes_done: done_before.load(Ordering::Relaxed),
bytes_verified,
cancelled: false,
error: Some(error),
};
}
start = end;
}
if let Some((idx, _)) = files
.slots
.iter()
.enumerate()
.find(|(_, s)| s.remaining.load(Ordering::Relaxed) != 0)
{
return DepotWriteOutcome::fail(format!(
"file '{}' incomplete after fetch",
manifest.files[idx].filename
));
}
DepotWriteOutcome {
bytes_done: done_before.load(Ordering::Relaxed),
bytes_verified,
error: None,
cancelled: false,
}
}
/// Per file, per chunk: is the chunk already correct on disk? Only files that already have bytes
/// are read; a fresh install skips this entirely.
fn verify_existing(
manifest: &ContentManifest,
slots: &[FileSlot],
existing: &[u64],
workers: usize,
cancel: &AtomicBool,
) -> Vec<Vec<bool>> {
let mut out: Vec<Vec<bool>> = manifest
.files
.iter()
.map(|f| vec![false; f.chunks.len()])
.collect();
let todo: Vec<usize> = (0..manifest.files.len())
.filter(|&i| existing[i] > 0 && !manifest.files[i].chunks.is_empty())
.collect();
if todo.is_empty() {
return out;
}
let queue = Mutex::new(todo.into_iter());
let results: Mutex<Vec<(usize, Vec<bool>)>> = Mutex::new(Vec::new());
std::thread::scope(|scope| {
for _ in 0..workers.clamp(1, 8) {
scope.spawn(|| {
crate::priority::background();
loop {
if cancel.load(Ordering::Relaxed) {
return;
}
let next = queue.lock().expect("verify queue poisoned").next();
let Some(idx) = next else {
return;
};
let Ok(file) = File::open(&slots[idx].path) else {
continue;
};
let flags = manifest.files[idx]
.chunks
.iter()
.map(|chunk| existing_chunk_matches(&file, existing[idx], chunk))
.collect();
results
.lock()
.expect("verify results poisoned")
.push((idx, flags));
}
});
}
});
for (idx, flags) in results.into_inner().expect("verify results poisoned") {
out[idx] = flags;
}
out
}
pub fn existing_chunk_matches(file: &File, file_len: u64, chunk: &ChunkData) -> bool {
if chunk.cb_original == 0 {
return false;
}
let end = chunk.offset.saturating_add(chunk.cb_original as u64);
if file_len < end {
return false;
}
let mut buf = vec![0u8; chunk.cb_original as usize];
if pread_exact_at(file, chunk.offset, &mut buf).is_err() {
return false;
}
steam_adler_hash(&buf) == chunk.crc
}
fn make_parent_dirs(path: &Path) -> Result<(), String> {
if let Some(parent) = path.parent() {
if !parent.as_os_str().is_empty() {
fs::create_dir_all(parent)
.map_err(|err| format!("mkdir '{}': {err}", parent.display()))?;
}
}
Ok(())
}
fn create_symlink(path: &Path, target: &str) -> Result<(), String> {
make_parent_dirs(path)?;
if fs::symlink_metadata(path).is_ok() {
fs::remove_file(path).map_err(|err| format!("unlink '{}': {err}", path.display()))?;
}
#[cfg(unix)]
{
std::os::unix::fs::symlink(target, path)
.map_err(|err| format!("symlink '{}': {err}", path.display()))
}
#[cfg(not(unix))]
{
let _ = target;
Err(format!("symlink '{}': unsupported", path.display()))
}
}
#[cfg(unix)]
fn set_file_mode(path: &Path, mode: u32) -> Result<(), String> {
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(path, fs::Permissions::from_mode(mode))
.map_err(|err| format!("chmod '{}': {err}", path.display()))
}
#[cfg(not(unix))]
fn set_file_mode(_path: &Path, _mode: u32) -> Result<(), String> {
Ok(())
}
#[cfg(unix)]
fn pwrite_all_at(file: &File, offset: u64, data: &[u8]) -> std::io::Result<()> {
use std::os::unix::fs::FileExt;
file.write_all_at(data, offset)
}
#[cfg(unix)]
fn pread_exact_at(file: &File, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
use std::os::unix::fs::FileExt;
file.read_exact_at(buf, offset)
}
#[cfg(any(target_os = "linux", target_os = "android"))]
pub fn available_space_bytes(path: &Path) -> Option<u64> {
use std::ffi::CString;
use std::os::unix::ffi::OsStrExt;
let c_path = CString::new(path.as_os_str().as_bytes()).ok()?;
let mut st: libc::statvfs = unsafe { std::mem::zeroed() };
if unsafe { libc::statvfs(c_path.as_ptr(), &mut st) } != 0 {
return None;
}
Some((st.f_bavail as u64).saturating_mul(st.f_frsize as u64))
}
#[cfg(not(any(target_os = "linux", target_os = "android")))]
pub fn available_space_bytes(_path: &Path) -> Option<u64> {
None
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::content_manifest::FileMapping;
#[test]
fn rejects_unsafe_paths() {
assert!(path_is_safe("bin/game.exe"));
assert!(path_is_safe("./a"));
assert!(!path_is_safe(""));
assert!(!path_is_safe("/etc/passwd"));
assert!(!path_is_safe("../x"));
assert!(!path_is_safe("a/../../x"));
assert!(!path_is_safe("\\x"));
}
#[test]
fn existing_chunk_check_reads_back_and_compares_adler() {
let dir = std::env::temp_dir().join(format!(
"droiddeck_steam_verify_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
fs::create_dir_all(&dir).unwrap();
let path = dir.join("f.bin");
fs::write(&path, b"helloworld").unwrap();
let file = File::open(&path).unwrap();
let good = ChunkData {
crc: steam_adler_hash(b"world"),
offset: 5,
cb_original: 5,
..Default::default()
};
let bad = ChunkData {
crc: steam_adler_hash(b"xxxxx"),
..good.clone()
};
let past_end = ChunkData {
offset: 8,
..good.clone()
};
assert!(existing_chunk_matches(&file, 10, &good));
assert!(!existing_chunk_matches(&file, 10, &bad));
assert!(!existing_chunk_matches(&file, 10, &past_end));
let manifest = ContentManifest {
files: vec![FileMapping {
filename: "f.bin".into(),
size: 10,
chunks: vec![good.clone(), bad.clone()],
..Default::default()
}],
..Default::default()
};
let slots = vec![FileSlot {
handle: Mutex::new(None),
remaining: AtomicUsize::new(0),
size: 10,
path: path.clone(),
mode: 0o644,
}];
let flags = verify_existing(&manifest, &slots, &[10], 2, &AtomicBool::new(false));
assert_eq!(flags, vec![vec![true, false]]);
let _ = fs::remove_dir_all(&dir);
}
fn zip_stored(payload: &[u8]) -> Vec<u8> {
let mut zip = Vec::new();
zip.extend_from_slice(&0x0403_4b50u32.to_le_bytes());
zip.extend_from_slice(&20u16.to_le_bytes());
zip.extend_from_slice(&[0u8; 8]);
zip.extend_from_slice(&0u32.to_le_bytes());
zip.extend_from_slice(&(payload.len() as u32).to_le_bytes());
zip.extend_from_slice(&(payload.len() as u32).to_le_bytes());
zip.extend_from_slice(&1u16.to_le_bytes());
zip.extend_from_slice(&0u16.to_le_bytes());
zip.push(b'x');
zip.extend_from_slice(payload);
zip
}
fn encrypted_chunk(key: &[u8; 32], payload: &[u8]) -> Vec<u8> {
use crate::steam::crypto::{aes256_cbc_encrypt, aes256_ecb_encrypt_block};
let iv = [9u8; 16];
let mut out = aes256_ecb_encrypt_block(key, &iv).unwrap().to_vec();
out.extend(aes256_cbc_encrypt(key, &iv, &zip_stored(payload)).unwrap());
out
}
fn chunk(sha: u8, data: &[u8], offset: u64) -> ChunkData {
ChunkData {
sha: vec![sha; 20],
crc: steam_adler_hash(data),
offset,
cb_original: data.len() as u32,
cb_compressed: data.len() as u32 + 64,
}
}
#[test]
fn writes_in_place_dedupes_chunks_and_resumes_from_disk() {
let dir = std::env::temp_dir().join(format!(
"droiddeck_steam_write_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let key = [3u8; 32];
let manifest = ContentManifest {
files: vec![
FileMapping {
filename: "bin".into(),
flags: DEPOT_FILE_FLAG_DIRECTORY,
..Default::default()
},
FileMapping {
filename: "bin/game.exe".into(),
size: 10,
flags: DEPOT_FILE_FLAG_EXECUTABLE,
chunks: vec![chunk(1, b"hello", 0), chunk(2, b"world", 5)],
..Default::default()
},
FileMapping {
filename: "data/copy.bin".into(),
size: 5,
chunks: vec![chunk(2, b"world", 0)],
..Default::default()
},
FileMapping {
filename: "empty.txt".into(),
..Default::default()
},
],
..Default::default()
};
let request = DepotWriteRequest {
manifest: &manifest,
depot_key: &key,
servers: &[],
target_dir: &dir,
ca_bundle_path: "",
max_workers: 4,
process_workers: 2,
};
let cancel = AtomicBool::new(false);
let prepared = prepare(&request, &cancel).unwrap();
assert_eq!(prepared.total, 15);
assert_eq!(prepared.bytes_verified, 0);
assert_eq!(prepared.chunks.len(), 2);
assert_eq!(prepared.chunks[1].targets.len(), 2);
assert!(dir.join("bin").is_dir());
assert_eq!(fs::metadata(dir.join("empty.txt")).unwrap().len(), 0);
let sink = ChunkSink {
chunks: &prepared.chunks,
files: &prepared.files,
depot_key: &key,
};
let item = |id: u64| FetchItem {
id,
urls: vec!["x".into()],
reserve: 0,
range: None,
};
assert!(matches!(
sink.process(&item(0), b"garbage-garbage-garbage-garbage!".to_vec()),
Err(SinkError::Retry(_))
));
assert_eq!(
sink.process(&item(1), encrypted_chunk(&key, b"world"))
.unwrap(),
10
);
assert_eq!(fs::read(dir.join("data/copy.bin")).unwrap(), b"world");
assert_eq!(
sink.process(&item(0), encrypted_chunk(&key, b"hello"))
.unwrap(),
5
);
assert_eq!(fs::read(dir.join("bin/game.exe")).unwrap(), b"helloworld");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = fs::metadata(dir.join("bin/game.exe"))
.unwrap()
.permissions()
.mode();
assert_eq!(mode & 0o777, 0o755);
}
drop(prepared);
// A resumed run reads back what is on disk and fetches only what is wrong or missing.
fs::write(dir.join("bin/game.exe"), b"helloWORLD").unwrap();
let again = prepare(&request, &cancel).unwrap();
assert_eq!(again.bytes_verified, 10);
assert_eq!(again.chunks.len(), 1);
assert_eq!(
again.chunks[0].targets,
vec![Target {
file_idx: 1,
offset: 5
}]
);
let _ = fs::remove_dir_all(&dir);
}
}
+102
View File
@@ -0,0 +1,102 @@
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
#[repr(transparent)]
pub struct EMsg(pub u32);
impl EMsg {
pub const INVALID: Self = Self(0);
pub const MULTI: Self = Self(1);
pub const CHANNEL_ENCRYPT_REQUEST: Self = Self(1303);
pub const CHANNEL_ENCRYPT_RESPONSE: Self = Self(1304);
pub const CHANNEL_ENCRYPT_RESULT: Self = Self(1305);
pub const CLIENT_HELLO: Self = Self(9805);
pub const CLIENT_LOGON: Self = Self(5514);
pub const CLIENT_LOGON_RESPONSE: Self = Self(751);
pub const CLIENT_LOG_OFF: Self = Self(706);
pub const CLIENT_LOGGED_OFF: Self = Self(757);
pub const CLIENT_HEART_BEAT: Self = Self(703);
pub const CLIENT_SESSION_TOKEN: Self = Self(850);
pub const CLIENT_SERVER_UNAVAILABLE: Self = Self(5500);
pub const CLIENT_LICENSE_LIST: Self = Self(780);
/// Free/F2P/demo license grant (verified against JavaSteam `EMsg.java`).
pub const CLIENT_REQUEST_FREE_LICENSE: Self = Self(5572);
pub const CLIENT_REQUEST_FREE_LICENSE_RESPONSE: Self = Self(5573);
pub const CLIENT_PICS_PRODUCT_INFO_REQUEST: Self = Self(8903);
pub const CLIENT_PICS_PRODUCT_INFO_RESPONSE: Self = Self(8904);
pub const CLIENT_PICS_ACCESS_TOKEN_REQUEST: Self = Self(8905);
pub const CLIENT_PICS_ACCESS_TOKEN_RESPONSE: Self = Self(8906);
pub const CLIENT_GET_DEPOT_DECRYPTION_KEY: Self = Self(5438);
pub const CLIENT_GET_DEPOT_DECRYPTION_KEY_RESPONSE: Self = Self(5439);
pub const SERVICE_METHOD: Self = Self(146);
pub const SERVICE_METHOD_CALL_FROM_CLIENT: Self = Self(151);
pub const SERVICE_METHOD_RESPONSE: Self = Self(147);
pub const SERVICE_METHOD_SEND_TO_CLIENT: Self = Self(152);
pub const SERVICE_METHOD_CALL_FROM_CLIENT_NON_AUTHED: Self = Self(9804);
}
pub const EMSG_PROTO_FLAG: u32 = 0x8000_0000;
pub const EMSG_MASK: u32 = 0x7fff_ffff;
pub const fn has_proto_flag(raw: u32) -> bool {
(raw & EMSG_PROTO_FLAG) != 0
}
pub const fn strip_proto_flag(raw: u32) -> EMsg {
EMsg(raw & EMSG_MASK)
}
pub const fn with_proto_flag(msg: EMsg) -> u32 {
msg.0 | EMSG_PROTO_FLAG
}
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
#[repr(u32)]
pub enum EUniverse {
#[default]
Invalid = 0,
Public = 1,
Beta = 2,
Internal = 3,
Dev = 4,
Max = 5,
}
impl EUniverse {
pub fn from_u32(v: u32) -> Option<Self> {
match v {
1 => Some(Self::Public),
2 => Some(Self::Beta),
3 => Some(Self::Internal),
4 => Some(Self::Dev),
5 => Some(Self::Max),
_ => None,
}
}
pub fn is_valid_universe(self) -> bool {
matches!(self, Self::Public | Self::Beta | Self::Internal | Self::Dev)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn universe_values_match_steam_enum() {
assert_eq!(EUniverse::Invalid as u32, 0);
assert_eq!(EUniverse::Public as u32, 1);
assert_eq!(EUniverse::Beta as u32, 2);
assert_eq!(EUniverse::Internal as u32, 3);
assert_eq!(EUniverse::Dev as u32, 4);
assert_eq!(EUniverse::Max as u32, 5);
assert!(!EUniverse::Max.is_valid_universe());
assert!(EUniverse::Public.is_valid_universe());
}
#[test]
fn free_license_emsgs_match_steamkit() {
// JavaSteam EMsg.java: ClientRequestFreeLicense(5572) / ...Response(5573).
assert_eq!(EMsg::CLIENT_REQUEST_FREE_LICENSE.0, 5572);
assert_eq!(EMsg::CLIENT_REQUEST_FREE_LICENSE_RESPONSE.0, 5573);
}
}
@@ -0,0 +1,466 @@
use crate::steam::crypto::{
aes256_cbc_decrypt, aes256_cbc_encrypt, aes256_ecb_decrypt_block, aes256_ecb_encrypt_block,
hmac_sha1, secure_random_bytes, AesBlock, SecureSessionKey, SessionKey, AES_BLOCK_BYTES,
HMAC_KEY_LENGTH,
};
use crate::steam::transport::{Transport, TransportDisconnectReason};
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::{Arc, Mutex};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum ChannelState {
Disconnected,
Connected,
Challenged,
Encrypted,
Closing,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum ChannelDisconnectReason {
UserInitiated,
TransportError,
HandshakeProtocolError,
HandshakeFailed,
EnvelopeDecryptFailed,
HmacMismatch,
}
type MessageCallback = Box<dyn Fn(&[u8]) + Send + Sync + 'static>;
type ConnectedCallback = Box<dyn Fn() + Send + Sync + 'static>;
type DisconnectedCallback = Box<dyn Fn(ChannelDisconnectReason, &str) + Send + Sync + 'static>;
pub struct EncryptedChannel {
inner: Arc<EncryptedChannelInner>,
transport: Mutex<Box<dyn Transport>>,
}
struct EncryptedChannelInner {
state: AtomicU8,
on_message: Mutex<Option<MessageCallback>>,
on_connected: Mutex<Option<ConnectedCallback>>,
on_disconnected: Mutex<Option<DisconnectedCallback>>,
}
impl Default for EncryptedChannelInner {
fn default() -> Self {
Self {
state: AtomicU8::new(ChannelState::Disconnected as u8),
on_message: Mutex::new(None),
on_connected: Mutex::new(None),
on_disconnected: Mutex::new(None),
}
}
}
impl EncryptedChannel {
pub fn new(mut transport: Box<dyn Transport>) -> Self {
let inner = Arc::new(EncryptedChannelInner::default());
let weak = Arc::downgrade(&inner);
transport.set_on_connected(Box::new(move || {
if let Some(inner) = weak.upgrade() {
inner
.state
.store(ChannelState::Encrypted as u8, Ordering::Release);
if let Some(callback) = inner
.on_connected
.lock()
.expect("encrypted channel callback poisoned")
.as_ref()
{
callback();
}
}
}));
let weak = Arc::downgrade(&inner);
transport.set_on_disconnected(Box::new(move |reason, detail| {
if let Some(inner) = weak.upgrade() {
inner
.state
.store(ChannelState::Disconnected as u8, Ordering::Release);
let reason = match reason {
TransportDisconnectReason::UserInitiated => {
ChannelDisconnectReason::UserInitiated
}
_ => ChannelDisconnectReason::TransportError,
};
if let Some(callback) = inner
.on_disconnected
.lock()
.expect("encrypted channel callback poisoned")
.as_ref()
{
callback(reason, detail);
}
}
}));
let weak = Arc::downgrade(&inner);
transport.set_on_message(Box::new(move |bytes| {
if let Some(inner) = weak.upgrade() {
if inner.state() != ChannelState::Encrypted {
return;
}
if let Some(callback) = inner
.on_message
.lock()
.expect("encrypted channel callback poisoned")
.as_ref()
{
callback(bytes);
}
}
}));
Self {
inner,
transport: Mutex::new(transport),
}
}
pub fn connect(&self, url: &str) -> bool {
if self
.inner
.state
.compare_exchange(
ChannelState::Disconnected as u8,
ChannelState::Connected as u8,
Ordering::AcqRel,
Ordering::Acquire,
)
.is_err()
{
return false;
}
if !self
.transport
.lock()
.expect("encrypted channel transport poisoned")
.connect(url)
{
self.inner
.state
.store(ChannelState::Disconnected as u8, Ordering::Release);
return false;
}
true
}
pub fn send(&self, plaintext: &[u8]) -> bool {
if self.state() != ChannelState::Encrypted {
return false;
}
self.transport
.lock()
.expect("encrypted channel transport poisoned")
.send(plaintext)
}
pub fn disconnect(&self) {
if self.state() == ChannelState::Disconnected {
return;
}
self.inner
.state
.store(ChannelState::Closing as u8, Ordering::Release);
self.transport
.lock()
.expect("encrypted channel transport poisoned")
.disconnect();
}
pub fn state(&self) -> ChannelState {
self.inner.state()
}
pub fn set_ca_bundle_path(&self, path: &str) {
self.transport
.lock()
.expect("encrypted channel transport poisoned")
.set_ca_bundle_path(path);
}
pub fn set_on_message<F>(&self, callback: F)
where
F: Fn(&[u8]) + Send + Sync + 'static,
{
*self
.inner
.on_message
.lock()
.expect("encrypted channel callback poisoned") = Some(Box::new(callback));
}
pub fn set_on_connected<F>(&self, callback: F)
where
F: Fn() + Send + Sync + 'static,
{
*self
.inner
.on_connected
.lock()
.expect("encrypted channel callback poisoned") = Some(Box::new(callback));
}
pub fn set_on_disconnected<F>(&self, callback: F)
where
F: Fn(ChannelDisconnectReason, &str) + Send + Sync + 'static,
{
*self
.inner
.on_disconnected
.lock()
.expect("encrypted channel callback poisoned") = Some(Box::new(callback));
}
}
impl Drop for EncryptedChannel {
fn drop(&mut self) {
self.disconnect();
}
}
impl EncryptedChannelInner {
fn state(&self) -> ChannelState {
match self.state.load(Ordering::Acquire) {
1 => ChannelState::Connected,
2 => ChannelState::Challenged,
3 => ChannelState::Encrypted,
4 => ChannelState::Closing,
_ => ChannelState::Disconnected,
}
}
}
#[derive(Clone)]
pub struct EncryptedEnvelope {
session_key: SecureSessionKey,
hmac_key: [u8; HMAC_KEY_LENGTH],
}
impl EncryptedEnvelope {
pub fn new(session_key: SessionKey) -> Self {
let mut hmac_key = [0u8; HMAC_KEY_LENGTH];
hmac_key.copy_from_slice(&session_key[..HMAC_KEY_LENGTH]);
Self {
session_key: SecureSessionKey::new(session_key),
hmac_key,
}
}
pub fn encrypt(&self, plaintext: &[u8]) -> Option<Vec<u8>> {
let mut random_iv = [0u8; AES_BLOCK_BYTES - 4];
if !secure_random_bytes(&mut random_iv) {
return None;
}
self.encrypt_with_random_iv(plaintext, random_iv)
}
fn encrypt_with_random_iv(
&self,
plaintext: &[u8],
random_iv: [u8; AES_BLOCK_BYTES - 4],
) -> Option<Vec<u8>> {
let mut hmac_input = Vec::with_capacity(random_iv.len() + plaintext.len());
hmac_input.extend_from_slice(&random_iv);
hmac_input.extend_from_slice(plaintext);
let hmac = hmac_sha1(&self.hmac_key, &hmac_input)?;
let mut iv_plaintext = [0u8; AES_BLOCK_BYTES];
iv_plaintext[..4].copy_from_slice(&hmac[..4]);
iv_plaintext[4..].copy_from_slice(&random_iv);
let iv_ciphertext = aes256_ecb_encrypt_block(&self.session_key.bytes, &iv_plaintext)?;
let body = aes256_cbc_encrypt(&self.session_key.bytes, &iv_plaintext, plaintext)?;
let mut out = Vec::with_capacity(AES_BLOCK_BYTES + body.len());
out.extend_from_slice(&iv_ciphertext);
out.extend_from_slice(&body);
Some(out)
}
pub fn decrypt(&self, wire: &[u8]) -> Option<Vec<u8>> {
if wire.len() < AES_BLOCK_BYTES * 2 {
return None;
}
let iv_ciphertext: AesBlock = wire[..AES_BLOCK_BYTES].try_into().ok()?;
let iv_plaintext = aes256_ecb_decrypt_block(&self.session_key.bytes, &iv_ciphertext)?;
let plaintext = aes256_cbc_decrypt(
&self.session_key.bytes,
&iv_plaintext,
&wire[AES_BLOCK_BYTES..],
)?;
let mut hmac_input = Vec::with_capacity((AES_BLOCK_BYTES - 4) + plaintext.len());
hmac_input.extend_from_slice(&iv_plaintext[4..]);
hmac_input.extend_from_slice(&plaintext);
let expected = hmac_sha1(&self.hmac_key, &hmac_input)?;
ct_equal(&iv_plaintext[..4], &expected[..4]).then_some(plaintext)
}
}
fn ct_equal(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut diff = 0u8;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::transport::TransportState;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
#[test]
fn envelope_roundtrips_with_fixed_iv() {
let key = [7u8; 32];
let env = EncryptedEnvelope::new(key);
let encrypted = env
.encrypt_with_random_iv(b"hello steam", [3u8; AES_BLOCK_BYTES - 4])
.unwrap();
assert_ne!(encrypted, b"hello steam");
assert_eq!(env.decrypt(&encrypted).unwrap(), b"hello steam");
}
#[test]
fn envelope_rejects_hmac_mismatch() {
let env = EncryptedEnvelope::new([7u8; 32]);
let mut encrypted = env
.encrypt_with_random_iv(b"hello steam", [3u8; AES_BLOCK_BYTES - 4])
.unwrap();
let last = encrypted.last_mut().unwrap();
*last ^= 0x55;
assert!(env.decrypt(&encrypted).is_none());
}
#[test]
fn websocket_channel_skips_app_layer_handshake() {
let shared = Arc::new(MockTransportState::default());
let channel = EncryptedChannel::new(Box::new(MockTransport {
shared: Arc::clone(&shared),
}));
let connected = Arc::new(AtomicBool::new(false));
let connected_cb = Arc::clone(&connected);
let (tx, rx) = mpsc::channel();
channel.set_on_connected(move || {
connected_cb.store(true, Ordering::SeqCst);
});
channel.set_on_message(move |bytes| {
tx.send(bytes.to_vec()).unwrap();
});
assert!(channel.connect("wss://cm.example.com:443/cmsocket/"));
assert_eq!(channel.state(), ChannelState::Connected);
shared.fire_connected();
assert_eq!(channel.state(), ChannelState::Encrypted);
assert!(connected.load(Ordering::SeqCst));
assert!(channel.send(b"client hello"));
assert_eq!(shared.sent.lock().unwrap()[0], b"client hello");
shared.fire_message(b"server frame");
assert_eq!(rx.recv().unwrap(), b"server frame");
}
#[test]
fn channel_maps_transport_disconnect_reasons() {
let shared = Arc::new(MockTransportState::default());
let channel = EncryptedChannel::new(Box::new(MockTransport {
shared: Arc::clone(&shared),
}));
let (tx, rx) = mpsc::channel();
channel.set_on_disconnected(move |reason, detail| {
tx.send((reason, detail.to_string())).unwrap();
});
assert!(channel.connect("wss://cm.example.com:443/cmsocket/"));
shared.fire_connected();
shared.fire_disconnected(TransportDisconnectReason::NetworkError, "net down");
assert_eq!(
rx.recv().unwrap(),
(
ChannelDisconnectReason::TransportError,
"net down".to_string()
)
);
assert_eq!(channel.state(), ChannelState::Disconnected);
}
#[derive(Default)]
struct MockTransportState {
connected: Mutex<Option<crate::steam::transport::ConnectedCallback>>,
disconnected: Mutex<Option<crate::steam::transport::DisconnectedCallback>>,
message: Mutex<Option<crate::steam::transport::MessageCallback>>,
sent: Mutex<Vec<Vec<u8>>>,
ca_bundle_path: Mutex<String>,
}
impl MockTransportState {
fn fire_connected(&self) {
if let Some(callback) = self.connected.lock().unwrap().as_ref() {
callback();
}
}
fn fire_disconnected(&self, reason: TransportDisconnectReason, detail: &str) {
if let Some(callback) = self.disconnected.lock().unwrap().as_ref() {
callback(reason, detail);
}
}
fn fire_message(&self, bytes: &[u8]) {
if let Some(callback) = self.message.lock().unwrap().as_ref() {
callback(bytes);
}
}
}
struct MockTransport {
shared: Arc<MockTransportState>,
}
impl Transport for MockTransport {
fn connect(&mut self, _url: &str) -> bool {
true
}
fn send(&mut self, data: &[u8]) -> bool {
self.shared.sent.lock().unwrap().push(data.to_vec());
true
}
fn disconnect(&mut self) {}
fn state(&self) -> TransportState {
TransportState::Connected
}
fn set_on_message(&mut self, cb: Box<dyn Fn(&[u8]) + Send + Sync>) {
*self.shared.message.lock().unwrap() = Some(cb);
}
fn set_on_connected(&mut self, cb: Box<dyn Fn() + Send + Sync>) {
*self.shared.connected.lock().unwrap() = Some(cb);
}
fn set_on_disconnected(
&mut self,
cb: Box<dyn Fn(TransportDisconnectReason, &str) + Send + Sync>,
) {
*self.shared.disconnected.lock().unwrap() = Some(cb);
}
fn set_ca_bundle_path(&mut self, path: &str) {
*self.shared.ca_bundle_path.lock().unwrap() = path.to_string();
}
}
}
@@ -0,0 +1,192 @@
use crate::steam::emsg::{has_proto_flag, strip_proto_flag, EMsg, EUniverse};
use crate::steam::wire_format;
pub const INVALID_JOB_ID: u64 = u64::MAX;
pub const MSG_HDR_BYTES: usize = 20;
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct MsgHdr {
pub msg: EMsg,
pub target_job_id: u64,
pub source_job_id: u64,
}
impl Default for MsgHdr {
fn default() -> Self {
Self {
msg: EMsg::INVALID,
target_job_id: INVALID_JOB_ID,
source_job_id: INVALID_JOB_ID,
}
}
}
impl MsgHdr {
pub fn serialize(&self, out: &mut Vec<u8>) {
let mut writer = wire_format::Writer::new(out);
writer.u32(self.msg.0);
writer.u64(self.target_job_id);
writer.u64(self.source_job_id);
}
pub fn deserialize(input: &[u8]) -> Option<(Self, usize)> {
if input.len() < MSG_HDR_BYTES {
return None;
}
let mut reader = wire_format::Reader::new(&input[..MSG_HDR_BYTES]);
let raw_msg = reader.u32();
if has_proto_flag(raw_msg) {
return None;
}
let hdr = Self {
msg: strip_proto_flag(raw_msg),
target_job_id: reader.u64(),
source_job_id: reader.u64(),
};
reader.ok().then_some((hdr, MSG_HDR_BYTES))
}
}
pub const CHANNEL_ENCRYPT_PROTOCOL_VERSION: u32 = 1;
pub const CHANNEL_ENCRYPT_REQUEST_FIXED_BODY: usize = 8;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MsgChannelEncryptRequest {
pub protocol_version: u32,
pub universe: EUniverse,
pub challenge: Vec<u8>,
}
impl Default for MsgChannelEncryptRequest {
fn default() -> Self {
Self {
protocol_version: CHANNEL_ENCRYPT_PROTOCOL_VERSION,
universe: EUniverse::Invalid,
challenge: Vec::new(),
}
}
}
impl MsgChannelEncryptRequest {
pub fn deserialize_body(body: &[u8]) -> Option<Self> {
if body.len() < CHANNEL_ENCRYPT_REQUEST_FIXED_BODY {
return None;
}
let mut reader = wire_format::Reader::new(body);
let protocol_version = reader.u32();
let universe = EUniverse::from_u32(reader.u32())?;
if !reader.ok() {
return None;
}
let challenge = body[CHANNEL_ENCRYPT_REQUEST_FIXED_BODY..].to_vec();
Some(Self {
protocol_version,
universe,
challenge,
})
}
}
pub const RSA_1024_CIPHER_BYTES: usize = 128;
pub const CHANNEL_ENCRYPT_RESPONSE_BODY_BYTES: usize = 144;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MsgChannelEncryptResponse {
pub protocol_version: u32,
pub key_size: u32,
pub encrypted_handshake_blob: [u8; RSA_1024_CIPHER_BYTES],
pub key_crc: u32,
pub unknown_zero: u32,
}
impl Default for MsgChannelEncryptResponse {
fn default() -> Self {
Self {
protocol_version: CHANNEL_ENCRYPT_PROTOCOL_VERSION,
key_size: RSA_1024_CIPHER_BYTES as u32,
encrypted_handshake_blob: [0; RSA_1024_CIPHER_BYTES],
key_crc: 0,
unknown_zero: 0,
}
}
}
impl MsgChannelEncryptResponse {
pub fn serialize_body(&self, out: &mut Vec<u8>) {
let mut writer = wire_format::Writer::new(out);
writer.u32(self.protocol_version);
writer.u32(self.key_size);
writer.bytes(&self.encrypted_handshake_blob);
writer.u32(self.key_crc);
writer.u32(self.unknown_zero);
}
}
pub const CHANNEL_ENCRYPT_RESULT_BODY_BYTES: usize = 4;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct MsgChannelEncryptResult {
pub result: u32,
}
impl MsgChannelEncryptResult {
pub fn deserialize_body(body: &[u8]) -> Option<Self> {
if body.len() < CHANNEL_ENCRYPT_RESULT_BODY_BYTES {
return None;
}
let mut reader = wire_format::Reader::new(body);
let result = reader.u32();
reader.ok().then_some(Self { result })
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::emsg::with_proto_flag;
#[test]
fn msg_hdr_roundtrips_and_rejects_proto_flag() {
let hdr = MsgHdr {
msg: EMsg::CHANNEL_ENCRYPT_REQUEST,
target_job_id: 7,
source_job_id: 9,
};
let mut bytes = Vec::new();
hdr.serialize(&mut bytes);
assert_eq!(bytes.len(), MSG_HDR_BYTES);
assert_eq!(MsgHdr::deserialize(&bytes), Some((hdr, MSG_HDR_BYTES)));
bytes[..4].copy_from_slice(&with_proto_flag(EMsg::CHANNEL_ENCRYPT_REQUEST).to_le_bytes());
assert_eq!(MsgHdr::deserialize(&bytes), None);
}
#[test]
fn channel_encrypt_request_parses_challenge() {
let mut body = Vec::new();
let mut writer = wire_format::Writer::new(&mut body);
writer.u32(1);
writer.u32(EUniverse::Public as u32);
writer.bytes(&[0xaa; 16]);
let msg = MsgChannelEncryptRequest::deserialize_body(&body).unwrap();
assert_eq!(msg.protocol_version, 1);
assert_eq!(msg.universe, EUniverse::Public);
assert_eq!(msg.challenge, vec![0xaa; 16]);
}
#[test]
fn channel_encrypt_response_is_144_bytes() {
let msg = MsgChannelEncryptResponse {
key_crc: 0xfeed_beef,
..Default::default()
};
let mut body = Vec::new();
msg.serialize_body(&mut body);
assert_eq!(body.len(), CHANNEL_ENCRYPT_RESPONSE_BODY_BYTES);
assert_eq!(&body[0..4], &1u32.to_le_bytes());
assert_eq!(
&body[8 + RSA_1024_CIPHER_BYTES..12 + RSA_1024_CIPHER_BYTES],
&0xfeed_beefu32.to_le_bytes()
);
}
}
@@ -0,0 +1,126 @@
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Condvar, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use std::{panic, panic::AssertUnwindSafe};
#[derive(Default)]
pub struct Heartbeat {
running: Arc<AtomicBool>,
stop: Arc<(Mutex<bool>, Condvar)>,
worker: Option<JoinHandle<()>>,
}
impl Heartbeat {
pub fn start<F>(&mut self, interval: Duration, cb: F) -> bool
where
F: Fn() + Send + 'static,
{
if interval.is_zero() {
return false;
}
self.stop();
self.running.store(true, Ordering::Relaxed);
{
let (mu, _) = &*self.stop;
*mu.lock().expect("heartbeat poisoned") = false;
}
let running = Arc::clone(&self.running);
let stop = Arc::clone(&self.stop);
self.worker = Some(thread::spawn(move || run_loop(interval, cb, running, stop)));
true
}
pub fn stop(&mut self) {
if !self.running.load(Ordering::Relaxed) {
return;
}
let (mu, cv) = &*self.stop;
*mu.lock().expect("heartbeat poisoned") = true;
cv.notify_all();
if let Some(worker) = self.worker.take() {
let _ = worker.join();
}
self.running.store(false, Ordering::Relaxed);
}
pub fn running(&self) -> bool {
self.running.load(Ordering::Relaxed)
}
}
impl Drop for Heartbeat {
fn drop(&mut self) {
self.stop();
}
}
fn run_loop<F>(
interval: Duration,
cb: F,
running: Arc<AtomicBool>,
stop: Arc<(Mutex<bool>, Condvar)>,
) where
F: Fn() + Send + 'static,
{
let (mu, cv) = &*stop;
loop {
let guard = mu.lock().expect("heartbeat poisoned");
let (guard, _) = cv
.wait_timeout_while(guard, interval, |stop_requested| !*stop_requested)
.expect("heartbeat poisoned");
if *guard {
return;
}
drop(guard);
let _ = panic::catch_unwind(AssertUnwindSafe(&cb));
if !running.load(Ordering::Relaxed) {
return;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
#[test]
fn rejects_zero_interval() {
let mut hb = Heartbeat::default();
assert!(!hb.start(Duration::ZERO, || {}));
assert!(!hb.running());
}
#[test]
fn ticks_and_stops() {
let ticks = Arc::new(AtomicUsize::new(0));
let tick_copy = Arc::clone(&ticks);
let mut hb = Heartbeat::default();
assert!(hb.start(Duration::from_millis(10), move || {
tick_copy.fetch_add(1, Ordering::Relaxed);
}));
thread::sleep(Duration::from_millis(35));
hb.stop();
assert!(ticks.load(Ordering::Relaxed) > 0);
assert!(!hb.running());
}
#[test]
fn callback_panic_does_not_stop_worker() {
let ticks = Arc::new(AtomicUsize::new(0));
let tick_copy = Arc::clone(&ticks);
let (tx, rx) = std::sync::mpsc::channel();
let mut hb = Heartbeat::default();
assert!(hb.start(Duration::from_millis(10), move || {
let n = tick_copy.fetch_add(1, Ordering::Relaxed);
if n == 0 {
panic!("first heartbeat panic");
}
tx.send(()).unwrap();
}));
rx.recv_timeout(Duration::from_secs(1)).unwrap();
hb.stop();
assert!(ticks.load(Ordering::Relaxed) > 1);
}
}
@@ -0,0 +1,56 @@
//! One-shot HTTPS GET for the few non-chunk requests (CM directory, manifests, HTTP-delivered
//! appinfo). Chunk downloads go through the shared fetch core instead.
use std::fs;
use std::time::Duration;
pub const USER_AGENT: &str = crate::fetch_tuning::USER_AGENT;
pub struct Response {
pub status: u16,
pub content_length: Option<u64>,
pub body: Vec<u8>,
}
pub fn get(url: &str, timeout: Duration, ca_bundle_path: &str) -> Result<Response, String> {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|err| format!("runtime: {err}"))?;
runtime.block_on(get_async(url, timeout, ca_bundle_path))
}
async fn get_async(url: &str, timeout: Duration, ca_bundle_path: &str) -> Result<Response, String> {
let mut builder = reqwest::Client::builder()
.user_agent(USER_AGENT)
.connect_timeout(crate::fetch_tuning::connect_timeout())
.timeout(timeout);
if !ca_bundle_path.is_empty() {
let pem = fs::read(ca_bundle_path).map_err(|err| format!("read CA bundle: {err}"))?;
let certs = reqwest::Certificate::from_pem_bundle(&pem)
.map_err(|err| format!("parse CA bundle: {err}"))?;
for cert in certs {
builder = builder.add_root_certificate(cert);
}
}
let client = builder
.build()
.map_err(|err| format!("http client: {err}"))?;
let response = client
.get(url)
.send()
.await
.map_err(|err| format!("http get: {}", err.without_url()))?;
let status = response.status().as_u16();
let content_length = response.content_length();
let body = response
.bytes()
.await
.map_err(|err| format!("http body: {}", err.without_url()))?
.to_vec();
Ok(Response {
status,
content_length,
body,
})
}
@@ -0,0 +1,411 @@
//! One `nativeStart` run: plan, take over a half-finished client download, download the game's
//! depots into its library folder, install missing shared depots into their app's folder, then
//! register everything the way the Steam client does. The resume journal lives in the
//! caller-given journal directory and is removed once the game is registered.
use crate::steam::depot_config::{app_journal_dir, DepotConfigStore};
use crate::steam::depot_downloader::{download_prepared, prepare_depot, DepotError, PreparedDepot};
use crate::steam::pb::ccontentserverdirectory::CContentServerDirectoryServerInfo;
use crate::steam::plan::AppPlan;
use crate::steam::register::{self, InstalledDepot, LibraryRoot, SharedInstall, Takeover};
use crate::steam::session::Session;
use serde_json::{json, Value};
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Mutex;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
pub const PHASE_PREPARING: &str = "preparing";
pub const PHASE_DOWNLOADING: &str = "downloading";
pub const PHASE_SHARED: &str = "shared";
pub const PHASE_REGISTERING: &str = "registering";
pub const DEFAULT_MAX_WORKERS: usize = 16;
const PROGRESS_INTERVAL: Duration = Duration::from_millis(250);
pub struct StartRequest {
pub app_id: u32,
pub language: String,
pub steam_root: PathBuf,
pub game_library: LibraryRoot,
pub libraries: Vec<LibraryRoot>,
pub journal_dir: PathBuf,
pub ca_bundle_path: String,
pub max_workers: usize,
pub process_workers: usize,
}
/// Decode/write threads when the caller passes 0: half the cores, between 2 and 6.
pub fn default_process_workers() -> usize {
std::thread::available_parallelism()
.map(|n| n.get() / 2)
.unwrap_or(2)
.clamp(2, 6)
}
pub trait Events: Sync {
fn progress(&self, done: u64, total: u64, phase: &str);
}
fn fail(error: impl Into<String>) -> Value {
json!({"ok": false, "error": error.into()})
}
fn now_unix() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
}
/// The app's plan with shared depots resolved. An app the account does not own is refused,
/// except a free one: `request_free_license` asks Steam for its license first (an install), else
/// it is planned as is (sizes for the UI).
pub fn build_plan(
session: &Session,
app_id: u32,
language: &str,
request_free_license: bool,
) -> Result<AppPlan, String> {
let appinfo = session
.app_info(app_id)
.ok_or_else(|| "appinfo unavailable".to_string())?;
let mut library = session.library()?;
if !library.owns(app_id) {
if !crate::steam::plan::is_free(&appinfo) {
return Err("not_owned".to_string());
}
if request_free_license {
if !session.request_free_license(app_id) {
return Err("free_license_refused".to_string());
}
library = session.library()?;
if !library.owns(app_id) {
return Err("not_owned".to_string());
}
}
}
let mut plan = crate::steam::plan::plan_app(app_id, &appinfo, &library.owned_apps, language)?;
crate::steam::plan::resolve_shared(&mut plan, &|from| session.app_info(from));
Ok(plan)
}
struct Progress<'a> {
events: &'a dyn Events,
total: AtomicU64,
base: AtomicU64,
phase: Mutex<&'static str>,
last: Mutex<Instant>,
}
impl<'a> Progress<'a> {
fn new(events: &'a dyn Events) -> Self {
Self {
events,
total: AtomicU64::new(0),
base: AtomicU64::new(0),
phase: Mutex::new(PHASE_PREPARING),
last: Mutex::new(Instant::now() - PROGRESS_INTERVAL),
}
}
fn phase(&self, phase: &'static str) {
*self.phase.lock().expect("phase poisoned") = phase;
self.emit(self.base.load(Ordering::Relaxed), true);
}
fn emit(&self, done: u64, force: bool) {
{
let mut last = self.last.lock().expect("progress poisoned");
if !force && last.elapsed() < PROGRESS_INTERVAL {
return;
}
*last = Instant::now();
}
let phase = *self.phase.lock().expect("phase poisoned");
let total = self.total.load(Ordering::Relaxed);
self.events.progress(done, total, phase);
}
/// Progress inside one depot: `done` bytes of it on top of what earlier depots finished.
fn depot(&self, done: u64) {
self.emit(self.base.load(Ordering::Relaxed) + done, false);
}
fn finish_depot(&self, bytes: u64) {
self.base.fetch_add(bytes, Ordering::Relaxed);
self.emit(self.base.load(Ordering::Relaxed), true);
}
}
fn servers_for(
servers: &[CContentServerDirectoryServerInfo],
app_id: u32,
) -> Vec<CContentServerDirectoryServerInfo> {
servers
.iter()
.filter(|s| s.allowed_app_ids.is_empty() || s.allowed_app_ids.contains(&app_id))
.cloned()
.collect()
}
pub fn run(
session: &Session,
req: &StartRequest,
cancel: &AtomicBool,
events: &dyn Events,
) -> Value {
let progress = Progress::new(events);
progress.phase(PHASE_PREPARING);
let log = |line: &str| crate::steam::log(line);
let cancelled = || cancel.load(Ordering::Relaxed);
let plan = match build_plan(session, req.app_id, &req.language, true) {
Ok(plan) => plan,
Err(err) => return fail(err),
};
if cancelled() {
return fail("cancelled");
}
let takeover = match register::takeover(&req.game_library, req.app_id, plan.build_id) {
Ok(t) => t,
Err(err) => return fail(format!("takeover: {err}")),
};
log(&format!(
"start app={} build={} depots={} shared={} takeover={takeover:?}",
req.app_id,
plan.build_id,
plan.depots.len(),
plan.shared.len()
));
if takeover == Takeover::AlreadyInstalled {
return json!({"ok": true, "alreadyInstalled": true});
}
if !register::library_registered(&req.steam_root, &req.game_library.guest) {
return fail("library_not_in_libraryfolders");
}
let mut journal =
DepotConfigStore::load(app_journal_dir(&req.journal_dir, req.app_id), plan.build_id);
if takeover == Takeover::TookOver {
journal.discard();
}
let Some(all_servers) = session.cdn_servers() else {
return fail("CDN server request failed");
};
let game_servers = servers_for(&all_servers, req.app_id);
let mut game_depots: Vec<(PreparedDepot, u32)> = Vec::new();
for depot in &plan.depots {
match prepare_depot(
session,
&game_servers,
Some(&journal),
&req.ca_bundle_path,
req.app_id,
depot.depot_id,
depot.manifest_id,
cancel,
) {
Ok(prepared) => game_depots.push((prepared, depot.dlc_app_id)),
Err(DepotError::AccessDenied(id)) if depot.dlc_app_id != 0 => {
log(&format!("skipping DLC depot {id}: access denied"));
}
Err(err) => return fail(err.message()),
}
}
let mut shared_jobs: Vec<(PreparedDepot, SharedInstall)> = Vec::new();
let mut shared_present: Vec<(u32, u32)> = Vec::new();
for shared in &plan.shared {
let library =
register::shared_app_library(shared.from_app_id, &req.steam_root, &req.libraries);
let installed = crate::steam::kv::parse_file(&library.acf_path(shared.from_app_id))
.and_then(|acf| register::installed_manifest(&acf, shared.depot_id));
if installed == Some(shared.manifest_id) {
shared_present.push((shared.depot_id, shared.from_app_id));
continue;
}
let servers = servers_for(&all_servers, shared.from_app_id);
let prepared = match prepare_depot(
session,
&servers,
Some(&journal),
&req.ca_bundle_path,
shared.from_app_id,
shared.depot_id,
shared.manifest_id,
cancel,
) {
Ok(p) => p,
Err(DepotError::AccessDenied(id)) => {
log(&format!("skipping shared depot {id}: access denied"));
continue;
}
Err(err) => return fail(err.message()),
};
let install = SharedInstall {
depot_id: shared.depot_id,
from_app_id: shared.from_app_id,
from_name: shared.from_name.clone(),
from_install_dir: shared.from_install_dir.clone(),
from_build_id: shared.from_build_id,
manifest_id: shared.manifest_id,
size: prepared.manifest.metadata.cb_disk_original.max(shared.size),
install_script: register::install_script_path(&prepared.manifest),
library,
};
shared_jobs.push((prepared, install));
}
let depot_bytes =
|p: &PreparedDepot| crate::steam::depot_writer::depot_total_bytes(&p.manifest);
let total: u64 = game_depots.iter().map(|(p, _)| depot_bytes(p)).sum::<u64>()
+ shared_jobs.iter().map(|(p, _)| depot_bytes(p)).sum::<u64>();
progress.total.store(total, Ordering::Relaxed);
let max_workers = if req.max_workers == 0 {
DEFAULT_MAX_WORKERS
} else {
req.max_workers
};
let process_workers = if req.process_workers == 0 {
default_process_workers()
} else {
req.process_workers
};
let ca = req.ca_bundle_path.as_str();
progress.phase(PHASE_DOWNLOADING);
let game_dir = req.game_library.common_dir(&plan.install_dir);
for (prepared, _) in &game_depots {
if journal.is_installed(prepared.depot_id, prepared.manifest_id) {
progress.finish_depot(depot_bytes(prepared));
continue;
}
if cancelled() {
return fail("cancelled");
}
journal.begin_depot(prepared.depot_id);
let outcome = download_prepared(
prepared,
&game_servers,
&game_dir,
ca,
max_workers,
process_workers,
cancel,
&|done| progress.depot(done),
&log,
);
if outcome.cancelled {
return fail("cancelled");
}
if let Some(err) = outcome.error {
return fail(format!("depot {}: {err}", prepared.depot_id));
}
journal.finish_depot(prepared.depot_id, prepared.manifest_id);
progress.finish_depot(depot_bytes(prepared));
}
progress.phase(PHASE_SHARED);
for (prepared, install) in &shared_jobs {
if cancelled() {
return fail("cancelled");
}
let servers = servers_for(&all_servers, install.from_app_id);
let target = install.library.common_dir(&install.from_install_dir);
if !journal.is_installed(prepared.depot_id, prepared.manifest_id) {
journal.begin_depot(prepared.depot_id);
let outcome = download_prepared(
prepared,
&servers,
&target,
ca,
max_workers,
process_workers,
cancel,
&|done| progress.depot(done),
&log,
);
if outcome.cancelled {
return fail("cancelled");
}
if let Some(err) = outcome.error {
return fail(format!("shared depot {}: {err}", prepared.depot_id));
}
journal.finish_depot(prepared.depot_id, prepared.manifest_id);
}
progress.finish_depot(depot_bytes(prepared));
}
progress.phase(PHASE_REGISTERING);
let now = now_unix();
let owner = session.steam_id;
for (_, install) in &shared_jobs {
if let Err(err) = register::register_shared_depot(install, owner, now) {
return fail(format!("register shared depot: {err}"));
}
if let Err(err) = register::update_libraryfolders(
&req.steam_root,
&install.library.guest,
install.from_app_id,
true,
) {
return fail(format!("libraryfolders: {err}"));
}
}
let installed: Vec<InstalledDepot> = game_depots
.iter()
.map(|(p, dlc)| InstalledDepot {
depot_id: p.depot_id,
manifest_id: p.manifest_id,
size: p.manifest.metadata.cb_disk_original,
dlc_app_id: *dlc,
})
.collect();
let scripts: Vec<(u32, String)> = game_depots
.iter()
.filter_map(|(p, _)| register::install_script_path(&p.manifest).map(|s| (p.depot_id, s)))
.collect();
let mut shared_list: Vec<(u32, u32)> = shared_jobs
.iter()
.map(|(_, s)| (s.depot_id, s.from_app_id))
.collect();
shared_list.extend(shared_present);
shared_list.sort_unstable();
let downloaded = game_depots
.iter()
.map(|(p, _)| p.manifest.metadata.cb_disk_compressed)
.sum::<u64>()
+ shared_jobs
.iter()
.map(|(p, _)| p.manifest.metadata.cb_disk_compressed)
.sum::<u64>();
let staged = installed.iter().map(|d| d.size).sum::<u64>()
+ shared_jobs.iter().map(|(_, s)| s.size).sum::<u64>();
let registration = register::GameRegistration {
plan: &plan,
owner_steam_id: owner,
depots: &installed,
shared: &shared_list,
install_scripts: &scripts,
bytes_downloaded: downloaded,
bytes_staged: staged,
now,
};
if let Err(err) = register::write_game_acf(&req.game_library, &registration) {
return fail(format!("app manifest: {err}"));
}
if let Err(err) =
register::update_libraryfolders(&req.steam_root, &req.game_library.guest, req.app_id, true)
{
return fail(format!("libraryfolders: {err}"));
}
journal.discard();
progress.emit(total, true);
log(&format!(
"installed app={} build={} bytes={total} downloaded={downloaded}",
req.app_id, plan.build_id
));
json!({"ok": true, "alreadyInstalled": false})
}
+446
View File
@@ -0,0 +1,446 @@
//! JNI surface of the Steam store: `com.droiddeck.launcher.stores.steam.SteamNative`
//! (see `JNI.md`). Every answer is a JSON object with `"ok"`; failures carry `"error"`.
use crate::steam::install::{self, Events, StartRequest};
use crate::steam::register::{self, LibraryRoot};
use crate::steam::session;
use crate::steam::signin;
use jni::objects::{GlobalRef, JClass, JObject, JString, JValue};
use jni::sys::{jint, jlong, jstring, JNI_FALSE, JNI_TRUE};
use jni::{JNIEnv, JavaVM};
use serde_json::{json, Value};
use std::collections::HashSet;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::thread;
static RUNNING: Mutex<Option<HashSet<u32>>> = Mutex::new(None);
fn jstring_to_string(env: &mut JNIEnv, value: &JString) -> String {
if value.is_null() {
return String::new();
}
env.get_string(value)
.map(|s| s.to_string_lossy().into_owned())
.unwrap_or_default()
}
fn answer(env: &mut JNIEnv, value: Value) -> jstring {
env.new_string(value.to_string())
.map(|s| s.into_raw())
.unwrap_or(std::ptr::null_mut())
}
fn error(message: impl Into<String>) -> Value {
json!({"ok": false, "error": message.into()})
}
/// Runs `f`, turning a panic into an `internal_error` answer.
fn guarded(f: impl FnOnce() -> Value) -> Value {
catch_unwind(AssertUnwindSafe(f)).unwrap_or_else(|_| error("internal_error"))
}
fn parse_string_array(text: &str) -> Vec<PathBuf> {
serde_json::from_str::<Value>(text)
.ok()
.and_then(|v| v.as_array().cloned())
.unwrap_or_default()
.iter()
.filter_map(|v| v.as_str())
.filter(|s| !s.is_empty())
.map(PathBuf::from)
.collect()
}
pub fn parse_library_roots(text: &str) -> Vec<LibraryRoot> {
serde_json::from_str::<Value>(text)
.ok()
.and_then(|v| v.as_array().cloned())
.unwrap_or_default()
.iter()
.filter_map(|v| {
let host = v.get("host")?.as_str()?;
let guest = v.get("guest")?.as_str()?;
(!host.is_empty()).then(|| LibraryRoot {
host: PathBuf::from(host),
guest: guest.to_string(),
})
})
.collect()
}
/// All libraries, with the game library first when the list misses it.
fn libraries_with(game: &LibraryRoot, mut libraries: Vec<LibraryRoot>) -> Vec<LibraryRoot> {
if !libraries.iter().any(|l| l.host == game.host) {
libraries.insert(0, game.clone());
}
libraries
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeSignIn(
mut env: JNIEnv,
_class: JClass,
steam_roots_json: JString,
registry_vdf_path: JString,
ca_bundle_path: JString,
) -> jstring {
let roots = parse_string_array(&jstring_to_string(&mut env, &steam_roots_json));
let registry = jstring_to_string(&mut env, &registry_vdf_path);
let ca = jstring_to_string(&mut env, &ca_bundle_path);
let value = guarded(|| {
if let Some(live) = session::current() {
return json!({"ok": true, "account": live.account, "steamId": live.steam_id.to_string()});
}
let registry = (!registry.is_empty()).then(|| Path::new(&registry));
let login = match signin::load_saved_login(&roots, registry) {
Ok(login) => login,
Err(err) => {
crate::steam::log(&format!("sign-in: {}", err.code()));
return error(err.code());
}
};
match session::sign_in(&login, &ca) {
Ok(live) => {
json!({"ok": true, "account": live.account, "steamId": live.steam_id.to_string()})
}
Err(err) => error(err),
}
});
answer(&mut env, value)
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeSignOut(
_env: JNIEnv,
_class: JClass,
) {
let _ = catch_unwind(session::sign_out);
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeLibrary(
mut env: JNIEnv,
_class: JClass,
) -> jstring {
let value = guarded(|| {
let Some(live) = session::current() else {
return error("not_signed_in");
};
match live.games() {
Ok(games) => crate::steam::library::games_json(&games),
Err(err) => error(err),
}
});
answer(&mut env, value)
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativePlan(
mut env: JNIEnv,
_class: JClass,
app_id: jint,
language: JString,
) -> jstring {
let language = jstring_to_string(&mut env, &language);
let value = guarded(|| {
let Some(live) = session::current() else {
return error("not_signed_in");
};
if app_id <= 0 {
return error("bad app id");
}
match install::build_plan(&live, app_id as u32, &language, false) {
Ok(plan) => plan.to_json(),
Err(err) => error(err),
}
});
answer(&mut env, value)
}
pub struct SteamRunHandle {
pub cancel: Arc<AtomicBool>,
}
struct JniEvents {
vm: JavaVM,
listener: GlobalRef,
}
impl JniEvents {
fn with_env(&self, f: impl FnOnce(&mut JNIEnv)) {
let Ok(mut env) = self.vm.attach_current_thread_as_daemon() else {
return;
};
f(&mut env);
if env.exception_check().unwrap_or(false) {
let _ = env.exception_clear();
}
}
fn complete(&self, result: &Value) {
let ok = result.get("ok").and_then(Value::as_bool).unwrap_or(false);
let text = result.to_string();
self.with_env(|env| {
let Ok(text) = env.new_string(&text) else {
return;
};
let text = JObject::from(text);
let _ = env.call_method(
self.listener.as_obj(),
"onComplete",
"(ZLjava/lang/String;)V",
&[
JValue::Bool(if ok { JNI_TRUE } else { JNI_FALSE }),
JValue::Object(&text),
],
);
let _ = env.delete_local_ref(text);
});
}
}
impl Events for JniEvents {
fn progress(&self, done: u64, total: u64, phase: &str) {
self.with_env(|env| {
let Ok(phase) = env.new_string(phase) else {
return;
};
let phase = JObject::from(phase);
let _ = env.call_method(
self.listener.as_obj(),
"onProgress",
"(JJLjava/lang/String;)V",
&[
JValue::Long(done as jlong),
JValue::Long(total as jlong),
JValue::Object(&phase),
],
);
let _ = env.delete_local_ref(phase);
});
}
}
fn claim(app_id: u32) -> bool {
let mut guard = RUNNING.lock().expect("running poisoned");
guard.get_or_insert_with(HashSet::new).insert(app_id)
}
fn release_claim(app_id: u32) {
if let Some(set) = RUNNING.lock().expect("running poisoned").as_mut() {
set.remove(&app_id);
}
}
#[no_mangle]
#[allow(clippy::too_many_arguments)]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeStart(
mut env: JNIEnv,
_class: JClass,
app_id: jint,
language: JString,
steam_root: JString,
game_library_host: JString,
game_library_guest: JString,
library_roots_json: JString,
journal_dir: JString,
ca_bundle_path: JString,
max_workers: jint,
process_workers: jint,
listener: JObject,
) -> jlong {
if listener.is_null() || app_id <= 0 {
crate::steam::log("nativeStart: null listener or bad app id");
return 0;
}
let Ok(vm) = env.get_java_vm() else {
return 0;
};
let Ok(listener) = env.new_global_ref(&listener) else {
return 0;
};
let game_library = LibraryRoot {
host: PathBuf::from(jstring_to_string(&mut env, &game_library_host)),
guest: jstring_to_string(&mut env, &game_library_guest),
};
let libraries = parse_library_roots(&jstring_to_string(&mut env, &library_roots_json));
let request = StartRequest {
app_id: app_id as u32,
language: jstring_to_string(&mut env, &language),
steam_root: PathBuf::from(jstring_to_string(&mut env, &steam_root)),
libraries: libraries_with(&game_library, libraries),
game_library,
journal_dir: PathBuf::from(jstring_to_string(&mut env, &journal_dir)),
ca_bundle_path: jstring_to_string(&mut env, &ca_bundle_path),
max_workers: max_workers.max(0) as usize,
process_workers: process_workers.max(0) as usize,
};
if request.steam_root.as_os_str().is_empty()
|| request.game_library.host.as_os_str().is_empty()
|| request.game_library.guest.is_empty()
|| request.journal_dir.as_os_str().is_empty()
{
crate::steam::log("nativeStart: empty path argument");
return 0;
}
let cancel = Arc::new(AtomicBool::new(false));
let handle = SteamRunHandle {
cancel: Arc::clone(&cancel),
};
let spawned = thread::Builder::new()
.name("steam-dl".to_string())
.spawn(move || {
crate::priority::background();
let events = JniEvents { vm, listener };
let result = if !claim(request.app_id) {
error("already_running")
} else {
let result = guarded(|| match session::current() {
Some(live) => install::run(&live, &request, &cancel, &events),
None => error("not_signed_in"),
});
release_claim(request.app_id);
result
};
crate::steam::log(&format!("run app={} result={result}", request.app_id));
events.complete(&result);
});
if spawned.is_err() {
crate::steam::log("nativeStart: worker thread spawn failed");
return 0;
}
Box::into_raw(Box::new(handle)) as jlong
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeCancel(
_env: JNIEnv,
_class: JClass,
handle: jlong,
) {
let ptr = handle as *const SteamRunHandle;
if let Some(run) = unsafe { ptr.as_ref() } {
run.cancel.store(true, Ordering::Relaxed);
}
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeRelease(
_env: JNIEnv,
_class: JClass,
handle: jlong,
) {
let ptr = handle as *mut SteamRunHandle;
if !ptr.is_null() {
unsafe { drop(Box::from_raw(ptr)) };
}
}
/// The file list of a shared depot for uninstall: the client's `depotcache` copy of the manifest
/// (it stores decrypted file names), else the manifest from the CDN through the live session.
fn shared_depot_files(
steam_root: &Path,
from_app: u32,
depot_id: u32,
manifest_id: u64,
) -> Option<Vec<String>> {
let cached = steam_root
.join("depotcache")
.join(format!("{depot_id}_{manifest_id}.manifest"));
if let Some(mut manifest) = std::fs::read(&cached)
.ok()
.and_then(|raw| crate::steam::content_manifest::ContentManifest::parse(&raw))
{
if !manifest.metadata.filenames_encrypted && manifest.decrypt_filenames(&[]) {
return Some(register::manifest_file_list(&manifest));
}
}
let live = session::current()?;
let servers = live.cdn_servers()?;
let ca = live.ca_bundle_path.clone();
let prepared = crate::steam::depot_downloader::prepare_depot(
&live,
&servers,
None,
&ca,
from_app,
depot_id,
manifest_id,
&AtomicBool::new(false),
)
.ok()?;
Some(register::manifest_file_list(&prepared.manifest))
}
#[no_mangle]
pub extern "system" fn Java_com_droiddeck_launcher_stores_steam_SteamNative_nativeUninstall(
mut env: JNIEnv,
_class: JClass,
app_id: jint,
steam_root: JString,
game_library_host: JString,
game_library_guest: JString,
library_roots_json: JString,
) -> jstring {
let steam_root = PathBuf::from(jstring_to_string(&mut env, &steam_root));
let game_library = LibraryRoot {
host: PathBuf::from(jstring_to_string(&mut env, &game_library_host)),
guest: jstring_to_string(&mut env, &game_library_guest),
};
let libraries = libraries_with(
&game_library,
parse_library_roots(&jstring_to_string(&mut env, &library_roots_json)),
);
let value = guarded(|| {
if app_id <= 0 || steam_root.as_os_str().is_empty() {
return error("bad arguments");
}
let root = steam_root.clone();
let files = move |from_app: u32, depot: u32, manifest: u64| {
shared_depot_files(&root, from_app, depot, manifest)
};
match register::uninstall(
app_id as u32,
&steam_root,
&game_library,
&libraries,
&files,
) {
Ok(report) => json!({
"ok": true,
"removedShared": report.removed_shared,
"keptShared": report.kept_shared,
}),
Err(err) => error(err),
}
});
answer(&mut env, value)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_library_roots_and_keeps_the_game_library() {
let libs = parse_library_roots(
r#"[{"host":"/data/Steam","guest":"/root/.local/share/Steam"},{"host":"","guest":"x"},{"guest":"y"}]"#,
);
assert_eq!(libs.len(), 1);
let game = LibraryRoot {
host: "/sd/steam".into(),
guest: "/mnt/droiddeck-sd".into(),
};
let all = libraries_with(&game, libs);
assert_eq!(all[0], game);
assert_eq!(all.len(), 2);
assert_eq!(
parse_string_array(r#"["/a", "", 3, "/b"]"#),
vec![PathBuf::from("/a"), PathBuf::from("/b")]
);
assert!(parse_library_roots("not json").is_empty());
}
}
@@ -0,0 +1,255 @@
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Condvar, Mutex};
use std::thread::{self, JoinHandle};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use std::{panic, panic::AssertUnwindSafe};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct JobResult {
pub eresult: i32,
pub error_message: String,
pub body: Vec<u8>,
pub synthetic_failure: bool,
}
impl Default for JobResult {
fn default() -> Self {
Self {
eresult: 2,
error_message: String::new(),
body: Vec::new(),
synthetic_failure: false,
}
}
}
type JobContinuation = Box<dyn FnOnce(JobResult) + Send + 'static>;
struct Entry {
cb: JobContinuation,
deadline: Instant,
}
#[derive(Default)]
struct Pending {
jobs: HashMap<u64, Entry>,
}
pub struct JobManager {
next_counter: AtomicU64,
process_epoch: u64,
default_timeout: Duration,
pending: Arc<(Mutex<Pending>, Condvar)>,
stop: Arc<AtomicBool>,
timeout_thread: Option<JoinHandle<()>>,
}
impl JobManager {
pub fn new(default_timeout: Duration) -> Self {
let pending = Arc::new((Mutex::new(Pending::default()), Condvar::new()));
let stop = Arc::new(AtomicBool::new(false));
let thread_pending = Arc::clone(&pending);
let thread_stop = Arc::clone(&stop);
let timeout_thread = thread::spawn(move || timeout_loop(thread_pending, thread_stop));
Self {
next_counter: AtomicU64::new(1),
process_epoch: make_process_epoch(),
default_timeout,
pending,
stop,
timeout_thread: Some(timeout_thread),
}
}
pub fn next_job_id(&self) -> u64 {
let lo = self.next_counter.fetch_add(1, Ordering::Relaxed);
((self.process_epoch & 0xFF_FFFF) << 40) | (lo & 0xFF_FFFF_FFFF)
}
pub fn track<F>(&self, job_id: u64, cb: F, timeout: Option<Duration>)
where
F: FnOnce(JobResult) + Send + 'static,
{
let timeout = timeout.unwrap_or(self.default_timeout);
let (mu, cv) = &*self.pending;
let mut pending = mu.lock().expect("job manager poisoned");
pending.jobs.insert(
job_id,
Entry {
cb: Box::new(cb),
deadline: Instant::now() + timeout,
},
);
cv.notify_all();
}
pub fn deliver(
&self,
job_id_target: u64,
mut eresult: i32,
error_message: String,
body: &[u8],
) {
let cb = {
let (mu, _) = &*self.pending;
let mut pending = mu.lock().expect("job manager poisoned");
pending.jobs.remove(&job_id_target).map(|entry| entry.cb)
};
if let Some(cb) = cb {
if eresult == -1 {
eresult = 1;
}
invoke_continuation(
cb,
JobResult {
eresult,
error_message,
body: body.to_vec(),
synthetic_failure: false,
},
);
}
}
pub fn fail_all(&self, reason: &str) {
let drained = {
let (mu, _) = &*self.pending;
let mut pending = mu.lock().expect("job manager poisoned");
std::mem::take(&mut pending.jobs)
};
for (_, entry) in drained {
invoke_continuation(
entry.cb,
JobResult {
eresult: -1,
error_message: reason.to_string(),
body: Vec::new(),
synthetic_failure: true,
},
);
}
}
}
impl Default for JobManager {
fn default() -> Self {
Self::new(Duration::from_secs(30))
}
}
impl Drop for JobManager {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
self.pending.1.notify_all();
if let Some(handle) = self.timeout_thread.take() {
let _ = handle.join();
}
self.fail_all("JobManager shutting down");
}
}
fn timeout_loop(pending: Arc<(Mutex<Pending>, Condvar)>, stop: Arc<AtomicBool>) {
let (mu, cv) = &*pending;
loop {
let mut guard = mu.lock().expect("job manager poisoned");
while guard.jobs.is_empty() && !stop.load(Ordering::Relaxed) {
guard = cv.wait(guard).expect("job manager poisoned");
}
if stop.load(Ordering::Relaxed) {
return;
}
let earliest = guard
.jobs
.values()
.map(|entry| entry.deadline)
.min()
.unwrap_or_else(Instant::now);
let now = Instant::now();
if earliest > now {
let (g, _) = cv
.wait_timeout(guard, earliest - now)
.expect("job manager poisoned");
guard = g;
}
if stop.load(Ordering::Relaxed) {
return;
}
let now = Instant::now();
let expired_ids: Vec<u64> = guard
.jobs
.iter()
.filter_map(|(id, entry)| (entry.deadline <= now).then_some(*id))
.collect();
let expired: Vec<Entry> = expired_ids
.into_iter()
.filter_map(|id| guard.jobs.remove(&id))
.collect();
drop(guard);
for entry in expired {
invoke_continuation(
entry.cb,
JobResult {
eresult: -1,
error_message: "job timeout".to_string(),
body: Vec::new(),
synthetic_failure: true,
},
);
}
}
}
fn invoke_continuation(cb: JobContinuation, result: JobResult) {
let _ = panic::catch_unwind(AssertUnwindSafe(|| cb(result)));
}
fn make_process_epoch() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::mpsc;
#[test]
fn deliver_maps_missing_eresult_to_ok() {
let jm = JobManager::new(Duration::from_secs(30));
let id = jm.next_job_id();
let (tx, rx) = mpsc::channel();
jm.track(id, move |result| tx.send(result).unwrap(), None);
jm.deliver(id, -1, String::new(), b"body");
let result = rx.recv_timeout(Duration::from_secs(1)).unwrap();
assert_eq!(result.eresult, 1);
assert_eq!(result.body, b"body");
}
#[test]
fn timeout_fails_jobs_synthetically() {
let jm = JobManager::new(Duration::from_millis(20));
let id = jm.next_job_id();
let (tx, rx) = mpsc::channel();
jm.track(id, move |result| tx.send(result).unwrap(), None);
let result = rx.recv_timeout(Duration::from_secs(2)).unwrap();
assert!(result.synthetic_failure);
assert_eq!(result.error_message, "job timeout");
}
#[test]
fn continuation_panic_is_caught() {
let jm = JobManager::new(Duration::from_secs(30));
let id = jm.next_job_id();
jm.track(
id,
|_| {
panic!("continuation panic");
},
None,
);
jm.deliver(id, 1, String::new(), b"body");
}
}
@@ -0,0 +1,91 @@
use crate::steam::emsg::EUniverse;
pub const PUBLIC_UNIVERSE_KEY: [u8; 160] = [
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xDF, 0xEC, 0x1A,
0xD6, 0x2C, 0x10, 0x66, 0x2C, 0x17, 0x35, 0x3A, 0x14, 0xB0, 0x7C, 0x59, 0x11, 0x7F, 0x9D, 0xD3,
0xD8, 0x2B, 0x7A, 0xE3, 0xE0, 0x15, 0xCD, 0x19, 0x1E, 0x46, 0xE8, 0x7B, 0x87, 0x74, 0xA2, 0x18,
0x46, 0x31, 0xA9, 0x03, 0x14, 0x79, 0x82, 0x8E, 0xE9, 0x45, 0xA2, 0x49, 0x12, 0xA9, 0x23, 0x68,
0x73, 0x89, 0xCF, 0x69, 0xA1, 0xB1, 0x61, 0x46, 0xBD, 0xC1, 0xBE, 0xBF, 0xD6, 0x01, 0x1B, 0xD8,
0x81, 0xD4, 0xDC, 0x90, 0xFB, 0xFE, 0x4F, 0x52, 0x73, 0x66, 0xCB, 0x95, 0x70, 0xD7, 0xC5, 0x8E,
0xBA, 0x1C, 0x7A, 0x33, 0x75, 0xA1, 0x62, 0x34, 0x46, 0xBB, 0x60, 0xB7, 0x80, 0x68, 0xFA, 0x13,
0xA7, 0x7A, 0x8A, 0x37, 0x4B, 0x9E, 0xC6, 0xF4, 0x5D, 0x5F, 0x3A, 0x99, 0xF9, 0x9E, 0xC4, 0x3A,
0xE9, 0x63, 0xA2, 0xBB, 0x88, 0x19, 0x28, 0xE0, 0xE7, 0x14, 0xC0, 0x42, 0x89, 0x02, 0x01, 0x11,
];
pub const BETA_UNIVERSE_KEY: [u8; 160] = [
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xAE, 0xD1, 0x4B,
0xC0, 0xA3, 0x36, 0x8B, 0xA0, 0x39, 0x0B, 0x43, 0xDC, 0xED, 0x6A, 0xC8, 0xF2, 0xA3, 0xE4, 0x7E,
0x09, 0x8C, 0x55, 0x2E, 0xE7, 0xE9, 0x3C, 0xBB, 0xE5, 0x5E, 0x0F, 0x18, 0x74, 0x54, 0x8F, 0xF3,
0xBD, 0x56, 0x69, 0x5B, 0x13, 0x09, 0xAF, 0xC8, 0xBE, 0xB3, 0xA1, 0x48, 0x69, 0xE9, 0x83, 0x49,
0x65, 0x8D, 0xD2, 0x93, 0x21, 0x2F, 0xB9, 0x1E, 0xFA, 0x74, 0x3B, 0x55, 0x22, 0x79, 0xBF, 0x85,
0x18, 0xCB, 0x6D, 0x52, 0x44, 0x4E, 0x05, 0x92, 0x89, 0x6A, 0xA8, 0x99, 0xED, 0x44, 0xAE, 0xE2,
0x66, 0x46, 0x42, 0x0C, 0xFB, 0x6E, 0x4C, 0x30, 0xC6, 0x6C, 0x5C, 0x16, 0xFF, 0xBA, 0x9C, 0xB9,
0x78, 0x3F, 0x17, 0x4B, 0xCB, 0xC9, 0x01, 0x5D, 0x3E, 0x37, 0x70, 0xEC, 0x67, 0x5A, 0x33, 0x48,
0xF7, 0x46, 0xCE, 0x58, 0xAA, 0xEC, 0xD9, 0xFF, 0x4A, 0x78, 0x6C, 0x83, 0x4B, 0x02, 0x01, 0x11,
];
pub const INTERNAL_UNIVERSE_KEY: [u8; 160] = [
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xA8, 0xFE, 0x01,
0x3B, 0xB6, 0xD7, 0x21, 0x4B, 0x53, 0x23, 0x6F, 0xA1, 0xAB, 0x4E, 0xF1, 0x07, 0x30, 0xA7, 0xC6,
0x7E, 0x6A, 0x2C, 0xC2, 0x5D, 0x3A, 0xB8, 0x40, 0xCA, 0x59, 0x4D, 0x16, 0x2D, 0x74, 0xEB, 0x0E,
0x72, 0x46, 0x29, 0xF9, 0xDE, 0x9B, 0xCE, 0x4B, 0x8C, 0xD0, 0xCA, 0xF4, 0x08, 0x94, 0x46, 0xA5,
0x11, 0xAF, 0x3A, 0xCB, 0xB8, 0x4E, 0xDE, 0xC6, 0xD8, 0x85, 0x0A, 0x7D, 0xAA, 0x96, 0x0A, 0xEA,
0x7B, 0x51, 0xD6, 0x22, 0x62, 0x5C, 0x1E, 0x58, 0xD7, 0x46, 0x1E, 0x09, 0xAE, 0x43, 0xA7, 0xC4,
0x34, 0x69, 0xA2, 0xA5, 0xE8, 0x44, 0x76, 0x18, 0xE2, 0x3D, 0xB7, 0xC5, 0xA8, 0x96, 0xFD, 0xE5,
0xB4, 0x4B, 0xF8, 0x40, 0x12, 0xA6, 0x17, 0x4E, 0xC4, 0xC1, 0x60, 0x0E, 0xB0, 0xC2, 0xB8, 0x40,
0x4D, 0x9E, 0x76, 0x4C, 0x44, 0xF4, 0xFC, 0x6F, 0x14, 0x89, 0x73, 0xB4, 0x13, 0x02, 0x01, 0x11,
];
pub const DEV_UNIVERSE_KEY: [u8; 160] = [
0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
0x05, 0x00, 0x03, 0x81, 0x8B, 0x00, 0x30, 0x81, 0x87, 0x02, 0x81, 0x81, 0x00, 0xD0, 0x05, 0x2C,
0xE9, 0x80, 0x95, 0xCD, 0x30, 0x83, 0xA8, 0xE9, 0x25, 0x96, 0x63, 0xCE, 0xCC, 0x48, 0x5D, 0x5C,
0x52, 0x00, 0xDB, 0x1E, 0x78, 0xD7, 0x6A, 0x4C, 0x2C, 0xC8, 0x41, 0x8C, 0xCC, 0x87, 0x46, 0xFB,
0x1B, 0xC9, 0xE8, 0x6E, 0x4F, 0x7A, 0x6B, 0xC3, 0xE7, 0x0F, 0xD5, 0xA9, 0x5D, 0x6C, 0xD4, 0xEE,
0xA2, 0xCC, 0x80, 0x5A, 0xD3, 0xCE, 0x53, 0x59, 0xE6, 0x80, 0x91, 0xC4, 0xC0, 0xD5, 0xF0, 0x63,
0x23, 0x91, 0x69, 0x70, 0xC5, 0xBB, 0xBD, 0x05, 0xE2, 0x4F, 0x7D, 0x90, 0x12, 0xED, 0xAC, 0x4F,
0x86, 0x96, 0x3C, 0x89, 0xCC, 0x92, 0x15, 0x63, 0xCB, 0x57, 0x70, 0xB9, 0xC3, 0xAE, 0x08, 0x4F,
0xC8, 0x56, 0x16, 0xB0, 0x0C, 0xC6, 0xC8, 0x8A, 0x80, 0xD2, 0x37, 0xF7, 0x7F, 0xAB, 0x93, 0xBB,
0xE6, 0xDE, 0x95, 0x78, 0xB8, 0x11, 0xC9, 0xE5, 0x62, 0xAD, 0xBC, 0x0C, 0x87, 0x02, 0x01, 0x11,
];
pub fn get_universe_public_key(universe: EUniverse) -> &'static [u8] {
match universe {
EUniverse::Public => &PUBLIC_UNIVERSE_KEY,
EUniverse::Beta => &BETA_UNIVERSE_KEY,
EUniverse::Internal => &INTERNAL_UNIVERSE_KEY,
EUniverse::Dev => &DEV_UNIVERSE_KEY,
EUniverse::Invalid | EUniverse::Max => &[],
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn returns_keys_for_known_universes_only() {
assert_eq!(get_universe_public_key(EUniverse::Public).len(), 160);
assert_eq!(get_universe_public_key(EUniverse::Beta).len(), 160);
assert_eq!(get_universe_public_key(EUniverse::Internal).len(), 160);
assert_eq!(get_universe_public_key(EUniverse::Dev).len(), 160);
assert!(get_universe_public_key(EUniverse::Invalid).is_empty());
}
#[test]
fn keys_are_spki_rsa_with_exponent_17() {
for universe in [
EUniverse::Public,
EUniverse::Beta,
EUniverse::Internal,
EUniverse::Dev,
] {
let key = get_universe_public_key(universe);
assert_eq!(&key[..8], &[0x30, 0x81, 0x9D, 0x30, 0x0D, 0x06, 0x09, 0x2A]);
assert_eq!(&key[157..], &[0x02, 0x01, 0x11]);
}
}
}
+177
View File
@@ -0,0 +1,177 @@
//! Valve KeyValues text files (`.acf`, `libraryfolders.vdf`) as the Steam client writes them:
//! `"key"\t\t"value"`, tab indentation, `{`/`}` on their own lines, LF line endings, `\` and `"`
//! escaped. Parsing reuses `vdf::parse_text`, which keeps the file's key order, so a rewrite only
//! changes the keys that were set.
use crate::steam::vdf::{KVNode, KVValue};
use std::fs;
use std::path::Path;
pub fn parse_file(path: &Path) -> Option<KVNode> {
let bytes = fs::read(path).ok()?;
crate::steam::vdf::parse_text(&bytes)
}
pub fn escape(text: &str) -> String {
let mut out = String::with_capacity(text.len());
for c in text.chars() {
match c {
'\\' => out.push_str("\\\\"),
'"' => out.push_str("\\\""),
'\n' => out.push_str("\\n"),
'\t' => out.push_str("\\t"),
'\r' => out.push_str("\\r"),
other => out.push(other),
}
}
out
}
pub fn serialize(root: &KVNode) -> String {
let mut out = String::new();
write_node(&mut out, root, 0);
out
}
fn write_node(out: &mut String, node: &KVNode, depth: usize) {
let indent = "\t".repeat(depth);
if node.is_object() {
out.push_str(&format!("{indent}\"{}\"\n{indent}{{\n", escape(&node.name)));
for child in &node.children {
write_node(out, child, depth + 1);
}
out.push_str(&format!("{indent}}}\n"));
} else {
out.push_str(&format!(
"{indent}\"{}\"\t\t\"{}\"\n",
escape(&node.name),
escape(&node.as_string(""))
));
}
}
/// Writes `root` to `path` through a temp file in the same folder + rename.
pub fn write_file(path: &Path, root: &KVNode) -> Result<(), String> {
let text = serialize(root);
if crate::steam::depot_config::atomic_write_synced(path, text.as_bytes()) {
Ok(())
} else {
Err(format!("write '{}' failed", path.display()))
}
}
pub fn object(name: &str) -> KVNode {
KVNode::new(name)
}
pub fn string(name: &str, value: impl Into<String>) -> KVNode {
KVNode {
name: name.to_string(),
value: KVValue::String(value.into()),
children: Vec::new(),
}
}
pub fn get<'a>(node: &'a KVNode, key: &str) -> Option<&'a KVNode> {
node.child(key)
}
pub fn get_str(node: &KVNode, key: &str) -> Option<String> {
node.child(key)
.filter(|c| !c.is_object())
.map(|c| c.as_string(""))
}
pub fn get_u64(node: &KVNode, key: &str) -> u64 {
get_str(node, key)
.and_then(|v| v.trim().parse().ok())
.unwrap_or(0)
}
pub fn get_mut<'a>(node: &'a mut KVNode, key: &str) -> Option<&'a mut KVNode> {
node.children
.iter_mut()
.find(|c| c.name.eq_ignore_ascii_case(key))
}
/// Sets `key` to a string value, in place when present (keeping its position and spelling),
/// appended otherwise.
pub fn set(node: &mut KVNode, key: &str, value: impl Into<String>) {
let value = value.into();
match get_mut(node, key) {
Some(child) => {
child.value = KVValue::String(value);
child.children.clear();
}
None => node.children.push(string(key, value)),
}
}
/// The object child `key`, created (appended) when missing.
pub fn object_mut<'a>(node: &'a mut KVNode, key: &str) -> &'a mut KVNode {
let idx = match node
.children
.iter()
.position(|c| c.name.eq_ignore_ascii_case(key))
{
Some(idx) => {
if !node.children[idx].is_object() {
node.children[idx] = object(key);
}
idx
}
None => {
node.children.push(object(key));
node.children.len() - 1
}
};
&mut node.children[idx]
}
pub fn remove(node: &mut KVNode, key: &str) -> bool {
let before = node.children.len();
node.children.retain(|c| !c.name.eq_ignore_ascii_case(key));
before != node.children.len()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn writes_steam_layout_and_round_trips_escapes() {
let mut root = object("AppState");
set(&mut root, "appid", "228980");
let scripts = object_mut(&mut root, "InstallScripts");
set(
scripts,
"228988",
"_CommonRedist\\vcredist\\2019\\installscript.vdf",
);
object_mut(&mut root, "UserConfig");
let text = serialize(&root);
assert_eq!(
text,
"\"AppState\"\n{\n\t\"appid\"\t\t\"228980\"\n\t\"InstallScripts\"\n\t{\n\t\t\"228988\"\t\t\"_CommonRedist\\\\vcredist\\\\2019\\\\installscript.vdf\"\n\t}\n\t\"UserConfig\"\n\t{\n\t}\n}\n"
);
let parsed = crate::steam::vdf::parse_text(text.as_bytes()).unwrap();
assert_eq!(parsed, root);
}
#[test]
fn set_keeps_position_and_spelling_and_appends_new_keys() {
let mut root = crate::steam::vdf::parse_text(
b"\"AppState\"\n{\n\t\"Name\"\t\t\"a\"\n\t\"x\"\t\t\"1\"\n}\n",
)
.unwrap();
set(&mut root, "name", "b");
set(&mut root, "y", "2");
assert_eq!(
serialize(&root),
"\"AppState\"\n{\n\t\"Name\"\t\t\"b\"\n\t\"x\"\t\t\"1\"\n\t\"y\"\t\t\"2\"\n}\n"
);
assert!(remove(&mut root, "X"));
assert!(!remove(&mut root, "x"));
assert_eq!(get_u64(&root, "y"), 2);
}
}
@@ -0,0 +1,220 @@
//! The signed-in account's library: licenses → packages (PICS) → apps (PICS, with access
//! tokens). Only apps of type `game` are listed.
use crate::steam::pb::cmsg_client_pics::{PicsAppInfoReq, PicsPackageInfoReq};
use crate::steam::session::Session;
use crate::steam::vdf::{self, KVNode};
use serde_json::{json, Value};
use std::collections::{HashMap, HashSet};
const PACKAGE_BATCH: usize = 200;
const APP_BATCH: usize = 100;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Game {
pub app_id: u32,
pub name: String,
pub install_dir: String,
pub app_type: String,
pub free: bool,
}
#[derive(Clone, Debug, Default)]
pub struct Library {
/// Every app id the account's licenses grant (games, DLC, tools …).
pub owned_apps: HashSet<u32>,
games: Option<Vec<Game>>,
}
pub fn package_app_ids(buffer: &[u8]) -> Vec<u32> {
let Some((_id, root)) = vdf::parse_binary_package(buffer) else {
return Vec::new();
};
root.child("appids")
.map(|node| {
node.children
.iter()
.map(|c| c.as_uint(0) as u32)
.filter(|id| *id != 0)
.collect()
})
.unwrap_or_default()
}
/// A library entry for an app, or `None` when it is not a game.
pub fn game_from_appinfo(app_id: u32, appinfo: &KVNode) -> Option<Game> {
let info = crate::steam::plan::appinfo_root(appinfo);
let app_type = crate::steam::plan::app_type(info);
if !app_type.eq_ignore_ascii_case("game") {
return None;
}
let name = crate::steam::plan::app_name(info);
if name.is_empty() {
return None;
}
Some(Game {
app_id,
name,
install_dir: crate::steam::plan::app_install_dir(info),
app_type: app_type.to_ascii_lowercase(),
free: crate::steam::plan::is_free(info),
})
}
pub fn sort_games(games: &mut [Game]) {
games.sort_by(|a, b| {
a.name
.to_lowercase()
.cmp(&b.name.to_lowercase())
.then(a.app_id.cmp(&b.app_id))
});
}
pub fn games_json(games: &[Game]) -> Value {
json!({
"ok": true,
"games": games.iter().map(|g| json!({
"appId": g.app_id,
"name": g.name,
"installDir": g.install_dir,
"type": g.app_type,
"free": g.free,
})).collect::<Vec<_>>(),
})
}
impl Library {
/// Licenses → package PICS → owned app ids. Package 0 (the basic Steam license every account
/// has) is skipped.
pub fn load(session: &Session) -> Result<Library, String> {
let licenses = session
.core()
.license_list()
.ok_or_else(|| "no license list from Steam".to_string())?;
let mut tokens: HashMap<u32, u64> = HashMap::new();
for license in &licenses {
if license.package_id == 0 {
continue;
}
let entry = tokens.entry(license.package_id).or_insert(0);
if license.access_token != 0 {
*entry = license.access_token;
}
}
let mut package_ids: Vec<u32> = tokens.keys().copied().collect();
package_ids.sort_unstable();
let mut owned_apps = HashSet::new();
for batch in package_ids.chunks(PACKAGE_BATCH) {
let request = batch
.iter()
.map(|id| PicsPackageInfoReq {
packageid: *id,
access_token: tokens.get(id).copied().unwrap_or(0),
})
.collect();
let response = session
.pics_product_info(request, Vec::new())
.ok_or_else(|| "package info request failed".to_string())?;
for package in &response.packages {
owned_apps.extend(package_app_ids(&package.buffer));
}
}
crate::steam::log(&format!(
"library: licenses={} packages={} apps={}",
licenses.len(),
package_ids.len(),
owned_apps.len()
));
Ok(Library {
owned_apps,
games: None,
})
}
pub fn cached_games(&self) -> Option<Vec<Game>> {
self.games.clone()
}
pub fn owns(&self, app_id: u32) -> bool {
self.owned_apps.contains(&app_id)
}
/// App PICS for every owned app (access tokens first), filtered to games, sorted by name.
pub fn load_games(&self, session: &Session) -> Result<Vec<Game>, String> {
if let Some(games) = &self.games {
return Ok(games.clone());
}
let mut app_ids: Vec<u32> = self.owned_apps.iter().copied().collect();
app_ids.sort_unstable();
let mut tokens: HashMap<u32, u64> = HashMap::new();
for batch in app_ids.chunks(APP_BATCH * 5) {
if let Some(response) = session.pics_access_tokens(Vec::new(), batch.to_vec()) {
for token in response.app_access_tokens {
tokens.insert(token.appid, token.access_token);
}
}
}
let mut games = Vec::new();
for batch in app_ids.chunks(APP_BATCH) {
let request = batch
.iter()
.map(|id| PicsAppInfoReq {
appid: *id,
access_token: tokens.get(id).copied().unwrap_or(0),
only_public_obsolete: false,
})
.collect();
let response = session
.pics_product_info(Vec::new(), request)
.ok_or_else(|| "app info request failed".to_string())?;
for app in &response.apps {
if app.buffer.is_empty() {
continue;
}
let Some(root) = vdf::parse_auto(&app.buffer) else {
continue;
};
if let Some(game) = game_from_appinfo(app.appid, &root) {
games.push(game);
}
}
}
sort_games(&mut games);
Ok(games)
}
pub fn with_games(&self, games: Vec<Game>) -> Library {
Library {
owned_apps: self.owned_apps.clone(),
games: Some(games),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn keeps_games_only_and_sorts_by_name() {
let parse = |t: &str| vdf::parse_text(t.as_bytes()).unwrap();
let game = parse(
r#""appinfo" { "common" { "name" "brawlhalla" "type" "Game" "freetogame" "1" } "config" { "installdir" "Brawlhalla" } }"#,
);
let tool = parse(r#""appinfo" { "common" { "name" "Proton" "type" "Tool" } }"#);
let other = parse(r#""appinfo" { "common" { "name" "Alpha" "type" "game" } }"#);
assert!(game_from_appinfo(5, &tool).is_none());
let mut games = vec![
game_from_appinfo(291550, &game).unwrap(),
game_from_appinfo(10, &other).unwrap(),
];
sort_games(&mut games);
assert_eq!(games[0].name, "Alpha");
assert_eq!(games[1].install_dir, "Brawlhalla");
assert!(games[1].free);
let json = games_json(&games);
assert_eq!(json["games"][1]["appId"], 291550);
assert_eq!(json["games"][1]["type"], "game");
assert_eq!(json["games"][0]["free"], false);
}
}
+69
View File
@@ -0,0 +1,69 @@
//! Steam store: signs in with the Linux Steam client's saved login, downloads a game straight into
//! the client's library folder and registers it the way the client does. Derived from WinNative's
//! wn-steam-client (GPL-3.0-or-later); see `NOTICE.md` in this directory.
pub mod base64;
pub mod cdn;
pub mod cm_client;
pub mod cm_runtime;
pub mod cm_server;
pub mod cm_server_list;
pub mod cmsg_protobuf_header;
pub mod content_manifest;
pub mod crypto;
pub mod depot_chunk;
pub mod depot_config;
pub mod depot_downloader;
pub mod depot_writer;
pub mod emsg;
pub mod encrypted_channel;
pub mod handshake_messages;
pub mod heartbeat;
pub mod http;
pub mod install;
pub mod jni;
pub mod job_manager;
pub mod key_dictionary;
pub mod kv;
pub mod library;
pub mod pb;
pub mod plan;
pub mod proto_envelope;
pub mod proto_wire;
pub mod register;
pub mod session;
pub mod signin;
pub mod steam_directory;
pub mod transport;
pub mod vdf;
pub mod wire_format;
pub mod ws_connection;
pub const LOG_TAG: &str = "DroidDeckSteam";
#[cfg(target_os = "android")]
#[link(name = "log")]
unsafe extern "C" {
fn __android_log_write(prio: i32, tag: *const i8, text: *const i8) -> i32;
}
/// One line to logcat under [`LOG_TAG`]. Never pass a token or any other secret.
pub fn log(message: &str) {
#[cfg(target_os = "android")]
{
use std::ffi::CString;
let Ok(tag) = CString::new(LOG_TAG) else {
return;
};
let Ok(text) = CString::new(message.replace('\0', " ")) else {
return;
};
unsafe {
let _ = __android_log_write(4, tag.as_ptr().cast(), text.as_ptr().cast());
}
}
#[cfg(not(target_os = "android"))]
{
let _ = message;
}
}
@@ -0,0 +1,212 @@
use crate::steam::proto_wire::{Reader, WireType, Writer};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CContentServerDirectoryGetManifestRequestCodeRequest {
pub app_id: u32,
pub depot_id: u32,
pub manifest_id: u64,
pub app_branch: String,
pub branch_password_hash: String,
}
impl CContentServerDirectoryGetManifestRequestCodeRequest {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.app_id);
w.uint32_field(2, self.depot_id);
w.uint64_field(3, self.manifest_id);
w.string_field(4, &self.app_branch);
w.string_field(5, &self.branch_password_hash);
out
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CContentServerDirectoryGetManifestRequestCodeResponse {
pub manifest_request_code: u64,
}
impl CContentServerDirectoryGetManifestRequestCodeResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.manifest_request_code = reader.u64()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CContentServerDirectoryServerInfo {
pub server_type: String,
pub source_id: i32,
pub cell_id: i32,
pub load: i32,
pub weighted_load: f32,
pub num_entries_in_client_list: i32,
pub steam_china_only: bool,
pub host: String,
pub vhost: String,
pub use_as_proxy: bool,
pub proxy_request_path_template: String,
pub https_support: String,
pub allowed_app_ids: Vec<u32>,
pub priority_class: u32,
}
impl CContentServerDirectoryServerInfo {
pub fn use_https(&self) -> bool {
self.https_support.eq_ignore_ascii_case("mandatory")
}
pub fn port(&self) -> u16 {
if self.use_https() {
443
} else {
80
}
}
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.server_type = reader.string()?,
2 => msg.source_id = reader.i32()?,
3 => msg.cell_id = reader.i32()?,
4 => msg.load = reader.i32()?,
5 => msg.weighted_load = f32::from_bits(reader.fixed32()?),
6 => msg.num_entries_in_client_list = reader.i32()?,
7 => msg.steam_china_only = reader.boolean()?,
8 => msg.host = reader.string()?,
9 => msg.vhost = reader.string()?,
10 => msg.use_as_proxy = reader.boolean()?,
11 => msg.proxy_request_path_template = reader.string()?,
12 => msg.https_support = reader.string()?,
13 => match tag.wire_type {
WireType::LengthDelimited => {
let mut packed = Reader::new(reader.bytes()?);
while !packed.eof() {
msg.allowed_app_ids.push(packed.varint()? as u32);
}
}
_ => msg.allowed_app_ids.push(reader.u32()?),
},
15 => msg.priority_class = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CContentServerDirectoryGetServersForSteamPipeRequest {
pub cell_id: u32,
pub max_servers: u32,
}
impl Default for CContentServerDirectoryGetServersForSteamPipeRequest {
fn default() -> Self {
Self {
cell_id: 0,
max_servers: 20,
}
}
}
impl CContentServerDirectoryGetServersForSteamPipeRequest {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.cell_id);
w.uint32_field(2, self.max_servers);
out
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CContentServerDirectoryGetServersForSteamPipeResponse {
pub servers: Vec<CContentServerDirectoryServerInfo>,
pub no_change: bool,
}
impl CContentServerDirectoryGetServersForSteamPipeResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg
.servers
.push(CContentServerDirectoryServerInfo::deserialize(
reader.bytes()?,
)?),
2 => msg.no_change = reader.boolean()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_server_info_with_packed_and_unpacked_app_ids() {
let mut server = Vec::new();
{
let mut w = Writer::new(&mut server);
w.string_field(1, "SteamCache");
w.int32_field(2, 5);
w.int32_field(3, 6);
w.int32_field(4, 7);
w.tag(5, WireType::Fixed32);
w.raw_bytes(&1.25f32.to_bits().to_le_bytes());
w.bool_field(7, true);
w.string_field(8, "cache.example");
w.string_field(12, "MANDATORY");
w.uint32_field(13, 480);
let mut packed = Vec::new();
Writer::new(&mut packed).varint(730);
w.bytes_field(13, &packed);
w.uint32_field(15, 2);
}
let parsed = CContentServerDirectoryServerInfo::deserialize(&server).unwrap();
assert_eq!(parsed.server_type, "SteamCache");
assert_eq!(parsed.weighted_load, 1.25);
assert_eq!(parsed.allowed_app_ids, [480, 730]);
assert!(parsed.use_https());
assert_eq!(parsed.port(), 443);
}
}
@@ -0,0 +1,57 @@
use crate::steam::proto_wire::{Reader, Writer};
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientGetDepotDecryptionKey {
pub depot_id: u32,
pub app_id: u32,
}
impl CMsgClientGetDepotDecryptionKey {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.depot_id);
w.uint32_field(2, self.app_id);
out
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientGetDepotDecryptionKeyResponse {
pub eresult: u32,
pub depot_id: u32,
pub depot_encryption_key: Vec<u8>,
}
impl Default for CMsgClientGetDepotDecryptionKeyResponse {
fn default() -> Self {
Self {
eresult: 2,
depot_id: 0,
depot_encryption_key: Vec::new(),
}
}
}
impl CMsgClientGetDepotDecryptionKeyResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.eresult = reader.u32()?,
2 => msg.depot_id = reader.u32()?,
3 => msg.depot_encryption_key = reader.bytes()?.to_vec(),
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
@@ -0,0 +1,143 @@
use crate::steam::proto_wire::{Reader, WireType};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct License {
pub package_id: u32,
pub time_created: u32,
pub time_next_process: u32,
pub minute_limit: i32,
pub minutes_used: i32,
pub payment_method: u32,
pub flags: u32,
pub purchase_country_code: String,
pub license_type: u32,
pub territory_code: i32,
pub change_number: i32,
pub owner_id: u32,
pub initial_period: u32,
pub initial_time_unit: u32,
pub renewal_period: u32,
pub renewal_time_unit: u32,
pub access_token: u64,
pub master_package_id: u32,
}
impl License {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.package_id = reader.u32()?,
2 => {
if tag.wire_type != WireType::Fixed32 {
return None;
}
msg.time_created = reader.fixed32()?;
}
3 => {
if tag.wire_type != WireType::Fixed32 {
return None;
}
msg.time_next_process = reader.fixed32()?;
}
4 => msg.minute_limit = reader.i32()?,
5 => msg.minutes_used = reader.i32()?,
6 => msg.payment_method = reader.u32()?,
7 => msg.flags = reader.u32()?,
8 => msg.purchase_country_code = reader.string()?,
9 => msg.license_type = reader.u32()?,
10 => msg.territory_code = reader.i32()?,
11 => msg.change_number = reader.i32()?,
12 => msg.owner_id = reader.u32()?,
13 => msg.initial_period = reader.u32()?,
14 => msg.initial_time_unit = reader.u32()?,
15 => msg.renewal_period = reader.u32()?,
16 => msg.renewal_time_unit = reader.u32()?,
17 => msg.access_token = reader.u64()?,
18 => msg.master_package_id = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientLicenseList {
pub eresult: i32,
pub licenses: Vec<License>,
}
impl Default for CMsgClientLicenseList {
fn default() -> Self {
Self {
eresult: 2,
licenses: Vec::new(),
}
}
}
impl CMsgClientLicenseList {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.eresult = reader.i32()?,
2 => msg.licenses.push(License::deserialize(reader.bytes()?)?),
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::proto_wire::Writer;
#[test]
fn parses_license_with_fixed_times_and_two_byte_tags() {
let mut lic = Vec::new();
{
let mut w = Writer::new(&mut lic);
w.uint32_field(1, 123);
w.tag(2, WireType::Fixed32);
w.raw_bytes(&1000u32.to_le_bytes());
w.tag(3, WireType::Fixed32);
w.raw_bytes(&2000u32.to_le_bytes());
w.string_field(8, "US");
w.uint32_field(16, 7);
w.uint64_field(17, 0x1234);
w.uint32_field(18, 456);
}
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.int32_field(1, 1);
w.submessage_field(2, &lic);
}
let parsed = CMsgClientLicenseList::deserialize(&body).unwrap();
assert_eq!(parsed.eresult, 1);
assert_eq!(parsed.licenses[0].package_id, 123);
assert_eq!(parsed.licenses[0].time_created, 1000);
assert_eq!(parsed.licenses[0].renewal_time_unit, 7);
assert_eq!(parsed.licenses[0].master_package_id, 456);
}
}
@@ -0,0 +1,432 @@
use crate::steam::proto_wire::{Reader, WireType, Writer};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientPICSAccessTokenRequest {
pub packageids: Vec<u32>,
pub appids: Vec<u32>,
}
impl CMsgClientPICSAccessTokenRequest {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
for id in &self.packageids {
w.tag(1, WireType::Varint);
w.varint(*id as u64);
}
for id in &self.appids {
w.tag(2, WireType::Varint);
w.varint(*id as u64);
}
out
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PicsPackageToken {
pub packageid: u32,
pub access_token: u64,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PicsAppToken {
pub appid: u32,
pub access_token: u64,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientPICSAccessTokenResponse {
pub package_access_tokens: Vec<PicsPackageToken>,
pub package_denied_tokens: Vec<u32>,
pub app_access_tokens: Vec<PicsAppToken>,
pub app_denied_tokens: Vec<u32>,
}
impl CMsgClientPICSAccessTokenResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg
.package_access_tokens
.push(parse_package_token(reader.bytes()?)?),
2 => read_repeated_uint32(
&mut reader,
tag.wire_type,
&mut msg.package_denied_tokens,
)?,
3 => msg
.app_access_tokens
.push(parse_app_token(reader.bytes()?)?),
4 => read_repeated_uint32(&mut reader, tag.wire_type, &mut msg.app_denied_tokens)?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PicsAppInfoReq {
pub appid: u32,
pub access_token: u64,
pub only_public_obsolete: bool,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct PicsPackageInfoReq {
pub packageid: u32,
pub access_token: u64,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientPICSProductInfoRequest {
pub packages: Vec<PicsPackageInfoReq>,
pub apps: Vec<PicsAppInfoReq>,
pub meta_data_only: bool,
pub num_prev_failed: u32,
pub sequence_number: u32,
pub single_response: bool,
}
impl CMsgClientPICSProductInfoRequest {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
for package in &self.packages {
let mut sub = Vec::new();
let mut sw = Writer::new(&mut sub);
sw.uint32_field(1, package.packageid);
sw.uint64_field(2, package.access_token);
w.submessage_field(1, &sub);
}
for app in &self.apps {
let mut sub = Vec::new();
let mut sw = Writer::new(&mut sub);
sw.uint32_field(1, app.appid);
sw.uint64_field(2, app.access_token);
sw.bool_field(3, app.only_public_obsolete);
w.submessage_field(2, &sub);
}
w.bool_field(3, self.meta_data_only);
w.uint32_field(4, self.num_prev_failed);
w.uint32_field(6, self.sequence_number);
w.bool_field(7, self.single_response);
out
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PicsAppInfoResp {
pub appid: u32,
pub change_number: u32,
pub missing_token: bool,
pub sha: Vec<u8>,
pub buffer: Vec<u8>,
pub only_public: bool,
pub size: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PicsPackageInfoResp {
pub packageid: u32,
pub change_number: u32,
pub missing_token: bool,
pub sha: Vec<u8>,
pub buffer: Vec<u8>,
pub size: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientPICSProductInfoResponse {
pub apps: Vec<PicsAppInfoResp>,
pub unknown_appids: Vec<u32>,
pub packages: Vec<PicsPackageInfoResp>,
pub unknown_packageids: Vec<u32>,
pub meta_data_only: bool,
pub response_pending: bool,
pub http_min_size: u32,
pub http_host: String,
}
impl CMsgClientPICSProductInfoResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.apps.push(parse_app_info_resp(reader.bytes()?)?),
2 => read_repeated_uint32(&mut reader, tag.wire_type, &mut msg.unknown_appids)?,
3 => msg.packages.push(parse_package_info_resp(reader.bytes()?)?),
4 => read_repeated_uint32(&mut reader, tag.wire_type, &mut msg.unknown_packageids)?,
5 => msg.meta_data_only = reader.boolean()?,
6 => msg.response_pending = reader.boolean()?,
7 => msg.http_min_size = reader.u32()?,
8 => msg.http_host = reader.string()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
for app in &self.apps {
w.submessage_field(1, &app.serialize());
}
for appid in &self.unknown_appids {
w.uint32_field(2, *appid);
}
for package in &self.packages {
w.submessage_field(3, &package.serialize());
}
for packageid in &self.unknown_packageids {
w.uint32_field(4, *packageid);
}
w.bool_field(5, self.meta_data_only);
w.bool_field(6, self.response_pending);
w.uint32_field(7, self.http_min_size);
w.string_field(8, &self.http_host);
out
}
}
fn parse_package_token(body: &[u8]) -> Option<PicsPackageToken> {
let raw = parse_token(body)?;
Some(PicsPackageToken {
packageid: raw.id,
access_token: raw.access_token,
})
}
fn parse_app_token(body: &[u8]) -> Option<PicsAppToken> {
let raw = parse_token(body)?;
Some(PicsAppToken {
appid: raw.id,
access_token: raw.access_token,
})
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
struct TokenRaw {
id: u32,
access_token: u64,
}
fn parse_token(body: &[u8]) -> Option<TokenRaw> {
let mut reader = Reader::new(body);
let mut msg = TokenRaw::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.id = reader.u32()?,
2 => msg.access_token = reader.u64()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
fn parse_app_info_resp(body: &[u8]) -> Option<PicsAppInfoResp> {
let mut reader = Reader::new(body);
let mut msg = PicsAppInfoResp::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.appid = reader.u32()?,
2 => msg.change_number = reader.u32()?,
3 => msg.missing_token = reader.boolean()?,
4 => msg.sha = reader.bytes()?.to_vec(),
5 => msg.buffer = reader.bytes()?.to_vec(),
6 => msg.only_public = reader.boolean()?,
7 => msg.size = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
impl PicsAppInfoResp {
fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.appid);
w.uint32_field(2, self.change_number);
w.bool_field(3, self.missing_token);
w.bytes_field(4, &self.sha);
w.bytes_field(5, &self.buffer);
w.bool_field(6, self.only_public);
w.uint32_field(7, self.size);
out
}
}
fn parse_package_info_resp(body: &[u8]) -> Option<PicsPackageInfoResp> {
let mut reader = Reader::new(body);
let mut msg = PicsPackageInfoResp::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.packageid = reader.u32()?,
2 => msg.change_number = reader.u32()?,
3 => msg.missing_token = reader.boolean()?,
4 => msg.sha = reader.bytes()?.to_vec(),
5 => msg.buffer = reader.bytes()?.to_vec(),
6 => msg.size = reader.u32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
impl PicsPackageInfoResp {
fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.packageid);
w.uint32_field(2, self.change_number);
w.bool_field(3, self.missing_token);
w.bytes_field(4, &self.sha);
w.bytes_field(5, &self.buffer);
w.uint32_field(6, self.size);
out
}
}
fn read_repeated_uint32(
reader: &mut Reader<'_>,
wire_type: WireType,
out: &mut Vec<u32>,
) -> Option<()> {
match wire_type {
WireType::Varint => out.push(reader.u32()?),
WireType::LengthDelimited => {
let mut packed = Reader::new(reader.bytes()?);
while !packed.eof() {
out.push(packed.varint()? as u32);
}
}
_ => return None,
}
Some(())
}
#[cfg(test)]
mod tests {
use super::*;
fn token_body(id: u32, token: u64) -> Vec<u8> {
let mut body = Vec::new();
let mut w = Writer::new(&mut body);
w.uint32_field(1, id);
w.uint64_field(2, token);
body
}
#[test]
fn parses_access_tokens_and_packed_denied_lists() {
let mut packed = Vec::new();
{
let mut w = Writer::new(&mut packed);
w.varint(10);
w.varint(11);
}
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.submessage_field(1, &token_body(100, 555));
w.uint32_field(2, 9);
w.bytes_field(2, &packed);
w.submessage_field(3, &token_body(480, 777));
w.uint32_field(4, 12);
}
let parsed = CMsgClientPICSAccessTokenResponse::deserialize(&body).unwrap();
assert_eq!(parsed.package_access_tokens[0].packageid, 100);
assert_eq!(parsed.package_denied_tokens, [9, 10, 11]);
assert_eq!(parsed.app_access_tokens[0].appid, 480);
assert_eq!(parsed.app_denied_tokens, [12]);
}
#[test]
fn parses_product_info_response_without_stripping_package_prefix() {
let mut app = Vec::new();
{
let mut w = Writer::new(&mut app);
w.uint32_field(1, 480);
w.uint32_field(2, 22);
w.bool_field(3, true);
w.bytes_field(4, &[1; 20]);
w.bytes_field(5, b"appvdf");
w.bool_field(6, true);
w.uint32_field(7, 6);
}
let mut package = Vec::new();
{
let mut w = Writer::new(&mut package);
w.uint32_field(1, 100);
w.uint32_field(2, 33);
w.bytes_field(5, &[100, 0, 0, 0, b'v', b'd', b'f']);
w.uint32_field(6, 7);
}
let mut packed_unknown = Vec::new();
Writer::new(&mut packed_unknown).varint(888);
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.submessage_field(1, &app);
w.uint32_field(2, 404);
w.submessage_field(3, &package);
w.bytes_field(4, &packed_unknown);
w.bool_field(6, true);
w.uint32_field(7, 1024);
w.string_field(8, "cdn.example");
}
let parsed = CMsgClientPICSProductInfoResponse::deserialize(&body).unwrap();
assert_eq!(parsed.apps[0].appid, 480);
assert_eq!(parsed.unknown_appids, [404]);
assert_eq!(parsed.unknown_packageids, [888]);
assert_eq!(parsed.packages[0].buffer, [100, 0, 0, 0, b'v', b'd', b'f']);
assert!(parsed.response_pending);
assert_eq!(parsed.http_host, "cdn.example");
}
}
@@ -0,0 +1,188 @@
//! `CMsgClientRequestFreeLicense` / `...Response` (SteamKit
//! `steammessages_clientserver_2.proto`, EMsg 5572 / 5573) — the legitimate "add a free/F2P/demo
//! title to my library" grant.
//!
//! Field numbers and the EMsg pair are verified against the JavaSteam protobufs bundled with the
//! app (`SteammessagesClientserver2.java`, `EMsg.java`), and corroborated by the field-name
//! strings (`granted_packageids` / `granted_appids`) in the reference Rust Steam engine.
//!
//! Two details that a guess would have got wrong, both taken from the real definition:
//! * the request's `appids` is field **2**, not 1;
//! * the response's `eresult` carries an explicit proto2 `[default = 2]` (EResult.Fail), so an
//! absent field must read as *failure*, never as 0/Invalid and never as success.
use crate::steam::proto_wire::{Reader, WireType, Writer};
/// Proto2 `[default = 2]` on `CMsgClientRequestFreeLicenseResponse.eresult` — EResult.Fail.
/// An omitted field means the grant did NOT happen.
pub const FREE_LICENSE_DEFAULT_ERESULT: i32 = 2;
/// `CMsgClientRequestFreeLicense` (EMsg 5572): `repeated uint32 appids = 2;`
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientRequestFreeLicense {
pub appids: Vec<u32>,
}
impl CMsgClientRequestFreeLicense {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
for appid in &self.appids {
// Field 2 (not 1). Force-emit so an appid of 0 still occupies a slot rather than
// silently shortening the request.
w.uint32_field_force(2, *appid);
}
out
}
}
/// `CMsgClientRequestFreeLicenseResponse` (EMsg 5573):
/// `eresult = 1 [default = 2]`, `granted_packageids = 2`, `granted_appids = 3`.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientRequestFreeLicenseResponse {
pub eresult: i32,
pub granted_packageids: Vec<u32>,
pub granted_appids: Vec<u32>,
}
impl Default for CMsgClientRequestFreeLicenseResponse {
fn default() -> Self {
Self {
eresult: FREE_LICENSE_DEFAULT_ERESULT,
granted_packageids: Vec::new(),
granted_appids: Vec::new(),
}
}
}
impl CMsgClientRequestFreeLicenseResponse {
/// True only when Steam reported EResult.OK *and* actually handed something over.
pub fn is_granted(&self) -> bool {
self.eresult == 1 && !(self.granted_packageids.is_empty() && self.granted_appids.is_empty())
}
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match (tag.field_number, tag.wire_type) {
(1, WireType::Varint) => msg.eresult = reader.i32()?,
// Repeated uint32 is unpacked in proto2, but accept a packed block too so a
// server-side encoding change cannot silently empty the grant list.
(2, WireType::Varint) => msg.granted_packageids.push(reader.u32()?),
(2, WireType::LengthDelimited) => {
read_packed_u32(reader.bytes()?, &mut msg.granted_packageids)?
}
(3, WireType::Varint) => msg.granted_appids.push(reader.u32()?),
(3, WireType::LengthDelimited) => {
read_packed_u32(reader.bytes()?, &mut msg.granted_appids)?
}
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
/// Drain a packed repeated-varint block into `out`.
fn read_packed_u32(block: &[u8], out: &mut Vec<u32>) -> Option<()> {
let mut reader = Reader::new(block);
while !reader.eof() {
out.push(reader.u32()?);
}
Some(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn request_puts_appids_on_field_two() {
let body = CMsgClientRequestFreeLicense {
appids: vec![440, 570],
}
.serialize();
// tag = (2 << 3) | 0 = 0x10. Field 1 (0x08) would be the wrong-by-one guess.
assert_eq!(body[0], 0x10);
let mut expected = Vec::new();
{
let mut w = Writer::new(&mut expected);
w.uint32_field_force(2, 440);
w.uint32_field_force(2, 570);
}
assert_eq!(body, expected);
}
#[test]
fn absent_eresult_defaults_to_fail_not_success() {
// Proto2 [default = 2]: an empty body must NEVER read as granted.
let parsed = CMsgClientRequestFreeLicenseResponse::deserialize(&[]).unwrap();
assert_eq!(parsed.eresult, FREE_LICENSE_DEFAULT_ERESULT);
assert_eq!(parsed.eresult, 2);
assert!(!parsed.is_granted());
}
#[test]
fn parses_unpacked_grant_response() {
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.int32_field(1, 1);
w.uint32_field_force(2, 303_386);
w.uint32_field_force(3, 440);
}
let parsed = CMsgClientRequestFreeLicenseResponse::deserialize(&body).unwrap();
assert_eq!(parsed.eresult, 1);
assert_eq!(parsed.granted_packageids, vec![303_386]);
assert_eq!(parsed.granted_appids, vec![440]);
assert!(parsed.is_granted());
}
#[test]
fn parses_packed_grant_response() {
let mut packed_packages = Vec::new();
{
let mut w = Writer::new(&mut packed_packages);
w.varint(100);
w.varint(300);
}
let mut body = Vec::new();
{
let mut w = Writer::new(&mut body);
w.int32_field(1, 1);
w.submessage_field(2, &packed_packages);
}
let parsed = CMsgClientRequestFreeLicenseResponse::deserialize(&body).unwrap();
assert_eq!(parsed.granted_packageids, vec![100, 300]);
}
#[test]
fn ok_with_no_grant_is_not_a_grant() {
// eresult OK but nothing handed over: must not be reported as success.
let mut body = Vec::new();
Writer::new(&mut body).int32_field(1, 1);
let parsed = CMsgClientRequestFreeLicenseResponse::deserialize(&body).unwrap();
assert_eq!(parsed.eresult, 1);
assert!(!parsed.is_granted());
}
#[test]
fn failure_eresult_is_preserved_verbatim() {
// A paid/unowned title comes back with a non-OK EResult; surface it, don't flatten it.
for eresult in [2, 8, 15, 16] {
let mut body = Vec::new();
Writer::new(&mut body).int32_field(1, eresult);
let parsed = CMsgClientRequestFreeLicenseResponse::deserialize(&body).unwrap();
assert_eq!(parsed.eresult, eresult);
assert!(!parsed.is_granted());
}
}
}
@@ -0,0 +1,275 @@
use crate::steam::proto_wire::{Reader, WireType, Writer};
pub const MSG_CLIENT_CURRENT_PROTOCOL: u32 = 65_581;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientHello {
pub protocol_version: u32,
}
impl Default for CMsgClientHello {
fn default() -> Self {
Self {
protocol_version: MSG_CLIENT_CURRENT_PROTOCOL,
}
}
}
impl CMsgClientHello {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
Writer::new(&mut out).uint32_field(1, self.protocol_version);
out
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientHeartBeat {
pub send_reply: bool,
}
impl CMsgClientHeartBeat {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
Writer::new(&mut out).bool_field(1, self.send_reply);
out
}
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CMsgClientLogOff;
impl CMsgClientLogOff {
pub fn serialize(&self) -> Vec<u8> {
Vec::new()
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CMsgClientLoggedOff {
pub eresult: i32,
}
impl Default for CMsgClientLoggedOff {
fn default() -> Self {
Self { eresult: 2 }
}
}
impl CMsgClientLoggedOff {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.eresult = reader.i32()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientLogon {
pub protocol_version: u32,
pub cell_id: u32,
pub client_package_version: u32,
pub client_language: String,
pub client_os_type: u32,
pub should_remember_password: bool,
pub qos_level: u32,
pub client_supplied_steam_id: u64,
pub machine_id: Vec<u8>,
pub ui_mode: u32,
pub chat_mode: u32,
pub account_name: String,
pub machine_name: String,
pub client_instance_id: u64,
pub supports_rate_limit_response: bool,
pub access_token: String,
pub obfuscated_private_ip: u32,
}
impl Default for CMsgClientLogon {
fn default() -> Self {
Self {
protocol_version: MSG_CLIENT_CURRENT_PROTOCOL,
cell_id: 0,
client_package_version: 1771,
client_language: "english".to_string(),
client_os_type: 16,
should_remember_password: true,
qos_level: 2,
client_supplied_steam_id: 0,
machine_id: Vec::new(),
ui_mode: 7,
chat_mode: 2,
account_name: String::new(),
machine_name: "DroidDeck".to_string(),
client_instance_id: 0,
supports_rate_limit_response: true,
access_token: String::new(),
obfuscated_private_ip: 0,
}
}
}
impl CMsgClientLogon {
pub fn serialize(&self) -> Vec<u8> {
let mut out = Vec::new();
let mut w = Writer::new(&mut out);
w.uint32_field(1, self.protocol_version);
w.uint32_field(3, self.cell_id);
w.uint32_field(5, self.client_package_version);
w.string_field(6, &self.client_language);
w.uint32_field(7, self.client_os_type);
w.bool_field(8, self.should_remember_password);
w.uint32_field(21, self.qos_level);
if self.client_supplied_steam_id != 0 {
w.tag(22, WireType::Fixed64);
w.raw_bytes(&self.client_supplied_steam_id.to_le_bytes());
}
w.bytes_field(30, &self.machine_id);
if self.obfuscated_private_ip != 0 {
w.uint32_field(31, self.obfuscated_private_ip);
let mut ip_msg = Vec::new();
Writer::new(&mut ip_msg).uint32_field(1, self.obfuscated_private_ip);
w.bytes_field(95, &ip_msg);
}
w.uint32_field(32, self.ui_mode);
w.uint32_field(33, self.chat_mode);
w.string_field(50, &self.account_name);
w.string_field(96, &self.machine_name);
w.uint64_field(100, self.client_instance_id);
w.bool_field(102, self.supports_rate_limit_response);
w.string_field(108, &self.access_token);
out
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CMsgClientLogonResponse {
pub eresult: i32,
pub heartbeat_seconds: i32,
pub rtime32_server_time: u32,
pub cell_id: u32,
pub eresult_extended: i32,
pub vanity_url: String,
pub client_supplied_steamid: u64,
pub client_instance_id: u64,
pub force_client_update_check: bool,
pub agreement_session_url: String,
pub token_id: u64,
pub family_group_id: u64,
}
impl Default for CMsgClientLogonResponse {
fn default() -> Self {
Self {
eresult: 2,
heartbeat_seconds: 0,
rtime32_server_time: 0,
cell_id: 0,
eresult_extended: 0,
vanity_url: String::new(),
client_supplied_steamid: 0,
client_instance_id: 0,
force_client_update_check: false,
agreement_session_url: String::new(),
token_id: 0,
family_group_id: 0,
}
}
}
impl CMsgClientLogonResponse {
pub fn deserialize(body: &[u8]) -> Option<Self> {
let mut reader = Reader::new(body);
let mut msg = Self::default();
while !reader.eof() {
let Some(tag) = reader.next_tag() else {
return reader.ok().then_some(msg);
};
match tag.field_number {
1 => msg.eresult = reader.i32()?,
3 => msg.heartbeat_seconds = reader.i32()?,
5 => {
if tag.wire_type != WireType::Fixed32 {
return None;
}
msg.rtime32_server_time = reader.fixed32()?;
}
7 => msg.cell_id = reader.u32()?,
10 => msg.eresult_extended = reader.i32()?,
14 => msg.vanity_url = reader.string()?,
20 => {
if tag.wire_type != WireType::Fixed64 {
return None;
}
msg.client_supplied_steamid = reader.fixed64()?;
}
27 => msg.client_instance_id = reader.u64()?,
28 => msg.force_client_update_check = reader.boolean()?,
29 => msg.agreement_session_url = reader.string()?,
30 => msg.token_id = reader.u64()?,
31 => msg.family_group_id = reader.u64()?,
_ => {
if !reader.skip(tag.wire_type) {
return None;
}
}
}
}
Some(msg)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn logon_serializes_canonical_fields() {
let msg = CMsgClientLogon {
account_name: "user".to_string(),
access_token: "refresh.jwt".to_string(),
client_instance_id: 99,
obfuscated_private_ip: 0x0102_0304,
..Default::default()
};
let bytes = msg.serialize();
let mut reader = Reader::new(&bytes);
let mut fields = Vec::new();
while let Some(tag) = reader.next_tag() {
fields.push(tag.field_number);
reader.skip(tag.wire_type);
}
assert!(fields.contains(&50));
assert!(fields.contains(&95));
assert!(fields.contains(&108));
assert!(!fields.contains(&10));
}
#[test]
fn logon_response_reads_token_id_as_varint() {
let mut bytes = Vec::new();
let mut w = Writer::new(&mut bytes);
w.int32_field(1, 1);
w.int32_field(3, 10);
w.tag(5, WireType::Fixed32);
w.raw_bytes(&123u32.to_le_bytes());
w.uint64_field(30, 987);
let msg = CMsgClientLogonResponse::deserialize(&bytes).unwrap();
assert_eq!(msg.eresult, 1);
assert_eq!(msg.rtime32_server_time, 123);
assert_eq!(msg.token_id, 987);
}
}
@@ -0,0 +1,8 @@
//! Hand-written protobuf messages for the CM requests the download store sends.
pub mod ccontentserverdirectory;
pub mod cmsg_client_get_depot_decryption_key;
pub mod cmsg_client_license_list;
pub mod cmsg_client_pics;
pub mod cmsg_client_request_free_license;
pub mod cmsg_clientserver_login;
+612
View File
@@ -0,0 +1,612 @@
//! Which depots to install: what the Steam client picks for a Windows game run through Proton
//! (DroidDeck maps Proton globally), from the app's PICS appinfo.
//!
//! - `config.oslist` empty or containing `windows`;
//! - `config.osarch` empty or `64`; depots marked `32` only when the set has no `64` depot;
//! - `config.language` empty or the client language (english when the game has no depot for the
//! requested language but has english ones);
//! - `config.lowviolence` depots skipped;
//! - DLC depots (`dlcappid`) only when that DLC is owned;
//! - `depotfromapp` / `sharedinstall` depots are shared depots of another app (e.g. 228980
//! Steamworks Common Redistributables) and go into that app's folder;
//! - the public branch's manifest gid, and the app's public `buildid`.
use crate::steam::vdf::KVNode;
use serde_json::{json, Value};
use std::collections::HashSet;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PlannedDepot {
pub depot_id: u32,
pub manifest_id: u64,
pub size: u64,
pub download: u64,
pub dlc_app_id: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SharedRef {
pub depot_id: u32,
pub from_app_id: u32,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SharedDepot {
pub depot_id: u32,
pub from_app_id: u32,
pub manifest_id: u64,
pub size: u64,
pub download: u64,
pub from_name: String,
pub from_install_dir: String,
pub from_build_id: u64,
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct AppPlan {
pub app_id: u32,
pub name: String,
pub install_dir: String,
pub build_id: u64,
/// The language written to the app manifest (the requested one, or english, see above).
pub language: String,
pub depots: Vec<PlannedDepot>,
pub shared_refs: Vec<SharedRef>,
pub shared: Vec<SharedDepot>,
}
impl AppPlan {
pub fn install_bytes(&self) -> u64 {
self.depots.iter().map(|d| d.size).sum::<u64>()
+ self.shared.iter().map(|d| d.size).sum::<u64>()
}
pub fn download_bytes(&self) -> u64 {
self.depots.iter().map(|d| d.download).sum::<u64>()
+ self.shared.iter().map(|d| d.download).sum::<u64>()
}
pub fn to_json(&self) -> Value {
json!({
"ok": true,
"appId": self.app_id,
"name": self.name,
"installDir": self.install_dir,
"buildId": self.build_id,
"language": self.language,
"downloadBytes": self.download_bytes(),
"installBytes": self.install_bytes(),
"depots": self.depots.iter().map(|d| json!({
"depotId": d.depot_id,
"manifestId": d.manifest_id.to_string(),
"size": d.size,
"dlcAppId": d.dlc_app_id,
})).collect::<Vec<_>>(),
"shared": self.shared.iter().map(|d| json!({
"depotId": d.depot_id,
"fromAppId": d.from_app_id,
"manifestId": d.manifest_id.to_string(),
"size": d.size,
})).collect::<Vec<_>>(),
})
}
}
/// `appinfo` as PICS delivers it: either the `appinfo` node itself or a root holding it.
pub fn appinfo_root(root: &KVNode) -> &KVNode {
if root.name.eq_ignore_ascii_case("appinfo") {
root
} else {
root.child("appinfo").unwrap_or(root)
}
}
fn str_at(node: &KVNode, path: &[&str]) -> String {
let mut cur = node;
for key in path {
match cur.child(key) {
Some(next) => cur = next,
None => return String::new(),
}
}
if cur.is_object() {
String::new()
} else {
cur.as_string("")
}
}
fn uint_at(node: &KVNode, path: &[&str]) -> u64 {
str_at(node, path).trim().parse().unwrap_or(0)
}
pub fn app_name(appinfo: &KVNode) -> String {
str_at(appinfo, &["common", "name"])
}
pub fn app_type(appinfo: &KVNode) -> String {
str_at(appinfo, &["common", "type"])
}
pub fn app_install_dir(appinfo: &KVNode) -> String {
str_at(appinfo, &["config", "installdir"])
}
pub fn public_build_id(appinfo: &KVNode) -> u64 {
uint_at(appinfo, &["depots", "branches", "public", "buildid"])
}
/// Free to play / free app, as appinfo marks it.
pub fn is_free(appinfo: &KVNode) -> bool {
str_at(appinfo, &["common", "freetogame"]) == "1"
|| str_at(appinfo, &["extended", "isfreeapp"]) == "1"
}
/// Public manifest gid, size and download size of one depot entry (new layout
/// `manifests.public { gid size download }`, or the old `manifests.public "<gid>"` + `maxsize`).
pub fn public_manifest(depot: &KVNode) -> Option<(u64, u64, u64)> {
let public = depot.child("manifests")?.child("public")?;
if public.is_object() {
let gid = uint_at(public, &["gid"]);
if gid == 0 {
return None;
}
let size = uint_at(public, &["size"]);
let download = uint_at(public, &["download"]);
Some((gid, size, download))
} else {
let gid = public.as_uint(0);
if gid == 0 {
return None;
}
Some((gid, uint_at(depot, &["maxsize"]), 0))
}
}
fn os_ok(config: Option<&KVNode>) -> bool {
let oslist = config.map(|c| str_at(c, &["oslist"])).unwrap_or_default();
oslist.trim().is_empty()
|| oslist
.split(',')
.any(|os| os.trim().eq_ignore_ascii_case("windows"))
}
fn arch_of(config: Option<&KVNode>) -> String {
config
.map(|c| str_at(c, &["osarch"]).trim().to_string())
.unwrap_or_default()
}
fn language_of(config: Option<&KVNode>) -> String {
config
.map(|c| str_at(c, &["language"]).trim().to_ascii_lowercase())
.unwrap_or_default()
}
fn low_violence(config: Option<&KVNode>) -> bool {
config.is_some_and(|c| str_at(c, &["lowviolence"]) == "1")
}
struct Candidate<'a> {
depot_id: u32,
node: &'a KVNode,
arch: String,
language: String,
}
/// Applies the osarch preference and the language choice to a candidate set.
fn narrow<'a>(mut set: Vec<Candidate<'a>>, language: &str) -> Vec<Candidate<'a>> {
if set.iter().any(|c| c.arch == "64") {
set.retain(|c| c.arch != "32");
}
set.retain(|c| c.arch.is_empty() || c.arch == "64" || c.arch == "32");
set.retain(|c| c.language.is_empty() || c.language == language);
set
}
/// The language to install: the requested one when the game has a depot for it (or has no
/// language-tagged depots at all), else english when the game has english depots.
pub fn effective_language(appinfo: &KVNode, requested: &str) -> String {
let requested = requested.trim().to_ascii_lowercase();
let requested = if requested.is_empty() {
"english".to_string()
} else {
requested
};
let Some(depots) = appinfo.child("depots") else {
return requested;
};
let tags: HashSet<String> = depots
.children
.iter()
.filter(|d| d.name.parse::<u32>().is_ok())
.map(|d| language_of(d.child("config")))
.filter(|l| !l.is_empty())
.collect();
if tags.is_empty() || tags.contains(&requested) || !tags.contains("english") {
requested
} else {
"english".to_string()
}
}
/// Plans the app's own depots and lists the shared depots it references (resolved later with
/// [`resolve_shared`] from the owning apps' appinfo).
pub fn plan_app(
app_id: u32,
appinfo: &KVNode,
owned_apps: &HashSet<u32>,
language: &str,
) -> Result<AppPlan, String> {
let appinfo = appinfo_root(appinfo);
let language = effective_language(appinfo, language);
let mut plan = AppPlan {
app_id,
name: app_name(appinfo),
install_dir: app_install_dir(appinfo),
build_id: public_build_id(appinfo),
language: language.clone(),
..Default::default()
};
if plan.install_dir.is_empty() {
return Err("appinfo has no installdir".to_string());
}
let Some(depots) = appinfo.child("depots") else {
return Err("appinfo has no depots".to_string());
};
let mut own: Vec<Candidate> = Vec::new();
let mut shared: Vec<Candidate> = Vec::new();
for depot in &depots.children {
let Ok(depot_id) = depot.name.parse::<u32>() else {
continue;
};
if !depot.is_object() {
continue;
}
let config = depot.child("config");
if !os_ok(config) || low_violence(config) {
continue;
}
let dlc = uint_at(depot, &["dlcappid"]) as u32;
if dlc != 0 && !owned_apps.contains(&dlc) {
continue;
}
let candidate = Candidate {
depot_id,
node: depot,
arch: arch_of(config),
language: language_of(config),
};
let from_app = uint_at(depot, &["depotfromapp"]) as u32;
let shared_install = str_at(depot, &["sharedinstall"]) == "1";
if from_app != 0 || shared_install {
shared.push(candidate);
} else {
own.push(candidate);
}
}
for candidate in narrow(own, &language) {
let Some((manifest_id, size, download)) = public_manifest(candidate.node) else {
continue;
};
plan.depots.push(PlannedDepot {
depot_id: candidate.depot_id,
manifest_id,
size,
download,
dlc_app_id: uint_at(candidate.node, &["dlcappid"]) as u32,
});
}
for candidate in narrow(shared, &language) {
let from_app = uint_at(candidate.node, &["depotfromapp"]) as u32;
if from_app == 0 || from_app == app_id {
continue;
}
plan.shared_refs.push(SharedRef {
depot_id: candidate.depot_id,
from_app_id: from_app,
});
}
if plan.depots.is_empty() {
return Err("no installable Windows depot".to_string());
}
Ok(plan)
}
/// Fills [`AppPlan::shared`] from the owning apps' appinfo (`lookup(from_app_id)`); a shared
/// depot without a public manifest there is left out.
pub fn resolve_shared(plan: &mut AppPlan, lookup: &dyn Fn(u32) -> Option<KVNode>) {
plan.shared.clear();
let mut cache: Vec<(u32, Option<KVNode>)> = Vec::new();
for shared_ref in plan.shared_refs.clone() {
let pos = match cache
.iter()
.position(|(id, _)| *id == shared_ref.from_app_id)
{
Some(pos) => pos,
None => {
cache.push((shared_ref.from_app_id, lookup(shared_ref.from_app_id)));
cache.len() - 1
}
};
let Some(info) = cache[pos].1.as_ref() else {
continue;
};
let info = appinfo_root(info);
let Some(depot) = info
.child("depots")
.and_then(|d| d.child(&shared_ref.depot_id.to_string()))
else {
continue;
};
let Some((manifest_id, size, download)) = public_manifest(depot) else {
continue;
};
let install_dir = app_install_dir(info);
if install_dir.is_empty() {
continue;
}
plan.shared.push(SharedDepot {
depot_id: shared_ref.depot_id,
from_app_id: shared_ref.from_app_id,
manifest_id,
size,
download,
from_name: app_name(info),
from_install_dir: install_dir,
from_build_id: public_build_id(info),
});
}
}
#[cfg(test)]
pub mod tests {
use super::*;
/// Shaped like Brawlhalla's (291550) appinfo. Depot 291551/228988 gids and sizes and the
/// build ids are the captured install's; `download` values and depots 291552-291556 are made
/// up for the selection rules.
pub const BRAWLHALLA: &str = r#""appinfo"
{
"appid" "291550"
"common"
{
"name" "Brawlhalla"
"type" "Game"
"freetogame" "1"
}
"config"
{
"installdir" "Brawlhalla"
}
"depots"
{
"228988"
{
"config"
{
"oslist" "windows"
}
"depotfromapp" "228980"
"sharedinstall" "1"
}
"291551"
{
"config"
{
"oslist" "windows"
}
"manifests"
{
"public"
{
"gid" "4224536525702420323"
"size" "1565156559"
"download" "1521899507"
}
}
}
"291552"
{
"config"
{
"oslist" "macos"
}
"manifests"
{
"public"
{
"gid" "11"
"size" "5"
}
}
}
"291553"
{
"config"
{
"oslist" "windows"
"osarch" "32"
}
"manifests"
{
"public"
{
"gid" "12"
"size" "5"
}
}
}
"291554"
{
"config"
{
"oslist" "windows"
"osarch" "64"
"language" "german"
}
"manifests"
{
"public"
{
"gid" "13"
"size" "7"
}
}
}
"291555"
{
"config"
{
"lowviolence" "1"
}
"manifests"
{
"public" "14"
}
"maxsize" "9"
}
"291556"
{
"dlcappid" "291560"
"manifests"
{
"public"
{
"gid" "15"
"size" "3"
}
}
}
"branches"
{
"public"
{
"buildid" "26465982"
}
}
}
}
"#;
pub const REDIST: &str = r#""appinfo"
{
"appid" "228980"
"common"
{
"name" "Steamworks Common Redistributables"
"type" "Config"
}
"config"
{
"installdir" "Steamworks Shared"
}
"depots"
{
"228988"
{
"config"
{
"oslist" "windows"
}
"manifests"
{
"public"
{
"gid" "6645201662696499616"
"size" "29212173"
"download" "29212496"
}
}
}
"branches"
{
"public"
{
"buildid" "24098430"
}
}
}
}
"#;
pub fn parse(text: &str) -> KVNode {
crate::steam::vdf::parse_text(text.as_bytes()).unwrap()
}
#[test]
fn picks_windows_64bit_language_and_shared_depots_like_the_client() {
let info = parse(BRAWLHALLA);
let mut plan = plan_app(291550, &info, &HashSet::new(), "english").unwrap();
assert_eq!(plan.name, "Brawlhalla");
assert_eq!(plan.install_dir, "Brawlhalla");
assert_eq!(plan.build_id, 26465982);
assert_eq!(plan.language, "english");
let ids: Vec<u32> = plan.depots.iter().map(|d| d.depot_id).collect();
// 291552 macOS, 291553 32-bit (a 64-bit depot exists), 291554 german, 291555 low
// violence and 291556 unowned DLC are all left out.
assert_eq!(ids, vec![291551]);
assert_eq!(plan.depots[0].manifest_id, 4224536525702420323);
assert_eq!(plan.depots[0].size, 1565156559);
assert_eq!(
plan.shared_refs,
vec![SharedRef {
depot_id: 228988,
from_app_id: 228980
}]
);
resolve_shared(&mut plan, &|app| (app == 228980).then(|| parse(REDIST)));
assert_eq!(plan.shared.len(), 1);
let shared = &plan.shared[0];
assert_eq!(shared.manifest_id, 6645201662696499616);
assert_eq!(shared.size, 29212173);
assert_eq!(shared.from_install_dir, "Steamworks Shared");
assert_eq!(shared.from_build_id, 24098430);
// BytesToStage of the captured install = game depot + shared depot.
assert_eq!(plan.install_bytes(), 1594368732);
let json = plan.to_json();
assert_eq!(json["depots"][0]["manifestId"], "4224536525702420323");
assert_eq!(json["shared"][0]["fromAppId"], 228980);
}
#[test]
fn owned_dlc_german_and_32bit_fallback() {
let info = parse(BRAWLHALLA);
let owned: HashSet<u32> = [291560].into_iter().collect();
let plan = plan_app(291550, &info, &owned, "german").unwrap();
let ids: Vec<u32> = plan.depots.iter().map(|d| d.depot_id).collect();
assert_eq!(ids, vec![291551, 291554, 291556]);
assert_eq!(plan.depots[2].dlc_app_id, 291560);
let only32 = parse(
r#""appinfo" { "config" { "installdir" "X" } "depots" { "1" { "config" { "osarch" "32" } "manifests" { "public" "5" } "maxsize" "10" } } }"#,
);
let plan = plan_app(1, &only32, &HashSet::new(), "english").unwrap();
assert_eq!(plan.depots[0].depot_id, 1);
assert_eq!(plan.depots[0].manifest_id, 5);
assert_eq!(plan.depots[0].size, 10);
}
#[test]
fn unsupported_language_falls_back_to_english_depots() {
let info = parse(
r#""appinfo" { "config" { "installdir" "X" } "depots" {
"1" { "manifests" { "public" { "gid" "1" "size" "1" } } }
"2" { "config" { "language" "english" } "manifests" { "public" { "gid" "2" "size" "1" } } }
"3" { "config" { "language" "german" } "manifests" { "public" { "gid" "3" "size" "1" } } } } }"#,
);
let plan = plan_app(9, &info, &HashSet::new(), "koreana").unwrap();
assert_eq!(plan.language, "english");
let ids: Vec<u32> = plan.depots.iter().map(|d| d.depot_id).collect();
assert_eq!(ids, vec![1, 2]);
assert!(plan_app(
9,
&parse(r#""appinfo" { "depots" { } }"#),
&HashSet::new(),
"english"
)
.is_err());
}
}
@@ -0,0 +1,87 @@
use crate::steam::cmsg_protobuf_header::CMsgProtoBufHeader;
use crate::steam::emsg::{has_proto_flag, strip_proto_flag, with_proto_flag, EMsg};
use crate::steam::wire_format;
pub const PROTO_ENVELOPE_PREFIX_BYTES: usize = 8;
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ProtoEnvelope {
pub emsg: EMsg,
pub header: CMsgProtoBufHeader,
pub body: Vec<u8>,
}
impl Default for ProtoEnvelope {
fn default() -> Self {
Self {
emsg: EMsg::INVALID,
header: CMsgProtoBufHeader::default(),
body: Vec::new(),
}
}
}
pub fn encode_proto_envelope(emsg: EMsg, header: &CMsgProtoBufHeader, body: &[u8]) -> Vec<u8> {
let mut hdr_bytes = Vec::with_capacity(64);
header.serialize(&mut hdr_bytes);
let mut out = Vec::with_capacity(PROTO_ENVELOPE_PREFIX_BYTES + hdr_bytes.len() + body.len());
let mut writer = wire_format::Writer::new(&mut out);
writer.u32(with_proto_flag(emsg));
writer.u32(hdr_bytes.len() as u32);
writer.bytes(&hdr_bytes);
writer.bytes(body);
out
}
pub fn decode_proto_envelope(wire: &[u8]) -> Option<ProtoEnvelope> {
if wire.len() < PROTO_ENVELOPE_PREFIX_BYTES {
return None;
}
let mut reader = wire_format::Reader::new(wire);
let raw_emsg = reader.u32();
let hdr_len = reader.u32() as usize;
if !reader.ok() || !has_proto_flag(raw_emsg) || reader.remaining() < hdr_len {
return None;
}
let header = CMsgProtoBufHeader::deserialize(reader.bytes(hdr_len))?;
if !reader.ok() {
return None;
}
let body_off = reader.position();
Some(ProtoEnvelope {
emsg: strip_proto_flag(raw_emsg),
header,
body: wire[body_off..].to_vec(),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn proto_envelope_roundtrips() {
let header = CMsgProtoBufHeader {
steamid: 76561197960287930,
jobid_source: 42,
target_job_name: "Player.GetOwnedGames#1".to_string(),
..Default::default()
};
let body = [1, 2, 3, 4, 5];
let bytes = encode_proto_envelope(EMsg::SERVICE_METHOD_CALL_FROM_CLIENT, &header, &body);
let decoded = decode_proto_envelope(&bytes).unwrap();
assert_eq!(decoded.emsg, EMsg::SERVICE_METHOD_CALL_FROM_CLIENT);
assert_eq!(decoded.header, header);
assert_eq!(decoded.body, body);
}
#[test]
fn decode_rejects_non_proto_messages() {
let mut bytes = Vec::new();
let mut writer = wire_format::Writer::new(&mut bytes);
writer.u32(EMsg::MULTI.0);
writer.u32(0);
assert_eq!(decode_proto_envelope(&bytes), None);
}
}
@@ -0,0 +1,459 @@
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum WireType {
Varint = 0,
Fixed64 = 1,
LengthDelimited = 2,
StartGroup = 3,
EndGroup = 4,
Fixed32 = 5,
}
impl TryFrom<u8> for WireType {
type Error = ();
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0 => Ok(Self::Varint),
1 => Ok(Self::Fixed64),
2 => Ok(Self::LengthDelimited),
3 => Ok(Self::StartGroup),
4 => Ok(Self::EndGroup),
5 => Ok(Self::Fixed32),
_ => Err(()),
}
}
}
pub const MAX_VARINT_BYTES: usize = 10;
pub const fn zigzag_encode_i64(v: i64) -> u64 {
((v as u64) << 1) ^ ((v >> 63) as u64)
}
pub const fn zigzag_decode_i64(v: u64) -> i64 {
((v >> 1) as i64) ^ -((v & 1) as i64)
}
pub const fn zigzag_encode_i32(v: i32) -> u32 {
((v as u32) << 1) ^ ((v >> 31) as u32)
}
pub const fn zigzag_decode_i32(v: u32) -> i32 {
((v >> 1) as i32) ^ -((v & 1) as i32)
}
pub const fn make_tag(field_number: i32, wire_type: WireType) -> u32 {
((field_number as u32) << 3) | wire_type as u32
}
pub struct Writer<'a> {
out: &'a mut Vec<u8>,
}
impl<'a> Writer<'a> {
pub fn new(out: &'a mut Vec<u8>) -> Self {
Self { out }
}
pub fn varint(&mut self, mut v: u64) {
while v >= 0x80 {
self.out.push((v as u8) | 0x80);
v >>= 7;
}
self.out.push(v as u8);
}
pub fn tag(&mut self, field_number: i32, wire_type: WireType) {
self.varint(make_tag(field_number, wire_type) as u64);
}
pub fn uint32_field(&mut self, field_number: i32, v: u32) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Varint);
self.varint(v as u64);
}
pub fn uint64_field(&mut self, field_number: i32, v: u64) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Varint);
self.varint(v);
}
pub fn int32_field(&mut self, field_number: i32, v: i32) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Varint);
self.varint(v as i64 as u64);
}
pub fn int64_field(&mut self, field_number: i32, v: i64) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Varint);
self.varint(v as u64);
}
pub fn bool_field(&mut self, field_number: i32, v: bool) {
if !v {
return;
}
self.tag(field_number, WireType::Varint);
self.varint(1);
}
pub fn fixed32_field(&mut self, field_number: i32, v: u32) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Fixed32);
self.out.extend_from_slice(&v.to_le_bytes());
}
pub fn fixed64_field(&mut self, field_number: i32, v: u64) {
if v == 0 {
return;
}
self.tag(field_number, WireType::Fixed64);
self.out.extend_from_slice(&v.to_le_bytes());
}
pub fn string_field(&mut self, field_number: i32, s: &str) {
if s.is_empty() {
return;
}
self.tag(field_number, WireType::LengthDelimited);
self.varint(s.len() as u64);
self.out.extend_from_slice(s.as_bytes());
}
pub fn bytes_field(&mut self, field_number: i32, bytes: &[u8]) {
if bytes.is_empty() {
return;
}
self.tag(field_number, WireType::LengthDelimited);
self.varint(bytes.len() as u64);
self.out.extend_from_slice(bytes);
}
pub fn submessage_field(&mut self, field_number: i32, body: &[u8]) {
self.tag(field_number, WireType::LengthDelimited);
self.varint(body.len() as u64);
self.out.extend_from_slice(body);
}
pub fn raw_bytes(&mut self, bytes: &[u8]) {
self.out.extend_from_slice(bytes);
}
pub fn uint32_field_force(&mut self, field_number: i32, v: u32) {
self.tag(field_number, WireType::Varint);
self.varint(v as u64);
}
pub fn bool_field_force(&mut self, field_number: i32, v: bool) {
self.tag(field_number, WireType::Varint);
self.varint(u64::from(v));
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct Tag {
pub field_number: i32,
pub wire_type: WireType,
}
pub struct Reader<'a> {
buf: &'a [u8],
pos: usize,
ok: bool,
}
impl<'a> Reader<'a> {
pub fn new(buf: &'a [u8]) -> Self {
Self {
buf,
pos: 0,
ok: true,
}
}
pub fn ok(&self) -> bool {
self.ok
}
pub fn eof(&self) -> bool {
self.pos >= self.buf.len()
}
pub fn position(&self) -> usize {
self.pos
}
pub fn next_tag(&mut self) -> Option<Tag> {
if self.eof() {
return None;
}
let raw = self.varint()? as u32;
let wire_type = match WireType::try_from((raw & 0x07) as u8) {
Ok(wire_type) => wire_type,
Err(_) => {
self.ok = false;
return None;
}
};
let field_number = (raw >> 3) as i32;
if matches!(wire_type, WireType::StartGroup | WireType::EndGroup) || field_number <= 0 {
self.ok = false;
return None;
}
Some(Tag {
field_number,
wire_type,
})
}
pub fn varint(&mut self) -> Option<u64> {
let mut result = 0u64;
for i in 0..MAX_VARINT_BYTES {
if self.pos >= self.buf.len() {
self.ok = false;
return None;
}
let b = self.buf[self.pos];
self.pos += 1;
result |= ((b & 0x7f) as u64) << (i * 7);
if (b & 0x80) == 0 {
return Some(result);
}
}
self.ok = false;
None
}
pub fn skip(&mut self, wire_type: WireType) -> bool {
match wire_type {
WireType::Varint => self.varint().is_some(),
WireType::Fixed64 => self.advance(8),
WireType::LengthDelimited => {
let Some(len) = self.varint() else {
return false;
};
if len > usize::MAX as u64 {
self.ok = false;
return false;
}
self.advance(len as usize)
}
WireType::Fixed32 => self.advance(4),
WireType::StartGroup | WireType::EndGroup => {
self.ok = false;
false
}
}
}
pub fn u32(&mut self) -> Option<u32> {
self.varint().map(|v| v as u32)
}
pub fn u64(&mut self) -> Option<u64> {
self.varint()
}
pub fn i32(&mut self) -> Option<i32> {
self.varint().map(|v| v as i32)
}
pub fn i64(&mut self) -> Option<i64> {
self.varint().map(|v| v as i64)
}
pub fn boolean(&mut self) -> Option<bool> {
self.varint().map(|v| v != 0)
}
pub fn fixed32(&mut self) -> Option<u32> {
let Some(end) = self.pos.checked_add(4) else {
self.ok = false;
return None;
};
if end > self.buf.len() {
self.ok = false;
return None;
}
let bytes: [u8; 4] = self.buf[self.pos..end].try_into().ok()?;
self.pos = end;
Some(u32::from_le_bytes(bytes))
}
pub fn fixed64(&mut self) -> Option<u64> {
let Some(end) = self.pos.checked_add(8) else {
self.ok = false;
return None;
};
if end > self.buf.len() {
self.ok = false;
return None;
}
let bytes: [u8; 8] = self.buf[self.pos..end].try_into().ok()?;
self.pos = end;
Some(u64::from_le_bytes(bytes))
}
pub fn bytes(&mut self) -> Option<&'a [u8]> {
let len = self.varint()?;
if len > usize::MAX as u64 {
self.ok = false;
return None;
}
let len = len as usize;
let Some(end) = self.pos.checked_add(len) else {
self.ok = false;
return None;
};
if end > self.buf.len() {
self.ok = false;
return None;
}
let out = &self.buf[self.pos..end];
self.pos = end;
Some(out)
}
pub fn string(&mut self) -> Option<String> {
Some(String::from_utf8_lossy(self.bytes()?).into_owned())
}
fn advance(&mut self, amount: usize) -> bool {
let Some(end) = self.pos.checked_add(amount) else {
self.ok = false;
return false;
};
if end > self.buf.len() {
self.ok = false;
return false;
}
self.pos = end;
true
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn varint_roundtrips_common_edges() {
let cases = [0, 1, 127, 128, 300, u32::MAX as u64, u64::MAX];
for case in cases {
let mut buf = Vec::new();
Writer::new(&mut buf).varint(case);
let mut reader = Reader::new(&buf);
assert_eq!(reader.varint(), Some(case));
assert!(reader.ok());
assert!(reader.eof());
}
}
#[test]
fn writes_and_reads_typed_fields() {
let mut buf = Vec::new();
let mut writer = Writer::new(&mut buf);
writer.uint32_field(1, 42);
writer.fixed32_field(2, 0x1234_5678);
writer.string_field(3, "steam");
writer.bool_field_force(4, false);
let mut reader = Reader::new(&buf);
assert_eq!(
reader.next_tag(),
Some(Tag {
field_number: 1,
wire_type: WireType::Varint
})
);
assert_eq!(reader.u32(), Some(42));
assert_eq!(
reader.next_tag(),
Some(Tag {
field_number: 2,
wire_type: WireType::Fixed32
})
);
assert_eq!(reader.fixed32(), Some(0x1234_5678));
assert_eq!(
reader.next_tag(),
Some(Tag {
field_number: 3,
wire_type: WireType::LengthDelimited
})
);
assert_eq!(reader.string(), Some("steam".to_string()));
assert_eq!(
reader.next_tag(),
Some(Tag {
field_number: 4,
wire_type: WireType::Varint
})
);
assert_eq!(reader.boolean(), Some(false));
assert!(reader.eof());
}
#[test]
fn rejects_deprecated_groups_and_truncated_data() {
let mut group = Vec::new();
Writer::new(&mut group).tag(1, WireType::StartGroup);
let mut reader = Reader::new(&group);
assert_eq!(reader.next_tag(), None);
assert!(!reader.ok());
let mut truncated = Reader::new(&[0x0a, 0x05, b'a']);
assert_eq!(
truncated.next_tag(),
Some(Tag {
field_number: 1,
wire_type: WireType::LengthDelimited
})
);
assert_eq!(truncated.bytes(), None);
assert!(!truncated.ok());
}
#[test]
fn rejects_invalid_wire_type_and_oversized_length() {
let mut invalid = Reader::new(&[0x0e]);
assert_eq!(invalid.next_tag(), None);
assert!(!invalid.ok());
let mut oversized = Vec::new();
Writer::new(&mut oversized).varint(make_tag(1, WireType::LengthDelimited) as u64);
Writer::new(&mut oversized).varint(u64::MAX);
let mut reader = Reader::new(&oversized);
assert_eq!(
reader.next_tag(),
Some(Tag {
field_number: 1,
wire_type: WireType::LengthDelimited
})
);
assert_eq!(reader.bytes(), None);
assert!(!reader.ok());
}
#[test]
fn zigzag_matches_known_values() {
assert_eq!(zigzag_encode_i32(0), 0);
assert_eq!(zigzag_encode_i32(-1), 1);
assert_eq!(zigzag_encode_i32(1), 2);
assert_eq!(zigzag_decode_i32(1), -1);
assert_eq!(zigzag_decode_i64(3), -2);
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,535 @@
//! The one process-wide Steam session: connect to a CM over WebSocket, log on with the saved
//! refresh token, then answer the store's requests (PICS, depot keys, manifest request codes,
//! CDN servers, free licenses) as blocking calls with timeouts.
use crate::steam::cm_client::{
CMClientCore, ClientState, OutboundProtoMessage, OutboundServiceCall,
};
use crate::steam::cm_runtime::CMClientRuntime;
use crate::steam::library::Library;
use crate::steam::pb::ccontentserverdirectory::{
CContentServerDirectoryGetManifestRequestCodeResponse,
CContentServerDirectoryGetServersForSteamPipeResponse, CContentServerDirectoryServerInfo,
};
use crate::steam::pb::cmsg_client_get_depot_decryption_key::CMsgClientGetDepotDecryptionKeyResponse;
use crate::steam::pb::cmsg_client_pics::{
CMsgClientPICSAccessTokenResponse, CMsgClientPICSProductInfoResponse, PicsAppInfoReq,
PicsPackageInfoReq,
};
use crate::steam::pb::cmsg_client_request_free_license::CMsgClientRequestFreeLicenseResponse;
use crate::steam::signin::SavedLogin;
use crate::steam::vdf::KVNode;
use crate::steam::ws_connection::WsConnection;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
const LOGON_TIMEOUT: Duration = Duration::from_secs(20);
const LICENSE_LIST_TIMEOUT: Duration = Duration::from_secs(10);
const MAX_CM_ATTEMPTS: usize = 4;
const MAX_RESOLVE_ATTEMPTS: u32 = 4;
const ERESULT_OK: i32 = 1;
/// EResults after which another CM is worth a try (the token itself was not refused).
const RETRY_ON_ANOTHER_CM: [i32; 3] = [20, 48, 3];
pub struct Session {
runtime: Arc<CMClientRuntime>,
pub account: String,
pub steam_id: u64,
pub ca_bundle_path: String,
library: Mutex<Option<Arc<Library>>>,
}
static SESSION: Mutex<Option<Arc<Session>>> = Mutex::new(None);
pub fn eresult_name(eresult: i32) -> &'static str {
match eresult {
1 => "OK",
2 => "Fail",
3 => "NoConnection",
5 => "InvalidPassword",
6 => "LoggedInElsewhere",
15 => "AccessDenied",
18 => "AccountNotFound",
20 => "ServiceUnavailable",
26 => "Revoked",
27 => "Expired",
48 => "TryAnotherCM",
63 => "AccountLogonDenied",
84 => "RateLimitExceeded",
_ => "",
}
}
/// The live session, if one is logged on.
pub fn current() -> Option<Arc<Session>> {
let guard = SESSION.lock().expect("session poisoned");
guard.as_ref().filter(|s| s.is_logged_on()).cloned()
}
/// Logs on with `login` unless a live session exists; returns the live session.
pub fn sign_in(login: &SavedLogin, ca_bundle_path: &str) -> Result<Arc<Session>, String> {
if let Some(live) = current() {
return Ok(live);
}
sign_out();
let runtime = connect_and_logon(login, ca_bundle_path)?;
let steam_id = runtime.core().steam_id();
let session = Arc::new(Session {
runtime,
account: login.account.clone(),
steam_id: if steam_id != 0 {
steam_id
} else {
login.steam_id
},
ca_bundle_path: ca_bundle_path.to_string(),
library: Mutex::new(None),
});
*SESSION.lock().expect("session poisoned") = Some(Arc::clone(&session));
Ok(session)
}
/// Logs off and drops the session. Never touches the Steam client's files.
pub fn sign_out() {
let previous = SESSION.lock().expect("session poisoned").take();
if let Some(session) = previous {
session.log_off();
}
}
fn cm_urls(ca_bundle_path: &str) -> Vec<String> {
let directory = crate::steam::steam_directory::SteamDirectoryClient::new(ca_bundle_path);
let result = directory.fetch(0, crate::steam::steam_directory::DEFAULT_TIMEOUT);
let mut urls: Vec<String> = Vec::new();
let servers = if result.ok() {
result.servers
} else {
crate::steam::log(&format!("cm directory failed: {}", result.error));
Vec::new()
};
for server in servers
.into_iter()
.chain(crate::steam::cm_server_list::hardcoded_fallback_servers())
{
let url = server.websocket_url();
if !url.is_empty() && !urls.contains(&url) {
urls.push(url);
}
}
urls
}
fn wait_until(timeout: Duration, mut done: impl FnMut() -> bool) -> bool {
let deadline = Instant::now() + timeout;
loop {
if done() {
return true;
}
if Instant::now() >= deadline {
return false;
}
thread::sleep(Duration::from_millis(50));
}
}
fn connect_and_logon(
login: &SavedLogin,
ca_bundle_path: &str,
) -> Result<Arc<CMClientRuntime>, String> {
let urls = cm_urls(ca_bundle_path);
let mut last_error = "logon_failed: no CM server".to_string();
for url in urls.iter().take(MAX_CM_ATTEMPTS) {
let core = Arc::new(CMClientCore::default());
let runtime = CMClientRuntime::new(Arc::clone(&core), Box::new(WsConnection::new()));
if !ca_bundle_path.is_empty() {
runtime.set_ca_bundle_path(ca_bundle_path);
}
if !runtime.connect(url) {
last_error = "logon_failed: connect".to_string();
continue;
}
if !wait_until(CONNECT_TIMEOUT, || core.state() == ClientState::Connected) {
runtime.disconnect();
last_error = "logon_failed: CM did not answer".to_string();
continue;
}
let message =
core.build_logon_with_refresh_token(&login.token, &login.account, login.steam_id);
if !core.enqueue_proto_message(message) {
runtime.disconnect();
last_error = "logon_failed: connection dropped".to_string();
continue;
}
runtime.flush_outbound();
let settled = wait_until(LOGON_TIMEOUT, || {
core.state() == ClientState::LoggedOn
|| core.last_logon_eresult() != 0
|| core.state() == ClientState::Disconnected
});
if core.state() == ClientState::LoggedOn {
crate::steam::log(&format!(
"logged on steam_id={} cell={}",
core.steam_id(),
core.cell_id()
));
wait_until(LICENSE_LIST_TIMEOUT, || core.license_list().is_some());
return Ok(runtime);
}
let eresult = core.last_logon_eresult();
runtime.disconnect();
if !settled {
last_error = "logon_failed: no logon response".to_string();
continue;
}
if eresult == 0 {
last_error = "logon_failed: connection dropped".to_string();
continue;
}
last_error = format!("logon_failed: eresult={eresult} {}", eresult_name(eresult))
.trim_end()
.to_string();
crate::steam::log(&last_error);
if !RETRY_ON_ANOTHER_CM.contains(&eresult) {
break;
}
}
Err(last_error)
}
pub enum KeyResolution {
Granted(Vec<u8>),
AccessDenied,
Cancelled,
Unavailable,
}
pub enum CodeResolution {
Code(u64),
AccessDenied,
Cancelled,
Unavailable,
}
impl Session {
pub fn is_logged_on(&self) -> bool {
self.runtime.core().state() == ClientState::LoggedOn
}
fn log_off(&self) {
let core = self.runtime.core();
if core.enqueue_proto_message(core.build_logoff()) {
self.runtime.flush_outbound();
thread::sleep(Duration::from_millis(500));
}
self.runtime.disconnect();
}
pub fn core(&self) -> &Arc<CMClientCore> {
self.runtime.core()
}
fn proto_response<F>(&self, timeout: Duration, build: F) -> Option<(i32, Vec<u8>)>
where
F: FnOnce(&CMClientCore, u64) -> Option<OutboundProtoMessage>,
{
if !self.is_logged_on() {
return None;
}
let job_id = self.runtime.next_job_id();
let message = build(self.runtime.core(), job_id)?;
let (tx, rx) = mpsc::channel();
self.runtime.track_job(
job_id,
move |job| {
let _ = tx.send((!job.synthetic_failure).then_some((job.eresult, job.body)));
},
Some(timeout),
);
if !self.runtime.core().enqueue_wire(message.wire) {
return None;
}
self.runtime.flush_outbound();
rx.recv_timeout(timeout + Duration::from_secs(1))
.ok()
.flatten()
}
fn service_response<F>(&self, timeout: Duration, build: F) -> Option<(i32, Vec<u8>)>
where
F: FnOnce(&CMClientCore, u64) -> Option<OutboundServiceCall>,
{
if !self.is_logged_on() {
return None;
}
let job_id = self.runtime.next_job_id();
let call = build(self.runtime.core(), job_id)?;
let (tx, rx) = mpsc::channel();
self.runtime.track_job(
job_id,
move |job| {
let _ = tx.send((!job.synthetic_failure).then_some((job.eresult, job.body)));
},
Some(timeout),
);
if !self.runtime.core().enqueue_wire(call.wire) {
return None;
}
self.runtime.flush_outbound();
rx.recv_timeout(timeout + Duration::from_secs(1))
.ok()
.flatten()
}
pub fn pics_access_tokens(
&self,
packages: Vec<u32>,
apps: Vec<u32>,
) -> Option<CMsgClientPICSAccessTokenResponse> {
let (eresult, body) = self.proto_response(REQUEST_TIMEOUT, |core, job| {
core.build_pics_access_tokens(packages, apps, job)
})?;
if eresult <= 0 {
return None;
}
CMsgClientPICSAccessTokenResponse::deserialize(&body)
}
/// PICS product info; large appinfo the CM delivers over HTTP is fetched here.
pub fn pics_product_info(
&self,
packages: Vec<PicsPackageInfoReq>,
apps: Vec<PicsAppInfoReq>,
) -> Option<CMsgClientPICSProductInfoResponse> {
let (eresult, body) = self.proto_response(Duration::from_secs(60), |core, job| {
core.build_pics_product_info(packages, apps, false, job)
})?;
if eresult <= 0 {
return None;
}
let mut response = CMsgClientPICSProductInfoResponse::deserialize(&body)?;
self.hydrate_http_appinfo(&mut response);
Some(response)
}
fn hydrate_http_appinfo(&self, response: &mut CMsgClientPICSProductInfoResponse) {
if response.http_host.is_empty() {
return;
}
let host = response.http_host.clone();
let targets: Vec<usize> = response
.apps
.iter()
.enumerate()
.filter(|(_, app)| !app.missing_token && app.buffer.is_empty() && !app.sha.is_empty())
.map(|(idx, _)| idx)
.collect();
if targets.is_empty() {
return;
}
let queue = Mutex::new(targets.into_iter());
let results: Mutex<Vec<(usize, Vec<u8>)>> = Mutex::new(Vec::new());
let apps = &response.apps;
let workers = queue.lock().expect("queue poisoned").len().clamp(1, 8);
thread::scope(|scope| {
for _ in 0..workers {
scope.spawn(|| loop {
let next = queue.lock().expect("queue poisoned").next();
let Some(idx) = next else {
return;
};
let app = &apps[idx];
if let Some(buffer) = crate::steam::cdn::fetch_appinfo(
&host,
app.appid,
&app.sha,
&self.ca_bundle_path,
REQUEST_TIMEOUT,
) {
results
.lock()
.expect("results poisoned")
.push((idx, buffer));
}
});
}
});
for (idx, buffer) in results.into_inner().expect("results poisoned") {
response.apps[idx].buffer = buffer;
}
}
/// The app's appinfo (`appinfo` node), with its PICS access token.
pub fn app_info(&self, app_id: u32) -> Option<KVNode> {
let token = self
.pics_access_tokens(Vec::new(), vec![app_id])
.and_then(|r| {
r.app_access_tokens
.iter()
.find(|t| t.appid == app_id)
.map(|t| t.access_token)
})
.unwrap_or(0);
let response = self.pics_product_info(
Vec::new(),
vec![PicsAppInfoReq {
appid: app_id,
access_token: token,
only_public_obsolete: false,
}],
)?;
let app = response
.apps
.into_iter()
.find(|a| a.appid == app_id && !a.buffer.is_empty())?;
let root = crate::steam::vdf::parse_auto(&app.buffer)?;
Some(crate::steam::plan::appinfo_root(&root).clone())
}
pub fn library(&self) -> Result<Arc<Library>, String> {
if let Some(lib) = self.library.lock().expect("library poisoned").as_ref() {
return Ok(Arc::clone(lib));
}
let lib = Arc::new(Library::load(self)?);
*self.library.lock().expect("library poisoned") = Some(Arc::clone(&lib));
Ok(lib)
}
/// The owned games, loaded once per session.
pub fn games(&self) -> Result<Vec<crate::steam::library::Game>, String> {
let lib = self.library()?;
if let Some(games) = lib.cached_games() {
return Ok(games);
}
let games = lib.load_games(self)?;
*self.library.lock().expect("library poisoned") =
Some(Arc::new(lib.with_games(games.clone())));
Ok(games)
}
pub fn forget_library(&self) {
*self.library.lock().expect("library poisoned") = None;
}
/// `CMsgClientRequestFreeLicense` for one app; true when Steam granted it and the license
/// list shows the new package.
pub fn request_free_license(&self, app_id: u32) -> bool {
let Some((_header, body)) = self.proto_response(Duration::from_secs(20), |core, job| {
core.build_request_free_license(&[app_id], job)
}) else {
return false;
};
let Some(response) = CMsgClientRequestFreeLicenseResponse::deserialize(&body) else {
return false;
};
let granted = response.is_granted();
crate::steam::log(&format!(
"free license app={app_id} eresult={} packages={:?}",
response.eresult, response.granted_packageids
));
if !granted {
return false;
}
let packages = response.granted_packageids.clone();
let core = self.runtime.core();
let visible = wait_until(Duration::from_secs(8), || {
core.license_list().is_some_and(|list| {
packages
.iter()
.all(|p| list.iter().any(|l| l.package_id == *p))
})
});
self.forget_library();
visible || packages.is_empty()
}
pub fn cdn_servers(&self) -> Option<Vec<CContentServerDirectoryServerInfo>> {
let (eresult, body) = self.service_response(REQUEST_TIMEOUT, |core, job| {
core.build_get_cdn_servers_call(0, job)
})?;
if eresult != ERESULT_OK {
return None;
}
let servers =
CContentServerDirectoryGetServersForSteamPipeResponse::deserialize(&body)?.servers;
let preview = servers
.iter()
.take(4)
.map(|s| s.host.as_str())
.collect::<Vec<_>>()
.join(",");
crate::steam::log(&format!(
"cdn pool: {} server(s) first=[{preview}]",
servers.len()
));
Some(servers)
}
pub fn depot_key(&self, app_id: u32, depot_id: u32, cancel: &AtomicBool) -> KeyResolution {
for attempt in 0..MAX_RESOLVE_ATTEMPTS {
if cancel.load(Ordering::Relaxed) {
return KeyResolution::Cancelled;
}
if attempt > 0 {
thread::sleep(Duration::from_millis(
crate::fetch_tuning::retry_backoff_millis(attempt),
));
}
let Some((header, body)) = self.proto_response(REQUEST_TIMEOUT, |core, job| {
core.build_get_depot_decryption_key(depot_id, app_id, job)
}) else {
continue;
};
let response = CMsgClientGetDepotDecryptionKeyResponse::deserialize(&body);
if let Some(r) = &response {
if r.eresult == ERESULT_OK as u32 && r.depot_encryption_key.len() == 32 {
return KeyResolution::Granted(r.depot_encryption_key.clone());
}
}
crate::steam::log(&format!(
"depot key refused depot={depot_id} header_eresult={header} body_eresult={}",
response.map(|r| r.eresult as i64).unwrap_or(-1)
));
return KeyResolution::AccessDenied;
}
KeyResolution::Unavailable
}
pub fn manifest_code(
&self,
app_id: u32,
depot_id: u32,
manifest_id: u64,
cancel: &AtomicBool,
) -> CodeResolution {
for attempt in 0..MAX_RESOLVE_ATTEMPTS {
if cancel.load(Ordering::Relaxed) {
return CodeResolution::Cancelled;
}
if attempt > 0 {
thread::sleep(Duration::from_millis(
crate::fetch_tuning::retry_backoff_millis(attempt),
));
}
let Some((eresult, body)) = self.service_response(REQUEST_TIMEOUT, |core, job| {
core.build_manifest_request_code_call(app_id, depot_id, manifest_id, "public", job)
}) else {
continue;
};
if eresult == ERESULT_OK {
match CContentServerDirectoryGetManifestRequestCodeResponse::deserialize(&body) {
Some(r) => return CodeResolution::Code(r.manifest_request_code),
None => continue,
}
}
crate::steam::log(&format!(
"manifest code refused depot={depot_id} eresult={eresult}"
));
return CodeResolution::AccessDenied;
}
CodeResolution::Unavailable
}
}
@@ -0,0 +1,501 @@
//! Reuses the sign-in the Linux Steam client saved ("Remember me"), so the user never signs in
//! twice. Read-only: nothing here writes to the client's files, and the token is never renewed,
//! refreshed or replaced (that would sign the client out).
//!
//! Where it lives, per Steam root:
//! - `config/loginusers.vdf`: the accounts (`<SteamID64> { AccountName, RememberPassword,
//! MostRecent, Timestamp … }`).
//! - `local.vdf`: `MachineUserConfigStore/Software/Valve/Steam/ConnectCache`, one entry per
//! remembered account whose key starts with the 8-hex-digit CRC32 of the lowercased account
//! name (e.g. `9a410a9b` + `1`) and whose value is a hex blob.
//! - `~/.steam/registry.vdf`: `Registry/HKCU/Software/Valve/Steam/AutoLoginUser`.
//!
//! The blob: key = SHA-256(lowercased account name); the first 16 bytes are the IV encrypted with
//! AES-256-ECB; the rest is AES-256-CBC with PKCS#7 padding; the plaintext is the refresh-token
//! JWT. Method as documented by deadlock-api-ingest, `src/gc/auth.rs` (MIT,
//! https://github.com/deadlock-api/deadlock-api-ingest). Keys are matched case-insensitively
//! because clients mix casings.
//!
//! The token stays in memory only, is never logged or written anywhere, and is zeroized on drop.
use crate::steam::crypto::{aes256_cbc_decrypt, aes256_ecb_decrypt_block, sha256};
use crate::steam::vdf::{self, KVNode};
use std::fs;
use std::path::{Path, PathBuf};
use zeroize::{Zeroize, Zeroizing};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SigninError {
/// No Steam root has an account in `loginusers.vdf`.
NoSavedLogin,
/// The account exists but the client kept no token for it (Remember me off, or signed out).
RememberMeOff,
/// A token blob exists but does not decrypt to this account's Steam JWT.
DecryptFailed,
}
impl SigninError {
pub fn code(self) -> &'static str {
match self {
SigninError::NoSavedLogin => "no_saved_login",
SigninError::RememberMeOff => "remember_me_off",
SigninError::DecryptFailed => "decrypt_failed",
}
}
}
/// The saved login of one account. `Debug` keeps the token out of any output.
pub struct SavedLogin {
pub account: String,
pub steam_id: u64,
pub steam_root: PathBuf,
pub token: Zeroizing<String>,
}
impl std::fmt::Debug for SavedLogin {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SavedLogin")
.field("account", &self.account)
.field("steam_id", &self.steam_id)
.field("steam_root", &self.steam_root)
.field("token", &"<redacted>")
.finish()
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Account {
pub steam_id: u64,
pub account_name: String,
pub remember_password: Option<bool>,
pub most_recent: bool,
pub timestamp: u64,
pub root_index: usize,
}
pub fn child_ci<'a>(node: &'a KVNode, key: &str) -> Option<&'a KVNode> {
node.child(key)
}
/// Follows `path` from `root` (whose own name is `path[0]`), matching every key case-insensitively.
pub fn find_path<'a>(root: &'a KVNode, path: &[&str]) -> Option<&'a KVNode> {
let (first, rest) = path.split_first()?;
if !root.name.eq_ignore_ascii_case(first) {
return None;
}
rest.iter().try_fold(root, |node, key| child_ci(node, key))
}
fn read_vdf(path: &Path) -> Option<KVNode> {
let bytes = fs::read(path).ok()?;
vdf::parse_text(&bytes)
}
pub fn parse_login_users(root: &KVNode, root_index: usize) -> Vec<Account> {
if !root.name.eq_ignore_ascii_case("users") {
return Vec::new();
}
let mut out = Vec::new();
for user in &root.children {
let Ok(steam_id) = user.name.parse::<u64>() else {
continue;
};
let Some(name) = child_ci(user, "AccountName").map(|n| n.as_string("")) else {
continue;
};
if name.is_empty() {
continue;
}
let flag = |key: &str| child_ci(user, key).map(|n| n.as_string("") == "1");
out.push(Account {
steam_id,
account_name: name,
remember_password: flag("RememberPassword"),
most_recent: flag("MostRecent").unwrap_or(false),
timestamp: child_ci(user, "Timestamp")
.map(|n| n.as_uint(0))
.unwrap_or(0),
root_index,
});
}
out
}
pub fn auto_login_user(registry: &KVNode) -> Option<String> {
let user = find_path(
registry,
&[
"Registry",
"HKCU",
"Software",
"Valve",
"Steam",
"AutoLoginUser",
],
)?
.as_string("");
(!user.is_empty()).then_some(user)
}
/// `AutoLoginUser` when it names a known account, else the `MostRecent` one, else the newest
/// `Timestamp` (Linux clients may omit `MostRecent`).
pub fn choose_account<'a>(
accounts: &'a [Account],
auto_login: Option<&str>,
) -> Option<&'a Account> {
if let Some(user) = auto_login {
if let Some(found) = accounts
.iter()
.find(|a| a.account_name.eq_ignore_ascii_case(user))
{
return Some(found);
}
}
if let Some(found) = accounts.iter().find(|a| a.most_recent) {
return Some(found);
}
accounts.iter().max_by_key(|a| a.timestamp)
}
pub fn connect_cache_key_prefix(account_name: &str) -> String {
format!(
"{:08x}",
crc32fast::hash(account_name.to_lowercase().as_bytes())
)
}
/// The hex blob for `account_name` in a parsed `local.vdf`.
pub fn connect_cache_blob(local: &KVNode, account_name: &str) -> Option<String> {
let cache = find_path(
local,
&[
"MachineUserConfigStore",
"Software",
"Valve",
"Steam",
"ConnectCache",
],
)?;
let prefix = connect_cache_key_prefix(account_name);
cache
.children
.iter()
.find(|entry| {
entry
.name
.get(..prefix.len())
.is_some_and(|p| p.eq_ignore_ascii_case(&prefix))
})
.map(|entry| entry.as_string(""))
.filter(|value| !value.is_empty())
}
fn decode_hex(text: &str) -> Option<Vec<u8>> {
let text = text.trim();
if !text.len().is_multiple_of(2) {
return None;
}
let digit = |c: u8| -> Option<u8> {
match c {
b'0'..=b'9' => Some(c - b'0'),
b'a'..=b'f' => Some(c - b'a' + 10),
b'A'..=b'F' => Some(c - b'A' + 10),
_ => None,
}
};
text.as_bytes()
.chunks(2)
.map(|pair| Some((digit(pair[0])? << 4) | digit(pair[1])?))
.collect()
}
/// Decrypts a ConnectCache blob (hex) into the refresh-token JWT.
pub fn decrypt_connect_cache(hex_blob: &str, account_name: &str) -> Option<Zeroizing<String>> {
let blob = Zeroizing::new(decode_hex(hex_blob)?);
if blob.len() < 32 {
return None;
}
let mut key = sha256(account_name.to_lowercase().as_bytes());
let mut wrapped = [0u8; 16];
wrapped.copy_from_slice(&blob[..16]);
let iv = aes256_ecb_decrypt_block(&key, &wrapped);
let plain = iv.and_then(|iv| aes256_cbc_decrypt(&key, &iv, &blob[16..]));
key.zeroize();
let mut plain = plain?;
let text = match String::from_utf8(std::mem::take(&mut plain)) {
Ok(text) => Zeroizing::new(text),
Err(err) => {
let mut bytes = err.into_bytes();
bytes.zeroize();
return None;
}
};
Some(text)
}
fn base64url_decode(text: &str) -> Option<Vec<u8>> {
let mut s: String = text
.chars()
.map(|c| match c {
'-' => '+',
'_' => '/',
other => other,
})
.collect();
while !s.len().is_multiple_of(4) {
s.push('=');
}
crate::steam::base64::decode(&s)
}
/// The SteamID64 a Steam JWT was issued for (`sub`), if it is a Steam JWT.
pub fn jwt_steam_id(jwt: &str) -> Option<u64> {
let mut parts = jwt.split('.');
let (_header, payload, _sig) = (parts.next()?, parts.next()?, parts.next()?);
if parts.next().is_some() {
return None;
}
let bytes = base64url_decode(payload)?;
let json: serde_json::Value = serde_json::from_slice(&bytes).ok()?;
if json.get("iss").and_then(|v| v.as_str()) != Some("steam") {
return None;
}
json.get("sub")?.as_str()?.parse().ok()
}
/// Loads the saved login. `steam_roots` are host paths of Steam roots, searched in order;
/// `registry_vdf` is `~/.steam/registry.vdf` (may be missing).
pub fn load_saved_login(
steam_roots: &[PathBuf],
registry_vdf: Option<&Path>,
) -> Result<SavedLogin, SigninError> {
let mut accounts = Vec::new();
for (idx, root) in steam_roots.iter().enumerate() {
if let Some(users) = read_vdf(&root.join("config").join("loginusers.vdf")) {
accounts.extend(parse_login_users(&users, idx));
}
}
let auto_login = registry_vdf
.and_then(read_vdf)
.and_then(|reg| auto_login_user(&reg));
let account = choose_account(&accounts, auto_login.as_deref())
.ok_or(SigninError::NoSavedLogin)?
.clone();
if account.remember_password == Some(false) {
return Err(SigninError::RememberMeOff);
}
let mut order: Vec<usize> = vec![account.root_index];
order.extend((0..steam_roots.len()).filter(|&i| i != account.root_index));
let mut found_blob = false;
for idx in order {
let Some(local) = read_vdf(&steam_roots[idx].join("local.vdf")) else {
continue;
};
let Some(mut blob) = connect_cache_blob(&local, &account.account_name) else {
continue;
};
found_blob = true;
let token = decrypt_connect_cache(&blob, &account.account_name);
blob.zeroize();
let Some(token) = token else {
continue;
};
if jwt_steam_id(&token) != Some(account.steam_id) {
continue;
}
return Ok(SavedLogin {
account: account.account_name.clone(),
steam_id: account.steam_id,
steam_root: steam_roots[idx].clone(),
token,
});
}
Err(if found_blob {
SigninError::DecryptFailed
} else {
SigninError::RememberMeOff
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::steam::crypto::{aes256_cbc_encrypt, aes256_ecb_encrypt_block};
const ID: u64 = 76561198000000001;
fn jwt_for(steam_id: u64) -> String {
let payload = format!(r#"{{"iss":"steam","sub":"{steam_id}","aud":["client","web"]}}"#);
let b64 = crate::steam::base64::encode(payload.as_bytes())
.trim_end_matches('=')
.replace('+', "-")
.replace('/', "_");
format!("eyJhbGciOiJFZERTQSJ9.{b64}.c2ln")
}
/// Same scheme the client uses: IV wrapped with AES-256-ECB, body AES-256-CBC + PKCS#7.
fn encrypt_blob(token: &str, account: &str) -> String {
let key = sha256(account.to_lowercase().as_bytes());
let iv = [0x5au8; 16];
let mut out = aes256_ecb_encrypt_block(&key, &iv).unwrap().to_vec();
out.extend(aes256_cbc_encrypt(&key, &iv, token.as_bytes()).unwrap());
out.iter().map(|b| format!("{b:02x}")).collect()
}
fn temp_dir(name: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"droiddeck_steam_signin_{name}_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
fs::create_dir_all(dir.join("config")).unwrap();
dir
}
fn write_root(root: &Path, users: &str, cache_entries: &str) {
fs::write(root.join("config").join("loginusers.vdf"), users).unwrap();
fs::write(
root.join("local.vdf"),
format!(
"\"MachineUserConfigStore\"\n{{\n\t\"Software\"\n\t{{\n\t\t\"valve\"\n\t\t{{\n\t\t\t\"steam\"\n\t\t\t{{\n\t\t\t\t\"ConnectCache\"\n\t\t\t\t{{\n{cache_entries}\t\t\t\t}}\n\t\t\t}}\n\t\t}}\n\t}}\n}}\n"
),
)
.unwrap();
}
fn user_block(id: u64, name: &str, extra: &str) -> String {
format!("\t\"{id}\"\n\t{{\n\t\t\"AccountName\"\t\t\"{name}\"\n{extra}\t}}\n")
}
#[test]
fn crc_prefix_is_zero_padded_lowercase_hex_of_lowercased_name() {
assert_eq!(
connect_cache_key_prefix("Ada"),
format!("{:08x}", crc32fast::hash(b"ada"))
);
assert_eq!(connect_cache_key_prefix("x").len(), 8);
}
#[test]
fn encrypts_a_known_token_and_decrypts_it_back() {
let token = jwt_for(ID);
let blob = encrypt_blob(&token, "AdaLovelace");
let clear = decrypt_connect_cache(&blob, "adalovelace").unwrap();
assert_eq!(clear.as_str(), token);
assert_eq!(jwt_steam_id(&clear), Some(ID));
assert!(decrypt_connect_cache(&blob, "someone_else").is_none());
assert!(decrypt_connect_cache("zz", "adalovelace").is_none());
assert!(decrypt_connect_cache("00ff", "adalovelace").is_none());
}
#[test]
fn loads_saved_login_with_mixed_case_keys_and_auto_login_user() {
let root = temp_dir("load");
let token = jwt_for(ID);
let other = ID + 1;
let users = format!(
"\"users\"\n{{\n{}{}}}\n",
user_block(other, "second", "\t\t\"MostRecent\"\t\t\"1\"\n"),
user_block(ID, "AdaLovelace", "\t\t\"RememberPassword\"\t\t\"1\"\n"),
);
let entry = format!(
"\t\t\t\t\t\"{}1\"\t\t\"{}\"\n",
connect_cache_key_prefix("AdaLovelace").to_uppercase(),
encrypt_blob(&token, "AdaLovelace")
);
write_root(&root, &users, &entry);
let registry = root.join("registry.vdf");
fs::write(
&registry,
"\"Registry\"\n{\n\t\"HKCU\"\n\t{\n\t\t\"Software\"\n\t\t{\n\t\t\t\"Valve\"\n\t\t\t{\n\t\t\t\t\"Steam\"\n\t\t\t\t{\n\t\t\t\t\t\"AutoLoginUser\"\t\t\"adalovelace\"\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n",
)
.unwrap();
let login = load_saved_login(std::slice::from_ref(&root), Some(&registry)).unwrap();
assert_eq!(login.account, "AdaLovelace");
assert_eq!(login.steam_id, ID);
assert_eq!(login.token.as_str(), token);
assert!(!format!("{login:?}").contains(&token));
// Without AutoLoginUser the MostRecent account wins; it has no token saved.
assert_eq!(
load_saved_login(std::slice::from_ref(&root), None).unwrap_err(),
SigninError::RememberMeOff
);
let _ = fs::remove_dir_all(&root);
}
#[test]
fn reports_no_login_remember_me_off_and_decrypt_failures() {
let empty = temp_dir("empty");
assert_eq!(
load_saved_login(std::slice::from_ref(&empty), None).unwrap_err(),
SigninError::NoSavedLogin
);
let off = temp_dir("off");
write_root(
&off,
&format!(
"\"users\"\n{{\n{}}}\n",
user_block(ID, "ada", "\t\t\"RememberPassword\"\t\t\"0\"\n")
),
"",
);
assert_eq!(
load_saved_login(std::slice::from_ref(&off), None).unwrap_err(),
SigninError::RememberMeOff
);
let wrong = temp_dir("wrong");
let entry = format!(
"\t\t\t\t\t\"{}1\"\t\t\"{}\"\n",
connect_cache_key_prefix("ada"),
encrypt_blob(&jwt_for(ID + 5), "ada")
);
write_root(
&wrong,
&format!("\"users\"\n{{\n{}}}\n", user_block(ID, "ada", "")),
&entry,
);
assert_eq!(
load_saved_login(std::slice::from_ref(&wrong), None).unwrap_err(),
SigninError::DecryptFailed
);
for dir in [empty, off, wrong] {
let _ = fs::remove_dir_all(dir);
}
}
#[test]
fn newest_timestamp_wins_when_most_recent_is_absent() {
let accounts = vec![
Account {
steam_id: 1,
account_name: "old".into(),
remember_password: None,
most_recent: false,
timestamp: 10,
root_index: 0,
},
Account {
steam_id: 2,
account_name: "new".into(),
remember_password: None,
most_recent: false,
timestamp: 20,
root_index: 0,
},
];
assert_eq!(choose_account(&accounts, None).unwrap().steam_id, 2);
assert_eq!(choose_account(&accounts, Some("OLD")).unwrap().steam_id, 1);
assert_eq!(
choose_account(&accounts, Some("nobody")).unwrap().steam_id,
2
);
assert!(choose_account(&[], None).is_none());
}
}
@@ -0,0 +1,238 @@
use crate::steam::cm_server::{parse_endpoint, CmServer, CmTransport};
use serde_json::Value;
use std::time::Duration;
pub const DEFAULT_USER_AGENT: &str = "Valve/Steam HTTP Client 1.0";
pub const DIRECTORY_ENDPOINT: &str =
"https://api.steampowered.com/ISteamDirectory/GetCMListForConnect/v1/";
pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SteamDirectoryResult {
pub servers: Vec<CmServer>,
pub error: String,
pub http_status: i32,
}
impl SteamDirectoryResult {
pub fn ok(&self) -> bool {
self.error.is_empty() && !self.servers.is_empty()
}
}
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SteamDirectoryClient {
ca_bundle_path: String,
}
impl SteamDirectoryClient {
pub fn new(ca_bundle_path: impl Into<String>) -> Self {
Self {
ca_bundle_path: ca_bundle_path.into(),
}
}
pub fn ca_bundle_path(&self) -> &str {
&self.ca_bundle_path
}
pub fn build_url(cell_id: u32) -> String {
format!(
"{DIRECTORY_ENDPOINT}?cellid={cell_id}&cmtype=websockets&maxcount=20&realm=steamglobal"
)
}
pub fn fetch(&self, cell_id: u32, timeout: Duration) -> SteamDirectoryResult {
self.fetch_with_user_agent(cell_id, timeout, DEFAULT_USER_AGENT)
}
pub fn fetch_with_user_agent(
&self,
cell_id: u32,
timeout: Duration,
user_agent: &str,
) -> SteamDirectoryResult {
let url = SteamDirectoryClient::build_url(cell_id);
match self.http_get_text(&url, timeout, user_agent) {
Ok(response) => {
SteamDirectoryClient::validate_response(response.http_status, &response.body)
}
Err(error) => SteamDirectoryResult {
error,
..Default::default()
},
}
}
pub fn validate_response(http_status: i32, body: &str) -> SteamDirectoryResult {
if http_status != 200 {
return SteamDirectoryResult {
error: "non-200 HTTP status".to_string(),
http_status,
..Default::default()
};
}
let mut result = parse_directory_response(body);
result.http_status = http_status;
result
}
pub fn default_timeout() -> Duration {
DEFAULT_TIMEOUT
}
fn http_get_text(
&self,
url: &str,
timeout: Duration,
_user_agent: &str,
) -> Result<HttpTextResponse, String> {
let response = crate::steam::http::get(url, timeout, &self.ca_bundle_path)?;
Ok(HttpTextResponse {
http_status: response.status as i32,
body: String::from_utf8_lossy(&response.body).into_owned(),
})
}
}
struct HttpTextResponse {
http_status: i32,
body: String,
}
pub fn parse_directory_response(body: &str) -> SteamDirectoryResult {
let mut result = SteamDirectoryResult::default();
let root: Value = match serde_json::from_str(body) {
Ok(v) => v,
Err(e) => {
result.error = format!("json parse error: {e}");
return result;
}
};
let Some(response) = root.get("response") else {
result.error = "directory response: missing response".to_string();
return result;
};
let ok = response
.get("success")
.map(|s| {
s.as_bool()
.unwrap_or_else(|| s.as_i64().is_some_and(|n| n == 1))
})
.unwrap_or(false);
if !ok {
result.error = "directory response: success=false".to_string();
return result;
}
let Some(list) = response.get("serverlist").and_then(|v| v.as_array()) else {
result.error = "directory response: missing serverlist".to_string();
return result;
};
for entry in list {
let Some(endpoint) = entry.get("endpoint").and_then(|v| v.as_str()) else {
continue;
};
let Some((host, port)) = parse_endpoint(endpoint) else {
continue;
};
let transport = entry
.get("type")
.and_then(|v| v.as_str())
.map(parse_transport)
.unwrap_or(CmTransport::Unknown);
if transport != CmTransport::WebSocket {
continue;
}
result.servers.push(CmServer {
endpoint: endpoint.to_string(),
host,
port,
transport,
realm: entry
.get("realm")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string(),
datacenter: entry
.get("dc")
.and_then(|v| v.as_str())
.unwrap_or("")
.to_string(),
load: entry.get("load").and_then(|v| v.as_i64()).unwrap_or(0) as i32,
weighted_load: entry
.get("wtd_load")
.and_then(|v| v.as_f64())
.unwrap_or(0.0) as f32,
});
}
result
}
pub fn parse_transport(s: &str) -> CmTransport {
match s {
"websockets" | "websocket" => CmTransport::WebSocket,
"netfilter" => CmTransport::Tcp,
_ => CmTransport::Unknown,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_websocket_entries_and_filters_tcp() {
let json = r#"{
"response": {
"success": 1,
"serverlist": [
{"endpoint":"ext1-sea1.steamserver.net:443","type":"websockets","realm":"steamglobal","dc":"sea1","load":1,"wtd_load":2.5},
{"endpoint":"tcp.example.com:27017","type":"netfilter"},
{"endpoint":"bad","type":"websockets"}
]
}
}"#;
let result = parse_directory_response(json);
assert!(result.error.is_empty());
assert_eq!(result.servers.len(), 1);
assert_eq!(result.servers[0].host, "ext1-sea1.steamserver.net");
assert_eq!(result.servers[0].weighted_load, 2.5);
}
#[test]
fn accepts_boolean_success() {
let json = r#"{"response":{"success":true,"serverlist":[]}}"#;
let result = parse_directory_response(json);
assert!(result.error.is_empty());
assert!(result.servers.is_empty());
}
#[test]
fn builds_directory_url_and_tracks_ca_bundle() {
let client = SteamDirectoryClient::new("/cacert.pem");
assert_eq!(client.ca_bundle_path(), "/cacert.pem");
assert_eq!(
SteamDirectoryClient::default_timeout(),
Duration::from_secs(10)
);
assert_eq!(
SteamDirectoryClient::build_url(123),
"https://api.steampowered.com/ISteamDirectory/GetCMListForConnect/v1/?cellid=123&cmtype=websockets&maxcount=20&realm=steamglobal"
);
}
#[test]
fn validates_http_status_before_json() {
let result = SteamDirectoryClient::validate_response(503, "{}");
assert_eq!(result.http_status, 503);
assert_eq!(result.error, "non-200 HTTP status");
let ok = SteamDirectoryClient::validate_response(
200,
r#"{"response":{"success":1,"serverlist":[{"endpoint":"ext1-sea1.steamserver.net:443","type":"websockets"}]}}"#,
);
assert_eq!(ok.http_status, 200);
assert!(ok.ok());
}
}
@@ -0,0 +1,36 @@
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum TransportState {
Disconnected,
Connecting,
Connected,
Disconnecting,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[repr(u8)]
pub enum TransportDisconnectReason {
UserInitiated,
RemoteClose,
TlsHandshakeFailed,
NetworkError,
HandshakeTimeout,
Unknown,
}
pub type MessageCallback = Box<dyn Fn(&[u8]) + Send + Sync>;
pub type ConnectedCallback = Box<dyn Fn() + Send + Sync>;
pub type DisconnectedCallback = Box<dyn Fn(TransportDisconnectReason, &str) + Send + Sync>;
pub trait Transport: Send {
fn connect(&mut self, url: &str) -> bool;
fn send(&mut self, data: &[u8]) -> bool;
fn disconnect(&mut self);
fn state(&self) -> TransportState;
fn set_on_message(&mut self, cb: MessageCallback);
fn set_on_connected(&mut self, cb: ConnectedCallback);
fn set_on_disconnected(&mut self, cb: DisconnectedCallback);
fn set_ca_bundle_path(&mut self, _path: &str) {}
}
+514
View File
@@ -0,0 +1,514 @@
#[derive(Clone, Debug, PartialEq)]
pub enum KVValue {
Object,
String(String),
Int32(i32),
Float32(f32),
UInt32(u32),
WideString(Vec<u16>),
UInt64(u64),
Int64(i64),
}
#[derive(Clone, Debug, PartialEq)]
pub struct KVNode {
pub name: String,
pub value: KVValue,
pub children: Vec<KVNode>,
}
impl KVNode {
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
value: KVValue::Object,
children: Vec::new(),
}
}
pub fn is_object(&self) -> bool {
matches!(self.value, KVValue::Object)
}
pub fn child(&self, key: &str) -> Option<&KVNode> {
self.children
.iter()
.find(|c| c.name.eq_ignore_ascii_case(key))
}
pub fn as_string(&self, fallback: &str) -> String {
match &self.value {
KVValue::String(v) => v.clone(),
KVValue::Int32(v) => v.to_string(),
KVValue::Float32(v) => v.to_string(),
KVValue::UInt32(v) => v.to_string(),
KVValue::UInt64(v) => v.to_string(),
KVValue::Int64(v) => v.to_string(),
_ => fallback.to_string(),
}
}
pub fn as_int(&self, fallback: i64) -> i64 {
match &self.value {
KVValue::Int32(v) => *v as i64,
KVValue::Int64(v) => *v,
KVValue::UInt32(v) => *v as i64,
KVValue::UInt64(v) => *v as i64,
KVValue::String(v) => v.parse().unwrap_or(fallback),
_ => fallback,
}
}
pub fn as_uint(&self, fallback: u64) -> u64 {
match &self.value {
KVValue::UInt32(v) => *v as u64,
KVValue::UInt64(v) => *v,
KVValue::Int32(v) => *v as u64,
KVValue::Int64(v) => *v as u64,
KVValue::String(v) => v.parse().unwrap_or(fallback),
_ => fallback,
}
}
pub fn as_bool(&self, fallback: bool) -> bool {
match &self.value {
KVValue::Int32(v) => *v != 0,
KVValue::Int64(v) => *v != 0,
KVValue::UInt32(v) => *v != 0,
KVValue::UInt64(v) => *v != 0,
KVValue::String(v)
if v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes") =>
{
true
}
KVValue::String(v)
if v == "0" || v.eq_ignore_ascii_case("false") || v.eq_ignore_ascii_case("no") =>
{
false
}
_ => fallback,
}
}
}
const TYPE_NONE: u8 = 0x00;
const TYPE_STRING: u8 = 0x01;
const TYPE_INT32: u8 = 0x02;
const TYPE_FLOAT32: u8 = 0x03;
const TYPE_POINTER: u8 = 0x04;
const TYPE_WIDE_STRING: u8 = 0x05;
const TYPE_COLOR: u8 = 0x06;
const TYPE_UINT64: u8 = 0x07;
const TYPE_END: u8 = 0x08;
const TYPE_INT64: u8 = 0x09;
const TYPE_END_ALT: u8 = 0x0b;
struct Cursor<'a> {
buf: &'a [u8],
pos: usize,
ok: bool,
}
impl<'a> Cursor<'a> {
fn new(buf: &'a [u8]) -> Self {
Self {
buf,
pos: 0,
ok: true,
}
}
fn read_u8(&mut self) -> u8 {
if self.pos + 1 > self.buf.len() {
self.ok = false;
return 0;
}
let v = self.buf[self.pos];
self.pos += 1;
v
}
fn read_u32_le(&mut self) -> u32 {
if self.pos + 4 > self.buf.len() {
self.ok = false;
return 0;
}
let v = u32::from_le_bytes(self.buf[self.pos..self.pos + 4].try_into().unwrap());
self.pos += 4;
v
}
fn read_u64_le(&mut self) -> u64 {
let lo = self.read_u32_le() as u64;
let hi = self.read_u32_le() as u64;
lo | (hi << 32)
}
fn read_f32_le(&mut self) -> f32 {
f32::from_bits(self.read_u32_le())
}
fn read_cstring(&mut self) -> String {
let mut out = Vec::new();
while self.pos < self.buf.len() {
let b = self.buf[self.pos];
self.pos += 1;
if b == 0 {
return String::from_utf8_lossy(&out).into_owned();
}
out.push(b);
}
self.ok = false;
String::from_utf8_lossy(&out).into_owned()
}
fn read_wide_cstring(&mut self) -> Vec<u16> {
let mut out = Vec::new();
while self.pos + 1 < self.buf.len() {
let u = u16::from_le_bytes([self.buf[self.pos], self.buf[self.pos + 1]]);
self.pos += 2;
if u == 0 {
return out;
}
out.push(u);
}
self.ok = false;
out
}
}
fn parse_value(cursor: &mut Cursor<'_>, ty: u8, node: &mut KVNode) -> bool {
match ty {
TYPE_NONE => {
while cursor.ok {
let inner_type = cursor.read_u8();
if !cursor.ok {
return false;
}
if inner_type == TYPE_END || inner_type == TYPE_END_ALT {
return true;
}
let name = cursor.read_cstring();
if !cursor.ok {
return false;
}
let mut child = KVNode::new(name);
if !parse_value(cursor, inner_type, &mut child) {
return false;
}
node.children.push(child);
}
false
}
TYPE_STRING => {
node.value = KVValue::String(cursor.read_cstring());
cursor.ok
}
TYPE_INT32 => {
node.value = KVValue::Int32(cursor.read_u32_le() as i32);
cursor.ok
}
TYPE_FLOAT32 => {
node.value = KVValue::Float32(cursor.read_f32_le());
cursor.ok
}
TYPE_POINTER | TYPE_COLOR => {
node.value = KVValue::UInt32(cursor.read_u32_le());
cursor.ok
}
TYPE_WIDE_STRING => {
node.value = KVValue::WideString(cursor.read_wide_cstring());
cursor.ok
}
TYPE_UINT64 => {
node.value = KVValue::UInt64(cursor.read_u64_le());
cursor.ok
}
TYPE_INT64 => {
node.value = KVValue::Int64(cursor.read_u64_le() as i64);
cursor.ok
}
_ => false,
}
}
pub fn parse_binary(body: &[u8]) -> Option<KVNode> {
if body.is_empty() {
return None;
}
let mut cursor = Cursor::new(body);
let ty = cursor.read_u8();
if !cursor.ok {
return None;
}
let mut root = KVNode::new(cursor.read_cstring());
if !cursor.ok || !parse_value(&mut cursor, ty, &mut root) {
return None;
}
Some(root)
}
pub fn parse_binary_package(body: &[u8]) -> Option<(u32, KVNode)> {
if body.len() < 4 {
return None;
}
let package_id = u32::from_le_bytes(body[..4].try_into().unwrap());
Some((package_id, parse_binary(&body[4..])?))
}
pub fn parse_auto(body: &[u8]) -> Option<KVNode> {
let first = body
.iter()
.copied()
.find(|b| !matches!(b, b' ' | b'\t' | b'\n' | b'\r'))?;
if first == b'"' {
parse_text(body)
} else {
parse_binary(body)
}
}
struct TextCursor<'a> {
buf: &'a [u8],
pos: usize,
ok: bool,
}
impl<'a> TextCursor<'a> {
fn new(buf: &'a [u8]) -> Self {
Self {
buf,
pos: 0,
ok: true,
}
}
fn eof(&self) -> bool {
self.pos >= self.buf.len()
}
fn peek(&self) -> u8 {
self.buf.get(self.pos).copied().unwrap_or(0)
}
fn next(&mut self) -> u8 {
let b = self.peek();
if !self.eof() {
self.pos += 1;
}
b
}
fn skip_ws_and_comments(&mut self) {
while self.pos < self.buf.len() {
match self.buf[self.pos] {
b' ' | b'\t' | b'\n' | b'\r' => self.pos += 1,
b'/' if self.buf.get(self.pos + 1) == Some(&b'/') => {
self.pos += 2;
while self.pos < self.buf.len() && self.buf[self.pos] != b'\n' {
self.pos += 1;
}
}
b'/' if self.buf.get(self.pos + 1) == Some(&b'*') => {
self.pos += 2;
while self.pos + 1 < self.buf.len()
&& !(self.buf[self.pos] == b'*' && self.buf[self.pos + 1] == b'/')
{
self.pos += 1;
}
self.pos = (self.pos + 2).min(self.buf.len());
}
_ => break,
}
}
}
fn read_token(&mut self) -> Option<String> {
self.skip_ws_and_comments();
if self.eof() {
return None;
}
if self.peek() == b'"' {
self.pos += 1;
let mut out = Vec::new();
while !self.eof() {
let c = self.next();
if c == b'"' {
return Some(String::from_utf8_lossy(&out).into_owned());
}
if c == b'\\' && !self.eof() {
out.push(match self.next() {
b'n' => b'\n',
b't' => b'\t',
b'r' => b'\r',
b'\\' => b'\\',
b'"' => b'"',
other => other,
});
} else {
out.push(c);
}
}
self.ok = false;
return None;
}
let start = self.pos;
while !self.eof() {
let c = self.peek();
if matches!(c, b' ' | b'\t' | b'\n' | b'\r' | b'{' | b'}' | b'"') {
break;
}
self.pos += 1;
}
(self.pos > start).then(|| String::from_utf8_lossy(&self.buf[start..self.pos]).into_owned())
}
}
fn parse_text_object(cursor: &mut TextCursor<'_>, parent: &mut KVNode) -> bool {
loop {
cursor.skip_ws_and_comments();
if cursor.eof() {
return true;
}
if cursor.peek() == b'}' {
cursor.pos += 1;
return true;
}
let Some(key) = cursor.read_token() else {
return cursor.ok;
};
cursor.skip_ws_and_comments();
if cursor.eof() {
return false;
}
let mut child = KVNode::new(key);
if cursor.peek() == b'{' {
cursor.pos += 1;
if !parse_text_object(cursor, &mut child) {
return false;
}
} else {
let Some(value) = cursor.read_token() else {
return false;
};
child.value = KVValue::String(value);
}
parent.children.push(child);
}
}
pub fn parse_text(body: &[u8]) -> Option<KVNode> {
let mut cursor = TextCursor::new(body);
cursor.skip_ws_and_comments();
let key = cursor.read_token()?;
cursor.skip_ws_and_comments();
if cursor.peek() != b'{' {
return None;
}
cursor.pos += 1;
let mut root = KVNode::new(key);
parse_text_object(&mut cursor, &mut root).then_some(root)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_text_vdf_with_comments_and_case_insensitive_lookup() {
let text = br#"
// comment
"appinfo" {
"appid" "480"
"Common" { "name" "Spacewar" "type" "Game" }
/* block */ "enabled" "true"
}
"#;
let root = parse_text(text).unwrap();
assert_eq!(root.name, "appinfo");
assert_eq!(root.child("APPID").unwrap().as_int(0), 480);
assert_eq!(
root.child("common")
.unwrap()
.child("NAME")
.unwrap()
.as_string(""),
"Spacewar"
);
assert!(root.child("enabled").unwrap().as_bool(false));
}
#[test]
fn parses_binary_tree() {
let mut bytes = Vec::new();
bytes.extend_from_slice(&[TYPE_NONE]);
bytes.extend_from_slice(b"root\0");
bytes.extend_from_slice(&[TYPE_STRING]);
bytes.extend_from_slice(b"name\0Spacewar\0");
bytes.extend_from_slice(&[TYPE_INT32]);
bytes.extend_from_slice(b"appid\0");
bytes.extend_from_slice(&480i32.to_le_bytes());
bytes.extend_from_slice(&[TYPE_END]);
let root = parse_binary(&bytes).unwrap();
assert!(root.is_object());
assert_eq!(root.child("name").unwrap().as_string(""), "Spacewar");
assert_eq!(root.child("appid").unwrap().as_int(0), 480);
}
#[test]
fn parses_package_prefix() {
let mut bytes = 123u32.to_le_bytes().to_vec();
bytes.extend_from_slice(&[TYPE_NONE]);
bytes.extend_from_slice(b"package\0");
bytes.extend_from_slice(&[TYPE_END]);
let (package_id, root) = parse_binary_package(&bytes).unwrap();
assert_eq!(package_id, 123);
assert_eq!(root.name, "package");
}
// Manifest gid/size/download: proves the parser reads download (the 3rd value)
// correctly, ruling out a parser cause for the stale corrupt download sizes.
#[test]
fn parses_manifest_uint64_gid_size_download() {
let gid: u64 = 8072044898226043193;
let size: u64 = 30738676601;
let download: u64 = 15000000000;
let mut b = vec![TYPE_NONE];
b.extend_from_slice(b"public\0");
b.push(TYPE_UINT64);
b.extend_from_slice(b"gid\0");
b.extend_from_slice(&gid.to_le_bytes());
b.push(TYPE_UINT64);
b.extend_from_slice(b"size\0");
b.extend_from_slice(&size.to_le_bytes());
b.push(TYPE_UINT64);
b.extend_from_slice(b"download\0");
b.extend_from_slice(&download.to_le_bytes());
b.push(TYPE_END);
let root = parse_binary(&b).unwrap();
assert_eq!(root.child("gid").unwrap().as_string(""), gid.to_string());
assert_eq!(root.child("size").unwrap().as_string(""), size.to_string());
assert_eq!(
root.child("download").unwrap().as_string(""),
download.to_string()
);
}
#[test]
fn parses_manifest_text_vdf() {
let text = br#"
"public"
{
"gid" "8072044898226043193"
"size" "30738676601"
"download" "15000000000"
}
"#;
let root = parse_text(text).unwrap();
assert_eq!(root.child("size").unwrap().as_string(""), "30738676601");
assert_eq!(root.child("download").unwrap().as_string(""), "15000000000");
}
}
@@ -0,0 +1,154 @@
pub fn read_u16_le(p: &[u8]) -> u16 {
u16::from_le_bytes([p[0], p[1]])
}
pub fn read_u32_le(p: &[u8]) -> u32 {
u32::from_le_bytes([p[0], p[1], p[2], p[3]])
}
pub fn read_u64_le(p: &[u8]) -> u64 {
u64::from_le_bytes([p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]])
}
pub fn write_u16_le(out: &mut [u8], v: u16) {
out[..2].copy_from_slice(&v.to_le_bytes());
}
pub fn write_u32_le(out: &mut [u8], v: u32) {
out[..4].copy_from_slice(&v.to_le_bytes());
}
pub fn write_u64_le(out: &mut [u8], v: u64) {
out[..8].copy_from_slice(&v.to_le_bytes());
}
pub struct Reader<'a> {
buf: &'a [u8],
pos: usize,
ok: bool,
}
impl<'a> Reader<'a> {
pub fn new(buf: &'a [u8]) -> Self {
Self {
buf,
pos: 0,
ok: true,
}
}
pub fn ok(&self) -> bool {
self.ok
}
pub fn position(&self) -> usize {
self.pos
}
pub fn remaining(&self) -> usize {
self.buf.len().saturating_sub(self.pos)
}
pub fn u16(&mut self) -> u16 {
if !self.check(2) {
return 0;
}
let v = read_u16_le(&self.buf[self.pos..]);
self.pos += 2;
v
}
pub fn u32(&mut self) -> u32 {
if !self.check(4) {
return 0;
}
let v = read_u32_le(&self.buf[self.pos..]);
self.pos += 4;
v
}
pub fn u64(&mut self) -> u64 {
if !self.check(8) {
return 0;
}
let v = read_u64_le(&self.buf[self.pos..]);
self.pos += 8;
v
}
pub fn bytes(&mut self, n: usize) -> &'a [u8] {
if !self.check(n) {
return &[];
}
let out = &self.buf[self.pos..self.pos + n];
self.pos += n;
out
}
fn check(&mut self, n: usize) -> bool {
if !self.ok || self.remaining() < n {
self.ok = false;
return false;
}
true
}
}
pub struct Writer<'a> {
out: &'a mut Vec<u8>,
}
impl<'a> Writer<'a> {
pub fn new(out: &'a mut Vec<u8>) -> Self {
Self { out }
}
pub fn u16(&mut self, v: u16) {
self.out.extend_from_slice(&v.to_le_bytes());
}
pub fn u32(&mut self, v: u32) {
self.out.extend_from_slice(&v.to_le_bytes());
}
pub fn u64(&mut self, v: u64) {
self.out.extend_from_slice(&v.to_le_bytes());
}
pub fn bytes(&mut self, bytes: &[u8]) {
self.out.extend_from_slice(bytes);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reader_writer_little_endian_roundtrip() {
let mut buf = Vec::new();
let mut writer = Writer::new(&mut buf);
writer.u16(0x1234);
writer.u32(0x89ab_cdef);
writer.u64(0x0123_4567_89ab_cdef);
assert_eq!(
buf,
[0x34, 0x12, 0xef, 0xcd, 0xab, 0x89, 0xef, 0xcd, 0xab, 0x89, 0x67, 0x45, 0x23, 0x01]
);
let mut reader = Reader::new(&buf);
assert_eq!(reader.u16(), 0x1234);
assert_eq!(reader.u32(), 0x89ab_cdef);
assert_eq!(reader.u64(), 0x0123_4567_89ab_cdef);
assert!(reader.ok());
assert_eq!(reader.remaining(), 0);
}
#[test]
fn reader_short_input_flips_ok() {
let mut reader = Reader::new(&[1, 2, 3]);
assert_eq!(reader.u32(), 0);
assert!(!reader.ok());
}
}
@@ -0,0 +1,446 @@
use crate::steam::transport::{Transport, TransportDisconnectReason, TransportState};
use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use tungstenite::error::Error as WsError;
use tungstenite::stream::MaybeTlsStream;
use tungstenite::{connect, Message};
const NORMAL_CLOSE_CODE: u16 = 1000;
const READ_POLL_TIMEOUT: Duration = Duration::from_millis(100);
type MessageCallback = Arc<dyn Fn(&[u8]) + Send + Sync + 'static>;
type ConnectedCallback = Arc<dyn Fn() + Send + Sync + 'static>;
type DisconnectedCallback = Arc<dyn Fn(TransportDisconnectReason, &str) + Send + Sync + 'static>;
pub struct WsConnection {
shared: Arc<WsConnectionShared>,
sender: Mutex<Option<mpsc::Sender<WsCommand>>>,
worker: Mutex<Option<JoinHandle<()>>>,
}
#[derive(Default)]
struct WsConnectionShared {
state: AtomicU8,
user_initiated_close: AtomicBool,
ca_bundle_path: Mutex<String>,
on_message: Mutex<Option<MessageCallback>>,
on_connected: Mutex<Option<ConnectedCallback>>,
on_disconnected: Mutex<Option<DisconnectedCallback>>,
}
enum WsCommand {
Send(Vec<u8>),
Disconnect,
}
impl WsConnection {
pub fn new() -> Self {
Self {
shared: Arc::new(WsConnectionShared {
state: AtomicU8::new(TransportState::Disconnected as u8),
user_initiated_close: AtomicBool::new(false),
ca_bundle_path: Mutex::new(String::new()),
on_message: Mutex::new(None),
on_connected: Mutex::new(None),
on_disconnected: Mutex::new(None),
}),
sender: Mutex::new(None),
worker: Mutex::new(None),
}
}
pub fn set_ca_bundle_path(&self, path: &str) {
*self
.shared
.ca_bundle_path
.lock()
.expect("ws connection poisoned") = path.to_string();
}
pub fn ca_bundle_path(&self) -> String {
self.shared
.ca_bundle_path
.lock()
.expect("ws connection poisoned")
.clone()
}
pub fn state(&self) -> TransportState {
match self.shared.state.load(Ordering::Relaxed) {
1 => TransportState::Connecting,
2 => TransportState::Connected,
3 => TransportState::Disconnecting,
_ => TransportState::Disconnected,
}
}
pub fn transition_connecting(&self) -> bool {
self.shared
.user_initiated_close
.store(false, Ordering::Relaxed);
self.shared
.state
.compare_exchange(
TransportState::Disconnected as u8,
TransportState::Connecting as u8,
Ordering::AcqRel,
Ordering::Acquire,
)
.is_ok()
}
pub fn mark_connected(&self) {
self.shared.mark_connected();
}
pub fn mark_disconnected(&self, close_code: u16, detail: &str, tls_failed: bool) {
self.shared
.mark_disconnected(close_code, detail, tls_failed);
}
pub fn mark_user_disconnect(&self) {
self.shared
.user_initiated_close
.store(true, Ordering::Relaxed);
self.shared
.state
.store(TransportState::Disconnecting as u8, Ordering::Release);
}
pub fn deliver_binary(&self, data: &[u8]) {
self.shared.deliver_binary(data);
}
pub fn set_on_message<F>(&self, cb: F)
where
F: Fn(&[u8]) + Send + Sync + 'static,
{
*self
.shared
.on_message
.lock()
.expect("ws connection poisoned") = Some(Arc::new(cb));
}
pub fn set_on_connected<F>(&self, cb: F)
where
F: Fn() + Send + Sync + 'static,
{
*self
.shared
.on_connected
.lock()
.expect("ws connection poisoned") = Some(Arc::new(cb));
}
pub fn set_on_disconnected<F>(&self, cb: F)
where
F: Fn(TransportDisconnectReason, &str) + Send + Sync + 'static,
{
*self
.shared
.on_disconnected
.lock()
.expect("ws connection poisoned") = Some(Arc::new(cb));
}
fn connect_worker(&self, url: &str) -> bool {
if !self.transition_connecting() {
return false;
}
let (tx, rx) = mpsc::channel();
*self.sender.lock().expect("ws connection poisoned") = Some(tx);
let shared = Arc::clone(&self.shared);
let url = url.to_string();
let worker = thread::spawn(move || run_ws_worker(shared, url, rx));
*self.worker.lock().expect("ws connection poisoned") = Some(worker);
true
}
}
impl Transport for WsConnection {
fn connect(&mut self, url: &str) -> bool {
self.connect_worker(url)
}
fn send(&mut self, data: &[u8]) -> bool {
if self.state() != TransportState::Connected {
return false;
}
self.sender
.lock()
.expect("ws connection poisoned")
.as_ref()
.is_some_and(|tx| tx.send(WsCommand::Send(data.to_vec())).is_ok())
}
fn disconnect(&mut self) {
if self.state() == TransportState::Disconnected {
return;
}
self.mark_user_disconnect();
let sent = self
.sender
.lock()
.expect("ws connection poisoned")
.as_ref()
.is_some_and(|tx| tx.send(WsCommand::Disconnect).is_ok());
if !sent {
self.mark_disconnected(NORMAL_CLOSE_CODE, "client disconnect", false);
}
}
fn state(&self) -> TransportState {
WsConnection::state(self)
}
fn set_on_message(&mut self, cb: Box<dyn Fn(&[u8]) + Send + Sync>) {
*self
.shared
.on_message
.lock()
.expect("ws connection poisoned") = Some(Arc::from(cb));
}
fn set_on_connected(&mut self, cb: Box<dyn Fn() + Send + Sync>) {
*self
.shared
.on_connected
.lock()
.expect("ws connection poisoned") = Some(Arc::from(cb));
}
fn set_on_disconnected(
&mut self,
cb: Box<dyn Fn(TransportDisconnectReason, &str) + Send + Sync>,
) {
*self
.shared
.on_disconnected
.lock()
.expect("ws connection poisoned") = Some(Arc::from(cb));
}
fn set_ca_bundle_path(&mut self, path: &str) {
WsConnection::set_ca_bundle_path(self, path);
}
}
impl Default for WsConnection {
fn default() -> Self {
Self::new()
}
}
impl Drop for WsConnection {
fn drop(&mut self) {
self.disconnect();
}
}
impl WsConnectionShared {
fn mark_connected(&self) {
self.state
.store(TransportState::Connected as u8, Ordering::Release);
if let Some(cb) = self
.on_connected
.lock()
.expect("ws connection poisoned")
.clone()
{
cb();
}
}
fn mark_disconnected(&self, close_code: u16, detail: &str, tls_failed: bool) {
self.state
.store(TransportState::Disconnected as u8, Ordering::Release);
let reason = if self.user_initiated_close.load(Ordering::Relaxed) {
TransportDisconnectReason::UserInitiated
} else {
map_close_reason(close_code, tls_failed)
};
if let Some(cb) = self
.on_disconnected
.lock()
.expect("ws connection poisoned")
.clone()
{
cb(reason, detail);
}
}
fn deliver_binary(&self, data: &[u8]) {
if let Some(cb) = self
.on_message
.lock()
.expect("ws connection poisoned")
.clone()
{
cb(data);
}
}
}
fn run_ws_worker(shared: Arc<WsConnectionShared>, url: String, rx: mpsc::Receiver<WsCommand>) {
let (mut socket, _) = match connect(url.as_str()) {
Ok(connection) => connection,
Err(err) => {
let detail = err.to_string();
let reason = map_error_reason(&detail, false);
shared.mark_disconnected(reason_to_close_code(reason), &detail, false);
return;
}
};
let _ = set_read_timeout(socket.get_mut(), Some(READ_POLL_TIMEOUT));
shared.mark_connected();
loop {
while let Ok(cmd) = rx.try_recv() {
match cmd {
WsCommand::Send(data) => {
if let Err(err) = socket.send(Message::Binary(data.into())) {
let detail = err.to_string();
let reason = map_error_reason(&detail, false);
shared.mark_disconnected(reason_to_close_code(reason), &detail, false);
return;
}
}
WsCommand::Disconnect => {
let _ = socket.close(None);
shared.mark_disconnected(NORMAL_CLOSE_CODE, "client disconnect", false);
return;
}
}
}
match socket.read() {
Ok(Message::Binary(bytes)) => shared.deliver_binary(&bytes),
Ok(Message::Close(frame)) => {
let detail = frame
.as_ref()
.map(|frame| frame.reason.to_string())
.unwrap_or_else(|| "remote close".to_string());
let code = frame
.map(|frame| u16::from(frame.code))
.unwrap_or(NORMAL_CLOSE_CODE);
shared.mark_disconnected(code, &detail, false);
return;
}
Ok(Message::Ping(_) | Message::Pong(_) | Message::Text(_) | Message::Frame(_)) => {}
Err(err) if is_timeout_error(&err) => {}
Err(WsError::ConnectionClosed | WsError::AlreadyClosed) => {
shared.mark_disconnected(NORMAL_CLOSE_CODE, "remote close", false);
return;
}
Err(err) => {
let detail = err.to_string();
let reason = map_error_reason(&detail, false);
shared.mark_disconnected(reason_to_close_code(reason), &detail, false);
return;
}
}
}
}
fn set_read_timeout(
stream: &mut MaybeTlsStream<std::net::TcpStream>,
timeout: Option<Duration>,
) -> std::io::Result<()> {
match stream {
MaybeTlsStream::Plain(stream) => stream.set_read_timeout(timeout),
MaybeTlsStream::Rustls(stream) => stream.sock.set_read_timeout(timeout),
#[allow(unreachable_patterns)]
_ => Ok(()),
}
}
fn is_timeout_error(err: &WsError) -> bool {
matches!(err, WsError::Io(io) if matches!(
io.kind(),
std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut
))
}
fn reason_to_close_code(reason: TransportDisconnectReason) -> u16 {
match reason {
TransportDisconnectReason::RemoteClose | TransportDisconnectReason::UserInitiated => {
NORMAL_CLOSE_CODE
}
_ => 0,
}
}
pub fn map_close_reason(close_code: u16, tls_handshake_failed: bool) -> TransportDisconnectReason {
if tls_handshake_failed {
TransportDisconnectReason::TlsHandshakeFailed
} else if (1000..1016).contains(&close_code) {
TransportDisconnectReason::RemoteClose
} else {
TransportDisconnectReason::Unknown
}
}
pub fn map_error_reason(reason: &str, user_initiated: bool) -> TransportDisconnectReason {
if user_initiated {
return TransportDisconnectReason::UserInitiated;
}
let tls_failed = reason.contains("tls")
|| reason.contains("TLS")
|| reason.contains("SSL")
|| reason.contains("certificate");
map_close_reason(0, tls_failed)
}
pub fn normal_close_code() -> u16 {
NORMAL_CLOSE_CODE
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::mpsc;
#[test]
fn maps_close_reasons() {
assert_eq!(
map_close_reason(0, true),
TransportDisconnectReason::TlsHandshakeFailed
);
assert_eq!(
map_close_reason(1000, false),
TransportDisconnectReason::RemoteClose
);
assert_eq!(
map_close_reason(2000, false),
TransportDisconnectReason::Unknown
);
assert_eq!(normal_close_code(), 1000);
assert_eq!(
map_error_reason("TLS certificate verify failed", false),
TransportDisconnectReason::TlsHandshakeFailed
);
assert_eq!(
map_error_reason("connection reset", false),
TransportDisconnectReason::Unknown
);
assert_eq!(
map_error_reason("connection reset", true),
TransportDisconnectReason::UserInitiated
);
}
#[test]
fn transitions_and_callbacks_fire() {
let ws = WsConnection::new();
let (tx, rx) = mpsc::channel();
ws.set_on_connected(move || tx.send("connected").unwrap());
assert!(ws.transition_connecting());
assert!(!ws.transition_connecting());
ws.mark_connected();
assert_eq!(ws.state(), TransportState::Connected);
assert_eq!(rx.recv().unwrap(), "connected");
}
}