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

diff --git a/lab1_rust/src/end_point.rs b/lab1_rust/src/end_point.rs
index bf8d4de..e7b0e32 100644
--- a/lab1_rust/src/end_point.rs
+++ b/lab1_rust/src/end_point.rs
@@ -2,7 +2,8 @@ use std::io;
 use std::io::{ MemWriter, Acceptor, Listener, TcpStream, IoResult, IoError, EndOfFile };
 use std::io::net::tcp::{ TcpAcceptor, TcpListener };
 use packet;
-use packet::{ Packet, Command, Answer, Error, ReadingResult, PacketType };
+use packet::{ Packet, ReadingResult, PacketType };
+use packet::PacketType::{ Command, Answer, Error };
 
 // Default timeout when waiting data on a stream (for instance: 'TcpStream::read').
 static DEFAULT_TIMEOUT: Option<u64> = Some(500); // [ms].
@@ -54,7 +55,7 @@ impl Server {
          match end_point.read() {
             Ok(packet@Packet { t: Command(..), .. }) => {
                end_point.print("Server",  format!("Valid command received: {}", packet));
-               let answer = Answer(Packet::random_packet_data([]));
+               let answer = Answer(Packet::random_packet_data(&[]));
                match end_point.send(answer.clone()) {
                   Ok(_) =>
                      end_point.print("Server", format!("Answer sent: {}", answer)),
@@ -63,7 +64,7 @@ impl Server {
                }
             },
             // Socket has been closed.
-            Err(packet::IOReadError(IoError { kind: EndOfFile, .. })) => {
+            Err(packet::ReadingError::IO(IoError { kind: EndOfFile, .. })) => {
                end_point.print("Server", format!("Connection closed: EOF"));
                return
             },
@@ -133,7 +134,7 @@ impl Client {
 
       fn raw_packet(timestamp: u64) -> Vec<u8> {
          let mut m = MemWriter::new();
-         match (Packet { t: Command(Packet::random_packet_data([42])), timestamp: timestamp }).write(&mut m, packet::Weak) {
+         match (Packet { t: Command(Packet::random_packet_data(&[42])), timestamp: timestamp }).write(&mut m, packet::Variant::Weak) {
             Err(_) => vec!(),
             _ => m.unwrap()
          }
@@ -143,7 +144,7 @@ impl Client {
          // 1)
          |client: &mut Client| -> bool {
             println!("Sending a valid packet...");
-            client.send(Command(Packet::random_packet_data([42])))
+            client.send(Command(Packet::random_packet_data(&[42])))
          },
          // 2)
          |client: &mut Client| -> bool {
@@ -152,7 +153,7 @@ impl Client {
             let mut raw_packet = raw_packet(client.end_point.current_timestamp);
             raw_packet[2] = 0xEE; // Alter the type.
             match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
-               Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
+               Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
                   println!("Error: {}", other);
                   false
@@ -165,7 +166,7 @@ impl Client {
             client.end_point.current_timestamp += 1;
             let raw_packet = raw_packet(0);
             match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
-               Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
+               Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
                   println!("Error: {}", other);
                   false
@@ -182,7 +183,7 @@ impl Client {
             raw_packet[13] = 0xBE;
             raw_packet[14] = 0xEF;
             match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
-               Ok(Ok(Packet { t: Error(packet::AuthError), .. })) => true,
+               Ok(Ok(Packet { t: Error(packet::ErrorType::Auth), .. })) => true,
                other => {
                   println!("Error: {}", other);
                   false
@@ -194,7 +195,7 @@ impl Client {
             println!("Sending a packet with too small data...");
             let command = Command(Packet::new_packet_data(0, Vec::from_elem(6, 0x00)));
             match client.end_point.send_with_result(command) {
-               Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
+               Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
                   println!("Error: {}", other);
                   false
@@ -206,7 +207,7 @@ impl Client {
             println!("Sending a packet with too large data...");
             let command = Command(Packet::new_packet_data(0, Vec::from_elem(40, 0x00)));
             match client.end_point.send_with_result(command) {
-               Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
+               Ok(Err(packet::ReadingError::IO( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
                other => {
                   println!("Error: {}", other);
                   false
@@ -218,13 +219,13 @@ impl Client {
             println!("Sending a packet with wrong padding (all 0)...");
             client.end_point.current_timestamp += 1;
             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::Weak, |_, _| -> u8 { 0 }) {
+            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()
             };
 
             match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
-               Ok(Ok(Packet { t: Error(packet::CryptError), .. })) => true,
+               Ok(Ok(Packet { t: Error(packet::ErrorType::Crypt), .. })) => true,
                other => {
                   println!("Error: {}", other);
                   false
@@ -291,7 +292,7 @@ impl EndPoint {
       self.socket.set_timeout(DEFAULT_TIMEOUT);
       self.current_timestamp += 1;
       match (Packet { t: p, timestamp: self.current_timestamp }).write(&mut self.socket, self.variant) {
-         Err(packet::WriteIOError(e)) => Err(e),
+         Err(packet::WritingError::IO(e)) => Err(e),
          _ => Ok(())
       }
    }
@@ -309,20 +310,20 @@ impl EndPoint {
          Ok(packet) => {
             if packet.timestamp <= self.current_timestamp {
                println!("Error, timestamp mismatch, current timestamp: {}, packet received: {}", self.current_timestamp, packet);
-               Err(packet::InvalidTimestampError)
+               Err(packet::ReadingError::InvalidTimestamp)
             } else {
                self.current_timestamp = packet.timestamp + 1;
                Ok(packet)
             }
          },
-         e @ Err(packet::PaddingError) => {
+         e @ Err(packet::ReadingError::Padding) => {
             self.current_timestamp += 1;
-            send_error(self, packet::CryptError);
+            send_error(self, packet::ErrorType::Crypt);
             e
          },
-         e @ Err(packet::MACMismatchError) => {
+         e @ Err(packet::ReadingError::MACMismatch) => {
             self.current_timestamp += 1;
-            send_error(self, packet::AuthError);
+            send_error(self, packet::ErrorType::Auth);
             e
          },
          other =>