use std::fmt;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
mod parser;
mod wire_bytes;
pub use parser::{
parse_request_head, parse_response_head, Http1HeadBuffer, Http1ParseError, Http1Parser,
DEFAULT_HTTP1_HEADER_LIMIT, DEFAULT_HTTP1_HEAD_CAPACITY, DEFAULT_HTTP1_HEAD_LIMIT,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HeadKind {
Request,
Response,
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Http1Head {
Request(RequestHead),
Response(ResponseHead),
}
impl Http1Head {
pub const fn kind(&self) -> HeadKind {
match self {
Self::Request(_) => HeadKind::Request,
Self::Response(_) => HeadKind::Response,
}
}
pub const fn as_request(&self) -> Option<&RequestHead> {
match self {
Self::Request(request) => Some(request),
Self::Response(_) => None,
}
}
pub const fn as_response(&self) -> Option<&ResponseHead> {
match self {
Self::Request(_) => None,
Self::Response(response) => Some(response),
}
}
pub fn into_request(self) -> Option<RequestHead> {
match self {
Self::Request(request) => Some(request),
Self::Response(_) => None,
}
}
pub fn into_response(self) -> Option<ResponseHead> {
match self {
Self::Request(_) => None,
Self::Response(response) => Some(response),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Version(u8);
impl Version {
pub const HTTP_10: Self = Self(0);
pub const HTTP_11: Self = Self(1);
pub const fn from_minor(minor: u8) -> Option<Self> {
if minor <= 9 {
Some(Self(minor))
} else {
None
}
}
pub const fn minor(self) -> u8 {
self.0
}
fn parse(value: &str) -> Option<Self> {
let minor = value.strip_prefix("HTTP/1.")?.as_bytes();
if minor.len() != 1 {
return None;
}
let digit = minor[0];
digit
.is_ascii_digit()
.then(|| Self(digit.saturating_sub(b'0')))
}
}
impl fmt::Display for Version {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "HTTP/1.{}", self.0)
}
}
impl Serialize for Version {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.collect_str(self)
}
}
impl<'de> Deserialize<'de> for Version {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let value = Box::<str>::deserialize(deserializer)?;
Self::parse(&value)
.ok_or_else(|| de::Error::custom(format_args!("invalid HTTP/1 version {value:?}")))
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct HeaderField {
pub name: Box<str>,
#[serde(with = "wire_bytes")]
pub value: Box<[u8]>,
}
impl HeaderField {
pub fn new(name: impl Into<Box<str>>, value: impl Into<Box<[u8]>>) -> Self {
Self {
name: name.into(),
value: value.into(),
}
}
pub fn value_as_str(&self) -> Option<&str> {
std::str::from_utf8(&self.value).ok()
}
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct RequestHead {
pub head_length: usize,
pub method: Box<str>,
pub target: Box<str>,
pub version: Version,
pub headers: Vec<HeaderField>,
}
#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResponseHead {
pub head_length: usize,
pub version: Version,
pub status_code: u16,
#[serde(with = "wire_bytes")]
pub reason_phrase: Box<[u8]>,
pub headers: Vec<HeaderField>,
}
impl ResponseHead {
pub fn reason_phrase_as_str(&self) -> Option<&str> {
std::str::from_utf8(&self.reason_phrase).ok()
}
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::{HeaderField, Version};
#[test]
fn version_uses_the_wire_spelling_in_json() {
assert_eq!(serde_json::to_value(Version::HTTP_11).unwrap(), "HTTP/1.1");
assert_eq!(
serde_json::from_value::<Version>(json!("HTTP/1.0")).unwrap(),
Version::HTTP_10
);
assert!(serde_json::from_value::<Version>(json!("HTTP/2.0")).is_err());
assert!(serde_json::from_value::<Version>(json!("HTTP/1.10")).is_err());
}
#[test]
fn non_utf8_header_values_roundtrip_without_loss() {
let field = HeaderField::new("X-Raw", [0xff, 0x00]);
let json = serde_json::to_value(&field).unwrap();
assert_eq!(json, json!({"name": "X-Raw", "value": {"hex": "ff00"}}));
assert_eq!(serde_json::from_value::<HeaderField>(json).unwrap(), field);
}
}