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 - name: Check Code Format
run: cargo fmt --all -- --check run: cargo fmt --all -- --check
- name: Build Minimal - name: Build Minimal
run: cargo build run: cargo build --no-default-features
- name: Build Client - name: Build Client
run: cargo build --features "client" run: cargo build --no-default-features --features "client"
- name: Build Server - name: Build Server
run: cargo build --features "server" run: cargo build --no-default-features --features "server"
- name: Build Hybrid - name: Build Hybrid
run: cargo build --features "server,client" run: cargo build --no-default-features --features "server,client"
- name: Run benches - name: Run benches
run: cargo bench run: cargo bench

2
Cargo.toml
View File

@ -29,6 +29,8 @@ chrono = "0.4"
tokio = { version = "*", features = [ "full" ] } tokio = { version = "*", features = [ "full" ] }
tokio-io = "*" tokio-io = "*"
tokio-rustls = { version = "*" } tokio-rustls = { version = "*" }
tokio-util = { version = "*" }
#rustls-pemfile = { version = "*" }
futures = "*" futures = "*"
bytes = "*" bytes = "*"
postgres = "0.17.3" 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 ct_logs;
use rustls; //use rustls;
use std::sync::Arc; //use std::sync::Arc;
use webpki_roots; //use webpki_roots;
//
/// A "always accept" Certficate verifier. ///// A "always accept" Certficate verifier.
/// /////
/// WARN: only to be used in development environments. ///// WARN: only to be used in development environments.
/// using this in production envs will be a HUGE security vuln. ///// using this in production envs will be a HUGE security vuln.
#[cfg(feature = "tls_no_verify")] //#[cfg(feature = "tls_no_verify")]
mod danger { //mod danger {
use super::rustls; // use super::rustls;
use webpki; // use webpki;
//
pub struct NoCertificateVerification {} // pub struct NoCertificateVerification {}
//
impl rustls::ServerCertVerifier for NoCertificateVerification { // impl rustls::ServerCertVerifier for NoCertificateVerification {
fn verify_server_cert( // fn verify_server_cert(
&self, // &self,
_roots: &rustls::RootCertStore, // _roots: &rustls::RootCertStore,
_presented_certs: &[rustls::Certificate], // _presented_certs: &[rustls::Certificate],
_dns_name: webpki::DNSNameRef<'_>, // _dns_name: webpki::DNSNameRef<'_>,
_ocsp: &[u8], // _ocsp: &[u8],
) -> Result<rustls::ServerCertVerified, rustls::TLSError> { // ) -> Result<rustls::ServerCertVerified, rustls::TLSError> {
warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED"); // warn!("IF THIS IS NOT A DEV BUILD DO NOT PROCEED");
Ok(rustls::ServerCertVerified::assertion()) // Ok(rustls::ServerCertVerified::assertion())
} // }
} // }
} //}
//
/// Generates a TlsClient Config. ///// Generates a TlsClient Config.
/// /////
/// Uses defualt settings for: ///// Uses defualt settings for:
/// - TLS Protocol Version. ///// - TLS Protocol Version.
/// - TLs Protocol CypherSuite. ///// - TLs Protocol CypherSuite.
/// /////
/// Assumed Settings: ///// Assumed Settings:
/// - Certificate Authentication. ///// - Certificate Authentication.
/// - No persistent session storage. ///// - No persistent session storage.
/// /////
/// Returns; the client configuration in an Arc. ///// Returns; the client configuration in an Arc.
pub fn gen_tls_client_config() -> Arc<rustls::ClientConfig> { //pub fn gen_tls_client_config() -> Arc<rustls::ClientConfig> {
let mut config = rustls::ClientConfig::new(); // let mut config = rustls::ClientConfig::new();
config.key_log = Arc::new(rustls::KeyLogFile::new()); // config.key_log = Arc::new(rustls::KeyLogFile::new());
//
config // config
.root_store // .root_store
.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); // .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
config.ct_logs = Some(&ct_logs::LOGS); // config.ct_logs = Some(&ct_logs::LOGS);
//
let persist = Arc::new(rustls::NoClientSessionStorage {}); // let persist = Arc::new(rustls::NoClientSessionStorage {});
config.set_persistence(persist); // config.set_persistence(persist);
//
#[cfg(feature = "tls_no_verify")] // #[cfg(feature = "tls_no_verify")]
config // config
.dangerous() // .dangerous()
.set_certificate_verifier(Arc::new(danger::NoCertificateVerification {})); // .set_certificate_verifier(Arc::new(danger::NoCertificateVerification {}));
//
Arc::new(config) // Arc::new(config)
} //}
//
#[cfg(test)] //#[cfg(test)]
mod test { //mod test {
use super::*; // use super::*;
//
#[test] // #[test]
fn test_gen_tls_client_config() { // fn test_gen_tls_client_config() {
let _ = 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 std::fs::File;
use rustls::NoClientAuth; use std::io::{self, BufReader};
use std::fs; use std::path::Path;
use std::io::{BufReader, Read};
use std::sync::Arc; 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 /// Loads a TLS public certificate
/// ///
/// Arguments: /// Arguments:
/// filename - Path to .crt file. /// filename - Path to .crt file.
/// ///
/// Returns: vector of rustls' Certificate /// Returns: vector of rustls' Certificate
fn load_certs(filename: &str) -> Vec<rustls::Certificate> { fn load_certs(path: &Path) -> io::Result<Vec<Certificate>> {
let certfile = fs::File::open(filename).expect("cannot open certificate file"); certs(&mut BufReader::new(File::open(path)?))
let mut reader = BufReader::new(certfile); .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid cert"))
rustls::internal::pemfile::certs(&mut reader).unwrap()
} }
/// Load a TLS private key. /// Load a TLS private key.
@ -22,46 +24,30 @@ fn load_certs(filename: &str) -> Vec<rustls::Certificate> {
/// filename - Path to .key file. /// filename - Path to .key file.
/// ///
/// Returns: rustls::PrivateKey /// 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 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); let mut reader = BufReader::new(keyfile);
rustls::internal::pemfile::rsa_private_keys(&mut reader) rsa_private_keys(&mut reader).expect("file contains invalid rsa private key")
.expect("file contains invalid rsa private key")
}; };
let pkcs8_keys = { 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); 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)") .expect("file contains invalid pkcs8 private key (encrypted keys not supported)")
}; };
// prefer to load pkcs8 keys // prefer to load pkcs8 keys
if !pkcs8_keys.is_empty() { if !pkcs8_keys.is_empty() {
pkcs8_keys[0].clone() Ok(pkcs8_keys.clone())
} else { } else {
assert!(!rsa_keys.is_empty()); assert!(!rsa_keys.is_empty());
rsa_keys[0].clone() Ok(rsa_keys.clone())
} }
} //rsa_private_keys(&mut BufReader::new(File::open(path)?))
// .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid key"))
/// Loads OCSP stapling key. // TODO: use this kind of chekcing elsewhere too
///
/// 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
} }
/// Generates a TlsServer Config. /// 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); /// let config = gen_tls_server_config("tests.crt", "priv.key", None);
/// ``` /// ```
pub fn gen_tls_server_config( pub fn gen_tls_server_config(
certs_file: &str, certs_file: &Path,
priv_key_file: &str, priv_key_file: &Path,
ocsp_key_file: Option<&str>, ) -> io::Result<Arc<ServerConfig>> {
) -> Arc<rustls::ServerConfig> { let mut config = ServerConfig::new(NoClientAuth::new());
let mut config = rustls::ServerConfig::new(NoClientAuth::new()); //config.key_log = Arc::new(rustls::KeyLogFile::new());
config.key_log = Arc::new(rustls::KeyLogFile::new());
/* load TLS certificate */ /* load TLS certificate */
let certs = load_certs(certs_file); let certs = load_certs(certs_file)?;
let privkey = load_private_key(priv_key_file); let mut privkeys = load_private_keys(priv_key_file)?;
let ocsp = load_ocsp(&ocsp_key_file);
config config
.set_single_cert_with_ocsp_and_sct(certs, privkey, ocsp, vec![]) .set_single_cert(certs, privkeys.remove(0))
.expect("bad certs/priv key"); .map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
/* enable session resumption */ /* enable session resumption */
config.set_persistence(rustls::ServerSessionMemoryCache::new(512)); //config.set_persistence(rustls::ServerSessionMemoryCache::new(512));
config.ticketer = rustls::Ticketer::new(); //config.ticketer = rustls::Ticketer::new();
Arc::new(config) Ok(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);
}
} }

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

