+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 };
+// Default timeout when waiting data on a stream (for instance: 'TcpStream::read').
static DEFAULT_TIMEOUT: Option<u64> = Some(500); // [ms].
pub struct Server {
end_point: EndPoint,
}
-struct EndPoint {
+pub struct EndPoint {
socket: TcpStream,
current_timestamp: u64
}
loop {
for stream in acceptor.incoming() {
match stream {
- Err(_) => return,
Ok(stream) => spawn(proc() {
- Server::handle_client(EndPoint { socket: stream, current_timestamp: 0 });
- })
+ Server::handle_client(EndPoint::new(stream));
+ }),
+ _ => return
}
}
}
}
/// Send some valid and not-valid packets to the server and check the result.
+ /// For each test a new client is created.
pub fn start_tests(address: &str, port: u16) {
let execute = |f: &mut |&mut Client| -> bool| -> bool {
match Client::new(address, port) {
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) {
- Err(e) => vec!(),
+ Err(_) => vec!(),
_ => m.unwrap()
}
}
let mut tests = vec!(
+ // 1)
|client: &mut Client| -> bool {
- println!("Send a valid packet...");
+ println!("Sending a valid packet...");
match client.end_point.send_with_result(Command(Packet::random_packet_data([42]))) {
- Ok(Ok(packet@Packet { t: Answer(..), .. })) => true,
+ Ok(Ok(Packet { t: Answer(..), .. })) => true,
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 2)
|client: &mut Client| -> bool {
- println!("Send a packet with an unknown type...");
+ println!("Sending a packet with an unknown type...");
client.end_point.current_timestamp += 1;
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: TimedOut, .. }))) => true, // OK: the server should not send any packet.
+ Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 3)
|client: &mut Client| -> bool {
- println!("Send a packet with an old timestamp...");
+ println!("Sending a packet with an old timestamp...");
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: TimedOut, .. }))) => true, // OK: the server should not send any packet.
+ Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 4)
|client: &mut Client| -> bool {
- println!("Send a packet with altered crypted data...");
+ println!("Sending a packet with altered crypted data (do not alter the padding)...");
client.end_point.current_timestamp += 1;
let mut raw_packet = raw_packet(client.end_point.current_timestamp);
raw_packet[11] = 0xDE;
raw_packet[13] = 0xBE;
raw_packet[14] = 0xEF;
match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
- Ok(Ok(packet@Packet { t: Error(packet::AuthError), .. })) => true,
+ Ok(Ok(Packet { t: Error(packet::AuthError), .. })) => true,
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 5)
|client: &mut Client| -> bool {
- println!("Send a packet with too small data...");
- let mut command = Command(Packet::new_packet_data(0, Vec::from_elem(6, 0x00)));
+ 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: TimedOut, .. }))) => true, // OK: the server should not send any packet.
+ Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 6)
|client: &mut Client| -> bool {
- println!("Send a packet with too large data...");
- let mut command = Command(Packet::new_packet_data(0, Vec::from_elem(40, 0x00)));
+ 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: TimedOut, .. }))) => true, // OK: the server should not send any packet.
+ Ok(Err(packet::IOReadError( IoError { kind: io::TimedOut, .. }))) => true, // OK: the server should not send any packet.
other => {
println!("Error: {}", other);
false
}
}
},
-
+ // 7)
|client: &mut Client| -> bool {
- println!("Send a packet with wrong padding...");
+ 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, |_, _| -> u8 { 0 }) {
- Err(e) => vec!(),
+ Err(_) => vec!(),
_ => m.unwrap()
};
match client.end_point.send_raw_with_result(raw_packet.as_slice()) {
- Ok(Ok(packet@Packet { t: Error(packet::CryptError), .. })) => true,
+ Ok(Ok(Packet { t: Error(packet::CryptError), .. })) => true,
other => {
println!("Error: {}", other);
false
}
impl EndPoint {
+ pub fn new(socket: TcpStream) -> EndPoint {
+ EndPoint { socket: socket, current_timestamp: 0 }
+ }
+
fn close(&mut self) -> IoResult<()> {
try!(self.socket.close_read());
try!(self.socket.close_write());
projects / crypto_lab1.git / blobdiff