add client http codec; websockets client

src/ws/client/connect.rs

@@ -0,0 +1,95 @@
+//! Http client request
+use std::str;
+
+use cookie::Cookie;
+use http::header::{HeaderName, HeaderValue};
+use http::{Error as HttpError, HttpTryFrom};
+
+use client::{ClientRequest, ClientRequestBuilder};
+use header::IntoHeaderValue;
+
+use super::ClientError;
+
+/// `WebSocket` connection
+pub struct Connect {
+    pub(super) request: ClientRequestBuilder,
+    pub(super) err: Option<ClientError>,
+    pub(super) http_err: Option<HttpError>,
+    pub(super) origin: Option<HeaderValue>,
+    pub(super) protocols: Option<String>,
+    pub(super) max_size: usize,
+    pub(super) server_mode: bool,
+}
+
+impl Connect {
+    /// Create new websocket connection
+    pub fn new<S: AsRef<str>>(uri: S) -> Connect {
+        let mut cl = Connect {
+            request: ClientRequest::build(),
+            err: None,
+            http_err: None,
+            origin: None,
+            protocols: None,
+            max_size: 65_536,
+            server_mode: false,
+        };
+        cl.request.uri(uri.as_ref());
+        cl
+    }
+
+    /// Set supported websocket protocols
+    pub fn protocols<U, V>(mut self, protos: U) -> Self
+    where
+        U: IntoIterator<Item = V> + 'static,
+        V: AsRef<str>,
+    {
+        let mut protos = protos
+            .into_iter()
+            .fold(String::new(), |acc, s| acc + s.as_ref() + ",");
+        protos.pop();
+        self.protocols = Some(protos);
+        self
+    }
+
+    /// Set cookie for handshake request
+    pub fn cookie(mut self, cookie: Cookie) -> Self {
+        self.request.cookie(cookie);
+        self
+    }
+
+    /// Set request Origin
+    pub fn origin<V>(mut self, origin: V) -> Self
+    where
+        HeaderValue: HttpTryFrom<V>,
+    {
+        match HeaderValue::try_from(origin) {
+            Ok(value) => self.origin = Some(value),
+            Err(e) => self.http_err = Some(e.into()),
+        }
+        self
+    }
+
+    /// Set max frame size
+    ///
+    /// By default max size is set to 64kb
+    pub fn max_frame_size(mut self, size: usize) -> Self {
+        self.max_size = size;
+        self
+    }
+
+    /// Disable payload masking. By default ws client masks frame payload.
+    pub fn server_mode(mut self) -> Self {
+        self.server_mode = true;
+        self
+    }
+
+    /// Set request header
+    pub fn header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: HttpTryFrom<K>,
+        V: IntoHeaderValue,
+    {
+        self.request.header(key, value);
+        self
+    }
+}

src/ws/client/error.rs

