diff --git a/Cargo.toml b/Cargo.toml index 42cc51ab..f824cef4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,13 @@ repository = "https://github.com/http-rs/http-types" documentation = "https://docs.rs/http-types" description = "Common types for HTTP operations." keywords = ["http", "types", "request", "response", "h2"] -categories = ["asynchronous", "web-programming", "web-programming::http-client", "web-programming::http-server", "web-programming::websocket"] +categories = [ + "asynchronous", + "web-programming", + "web-programming::http-client", + "web-programming::http-server", + "web-programming::websocket", +] authors = ["Yoshua Wuyts "] readme = "README.md" edition = "2018" @@ -19,39 +25,50 @@ rustdoc-args = ["--cfg", "feature=\"docs\""] default = ["fs", "cookie-secure", "serde"] docs = ["unstable"] unstable = [] -hyperium_http = ["http"] +hyperium_http = ["hyperium_http_02"] +hyperium_http_02 = ["http02"] +hyperium_http_1 = ["http1"] async_std = ["fs"] cookies = ["cookie"] cookie-secure = ["cookies", "cookie/secure"] fs = ["async-std"] -serde = ["serde_qs", "serde_crate", "serde_json", "serde_urlencoded", "url/serde"] +serde = [ + "serde_qs", + "serde_crate", + "serde_json", + "serde_urlencoded", + "url/serde", +] [dependencies] -fastrand = "1.4.0" -base64 = "0.13.0" -futures-lite = "1.11.1" -async-channel = "1.5.1" -infer = "0.7.0" -pin-project-lite = "0.2.0" -url = "2.1.1" -anyhow = "1.0.26" +fastrand = "2.0.1" +base64 = "0.21.5" +futures-lite = "2.2.0" +async-channel = "2.1.1" +infer = "0.15.0" +pin-project-lite = "0.2.13" +url = "2.5.0" +anyhow = "1.0.79" # features: async_std -async-std = { version = "1.6.0", optional = true } +async-std = { version = "1.12.0", optional = true } -# features: hyperium/http -http = { version = "0.2.0", optional = true } +# features: hyperium_http or hyperium_http_02 +http02 = { package = "http", version = "0.2.0", optional = true } +# features: hyperium_http_1 +http1 = { package = "http", version = "1.0.0", optional = true } # features: cookies -cookie = { version = "0.16.0", features = ["percent-encode"], optional = true } +cookie = { version = "0.18.0", features = ["percent-encode"], optional = true } # features: serde -serde_json = { version = "1.0.51", optional = true } -serde_crate = { version = "1.0.106", features = ["derive"], optional = true, package = "serde" } -serde_urlencoded = { version = "0.7.0", optional = true} -serde_qs = { version = "0.9.1", optional = true } +serde_json = { version = "1.0.111", optional = true } +serde_crate = { version = "1.0.195", features = [ + "derive", +], optional = true, package = "serde" } +serde_urlencoded = { version = "0.7.1", optional = true } +serde_qs = { version = "0.12.0", optional = true } [dev-dependencies] -http = "0.2.0" -async-std = { version = "1.6.0", features = ["attributes"] } +async-std = { version = "1.12.0", features = ["attributes"] } diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 00000000..5d56faf9 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,2 @@ +[toolchain] +channel = "nightly" diff --git a/src/auth/basic_auth.rs b/src/auth/basic_auth.rs index 664cfcb5..b161b20f 100644 --- a/src/auth/basic_auth.rs +++ b/src/auth/basic_auth.rs @@ -1,3 +1,5 @@ +use base64::Engine; + use crate::headers::{HeaderName, HeaderValue, Headers, AUTHORIZATION}; use crate::Status; use crate::{ @@ -71,7 +73,9 @@ impl BasicAuth { /// Create a new instance from the base64 encoded credentials. pub fn from_credentials(credentials: impl AsRef<[u8]>) -> crate::Result { - let bytes = base64::decode(credentials).status(400)?; + let bytes = base64::engine::general_purpose::STANDARD + .decode(credentials) + .status(400)?; let credentials = String::from_utf8(bytes).status(400)?; let mut iter = credentials.splitn(2, ':'); @@ -105,7 +109,13 @@ impl Header for BasicAuth { fn header_value(&self) -> HeaderValue { let scheme = AuthenticationScheme::Basic; - let credentials = base64::encode(format!("{}:{}", self.username, self.password)); + + let mut credentials = String::new(); + base64::engine::general_purpose::STANDARD.encode_string( + format!("{}:{}", self.username, self.password), + &mut credentials, + ); + let auth = Authorization::new(scheme, credentials); auth.header_value() } diff --git a/src/hyperium_http.rs b/src/hyperium_http.rs index 81d33425..5bf3ed49 100644 --- a/src/hyperium_http.rs +++ b/src/hyperium_http.rs @@ -5,95 +5,95 @@ use crate::{Body, Error, Method, Request, Response, StatusCode, Url, Version}; use std::convert::{TryFrom, TryInto}; use std::str::FromStr; -impl From for Method { - fn from(method: http::Method) -> Self { +impl From for Method { + fn from(method: http02::Method) -> Self { Method::from_str(method.as_str()).unwrap() } } -impl From for http::Method { +impl From for http02::Method { fn from(method: Method) -> Self { - http::Method::from_str(method.as_ref()).unwrap() + http02::Method::from_str(method.as_ref()).unwrap() } } -impl From for StatusCode { - fn from(status: http::StatusCode) -> Self { +impl From for StatusCode { + fn from(status: http02::StatusCode) -> Self { StatusCode::try_from(status.as_u16()).unwrap() } } -impl From for http::StatusCode { +impl From for http02::StatusCode { fn from(status: StatusCode) -> Self { - http::StatusCode::from_u16(status.into()).unwrap() + http02::StatusCode::from_u16(status.into()).unwrap() } } -impl From for Version { - fn from(version: http::Version) -> Self { +impl From for Version { + fn from(version: http02::Version) -> Self { match version { - http::Version::HTTP_09 => Version::Http0_9, - http::Version::HTTP_10 => Version::Http1_0, - http::Version::HTTP_11 => Version::Http1_1, - http::Version::HTTP_2 => Version::Http2_0, - http::Version::HTTP_3 => Version::Http3_0, + http02::Version::HTTP_09 => Version::Http0_9, + http02::Version::HTTP_10 => Version::Http1_0, + http02::Version::HTTP_11 => Version::Http1_1, + http02::Version::HTTP_2 => Version::Http2_0, + http02::Version::HTTP_3 => Version::Http3_0, _ => panic!("unknown HTTP version conversion"), } } } -impl From for http::Version { +impl From for http02::Version { fn from(version: Version) -> Self { match version { - Version::Http0_9 => http::Version::HTTP_09, - Version::Http1_0 => http::Version::HTTP_10, - Version::Http1_1 => http::Version::HTTP_11, - Version::Http2_0 => http::Version::HTTP_2, - Version::Http3_0 => http::Version::HTTP_3, + Version::Http0_9 => http02::Version::HTTP_09, + Version::Http1_0 => http02::Version::HTTP_10, + Version::Http1_1 => http02::Version::HTTP_11, + Version::Http2_0 => http02::Version::HTTP_2, + Version::Http3_0 => http02::Version::HTTP_3, } } } -impl TryFrom for HeaderName { +impl TryFrom for HeaderName { type Error = Error; - fn try_from(name: http::header::HeaderName) -> Result { + fn try_from(name: http02::header::HeaderName) -> Result { let name = name.as_str().as_bytes().to_owned(); HeaderName::from_bytes(name) } } -impl TryFrom for http::header::HeaderName { +impl TryFrom for http02::header::HeaderName { type Error = Error; fn try_from(name: HeaderName) -> Result { let name = name.as_str().as_bytes(); - http::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc) + http02::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc) } } -impl TryFrom for HeaderValue { +impl TryFrom for HeaderValue { type Error = Error; - fn try_from(value: http::header::HeaderValue) -> Result { + fn try_from(value: http02::header::HeaderValue) -> Result { let value = value.as_bytes().to_owned(); HeaderValue::from_bytes(value) } } -impl TryFrom for http::header::HeaderValue { +impl TryFrom for http02::header::HeaderValue { type Error = Error; fn try_from(value: HeaderValue) -> Result { let value = value.as_str().as_bytes(); - http::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc) + http02::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc) } } -impl TryFrom for Headers { +impl TryFrom for Headers { type Error = Error; - fn try_from(hyperium_headers: http::HeaderMap) -> Result { + fn try_from(hyperium_headers: http02::HeaderMap) -> Result { let mut headers = Headers::new(); hyperium_headers @@ -112,21 +112,21 @@ impl TryFrom for Headers { } } -impl TryFrom for http::HeaderMap { +impl TryFrom for http02::HeaderMap { type Error = Error; fn try_from(headers: Headers) -> Result { - let mut hyperium_headers = http::HeaderMap::new(); + let mut hyperium_headers = http02::HeaderMap::new(); headers .into_iter() .map(|(name, values)| { - let name: http::header::HeaderName = name.try_into()?; + let name: http02::header::HeaderName = name.try_into()?; values .into_iter() .map(|value| { - let value: http::header::HeaderValue = value.try_into()?; + let value: http02::header::HeaderValue = value.try_into()?; hyperium_headers.append(&name, value); Ok(()) }) @@ -141,7 +141,7 @@ impl TryFrom for http::HeaderMap { } fn hyperium_headers_to_headers( - hyperium_headers: http::HeaderMap, + hyperium_headers: http02::HeaderMap, headers: &mut Headers, ) -> crate::Result<()> { for (name, value) in hyperium_headers { @@ -156,33 +156,33 @@ fn hyperium_headers_to_headers( Ok(()) } -fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http::HeaderMap) { +fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http02::HeaderMap) { for (name, values) in headers { let name = format!("{}", name).into_bytes(); - let name = http::header::HeaderName::from_bytes(&name).unwrap(); + let name = http02::header::HeaderName::from_bytes(&name).unwrap(); for value in values.iter() { let value = format!("{}", value).into_bytes(); - let value = http::header::HeaderValue::from_bytes(&value).unwrap(); + let value = http02::header::HeaderValue::from_bytes(&value).unwrap(); hyperium_headers.append(&name, value); } } } // Neither type is defined in this lib, so we can't do From/Into impls -fn from_uri_to_url(uri: http::Uri) -> Result { +fn from_uri_to_url(uri: http02::Uri) -> Result { format!("{}", uri).parse() } // Neither type is defined in this lib, so we can't do From/Into impls -fn from_url_to_uri(url: &Url) -> http::Uri { - http::Uri::try_from(&format!("{}", url)).unwrap() +fn from_url_to_uri(url: &Url) -> http02::Uri { + http02::Uri::try_from(&format!("{}", url)).unwrap() } -impl TryFrom> for Request { +impl TryFrom> for Request { type Error = crate::Error; - fn try_from(req: http::Request) -> Result { + fn try_from(req: http02::Request) -> Result { let (parts, body) = req.into_parts(); let method = parts.method.into(); let url = from_uri_to_url(parts.uri)?; @@ -194,11 +194,11 @@ impl TryFrom> for Request { } } -impl From for http::Request { +impl From for http02::Request { fn from(mut req: Request) -> Self { - let method: http::Method = req.method().into(); + let method: http02::Method = req.method().into(); let version = req.version().map(|v| v.into()).unwrap_or_default(); - let mut builder = http::request::Builder::new() + let mut builder = http02::request::Builder::new() .method(method) .uri(from_url_to_uri(req.url())) .version(version); @@ -207,9 +207,9 @@ impl From for http::Request { } } -impl TryFrom> for Response { +impl TryFrom> for Response { type Error = crate::Error; - fn try_from(res: http::Response) -> Result { + fn try_from(res: http02::Response) -> Result { let (parts, body) = res.into_parts(); let mut res = Response::new(parts.status); res.set_body(body); @@ -219,11 +219,11 @@ impl TryFrom> for Response { } } -impl From for http::Response { +impl From for http02::Response { fn from(mut res: Response) -> Self { let status: u16 = res.status().into(); let version = res.version().map(|v| v.into()).unwrap_or_default(); - let mut builder = http::response::Builder::new() + let mut builder = http02::response::Builder::new() .status(status) .version(version); headers_to_hyperium_headers(res.as_mut(), builder.headers_mut().unwrap()); diff --git a/src/hyperium_http_1.rs b/src/hyperium_http_1.rs new file mode 100644 index 00000000..3a2b5703 --- /dev/null +++ b/src/hyperium_http_1.rs @@ -0,0 +1,231 @@ +use crate::headers::{HeaderName, HeaderValue, Headers}; +use crate::{Body, Error, Method, Request, Response, StatusCode, Url, Version}; +use std::convert::{TryFrom, TryInto}; +use std::str::FromStr; + +impl From for Method { + fn from(method: http1::Method) -> Self { + Method::from_str(method.as_str()).unwrap() + } +} + +impl From for http1::Method { + fn from(method: Method) -> Self { + http1::Method::from_str(method.as_ref()).unwrap() + } +} + +impl From for StatusCode { + fn from(status: http1::StatusCode) -> Self { + StatusCode::try_from(status.as_u16()).unwrap() + } +} + +impl From for http1::StatusCode { + fn from(status: StatusCode) -> Self { + http1::StatusCode::from_u16(status.into()).unwrap() + } +} + +impl From for Version { + fn from(version: http1::Version) -> Self { + match version { + http1::Version::HTTP_09 => Version::Http0_9, + http1::Version::HTTP_10 => Version::Http1_0, + http1::Version::HTTP_11 => Version::Http1_1, + http1::Version::HTTP_2 => Version::Http2_0, + http1::Version::HTTP_3 => Version::Http3_0, + _ => panic!("unknown http1 version conversion"), + } + } +} + +impl From for http1::Version { + fn from(version: Version) -> Self { + match version { + Version::Http0_9 => http1::Version::HTTP_09, + Version::Http1_0 => http1::Version::HTTP_10, + Version::Http1_1 => http1::Version::HTTP_11, + Version::Http2_0 => http1::Version::HTTP_2, + Version::Http3_0 => http1::Version::HTTP_3, + } + } +} + +impl TryFrom for HeaderName { + type Error = Error; + + fn try_from(name: http1::header::HeaderName) -> Result { + let name = name.as_str().as_bytes().to_owned(); + HeaderName::from_bytes(name) + } +} + +impl TryFrom for http1::header::HeaderName { + type Error = Error; + + fn try_from(name: HeaderName) -> Result { + let name = name.as_str().as_bytes(); + http1::header::HeaderName::from_bytes(name).map_err(Error::new_adhoc) + } +} + +impl TryFrom for HeaderValue { + type Error = Error; + + fn try_from(value: http1::header::HeaderValue) -> Result { + let value = value.as_bytes().to_owned(); + HeaderValue::from_bytes(value) + } +} + +impl TryFrom for http1::header::HeaderValue { + type Error = Error; + + fn try_from(value: HeaderValue) -> Result { + let value = value.as_str().as_bytes(); + http1::header::HeaderValue::from_bytes(value).map_err(Error::new_adhoc) + } +} + +impl TryFrom for Headers { + type Error = Error; + + fn try_from(hyperium_headers: http1::HeaderMap) -> Result { + let mut headers = Headers::new(); + + hyperium_headers + .into_iter() + .map(|(name, value)| { + if let Some(name) = name { + let value: HeaderValue = value.try_into()?; + let name: HeaderName = name.try_into()?; + headers.append(name, value)?; + } + Ok(()) + }) + .collect::, Error>>()?; + + Ok(headers) + } +} + +impl TryFrom for http1::HeaderMap { + type Error = Error; + + fn try_from(headers: Headers) -> Result { + let mut hyperium_headers = http1::HeaderMap::new(); + + headers + .into_iter() + .map(|(name, values)| { + let name: http1::header::HeaderName = name.try_into()?; + + values + .into_iter() + .map(|value| { + let value: http1::header::HeaderValue = value.try_into()?; + hyperium_headers.append(&name, value); + Ok(()) + }) + .collect::, Error>>()?; + + Ok(()) + }) + .collect::, Error>>()?; + + Ok(hyperium_headers) + } +} + +fn hyperium_headers_to_headers( + hyperium_headers: http1::HeaderMap, + headers: &mut Headers, +) -> crate::Result<()> { + for (name, value) in hyperium_headers { + let value = value.as_bytes().to_owned(); + let value = unsafe { HeaderValue::from_bytes_unchecked(value) }; + if let Some(name) = name { + let name = name.as_str().as_bytes().to_owned(); + let name = unsafe { HeaderName::from_bytes_unchecked(name) }; + headers.append(name, value)?; + } + } + Ok(()) +} + +fn headers_to_hyperium_headers(headers: &mut Headers, hyperium_headers: &mut http1::HeaderMap) { + for (name, values) in headers { + let name = format!("{}", name).into_bytes(); + let name = http1::header::HeaderName::from_bytes(&name).unwrap(); + + for value in values.iter() { + let value = format!("{}", value).into_bytes(); + let value = http1::header::HeaderValue::from_bytes(&value).unwrap(); + hyperium_headers.append(&name, value); + } + } +} + +// Neither type is defined in this lib, so we can't do From/Into impls +fn from_uri_to_url(uri: http1::Uri) -> Result { + format!("{}", uri).parse() +} + +// Neither type is defined in this lib, so we can't do From/Into impls +fn from_url_to_uri(url: &Url) -> http1::Uri { + http1::Uri::try_from(&format!("{}", url)).unwrap() +} + +impl TryFrom> for Request { + type Error = crate::Error; + + fn try_from(req: http1::Request) -> Result { + let (parts, body) = req.into_parts(); + let method = parts.method.into(); + let url = from_uri_to_url(parts.uri)?; + let mut req = Request::new(method, url); + req.set_body(body); + req.set_version(Some(parts.version.into())); + hyperium_headers_to_headers(parts.headers, req.as_mut())?; + Ok(req) + } +} + +impl From for http1::Request { + fn from(mut req: Request) -> Self { + let method: http1::Method = req.method().into(); + let version = req.version().map(|v| v.into()).unwrap_or_default(); + let mut builder = http1::request::Builder::new() + .method(method) + .uri(from_url_to_uri(req.url())) + .version(version); + headers_to_hyperium_headers(req.as_mut(), builder.headers_mut().unwrap()); + builder.body(req.into()).unwrap() + } +} + +impl TryFrom> for Response { + type Error = crate::Error; + fn try_from(res: http1::Response) -> Result { + let (parts, body) = res.into_parts(); + let mut res = Response::new(parts.status); + res.set_body(body); + res.set_version(Some(parts.version.into())); + hyperium_headers_to_headers(parts.headers, res.as_mut())?; + Ok(res) + } +} + +impl From for http1::Response { + fn from(mut res: Response) -> Self { + let status: u16 = res.status().into(); + let version = res.version().map(|v| v.into()).unwrap_or_default(); + let mut builder = http1::response::Builder::new() + .status(status) + .version(version); + headers_to_hyperium_headers(res.as_mut(), builder.headers_mut().unwrap()); + let body = res.take_body(); + builder.body(body).unwrap() + } +} diff --git a/src/lib.rs b/src/lib.rs index c8821a41..0e93b0dc 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -96,6 +96,7 @@ #![deny(missing_debug_implementations, nonstandard_style)] #![warn(missing_docs)] #![allow(clippy::new_without_default)] +#![feature(rustdoc_missing_doc_code_examples)] #![cfg_attr(backtrace, feature(backtrace))] #![cfg_attr(feature = "docs", feature(doc_cfg))] #![doc(html_favicon_url = "https://yoshuawuyts.com/assets/http-rs/favicon.ico")] @@ -158,9 +159,12 @@ pub use crate::url::Url; pub mod security; pub mod trailers; -#[cfg(feature = "hyperium_http")] +#[cfg(feature = "hyperium_http_02")] mod hyperium_http; +#[cfg(feature = "hyperium_http_1")] +mod hyperium_http_1; + #[doc(inline)] pub use crate::extensions::Extensions; diff --git a/src/security/csp.rs b/src/security/csp.rs index 9478f34a..7cd9411f 100644 --- a/src/security/csp.rs +++ b/src/security/csp.rs @@ -160,7 +160,7 @@ impl ContentSecurityPolicy { fn insert_directive>(&mut self, directive: &str, source: T) { let directive = String::from(directive); - let directives = self.directives.entry(directive).or_insert_with(Vec::new); + let directives = self.directives.entry(directive).or_default(); let source: String = source.as_ref().to_string(); directives.push(source); } diff --git a/src/trailers.rs b/src/trailers.rs index c65801c6..0959bbc7 100644 --- a/src/trailers.rs +++ b/src/trailers.rs @@ -242,13 +242,15 @@ impl Sender { #[must_use = "Futures do nothing unless polled or .awaited"] #[derive(Debug)] pub struct Receiver { - receiver: async_channel::Receiver, + receiver: Pin>>, } impl Receiver { /// Create a new instance of `Receiver`. pub(crate) fn new(receiver: async_channel::Receiver) -> Self { - Self { receiver } + Self { + receiver: Box::pin(receiver), + } } } @@ -256,6 +258,6 @@ impl Future for Receiver { type Output = Option; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - Pin::new(&mut self.receiver).poll_next(cx) + self.receiver.as_mut().poll_next(cx) } } diff --git a/src/upgrade/receiver.rs b/src/upgrade/receiver.rs index 96c322dc..5d231244 100644 --- a/src/upgrade/receiver.rs +++ b/src/upgrade/receiver.rs @@ -10,14 +10,16 @@ use crate::upgrade::Connection; #[must_use = "Futures do nothing unless polled or .awaited"] #[derive(Debug)] pub struct Receiver { - receiver: async_channel::Receiver, + receiver: Pin>>, } impl Receiver { /// Create a new instance of `Receiver`. #[allow(unused)] pub(crate) fn new(receiver: async_channel::Receiver) -> Self { - Self { receiver } + Self { + receiver: Box::pin(receiver), + } } } @@ -25,6 +27,6 @@ impl Future for Receiver { type Output = Option; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { - Pin::new(&mut self.receiver).poll_next(cx) + self.receiver.as_mut().poll_next(cx) } } diff --git a/src/utils/date.rs b/src/utils/date.rs index 7f9f382b..477b82c5 100644 --- a/src/utils/date.rs +++ b/src/utils/date.rs @@ -378,8 +378,8 @@ impl Display for HttpDate { buf[0] = week_day[0]; buf[1] = week_day[1]; buf[2] = week_day[2]; - buf[5] = b'0' + (self.day / 10) as u8; - buf[6] = b'0' + (self.day % 10) as u8; + buf[5] = b'0' + (self.day / 10); + buf[6] = b'0' + (self.day % 10); buf[8] = month[0]; buf[9] = month[1]; buf[10] = month[2]; @@ -387,12 +387,12 @@ impl Display for HttpDate { buf[13] = b'0' + (self.year / 100 % 10) as u8; buf[14] = b'0' + (self.year / 10 % 10) as u8; buf[15] = b'0' + (self.year % 10) as u8; - buf[17] = b'0' + (self.hour / 10) as u8; - buf[18] = b'0' + (self.hour % 10) as u8; - buf[20] = b'0' + (self.minute / 10) as u8; - buf[21] = b'0' + (self.minute % 10) as u8; - buf[23] = b'0' + (self.second / 10) as u8; - buf[24] = b'0' + (self.second % 10) as u8; + buf[17] = b'0' + (self.hour / 10); + buf[18] = b'0' + (self.hour % 10); + buf[20] = b'0' + (self.minute / 10); + buf[21] = b'0' + (self.minute % 10); + buf[23] = b'0' + (self.second / 10); + buf[24] = b'0' + (self.second % 10); f.write_str(from_utf8(&buf[..]).unwrap()) } }