Revert "rustls-mio: bump mio to 0.7"

This reverts commit a99d3f0a2c.
This reverts commit d5ecfb4b75.
This reverts commit 83c6495770.

rustls-mio/Cargo.toml

@@ -23,7 +23,7 @@ webpki = "0.21.0"
 ct-logs = "0.6"
 docopt = "~1.1"
 env_logger = "0.7.1"
-mio = { version = "0.7", features = ["os-poll", "tcp"] }
+mio = "0.6.14"
 regex = "1.0"
 serde = "1.0"
 serde_derive = "1.0"

rustls-mio/examples/tlsclient.rs

@@ -2,7 +2,7 @@ use std::sync::{Arc, Mutex};
 use std::process;
 
 use mio;
-use mio::net::TcpStream;
+use mio::tcp::TcpStream;
 
 use std::net::SocketAddr;
 use std::str;
@@ -40,14 +40,16 @@ struct TlsClient {
 }
 
 impl TlsClient {
-    fn ready(&mut self, ev: &mio::event::Event) {
+    fn ready(&mut self,
+             poll: &mut mio::Poll,
+             ev: &mio::Event) {
         assert_eq!(ev.token(), CLIENT);
 
-        if ev.is_readable() {
+        if ev.readiness().is_readable() {
             self.do_read();
         }
 
-        if ev.is_writable() {
+        if ev.readiness().is_writable() {
             self.do_write();
         }
 
@@ -55,6 +57,8 @@ impl TlsClient {
             println!("Connection closed");
             process::exit(if self.clean_closure { 0 } else { 1 });
         }
+
+        self.reregister(poll);
     }
 }
 
@@ -157,24 +161,34 @@ impl TlsClient {
         self.tls_session.writev_tls(&mut WriteVAdapter::new(&mut self.socket)).unwrap();
     }
 
-    fn register(&mut self, poll: &mut mio::Poll) {
+    fn register(&self, poll: &mut mio::Poll) {
-        let registry = poll.registry();
+        poll.register(&self.socket,
-        let interest = self.ready_interest();
+                      CLIENT,
-        registry.register(&mut self.socket, CLIENT, interest).unwrap();
+                      self.ready_interest(),
+                      mio::PollOpt::level() | mio::PollOpt::oneshot())
+            .unwrap();
+    }
+
+    fn reregister(&self, poll: &mut mio::Poll) {
+        poll.reregister(&self.socket,
+                        CLIENT,
+                        self.ready_interest(),
+                        mio::PollOpt::level() | mio::PollOpt::oneshot())
+            .unwrap();
     }
 
     // Use wants_read/wants_write to register for different mio-level
     // IO readiness events.
-    fn ready_interest(&self) -> mio::Interest {
+    fn ready_interest(&self) -> mio::Ready {
         let rd = self.tls_session.wants_read();
         let wr = self.tls_session.wants_write();
 
         if rd && wr {
-            mio::Interest::READABLE | mio::Interest::WRITABLE
+            mio::Ready::readable() | mio::Ready::writable()
         } else if wr {
-            mio::Interest::WRITABLE
+            mio::Ready::writable()
         } else {
-            mio::Interest::READABLE
+            mio::Ready::readable()
         }
     }
 
@@ -525,7 +539,7 @@ fn main() {
 
     let config = make_config(&args);
 
-    let sock = TcpStream::connect(addr).unwrap();
+    let sock = TcpStream::connect(&addr).unwrap();
     let dns_name = webpki::DNSNameRef::try_from_ascii_str(&args.arg_hostname).unwrap();
     let mut tlsclient = TlsClient::new(sock, dns_name, config);
 
@@ -549,7 +563,7 @@ fn main() {
             .unwrap();
 
         for ev in events.iter() {
-            tlsclient.ready(&ev);
+            tlsclient.ready(&mut poll, &ev);
         }
     }
 }

rustls-mio/examples/tlsserver.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use mio;
-use mio::net::{TcpListener, TcpStream};
+use mio::tcp::{TcpListener, TcpStream, Shutdown};
 
 #[macro_use]
 extern crate log;
@@ -75,9 +75,8 @@ impl TlsServer {
                 let token = mio::Token(self.next_id);
                 self.next_id += 1;
 
-                let mut connection = Connection::new(socket, token, mode, tls_session);
+                self.connections.insert(token, Connection::new(socket, token, mode, tls_session));
-                connection.register(poll);
+                self.connections[&token].register(poll);
-                self.connections.insert(token, connection);
                 true
             }
             Err(e) => {
@@ -87,7 +86,7 @@ impl TlsServer {
         }
     }
 
-    fn conn_event(&mut self, poll: &mut mio::Poll, event: &mio::event::Event) {
+    fn conn_event(&mut self, poll: &mut mio::Poll, event: &mio::Event) {
         let token = event.token();
 
         if self.connections.contains_key(&token) {
@@ -124,7 +123,7 @@ fn open_back(mode: &ServerMode) -> Option<TcpStream> {
     match *mode {
         ServerMode::Forward(ref port) => {
             let addr = net::SocketAddrV4::new(net::Ipv4Addr::new(127, 0, 0, 1), *port);
-            let conn = TcpStream::connect(net::SocketAddr::V4(addr)).unwrap();
+            let conn = TcpStream::connect(&net::SocketAddr::V4(addr)).unwrap();
             Some(conn)
         }
         _ => None,
@@ -166,25 +165,26 @@ impl Connection {
     }
 
     /// We're a connection, and we have something to do.
-    fn ready(&mut self, poll: &mut mio::Poll, ev: &mio::event::Event) {
+    fn ready(&mut self, poll: &mut mio::Poll, ev: &mio::Event) {
         // If we're readable: read some TLS.  Then
         // see if that yielded new plaintext.  Then
         // see if the backend is readable too.
-        if ev.is_readable() {
+        if ev.readiness().is_readable() {
             self.do_tls_read();
             self.try_plain_read();
             self.try_back_read();
         }
 
-        if ev.is_writable() {
+        if ev.readiness().is_writable() {
             self.do_tls_write_and_handle_error();
         }
 
         if self.closing {
-            let _ = self.socket.shutdown(net::Shutdown::Both);
+            let _ = self.socket.shutdown(Shutdown::Both);
             self.close_back();
             self.closed = true;
-            self.deregister(poll);
+        } else {
+            self.reregister(poll);
         }
     }
 
@@ -192,7 +192,7 @@ impl Connection {
     fn close_back(&mut self) {
         if self.back.is_some() {
             let back = self.back.as_mut().unwrap();
-            back.shutdown(net::Shutdown::Both).unwrap();
+            back.shutdown(Shutdown::Both).unwrap();
         }
         self.back = None;
     }
@@ -326,45 +326,50 @@ impl Connection {
         }
     }
 
-    fn register(&mut self, poll: &mut mio::Poll) {
+    fn register(&self, poll: &mut mio::Poll) {
-        let registry = poll.registry();
+        poll.register(&self.socket,
-        let event_set = self.event_set();
+                      self.token,
-        registry.register(&mut self.socket,
+                      self.event_set(),
-                          self.token,
+                      mio::PollOpt::level() | mio::PollOpt::oneshot())
-                          event_set)
             .unwrap();
 
         if self.back.is_some() {
-            registry.register(self.back.as_mut().unwrap(),
+            poll.register(self.back.as_ref().unwrap(),
-                              self.token,
+                          self.token,
-                              mio::Interest::READABLE)
+                          mio::Ready::readable(),
+                          mio::PollOpt::level() | mio::PollOpt::oneshot())
                 .unwrap();
         }
     }
 
-    fn deregister(&mut self, poll: &mut mio::Poll) {
+    fn reregister(&self, poll: &mut mio::Poll) {
-        let registry = poll.registry();
+        poll.reregister(&self.socket,
-        registry.deregister(&mut self.socket)
+                        self.token,
+                        self.event_set(),
+                        mio::PollOpt::level() | mio::PollOpt::oneshot())
             .unwrap();
 
         if self.back.is_some() {
-            registry.deregister(self.back.as_mut().unwrap())
+            poll.reregister(self.back.as_ref().unwrap(),
+                            self.token,
+                            mio::Ready::readable(),
+                            mio::PollOpt::level() | mio::PollOpt::oneshot())
                 .unwrap();
         }
     }
 
     /// What IO events we're currently waiting for,
     /// based on wants_read/wants_write.
-    fn event_set(&self) -> mio::Interest {
+    fn event_set(&self) -> mio::Ready {
         let rd = self.tls_session.wants_read();
         let wr = self.tls_session.wants_write();
 
         if rd && wr {
-            mio::Interest::READABLE | mio::Interest::WRITABLE
+            mio::Ready::readable() | mio::Ready::writable()
         } else if wr {
-            mio::Interest::WRITABLE
+            mio::Ready::writable()
         } else {
-            mio::Interest::READABLE
+            mio::Ready::readable()
         }
     }
 
@@ -601,12 +606,13 @@ fn main() {
 
     let config = make_config(&args);
 
-    let mut listener = TcpListener::bind(addr).expect("cannot listen on port");
+    let listener = TcpListener::bind(&addr).expect("cannot listen on port");
     let mut poll = mio::Poll::new()
         .unwrap();
-    poll.registry().register(&mut listener,
+    poll.register(&listener,
                   LISTENER,
-                  mio::Interest::READABLE)
+                  mio::Ready::readable(),
+                  mio::PollOpt::level())
         .unwrap();
 
     let mode = if args.cmd_echo {