From 6deaef8eb0cb6ca4689113e97780f8a6ba98cf12 Mon Sep 17 00:00:00 2001 From: Max Inden Date: Thu, 19 Sep 2024 19:58:23 +0200 Subject: [PATCH] Rename write_buffer to out --- fuzz/fuzz_targets/client_initial.rs | 8 +- fuzz/fuzz_targets/server_initial.rs | 8 +- neqo-bin/src/client/http09.rs | 4 +- neqo-bin/src/client/http3.rs | 4 +- neqo-bin/src/client/mod.rs | 2 +- neqo-bin/src/server/http09.rs | 4 +- neqo-bin/src/server/http3.rs | 4 +- neqo-bin/src/server/mod.rs | 2 +- neqo-common/src/codec.rs | 170 +++++++++--------- neqo-common/src/incrdecoder.rs | 12 +- neqo-crypto/src/selfencrypt.rs | 12 +- neqo-http3/src/connection_client.rs | 128 ++++++------- neqo-http3/src/control_stream_local.rs | 8 +- .../tests/webtransport/negotiation.rs | 4 +- .../extended_connect/webtransport_session.rs | 10 +- .../extended_connect/webtransport_streams.rs | 6 +- neqo-http3/src/frames/hframe.rs | 4 +- neqo-http3/src/frames/tests/hframe.rs | 4 +- neqo-http3/src/frames/tests/mod.rs | 16 +- neqo-http3/src/lib.rs | 2 +- neqo-http3/src/send_message.rs | 14 +- neqo-http3/src/server.rs | 24 ++- neqo-http3/src/settings.rs | 6 +- neqo-http3/src/stream_type_reader.rs | 4 +- neqo-transport/src/addr_valid.rs | 14 +- neqo-transport/src/connection/mod.rs | 38 ++-- neqo-transport/src/connection/tests/vn.rs | 6 +- neqo-transport/src/crypto.rs | 6 +- neqo-transport/src/frame.rs | 28 +-- neqo-transport/src/packet/mod.rs | 24 +-- neqo-transport/src/recv_stream.rs | 20 +-- neqo-transport/src/server.rs | 50 +++--- neqo-transport/src/tparams.rs | 36 ++-- neqo-transport/tests/connection.rs | 10 +- neqo-transport/tests/retry.rs | 14 +- neqo-transport/tests/server.rs | 12 +- test-fixture/src/sim/mod.rs | 4 +- 37 files changed, 352 insertions(+), 370 deletions(-) diff --git a/fuzz/fuzz_targets/client_initial.rs b/fuzz/fuzz_targets/client_initial.rs index a9fd11f2b0..29390b4fd2 100644 --- a/fuzz/fuzz_targets/client_initial.rs +++ b/fuzz/fuzz_targets/client_initial.rs @@ -24,13 +24,13 @@ fuzz_target!(|data: &[u8]| { let (aead, hp) = initial_aead_and_hp(d_cid, Role::Client); let (_, pn) = remove_header_protection(&hp, header, payload); - let mut write_buffer = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); - let mut payload_enc = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); + let mut payload_enc = Encoder::new(&mut out); payload_enc.encode(data); // Add fuzzed data. // Make a new header with a 1 byte packet number length. - let mut write_buffer = Vec::new(); - let mut header_enc = Encoder::new(&mut write_buffer); + let mut out = Vec::new(); + let mut header_enc = Encoder::new(&mut out); header_enc .encode_byte(0xc0) // Initial with 1 byte packet number. .encode_uint(4, Version::default().wire_version()) diff --git a/fuzz/fuzz_targets/server_initial.rs b/fuzz/fuzz_targets/server_initial.rs index 504be8965c..f2bd6fbbf5 100644 --- a/fuzz/fuzz_targets/server_initial.rs +++ b/fuzz/fuzz_targets/server_initial.rs @@ -30,13 +30,13 @@ fuzz_target!(|data: &[u8]| { let (aead, hp) = initial_aead_and_hp(d_cid, Role::Server); let (_, pn) = remove_header_protection(&hp, header, payload); - let mut write_buffer = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); - let mut payload_enc = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); + let mut payload_enc = Encoder::new(&mut out); payload_enc.encode(data); // Add fuzzed data. // Make a new header with a 1 byte packet number length. - let mut write_buffer = Vec::new(); - let mut header_enc = Encoder::new(&mut write_buffer); + let mut out = Vec::new(); + let mut header_enc = Encoder::new(&mut out); header_enc .encode_byte(0xc0) // Initial with 1 byte packet number. .encode_uint(4, Version::default().wire_version()) diff --git a/neqo-bin/src/client/http09.rs b/neqo-bin/src/client/http09.rs index b3e5d1c86b..f4bb818182 100644 --- a/neqo-bin/src/client/http09.rs +++ b/neqo-bin/src/client/http09.rs @@ -181,9 +181,9 @@ impl super::Client for Connection { &mut self, input: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - self.process_into_buffer(input, now, write_buffer) + self.process_into_buffer(input, now, out) } fn close(&mut self, now: Instant, app_error: neqo_transport::AppError, msg: S) diff --git a/neqo-bin/src/client/http3.rs b/neqo-bin/src/client/http3.rs index f2e3257e2c..b571c2a0ce 100644 --- a/neqo-bin/src/client/http3.rs +++ b/neqo-bin/src/client/http3.rs @@ -132,9 +132,9 @@ impl super::Client for Http3Client { &mut self, input: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - self.process_into_buffer(input, now, write_buffer) + self.process_into_buffer(input, now, out) } fn close(&mut self, now: Instant, app_error: AppError, msg: S) diff --git a/neqo-bin/src/client/mod.rs b/neqo-bin/src/client/mod.rs index a5fe866a59..269312de95 100644 --- a/neqo-bin/src/client/mod.rs +++ b/neqo-bin/src/client/mod.rs @@ -376,7 +376,7 @@ trait Client { &mut self, input: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]>; fn has_events(&self) -> bool; fn close(&mut self, now: Instant, app_error: AppError, msg: S) diff --git a/neqo-bin/src/server/http09.rs b/neqo-bin/src/server/http09.rs index f91dd39356..379a835ae7 100644 --- a/neqo-bin/src/server/http09.rs +++ b/neqo-bin/src/server/http09.rs @@ -189,9 +189,9 @@ impl super::HttpServer for HttpServer { &mut self, dgram: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - self.server.process_into_buffer(dgram, now, write_buffer) + self.server.process_into_buffer(dgram, now, out) } fn process_events(&mut self, now: Instant) { diff --git a/neqo-bin/src/server/http3.rs b/neqo-bin/src/server/http3.rs index 25dd5d46a4..8ff72a95d4 100644 --- a/neqo-bin/src/server/http3.rs +++ b/neqo-bin/src/server/http3.rs @@ -83,9 +83,9 @@ impl super::HttpServer for HttpServer { &mut self, dgram: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> neqo_http3::Output<&'a [u8]> { - self.server.process_into_buffer(dgram, now, write_buffer) + self.server.process_into_buffer(dgram, now, out) } fn process_events(&mut self, _now: Instant) { diff --git a/neqo-bin/src/server/mod.rs b/neqo-bin/src/server/mod.rs index 385e2081d4..dccb035977 100644 --- a/neqo-bin/src/server/mod.rs +++ b/neqo-bin/src/server/mod.rs @@ -198,7 +198,7 @@ pub trait HttpServer: Display { &mut self, dgram: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]>; fn process_events(&mut self, now: Instant); fn has_events(&self) -> bool; diff --git a/neqo-common/src/codec.rs b/neqo-common/src/codec.rs index a8d29a68bc..b83bfd0092 100644 --- a/neqo-common/src/codec.rs +++ b/neqo-common/src/codec.rs @@ -457,8 +457,8 @@ mod tests { #[test] fn decode() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode(2).unwrap(), &[0x01, 0x23]); assert!(dec.decode(2).is_none()); @@ -466,8 +466,8 @@ mod tests { #[test] fn decode_byte() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("0123"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("0123"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_byte().unwrap(), 0x01); @@ -477,16 +477,16 @@ mod tests { #[test] fn decode_byte_short() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex(""); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex(""); let mut dec = enc.as_decoder(); assert!(dec.decode_byte().is_none()); } #[test] fn decode_remainder() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_remainder(), &[0x01, 0x23, 0x45]); assert!(dec.decode(2).is_none()); @@ -497,14 +497,14 @@ mod tests { #[test] fn decode_vec() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_vec(1).expect("read one octet length"), &[0x23]); assert_eq!(dec.remaining(), 1); - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("00012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("00012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_vec(2).expect("read two octet length"), &[0x23]); assert_eq!(dec.remaining(), 1); @@ -513,28 +513,28 @@ mod tests { #[test] fn decode_vec_short() { // The length is too short. - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("02"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("02"); let mut dec = enc.as_decoder(); assert!(dec.decode_vec(2).is_none()); // The body is too short. - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("0200"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("0200"); let mut dec = enc.as_decoder(); assert!(dec.decode_vec(1).is_none()); } #[test] fn decode_vvec() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_vvec().expect("read one octet length"), &[0x23]); assert_eq!(dec.remaining(), 1); - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("40012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("40012345"); let mut dec = enc.as_decoder(); assert_eq!(dec.decode_vvec().expect("read two octet length"), &[0x23]); assert_eq!(dec.remaining(), 1); @@ -543,21 +543,21 @@ mod tests { #[test] fn decode_vvec_short() { // The length field is too short. - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff"); let mut dec = enc.as_decoder(); assert!(dec.decode_vvec().is_none()); - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("405500"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("405500"); let mut dec = enc.as_decoder(); assert!(dec.decode_vvec().is_none()); } #[test] fn skip() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ffff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ffff"); let mut dec = enc.as_decoder(); dec.skip(1); assert_eq!(dec.remaining(), 1); @@ -566,16 +566,16 @@ mod tests { #[test] #[should_panic(expected = "insufficient data")] fn skip_too_much() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff"); let mut dec = enc.as_decoder(); dec.skip(2); } #[test] fn skip_vec() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); dec.skip_vec(1); assert_eq!(dec.remaining(), 1); @@ -584,8 +584,8 @@ mod tests { #[test] #[should_panic(expected = "insufficient data")] fn skip_vec_too_much() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff1234"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff1234"); let mut dec = enc.as_decoder(); dec.skip_vec(1); } @@ -593,15 +593,15 @@ mod tests { #[test] #[should_panic(expected = "invalid length")] fn skip_vec_short_length() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff"); let mut dec = enc.as_decoder(); dec.skip_vec(4); } #[test] fn skip_vvec() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("012345"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("012345"); let mut dec = enc.as_decoder(); dec.skip_vvec(); assert_eq!(dec.remaining(), 1); @@ -610,8 +610,8 @@ mod tests { #[test] #[should_panic(expected = "insufficient data")] fn skip_vvec_too_much() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("0f1234"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("0f1234"); let mut dec = enc.as_decoder(); dec.skip_vvec(); } @@ -619,8 +619,8 @@ mod tests { #[test] #[should_panic(expected = "invalid length")] fn skip_vvec_short_length() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff"); let mut dec = enc.as_decoder(); dec.skip_vvec(); } @@ -661,8 +661,8 @@ mod tests { #[test] fn encode_byte() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_byte(1); assert_eq!(enc, Encoder::new(&mut vec![]).from_hex("01")); @@ -673,16 +673,16 @@ mod tests { #[test] fn encode() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode(&[1, 2, 3]); assert_eq!(enc, Encoder::new(&mut vec![]).from_hex("010203")); } #[test] fn encode_uint() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_uint(2, 10_u8); // 000a enc.encode_uint(1, 257_u16); // 01 enc.encode_uint(3, 0xff_ffff_u32); // ffffff @@ -702,8 +702,8 @@ mod tests { #[test] fn builder_inas_decoder() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("010203"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("010203"); let buf = &[1, 2, 3]; assert_eq!(enc.as_decoder(), Decoder::new(buf)); } @@ -736,11 +736,11 @@ mod tests { for c in cases { assert_eq!(Encoder::varint_len(c.v), c.b.len() / 2); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_varint(c.v); - let mut write_buffer = vec![]; - let encoded = Encoder::new(&mut write_buffer).from_hex(&c.b); + let mut out = vec![]; + let encoded = Encoder::new(&mut out).from_hex(&c.b); assert_eq!(enc, encoded); let mut dec = encoded.as_decoder(); @@ -753,8 +753,8 @@ mod tests { #[test] fn varint_decode_long_zero() { for c in &["4000", "80000000", "c000000000000000"] { - let mut write_buffer = vec![]; - let encoded = Encoder::new(&mut write_buffer).from_hex(c); + let mut out = vec![]; + let encoded = Encoder::new(&mut out).from_hex(c); let mut dec = encoded.as_decoder(); let v = dec.decode_varint().expect("should decode"); assert_eq!(dec.remaining(), 0); @@ -765,8 +765,8 @@ mod tests { #[test] fn varint_decode_short() { for c in &["40", "800000", "c0000000000000"] { - let mut write_buffer = vec![]; - let encoded = Encoder::new(&mut write_buffer).from_hex(c); + let mut out = vec![]; + let encoded = Encoder::new(&mut out).from_hex(c); let mut dec = encoded.as_decoder(); assert!(dec.decode_varint().is_none()); } @@ -774,19 +774,19 @@ mod tests { #[test] fn encode_vec() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vec(2, &[1, 2, 0x34]); assert_eq!(enc.to_hex(), "0003010234"); } #[test] fn encode_vec_with() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vec_with(2, |enc_inner| { - let mut write_buffer = vec![]; - let hex = Encoder::new(&mut write_buffer).from_hex("02"); + let mut out = vec![]; + let hex = Encoder::new(&mut out).from_hex("02"); enc_inner.encode(hex.as_ref()); }); assert_eq!(enc.to_hex(), "000102"); @@ -795,8 +795,8 @@ mod tests { #[test] #[should_panic(expected = "assertion failed")] fn encode_vec_with_overflow() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vec_with(1, |enc_inner| { enc_inner.encode(&[0xb0; 256]); }); @@ -804,19 +804,19 @@ mod tests { #[test] fn encode_vvec() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vvec(&[1, 2, 0x34]); assert_eq!(enc.to_hex(), "03010234"); } #[test] fn encode_vvec_with() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vvec_with(|enc_inner| { - let mut write_buffer = vec![]; - let hex = Encoder::new(&mut write_buffer).from_hex("02"); + let mut out = vec![]; + let hex = Encoder::new(&mut out).from_hex("02"); enc_inner.encode(hex.as_ref()); }); assert_eq!(enc.to_hex(), "0102"); @@ -824,21 +824,21 @@ mod tests { #[test] fn encode_vvec_with_longer() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vvec_with(|enc_inner| { enc_inner.encode(&[0xa5; 65]); }); - assert_eq!(&write_buffer[..3], &[0x40, 0x41, 0xa5]); + assert_eq!(&out[..3], &[0x40, 0x41, 0xa5]); } // Test that Deref to &[u8] works for Encoder. #[test] fn encode_builder() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer).from_hex("ff"); - let mut write_buffer = vec![]; - let enc2 = Encoder::new(&mut write_buffer).from_hex("010234"); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out).from_hex("ff"); + let mut out = vec![]; + let enc2 = Encoder::new(&mut out).from_hex("010234"); enc.encode(enc2.as_ref()); assert_eq!(enc.to_hex(), "ff010234"); } @@ -846,10 +846,10 @@ mod tests { // Test that Deref to &[u8] works for Decoder. #[test] fn encode_view() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer).from_hex("ff"); - let mut write_buffer = vec![]; - let enc2 = Encoder::new(&mut write_buffer).from_hex("010234"); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out).from_hex("ff"); + let mut out = vec![]; + let enc2 = Encoder::new(&mut out).from_hex("010234"); let v = enc2.as_decoder(); enc.encode(v.as_ref()); assert_eq!(enc.to_hex(), "ff010234"); @@ -857,16 +857,16 @@ mod tests { #[test] fn encode_mutate() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer).from_hex("010234"); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out).from_hex("010234"); enc.as_mut()[0] = 0xff; assert_eq!(enc.to_hex(), "ff0234"); } #[test] fn pad() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer).from_hex("010234"); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out).from_hex("010234"); enc.pad_to(5, 0); assert_eq!(enc.to_hex(), "0102340000"); enc.pad_to(4, 0); diff --git a/neqo-common/src/incrdecoder.rs b/neqo-common/src/incrdecoder.rs index e2824cadfe..4fdbd664a6 100644 --- a/neqo-common/src/incrdecoder.rs +++ b/neqo-common/src/incrdecoder.rs @@ -180,8 +180,8 @@ mod tests { ); let decoder = IncrementalDecoderUint::default(); - let mut write_buffer = vec![]; - let mut db = Encoder::new(&mut write_buffer).from_hex(&self.b); + let mut out = vec![]; + let mut db = Encoder::new(&mut out).from_hex(&self.b); // Add padding so that we can verify that the reader doesn't over-consume. db.encode_byte(0xff); @@ -238,8 +238,8 @@ mod tests { #[test] fn zero_len() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("ff"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("ff"); let mut dec = Decoder::new(enc.as_ref()); let mut incr = IncrementalDecoderBuffer::new(0); assert_eq!(incr.consume(&mut dec), Some(Vec::new())); @@ -248,8 +248,8 @@ mod tests { #[test] fn ignore() { - let mut write_buffer = vec![]; - let db = Encoder::new(&mut write_buffer).from_hex("12345678ff"); + let mut out = vec![]; + let db = Encoder::new(&mut out).from_hex("12345678ff"); let decoder = IncrementalDecoderIgnore::new(4); diff --git a/neqo-crypto/src/selfencrypt.rs b/neqo-crypto/src/selfencrypt.rs index b55ae478d2..b113efff7b 100644 --- a/neqo-crypto/src/selfencrypt.rs +++ b/neqo-crypto/src/selfencrypt.rs @@ -86,14 +86,14 @@ impl SelfEncrypt { let cipher = self.make_aead(&self.key, &salt)?; let encoded_len = 2 + salt.len() + plaintext.len() + cipher.expansion(); - let mut write_buffer = Vec::with_capacity(encoded_len); - let mut enc = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(encoded_len); + let mut enc = Encoder::new(&mut out); enc.encode_byte(Self::VERSION); enc.encode_byte(self.key_id); enc.encode(&salt); - let mut write_buffer_2 = enc.to_vec(); - let mut extended_aad = Encoder::new(&mut write_buffer_2); + let mut out_2 = enc.to_vec(); + let mut extended_aad = Encoder::new(&mut out_2); extended_aad.encode(aad); let offset = enc.len(); @@ -139,8 +139,8 @@ impl SelfEncrypt { }; let offset = 2 + Self::SALT_LENGTH; - let mut write_buffer = Vec::with_capacity(offset + aad.len()); - let mut extended_aad = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(offset + aad.len()); + let mut extended_aad = Encoder::new(&mut out); extended_aad.encode(&ciphertext[0..offset]); extended_aad.encode(aad); diff --git a/neqo-http3/src/connection_client.rs b/neqo-http3/src/connection_client.rs index 0c4182eb3a..f5aee9df99 100644 --- a/neqo-http3/src/connection_client.rs +++ b/neqo-http3/src/connection_client.rs @@ -409,11 +409,11 @@ impl Http3Client { fn encode_resumption_token(&self, token: &ResumptionToken) -> Option { self.base_handler.get_settings().map(|settings| { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); settings.encode_frame_contents(&mut enc); enc.encode(token.as_ref()); - ResumptionToken::new(write_buffer, token.expiration_time()) + ResumptionToken::new(out, token.expiration_time()) }) } @@ -622,8 +622,8 @@ impl Http3Client { /// `InvalidStreamId` if the stream does not exist, /// `AlreadyClosed` if the stream has already been closed. /// `TransportStreamDoesNotExist` if the transport stream does not exist (this may happen if - /// [`Http3Client::process`] has not been called when needed, and HTTP3 layer has not picked up the - /// info that the stream has been closed.) `InvalidInput` if an empty buffer has been + /// [`Http3Client::process`] has not been called when needed, and HTTP3 layer has not picked up + /// the info that the stream has been closed.) `InvalidInput` if an empty buffer has been /// supplied. pub fn send_data(&mut self, stream_id: StreamId, buf: &[u8]) -> Res { qinfo!( @@ -858,7 +858,7 @@ impl Http3Client { &mut self, input: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { qtrace!([self], "Process."); if let Some(d) = input { @@ -870,7 +870,7 @@ impl Http3Client { self.process_http3(now); } - let out = self.conn.process_into_buffer(None, now, write_buffer); + let out = self.conn.process_into_buffer(None, now, out); self.process_http3(now); out } @@ -878,8 +878,8 @@ impl Http3Client { /// Same as [`Http3Client::process_into_buffer`] but allocating output into /// new [`Vec`]. pub fn process(&mut self, dgram: Option<&Datagram>, now: Instant) -> Output { - let mut write_buffer = vec![]; - self.process_into_buffer(dgram.map(Into::into), now, &mut write_buffer) + let mut out = vec![]; + self.process_into_buffer(dgram.map(Into::into), now, &mut out) .map_datagram(Into::into) } @@ -1451,8 +1451,8 @@ mod tests { ); // Encode a settings frame and send it. - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); self.settings.encode(&mut enc); assert_eq!( self.conn @@ -1896,8 +1896,8 @@ mod tests { push_id, header_block: PUSH_PROMISE_DATA.to_vec(), }; - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); frame.encode(&mut d); _ = conn.stream_send(stream_id, d.as_ref()).unwrap(); } @@ -1936,8 +1936,8 @@ mod tests { push_id: u64, ) { let frame = HFrame::CancelPush { push_id }; - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); frame.encode(&mut d); server .conn @@ -2854,11 +2854,11 @@ mod tests { fn alloc_buffer(size: usize) -> (Vec, Vec) { let data_frame = HFrame::Data { len: size as u64 }; - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); data_frame.encode(&mut enc); - (vec![0_u8; size], write_buffer) + (vec![0_u8; size], out) } // Send 2 frames. For the second one we can only send 63 bytes. @@ -3996,8 +3996,8 @@ mod tests { let encoder_inst_pkt = server.conn.process(None, now()); // Send response - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: 3 }; d_frame.encode(&mut d); @@ -4065,8 +4065,8 @@ mod tests { // headers. let encoder_inst_pkt = server.conn.process(None, now()); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); server_send_response_and_exchange_packet( @@ -4347,8 +4347,8 @@ mod tests { // Send new settings. let control_stream = server.conn.stream_create(StreamType::UniDi).unwrap(); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); server.settings.encode(&mut enc); let mut sent = server.conn.stream_send(control_stream, CONTROL_STREAM_TYPE); assert_eq!(sent.unwrap(), CONTROL_STREAM_TYPE.len()); @@ -4987,8 +4987,8 @@ mod tests { client.process(out.as_dgram_ref(), now()); // Send response - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: 3 }; d_frame.encode(&mut d); @@ -5957,8 +5957,8 @@ mod tests { let encoder_inst_pkt = server.conn.process(None, now()).dgram(); assert!(encoder_inst_pkt.is_some()); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); push_promise_frame.encode(&mut d); server_send_response_and_exchange_packet(client, server, stream_id, &d, false); @@ -6102,8 +6102,8 @@ mod tests { let header_hframe = HFrame::Headers { header_block: encoded_headers.to_vec(), }; - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); header_hframe.encode(&mut d); server_send_response_and_exchange_packet( &mut client, @@ -6176,8 +6176,8 @@ mod tests { let header_hframe = HFrame::Headers { header_block: encoded_headers.to_vec(), }; - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); header_hframe.encode(&mut d); server_send_response_and_exchange_packet( &mut client, @@ -6267,8 +6267,8 @@ mod tests { let encoder_insts = server.conn.process(None, now()); // Send response headers. - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); server_send_response_and_exchange_packet( &mut client, @@ -6283,8 +6283,8 @@ mod tests { assert!(!client.events().any(header_ready_event)); // Now send data frame. This will trigger DataRead event. - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: 0 }; d_frame.encode(&mut d); @@ -6329,11 +6329,11 @@ mod tests { header_block: encoded_headers.to_vec(), }; - let out = server.conn.process(None, now()); + let output = server.conn.process(None, now()); // Send response - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: u64::try_from(data.len()).unwrap(), @@ -6342,7 +6342,7 @@ mod tests { d.encode(data); server_send_response_and_exchange_packet(client, server, request_stream_id, &d, true); - out.dgram() + output.dgram() } #[test] @@ -6466,8 +6466,8 @@ mod tests { ); // Send response - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: 0 }; d_frame.encode(&mut d); @@ -6531,8 +6531,8 @@ mod tests { let encoder_insts = server.conn.process(None, now()); // Send response headers. - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); server_send_response_and_exchange_packet( &mut client, @@ -6572,8 +6572,8 @@ mod tests { #[test] fn reserved_frames() { for f in H3_RESERVED_FRAME_TYPES { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_varint(*f); test_wrong_frame_on_control_stream(enc.as_ref()); test_wrong_frame_on_push_stream(enc.as_ref()); @@ -6592,8 +6592,8 @@ mod tests { .stream_send(control_stream, CONTROL_STREAM_TYPE) .unwrap(); // Create a settings frame of length 2. - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_varint(H3_FRAME_TYPE_SETTINGS); enc.encode_varint(2_u64); // The settings frame contains a reserved settings type and some value (0x1). @@ -6613,8 +6613,8 @@ mod tests { setup_server_side_encoder(&mut client, &mut server); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); let headers1xx: &[Header] = &[Header::new(":status", "103")]; server.encode_headers(request_stream_id, headers1xx, &mut d); @@ -6676,8 +6676,8 @@ mod tests { setup_server_side_encoder(&mut client, &mut server); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); let headers = vec![ Header::new("my-header", "my-header"), Header::new("content-length", "3"), @@ -6736,8 +6736,8 @@ mod tests { // Create a push stream let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap(); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); let headers1xx: &[Header] = &[Header::new(":status", "100")]; server.encode_headers(push_stream_id, headers1xx, &mut d); @@ -6805,8 +6805,8 @@ mod tests { // Create a push stream let push_stream_id = server.conn.stream_create(StreamType::UniDi).unwrap(); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); let headers = vec![ Header::new("my-header", "my-header"), Header::new("content-length", "3"), @@ -6885,8 +6885,8 @@ mod tests { setup_server_side_encoder(&mut client, &mut server); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); server.encode_headers(request_stream_id, headers, &mut d); // Send response @@ -6946,8 +6946,8 @@ mod tests { setup_server_side_encoder(&mut client, &mut server); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); server.encode_headers( request_stream_id, &[ @@ -7226,8 +7226,8 @@ mod tests { let encoder_inst_pkt = server.conn.process(None, now()); // Send response - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); let d_frame = HFrame::Data { len: 3 }; d_frame.encode(&mut d); @@ -7253,8 +7253,8 @@ mod tests { setup_server_side_encoder(&mut client, &mut server); - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); let headers1xx = &[Header::new(":status", "101")]; server.encode_headers(request_stream_id, headers1xx, &mut d); diff --git a/neqo-http3/src/control_stream_local.rs b/neqo-http3/src/control_stream_local.rs index 81e80617d1..3471cf28f8 100644 --- a/neqo-http3/src/control_stream_local.rs +++ b/neqo-http3/src/control_stream_local.rs @@ -37,8 +37,8 @@ impl ControlStreamLocal { /// Add a new frame that needs to be send. pub fn queue_frame(&mut self, f: &HFrame) { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); f.encode(&mut enc); self.stream.buffer(enc.as_ref()); } @@ -78,8 +78,8 @@ impl ControlStreamLocal { // in case multiple priority_updates were issued, ignore now irrelevant if let Some(hframe) = stream.priority_update_frame() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); hframe.encode(&mut enc); if self.stream.send_atomic(conn, enc.as_ref())? { stream.priority_update_sent(); diff --git a/neqo-http3/src/features/extended_connect/tests/webtransport/negotiation.rs b/neqo-http3/src/features/extended_connect/tests/webtransport/negotiation.rs index 2d8b7d7115..b97527f6d9 100644 --- a/neqo-http3/src/features/extended_connect/tests/webtransport/negotiation.rs +++ b/neqo-http3/src/features/extended_connect/tests/webtransport/negotiation.rs @@ -254,8 +254,8 @@ fn wrong_setting_value() { let control = server.stream_create(StreamType::UniDi).unwrap(); server.stream_send(control, CONTROL_STREAM_TYPE).unwrap(); // Encode a settings frame and send it. - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); let settings = HFrame::Settings { settings: HSettings::new(&[HSetting::new(HSettingType::EnableWebTransport, 2)]), }; diff --git a/neqo-http3/src/features/extended_connect/webtransport_session.rs b/neqo-http3/src/features/extended_connect/webtransport_session.rs index bb662fe503..9283abf986 100644 --- a/neqo-http3/src/features/extended_connect/webtransport_session.rs +++ b/neqo-http3/src/features/extended_connect/webtransport_session.rs @@ -384,8 +384,8 @@ impl WebTransportSession { error, message: message.to_string(), }; - let mut write_buffer = vec![]; - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut encoder = Encoder::new(&mut out); close_frame.encode(&mut encoder); self.control_stream_send .send_data_atomic(conn, encoder.as_ref())?; @@ -413,11 +413,11 @@ impl WebTransportSession { ) -> Res<()> { qtrace!([self], "send_datagram state={:?}", self.state); if self.state == SessionState::Active { - let mut write_buffer = vec![]; - let mut dgram_data = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut dgram_data = Encoder::new(&mut out); dgram_data.encode_varint(self.session_id.as_u64() / 4); dgram_data.encode(buf); - conn.send_datagram(write_buffer, id)?; + conn.send_datagram(out, id)?; } else { debug_assert!(false); return Err(Error::Unavailable); diff --git a/neqo-http3/src/features/extended_connect/webtransport_streams.rs b/neqo-http3/src/features/extended_connect/webtransport_streams.rs index f876160065..898608efc1 100644 --- a/neqo-http3/src/features/extended_connect/webtransport_streams.rs +++ b/neqo-http3/src/features/extended_connect/webtransport_streams.rs @@ -134,8 +134,8 @@ impl WebTransportSendStream { Self { stream_id, state: if local { - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); if stream_id.is_uni() { d.encode_varint(WEBTRANSPORT_UNI_STREAM); } else { @@ -143,7 +143,7 @@ impl WebTransportSendStream { } d.encode_varint(session_id.as_u64()); WebTransportSenderStreamState::SendingInit { - buf: write_buffer, + buf: out, fin: false, } } else { diff --git a/neqo-http3/src/frames/hframe.rs b/neqo-http3/src/frames/hframe.rs index 5df4f0cc87..05448fc0fb 100644 --- a/neqo-http3/src/frames/hframe.rs +++ b/neqo-http3/src/frames/hframe.rs @@ -142,9 +142,9 @@ impl HFrame { element_id, priority, } => { - let mut write_buffer = vec![]; + let mut out = vec![]; // TODO: separate encoder needed? - let mut update_frame = Encoder::new(&mut write_buffer); + let mut update_frame = Encoder::new(&mut out); update_frame.encode_varint(*element_id); let mut priority_enc: Vec = Vec::new(); diff --git a/neqo-http3/src/frames/tests/hframe.rs b/neqo-http3/src/frames/tests/hframe.rs index bfb0f4039c..2b407d5d99 100644 --- a/neqo-http3/src/frames/tests/hframe.rs +++ b/neqo-http3/src/frames/tests/hframe.rs @@ -63,8 +63,8 @@ fn goaway_frame4() { #[test] fn grease() { fn make_grease() -> u64 { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); HFrame::Grease.encode(&mut enc); let mut dec = Decoder::from(&enc); let ft = dec.decode_varint().unwrap(); diff --git a/neqo-http3/src/frames/tests/mod.rs b/neqo-http3/src/frames/tests/mod.rs index 17519bdceb..ec9817fb38 100644 --- a/neqo-http3/src/frames/tests/mod.rs +++ b/neqo-http3/src/frames/tests/mod.rs @@ -17,8 +17,8 @@ use crate::frames::{ pub fn enc_dec>(d: &Encoder, st: &str, remaining: usize) -> T { // For data, headers and push_promise we do not read all bytes from the buffer - let mut write_buffer = vec![]; - let d2 = Encoder::new(&mut write_buffer).from_hex(st); + let mut out = vec![]; + let d2 = Encoder::new(&mut out).from_hex(st); assert_eq!(d.as_ref(), &d2.as_ref()[..d.as_ref().len()]); let mut conn_c = default_client(); @@ -37,8 +37,8 @@ pub fn enc_dec>(d: &Encoder, st: &str, remaining: usize) -> T let mut fr: FrameReader = FrameReader::new(); // conver string into u8 vector - let mut write_buffer = vec![]; - let buf = Encoder::new(&mut write_buffer).from_hex(st); + let mut out = vec![]; + let buf = Encoder::new(&mut out).from_hex(st); conn_s.stream_send(stream_id, buf.as_ref()).unwrap(); let out = conn_s.process(None, now()); mem::drop(conn_c.process(out.as_dgram_ref(), now())); @@ -61,8 +61,8 @@ pub fn enc_dec>(d: &Encoder, st: &str, remaining: usize) -> T } pub fn enc_dec_hframe(f: &HFrame, st: &str, remaining: usize) { - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); f.encode(&mut d); @@ -72,8 +72,8 @@ pub fn enc_dec_hframe(f: &HFrame, st: &str, remaining: usize) { } pub fn enc_dec_wtframe(f: &WebTransportFrame, st: &str, remaining: usize) { - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); f.encode(&mut d); diff --git a/neqo-http3/src/lib.rs b/neqo-http3/src/lib.rs index 625afbfcde..dece43c050 100644 --- a/neqo-http3/src/lib.rs +++ b/neqo-http3/src/lib.rs @@ -68,7 +68,7 @@ let mut client = Http3Client::new(...); // process can return 3 values, data to be sent, time duration when process should // be called, and None when Http3Client is done. -match client.process(None, Instant::now(), &mut write_buffer) { +match client.process(None, Instant::now(), &mut out) { Output::Datagram(dgram) => { // Send dgram on a socket. socket.send_to(&dgram[..], dgram.destination()) diff --git a/neqo-http3/src/send_message.rs b/neqo-http3/src/send_message.rs index c69a57fa6f..90560ec983 100644 --- a/neqo-http3/src/send_message.rs +++ b/neqo-http3/src/send_message.rs @@ -145,10 +145,10 @@ impl SendMessage { let hframe = HFrame::Headers { header_block: header_block.to_vec(), }; - let mut write_buffer = vec![]; - let mut d = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut d = Encoder::new(&mut out); hframe.encode(&mut d); - write_buffer + out } fn stream_id(&self) -> StreamId { @@ -211,8 +211,8 @@ impl SendStream for SendMessage { let data_frame = HFrame::Data { len: to_send as u64, }; - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); data_frame.encode(&mut enc); let sent_fh = self .stream @@ -303,8 +303,8 @@ impl SendStream for SendMessage { let data_frame = HFrame::Data { len: buf.len() as u64, }; - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); data_frame.encode(&mut enc); self.stream.buffer(enc.as_ref()); self.stream.buffer(buf); diff --git a/neqo-http3/src/server.rs b/neqo-http3/src/server.rs index 78735494fd..f6af360ca1 100644 --- a/neqo-http3/src/server.rs +++ b/neqo-http3/src/server.rs @@ -117,37 +117,35 @@ impl Http3Server { &mut self, dgram: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { qtrace!([self], "Process."); - let mut out = self + let mut output = self .server // TODO: NLL borrow issue. See https://github.com/rust-lang/rust/issues/54663 // // Find alternative. - .process_into_buffer(dgram, now, unsafe { - &mut *std::ptr::from_mut(write_buffer) - }); + .process_into_buffer(dgram, now, unsafe { &mut *std::ptr::from_mut(out) }); self.process_http3(now); // If we do not have a dgram already try again after process_http3. - if !matches!(out, Output::Datagram(_)) { - out = self.server.process_into_buffer(None, now, write_buffer); + if !matches!(output, Output::Datagram(_)) { + output = self.server.process_into_buffer(None, now, out); } - if let Output::Datagram(d) = out { + if let Output::Datagram(d) = output { qtrace!([self], "Send packet: {:?}", d); } - out + output } /// Same as [`Http3Server::process_into_buffer`] but allocating output into /// new [`Vec`]. pub fn process(&mut self, dgram: Option<&Datagram>, now: Instant) -> Output { - let mut write_buffer = vec![]; - self.process_into_buffer(dgram.map(Into::into), now, &mut write_buffer) + let mut out = vec![]; + self.process_into_buffer(dgram.map(Into::into), now, &mut out) .map_datagram(Into::into) } @@ -647,8 +645,8 @@ mod tests { element_id: stream_id.as_u64(), priority: Priority::default(), }; - let mut write_buffer = vec![]; - let mut e = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut e = Encoder::new(&mut out); frame.encode(&mut e); peer_conn.control_send(e.as_ref()); let out = peer_conn.process(None, now()); diff --git a/neqo-http3/src/settings.rs b/neqo-http3/src/settings.rs index a4bd5439ca..340388ed6e 100644 --- a/neqo-http3/src/settings.rs +++ b/neqo-http3/src/settings.rs @@ -233,8 +233,8 @@ impl HttpZeroRttChecker { /// Save the settings that matter for 0-RTT. #[must_use] pub fn save(settings: &Http3Parameters) -> Vec { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_varint(SETTINGS_ZERO_RTT_VERSION) .encode_varint(SETTINGS_QPACK_MAX_TABLE_CAPACITY) .encode_varint(settings.get_max_table_size_decoder()) @@ -247,7 +247,7 @@ impl HttpZeroRttChecker { if settings.get_http3_datagram() { enc.encode_varint(SETTINGS_H3_DATAGRAM).encode_varint(true); } - write_buffer + out } } diff --git a/neqo-http3/src/stream_type_reader.rs b/neqo-http3/src/stream_type_reader.rs index a1c2d6020a..d79aeba8a2 100644 --- a/neqo-http3/src/stream_type_reader.rs +++ b/neqo-http3/src/stream_type_reader.rs @@ -318,8 +318,8 @@ mod tests { outcome: &Res<(ReceiveOutput, bool)>, done: bool, ) { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); for i in to_encode { enc.encode_varint(*i); } diff --git a/neqo-transport/src/addr_valid.rs b/neqo-transport/src/addr_valid.rs index 54df7f7ca5..01156ba048 100644 --- a/neqo-transport/src/addr_valid.rs +++ b/neqo-transport/src/addr_valid.rs @@ -110,8 +110,8 @@ impl AddressValidation { // TODO(mt) rotate keys on a fixed schedule. let retry = dcid.is_some(); - let mut write_buffer = vec![]; - let mut data = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut data = Encoder::new(&mut out); let end = now + if retry { EXPIRATION_RETRY @@ -125,13 +125,13 @@ impl AddressValidation { } // Include the token identifier ("Retry"/~) in the AAD, then keep it for plaintext. - let mut write_buffer = vec![]; - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut encoder = Encoder::new(&mut out); Self::encode_aad(peer_address, retry, &mut encoder); let encrypted = self.self_encrypt.seal(encoder.as_ref(), data.as_ref())?; encoder.truncate(TOKEN_IDENTIFIER_RETRY.len()); encoder.encode(&encrypted); - Ok(write_buffer) + Ok(out) } /// This generates a token for use with Retry. @@ -165,8 +165,8 @@ impl AddressValidation { retry: bool, now: Instant, ) -> Option { - let mut write_buffer = vec![]; - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut encoder = Encoder::new(&mut out); Self::encode_aad(peer_address, retry, &mut encoder); let data = self.self_encrypt.open(encoder.as_ref(), token).ok()?; let mut dec = Decoder::new(&data); diff --git a/neqo-transport/src/connection/mod.rs b/neqo-transport/src/connection/mod.rs index 9daf0baf08..ab1f8533a2 100644 --- a/neqo-transport/src/connection/mod.rs +++ b/neqo-transport/src/connection/mod.rs @@ -818,8 +818,8 @@ impl Connection { let tps = &self.tps; if let Agent::Server(ref mut s) = self.crypto.tls { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_vvec_with(|enc_inner| { tps.borrow().local.encode(enc_inner); }); @@ -1113,11 +1113,7 @@ impl Connection { /// Returns datagrams to send, and how long to wait before calling again /// even if no incoming packets. #[must_use = "Output of the process_output function must be handled"] - fn process_output<'a>( - &mut self, - now: Instant, - write_buffer: &'a mut Vec, - ) -> Output<&'a [u8]> { + fn process_output<'a>(&mut self, now: Instant, out: &'a mut Vec) -> Output<&'a [u8]> { qtrace!([self], "process_output {:?} {:?}", self.state, now); match (&self.state, self.role) { @@ -1133,7 +1129,7 @@ impl Connection { } } - match self.output(now, write_buffer) { + match self.output(now, out) { SendOption::Yes(dgram) => Output::Datagram(dgram), SendOption::No(paced) => match self.state { State::Init | State::Closed(_) => Output::None, @@ -1149,8 +1145,8 @@ impl Connection { /// new [`Vec`]. #[must_use = "Output of the process function must be handled"] pub fn process(&mut self, dgram: Option<&Datagram>, now: Instant) -> Output { - let mut write_buffer = vec![]; - self.process_into_buffer(dgram.map(Into::into), now, &mut write_buffer) + let mut out = vec![]; + self.process_into_buffer(dgram.map(Into::into), now, &mut out) .map_datagram(Into::into) } @@ -1164,15 +1160,15 @@ impl Connection { &mut self, input: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - assert!(write_buffer.is_empty()); + assert!(out.is_empty()); if let Some(d) = input { self.input(d, now, now); self.process_saved(now); } #[allow(clippy::let_and_return)] - let output = self.process_output(now, write_buffer); + let output = self.process_output(now, out); #[cfg(all(feature = "build-fuzzing-corpus", test))] if self.test_frame_writer.is_none() { if let Some(d) = output.clone().map_datagram(Into::into).dgram() { @@ -1978,7 +1974,7 @@ impl Connection { } } - fn output<'a>(&mut self, now: Instant, write_buffer: &'a mut Vec) -> SendOption<'a> { + fn output<'a>(&mut self, now: Instant, out: &'a mut Vec) -> SendOption<'a> { qtrace!([self], "output {:?}", now); let res = match &self.state { State::Init @@ -1989,7 +1985,7 @@ impl Connection { | State::Confirmed => self.paths.select_path().map_or_else( || Ok(SendOption::default()), |path| { - let res = self.output_path(&path, now, &None, write_buffer); + let res = self.output_path(&path, now, &None, out); self.capture_error(Some(path), now, 0, res) }, ), @@ -2006,7 +2002,7 @@ impl Connection { qerror!([self], "Attempting to close with a temporary path"); Err(Error::InternalError) } else { - self.output_path(&path, now, &Some(details), write_buffer) + self.output_path(&path, now, &Some(details), out) }; self.capture_error(Some(path), now, 0, res) }, @@ -2345,7 +2341,7 @@ impl Connection { path: &PathRef, now: Instant, closing_frame: &Option, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Res> { let mut initial_sent = None; let mut needs_padding = false; @@ -2359,8 +2355,8 @@ impl Connection { // TODO: epochs or packetnumberspaces below? // Frames for different epochs must go in different packets, but then these // packets can go in a single datagram - assert_eq!(write_buffer.len(), 0); - let mut encoder = Encoder::new(write_buffer); + assert_eq!(out.len(), 0); + let mut encoder = Encoder::new(out); for space in PacketNumberSpace::iter() { // Ensure we have tx crypto state for this epoch, or skip it. let Some((cspace, tx)) = self.crypto.states.select_tx_mut(self.version, *space) else { @@ -3483,10 +3479,10 @@ impl Connection { let mtu = path.borrow().plpmtu(); // TODO: Is this the cleanest way? - let mut tmp_write_buffer = vec![]; + let mut tmp_out = vec![]; // TODO: This was previously initialized with the mtu. Relevant? - let encoder = Encoder::new(&mut tmp_write_buffer); + let encoder = Encoder::new(&mut tmp_out); let (_, mut builder) = Self::build_packet_header( &path.borrow(), diff --git a/neqo-transport/src/connection/tests/vn.rs b/neqo-transport/src/connection/tests/vn.rs index 8f013db2d9..b56513da28 100644 --- a/neqo-transport/src/connection/tests/vn.rs +++ b/neqo-transport/src/connection/tests/vn.rs @@ -55,8 +55,8 @@ fn create_vn(initial_pkt: &[u8], versions: &[u32]) -> Vec { let dst_cid = dec.decode_vec(1).expect("client DCID"); let src_cid = dec.decode_vec(1).expect("client SCID"); - let mut write_buffer = vec![]; - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut encoder = Encoder::new(&mut out); encoder.encode_byte(PACKET_BIT_LONG); encoder.encode(&[0; 4]); // Zero version == VN. encoder.encode_vec(1, src_cid); @@ -65,7 +65,7 @@ fn create_vn(initial_pkt: &[u8], versions: &[u32]) -> Vec { for v in versions { encoder.encode_uint(4, *v); } - write_buffer + out } #[test] diff --git a/neqo-transport/src/crypto.rs b/neqo-transport/src/crypto.rs index 71aeb9c2c8..57a5650680 100644 --- a/neqo-transport/src/crypto.rs +++ b/neqo-transport/src/crypto.rs @@ -373,8 +373,8 @@ impl Crypto { if let Agent::Client(ref mut c) = self.tls { c.resumption_token().as_ref().map(|t| { qtrace!("TLS token {}", hex(t.as_ref())); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_uint(4, version.wire_version()); enc.encode_varint(rtt); enc.encode_vvec_with(|enc_inner| { @@ -383,7 +383,7 @@ impl Crypto { enc.encode_vvec(new_token.unwrap_or(&[])); enc.encode(t.as_ref()); qdebug!("resumption token {}", hex_snip_middle(enc.as_ref())); - ResumptionToken::new(write_buffer, t.expiration_time()) + ResumptionToken::new(out, t.expiration_time()) }) } else { unreachable!("It is a server."); diff --git a/neqo-transport/src/frame.rs b/neqo-transport/src/frame.rs index 039a723e00..d422a695d3 100644 --- a/neqo-transport/src/frame.rs +++ b/neqo-transport/src/frame.rs @@ -669,8 +669,8 @@ mod tests { }; fn just_dec(f: &Frame, s: &str) { - let mut write_buffer = vec![]; - let encoded = Encoder::new(&mut write_buffer).from_hex(s); + let mut out = vec![]; + let encoded = Encoder::new(&mut out).from_hex(s); let decoded = Frame::decode(&mut encoded.as_decoder()).expect("Failed to decode frame"); assert_eq!(*f, decoded); } @@ -703,9 +703,9 @@ mod tests { just_dec(&f, "025234523502523601020304"); - let mut write_buffer = vec![]; + let mut out = vec![]; // Try to parse ACK_ECN without ECN values - let enc = Encoder::new(&mut write_buffer).from_hex("035234523502523601020304"); + let enc = Encoder::new(&mut out).from_hex("035234523502523601020304"); let mut dec = enc.as_decoder(); assert_eq!(Frame::decode(&mut dec).unwrap_err(), Error::NoMoreData); @@ -718,8 +718,8 @@ mod tests { ack_ranges: ar, ecn_count, }; - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("035234523502523601020304010203"); + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("035234523502523601020304010203"); let mut dec = enc.as_decoder(); assert_eq!(Frame::decode(&mut dec).unwrap(), fe); } @@ -891,8 +891,8 @@ mod tests { #[test] fn too_large_new_connection_id() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer).from_hex("18523400"); // up to the CID + let mut out = vec![]; + let mut enc = Encoder::new(&mut out).from_hex("18523400"); // up to the CID enc.encode_vvec(&[0x0c; MAX_CONNECTION_ID_LEN + 10]); enc.encode(&[0x11; 16][..]); assert_eq!( @@ -994,8 +994,8 @@ mod tests { #[test] fn ack_frequency_ignore_error_error() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("40af0a0547d003"); // ignore_order of 3 + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("40af0a0547d003"); // ignore_order of 3 assert_eq!( Frame::decode(&mut enc.as_decoder()).unwrap_err(), Error::FrameEncodingError @@ -1005,8 +1005,8 @@ mod tests { /// Hopefully this test is eventually redundant. #[test] fn ack_frequency_zero_packets() { - let mut write_buffer = vec![]; - let enc = Encoder::new(&mut write_buffer).from_hex("40af0a000101"); // packets of 0 + let mut out = vec![]; + let enc = Encoder::new(&mut out).from_hex("40af0a000101"); // packets of 0 assert_eq!( Frame::decode(&mut enc.as_decoder()).unwrap_err(), Error::FrameEncodingError @@ -1033,8 +1033,8 @@ mod tests { #[test] fn frame_decode_enforces_bound_on_ack_range() { - let mut write_buffer = vec![]; - let mut e = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut e = Encoder::new(&mut out); e.encode_varint(FRAME_TYPE_ACK); e.encode_varint(0u64); // largest acknowledged diff --git a/neqo-transport/src/packet/mod.rs b/neqo-transport/src/packet/mod.rs index 93535ea492..e424545829 100644 --- a/neqo-transport/src/packet/mod.rs +++ b/neqo-transport/src/packet/mod.rs @@ -474,9 +474,9 @@ impl<'a> PacketBuilder<'a> { scid: &[u8], token: &[u8], odcid: &[u8], - write_buffer: &'b mut Vec, + out: &'b mut Vec, ) -> Res<&'b [u8]> { - let mut encoder = Encoder::new(write_buffer); + let mut encoder = Encoder::new(out); encoder.encode_vec(1, odcid); let start = encoder.len(); encoder.encode_byte( @@ -508,9 +508,9 @@ impl<'a> PacketBuilder<'a> { scid: &[u8], client_version: u32, versions: &[Version], - write_buffer: &'b mut Vec, + out: &'b mut Vec, ) -> &'b [u8] { - let mut encoder = Encoder::new(write_buffer); + let mut encoder = Encoder::new(out); let mut grease = random::<4>(); // This will not include the "QUIC bit" sometimes. Intentionally. encoder.encode_byte(PACKET_BIT_LONG | (grease[3] & 0x7f)); @@ -722,8 +722,8 @@ impl<'a> PublicPacket<'a> { return false; } let (header, tag) = self.data.split_at(self.data.len() - expansion); - let mut write_buffer = Vec::with_capacity(self.data.len()); - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(self.data.len()); + let mut encoder = Encoder::new(&mut out); encoder.encode_vec(1, odcid); encoder.encode(header); retry::use_aead(version, |aead| { @@ -1048,8 +1048,8 @@ mod tests { #[test] fn disallow_long_dcid() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_byte(PACKET_BIT_LONG | PACKET_BIT_FIXED_QUIC); enc.encode_uint(4, Version::default().wire_version()); enc.encode_vec(1, &[0x00; MAX_CONNECTION_ID_LEN + 1]); @@ -1061,8 +1061,8 @@ mod tests { #[test] fn disallow_long_scid() { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); enc.encode_byte(PACKET_BIT_LONG | PACKET_BIT_FIXED_QUIC); enc.encode_uint(4, Version::default().wire_version()); enc.encode_vec(1, &[]); @@ -1545,8 +1545,8 @@ mod tests { const BIG_DCID: &[u8] = &[0x44; MAX_CONNECTION_ID_LEN + 1]; const BIG_SCID: &[u8] = &[0xee; 255]; - let mut write_buffer = vec![0xff, 0x00, 0x00, 0x00, 0x00]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![0xff, 0x00, 0x00, 0x00, 0x00]; + let mut enc = Encoder::new(&mut out); enc.encode_vec(1, BIG_DCID); enc.encode_vec(1, BIG_SCID); enc.encode_uint(4, 0x1a2a_3a4a_u64); diff --git a/neqo-transport/src/recv_stream.rs b/neqo-transport/src/recv_stream.rs index 98a755c411..cde7381977 100644 --- a/neqo-transport/src/recv_stream.rs +++ b/neqo-transport/src/recv_stream.rs @@ -1482,11 +1482,10 @@ mod tests { // flow msg generated! assert!(s.has_frames_to_write()); - let mut write_buffer = vec![]; + let mut out = vec![]; // consume it // TODO: 0 ideal here? - let mut builder = - PacketBuilder::short(Encoder::new(&mut write_buffer), false, None::<&[u8]>, 0); + let mut builder = PacketBuilder::short(Encoder::new(&mut out), false, None::<&[u8]>, 0); let mut token = Vec::new(); s.write_frame(&mut builder, &mut token, &mut FrameStats::default()); @@ -1600,10 +1599,9 @@ mod tests { s.read(&mut buf).unwrap(); assert!(session_fc.borrow().frame_needed()); // consume it - let mut write_buffer = vec![]; + let mut out = vec![]; // TODO: 0 ideal here? - let mut builder = - PacketBuilder::short(Encoder::new(&mut write_buffer), false, None::<&[u8]>, 0); + let mut builder = PacketBuilder::short(Encoder::new(&mut out), false, None::<&[u8]>, 0); let mut token = Vec::new(); session_fc .borrow_mut() @@ -1623,11 +1621,10 @@ mod tests { assert!(!session_fc.borrow().frame_needed()); s.read(&mut buf).unwrap(); assert!(session_fc.borrow().frame_needed()); - let mut write_buffer = vec![]; + let mut out = vec![]; // consume it // TODO: 0 ideal here? - let mut builder = - PacketBuilder::short(Encoder::new(&mut write_buffer), false, None::<&[u8]>, 0); + let mut builder = PacketBuilder::short(Encoder::new(&mut out), false, None::<&[u8]>, 0); let mut token = Vec::new(); session_fc .borrow_mut() @@ -1874,11 +1871,10 @@ mod tests { assert!(!fc.borrow().frame_needed()); assert!(s.fc().unwrap().frame_needed()); - let mut write_buffer = vec![]; + let mut out = vec![]; // Write the fc update frame // TODO: 0 ideal here? - let mut builder = - PacketBuilder::short(Encoder::new(&mut write_buffer), false, None::<&[u8]>, 0); + let mut builder = PacketBuilder::short(Encoder::new(&mut out), false, None::<&[u8]>, 0); let mut token = Vec::new(); let mut stats = FrameStats::default(); fc.borrow_mut() diff --git a/neqo-transport/src/server.rs b/neqo-transport/src/server.rs index 605c2c7bc6..708f36b593 100644 --- a/neqo-transport/src/server.rs +++ b/neqo-transport/src/server.rs @@ -197,9 +197,9 @@ impl Server { initial: InitialDetails, dgram: Datagram<&[u8]>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - assert!(write_buffer.is_empty()); + assert!(out.is_empty()); qdebug!([self], "Handle initial"); let res = self @@ -208,11 +208,9 @@ impl Server { .validate(&initial.token, dgram.source(), now); match res { AddressValidationResult::Invalid => Output::None, - AddressValidationResult::Pass => { - self.accept_connection(initial, dgram, None, now, write_buffer) - } + AddressValidationResult::Pass => self.accept_connection(initial, dgram, None, now, out), AddressValidationResult::ValidRetry(orig_dcid) => { - self.accept_connection(initial, dgram, Some(orig_dcid), now, write_buffer) + self.accept_connection(initial, dgram, Some(orig_dcid), now, out) } AddressValidationResult::Validate => { qinfo!([self], "Send retry for {:?}", initial.dst_cid); @@ -233,7 +231,7 @@ impl Server { &new_dcid, &token, &initial.dst_cid, - write_buffer, + out, ); packet.map_or_else( |_| { @@ -307,7 +305,7 @@ impl Server { dgram: Datagram<&[u8]>, orig_dcid: Option, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { qinfo!( [self], @@ -329,7 +327,7 @@ impl Server { match sconn { Ok(mut c) => { self.setup_connection(&mut c, initial, orig_dcid); - let out = c.process_into_buffer(Some(dgram), now, write_buffer); + let out = c.process_into_buffer(Some(dgram), now, out); self.connections.push(Rc::new(RefCell::new(c))); out } @@ -351,9 +349,9 @@ impl Server { &mut self, dgram: Datagram<&[u8]>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { - assert!(write_buffer.is_empty()); + assert!(out.is_empty()); qtrace!("Process datagram: {}", hex(&dgram[..])); // This is only looking at the first packet header in the datagram. @@ -370,9 +368,7 @@ impl Server { .iter_mut() .find(|c| c.borrow().is_valid_local_cid(packet.dcid())) { - return c - .borrow_mut() - .process_into_buffer(Some(dgram), now, write_buffer); + return c.borrow_mut().process_into_buffer(Some(dgram), now, out); } if packet.packet_type() == PacketType::Short { @@ -400,7 +396,7 @@ impl Server { &packet.dcid()[..], packet.wire_version(), self.conn_params.get_versions().all(), - write_buffer, + out, ); crate::qlog::server_version_information_failed( @@ -427,7 +423,7 @@ impl Server { // Copy values from `packet` because they are currently still borrowing from // `dgram`. let initial = InitialDetails::new(&packet); - self.handle_initial(initial, dgram, now, write_buffer) + self.handle_initial(initial, dgram, now, out) } PacketType::ZeroRtt => { let dcid = ConnectionId::from(packet.dcid()); @@ -444,12 +440,8 @@ impl Server { /// Iterate through the pending connections looking for any that might want /// to send a datagram. Stop at the first one that does. - fn process_next_output<'a>( - &mut self, - now: Instant, - write_buffer: &'a mut Vec, - ) -> Output<&'a [u8]> { - assert!(write_buffer.is_empty()); + fn process_next_output<'a>(&mut self, now: Instant, out: &'a mut Vec) -> Output<&'a [u8]> { + assert!(out.is_empty()); let mut callback = None; for connection in &mut self.connections { @@ -458,7 +450,7 @@ impl Server { // TODO: NLL borrow issue. See https://github.com/rust-lang/rust/issues/54663 // // Find alternative. - .process_into_buffer(None, now, unsafe { &mut *std::ptr::from_mut(write_buffer) }) + .process_into_buffer(None, now, unsafe { &mut *std::ptr::from_mut(out) }) { Output::None => {} d @ Output::Datagram(_) => return d, @@ -476,8 +468,8 @@ impl Server { /// [`Vec`]. #[must_use] pub fn process(&mut self, dgram: Option<&Datagram>, now: Instant) -> Output { - let mut write_buffer = vec![]; - self.process_into_buffer(dgram.map(Into::into), now, &mut write_buffer) + let mut out = vec![]; + self.process_into_buffer(dgram.map(Into::into), now, &mut out) .map_datagram(Into::into) } @@ -489,18 +481,18 @@ impl Server { &mut self, dgram: Option>, now: Instant, - write_buffer: &'a mut Vec, + out: &'a mut Vec, ) -> Output<&'a [u8]> { // TODO: This the right place? - assert!(write_buffer.is_empty()); + assert!(out.is_empty()); let out = dgram .map_or(Output::None, |d| { // TODO: NLL borrow issue. See https://github.com/rust-lang/rust/issues/54663 // // Find alternative. - self.process_input(d, now, unsafe { &mut *std::ptr::from_mut(write_buffer) }) + self.process_input(d, now, unsafe { &mut *std::ptr::from_mut(out) }) }) - .or_else(|| self.process_next_output(now, write_buffer)); + .or_else(|| self.process_next_output(now, out)); // Clean-up closed connections. self.connections diff --git a/neqo-transport/src/tparams.rs b/neqo-transport/src/tparams.rs index c696477873..dba4b6c8aa 100644 --- a/neqo-transport/src/tparams.rs +++ b/neqo-transport/src/tparams.rs @@ -688,8 +688,8 @@ impl ExtensionHandler for TransportParametersHandler { qdebug!("Writing transport parameters, msg={:?}", msg); // TODO(ekr@rtfm.com): Modify to avoid a copy. - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); self.local.encode(&mut enc); assert!(enc.len() <= d.len()); d[..enc.len()].copy_from_slice(enc.as_ref()); @@ -806,8 +806,8 @@ mod tests { tps.params .insert(INITIAL_MAX_STREAMS_BIDI, TransportParameter::Integer(10)); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); tps.encode(&mut enc); let tps2 = TransportParameters::decode(&mut enc.as_decoder()).expect("Couldn't decode"); @@ -827,8 +827,8 @@ mod tests { assert!(!tps2.has_value(RETRY_SOURCE_CONNECTION_ID)); assert!(tps2.has_value(STATELESS_RESET_TOKEN)); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); tps.encode(&mut enc); let tps2 = TransportParameters::decode(&mut enc.as_decoder()).expect("Couldn't decode"); @@ -857,8 +857,8 @@ mod tests { 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, ]; let spa = make_spa(); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); spa.encode(&mut enc, PREFERRED_ADDRESS); assert_eq!(enc.as_ref(), ENCODED); @@ -891,8 +891,8 @@ mod tests { /// It then encodes it, working from the knowledge that the `encode` function /// doesn't care about validity, and decodes it. The result should be failure. fn assert_invalid_spa(spa: &TransportParameter) { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); spa.encode(&mut enc, PREFERRED_ADDRESS); assert_eq!( TransportParameter::decode(&mut enc.as_decoder()).unwrap_err(), @@ -902,8 +902,8 @@ mod tests { /// This is for those rare mutations that are acceptable. fn assert_valid_spa(spa: &TransportParameter) { - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); spa.encode(&mut enc, PREFERRED_ADDRESS); let mut dec = enc.as_decoder(); let (id, decoded) = TransportParameter::decode(&mut dec).unwrap().unwrap(); @@ -954,8 +954,8 @@ mod tests { #[test] fn preferred_address_truncated() { let spa = make_spa(); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); spa.encode(&mut enc, PREFERRED_ADDRESS); let mut dec = Decoder::from(&enc.as_ref()[..enc.len() - 1]); assert_eq!( @@ -1080,8 +1080,8 @@ mod tests { tps.params .insert(ACTIVE_CONNECTION_ID_LIMIT, TransportParameter::Integer(1)); - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); tps.encode(&mut enc); // When decoding a set of transport parameters with an invalid ACTIVE_CONNECTION_ID_LIMIT @@ -1100,8 +1100,8 @@ mod tests { other: vec![0x1a2a_3a4a, 0x5a6a_7a8a], }; - let mut write_buffer = vec![]; - let mut enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut enc = Encoder::new(&mut out); vn.encode(&mut enc, VERSION_INFORMATION); assert_eq!(enc.as_ref(), ENCODED); diff --git a/neqo-transport/tests/connection.rs b/neqo-transport/tests/connection.rs index 7a8807628c..5be77ec55b 100644 --- a/neqo-transport/tests/connection.rs +++ b/neqo-transport/tests/connection.rs @@ -229,8 +229,8 @@ fn overflow_crypto() { // Send in 100 packets, each with 1000 bytes of crypto frame data each, // eventually this will overrun the buffer we keep for crypto data. - let mut write_buffer = Vec::with_capacity(1024); - let mut payload = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(1024); + let mut payload = Encoder::new(&mut out); for pn in 0..100_u64 { payload.truncate(0); payload @@ -240,8 +240,8 @@ fn overflow_crypto() { let plen = payload.len(); payload.pad_to(plen + 1000, 44); - let mut write_buffer = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); - let mut packet = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); + let mut packet = Encoder::new(&mut out); packet .encode_byte(0xc1) // Initial with packet number length of 2. .encode_uint(4, Version::Version1.wire_version()) @@ -252,7 +252,7 @@ fn overflow_crypto() { let pn_offset = packet.len(); packet.encode_uint(2, pn); - let mut packet = write_buffer; + let mut packet = out; let header = packet.clone(); packet.resize(header.len() + payload.len() + aead.expansion(), 0); aead.encrypt(pn, &header, payload.as_ref(), &mut packet[header.len()..]) diff --git a/neqo-transport/tests/retry.rs b/neqo-transport/tests/retry.rs index ff03d55a1c..c8120cf1b8 100644 --- a/neqo-transport/tests/retry.rs +++ b/neqo-transport/tests/retry.rs @@ -360,14 +360,14 @@ fn vn_after_retry() { let dgram = client.process(dgram.as_ref(), now()).dgram(); // Initial w/token assert!(dgram.is_some()); - let mut write_buffer = vec![]; - let mut encoder = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut encoder = Encoder::new(&mut out); encoder.encode_byte(0x80); encoder.encode(&[0; 4]); // Zero version == VN. encoder.encode_vec(1, &client.odcid().unwrap()[..]); encoder.encode_vec(1, &[]); encoder.encode_uint(4, 0x5a5a_6a6a_u64); - let vn = datagram(write_buffer); + let vn = datagram(out); assert_ne!( client.process(Some(&vn), now()).callback(), @@ -420,9 +420,9 @@ fn mitm_retry() { .decrypt(pn, &header, &payload[pn_len..], &mut plaintext_buf) .unwrap(); - let mut write_buffer = Vec::with_capacity(header.len()); + let mut out = Vec::with_capacity(header.len()); // Now re-encode without the token. - let mut enc = Encoder::new(&mut write_buffer); + let mut enc = Encoder::new(&mut out); enc.encode(&header[..5]) .encode_vec(1, d_cid) .encode_vec(1, s_cid) @@ -432,9 +432,9 @@ fn mitm_retry() { let notoken_header = enc.encode_uint(pn_len, pn).as_ref().to_vec(); qtrace!("notoken_header={}", hex_with_len(¬oken_header)); - let mut write_buffer = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); + let mut out = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); // Encrypt. - let mut notoken_packet = Encoder::new(&mut write_buffer) + let mut notoken_packet = Encoder::new(&mut out) .encode(¬oken_header) .as_ref() .to_vec(); diff --git a/neqo-transport/tests/server.rs b/neqo-transport/tests/server.rs index 1478601bf8..743ecff31c 100644 --- a/neqo-transport/tests/server.rs +++ b/neqo-transport/tests/server.rs @@ -440,8 +440,8 @@ fn bad_client_initial() { payload_enc.encode(&[0x08, 0x02, 0x00, 0x00]); // Add a stream frame. // Make a new header with a 1 byte packet number length. - let mut write_buffer = vec![]; - let mut header_enc = Encoder::new(&mut write_buffer); + let mut out = vec![]; + let mut header_enc = Encoder::new(&mut out); header_enc .encode_byte(0xc0) // Initial with 1 byte packet number. .encode_uint(4, Version::default().wire_version()) @@ -525,13 +525,13 @@ fn bad_client_initial_connection_close() { let (aead, hp) = initial_aead_and_hp(d_cid, Role::Client); let (_, pn) = remove_header_protection(&hp, header, payload); - let mut write_buffer = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); - let mut payload_enc = Encoder::new(&mut write_buffer); + let mut out = Vec::with_capacity(MIN_INITIAL_PACKET_SIZE); + let mut payload_enc = Encoder::new(&mut out); payload_enc.encode(&[0x1c, 0x01, 0x00, 0x00]); // Add a CONNECTION_CLOSE frame. - let mut write_buffer = vec![]; + let mut out = vec![]; // Make a new header with a 1 byte packet number length. - let mut header_enc = Encoder::new(&mut write_buffer); + let mut header_enc = Encoder::new(&mut out); header_enc .encode_byte(0xc0) // Initial with 1 byte packet number. .encode_uint(4, Version::default().wire_version()) diff --git a/test-fixture/src/sim/mod.rs b/test-fixture/src/sim/mod.rs index 9600340913..5dfb112eec 100644 --- a/test-fixture/src/sim/mod.rs +++ b/test-fixture/src/sim/mod.rs @@ -166,8 +166,8 @@ impl Simulator { /// # Panics /// When the provided string is not 32 bytes of hex (64 characters). pub fn seed_str(&mut self, seed: impl AsRef) { - let mut write_buffer = vec![]; - let seed = Encoder::new(&mut write_buffer).from_hex(seed); + let mut out = vec![]; + let seed = Encoder::new(&mut out).from_hex(seed); self.seed(<[u8; 32]>::try_from(seed.as_ref()).unwrap()); }