Skip to main content

turnloop_http/
http2.rs

1//! RFC 9113 connection/stream framing. Caller retains partial frames and acknowledges
2//! writes. DATA is borrowed, flow-control credit is returned explicitly by the host.
3use 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    /// Host-supplied SETTINGS acknowledgement deadline; no clock is sampled.
218    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    /// Notify transport loss, then call `poll_failed_stream` until exhausted.
244    pub fn eof(&mut self) {
245        self.failed = true;
246    }
247    /// Exactly one terminal result for each still-open stream after connection failure.
248    /// Fully ended/reset streams have already produced their terminal event.
249    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    /// Returns accepted bytes (zero on flow-control stall). Host retains remainder.
405    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                // Padding is consumed by the protocol, never charged to the application.
561                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}