hyper/proto/h1/
decode.rs

Help
1use std::error::Error as StdError;
2use std::fmt;
3use std::io;
4use std::usize;
5
6use bytes::Bytes;
7use tracing::{debug, trace};
8
9use crate::common::{task, Poll};
10
11use super::io::MemRead;
12use super::DecodedLength;
13
14use self::Kind::{Chunked, Eof, Length};
15
16/// Decoders to handle different Transfer-Encodings.
17///
18/// If a message body does not include a Transfer-Encoding, it *should*
19/// include a Content-Length header.
20#[derive(Clone, PartialEq)]
21pub(crate) struct Decoder {
22    kind: Kind,
23}
24
25#[derive(Debug, Clone, Copy, PartialEq)]
26enum Kind {
27    /// A Reader used when a Content-Length header is passed with a positive integer.
28    Length(u64),
29    /// A Reader used when Transfer-Encoding is `chunked`.
30    Chunked(ChunkedState, u64),
31    /// A Reader used for responses that don't indicate a length or chunked.
32    ///
33    /// The bool tracks when EOF is seen on the transport.
34    ///
35    /// Note: This should only used for `Response`s. It is illegal for a
36    /// `Request` to be made with both `Content-Length` and
37    /// `Transfer-Encoding: chunked` missing, as explained from the spec:
38    ///
39    /// > If a Transfer-Encoding header field is present in a response and
40    /// > the chunked transfer coding is not the final encoding, the
41    /// > message body length is determined by reading the connection until
42    /// > it is closed by the server.  If a Transfer-Encoding header field
43    /// > is present in a request and the chunked transfer coding is not
44    /// > the final encoding, the message body length cannot be determined
45    /// > reliably; the server MUST respond with the 400 (Bad Request)
46    /// > status code and then close the connection.
47    Eof(bool),
48}
49
50#[derive(Debug, PartialEq, Clone, Copy)]
51enum ChunkedState {
52    Size,
53    SizeLws,
54    Extension,
55    SizeLf,
56    Body,
57    BodyCr,
58    BodyLf,
59    Trailer,
60    TrailerLf,
61    EndCr,
62    EndLf,
63    End,
64}
65
66impl Decoder {
67    // constructors
68
69    pub(crate) fn length(x: u64) -> Decoder {
70        Decoder {
71            kind: Kind::Length(x),
72        }
73    }
74
75    pub(crate) fn chunked() -> Decoder {
76        Decoder {
77            kind: Kind::Chunked(ChunkedState::Size, 0),
78        }
79    }
80
81    pub(crate) fn eof() -> Decoder {
82        Decoder {
83            kind: Kind::Eof(false),
84        }
85    }
86
87    pub(super) fn new(len: DecodedLength) -> Self {
88        match len {
89            DecodedLength::CHUNKED => Decoder::chunked(),
90            DecodedLength::CLOSE_DELIMITED => Decoder::eof(),
91            length => Decoder::length(length.danger_len()),
92        }
93    }
94
95    // methods
96
97    pub(crate) fn is_eof(&self) -> bool {
98        matches!(self.kind, Length(0) | Chunked(ChunkedState::End, _) | Eof(true))
99    }
100
101    pub(crate) fn decode<R: MemRead>(
102        &mut self,
103        cx: &mut task::Context<'_>,
104        body: &mut R,
105    ) -> Poll<Result<Bytes, io::Error>> {
106        trace!("decode; state={:?}", self.kind);
107        match self.kind {
108            Length(ref mut remaining) => {
109                if *remaining == 0 {
110                    Poll::Ready(Ok(Bytes::new()))
111                } else {
112                    let to_read = *remaining as usize;
113                    let buf = ready!(body.read_mem(cx, to_read))?;
114                    let num = buf.as_ref().len() as u64;
115                    if num > *remaining {
116                        *remaining = 0;
117                    } else if num == 0 {
118                        return Poll::Ready(Err(io::Error::new(
119                            io::ErrorKind::UnexpectedEof,
120                            IncompleteBody,
121                        )));
122                    } else {
123                        *remaining -= num;
124                    }
125                    Poll::Ready(Ok(buf))
126                }
127            }
128            Chunked(ref mut state, ref mut size) => {
129                loop {
130                    let mut buf = None;
131                    // advances the chunked state
132                    *state = ready!(state.step(cx, body, size, &mut buf))?;
133                    if *state == ChunkedState::End {
134                        trace!("end of chunked");
135                        return Poll::Ready(Ok(Bytes::new()));
136                    }
137                    if let Some(buf) = buf {
138                        return Poll::Ready(Ok(buf));
139                    }
140                }
141            }
142            Eof(ref mut is_eof) => {
143                if *is_eof {
144                    Poll::Ready(Ok(Bytes::new()))
145                } else {
146                    // 8192 chosen because its about 2 packets, there probably
147                    // won't be that much available, so don't have MemReaders
148                    // allocate buffers to big
149                    body.read_mem(cx, 8192).map_ok(|slice| {
150                        *is_eof = slice.is_empty();
151                        slice
152                    })
153                }
154            }
155        }
156    }
157
158    #[cfg(test)]
159    async fn decode_fut<R: MemRead>(&mut self, body: &mut R) -> Result<Bytes, io::Error> {
160        futures_util::future::poll_fn(move |cx| self.decode(cx, body)).await
161    }
162}
163
164impl fmt::Debug for Decoder {
165    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
166        fmt::Debug::fmt(&self.kind, f)
167    }
168}
169
170macro_rules! byte (
171    ($rdr:ident, $cx:expr) => ({
172        let buf = ready!($rdr.read_mem($cx, 1))?;
173        if !buf.is_empty() {
174            buf[0]
175        } else {
176            return Poll::Ready(Err(io::Error::new(io::ErrorKind::UnexpectedEof,
177                                      "unexpected EOF during chunk size line")));
178        }
179    })
180);
181
182impl ChunkedState {
183    fn step<R: MemRead>(
184        &self,
185        cx: &mut task::Context<'_>,
186        body: &mut R,
187        size: &mut u64,
188        buf: &mut Option<Bytes>,
189    ) -> Poll<Result<ChunkedState, io::Error>> {
190        use self::ChunkedState::*;
191        match *self {
192            Size => ChunkedState::read_size(cx, body, size),
193            SizeLws => ChunkedState::read_size_lws(cx, body),
194            Extension => ChunkedState::read_extension(cx, body),
195            SizeLf => ChunkedState::read_size_lf(cx, body, *size),
196            Body => ChunkedState::read_body(cx, body, size, buf),
197            BodyCr => ChunkedState::read_body_cr(cx, body),
198            BodyLf => ChunkedState::read_body_lf(cx, body),
199            Trailer => ChunkedState::read_trailer(cx, body),
200            TrailerLf => ChunkedState::read_trailer_lf(cx, body),
201            EndCr => ChunkedState::read_end_cr(cx, body),
202            EndLf => ChunkedState::read_end_lf(cx, body),
203            End => Poll::Ready(Ok(ChunkedState::End)),
204        }
205    }
206    fn read_size<R: MemRead>(
207        cx: &mut task::Context<'_>,
208        rdr: &mut R,
209        size: &mut u64,
210    ) -> Poll<Result<ChunkedState, io::Error>> {
211        trace!("Read chunk hex size");
212
213        macro_rules! or_overflow {
214            ($e:expr) => (
215                match $e {
216                    Some(val) => val,
217                    None => return Poll::Ready(Err(io::Error::new(
218                        io::ErrorKind::InvalidData,
219                        "invalid chunk size: overflow",
220                    ))),
221                }
222            )
223        }
224
225        let radix = 16;
226        match byte!(rdr, cx) {
227            b @ b'0'..=b'9' => {
228                *size = or_overflow!(size.checked_mul(radix));
229                *size = or_overflow!(size.checked_add((b - b'0') as u64));
230            }
231            b @ b'a'..=b'f' => {
232                *size = or_overflow!(size.checked_mul(radix));
233                *size = or_overflow!(size.checked_add((b + 10 - b'a') as u64));
234            }
235            b @ b'A'..=b'F' => {
236                *size = or_overflow!(size.checked_mul(radix));
237                *size = or_overflow!(size.checked_add((b + 10 - b'A') as u64));
238            }
239            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
240            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
241            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
242            _ => {
243                return Poll::Ready(Err(io::Error::new(
244                    io::ErrorKind::InvalidInput,
245                    "Invalid chunk size line: Invalid Size",
246                )));
247            }
248        }
249        Poll::Ready(Ok(ChunkedState::Size))
250    }
251    fn read_size_lws<R: MemRead>(
252        cx: &mut task::Context<'_>,
253        rdr: &mut R,
254    ) -> Poll<Result<ChunkedState, io::Error>> {
255        trace!("read_size_lws");
256        match byte!(rdr, cx) {
257            // LWS can follow the chunk size, but no more digits can come
258            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
259            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
260            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
261            _ => Poll::Ready(Err(io::Error::new(
262                io::ErrorKind::InvalidInput,
263                "Invalid chunk size linear white space",
264            ))),
265        }
266    }
267    fn read_extension<R: MemRead>(
268        cx: &mut task::Context<'_>,
269        rdr: &mut R,
270    ) -> Poll<Result<ChunkedState, io::Error>> {
271        trace!("read_extension");
272        // We don't care about extensions really at all. Just ignore them.
273        // They "end" at the next CRLF.
274        //
275        // However, some implementations may not check for the CR, so to save
276        // them from themselves, we reject extensions containing plain LF as
277        // well.
278        match byte!(rdr, cx) {
279            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
280            b'\n' => Poll::Ready(Err(io::Error::new(
281                io::ErrorKind::InvalidData,
282                "invalid chunk extension contains newline",
283            ))),
284            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
285        }
286    }
287    fn read_size_lf<R: MemRead>(
288        cx: &mut task::Context<'_>,
289        rdr: &mut R,
290        size: u64,
291    ) -> Poll<Result<ChunkedState, io::Error>> {
292        trace!("Chunk size is {:?}", size);
293        match byte!(rdr, cx) {
294            b'\n' => {
295                if size == 0 {
296                    Poll::Ready(Ok(ChunkedState::EndCr))
297                } else {
298                    debug!("incoming chunked header: {0:#X} ({0} bytes)", size);
299                    Poll::Ready(Ok(ChunkedState::Body))
300                }
301            }
302            _ => Poll::Ready(Err(io::Error::new(
303                io::ErrorKind::InvalidInput,
304                "Invalid chunk size LF",
305            ))),
306        }
307    }
308
309    fn read_body<R: MemRead>(
310        cx: &mut task::Context<'_>,
311        rdr: &mut R,
312        rem: &mut u64,
313        buf: &mut Option<Bytes>,
314    ) -> Poll<Result<ChunkedState, io::Error>> {
315        trace!("Chunked read, remaining={:?}", rem);
316
317        // cap remaining bytes at the max capacity of usize
318        let rem_cap = match *rem {
319            r if r > usize::MAX as u64 => usize::MAX,
320            r => r as usize,
321        };
322
323        let to_read = rem_cap;
324        let slice = ready!(rdr.read_mem(cx, to_read))?;
325        let count = slice.len();
326
327        if count == 0 {
328            *rem = 0;
329            return Poll::Ready(Err(io::Error::new(
330                io::ErrorKind::UnexpectedEof,
331                IncompleteBody,
332            )));
333        }
334        *buf = Some(slice);
335        *rem -= count as u64;
336
337        if *rem > 0 {
338            Poll::Ready(Ok(ChunkedState::Body))
339        } else {
340            Poll::Ready(Ok(ChunkedState::BodyCr))
341        }
342    }
343    fn read_body_cr<R: MemRead>(
344        cx: &mut task::Context<'_>,
345        rdr: &mut R,
346    ) -> Poll<Result<ChunkedState, io::Error>> {
347        match byte!(rdr, cx) {
348            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
349            _ => Poll::Ready(Err(io::Error::new(
350                io::ErrorKind::InvalidInput,
351                "Invalid chunk body CR",
352            ))),
353        }
354    }
355    fn read_body_lf<R: MemRead>(
356        cx: &mut task::Context<'_>,
357        rdr: &mut R,
358    ) -> Poll<Result<ChunkedState, io::Error>> {
359        match byte!(rdr, cx) {
360            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
361            _ => Poll::Ready(Err(io::Error::new(
362                io::ErrorKind::InvalidInput,
363                "Invalid chunk body LF",
364            ))),
365        }
366    }
367
368    fn read_trailer<R: MemRead>(
369        cx: &mut task::Context<'_>,
370        rdr: &mut R,
371    ) -> Poll<Result<ChunkedState, io::Error>> {
372        trace!("read_trailer");
373        match byte!(rdr, cx) {
374            b'\r' => Poll::Ready(Ok(ChunkedState::TrailerLf)),
375            _ => Poll::Ready(Ok(ChunkedState::Trailer)),
376        }
377    }
378    fn read_trailer_lf<R: MemRead>(
379        cx: &mut task::Context<'_>,
380        rdr: &mut R,
381    ) -> Poll<Result<ChunkedState, io::Error>> {
382        match byte!(rdr, cx) {
383            b'\n' => Poll::Ready(Ok(ChunkedState::EndCr)),
384            _ => Poll::Ready(Err(io::Error::new(
385                io::ErrorKind::InvalidInput,
386                "Invalid trailer end LF",
387            ))),
388        }
389    }
390
391    fn read_end_cr<R: MemRead>(
392        cx: &mut task::Context<'_>,
393        rdr: &mut R,
394    ) -> Poll<Result<ChunkedState, io::Error>> {
395        match byte!(rdr, cx) {
396            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
397            _ => Poll::Ready(Ok(ChunkedState::Trailer)),
398        }
399    }
400    fn read_end_lf<R: MemRead>(
401        cx: &mut task::Context<'_>,
402        rdr: &mut R,
403    ) -> Poll<Result<ChunkedState, io::Error>> {
404        match byte!(rdr, cx) {
405            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
406            _ => Poll::Ready(Err(io::Error::new(
407                io::ErrorKind::InvalidInput,
408                "Invalid chunk end LF",
409            ))),
410        }
411    }
412}
413
414#[derive(Debug)]
415struct IncompleteBody;
416
417impl fmt::Display for IncompleteBody {
418    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
419        write!(f, "end of file before message length reached")
420    }
421}
422
423impl StdError for IncompleteBody {}
424
425#[cfg(test)]
426mod tests {
427    use super::*;
428    use std::pin::Pin;
429    use std::time::Duration;
430    use tokio::io::{AsyncRead, ReadBuf};
431
432    impl<'a> MemRead for &'a [u8] {
433        fn read_mem(&mut self, _: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
434            let n = std::cmp::min(len, self.len());
435            if n > 0 {
436                let (a, b) = self.split_at(n);
437                let buf = Bytes::copy_from_slice(a);
438                *self = b;
439                Poll::Ready(Ok(buf))
440            } else {
441                Poll::Ready(Ok(Bytes::new()))
442            }
443        }
444    }
445
446    impl<'a> MemRead for &'a mut (dyn AsyncRead + Unpin) {
447        fn read_mem(&mut self, cx: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
448            let mut v = vec![0; len];
449            let mut buf = ReadBuf::new(&mut v);
450            ready!(Pin::new(self).poll_read(cx, &mut buf)?);
451            Poll::Ready(Ok(Bytes::copy_from_slice(&buf.filled())))
452        }
453    }
454
455    #[cfg(feature = "nightly")]
456    impl MemRead for Bytes {
457        fn read_mem(&mut self, _: &mut task::Context<'_>, len: usize) -> Poll<io::Result<Bytes>> {
458            let n = std::cmp::min(len, self.len());
459            let ret = self.split_to(n);
460            Poll::Ready(Ok(ret))
461        }
462    }
463
464    /*
465    use std::io;
466    use std::io::Write;
467    use super::Decoder;
468    use super::ChunkedState;
469    use futures::{Async, Poll};
470    use bytes::{BytesMut, Bytes};
471    use crate::mock::AsyncIo;
472    */
473
474    #[tokio::test]
475    async fn test_read_chunk_size() {
476        use std::io::ErrorKind::{InvalidData, InvalidInput, UnexpectedEof};
477
478        async fn read(s: &str) -> u64 {
479            let mut state = ChunkedState::Size;
480            let rdr = &mut s.as_bytes();
481            let mut size = 0;
482            loop {
483                let result =
484                    futures_util::future::poll_fn(|cx| state.step(cx, rdr, &mut size, &mut None))
485                        .await;
486                let desc = format!("read_size failed for {:?}", s);
487                state = result.expect(desc.as_str());
488                if state == ChunkedState::Body || state == ChunkedState::EndCr {
489                    break;
490                }
491            }
492            size
493        }
494
495        async fn read_err(s: &str, expected_err: io::ErrorKind) {
496            let mut state = ChunkedState::Size;
497            let rdr = &mut s.as_bytes();
498            let mut size = 0;
499            loop {
500                let result =
501                    futures_util::future::poll_fn(|cx| state.step(cx, rdr, &mut size, &mut None))
502                        .await;
503                state = match result {
504                    Ok(s) => s,
505                    Err(e) => {
506                        assert!(
507                            expected_err == e.kind(),
508                            "Reading {:?}, expected {:?}, but got {:?}",
509                            s,
510                            expected_err,
511                            e.kind()
512                        );
513                        return;
514                    }
515                };
516                if state == ChunkedState::Body || state == ChunkedState::End {
517                    panic!("Was Ok. Expected Err for {:?}", s);
518                }
519            }
520        }
521
522        assert_eq!(1, read("1\r\n").await);
523        assert_eq!(1, read("01\r\n").await);
524        assert_eq!(0, read("0\r\n").await);
525        assert_eq!(0, read("00\r\n").await);
526        assert_eq!(10, read("A\r\n").await);
527        assert_eq!(10, read("a\r\n").await);
528        assert_eq!(255, read("Ff\r\n").await);
529        assert_eq!(255, read("Ff   \r\n").await);
530        // Missing LF or CRLF
531        read_err("F\rF", InvalidInput).await;
532        read_err("F", UnexpectedEof).await;
533        // Invalid hex digit
534        read_err("X\r\n", InvalidInput).await;
535        read_err("1X\r\n", InvalidInput).await;
536        read_err("-\r\n", InvalidInput).await;
537        read_err("-1\r\n", InvalidInput).await;
538        // Acceptable (if not fully valid) extensions do not influence the size
539        assert_eq!(1, read("1;extension\r\n").await);
540        assert_eq!(10, read("a;ext name=value\r\n").await);
541        assert_eq!(1, read("1;extension;extension2\r\n").await);
542        assert_eq!(1, read("1;;;  ;\r\n").await);
543        assert_eq!(2, read("2; extension...\r\n").await);
544        assert_eq!(3, read("3   ; extension=123\r\n").await);
545        assert_eq!(3, read("3   ;\r\n").await);
546        assert_eq!(3, read("3   ;   \r\n").await);
547        // Invalid extensions cause an error
548        read_err("1 invalid extension\r\n", InvalidInput).await;
549        read_err("1 A\r\n", InvalidInput).await;
550        read_err("1;no CRLF", UnexpectedEof).await;
551        read_err("1;reject\nnewlines\r\n", InvalidData).await;
552        // Overflow
553        read_err("f0000000000000003\r\n", InvalidData).await;
554    }
555
556    #[tokio::test]
557    async fn test_read_sized_early_eof() {
558        let mut bytes = &b"foo bar"[..];
559        let mut decoder = Decoder::length(10);
560        assert_eq!(decoder.decode_fut(&mut bytes).await.unwrap().len(), 7);
561        let e = decoder.decode_fut(&mut bytes).await.unwrap_err();
562        assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
563    }
564
565    #[tokio::test]
566    async fn test_read_chunked_early_eof() {
567        let mut bytes = &b"\
568            9\r\n\
569            foo bar\
570        "[..];
571        let mut decoder = Decoder::chunked();
572        assert_eq!(decoder.decode_fut(&mut bytes).await.unwrap().len(), 7);
573        let e = decoder.decode_fut(&mut bytes).await.unwrap_err();
574        assert_eq!(e.kind(), io::ErrorKind::UnexpectedEof);
575    }
576
577    #[tokio::test]
578    async fn test_read_chunked_single_read() {
579        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n"[..];
580        let buf = Decoder::chunked()
581            .decode_fut(&mut mock_buf)
582            .await
583            .expect("decode");
584        assert_eq!(16, buf.len());
585        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
586        assert_eq!("1234567890abcdef", &result);
587    }
588
589    #[tokio::test]
590    async fn test_read_chunked_trailer_with_missing_lf() {
591        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\nbad\r\r\n"[..];
592        let mut decoder = Decoder::chunked();
593        decoder.decode_fut(&mut mock_buf).await.expect("decode");
594        let e = decoder.decode_fut(&mut mock_buf).await.unwrap_err();
595        assert_eq!(e.kind(), io::ErrorKind::InvalidInput);
596    }
597
598    #[tokio::test]
599    async fn test_read_chunked_after_eof() {
600        let mut mock_buf = &b"10\r\n1234567890abcdef\r\n0\r\n\r\n"[..];
601        let mut decoder = Decoder::chunked();
602
603        // normal read
604        let buf = decoder.decode_fut(&mut mock_buf).await.unwrap();
605        assert_eq!(16, buf.len());
606        let result = String::from_utf8(buf.as_ref().to_vec()).expect("decode String");
607        assert_eq!("1234567890abcdef", &result);
608
609        // eof read
610        let buf = decoder.decode_fut(&mut mock_buf).await.expect("decode");
611        assert_eq!(0, buf.len());
612
613        // ensure read after eof also returns eof
614        let buf = decoder.decode_fut(&mut mock_buf).await.expect("decode");
615        assert_eq!(0, buf.len());
616    }
617
618    // perform an async read using a custom buffer size and causing a blocking
619    // read at the specified byte
620    async fn read_async(mut decoder: Decoder, content: &[u8], block_at: usize) -> String {
621        let mut outs = Vec::new();
622
623        let mut ins = if block_at == 0 {
624            tokio_test::io::Builder::new()
625                .wait(Duration::from_millis(10))
626                .read(content)
627                .build()
628        } else {
629            tokio_test::io::Builder::new()
630                .read(&content[..block_at])
631                .wait(Duration::from_millis(10))
632                .read(&content[block_at..])
633                .build()
634        };
635
636        let mut ins = &mut ins as &mut (dyn AsyncRead + Unpin);
637
638        loop {
639            let buf = decoder
640                .decode_fut(&mut ins)
641                .await
642                .expect("unexpected decode error");
643            if buf.is_empty() {
644                break; // eof
645            }
646            outs.extend(buf.as_ref());
647        }
648
649        String::from_utf8(outs).expect("decode String")
650    }
651
652    // iterate over the different ways that this async read could go.
653    // tests blocking a read at each byte along the content - The shotgun approach
654    async fn all_async_cases(content: &str, expected: &str, decoder: Decoder) {
655        let content_len = content.len();
656        for block_at in 0..content_len {
657            let actual = read_async(decoder.clone(), content.as_bytes(), block_at).await;
658            assert_eq!(expected, &actual) //, "Failed async. Blocking at {}", block_at);
659        }
660    }
661
662    #[tokio::test]
663    async fn test_read_length_async() {
664        let content = "foobar";
665        all_async_cases(content, content, Decoder::length(content.len() as u64)).await;
666    }
667
668    #[tokio::test]
669    async fn test_read_chunked_async() {
670        let content = "3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n";
671        let expected = "foobar";
672        all_async_cases(content, expected, Decoder::chunked()).await;
673    }
674
675    #[tokio::test]
676    async fn test_read_eof_async() {
677        let content = "foobar";
678        all_async_cases(content, content, Decoder::eof()).await;
679    }
680
681    #[cfg(feature = "nightly")]
682    #[bench]
683    fn bench_decode_chunked_1kb(b: &mut test::Bencher) {
684        let rt = new_runtime();
685
686        const LEN: usize = 1024;
687        let mut vec = Vec::new();
688        vec.extend(format!("{:x}\r\n", LEN).as_bytes());
689        vec.extend(&[0; LEN][..]);
690        vec.extend(b"\r\n");
691        let content = Bytes::from(vec);
692
693        b.bytes = LEN as u64;
694
695        b.iter(|| {
696            let mut decoder = Decoder::chunked();
697            rt.block_on(async {
698                let mut raw = content.clone();
699                let chunk = decoder.decode_fut(&mut raw).await.unwrap();
700                assert_eq!(chunk.len(), LEN);
701            });
702        });
703    }
704
705    #[cfg(feature = "nightly")]
706    #[bench]
707    fn bench_decode_length_1kb(b: &mut test::Bencher) {
708        let rt = new_runtime();
709
710        const LEN: usize = 1024;
711        let content = Bytes::from(&[0; LEN][..]);
712        b.bytes = LEN as u64;
713
714        b.iter(|| {
715            let mut decoder = Decoder::length(LEN as u64);
716            rt.block_on(async {
717                let mut raw = content.clone();
718                let chunk = decoder.decode_fut(&mut raw).await.unwrap();
719                assert_eq!(chunk.len(), LEN);
720            });
721        });
722    }
723
724    #[cfg(feature = "nightly")]
725    fn new_runtime() -> tokio::runtime::Runtime {
726        tokio::runtime::Builder::new_current_thread()
727            .enable_all()
728            .build()
729            .expect("rt build")
730    }
731}
hyper/proto/h1/decode.rs

hyper/proto/h1/
decode.rs
