1use crate::{Error, Result, hpack, http1::Header};
4use std::time::Instant;
5pub const PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
6#[derive(Debug, Clone, Copy, PartialEq, Eq)]
7pub enum Role {
8 Client,
9 Server,
10}
11#[derive(Debug, Clone, Copy)]
12pub struct Limits {
13 pub frame_size: usize,
14 pub header_block: usize,
15 pub header_list: usize,
16 pub continuations: usize,
17 pub streams: usize,
18}
19impl Default for Limits {
20 fn default() -> Self {
21 Self {
22 frame_size: 16384,
23 header_block: 65536,
24 header_list: 32768,
25 continuations: 16,
26 streams: 100,
27 }
28 }
29}
30#[derive(Debug, Clone, Copy)]
31pub struct Frame<'a> {
32 pub kind: u8,
33 pub flags: u8,
34 pub stream: u32,
35 pub payload: &'a [u8],
36}
37fn error(code: &'static str, message: &'static str) -> Error {
38 Error::new(code, message)
39}
40fn protocol(message: &'static str) -> Error {
41 error("PROTOCOL_ERROR", message)
42}
43fn frame_error() -> Error {
44 error("FRAME_SIZE_ERROR", "invalid frame size")
45}
46fn u32be(b: &[u8]) -> u32 {
47 u32::from_be_bytes(b[..4].try_into().unwrap())
48}
49pub fn decode_frame(input: &[u8], max: usize) -> Result<Option<Frame<'_>>> {
50 if input.len() < 9 {
51 return Ok(None);
52 }
53 let len = ((input[0] as usize) << 16) | ((input[1] as usize) << 8) | input[2] as usize;
54 if len > max {
55 return Err(frame_error());
56 }
57 if input.len() < 9 + len {
58 return Ok(None);
59 }
60 Ok(Some(Frame {
61 kind: input[3],
62 flags: input[4],
63 stream: u32be(&input[5..9]) & 0x7fffffff,
64 payload: &input[9..9 + len],
65 }))
66}
67pub fn encode_frame(
68 kind: u8,
69 flags: u8,
70 stream: u32,
71 payload: &[u8],
72 out: &mut Vec<u8>,
73) -> Result<()> {
74 if payload.len() > 0xffffff || stream > 0x7fffffff {
75 return Err(frame_error());
76 }
77 let len = payload.len() as u32;
78 out.extend_from_slice(&len.to_be_bytes()[1..]);
79 out.push(kind);
80 out.push(flags);
81 out.extend_from_slice(&stream.to_be_bytes());
82 out.extend_from_slice(payload);
83 Ok(())
84}
85#[derive(Debug)]
86pub enum Event<'a> {
87 Settings,
88 Headers {
89 stream: u32,
90 headers: Vec<Header>,
91 end_stream: bool,
92 },
93 Data {
94 stream: u32,
95 bytes: &'a [u8],
96 end_stream: bool,
97 },
98 Reset {
99 stream: u32,
100 code: u32,
101 },
102 Goaway {
103 last_stream: u32,
104 code: u32,
105 },
106 Ping {
107 ack: bool,
108 data: [u8; 8],
109 },
110 WindowUpdate {
111 stream: u32,
112 },
113}
114pub struct Step<'a> {
115 pub consumed: usize,
116 pub event: Option<Event<'a>>,
117}
118#[derive(Debug)]
119struct Stream {
120 id: u32,
121 send_window: i64,
122 recv_window: i64,
123 unreleased: u32,
124 local_end: bool,
125 remote_end: bool,
126 received_head: bool,
127 sent_head: bool,
128 recv_length: Option<u64>,
129 received: u64,
130 head_request: bool,
131 recv_no_body: bool,
132 send_no_body: bool,
133 send_length: Option<u64>,
134 sent: u64,
135}
136impl Stream {
137 fn closed(&self) -> bool {
138 self.local_end && self.remote_end
139 }
140}
141pub struct Connection {
142 role: Role,
143 limits: Limits,
144 streams: Vec<Stream>,
145 next_id: u32,
146 last_remote: u32,
147 send_window: i64,
148 recv_window: i64,
149 initial_send: i64,
150 peer_frame: usize,
151 peer_streams: usize,
152 preface: bool,
153 settings_received: bool,
154 settings_awaiting_ack: bool,
155 decoder: hpack::Decoder,
156 encoder: hpack::Encoder,
157 block: Vec<u8>,
158 scratch: Vec<u8>,
159 continuation: Option<(u32, bool, usize)>,
160 output: Vec<u8>,
161 output_pos: usize,
162 draining: bool,
163 failed: bool,
164 settings_deadline: Option<Instant>,
165}
166impl Connection {
167 pub fn new(role: Role, limits: Limits) -> Result<Self> {
168 if !(16384..=0xffffff).contains(&limits.frame_size)
169 || limits.streams == 0
170 || limits.streams > u32::MAX as usize
171 {
172 return Err(protocol("invalid limits"));
173 }
174 let mut result = Self {
175 role,
176 limits,
177 streams: Vec::with_capacity(limits.streams),
178 next_id: if role == Role::Client { 1 } else { 2 },
179 last_remote: 0,
180 send_window: 65535,
181 recv_window: 65535,
182 initial_send: 65535,
183 peer_frame: 16384,
184 peer_streams: usize::MAX,
185 preface: role == Role::Client,
186 settings_received: false,
187 settings_awaiting_ack: true,
188 decoder: hpack::Decoder::new(4096, limits.header_list),
189 encoder: hpack::Encoder::new(4096),
190 block: Vec::new(),
191 scratch: Vec::new(),
192 continuation: None,
193 output: Vec::new(),
194 output_pos: 0,
195 draining: false,
196 failed: false,
197 settings_deadline: None,
198 };
199 if role == Role::Client {
200 result.output.extend_from_slice(PREFACE);
201 }
202 let mut settings = Vec::new();
203 for (id, value) in [
204 (3, limits.streams as u32),
205 (5, limits.frame_size as u32),
206 (6, limits.header_list as u32),
207 ] {
208 settings.extend_from_slice(&(id as u16).to_be_bytes());
209 settings.extend_from_slice(&value.to_be_bytes());
210 }
211 if role == Role::Client {
212 settings.extend_from_slice(&[0, 2, 0, 0, 0, 0]);
213 }
214 result.frame(4, 0, 0, &settings)?;
215 Ok(result)
216 }
217 pub fn set_settings_deadline(&mut self, deadline: Option<Instant>) {
219 self.settings_deadline = deadline;
220 }
221 pub fn next_timeout(&self) -> Option<Instant> {
222 if self.settings_awaiting_ack && !self.failed {
223 self.settings_deadline
224 } else {
225 None
226 }
227 }
228 pub fn handle_timeout(&mut self, now: Instant) -> Option<Error> {
229 if self.next_timeout().is_some_and(|d| d <= now) {
230 self.failed = true;
231 let mut payload = [0; 8];
232 payload[..4].copy_from_slice(&self.last_remote.to_be_bytes());
233 payload[7] = 4;
234 self.frame(7, 0, 0, &payload).expect("fixed-size GOAWAY");
235 Some(error(
236 "SETTINGS_TIMEOUT",
237 "SETTINGS acknowledgement timeout",
238 ))
239 } else {
240 None
241 }
242 }
243 pub fn eof(&mut self) {
245 self.failed = true;
246 }
247 pub fn poll_failed_stream(&mut self) -> Option<u32> {
250 if !self.failed {
251 return None;
252 }
253 let stream = self.streams.iter_mut().find(|s| !s.remote_end)?;
254 stream.local_end = true;
255 stream.remote_end = true;
256 Some(stream.id)
257 }
258 pub fn output(&self) -> &[u8] {
259 &self.output[self.output_pos..]
260 }
261 pub fn consume_output(&mut self, n: usize) -> Result<()> {
262 if n > self.output().len() {
263 return Err(protocol("write acknowledgement exceeds output"));
264 }
265 self.output_pos += n;
266 if self.output_pos == self.output.len() {
267 self.output.clear();
268 self.output_pos = 0;
269 }
270 Ok(())
271 }
272 fn frame(&mut self, kind: u8, flags: u8, id: u32, payload: &[u8]) -> Result<()> {
273 encode_frame(kind, flags, id, payload, &mut self.output)
274 }
275 fn index(&self, id: u32) -> Result<usize> {
276 self.streams
277 .iter()
278 .position(|s| s.id == id)
279 .ok_or(protocol("unknown or idle stream"))
280 }
281 fn active(&self) -> usize {
282 self.streams.iter().filter(|s| !s.closed()).count()
283 }
284 fn add_stream(&mut self, id: u32) -> Result<usize> {
285 if self.active() >= self.limits.streams {
286 return Err(error("REFUSED_STREAM", "stream limit"));
287 }
288 let stream = Stream {
289 id,
290 send_window: self.initial_send,
291 recv_window: 65535,
292 unreleased: 0,
293 local_end: false,
294 remote_end: false,
295 received_head: false,
296 sent_head: false,
297 recv_length: None,
298 received: 0,
299 head_request: false,
300 recv_no_body: false,
301 send_no_body: false,
302 send_length: None,
303 sent: 0,
304 };
305 if let Some(i) = self
306 .streams
307 .iter()
308 .position(|s| s.closed() && s.unreleased == 0)
309 {
310 self.streams[i] = stream;
311 Ok(i)
312 } else {
313 if self.streams.len() >= self.limits.streams {
314 return Err(error(
315 "REFUSED_STREAM",
316 "release consumed capacity before opening streams",
317 ));
318 }
319 self.streams.push(stream);
320 Ok(self.streams.len() - 1)
321 }
322 }
323 pub fn open(&mut self, headers: &[Header], end_stream: bool) -> Result<u32> {
324 if self.role != Role::Client || self.draining || self.failed {
325 return Err(protocol("cannot open stream"));
326 }
327 if self.active() >= self.peer_streams {
328 return Err(error("REFUSED_STREAM", "peer stream limit"));
329 }
330 validate_headers(headers, true, false)?;
331 let id = self.next_id;
332 self.next_id = self
333 .next_id
334 .checked_add(2)
335 .filter(|n| *n <= 0x7fffffff)
336 .ok_or(protocol("stream IDs exhausted"))?;
337 self.add_stream(id)?;
338 self.send_headers(id, headers, end_stream)?;
339 Ok(id)
340 }
341 pub fn send_headers(&mut self, id: u32, headers: &[Header], end_stream: bool) -> Result<()> {
342 if self.failed {
343 return Err(protocol("failed connection"));
344 }
345 let i = self.index(id)?;
346 let s = &self.streams[i];
347 if s.local_end {
348 return Err(error("STREAM_CLOSED", "local stream closed"));
349 }
350 validate_headers(headers, self.role == Role::Client, s.sent_head)?;
351 let informational = headers
352 .iter()
353 .find(|h| h.name == ":status")
354 .is_some_and(|h| h.value.starts_with(b"1"));
355 if informational && end_stream {
356 return Err(protocol("informational END_STREAM"));
357 }
358 if s.sent_head && !end_stream {
359 return Err(protocol("trailers must end stream"));
360 }
361 let no_body = self.role == Role::Server
362 && (s.head_request
363 || headers
364 .iter()
365 .any(|h| h.name == ":status" && matches!(h.value.as_slice(), b"204" | b"304")));
366 let length = if s.sent_head {
367 s.send_length
368 } else if no_body {
369 None
370 } else {
371 content_length(headers)?
372 };
373 if end_stream && length.is_some_and(|n| n != s.sent) {
374 return Err(protocol("outgoing content-length mismatch"));
375 }
376 self.scratch.clear();
377 self.encoder.encode(headers, &mut self.scratch);
378 let count = self.scratch.len().max(1).div_ceil(self.peer_frame);
379 for n in 0..count {
380 let start = n * self.peer_frame;
381 let end = (start + self.peer_frame).min(self.scratch.len());
382 let flags =
383 if n + 1 == count { 4 } else { 0 } | if n == 0 && end_stream { 1 } else { 0 };
384 encode_frame(
385 if n == 0 { 1 } else { 9 },
386 flags,
387 id,
388 &self.scratch[start..end],
389 &mut self.output,
390 )?;
391 }
392 let s = &mut self.streams[i];
393 s.sent_head |= !informational;
394 s.send_no_body = no_body;
395 s.send_length = length;
396 s.local_end = end_stream;
397 if self.role == Role::Client {
398 s.head_request = headers
399 .iter()
400 .any(|h| h.name == ":method" && h.value == b"HEAD");
401 }
402 Ok(())
403 }
404 pub fn send_data(&mut self, id: u32, bytes: &[u8], end_stream: bool) -> Result<usize> {
406 let i = self.index(id)?;
407 let s = &self.streams[i];
408 if self.failed || s.local_end || !s.sent_head {
409 return Err(error("STREAM_CLOSED", "cannot send DATA"));
410 }
411 let n = bytes
412 .len()
413 .min(self.peer_frame)
414 .min(self.send_window.max(0) as usize)
415 .min(s.send_window.max(0) as usize);
416 if n == 0 && !bytes.is_empty() {
417 return Ok(0);
418 }
419 let end = end_stream && n == bytes.len();
420 if s.send_no_body && !bytes.is_empty() {
421 return Err(protocol("DATA on bodyless response"));
422 }
423 if s.send_length.is_some_and(|length| {
424 s.sent + n as u64 > length || (end && s.sent + n as u64 != length)
425 }) {
426 return Err(protocol("outgoing content-length mismatch"));
427 }
428 self.frame(0, u8::from(end), id, &bytes[..n])?;
429 self.send_window -= n as i64;
430 let s = &mut self.streams[i];
431 s.send_window -= n as i64;
432 s.sent += n as u64;
433 s.local_end = end;
434 Ok(n)
435 }
436 pub fn release_capacity(&mut self, id: u32, n: u32) -> Result<()> {
437 let i = self.index(id)?;
438 if n == 0 {
439 return Ok(());
440 }
441 let s = &mut self.streams[i];
442 if n > s.unreleased {
443 return Err(protocol("capacity exceeds received DATA"));
444 }
445 s.unreleased -= n;
446 s.recv_window += n as i64;
447 self.recv_window += n as i64;
448 self.frame(8, 0, 0, &n.to_be_bytes())?;
449 if !self.streams[i].remote_end {
450 self.frame(8, 0, id, &n.to_be_bytes())?;
451 }
452 Ok(())
453 }
454 pub fn reset(&mut self, id: u32, code: u32) -> Result<()> {
455 let i = self.index(id)?;
456 self.streams[i].local_end = true;
457 self.streams[i].remote_end = true;
458 self.frame(3, 0, id, &code.to_be_bytes())
459 }
460 pub fn ping(&mut self, data: [u8; 8]) -> Result<()> {
461 self.frame(6, 0, 0, &data)
462 }
463 pub fn shutdown(&mut self) -> Result<()> {
464 self.draining = true;
465 let mut bytes = [0; 8];
466 bytes[..4].copy_from_slice(&self.last_remote.to_be_bytes());
467 self.frame(7, 0, 0, &bytes)
468 }
469 pub fn is_drained(&self) -> bool {
470 self.draining && self.active() == 0 && self.output().is_empty()
471 }
472 pub fn receive<'a>(&mut self, input: &'a [u8]) -> Result<Step<'a>> {
473 if self.failed {
474 return Err(protocol("failed connection"));
475 }
476 let result = self.receive_inner(input);
477 if let Err(e) = &result {
478 self.failed = true;
479 let code = match e.code {
480 "FLOW_CONTROL_ERROR" => 3,
481 "FRAME_SIZE_ERROR" => 6,
482 "COMPRESSION_ERROR" => 9,
483 "ENHANCE_YOUR_CALM" => 11,
484 _ => 1,
485 };
486 let mut payload = [0; 8];
487 payload[..4].copy_from_slice(&self.last_remote.to_be_bytes());
488 payload[4..].copy_from_slice(&(code as u32).to_be_bytes());
489 self.frame(7, 0, 0, &payload)?;
490 }
491 result
492 }
493 fn receive_inner<'a>(&mut self, input: &'a [u8]) -> Result<Step<'a>> {
494 if !self.preface {
495 let n = input.len().min(PREFACE.len());
496 if input[..n] != PREFACE[..n] {
497 return Err(protocol("invalid client preface"));
498 }
499 if n < PREFACE.len() {
500 return Ok(Step {
501 consumed: 0,
502 event: None,
503 });
504 }
505 self.preface = true;
506 return Ok(Step {
507 consumed: PREFACE.len(),
508 event: None,
509 });
510 }
511 let Some(f) = decode_frame(input, self.limits.frame_size)? else {
512 return Ok(Step {
513 consumed: 0,
514 event: None,
515 });
516 };
517 if !self.settings_received && (f.kind != 4 || f.flags & 1 != 0) {
518 return Err(protocol("first frame must be SETTINGS"));
519 }
520 if let Some((id, _, _)) = self.continuation {
521 if f.kind != 9 || f.stream != id {
522 return Err(protocol("interleaved header block"));
523 }
524 } else if f.kind == 9 {
525 return Err(protocol("unexpected CONTINUATION"));
526 }
527 let mut step = Step {
528 consumed: 9 + f.payload.len(),
529 event: None,
530 };
531 match f.kind {
532 0 => {
533 if f.stream == 0 {
534 return Err(protocol("DATA on connection"));
535 }
536 let i = self.index(f.stream)?;
537 let s = &mut self.streams[i];
538 if s.remote_end || !s.received_head {
539 return Err(protocol("DATA in invalid stream state"));
540 }
541 let payload = unpadded(f)?;
542 let flow = f.payload.len() as i64;
543 if flow > self.recv_window || flow > s.recv_window {
544 return Err(error("FLOW_CONTROL_ERROR", "receive window exceeded"));
545 }
546 self.recv_window -= flow;
547 s.recv_window -= flow;
548 s.unreleased += flow as u32;
549 s.received += payload.len() as u64;
550 let end = f.flags & 1 != 0;
551 if s.recv_no_body && !payload.is_empty() {
552 return Err(protocol("DATA on bodyless response"));
553 }
554 if s.recv_length
555 .is_some_and(|n| s.received > n || (end && n != s.received))
556 {
557 return Err(protocol("content-length mismatch"));
558 }
559 s.remote_end = end;
560 let padding = f.payload.len() - payload.len();
562 if padding > 0 {
563 self.release_capacity(f.stream, padding as u32)?;
564 }
565 step.event = Some(Event::Data {
566 stream: f.stream,
567 bytes: payload,
568 end_stream: end,
569 });
570 }
571 1 => {
572 if f.stream == 0 {
573 return Err(protocol("HEADERS on connection"));
574 }
575 if self.index(f.stream).is_err() {
576 if self.role != Role::Server
577 || f.stream % 2 == 0
578 || f.stream <= self.last_remote
579 || self.draining
580 {
581 return Err(protocol("invalid new stream"));
582 }
583 self.last_remote = f.stream;
584 self.add_stream(f.stream)?;
585 }
586 let mut payload = unpadded(f)?;
587 if f.flags & 32 != 0 {
588 if payload.len() < 5 {
589 return Err(frame_error());
590 }
591 if u32be(payload) & 0x7fffffff == f.stream {
592 return Err(protocol("stream depends on itself"));
593 }
594 payload = &payload[5..];
595 }
596 self.block.clear();
597 self.append_block(payload)?;
598 let end = f.flags & 1 != 0;
599 if f.flags & 4 != 0 {
600 step.event = Some(self.finish_headers(f.stream, end)?);
601 } else {
602 self.continuation = Some((f.stream, end, 0));
603 }
604 }
605 9 => {
606 let (id, end, count) = self.continuation.unwrap();
607 if count >= self.limits.continuations {
608 return Err(error("ENHANCE_YOUR_CALM", "CONTINUATION limit"));
609 }
610 self.append_block(f.payload)?;
611 if f.flags & 4 != 0 {
612 self.continuation = None;
613 step.event = Some(self.finish_headers(id, end)?);
614 } else {
615 self.continuation = Some((id, end, count + 1));
616 }
617 }
618 2 => {
619 if f.stream == 0 {
620 return Err(protocol("PRIORITY on connection"));
621 }
622 if f.payload.len() != 5 {
623 return Err(frame_error());
624 }
625 if u32be(f.payload) & 0x7fffffff == f.stream {
626 return Err(protocol("stream depends on itself"));
627 }
628 }
629 3 => {
630 if f.stream == 0 {
631 return Err(protocol("RST_STREAM on connection"));
632 }
633 if f.payload.len() != 4 {
634 return Err(frame_error());
635 }
636 let i = self.index(f.stream)?;
637 self.streams[i].remote_end = true;
638 self.streams[i].local_end = true;
639 step.event = Some(Event::Reset {
640 stream: f.stream,
641 code: u32be(f.payload),
642 });
643 }
644 4 => {
645 if f.stream != 0 {
646 return Err(protocol("SETTINGS on stream"));
647 }
648 if f.flags & 1 != 0 {
649 if !f.payload.is_empty() {
650 return Err(frame_error());
651 }
652 if !self.settings_awaiting_ack {
653 return Err(protocol("unsolicited SETTINGS ack"));
654 }
655 self.settings_awaiting_ack = false;
656 } else {
657 if f.payload.len() % 6 != 0 {
658 return Err(frame_error());
659 }
660 for setting in f.payload.as_chunks::<6>().0 {
661 let id = u16::from_be_bytes(setting[..2].try_into().unwrap());
662 let value = u32be(&setting[2..]);
663 match id {
664 1 => self.encoder.set_table_size((value as usize).min(4096)),
665 2 => {
666 if value > 1 || self.role == Role::Client {
667 return Err(protocol("invalid ENABLE_PUSH"));
668 }
669 }
670 3 => self.peer_streams = value as usize,
671 4 => {
672 if value > 0x7fffffff {
673 return Err(error(
674 "FLOW_CONTROL_ERROR",
675 "invalid initial window",
676 ));
677 }
678 let delta = value as i64 - self.initial_send;
679 for s in &mut self.streams {
680 if s.send_window + delta > 0x7fffffff {
681 return Err(error("FLOW_CONTROL_ERROR", "window overflow"));
682 }
683 s.send_window += delta;
684 }
685 self.initial_send = value as i64;
686 }
687 5 => {
688 if !(16384..=0xffffff).contains(&value) {
689 return Err(protocol("invalid MAX_FRAME_SIZE"));
690 }
691 self.peer_frame = value as usize;
692 }
693 _ => {}
694 }
695 }
696 self.settings_received = true;
697 self.frame(4, 1, 0, &[])?;
698 step.event = Some(Event::Settings);
699 }
700 }
701 5 => return Err(protocol("server push disabled")),
702 6 => {
703 if f.stream != 0 {
704 return Err(protocol("PING on stream"));
705 }
706 if f.payload.len() != 8 {
707 return Err(frame_error());
708 }
709 let data = f.payload.try_into().unwrap();
710 let ack = f.flags & 1 != 0;
711 if !ack {
712 self.frame(6, 1, 0, f.payload)?;
713 }
714 step.event = Some(Event::Ping { ack, data });
715 }
716 7 => {
717 if f.stream != 0 {
718 return Err(protocol("GOAWAY on stream"));
719 }
720 if f.payload.len() < 8 {
721 return Err(frame_error());
722 }
723 self.draining = true;
724 step.event = Some(Event::Goaway {
725 last_stream: u32be(f.payload) & 0x7fffffff,
726 code: u32be(&f.payload[4..]),
727 });
728 }
729 8 => {
730 if f.payload.len() != 4 {
731 return Err(frame_error());
732 }
733 let n = (u32be(f.payload) & 0x7fffffff) as i64;
734 if n == 0 {
735 if f.stream != 0 {
736 self.reset(f.stream, 1)?;
737 step.event = Some(Event::Reset {
738 stream: f.stream,
739 code: 1,
740 });
741 return Ok(step);
742 }
743 return Err(protocol("zero WINDOW_UPDATE"));
744 }
745 let window = if f.stream == 0 {
746 &mut self.send_window
747 } else {
748 let i = self.index(f.stream)?;
749 &mut self.streams[i].send_window
750 };
751 if *window + n > 0x7fffffff {
752 if f.stream != 0 {
753 self.reset(f.stream, 3)?;
754 step.event = Some(Event::Reset {
755 stream: f.stream,
756 code: 3,
757 });
758 return Ok(step);
759 }
760 return Err(error("FLOW_CONTROL_ERROR", "window overflow"));
761 }
762 *window += n;
763 step.event = Some(Event::WindowUpdate { stream: f.stream });
764 }
765 _ => {}
766 }
767 Ok(step)
768 }
769 fn append_block(&mut self, bytes: &[u8]) -> Result<()> {
770 if bytes.len() > self.limits.header_block.saturating_sub(self.block.len()) {
771 return Err(error("ENHANCE_YOUR_CALM", "compressed header block limit"));
772 }
773 self.block.extend_from_slice(bytes);
774 Ok(())
775 }
776 fn finish_headers(&mut self, id: u32, end: bool) -> Result<Event<'static>> {
777 let mut headers = Vec::new();
778 self.decoder.decode(&self.block, &mut headers)?;
779 let i = self.index(id)?;
780 let s = &mut self.streams[i];
781 if s.remote_end {
782 return Err(error("STREAM_CLOSED", "headers after END_STREAM"));
783 }
784 validate_headers(&headers, self.role == Role::Server, s.received_head)?;
785 let informational = headers
786 .iter()
787 .find(|h| h.name == ":status")
788 .is_some_and(|h| h.value.starts_with(b"1"));
789 if informational && end {
790 return Err(protocol("informational END_STREAM"));
791 }
792 if s.received_head && !end {
793 return Err(protocol("trailers without END_STREAM"));
794 }
795 if !s.received_head && !informational {
796 s.recv_no_body = self.role == Role::Client
797 && (s.head_request
798 || headers.iter().any(|h| {
799 h.name == ":status" && matches!(h.value.as_slice(), b"204" | b"304")
800 }));
801 s.recv_length = if s.recv_no_body {
802 None
803 } else {
804 content_length(&headers)?
805 };
806 if self.role == Role::Server {
807 s.head_request = headers
808 .iter()
809 .any(|h| h.name == ":method" && h.value == b"HEAD");
810 }
811 s.received_head = true;
812 }
813 if end && s.recv_length.is_some_and(|n| n != s.received) {
814 return Err(protocol("content-length mismatch"));
815 }
816 s.remote_end = end;
817 Ok(Event::Headers {
818 stream: id,
819 headers,
820 end_stream: end,
821 })
822 }
823}
824fn unpadded(f: Frame<'_>) -> Result<&[u8]> {
825 if f.flags & 8 == 0 {
826 return Ok(f.payload);
827 }
828 let pad = *f.payload.first().ok_or_else(frame_error)? as usize;
829 if pad >= f.payload.len() {
830 return Err(protocol("invalid padding"));
831 }
832 Ok(&f.payload[1..f.payload.len() - pad])
833}
834fn content_length(headers: &[Header]) -> Result<Option<u64>> {
835 let mut found = None;
836 for h in headers {
837 if h.name == "content-length" {
838 if found.is_some() || h.value.is_empty() || !h.value.iter().all(u8::is_ascii_digit) {
839 return Err(protocol("invalid content-length"));
840 }
841 found = Some(
842 h.value
843 .iter()
844 .try_fold(0u64, |n, b| {
845 n.checked_mul(10)?.checked_add((b - b'0') as u64)
846 })
847 .ok_or(protocol("content-length overflow"))?,
848 );
849 }
850 }
851 Ok(found)
852}
853fn validate_headers(headers: &[Header], request: bool, trailers: bool) -> Result<()> {
854 let mut regular = false;
855 let mut pseudo = [false; 5];
856 for h in headers {
857 if h.name.is_empty()
858 || h.name.bytes().any(|b| b.is_ascii_uppercase())
859 || h.value.iter().any(|b| matches!(b, 0 | 10 | 13))
860 || h.value.first().is_some_and(|b| matches!(b, b' ' | b'\t'))
861 || h.value.last().is_some_and(|b| matches!(b, b' ' | b'\t'))
862 {
863 return Err(protocol("invalid header field"));
864 }
865 if h.name.starts_with(':') {
866 if regular || trailers {
867 return Err(protocol("pseudo-header ordering"));
868 }
869 let index = match h.name.as_str() {
870 ":method" if request => 0,
871 ":scheme" if request => 1,
872 ":path" if request => 2,
873 ":authority" if request => 3,
874 ":status" if !request => 4,
875 _ => return Err(protocol("invalid pseudo-header")),
876 };
877 if pseudo[index] {
878 return Err(protocol("duplicate pseudo-header"));
879 }
880 pseudo[index] = true;
881 } else {
882 regular = true;
883 if !crate::http1::valid_token(h.name.as_bytes()) {
884 return Err(protocol("invalid header name"));
885 }
886 if matches!(
887 h.name.as_str(),
888 "connection" | "proxy-connection" | "keep-alive" | "transfer-encoding" | "upgrade"
889 ) || h.name == "te" && h.value != b"trailers"
890 {
891 return Err(protocol("connection-specific field"));
892 }
893 }
894 }
895 if !trailers {
896 if request {
897 let connect = headers
898 .iter()
899 .any(|h| h.name == ":method" && h.value == b"CONNECT");
900 if !pseudo[0]
901 || if connect {
902 !pseudo[3] || pseudo[1] || pseudo[2]
903 } else {
904 !pseudo[1]
905 || !pseudo[2]
906 || headers
907 .iter()
908 .any(|h| h.name == ":path" && h.value.is_empty())
909 }
910 {
911 return Err(protocol("missing request pseudo-header"));
912 }
913 } else {
914 let Some(status) = headers.iter().find(|h| h.name == ":status") else {
915 return Err(protocol("missing status"));
916 };
917 if status.value.len() != 3
918 || !status.value.iter().all(u8::is_ascii_digit)
919 || status.value.as_slice() < b"100".as_slice()
920 || status.value == b"101"
921 {
922 return Err(protocol("invalid status"));
923 }
924 }
925 }
926 if trailers && headers.iter().any(|h| h.name == "content-length") {
927 return Err(protocol("content-length in trailers"));
928 }
929 content_length(headers)?;
930 Ok(())
931}