@ -1,5 +1,3 @@
use std::io::Write;
use data_encoding::HEXUPPER; use data_encoding::HEXUPPER;
use ring::pbkdf2; use ring::pbkdf2;
use std::num::NonZeroU32; 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_hash::get_user_hash;
use crate::server::db::cmd::get_user_id::get_user_id; 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::db::cmd::get_user_salt::get_user_salt;
use crate::server::network::tls_connection::TlsConnection;
use crate::server::network::jwt_wrapper::create_jwt_token; 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. * Parse account data.
* */ * */
@ -106,7 +110,10 @@ pub fn acc_auth(tls_connection: &mut TlsConnection, message: &Message) -> Result
0, 0,
jwt_token.as_bytes().to_vec(), 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(()) 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::portfolio::Portfolio;
use crate::common::account::position::Position; use crate::common::account::position::Position;
use crate::common::message::message::Message; 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::config::{DB_PORTFOLIO_PASS, DB_PORTFOLIO_USER};
use crate::server::db::initializer::db_connect; use crate::server::db::initializer::db_connect;
use crate::server::network::jwt_wrapper::verify_jwt_token; use crate::server::network::jwt_wrapper::verify_jwt_token;
use crate::server::network::tls_connection::TlsConnection;
pub fn acc_retrieve_portfolio( use tokio::io::AsyncWriteExt;
tls_connection: &mut TlsConnection, use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn acc_retrieve_portfolio(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message, message: &Message,
) -> Result<(), ReturnFlags> { ) -> Result<(), ReturnFlags> {
/* verify JWT token */ /* verify JWT token */
@ -21,7 +22,7 @@ pub fn acc_retrieve_portfolio(
Ok(token) => token, Ok(token) => token,
Err(_) => { Err(_) => {
warn!("ACC_RETRIEVE_PORTFOLIO_UNAUTH_TOKEN"); warn!("ACC_RETRIEVE_PORTFOLIO_UNAUTH_TOKEN");
tls_connection.closing = true; tls_connection.shutdown().await.unwrap();
return Err(ReturnFlags::ServerAccUnauthorized); return Err(ReturnFlags::ServerAccUnauthorized);
} }
}; };
@ -63,7 +64,10 @@ pub fn acc_retrieve_portfolio(
0, 0,
bincode::serialize(&portfolio).unwrap(), 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(()) 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::account::transaction::Transaction;
use crate::common::message::message::Message; use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; 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::config::{DB_ACC_PASS, DB_ACC_USER};
use crate::server::db::initializer::db_connect; use crate::server::db::initializer::db_connect;
use crate::server::network::jwt_wrapper::verify_jwt_token; use crate::server::network::jwt_wrapper::verify_jwt_token;
use crate::server::network::tls_connection::TlsConnection;
pub fn acc_retrieve_transaction( use tokio::io::AsyncWriteExt;
tls_connection: &mut TlsConnection, use tokio::net::TcpStream;
use tokio_rustls::server::TlsStream;
pub async fn acc_retrieve_transaction(
tls_connection: &mut TlsStream<TcpStream>,
message: &Message, message: &Message,
) -> Result<(), ReturnFlags> { ) -> Result<(), ReturnFlags> {
/* verify JWT token */ /* verify JWT token */
@ -20,7 +21,7 @@ pub fn acc_retrieve_transaction(
Ok(token) => token, Ok(token) => token,
Err(_) => { Err(_) => {
warn!("ACC_RETRIEVE_TRANSACTION_UNAUTH_TOKEN"); warn!("ACC_RETRIEVE_TRANSACTION_UNAUTH_TOKEN");
tls_connection.closing = true; tls_connection.shutdown().await.unwrap();
return Err(ReturnFlags::ServerAccUnauthorized); return Err(ReturnFlags::ServerAccUnauthorized);
} }
}; };

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

@ -1,6 +1,6 @@
use argh::FromArgs; use argh::FromArgs;
use std::path::PathBuf; use std::path::PathBuf;
use tokio::io::{copy, sink, split, AsyncWriteExt}; use tokio::io::AsyncReadExt;
use tokio::net::TcpListener; use tokio::net::TcpListener;
use tokio_rustls::TlsAcceptor; 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::gen_tls_server_config::gen_tls_server_config;
use crate::common::misc::path_exists::path_exists; use crate::common::misc::path_exists::path_exists;
use crate::common::misc::return_flags::ReturnFlags; use crate::common::misc::return_flags::ReturnFlags;
use crate::server::network::handle_data::handle_data;
//use crate::server::network::tls_server::TlsServer;
/// Server Options /// Server Options
#[derive(FromArgs)] #[derive(FromArgs)]
@ -54,7 +53,8 @@ fn libtrader_init_log() -> Result<(), ReturnFlags> {
gen_log(); gen_log();
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
{ use simplelog::*; {
use simplelog::*;
use std::fs::File; use std::fs::File;
if !path_exists("log") { if !path_exists("log") {
@ -94,15 +94,18 @@ pub async fn libtrader_init_server() -> std::io::Result<()> {
// Initialize log. // Initialize log.
//#[cfg(not(test))] // wot dis //#[cfg(not(test))] // wot dis
match libtrader_init_log() { match libtrader_init_log() {
Ok(()) => {} Ok(_) => {}
Err(err) => {}, // TODO: handle this case Err(_) => {} // TODO: handle this case
}; };
// Initialize arguments // Initialize arguments
let options: Options = argh::from_env(); let options: Options = argh::from_env();
let addr = options.addr.to_socket_addrs()?.next(). let addr = options
ok_or_else(|| std::io::Error::from(std::io::ErrorKind::AddrNotAvailable))?; .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 config = gen_tls_server_config(&options.cert, &options.key)?;
let acceptor = TlsAcceptor::from(config); let acceptor = TlsAcceptor::from(config);
@ -110,13 +113,24 @@ pub async fn libtrader_init_server() -> std::io::Result<()> {
let listener = TcpListener::bind(&addr).await?; let listener = TcpListener::bind(&addr).await?;
loop { loop {
let (stream, peer_addr) = listener.accept().await?; let (socket, _) = listener.accept().await?; // socket, peer_addr
let acceptor = acceptor.clone(); let acceptor = acceptor.clone();
// function to run in the thread
let fut = async move { 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<()> 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 std::io::Write;
//
use crate::common::message::message::Message; //use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; //use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType; //use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg; //use crate::common::misc::assert_msg::assert_msg;
//
use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs; //use crate::server::db::cmd::get_stock::get_stock_from_db_between_epochs;
use crate::server::network::tls_connection::TlsConnection; //use crate::server::network::tls_connection::TlsConnection;
//
pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) { //pub fn get_asset_data(tls_connection: &mut TlsConnection, message: &Message) {
/* assert recieved message */ // /* assert recieved message */
if !assert_msg( // if !assert_msg(
message, // message,
MessageType::DataTransfer, // MessageType::DataTransfer,
true, // true,
3, // 3,
false, // false,
0, // 0,
false, // false,
0, // 0,
false, // false,
0, // 0,
) { // ) {
tls_connection.closing = true; // tls_connection.closing = true;
warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED"); // warn!("GET_ASSET_DATA_MSG_ASSERT_FAILED");
return; // return;
} // }
//
/* // /*
* Parse arguments // * Parse arguments
* */ // * */
/* get json data */ // /* get json data */
let stringified_data = std::str::from_utf8(&message.data).unwrap(); // let stringified_data = std::str::from_utf8(&message.data).unwrap();
let data = json::parse(&stringified_data).unwrap(); // let data = json::parse(&stringified_data).unwrap();
/* get symbol, start_epoch, and end_epoch */ // /* get symbol, start_epoch, and end_epoch */
let symbol = data["symbol"].as_str().unwrap(); // let symbol = data["symbol"].as_str().unwrap();
let start_epoch = data["start_epoch"] // let start_epoch = data["start_epoch"]
.as_str() // .as_str()
.unwrap() // .unwrap()
.to_string() // .to_string()
.parse::<i64>() // .parse::<i64>()
.unwrap(); // .unwrap();
let end_epoch = data["end_epoch"] // let end_epoch = data["end_epoch"]
.as_str() // .as_str()
.unwrap() // .unwrap()
.to_string() // .to_string()
.parse::<i64>() // .parse::<i64>()
.unwrap(); // .unwrap();
//
/* call get_stock_from_db_between_epochs() */ // /* call get_stock_from_db_between_epochs() */
match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) { // match get_stock_from_db_between_epochs(symbol, start_epoch, end_epoch) {
Ok(vals) => { // Ok(vals) => {
/* send the data */ // /* send the data */
let mut counter = 0; // let mut counter = 0;
for val in &vals { // for val in &vals {
let message = message_builder( // let message = message_builder(
MessageType::DataTransfer, // MessageType::DataTransfer,
1, // 1,
counter, // counter,
vals.len(), // vals.len(),
0, // 0,
bincode::serialize(&val).unwrap(), // bincode::serialize(&val).unwrap(),
); // );
let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); // let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
counter = counter + 1; // counter = counter + 1;
} // }
} // }
Err(err) => { // Err(err) => {
/* handle error */ // /* handle error */
let message = message_builder( // let message = message_builder(
MessageType::ServerReturn, // MessageType::ServerReturn,
0, // 0,
0, // 0,
0, // 0,
0, // 0,
bincode::serialize(&err).unwrap(), // bincode::serialize(&err).unwrap(),
); // );
let _ = tls_connection.write(&bincode::serialize(&message).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 std::io::Write;
//
use crate::common::message::inst::DataTransferInst; //use crate::common::message::inst::DataTransferInst;
use crate::common::message::message::Message; //use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; //use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType; //use crate::common::message::message_type::MessageType;
use crate::common::misc::assert_msg::assert_msg; //use crate::common::misc::assert_msg::assert_msg;
//
use crate::server::db::cmd::get_company::get_company_from_db; //use crate::server::db::cmd::get_company::get_company_from_db;
use crate::server::network::tls_connection::TlsConnection; //use crate::server::network::tls_connection::TlsConnection;
//
pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) { //pub fn get_asset_info(tls_connection: &mut TlsConnection, message: &Message) {
/* assert recieved message */ // /* assert recieved message */
if !assert_msg( // if !assert_msg(
message, // message,
MessageType::DataTransfer, // MessageType::DataTransfer,
true, // true,
1, // 1,
false, // false,
0, // 0,
false, // false,
0, // 0,
false, // false,
0, // 0,
) { // ) {
tls_connection.closing = true; // tls_connection.closing = true;
warn!("GET_ASSET_INFO_INVALID_MESSAGE"); // warn!("GET_ASSET_INFO_INVALID_MESSAGE");
return; // return;
} // }
//
/* call get_company_from_db() */ // /* call get_company_from_db() */
match get_company_from_db(bincode::deserialize(&message.data).unwrap()) { // match get_company_from_db(bincode::deserialize(&message.data).unwrap()) {
Ok(company) => { // Ok(company) => {
let message = message_builder( // let message = message_builder(
MessageType::ServerReturn, // MessageType::ServerReturn,
DataTransferInst::GetAssetInfo as i64, // DataTransferInst::GetAssetInfo as i64,
0, // 0,
0, // 0,
1, // 1,
bincode::serialize(&company).unwrap(), // bincode::serialize(&company).unwrap(),
); // );
let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); // let _ = tls_connection.write(&bincode::serialize(&message).unwrap());
} // }
Err(err) => { // Err(err) => {
let message = message_builder( // let message = message_builder(
MessageType::ServerReturn, // MessageType::ServerReturn,
0, // 0,
0, // 0,
0, // 0,
0, // 0,
bincode::serialize(&err).unwrap(), // bincode::serialize(&err).unwrap(),
); // );
let _ = tls_connection.write(&bincode::serialize(&message).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::inst::CommandInst;
use crate::common::message::message::Message; use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; 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::common::misc::assert_msg::assert_msg;
use crate::server::account::authorization::acc_auth; 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 */ /* assert recieved message */
if !assert_msg( if !assert_msg(
message, message,
@ -25,16 +29,15 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) {
) && message.instruction == CommandInst::LoginMethod1 as i64 ) && message.instruction == CommandInst::LoginMethod1 as i64
&& message.data.len() != 0 && message.data.len() != 0
{ {
tls_connection.closing = true;
warn!("LOGIN_INVALID_MESSAGE"); warn!("LOGIN_INVALID_MESSAGE");
return; return tls_connection.shutdown().await;
} }
/* call acc_auth() server version */ /* call acc_auth() server version */
match acc_auth(tls_connection, message) { match acc_auth(tls_connection, message).await {
Ok(_) => {} Ok(_) => Ok(()),
Err(err) => { Err(err) => {
let message = message_builder( let server_response = message_builder(
MessageType::ServerReturn, MessageType::ServerReturn,
0, 0,
0, 0,
@ -42,7 +45,9 @@ pub fn login_normal(tls_connection: &mut TlsConnection, message: &Message) {
0, 0,
bincode::serialize(&err).unwrap(), 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::common::message::message::Message;
//
use crate::server::network::tls_connection::TlsConnection; //use crate::server::network::tls_connection::TlsConnection;
//
pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) { //pub fn purchase_asset(_tls_connection: &mut TlsConnection, _message: &Message) {
/* assert recieved message */ // /* assert recieved message */
//if message.msgtype != MessageType::Command || message.argument_count != 4 // //if message.msgtype != MessageType::Command || message.argument_count != 4
// || message.data_message_number != 0 || message.data_message_max != 0 // // || message.data_message_number != 0 || message.data_message_max != 0
// || message.data.len() == 0 { // // || message.data.len() == 0 {
// warn!("PURCHASE_ASSET_INVALID_MESSAGE"); // // warn!("PURCHASE_ASSET_INVALID_MESSAGE");
// tls_connection.closing = true; // // tls_connection.closing = true;
// return; // // return;
// } // // }
//
//* parse request data */ // //* parse request data */
//let stringified_data = std::str::from_utf8(&message.data).unwrap(); // //let stringified_data = std::str::from_utf8(&message.data).unwrap();
//let data = json::parse(&stringified_data).unwrap(); // //let data = json::parse(&stringified_data).unwrap();
//* get symbol, shares amount, price, buy or sell */ // //* get symbol, shares amount, price, buy or sell */
//let symbol = data["symbol"].as_str().unwrap(); // //let symbol = data["symbol"].as_str().unwrap();
//let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::<i64>().unwrap(); // //let shares_amount = data["shares_amount"].as_str().unwrap().to_string().parse::<i64>().unwrap();
//let is_buy = data["is_buy"].as_bool().unwrap(); // //let is_buy = data["is_buy"].as_bool().unwrap();
//
//* connect to the data base */ // //* connect to the data base */
//let mut client = db_connect(DB_USER, DB_PASS).unwrap(); // //let mut client = db_connect(DB_USER, DB_PASS).unwrap();
//
//* check if the symbol exists */ // //* check if the symbol exists */
//let company = get_company_from_db(symbol); // //let company = get_company_from_db(symbol);
//if !company.is_ok() { // //if !company.is_ok() {
// let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0, // // let msg = message_builder(MessageType::ServerReturn, 0, 1, 0, 0,
// bincode::serialize("COULDNOT FIND COMPANY")).unwrap(); // // bincode::serialize("COULDNOT FIND COMPANY")).unwrap();
// return; // // 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::inst::CommandInst;
use crate::common::message::message::Message; use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; 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::common::misc::assert_msg::assert_msg;
use crate::server::account::creation::acc_create; 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 */ /* assert recieved message */
if !assert_msg( if !assert_msg(
message, message,
@ -26,18 +30,21 @@ pub fn register(tls_connection: &mut TlsConnection, message: &Message) {
&& message.data.len() != 0 && message.data.len() != 0
{ {
warn!("REGISTER_INVALID_MESSAGE"); warn!("REGISTER_INVALID_MESSAGE");
tls_connection.closing = true; return tls_connection.shutdown().await;
return;
} }
/* call acc_create() server version */ /* call acc_create() server version */
match acc_create(message) { match acc_create(message) {
Ok(_) => { Ok(_) => {
let message = message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new()); let server_response =
let _ = tls_connection.write(&bincode::serialize(&message).unwrap()); message_builder(MessageType::ServerReturn, 1, 0, 0, 0, Vec::new());
tls_connection
.write_all(&bincode::serialize(&server_response).unwrap())
.await
} }
Err(err) => { Err(err) => {
warn!("REGISTER_FAILED: {}", 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::common::misc::assert_msg::assert_msg;
use crate::server::account::retrieval_portfolio::acc_retrieve_portfolio; 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 */ /* assert recieved message */
if !assert_msg( if !assert_msg(
message, message,
@ -22,14 +28,16 @@ pub fn retrieve_portfolio(tls_connection: &mut TlsConnection, message: &Message)
) && message.instruction == DataTransferInst::GetUserPortfolio as i64 ) && message.instruction == DataTransferInst::GetUserPortfolio as i64
&& message.data.len() != 0 && message.data.len() != 0
{ {
tls_connection.closing = true;
warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE"); warn!("RETRIEVE_PORTFOLIO_INVALID_MESSAGE");
return; return tls_connection.shutdown().await;
} }
/* call acc_retrieve_portfolio() server version */ /* call acc_retrieve_portfolio() server version */
match acc_retrieve_portfolio(tls_connection, message) { match acc_retrieve_portfolio(tls_connection, message).await {
Ok(_) => {} Ok(_) => Ok(()),
Err(err) => warn!("RETRIEVE_PORTFOLIO_FAILED: {}", err), 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::common::misc::assert_msg::assert_msg;
use crate::server::account::retrieval_transaction::acc_retrieve_transaction; 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 */ /* assert recieved message */
if !assert_msg( if !assert_msg(
message, message,
@ -22,14 +28,16 @@ pub fn retrieve_transactions(tls_connection: &mut TlsConnection, message: &Messa
) && message.instruction == DataTransferInst::GetUserTransactionHist as i64 ) && message.instruction == DataTransferInst::GetUserTransactionHist as i64
&& message.data.len() != 0 && message.data.len() != 0
{ {
tls_connection.closing = true;
warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE"); warn!("RETRIEVE_TRANSACTION_INVALID_MESSAGE");
return; return tls_connection.shutdown().await;
} }
/* call acc_retrieve_transaction() server version */ /* call acc_retrieve_transaction() server version */
match acc_retrieve_transaction(tls_connection, message) { match acc_retrieve_transaction(tls_connection, message).await {
Ok(_) => {} Ok(_) => Ok(()),
Err(err) => warn!("RETRIEVE_TRANSACTION_FAILED: {}", err), 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 data_encoding::HEXUPPER;
use std::io::Write;
use crate::common::message::inst::{CommandInst, DataTransferInst}; use crate::common::message::inst::{CommandInst, DataTransferInst};
use crate::common::message::message::Message; use crate::common::message::message::Message;
use crate::common::message::message_builder::message_builder; use crate::common::message::message_builder::message_builder;
use crate::common::message::message_type::MessageType; 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::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::register::register;
use crate::server::network::cmd::retrieve_portfolio::retrieve_portfolio; use crate::server::network::cmd::retrieve_portfolio::retrieve_portfolio;
use crate::server::network::cmd::retrieve_transactions::retrieve_transactions; 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 */ /* decode incoming message */
let client_msg: Message = match bincode::deserialize(&buf) { let client_msg: Message = bincode::deserialize(&buf).expect("HANDLE_DATA_RCVD_INV_MSG");
Ok(msg) => msg,
Err(err) => {
warn!("HANDLE_DATA_RCVD_INV_MSG: {}", err);
connection.closing = true; /* disconnect any unrecognized message senders */
return Ok(());
}
};
/* handle individual client instructions */ /* handle individual client instructions */
match client_msg.instruction { match client_msg.instruction {
@ -43,100 +36,81 @@ pub fn handle_data(connection: &mut TlsConnection, buf: &[u8]) -> Result<(), Str
1, 1,
salt.to_vec(), salt.to_vec(),
); );
connection socket
.tls_session .write_all(bincode::serialize(&server_response).unwrap().as_slice())
.write(bincode::serialize(&server_response).unwrap().as_slice()) .await
.unwrap();
connection.do_tls_write_and_handle_error();
} }
_ if client_msg.instruction == CommandInst::GetEmailSalt as i64 => { _ if client_msg.instruction == CommandInst::GetEmailSalt as i64 => {
use crate::server::db::cmd::get_user_salt::get_user_salt; 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(), String::from_utf8(client_msg.data).unwrap().as_str(),
true, true,
false, false,
) { ) {
Ok(salt) => salt, Ok(salt) => {
Err(_) => { let server_response: Message = message_builder(
let msg = message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); MessageType::DataTransfer,
connection CommandInst::GetEmailSalt as i64,
.tls_session 1,
.write(&bincode::serialize(&msg).unwrap()) 0,
.unwrap(); 1,
connection.do_tls_write_and_handle_error(); HEXUPPER.decode(salt.as_bytes()).unwrap(),
return Ok(()); );
socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
} }
}; Err(_) => {
let server_response: Message = message_builder( let server_response =
MessageType::DataTransfer, message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
CommandInst::GetEmailSalt as i64, socket
1, .write_all(bincode::serialize(&server_response).unwrap().as_slice())
0, .await
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();
} }
_ if client_msg.instruction == CommandInst::GetPasswordSalt as i64 => { _ if client_msg.instruction == CommandInst::GetPasswordSalt as i64 => {
use crate::server::db::cmd::get_user_salt::get_user_salt; 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(), String::from_utf8(client_msg.data).unwrap().as_str(),
false, false,
false, false,
) { ) {
Ok(salt) => salt, Ok(salt) => {
Err(_) => { let server_response: Message = message_builder(
let message = MessageType::DataTransfer,
message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new()); CommandInst::GetPasswordSalt as i64,
connection 1,
.tls_session 0,
.write(&bincode::serialize(&message).unwrap()) 1,
.unwrap(); HEXUPPER.decode(salt.as_bytes()).unwrap(),
connection.do_tls_write_and_handle_error(); );
return Ok(()); socket
.write_all(bincode::serialize(&server_response).unwrap().as_slice())
.await
} }
}; Err(_) => {
let server_response: Message = message_builder( let server_response =
MessageType::DataTransfer, message_builder(MessageType::ServerReturn, 0, 0, 0, 0, Vec::new());
CommandInst::GetPasswordSalt as i64,
1, socket
0, .write_all(bincode::serialize(&server_response).unwrap().as_slice())
1, .await
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();
} }
_ if client_msg.instruction == CommandInst::Register as i64 => { _ 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 => { _ 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 => { _ 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 => { _ 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 => { _ => Ok(()),
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(())
} }

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

@ -1,5 +1,3 @@
pub mod cmd; pub mod cmd;
pub mod handle_data; pub mod handle_data;
pub mod jwt_wrapper; 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);
}
}
}
}