wreq-rb 0.3.0

data/vendor/wreq/src/client/core/error.rs

@@ -0,0 +1,435 @@
+//! Error and Result module.
+use std::{error::Error as StdError, fmt};
+
+/// Result type often returned from methods that can have crate::core: `Error`s.
+pub type Result<T> = std::result::Result<T, Error>;
+
+pub type BoxError = Box<dyn StdError + Send + Sync>;
+
+type Cause = BoxError;
+
+/// Represents errors that can occur handling HTTP streams.
+///
+/// # Formatting
+///
+/// The `Display` implementation of this type will only print the details of
+/// this level of error, even though it may have been caused by another error
+/// and contain that error in its source. To print all the relevant
+/// information, including the source chain, using something like
+/// `std::error::Report`, or equivalent 3rd party types.
+///
+/// The contents of the formatted error message of this specific `Error` type
+/// is unspecified. **You must not depend on it.** The wording and details may
+/// change in any version, with the goal of improving error messages.
+///
+/// # Source
+///
+/// A `crate::core::Error` may be caused by another error. To aid in debugging,
+/// those are exposed in `Error::source()` as erased types. While it is
+/// possible to check the exact type of the sources, they **can not be depended
+/// on**. They may come from private internal dependencies, and are subject to
+/// change at any moment.
+pub struct Error {
+    inner: Box<ErrorImpl>,
+}
+
+struct ErrorImpl {
+    kind: Kind,
+    cause: Option<Cause>,
+}
+
+#[derive(Debug)]
+pub(super) enum Kind {
+    Parse(Parse),
+    User(User),
+    /// A message reached EOF, but is not complete.
+    IncompleteMessage,
+    /// A connection received a message (or bytes) when not waiting for one.
+    UnexpectedMessage,
+    /// A pending item was dropped before ever being processed.
+    Canceled,
+    /// Indicates a channel (client or body sender) is closed.
+    ChannelClosed,
+    /// An `io::Error` that occurred while trying to read or write to a network stream.
+    Io,
+    /// Error while reading a body from connection.
+    Body,
+    /// Error while writing a body to connection.
+    BodyWrite,
+    /// Error calling AsyncWrite::shutdown()
+    Shutdown,
+    /// A general error from h2.
+    Http2,
+}
+
+#[derive(Debug)]
+pub(crate) enum Parse {
+    Method,
+    Version,
+    VersionH2,
+    Uri,
+    Header(Header),
+    TooLarge,
+    Status,
+    Internal,
+}
+
+#[derive(Debug)]
+pub(crate) enum Header {
+    Token,
+    ContentLengthInvalid,
+    TransferEncodingUnexpected,
+}
+
+#[derive(Debug)]
+pub(super) enum User {
+    /// Error calling user's Body::poll_data().
+    Body,
+    /// The user aborted writing of the outgoing body.
+    BodyWriteAborted,
+
+    /// User tried to send a connect request with a nonzero body
+    InvalidConnectWithBody,
+
+    /// Error from future of user's Service.
+    Service,
+
+    /// User tried polling for an upgrade that doesn't exist.
+    NoUpgrade,
+
+    /// User polled for an upgrade, but low-level API is not using upgrades.
+    ManualUpgrade,
+
+    /// The dispatch task is gone.
+    DispatchGone,
+}
+
+// Sentinel type to indicate the error was caused by a timeout.
+#[derive(Debug)]
+pub(super) struct TimedOut;
+
+impl Error {
+    /// Returns true if this was an HTTP parse error.
+    pub fn is_parse(&self) -> bool {
+        matches!(self.inner.kind, Kind::Parse(_))
+    }
+
+    /// Returns true if this was an HTTP parse error caused by an invalid response status code or
+    /// reason phrase.
+    pub fn is_parse_status(&self) -> bool {
+        matches!(self.inner.kind, Kind::Parse(Parse::Status))
+    }
+
+    /// Returns true if this error was caused by user code.
+    pub fn is_user(&self) -> bool {
+        matches!(self.inner.kind, Kind::User(_))
+    }
+
+    /// Returns true if this was about a `Request` that was canceled.
+    pub fn is_canceled(&self) -> bool {
+        matches!(self.inner.kind, Kind::Canceled)
+    }
+
+    /// Returns true if a sender's channel is closed.
+    pub fn is_closed(&self) -> bool {
+        matches!(self.inner.kind, Kind::ChannelClosed)
+    }
+
+    /// Returns true if the connection closed before a message could complete.
+    pub fn is_incomplete_message(&self) -> bool {
+        matches!(self.inner.kind, Kind::IncompleteMessage)
+    }
+
+    /// Returns true if the body write was aborted.
+    pub fn is_body_write_aborted(&self) -> bool {
+        matches!(self.inner.kind, Kind::User(User::BodyWriteAborted))
+    }
+
+    /// Returns true if the error was caused by a timeout.
+    pub fn is_timeout(&self) -> bool {
+        self.find_source::<TimedOut>().is_some()
+    }
+
+    pub(super) fn new(kind: Kind) -> Error {
+        Error {
+            inner: Box::new(ErrorImpl { kind, cause: None }),
+        }
+    }
+
+    pub(super) fn with<C: Into<Cause>>(mut self, cause: C) -> Error {
+        self.inner.cause = Some(cause.into());
+        self
+    }
+
+    pub(crate) fn find_source<E: StdError + 'static>(&self) -> Option<&E> {
+        let mut cause = self.source();
+        while let Some(err) = cause {
+            if let Some(typed) = err.downcast_ref() {
+                return Some(typed);
+            }
+            cause = err.source();
+        }
+
+        // else
+        None
+    }
+
+    pub(super) fn h2_reason(&self) -> http2::Reason {
+        // Find an http2::Reason somewhere in the cause stack, if it exists,
+        // otherwise assume an INTERNAL_ERROR.
+        self.find_source::<http2::Error>()
+            .and_then(|h2_err| h2_err.reason())
+            .unwrap_or(http2::Reason::INTERNAL_ERROR)
+    }
+
+    pub(super) fn new_canceled() -> Error {
+        Error::new(Kind::Canceled)
+    }
+
+    pub(super) fn new_incomplete() -> Error {
+        Error::new(Kind::IncompleteMessage)
+    }
+
+    pub(super) fn new_too_large() -> Error {
+        Error::new(Kind::Parse(Parse::TooLarge))
+    }
+
+    pub(super) fn new_version_h2() -> Error {
+        Error::new(Kind::Parse(Parse::VersionH2))
+    }
+
+    pub(super) fn new_unexpected_message() -> Error {
+        Error::new(Kind::UnexpectedMessage)
+    }
+
+    pub(super) fn new_io(cause: std::io::Error) -> Error {
+        Error::new(Kind::Io).with(cause)
+    }
+
+    pub(super) fn new_closed() -> Error {
+        Error::new(Kind::ChannelClosed)
+    }
+
+    pub(super) fn new_body<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::Body).with(cause)
+    }
+
+    pub(super) fn new_body_write<E: Into<Cause>>(cause: E) -> Error {
+        Error::new(Kind::BodyWrite).with(cause)
+    }
+
+    pub(super) fn new_body_write_aborted() -> Error {
+        Error::new(Kind::User(User::BodyWriteAborted))
+    }
+
+    fn new_user(user: User) -> Error {
+        Error::new(Kind::User(user))
+    }
+
+    pub(super) fn new_user_no_upgrade() -> Error {
+        Error::new_user(User::NoUpgrade)
+    }
+
+    pub(super) fn new_user_manual_upgrade() -> Error {
+        Error::new_user(User::ManualUpgrade)
+    }
+
+    pub(super) fn new_user_service<E: Into<Cause>>(cause: E) -> Error {
+        Error::new_user(User::Service).with(cause)
+    }
+
+    pub(super) fn new_user_body<E: Into<Cause>>(cause: E) -> Error {
+        Error::new_user(User::Body).with(cause)
+    }
+
+    pub(super) fn new_user_invalid_connect() -> Error {
+        Error::new_user(User::InvalidConnectWithBody)
+    }
+
+    pub(super) fn new_shutdown(cause: std::io::Error) -> Error {
+        Error::new(Kind::Shutdown).with(cause)
+    }
+
+    pub(super) fn new_user_dispatch_gone() -> Error {
+        Error::new(Kind::User(User::DispatchGone))
+    }
+
+    pub(super) fn new_h2(cause: ::http2::Error) -> Error {
+        if cause.is_io() {
+            Error::new_io(cause.into_io().expect("http2::Error::is_io"))
+        } else {
+            Error::new(Kind::Http2).with(cause)
+        }
+    }
+
+    fn description(&self) -> &str {
+        match self.inner.kind {
+            Kind::Parse(Parse::Method) => "invalid HTTP method parsed",
+            Kind::Parse(Parse::Version) => "invalid HTTP version parsed",
+            Kind::Parse(Parse::VersionH2) => "invalid HTTP version parsed (found HTTP2 preface)",
+            Kind::Parse(Parse::Uri) => "invalid URI",
+            Kind::Parse(Parse::Header(Header::Token)) => "invalid HTTP header parsed",
+            Kind::Parse(Parse::Header(Header::ContentLengthInvalid)) => {
+                "invalid content-length parsed"
+            }
+            Kind::Parse(Parse::Header(Header::TransferEncodingUnexpected)) => {
+                "unexpected transfer-encoding parsed"
+            }
+            Kind::Parse(Parse::TooLarge) => "message head is too large",
+            Kind::Parse(Parse::Status) => "invalid HTTP status-code parsed",
+            Kind::Parse(Parse::Internal) => {
+                "internal error inside wreq and/or its dependencies, please report"
+            }
+
+            Kind::IncompleteMessage => "connection closed before message completed",
+            Kind::UnexpectedMessage => "received unexpected message from connection",
+            Kind::ChannelClosed => "channel closed",
+            Kind::Canceled => "operation was canceled",
+            Kind::Body => "error reading a body from connection",
+            Kind::BodyWrite => "error writing a body to connection",
+            Kind::Shutdown => "error shutting down connection",
+            Kind::Http2 => "http2 error",
+            Kind::Io => "connection error",
+
+            Kind::User(User::Body) => "error from user's Body stream",
+            Kind::User(User::BodyWriteAborted) => "user body write aborted",
+            Kind::User(User::InvalidConnectWithBody) => {
+                "user sent CONNECT request with non-zero body"
+            }
+            Kind::User(User::Service) => "error from user's Service",
+            Kind::User(User::NoUpgrade) => "no upgrade available",
+            Kind::User(User::ManualUpgrade) => "upgrade expected but low level API in use",
+            Kind::User(User::DispatchGone) => "dispatch task is gone",
+        }
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut f = f.debug_tuple("crate::core::Error");
+        f.field(&self.inner.kind);
+        if let Some(ref cause) = self.inner.cause {
+            f.field(cause);
+        }
+        f.finish()
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.description())
+    }
+}
+
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.inner
+            .cause
+            .as_ref()
+            .map(|cause| &**cause as &(dyn StdError + 'static))
+    }
+}
+
+#[doc(hidden)]
+impl From<Parse> for Error {
+    fn from(err: Parse) -> Error {
+        Error::new(Kind::Parse(err))
+    }
+}
+
+impl Parse {
+    pub(crate) fn content_length_invalid() -> Self {
+        Parse::Header(Header::ContentLengthInvalid)
+    }
+
+    pub(crate) fn transfer_encoding_unexpected() -> Self {
+        Parse::Header(Header::TransferEncodingUnexpected)
+    }
+}
+
+impl From<httparse::Error> for Parse {
+    fn from(err: httparse::Error) -> Parse {
+        match err {
+            httparse::Error::HeaderName
+            | httparse::Error::HeaderValue
+            | httparse::Error::NewLine
+            | httparse::Error::Token => Parse::Header(Header::Token),
+            httparse::Error::Status => Parse::Status,
+            httparse::Error::TooManyHeaders => Parse::TooLarge,
+            httparse::Error::Version => Parse::Version,
+        }
+    }
+}
+
+impl From<http::method::InvalidMethod> for Parse {
+    fn from(_: http::method::InvalidMethod) -> Parse {
+        Parse::Method
+    }
+}
+
+impl From<http::status::InvalidStatusCode> for Parse {
+    fn from(_: http::status::InvalidStatusCode) -> Parse {
+        Parse::Status
+    }
+}
+
+impl From<http::uri::InvalidUri> for Parse {
+    fn from(_: http::uri::InvalidUri) -> Parse {
+        Parse::Uri
+    }
+}
+
+impl From<http::uri::InvalidUriParts> for Parse {
+    fn from(_: http::uri::InvalidUriParts) -> Parse {
+        Parse::Uri
+    }
+}
+
+// ===== impl TimedOut ====
+
+impl fmt::Display for TimedOut {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("operation timed out")
+    }
+}
+
+impl StdError for TimedOut {}
+
+#[cfg(test)]
+mod tests {
+    use std::mem;
+
+    use super::*;
+
+    fn assert_send_sync<T: Send + Sync + 'static>() {}
+
+    #[test]
+    fn error_satisfies_send_sync() {
+        assert_send_sync::<Error>()
+    }
+
+    #[test]
+    fn error_size_of() {
+        assert_eq!(mem::size_of::<Error>(), mem::size_of::<usize>());
+    }
+
+    #[test]
+    fn h2_reason_unknown() {
+        let closed = Error::new_closed();
+        assert_eq!(closed.h2_reason(), http2::Reason::INTERNAL_ERROR);
+    }
+
+    #[test]
+    fn h2_reason_one_level() {
+        let body_err = Error::new_user_body(http2::Error::from(http2::Reason::ENHANCE_YOUR_CALM));
+        assert_eq!(body_err.h2_reason(), http2::Reason::ENHANCE_YOUR_CALM);
+    }
+
+    #[test]
+    fn h2_reason_nested() {
+        let recvd = Error::new_h2(http2::Error::from(http2::Reason::HTTP_1_1_REQUIRED));
+        // Suppose a user were proxying the received error
+        let svc_err = Error::new_user_service(recvd);
+        assert_eq!(svc_err.h2_reason(), http2::Reason::HTTP_1_1_REQUIRED);
+    }
+}

