mirrors/ntex
1
0
Fork 0
mirror of https://github.com/ntex-rs/ntex.git synced 2025-04-03 21:07:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

Use custom Error and HeaderValue types

Browse source
This commit is contained in:
Nikolay Kim 2022-11-03 14:00:24 +01:00
parent 75f7cfbc7d
commit c89b083133
21 changed files with 960 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ntex-http/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.1.3] - 2022-11-03
* Use custom `Error` and `HeaderValue` types
## [0.1.2] - 2022-11-01
* Re-export http::Error

4
ntex-http/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex-http"
version = "0.1.2"
version = "0.1.3"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Http types for ntex framework"
keywords = ["network", "framework", "async", "futures"]
@ -19,3 +19,5 @@ path = "src/lib.rs"
http = "0.2"
log = "0.4"
fxhash = "0.2.1"
itoa = "1.0.4"
ntex-bytes = "0.1.15"

154
ntex-http/src/error.rs Normal file
View file

@ -0,0 +1,154 @@
use std::{error, fmt, result};
pub use http::header::InvalidHeaderName;
pub use http::method::InvalidMethod;
pub use http::status::InvalidStatusCode;
pub use http::uri::InvalidUri;
pub use crate::value::{InvalidHeaderValue, ToStrError};
use http::header;
use http::method;
use http::status;
use http::uri;
/// A generic "error" for HTTP connections
///
/// This error type is less specific than the error returned from other
/// functions in this crate, but all other errors can be converted to this
/// error. Consumers of this crate can typically consume and work with this form
/// of error for conversions with the `?` operator.
pub struct Error {
inner: ErrorKind,
}
/// A `Result` typedef to use with the `http::Error` type
pub type Result<T> = result::Result<T, Error>;
enum ErrorKind {
StatusCode(status::InvalidStatusCode),
Method(method::InvalidMethod),
Uri(uri::InvalidUri),
UriParts(uri::InvalidUriParts),
HeaderName(header::InvalidHeaderName),
HeaderValue(InvalidHeaderValue),
}
impl fmt::Debug for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_tuple("ntex_http::Error")
// Skip the noise of the ErrorKind enum
.field(&self.get_ref())
.finish()
}
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(self.get_ref(), f)
}
}
impl Error {
/// Return true if the underlying error has the same type as T.
pub fn is<T: error::Error + 'static>(&self) -> bool {
self.get_ref().is::<T>()
}
/// Return a reference to the lower level, inner error.
pub fn get_ref(&self) -> &(dyn error::Error + 'static) {
use self::ErrorKind::*;
match self.inner {
StatusCode(ref e) => e,
Method(ref e) => e,
Uri(ref e) => e,
UriParts(ref e) => e,
HeaderName(ref e) => e,
HeaderValue(ref e) => e,
}
}
}
impl error::Error for Error {
// Return any available cause from the inner error. Note the inner error is
// not itself the cause.
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
self.get_ref().source()
}
}
impl From<status::InvalidStatusCode> for Error {
fn from(err: status::InvalidStatusCode) -> Error {
Error {
inner: ErrorKind::StatusCode(err),
}
}
}
impl From<method::InvalidMethod> for Error {
fn from(err: method::InvalidMethod) -> Error {
Error {
inner: ErrorKind::Method(err),
}
}
}
impl From<uri::InvalidUri> for Error {
fn from(err: uri::InvalidUri) -> Error {
Error {
inner: ErrorKind::Uri(err),
}
}
}
impl From<uri::InvalidUriParts> for Error {
fn from(err: uri::InvalidUriParts) -> Error {
Error {
inner: ErrorKind::UriParts(err),
}
}
}
impl From<header::InvalidHeaderName> for Error {
fn from(err: header::InvalidHeaderName) -> Error {
Error {
inner: ErrorKind::HeaderName(err),
}
}
}
impl From<InvalidHeaderValue> for Error {
fn from(err: InvalidHeaderValue) -> Error {
Error {
inner: ErrorKind::HeaderValue(err),
}
}
}
impl From<std::convert::Infallible> for Error {
fn from(err: std::convert::Infallible) -> Error {
match err {}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn inner_error_is_invalid_status_code() {
if let Err(e) = status::StatusCode::from_u16(6666) {
let err: Error = e.into();
let ie = err.get_ref();
assert!(!ie.is::<header::InvalidHeaderValue>());
assert!(ie.is::<status::InvalidStatusCode>());
ie.downcast_ref::<status::InvalidStatusCode>().unwrap();
assert!(!err.is::<InvalidHeaderValue>());
assert!(err.is::<status::InvalidStatusCode>());
} else {
panic!("Bad status allowed!");
}
}
}

23
ntex-http/src/lib.rs
View file

@ -1,30 +1,26 @@
//! Http protocol support.
// pub mod body;
pub mod error;
mod map;
mod value;
pub use self::error::Error;
pub use self::map::HeaderMap;
pub use self::value::HeaderValue;
#[doc(hidden)]
pub use self::map::Value;
// re-exports
pub use http::header::{HeaderName, HeaderValue};
pub use http::header::HeaderName;
pub use http::uri::{self, Uri};
pub use http::{Method, StatusCode, Version};
pub mod error {
pub use http::header::{InvalidHeaderName, InvalidHeaderValue};
pub use http::method::InvalidMethod;
pub use http::status::InvalidStatusCode;
pub use http::uri::InvalidUri;
pub use http::Error;
}
/// Convert http::HeaderMap to a HeaderMap
impl From<http::HeaderMap> for HeaderMap {
fn from(map: http::HeaderMap) -> HeaderMap {
let mut new_map = HeaderMap::with_capacity(map.capacity());
for (h, v) in map.iter() {
new_map.append(h.clone(), v.clone());
new_map.append(h.clone(), HeaderValue::from(v));
}
new_map
}
@ -35,10 +31,9 @@ pub mod header {
#[doc(hidden)]
pub use crate::map::{AsName, Either, GetAll, Iter, Value};
pub use crate::value::{HeaderValue, InvalidHeaderValue, ToStrError};
pub use http::header::{
HeaderName, HeaderValue, InvalidHeaderName, InvalidHeaderValue,
};
pub use http::header::{HeaderName, InvalidHeaderName};
pub use http::header::{
ACCEPT, ACCEPT_CHARSET, ACCEPT_ENCODING, ACCEPT_LANGUAGE, ACCEPT_RANGES,
ACCESS_CONTROL_ALLOW_CREDENTIALS, ACCESS_CONTROL_ALLOW_HEADERS,

4
ntex-http/src/map.rs
View file

@ -1,8 +1,8 @@
use core::iter::FromIterator;
use std::collections::{self, hash_map, hash_map::Entry};
use std::convert::TryFrom;
use std::iter::FromIterator;
use http::header::{HeaderName, HeaderValue};
use crate::{HeaderName, HeaderValue};
type HashMap<K, V> = collections::HashMap<K, V, fxhash::FxBuildHasher>;

738
ntex-http/src/value.rs Normal file
View file

@ -0,0 +1,738 @@
#![allow(
clippy::derive_hash_xor_eq,
clippy::should_implement_trait,
clippy::no_effect,
clippy::missing_safety_doc
)]
use std::{cmp, convert::TryFrom, error::Error, fmt, str, str::FromStr};
use ntex_bytes::Bytes;
/// Represents an HTTP header field value.
///
/// In practice, HTTP header field values are usually valid ASCII. However, the
/// HTTP spec allows for a header value to contain opaque bytes as well. In this
/// case, the header field value is not able to be represented as a string.
///
/// To handle this, the `HeaderValue` is useable as a type and can be compared
/// with strings and implements `Debug`. A `to_str` fn is provided that returns
/// an `Err` if the header value contains non visible ascii characters.
#[derive(Clone, Hash)]
pub struct HeaderValue {
inner: Bytes,
is_sensitive: bool,
}
/// A possible error when converting a `HeaderValue` from a string or byte
/// slice.
pub struct InvalidHeaderValue {
_priv: (),
}
/// A possible error when converting a `HeaderValue` to a string representation.
///
/// Header field values may contain opaque bytes, in which case it is not
/// possible to represent the value as a string.
#[derive(Debug)]
pub struct ToStrError {
_priv: (),
}
impl HeaderValue {
/// Convert a static string to a `HeaderValue`.
///
/// This function will not perform any copying, however the string is
/// checked to ensure that no invalid characters are present. Only visible
/// ASCII characters (32-127) are permitted.
///
/// # Panics
///
/// This function panics if the argument contains invalid header value
/// characters.
///
/// Until [Allow panicking in constants](https://github.com/rust-lang/rfcs/pull/2345)
/// makes its way into stable, the panic message at compile-time is
/// going to look cryptic, but should at least point at your header value:
///
/// ```text
/// error: any use of this value will cause an error
/// --> http/src/header/value.rs:67:17
/// |
/// 67 | ([] as [u8; 0])[0]; // Invalid header value
/// | ^^^^^^^^^^^^^^^^^^
/// | |
/// | index out of bounds: the length is 0 but the index is 0
/// | inside `HeaderValue::from_static` at http/src/header/value.rs:67:17
/// | inside `INVALID_HEADER` at src/main.rs:73:33
/// |
/// ::: src/main.rs:73:1
/// |
/// 73 | const INVALID_HEADER: HeaderValue = HeaderValue::from_static("жsome value");
/// | ----------------------------------------------------------------------------
/// ```
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_static("hello");
/// assert_eq!(val, "hello");
/// ```
#[inline]
#[allow(unconditional_panic)] // required for the panic circumvention
pub const fn from_static(src: &'static str) -> HeaderValue {
let bytes = src.as_bytes();
let mut i = 0;
while i < bytes.len() {
if !is_visible_ascii(bytes[i]) {
([] as [u8; 0])[0]; // Invalid header value
}
i += 1;
}
HeaderValue {
inner: Bytes::from_static(bytes),
is_sensitive: false,
}
}
/// Attempt to convert a string to a `HeaderValue`.
///
/// If the argument contains invalid header value characters, an error is
/// returned. Only visible ASCII characters (32-127) are permitted. Use
/// `from_bytes` to create a `HeaderValue` that includes opaque octets
/// (128-255).
///
/// This function is intended to be replaced in the future by a `TryFrom`
/// implementation once the trait is stabilized in std.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_str("hello").unwrap();
/// assert_eq!(val, "hello");
/// ```
///
/// An invalid value
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_str("\n");
/// assert!(val.is_err());
/// ```
#[inline]
pub fn from_str(src: &str) -> Result<HeaderValue, InvalidHeaderValue> {
HeaderValue::try_from_generic(src, |s| Bytes::copy_from_slice(s.as_bytes()))
}
/// Attempt to convert a byte slice to a `HeaderValue`.
///
/// If the argument contains invalid header value bytes, an error is
/// returned. Only byte values between 32 and 255 (inclusive) are permitted,
/// excluding byte 127 (DEL).
///
/// This function is intended to be replaced in the future by a `TryFrom`
/// implementation once the trait is stabilized in std.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_bytes(b"hello\xfa").unwrap();
/// assert_eq!(val, &b"hello\xfa"[..]);
/// ```
///
/// An invalid value
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_bytes(b"\n");
/// assert!(val.is_err());
/// ```
#[inline]
pub fn from_bytes(src: &[u8]) -> Result<HeaderValue, InvalidHeaderValue> {
HeaderValue::try_from_generic(src, Bytes::copy_from_slice)
}
/// Attempt to convert a `Bytes` buffer to a `HeaderValue`.
///
/// This will try to prevent a copy if the type passed is the type used
/// internally, and will copy the data if it is not.
pub fn from_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue>
where
Bytes: From<T>,
{
let inner = Bytes::from(src);
for &b in inner.as_ref() {
if !is_valid(b) {
return Err(InvalidHeaderValue { _priv: () });
}
}
Ok(HeaderValue {
inner,
is_sensitive: false,
})
}
/// Attempt to convert a `Bytes` buffer to a `HeaderValue`.
///
/// This will try to prevent a copy if the type passed is the type used
/// internally, and will copy the data if it is not.
pub unsafe fn from_shared_unchecked(src: Bytes) -> HeaderValue {
HeaderValue {
inner: src,
is_sensitive: false,
}
}
#[deprecated]
#[doc(hidden)]
pub fn from_maybe_shared<T>(src: T) -> Result<HeaderValue, InvalidHeaderValue>
where
Bytes: From<T>,
{
HeaderValue::from_shared(src)
}
#[deprecated]
#[doc(hidden)]
pub unsafe fn from_maybe_shared_unchecked(inner: Bytes) -> HeaderValue {
HeaderValue::from_shared_unchecked(inner)
}
fn try_from_generic<T: AsRef<[u8]>, F: FnOnce(T) -> Bytes>(
src: T,
into: F,
) -> Result<HeaderValue, InvalidHeaderValue> {
for &b in src.as_ref() {
if !is_valid(b) {
return Err(InvalidHeaderValue { _priv: () });
}
}
Ok(HeaderValue {
inner: into(src),
is_sensitive: false,
})
}
/// Yields a `&str` slice if the `HeaderValue` only contains visible ASCII
/// chars.
///
/// This function will perform a scan of the header value, checking all the
/// characters.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_static("hello");
/// assert_eq!(val.to_str().unwrap(), "hello");
/// ```
pub fn to_str(&self) -> Result<&str, ToStrError> {
let bytes = self.as_ref();
for &b in bytes {
if !is_visible_ascii(b) {
return Err(ToStrError { _priv: () });
}
}
unsafe { Ok(str::from_utf8_unchecked(bytes)) }
}
/// Returns the length of `self`.
///
/// This length is in bytes.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_static("hello");
/// assert_eq!(val.len(), 5);
/// ```
#[inline]
pub fn len(&self) -> usize {
self.as_ref().len()
}
/// Returns true if the `HeaderValue` has a length of zero bytes.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_static("");
/// assert!(val.is_empty());
///
/// let val = HeaderValue::from_static("hello");
/// assert!(!val.is_empty());
/// ```
#[inline]
pub fn is_empty(&self) -> bool {
self.len() == 0
}
/// Converts a `HeaderValue` to a byte slice.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let val = HeaderValue::from_static("hello");
/// assert_eq!(val.as_bytes(), b"hello");
/// ```
#[inline]
pub fn as_bytes(&self) -> &[u8] {
self.as_ref()
}
/// Mark that the header value represents sensitive information.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let mut val = HeaderValue::from_static("my secret");
///
/// val.set_sensitive(true);
/// assert!(val.is_sensitive());
///
/// val.set_sensitive(false);
/// assert!(!val.is_sensitive());
/// ```
#[inline]
pub fn set_sensitive(&mut self, val: bool) {
self.is_sensitive = val;
}
/// Returns `true` if the value represents sensitive data.
///
/// Sensitive data could represent passwords or other data that should not
/// be stored on disk or in memory. By marking header values as sensitive,
/// components using this crate can be instructed to treat them with special
/// care for security reasons. For example, caches can avoid storing
/// sensitive values, and HPACK encoders used by HTTP/2.0 implementations
/// can choose not to compress them.
///
/// Additionally, sensitive values will be masked by the `Debug`
/// implementation of `HeaderValue`.
///
/// Note that sensitivity is not factored into equality or ordering.
///
/// # Examples
///
/// ```
/// # use ntex_http::header::HeaderValue;
/// let mut val = HeaderValue::from_static("my secret");
///
/// val.set_sensitive(true);
/// assert!(val.is_sensitive());
///
/// val.set_sensitive(false);
/// assert!(!val.is_sensitive());
/// ```
#[inline]
pub fn is_sensitive(&self) -> bool {
self.is_sensitive
}
}
impl AsRef<[u8]> for HeaderValue {
#[inline]
fn as_ref(&self) -> &[u8] {
self.inner.as_ref()
}
}
impl fmt::Debug for HeaderValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.is_sensitive {
f.write_str("Sensitive")
} else {
f.write_str("\"")?;
let mut from = 0;
let bytes = self.as_bytes();
for (i, &b) in bytes.iter().enumerate() {
if !is_visible_ascii(b) || b == b'"' {
if from != i {
f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..i]) })?;
}
if b == b'"' {
f.write_str("\\\"")?;
} else {
write!(f, "\\x{:x}", b)?;
}
from = i + 1;
}
}
f.write_str(unsafe { str::from_utf8_unchecked(&bytes[from..]) })?;
f.write_str("\"")
}
}
}
impl FromStr for HeaderValue {
type Err = InvalidHeaderValue;
#[inline]
fn from_str(s: &str) -> Result<HeaderValue, Self::Err> {
HeaderValue::from_str(s)
}
}
impl<'a> From<&'a HeaderValue> for HeaderValue {
#[inline]
fn from(t: &'a HeaderValue) -> Self {
t.clone()
}
}
impl From<http::header::HeaderValue> for HeaderValue {
#[inline]
fn from(t: http::header::HeaderValue) -> Self {
let inner = Bytes::copy_from_slice(t.as_ref());
HeaderValue {
inner,
is_sensitive: t.is_sensitive(),
}
}
}
impl<'a> From<&'a http::header::HeaderValue> for HeaderValue {
#[inline]
fn from(t: &'a http::header::HeaderValue) -> Self {
let inner = Bytes::copy_from_slice(t.as_ref());
HeaderValue {
inner,
is_sensitive: t.is_sensitive(),
}
}
}
impl<'a> TryFrom<&'a str> for HeaderValue {
type Error = InvalidHeaderValue;
#[inline]
fn try_from(t: &'a str) -> Result<Self, Self::Error> {
t.parse()
}
}
impl<'a> TryFrom<&'a String> for HeaderValue {
type Error = InvalidHeaderValue;
#[inline]
fn try_from(s: &'a String) -> Result<Self, Self::Error> {
Self::from_bytes(s.as_bytes())
}
}
impl<'a> TryFrom<&'a [u8]> for HeaderValue {
type Error = InvalidHeaderValue;
#[inline]
fn try_from(t: &'a [u8]) -> Result<Self, Self::Error> {
HeaderValue::from_bytes(t)
}
}
impl TryFrom<String> for HeaderValue {
type Error = InvalidHeaderValue;
#[inline]
fn try_from(s: String) -> Result<Self, Self::Error> {
HeaderValue::from_shared(s)
}
}
impl TryFrom<Vec<u8>> for HeaderValue {
type Error = InvalidHeaderValue;
#[inline]
fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
HeaderValue::from_shared(vec)
}
}
const fn is_visible_ascii(b: u8) -> bool {
b >= 32 && b < 127 || b == b'\t'
}
#[inline]
fn is_valid(b: u8) -> bool {
b >= 32 && b != 127 || b == b'\t'
}
impl Error for InvalidHeaderValue {}
impl fmt::Debug for InvalidHeaderValue {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("InvalidHeaderValue")
// skip _priv noise
.finish()
}
}
impl fmt::Display for InvalidHeaderValue {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("failed to parse header value")
}
}
impl Error for ToStrError {}
impl fmt::Display for ToStrError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("failed to convert header to a str")
}
}
// ===== PartialEq / PartialOrd =====
impl PartialEq for HeaderValue {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
self.inner == other.inner
}
}
impl Eq for HeaderValue {}
impl PartialOrd for HeaderValue {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
self.inner.partial_cmp(&other.inner)
}
}
impl Ord for HeaderValue {
#[inline]
fn cmp(&self, other: &Self) -> cmp::Ordering {
self.inner.cmp(&other.inner)
}
}
impl PartialEq<str> for HeaderValue {
#[inline]
fn eq(&self, other: &str) -> bool {
self.inner == other.as_bytes()
}
}
impl PartialEq<[u8]> for HeaderValue {
#[inline]
fn eq(&self, other: &[u8]) -> bool {
self.inner == other
}
}
impl PartialOrd<str> for HeaderValue {
#[inline]
fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
(*self.inner).partial_cmp(other.as_bytes())
}
}
impl PartialOrd<[u8]> for HeaderValue {
#[inline]
fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
(*self.inner).partial_cmp(other)
}
}
impl PartialEq<HeaderValue> for str {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
*other == *self
}
}
impl PartialEq<HeaderValue> for [u8] {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
*other == *self
}
}
impl PartialOrd<HeaderValue> for str {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
self.as_bytes().partial_cmp(other.as_bytes())
}
}
impl PartialOrd<HeaderValue> for [u8] {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
self.partial_cmp(other.as_bytes())
}
}
impl PartialEq<String> for HeaderValue {
#[inline]
fn eq(&self, other: &String) -> bool {
*self == other[..]
}
}
impl PartialOrd<String> for HeaderValue {
#[inline]
fn partial_cmp(&self, other: &String) -> Option<cmp::Ordering> {
self.inner.partial_cmp(other.as_bytes())
}
}
impl PartialEq<HeaderValue> for String {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
*other == *self
}
}
impl PartialOrd<HeaderValue> for String {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
self.as_bytes().partial_cmp(other.as_bytes())
}
}
impl<'a> PartialEq<HeaderValue> for &'a HeaderValue {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
**self == *other
}
}
impl<'a> PartialOrd<HeaderValue> for &'a HeaderValue {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
(**self).partial_cmp(other)
}
}
impl<'a, T: ?Sized> PartialEq<&'a T> for HeaderValue
where
HeaderValue: PartialEq<T>,
{
#[inline]
fn eq(&self, other: &&'a T) -> bool {
*self == **other
}
}
impl<'a, T: ?Sized> PartialOrd<&'a T> for HeaderValue
where
HeaderValue: PartialOrd<T>,
{
#[inline]
fn partial_cmp(&self, other: &&'a T) -> Option<cmp::Ordering> {
self.partial_cmp(*other)
}
}
impl<'a> PartialEq<HeaderValue> for &'a str {
#[inline]
fn eq(&self, other: &HeaderValue) -> bool {
*other == *self
}
}
impl<'a> PartialOrd<HeaderValue> for &'a str {
#[inline]
fn partial_cmp(&self, other: &HeaderValue) -> Option<cmp::Ordering> {
self.as_bytes().partial_cmp(other.as_bytes())
}
}
macro_rules! from_integers {
($($name:ident: $t:ident => $max_len:expr),*) => {$(
impl From<$t> for HeaderValue {
fn from(num: $t) -> HeaderValue {
let mut b = itoa::Buffer::new();
let inner = Bytes::copy_from_slice(b.format(num).as_ref());
HeaderValue {
inner,
is_sensitive: false,
}
}
}
#[test]
fn $name() {
let n: $t = 55;
let val = HeaderValue::from(n);
assert_eq!(val, &n.to_string());
let n = ::std::$t::MAX;
let val = HeaderValue::from(n);
assert_eq!(val, &n.to_string());
}
)*};
}
from_integers! {
// integer type => maximum decimal length
// u8 purposely left off... HeaderValue::from(b'3') could be confusing
from_u16: u16 => 5,
from_i16: i16 => 6,
from_u32: u32 => 10,
from_i32: i32 => 11,
from_u64: u64 => 20,
from_i64: i64 => 20
}
#[cfg(target_pointer_width = "16")]
from_integers! {
from_usize: usize => 5,
from_isize: isize => 6
}
#[cfg(target_pointer_width = "32")]
from_integers! {
from_usize: usize => 10,
from_isize: isize => 11
}
#[cfg(target_pointer_width = "64")]
from_integers! {
from_usize: usize => 20,
from_isize: isize => 20
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_try_from() {
HeaderValue::try_from(vec![127]).unwrap_err();
}
#[test]
fn it_converts_using_try_from() {
assert!(HeaderValue::from_bytes(b"upgrade").is_ok());
}
#[test]
fn test_debug() {
let cases = &[
("hello", "\"hello\""),
("hello \"world\"", "\"hello \\\"world\\\"\""),
("\u{7FFF}hello", "\"\\xe7\\xbf\\xbfhello\""),
];
for &(value, expected) in cases {
let val = HeaderValue::from_bytes(value.as_bytes()).unwrap();
let actual = format!("{:?}", val);
assert_eq!(expected, actual);
}
let mut sensitive = HeaderValue::from_static("password");
sensitive.set_sensitive(true);
assert_eq!("Sensitive", format!("{:?}", sensitive));
}
}

