ayham
/
PaperTrader
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

server now runs (hopefully)

This commit is contained in:
ayham 2021-05-24 13:53:43 +03:00
parent 17d2a0e93e
commit 924603e43e
Signed by: ayham
GPG Key ID: EAB7F5A9DF503678
23 changed files with 541 additions and 859 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.github/workflows/CI.yml vendored
View File

@ -16,12 +16,12 @@ jobs:
- name: Check Code Format
run: cargo fmt --all -- --check
- name: Build Minimal
run: cargo build
run: cargo build --no-default-features
- name: Build Client
run: cargo build --features "client"
run: cargo build --no-default-features --features "client"
- name: Build Server
run: cargo build --features "server"
run: cargo build --no-default-features --features "server"
- name: Build Hybrid
run: cargo build --features "server,client"
run: cargo build --no-default-features --features "server,client"
- name: Run benches
run: cargo bench

2
Cargo.toml
View File

@ -29,6 +29,8 @@ chrono = "0.4"
tokio = { version = "*", features = [ "full" ] }
tokio-io = "*"
tokio-rustls = { version = "*" }
tokio-util = { version = "*" }
#rustls-pemfile = { version = "*" }
futures = "*"
bytes = "*"
postgres = "0.17.3"

31
certs/certificate.crt Normal file
View File

@ -0,0 +1,31 @@
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIUE/QczssNBXwqW/RVRiG4BjGSaRUwDQYJKoZIhvcNAQEL
BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMTA1MjMxNTQ0MTBaFw0yMjA1
MjMxNTQ0MTBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggIiMA0GCSqGSIb3DQEB
AQUAA4ICDwAwggIKAoICAQCqRBit5zb9lhOOR4GK9pAu9l+0Z1Br7G693S+UU/sZ
TmQVlpq89z3qV3teKveNmak0ambJe9ULkGVb00vubJa5Pzf7n6bbxtRrMnawVTPV
nXUQh6mPdiz6z69pqIH/BekNdQ8RG2ZNeYvtfhcyOI8KCwwP4IzcnwEJl8O9sYD5
sskP4wVL7rNQNOmiiLBO5NUDHGY3sTkgmU3UA+SXJrxm22J9g8Uw1eSH8dd/ilZ2
lRuirfQ7AZQqvs0nJ970oz52CM49v4wGLotqOcsn3kS8mKynT9/KZGzNZfdknyiQ
ZkCCQmPc85uU7ZNctimPCjiwqd5BINL2tekpKMlafolR+AdegON9G19y2YE+nkYf
bIAjIlGxEpkIuHNvd/FixsgJCSPMRPwBMFbBlombKLZ38Jmbi1ktO264Ah27nOKt
7Q4lCWscD0ED/Q1Lpn2l3S9zvsMDukJoV65sjJy2dj1rrTg4jqOd+3ejgp7cLWS5
RbmGOOOzQsNOR6BfqXeQfgwKd8TKYtuUEF02sUXif6yebWhWwaSCI4Fia7B90wc7
OR3KZmC0ZEOlGvyUPHq6iDiDWmxTRl/D7CkRHCkWngaKiTgBT+3v4rmdg7ZoPyQq
ECjFRgLM/1bWdyoVZqtB4AiFviBja7nb7MC9v/9eG2GSPXTpNUIL5uXUruhIamIZ
MQIDAQABo1MwUTAdBgNVHQ4EFgQUCgavSrC/1bXWujQJNGiVGpPS2ZswHwYDVR0j
BBgwFoAUCgavSrC/1bXWujQJNGiVGpPS2ZswDwYDVR0TAQH/BAUwAwEB/zANBgkq
hkiG9w0BAQsFAAOCAgEASj0HFJ9bw8vfqN8vVsKxQOkeG9WrYLvJhhUQqNjojSt/
016+3NlPbh6Xy/AeCcoEAdA9umi9pcJChsVdASpZSGZBYcVilSR1uHjhgmQgSX7t
2JFHkRUOeMOSyDuY3q7N1+WJaSAJdyRCfjC1Sug+vfDKvo3lplV4r3t3JvdeBjcs
3qd9ybH1vEGQf9qAa3qSrH2YV92wFYazva2vv52AEzeIwErPR8yvB8poqFK8xgwV
MTh/N9Rluzkp2SfhtoatOcc+MJ1Txuh/PXTVFQJySvh7zduUOdE3zFGrqKmJjDYx
xON1JSgYeIoBjpwzMl+CXAAI6gMlm9AzRTSkpgM7qf07fr1Wd1uDm/HmFJk8QSvv
DPFfLJcSajsyEE+AhNs6EpQo+Y2CPadAYSt7VFmJfYlOmKmib3+gbH/f28rzXP7n
C1TwqQWX3esWcLcMrbU5lyiorDMAs5d9Q3CiMZUSeCz00v64lSAnQgP4SVmZDPzI
vbJyFwn+SyR7wjn/976m/GZsjD0FLd2DI+jFWABml8nBqiGy/JO64scmAzxNqYe8
/6an4yzclrlvdM1F3PjYcjwsK4/suxFKn/2O9aI2JwFeLJB03L66L4yXX2ugaeWk
ZuOlf8Jex9dh/eeqaSGg7hjLS6yVi7a5oY+tUGa3rg9n02gJB6OXKg8hOtMQtPE=
-----END CERTIFICATE-----

52
certs/private.key Normal file
View File

@ -0,0 +1,52 @@
-----BEGIN PRIVATE KEY-----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-----END PRIVATE KEY-----

35
certs/test_tls.crt
View File

@ -1,35 +0,0 @@
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----

52
certs/test_tls.key
View File

@ -1,52 +0,0 @@
-----BEGIN PRIVATE KEY-----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-----END PRIVATE KEY-----

140
src/libtrader/common/misc/gen_tls_client_config.rs
View File

