#![doc(html_root_url = "https://docs.rs/mio_httpc")]
#![crate_name = "mio_httpc"]
#[macro_use]
extern crate pest_derive;
#[cfg(any(target_os = "ios", target_os = "macos"))]
#[macro_use]
extern crate core_foundation;
#[cfg(any(target_os = "ios", target_os = "macos"))]
extern crate core_foundation_sys;
#[macro_use]
extern crate failure;
#[cfg(test)]
#[macro_use]
extern crate matches;
mod api;
mod call;
mod connection;
#[allow(dead_code, unused_imports)]
mod dns_parser;
mod httpc;
mod resolve;
mod tls_api;
#[allow(dead_code, unused_variables)]
mod types;
pub use crate::api::*;
#[cfg(feature = "native")]
pub use native_tls::Error as TLSError;
#[cfg(feature = "openssl")]
pub use openssl::error::Error as OpenSSLError;
#[cfg(feature = "openssl")]
pub use openssl::error::ErrorStack as OpenSSLErrorStack;
#[cfg(feature = "openssl")]
pub use openssl::ssl::Error as TLSError;
#[cfg(feature = "rustls")]
pub use rustls::Error as TLSError;
#[cfg(not(any(feature = "rustls", feature = "native", feature = "openssl")))]
pub use crate::tls_api::{dummy::hash, HashType};
#[cfg(feature = "native")]
pub use crate::tls_api::{native::hash, HashType};
#[cfg(feature = "openssl")]
pub use crate::tls_api::{openssl::hash, HashType};
#[cfg(feature = "rustls")]
pub use crate::tls_api::{rustls::hash, HashType};
pub type Result<T> = ::std::result::Result<T, Error>;
#[derive(Debug, Fail)]
pub enum Error {
#[fail(display = "IO error: {}", _0)]
Io(#[cause] ::std::io::Error),
#[fail(display = "Utf8 error: {}", _0)]
Utf8(#[cause] std::str::Utf8Error),
#[fail(display = "FromUtf8 error: {}", _0)]
FromUtf8(#[cause] std::string::FromUtf8Error),
#[fail(display = "AddrParseError: {}", _0)]
Addr(#[cause] std::net::AddrParseError),
#[fail(display = "Httparse error: {}", _0)]
Httparse(#[cause] httparse::Error),
#[fail(display = "WebSocket setup failed")]
WebSocketFail(Response),
#[fail(display = "Sync call timed out")]
TimeOut,
#[fail(
display = "Request structure did not contain body and CallSimple was used for POST/PUT."
)]
MissingBody,
#[fail(display = "Response over max_response limit")]
ResponseTooBig,
#[fail(display = "Redirects back to itself, missing or invalid location header")]
InvalidRedirect,
#[fail(display = "Connection closed")]
Closed,
#[fail(display = "No host found in request")]
NoHost,
#[fail(display = "Invalid scheme")]
InvalidScheme,
#[cfg(any(feature = "rustls", feature = "native", feature = "openssl"))]
#[fail(display = "TLS error {}", _0)]
Tls(#[cause] TLSError),
#[cfg(feature = "openssl")]
#[fail(display = "OpenSSL stack error {}", _0)]
OpenSSLErrorStack(#[cause] OpenSSLErrorStack),
#[cfg(feature = "openssl")]
#[fail(display = "OpenSSL error {}", _0)]
OpenSSLError(#[cause] OpenSSLError),
#[fail(display = "Concurrent connection limit")]
NoSpace,
#[fail(display = "URL parse error {}", _0)]
Url(#[cause] url::ParseError),
#[fail(display = "{}", _0)]
Other(&'static str),
#[fail(display = "You must pick one of the features: native, rustls, openssl")]
NoTls,
#[fail(display = "Error parsing chunked transfer")]
ChunkedParse,
#[fail(display = "Error parsing WebSocket transfer")]
WebSocketParse,
#[fail(display = "Error parsing WWW-Authenticate header")]
AuthenticateParse,
#[fail(display = "Pins were configured for domain and they did not match")]
InvalidPin,
#[fail(display = "Can not decompress gzip/deflate response")]
DecompressionFailure,
#[fail(
display = "Chunk was larger than configured CallBuilder::chunked_max_chunk. {}",
_0
)]
ChunkOverlimit(usize),
}
impl From<std::io::Error> for Error {
fn from(e: std::io::Error) -> Self {
Error::Io(e)
}
}
impl From<url::ParseError> for Error {
fn from(e: url::ParseError) -> Self {
Error::Url(e)
}
}
#[cfg(any(feature = "rustls", feature = "native", feature = "openssl"))]
impl From<TLSError> for Error {
fn from(e: TLSError) -> Self {
Error::Tls(e)
}
}
#[cfg(feature = "openssl")]
impl From<openssl::error::ErrorStack> for Error {
fn from(e: openssl::error::ErrorStack) -> Self {
Error::OpenSSLErrorStack(e)
}
}
#[cfg(feature = "openssl")]
impl From<OpenSSLError> for Error {
fn from(e: OpenSSLError) -> Self {
Error::OpenSSLError(e)
}
}
impl From<httparse::Error> for Error {
fn from(e: httparse::Error) -> Self {
Error::Httparse(e)
}
}
impl From<std::string::FromUtf8Error> for Error {
fn from(e: std::string::FromUtf8Error) -> Self {
Error::FromUtf8(e)
}
}
#[cfg(test)]
mod tests {
#[test]
fn parse_headers() {
let v = b"HTTP/1.1 200 OK\r\nContent-length: 100\r\nUpgrade: websocket\r\n".to_vec();
let mut r = crate::Response::new();
r.hdrs = v;
{
let hdrs = r.headers();
for h in hdrs {
println!("{}: {}", h.name, h.value);
}
}
}
}