| 1 |
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| 2 |
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| 3 |
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| 4 |
// option. This file may not be copied, modified, or distributed |
| 5 |
// except according to those terms. |
| 6 |
|
| 7 |
use std::{cell::RefCell, rc::Rc}; |
| 8 |
|
| 9 |
use neqo_common::{event::Provider as _, Datagram}; |
| 10 |
use test_fixture::now; |
| 11 |
|
| 12 |
use super::{ |
| 13 |
super::{Connection, Error, Output}, |
| 14 |
connect, default_client, default_server, fill_cwnd, maybe_authenticate, |
| 15 |
}; |
| 16 |
use crate::{ |
| 17 |
addr_valid::{AddressValidation, ValidateAddress}, |
| 18 |
send_stream::{RetransmissionPriority, TransmissionPriority}, |
| 19 |
ConnectionEvent, StreamId, StreamType, |
| 20 |
}; |
| 21 |
|
| 22 |
const BLOCK_SIZE: usize = 4_096; |
| 23 |
|
| 24 |
fn fill_stream(c: &mut Connection, id: StreamId) { |
| 25 |
loop { |
| 26 |
if c.stream_send(id, &[0x42; BLOCK_SIZE]).unwrap() < BLOCK_SIZE { |
| 27 |
return; |
| 28 |
} |
| 29 |
} |
| 30 |
} |
| 31 |
|
| 32 |
/// A receive stream cannot be prioritized (yet). |
| 33 |
#[test] |
| 34 |
fn receive_stream() { |
| 35 |
const MESSAGE: &[u8] = b"hello"; |
| 36 |
let mut client = default_client(); |
| 37 |
let mut server = default_server(); |
| 38 |
connect(&mut client, &mut server); |
| 39 |
|
| 40 |
let id = client.stream_create(StreamType::UniDi).unwrap(); |
| 41 |
assert_eq!(MESSAGE.len(), client.stream_send(id, MESSAGE).unwrap()); |
| 42 |
let dgram = client.process_output(now()).dgram(); |
| 43 |
|
| 44 |
server.process_input(dgram.unwrap(), now()); |
| 45 |
assert_eq!( |
| 46 |
server |
| 47 |
.stream_priority( |
| 48 |
id, |
| 49 |
TransmissionPriority::default(), |
| 50 |
RetransmissionPriority::default() |
| 51 |
) |
| 52 |
.unwrap_err(), |
| 53 |
Error::InvalidStreamId, |
| 54 |
"Priority doesn't apply to inbound unidirectional streams" |
| 55 |
); |
| 56 |
|
| 57 |
// But the stream does exist and can be read. |
| 58 |
let mut buf = [0; 10]; |
| 59 |
let (len, end) = server.stream_recv(id, &mut buf).unwrap(); |
| 60 |
assert_eq!(MESSAGE, &buf[..len]); |
| 61 |
assert!(!end); |
| 62 |
} |
| 63 |
|
| 64 |
/// Higher priority streams get sent ahead of lower ones, even when |
| 65 |
/// the higher priority stream is written to later. |
| 66 |
#[test] |
| 67 |
fn relative() { |
| 68 |
let mut client = default_client(); |
| 69 |
let mut server = default_server(); |
| 70 |
connect(&mut client, &mut server); |
| 71 |
|
| 72 |
// id_normal is created first, but it is lower priority. |
| 73 |
let id_normal = client.stream_create(StreamType::UniDi).unwrap(); |
| 74 |
fill_stream(&mut client, id_normal); |
| 75 |
let high = client.stream_create(StreamType::UniDi).unwrap(); |
| 76 |
fill_stream(&mut client, high); |
| 77 |
client |
| 78 |
.stream_priority( |
| 79 |
high, |
| 80 |
TransmissionPriority::High, |
| 81 |
RetransmissionPriority::default(), |
| 82 |
) |
| 83 |
.unwrap(); |
| 84 |
|
| 85 |
let dgram = client.process_output(now()).dgram(); |
| 86 |
server.process_input(dgram.unwrap(), now()); |
| 87 |
|
| 88 |
// The "id_normal" stream will get a `NewStream` event, but no data. |
| 89 |
for e in server.events() { |
| 90 |
if let ConnectionEvent::RecvStreamReadable { stream_id } = e { |
| 91 |
assert_ne!(stream_id, id_normal); |
| 92 |
} |
| 93 |
} |
| 94 |
} |
| 95 |
|
| 96 |
/// Check that changing priority has effect on the next packet that is sent. |
| 97 |
#[test] |
| 98 |
fn reprioritize() { |
| 99 |
let mut client = default_client(); |
| 100 |
let mut server = default_server(); |
| 101 |
connect(&mut client, &mut server); |
| 102 |
|
| 103 |
// id_normal is created first, but it is lower priority. |
| 104 |
let id_normal = client.stream_create(StreamType::UniDi).unwrap(); |
| 105 |
fill_stream(&mut client, id_normal); |
| 106 |
let id_high = client.stream_create(StreamType::UniDi).unwrap(); |
| 107 |
fill_stream(&mut client, id_high); |
| 108 |
client |
| 109 |
.stream_priority( |
| 110 |
id_high, |
| 111 |
TransmissionPriority::High, |
| 112 |
RetransmissionPriority::default(), |
| 113 |
) |
| 114 |
.unwrap(); |
| 115 |
|
| 116 |
let dgram = client.process_output(now()).dgram(); |
| 117 |
server.process_input(dgram.unwrap(), now()); |
| 118 |
|
| 119 |
// The "id_normal" stream will get a `NewStream` event, but no data. |
| 120 |
for e in server.events() { |
| 121 |
if let ConnectionEvent::RecvStreamReadable { stream_id } = e { |
| 122 |
assert_ne!(stream_id, id_normal); |
| 123 |
} |
| 124 |
} |
| 125 |
|
| 126 |
// When the high priority stream drops in priority, the streams are equal |
| 127 |
// priority and so their stream ID determines what is sent. |
| 128 |
client |
| 129 |
.stream_priority( |
| 130 |
id_high, |
| 131 |
TransmissionPriority::Normal, |
| 132 |
RetransmissionPriority::default(), |
| 133 |
) |
| 134 |
.unwrap(); |
| 135 |
let dgram = client.process_output(now()).dgram(); |
| 136 |
server.process_input(dgram.unwrap(), now()); |
| 137 |
|
| 138 |
for e in server.events() { |
| 139 |
if let ConnectionEvent::RecvStreamReadable { stream_id } = e { |
| 140 |
assert_ne!(stream_id, id_high); |
| 141 |
} |
| 142 |
} |
| 143 |
} |
| 144 |
|
| 145 |
/// Retransmission can be prioritized differently (usually higher). |
| 146 |
#[test] |
| 147 |
fn repairing_loss() { |
| 148 |
let mut client = default_client(); |
| 149 |
let mut server = default_server(); |
| 150 |
connect(&mut client, &mut server); |
| 151 |
let mut now = now(); |
| 152 |
|
| 153 |
// Send a few packets at low priority, lose one. |
| 154 |
let id_low = client.stream_create(StreamType::UniDi).unwrap(); |
| 155 |
fill_stream(&mut client, id_low); |
| 156 |
client |
| 157 |
.stream_priority( |
| 158 |
id_low, |
| 159 |
TransmissionPriority::Low, |
| 160 |
RetransmissionPriority::Higher, |
| 161 |
) |
| 162 |
.unwrap(); |
| 163 |
|
| 164 |
let _lost = client.process_output(now).dgram(); |
| 165 |
for _ in 0..5 { |
| 166 |
match client.process_output(now) { |
| 167 |
Output::Datagram(d) => server.process_input(d, now), |
| 168 |
Output::Callback(delay) => now += delay, |
| 169 |
Output::None => unreachable!(), |
| 170 |
} |
| 171 |
} |
| 172 |
|
| 173 |
// Generate an ACK. The first packet is now considered lost. |
| 174 |
let ack = server.process_output(now).dgram(); |
| 175 |
_ = server.events().count(); // Drain events. |
| 176 |
|
| 177 |
let id_normal = client.stream_create(StreamType::UniDi).unwrap(); |
| 178 |
fill_stream(&mut client, id_normal); |
| 179 |
|
| 180 |
let dgram = client.process(ack, now).dgram(); |
| 181 |
assert_eq!(client.stats().lost, 1); // Client should have noticed the loss. |
| 182 |
server.process_input(dgram.unwrap(), now); |
| 183 |
|
| 184 |
// Only the low priority stream has data as the retransmission of the data from |
| 185 |
// the lost packet is now more important than new data from the high priority stream. |
| 186 |
for e in server.events() { |
| 187 |
println!("Event: {e:?}"); |
| 188 |
if let ConnectionEvent::RecvStreamReadable { stream_id } = e { |
| 189 |
assert_eq!(stream_id, id_low); |
| 190 |
} |
| 191 |
} |
| 192 |
|
| 193 |
// However, only the retransmission is prioritized. |
| 194 |
// Though this might contain some retransmitted data, as other frames might push |
| 195 |
// the retransmitted data into a second packet, it will also contain data from the |
| 196 |
// normal priority stream. |
| 197 |
let dgram = client.process_output(now).dgram(); |
| 198 |
server.process_input(dgram.unwrap(), now); |
| 199 |
assert!(server.events().any( |
| 200 |
|e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id_normal), |
| 201 |
)); |
| 202 |
} |
| 203 |
|
| 204 |
fn connect_for_0rtt() -> (Connection, Connection) { |
| 205 |
let mut client = default_client(); |
| 206 |
let mut server = default_server(); |
| 207 |
|
| 208 |
// Rather than connect, send stream data in 0.5-RTT. |
| 209 |
// That allows this to test that critical streams preempt most frame types. |
| 210 |
let dgram = client.process_output(now()).dgram(); |
| 211 |
let dgram2 = client.process_output(now()).dgram(); |
| 212 |
server.process_input(dgram.unwrap(), now()); |
| 213 |
let dgram = server.process(dgram2, now()).dgram(); |
| 214 |
client.process_input(dgram.unwrap(), now()); |
| 215 |
(client, server) |
| 216 |
} |
| 217 |
|
| 218 |
fn complete_handshake(client: &mut Connection, server: &mut Connection, dgram: Option<Datagram>) { |
| 219 |
let dgram = client.process(dgram, now()).dgram(); |
| 220 |
maybe_authenticate(client); |
| 221 |
let dgram = server.process(dgram, now()).dgram(); |
| 222 |
let dgram = client.process(dgram, now()).dgram(); |
| 223 |
server.process_input(dgram.unwrap(), now()); |
| 224 |
} |
| 225 |
|
| 226 |
#[test] |
| 227 |
fn critical() { |
| 228 |
let (mut client, mut server) = connect_for_0rtt(); |
| 229 |
|
| 230 |
let id = server.stream_create(StreamType::UniDi).unwrap(); |
| 231 |
server |
| 232 |
.stream_priority( |
| 233 |
id, |
| 234 |
TransmissionPriority::Critical, |
| 235 |
RetransmissionPriority::default(), |
| 236 |
) |
| 237 |
.unwrap(); |
| 238 |
|
| 239 |
// Can't use fill_cwnd here because the server is blocked on the amplification |
| 240 |
// limit, so it can't fill the congestion window. |
| 241 |
while server.stream_create(StreamType::UniDi).is_ok() {} |
| 242 |
|
| 243 |
fill_stream(&mut server, id); |
| 244 |
let stats_before = server.stats().frame_tx; |
| 245 |
let dgram = server.process_output(now()).dgram(); |
| 246 |
let stats_after = server.stats().frame_tx; |
| 247 |
assert_eq!(stats_after.crypto, stats_before.crypto + 2); |
| 248 |
assert_eq!(stats_after.streams_blocked, 0); |
| 249 |
assert_eq!(stats_after.new_connection_id, 0); |
| 250 |
assert_eq!(stats_after.new_token, 0); |
| 251 |
assert_eq!(stats_after.handshake_done, 0); |
| 252 |
|
| 253 |
// Complete the handshake. |
| 254 |
complete_handshake(&mut client, &mut server, dgram); |
| 255 |
|
| 256 |
// Critical beats everything but HANDSHAKE_DONE. |
| 257 |
let stats_before = server.stats().frame_tx; |
| 258 |
drop(fill_cwnd(&mut server, id, now())); |
| 259 |
let stats_after = server.stats().frame_tx; |
| 260 |
assert_eq!(stats_after.crypto, stats_before.crypto); |
| 261 |
assert_eq!(stats_after.streams_blocked, 0); |
| 262 |
assert_eq!(stats_after.new_connection_id, 0); |
| 263 |
assert_eq!(stats_after.new_token, 0); |
| 264 |
assert_eq!(stats_after.handshake_done, 1); |
| 265 |
} |
| 266 |
|
| 267 |
#[test] |
| 268 |
fn important() { |
| 269 |
let (mut client, mut server) = connect_for_0rtt(); |
| 270 |
|
| 271 |
let id = server.stream_create(StreamType::UniDi).unwrap(); |
| 272 |
server |
| 273 |
.stream_priority( |
| 274 |
id, |
| 275 |
TransmissionPriority::Important, |
| 276 |
RetransmissionPriority::default(), |
| 277 |
) |
| 278 |
.unwrap(); |
| 279 |
fill_stream(&mut server, id); |
| 280 |
|
| 281 |
// Important beats everything but flow control. |
| 282 |
// Make enough streams to get a STREAMS_BLOCKED frame out. |
| 283 |
while server.stream_create(StreamType::UniDi).is_ok() {} |
| 284 |
|
| 285 |
let stats_before = server.stats().frame_tx; |
| 286 |
let dgram = server.process_output(now()).dgram(); |
| 287 |
let stats_after = server.stats().frame_tx; |
| 288 |
assert_eq!(stats_after.crypto, stats_before.crypto + 2); |
| 289 |
assert_eq!(stats_after.streams_blocked, 1); |
| 290 |
assert_eq!(stats_after.new_connection_id, 0); |
| 291 |
assert_eq!(stats_after.new_token, 0); |
| 292 |
assert_eq!(stats_after.handshake_done, 0); |
| 293 |
assert_eq!(stats_after.stream, stats_before.stream + 1); |
| 294 |
|
| 295 |
// Complete the handshake. |
| 296 |
complete_handshake(&mut client, &mut server, dgram); |
| 297 |
|
| 298 |
// Important beats everything but flow control. |
| 299 |
let stats_before = server.stats().frame_tx; |
| 300 |
drop(fill_cwnd(&mut server, id, now())); |
| 301 |
let stats_after = server.stats().frame_tx; |
| 302 |
assert_eq!(stats_after.crypto, stats_before.crypto); |
| 303 |
assert_eq!(stats_after.streams_blocked, 1); |
| 304 |
assert_eq!(stats_after.new_connection_id, 0); |
| 305 |
assert_eq!(stats_after.new_token, 0); |
| 306 |
assert_eq!(stats_after.handshake_done, 1); |
| 307 |
assert!(stats_after.stream > stats_before.stream); |
| 308 |
} |
| 309 |
|
| 310 |
#[test] |
| 311 |
fn high_normal() { |
| 312 |
let (mut client, mut server) = connect_for_0rtt(); |
| 313 |
|
| 314 |
let id = server.stream_create(StreamType::UniDi).unwrap(); |
| 315 |
server |
| 316 |
.stream_priority( |
| 317 |
id, |
| 318 |
TransmissionPriority::High, |
| 319 |
RetransmissionPriority::default(), |
| 320 |
) |
| 321 |
.unwrap(); |
| 322 |
fill_stream(&mut server, id); |
| 323 |
|
| 324 |
// Important beats everything but flow control. |
| 325 |
// Make enough streams to get a STREAMS_BLOCKED frame out. |
| 326 |
while server.stream_create(StreamType::UniDi).is_ok() {} |
| 327 |
|
| 328 |
let stats_before = server.stats().frame_tx; |
| 329 |
let dgram = server.process_output(now()).dgram(); |
| 330 |
let stats_after = server.stats().frame_tx; |
| 331 |
assert_eq!(stats_after.crypto, stats_before.crypto + 2); |
| 332 |
assert_eq!(stats_after.streams_blocked, 1); |
| 333 |
assert_eq!(stats_after.new_connection_id, 0); |
| 334 |
assert_eq!(stats_after.new_token, 0); |
| 335 |
assert_eq!(stats_after.handshake_done, 0); |
| 336 |
assert_eq!(stats_after.stream, stats_before.stream + 1); |
| 337 |
|
| 338 |
// Complete the handshake. |
| 339 |
complete_handshake(&mut client, &mut server, dgram); |
| 340 |
|
| 341 |
// High or Normal doesn't beat NEW_CONNECTION_ID, |
| 342 |
// but they beat CRYPTO/NEW_TOKEN. |
| 343 |
let stats_before = server.stats().frame_tx; |
| 344 |
server.send_ticket(now(), &[]).unwrap(); |
| 345 |
drop(fill_cwnd(&mut server, id, now())); |
| 346 |
let stats_after = server.stats().frame_tx; |
| 347 |
assert_eq!(stats_after.crypto, stats_before.crypto); |
| 348 |
assert_eq!(stats_after.streams_blocked, 1); |
| 349 |
assert_ne!(stats_after.new_connection_id, 0); // Note: > 0 |
| 350 |
assert_eq!(stats_after.new_token, 0); |
| 351 |
assert_eq!(stats_after.handshake_done, 1); |
| 352 |
assert!(stats_after.stream > stats_before.stream); |
| 353 |
} |
| 354 |
|
| 355 |
#[test] |
| 356 |
fn low() { |
| 357 |
let mut client = default_client(); |
| 358 |
let mut server = default_server(); |
| 359 |
let now = now(); |
| 360 |
// Use address validation; note that we need to hold a strong reference |
| 361 |
// as the server will only hold a weak reference. |
| 362 |
let validation = Rc::new(RefCell::new( |
| 363 |
AddressValidation::new(now, ValidateAddress::Never).unwrap(), |
| 364 |
)); |
| 365 |
server.set_validation(&validation); |
| 366 |
connect(&mut client, &mut server); |
| 367 |
|
| 368 |
let id = server.stream_create(StreamType::UniDi).unwrap(); |
| 369 |
server |
| 370 |
.stream_priority( |
| 371 |
id, |
| 372 |
TransmissionPriority::Low, |
| 373 |
RetransmissionPriority::default(), |
| 374 |
) |
| 375 |
.unwrap(); |
| 376 |
fill_stream(&mut server, id); |
| 377 |
|
| 378 |
// Send a session ticket and make it big enough to require a whole packet. |
| 379 |
// The resulting CRYPTO frame beats out the stream data. |
| 380 |
let stats_before = server.stats().frame_tx; |
| 381 |
server.send_ticket(now, &vec![0; server.plpmtu()]).unwrap(); |
| 382 |
drop(server.process_output(now)); |
| 383 |
let stats_after = server.stats().frame_tx; |
| 384 |
assert_eq!(stats_after.crypto, stats_before.crypto + 1); |
| 385 |
assert_eq!(stats_after.stream, stats_before.stream); |
| 386 |
|
| 387 |
// The above can't test if NEW_TOKEN wins because once that fits in a packet, |
| 388 |
// it is very hard to ensure that the STREAM frame won't also fit. |
| 389 |
// However, we can ensure that the next packet doesn't consist of just STREAM. |
| 390 |
let stats_before = server.stats().frame_tx; |
| 391 |
drop(server.process_output(now)); |
| 392 |
let stats_after = server.stats().frame_tx; |
| 393 |
assert_eq!(stats_after.crypto, stats_before.crypto + 1); |
| 394 |
assert_eq!(stats_after.new_token, 1); |
| 395 |
assert_eq!(stats_after.stream, stats_before.stream + 1); |
| 396 |
} |