added TCP settings functions and verified questions about ws protocol

Author: illegalprime

ROADMAP.md

@@ -0,0 +1,5 @@
+
+### Adding Features
+
+ - Make the usage of `net2` a feature
+ - Make evented

src/client/builder.rs

@@ -262,7 +262,6 @@ impl<'u, 's> ClientBuilder<'u, 's> {
 
         self.headers.set(Upgrade(vec![Protocol {
             name: ProtocolName::WebSocket,
-            // TODO: actually correct or just works?
             version: None
         }]));
 

src/client/mod.rs

@@ -1,10 +1,12 @@
 //! Contains the WebSocket client.
 extern crate url;
+extern crate net2;
 
 use std::borrow::{
     Cow,
 };
 use std::net::TcpStream;
+use std::net::SocketAddr;
 use std::io::Result as IoResult;
 use std::io::{
     Write,
@@ -35,6 +37,7 @@ use hyper::header::{
     ProtocolName,
 };
 use unicase::UniCase;
+use self::net2::TcpStreamExt;
 
 use ws;
 use ws::sender::Sender as SenderTrait;
@@ -111,7 +114,7 @@ pub use self::builder::ClientBuilder;
 pub struct Client<S>
     where S: Stream,
 {
-    stream: S,
+    pub stream: S,
     sender: Sender,
     receiver: Receiver,
 }
@@ -130,7 +133,6 @@ impl Client<TcpStream> {
     }
 }
 
-// TODO: add net2 set_nonblocking and stuff
 impl<S> Client<S>
     where S: AsTcpStream + Stream,
 {
@@ -139,6 +141,31 @@ impl<S> Client<S>
     pub fn shutdown(&self) -> IoResult<()> {
         self.stream.as_tcp().shutdown(Shutdown::Both)
     }
+
+    /// See `TcpStream.peer_addr()`.
+    pub fn peer_addr(&self) -> IoResult<SocketAddr> {
+        self.stream.as_tcp().peer_addr()
+	  }
+
+	  /// See `TcpStream.local_addr()`.
+	  pub fn local_addr(&self) -> IoResult<SocketAddr> {
+        self.stream.as_tcp().local_addr()
+	  }
+
+	  /// See `TcpStream.set_nodelay()`.
+	  pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> {
+        self.stream.as_tcp().set_nodelay(nodelay)
+	  }
+
+	  /// See `TcpStream.set_keepalive()`.
+	  pub fn set_keepalive(&mut self, delay_in_ms: Option<u32>) -> IoResult<()> {
+        TcpStreamExt::set_keepalive_ms(self.stream.as_tcp(), delay_in_ms)
+	  }
+
+    /// Changes whether the stream is in nonblocking mode.
+    pub fn set_nonblocking(&self, nonblocking: bool) -> IoResult<()> {
+        self.stream.as_tcp().set_nonblocking(nonblocking)
+    }
 }
 
 impl<'u, 'p, 'e, 's, S> Client<S>
@@ -160,9 +187,9 @@ impl<'u, 'p, 'e, 's, S> Client<S>
     pub fn unchecked(stream: S) -> Self {
         Client {
             stream: stream,
-            // TODO: always true?
+            // NOTE: these are always true & false, see
+            // https://tools.ietf.org/html/rfc6455#section-5
             sender: Sender::new(true),
-            // TODO: always false?
             receiver: Receiver::new(false),
         }
     }
@@ -293,10 +320,10 @@ impl<S> Client<S>
     pub fn split(self) -> IoResult<(Reader<<S as Splittable>::Reader>, Writer<<S as Splittable>::Writer>)> {
         let (read, write) = try!(self.stream.split());
         Ok((Reader {
-            reader: read,
+            stream: read,
             receiver: self.receiver,
         }, Writer {
-            writer: write,
+            stream: write,
             sender: self.sender,
         }))
     }

src/receiver.rs

@@ -28,7 +28,7 @@ pub use stream::Shutdown;
 pub struct Reader<R>
     where R: Read
 {
-    pub reader: R,
+    pub stream: R,
     pub receiver: Receiver,
 }
 
@@ -37,27 +37,27 @@ impl<R> Reader<R>
 {
 	  /// Reads a single data frame from the remote endpoint.
 	  pub fn recv_dataframe(&mut self) -> WebSocketResult<DataFrame> {
-		    self.receiver.recv_dataframe(&mut self.reader)
+		    self.receiver.recv_dataframe(&mut self.stream)
 	  }
 
 	  /// Returns an iterator over incoming data frames.
 	  pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, R> {
-		    self.receiver.incoming_dataframes(&mut self.reader)
+		    self.receiver.incoming_dataframes(&mut self.stream)
 	  }
 
 	  /// Reads a single message from this receiver.
 	  pub fn recv_message<'m, M, I>(&mut self) -> WebSocketResult<M>
 	      where M: ws::Message<'m, DataFrame, DataFrameIterator = I>,
               I: Iterator<Item = DataFrame>
     {
-		    self.receiver.recv_message(&mut self.reader)
+		    self.receiver.recv_message(&mut self.stream)
 	  }
 
 	  pub fn incoming_messages<'a, M, D>(&'a mut self) -> MessageIterator<'a, Receiver, D, M, R>
 	      where M: ws::Message<'a, D>,
               D: DataFrameable
     {
-		    self.receiver.incoming_messages(&mut self.reader)
+		    self.receiver.incoming_messages(&mut self.stream)
 	  }
 }
 
