diff --git a/bonknet_broker/src/main.rs b/bonknet_broker/src/main.rs index 5b75c30..3d351b8 100644 --- a/bonknet_broker/src/main.rs +++ b/bonknet_broker/src/main.rs @@ -10,15 +10,17 @@ use dataconnmanager::*; use actix::prelude::*; use std::sync::Arc; use libbonknet::*; +use libbonknet::servermsg::*; +use libbonknet::clientmsg::*; use rustls::{RootCertStore, ServerConfig}; use rustls::server::WebPkiClientVerifier; use actix_tls::accept::rustls_0_22::{Acceptor as RustlsAcceptor, TlsStream}; use actix_server::Server; use actix_rt::net::TcpStream; -use actix_service::{ServiceFactoryExt as _}; -use futures::{StreamExt, SinkExt}; +use actix_service::ServiceFactoryExt as _; +use futures::{SinkExt, StreamExt}; use tokio_util::codec::{Framed, FramedRead, FramedWrite, LengthDelimitedCodec}; -use tracing::{info, error, warn}; +use tracing::{error, info, warn}; use rcgen::{Certificate, CertificateParams, DnType, KeyPair}; use tokio::io::{ReadHalf, WriteHalf}; @@ -125,7 +127,8 @@ async fn main() { } Some(item) => match item { Ok(buf) => { - use FromServerConnTypeMessage::*; + use libbonknet::servermsg::{FromServerConnTypeMessage, ToServerConnTypeReply}; + use libbonknet::servermsg::FromServerConnTypeMessage::*; let msg: FromServerConnTypeMessage = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -207,7 +210,7 @@ async fn server_command_handler(mut transport: TransportStream, peer_cert_bytes: } Some(item) => match item { Ok(buf) => { - use FromServerCommandMessage::*; + use libbonknet::servermsg::FromServerCommandMessage::*; let msg: FromServerCommandMessage = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -269,7 +272,7 @@ async fn guestserver_handler(mut transport: TransportStream, server_db_addr: Add Some(item) => { match item { Ok(buf) => { - use FromGuestServerMessage::*; + use libbonknet::servermsg::FromGuestServerMessage::*; let msg: FromGuestServerMessage = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { diff --git a/bonknet_broker/src/servermanager.rs b/bonknet_broker/src/servermanager.rs index 85ee1d5..964f544 100644 --- a/bonknet_broker/src/servermanager.rs +++ b/bonknet_broker/src/servermanager.rs @@ -1,18 +1,18 @@ use std::collections::HashMap; use std::io::Error; -use std::sync::{Arc}; +use std::sync::Arc; use std::time::{Duration, Instant}; use actix::prelude::*; use rand::random; use thiserror::Error; -use futures::{SinkExt}; +use futures::SinkExt; use tokio::sync::{Mutex, oneshot}; use tokio_util::bytes::{Bytes, BytesMut}; use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec}; use tracing::{debug, error, info}; -use libbonknet::*; use crate::{TransportStream, TransportStreamRx, TransportStreamTx}; use uuid::Uuid; +use libbonknet::servermsg::*; use crate::pendingdataconndb::*; #[derive(Error, Debug)] @@ -122,7 +122,7 @@ impl StreamHandler> for ServerTransporter { fn handle(&mut self, item: Result, ctx: &mut Self::Context) { match item { Ok(buf) => { - use FromServerReply::*; + use libbonknet::servermsg::FromServerReply::*; let msg: FromServerReply = rmp_serde::from_slice(&buf).unwrap(); match msg { Pong => { diff --git a/bonknet_client/src/bin/client.rs b/bonknet_client/src/bin/client.rs index 3f9113b..26eb7a0 100644 --- a/bonknet_client/src/bin/client.rs +++ b/bonknet_client/src/bin/client.rs @@ -1,15 +1,16 @@ use std::io::{Error, ErrorKind}; use std::sync::Arc; use std::time::Duration; -use futures::{StreamExt, SinkExt}; +use futures::{SinkExt, StreamExt}; use tokio::net::TcpStream; use tokio_rustls::rustls::{ClientConfig, RootCertStore}; -use tokio_rustls::rustls::pki_types::{ServerName}; +use tokio_rustls::rustls::pki_types::ServerName; use tokio_rustls::TlsConnector; use tokio_util::codec::{Framed, LengthDelimitedCodec}; use libbonknet::*; +use libbonknet::clientmsg::*; use uuid::Uuid; -use tracing::{info, error}; +use tracing::{error, info}; async fn datastream(tlsconfig: ClientConfig, conn_id: Uuid) -> std::io::Result<()> { @@ -129,7 +130,8 @@ async fn main() -> std::io::Result<()> { None => panic!("None in the transport"), Some(item) => match item { Ok(buf) => { - use ToClientResponse::*; + use libbonknet::clientmsg::ToClientResponse; + use libbonknet::clientmsg::ToClientResponse::*; let msg: ToClientResponse = rmp_serde::from_slice(&buf).unwrap(); match msg { OkServerList { data } => info!("{}", data.join("\n")), @@ -151,7 +153,8 @@ async fn main() -> std::io::Result<()> { None => panic!("None in the transport"), Some(item) => match item { Ok(buf) => { - use ToClientResponse::*; + use libbonknet::clientmsg::ToClientResponse; + use libbonknet::clientmsg::ToClientResponse::*; let msg: ToClientResponse = rmp_serde::from_slice(&buf).unwrap(); match msg { OkRequest { conn_id } => { diff --git a/bonknet_server/src/bin/server.rs b/bonknet_server/src/bin/server.rs index 5391bbd..f49dec5 100644 --- a/bonknet_server/src/bin/server.rs +++ b/bonknet_server/src/bin/server.rs @@ -1,14 +1,15 @@ use std::io::{Error, ErrorKind}; use std::sync::Arc; -use futures::{StreamExt, SinkExt}; +use futures::{SinkExt, StreamExt}; use tokio::net::TcpStream; use tokio_rustls::rustls::{ClientConfig, RootCertStore}; -use tokio_rustls::rustls::pki_types::{ServerName, CertificateDer, PrivatePkcs8KeyDer}; +use tokio_rustls::rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer, ServerName}; use tokio_rustls::TlsConnector; use tokio_util::codec::{Framed, LengthDelimitedCodec}; use libbonknet::*; +use libbonknet::servermsg::*; use uuid::Uuid; -use tracing::{info, error}; +use tracing::{error, info}; async fn datastream(tlsconfig: Arc, conn_id: Uuid) -> std::io::Result<()> { @@ -123,7 +124,8 @@ async fn main() -> std::io::Result<()> { } Some(item) => match item { Ok(buf) => { - use ToGuestServerMessage::*; + use libbonknet::servermsg::{okannounce_to_cert, ToGuestServerMessage}; + use libbonknet::servermsg::ToGuestServerMessage::*; let msg: ToGuestServerMessage = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -164,7 +166,8 @@ async fn main() -> std::io::Result<()> { } Some(item) => match item { Ok(buf) => { - use ToServerConnTypeReply::*; + use libbonknet::servermsg::ToServerConnTypeReply; + use libbonknet::servermsg::ToServerConnTypeReply::*; let msg: ToServerConnTypeReply = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -193,7 +196,8 @@ async fn main() -> std::io::Result<()> { } Some(item) => match item { Ok(buf) => { - use ToServerCommandReply::*; + use libbonknet::servermsg::ToServerCommandReply; + use libbonknet::servermsg::ToServerCommandReply::*; let msg: ToServerCommandReply = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -229,7 +233,8 @@ async fn main() -> std::io::Result<()> { } Some(item) => match item { Ok(buf) => { - use ToServerConnTypeReply::*; + use libbonknet::servermsg::ToServerConnTypeReply; + use libbonknet::servermsg::ToServerConnTypeReply::*; let msg: ToServerConnTypeReply = rmp_serde::from_slice(&buf).unwrap(); info!("{:?}", msg); match msg { @@ -259,11 +264,13 @@ async fn main() -> std::io::Result<()> { let mut out: Option = None; match item { Ok(buf) => { - use ToServerMessage::*; + use libbonknet::servermsg::ToServerMessage; + use libbonknet::servermsg::ToServerMessage::*; let msg: ToServerMessage = rmp_serde::from_slice(&buf).unwrap(); match msg { Msg { reply_id, body } => { - use ToServerMessageBody::*; + use libbonknet::servermsg::FromServerReplyBody; + use libbonknet::servermsg::ToServerMessageBody::*; match body { Request { conn_id } => { info!("I'm required with Connection ID {}", conn_id); diff --git a/libbonknet/src/clientmsg.rs b/libbonknet/src/clientmsg.rs new file mode 100644 index 0000000..48b2725 --- /dev/null +++ b/libbonknet/src/clientmsg.rs @@ -0,0 +1,23 @@ +pub use crate::ToPeerDataStream; + +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +// Client things +#[derive(Debug, Serialize, Deserialize)] +pub enum FromClientCommand { + RequestServer { name: String }, + ServerList, + UpgradeToDataStream(Uuid), +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToClientResponse { + OkRequest { conn_id: Uuid }, + OkServerList { data: Vec }, + // You are now a DataStream, wait the Open message + OkDataStreamRequestAccepted, + // The stream is open, you can pipe in-out the content you want! + OkDataStreamOpen, + GenericError, +} diff --git a/libbonknet/src/lib.rs b/libbonknet/src/lib.rs index 1d935c9..d5e8055 100644 --- a/libbonknet/src/lib.rs +++ b/libbonknet/src/lib.rs @@ -1,8 +1,10 @@ +pub mod servermsg; +pub mod clientmsg; + use std::io::{BufReader, Error, ErrorKind}; -use rustls_pemfile::{read_one, Item}; +use rustls_pemfile::{Item, read_one}; use serde::{Deserialize, Serialize}; use tokio_rustls::rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer}; -use uuid::Uuid; pub fn load_cert(filename: &str) -> std::io::Result { let cert_file = std::fs::File::open(filename).unwrap(); @@ -26,119 +28,6 @@ pub fn load_prkey(filename: &str) -> std::io::Result { } } -#[derive(Debug, Serialize, Deserialize)] -pub enum FromServerConnTypeMessage { - SendCommand, - Subscribe, - OpenDataStream(Uuid), -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToServerConnTypeReply { - OkSendCommand, - OkSubscribe, - // You are now a DataStream, wait the Open message - OkDataStreamRequestAccepted, - // The stream is open, you can pipe in-out the content you want! - OkDataStreamOpen, - GenericFailure, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum FromServerCommandMessage { - ChangeName { name: String }, - WhoAmI, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToServerCommandReply { - NameChanged, - NameNotAvailable, - YouAre { name: String }, - GenericFailure, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum YouAreValues { - Registered { name: String }, - NotRegistered, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToServerMessageBody { - Request { conn_id: Uuid }, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToServerMessage { - Ping, - Msg { - reply_id: u64, - body: ToServerMessageBody, - }, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum FromServerReplyBody { - RequestAccepted, - RequestFailed, - Pong, -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum FromServerReply { - Pong, - Msg { - reply_id: u64, - body: FromServerReplyBody - } -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum FromGuestServerMessage { - Announce { name: String } -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToGuestServerMessage { - OkAnnounce { server_cert: Vec, server_prkey: Vec }, - FailedNameAlreadyOccupied, -} - -pub fn okannounce_to_cert<'a>(server_cert: Vec, server_prkey: Vec) -> (CertificateDer<'a>, PrivatePkcs8KeyDer<'a>) { - let server_cert = CertificateDer::from(server_cert); - let server_prkey = PrivatePkcs8KeyDer::from(server_prkey); - (server_cert, server_prkey) -} - -impl ToGuestServerMessage { - pub fn make_okannounce(server_cert: CertificateDer, server_prkey: PrivatePkcs8KeyDer) -> Self { - ToGuestServerMessage::OkAnnounce { - server_cert: server_cert.to_vec(), - server_prkey: server_prkey.secret_pkcs8_der().to_vec() - } - } -} - -// Client things -#[derive(Debug, Serialize, Deserialize)] -pub enum FromClientCommand { - RequestServer { name: String }, - ServerList, - UpgradeToDataStream(Uuid), -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ToClientResponse { - OkRequest { conn_id: Uuid }, - OkServerList { data: Vec }, - // You are now a DataStream, wait the Open message - OkDataStreamRequestAccepted, - // The stream is open, you can pipe in-out the content you want! - OkDataStreamOpen, - GenericError, -} - #[derive(Debug, Serialize, Deserialize)] pub enum ToPeerDataStream { // You are now a DataStream, wait the Open message diff --git a/libbonknet/src/servermsg.rs b/libbonknet/src/servermsg.rs new file mode 100644 index 0000000..a65e5c1 --- /dev/null +++ b/libbonknet/src/servermsg.rs @@ -0,0 +1,93 @@ +pub use crate::ToPeerDataStream; + +use tokio_rustls::rustls::pki_types::{CertificateDer, PrivatePkcs8KeyDer}; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +#[derive(Debug, Serialize, Deserialize)] +pub enum FromServerConnTypeMessage { + SendCommand, + Subscribe, + OpenDataStream(Uuid), +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToServerConnTypeReply { + OkSendCommand, + OkSubscribe, + // You are now a DataStream, wait the Open message + OkDataStreamRequestAccepted, + // The stream is open, you can pipe in-out the content you want! + OkDataStreamOpen, + GenericFailure, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum FromServerCommandMessage { + ChangeName { name: String }, + WhoAmI, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToServerCommandReply { + NameChanged, + NameNotAvailable, + YouAre { name: String }, + GenericFailure, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToServerMessageBody { + Request { conn_id: Uuid }, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToServerMessage { + Ping, + Msg { + reply_id: u64, + body: ToServerMessageBody, + }, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum FromServerReplyBody { + RequestAccepted, + RequestFailed, + Pong, +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum FromServerReply { + Pong, + Msg { + reply_id: u64, + body: FromServerReplyBody + } +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum FromGuestServerMessage { + Announce { name: String } +} + +pub fn okannounce_to_cert<'a>(server_cert: Vec, server_prkey: Vec) -> (CertificateDer<'a>, PrivatePkcs8KeyDer<'a>) { + let server_cert = CertificateDer::from(server_cert); + let server_prkey = PrivatePkcs8KeyDer::from(server_prkey); + (server_cert, server_prkey) +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ToGuestServerMessage { + OkAnnounce { server_cert: Vec, server_prkey: Vec }, + FailedNameAlreadyOccupied, +} + +impl ToGuestServerMessage { + pub fn make_okannounce(server_cert: CertificateDer, server_prkey: PrivatePkcs8KeyDer) -> Self { + ToGuestServerMessage::OkAnnounce { + server_cert: server_cert.to_vec(), + server_prkey: server_prkey.secret_pkcs8_der().to_vec() + } + } +}