@ -1,70 +1,70 @@
use ct_logs;
use rustls;
use std::sync::Arc;
use webpki_roots;
/// A "always accept" Certficate verifier.
///
/// WARN: only to be used in development environments.
/// using this in production envs will be a HUGE security vuln.
#[cfg(feature = "tls_no_verify")]
mod danger {
use super::rustls;
use webpki;
pub struct NoCertificateVerification {}
impl rustls::ServerCertVerifier for NoCertificateVerification {
fn verify_server_cert(
&self,
_roots: &rustls::RootCertStore,
_presented_certs: &[rustls::Certificate],
_dns_name: webpki::DNSNameRef<'_>,
_ocsp: &[u8],
) -> Result<rustls::ServerCertVerified, rustls::TLSError> {
warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED");
Ok(rustls::ServerCertVerified::assertion())
}
}
}
/// Generates a TlsClient Config.
///
/// Uses defualt settings for:
/// - TLS Protocol Version.
/// - TLs Protocol CypherSuite.
///
/// Assumed Settings:
/// - Certificate Authentication.
/// - No persistent session storage.
///
/// Returns; the client configuration in an Arc.
pub fn gen_tls_client_config() -> Arc<rustls::ClientConfig> {
let mut config = rustls::ClientConfig::new();
config.key_log = Arc::new(rustls::KeyLogFile::new());
config
.root_store
.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
config.ct_logs = Some(&ct_logs::LOGS);
let persist = Arc::new(rustls::NoClientSessionStorage {});
config.set_persistence(persist);
#[cfg(feature = "tls_no_verify")]
config
.dangerous()
.set_certificate_verifier(Arc::new(danger::NoCertificateVerification {}));
Arc::new(config)
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_gen_tls_client_config() {
let _ = gen_tls_client_config();
}
}
//use ct_logs;
//use rustls;
//use std::sync::Arc;
//use webpki_roots;
//
///// A "always accept" Certficate verifier.
/////
///// WARN: only to be used in development environments.
///// using this in production envs will be a HUGE security vuln.
//#[cfg(feature = "tls_no_verify")]
//mod danger {
// use super::rustls;
// use webpki;
//
// pub struct NoCertificateVerification {}
//
// impl rustls::ServerCertVerifier for NoCertificateVerification {
// fn verify_server_cert(
// &self,
// _roots: &rustls::RootCertStore,
// _presented_certs: &[rustls::Certificate],
// _dns_name: webpki::DNSNameRef<'_>,
// _ocsp: &[u8],
// ) -> Result<rustls::ServerCertVerified, rustls::TLSError> {
// warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED");
// Ok(rustls::ServerCertVerified::assertion())
// }
// }
//}
//
///// Generates a TlsClient Config.
/////
///// Uses defualt settings for:
///// - TLS Protocol Version.
///// - TLs Protocol CypherSuite.
/////
///// Assumed Settings:
///// - Certificate Authentication.
///// - No persistent session storage.
/////
///// Returns; the client configuration in an Arc.
//pub fn gen_tls_client_config() -> Arc<rustls::ClientConfig> {
// let mut config = rustls::ClientConfig::new();
// config.key_log = Arc::new(rustls::KeyLogFile::new());
//
// config
// .root_store
// .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
// config.ct_logs = Some(&ct_logs::LOGS);
//
// let persist = Arc::new(rustls::NoClientSessionStorage {});
// config.set_persistence(persist);
//
// #[cfg(feature = "tls_no_verify")]
// config
// .dangerous()
// .set_certificate_verifier(Arc::new(danger::NoCertificateVerification {}));
//
// Arc::new(config)
//}
//
//#[cfg(test)]
//mod test {
// use super::*;
//
// #[test]
// fn test_gen_tls_client_config() {
// let _ = gen_tls_client_config();
// }
//}

90
src/libtrader/common/misc/gen_tls_server_config.rs
View File

