Use generic cloneable stream

This should allow for wss:// to work

Author: cyderize

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "websocket"
-version = "0.5.0"
+version = "0.6.0"
 authors = ["cyderize <[email protected]>"]
 
 description = "A WebSocket (RFC6455) library for Rust."
@@ -17,5 +17,5 @@ keywords = ["websocket", "websockets", "rfc6455"]
 license = "MIT"
 
 [dependencies]
-url = "~0.2.1"
+url = "~0.2.2"
 sha1 = "~0.0.3"

README.md

@@ -10,7 +10,7 @@ Rust-WebSocket attempts to provide a framework for WebSocket connections (both c
 To add a library release version from [crates.io](https://crates.io/crates/websocket) to a Cargo project, add this to the 'dependencies' section of your Cargo.toml:
 
 ```INI
-websocket = "~0.5.0"
+websocket = "~0.6.0"
 ```
 
 To add the library's Git repository to a Cargo project, add this to your Cargo.toml:

src/lib.rs

@@ -7,7 +7,7 @@
 //! with the capability to send and receive fragmented messages.
 //! 
 //! Rust-WebSocket does not provide a 'listener' object, since the WebSocket protocol utilises a TcpStream.
-//! To implement a WebSocket server, use a normal TcpListener, and the WebSocketClient::from_stream() function
+//! To implement a WebSocket server, use a normal TcpListener, and the WebSocketClient::new() function
 //! on an accepted stream. You will then need to read the handshake from the client and send a response.
 //! 
 //! ```no_run
@@ -26,18 +26,18 @@
 //! 			spawn(proc() {
 //! 				// Get a WebSocketClient from this stream
 //! 				// The mask argument is false as messages sent by the server are always unmasked
-//! 				let mut client = WebSocketClient::from_stream(stream, false); 
+//! 				let mut client = WebSocketClient::new(stream, false); 
 //! 				
 //! 				// Read the handshake from the client
 //! 				let request = client.receive_handshake_request().unwrap();
 //! 				
-//! 				// Get the headers we need to respond
+//! 				// Get the Sec-WebSocket-Key from the request
 //! 				let key = request.key().unwrap();
 //! 				
 //! 				// Form a response from the key
-//!					/* In this example, we don't deal with the requested protocol
-//!					   Because of this, however, we need to a type annotation,
-//!					   which would usually not be required. */
+//!					/* In this example, we don't deal with the requested Sec-WebSocket-Protocol.
+//!					   Because of this, however, we need a type annotation, which would 
+//!					   not usually be required. */
 //! 				let response = WebSocketResponse::new::<String>(key.as_slice(), None);
 //! 				
 //! 				// Send the response to the client

src/ws/client.rs

@@ -2,23 +2,26 @@ use super::handshake::request::{WebSocketRequest, ReadWebSocketRequest, WriteWeb
 use super::handshake::response::{WebSocketResponse, ReadWebSocketResponse, WriteWebSocketResponse};
 use super::message::send::{WebSocketSender, new_sender};
 use super::message::receive::{WebSocketReceiver, new_receiver};
-use std::io::net::tcp::TcpStream;
-use std::io::net::ip::SocketAddr;
-use std::io::{IoResult, IoError, IoErrorKind};
+use std::io::{Stream, IoResult};
 use std::clone::Clone;
 
 /// Represents a WebSocket client.
-/// To use WebSocketClient, you must create one using either WebSocketClient::connect(),
-/// which is used for writing clients, or WebSocketClient::from_stream(), which creates
-/// a WebSocketClient from a TcpStream (typically used in a server).
+/// To use WebSocketClient, you must create one using either WebSocketClient::new().
+/// For a client, you can use TcpStream::connect() to connect to the server, then call
+/// WebSocketClient::new() passing the resultant stream.
 /// 
 /// ```no_run
+/// use std::io::TcpStream;
 /// use websocket::WebSocketClient;
 /// use websocket::handshake::WebSocketRequest;
 /// 
 /// let request = WebSocketRequest::new("ws://127.0.0.1:1234", ["myProtocol"].as_slice()).unwrap();
 /// let key = request.key().unwrap();
-/// let mut client = WebSocketClient::connect(&request).unwrap();
+///
+/// // We can get the hostname from the request
+/// let stream = TcpStream::connect(request.host().unwrap().as_slice()).unwrap();
+///
+/// let mut client = WebSocketClient::new(stream, true);
 /// let response = client.receive_handshake_response().unwrap();
 /// 
 /// if !response.is_successful(key) {
@@ -31,62 +34,31 @@ use std::clone::Clone;
 /// 
 /// // ...
 /// ```
-pub struct WebSocketClient {
-	stream: TcpStream,
+pub struct WebSocketClient<S: Stream + Clone> {
+	stream: S,
 	mask: bool,
 }
 
-impl WebSocketClient {
-	/// Connect to the WebSocket server using the given request.
-	/// Use WebSocketRequest::new() to create a request for use with this function.
-	pub fn connect(request: &WebSocketRequest) -> IoResult<WebSocketClient> {
-		let host = try!(request.headers.get("Host").ok_or(
-			IoError {
-				kind: IoErrorKind::InvalidInput,
-				desc: "No host specified",
-				detail: None,
-			}
-		));
-		//Connect to the server
-		let mut stream = try!(TcpStream::connect(host.as_slice()));
-		//Send the opening handshake
-		try!(stream.write_websocket_request(request));
-		
-		Ok(WebSocketClient{
-			stream: stream,
-			mask: true,
-		})
-	}
-	
-	/// Creates a new WebSocketClient from a given TcpStream.
+impl<S: Stream + Clone> WebSocketClient<S> {
+	/// Creates a new WebSocketClient from a given cloneable stream.
 	/// The mask parameter determines whether or not messages send to the remote endpoint will be masked.
 	/// If the client is connecting to a remote endpoint, set mask to true. If the client is the remote
 	/// endpoint (and therefore, the server is the local endpoint), set mask to false.
 	/// 
 	/// Nothing is sent to or read from the stream during the conversion.
-	pub fn from_stream(stream: TcpStream, mask: bool) -> WebSocketClient {
+	pub fn new(stream: S, mask: bool) -> WebSocketClient<S> {
 		WebSocketClient {
 			stream: stream,
 			mask: mask,
 		}
 	}
 
-	/// Returns a copy of the underlying TcpStream for this WebSocketClient.
+	/// Returns a copy of the underlying S for this WebSocketClient.
 	/// Note that writing to this stream will likely invalidate the WebSocket data stream.
-	pub fn stream(&self) -> TcpStream {
+	pub fn stream(&self) -> S {
 		self.stream.clone()
 	}
 
-	/// Returns the socket address of the remote peer of this TCP connection.
-	pub fn peer_name(&mut self) -> IoResult<SocketAddr> {
-		self.stream.peer_name()
-	}
-
-	/// Returns the socket address of the local half of this TCP connection.
-	pub fn socket_name(&mut self) -> IoResult<SocketAddr> {
-		self.stream.socket_name()
-	}
-	
 	/// Reads a request from this client. Only to be used if the server is the local endpoint and
 	/// the client is the remote endpoint.
 	pub fn receive_handshake_request(&mut self) -> IoResult<WebSocketRequest> {
@@ -99,6 +71,12 @@ impl WebSocketClient {
 		self.stream.read_websocket_response()
 	}
 
+	/// Sends the specified WebSocketRequest to the remote endpoint. Only to be used if the server is
+	/// the remote endpoint and the client is the local endpoint.
+	pub fn send_handshake_request(&mut self, request: WebSocketRequest) -> IoResult<()> {
+		self.stream.write_websocket_request(&request)
+	}
+	
 	/// Sends the specified WebSocketResponse to this client. Only to be used if the server is
 	/// the local endpoint and the client is the remote endpoint.
 	pub fn send_handshake_response(&mut self, response: WebSocketResponse) -> IoResult<()> {
@@ -107,37 +85,19 @@ impl WebSocketClient {
 
 	/// Returns a WebSocketSender from this client. Used to transmit data to the remote endpoint,
 	/// that is, to the server if WebSocketClient::connect() has been used, or to this client otherwise.
-	pub fn sender(&self) -> WebSocketSender {
+	pub fn sender(&self) -> WebSocketSender<S> {
 		new_sender(self.stream.clone(), self.mask)
 	}
 
-	/// Closes the sender for this WebSocketClient.
-	/// This method will close the message sending portion of this client, causing all pending and future sends to immediately return with an error.
-	/// This affects all WebSocketSenders for the client, and any copies of the underlying stream will be unable to write.
-	///
-	/// Note that you should send a WebSocketMessage:Close message to the remote endpoint before calling this method.
-	pub fn close_send(&mut self) -> IoResult<()> {
-		self.stream.close_write()
-	}
-	
 	/// Returns a WebSocketReceiver from this client. Used to receive data from the remote endpoint,
 	/// that is, from the server if WebSocketClient::connect() has been used, or from this client otherwise.
-	pub fn receiver(&self) -> WebSocketReceiver {
+	pub fn receiver(&self) -> WebSocketReceiver<S> {
 		new_receiver(self.stream.clone())
 	}
-	
-	/// Closes the receiver for this WebSocketClient.
-	/// This method will close the message receiving portion of this client, causing all pending and future receives to immediately return with an error.
-	/// This affects all WebSocketReceivers for the client, and any copies of the underlying stream will be unable to read.
-	///
-	/// Note that you should send a WebSocketMessage:Close message to the remote endpoint before calling this method.
-	pub fn close_receive(&mut self) -> IoResult<()> {
-		self.stream.close_read()
-	}
 }
 
-impl Clone for WebSocketClient {
-	fn clone(&self) -> WebSocketClient {
+impl<S: Stream + Clone> Clone for WebSocketClient<S> {
+	fn clone(&self) -> WebSocketClient<S> {
 		WebSocketClient {
 			stream: self.stream.clone(),
 			mask: self.mask,

src/ws/handshake/request.rs

@@ -47,10 +47,7 @@ impl WebSocketRequest {
 		};
 
 		match ws_uri.scheme.as_slice() {
-			"ws" => { }
-			/* "wss" => {
-				// Don't know how to handle secure WebSocket
-			} */
+			"ws" | "wss" => { }
 			_ => { return Err(ParseError::InvalidScheme); }
 		}
 

src/ws/handshake/response.rs

@@ -23,7 +23,18 @@ static MAGIC_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 /// 
 /// assert_eq!(response.accept().unwrap().as_slice(), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=");
 /// assert_eq!(response.upgrade().unwrap().as_slice(), "websocket");
-/// //...
+/// // ...
+/// ```
+/// Note that we can also send WebSocket failure responses.
+/// 
+/// ```
+/// use websocket::handshake::WebSocketResponse;
+/// 
+/// let response = WebSocketResponse::failure(403, "Forbidden");
+/// assert_eq!(response.status_code, 403);
+/// assert_eq!(response.reason_phrase.as_slice(), "Forbidden");
+/// 
+/// // ...
 /// ```
 pub struct WebSocketResponse {
 	/// The HTTP version of this request
@@ -62,6 +73,17 @@ impl WebSocketResponse {
 		}
 	}
 
+	/// Create a WebSocket response with a particular status code and reason phrase - generally
+	/// used to indicate a handshake failure.
+	pub fn failure<A: ToString>(status_code: uint, reason_phrase: A) -> WebSocketResponse {
+		WebSocketResponse {
+			http_version: HttpVersion::new(1u8, Some(1u8)),
+			status_code: status_code,
+			reason_phrase: reason_phrase.to_string(),
+			headers: HeaderCollection::new(),
+		}
+	}
+	
 	/// Short-cut to get the Upgrade field value of this request
 	pub fn upgrade(&self) -> Option<String> {
 		self.headers.get("Upgrade")

src/ws/message/receive.rs

@@ -2,10 +2,10 @@ use super::dataframe::{WebSocketOpcode, ReadWebSocketDataFrame};
 use super::WebSocketMessage;
 use super::mask::mask_data;
 use std::iter::Iterator;
-use std::io::net::tcp::TcpStream;
-use std::io::{IoResult, IoError, IoErrorKind};
+use std::io::{Stream, IoResult, IoError, IoErrorKind};
 use std::option::Option;
 use std::str::from_utf8;
+use std::clone::Clone;
 
 /// Represents a WebSocket receiver which can receive data from the remote endpoint.
 /// All methods are task blocking (but not stream blocking, so you can send and receive concurrently).
@@ -14,11 +14,11 @@ use std::str::from_utf8;
 /// ```no_run
 /// use websocket::message::WebSocketMessage;
 /// # use websocket::WebSocketClient;
-/// # use websocket::handshake::WebSocketRequest;
+/// # use std::io::TcpStream;
 /// # #[allow(unused_must_use)]
 /// # fn foo() {
-/// # let request = WebSocketRequest::new("ws://127.0.0.1:1234", ["None"].as_slice()).unwrap();
-/// # let mut client = WebSocketClient::connect(&request).unwrap();
+/// # let stream = TcpStream::connect("127.0.0.1:1234").unwrap();
+/// # let mut client = WebSocketClient::new(stream, true);
 /// 
 /// let receiver = client.receiver();
 /// 
@@ -46,13 +46,13 @@ use std::str::from_utf8;
 /// });
 /// # }
 /// ```
-pub struct WebSocketReceiver {
-	stream: TcpStream,
+pub struct WebSocketReceiver<S: Stream + Clone> {
+	stream: S,
 	opcode: Option<WebSocketOpcode>,
 	data: Vec<u8>,
 }
 
-impl WebSocketReceiver {
+impl<S: Stream + Clone> WebSocketReceiver<S> {
 	/// Wait for and accept a message (subjected to the underlying stream timeout).
 	/// If the received message is fragmented, this function will not return
 	/// until the final fragment has been received.
@@ -163,14 +163,14 @@ impl WebSocketReceiver {
 	}
 
 	/// Returns an iterator over the incoming messages for/from this client
-	pub fn incoming(self) -> IncomingMessages {
+	pub fn incoming(self) -> IncomingMessages<S> {
 		IncomingMessages {
 			inc: self,
 		}
 	}
 }
 
-pub fn new_receiver(stream: TcpStream) -> WebSocketReceiver {
+pub fn new_receiver<S: Stream + Clone>(stream: S) -> WebSocketReceiver<S> {
 	WebSocketReceiver {
 		stream: stream,
 		opcode: None,
@@ -179,11 +179,11 @@ pub fn new_receiver(stream: TcpStream) -> WebSocketReceiver {
 }
 
 /// An iterator over incoming messages. Blocks the task and always returns Some.
-pub struct IncomingMessages {
-	inc: WebSocketReceiver,
+pub struct IncomingMessages<S: Stream + Clone> {
+	inc: WebSocketReceiver<S>,
 }
 
-impl Iterator<IoResult<WebSocketMessage>> for IncomingMessages {
+impl<S: Stream + Clone> Iterator<IoResult<WebSocketMessage>> for IncomingMessages<S> {
 	fn next(&mut self) -> Option<IoResult<WebSocketMessage>> {
 		Some(self.inc.receive_message())
 	}