barehttp 0.1.0

Blocking HTTP/1.1 client for no_std + alloc
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

/// HTTP version (e.g. HTTP/1.1).
///
/// # Examples
///
/// ```
/// use barehttp::Version;
///
/// assert_eq!(Version::HTTP_11.major(), 1);
/// assert_eq!(Version::HTTP_11.minor(), 1);
/// assert!(Version::HTTP_11.defaults_to_persistent());
/// assert_eq!(Version::parse(b"HTTP/1.0")?, Version::HTTP_10);
/// # Ok::<(), barehttp::ParseError>(())
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Version {
  major: u8,
  minor: u8,
}

impl Default for Version {
  fn default() -> Self {
    Self::HTTP_11
  }
}

impl Version {
  /// HTTP/1.0
  pub const HTTP_10: Self = Self { major: 1, minor: 0 };
  /// HTTP/1.1
  pub const HTTP_11: Self = Self { major: 1, minor: 1 };

  /// Major version digit.
  #[must_use]
  pub const fn major(self) -> u8 {
    self.major
  }

  /// Minor version digit.
  #[must_use]
  pub const fn minor(self) -> u8 {
    self.minor
  }

  /// RFC 9112 ยง9.3: HTTP/1.1 (or later) defaults to persistent connections.
  #[must_use]
  pub const fn defaults_to_persistent(self) -> bool {
    self.major > 1 || (self.major == 1 && self.minor >= 1)
  }

  /// Parse `HTTP/x.y` from bytes.
  ///
  /// # Errors
  /// [`crate::ParseError::InvalidHttpVersion`] if the prefix is wrong or digits are missing.
  pub fn parse(input: &[u8]) -> Result<Self, crate::error::ParseError> {
    use crate::error::ParseError;
    if input.len() < 8 {
      return Err(ParseError::InvalidHttpVersion);
    }

    if input.get(0..5) != Some(b"HTTP/") {
      return Err(ParseError::InvalidHttpVersion);
    }

    let major = *input.get(5).ok_or(ParseError::InvalidHttpVersion)?;
    if !major.is_ascii_digit() {
      return Err(ParseError::InvalidHttpVersion);
    }

    if input.get(6) != Some(&b'.') {
      return Err(ParseError::InvalidHttpVersion);
    }

    let minor = *input.get(7).ok_or(ParseError::InvalidHttpVersion)?;
    if !minor.is_ascii_digit() {
      return Err(ParseError::InvalidHttpVersion);
    }

    Ok(Self {
      major: major - b'0',
      minor: minor - b'0',
    })
  }
}

impl core::fmt::Display for Version {
  fn fmt(
    &self,
    f: &mut core::fmt::Formatter<'_>,
  ) -> core::fmt::Result {
    write!(f, "HTTP/{}.{}", self.major, self.minor)
  }
}

/// Parse status line: `HTTP/x.y <code> <reason>\r\n`.
///
/// Returns `(version, status, reason, rest)`.
pub fn parse_status_line(input: &[u8]) -> Result<(Version, u16, &[u8], &[u8]), crate::error::ParseError> {
  use crate::error::ParseError;
  use crate::parser::headers::expect_crlf;

  if input.len() < 8 {
    return Err(ParseError::InvalidHttpVersion);
  }
  let version = Version::parse(input)?;
  let rest1 = input.get(8..).ok_or(ParseError::InvalidHttpVersion)?;

  if rest1.first().copied() != Some(b' ') {
    return Err(ParseError::InvalidWhitespace);
  }
  let rest2 = rest1.get(1..).ok_or(ParseError::InvalidWhitespace)?;

  let (status, rest3) = parse_status_code(rest2)?;

  if rest3.first().copied() != Some(b' ') {
    return Err(ParseError::InvalidWhitespace);
  }
  let rest4 = rest3.get(1..).ok_or(ParseError::InvalidWhitespace)?;

  let mut i = 0;
  while i < rest4.len() {
    let ch = rest4.get(i).copied();
    if ch == Some(b'\r') || ch == Some(b'\n') {
      break;
    }
    i += 1;
  }

  let reason = rest4.get(..i).ok_or(ParseError::InvalidReasonPhrase)?;
  let rest5 = rest4.get(i..).ok_or(ParseError::InvalidReasonPhrase)?;
  let rest6 = expect_crlf(rest5)?;

  Ok((version, status, reason, rest6))
}

fn parse_status_code(input: &[u8]) -> Result<(u16, &[u8]), crate::error::ParseError> {
  use crate::error::ParseError;

  if input.len() < 3 {
    return Err(ParseError::InvalidStatusCode);
  }

  let d0 = *input.first().ok_or(ParseError::InvalidStatusCode)?;
  let d1 = *input.get(1).ok_or(ParseError::InvalidStatusCode)?;
  let d2 = *input.get(2).ok_or(ParseError::InvalidStatusCode)?;

  if !d0.is_ascii_digit() || !d1.is_ascii_digit() || !d2.is_ascii_digit() {
    return Err(ParseError::InvalidStatusCode);
  }

  #[allow(clippy::cast_lossless)]
  let code = u16::from(d0 - b'0') * 100 + u16::from(d1 - b'0') * 10 + u16::from(d2 - b'0');

  if !(100..=599).contains(&code) {
    return Err(ParseError::InvalidStatusCode);
  }
  let remaining = input.get(3..).ok_or(ParseError::InvalidStatusCode)?;
  Ok((code, remaining))
}