data/vendor/wreq/src/client/core/ext.rs

@@ -0,0 +1,201 @@
+//! HTTP extensions.
+
+use bytes::Bytes;
+
+/// A reason phrase in an HTTP/1 response.
+///
+/// # Clients
+///
+/// For clients, a `ReasonPhrase` will be present in the extensions of the `http::Response` returned
+/// for a request if the reason phrase is different from the canonical reason phrase for the
+/// response's status code. For example, if a server returns `HTTP/1.1 200 Awesome`, the
+/// `ReasonPhrase` will be present and contain `Awesome`, but if a server returns `HTTP/1.1 200 OK`,
+/// the response will not contain a `ReasonPhrase`.
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ReasonPhrase(Bytes);
+
+impl ReasonPhrase {
+    /// Gets the reason phrase as bytes.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+
+    /// Converts a static byte slice to a reason phrase.
+    pub const fn from_static(reason: &'static [u8]) -> Self {
+        // TODO: this can be made const once MSRV is >= 1.57.0
+        if find_invalid_byte(reason).is_some() {
+            panic!("invalid byte in static reason phrase");
+        }
+        Self(Bytes::from_static(reason))
+    }
+
+    // Not public on purpose.
+    /// Converts a `Bytes` directly into a `ReasonPhrase` without validating.
+    ///
+    /// Use with care; invalid bytes in a reason phrase can cause serious security problems if
+    /// emitted in a response.
+    pub(crate) fn from_bytes_unchecked(reason: Bytes) -> Self {
+        Self(reason)
+    }
+}
+
+impl TryFrom<&[u8]> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+
+    fn try_from(reason: &[u8]) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::copy_from_slice(reason)))
+        }
+    }
+}
+
+impl TryFrom<Vec<u8>> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+
+    fn try_from(reason: Vec<u8>) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(&reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::from(reason)))
+        }
+    }
+}
+
+impl TryFrom<String> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+
+    fn try_from(reason: String) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(reason.as_bytes()) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(Bytes::from(reason)))
+        }
+    }
+}
+
+impl TryFrom<Bytes> for ReasonPhrase {
+    type Error = InvalidReasonPhrase;
+
+    fn try_from(reason: Bytes) -> Result<Self, Self::Error> {
+        if let Some(bad_byte) = find_invalid_byte(&reason) {
+            Err(InvalidReasonPhrase { bad_byte })
+        } else {
+            Ok(Self(reason))
+        }
+    }
+}
+
+impl From<ReasonPhrase> for Bytes {
+    fn from(reason: ReasonPhrase) -> Self {
+        reason.0
+    }
+}
+
+impl AsRef<[u8]> for ReasonPhrase {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// Error indicating an invalid byte when constructing a `ReasonPhrase`.
+///
+/// See [the spec][spec] for details on allowed bytes.
+///
+/// [spec]: https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.4.p.7
+#[derive(Debug)]
+pub struct InvalidReasonPhrase {
+    bad_byte: u8,
+}
+
+impl std::fmt::Display for InvalidReasonPhrase {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Invalid byte in reason phrase: {}", self.bad_byte)
+    }
+}
+
+impl std::error::Error for InvalidReasonPhrase {}
+
+const fn is_valid_byte(b: u8) -> bool {
+    // See https://www.rfc-editor.org/rfc/rfc5234.html#appendix-B.1
+    const fn is_vchar(b: u8) -> bool {
+        0x21 <= b && b <= 0x7E
+    }
+
+    // See https://httpwg.org/http-core/draft-ietf-httpbis-semantics-latest.html#fields.values
+    //
+    // The 0xFF comparison is technically redundant, but it matches the text of the spec more
+    // clearly and will be optimized away.
+    #[allow(unused_comparisons, clippy::absurd_extreme_comparisons)]
+    const fn is_obs_text(b: u8) -> bool {
+        0x80 <= b && b <= 0xFF
+    }
+
+    // See https://httpwg.org/http-core/draft-ietf-httpbis-messaging-latest.html#rfc.section.4.p.7
+    b == b'\t' || b == b' ' || is_vchar(b) || is_obs_text(b)
+}
+
+const fn find_invalid_byte(bytes: &[u8]) -> Option<u8> {
+    let mut i = 0;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if !is_valid_byte(b) {
+            return Some(b);
+        }
+        i += 1;
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic_valid() {
+        const PHRASE: &[u8] = b"OK";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+
+    #[test]
+    fn empty_valid() {
+        const PHRASE: &[u8] = b"";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+
+    #[test]
+    fn obs_text_valid() {
+        const PHRASE: &[u8] = b"hyp\xe9r";
+        assert_eq!(ReasonPhrase::from_static(PHRASE).as_bytes(), PHRASE);
+        assert_eq!(ReasonPhrase::try_from(PHRASE).unwrap().as_bytes(), PHRASE);
+    }
+
+    const NEWLINE_PHRASE: &[u8] = b"hyp\ner";
+
+    #[test]
+    #[should_panic]
+    fn newline_invalid_panic() {
+        ReasonPhrase::from_static(NEWLINE_PHRASE);
+    }
+
+    #[test]
+    fn newline_invalid_err() {
+        assert!(ReasonPhrase::try_from(NEWLINE_PHRASE).is_err());
+    }
+
+    const CR_PHRASE: &[u8] = b"hyp\rer";
+
+    #[test]
+    #[should_panic]
+    fn cr_invalid_panic() {
+        ReasonPhrase::from_static(CR_PHRASE);
+    }
+
+    #[test]
+    fn cr_invalid_err() {
+        assert!(ReasonPhrase::try_from(CR_PHRASE).is_err());
+    }
+}