X-Git-Url: http://git.euphorik.ch/?p=crypto_lab1.git;a=blobdiff_plain;f=lab1_rust%2Fsrc%2Fend_point.rs;h=83967dac4640651ecce039c4ecc277da7d58ccfe;hp=e7b0e321058de51102344abdcdeb97e99381dfcb;hb=d7f0bb987b21e93a5798403d294f7905151682f7;hpb=4d892f864a1f47eb1aab23f1c70ccb143081849c

diff --git a/lab1_rust/src/end_point.rs b/lab1_rust/src/end_point.rs
index e7b0e32..83967da 100644
--- a/lab1_rust/src/end_point.rs
+++ b/lab1_rust/src/end_point.rs
@@ -1,9 +1,11 @@
 use std::io;
 use std::io::{ MemWriter, Acceptor, Listener, TcpStream, IoResult, IoError, EndOfFile };
 use std::io::net::tcp::{ TcpAcceptor, TcpListener };
+use std::thread::Thread;
 use packet;
 use packet::{ Packet, ReadingResult, PacketType };
 use packet::PacketType::{ Command, Answer, Error };
+use utils::from_elem;
 
 // Default timeout when waiting data on a stream (for instance: 'TcpStream::read').
 static DEFAULT_TIMEOUT: Option<u64> = Some(500); // [ms].
@@ -30,18 +32,19 @@ impl Server {
          acceptor: acceptor.clone()
       };
 
-      spawn(proc() {
+      Thread::spawn(move || {
          loop {
             for stream in acceptor.incoming() {
                match stream {
-                  Ok(stream) => spawn(proc() {
-                     Server::handle_client(EndPoint::new(stream, variant));
-                  }),
+                  Ok(stream) =>
+                     Thread::spawn(move || {
+                        Server::handle_client(EndPoint::new(stream, variant));
+                     }).detach(),
                   _ => return
                }
             }
          }
-      });
+      }).detach();
 
       Ok(server)
    }
@@ -136,7 +139,7 @@ impl Client {
          let mut m = MemWriter::new();
          match (Packet { t: Command(Packet::random_packet_data(&[42])), timestamp: timestamp }).write(&mut m, packet::Variant::Weak) {
             Err(_) => vec!(),
-            _ => m.unwrap()
+            _ => m.into_inner()
          }
       }
 
@@ -193,7 +196,7 @@ impl Client {
          // 5)
          |client: &mut Client| -> bool {
             println!("Sending a packet with too small data...");
-            let command = Command(Packet::new_packet_data(0, Vec::from_elem(6, 0x00)));
+            let command = Command(Packet::new_packet_data(0, from_elem(6, 0x00)));
             match client.end_point.send_with_result(command) {
                Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
@@ -205,7 +208,7 @@ impl Client {
          // 6)
          |client: &mut Client| -> bool {
             println!("Sending a packet with too large data...");
-            let command = Command(Packet::new_packet_data(0, Vec::from_elem(40, 0x00)));
+            let command = Command(Packet::new_packet_data(0, from_elem(40, 0x00)));
             match client.end_point.send_with_result(command) {
                Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
@@ -221,7 +224,7 @@ impl Client {
             let mut m = MemWriter::new();
             let raw_packet = match (Packet { t: Command(Packet::random_packet_data(&[42])), timestamp: client.end_point.current_timestamp }).write_with_padding_fun(&mut m, packet::Variant::Weak, |_, _| -> u8 { 0 }) {
                Err(_) => vec!(),
-               _ => m.unwrap()
+               _ => m.into_inner()
             };
 
             match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
@@ -236,7 +239,7 @@ impl Client {
 
       let mut nb_test_passed = 0;
       for (i, test) in range(1, tests.len()+1).zip(tests.iter_mut()) {
-         println!("===== Test case #{}:", i)
+         println!("===== Test case #{}:", i);
          if execute(test) {
             nb_test_passed += 1;
             println!("===== Test passed");
@@ -299,10 +302,9 @@ impl EndPoint {
 
    fn read(&mut self) -> ReadingResult {
       fn send_error(ep: &mut EndPoint, error_type: packet::ErrorType) {
-         match ep.send(Error(error_type)) {
-            Err(e) => println!("Unable to send error packet: {}", e),
-            Ok(_) => ()
-         };
+         if let Err(e) = ep.send(Error(error_type)) {
+            println!("Unable to send error packet: {}", e)
+         }
       };
 
       self.socket.set_timeout(DEFAULT_TIMEOUT);