1 use std
::io
::{ Acceptor
, Listener
, TcpStream
, IoResult
, IoError
, EndOfFile
};
2 use std
::io
::net
::tcp
::{ TcpAcceptor
, TcpListener
};
4 use packet
::{ Packet
, Command
, Answer
, Error
, ReadingResult
, PacketType
};
16 current_timestamp
: u64
20 pub fn new(port
: u16) -> IoResult
<Server
> {
21 let mut acceptor
= try!(TcpListener
::bind("127.0.0.1", port
).listen());
24 acceptor
: acceptor
.clone()
29 for stream
in acceptor
.incoming() {
32 Ok(stream
) => spawn(proc() {
33 Server
::handle_client(EndPoint
{ socket
: stream
, current_timestamp
: 0 });
43 pub fn close(&mut self) -> IoResult
<()> {
44 self.acceptor
.close_accept()
47 fn handle_client(mut end_point
: EndPoint
) {
49 match end_point
.read() {
50 Ok(packet@Packet
{ t
: Command(..), .. }) => {
51 println!("[Server] Valid command received: {}", packet
);
52 let answer
= Answer(Packet
::random_packet_data());
53 match end_point
.send(answer
.clone()) {
55 println!("[Server] Answer sent: {}", answer
),
57 println!("[Server] Can't send the answer. Error: {}", e
)
60 // Socket has been closed.
61 Err(packet
::IOReadError(IoError
{ kind
: EndOfFile
, .. })) => {
62 println!("[Server] Connection closed: EOF");
66 println!("[Server] Error or invalid packet: {}", other
)
73 pub fn new(address
: &str, port
: u16) -> IoResult
<Client
> {
74 Ok(Client
{ end_point
: EndPoint
{
75 socket
: try!(TcpStream
::connect(address
, port
)),
80 pub fn close(&mut self) -> IoResult
<()> {
81 self.end_point
.close()
84 pub fn send(&mut self, packet
: PacketType
) {
87 println!("[Client] Sending: {}", packet
);
88 match self.end_point
.send_with_result(packet
) {
89 Ok(Ok(packet@Packet
{ t
: Answer(..), .. })) =>
90 println!("[Client] Command transmitted correctly, answer: {}", packet
),
92 println!("[Client] Command transmitted correctly, wrong answer: {}", packet
),
94 println!("[Client] Answer error: {}", e
),
96 println!("[Client] Can't send the packet. Error: {}", e
)
100 println!("[Client] Cannot send this type of packet: {}", other
)
106 fn close(&mut self) -> IoResult
<()> {
107 try!(self.socket
.close_read());
108 try!(self.socket
.close_write());
113 * Send a packet and wait synchronously an answer.
115 fn send_with_result(&mut self, p
: PacketType
) -> IoResult
<ReadingResult
> {
122 fn send(&mut self, p
: PacketType
) -> IoResult
<()> {
123 self.current_timestamp
+= 1;
124 match (Packet
{ t
: p
, timestamp
: self.current_timestamp
}).write(&mut self.socket
) {
126 Err(packet
::WriteIOError(e
)) => Err(e
)
130 fn read(&mut self) -> ReadingResult
{
131 fn send_error(ep
: &mut EndPoint
, error_type
: packet
::ErrorType
) {
132 match ep
.send(Error(error_type
)) {
133 Err(e
) => println!("Unable to send error packet: {}", e
),
138 match Packet
::read(&mut self.socket
) {
140 if packet
.timestamp
<= self.current_timestamp
{
141 println!("Error, timestamp mismatch, current timestamp: {}, packet received: {}", self.current_timestamp
, packet
);
142 Err(packet
::InvalidTimestamp
)
144 self.current_timestamp
= packet
.timestamp
+ 1;
148 e @
Err(packet
::PaddingError
) => {
149 send_error(self, packet
::CryptError
);
152 e @
Err(packet
::MACMismatchError
) => {
153 send_error(self, packet
::AuthError
);