Clean up warnings.

src/main.rs

@@ -11,7 +11,7 @@ extern crate mio;
 use std::io;
 use std::net::ToSocketAddrs;
 
-use mio::{EventLoop, EventSet, Handler, PollOpt, Token};
+use mio::EventLoop;
 use mio::tcp::TcpStream;
 
 use proto::PacketStream;
@@ -39,7 +39,7 @@ fn main() {
 
     let packet_stream = PacketStream::new(stream);
     let mut server_conn = ServerConnection::new(packet_stream);
-    server_conn.register_all(&mut event_loop);
+    server_conn.register_all(&mut event_loop).unwrap();
 
     event_loop.run(&mut server_conn).unwrap();
 }

src/proto/packet.rs

@@ -1,13 +1,12 @@
 use std::iter::repeat;
 use std::io;
-use std::io::{Cursor, Read, Write};
+use std::io::{Read, Write};
 use std::mem;
 
 use byteorder::{ByteOrder, LittleEndian, ReadBytesExt, WriteBytesExt};
 use mio::{
     Evented, EventLoop, EventSet, Handler, PollOpt, Token, TryRead, TryWrite
 };
-use mio::tcp::TcpStream;
 
 const MAX_PACKET_SIZE: usize = 1 << 20; // 1 MiB
 const U32_SIZE: usize = 4;
@@ -191,15 +190,19 @@ impl<T: Read + Write + Evented> PacketStream<T> {
         }
     }
 
-    pub fn register<U: Handler>(&self, event_loop: &mut EventLoop<U>,
-                                token: Token, event_set: EventSet,
-                                poll_opt: PollOpt) {
-        event_loop.register(&self.stream, token, event_set, poll_opt);
+    pub fn register<U: Handler>(
+        &self, event_loop: &mut EventLoop<U>, token: Token,
+        event_set: EventSet, poll_opt: PollOpt)
+        -> io::Result<()>
+    {
+        event_loop.register(&self.stream, token, event_set, poll_opt)
     }
 
-    pub fn reregister<U: Handler>(&self, event_loop: &mut EventLoop<U>,
-                                token: Token, event_set: EventSet,
-                                poll_opt: PollOpt) {
-        event_loop.reregister(&self.stream, token, event_set, poll_opt);
+    pub fn reregister<U: Handler>(
+        &self, event_loop: &mut EventLoop<U>, token: Token,
+        event_set: EventSet, poll_opt: PollOpt)
+        -> io::Result<()>
+    {
+        event_loop.reregister(&self.stream, token, event_set, poll_opt)
     }
 }

src/proto/server.rs

@@ -6,9 +6,6 @@ use crypto::digest::Digest;
 
 use super::Packet;
 
-const VERSION_MAJOR: u32 = 181;
-const VERSION_MINOR: u32 = 0;
-
 const CODE_LOGIN: u32 = 1;
 const CODE_ROOM_LIST: u32 = 64;
 
@@ -100,7 +97,7 @@ impl WriteToPacket for LoginRequest {
         try!(packet.write_str(&self.username));
         try!(packet.write_str(&self.password));
         try!(packet.write_uint(self.major));
-        try!(packet.write_str(&md5_str(&userpass)));
+        try!(packet.write_str(&userpass_md5));
         try!(packet.write_uint(self.minor));
 
         Ok(())
@@ -151,7 +148,7 @@ impl RoomListRequest {
 }
 
 impl WriteToPacket for RoomListRequest {
-    fn write_to_packet(&self, packet: &mut Packet) -> io::Result<()> {
+    fn write_to_packet(&self, _: &mut Packet) -> io::Result<()> {
         Ok(())
     }
 }
@@ -169,10 +166,16 @@ impl RoomListResponse {
         let (owned_private_rooms, other_private_rooms) =
             match Self::read_rooms(&mut packet) {
 
-            Err(e) => (Vec::new(), Vec::new()),
+            Err(e) => {
+                debug!("Error while parsing RoomListResponse: {}", e);
+                (Vec::new(), Vec::new())
+            },
 
             Ok(owned_private_rooms) => match Self::read_rooms(&mut packet) {
-                Err(e) => (owned_private_rooms, Vec::new()),
+                Err(e) => {
+                    debug!("Error while parsing RoomListResponse: {}", e);
+                    (owned_private_rooms, Vec::new())
+                },
 
                 Ok(other_private_rooms) =>
                     (owned_private_rooms, other_private_rooms)
@@ -190,7 +193,7 @@ impl RoomListResponse {
         let mut rooms = Vec::new();
 
         let num_rooms = try!(packet.read_uint()) as usize;
-        for i in 0..num_rooms {
+        for _ in 0..num_rooms {
             let room_name = try!(packet.read_str());
             rooms.push((room_name, 0));
         }

src/server.rs

@@ -1,12 +1,10 @@
 use std::io;
-use std::io::{Read, Write};
-use std::net::Ipv4Addr;
 
 use mio::{EventLoop, EventSet, Handler, PollOpt, Token};
 use mio::tcp::TcpStream;
 
 use config;
-use proto::{Packet, PacketStream};
+use proto::{PacketStream};
 use proto::server::*;
 
 #[derive(Debug, Clone, Copy)]
@@ -51,7 +49,8 @@ impl ServerConnection {
                             config::VER_MAJOR,
                             config::VER_MINOR,
                             ).unwrap());
-                self.server_stream.try_write(request.to_packet().unwrap());
+                self.server_stream.try_write(request.to_packet().unwrap())
+                    .unwrap();
             },
 
             _ => ()
@@ -79,14 +78,18 @@ impl ServerConnection {
             ServerResponse::RoomListResponse(room_list_response) =>
                 self.handle_room_list_response(room_list_response),
 
-            ServerResponse::UnknownResponse(code, packet) =>
+            ServerResponse::UnknownResponse(code, _) =>
                 println!("Unknown packet code {}", code),
         }
     }
 
-    pub fn register_all<T: Handler>(&self, event_loop: &mut EventLoop<T>) {
-        self.server_stream.register(event_loop, self.server_token,
-                                    self.server_interest, PollOpt::edge());
+    pub fn register_all<T: Handler>(&self, event_loop: &mut EventLoop<T>)
+        -> io::Result<()>
+    {
+        try!(self.server_stream.register(
+                event_loop, self.server_token, self.server_interest,
+                PollOpt::edge()));
+        Ok(())
     }
 
     fn handle_login_response(&mut self, login: LoginResponse) {
@@ -149,7 +152,7 @@ impl Handler for ServerConnection {
             }
             self.server_stream.reregister(
                 event_loop, token, self.server_interest,
-                PollOpt::edge() | PollOpt::oneshot())
+                PollOpt::edge() | PollOpt::oneshot()).unwrap();
         } else {
             unreachable!("Unknown token!");
         }