You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
115 lines
3.0 KiB
115 lines
3.0 KiB
//! Error handling.
|
|
|
|
use std::borrow::{Borrow, Cow};
|
|
|
|
use std::error::Error as ErrorTrait;
|
|
use std::fmt;
|
|
use std::io;
|
|
use std::result;
|
|
use std::str;
|
|
use std::string;
|
|
|
|
use httparse;
|
|
|
|
use protocol::frame::CloseFrame;
|
|
|
|
#[cfg(feature="tls")]
|
|
pub mod tls {
|
|
pub use native_tls::Error;
|
|
}
|
|
|
|
pub type Result<T> = result::Result<T, Error>;
|
|
|
|
/// Possible WebSocket errors
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
/// WebSocket connection closed (normally)
|
|
ConnectionClosed(Option<CloseFrame<'static>>),
|
|
/// Input-output error
|
|
Io(io::Error),
|
|
#[cfg(feature="tls")]
|
|
/// TLS error
|
|
Tls(tls::Error),
|
|
/// Buffer capacity exhausted
|
|
Capacity(Cow<'static, str>),
|
|
/// Protocol violation
|
|
Protocol(Cow<'static, str>),
|
|
/// UTF coding error
|
|
Utf8,
|
|
/// Invlid URL.
|
|
Url(Cow<'static, str>),
|
|
/// HTTP error.
|
|
Http(u16),
|
|
}
|
|
|
|
impl fmt::Display for Error {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
Error::ConnectionClosed(ref frame) => {
|
|
if let Some(ref cf) = *frame {
|
|
write!(f, "Connection closed: {}", cf)
|
|
} else {
|
|
write!(f, "Connection closed (empty close frame)")
|
|
}
|
|
}
|
|
Error::Io(ref err) => write!(f, "IO error: {}", err),
|
|
#[cfg(feature="tls")]
|
|
Error::Tls(ref err) => write!(f, "TLS error: {}", err),
|
|
Error::Capacity(ref msg) => write!(f, "Space limit exceeded: {}", msg),
|
|
Error::Protocol(ref msg) => write!(f, "WebSocket protocol error: {}", msg),
|
|
Error::Utf8 => write!(f, "UTF-8 encoding error"),
|
|
Error::Url(ref msg) => write!(f, "URL error: {}", msg),
|
|
Error::Http(code) => write!(f, "HTTP code: {}", code),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ErrorTrait for Error {
|
|
fn description(&self) -> &str {
|
|
match *self {
|
|
Error::ConnectionClosed(_) => "A close handshake is performed",
|
|
Error::Io(ref err) => err.description(),
|
|
#[cfg(feature="tls")]
|
|
Error::Tls(ref err) => err.description(),
|
|
Error::Capacity(ref msg) => msg.borrow(),
|
|
Error::Protocol(ref msg) => msg.borrow(),
|
|
Error::Utf8 => "",
|
|
Error::Url(ref msg) => msg.borrow(),
|
|
Error::Http(_) => "",
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<io::Error> for Error {
|
|
fn from(err: io::Error) -> Self {
|
|
Error::Io(err)
|
|
}
|
|
}
|
|
|
|
impl From<str::Utf8Error> for Error {
|
|
fn from(_: str::Utf8Error) -> Self {
|
|
Error::Utf8
|
|
}
|
|
}
|
|
|
|
impl From<string::FromUtf8Error> for Error {
|
|
fn from(_: string::FromUtf8Error) -> Self {
|
|
Error::Utf8
|
|
}
|
|
}
|
|
|
|
#[cfg(feature="tls")]
|
|
impl From<tls::Error> for Error {
|
|
fn from(err: tls::Error) -> Self {
|
|
Error::Tls(err)
|
|
}
|
|
}
|
|
|
|
impl From<httparse::Error> for Error {
|
|
fn from(err: httparse::Error) -> Self {
|
|
match err {
|
|
httparse::Error::TooManyHeaders => Error::Capacity("Too many headers".into()),
|
|
e => Error::Protocol(Cow::Owned(e.description().into())),
|
|
}
|
|
}
|
|
}
|
|
|