Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-02-25 20:01:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1922479 - update neqo to v0.9.1 r=kershaw,necko-reviewers

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D224482
This commit is contained in:
Max Inden 2024-10-07 07:14:04 +00:00
parent 5532794a77
commit 00ba6754b5
49 changed files with 567 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.cargo/config.toml.in
View File

@ -90,9 +90,9 @@ git = "https://github.com/mozilla/mp4parse-rust"
rev = "a138e40ec1c603615873e524b5b22e11c0ec4820"
replace-with = "vendored-sources"
[source."git+https://github.com/mozilla/neqo?tag=v0.9.0"]
[source."git+https://github.com/mozilla/neqo?tag=v0.9.1"]
git = "https://github.com/mozilla/neqo"
tag = "v0.9.0"
tag = "v0.9.1"
replace-with = "vendored-sources"
[source."git+https://github.com/servo/unicode-bidi?rev=ca612daf1c08c53abe07327cb3e6ef6e0a760f0c"]

28
Cargo.lock generated
View File

@ -4236,8 +4236,8 @@ dependencies = [
[[package]]
name = "neqo-bin"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"clap",
"clap-verbosity-flag",
@ -4258,8 +4258,8 @@ dependencies = [
[[package]]
name = "neqo-common"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"enum-map",
"env_logger",
@ -4270,8 +4270,8 @@ dependencies = [
[[package]]
name = "neqo-crypto"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"bindgen 0.69.4",
"log",
@ -4285,8 +4285,8 @@ dependencies = [
[[package]]
name = "neqo-http3"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"enumset",
"log",
@ -4301,8 +4301,8 @@ dependencies = [
[[package]]
name = "neqo-qpack"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"log",
"neqo-common",
@ -4313,8 +4313,8 @@ dependencies = [
[[package]]
name = "neqo-transport"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"enum-map",
"indexmap 2.2.6",
@ -4328,8 +4328,8 @@ dependencies = [
[[package]]
name = "neqo-udp"
version = "0.9.0"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.0#28f60bd0ba3209ecba4102eec123859a3a8afd45"
version = "0.9.1"
source = "git+https://github.com/mozilla/neqo?tag=v0.9.1#1708886bc9750677b1c43f4d8fc4b89367736198"
dependencies = [
"log",
"neqo-common",

12
netwerk/socket/neqo_glue/Cargo.toml
View File

@ -10,11 +10,11 @@ name = "neqo_glue"
[dependencies]
firefox-on-glean = { path = "../../../toolkit/components/glean/api" }
neqo-udp = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-http3 = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-transport = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-common = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-qpack = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-udp = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-http3 = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-transport = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-common = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-qpack = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
nserror = { path = "../../../xpcom/rust/nserror" }
nsstring = { path = "../../../xpcom/rust/nsstring" }
xpcom = { path = "../../../xpcom/rust/xpcom" }
@ -29,7 +29,7 @@ uuid = { version = "1.0", features = ["v4"] }
winapi = {version = "0.3", features = ["ws2def"] }
[dependencies.neqo-crypto]
tag = "v0.9.0"
tag = "v0.9.1"
git = "https://github.com/mozilla/neqo"
default-features = false
features = ["gecko"]

12
netwerk/test/http3server/Cargo.toml
View File

@ -6,11 +6,11 @@ edition = "2018"
license = "MPL-2.0"
[dependencies]
neqo-bin = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-transport = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-common = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-http3 = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-qpack = { tag = "v0.9.0", git = "https://github.com/mozilla/neqo" }
neqo-bin = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-transport = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-common = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-http3 = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
neqo-qpack = { tag = "v0.9.1", git = "https://github.com/mozilla/neqo" }
log = "0.4.0"
base64 = "0.21"
cfg-if = "1.0"
@ -20,7 +20,7 @@ tokio = { version = "1", features = ["rt-multi-thread"] }
mozilla-central-workspace-hack = { version = "0.1", features = ["http3server"], optional = true }
[dependencies.neqo-crypto]
tag = "v0.9.0"
tag = "v0.9.1"
git = "https://github.com/mozilla/neqo"
default-features = false
features = ["gecko"]

2
third_party/rust/neqo-bin/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"d92e72cb2dfb8fa745963ec43314590b8c9d69f21a9068f58d53bdd6d2193282","benches/main.rs":"aa39bf1f08863e3bace034a991c60a4723f1a7d30b3fc1d1f8c4d7f73bc748c3","src/bin/client.rs":"db77efd75dc0745b6dd983ab8fa3bc8f5f9111967f0d90d23cb19140a940246d","src/bin/server.rs":"2f7ab3c7a98117bd162e6fd07abef1d21791d1bb240db3aae61afa6ff72df83a","src/client/http09.rs":"1849b2ba103ad0e6b365aa63a272457d798d0635db2711e0a88496feb6336d5b","src/client/http3.rs":"de98fc88347b5216911c9536420e6557c50241267064c0f62b5b77789db62ffa","src/client/mod.rs":"6423e41fc351ae36868a165e9bca172aac9c08195f67ca91b692f0ca58979c95","src/lib.rs":"3264b53d5d9d99420dab92578572ac7c4b3ece747840c115d2a0db6a420d56e8","src/server/http09.rs":"9ffb0f62c6202a2914086b7e1d8ba77e016c1b4f4a9895b268a6312a04ad70e3","src/server/http3.rs":"0bdab101bffda37257360f9a968d32ff8884b40f292878f3dc27b055e0b5864b","src/server/mod.rs":"e1edfc71853f8b5be96287391919dc84d24191e865f7b9b4a38eebfda07ce453","src/udp.rs":"9042b73c20223e1c7b45d862dea9417fc367032db09dd05d48ca06ac33638435"},"package":null}
{"files":{"Cargo.toml":"af3835a499a384af73c47f30ff52f2296ccf73500d3fa10a9d6eeba61824b7c0","benches/main.rs":"aa39bf1f08863e3bace034a991c60a4723f1a7d30b3fc1d1f8c4d7f73bc748c3","src/bin/client.rs":"db77efd75dc0745b6dd983ab8fa3bc8f5f9111967f0d90d23cb19140a940246d","src/bin/server.rs":"2f7ab3c7a98117bd162e6fd07abef1d21791d1bb240db3aae61afa6ff72df83a","src/client/http09.rs":"1849b2ba103ad0e6b365aa63a272457d798d0635db2711e0a88496feb6336d5b","src/client/http3.rs":"de98fc88347b5216911c9536420e6557c50241267064c0f62b5b77789db62ffa","src/client/mod.rs":"4a023d1f8db9bb163752dd9db14066e8fd03c6c691abda92387c0a0d35ac0476","src/lib.rs":"3264b53d5d9d99420dab92578572ac7c4b3ece747840c115d2a0db6a420d56e8","src/server/http09.rs":"9ffb0f62c6202a2914086b7e1d8ba77e016c1b4f4a9895b268a6312a04ad70e3","src/server/http3.rs":"0bdab101bffda37257360f9a968d32ff8884b40f292878f3dc27b055e0b5864b","src/server/mod.rs":"e1edfc71853f8b5be96287391919dc84d24191e865f7b9b4a38eebfda07ce453","src/udp.rs":"9042b73c20223e1c7b45d862dea9417fc367032db09dd05d48ca06ac33638435"},"package":null}

7
third_party/rust/neqo-bin/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-bin"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = false
autobins = false
@ -135,10 +135,7 @@ default-features = false
[dev-dependencies.criterion]
version = "0.5"
features = [
"html_reports",
"async_tokio",
]
features = ["async_tokio"]
default-features = false
[dev-dependencies.tokio]

15
third_party/rust/neqo-bin/src/client/mod.rs vendored
View File

@ -245,15 +245,26 @@ impl Args {
"handshake" | "transfer" | "retry" | "ecn" => {
self.shared.use_old_http = true;
}
"zerortt" | "resumption" => {
"resumption" => {
if self.urls.len() < 2 {
qerror!("Warning: resumption tests won't work without >1 URL");
qerror!("Warning: resumption test won't work without >1 URL");
exit(127);
}
self.shared.use_old_http = true;
self.resume = true;
}
"zerortt" => {
if self.urls.len() < 2 {
qerror!("Warning: zerortt test won't work without >1 URL");
exit(127);
}
self.shared.use_old_http = true;
self.resume = true;
// PMTUD probes inflate what we sent in 1-RTT, causing QNS to fail the test.
self.shared.quic_parameters.no_pmtud = true;
// If we pace, we might get the initial server flight before sending sufficient
// 0-RTT data to pass the QNS check. So let's burst.
self.shared.quic_parameters.no_pacing = true;
}
"multiconnect" => {
self.shared.use_old_http = true;

2
third_party/rust/neqo-common/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"79cedc3f016014303f32cc50f59247629e73322b408c00c0e7cbf822cf9387e2","build.rs":"306b2f909a25ae38daf5404a4e128d2a94e8975b70870864c2a71cafec9717c7","src/codec.rs":"549ee76e90898d37102bd4eabfce69a98aaec6862785eaeb4c9af57b7a36a655","src/datagram.rs":"2acecfcbecfbb767ea920e3b22388e67b31fcda776cae5b2d7ecbc67dd9febf7","src/event.rs":"106ca6c4afb107fa49a1bc72f5eb4ae95f4baa1ba19736aa38c8ba973774c160","src/fuzz.rs":"1ca74a34bdc97fedecf8a63c4a13cc487d1b2212398fb76f67792c822002138d","src/header.rs":"480a7848466249a78acddbf0bc0b4a096189abc14a89ad1a0943be571add2c2b","src/hrtime.rs":"cbae4363ba64ff208d818d1a6ff0b42ec40a4e2b01b9cec224e57b4dc70c3830","src/incrdecoder.rs":"5c45034e61e75c76d2bca8b075c3e7a3cdd8af8c82b67c76283a2b08ab11846b","src/lib.rs":"2381fc00127a7eaf2265c3a13dc1e1d5843e048f3a8a1c97f1e6621c038de380","src/log.rs":"6ed99e15707c4256ae793011ed2f4b33aa81fed70205aaf5f8d3cd11ad451cf0","src/qlog.rs":"f53cb2a52dd7725c577d4e42065fb1c498ccc33dff0449b6889d9fbc1fdb96e2","src/tos.rs":"28fd9acfce06f68ac6691efd2609618850182f77ef3717ce2db07bfac19a9396","tests/log.rs":"a11e21fb570258ca93bb40e3923817d381e1e605accbc3aed1df5a0a9918b41d"},"package":null}
{"files":{"Cargo.toml":"e07edda5dcda7da8a42f0572578102a29e56b643539cb75b450e1a7d62591939","build.rs":"ee5dc521f3d8e18c2b617192d6b6e678f7f2f9886fdd34c0c1c5ef841419b248","src/codec.rs":"549ee76e90898d37102bd4eabfce69a98aaec6862785eaeb4c9af57b7a36a655","src/datagram.rs":"2acecfcbecfbb767ea920e3b22388e67b31fcda776cae5b2d7ecbc67dd9febf7","src/event.rs":"106ca6c4afb107fa49a1bc72f5eb4ae95f4baa1ba19736aa38c8ba973774c160","src/fuzz.rs":"1ca74a34bdc97fedecf8a63c4a13cc487d1b2212398fb76f67792c822002138d","src/header.rs":"480a7848466249a78acddbf0bc0b4a096189abc14a89ad1a0943be571add2c2b","src/hrtime.rs":"37447c51c7fd84baad31bc420bf9170c1f4e71356bb6d102bd5651ddf69a2f89","src/incrdecoder.rs":"5c45034e61e75c76d2bca8b075c3e7a3cdd8af8c82b67c76283a2b08ab11846b","src/lib.rs":"2381fc00127a7eaf2265c3a13dc1e1d5843e048f3a8a1c97f1e6621c038de380","src/log.rs":"6ed99e15707c4256ae793011ed2f4b33aa81fed70205aaf5f8d3cd11ad451cf0","src/qlog.rs":"f53cb2a52dd7725c577d4e42065fb1c498ccc33dff0449b6889d9fbc1fdb96e2","src/tos.rs":"28fd9acfce06f68ac6691efd2609618850182f77ef3717ce2db07bfac19a9396","tests/log.rs":"a11e21fb570258ca93bb40e3923817d381e1e605accbc3aed1df5a0a9918b41d"},"package":null}

2
third_party/rust/neqo-common/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-common"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = "build.rs"
autobins = false

8
third_party/rust/neqo-common/build.rs vendored
View File

@ -11,4 +11,12 @@ fn main() {
if target.contains("windows") {
println!("cargo:rustc-link-lib=winmm");
}
// `cfg(sanitize = "..")` is not stabilized.
//
// See <https://doc.rust-lang.org/stable/unstable-book/language-features/cfg-sanitize.html>.
println!("cargo:rustc-check-cfg=cfg(neqo_sanitize)");
if env::var("CARGO_CFG_SANITIZE").is_ok() {
println!("cargo:rustc-cfg=neqo_sanitize");
}
}

4
third_party/rust/neqo-common/src/hrtime.rs vendored
View File

@ -374,7 +374,9 @@ impl Drop for Time {
// inaccuracies are too high to pass the tests.
#[cfg(all(
test,
not(all(any(target_os = "macos", target_os = "windows"), feature = "ci"))
not(all(any(target_os = "macos", target_os = "windows"), feature = "ci")),
// Sanitizers are too slow to uphold timing assumptions.
not(neqo_sanitize),
))]
mod test {
use std::{

2
third_party/rust/neqo-crypto/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"9edaf4e9a0b525ad72b4106bb2cf9384c8fb47175a500d2f09eea7120f25c65d","bindings/bindings.toml":"0e06a03035a90ec5f823b30c8b78ec010a332ae0e5ed0c953da2e4c406451793","bindings/nspr_err.h":"2d5205d017b536c2d838bcf9bc4ec79f96dd50e7bb9b73892328781f1ee6629d","bindings/nspr_error.h":"e41c03c77b8c22046f8618832c9569fbcc7b26d8b9bbc35eea7168f35e346889","bindings/nspr_io.h":"085b289849ef0e77f88512a27b4d9bdc28252bd4d39c6a17303204e46ef45f72","bindings/nspr_time.h":"2e637fd338a5cf0fd3fb0070a47f474a34c2a7f4447f31b6875f5a9928d0a261","bindings/nss_ciphers.h":"95ec6344a607558b3c5ba8510f463b6295f3a2fb3f538a01410531045a5f62d1","bindings/nss_init.h":"ef49045063782fb612aff459172cc6a89340f15005808608ade5320ca9974310","bindings/nss_p11.h":"0b81e64fe6db49b2ecff94edd850be111ef99ec11220e88ceb1c67be90143a78","bindings/nss_secerr.h":"713e8368bdae5159af7893cfa517dabfe5103cede051dee9c9557c850a2defc6","bindings/nss_ssl.h":"af222fb957b989e392e762fa2125c82608a0053aff4fb97e556691646c88c335","bindings/nss_sslerr.h":"24b97f092183d8486f774cdaef5030d0249221c78343570d83a4ee5b594210ae","bindings/nss_sslopt.h":"b7807eb7abdad14db6ad7bc51048a46b065a0ea65a4508c95a12ce90e59d1eea","build.rs":"3618becbcf1d8d47fe681c13ff9fce070688c67db9d5203e6e8bc038e19a48fc","min_version.txt":"94ebbba5fc5de230ca467b7e316e9202e4a86c603b3a629cffd647859f48b730","src/aead.rs":"6410bcbe717a6b9ea6f11209b0888033358113ebc05b8a95cec1980d1360be4d","src/aead_null.rs":"81163fafef59bd2800bd0a078d53d0f05ee114f0e22165717823a5ff1cb908af","src/agent.rs":"d24f1a3df8300b93a1b606b2089bd758c9aa41c3a9e333089e6165b3449df94f","src/agentio.rs":"22e63d5efefbff41113cf002a75bb08f15228cb83e9e2cba65eb6da52dad0264","src/auth.rs":"ced1a18f691894984244088020ea25dc1ee678603317f0c7dfc8b8842fa750b4","src/cert.rs":"8e75e69ec3544474b21f8915a7559463889c2f608b201dee274a8d701880950e","src/constants.rs":"f5c779db128a8b0607841ca18c376971017eb327e102e5e6959a7d8effe4b3a6","src/ech.rs":"75dd192423e8996d9061da5e9c20d30bff5153b9344132eda4fe321c4c141870","src/err.rs":"2366501e0b48933a6a2e1c5b934aa55108c093729c84878b45e1e012e4e45d51","src/exp.rs":"d953873e87430b1c84d4a83c8eb3815041f5585b210bbaf59ae2c4d0057f5edd","src/ext.rs":"cbf7d9f5ecabf4b8c9efd6c334637ab1596ec5266d38ab8d2d6ceae305283deb","src/hkdf.rs":"8745ba761be821c1819cedf6dfd91f8b3148c6718053a4a74f33eb50c7d0cc40","src/hp.rs":"510a4a7f278203aa306ead05608f99397edc3806dc22b0af9e28c665b43ae56c","src/lib.rs":"c8bd48f9d1d2ebbccfa1224047de3cc47f8bbd0f9fbc4fe073454d0288c66856","src/min_version.rs":"c6e1f98b9f56db0622ac38c1be131c55acf4a0f09ed0d6283f4d6308e2d1301a","src/p11.rs":"375397b18fcdf36dcdd22c164c8572dd83caf01b8d0065be3029444b197e1464","src/prio.rs":"5cf0105e78b1db43c65283208174abc3714a41dbb4d5cd80ac547a5a5a7c627c","src/replay.rs":"5cda39bc8fa8a07c493b761b8dfb5cbc9f669f97a2df7832a028ab366b3426be","src/result.rs":"0587cbb6aace71a7f9765ef7c01dcd9f73a49dcc6331e1d8fe4de2aef6ca65b6","src/secrets.rs":"2c47935c5b8c42363897881eaa0c171e84cf031e57a6e1387b99327080e8dd60","src/selfencrypt.rs":"018c2dacabd3e463fdadd5707715b23c26c261c4c7d86e66c62f0acec986cad9","src/ssl.rs":"59bafcaed7caa66fe448339a1f75ce807ef92fc28247709df4f8058499b0787e","src/time.rs":"ade63a72ae90796d7fcccadbb15efc4594fcdb68913a914a657d4556fde88f62","tests/aead.rs":"e36ae77802df1ea6d17cfd1bd2178a3706089577d6fd1554ca86e748b8b235b9","tests/agent.rs":"cbd0011f1d33281883a45d433228221062424c94e86decade5697731c08a1c52","tests/ext.rs":"57af4e2df211fa8afdb73125d4344ef5c70c1ea4579107c3e6f5746308ee3e7b","tests/handshake.rs":"aa904736d36cc5d5cc0c4f6053b529987f33f944a73411bf08e01d30c4867186","tests/hkdf.rs":"1d2098dc8398395864baf13e4886cfd1da6d36118727c3b264f457ee3da6b048","tests/hp.rs":"ccda23018dac70b3ff3742afcb0fbae0735be9aeb36644a4ae2b1d7c9126801c","tests/init.rs":"3e15150c4b324c06ca5e8935618e4008da53dc0ef4b69325d150831e87dc0b63","tests/selfencrypt.rs":"8d10840b41629bf449a6b3a551377315e8a05ca26c6b041548748196652c5909"},"package":null}
{"files":{"Cargo.toml":"eb8098ab34c48d12b9ab698175195e450f9ad8555fae1e542334c042f1b0e0dd","bindings/bindings.toml":"0e06a03035a90ec5f823b30c8b78ec010a332ae0e5ed0c953da2e4c406451793","bindings/nspr_err.h":"2d5205d017b536c2d838bcf9bc4ec79f96dd50e7bb9b73892328781f1ee6629d","bindings/nspr_error.h":"e41c03c77b8c22046f8618832c9569fbcc7b26d8b9bbc35eea7168f35e346889","bindings/nspr_io.h":"085b289849ef0e77f88512a27b4d9bdc28252bd4d39c6a17303204e46ef45f72","bindings/nspr_time.h":"2e637fd338a5cf0fd3fb0070a47f474a34c2a7f4447f31b6875f5a9928d0a261","bindings/nss_ciphers.h":"95ec6344a607558b3c5ba8510f463b6295f3a2fb3f538a01410531045a5f62d1","bindings/nss_init.h":"ef49045063782fb612aff459172cc6a89340f15005808608ade5320ca9974310","bindings/nss_p11.h":"0b81e64fe6db49b2ecff94edd850be111ef99ec11220e88ceb1c67be90143a78","bindings/nss_secerr.h":"713e8368bdae5159af7893cfa517dabfe5103cede051dee9c9557c850a2defc6","bindings/nss_ssl.h":"af222fb957b989e392e762fa2125c82608a0053aff4fb97e556691646c88c335","bindings/nss_sslerr.h":"24b97f092183d8486f774cdaef5030d0249221c78343570d83a4ee5b594210ae","bindings/nss_sslopt.h":"b7807eb7abdad14db6ad7bc51048a46b065a0ea65a4508c95a12ce90e59d1eea","build.rs":"dfc3b2c8038c4b1c69d7a10bd06c4226e36935e7597225aba26039f700cc8f4f","min_version.txt":"04b271df436ebebd03df52ef009d6814f6a64e55203988790a6fcee7b2dc27af","src/aead.rs":"6410bcbe717a6b9ea6f11209b0888033358113ebc05b8a95cec1980d1360be4d","src/aead_null.rs":"81163fafef59bd2800bd0a078d53d0f05ee114f0e22165717823a5ff1cb908af","src/agent.rs":"d24f1a3df8300b93a1b606b2089bd758c9aa41c3a9e333089e6165b3449df94f","src/agentio.rs":"22e63d5efefbff41113cf002a75bb08f15228cb83e9e2cba65eb6da52dad0264","src/auth.rs":"ced1a18f691894984244088020ea25dc1ee678603317f0c7dfc8b8842fa750b4","src/cert.rs":"8e75e69ec3544474b21f8915a7559463889c2f608b201dee274a8d701880950e","src/constants.rs":"58e296e314825753b2ab1d6effe9a1386421dc568f6ebfa8e95a95acb87205da","src/ech.rs":"75dd192423e8996d9061da5e9c20d30bff5153b9344132eda4fe321c4c141870","src/err.rs":"2366501e0b48933a6a2e1c5b934aa55108c093729c84878b45e1e012e4e45d51","src/exp.rs":"d953873e87430b1c84d4a83c8eb3815041f5585b210bbaf59ae2c4d0057f5edd","src/ext.rs":"cbf7d9f5ecabf4b8c9efd6c334637ab1596ec5266d38ab8d2d6ceae305283deb","src/hkdf.rs":"8745ba761be821c1819cedf6dfd91f8b3148c6718053a4a74f33eb50c7d0cc40","src/hp.rs":"510a4a7f278203aa306ead05608f99397edc3806dc22b0af9e28c665b43ae56c","src/lib.rs":"30632dacb1b6ed9321e42ca1aaa2b71db8d4878eeb27c608e4eabdc0b76bcdba","src/min_version.rs":"c6e1f98b9f56db0622ac38c1be131c55acf4a0f09ed0d6283f4d6308e2d1301a","src/p11.rs":"375397b18fcdf36dcdd22c164c8572dd83caf01b8d0065be3029444b197e1464","src/prio.rs":"5cf0105e78b1db43c65283208174abc3714a41dbb4d5cd80ac547a5a5a7c627c","src/replay.rs":"5cda39bc8fa8a07c493b761b8dfb5cbc9f669f97a2df7832a028ab366b3426be","src/result.rs":"0587cbb6aace71a7f9765ef7c01dcd9f73a49dcc6331e1d8fe4de2aef6ca65b6","src/secrets.rs":"2c47935c5b8c42363897881eaa0c171e84cf031e57a6e1387b99327080e8dd60","src/selfencrypt.rs":"018c2dacabd3e463fdadd5707715b23c26c261c4c7d86e66c62f0acec986cad9","src/ssl.rs":"59bafcaed7caa66fe448339a1f75ce807ef92fc28247709df4f8058499b0787e","src/time.rs":"ade63a72ae90796d7fcccadbb15efc4594fcdb68913a914a657d4556fde88f62","tests/aead.rs":"e36ae77802df1ea6d17cfd1bd2178a3706089577d6fd1554ca86e748b8b235b9","tests/agent.rs":"cbd0011f1d33281883a45d433228221062424c94e86decade5697731c08a1c52","tests/ext.rs":"57af4e2df211fa8afdb73125d4344ef5c70c1ea4579107c3e6f5746308ee3e7b","tests/handshake.rs":"aa904736d36cc5d5cc0c4f6053b529987f33f944a73411bf08e01d30c4867186","tests/hkdf.rs":"1d2098dc8398395864baf13e4886cfd1da6d36118727c3b264f457ee3da6b048","tests/hp.rs":"ccda23018dac70b3ff3742afcb0fbae0735be9aeb36644a4ae2b1d7c9126801c","tests/init.rs":"3e15150c4b324c06ca5e8935618e4008da53dc0ef4b69325d150831e87dc0b63","tests/selfencrypt.rs":"8d10840b41629bf449a6b3a551377315e8a05ca26c6b041548748196652c5909"},"package":null}

2
third_party/rust/neqo-crypto/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-crypto"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = "build.rs"
autobins = false

13
third_party/rust/neqo-crypto/build.rs vendored
View File

@ -109,14 +109,14 @@ fn get_bash() -> PathBuf {
)
}
fn build_nss(dir: PathBuf) {
fn build_nss(dir: PathBuf, nsstarget: &str) {
let mut build_nss = vec![
String::from("./build.sh"),
String::from("-Ddisable_tests=1"),
// Generate static libraries in addition to shared libraries.
String::from("--static"),
];
if !is_debug() {
if nsstarget == "Release" {
build_nss.push(String::from("-o"));
}
if let Ok(d) = env::var("NSS_JOBS") {
@ -317,15 +317,18 @@ fn setup_standalone(nss: &str) -> Vec<String> {
"The NSS_DIR environment variable is expected to be an absolute path."
);
build_nss(nss.clone());
// $NSS_DIR/../dist/
let nssdist = nss.parent().unwrap().join("dist");
println!("cargo:rerun-if-env-changed=NSS_TARGET");
let nsstarget = env::var("NSS_TARGET")
.unwrap_or_else(|_| fs::read_to_string(nssdist.join("latest")).unwrap());
let nsstarget = nssdist.join(nsstarget.trim());
// If NSS_PREBUILT is set, we assume that the NSS libraries are already built.
if env::var("NSS_PREBUILT").is_err() {
build_nss(nss, &nsstarget);
}
let nsstarget = nssdist.join(nsstarget.trim());
let includes = get_includes(&nsstarget, &nssdist);
let nsslibdir = nsstarget.join("lib");

2
third_party/rust/neqo-crypto/min_version.txt vendored
View File

@ -1 +1 @@
3.103
3.105

1
third_party/rust/neqo-crypto/src/constants.rs vendored
View File

@ -63,6 +63,7 @@ remap_enum! {
TLS_GRP_EC_SECP521R1 = ssl_grp_ec_secp521r1,
TLS_GRP_EC_X25519 = ssl_grp_ec_curve25519,
TLS_GRP_KEM_XYBER768D00 = ssl_grp_kem_xyber768d00,
TLS_GRP_KEM_MLKEM768X25519 = ssl_grp_kem_mlkem768x25519,
}
}

7
third_party/rust/neqo-crypto/src/lib.rs vendored
View File

@ -146,13 +146,6 @@ fn init_once(db: Option<PathBuf>) -> Res<NssLoaded> {
};
secstatus_to_res(unsafe { nss::NSS_SetDomesticPolicy() })?;
secstatus_to_res(unsafe {
p11::NSS_SetAlgorithmPolicy(
p11::SECOidTag::SEC_OID_XYBER768D00,
p11::NSS_USE_ALG_IN_SSL_KX,
0,
)
})?;
#[cfg(debug_assertions)]
enable_ssl_trace()?;

2
third_party/rust/neqo-http3/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"66bc37c5cfb65f37328530035a7f340e7e4cf3b5e2fed07ba5deafb8e5f13a66","src/buffered_send_stream.rs":"dfb248c66ea65418b0c7798c2ecaa3ed70ef1af818ef58d53ef742b3445077b7","src/client_events.rs":"77fedca72ce54956eaba3fb7103085d196a631b764662584ea2629224c5c234e","src/conn_params.rs":"7f0df52bceda1923aef2b7c5c64a532f49ea083ea45e3dcd5bd4b03031b89643","src/connection.rs":"1bf52ac3f3714f5bb2b1237fdb7b026ee4a2183f8f173120661f46213f8c5daa","src/connection_client.rs":"ec979c1ed03002ec2095aab40986089d6c2b0eda541566e0023424a0a896b687","src/connection_server.rs":"cf4da2cdd823e31d2352e45de84d366c45bd3d8adf38c9151a84d808bda80209","src/control_stream_local.rs":"20917762c7e7c1112c56abf1cbaf0ad7f0eab97d8db9a3b10ff524315a235670","src/control_stream_remote.rs":"3729f67aa0681b1dbd4147063890f8440f27d82454776500ae964a17cda4d6b5","src/features/extended_connect/mod.rs":"cbeb2294eaf34f08a2c0d0fe4d3473aea9c65df6faaec9dc3ed29dcb577b1c3f","src/features/extended_connect/tests/mod.rs":"fd6aee37243713e80fc526552f21f0222338cec9890409b6575a2a637b17ec1f","src/features/extended_connect/tests/webtransport/datagrams.rs":"51d6f3828c44b438eb1776e8dcce531af520f28bc0d715807d3f53a0eaa071d1","src/features/extended_connect/tests/webtransport/mod.rs":"27f77213414089148e94067bfc54133945a971fd7ddd6936bbfeabb9badc7e67","src/features/extended_connect/tests/webtransport/negotiation.rs":"a22094dbaf0754d39ac8ac08fce1ae34ace108220b696c7d618567df56cddeec","src/features/extended_connect/tests/webtransport/sessions.rs":"cf8aa14087cc3ff42657d86ecacbd51bc182357fdcbd10f57d32784abb415a12","src/features/extended_connect/tests/webtransport/streams.rs":"4c136855292d5ba5169f41c18beea13e7f1e014a0acb13c565c872d3a80d6377","src/features/extended_connect/webtransport_session.rs":"a55876a7ba1de47950f4209cfaa0e04ddbc54fb4109d0133f8e6e6b150971563","src/features/extended_connect/webtransport_streams.rs":"9855d77705acb7d21566333c4b297816e363be2ade14b8685fd1df4a4861cf74","src/features/mod.rs":"89056df3a868cb0037963c942fc27093cc16d84538ffca2d4759f9a6a6c74c7f","src/frames/hframe.rs":"de2c3d1a9205b0459fe676d7d5e1c0e463d3c1dd9e5f518a07b2e4ebbe66e3ec","src/frames/mod.rs":"0e6d49888d723b2c2c73df11020ceb88d9f062e9d4dc436eb38173e0b772d905","src/frames/reader.rs":"36e113164995fbd202c5024b51230c12fa7134b1759170abfd4fc1b4e7f5a5da","src/frames/tests/hframe.rs":"53941fd7656f5e424d499278e6d9ba93ce716f219e86fe6fa08c058ea92f8d7b","src/frames/tests/mod.rs":"c6bbf85fbc6cb9adf6115d315f0564317eefd83ff3177c93050844ad77f6e694","src/frames/tests/reader.rs":"9ee0d9cdd87b98da2b94e577bbcc2bfde6d72be5177bf02364188935f79cb36a","src/frames/tests/wtframe.rs":"c6598d24f5e12972f02de6e1394362671633982db637a07e1c0bb9b56d93ea2a","src/frames/wtframe.rs":"0f0366e590f7409580459e8a8b86fc48308ca7585837dddd7c319581a9a5a972","src/headers_checks.rs":"69964deb121721be01df7174c177543c161389295ce1450d348369279e312ba4","src/lib.rs":"3fb980eee46bee8dcb97ad9d55014555d8994a7a2d040ca223f2d28fe7d923ef","src/priority.rs":"946307329f31819d969093406ae5448f7923343ccc112221ea6eedf86cf447dc","src/push_controller.rs":"53f72e8043505f85cba0f9c16b4a5ce14d6668b030d773067bc88b2a10bdd25b","src/qlog.rs":"db5f2dd6566d44b4f0541f75266b417b558c09e62141f056885cb8c66478a932","src/qpack_decoder_receiver.rs":"eb06c4be59da567fef70c20daa2c0f165c768131165479a210e69659f168b88f","src/qpack_encoder_receiver.rs":"831f3da9ec17966286786ba3f2c723395a132e65d6a33b4ec341fe7640c1a53d","src/recv_message.rs":"8b2fb49850560b32dcdd7a90933361ef7d61bc42daad3f2952462913d49e8787","src/request_target.rs":"9720b9f87d66a7c2301bba7de5a5a9300f547613a63153a4d35c7a7506a59b31","src/send_message.rs":"be4e9f64db2c25eb7176b84695e608e768115d62e615d389a33d26f7cd5b0c6c","src/server.rs":"8d48376abf36d036f51a84cddcc3d5acd56786b181fba0e24449e1417b030d63","src/server_connection_events.rs":"1396baab265a814045ccfe63d637a4fdc32a667b5eb2925fa4951f5c3078fb20","src/server_events.rs":"02fc8c0711efd758fb1ddee27d257c12ed35e2a989e7bf3de44bd662dc8234e3","src/settings.rs":"d0f8c546e70161422a029a40564b9e9b953fe671c60835196b16f3364779eaf9","src/stream_type_reader.rs":"4e79202e7f1415165fe4eb88b9af67cbb8f85a13d68a577249c397fd5a78dbfb","tests/httpconn.rs":"87c32197258711d916cace23ed850c5bf0198f5e32756c68a32d91206b6e6db8","tests/priority.rs":"364754507873298612ad12e8d1d106d26d993712142d0be4cbf056da5338854c","tests/send_message.rs":"cdf7028eb64f8f3778c3bbb2a10e9482c4e995e9e1813143ccd83ec96b2d4b6a","tests/webtransport.rs":"02b81be0a20252a8bb0796b5287e426c1af5ddaf5a47d68aa9165393cba83c45"},"package":null}
{"files":{"Cargo.toml":"38f1dcfa628f9f3fdafc2bddcd6f894f8d89456c479bf07c276584beee2b78a8","src/buffered_send_stream.rs":"dfb248c66ea65418b0c7798c2ecaa3ed70ef1af818ef58d53ef742b3445077b7","src/client_events.rs":"77fedca72ce54956eaba3fb7103085d196a631b764662584ea2629224c5c234e","src/conn_params.rs":"7f0df52bceda1923aef2b7c5c64a532f49ea083ea45e3dcd5bd4b03031b89643","src/connection.rs":"1bf52ac3f3714f5bb2b1237fdb7b026ee4a2183f8f173120661f46213f8c5daa","src/connection_client.rs":"e1ad0e79033735373b5c90971f5ef6269c937f9677ab9ec3a271d6a1b5128370","src/connection_server.rs":"cf4da2cdd823e31d2352e45de84d366c45bd3d8adf38c9151a84d808bda80209","src/control_stream_local.rs":"20917762c7e7c1112c56abf1cbaf0ad7f0eab97d8db9a3b10ff524315a235670","src/control_stream_remote.rs":"3729f67aa0681b1dbd4147063890f8440f27d82454776500ae964a17cda4d6b5","src/features/extended_connect/mod.rs":"cbeb2294eaf34f08a2c0d0fe4d3473aea9c65df6faaec9dc3ed29dcb577b1c3f","src/features/extended_connect/tests/mod.rs":"fd6aee37243713e80fc526552f21f0222338cec9890409b6575a2a637b17ec1f","src/features/extended_connect/tests/webtransport/datagrams.rs":"51d6f3828c44b438eb1776e8dcce531af520f28bc0d715807d3f53a0eaa071d1","src/features/extended_connect/tests/webtransport/mod.rs":"27f77213414089148e94067bfc54133945a971fd7ddd6936bbfeabb9badc7e67","src/features/extended_connect/tests/webtransport/negotiation.rs":"a22094dbaf0754d39ac8ac08fce1ae34ace108220b696c7d618567df56cddeec","src/features/extended_connect/tests/webtransport/sessions.rs":"cf8aa14087cc3ff42657d86ecacbd51bc182357fdcbd10f57d32784abb415a12","src/features/extended_connect/tests/webtransport/streams.rs":"4c136855292d5ba5169f41c18beea13e7f1e014a0acb13c565c872d3a80d6377","src/features/extended_connect/webtransport_session.rs":"debe63b81c8c3c49da9f2b9abb92ea05fb95745a8ee725a956dfeffa53dc9574","src/features/extended_connect/webtransport_streams.rs":"9855d77705acb7d21566333c4b297816e363be2ade14b8685fd1df4a4861cf74","src/features/mod.rs":"89056df3a868cb0037963c942fc27093cc16d84538ffca2d4759f9a6a6c74c7f","src/frames/hframe.rs":"de2c3d1a9205b0459fe676d7d5e1c0e463d3c1dd9e5f518a07b2e4ebbe66e3ec","src/frames/mod.rs":"0e6d49888d723b2c2c73df11020ceb88d9f062e9d4dc436eb38173e0b772d905","src/frames/reader.rs":"36e113164995fbd202c5024b51230c12fa7134b1759170abfd4fc1b4e7f5a5da","src/frames/tests/hframe.rs":"53941fd7656f5e424d499278e6d9ba93ce716f219e86fe6fa08c058ea92f8d7b","src/frames/tests/mod.rs":"c6bbf85fbc6cb9adf6115d315f0564317eefd83ff3177c93050844ad77f6e694","src/frames/tests/reader.rs":"9ee0d9cdd87b98da2b94e577bbcc2bfde6d72be5177bf02364188935f79cb36a","src/frames/tests/wtframe.rs":"c6598d24f5e12972f02de6e1394362671633982db637a07e1c0bb9b56d93ea2a","src/frames/wtframe.rs":"0f0366e590f7409580459e8a8b86fc48308ca7585837dddd7c319581a9a5a972","src/headers_checks.rs":"69964deb121721be01df7174c177543c161389295ce1450d348369279e312ba4","src/lib.rs":"3fb980eee46bee8dcb97ad9d55014555d8994a7a2d040ca223f2d28fe7d923ef","src/priority.rs":"946307329f31819d969093406ae5448f7923343ccc112221ea6eedf86cf447dc","src/push_controller.rs":"53f72e8043505f85cba0f9c16b4a5ce14d6668b030d773067bc88b2a10bdd25b","src/qlog.rs":"db5f2dd6566d44b4f0541f75266b417b558c09e62141f056885cb8c66478a932","src/qpack_decoder_receiver.rs":"eb06c4be59da567fef70c20daa2c0f165c768131165479a210e69659f168b88f","src/qpack_encoder_receiver.rs":"831f3da9ec17966286786ba3f2c723395a132e65d6a33b4ec341fe7640c1a53d","src/recv_message.rs":"8b2fb49850560b32dcdd7a90933361ef7d61bc42daad3f2952462913d49e8787","src/request_target.rs":"9720b9f87d66a7c2301bba7de5a5a9300f547613a63153a4d35c7a7506a59b31","src/send_message.rs":"be4e9f64db2c25eb7176b84695e608e768115d62e615d389a33d26f7cd5b0c6c","src/server.rs":"8d48376abf36d036f51a84cddcc3d5acd56786b181fba0e24449e1417b030d63","src/server_connection_events.rs":"1396baab265a814045ccfe63d637a4fdc32a667b5eb2925fa4951f5c3078fb20","src/server_events.rs":"02fc8c0711efd758fb1ddee27d257c12ed35e2a989e7bf3de44bd662dc8234e3","src/settings.rs":"d0f8c546e70161422a029a40564b9e9b953fe671c60835196b16f3364779eaf9","src/stream_type_reader.rs":"4e79202e7f1415165fe4eb88b9af67cbb8f85a13d68a577249c397fd5a78dbfb","tests/httpconn.rs":"87c32197258711d916cace23ed850c5bf0198f5e32756c68a32d91206b6e6db8","tests/priority.rs":"364754507873298612ad12e8d1d106d26d993712142d0be4cbf056da5338854c","tests/send_message.rs":"cdf7028eb64f8f3778c3bbb2a10e9482c4e995e9e1813143ccd83ec96b2d4b6a","tests/webtransport.rs":"02b81be0a20252a8bb0796b5287e426c1af5ddaf5a47d68aa9165393cba83c45"},"package":null}

2
third_party/rust/neqo-http3/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-http3"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = false
autobins = false

6
third_party/rust/neqo-http3/src/connection_client.rs vendored
View File

@ -2620,7 +2620,7 @@ mod tests {
force_idle(&mut client, &mut server);
let idle_timeout = ConnectionParameters::default().get_idle_timeout();
assert_eq!(client.process_output(now()).callback(), idle_timeout);
assert_eq!(client.process_output(now()).callback(), idle_timeout / 2);
}
// Helper function: read response when a server sends HTTP_RESPONSE_2.
@ -4351,7 +4351,7 @@ mod tests {
assert_eq!(*server.conn.state(), State::Init);
let out = server.conn.process(out.as_dgram_ref(), now());
// Check that control and qpack streams anda SETTINGS frame are received.
// Check that control and qpack streams and a SETTINGS frame are received.
// Also qpack encoder stream will send "change capacity" instruction because it has
// the peer settings already.
server.check_control_qpack_request_streams_resumption(
@ -5114,7 +5114,7 @@ mod tests {
assert!(!fin);
force_idle(&mut client, &mut server);
assert_eq!(client.process_output(now()).callback(), idle_timeout);
assert_eq!(client.process_output(now()).callback(), idle_timeout / 2);
}
#[test]

2
third_party/rust/neqo-http3/src/features/extended_connect/webtransport_session.rs vendored
View File

@ -415,7 +415,7 @@ impl WebTransportSession {
let mut dgram_data = Encoder::default();
dgram_data.encode_varint(self.session_id.as_u64() / 4);
dgram_data.encode(buf);
conn.send_datagram(dgram_data.as_ref(), id)?;
conn.send_datagram(dgram_data.into(), id)?;
} else {
debug_assert!(false);
return Err(Error::Unavailable);

2
third_party/rust/neqo-qpack/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"d58f4188dfa53d634d32f7276f2427ffcebc77b5a63a25f7f885601c59721804","src/decoder.rs":"ed2d6fa29e8726429aabb84e65f5d8025b320c0219b442b47c38903728ba3b2d","src/decoder_instructions.rs":"7e23ad00bcc6a1f0ee9af6c3d7f5ec5fcf11e9bc6cd895e125e3392c34b309e0","src/encoder.rs":"ebc9e82e5ad6b31be46ab876965d0e9dc710c4c5db084a631f384185b56cab36","src/encoder_instructions.rs":"5afc60ecc5b65f5b1908cff7eb3b7394c5c36cebe8ebfcdefbf792c827799390","src/header_block.rs":"1ea71fe2f588a0f96e39fd3a3157c66cc0ed2794f14c6f01b4a3069a43f7997b","src/huffman.rs":"6976f1b4d3e5ef849a6b080cfb2e8804bf01cfe3b9bd9e3994a319d5405cd8f3","src/huffman_decode_helper.rs":"9ce470e318b3664f58aa109bed483ab15bfd9e0b17d261ea2b609668a42a9d80","src/huffman_table.rs":"06fea766a6276ac56c7ee0326faed800a742c15fda1f33bf2513e6cc6a5e6d27","src/lib.rs":"f9bad0fe7643c618d034c4941ebd30ad5f6015b8b87b484b0ea79681d13d8b49","src/prefix.rs":"d9ad12838d61b38dc2300948e3da01fd65371215edde1c370cf54ccd87d64d46","src/qlog.rs":"fbd96ef7d21db2bae19b8e379995544e8cf123e8e5129c1500ace2773acf5649","src/qpack_send_buf.rs":"48f8d0e011e0fb8e4bd0774279d3465e2be01fd9480eaf374ae2adada6be430d","src/reader.rs":"c23214ba190c7a59e416eaffac612ff8c2043c3a84e884fb10ae3bc112d884a5","src/static_table.rs":"6e5ec26e2b6bd63375d2d77e72748151d430d1629a8e497ec0d0ea21c078524a","src/stats.rs":"624dfa3b40858c304097bb0ce5b1be1bb4d7916b1abfc222f1aa705907009730","src/table.rs":"2d2c9e6070a1e90048a4ad7c8279f9e1ce7615b44d7d8145fb0f140e554f5ca2"},"package":null}
{"files":{"Cargo.toml":"64f551c6814f7f0d66746d2fef8a5bd627059904685cdcea5af241e3d6fef4ac","src/decoder.rs":"ed2d6fa29e8726429aabb84e65f5d8025b320c0219b442b47c38903728ba3b2d","src/decoder_instructions.rs":"addf304fbd566ca387e5111cbe25784f7f50e0112ce0372b1ad6d18185b45a02","src/encoder.rs":"9a09c2eb6476fb72e3d73937a6e1c98072910fc7f709aca13f41afed38c7dd9f","src/encoder_instructions.rs":"5afc60ecc5b65f5b1908cff7eb3b7394c5c36cebe8ebfcdefbf792c827799390","src/header_block.rs":"1ea71fe2f588a0f96e39fd3a3157c66cc0ed2794f14c6f01b4a3069a43f7997b","src/huffman.rs":"6976f1b4d3e5ef849a6b080cfb2e8804bf01cfe3b9bd9e3994a319d5405cd8f3","src/huffman_decode_helper.rs":"9ce470e318b3664f58aa109bed483ab15bfd9e0b17d261ea2b609668a42a9d80","src/huffman_table.rs":"06fea766a6276ac56c7ee0326faed800a742c15fda1f33bf2513e6cc6a5e6d27","src/lib.rs":"f9bad0fe7643c618d034c4941ebd30ad5f6015b8b87b484b0ea79681d13d8b49","src/prefix.rs":"d9ad12838d61b38dc2300948e3da01fd65371215edde1c370cf54ccd87d64d46","src/qlog.rs":"fbd96ef7d21db2bae19b8e379995544e8cf123e8e5129c1500ace2773acf5649","src/qpack_send_buf.rs":"48f8d0e011e0fb8e4bd0774279d3465e2be01fd9480eaf374ae2adada6be430d","src/reader.rs":"c23214ba190c7a59e416eaffac612ff8c2043c3a84e884fb10ae3bc112d884a5","src/static_table.rs":"6e5ec26e2b6bd63375d2d77e72748151d430d1629a8e497ec0d0ea21c078524a","src/stats.rs":"624dfa3b40858c304097bb0ce5b1be1bb4d7916b1abfc222f1aa705907009730","src/table.rs":"2d2c9e6070a1e90048a4ad7c8279f9e1ce7615b44d7d8145fb0f140e554f5ca2"},"package":null}

2
third_party/rust/neqo-qpack/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-qpack"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = false
autobins = false

2
third_party/rust/neqo-qpack/src/decoder_instructions.rs vendored
View File

@ -89,7 +89,7 @@ impl DecoderInstructionReader {
/// 2) `ClosedCriticalStream`
/// 3) other errors will be translated to `DecoderStream` by the caller of this function.
pub fn read_instructions<R: ReadByte>(&mut self, recv: &mut R) -> Res<DecoderInstruction> {
qdebug!([self], "read a new instraction");
qdebug!([self], "read a new instruction");
loop {
match &mut self.state {
DecoderInstructionReaderState::ReadInstruction => {

2
third_party/rust/neqo-qpack/src/encoder.rs vendored
View File

@ -129,7 +129,7 @@ impl QPackEncoder {
}
fn read_instructions(&mut self, conn: &mut Connection, stream_id: StreamId) -> Res<()> {
qdebug!([self], "read a new instraction");
qdebug!([self], "read a new instruction");
loop {
let mut recv = ReceiverConnWrapper::new(conn, stream_id);
match self.instruction_reader.read_instructions(&mut recv) {

2
third_party/rust/neqo-transport/.cargo-checksum.json vendored
View File

File diff suppressed because one or more lines are too long

3
third_party/rust/neqo-transport/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-transport"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = "build.rs"
autobins = false
@ -113,7 +113,6 @@ default-features = false
[dev-dependencies.criterion]
version = "0.5"
features = ["html_reports"]
default-features = false
[dev-dependencies.test-fixture]

15
third_party/rust/neqo-transport/src/connection/idle.rs vendored
View File

@ -96,6 +96,21 @@ impl IdleTimeout {
self.start(now) + max(self.timeout / 2, pto)
}
pub fn next_keep_alive(&self, now: Instant, pto: Duration) -> Option<Instant> {
if self.keep_alive_outstanding {
return None;
}
let timeout = self.keep_alive_timeout(now, pto);
// Timer is in the past, i.e. we should have sent a keep alive,
// but we were unable to, e.g. due to CC.
if timeout <= now {
return None;
}
Some(timeout)
}
pub fn send_keep_alive(
&mut self,
now: Instant,

88
third_party/rust/neqo-transport/src/connection/mod.rs vendored
View File

@ -48,7 +48,7 @@ use crate::{
quic_datagrams::{DatagramTracking, QuicDatagrams},
recovery::{LossRecovery, RecoveryToken, SendProfile, SentPacket},
recv_stream::RecvStreamStats,
rtt::{RttEstimate, GRANULARITY},
rtt::{RttEstimate, GRANULARITY, INITIAL_RTT},
send_stream::SendStream,
stats::{Stats, StatsCell},
stream_id::StreamType,
@ -594,9 +594,25 @@ impl Connection {
fn make_resumption_token(&mut self) -> ResumptionToken {
debug_assert_eq!(self.role, Role::Client);
debug_assert!(self.crypto.has_resumption_token());
// Values less than GRANULARITY are ignored when using the token, so use 0 where needed.
let rtt = self.paths.primary().map_or_else(
|| RttEstimate::default().estimate(),
|p| p.borrow().rtt().estimate(),
// If we don't have a path, we don't have an RTT.
|| Duration::from_millis(0),
|p| {
let rtt = p.borrow().rtt().estimate();
if p.borrow().rtt().is_guesstimate() {
// When we have no actual RTT sample, do not encode a guestimated RTT larger
// than the default initial RTT. (The guess can be very large under lossy
// conditions.)
if rtt < INITIAL_RTT {
rtt
} else {
Duration::from_millis(0)
}
} else {
rtt
}
},
);
self.crypto
@ -613,13 +629,17 @@ impl Connection {
.unwrap()
}
fn confirmed(&self) -> bool {
self.state == State::Confirmed
}
/// Get the simplest PTO calculation for all those cases where we need
/// a value of this approximate order. Don't use this for loss recovery,
/// only use it where a more precise value is not important.
fn pto(&self) -> Duration {
self.paths.primary().map_or_else(
|| RttEstimate::default().pto(PacketNumberSpace::ApplicationData),
|p| p.borrow().rtt().pto(PacketNumberSpace::ApplicationData),
|| RttEstimate::default().pto(self.confirmed()),
|p| p.borrow().rtt().pto(self.confirmed()),
)
}
@ -1033,7 +1053,7 @@ impl Connection {
return timeout.duration_since(now);
}
let mut delays = SmallVec::<[_; 6]>::new();
let mut delays = SmallVec::<[_; 7]>::new();
if let Some(ack_time) = self.acks.ack_time(now) {
qtrace!([self], "Delayed ACK timer {:?}", ack_time);
delays.push(ack_time);
@ -1042,12 +1062,19 @@ impl Connection {
if let Some(p) = self.paths.primary() {
let path = p.borrow();
let rtt = path.rtt();
let pto = rtt.pto(PacketNumberSpace::ApplicationData);
let pto = rtt.pto(self.confirmed());
let idle_time = self.idle_timeout.expiry(now, pto);
qtrace!([self], "Idle/keepalive timer {:?}", idle_time);
qtrace!([self], "Idle timer {:?}", idle_time);
delays.push(idle_time);
if self.streams.need_keep_alive() {
if let Some(keep_alive_time) = self.idle_timeout.next_keep_alive(now, pto) {
qtrace!([self], "Keep alive timer {:?}", keep_alive_time);
delays.push(keep_alive_time);
}
}
if let Some(lr_time) = self.loss_recovery.next_timeout(&path) {
qtrace!([self], "Loss recovery timer {:?}", lr_time);
delays.push(lr_time);
@ -1396,12 +1423,14 @@ impl Connection {
// that Initial packets were lost.
// Resend Initial CRYPTO frames immediately a few times just
// in case. As we don't have an RTT estimate yet, this helps
// when there is a short RTT and losses.
// when there is a short RTT and losses. Also mark all 0-RTT
// data as lost.
if dcid.is_none()
&& self.cid_manager.is_valid(packet.dcid())
&& self.stats.borrow().saved_datagrams <= EXTRA_INITIALS
{
self.crypto.resend_unacked(PacketNumberSpace::Initial);
self.resend_0rtt(now);
}
}
(PacketType::VersionNegotiation | PacketType::Retry | PacketType::OtherVersion, ..) => {
@ -1507,7 +1536,7 @@ impl Connection {
let mut dcid = None;
qtrace!([self], "{} input {}", path.borrow(), hex(&**d));
let pto = path.borrow().rtt().pto(PacketNumberSpace::ApplicationData);
let pto = path.borrow().rtt().pto(self.confirmed());
// Handle each packet in the datagram.
while !slc.is_empty() {
@ -2000,7 +2029,10 @@ impl Connection {
// Count how many bytes in this range are non-zero.
let pn_len = mem::size_of::<PacketNumber>()
- usize::try_from(unacked_range.leading_zeros() / 8).unwrap();
// pn_len can't be zero (unacked_range is > 0)
assert!(
pn_len > 0,
"pn_len can't be zero as unacked_range should be > 0, pn {pn}, largest_acknowledged {largest_acknowledged:?}, tx {tx}"
);
// TODO(mt) also use `4*path CWND/path MTU` to set a minimum length.
builder.pn(pn, pn_len);
pn
@ -2120,7 +2152,7 @@ impl Connection {
// or the PTO timer fired: probe.
true
} else {
let pto = path.borrow().rtt().pto(PacketNumberSpace::ApplicationData);
let pto = path.borrow().rtt().pto(self.confirmed());
if !builder.packet_empty() {
// The packet only contains an ACK. Check whether we want to
// force an ACK with a PING so we can stop tracking packets.
@ -2139,7 +2171,6 @@ impl Connection {
builder.encode_varint(crate::frame::FRAME_TYPE_PING);
let stats = &mut self.stats.borrow_mut().frame_tx;
stats.ping += 1;
stats.all += 1;
}
probe
}
@ -2226,13 +2257,11 @@ impl Connection {
let stats = &mut self.stats.borrow_mut().frame_tx;
let padded = if ack_eliciting && full_mtu && builder.pad() {
stats.padding += 1;
stats.all += 1;
true
} else {
false
};
stats.all += tokens.len();
(tokens, ack_eliciting, padded)
}
@ -2799,7 +2828,6 @@ impl Connection {
qinfo!("frame not allowed: {:?} {:?}", frame, packet_type);
return Err(Error::ProtocolViolation);
}
self.stats.borrow_mut().frame_rx.all += 1;
let space = PacketNumberSpace::from(packet_type);
if frame.is_stream() {
return self
@ -2853,8 +2881,13 @@ impl Connection {
self.handshake(now, packet_version, space, Some(&buf))?;
self.create_resumption_token(now);
} else {
// If we get a useless CRYPTO frame send outstanding CRYPTO frames again.
// If we get a useless CRYPTO frame send outstanding CRYPTO frames and 0-RTT
// data again.
self.crypto.resend_unacked(space);
if space == PacketNumberSpace::Initial {
self.crypto.resend_unacked(PacketNumberSpace::Handshake);
self.resend_0rtt(now);
}
}
}
Frame::NewToken { token } => {
@ -3066,21 +3099,22 @@ impl Connection {
stats.largest_acknowledged = max(stats.largest_acknowledged, largest_acknowledged);
}
/// Tell 0-RTT packets that they were "lost".
fn resend_0rtt(&mut self, now: Instant) {
if let Some(path) = self.paths.primary() {
let dropped = self.loss_recovery.drop_0rtt(&path, now);
self.handle_lost_packets(&dropped);
}
}
/// When the server rejects 0-RTT we need to drop a bunch of stuff.
fn client_0rtt_rejected(&mut self, now: Instant) {
if !matches!(self.zero_rtt_state, ZeroRttState::Sending) {
return;
}
qdebug!([self], "0-RTT rejected");
// Tell 0-RTT packets that they were "lost".
if let Some(path) = self.paths.primary() {
let dropped = self.loss_recovery.drop_0rtt(&path, now);
self.handle_lost_packets(&dropped);
}
self.resend_0rtt(now);
self.streams.zero_rtt_rejected();
self.crypto.states.discard_0rtt_keys();
self.events.client_0rtt_rejected();
}
@ -3405,7 +3439,7 @@ impl Connection {
};
let path = self.paths.primary().ok_or(Error::NotAvailable)?;
let mtu = path.borrow().plpmtu();
let encoder = Encoder::with_capacity(mtu);
let encoder = Encoder::default();
let (_, mut builder) = Self::build_packet_header(
&path.borrow(),
@ -3440,7 +3474,7 @@ impl Connection {
/// to check the estimated max datagram size and to use smaller datagrams.
/// `max_datagram_size` is just a current estimate and will change over
/// time depending on the encoded size of the packet number, ack frames, etc.
pub fn send_datagram(&mut self, buf: &[u8], id: impl Into<DatagramTracking>) -> Res<()> {
pub fn send_datagram(&mut self, buf: Vec<u8>, id: impl Into<DatagramTracking>) -> Res<()> {
self.quic_datagrams
.add_datagram(buf, id.into(), &mut self.stats.borrow_mut())
}

17
third_party/rust/neqo-transport/src/connection/params.rs vendored
View File

@ -44,6 +44,7 @@ pub enum PreferredAddressConfig {
/// `ConnectionParameters` use for setting intitial value for QUIC parameters.
/// This collects configuration like initial limits, protocol version, and
/// congestion control algorithm.
#[allow(clippy::struct_excessive_bools)] // We need that many, sorry.
#[derive(Debug, Clone)]
pub struct ConnectionParameters {
versions: VersionConfig,
@ -78,6 +79,7 @@ pub struct ConnectionParameters {
incoming_datagram_queue: usize,
fast_pto: u8,
grease: bool,
disable_migration: bool,
pacing: bool,
/// Whether the connection performs PLPMTUD.
pmtud: bool,
@ -102,6 +104,7 @@ impl Default for ConnectionParameters {
incoming_datagram_queue: MAX_QUEUED_DATAGRAMS_DEFAULT,
fast_pto: FAST_PTO_SCALE,
grease: true,
disable_migration: false,
pacing: true,
pmtud: false,
}
@ -336,6 +339,12 @@ impl ConnectionParameters {
self
}
#[must_use]
pub const fn disable_migration(mut self, disable_migration: bool) -> Self {
self.disable_migration = disable_migration;
self
}
#[must_use]
pub const fn pacing_enabled(&self) -> bool {
self.pacing
@ -373,8 +382,12 @@ impl ConnectionParameters {
tparams::ACTIVE_CONNECTION_ID_LIMIT,
u64::try_from(LOCAL_ACTIVE_CID_LIMIT)?,
);
tps.local.set_empty(tparams::DISABLE_MIGRATION);
tps.local.set_empty(tparams::GREASE_QUIC_BIT);
if self.disable_migration {
tps.local.set_empty(tparams::DISABLE_MIGRATION);
}
if self.grease {
tps.local.set_empty(tparams::GREASE_QUIC_BIT);
}
tps.local.set_integer(
tparams::MAX_ACK_DELAY,
u64::try_from(DEFAULT_ACK_DELAY.as_millis())?,

98
third_party/rust/neqo-transport/src/connection/tests/datagram.rs vendored
View File

@ -58,12 +58,12 @@ fn datagram_disabled_both() {
assert_eq!(client.max_datagram_size(), Err(Error::NotAvailable));
assert_eq!(server.max_datagram_size(), Err(Error::NotAvailable));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU, None),
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), None),
Err(Error::TooMuchData)
);
assert_eq!(server.stats().frame_tx.datagram, 0);
assert_eq!(
server.send_datagram(DATA_SMALLER_THAN_MTU, None),
server.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), None),
Err(Error::TooMuchData)
);
assert_eq!(server.stats().frame_tx.datagram, 0);
@ -82,11 +82,14 @@ fn datagram_enabled_on_client() {
Ok(DATAGRAM_LEN_SMALLER_THAN_MTU)
);
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)),
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Err(Error::TooMuchData)
);
let dgram_sent = server.stats().frame_tx.datagram;
assert_eq!(server.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
server.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let out = server.process_output(now()).dgram().unwrap();
assert_eq!(server.stats().frame_tx.datagram, dgram_sent + 1);
@ -110,11 +113,14 @@ fn datagram_enabled_on_server() {
);
assert_eq!(server.max_datagram_size(), Err(Error::NotAvailable));
assert_eq!(
server.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)),
server.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Err(Error::TooMuchData)
);
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let out = client.process_output(now()).dgram().unwrap();
assert_eq!(client.stats().frame_tx.datagram, dgram_sent + 1);
@ -156,7 +162,10 @@ fn limit_data_size() {
// Datagram can be queued because they are smaller than allowed by the peer,
// but they cannot be sent.
assert_eq!(server.send_datagram(DATA_BIGGER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
server.send_datagram(DATA_BIGGER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let dgram_dropped_s = server.stats().datagram_tx.dropped_too_big;
let dgram_sent_s = server.stats().frame_tx.datagram;
@ -172,7 +181,10 @@ fn limit_data_size() {
));
// The same test for the client side.
assert_eq!(client.send_datagram(DATA_BIGGER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_BIGGER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let dgram_sent_c = client.stats().frame_tx.datagram;
assert!(client.process_output(now()).dgram().is_none());
assert_eq!(client.stats().frame_tx.datagram, dgram_sent_c);
@ -188,8 +200,14 @@ fn after_dgram_dropped_continue_writing_frames() {
// Datagram can be queued because they are smaller than allowed by the peer,
// but they cannot be sent.
assert_eq!(client.send_datagram(DATA_BIGGER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(2)), Ok(()));
assert_eq!(
client.send_datagram(DATA_BIGGER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(2)),
Ok(())
);
let datagram_dropped = |e| {
matches!(
@ -214,7 +232,10 @@ fn datagram_acked() {
let (mut client, mut server) = connect_datagram();
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let out = client.process_output(now()).dgram();
assert_eq!(client.stats().frame_tx.datagram, dgram_sent + 1);
@ -267,7 +288,7 @@ fn datagram_after_stream_data() {
// Write a datagram first.
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_MTU, Some(1)), Ok(()));
assert_eq!(client.send_datagram(DATA_MTU.to_vec(), Some(1)), Ok(()));
// Create a stream with normal priority and send some data.
let stream_id = client.stream_create(StreamType::BiDi).unwrap();
@ -309,7 +330,7 @@ fn datagram_before_stream_data() {
// Write a datagram.
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_MTU, Some(1)), Ok(()));
assert_eq!(client.send_datagram(DATA_MTU.to_vec(), Some(1)), Ok(()));
if let ConnectionEvent::Datagram(data) =
&send_packet_and_get_server_event(&mut client, &mut server)
@ -331,7 +352,10 @@ fn datagram_lost() {
let (mut client, _) = connect_datagram();
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let _out = client.process_output(now()).dgram(); // This packet will be lost.
assert_eq!(client.stats().frame_tx.datagram, dgram_sent + 1);
@ -358,7 +382,10 @@ fn datagram_sent_once() {
let (mut client, _) = connect_datagram();
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
let _out = client.process_output(now()).dgram();
assert_eq!(client.stats().frame_tx.datagram, dgram_sent + 1);
@ -402,16 +429,19 @@ fn outgoing_datagram_queue_full() {
let (mut client, mut server) = connect_datagram();
let dgram_sent = client.stats().frame_tx.datagram;
assert_eq!(client.send_datagram(DATA_SMALLER_THAN_MTU, Some(1)), Ok(()));
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU_2, Some(2)),
client.send_datagram(DATA_SMALLER_THAN_MTU.to_vec(), Some(1)),
Ok(())
);
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU_2.to_vec(), Some(2)),
Ok(())
);
// The outgoing datagram queue limit is 2, therefore the datagram with id 1
// will be dropped after adding one more datagram.
let dgram_dropped = client.stats().datagram_tx.dropped_queue_full;
assert_eq!(client.send_datagram(DATA_MTU, Some(3)), Ok(()));
assert_eq!(client.send_datagram(DATA_MTU.to_vec(), Some(3)), Ok(()));
assert!(matches!(
client.next_event().unwrap(),
ConnectionEvent::OutgoingDatagramOutcome { id, outcome } if id == 1 && outcome == OutgoingDatagramOutcome::DroppedQueueFull
@ -441,7 +471,7 @@ fn outgoing_datagram_queue_full() {
));
}
fn send_datagram(sender: &mut Connection, receiver: &mut Connection, data: &[u8]) {
fn send_datagram(sender: &mut Connection, receiver: &mut Connection, data: Vec<u8>) {
let dgram_sent = sender.stats().frame_tx.datagram;
assert_eq!(sender.send_datagram(data, Some(1)), Ok(()));
let out = sender.process_output(now()).dgram().unwrap();
@ -469,9 +499,9 @@ fn multiple_datagram_events() {
let mut server = default_server();
connect_force_idle(&mut client, &mut server);
send_datagram(&mut server, &mut client, FIRST_DATAGRAM);
send_datagram(&mut server, &mut client, SECOND_DATAGRAM);
send_datagram(&mut server, &mut client, THIRD_DATAGRAM);
send_datagram(&mut server, &mut client, FIRST_DATAGRAM.to_vec());
send_datagram(&mut server, &mut client, SECOND_DATAGRAM.to_vec());
send_datagram(&mut server, &mut client, THIRD_DATAGRAM.to_vec());
let mut datagrams = client.events().filter_map(|evt| {
if let ConnectionEvent::Datagram(d) = evt {
@ -486,7 +516,7 @@ fn multiple_datagram_events() {
assert!(datagrams.next().is_none());
// New events can be queued.
send_datagram(&mut server, &mut client, FOURTH_DATAGRAM);
send_datagram(&mut server, &mut client, FOURTH_DATAGRAM.to_vec());
let mut datagrams = client.events().filter_map(|evt| {
if let ConnectionEvent::Datagram(d) = evt {
Some(d)
@ -515,9 +545,9 @@ fn too_many_datagram_events() {
let mut server = default_server();
connect_force_idle(&mut client, &mut server);
send_datagram(&mut server, &mut client, FIRST_DATAGRAM);
send_datagram(&mut server, &mut client, SECOND_DATAGRAM);
send_datagram(&mut server, &mut client, THIRD_DATAGRAM);
send_datagram(&mut server, &mut client, FIRST_DATAGRAM.to_vec());
send_datagram(&mut server, &mut client, SECOND_DATAGRAM.to_vec());
send_datagram(&mut server, &mut client, THIRD_DATAGRAM.to_vec());
// Datagram with FIRST_DATAGRAM data will be dropped.
assert!(matches!(
@ -536,7 +566,7 @@ fn too_many_datagram_events() {
assert_eq!(client.stats().incoming_datagram_dropped, 1);
// New events can be queued.
send_datagram(&mut server, &mut client, FOURTH_DATAGRAM);
send_datagram(&mut server, &mut client, FOURTH_DATAGRAM.to_vec());
assert!(matches!(
client.next_event().unwrap(),
ConnectionEvent::Datagram(data) if data == FOURTH_DATAGRAM
@ -552,11 +582,11 @@ fn multiple_quic_datagrams_in_one_packet() {
let dgram_sent = client.stats().frame_tx.datagram;
// Enqueue 2 datagrams that can fit in a single packet.
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU_2, Some(1)),
client.send_datagram(DATA_SMALLER_THAN_MTU_2.to_vec(), Some(1)),
Ok(())
);
assert_eq!(
client.send_datagram(DATA_SMALLER_THAN_MTU_2, Some(2)),
client.send_datagram(DATA_SMALLER_THAN_MTU_2.to_vec(), Some(2)),
Ok(())
);
@ -608,21 +638,21 @@ fn datagram_fill() {
let buf = vec![9; space];
// This will completely fill available space.
send_datagram(&mut client, &mut server, &buf);
send_datagram(&mut client, &mut server, buf.clone());
// This will leave 1 byte free, but more frames won't be added in this space.
send_datagram(&mut client, &mut server, &buf[..buf.len() - 1]);
send_datagram(&mut client, &mut server, buf[..buf.len() - 1].to_vec());
// This will leave 2 bytes free, which is enough space for a length field,
// but not enough space for another frame after that.
send_datagram(&mut client, &mut server, &buf[..buf.len() - 2]);
send_datagram(&mut client, &mut server, buf[..buf.len() - 2].to_vec());
// Three bytes free will be space enough for a length frame, but not enough
// space left over for another frame (we need 2 bytes).
send_datagram(&mut client, &mut server, &buf[..buf.len() - 3]);
send_datagram(&mut client, &mut server, buf[..buf.len() - 3].to_vec());
// Four bytes free is enough space for another frame.
let called = Rc::new(RefCell::new(false));
client.test_frame_writer = Some(Box::new(TrackingFrameWriter {
called: Rc::clone(&called),
}));
send_datagram(&mut client, &mut server, &buf[..buf.len() - 4]);
send_datagram(&mut client, &mut server, buf[..buf.len() - 4].to_vec());
assert!(*called.borrow());
}

32
third_party/rust/neqo-transport/src/connection/tests/handshake.rs vendored
View File

@ -36,7 +36,7 @@ use crate::{
events::ConnectionEvent,
server::ValidateAddress,
stats::FrameStats,
tparams::{TransportParameter, MIN_ACK_DELAY},
tparams::{self, TransportParameter, MIN_ACK_DELAY},
tracking::DEFAULT_ACK_DELAY,
CloseReason, ConnectionParameters, EmptyConnectionIdGenerator, Error, Pmtud, StreamType,
Version,
@ -798,13 +798,13 @@ fn anti_amplification() {
client.process_input(&s_init1, now);
client.process_input(&s_init2, now);
let ack_count = client.stats().frame_tx.ack;
let frame_count = client.stats().frame_tx.all;
let frame_count = client.stats().frame_tx.all();
let ack = client.process(Some(&s_init3), now).dgram().unwrap();
assert!(!maybe_authenticate(&mut client)); // No need yet.
// The client sends a padded datagram, with just ACK for Handshake.
assert_eq!(client.stats().frame_tx.ack, ack_count + 1);
assert_eq!(client.stats().frame_tx.all, frame_count + 1);
assert_eq!(client.stats().frame_tx.all(), frame_count + 1);
assert_ne!(ack.len(), client.plpmtu()); // Not padded (it includes Handshake).
now += DEFAULT_RTT / 2;
@ -1210,7 +1210,6 @@ fn client_initial_retransmits_identical() {
client.stats().frame_tx,
FrameStats {
crypto: i,
all: i,
..Default::default()
}
);
@ -1238,7 +1237,6 @@ fn server_initial_retransmits_identical() {
FrameStats {
crypto: i * 2,
ack: i,
all: i * 3,
..Default::default()
}
);
@ -1254,3 +1252,27 @@ fn server_initial_retransmits_identical() {
total_ptos += pto;
}
}
#[test]
fn grease_quic_bit_transport_parameter() {
fn get_remote_tp(conn: &Connection) -> bool {
conn.tps
.borrow()
.remote
.as_ref()
.unwrap()
.get_empty(tparams::GREASE_QUIC_BIT)
}
for client_grease in [true, false] {
for server_grease in [true, false] {
let mut client = new_client(ConnectionParameters::default().grease(client_grease));
let mut server = new_server(ConnectionParameters::default().grease(server_grease));
connect(&mut client, &mut server);
assert_eq!(client_grease, get_remote_tp(&server));
assert_eq!(server_grease, get_remote_tp(&client));
}
}
}

63
third_party/rust/neqo-transport/src/connection/tests/idle.rs vendored
View File

@ -30,6 +30,10 @@ fn default_timeout() -> Duration {
ConnectionParameters::default().get_idle_timeout()
}
fn keep_alive_timeout() -> Duration {
default_timeout() / 2
}
fn test_idle_timeout(client: &mut Connection, server: &mut Connection, timeout: Duration) {
assert!(timeout > Duration::from_secs(1));
connect_force_idle(client, server);
@ -412,11 +416,12 @@ fn keep_alive_initiator() {
let stream = create_stream_idle(&mut server, &mut client);
let mut now = now();
// Marking the stream for keep-alive changes the idle timeout.
server.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut server, now, default_timeout());
assert_idle(&mut server, now, keep_alive_timeout());
// Wait that long and the server should send a PING frame.
now += default_timeout() / 2;
now += keep_alive_timeout();
let pings_before = server.stats().frame_tx.ping;
let ping = server.process_output(now).dgram();
assert!(ping.is_some());
@ -427,9 +432,9 @@ fn keep_alive_initiator() {
let out = server.process(out.as_ref(), now).dgram();
assert!(client.process(out.as_ref(), now).dgram().is_none());
// Check that there will be next keep-alive ping after default_timeout().
assert_idle(&mut server, now, default_timeout());
now += default_timeout() / 2;
// Check that there will be next keep-alive ping after keep_alive_timeout().
assert_idle(&mut server, now, keep_alive_timeout());
now += keep_alive_timeout();
let pings_before2 = server.stats().frame_tx.ping;
let ping = server.process_output(now).dgram();
assert!(ping.is_some());
@ -446,10 +451,10 @@ fn keep_alive_lost() {
let mut now = now();
server.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut server, now, default_timeout());
assert_idle(&mut server, now, keep_alive_timeout());
// Wait that long and the server should send a PING frame.
now += default_timeout() / 2;
now += keep_alive_timeout();
let pings_before = server.stats().frame_tx.ping;
let ping = server.process_output(now).dgram();
assert!(ping.is_some());
@ -475,7 +480,7 @@ fn keep_alive_lost() {
// return some small timeout for the recovry although it does not have
// any outstanding data. Therefore we call it after AT_LEAST_PTO.
now += AT_LEAST_PTO;
assert_idle(&mut server, now, default_timeout() - AT_LEAST_PTO);
assert_idle(&mut server, now, keep_alive_timeout() - AT_LEAST_PTO);
}
/// The other peer can also keep it alive.
@ -488,10 +493,11 @@ fn keep_alive_responder() {
let mut now = now();
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now, default_timeout());
assert_idle(&mut client, now, keep_alive_timeout());
// Wait that long and the client should send a PING frame.
now += default_timeout() / 2;
now += keep_alive_timeout();
eprintln!("after wait");
let pings_before = client.stats().frame_tx.ping;
let ping = client.process_output(now).dgram();
assert!(ping.is_some());
@ -507,7 +513,7 @@ fn keep_alive_unmark() {
let stream = create_stream_idle(&mut client, &mut server);
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_keep_alive(stream, false).unwrap();
assert_idle(&mut client, now(), default_timeout());
@ -537,11 +543,11 @@ fn keep_alive_close() {
let stream = create_stream_idle(&mut client, &mut server);
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_close_send(stream).unwrap();
transfer_force_idle(&mut client, &mut server);
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
server.stream_close_send(stream).unwrap();
transfer_force_idle(&mut server, &mut client);
@ -558,19 +564,19 @@ fn keep_alive_reset() {
let stream = create_stream_idle(&mut client, &mut server);
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_close_send(stream).unwrap();
transfer_force_idle(&mut client, &mut server);
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
server.stream_reset_send(stream, 0).unwrap();
transfer_force_idle(&mut server, &mut client);
assert_idle(&mut client, now(), default_timeout());
// The client will fade away from here.
let t = now() + (default_timeout() / 2);
assert_eq!(client.process_output(t).callback(), default_timeout() / 2);
let t = now() + keep_alive_timeout();
assert_eq!(client.process_output(t).callback(), keep_alive_timeout());
let t = now() + default_timeout();
assert_eq!(client.process_output(t), Output::None);
}
@ -584,7 +590,7 @@ fn keep_alive_stop_sending() {
let stream = create_stream_idle(&mut client, &mut server);
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_close_send(stream).unwrap();
client.stream_stop_sending(stream, 0).unwrap();
@ -608,14 +614,14 @@ fn keep_alive_multiple_stop() {
let stream = create_stream_idle(&mut client, &mut server);
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
let other = client.stream_create(StreamType::BiDi).unwrap();
client.stream_keep_alive(other, true).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_keep_alive(stream, false).unwrap();
assert_idle(&mut client, now(), default_timeout());
assert_idle(&mut client, now(), keep_alive_timeout());
client.stream_keep_alive(other, false).unwrap();
assert_idle(&mut client, now(), default_timeout());
@ -638,7 +644,7 @@ fn keep_alive_large_rtt() {
endpoint.stream_keep_alive(stream, true).unwrap();
let delay = endpoint.process_output(now).callback();
qtrace!([endpoint], "new delay {:?}", delay);
assert!(delay > default_timeout() / 2);
assert!(delay > keep_alive_timeout());
assert!(delay > rtt);
}
}
@ -686,8 +692,9 @@ fn keep_alive_with_ack_eliciting_packet_lost() {
// Create a stream.
let stream = client.stream_create(StreamType::BiDi).unwrap();
// Marking the stream for keep-alive changes the idle timeout.
client.stream_keep_alive(stream, true).unwrap();
assert_idle(&mut client, now, IDLE_TIMEOUT);
assert_idle(&mut client, now, IDLE_TIMEOUT / 2);
// Send data on the stream that will be lost.
_ = client.stream_send(stream, DEFAULT_STREAM_DATA).unwrap();
@ -702,11 +709,13 @@ fn keep_alive_with_ack_eliciting_packet_lost() {
let retransmit = client.process_output(now).dgram();
assert!(retransmit.is_some());
// The timeout is the twice the PTO, because we've already sent one probe.
assert_eq!(client.process_output(now).callback(), pto * 2);
// The next callback should be for an idle PING.
assert_eq!(
client.process_output(now).callback(),
IDLE_TIMEOUT / 2 - pto
);
// Wait for half the idle timeout (less the PTO we've already waited)
// so that we get a keep-alive.
// Wait that long and the client should send a PING frame.
now += IDLE_TIMEOUT / 2 - pto;
let pings_before = client.stats().frame_tx.ping;
let ping = client.process_output(now).dgram();

12
third_party/rust/neqo-transport/src/connection/tests/migration.rs vendored
View File

@ -191,11 +191,11 @@ fn migrate_immediate() {
assert_v6_path(&server2, true);
// The second packet has no real effect, it just elicits an ACK.
let all_before = server.stats().frame_tx.all;
let all_before = server.stats().frame_tx.all();
let ack_before = server.stats().frame_tx.ack;
let server3 = server.process(Some(&client2), now).dgram();
assert!(server3.is_some());
assert_eq!(server.stats().frame_tx.all, all_before + 1);
assert_eq!(server.stats().frame_tx.all(), all_before + 1);
assert_eq!(server.stats().frame_tx.ack, ack_before + 1);
// Receiving a packet sent by the server before migration doesn't change path.
@ -249,14 +249,14 @@ fn migrate_immediate_fail() {
let after = client.stats().frame_tx;
assert_eq!(after.path_challenge, before.path_challenge + 1);
assert_eq!(after.padding, before.padding + 1);
assert_eq!(after.all, before.all + 2);
assert_eq!(after.all(), before.all() + 2);
// This might be a PTO, which will result in sending a probe.
if let Some(probe) = client.process_output(now).dgram() {
assert_v4_path(&probe, false); // Contains PATH_CHALLENGE.
let after = client.stats().frame_tx;
assert_eq!(after.ping, before.ping + 1);
assert_eq!(after.all, before.all + 3);
assert_eq!(after.all(), before.all() + 3);
}
}
@ -325,14 +325,14 @@ fn migrate_same_fail() {
let after = client.stats().frame_tx;
assert_eq!(after.path_challenge, before.path_challenge + 1);
assert_eq!(after.padding, before.padding + 1);
assert_eq!(after.all, before.all + 2);
assert_eq!(after.all(), before.all() + 2);
// This might be a PTO, which will result in sending a probe.
if let Some(probe) = client.process_output(now).dgram() {
assert_v6_path(&probe, false); // Contains PATH_CHALLENGE.
let after = client.stats().frame_tx;
assert_eq!(after.ping, before.ping + 1);
assert_eq!(after.all, before.all + 3);
assert_eq!(after.all(), before.all() + 3);
}
}

19
third_party/rust/neqo-transport/src/connection/tests/mod.rs vendored
View File

@ -28,6 +28,7 @@ use crate::{
pmtud::Pmtud,
recovery::ACK_ONLY_SIZE_LIMIT,
stats::{FrameStats, Stats, MAX_PTO_COUNTS},
tparams::{DISABLE_MIGRATION, GREASE_QUIC_BIT},
ConnectionIdDecoder, ConnectionIdGenerator, ConnectionParameters, Error, StreamId, StreamType,
Version,
};
@ -678,3 +679,21 @@ fn create_server() {
// Server won't have a default path, so no RTT.
assert_eq!(stats.rtt, Duration::from_secs(0));
}
#[test]
fn tp_grease() {
for enable in [true, false] {
let client = new_client(ConnectionParameters::default().grease(enable));
let grease = client.tps.borrow_mut().local.get_empty(GREASE_QUIC_BIT);
assert_eq!(enable, grease);
}
}
#[test]
fn tp_disable_migration() {
for disable in [true, false] {
let client = new_client(ConnectionParameters::default().disable_migration(disable));
let disable_migration = client.tps.borrow_mut().local.get_empty(DISABLE_MIGRATION);
assert_eq!(disable, disable_migration);
}
}

12
third_party/rust/neqo-transport/src/connection/tests/recovery.rs vendored
View File

@ -299,17 +299,17 @@ fn pto_handshake_complete() {
assert_handshake(&pkt2_hs);
assert!(pkt2_1rtt.is_some());
let dropped_before1 = server.stats().dropped_rx;
let server_frames = server.stats().frame_rx.all;
let server_frames = server.stats().frame_rx.all();
server.process_input(&pkt2_hs, now);
assert_eq!(1, server.stats().dropped_rx - dropped_before1);
assert_eq!(server.stats().frame_rx.all, server_frames);
assert_eq!(server.stats().frame_rx.all(), server_frames);
server.process_input(&pkt2_1rtt.unwrap(), now);
let server_frames2 = server.stats().frame_rx.all;
let server_frames2 = server.stats().frame_rx.all();
let dropped_before2 = server.stats().dropped_rx;
server.process_input(&pkt3_hs, now);
assert_eq!(1, server.stats().dropped_rx - dropped_before2);
assert_eq!(server.stats().frame_rx.all, server_frames2);
assert_eq!(server.stats().frame_rx.all(), server_frames2);
now += HALF_RTT;
@ -497,10 +497,10 @@ fn ack_after_pto() {
assert!(ack.is_some());
// Make sure that the packet only contained an ACK frame.
let all_frames_before = server.stats().frame_rx.all;
let all_frames_before = server.stats().frame_rx.all();
let ack_before = server.stats().frame_rx.ack;
server.process_input(&ack.unwrap(), now);
assert_eq!(server.stats().frame_rx.all, all_frames_before + 1);
assert_eq!(server.stats().frame_rx.all(), all_frames_before + 1);
assert_eq!(server.stats().frame_rx.ack, ack_before + 1);
}

124
third_party/rust/neqo-transport/src/connection/tests/resumption.rs vendored
View File

@ -6,7 +6,16 @@
use std::{cell::RefCell, mem, rc::Rc, time::Duration};
use test_fixture::{assertions, now};
use neqo_common::{Datagram, Decoder, Role};
use neqo_crypto::AuthenticationStatus;
use test_fixture::{
assertions,
header_protection::{
apply_header_protection, decode_initial_header, initial_aead_and_hp,
remove_header_protection,
},
now, split_datagram,
};
use super::{
connect, connect_with_rtt, default_client, default_server, exchange_ticket, get_tokens,
@ -14,7 +23,9 @@ use super::{
};
use crate::{
addr_valid::{AddressValidation, ValidateAddress},
ConnectionParameters, Error, Version,
frame::FRAME_TYPE_PADDING,
rtt::INITIAL_RTT,
ConnectionParameters, Error, State, Version, MIN_INITIAL_PACKET_SIZE,
};
#[test]
@ -75,6 +86,115 @@ fn remember_smoothed_rtt() {
);
}
fn ticket_rtt(rtt: Duration) -> Duration {
// A simple ACK_ECN frame for a single packet with packet number 0 with a single ECT(0) mark.
const ACK_FRAME_1: &[u8] = &[0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00];
let mut client = new_client(
ConnectionParameters::default().versions(Version::Version1, vec![Version::Version1]),
);
let mut server = default_server();
let mut now = now();
let client_initial = client.process_output(now);
let (_, client_dcid, _, _) =
decode_initial_header(client_initial.as_dgram_ref().unwrap(), Role::Client).unwrap();
let client_dcid = client_dcid.to_owned();
now += rtt / 2;
let server_packet = server.process(client_initial.as_dgram_ref(), now).dgram();
let (server_initial, server_hs) = split_datagram(server_packet.as_ref().unwrap());
let (protected_header, _, _, payload) =
decode_initial_header(&server_initial, Role::Server).unwrap();
// Now decrypt the packet.
let (aead, hp) = initial_aead_and_hp(&client_dcid, Role::Server);
let (header, pn) = remove_header_protection(&hp, protected_header, payload);
assert_eq!(pn, 0);
let pn_len = header.len() - protected_header.len();
let mut buf = vec![0; payload.len()];
let mut plaintext = aead
.decrypt(pn, &header, &payload[pn_len..], &mut buf)
.unwrap()
.to_owned();
// Now we need to find the frames. Make some really strong assumptions.
let mut dec = Decoder::new(&plaintext[..]);
assert_eq!(dec.decode(ACK_FRAME_1.len()), Some(ACK_FRAME_1));
assert_eq!(dec.decode_varint(), Some(0x06)); // CRYPTO
assert_eq!(dec.decode_varint(), Some(0x00)); // offset
dec.skip_vvec(); // Skip over the payload.
// Replace the ACK frame with PADDING.
plaintext[..ACK_FRAME_1.len()].fill(FRAME_TYPE_PADDING.try_into().unwrap());
// And rebuild a packet.
let mut packet = header.clone();
packet.resize(MIN_INITIAL_PACKET_SIZE, 0);
aead.encrypt(pn, &header, &plaintext, &mut packet[header.len()..])
.unwrap();
apply_header_protection(&hp, &mut packet, protected_header.len()..header.len());
let si = Datagram::new(
server_initial.source(),
server_initial.destination(),
server_initial.tos(),
packet,
);
// Now a connection can be made successfully.
now += rtt / 2;
client.process_input(&si, now);
client.process_input(&server_hs.unwrap(), now);
client.authenticated(AuthenticationStatus::Ok, now);
let finished = client.process_output(now);
assert_eq!(*client.state(), State::Connected);
now += rtt / 2;
_ = server.process(finished.as_dgram_ref(), now);
assert_eq!(*server.state(), State::Confirmed);
// Don't deliver the server's handshake finished, it has ACKs.
// Now get a ticket.
let validation = AddressValidation::new(now, ValidateAddress::NoToken).unwrap();
let validation = Rc::new(RefCell::new(validation));
server.set_validation(&validation);
send_something(&mut server, now);
server.send_ticket(now, &[]).expect("can send ticket");
let ticket = server.process_output(now).dgram();
assert!(ticket.is_some());
now += rtt / 2;
client.process_input(&ticket.unwrap(), now);
let token = get_tokens(&mut client).pop().unwrap();
// And connect again.
let mut client = default_client();
client.enable_resumption(now, token).unwrap();
let ticket_rtt = client.paths.rtt();
let mut server = resumed_server(&client);
connect_with_rtt(&mut client, &mut server, now, Duration::from_millis(50));
assert_eq!(
client.paths.rtt(),
Duration::from_millis(50),
"previous RTT should be completely erased"
);
ticket_rtt
}
#[test]
fn ticket_rtt_less_than_default() {
assert_eq!(
ticket_rtt(Duration::from_millis(10)),
Duration::from_millis(10)
);
}
#[test]
fn ticket_rtt_larger_than_default() {
assert_eq!(ticket_rtt(Duration::from_millis(500)), INITIAL_RTT);
}
/// Check that a resumed connection uses a token on Initial packets.
#[test]
fn address_validation_token_resume() {

4
third_party/rust/neqo-transport/src/connection/tests/zerortt.rs vendored
View File

@ -66,11 +66,11 @@ fn zero_rtt_send_recv() {
let server_hs = server.process(client_hs.as_dgram_ref(), now());
assert!(server_hs.as_dgram_ref().is_some()); // ServerHello, etc...
let all_frames = server.stats().frame_tx.all;
let all_frames = server.stats().frame_tx.all();
let ack_frames = server.stats().frame_tx.ack;
let server_process_0rtt = server.process(client_0rtt.as_dgram_ref(), now());
assert!(server_process_0rtt.as_dgram_ref().is_some());
assert_eq!(server.stats().frame_tx.all, all_frames + 1);
assert_eq!(server.stats().frame_tx.all(), all_frames + 1);
assert_eq!(server.stats().frame_tx.ack, ack_frames + 1);
let server_stream_id = server

7
third_party/rust/neqo-transport/src/crypto.rs vendored
View File

@ -21,7 +21,7 @@ use neqo_crypto::{
TLS_AES_128_GCM_SHA256, TLS_AES_256_GCM_SHA384, TLS_CHACHA20_POLY1305_SHA256, TLS_CT_HANDSHAKE,
TLS_EPOCH_APPLICATION_DATA, TLS_EPOCH_HANDSHAKE, TLS_EPOCH_INITIAL, TLS_EPOCH_ZERO_RTT,
TLS_GRP_EC_SECP256R1, TLS_GRP_EC_SECP384R1, TLS_GRP_EC_SECP521R1, TLS_GRP_EC_X25519,
TLS_GRP_KEM_XYBER768D00, TLS_VERSION_1_3,
TLS_GRP_KEM_MLKEM768X25519, TLS_VERSION_1_3,
};
use crate::{
@ -78,9 +78,10 @@ impl Crypto {
])?;
match &mut agent {
Agent::Server(c) => {
// Clients do not send xyber shares by default, but servers should accept them.
// Clients do not send mlkem768x25519 shares by default, but servers should accept
// them.
c.set_groups(&[
TLS_GRP_KEM_XYBER768D00,
TLS_GRP_KEM_MLKEM768X25519,
TLS_GRP_EC_X25519,
TLS_GRP_EC_SECP256R1,
TLS_GRP_EC_SECP384R1,

12
third_party/rust/neqo-transport/src/path.rs vendored
View File

@ -27,10 +27,9 @@ use crate::{
packet::PacketBuilder,
pmtud::Pmtud,
recovery::{RecoveryToken, SentPacket},
rtt::RttEstimate,
rtt::{RttEstimate, RttSource},
sender::PacketSender,
stats::FrameStats,
tracking::PacketNumberSpace,
Stats,
};
@ -811,9 +810,7 @@ impl Path {
builder.encode(&challenge[..]);
// These frames are not retransmitted in the usual fashion.
// There is no token, therefore we need to count `all` specially.
stats.path_response += 1;
stats.all += 1;
if builder.remaining() < 9 {
return true;
@ -832,7 +829,6 @@ impl Path {
// As above, no recovery token.
stats.path_challenge += 1;
stats.all += 1;
self.state = ProbeState::Probing {
probe_count,
@ -987,7 +983,7 @@ impl Path {
&self.qlog,
now - sent.time_sent(),
Duration::new(0, 0),
false,
RttSource::Guesstimate,
now,
);
}
@ -1023,7 +1019,7 @@ impl Path {
pub fn on_packets_lost(
&mut self,
prev_largest_acked_sent: Option<Instant>,
space: PacketNumberSpace,
confirmed: bool,
lost_packets: &[SentPacket],
stats: &mut Stats,
now: Instant,
@ -1033,7 +1029,7 @@ impl Path {
let cwnd_reduced = self.sender.on_packets_lost(
self.rtt.first_sample_time(),
prev_largest_acked_sent,
self.rtt.pto(space), // Important: the base PTO, not adjusted.
self.rtt.pto(confirmed), // Important: the base PTO, not adjusted.
lost_packets,
stats,
now,

1
third_party/rust/neqo-transport/src/pmtud.rs vendored
View File

@ -126,7 +126,6 @@ impl Pmtud {
// seems OK to burn one byte here to simply include a PING.
builder.encode_varint(FRAME_TYPE_PING);
stats.frame_tx.ping += 1;
stats.frame_tx.all += 1;
stats.pmtud_tx += 1;
self.probe_count += 1;
self.probe_state = Probe::Sent;

9
third_party/rust/neqo-transport/src/quic_datagrams.rs vendored
View File

@ -150,11 +150,11 @@ impl QuicDatagrams {
/// not fit into the packet.
pub fn add_datagram(
&mut self,
buf: &[u8],
data: Vec<u8>,
tracking: DatagramTracking,
stats: &mut Stats,
) -> Res<()> {
if u64::try_from(buf.len())? > self.remote_datagram_size {
if u64::try_from(data.len())? > self.remote_datagram_size {
return Err(Error::TooMuchData);
}
if self.datagrams.len() == self.max_queued_outgoing_datagrams {
@ -167,10 +167,7 @@ impl QuicDatagrams {
);
stats.datagram_tx.dropped_queue_full += 1;
}
self.datagrams.push_back(QuicDatagram {
data: buf.to_vec(),
tracking,
});
self.datagrams.push_back(QuicDatagram { data, tracking });
Ok(())
}

73
third_party/rust/neqo-transport/src/recovery/mod.rs vendored
View File

@ -27,7 +27,7 @@ use crate::{
packet::PacketNumber,
path::{Path, PathRef},
qlog::{self, QlogMetric},
rtt::RttEstimate,
rtt::{RttEstimate, RttSource},
stats::{Stats, StatsCell},
tracking::{PacketNumberSpace, PacketNumberSpaceSet},
};
@ -153,11 +153,6 @@ impl LossRecoverySpace {
}
}
#[must_use]
pub const fn space(&self) -> PacketNumberSpace {
self.space
}
/// Find the time we sent the first packet that is lower than the
/// largest acknowledged and that isn't yet declared lost.
/// Use the value we prepared earlier in `detect_lost_packets`.
@ -563,12 +558,20 @@ impl LossRecovery {
now: Instant,
ack_delay: Duration,
) {
let confirmed = self.confirmed_time.map_or(false, |t| t < send_time);
let source = if self.confirmed_time.map_or(false, |t| t < send_time) {
RttSource::AckConfirmed
} else {
RttSource::Ack
};
if let Some(sample) = now.checked_duration_since(send_time) {
rtt.update(&self.qlog, sample, ack_delay, confirmed, now);
rtt.update(&self.qlog, sample, ack_delay, source, now);
}
}
const fn confirmed(&self) -> bool {
self.confirmed_time.is_some()
}
/// Returns (acked packets, lost packets)
#[allow(clippy::too_many_arguments)]
pub fn on_ack_received<R>(
@ -628,7 +631,7 @@ impl LossRecovery {
// as we rely on the count of in-flight packets to determine whether to send
// another probe. Removing them too soon would result in not sending on PTO.
let loss_delay = primary_path.borrow().rtt().loss_delay();
let cleanup_delay = self.pto_period(primary_path.borrow().rtt(), pn_space);
let cleanup_delay = self.pto_period(primary_path.borrow().rtt());
let mut lost = Vec::new();
self.spaces.get_mut(pn_space).unwrap().detect_lost_packets(
now,
@ -643,7 +646,7 @@ impl LossRecovery {
// backoff, so that we can determine persistent congestion.
primary_path.borrow_mut().on_packets_lost(
prev_largest_acked,
pn_space,
self.confirmed(),
&lost,
&mut self.stats.borrow_mut(),
now,
@ -680,7 +683,7 @@ impl LossRecovery {
dropped
}
fn confirmed(&mut self, rtt: &RttEstimate, now: Instant) {
fn confirm(&mut self, rtt: &RttEstimate, now: Instant) {
debug_assert!(self.confirmed_time.is_none());
self.confirmed_time = Some(now);
// Up until now, the ApplicationData space has been ignored for PTO.
@ -717,7 +720,7 @@ impl LossRecovery {
self.pto_state = None;
if space == PacketNumberSpace::Handshake {
self.confirmed(path.rtt(), now);
self.confirm(path.rtt(), now);
}
}
@ -758,41 +761,40 @@ impl LossRecovery {
fn pto_period_inner(
rtt: &RttEstimate,
pto_state: Option<&PtoState>,
pn_space: PacketNumberSpace,
confirmed: bool,
fast_pto: u8,
) -> Duration {
// This is a complicated (but safe) way of calculating:
// base_pto * F * 2^pto_count
// where F = fast_pto / FAST_PTO_SCALE (== 1 by default)
let pto_count = pto_state.map_or(0, |p| u32::try_from(p.count).unwrap_or(0));
rtt.pto(pn_space)
rtt.pto(confirmed)
.checked_mul(u32::from(fast_pto) << min(pto_count, u32::BITS - u8::BITS))
.map_or(Duration::from_secs(3600), |p| p / u32::from(FAST_PTO_SCALE))
}
/// Get the current PTO period for the given packet number space.
/// Unlike calling `RttEstimate::pto` directly, this includes exponential backoff.
fn pto_period(&self, rtt: &RttEstimate, pn_space: PacketNumberSpace) -> Duration {
Self::pto_period_inner(rtt, self.pto_state.as_ref(), pn_space, self.fast_pto)
fn pto_period(&self, rtt: &RttEstimate) -> Duration {
Self::pto_period_inner(
rtt,
self.pto_state.as_ref(),
self.confirmed(),
self.fast_pto,
)
}
// Calculate PTO time for the given space.
fn pto_time(&self, rtt: &RttEstimate, pn_space: PacketNumberSpace) -> Option<Instant> {
if self.confirmed_time.is_none() && pn_space == PacketNumberSpace::ApplicationData {
None
} else {
self.spaces.get(pn_space).and_then(|space| {
space
.pto_base_time()
.map(|t| t + self.pto_period(rtt, pn_space))
})
}
self.spaces
.get(pn_space)
.and_then(|space| space.pto_base_time().map(|t| t + self.pto_period(rtt)))
}
/// Find the earliest PTO time for all active packet number spaces.
/// Ignore Application if either Initial or Handshake have an active PTO.
fn earliest_pto(&self, rtt: &RttEstimate) -> Option<Instant> {
if self.confirmed_time.is_some() {
if self.confirmed() {
self.pto_time(rtt, PacketNumberSpace::ApplicationData)
} else {
self.pto_time(rtt, PacketNumberSpace::Initial)
@ -860,6 +862,7 @@ impl LossRecovery {
qtrace!([self], "timeout {:?}", now);
let loss_delay = primary_path.borrow().rtt().loss_delay();
let confirmed = self.confirmed();
let mut lost_packets = Vec::new();
for space in self.spaces.iter_mut() {
@ -867,14 +870,14 @@ impl LossRecovery {
let pto = Self::pto_period_inner(
primary_path.borrow().rtt(),
self.pto_state.as_ref(),
space.space(),
confirmed,
self.fast_pto,
);
space.detect_lost_packets(now, loss_delay, pto, &mut lost_packets);
primary_path.borrow_mut().on_packets_lost(
space.largest_acked_sent_time,
space.space(),
confirmed,
&lost_packets[first..],
&mut self.stats.borrow_mut(),
now,
@ -951,7 +954,6 @@ mod tests {
ecn::EcnCount,
packet::{PacketNumber, PacketType},
path::{Path, PathRef},
rtt::RttEstimate,
stats::{Stats, StatsCell},
};
@ -962,8 +964,8 @@ mod tests {
const ON_SENT_SIZE: usize = 100;
/// An initial RTT for using with `setup_lr`.
const TEST_RTT: Duration = ms(80);
const TEST_RTTVAR: Duration = ms(40);
const TEST_RTT: Duration = ms(7000);
const TEST_RTTVAR: Duration = ms(3500);
struct Fixture {
lr: LossRecovery,
@ -1034,6 +1036,7 @@ mod tests {
ConnectionIdEntry::new(0, ConnectionId::from(&[1, 2, 3]), [0; 16]),
);
path.set_primary(true);
path.rtt_mut().set_initial(TEST_RTT);
Self {
lr: LossRecovery::new(StatsCell::default(), FAST_PTO_SCALE),
path: Rc::new(RefCell::new(path)),
@ -1511,13 +1514,13 @@ mod tests {
ON_SENT_SIZE,
));
assert_eq!(lr.pto_time(PacketNumberSpace::ApplicationData), None);
assert!(lr.pto_time(PacketNumberSpace::ApplicationData).is_some());
lr.discard(PacketNumberSpace::Initial, pn_time(1));
assert_eq!(lr.pto_time(PacketNumberSpace::ApplicationData), None);
assert!(lr.pto_time(PacketNumberSpace::ApplicationData).is_some());
// Expiring state after the PTO on the ApplicationData space has
// expired should result in setting a PTO state.
let default_pto = RttEstimate::default().pto(PacketNumberSpace::ApplicationData);
let default_pto = lr.path.borrow().rtt().pto(true);
let expected_pto = pn_time(2) + default_pto;
lr.discard(PacketNumberSpace::Handshake, expected_pto);
let profile = lr.send_profile(now());
@ -1549,7 +1552,7 @@ mod tests {
ON_SENT_SIZE,
));
let handshake_pto = RttEstimate::default().pto(PacketNumberSpace::Handshake);
let handshake_pto = lr.path.borrow().rtt().pto(false);
let expected_pto = now() + handshake_pto;
assert_eq!(lr.pto_time(PacketNumberSpace::Initial), Some(expected_pto));
let profile = lr.send_profile(now());

23
third_party/rust/neqo-transport/src/recv_stream.rs vendored
View File

@ -92,32 +92,19 @@ impl RecvStreams {
}
pub fn clear_terminal(&mut self, send_streams: &SendStreams, role: Role) -> (u64, u64) {
let recv_to_remove = self
.streams
.iter()
.filter_map(|(id, stream)| {
// Remove all streams for which the receiving is done (or aborted).
// But only if they are unidirectional, or we have finished sending.
if stream.is_terminal() && (id.is_uni() || !send_streams.exists(*id)) {
Some(*id)
} else {
None
}
})
.collect::<Vec<_>>();
let mut removed_bidi = 0;
let mut removed_uni = 0;
for id in &recv_to_remove {
self.streams.remove(id);
if id.is_remote_initiated(role) {
self.streams.retain(|id, s| {
let dead = s.is_terminal() && (id.is_uni() || !send_streams.exists(*id));
if dead && id.is_remote_initiated(role) {
if id.is_bidi() {
removed_bidi += 1;
} else {
removed_uni += 1;
}
}
}
!dead
});
(removed_bidi, removed_uni)
}

30
third_party/rust/neqo-transport/src/rtt.rs vendored
View File

@ -19,7 +19,6 @@ use crate::{
qlog::{self, QlogMetric},
recovery::RecoveryToken,
stats::FrameStats,
tracking::PacketNumberSpace,
};
/// The smallest time that the system timer (via `sleep()`, `nanosleep()`,
@ -28,6 +27,17 @@ pub const GRANULARITY: Duration = Duration::from_millis(1);
// Defined in -recovery 6.2 as 333ms but using lower value.
pub const INITIAL_RTT: Duration = Duration::from_millis(100);
/// The source of the RTT measurement.
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
pub enum RttSource {
/// RTT guess from a retry or dropping a packet number space.
Guesstimate,
/// Ack on an unconfirmed connection.
Ack,
/// Ack on a confirmed connection.
AckConfirmed,
}
#[derive(Debug)]
#[allow(clippy::module_name_repetitions)]
pub struct RttEstimate {
@ -37,6 +47,7 @@ pub struct RttEstimate {
rttvar: Duration,
min_rtt: Duration,
ack_delay: PeerAckDelay,
best_source: RttSource,
}
impl RttEstimate {
@ -58,6 +69,7 @@ impl RttEstimate {
rttvar: Duration::from_millis(0),
min_rtt: rtt,
ack_delay: PeerAckDelay::Fixed(Duration::from_millis(25)),
best_source: RttSource::Ack,
}
}
@ -83,17 +95,24 @@ impl RttEstimate {
self.ack_delay.update(cwnd, mtu, self.smoothed_rtt);
}
pub fn is_guesstimate(&self) -> bool {
self.best_source == RttSource::Guesstimate
}
pub fn update(
&mut self,
qlog: &NeqoQlog,
mut rtt_sample: Duration,
ack_delay: Duration,
confirmed: bool,
source: RttSource,
now: Instant,
) {
debug_assert!(source >= self.best_source);
self.best_source = max(self.best_source, source);
// Limit ack delay by max_ack_delay if confirmed.
let mad = self.ack_delay.max();
let ack_delay = if confirmed && ack_delay > mad {
let ack_delay = if self.best_source == RttSource::AckConfirmed && ack_delay > mad {
mad
} else {
ack_delay
@ -143,9 +162,9 @@ impl RttEstimate {
self.smoothed_rtt
}
pub fn pto(&self, pn_space: PacketNumberSpace) -> Duration {
pub fn pto(&self, confirmed: bool) -> Duration {
let mut t = self.estimate() + max(4 * self.rttvar, GRANULARITY);
if pn_space == PacketNumberSpace::ApplicationData {
if confirmed {
t += self.ack_delay.max();
}
t
@ -205,6 +224,7 @@ impl Default for RttEstimate {
rttvar: INITIAL_RTT / 2,
min_rtt: INITIAL_RTT,
ack_delay: PeerAckDelay::default(),
best_source: RttSource::Guesstimate,
}
}
}

29
third_party/rust/neqo-transport/src/stats.rs vendored
View File

@ -24,7 +24,6 @@ pub const MAX_PTO_COUNTS: usize = 16;
#[cfg_attr(test, derive(PartialEq, Eq))]
#[allow(clippy::module_name_repetitions)]
pub struct FrameStats {
pub all: usize,
pub ack: usize,
pub largest_acknowledged: PacketNumber,
@ -97,6 +96,34 @@ impl Debug for FrameStats {
}
}
#[cfg(test)]
impl FrameStats {
pub const fn all(&self) -> usize {
self.ack
+ self.crypto
+ self.stream
+ self.reset_stream
+ self.stop_sending
+ self.ping
+ self.padding
+ self.max_streams
+ self.streams_blocked
+ self.max_data
+ self.data_blocked
+ self.max_stream_data
+ self.stream_data_blocked
+ self.new_connection_id
+ self.retire_connection_id
+ self.path_challenge
+ self.path_response
+ self.connection_close
+ self.handshake_done
+ self.new_token
+ self.ack_frequency
+ self.datagram
}
}
/// Datagram stats
#[derive(Default, Clone)]
#[allow(clippy::module_name_repetitions)]

8
third_party/rust/neqo-transport/tests/connection.rs vendored
View File

@ -275,12 +275,12 @@ fn overflow_crypto() {
}
#[test]
fn handshake_xyber() {
fn handshake_mlkem768x25519() {
let mut client = default_client();
let mut server = default_server();
client
.set_groups(&[neqo_crypto::TLS_GRP_KEM_XYBER768D00])
.set_groups(&[neqo_crypto::TLS_GRP_KEM_MLKEM768X25519])
.ok();
client.send_additional_key_shares(0).ok();
@ -289,10 +289,10 @@ fn handshake_xyber() {
assert_eq!(*server.state(), State::Confirmed);
assert_eq!(
client.tls_info().unwrap().key_exchange(),
neqo_crypto::TLS_GRP_KEM_XYBER768D00
neqo_crypto::TLS_GRP_KEM_MLKEM768X25519
);
assert_eq!(
server.tls_info().unwrap().key_exchange(),
neqo_crypto::TLS_GRP_KEM_XYBER768D00
neqo_crypto::TLS_GRP_KEM_MLKEM768X25519
);
}

2
third_party/rust/neqo-udp/.cargo-checksum.json vendored
View File

@ -1 +1 @@
{"files":{"Cargo.toml":"8cfcba41a8fd167767c8e76921ea60e82e262feb014a28fed7f94c0453e2917c","src/lib.rs":"bf3bc79b1d799a42b73e64d2b203ce688cc0859d7afa6c66eec429ec36199ba6"},"package":null}
{"files":{"Cargo.toml":"1382d90af5009ac2e42ec2f5f04407d9e8750a7fe05c28bd573860b5e15be713","src/lib.rs":"bf3bc79b1d799a42b73e64d2b203ce688cc0859d7afa6c66eec429ec36199ba6"},"package":null}

2
third_party/rust/neqo-udp/Cargo.toml vendored
View File

@ -13,7 +13,7 @@
edition = "2021"
rust-version = "1.76.0"
name = "neqo-udp"
version = "0.9.0"
version = "0.9.1"
authors = ["The Neqo Authors <necko@mozilla.com>"]
build = false
autobins = false