@@ -67,13 +67,13 @@ impl<S> Reader<S>
 	  /// Closes the receiver side of the connection, will cause all pending and future IO to
 	  /// return immediately with an appropriate value.
 	  pub fn shutdown(&self) -> IoResult<()> {
-		    self.reader.as_tcp().shutdown(Shutdown::Read)
+		    self.stream.as_tcp().shutdown(Shutdown::Read)
 	  }
 
 	  /// Shuts down both Sender and Receiver, will cause all pending and future IO to
 	  /// return immediately with an appropriate value.
 	  pub fn shutdown_all(&self) -> IoResult<()> {
-		    self.reader.as_tcp().shutdown(Shutdown::Both)
+		    self.stream.as_tcp().shutdown(Shutdown::Both)
 	  }
 }
 

src/sender.rs

@@ -10,7 +10,7 @@ use ws::sender::Sender as SenderTrait;
 pub use stream::Shutdown;
 
 pub struct Writer<W> {
-    pub writer: W,
+    pub stream: W,
     pub sender: Sender,
 }
 
@@ -22,15 +22,15 @@ impl<W> Writer<W>
 	      where D: DataFrame,
               W: Write,
     {
-        self.sender.send_dataframe(&mut self.writer, dataframe)
+        self.sender.send_dataframe(&mut self.stream, dataframe)
     }
 
 	  /// Sends a single message to the remote endpoint.
 	  pub fn send_message<'m, M, D>(&mut self, message: &'m M) -> WebSocketResult<()>
 	      where M: ws::Message<'m, D>,
               D: DataFrame
     {
-		    self.sender.send_message(&mut self.writer, message)
+		    self.sender.send_message(&mut self.stream, message)
 	  }
 }
 
@@ -40,13 +40,13 @@ impl<S> Writer<S>
 	  /// Closes the sender side of the connection, will cause all pending and future IO to
 	  /// return immediately with an appropriate value.
 	  pub fn shutdown(&self) -> IoResult<()> {
-		    self.writer.as_tcp().shutdown(Shutdown::Write)
+		    self.stream.as_tcp().shutdown(Shutdown::Write)
 	  }
 
 	  /// Shuts down both Sender and Receiver, will cause all pending and future IO to
 	  /// return immediately with an appropriate value.
 	  pub fn shutdown_all(&self) -> IoResult<()> {
-		    self.writer.as_tcp().shutdown(Shutdown::Both)
+		    self.stream.as_tcp().shutdown(Shutdown::Both)
 	  }
 }
 

src/server/upgrade/mod.rs

@@ -81,7 +81,6 @@ impl<S> WsUpgrade<S>
 			      ConnectionOption::ConnectionHeader(UniCase("Upgrade".to_string()))
 		    ]));
         headers.set(Upgrade(vec![
-            // TODO: really not set a version for this?
             Protocol::new(ProtocolName::WebSocket, None)
         ]));