@@ -0,0 +1,87 @@
+//! Http client request
+use std::io;
+
+use actix_net::connector::ConnectorError;
+use http::header::HeaderValue;
+use http::StatusCode;
+
+use error::ParseError;
+use http::Error as HttpError;
+use ws::ProtocolError;
+
+/// Websocket client error
+#[derive(Fail, Debug)]
+pub enum ClientError {
+    /// Invalid url
+    #[fail(display = "Invalid url")]
+    InvalidUrl,
+    /// Invalid response status
+    #[fail(display = "Invalid response status")]
+    InvalidResponseStatus(StatusCode),
+    /// Invalid upgrade header
+    #[fail(display = "Invalid upgrade header")]
+    InvalidUpgradeHeader,
+    /// Invalid connection header
+    #[fail(display = "Invalid connection header")]
+    InvalidConnectionHeader(HeaderValue),
+    /// Missing CONNECTION header
+    #[fail(display = "Missing CONNECTION header")]
+    MissingConnectionHeader,
+    /// Missing SEC-WEBSOCKET-ACCEPT header
+    #[fail(display = "Missing SEC-WEBSOCKET-ACCEPT header")]
+    MissingWebSocketAcceptHeader,
+    /// Invalid challenge response
+    #[fail(display = "Invalid challenge response")]
+    InvalidChallengeResponse(String, HeaderValue),
+    /// Http parsing error
+    #[fail(display = "Http parsing error")]
+    Http(HttpError),
+    // /// Url parsing error
+    // #[fail(display = "Url parsing error")]
+    // Url(UrlParseError),
+    /// Response parsing error
+    #[fail(display = "Response parsing error")]
+    ParseError(ParseError),
+    /// Protocol error
+    #[fail(display = "{}", _0)]
+    Protocol(#[cause] ProtocolError),
+    /// Connect error
+    #[fail(display = "{:?}", _0)]
+    Connect(ConnectorError),
+    /// IO Error
+    #[fail(display = "{}", _0)]
+    Io(io::Error),
+    /// "Disconnected"
+    #[fail(display = "Disconnected")]
+    Disconnected,
+}
+
+impl From<HttpError> for ClientError {
+    fn from(err: HttpError) -> ClientError {
+        ClientError::Http(err)
+    }
+}
+
+impl From<ConnectorError> for ClientError {
+    fn from(err: ConnectorError) -> ClientError {
+        ClientError::Connect(err)
+    }
+}
+
+impl From<ProtocolError> for ClientError {
+    fn from(err: ProtocolError) -> ClientError {
+        ClientError::Protocol(err)
+    }
+}
+
+impl From<io::Error> for ClientError {
+    fn from(err: io::Error) -> ClientError {
+        ClientError::Io(err)
+    }
+}
+
+impl From<ParseError> for ClientError {
+    fn from(err: ParseError) -> ClientError {
+        ClientError::ParseError(err)
+    }
+}

src/ws/client/mod.rs

@@ -0,0 +1,48 @@
+mod connect;
+mod error;
+mod service;
+
+pub use self::connect::Connect;
+pub use self::error::ClientError;
+pub use self::service::Client;
+
+#[derive(PartialEq, Hash, Debug, Clone, Copy)]
+pub(crate) enum Protocol {
+    Http,
+    Https,
+    Ws,
+    Wss,
+}
+
+impl Protocol {
+    fn from(s: &str) -> Option<Protocol> {
+        match s {
+            "http" => Some(Protocol::Http),
+            "https" => Some(Protocol::Https),
+            "ws" => Some(Protocol::Ws),
+            "wss" => Some(Protocol::Wss),
+            _ => None,
+        }
+    }
+
+    fn is_http(self) -> bool {
+        match self {
+            Protocol::Https | Protocol::Http => true,
+            _ => false,
+        }
+    }
+
+    fn is_secure(self) -> bool {
+        match self {
+            Protocol::Https | Protocol::Wss => true,
+            _ => false,
+        }
+    }
+
+    fn port(self) -> u16 {
+        match self {
+            Protocol::Http | Protocol::Ws => 80,
+            Protocol::Https | Protocol::Wss => 443,
+        }
+    }
+}

src/ws/client/service.rs

@@ -0,0 +1,270 @@
+//! websockets client
+use std::marker::PhantomData;
+
+use actix_net::codec::Framed;
+use actix_net::connector::{ConnectorError, DefaultConnector};
+use actix_net::service::Service;
+use base64;
+use futures::future::{err, Either, FutureResult};
+use futures::{Async, Future, Poll, Sink, Stream};
+use http::header::{self, HeaderValue};
+use http::{HttpTryFrom, StatusCode};
+use rand;
+use sha1::Sha1;
+use tokio_io::{AsyncRead, AsyncWrite};
+
+use client::ClientResponse;
+use h1;
+use ws::Codec;
+
+use super::{ClientError, Connect, Protocol};
+
+/// WebSocket's client
+pub struct Client<T>
+where
+    T: Service<Error = ConnectorError>,
+    T::Response: AsyncRead + AsyncWrite,
+{
+    connector: T,
+}
+
+impl<T> Client<T>
+where
+    T: Service<Request = String, Error = ConnectorError>,
+    T::Response: AsyncRead + AsyncWrite,
+{
+    /// Create new websocket's client factory
+    pub fn new(connector: T) -> Self {
+        Client { connector }
+    }
+}
+
+impl Default for Client<DefaultConnector<String>> {
+    fn default() -> Self {
+        Client::new(DefaultConnector::default())
+    }
+}
+
+impl<T> Clone for Client<T>
+where
+    T: Service<Request = String, Error = ConnectorError> + Clone,
+    T::Response: AsyncRead + AsyncWrite,
+{
+    fn clone(&self) -> Self {
+        Client {
+            connector: self.connector.clone(),
+        }
+    }
+}
+
+impl<T> Service for Client<T>
+where
+    T: Service<Request = String, Error = ConnectorError>,
+    T::Response: AsyncRead + AsyncWrite + 'static,
+    T::Future: 'static,
+{
+    type Request = Connect;
+    type Response = Framed<T::Response, Codec>;
+    type Error = ClientError;
+    type Future = Either<
+        FutureResult<Self::Response, Self::Error>,
+        ClientResponseFut<T::Response>,
+    >;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.connector.poll_ready().map_err(ClientError::from)
+    }
+
+    fn call(&mut self, mut req: Self::Request) -> Self::Future {
+        if let Some(e) = req.err.take() {
+            Either::A(err(e))
+        } else if let Some(e) = req.http_err.take() {
+            Either::A(err(e.into()))
+        } else {
+            // origin
+            if let Some(origin) = req.origin.take() {
+                req.request.set_header(header::ORIGIN, origin);
+            }
+
+            req.request.upgrade();
+            req.request.set_header(header::UPGRADE, "websocket");
+            req.request.set_header(header::CONNECTION, "upgrade");
+            req.request.set_header(header::SEC_WEBSOCKET_VERSION, "13");
+
+            if let Some(protocols) = req.protocols.take() {
+                req.request
+                    .set_header(header::SEC_WEBSOCKET_PROTOCOL, protocols.as_str());
+            }
+            let mut request = match req.request.finish() {
+                Ok(req) => req,
+                Err(e) => return Either::A(err(e.into())),
+            };
+
+            if request.uri().host().is_none() {
+                return Either::A(err(ClientError::InvalidUrl));
+            }
+
+            // supported protocols
+            let proto = if let Some(scheme) = request.uri().scheme_part() {
+                match Protocol::from(scheme.as_str()) {
+                    Some(proto) => proto,
+                    None => return Either::A(err(ClientError::InvalidUrl)),
+                }
+            } else {
+                return Either::A(err(ClientError::InvalidUrl));
+            };
+
+            // Generate a random key for the `Sec-WebSocket-Key` header.
+            // a base64-encoded (see Section 4 of [RFC4648]) value that,
+            // when decoded, is 16 bytes in length (RFC 6455)
+            let sec_key: [u8; 16] = rand::random();
+            let key = base64::encode(&sec_key);
+
+            request.headers_mut().insert(
+                header::SEC_WEBSOCKET_KEY,
+                HeaderValue::try_from(key.as_str()).unwrap(),
+            );
+
+            // prep connection
+            let host = {
+                let uri = request.uri();
+                format!(
+                    "{}:{}",
+                    uri.host().unwrap(),
+                    uri.port().unwrap_or_else(|| proto.port())
+                )
+            };
+
+            let fut = Box::new(
+                self.connector
+                    .call(host)
+                    .map_err(|e| ClientError::from(e))
+                    .and_then(move |io| {
+                        // h1 protocol
+                        let framed = Framed::new(io, h1::ClientCodec::default());
+                        framed
+                            .send(request.into())
+                            .map_err(|e| ClientError::from(e))
+                            .and_then(|framed| {
+                                framed
+                                    .into_future()
+                                    .map_err(|(e, _)| ClientError::from(e))
+                            })
+                    }),
+            );
+
+            // start handshake
+            Either::B(ClientResponseFut {
+                key,
+                fut,
+                max_size: req.max_size,
+                server_mode: req.server_mode,
+                _t: PhantomData,
+            })
+        }
+    }
+}
+
+/// Future that implementes client websocket handshake process.
+///
+/// It resolves to a `Framed<T, ws::Codec>` instance.
+pub struct ClientResponseFut<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    fut: Box<
+        Future<
+            Item = (
+                Option<h1::Message<ClientResponse>>,
+                Framed<T, h1::ClientCodec>,
+            ),
+            Error = ClientError,
+        >,
+    >,
+    key: String,
+    max_size: usize,
+    server_mode: bool,
+    _t: PhantomData<T>,
+}
+
+impl<T> Future for ClientResponseFut<T>
+where
+    T: AsyncRead + AsyncWrite,
+{
+    type Item = Framed<T, Codec>;
+    type Error = ClientError;
+
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
+        let (item, framed) = try_ready!(self.fut.poll());
+
+        let res = match item {
+            Some(h1::Message::Item(res)) => res,
+            Some(h1::Message::Chunk(_)) => unreachable!(),
+            None => return Err(ClientError::Disconnected),
+        };
+
+        // verify response
+        if res.status() != StatusCode::SWITCHING_PROTOCOLS {
+            return Err(ClientError::InvalidResponseStatus(res.status()));
+        }
+        // Check for "UPGRADE" to websocket header
+        let has_hdr = if let Some(hdr) = res.headers().get(header::UPGRADE) {
+            if let Ok(s) = hdr.to_str() {
+                s.to_lowercase().contains("websocket")
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+        if !has_hdr {
+            trace!("Invalid upgrade header");
+            return Err(ClientError::InvalidUpgradeHeader);
+        }
+        // Check for "CONNECTION" header
+        if let Some(conn) = res.headers().get(header::CONNECTION) {
+            if let Ok(s) = conn.to_str() {
+                if !s.to_lowercase().contains("upgrade") {
+                    trace!("Invalid connection header: {}", s);
+                    return Err(ClientError::InvalidConnectionHeader(conn.clone()));
+                }
+            } else {
+                trace!("Invalid connection header: {:?}", conn);
+                return Err(ClientError::InvalidConnectionHeader(conn.clone()));
+            }
+        } else {
+            trace!("Missing connection header");
+            return Err(ClientError::MissingConnectionHeader);
+        }
+
+        if let Some(key) = res.headers().get(header::SEC_WEBSOCKET_ACCEPT) {
+            // field is constructed by concatenating /key/
+            // with the string "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" (RFC 6455)
+            const WS_GUID: &[u8] = b"258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+            let mut sha1 = Sha1::new();
+            sha1.update(self.key.as_ref());
+            sha1.update(WS_GUID);
+            let encoded = base64::encode(&sha1.digest().bytes());
+            if key.as_bytes() != encoded.as_bytes() {
+                trace!(
+                    "Invalid challenge response: expected: {} received: {:?}",
+                    encoded,
+                    key
+                );
+                return Err(ClientError::InvalidChallengeResponse(encoded, key.clone()));
+            }
+        } else {
+            trace!("Missing SEC-WEBSOCKET-ACCEPT header");
+            return Err(ClientError::MissingWebSocketAcceptHeader);
+        };
+
+        // websockets codec
+        let codec = if self.server_mode {
+            Codec::new().max_size(self.max_size)
+        } else {
+            Codec::new().max_size(self.max_size).client_mode()
+        };
+
+        Ok(Async::Ready(framed.into_framed(codec)))
+    }
+}

src/ws/mod.rs

@@ -10,6 +10,7 @@ use http::{header, Method, StatusCode};
 use request::Request;
 use response::{ConnectionType, Response, ResponseBuilder};
 
+mod client;
 mod codec;
 mod frame;
 mod mask;
@@ -17,6 +18,7 @@ mod proto;
 mod service;
 mod transport;
 
+pub use self::client::{Client, ClientError, Connect};
 pub use self::codec::{Codec, Frame, Message};
 pub use self::frame::Parser;
 pub use self::proto::{CloseCode, CloseReason, OpCode};