You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
187 lines
5.1 KiB
187 lines
5.1 KiB
use std::io;
|
|
|
|
use proto::{DecodeError, MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecoder,
|
|
ProtoEncode, ProtoEncoder, ReadFromPacket, WriteToPacket};
|
|
use proto::peer::constants::*;
|
|
|
|
/*=========*
|
|
* MESSAGE *
|
|
*=========*/
|
|
|
|
/// This enum contains all the possible messages peers can exchange.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum Message {
|
|
PierceFirewall(u32),
|
|
PeerInit(PeerInit),
|
|
Unknown(u32),
|
|
}
|
|
|
|
impl ReadFromPacket for Message {
|
|
fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
|
|
let code: u32 = try!(packet.read_value());
|
|
let message = match code {
|
|
CODE_PIERCE_FIREWALL => Message::PierceFirewall(try!(packet.read_value())),
|
|
|
|
CODE_PEER_INIT => Message::PeerInit(try!(packet.read_value())),
|
|
|
|
code => Message::Unknown(code),
|
|
};
|
|
|
|
let bytes_remaining = packet.bytes_remaining();
|
|
if bytes_remaining > 0 {
|
|
warn!(
|
|
"Peer message with code {} contains {} extra bytes",
|
|
code,
|
|
bytes_remaining
|
|
)
|
|
}
|
|
|
|
Ok(message)
|
|
}
|
|
}
|
|
|
|
impl ProtoDecode for Message {
|
|
fn decode(decoder: &mut ProtoDecoder) -> Result<Self, DecodeError> {
|
|
let code = decoder.decode_u32()?;
|
|
let message = match code {
|
|
CODE_PIERCE_FIREWALL => {
|
|
let val = decoder.decode_u32()?;
|
|
Message::PierceFirewall(val)
|
|
}
|
|
CODE_PEER_INIT => {
|
|
let peer_init = PeerInit::decode(decoder)?;
|
|
Message::PeerInit(peer_init)
|
|
}
|
|
_ => {
|
|
return Err(DecodeError::UnknownCodeError(code));
|
|
}
|
|
};
|
|
Ok(message)
|
|
}
|
|
}
|
|
|
|
impl ProtoEncode for Message {
|
|
fn encode(&self, encoder: &mut ProtoEncoder) -> io::Result<()> {
|
|
match *self {
|
|
Message::PierceFirewall(token) => {
|
|
encoder.encode_u32(CODE_PIERCE_FIREWALL)?;
|
|
encoder.encode_u32(token)?;
|
|
}
|
|
Message::PeerInit(ref request) => {
|
|
encoder.encode_u32(CODE_PEER_INIT)?;
|
|
request.encode(encoder)?;
|
|
}
|
|
Message::Unknown(_) => unreachable!(),
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl WriteToPacket for Message {
|
|
fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
|
|
match *self {
|
|
Message::PierceFirewall(ref token) => {
|
|
try!(packet.write_value(&CODE_PIERCE_FIREWALL));
|
|
try!(packet.write_value(token));
|
|
}
|
|
|
|
Message::PeerInit(ref request) => {
|
|
try!(packet.write_value(&CODE_PEER_INIT));
|
|
try!(packet.write_value(request));
|
|
}
|
|
|
|
Message::Unknown(_) => unreachable!(),
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct PeerInit {
|
|
pub user_name: String,
|
|
pub connection_type: String,
|
|
pub token: u32,
|
|
}
|
|
|
|
impl ReadFromPacket for PeerInit {
|
|
fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
|
|
let user_name = try!(packet.read_value());
|
|
let connection_type = try!(packet.read_value());
|
|
let token = try!(packet.read_value());
|
|
Ok(PeerInit {
|
|
user_name,
|
|
connection_type,
|
|
token,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl WriteToPacket for PeerInit {
|
|
fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
|
|
try!(packet.write_value(&self.user_name));
|
|
try!(packet.write_value(&self.connection_type));
|
|
try!(packet.write_value(&self.token));
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl ProtoEncode for PeerInit {
|
|
fn encode(&self, encoder: &mut ProtoEncoder) -> io::Result<()> {
|
|
encoder.encode_string(&self.user_name)?;
|
|
encoder.encode_string(&self.connection_type)?;
|
|
encoder.encode_u32(self.token)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl ProtoDecode for PeerInit {
|
|
fn decode(decoder: &mut ProtoDecoder) -> Result<Self, DecodeError> {
|
|
let user_name = decoder.decode_string()?;
|
|
let connection_type = decoder.decode_string()?;
|
|
let token = decoder.decode_u32()?;
|
|
Ok(PeerInit {
|
|
user_name,
|
|
connection_type,
|
|
token,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::fmt::Debug;
|
|
use std::io;
|
|
|
|
use bytes::BytesMut;
|
|
|
|
use proto::{DecodeError, ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder};
|
|
use proto::codec::tests::roundtrip;
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn invalid_code() {
|
|
let mut bytes = BytesMut::new();
|
|
ProtoEncoder::new(&mut bytes).encode_u32(1337).unwrap();
|
|
|
|
let mut cursor = io::Cursor::new(bytes);
|
|
match Message::decode(&mut ProtoDecoder::new(&mut cursor)) {
|
|
Err(DecodeError::UnknownCodeError(1337)) => {}
|
|
result => panic!(result),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_pierce_firewall() {
|
|
roundtrip(Message::PierceFirewall(1337))
|
|
}
|
|
|
|
#[test]
|
|
fn roundtrip_peer_init() {
|
|
roundtrip(Message::PeerInit(PeerInit {
|
|
user_name: "alice".to_string(),
|
|
connection_type: "P".to_string(),
|
|
token: 1337,
|
|
}));
|
|
}
|
|
}
|