4
ntex/CHANGES.md
View file

@ -1,5 +1,9 @@
# Changes
## [0.5.28] - 2022-11-03
* Drop direct http crate dependency
## [0.5.27] - 2022-09-20
* server: Fix ServerBuilder::configure_async() helper method

5
ntex/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ntex"
version = "0.5.27"
version = "0.5.28"
authors = ["ntex contributors <team@ntex.rs>"]
description = "Framework for composable network services"
readme = "README.md"
@ -50,7 +50,7 @@ async-std = ["ntex-rt/async-std", "ntex-async-std", "ntex-connect/async-std"]
[dependencies]
ntex-codec = "0.6.2"
ntex-connect = "0.1.0"
ntex-http = "0.1.0"
ntex-http = "0.1.3"
ntex-router = "0.5.1"
ntex-service = "0.3.2"
ntex-macros = "0.1.3"
@ -80,7 +80,6 @@ socket2 = "0.4"
thiserror = "1.0"
# http/web framework
http = "0.2"
httparse = "1.6.0"
httpdate = "1.0"
encoding_rs = "0.8"

2
ntex/src/http/client/h1proto.rs
View file

@ -35,7 +35,7 @@ where
Some(port) => write!(wrt, "{}:{}", host, port),
};
match HeaderValue::from_maybe_shared(wrt.get_mut().split()) {
match HeaderValue::from_shared(wrt.get_mut().split()) {
Ok(value) => match head {
RequestHeadType::Owned(ref mut head) => {
head.headers.insert(HOST, value)

6
ntex/src/http/error.rs
View file

@ -1,12 +1,12 @@
//! Http related errors
use std::{error, fmt, io, io::Write, str::Utf8Error, string::FromUtf8Error};
use http::{header, uri::InvalidUri, StatusCode};
use ntex_h2::{self as h2};
use ntex_http::{header, uri::InvalidUri, StatusCode};
// re-export for convinience
pub use crate::channel::Canceled;
pub use http::Error as HttpError;
pub use ntex_http::error::Error as HttpError;
use crate::http::body::Body;
use crate::http::response::Response;
@ -277,7 +277,7 @@ impl From<BlockingError<io::Error>> for PayloadError {
#[cfg(test)]
mod tests {
use super::*;
use http::{Error as HttpError, StatusCode};
use ntex_http::{Error as HttpError, StatusCode};
use std::io;
#[test]

6
ntex/src/http/h1/decoder.rs
View file

@ -1,7 +1,7 @@
use std::{cell::Cell, convert::TryFrom, marker::PhantomData, mem, task::Poll};
use http::header::{HeaderName, HeaderValue};
use http::{header, Method, StatusCode, Uri, Version};
use ntex_http::header::{HeaderName, HeaderValue};
use ntex_http::{header, Method, StatusCode, Uri, Version};
use crate::codec::Decoder;
use crate::http::error::ParseError;
@ -100,7 +100,7 @@ pub(super) trait MessageType: Sized {
// Unsafe: httparse check header value for valid utf-8
let value = unsafe {
HeaderValue::from_maybe_shared_unchecked(
HeaderValue::from_shared_unchecked(
slice.slice(idx.value.0..idx.value.1),
)
};

2
ntex/src/http/h2/service.rs
View file

@ -486,7 +486,7 @@ fn prepare_response(timer: &DateService, head: &mut ResponseHead, size: &mut Bod
let mut bytes = BytesMut::with_capacity(29);
timer.set_date(|date| bytes.extend_from_slice(date));
head.headers.insert(header::DATE, unsafe {
HeaderValue::from_maybe_shared_unchecked(bytes.freeze())
HeaderValue::from_shared_unchecked(bytes.freeze())
});
}
}

4
ntex/src/http/header.rs
View file

@ -1,8 +1,8 @@
//! Various http headers
pub use http::header::{HeaderName, HeaderValue, InvalidHeaderValue};
pub use ntex_http::header::{HeaderName, HeaderValue, InvalidHeaderValue};
pub use http::header::*;
pub use ntex_http::header::*;
#[doc(hidden)]
pub use ntex_http::header::{AsName, GetAll, Value};
pub use ntex_http::HeaderMap;

2
ntex/src/http/httpmessage.rs
View file

@ -2,8 +2,8 @@ use std::cell::{Ref, RefMut};
use std::str;
use encoding_rs::{Encoding, UTF_8};
use http::header;
use mime::Mime;
use ntex_http::header;
#[cfg(feature = "cookie")]
use coo_kie::Cookie;

2
ntex/src/web/error.rs
View file

@ -3,7 +3,7 @@ use std::{cell::RefCell, fmt, io::Write, marker::PhantomData};
use thiserror::Error;
pub use http::Error as HttpError;
pub use ntex_http::error::Error as HttpError;
pub use serde_json::error::Error as JsonError;
#[cfg(feature = "url")]
pub use url_pkg::ParseError as UrlParseError;

24
ntex/src/web/guard.rs
View file

@ -28,7 +28,7 @@
#![allow(non_snake_case)]
use std::convert::TryFrom;
use crate::http::{header, RequestHead, Uri};
use crate::http::{header, Method, RequestHead, Uri};
/// Trait defines resource guards. Guards are used for route selection.
///
@ -178,7 +178,7 @@ impl Guard for NotGuard {
/// Http method guard
#[doc(hidden)]
pub struct MethodGuard(http::Method);
pub struct MethodGuard(Method);
impl Guard for MethodGuard {
fn check(&self, request: &RequestHead) -> bool {
@ -188,51 +188,51 @@ impl Guard for MethodGuard {
/// Guard to match *GET* http method
pub fn Get() -> MethodGuard {
MethodGuard(http::Method::GET)
MethodGuard(Method::GET)
}
/// Predicate to match *POST* http method
pub fn Post() -> MethodGuard {
MethodGuard(http::Method::POST)
MethodGuard(Method::POST)
}
/// Predicate to match *PUT* http method
pub fn Put() -> MethodGuard {
MethodGuard(http::Method::PUT)
MethodGuard(Method::PUT)
}
/// Predicate to match *DELETE* http method
pub fn Delete() -> MethodGuard {
MethodGuard(http::Method::DELETE)
MethodGuard(Method::DELETE)
}
/// Predicate to match *HEAD* http method
pub fn Head() -> MethodGuard {
MethodGuard(http::Method::HEAD)
MethodGuard(Method::HEAD)
}
/// Predicate to match *OPTIONS* http method
pub fn Options() -> MethodGuard {
MethodGuard(http::Method::OPTIONS)
MethodGuard(Method::OPTIONS)
}
/// Predicate to match *CONNECT* http method
pub fn Connect() -> MethodGuard {
MethodGuard(http::Method::CONNECT)
MethodGuard(Method::CONNECT)
}
/// Predicate to match *PATCH* http method
pub fn Patch() -> MethodGuard {
MethodGuard(http::Method::PATCH)
MethodGuard(Method::PATCH)
}
/// Predicate to match *TRACE* http method
pub fn Trace() -> MethodGuard {
MethodGuard(http::Method::TRACE)
MethodGuard(Method::TRACE)
}
/// Predicate to match specified http method
pub fn Method(method: http::Method) -> MethodGuard {
pub fn Method(method: Method) -> MethodGuard {
MethodGuard(method)
}

2
ntex/src/web/route.rs
View file

@ -108,7 +108,7 @@ impl<Err: ErrorRenderer> Route<Err> {
/// # fn main() {
/// App::new().service(web::resource("/path").route(
/// web::route()
/// .method(http::Method::CONNECT)
/// .method(ntex::http::Method::CONNECT)
/// .guard(guard::Header("content-type", "text/plain"))
/// .to(|req: HttpRequest| async { HttpResponse::Ok() }))
/// );

2
ntex/src/web/util.rs
View file

@ -195,7 +195,7 @@ pub fn head<Err: ErrorRenderer>() -> Route<Err> {
/// Create *route* and add method guard.
///
/// ```rust
/// use ntex::web;
/// use ntex::{http, web};
///
/// let app = web::App::new().service(
/// web::resource("/{project_id}")

4
ntex/tests/http_awc_client.rs
View file

@ -12,7 +12,7 @@ use rand::Rng;
use ntex::http::client::error::{JsonPayloadError, SendRequestError};
use ntex::http::client::{Client, Connector};
use ntex::http::test::server as test_server;
use ntex::http::{header, HttpMessage, HttpService};
use ntex::http::{header, HttpMessage, HttpService, Method};
use ntex::service::{map_config, pipeline_factory};
use ntex::web::dev::AppConfig;
use ntex::web::middleware::Compress;
@ -586,7 +586,7 @@ async fn test_client_brotli_encoding_large_random() {
// frozen request
let request = srv.post("/").timeout(Seconds(30)).freeze().unwrap();
assert_eq!(request.get_method(), http::Method::POST);
assert_eq!(request.get_method(), Method::POST);
assert_eq!(request.get_uri(), srv.url("/").as_str());
let mut response = request.send_body(data.clone()).await.unwrap();
assert!(response.status().is_success());

2
ntex/tests/http_client.rs
View file

@ -44,7 +44,7 @@ async fn test_h1_v2() {
let bytes = response.body().await.unwrap();
assert_eq!(bytes, Bytes::from_static(STR.as_ref()));
let mut response = srv.request(http::Method::POST, "/").send().await.unwrap();
let mut response = srv.request(Method::POST, "/").send().await.unwrap();
assert!(response.status().is_success());
// read response

39
ntex/tests/http_server.rs
View file

@ -4,10 +4,10 @@ use futures_util::future::{self, FutureExt};
use futures_util::stream::{once, StreamExt};
use regex::Regex;
use ntex::http::header::{HeaderName, HeaderValue};
use ntex::http::header::{self, HeaderName, HeaderValue};
use ntex::http::test::server as test_server;
use ntex::http::{
body, header, HttpService, KeepAlive, Method, Request, Response, StatusCode,
body, HttpService, KeepAlive, Method, Request, Response, StatusCode, Version,
};
use ntex::time::{sleep, Millis, Seconds};
use ntex::{service::fn_service, util::Bytes, util::Ready, web::error};
@ -38,7 +38,7 @@ async fn test_h1_2() {
.disconnect_timeout(Seconds(1))
.finish(|req: Request| {
assert!(req.peer_addr().is_some());
assert_eq!(req.version(), http::Version::HTTP_11);
assert_eq!(req.version(), Version::HTTP_11);
Ready::Ok::<_, io::Error>(Response::Ok().finish())
})
});
@ -336,17 +336,17 @@ async fn test_content_length() {
{
for i in 0..4 {
let req = srv.request(http::Method::GET, &format!("/{}", i));
let req = srv.request(Method::GET, &format!("/{}", i));
let response = req.send().await.unwrap();
assert_eq!(response.headers().get(&header), None);
let req = srv.request(http::Method::HEAD, &format!("/{}", i));
let req = srv.request(Method::HEAD, &format!("/{}", i));
let response = req.send().await.unwrap();
assert_eq!(response.headers().get(&header), None);
}
for i in 4..6 {
let req = srv.request(http::Method::GET, &format!("/{}", i));
let req = srv.request(Method::GET, &format!("/{}", i));
let response = req.send().await.unwrap();
assert_eq!(response.headers().get(&header), Some(&value));
}
@ -434,14 +434,11 @@ async fn test_h1_head_empty() {
HttpService::build().h1(|_| Ready::Ok::<_, io::Error>(Response::Ok().body(STR)))
});
let response = srv.request(http::Method::HEAD, "/").send().await.unwrap();
let response = srv.request(Method::HEAD, "/").send().await.unwrap();
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
@ -460,14 +457,11 @@ async fn test_h1_head_binary() {
})
});
let response = srv.request(http::Method::HEAD, "/").send().await.unwrap();
let response = srv.request(Method::HEAD, "/").send().await.unwrap();
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
@ -482,14 +476,11 @@ async fn test_h1_head_binary2() {
HttpService::build().h1(|_| Ready::Ok::<_, io::Error>(Response::Ok().body(STR)))
});
let response = srv.request(http::Method::HEAD, "/").send().await.unwrap();
let response = srv.request(Method::HEAD, "/").send().await.unwrap();
assert!(response.status().is_success());
{
let len = response
.headers()
.get(http::header::CONTENT_LENGTH)
.unwrap();
let len = response.headers().get(header::CONTENT_LENGTH).unwrap();
assert_eq!(format!("{}", STR.len()), len.to_str().unwrap());
}
}
@ -578,14 +569,14 @@ async fn test_h1_response_http_error_handling() {
let broken_header = Bytes::from_static(b"\0\0\0");
Ready::Ok::<_, io::Error>(
Response::Ok()
.header(http::header::CONTENT_TYPE, &broken_header[..])
.header(header::CONTENT_TYPE, &broken_header[..])
.body(STR),
)
}))
});
let response = srv.request(Method::GET, "/").send().await.unwrap();
assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
// read response
let bytes = srv.load_body(response).await.unwrap();
@ -604,7 +595,7 @@ async fn test_h1_service_error() {
});
let response = srv.request(Method::GET, "/").send().await.unwrap();
assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
// read response
let bytes = srv.load_body(response).await.unwrap();