fix(net): set timeouts directly in accept

Currently, timeouts are set in `Worker::handle_connection`, _after_ the
stream has been returned by `Listener::accept`. This is not quite right,
as a `Listener` implementation that wraps `HttpListener` might do I/O in
its own `accept` implementation. For that I/O, no timeouts have been set
yet.

This is not a purely theoretical concern either, as `HttpsListener` can
do this, depending on the implementation of `SslServer` it uses. I
suspect, but could not yet confirm, that this behavior is responsible
for issue #950.

As of this commit, the timeouts are set by `HttpListener`, directly
after the connection has been accepted. Please note that `Worker` also
still sets the timeouts. This redundancy will be cleaned up in the
following commits.

src/net.rs

@@ -31,6 +31,22 @@ pub trait NetworkListener: Clone {
     fn incoming(&mut self) -> NetworkConnections<Self> {
         NetworkConnections(self)
     }
+
+    /// Sets the read timeout for all streams that are accepted
+    fn set_read_timeout(&mut self, _: Option<Duration>) {
+        // This default implementation is only here to prevent the addition of
+        // these methods from being a breaking change. They should be removed
+        // when the next breaking release is made.
+        warn!("Ignoring read timeout");
+    }
+
+    /// Sets the write timeout for all streams that are accepted
+    fn set_write_timeout(&mut self, _: Option<Duration>) {
+        // This default implementation is only here to prevent the addition of
+        // these methods from being a breaking change. They should be removed
+        // when the next breaking release is made.
+        warn!("Ignoring write timeout");
+    }
 }
 
 /// An iterator wrapper over a `NetworkAcceptor`.
@@ -205,13 +221,19 @@ impl NetworkStream + Send {
 /// A `NetworkListener` for `HttpStream`s.
 pub struct HttpListener {
     listener: TcpListener,
+
+    read_timeout : Option<Duration>,
+    write_timeout: Option<Duration>,
 }
 
 impl Clone for HttpListener {
     #[inline]
     fn clone(&self) -> HttpListener {
         HttpListener {
             listener: self.listener.try_clone().unwrap(),
+
+            read_timeout : self.read_timeout.clone(),
+            write_timeout: self.write_timeout.clone(),
         }
     }
 }
@@ -220,6 +242,9 @@ impl From<TcpListener> for HttpListener {
     fn from(listener: TcpListener) -> HttpListener {
         HttpListener {
             listener: listener,
+
+            read_timeout : None,
+            write_timeout: None,
         }
     }
 }
@@ -236,13 +261,24 @@ impl NetworkListener for HttpListener {
 
     #[inline]
     fn accept(&mut self) -> ::Result<HttpStream> {
-        Ok(HttpStream(try!(self.listener.accept()).0))
+        let stream = HttpStream(try!(self.listener.accept()).0);
+        try!(stream.set_read_timeout(self.read_timeout));
+        try!(stream.set_write_timeout(self.write_timeout));
+        Ok(stream)
     }
 
     #[inline]
     fn local_addr(&mut self) -> io::Result<SocketAddr> {
         self.listener.local_addr()
     }
+
+    fn set_read_timeout(&mut self, duration: Option<Duration>) {
+        self.read_timeout = duration;
+    }
+
+    fn set_write_timeout(&mut self, duration: Option<Duration>) {
+        self.write_timeout = duration;
+    }
 }
 
 #[cfg(windows)]
@@ -537,6 +573,14 @@ impl<S: SslServer + Clone> NetworkListener for HttpsListener<S> {
     fn local_addr(&mut self) -> io::Result<SocketAddr> {
         self.listener.local_addr()
     }
+
+    fn set_read_timeout(&mut self, duration: Option<Duration>) {
+        self.listener.set_read_timeout(duration)
+    }
+
+    fn set_write_timeout(&mut self, duration: Option<Duration>) {
+        self.listener.set_write_timeout(duration)
+    }
 }
 
 /// A connector that can protect HTTP streams using SSL.

src/server/mod.rs

@@ -198,11 +198,13 @@ impl<L: NetworkListener> Server<L> {
 
     /// Sets the read timeout for all Request reads.
     pub fn set_read_timeout(&mut self, dur: Option<Duration>) {
+        self.listener.set_read_timeout(dur);
         self.timeouts.read = dur;
     }
 
     /// Sets the write timeout for all Response writes.
     pub fn set_write_timeout(&mut self, dur: Option<Duration>) {
+        self.listener.set_write_timeout(dur);
         self.timeouts.write = dur;
     }
 }