115 lines
3.3 KiB
Rust
115 lines
3.3 KiB
Rust
use crate::peer;
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
#[derive(Serialize, Deserialize)]
|
||
pub struct RegisterSuper<'a> {
|
||
// pass, 用于给registersuper一个初步的雁阵，固定8位
|
||
pub pass: &'a str,
|
||
// 自身的sock信息
|
||
pub sock: peer::SdlanSock,
|
||
|
||
// 自身的ip信息
|
||
pub dev_addr: peer::IpSubnet,
|
||
|
||
// 自身的公钥
|
||
pub pub_key: &'a str,
|
||
|
||
// user's token, can be used to specify a user
|
||
pub token: &'a str,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod test {
|
||
use crate::config;
|
||
use crate::packet::decode_packet;
|
||
use crate::packet::encode_packet;
|
||
use crate::packet::PacketType;
|
||
|
||
use self::peer::SdlanSock;
|
||
use crate::packet::Common;
|
||
use crate::utils::Result;
|
||
use std::sync::atomic;
|
||
use std::sync::atomic::Ordering::Relaxed;
|
||
|
||
use super::*;
|
||
|
||
fn do_encode() -> Result<(Vec<u8>, Common<'static>, RegisterSuper<'static>)> {
|
||
let cmn1 = Common {
|
||
version: 1,
|
||
id: "asxalex",
|
||
ttl: 128,
|
||
pc: PacketType::PKTRegisterSuper,
|
||
flags: config::SDLAN_FLAGS_FROM_SN,
|
||
};
|
||
let pkt1 = RegisterSuper {
|
||
pass: "encrypt!",
|
||
sock: SdlanSock {
|
||
family: 0,
|
||
port: 1,
|
||
has_v6: true,
|
||
v6_port: 2345,
|
||
v4: [0; 4],
|
||
v6: [1; 16],
|
||
},
|
||
dev_addr: peer::IpSubnet {
|
||
net_addr: atomic::AtomicU32::new(192),
|
||
net_bit_len: atomic::AtomicU8::new(24),
|
||
},
|
||
pub_key: "public key",
|
||
token: "user's token",
|
||
};
|
||
let res = encode_packet(&cmn1, &pkt1).unwrap();
|
||
Ok((res, cmn1, pkt1))
|
||
}
|
||
|
||
fn do_decode<'a, T: serde::Deserialize<'a>>(value: &'a [u8]) -> Result<(Common, T)> {
|
||
decode_packet(value)
|
||
}
|
||
|
||
fn compare_two(cmn1: Common, cmn2: Common, pkt1: RegisterSuper, pkt2: RegisterSuper) {
|
||
assert_eq!(cmn1.version, cmn2.version);
|
||
assert_eq!(cmn1.id, cmn2.id);
|
||
assert_eq!(cmn1.ttl, cmn2.ttl);
|
||
assert_eq!(cmn1.pc, cmn2.pc);
|
||
assert_eq!(cmn1.flags, cmn2.flags);
|
||
|
||
assert_eq!(pkt1.pass, pkt2.pass);
|
||
assert_eq!(pkt1.sock, pkt2.sock);
|
||
assert_eq!(
|
||
pkt1.dev_addr.net_addr.load(Relaxed),
|
||
pkt2.dev_addr.net_addr.load(Relaxed)
|
||
);
|
||
assert_eq!(
|
||
pkt1.dev_addr.net_bit_len.load(Relaxed),
|
||
pkt2.dev_addr.net_bit_len.load(Relaxed)
|
||
);
|
||
assert_eq!(pkt1.pub_key, pkt2.pub_key);
|
||
assert_eq!(pkt1.token, pkt2.token);
|
||
}
|
||
|
||
#[test]
|
||
fn test_register_super_encode_decode() {
|
||
let (value, cmn1, pkt1) = do_encode().unwrap();
|
||
let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
|
||
compare_two(cmn1, cmn2, pkt1, pkt2);
|
||
}
|
||
|
||
#[test]
|
||
#[should_panic]
|
||
fn test_register_super_encode_decode_panic() {
|
||
let (mut value, cmn1, pkt1) = do_encode().unwrap();
|
||
value.pop();
|
||
let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
|
||
compare_two(cmn1, cmn2, pkt1, pkt2);
|
||
}
|
||
|
||
#[test]
|
||
fn test_register_super_encode_decode_nopanic() {
|
||
let (mut value, cmn1, pkt1) = do_encode().unwrap();
|
||
value.extend_from_slice(&[1; 10]);
|
||
let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
|
||
compare_two(cmn1, cmn2, pkt1, pkt2);
|
||
}
|
||
}
|