#[macro_use]
extern crate serde_derive;
pub mod encryption;
pub mod error;
use encryption::*;
pub mod asyncronous;
pub mod peers;
pub mod protocol;
use protocol::StreamHeader;
pub mod sllp;
pub mod database;
pub mod syncronous;
use crate::encryption::PubKeyComp;
use crate::error::NetworkError;
pub use peers::*;
pub mod utils;
use rsa::{RSAPrivateKey, RSAPublicKey};
use std::error::Error;
use std::net::ToSocketAddrs;
use std::{
net::{SocketAddr, UdpSocket},
sync::mpsc::{channel, RecvTimeoutError, Sender},
thread,
time::Duration,
};
pub use utils::*;
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct ArtificeConfig {
broadcast: bool,
addr: Layer3SocketAddr,
host: ArtificeHostData,
}
impl ArtificeConfig {
pub fn new(addr: Layer3SocketAddr, host: ArtificeHostData, broadcast: bool) -> Self {
Self {
broadcast,
addr,
host,
}
}
pub fn generate(addr: Layer3SocketAddr) -> Self {
let broadcast = false;
let host = ArtificeHostData::default();
Self {
broadcast,
addr,
host,
}
}
pub fn host_data(&self) -> &ArtificeHostData {
&self.host
}
pub fn broadcast(&self) -> bool {
self.broadcast
}
pub fn port(&self) -> u16 {
self.addr.port()
}
pub fn addr(&self) -> Layer3Addr {
self.addr.ip()
}
pub fn socket_addr(&self) -> Layer3SocketAddr {
self.addr
}
pub fn set_socket_addr(&mut self, addr: SocketAddr) {
self.addr = addr.into();
}
}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct ArtificeHostData {
priv_key: PrivKeyComp,
global_peer_hash: String,
}
impl Default for ArtificeHostData {
fn default() -> Self {
let global_peer_hash = random_string(50);
let priv_key = PrivKeyComp::generate().unwrap();
Self {
priv_key,
global_peer_hash,
}
}
}
impl ArtificeHostData {
pub fn new(private_key: &RSAPrivateKey, global_peer_hash: &str) -> Self {
let priv_key = PrivKeyComp::from(private_key);
Self {
priv_key,
global_peer_hash: global_peer_hash.to_string(),
}
}
pub fn privkeycomp(&self) -> &PrivKeyComp {
&self.priv_key
}
pub fn global_peer_hash(&self) -> &str {
&self.global_peer_hash
}
}
#[derive(Debug, Clone, Eq, Serialize, Deserialize)]
pub struct Header {
peer: ArtificePeer,
packet_len: usize,
new_connection: bool,
key: Vec<u8>,
}
impl Header {
pub fn new(peer: &ArtificePeer, key: Vec<u8>) -> Self {
Self {
peer: peer.to_owned(),
packet_len: 0,
new_connection: false,
key,
}
}
pub fn new_pair(peer: &ArtificePeer, key: Vec<u8>) -> Self {
Self {
peer: peer.to_owned(),
packet_len: 0,
new_connection: true,
key,
}
}
pub fn stream_header(&self) -> StreamHeader {
StreamHeader::from(self)
}
pub fn peer(&self) -> &ArtificePeer {
&self.peer
}
pub fn pubkey(&self) -> Result<RSAPublicKey, NetworkError> {
self.peer.pubkey()
}
pub fn pubkeycomp(&self) -> &Option<PubKeyComp> {
self.peer.pubkeycomp()
}
pub fn packet_len(&self) -> usize {
self.packet_len
}
pub fn set_len(&mut self, len: usize) {
self.packet_len = len;
}
pub fn set_pubkey(&mut self, pubkey: &PubKeyComp) {
self.peer.set_pubkey(pubkey);
}
pub fn key(&self) -> Vec<u8> {
self.key.clone()
}
}
impl From<&Header> for StreamHeader {
fn from(header: &Header) -> Self {
StreamHeader::with_key(
header.peer().global_peer_hash(),
header.peer().peer_hash(),
header.key(),
header.packet_len(),
)
}
}
impl From<Header> for StreamHeader {
fn from(header: Header) -> Self {
StreamHeader::from(&header)
}
}
#[test]
fn header_to_raw_from_raw() {
let stream_header = StreamHeader::new(&random_string(50), &random_string(50), 0);
let raw = stream_header.to_raw();
let new_header = StreamHeader::from_raw(&raw).unwrap();
assert_eq!(stream_header, new_header);
}
pub trait ArtificeHost {
fn begin_broadcast<S: ToSocketAddrs>(socket_addr: S) -> std::io::Result<Sender<bool>> {
let (sender, recv) = channel();
let socket = UdpSocket::bind(socket_addr)?;
socket.set_broadcast(true)?;
thread::spawn(move || loop {
match recv.recv_timeout(Duration::from_millis(200)) {
Ok(_) => break,
Err(e) => match e {
RecvTimeoutError::Timeout => continue,
RecvTimeoutError::Disconnected => break,
},
}
});
Ok(sender)
}
fn stop_broadcasting(&self);
}
pub trait ConnectionRequest {
type Error: Error;
type NetStream;
fn new(stream: Self::NetStream) -> Self;
fn verify<L: PeerList>(self, list: &L) -> Result<Self::NetStream, Self::Error>;
unsafe fn unverify(self) -> Self::NetStream;
}