@ -1,19 +1,21 @@
use rustls;
use rustls::NoClientAuth;
use std::fs;
use std::io::{BufReader, Read};
use std::fs::File;
use std::io::{self, BufReader};
use std::path::Path;
use std::sync::Arc;
//use tokio_rustls::rustls::internal::pemfile::{certs, rsa_private_keys};
use tokio_rustls::rustls::internal::pemfile::{certs, pkcs8_private_keys, rsa_private_keys};
use tokio_rustls::rustls::{Certificate, NoClientAuth, PrivateKey, ServerConfig};
/// Loads a TLS public certificate
///
/// Arguments:
/// filename - Path to .crt file.
///
/// Returns: vector of rustls' Certificate
fn load_certs(filename: &str) -> Vec<rustls::Certificate> {
let certfile = fs::File::open(filename).expect("cannot open certificate file");
let mut reader = BufReader::new(certfile);
rustls::internal::pemfile::certs(&mut reader).unwrap()
fn load_certs(path: &Path) -> io::Result<Vec<Certificate>> {
certs(&mut BufReader::new(File::open(path)?))
.map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid cert"))
}
/// Load a TLS private key.
@ -22,46 +24,30 @@ fn load_certs(filename: &str) -> Vec<rustls::Certificate> {
/// filename - Path to .key file.
///
/// Returns: rustls::PrivateKey
fn load_private_key(filename: &str) -> rustls::PrivateKey {
fn load_private_keys(path: &Path) -> io::Result<Vec<PrivateKey>> {
let rsa_keys = {
let keyfile = fs::File::open(filename).expect("cannot open private key file");
let keyfile = File::open(path).expect("cannot open private key file");
let mut reader = BufReader::new(keyfile);
rustls::internal::pemfile::rsa_private_keys(&mut reader)
.expect("file contains invalid rsa private key")
rsa_private_keys(&mut reader).expect("file contains invalid rsa private key")
};
let pkcs8_keys = {
let keyfile = fs::File::open(filename).expect("cannot open private key file");
let keyfile = File::open(path).expect("cannot open private key file");
let mut reader = BufReader::new(keyfile);
rustls::internal::pemfile::pkcs8_private_keys(&mut reader)
pkcs8_private_keys(&mut reader)
.expect("file contains invalid pkcs8 private key (encrypted keys not supported)")
};
// prefer to load pkcs8 keys
if !pkcs8_keys.is_empty() {
pkcs8_keys[0].clone()
Ok(pkcs8_keys.clone())
} else {
assert!(!rsa_keys.is_empty());
rsa_keys[0].clone()
Ok(rsa_keys.clone())
}
}
/// Loads OCSP stapling key.
///
/// Argument:
/// filename - path to OCSP stapling key.
///
/// Returns: u8 vec
fn load_ocsp(filename: &Option<&str>) -> Vec<u8> {
let mut ret = Vec::new();
if let &Some(ref name) = filename {
fs::File::open(name)
.expect("cannot open ocsp file")
.read_to_end(&mut ret)
.unwrap();
}
ret
//rsa_private_keys(&mut BufReader::new(File::open(path)?))
// .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid key"))
// TODO: use this kind of chekcing elsewhere too
}
/// Generates a TlsServer Config.
@ -87,34 +73,22 @@ fn load_ocsp(filename: &Option<&str>) -> Vec<u8> {
/// let config = gen_tls_server_config("tests.crt", "priv.key", None);
/// ```
pub fn gen_tls_server_config(
certs_file: &str,
priv_key_file: &str,
ocsp_key_file: Option<&str>,
) -> Arc<rustls::ServerConfig> {
let mut config = rustls::ServerConfig::new(NoClientAuth::new());
config.key_log = Arc::new(rustls::KeyLogFile::new());
certs_file: &Path,
priv_key_file: &Path,
) -> io::Result<Arc<ServerConfig>> {
let mut config = ServerConfig::new(NoClientAuth::new());
//config.key_log = Arc::new(rustls::KeyLogFile::new());
/* load TLS certificate */
let certs = load_certs(certs_file);
let privkey = load_private_key(priv_key_file);
let ocsp = load_ocsp(&ocsp_key_file);
let certs = load_certs(certs_file)?;
let mut privkeys = load_private_keys(priv_key_file)?;
config
.set_single_cert_with_ocsp_and_sct(certs, privkey, ocsp, vec![])
.expect("bad certs/priv key");
.set_single_cert(certs, privkeys.remove(0))
.map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
/* enable session resumption */
config.set_persistence(rustls::ServerSessionMemoryCache::new(512));
config.ticketer = rustls::Ticketer::new();
//config.set_persistence(rustls::ServerSessionMemoryCache::new(512));
//config.ticketer = rustls::Ticketer::new();
Arc::new(config)
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_gen_tls_server_config() {
let _ = gen_tls_server_config("certs/test_tls.crt", "certs/test_tls.key", None);
}
Ok(Arc::new(config))
}

17
src/libtrader/server/account/authorization.rs
View File

@ -1,5 +1,3 @@
use std::io::Write;
use data_encoding::HEXUPPER;
use ring::pbkdf2;
use std::num::NonZeroU32;
@ -12,11 +10,17 @@ use crate::common::misc::return_flags::ReturnFlags;
use crate::server::db::cmd::get_user_hash::get_user_hash;
use crate::server::db::cmd::get_user_id::get_user_id;
use crate::server::db::cmd::get_user_salt::get_user_salt;
use crate::server::network::tls_connection::TlsConnection;
use crate::server::network::jwt_wrapper::create_jwt_token;
pub fn acc_auth(tls_connection: &mut TlsConnection, message: &Message) -> Result<(), ReturnFlags> {
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn acc_auth(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> Result<(), ReturnFlags> {
/*
* Parse account data.
* */
@ -106,7 +110,10 @@ pub fn acc_auth(tls_connection: &mut TlsConnection, message: &Message) -> Result
0,
jwt_token.as_bytes().to_vec(),
);
let _ = tls_connection.write(bincode::serialize(&message).unwrap().as_slice());
tls_connection
.write_all(bincode::serialize(&message).unwrap().as_slice())
.await
.expect("could not write to client");
Ok(())
}

18
src/libtrader/server/account/retrieval_portfolio.rs
View File

@ -1,5 +1,3 @@
use std::io::Write;
use crate::common::account::portfolio::Portfolio;
use crate::common::account::position::Position;
use crate::common::message::message::Message;
@ -10,10 +8,13 @@ use crate::common::misc::return_flags::ReturnFlags;
use crate::server::db::config::{DB_PORTFOLIO_PASS, DB_PORTFOLIO_USER};
use crate::server::db::initializer::db_connect;
use crate::server::network::jwt_wrapper::verify_jwt_token;
use crate::server::network::tls_connection::TlsConnection;
pub fn acc_retrieve_portfolio(
tls_connection: &mut TlsConnection,
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn acc_retrieve_portfolio(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> Result<(), ReturnFlags> {
/* verify JWT token */
@ -21,7 +22,7 @@ pub fn acc_retrieve_portfolio(
Ok(token) => token,
Err(_) => {
warn!("ACC_RETRIEVE_PORTFOLIO_UNAUTH_TOKEN");
tls_connection.closing = true;
tls_connection.shutdown().await.unwrap();
return Err(ReturnFlags::ServerAccUnauthorized);
}
};
@ -63,7 +64,10 @@ pub fn acc_retrieve_portfolio(
0,
bincode::serialize(&portfolio).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
let _ = tls_connection
.write_all(&bincode::serialize(&message).unwrap())
.await
.expect("could not write to client");
Ok(())
}

13
src/libtrader/server/account/retrieval_transaction.rs
View File

@ -1,5 +1,3 @@
use std::io::Write;
use crate::common::account::transaction::Transaction;
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
@ -9,10 +7,13 @@ use crate::common::misc::return_flags::ReturnFlags;
use crate::server::db::config::{DB_ACC_PASS, DB_ACC_USER};
use crate::server::db::initializer::db_connect;
use crate::server::network::jwt_wrapper::verify_jwt_token;
use crate::server::network::tls_connection::TlsConnection;
pub fn acc_retrieve_transaction(
tls_connection: &mut TlsConnection,
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn acc_retrieve_transaction(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> Result<(), ReturnFlags> {
/* verify JWT token */
@ -20,7 +21,7 @@ pub fn acc_retrieve_transaction(
Ok(token) => token,
Err(_) => {
warn!("ACC_RETRIEVE_TRANSACTION_UNAUTH_TOKEN");
tls_connection.closing = true;
tls_connection.shutdown().await.unwrap();
return Err(ReturnFlags::ServerAccUnauthorized);
}
};

36
src/libtrader/server/initializer.rs
View File

@ -1,6 +1,6 @@
use argh::FromArgs;
use std::path::PathBuf;
use tokio::io::{copy, sink, split, AsyncWriteExt};
use tokio::io::AsyncReadExt;
use tokio::net::TcpListener;
use tokio_rustls::TlsAcceptor;
@ -9,8 +9,7 @@ use std::net::ToSocketAddrs;
use crate::common::misc::gen_tls_server_config::gen_tls_server_config;
use crate::common::misc::path_exists::path_exists;
use crate::common::misc::return_flags::ReturnFlags;
//use crate::server::network::tls_server::TlsServer;
use crate::server::network::handle_data::handle_data;
/// Server Options
#[derive(FromArgs)]
@ -54,7 +53,8 @@ fn libtrader_init_log() -> Result<(), ReturnFlags> {
gen_log();
#[cfg(debug_assertions)]
{ use simplelog::*;
{
use simplelog::*;
use std::fs::File;
if !path_exists("log") {
@ -94,15 +94,18 @@ pub async fn libtrader_init_server() -> std::io::Result<()> {
// Initialize log.
//#[cfg(not(test))] // wot dis
match libtrader_init_log() {
Ok(()) => {}
Err(err) => {}, // TODO: handle this case
Ok(_) => {}
Err(_) => {} // TODO: handle this case
};
// Initialize arguments
let options: Options = argh::from_env();
let addr = options.addr.to_socket_addrs()?.next().
ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?;
let addr = options
.addr
.to_socket_addrs()?
.next()
.ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?;
let config = gen_tls_server_config(&options.cert, &options.key)?;
let acceptor = TlsAcceptor::from(config);
@ -110,13 +113,24 @@ pub async fn libtrader_init_server() -> std::io::Result<()> {
let listener = TcpListener::bind(&addr).await?;
loop {
let (stream, peer_addr) = listener.accept().await?;
let (socket, _) = listener.accept().await?; // socket, peer_addr
let acceptor = acceptor.clone();
// function to run in the thread
let fut = async move {
let mut _stream = acceptor.accept(stream).await?;
let mut socket = acceptor.accept(socket).await?;
// handle_data here?
let mut buf = Vec::with_capacity(4096);
loop {
socket.read_buf(&mut buf).await?;
match handle_data(&mut socket, buf.as_slice()).await {
Ok(()) => {}
Err(err) => {
warn!("{}", format!("Failed running handle_data: {:#?}", err));
break;
}
};
}
Ok(()) as std::io::Result<()>
};

164
src/libtrader/server/network/cmd/get_asset_data.rs
View File

@ -1,82 +1,82 @@
use std::io::Write;
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs;
use crate::server::network::tls_connection::TlsConnection;
pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) {
/* assert recieved message */
if !assert_msg(
message,
MessageType::DataTransfer,
true,
3,
false,
0,
false,
0,
false,
0,
) {
tls_connection.closing = true;
warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED");
return;
}
/*
* Parse arguments
* */
/* get json data */
let stringified_data = std::str::from_utf8(&message.data).unwrap();
let data = json::parse(&stringified_data).unwrap();
/* get symbol, start_epoch, and end_epoch */
let symbol = data["symbol"].as_str().unwrap();
let start_epoch = data["start_epoch"]
.as_str()
.unwrap()
.to_string()
.parse::<i64>()
.unwrap();
let end_epoch = data["end_epoch"]
.as_str()
.unwrap()
.to_string()
.parse::<i64>()
.unwrap();
/* call get_stock_from_db_between_epochs() */
match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) {
Ok(vals) => {
/* send the data */
let mut counter = 0;
for val in &vals {
let message = message_builder(
MessageType::DataTransfer,
1,
counter,
vals.len(),
0,
bincode::serialize(&val).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
counter = counter + 1;
}
}
Err(err) => {
/* handle error */
let message = message_builder(
MessageType::ServerReturn,
0,
0,
0,
0,
bincode::serialize(&err).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
}
}
}
//use std::io::Write;
//
//use crate::common::message::message::Message;
//use crate::common::message::message_builder::message_builder;
//use crate::common::message::message_type::MessageType;
//use crate::common::misc::assert_msg::assert_msg;
//
//use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs;
//use crate::server::network::tls_connection::TlsConnection;
//
//pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) {
// /* assert recieved message */
// if !assert_msg(
// message,
// MessageType::DataTransfer,
// true,
// 3,
// false,
// 0,
// false,
// 0,
// false,
// 0,
// ) {
// tls_connection.closing = true;
// warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED");
// return;
// }
//
// /*
// * Parse arguments
// * */
// /* get json data */
// let stringified_data = std::str::from_utf8(&message.data).unwrap();
// let data = json::parse(&stringified_data).unwrap();
// /* get symbol, start_epoch, and end_epoch */
// let symbol = data["symbol"].as_str().unwrap();
// let start_epoch = data["start_epoch"]
// .as_str()
// .unwrap()
// .to_string()
// .parse::<i64>()
// .unwrap();
// let end_epoch = data["end_epoch"]
// .as_str()
// .unwrap()
// .to_string()
// .parse::<i64>()
// .unwrap();
//
// /* call get_stock_from_db_between_epochs() */
// match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) {
// Ok(vals) => {
// /* send the data */
// let mut counter = 0;
// for val in &vals {
// let message = message_builder(
// MessageType::DataTransfer,
// 1,
// counter,
// vals.len(),
// 0,
// bincode::serialize(&val).unwrap(),
// );
// let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
// counter = counter + 1;
// }
// }
// Err(err) => {
// /* handle error */
// let message = message_builder(
// MessageType::ServerReturn,
// 0,
// 0,
// 0,
// 0,
// bincode::serialize(&err).unwrap(),
// );
// let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
// }
// }
//}

112
src/libtrader/server/network/cmd/get_asset_info.rs
View File

@ -1,56 +1,56 @@
use std::io::Write;
use crate::common::message::inst::DataTransferInst;
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::db::cmd::get_company::get_company_from_db;
use crate::server::network::tls_connection::TlsConnection;
pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) {
/* assert recieved message */
if !assert_msg(
message,
MessageType::DataTransfer,
true,
1,
false,
0,
false,
0,
false,
0,
) {
tls_connection.closing = true;
warn!("GET_ASSET_INFO_INVALID_MESSAGE");
return;
}
/* call get_company_from_db() */
match get_company_from_db(bincode::deserialize(&message.data).unwrap()) {
Ok(company) => {
let message = message_builder(
MessageType::ServerReturn,
DataTransferInst::GetAssetInfo as i64,
0,
0,
1,
bincode::serialize(&company).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
}
Err(err) => {
let message = message_builder(
MessageType::ServerReturn,
0,
0,
0,
0,
bincode::serialize(&err).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
}
}
}
//use std::io::Write;
//
//use crate::common::message::inst::DataTransferInst;
//use crate::common::message::message::Message;
//use crate::common::message::message_builder::message_builder;
//use crate::common::message::message_type::MessageType;
//use crate::common::misc::assert_msg::assert_msg;
//
//use crate::server::db::cmd::get_company::get_company_from_db;
//use crate::server::network::tls_connection::TlsConnection;
//
//pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) {
// /* assert recieved message */
// if !assert_msg(
// message,
// MessageType::DataTransfer,
// true,
// 1,
// false,
// 0,
// false,
// 0,
// false,
// 0,
// ) {
// tls_connection.closing = true;
// warn!("GET_ASSET_INFO_INVALID_MESSAGE");
// return;
// }
//
// /* call get_company_from_db() */
// match get_company_from_db(bincode::deserialize(&message.data).unwrap()) {
// Ok(company) => {
// let message = message_builder(
// MessageType::ServerReturn,
// DataTransferInst::GetAssetInfo as i64,
// 0,
// 0,
// 1,
// bincode::serialize(&company).unwrap(),
// );
// let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
// }
// Err(err) => {
// let message = message_builder(
// MessageType::ServerReturn,
// 0,
// 0,
// 0,
// 0,
// bincode::serialize(&err).unwrap(),
// );
// let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
// }
// }
//}

25
src/libtrader/server/network/cmd/login_normal.rs
View File

@ -1,5 +1,3 @@
use std::io::Write;
use crate::common::message::inst::CommandInst;
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
@ -7,9 +5,15 @@ use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::account::authorization::acc_auth;
use crate::server::network::tls_connection::TlsConnection;
pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) {
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn login_normal(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> std::io::Result<()> {
/* assert recieved message */
if !assert_msg(
message,
@ -25,16 +29,15 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) {
) && message.instruction == CommandInst::LoginMethod1 as i64
&& message.data.len() != 0
{
tls_connection.closing = true;
warn!("LOGIN_INVALID_MESSAGE");
return;
return tls_connection.shutdown().await;
}
/* call acc_auth() server version */
match acc_auth(tls_connection, message) {
Ok(_) => {}
match acc_auth(tls_connection, message).await {
Ok(_) => Ok(()),
Err(err) => {
let message = message_builder(
let server_response = message_builder(
MessageType::ServerReturn,
0,
0,
@ -42,7 +45,9 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) {
0,
bincode::serialize(&err).unwrap(),
);
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
tls_connection
.write_all(&bincode::serialize(&server_response).unwrap())
.await
}
}
}

70
src/libtrader/server/network/cmd/purchase_asset.rs
View File

@ -1,35 +1,35 @@
use crate::common::message::message::Message;
use crate::server::network::tls_connection::TlsConnection;
pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) {
/* assert recieved message */
//if message.msgtype != MessageType::Command || message.argument_count != 4
// || message.data_message_number != 0 || message.data_message_max != 0
// || message.data.len() == 0 {
// warn!("PURCHASE_ASSET_INVALID_MESSAGE");
// tls_connection.closing = true;
// return;
// }
//* parse request data */
//let stringified_data = std::str::from_utf8(&message.data).unwrap();
//let data = json::parse(&stringified_data).unwrap();
//* get symbol, shares amount, price, buy or sell */
//let symbol = data["symbol"].as_str().unwrap();
//let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::<i64>().unwrap();
//let is_buy = data["is_buy"].as_bool().unwrap();
//* connect to the data base */
//let mut client = db_connect(DB_USER, DB_PASS).unwrap();
//* check if the symbol exists */
//let company = get_company_from_db(symbol);
//if !company.is_ok() {
// let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0,
// bincode::serialize("COULDNOT FIND COMPANY")).unwrap();
// return;
//}
//* */
}
//use crate::common::message::message::Message;
//
//use crate::server::network::tls_connection::TlsConnection;
//
//pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) {
// /* assert recieved message */
// //if message.msgtype != MessageType::Command || message.argument_count != 4
// // || message.data_message_number != 0 || message.data_message_max != 0
// // || message.data.len() == 0 {
// // warn!("PURCHASE_ASSET_INVALID_MESSAGE");
// // tls_connection.closing = true;
// // return;
// // }
//
// //* parse request data */
// //let stringified_data = std::str::from_utf8(&message.data).unwrap();
// //let data = json::parse(&stringified_data).unwrap();
// //* get symbol, shares amount, price, buy or sell */
// //let symbol = data["symbol"].as_str().unwrap();
// //let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::<i64>().unwrap();
// //let is_buy = data["is_buy"].as_bool().unwrap();
//
// //* connect to the data base */
// //let mut client = db_connect(DB_USER, DB_PASS).unwrap();
//
// //* check if the symbol exists */
// //let company = get_company_from_db(symbol);
// //if !company.is_ok() {
// // let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0,
// // bincode::serialize("COULDNOT FIND COMPANY")).unwrap();
// // return;
// //}
//
// //* */
//}

25
src/libtrader/server/network/cmd/register.rs
View File

@ -1,5 +1,3 @@
use std::io::Write;
use crate::common::message::inst::CommandInst;
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
@ -7,9 +5,15 @@ use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::account::creation::acc_create;
use crate::server::network::tls_connection::TlsConnection;
pub fn register(tls_connection: &mut TlsConnection, message: &Message) {
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn register(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> std::io::Result<()> {
/* assert recieved message */
if !assert_msg(
message,
@ -26,18 +30,21 @@ pub fn register(tls_connection: &mut TlsConnection, message: &Message) {
&& message.data.len() != 0
{
warn!("REGISTER_INVALID_MESSAGE");
tls_connection.closing = true;
return;
return tls_connection.shutdown().await;
}
/* call acc_create() server version */
match acc_create(message) {
Ok(_) => {
let message = message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new());
let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
let server_response =
message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new());
tls_connection
.write_all(&bincode::serialize(&server_response).unwrap())
.await
}
Err(err) => {
warn!("REGISTER_FAILED: {}", err);
Ok(())
}
};
}
}

24
src/libtrader/server/network/cmd/retrieve_portfolio.rs
View File

@ -4,9 +4,15 @@ use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::account::retrieval_portfolio::acc_retrieve_portfolio;
use crate::server::network::tls_connection::TlsConnection;
pub fn retrieve_portfolio(tls_connection: &mut TlsConnection, message: &Message) {
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn retrieve_portfolio(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> std::io::Result<()> {
/* assert recieved message */
if !assert_msg(
message,
@ -22,14 +28,16 @@ pub fn retrieve_portfolio(tls_connection: &mut TlsConnection, message: &Message)
) && message.instruction == DataTransferInst::GetUserPortfolio as i64
&& message.data.len() != 0
{
tls_connection.closing = true;
warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE");
return;
return tls_connection.shutdown().await;
}
/* call acc_retrieve_portfolio() server version */
match acc_retrieve_portfolio(tls_connection, message) {
Ok(_) => {}
Err(err) => warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err),
};
match acc_retrieve_portfolio(tls_connection, message).await {
Ok(_) => Ok(()),
Err(err) => {
warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err);
Ok(()) // TODO: return error
}
}
}

24
src/libtrader/server/network/cmd/retrieve_transactions.rs
View File

@ -4,9 +4,15 @@ use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg;
use crate::server::account::retrieval_transaction::acc_retrieve_transaction;
use crate::server::network::tls_connection::TlsConnection;
pub fn retrieve_transactions(tls_connection: &mut TlsConnection, message: &Message) {
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn retrieve_transactions(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message,
) -> std::io::Result<()> {
/* assert recieved message */
if !assert_msg(
message,
@ -22,14 +28,16 @@ pub fn retrieve_transactions(tls_connection: &mut TlsConnection, message: &Messa
) && message.instruction == DataTransferInst::GetUserTransactionHist as i64
&& message.data.len() != 0
{
tls_connection.closing = true;
warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE");
return;
return tls_connection.shutdown().await;
}
/* call acc_retrieve_transaction() server version */
match acc_retrieve_transaction(tls_connection, message) {
Ok(_) => {}
Err(err) => warn!("RETRIEVE_TRANSACTION_FAILED: {}", err),
};
match acc_retrieve_transaction(tls_connection, message).await {
Ok(_) => Ok(()),
Err(err) => {
warn!("RETRIEVE_TRANSACTION_FAILED: {}", err);
Ok(()) // TODO: return error
}
}
}

144
src/libtrader/server/network/handle_data.rs
View File

@ -1,30 +1,23 @@
use data_encoding::HEXUPPER;
use std::io::Write;
use crate::common::message::inst::{CommandInst, DataTransferInst};
use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType;
use crate::server::network::cmd::get_asset_data::get_asset_data;
use crate::server::network::cmd::get_asset_info::get_asset_info;
use crate::server::network::cmd::login_normal::login_normal;
use crate::server::network::cmd::purchase_asset::purchase_asset;
use crate::server::network::cmd::register::register;
use crate::server::network::cmd::retrieve_portfolio::retrieve_portfolio;
use crate::server::network::cmd::retrieve_transactions::retrieve_transactions;
use crate::server::network::tls_connection::TlsConnection;
pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), String> {
//use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn handle_data(socket: &mut TlsStream<TcpStream>, buf: &[u8]) -> std::io::Result<()> {
/* decode incoming message */
let client_msg: Message = match bincode::deserialize(&buf) {
Ok(msg) => msg,
Err(err) => {
warn!("HANDLE_DATA_RCVD_INV_MSG: {}", err);
connection.closing = true; /* disconnect any unrecognized message senders */
return Ok(());
}
};
let client_msg: Message = bincode::deserialize(&buf).expect("HANDLE_DATA_RCVD_INV_MSG");
/* handle individual client instructions */
match client_msg.instruction {
@ -43,100 +36,81 @@ pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), Str
1,
salt.to_vec(),
);
connection
.tls_session
.write(bincode::serialize(&server_response).unwrap().as_slice())
.unwrap();
connection.do_tls_write_and_handle_error();
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
}
_ if client_msg.instruction == CommandInst::GetEmailSalt as i64 => {
use crate::server::db::cmd::get_user_salt::get_user_salt;
let salt = match get_user_salt(
match get_user_salt(
String::from_utf8(client_msg.data).unwrap().as_str(),
true,
false,
) {
Ok(salt) => salt,
Err(_) => {
let msg = message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
connection
.tls_session
.write(&bincode::serialize(&msg).unwrap())
.unwrap();
connection.do_tls_write_and_handle_error();
return Ok(());
Ok(salt) => {
let server_response: Message = message_builder(
MessageType::DataTransfer,
CommandInst::GetEmailSalt as i64,
1,
0,
1,
HEXUPPER.decode(salt.as_bytes()).unwrap(),
);
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
}
};
let server_response: Message = message_builder(
MessageType::DataTransfer,
CommandInst::GetEmailSalt as i64,
1,
0,
1,
HEXUPPER.decode(salt.as_bytes()).unwrap(),
);
connection
.tls_session
.write(bincode::serialize(&server_response).unwrap().as_slice())
.unwrap();
connection.do_tls_write_and_handle_error();
Err(_) => {
let server_response =
message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
}
}
}
_ if client_msg.instruction == CommandInst::GetPasswordSalt as i64 => {
use crate::server::db::cmd::get_user_salt::get_user_salt;
let salt = match get_user_salt(
match get_user_salt(
String::from_utf8(client_msg.data).unwrap().as_str(),
false,
false,
) {
Ok(salt) => salt,
Err(_) => {
let message =
message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
connection
.tls_session
.write(&bincode::serialize(&message).unwrap())
.unwrap();
connection.do_tls_write_and_handle_error();
return Ok(());
Ok(salt) => {
let server_response: Message = message_builder(
MessageType::DataTransfer,
CommandInst::GetPasswordSalt as i64,
1,
0,
1,
HEXUPPER.decode(salt.as_bytes()).unwrap(),
);
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
}
};
let server_response: Message = message_builder(
MessageType::DataTransfer,
CommandInst::GetPasswordSalt as i64,
1,
0,
1,
HEXUPPER.decode(salt.as_bytes()).unwrap(),
);
connection
.tls_session
.write(bincode::serialize(&server_response).unwrap().as_slice())
.unwrap();
connection.do_tls_write_and_handle_error();
Err(_) => {
let server_response =
message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
}
}
}
_ if client_msg.instruction == CommandInst::Register as i64 => {
register(connection, &client_msg)
register(socket, &client_msg).await
}
_ if client_msg.instruction == CommandInst::LoginMethod1 as i64 => {
login_normal(connection, &client_msg)
login_normal(socket, &client_msg).await
}
_ if client_msg.instruction == DataTransferInst::GetUserPortfolio as i64 => {
retrieve_portfolio(connection, &client_msg)
retrieve_portfolio(socket, &client_msg).await
}
_ if client_msg.instruction == DataTransferInst::GetUserTransactionHist as i64 => {
retrieve_transactions(connection, &client_msg)
retrieve_transactions(socket, &client_msg).await
}
_ if client_msg.instruction == DataTransferInst::GetAssetInfo as i64 => {
get_asset_info(connection, &client_msg)
}
_ if client_msg.instruction == DataTransferInst::GetAssetValue as i64 => {
get_asset_data(connection, &client_msg)
}
_ if client_msg.instruction == CommandInst::PurchaseAsset as i64 => {
purchase_asset(connection, &client_msg)
}
_ => {}
};
Ok(())
_ => Ok(()),
}
}

2
src/libtrader/server/network/mod.rs
View File

@ -1,5 +1,3 @@
pub mod cmd;
pub mod handle_data;
pub mod jwt_wrapper;
pub mod tls_connection;
pub mod tls_server;

222
src/libtrader/server/network/tls_connection.rs
View File

@ -1,222 +0,0 @@
use std::io;
use std::io::Read;
use std::net;
use mio;
use mio::net::TcpStream;
use rustls;
use rustls::Session;
use crate::server::network::handle_data::handle_data;
/// The TlsConnection struct that represents a tls connection.
///
/// Members:
/// socket - The TcpStream for which TLS is used on.
/// token - The ```mio::Token``` representing the TlsConnection.
/// closing - Used for starting a closing TlsConnection state.
/// closed - Used for determining whether the TlsConnection is closed.
/// tls_session - The ServerSession that is the TLS connecton.
#[derive(Debug)]
pub struct TlsConnection {
pub socket: TcpStream,
pub token: mio::Token,
pub closing: bool,
pub closed: bool,
pub tls_session: rustls::ServerSession,
}
impl TlsConnection {
/// Returns a new TlsConnection struct.
///
/// Arguments:
/// socket - The ```TcpStream``` to be used for the TlsConnection
/// token - The ```mio::Token``` to be used to identify the TlsConnection
/// tls_session - The ```rustls::ServerSession``` to be used in the Tls Connection
///
/// Returns: a new TlsConnection
pub fn new(
socket: TcpStream,
token: mio::Token,
tls_session: rustls::ServerSession,
) -> TlsConnection {
TlsConnection {
socket,
token,
closing: false,
closed: false,
tls_session,
}
}
/// TlsConnection event reciever.
///
/// Determines if the mio::event::Event is readable/writable or is closing. Calls the
/// appropriate TlsConnection function to handle the event. The event is not sent to the
/// receiving function.
///
/// Arguments:
/// registry - The mio::Registry containing the mio::Tokens.
/// event - The event to be 'dispatched'.
///
/// Returns: nothing
pub fn ready(&mut self, registry: &mio::Registry, ev: &mio::event::Event) {
if ev.is_readable() {
self.do_tls_read();
self.try_plain_read();
}
if ev.is_writable() {
self.do_tls_write_and_handle_error();
}
if self.closing {
let _ = self.socket.shutdown(net::Shutdown::Both);
self.closed = true;
self.deregister(registry);
} else {
self.reregister(registry);
}
}
/// Private TlsConnection function that reads incoming TLS packets.
///
/// Reads the ```self.tls_session``` received TLS packets and then handles any errors
/// generated. If reading TLS packets succeeds, issue new packets to be ready for reading.
fn do_tls_read(&mut self) {
// read some tls data.
let rc = self.tls_session.read_tls(&mut self.socket);
if rc.is_err() {
let err = rc.unwrap_err();
if let io::ErrorKind::WouldBlock = err.kind() {
/* make this simpler */
return;
}
error!("tls read error: {:?}", err);
self.closing = true;
return;
}
if rc.unwrap() == 0 {
self.closing = true;
return;
}
// process newly-recieved tls messages.
let processed = self.tls_session.process_new_packets();
if processed.is_err() {
error!("tls cannot process packet: {:?}", processed);
// last gasp write to send any alerts
self.do_tls_write_and_handle_error();
self.closing = true;
return;
}
}
/// Private TlsConnection function that reads decrypted TLS packets.
///
/// Reads from ``self.tls_sessions``` and fills a buffer. The buffer is sent to
/// ```self.incoming_plaintext()```.
fn try_plain_read(&mut self) {
// read and process all available plaintext.
let mut buf = Vec::new();
let rc = self.tls_session.read_to_end(&mut buf);
if rc.is_err() {
error!("tls plaintext read failed: {:?}", rc);
self.closing = true;
return;
}
if !buf.is_empty() {
debug!("plaintext read {:?}", buf.len());
self.incoming_plaintext(&buf);
}
}
/// Private TlsConnection function that dispatches decrypted TLS packets.
///
/// Dispatches decrypted TLS data to ```handle_data()```.
fn incoming_plaintext(&mut self, buf: &[u8]) {
match handle_data(self, buf) {
Ok(()) => {}
Err(err) => error!("Error processing TLS connection: {}", err),
}
}
/// Private TlsConnection function that flushes TLS packets and handles any errors.
pub fn do_tls_write_and_handle_error(&mut self) {
let rc = self.tls_session.write_tls(&mut self.socket);
if rc.is_err() {
error!("write failed: {:?}", rc);
self.closing = true;
return;
}
}
/// Registers the TlsConnection to a mio::Registry
///
/// Arguments:
/// registry - The registry to register
pub fn register(&mut self, registry: &mio::Registry) {
let event_set = self.event_set();
registry
.register(&mut self.socket, self.token, event_set)
.unwrap();
}
/// Reregisters the TlsConnection to a mio::Registry
///
/// Arguments:
/// registry - The registry to reregister
fn reregister(&mut self, registry: &mio::Registry) {
let event_set = self.event_set();
registry
.reregister(&mut self.socket, self.token, event_set)
.unwrap();
}
/// Unregisters the TlsConnection from a mio::Registry
///
/// Arguments:
/// registry - The registry to unregister
fn deregister(&mut self, registry: &mio::Registry) {
registry.deregister(&mut self.socket).unwrap();
}
/// Private TlsConnection function to return the ```self.tls_session```'s ```mio::Interest```
///
/// Returns: the interests of ```self.tls_session```
fn event_set(&self) -> mio::Interest {
let rd = self.tls_session.wants_read();
let wr = self.tls_session.wants_write();
if rd && wr {
mio::Interest::READABLE | mio::Interest::WRITABLE
} else if wr {
mio::Interest::WRITABLE
} else {
mio::Interest::READABLE
}
}
}
impl io::Write for TlsConnection {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let res = self.tls_session.write(bytes);
if res.is_err() {
warn!("TLS_CONNECTION_WRITE_FAILED");
} else {
self.do_tls_write_and_handle_error();
}
res
}
fn flush(&mut self) -> io::Result<()> {
self.tls_session.flush()
}
}

94
src/libtrader/server/network/tls_server.rs
View File

@ -1,94 +0,0 @@
use std::collections::HashMap;
use std::io;
use std::sync::Arc;
use mio;
use mio::net::TcpListener;
use rustls;
use crate::server::network::tls_connection::TlsConnection;
/// The TlsServer struct that represents a working TLS Server
///
/// Members:
/// server - The TcpListener for which TLS is accepted.
/// connections - The map of all connections.
/// next_id - The next unused ID for registering in the mio::Poll
/// tls_config - The TLS server configuration.
pub struct TlsServer {
pub server: TcpListener,
pub connections: HashMap<mio::Token, TlsConnection>,
pub next_id: usize,
pub tls_config: Arc<rustls::ServerConfig>,
}
impl TlsServer {
/// Returns a new TlsServer struct
///
/// Arguments:
/// server - The ```TcpListener``` to be used for the TLS Server.
/// cfg - The TLS server configuration to be used.
///
/// Returns: a new TlsServer
pub fn new(server: TcpListener, cfg: Arc<rustls::ServerConfig>) -> TlsServer {
TlsServer {
server,
connections: HashMap::new(),
next_id: 1,
tls_config: cfg,
}
}
/// Accepts any new TLS connections.
///
/// Arguments:
/// registry - The registry to register connections.
///
/// Returns: nothing on success, io::Error on failure.
pub fn accept(&mut self, registry: &mio::Registry) -> Result<(), io::Error> {
loop {
match self.server.accept() {
Ok((socket, addr)) => {
debug!("Accepting new connection from {:?}", addr);
let tls_session = rustls::ServerSession::new(&self.tls_config);
let token = mio::Token(self.next_id);
self.next_id += 1;
let mut connection = TlsConnection::new(socket, token, tls_session);
connection.register(registry);
self.connections.insert(token, connection);
}
Err(err) if err.kind() == io::ErrorKind::WouldBlock => return Ok(()),
Err(err) => {
error!("tls server error accepting connections; err={:?}", err);
return Err(err);
}
}
}
}
/// TLS Server Dispatcher
///
/// Checks if the token issuing the event is in the list of active connections and then
/// dispatches the event to TlsConnection.
///
/// Arguments:
/// registry - The registry to check the registered connections from.
/// event - The event to be dispatched.
pub fn conn_event(&mut self, registry: &mio::Registry, event: &mio::event::Event) {
let token = event.token();
if self.connections.contains_key(&token) {
self.connections
.get_mut(&token)
.unwrap()
.ready(registry, event);
if self.connections[&token].closed {
self.connections.remove(&token);
}
}
}
}