| 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::{cmp::max, collections::HashMap, fmt::Debug}; |
| 8 |
|
| 9 |
use neqo_common::{event::Provider as _, qdebug}; |
| 10 |
use test_fixture::now; |
| 11 |
|
| 12 |
use super::{ |
| 13 |
super::State, assert_error, connect, connect_force_idle, default_client, default_server, |
| 14 |
maybe_authenticate, new_client, new_server, send_something, send_with_extra, |
| 15 |
DEFAULT_STREAM_DATA, |
| 16 |
}; |
| 17 |
use crate::{ |
| 18 |
events::ConnectionEvent, |
| 19 |
frame::FrameType, |
| 20 |
packet::PacketBuilder, |
| 21 |
recv_stream::INITIAL_RECV_WINDOW_SIZE, |
| 22 |
send_stream::{OrderGroup, SendStreamState}, |
| 23 |
streams::{SendOrder, StreamOrder}, |
| 24 |
tparams::{TransportParameter, TransportParameterId::*}, |
| 25 |
CloseReason, Connection, ConnectionParameters, Error, StreamId, StreamType, |
| 26 |
}; |
| 27 |
|
| 28 |
#[test] |
| 29 |
fn stream_create() { |
| 30 |
let mut client = default_client(); |
| 31 |
|
| 32 |
let out = client.process_output(now()); |
| 33 |
let out2 = client.process_output(now()); |
| 34 |
let mut server = default_server(); |
| 35 |
server.process_input(out.dgram().unwrap(), now()); |
| 36 |
let out = server.process(out2.dgram(), now()); |
| 37 |
|
| 38 |
let out = client.process(out.dgram(), now()); |
| 39 |
let out = server.process(out.dgram(), now()); |
| 40 |
let out = client.process(out.dgram(), now()); |
| 41 |
drop(server.process(out.dgram(), now())); |
| 42 |
assert!(maybe_authenticate(&mut client)); |
| 43 |
let out = client.process_output(now()); |
| 44 |
|
| 45 |
// client now in State::Connected |
| 46 |
assert_eq!(client.stream_create(StreamType::UniDi).unwrap(), 2); |
| 47 |
assert_eq!(client.stream_create(StreamType::UniDi).unwrap(), 6); |
| 48 |
assert_eq!(client.stream_create(StreamType::BiDi).unwrap(), 0); |
| 49 |
assert_eq!(client.stream_create(StreamType::BiDi).unwrap(), 4); |
| 50 |
|
| 51 |
drop(server.process(out.dgram(), now())); |
| 52 |
// server now in State::Connected |
| 53 |
assert_eq!(server.stream_create(StreamType::UniDi).unwrap(), 3); |
| 54 |
assert_eq!(server.stream_create(StreamType::UniDi).unwrap(), 7); |
| 55 |
assert_eq!(server.stream_create(StreamType::BiDi).unwrap(), 1); |
| 56 |
assert_eq!(server.stream_create(StreamType::BiDi).unwrap(), 5); |
| 57 |
} |
| 58 |
|
| 59 |
#[test] |
| 60 |
// tests stream send/recv after connection is established. |
| 61 |
fn transfer() { |
| 62 |
let mut client = default_client(); |
| 63 |
let mut server = default_server(); |
| 64 |
connect_force_idle(&mut client, &mut server); |
| 65 |
|
| 66 |
qdebug!("---- client sends"); |
| 67 |
// Send |
| 68 |
let client_stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 69 |
client.stream_send(client_stream_id, &[6; 100]).unwrap(); |
| 70 |
client.stream_send(client_stream_id, &[7; 40]).unwrap(); |
| 71 |
client.stream_send(client_stream_id, &[8; 4000]).unwrap(); |
| 72 |
|
| 73 |
// Send to another stream but some data after fin has been set |
| 74 |
let client_stream_id2 = client.stream_create(StreamType::UniDi).unwrap(); |
| 75 |
client.stream_send(client_stream_id2, &[6; 60]).unwrap(); |
| 76 |
client.stream_close_send(client_stream_id2).unwrap(); |
| 77 |
client.stream_send(client_stream_id2, &[7; 50]).unwrap_err(); |
| 78 |
// Sending this much takes a few datagrams. |
| 79 |
let mut datagrams = vec![]; |
| 80 |
let mut out = client.process_output(now()); |
| 81 |
while let Some(d) = out.dgram() { |
| 82 |
datagrams.push(d); |
| 83 |
out = client.process_output(now()); |
| 84 |
} |
| 85 |
assert_eq!(datagrams.len(), 4); |
| 86 |
assert_eq!(*client.state(), State::Confirmed); |
| 87 |
|
| 88 |
qdebug!("---- server receives"); |
| 89 |
for d in datagrams { |
| 90 |
let out = server.process(Some(d), now()); |
| 91 |
// With an RTT of zero, the server will acknowledge every packet immediately. |
| 92 |
assert!(out.as_dgram_ref().is_some()); |
| 93 |
qdebug!("Output={:0x?}", out.as_dgram_ref()); |
| 94 |
} |
| 95 |
assert_eq!(*server.state(), State::Confirmed); |
| 96 |
|
| 97 |
let mut buf = vec![0; 4000]; |
| 98 |
|
| 99 |
let mut stream_ids = server.events().filter_map(|evt| match evt { |
| 100 |
ConnectionEvent::NewStream { stream_id, .. } => Some(stream_id), |
| 101 |
_ => None, |
| 102 |
}); |
| 103 |
let first_stream = stream_ids.next().expect("should have a new stream event"); |
| 104 |
let second_stream = stream_ids |
| 105 |
.next() |
| 106 |
.expect("should have a second new stream event"); |
| 107 |
assert!(stream_ids.next().is_none()); |
| 108 |
let (received1, fin1) = server.stream_recv(first_stream, &mut buf).unwrap(); |
| 109 |
assert_eq!(received1, 4000); |
| 110 |
assert!(!fin1); |
| 111 |
let (received2, fin2) = server.stream_recv(first_stream, &mut buf).unwrap(); |
| 112 |
assert_eq!(received2, 140); |
| 113 |
assert!(!fin2); |
| 114 |
|
| 115 |
let (received3, fin3) = server.stream_recv(second_stream, &mut buf).unwrap(); |
| 116 |
assert_eq!(received3, 60); |
| 117 |
assert!(fin3); |
| 118 |
} |
| 119 |
|
| 120 |
// tests stream sendorder prioritization |
| 121 |
fn sendorder_test(order_of_sendorder: &[Option<SendOrder>]) { |
| 122 |
let mut client = default_client(); |
| 123 |
let mut server = default_server(); |
| 124 |
connect_force_idle(&mut client, &mut server); |
| 125 |
|
| 126 |
qdebug!("---- client sends"); |
| 127 |
// open all streams and set the sendorders |
| 128 |
let mut ordered = Vec::new(); |
| 129 |
let mut streams = Vec::<StreamId>::new(); |
| 130 |
for sendorder in order_of_sendorder { |
| 131 |
let id = client.stream_create(StreamType::UniDi).unwrap(); |
| 132 |
streams.push(id); |
| 133 |
ordered.push((id, *sendorder)); |
| 134 |
// must be set before sendorder |
| 135 |
client.streams.set_fairness(id, true).unwrap(); |
| 136 |
client.streams.set_sendorder(id, *sendorder).unwrap(); |
| 137 |
} |
| 138 |
// Write some data to all the streams |
| 139 |
for stream_id in streams { |
| 140 |
client.stream_send(stream_id, &[6; 100]).unwrap(); |
| 141 |
} |
| 142 |
|
| 143 |
// Sending this much takes a few datagrams. |
| 144 |
// Note: this test uses an RTT of 0 which simplifies things (no pacing) |
| 145 |
let mut datagrams = Vec::new(); |
| 146 |
let mut out = client.process_output(now()); |
| 147 |
while let Some(d) = out.dgram() { |
| 148 |
datagrams.push(d); |
| 149 |
out = client.process_output(now()); |
| 150 |
} |
| 151 |
assert_eq!(*client.state(), State::Confirmed); |
| 152 |
|
| 153 |
qdebug!("---- server receives"); |
| 154 |
for d in datagrams { |
| 155 |
let out = server.process(Some(d), now()); |
| 156 |
qdebug!("Output={:0x?}", out.as_dgram_ref()); |
| 157 |
} |
| 158 |
assert_eq!(*server.state(), State::Confirmed); |
| 159 |
|
| 160 |
let stream_ids = server |
| 161 |
.events() |
| 162 |
.filter_map(|evt| match evt { |
| 163 |
ConnectionEvent::RecvStreamReadable { stream_id, .. } => Some(stream_id), |
| 164 |
_ => None, |
| 165 |
}) |
| 166 |
.enumerate() |
| 167 |
.map(|(a, b)| (b, a)) |
| 168 |
.collect::<HashMap<_, _>>(); |
| 169 |
|
| 170 |
// streams should arrive in priority order, not order of creation, if sendorder prioritization |
| 171 |
// is working correctly |
| 172 |
|
| 173 |
// 'ordered' has the send order currently. Re-sort it by sendorder, but |
| 174 |
// if two items from the same sendorder exist, secondarily sort by the ordering in |
| 175 |
// the stream_ids vector (HashMap<StreamId, index: usize>) |
| 176 |
ordered.sort_unstable_by_key(|(stream_id, sendorder)| { |
| 177 |
( |
| 178 |
StreamOrder { |
| 179 |
sendorder: *sendorder, |
| 180 |
}, |
| 181 |
stream_ids[stream_id], |
| 182 |
) |
| 183 |
}); |
| 184 |
// make sure everything now is in the same order, since we modified the order of |
| 185 |
// same-sendorder items to match the ordering of those we saw in reception |
| 186 |
for (i, (stream_id, _sendorder)) in ordered.iter().enumerate() { |
| 187 |
assert_eq!(i, stream_ids[stream_id]); |
| 188 |
} |
| 189 |
} |
| 190 |
|
| 191 |
#[test] |
| 192 |
fn sendorder_0() { |
| 193 |
sendorder_test(&[None, Some(1), Some(2), Some(3)]); |
| 194 |
} |
| 195 |
#[test] |
| 196 |
fn sendorder_1() { |
| 197 |
sendorder_test(&[Some(3), Some(2), Some(1), None]); |
| 198 |
} |
| 199 |
#[test] |
| 200 |
fn sendorder_2() { |
| 201 |
sendorder_test(&[Some(3), None, Some(2), Some(1)]); |
| 202 |
} |
| 203 |
#[test] |
| 204 |
fn sendorder_3() { |
| 205 |
sendorder_test(&[Some(1), Some(2), None, Some(3)]); |
| 206 |
} |
| 207 |
#[test] |
| 208 |
fn sendorder_4() { |
| 209 |
sendorder_test(&[ |
| 210 |
Some(1), |
| 211 |
Some(2), |
| 212 |
Some(1), |
| 213 |
None, |
| 214 |
Some(3), |
| 215 |
Some(1), |
| 216 |
Some(3), |
| 217 |
None, |
| 218 |
]); |
| 219 |
} |
| 220 |
|
| 221 |
// Tests stream sendorder prioritization |
| 222 |
// Converts Vecs of u64's into StreamIds |
| 223 |
fn fairness_test<S, R>(source: S, number_iterates: usize, truncate_to: usize, result_array: &R) |
| 224 |
where |
| 225 |
S: IntoIterator, |
| 226 |
S::Item: Into<StreamId>, |
| 227 |
R: IntoIterator + Debug, |
| 228 |
R::Item: Into<StreamId>, |
| 229 |
Vec<u64>: PartialEq<R>, |
| 230 |
{ |
| 231 |
// test the OrderGroup code used for fairness |
| 232 |
let mut group: OrderGroup = OrderGroup::default(); |
| 233 |
for stream_id in source { |
| 234 |
group.insert(stream_id.into()); |
| 235 |
} |
| 236 |
{ |
| 237 |
let mut iterator1 = group.iter(); |
| 238 |
// advance_by() would help here |
| 239 |
let mut n = number_iterates; |
| 240 |
while n > 0 { |
| 241 |
iterator1.next(); |
| 242 |
n -= 1; |
| 243 |
} |
| 244 |
// let iterator1 go out of scope |
| 245 |
} |
| 246 |
group.truncate(truncate_to); |
| 247 |
|
| 248 |
let iterator2 = group.iter(); |
| 249 |
let result: Vec<u64> = iterator2.map(StreamId::as_u64).collect(); |
| 250 |
assert_eq!(result, *result_array); |
| 251 |
} |
| 252 |
|
| 253 |
#[test] |
| 254 |
fn ordergroup_0() { |
| 255 |
let source: [u64; 0] = []; |
| 256 |
let result: [u64; 0] = []; |
| 257 |
fairness_test(source, 1, usize::MAX, &result); |
| 258 |
} |
| 259 |
|
| 260 |
#[test] |
| 261 |
fn ordergroup_1() { |
| 262 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 263 |
let result: [u64; 6] = [1, 2, 3, 4, 5, 0]; |
| 264 |
fairness_test(source, 1, usize::MAX, &result); |
| 265 |
} |
| 266 |
|
| 267 |
#[test] |
| 268 |
fn ordergroup_2() { |
| 269 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 270 |
let result: [u64; 6] = [2, 3, 4, 5, 0, 1]; |
| 271 |
fairness_test(source, 2, usize::MAX, &result); |
| 272 |
} |
| 273 |
|
| 274 |
#[test] |
| 275 |
fn ordergroup_3() { |
| 276 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 277 |
let result: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 278 |
fairness_test(source, 10, usize::MAX, &result); |
| 279 |
} |
| 280 |
|
| 281 |
#[test] |
| 282 |
fn ordergroup_4() { |
| 283 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 284 |
let result: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 285 |
fairness_test(source, 0, usize::MAX, &result); |
| 286 |
} |
| 287 |
|
| 288 |
#[test] |
| 289 |
fn ordergroup_5() { |
| 290 |
let source: [u64; 1] = [0]; |
| 291 |
let result: [u64; 1] = [0]; |
| 292 |
fairness_test(source, 1, usize::MAX, &result); |
| 293 |
} |
| 294 |
|
| 295 |
#[test] |
| 296 |
fn ordergroup_6() { |
| 297 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 298 |
let result: [u64; 6] = [5, 0, 1, 2, 3, 4]; |
| 299 |
fairness_test(source, 5, usize::MAX, &result); |
| 300 |
} |
| 301 |
|
| 302 |
#[test] |
| 303 |
fn ordergroup_7() { |
| 304 |
let source: [u64; 6] = [0, 1, 2, 3, 4, 5]; |
| 305 |
let result: [u64; 3] = [0, 1, 2]; |
| 306 |
fairness_test(source, 5, 3, &result); |
| 307 |
} |
| 308 |
|
| 309 |
#[test] |
| 310 |
// Send fin even if a peer closes a remote bidi send stream before sending any data. |
| 311 |
fn report_fin_when_stream_closed_wo_data() { |
| 312 |
// Note that the two servers in this test will get different anti-replay filters. |
| 313 |
// That's OK because we aren't testing anti-replay. |
| 314 |
let mut client = default_client(); |
| 315 |
let mut server = default_server(); |
| 316 |
connect(&mut client, &mut server); |
| 317 |
|
| 318 |
// create a stream |
| 319 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 320 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 321 |
let out = client.process_output(now()); |
| 322 |
drop(server.process(out.dgram(), now())); |
| 323 |
|
| 324 |
server.stream_close_send(stream_id).unwrap(); |
| 325 |
let out = server.process_output(now()); |
| 326 |
drop(client.process(out.dgram(), now())); |
| 327 |
let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. }); |
| 328 |
assert!(client.events().any(stream_readable)); |
| 329 |
} |
| 330 |
|
| 331 |
fn exchange_data(client: &mut Connection, server: &mut Connection) { |
| 332 |
let mut input = None; |
| 333 |
loop { |
| 334 |
let out = client.process(input, now()).dgram(); |
| 335 |
let c_done = out.is_none(); |
| 336 |
let out = server.process(out, now()).dgram(); |
| 337 |
if out.is_none() && c_done { |
| 338 |
break; |
| 339 |
} |
| 340 |
input = out; |
| 341 |
} |
| 342 |
} |
| 343 |
|
| 344 |
#[test] |
| 345 |
fn sending_max_data() { |
| 346 |
const SMALL_MAX_DATA: usize = 2048; |
| 347 |
|
| 348 |
let mut client = default_client(); |
| 349 |
let mut server = new_server( |
| 350 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 351 |
); |
| 352 |
|
| 353 |
connect(&mut client, &mut server); |
| 354 |
|
| 355 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 356 |
assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected) |
| 357 |
assert_eq!(stream_id, 2); |
| 358 |
assert_eq!( |
| 359 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 360 |
SMALL_MAX_DATA |
| 361 |
); |
| 362 |
|
| 363 |
assert_eq!( |
| 364 |
client |
| 365 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 366 |
.unwrap(), |
| 367 |
SMALL_MAX_DATA |
| 368 |
); |
| 369 |
|
| 370 |
exchange_data(&mut client, &mut server); |
| 371 |
|
| 372 |
let mut buf = vec![0; 40000]; |
| 373 |
let (received, fin) = server.stream_recv(stream_id, &mut buf).unwrap(); |
| 374 |
assert_eq!(received, SMALL_MAX_DATA); |
| 375 |
assert!(!fin); |
| 376 |
|
| 377 |
let out = server.process_output(now()).dgram(); |
| 378 |
client.process_input(out.unwrap(), now()); |
| 379 |
|
| 380 |
assert_eq!( |
| 381 |
client |
| 382 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 383 |
.unwrap(), |
| 384 |
SMALL_MAX_DATA |
| 385 |
); |
| 386 |
} |
| 387 |
|
| 388 |
#[test] |
| 389 |
fn max_data() { |
| 390 |
const SMALL_MAX_DATA: usize = 16383; |
| 391 |
|
| 392 |
let mut client = default_client(); |
| 393 |
let mut server = default_server(); |
| 394 |
|
| 395 |
server |
| 396 |
.set_local_tparam( |
| 397 |
InitialMaxData, |
| 398 |
TransportParameter::Integer(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 399 |
) |
| 400 |
.unwrap(); |
| 401 |
|
| 402 |
connect(&mut client, &mut server); |
| 403 |
|
| 404 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 405 |
assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected) |
| 406 |
assert_eq!(stream_id, 2); |
| 407 |
assert_eq!( |
| 408 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 409 |
SMALL_MAX_DATA |
| 410 |
); |
| 411 |
assert_eq!( |
| 412 |
client |
| 413 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 414 |
.unwrap(), |
| 415 |
SMALL_MAX_DATA |
| 416 |
); |
| 417 |
assert_eq!(client.events().count(), 0); |
| 418 |
|
| 419 |
assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0); |
| 420 |
client |
| 421 |
.streams |
| 422 |
.get_send_stream_mut(stream_id) |
| 423 |
.unwrap() |
| 424 |
.mark_as_sent(0, 4096, false); |
| 425 |
assert_eq!(client.events().count(), 0); |
| 426 |
client |
| 427 |
.streams |
| 428 |
.get_send_stream_mut(stream_id) |
| 429 |
.unwrap() |
| 430 |
.mark_as_acked(0, 4096, false); |
| 431 |
assert_eq!(client.events().count(), 0); |
| 432 |
|
| 433 |
assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0); |
| 434 |
// no event because still limited by conn max data |
| 435 |
assert_eq!(client.events().count(), 0); |
| 436 |
|
| 437 |
// Increase max data. Avail space now limited by stream credit |
| 438 |
client.streams.handle_max_data(100_000_000); |
| 439 |
assert_eq!( |
| 440 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 441 |
INITIAL_RECV_WINDOW_SIZE - SMALL_MAX_DATA |
| 442 |
); |
| 443 |
|
| 444 |
let evts = client.events().collect::<Vec<_>>(); |
| 445 |
assert_eq!(evts.len(), 1); |
| 446 |
assert!(matches!( |
| 447 |
evts[0], |
| 448 |
ConnectionEvent::SendStreamWritable { .. } |
| 449 |
)); |
| 450 |
} |
| 451 |
|
| 452 |
#[test] |
| 453 |
fn exceed_max_data() { |
| 454 |
const SMALL_MAX_DATA: usize = 1024; |
| 455 |
|
| 456 |
let mut client = default_client(); |
| 457 |
let mut server = new_server( |
| 458 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 459 |
); |
| 460 |
|
| 461 |
connect(&mut client, &mut server); |
| 462 |
|
| 463 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 464 |
assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected) |
| 465 |
assert_eq!(stream_id, 2); |
| 466 |
assert_eq!( |
| 467 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 468 |
SMALL_MAX_DATA |
| 469 |
); |
| 470 |
assert_eq!( |
| 471 |
client |
| 472 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 473 |
.unwrap(), |
| 474 |
SMALL_MAX_DATA |
| 475 |
); |
| 476 |
|
| 477 |
assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0); |
| 478 |
|
| 479 |
// Artificially trick the client to think that it has more flow control credit. |
| 480 |
client.streams.handle_max_data(100_000_000); |
| 481 |
assert_eq!(client.stream_send(stream_id, b"h").unwrap(), 1); |
| 482 |
|
| 483 |
exchange_data(&mut client, &mut server); |
| 484 |
|
| 485 |
assert_error( |
| 486 |
&client, |
| 487 |
&CloseReason::Transport(Error::PeerError(Error::FlowControlError.code())), |
| 488 |
); |
| 489 |
assert_error(&server, &CloseReason::Transport(Error::FlowControlError)); |
| 490 |
} |
| 491 |
|
| 492 |
#[test] |
| 493 |
// If we send a stop_sending to the peer, we should not accept more data from the peer. |
| 494 |
fn do_not_accept_data_after_stop_sending() { |
| 495 |
// Note that the two servers in this test will get different anti-replay filters. |
| 496 |
// That's OK because we aren't testing anti-replay. |
| 497 |
let mut client = default_client(); |
| 498 |
let mut server = default_server(); |
| 499 |
connect(&mut client, &mut server); |
| 500 |
|
| 501 |
// create a stream |
| 502 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 503 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 504 |
let out = client.process_output(now()); |
| 505 |
drop(server.process(out.dgram(), now())); |
| 506 |
|
| 507 |
let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. }); |
| 508 |
assert!(server.events().any(stream_readable)); |
| 509 |
|
| 510 |
// Send one more packet from client. The packet should arrive after the server |
| 511 |
// has already requested stop_sending. |
| 512 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 513 |
let out_second_data_frame = client.process_output(now()); |
| 514 |
// Call stop sending. |
| 515 |
assert_eq!( |
| 516 |
Ok(()), |
| 517 |
server.stream_stop_sending(stream_id, Error::NoError.code()) |
| 518 |
); |
| 519 |
|
| 520 |
// Receive the second data frame. The frame should be ignored and |
| 521 |
// DataReadable events shouldn't be posted. |
| 522 |
let out = server.process(out_second_data_frame.dgram(), now()); |
| 523 |
assert!(!server.events().any(stream_readable)); |
| 524 |
|
| 525 |
drop(client.process(out.dgram(), now())); |
| 526 |
assert_eq!( |
| 527 |
Err(Error::FinalSizeError), |
| 528 |
client.stream_send(stream_id, &[0x00]) |
| 529 |
); |
| 530 |
} |
| 531 |
|
| 532 |
struct Writer(Vec<u64>); |
| 533 |
|
| 534 |
impl crate::connection::test_internal::FrameWriter for Writer { |
| 535 |
fn write_frames(&mut self, builder: &mut PacketBuilder) { |
| 536 |
builder.write_varint_frame(&self.0); |
| 537 |
} |
| 538 |
} |
| 539 |
|
| 540 |
#[test] |
| 541 |
/// Server sends a number of stream-related frames for a client-initiated stream that is not yet |
| 542 |
/// created. This should cause the client to close the connection. |
| 543 |
fn illegal_stream_related_frames() { |
| 544 |
fn test_with_illegal_frame(frame: &[u64]) { |
| 545 |
let mut client = default_client(); |
| 546 |
let mut server = default_server(); |
| 547 |
connect(&mut client, &mut server); |
| 548 |
let dgram = send_with_extra(&mut server, Writer(frame.to_vec()), now()); |
| 549 |
client.process_input(dgram, now()); |
| 550 |
assert!(client.state().closed()); |
| 551 |
} |
| 552 |
|
| 553 |
// 0 = Client-Initiated, Bidirectional; 2 = Client-Initiated, Unidirectional |
| 554 |
for stream_id in [0, 2] { |
| 555 |
for frame_type in [ |
| 556 |
FrameType::ResetStream, |
| 557 |
FrameType::StopSending, |
| 558 |
FrameType::MaxStreamData, |
| 559 |
FrameType::StreamDataBlocked, |
| 560 |
FrameType::Stream, |
| 561 |
] { |
| 562 |
// The slice contains an extra 0 that is only needed for a RESET_STREAM frame. |
| 563 |
// It's ignored for the other frame types as PADDING. |
| 564 |
test_with_illegal_frame(&[frame_type.into(), stream_id, 0, 0]); |
| 565 |
} |
| 566 |
} |
| 567 |
} |
| 568 |
|
| 569 |
#[test] |
| 570 |
/// Regression <https://github.com/mozilla/neqo/pull/2358>. |
| 571 |
fn legal_out_of_order_frame_on_remote_initiated_closed_stream() { |
| 572 |
const REQUEST: &[u8] = b"ping"; |
| 573 |
let mut client = default_client(); |
| 574 |
let mut server = default_server(); |
| 575 |
connect(&mut client, &mut server); |
| 576 |
|
| 577 |
// Client sends request and closes stream. |
| 578 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 579 |
_ = client.stream_send(stream_id, REQUEST).unwrap(); |
| 580 |
client.stream_close_send(stream_id).unwrap(); |
| 581 |
let dgram = client.process_output(now()).dgram(); |
| 582 |
|
| 583 |
// Server reads request and closes stream. |
| 584 |
server.process_input(dgram.unwrap(), now()); |
| 585 |
let mut buf = [0; REQUEST.len()]; |
| 586 |
server.stream_recv(stream_id, &mut buf).unwrap(); |
| 587 |
server.stream_close_send(stream_id).unwrap(); |
| 588 |
let dgram = server.process_output(now()).dgram(); |
| 589 |
client.process_input(dgram.unwrap(), now()); |
| 590 |
|
| 591 |
// Client ACKs server's close stream, thus server forgetting about stream. |
| 592 |
let dgram = send_something(&mut client, now()); |
| 593 |
let dgram = server.process(Some(dgram), now()).dgram(); |
| 594 |
client.process_input(dgram.unwrap(), now()); |
| 595 |
|
| 596 |
// Deliver an out-of-order `FRAME_TYPE_MAX_STREAM_DATA` on forgotten stream. |
| 597 |
let dgram = send_with_extra( |
| 598 |
&mut client, |
| 599 |
Writer(vec![ |
| 600 |
u64::from(FrameType::MaxStreamData), |
| 601 |
stream_id.as_u64(), |
| 602 |
0, |
| 603 |
0, |
| 604 |
]), |
| 605 |
now(), |
| 606 |
); |
| 607 |
server.process_input(dgram, now()); |
| 608 |
|
| 609 |
assert!( |
| 610 |
!server.state().closed(), |
| 611 |
"expect server to ignore out-of-order frame on forgotten stream" |
| 612 |
); |
| 613 |
} |
| 614 |
|
| 615 |
#[test] |
| 616 |
// Server sends stop_sending, the client simultaneous sends reset. |
| 617 |
fn simultaneous_stop_sending_and_reset() { |
| 618 |
let mut client = default_client(); |
| 619 |
let mut server = default_server(); |
| 620 |
connect(&mut client, &mut server); |
| 621 |
|
| 622 |
// create a stream |
| 623 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 624 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 625 |
let out = client.process_output(now()); |
| 626 |
let ack = server.process(out.dgram(), now()).dgram(); |
| 627 |
|
| 628 |
let stream_readable = |
| 629 |
|e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id: id } if id == stream_id); |
| 630 |
assert!(server.events().any(stream_readable)); |
| 631 |
|
| 632 |
// The client resets the stream. The packet with reset should arrive after the server |
| 633 |
// has already requested stop_sending. |
| 634 |
client.stream_reset_send(stream_id, 0).unwrap(); |
| 635 |
let out_reset_frame = client.process(ack, now()).dgram(); |
| 636 |
|
| 637 |
// Send something out of order to force the server to generate an |
| 638 |
// acknowledgment at the next opportunity. |
| 639 |
let force_ack = send_something(&mut client, now()); |
| 640 |
server.process_input(force_ack, now()); |
| 641 |
|
| 642 |
// Call stop sending. |
| 643 |
server.stream_stop_sending(stream_id, 0).unwrap(); |
| 644 |
// Receive the second data frame. The frame should be ignored and |
| 645 |
// DataReadable events shouldn't be posted. |
| 646 |
let ack = server.process(out_reset_frame, now()).dgram(); |
| 647 |
assert!(ack.is_some()); |
| 648 |
assert!(!server.events().any(stream_readable)); |
| 649 |
|
| 650 |
// The client gets the STOP_SENDING frame. |
| 651 |
client.process_input(ack.unwrap(), now()); |
| 652 |
assert_eq!( |
| 653 |
Err(Error::InvalidStreamId), |
| 654 |
client.stream_send(stream_id, &[0x00]) |
| 655 |
); |
| 656 |
} |
| 657 |
|
| 658 |
#[test] |
| 659 |
/// Make a stream data or control frame arrive after the stream has been used and cleared. |
| 660 |
fn late_stream_related_frames() { |
| 661 |
fn late_stream_related_frame(frame_type: FrameType) { |
| 662 |
let mut client = default_client(); |
| 663 |
let mut server = default_server(); |
| 664 |
connect(&mut client, &mut server); |
| 665 |
|
| 666 |
// Client creates a stream and sends some data. |
| 667 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 668 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 669 |
let out = client.process_output(now()); |
| 670 |
_ = server.process(out.dgram(), now()).dgram(); |
| 671 |
|
| 672 |
// Make the server generate a packet containing the test frame. |
| 673 |
let before = server.stats().frame_tx; |
| 674 |
match frame_type { |
| 675 |
FrameType::ResetStream => { |
| 676 |
server.stream_reset_send(stream_id, 0).unwrap(); |
| 677 |
} |
| 678 |
FrameType::StopSending => { |
| 679 |
server.stream_stop_sending(stream_id, 0).unwrap(); |
| 680 |
} |
| 681 |
FrameType::Stream => { |
| 682 |
server.stream_send(stream_id, &[0x00]).unwrap(); |
| 683 |
server.stream_close_send(stream_id).unwrap(); |
| 684 |
} |
| 685 |
FrameType::MaxStreamData => { |
| 686 |
server |
| 687 |
.streams |
| 688 |
.get_recv_stream_mut(stream_id) |
| 689 |
.unwrap() |
| 690 |
.set_stream_max_data(u32::MAX.into()); |
| 691 |
} |
| 692 |
FrameType::StreamDataBlocked => { |
| 693 |
let internal_stream = server.streams.get_send_stream_mut(stream_id).unwrap(); |
| 694 |
if let SendStreamState::Ready { fc, .. } = internal_stream.state() { |
| 695 |
fc.blocked(); |
| 696 |
} else { |
| 697 |
panic!("unexpected stream state"); |
| 698 |
} |
| 699 |
} |
| 700 |
_ => panic!("unexpected frame type"), |
| 701 |
} |
| 702 |
let tester = server.process_output(now()).dgram(); |
| 703 |
let after = server.stats().frame_tx; |
| 704 |
match frame_type { |
| 705 |
FrameType::ResetStream => { |
| 706 |
assert_eq!(after.reset_stream, before.reset_stream + 1); |
| 707 |
} |
| 708 |
FrameType::StopSending => { |
| 709 |
assert_eq!(after.stop_sending, before.stop_sending + 1); |
| 710 |
} |
| 711 |
FrameType::Stream => { |
| 712 |
assert_eq!(after.stream, before.stream + 1); |
| 713 |
} |
| 714 |
FrameType::MaxStreamData => { |
| 715 |
assert_eq!(after.max_stream_data, before.max_stream_data + 1); |
| 716 |
} |
| 717 |
FrameType::StreamDataBlocked => { |
| 718 |
assert_eq!(after.stream_data_blocked, before.stream_data_blocked + 1); |
| 719 |
} |
| 720 |
_ => panic!("unexpected frame type"), |
| 721 |
} |
| 722 |
|
| 723 |
// Now clear the streams on the client, and then deliver the test frame. |
| 724 |
client.streams.clear_streams(); |
| 725 |
let (ss, rs) = client.streams.obtain_stream(stream_id).unwrap(); |
| 726 |
assert!(ss.is_none() && rs.is_none()); |
| 727 |
_ = client.process(tester, now()).dgram(); |
| 728 |
|
| 729 |
// Make sure this worked, i.e., the connection didn't close. |
| 730 |
assert_eq!(*client.state(), State::Confirmed); |
| 731 |
} |
| 732 |
|
| 733 |
for frame_type in [ |
| 734 |
FrameType::ResetStream, |
| 735 |
FrameType::StopSending, |
| 736 |
FrameType::MaxStreamData, |
| 737 |
FrameType::StreamDataBlocked, |
| 738 |
FrameType::Stream, |
| 739 |
] { |
| 740 |
late_stream_related_frame(frame_type); |
| 741 |
} |
| 742 |
} |
| 743 |
|
| 744 |
#[test] |
| 745 |
fn client_fin_reorder() { |
| 746 |
let mut client = default_client(); |
| 747 |
let mut server = default_server(); |
| 748 |
|
| 749 |
// Send ClientHello. |
| 750 |
let client_hs = client.process_output(now()); |
| 751 |
let client_hs2 = client.process_output(now()); |
| 752 |
assert!(client_hs.as_dgram_ref().is_some() && client_hs2.as_dgram_ref().is_some()); |
| 753 |
|
| 754 |
server.process_input(client_hs.dgram().unwrap(), now()); |
| 755 |
let server_hs = server.process(client_hs2.dgram(), now()); |
| 756 |
assert!(server_hs.as_dgram_ref().is_some()); // ServerHello, etc... |
| 757 |
|
| 758 |
let client_ack = client.process(server_hs.dgram(), now()); |
| 759 |
assert!(client_ack.as_dgram_ref().is_some()); |
| 760 |
|
| 761 |
let dgram = server.process(client_ack.dgram(), now()); |
| 762 |
let dgram = client.process(dgram.dgram(), now()); |
| 763 |
|
| 764 |
let server_out = server.process(dgram.dgram(), now()); |
| 765 |
assert!(server_out.as_dgram_ref().is_none()); |
| 766 |
|
| 767 |
assert!(maybe_authenticate(&mut client)); |
| 768 |
assert_eq!(*client.state(), State::Connected); |
| 769 |
|
| 770 |
let client_fin = client.process_output(now()); |
| 771 |
assert!(client_fin.as_dgram_ref().is_some()); |
| 772 |
|
| 773 |
let client_stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 774 |
client.stream_send(client_stream_id, &[1, 2, 3]).unwrap(); |
| 775 |
let client_stream_data = client.process_output(now()); |
| 776 |
assert!(client_stream_data.as_dgram_ref().is_some()); |
| 777 |
|
| 778 |
// Now stream data gets before client_fin |
| 779 |
let server_out = server.process(client_stream_data.dgram(), now()); |
| 780 |
assert!(server_out.as_dgram_ref().is_none()); // the packet will be discarded |
| 781 |
|
| 782 |
assert_eq!(*server.state(), State::Handshaking); |
| 783 |
let server_out = server.process(client_fin.dgram(), now()); |
| 784 |
assert!(server_out.as_dgram_ref().is_some()); |
| 785 |
} |
| 786 |
|
| 787 |
#[test] |
| 788 |
fn after_fin_is_read_conn_events_for_stream_should_be_removed() { |
| 789 |
let mut client = default_client(); |
| 790 |
let mut server = default_server(); |
| 791 |
connect(&mut client, &mut server); |
| 792 |
|
| 793 |
let id = server.stream_create(StreamType::BiDi).unwrap(); |
| 794 |
server.stream_send(id, &[6; 10]).unwrap(); |
| 795 |
server.stream_close_send(id).unwrap(); |
| 796 |
let out = server.process_output(now()).dgram(); |
| 797 |
assert!(out.is_some()); |
| 798 |
|
| 799 |
drop(client.process(out, now())); |
| 800 |
|
| 801 |
// read from the stream before checking connection events. |
| 802 |
let mut buf = vec![0; 4000]; |
| 803 |
let (_, fin) = client.stream_recv(id, &mut buf).unwrap(); |
| 804 |
assert!(fin); |
| 805 |
|
| 806 |
// Make sure we do not have RecvStreamReadable events for the stream when fin has been read. |
| 807 |
let readable_stream_evt = |
| 808 |
|e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id); |
| 809 |
assert!(!client.events().any(readable_stream_evt)); |
| 810 |
} |
| 811 |
|
| 812 |
#[test] |
| 813 |
fn after_stream_stop_sending_is_called_conn_events_for_stream_should_be_removed() { |
| 814 |
let mut client = default_client(); |
| 815 |
let mut server = default_server(); |
| 816 |
connect(&mut client, &mut server); |
| 817 |
|
| 818 |
let id = server.stream_create(StreamType::BiDi).unwrap(); |
| 819 |
server.stream_send(id, &[6; 10]).unwrap(); |
| 820 |
server.stream_close_send(id).unwrap(); |
| 821 |
let out = server.process_output(now()).dgram(); |
| 822 |
assert!(out.is_some()); |
| 823 |
|
| 824 |
drop(client.process(out, now())); |
| 825 |
|
| 826 |
// send stop sending. |
| 827 |
client |
| 828 |
.stream_stop_sending(id, Error::NoError.code()) |
| 829 |
.unwrap(); |
| 830 |
|
| 831 |
// Make sure we do not have RecvStreamReadable events for the stream after stream_stop_sending |
| 832 |
// has been called. |
| 833 |
let readable_stream_evt = |
| 834 |
|e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id); |
| 835 |
assert!(!client.events().any(readable_stream_evt)); |
| 836 |
} |
| 837 |
|
| 838 |
#[test] |
| 839 |
fn stream_data_blocked_generates_max_stream_data() { |
| 840 |
let mut client = default_client(); |
| 841 |
let mut server = default_server(); |
| 842 |
connect(&mut client, &mut server); |
| 843 |
|
| 844 |
let now = now(); |
| 845 |
|
| 846 |
// Send some data and consume some flow control. |
| 847 |
let stream_id = server.stream_create(StreamType::UniDi).unwrap(); |
| 848 |
_ = server.stream_send(stream_id, DEFAULT_STREAM_DATA).unwrap(); |
| 849 |
let dgram = server.process_output(now).dgram(); |
| 850 |
assert!(dgram.is_some()); |
| 851 |
|
| 852 |
// Consume the data. |
| 853 |
client.process_input(dgram.unwrap(), now); |
| 854 |
let mut buf = [0; 10]; |
| 855 |
let (count, end) = client.stream_recv(stream_id, &mut buf[..]).unwrap(); |
| 856 |
assert_eq!(count, DEFAULT_STREAM_DATA.len()); |
| 857 |
assert!(!end); |
| 858 |
|
| 859 |
// Now send `STREAM_DATA_BLOCKED`. |
| 860 |
let internal_stream = server.streams.get_send_stream_mut(stream_id).unwrap(); |
| 861 |
if let SendStreamState::Send { fc, .. } = internal_stream.state() { |
| 862 |
fc.blocked(); |
| 863 |
} else { |
| 864 |
panic!("unexpected stream state"); |
| 865 |
} |
| 866 |
let dgram = server.process_output(now).dgram(); |
| 867 |
assert!(dgram.is_some()); |
| 868 |
|
| 869 |
let sdb_before = client.stats().frame_rx.stream_data_blocked; |
| 870 |
let dgram = client.process(dgram, now).dgram(); |
| 871 |
assert_eq!(client.stats().frame_rx.stream_data_blocked, sdb_before + 1); |
| 872 |
assert!(dgram.is_some()); |
| 873 |
|
| 874 |
// Client should have sent a MAX_STREAM_DATA frame with just a small increase |
| 875 |
// on the default window size. |
| 876 |
let msd_before = server.stats().frame_rx.max_stream_data; |
| 877 |
server.process_input(dgram.unwrap(), now); |
| 878 |
assert_eq!(server.stats().frame_rx.max_stream_data, msd_before + 1); |
| 879 |
|
| 880 |
// Test that the entirety of the receive buffer is available now. |
| 881 |
let mut written = 0; |
| 882 |
loop { |
| 883 |
const LARGE_BUFFER: &[u8] = &[0; 1024]; |
| 884 |
let amount = server.stream_send(stream_id, LARGE_BUFFER).unwrap(); |
| 885 |
if amount == 0 { |
| 886 |
break; |
| 887 |
} |
| 888 |
written += amount; |
| 889 |
} |
| 890 |
assert_eq!(written, INITIAL_RECV_WINDOW_SIZE); |
| 891 |
} |
| 892 |
|
| 893 |
/// See <https://github.com/mozilla/neqo/issues/871> |
| 894 |
#[test] |
| 895 |
fn max_streams_after_bidi_closed() { |
| 896 |
const REQUEST: &[u8] = b"ping"; |
| 897 |
const RESPONSE: &[u8] = b"pong"; |
| 898 |
let mut client = default_client(); |
| 899 |
let mut server = default_server(); |
| 900 |
connect(&mut client, &mut server); |
| 901 |
|
| 902 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 903 |
while client.stream_create(StreamType::BiDi).is_ok() { |
| 904 |
// Exhaust the stream limit. |
| 905 |
} |
| 906 |
// Write on the one stream and send that out. |
| 907 |
_ = client.stream_send(stream_id, REQUEST).unwrap(); |
| 908 |
client.stream_close_send(stream_id).unwrap(); |
| 909 |
let dgram = client.process_output(now()).dgram(); |
| 910 |
|
| 911 |
// Now handle the stream and send an incomplete response. |
| 912 |
server.process_input(dgram.unwrap(), now()); |
| 913 |
server.stream_send(stream_id, RESPONSE).unwrap(); |
| 914 |
let dgram = server.process_output(now()).dgram(); |
| 915 |
|
| 916 |
// The server shouldn't have released more stream credit. |
| 917 |
client.process_input(dgram.unwrap(), now()); |
| 918 |
let e = client.stream_create(StreamType::BiDi).unwrap_err(); |
| 919 |
assert!(matches!(e, Error::StreamLimitError)); |
| 920 |
|
| 921 |
// Closing the stream isn't enough. |
| 922 |
server.stream_close_send(stream_id).unwrap(); |
| 923 |
let dgram = server.process_output(now()).dgram(); |
| 924 |
client.process_input(dgram.unwrap(), now()); |
| 925 |
assert!(client.stream_create(StreamType::BiDi).is_err()); |
| 926 |
|
| 927 |
// The server needs to see an acknowledgment from the client for its |
| 928 |
// response AND the server has to read all of the request. |
| 929 |
// and the server needs to read all the data. Read first. |
| 930 |
let mut buf = [0; REQUEST.len()]; |
| 931 |
let (count, fin) = server.stream_recv(stream_id, &mut buf).unwrap(); |
| 932 |
assert_eq!(&buf[..count], REQUEST); |
| 933 |
assert!(fin); |
| 934 |
|
| 935 |
// We need an ACK from the client now, but that isn't guaranteed, |
| 936 |
// so give the client one more packet just in case. |
| 937 |
let dgram = send_something(&mut server, now()); |
| 938 |
client.process_input(dgram, now()); |
| 939 |
|
| 940 |
// Now get the client to send the ACK and have the server handle that. |
| 941 |
let dgram = send_something(&mut client, now()); |
| 942 |
let dgram = server.process(Some(dgram), now()).dgram(); |
| 943 |
client.process_input(dgram.unwrap(), now()); |
| 944 |
assert!(client.stream_create(StreamType::BiDi).is_ok()); |
| 945 |
assert!(client.stream_create(StreamType::BiDi).is_err()); |
| 946 |
} |
| 947 |
|
| 948 |
#[test] |
| 949 |
fn no_dupdata_readable_events() { |
| 950 |
let mut client = default_client(); |
| 951 |
let mut server = default_server(); |
| 952 |
connect(&mut client, &mut server); |
| 953 |
|
| 954 |
// create a stream |
| 955 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 956 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 957 |
let out = client.process_output(now()); |
| 958 |
drop(server.process(out.dgram(), now())); |
| 959 |
|
| 960 |
// We have a data_readable event. |
| 961 |
let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. }); |
| 962 |
assert!(server.events().any(stream_readable)); |
| 963 |
|
| 964 |
// Send one more data frame from client. The previous stream data has not been read yet, |
| 965 |
// therefore there should not be a new DataReadable event. |
| 966 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 967 |
let out_second_data_frame = client.process_output(now()); |
| 968 |
drop(server.process(out_second_data_frame.dgram(), now())); |
| 969 |
assert!(!server.events().any(stream_readable)); |
| 970 |
|
| 971 |
// One more frame with a fin will not produce a new DataReadable event, because the |
| 972 |
// previous stream data has not been read yet. |
| 973 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 974 |
client.stream_close_send(stream_id).unwrap(); |
| 975 |
let out_third_data_frame = client.process_output(now()); |
| 976 |
drop(server.process(out_third_data_frame.dgram(), now())); |
| 977 |
assert!(!server.events().any(stream_readable)); |
| 978 |
} |
| 979 |
|
| 980 |
#[test] |
| 981 |
fn no_dupdata_readable_events_empty_last_frame() { |
| 982 |
let mut client = default_client(); |
| 983 |
let mut server = default_server(); |
| 984 |
connect(&mut client, &mut server); |
| 985 |
|
| 986 |
// create a stream |
| 987 |
let stream_id = client.stream_create(StreamType::BiDi).unwrap(); |
| 988 |
client.stream_send(stream_id, &[0x00]).unwrap(); |
| 989 |
let out = client.process_output(now()); |
| 990 |
drop(server.process(out.dgram(), now())); |
| 991 |
|
| 992 |
// We have a data_readable event. |
| 993 |
let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. }); |
| 994 |
assert!(server.events().any(stream_readable)); |
| 995 |
|
| 996 |
// An empty frame with a fin will not produce a new DataReadable event, because |
| 997 |
// the previous stream data has not been read yet. |
| 998 |
client.stream_close_send(stream_id).unwrap(); |
| 999 |
let out_second_data_frame = client.process_output(now()); |
| 1000 |
drop(server.process(out_second_data_frame.dgram(), now())); |
| 1001 |
assert!(!server.events().any(stream_readable)); |
| 1002 |
} |
| 1003 |
|
| 1004 |
fn change_flow_control(stream_type: StreamType, new_fc: u64) { |
| 1005 |
const RECV_BUFFER_START: u64 = 300; |
| 1006 |
|
| 1007 |
let mut client = new_client( |
| 1008 |
ConnectionParameters::default() |
| 1009 |
.max_stream_data(StreamType::BiDi, true, RECV_BUFFER_START) |
| 1010 |
.max_stream_data(StreamType::UniDi, true, RECV_BUFFER_START), |
| 1011 |
); |
| 1012 |
let mut server = default_server(); |
| 1013 |
connect(&mut client, &mut server); |
| 1014 |
|
| 1015 |
// create a stream |
| 1016 |
let stream_id = server.stream_create(stream_type).unwrap(); |
| 1017 |
let written1 = server.stream_send(stream_id, &[0x0; 10000]).unwrap(); |
| 1018 |
assert_eq!(u64::try_from(written1).unwrap(), RECV_BUFFER_START); |
| 1019 |
|
| 1020 |
// Send the stream to the client. |
| 1021 |
let out = server.process_output(now()); |
| 1022 |
drop(client.process(out.dgram(), now())); |
| 1023 |
|
| 1024 |
// change max_stream_data for stream_id. |
| 1025 |
client.set_stream_max_data(stream_id, new_fc).unwrap(); |
| 1026 |
|
| 1027 |
// server should receive a MAX_SREAM_DATA frame if the flow control window is updated. |
| 1028 |
let out2 = client.process_output(now()); |
| 1029 |
let out3 = server.process(out2.dgram(), now()); |
| 1030 |
let expected = usize::from(RECV_BUFFER_START < new_fc); |
| 1031 |
assert_eq!(server.stats().frame_rx.max_stream_data, expected); |
| 1032 |
|
| 1033 |
// If the flow control window has been increased, server can write more data. |
| 1034 |
let written2 = server.stream_send(stream_id, &[0x0; 10000]).unwrap(); |
| 1035 |
if RECV_BUFFER_START < new_fc { |
| 1036 |
assert_eq!(u64::try_from(written2).unwrap(), new_fc - RECV_BUFFER_START); |
| 1037 |
} else { |
| 1038 |
assert_eq!(written2, 0); |
| 1039 |
} |
| 1040 |
|
| 1041 |
// Exchange packets so that client gets all data. |
| 1042 |
let out4 = client.process(out3.dgram(), now()); |
| 1043 |
let out5 = server.process(out4.dgram(), now()); |
| 1044 |
drop(client.process(out5.dgram(), now())); |
| 1045 |
|
| 1046 |
// read all data by client |
| 1047 |
let mut buf = [0x0; 10000]; |
| 1048 |
let (read, _) = client.stream_recv(stream_id, &mut buf).unwrap(); |
| 1049 |
assert_eq!(u64::try_from(read).unwrap(), max(RECV_BUFFER_START, new_fc)); |
| 1050 |
|
| 1051 |
let out4 = client.process_output(now()); |
| 1052 |
drop(server.process(out4.dgram(), now())); |
| 1053 |
|
| 1054 |
let written3 = server.stream_send(stream_id, &[0x0; 10000]).unwrap(); |
| 1055 |
assert_eq!(u64::try_from(written3).unwrap(), new_fc); |
| 1056 |
} |
| 1057 |
|
| 1058 |
#[test] |
| 1059 |
fn increase_decrease_flow_control() { |
| 1060 |
const RECV_BUFFER_NEW_BIGGER: u64 = 400; |
| 1061 |
const RECV_BUFFER_NEW_SMALLER: u64 = 200; |
| 1062 |
|
| 1063 |
change_flow_control(StreamType::UniDi, RECV_BUFFER_NEW_BIGGER); |
| 1064 |
change_flow_control(StreamType::BiDi, RECV_BUFFER_NEW_BIGGER); |
| 1065 |
|
| 1066 |
change_flow_control(StreamType::UniDi, RECV_BUFFER_NEW_SMALLER); |
| 1067 |
change_flow_control(StreamType::BiDi, RECV_BUFFER_NEW_SMALLER); |
| 1068 |
} |
| 1069 |
|
| 1070 |
#[test] |
| 1071 |
fn session_flow_control_stop_sending_state_recv() { |
| 1072 |
const SMALL_MAX_DATA: usize = 1024; |
| 1073 |
|
| 1074 |
let mut client = default_client(); |
| 1075 |
let mut server = new_server( |
| 1076 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 1077 |
); |
| 1078 |
|
| 1079 |
connect(&mut client, &mut server); |
| 1080 |
|
| 1081 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 1082 |
assert_eq!( |
| 1083 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1084 |
SMALL_MAX_DATA |
| 1085 |
); |
| 1086 |
|
| 1087 |
// send 1 byte so that the server learns about the stream. |
| 1088 |
assert_eq!(client.stream_send(stream_id, b"a").unwrap(), 1); |
| 1089 |
|
| 1090 |
exchange_data(&mut client, &mut server); |
| 1091 |
|
| 1092 |
server |
| 1093 |
.stream_stop_sending(stream_id, Error::NoError.code()) |
| 1094 |
.unwrap(); |
| 1095 |
|
| 1096 |
assert_eq!( |
| 1097 |
client |
| 1098 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA]) |
| 1099 |
.unwrap(), |
| 1100 |
SMALL_MAX_DATA - 1 |
| 1101 |
); |
| 1102 |
|
| 1103 |
// In this case the final size is only known after RESET frame is received. |
| 1104 |
// The server sends STOP_SENDING -> the client sends RESET -> the server |
| 1105 |
// sends MAX_DATA. |
| 1106 |
let out = server.process_output(now()).dgram(); |
| 1107 |
let out = client.process(out, now()).dgram(); |
| 1108 |
// the client is still limited. |
| 1109 |
let stream_id2 = client.stream_create(StreamType::UniDi).unwrap(); |
| 1110 |
assert_eq!(client.stream_avail_send_space(stream_id2).unwrap(), 0); |
| 1111 |
let out = server.process(out, now()).dgram(); |
| 1112 |
client.process_input(out.unwrap(), now()); |
| 1113 |
assert_eq!( |
| 1114 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1115 |
SMALL_MAX_DATA |
| 1116 |
); |
| 1117 |
} |
| 1118 |
|
| 1119 |
#[test] |
| 1120 |
fn session_flow_control_stop_sending_state_size_known() { |
| 1121 |
const SMALL_MAX_DATA: usize = 1024; |
| 1122 |
|
| 1123 |
let mut client = default_client(); |
| 1124 |
let mut server = new_server( |
| 1125 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 1126 |
); |
| 1127 |
|
| 1128 |
connect(&mut client, &mut server); |
| 1129 |
|
| 1130 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 1131 |
assert_eq!( |
| 1132 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1133 |
SMALL_MAX_DATA |
| 1134 |
); |
| 1135 |
|
| 1136 |
// send 1 byte so that the server learns about the stream. |
| 1137 |
assert_eq!( |
| 1138 |
client |
| 1139 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 1140 |
.unwrap(), |
| 1141 |
SMALL_MAX_DATA |
| 1142 |
); |
| 1143 |
|
| 1144 |
let out1 = client.process_output(now()).dgram(); |
| 1145 |
// Delay this packet and let the server receive fin first (it will enter SizeKnown state). |
| 1146 |
client.stream_close_send(stream_id).unwrap(); |
| 1147 |
let out2 = client.process_output(now()).dgram(); |
| 1148 |
|
| 1149 |
server.process_input(out2.unwrap(), now()); |
| 1150 |
|
| 1151 |
server |
| 1152 |
.stream_stop_sending(stream_id, Error::NoError.code()) |
| 1153 |
.unwrap(); |
| 1154 |
|
| 1155 |
// In this case the final size is known when stream_stop_sending is called |
| 1156 |
// and the server releases flow control immediately and sends STOP_SENDING and |
| 1157 |
// MAX_DATA in the same packet. |
| 1158 |
let out = server.process(out1, now()).dgram(); |
| 1159 |
client.process_input(out.unwrap(), now()); |
| 1160 |
|
| 1161 |
// The flow control should have been updated and the client can again send |
| 1162 |
// SMALL_MAX_DATA. |
| 1163 |
let stream_id2 = client.stream_create(StreamType::UniDi).unwrap(); |
| 1164 |
assert_eq!( |
| 1165 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1166 |
SMALL_MAX_DATA |
| 1167 |
); |
| 1168 |
} |
| 1169 |
|
| 1170 |
#[test] |
| 1171 |
fn session_flow_control_stop_sending_state_data_recvd() { |
| 1172 |
const SMALL_MAX_DATA: usize = 1024; |
| 1173 |
|
| 1174 |
let mut client = default_client(); |
| 1175 |
let mut server = new_server( |
| 1176 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 1177 |
); |
| 1178 |
|
| 1179 |
connect(&mut client, &mut server); |
| 1180 |
|
| 1181 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 1182 |
assert_eq!( |
| 1183 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1184 |
SMALL_MAX_DATA |
| 1185 |
); |
| 1186 |
|
| 1187 |
// send 1 byte so that the server learns about the stream. |
| 1188 |
assert_eq!( |
| 1189 |
client |
| 1190 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1]) |
| 1191 |
.unwrap(), |
| 1192 |
SMALL_MAX_DATA |
| 1193 |
); |
| 1194 |
|
| 1195 |
client.stream_close_send(stream_id).unwrap(); |
| 1196 |
|
| 1197 |
exchange_data(&mut client, &mut server); |
| 1198 |
|
| 1199 |
// The stream is DataRecvd state |
| 1200 |
server |
| 1201 |
.stream_stop_sending(stream_id, Error::NoError.code()) |
| 1202 |
.unwrap(); |
| 1203 |
|
| 1204 |
exchange_data(&mut client, &mut server); |
| 1205 |
|
| 1206 |
// The flow control should have been updated and the client can again send |
| 1207 |
// SMALL_MAX_DATA. |
| 1208 |
let stream_id2 = client.stream_create(StreamType::UniDi).unwrap(); |
| 1209 |
assert_eq!( |
| 1210 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1211 |
SMALL_MAX_DATA |
| 1212 |
); |
| 1213 |
} |
| 1214 |
|
| 1215 |
#[test] |
| 1216 |
fn session_flow_control_affects_all_streams() { |
| 1217 |
const SMALL_MAX_DATA: usize = 1024; |
| 1218 |
|
| 1219 |
let mut client = default_client(); |
| 1220 |
let mut server = new_server( |
| 1221 |
ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()), |
| 1222 |
); |
| 1223 |
|
| 1224 |
connect(&mut client, &mut server); |
| 1225 |
|
| 1226 |
let stream_id = client.stream_create(StreamType::UniDi).unwrap(); |
| 1227 |
assert_eq!( |
| 1228 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1229 |
SMALL_MAX_DATA |
| 1230 |
); |
| 1231 |
|
| 1232 |
let stream_id2 = client.stream_create(StreamType::UniDi).unwrap(); |
| 1233 |
assert_eq!( |
| 1234 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1235 |
SMALL_MAX_DATA |
| 1236 |
); |
| 1237 |
|
| 1238 |
assert_eq!( |
| 1239 |
client |
| 1240 |
.stream_send(stream_id, &[b'a'; SMALL_MAX_DATA / 2 + 1]) |
| 1241 |
.unwrap(), |
| 1242 |
SMALL_MAX_DATA / 2 + 1 |
| 1243 |
); |
| 1244 |
|
| 1245 |
assert_eq!( |
| 1246 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1247 |
SMALL_MAX_DATA / 2 - 1 |
| 1248 |
); |
| 1249 |
assert_eq!( |
| 1250 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1251 |
SMALL_MAX_DATA / 2 - 1 |
| 1252 |
); |
| 1253 |
|
| 1254 |
exchange_data(&mut client, &mut server); |
| 1255 |
|
| 1256 |
let mut buf = [0x0; SMALL_MAX_DATA]; |
| 1257 |
let (read, _) = server.stream_recv(stream_id, &mut buf).unwrap(); |
| 1258 |
assert_eq!(read, SMALL_MAX_DATA / 2 + 1); |
| 1259 |
|
| 1260 |
exchange_data(&mut client, &mut server); |
| 1261 |
|
| 1262 |
assert_eq!( |
| 1263 |
client.stream_avail_send_space(stream_id).unwrap(), |
| 1264 |
SMALL_MAX_DATA |
| 1265 |
); |
| 1266 |
|
| 1267 |
assert_eq!( |
| 1268 |
client.stream_avail_send_space(stream_id2).unwrap(), |
| 1269 |
SMALL_MAX_DATA |
| 1270 |
); |
| 1271 |
} |
| 1272 |
|
| 1273 |
fn connect_w_different_limit(bidi_limit: u64, unidi_limit: u64) { |
| 1274 |
let mut client = default_client(); |
| 1275 |
let out = client.process_output(now()); |
| 1276 |
let out2 = client.process_output(now()); |
| 1277 |
let mut server = new_server( |
| 1278 |
ConnectionParameters::default() |
| 1279 |
.max_streams(StreamType::BiDi, bidi_limit) |
| 1280 |
.max_streams(StreamType::UniDi, unidi_limit), |
| 1281 |
); |
| 1282 |
server.process_input(out.dgram().unwrap(), now()); |
| 1283 |
let out = server.process(out2.dgram(), now()); |
| 1284 |
|
| 1285 |
let out = client.process(out.dgram(), now()); |
| 1286 |
let out = server.process(out.dgram(), now()); |
| 1287 |
let out = client.process(out.dgram(), now()); |
| 1288 |
drop(server.process(out.dgram(), now())); |
| 1289 |
|
| 1290 |
assert!(maybe_authenticate(&mut client)); |
| 1291 |
|
| 1292 |
let mut bidi_events = 0; |
| 1293 |
let mut unidi_events = 0; |
| 1294 |
let mut connected_events = 0; |
| 1295 |
for e in client.events() { |
| 1296 |
match e { |
| 1297 |
ConnectionEvent::SendStreamCreatable { stream_type } => { |
| 1298 |
if stream_type == StreamType::BiDi { |
| 1299 |
bidi_events += 1; |
| 1300 |
} else { |
| 1301 |
unidi_events += 1; |
| 1302 |
} |
| 1303 |
} |
| 1304 |
ConnectionEvent::StateChange(State::Connected) => { |
| 1305 |
connected_events += 1; |
| 1306 |
} |
| 1307 |
_ => {} |
| 1308 |
} |
| 1309 |
} |
| 1310 |
assert_eq!(bidi_events, usize::from(bidi_limit > 0)); |
| 1311 |
assert_eq!(unidi_events, usize::from(unidi_limit > 0)); |
| 1312 |
assert_eq!(connected_events, 1); |
| 1313 |
} |
| 1314 |
|
| 1315 |
#[test] |
| 1316 |
fn client_stream_creatable_event() { |
| 1317 |
connect_w_different_limit(0, 0); |
| 1318 |
connect_w_different_limit(0, 1); |
| 1319 |
connect_w_different_limit(1, 0); |
| 1320 |
connect_w_different_limit(1, 1); |
| 1321 |
} |