Add unencrypted TCP handling.

server/src/app/mod.rs

@@ -36,6 +36,7 @@ impl App {
         if let Ok(mut filesystem) = FileSystem::init() {
 
             // Load salts
+            println!("Loading salts..");
             let mut salts = Sparse::new();
             let salt_count = filesystem.salt_count()?;
             for id in 0..salt_count {
@@ -44,6 +45,7 @@ impl App {
             }
 
             // Load handles
+            println!("Loading handles..");
             let mut user_handle = Trie::new();
             let handle_count = filesystem.handle_count()?;
             for id in 0..handle_count {
@@ -52,7 +54,7 @@ impl App {
             }
 
             // Load users
-            println!("Load users..");
+            println!("Loading users..");
             let mut users = Pool::new();
             let mut user_id = Sparse::new();
             let user_count = filesystem.user_count()?;
@@ -63,7 +65,7 @@ impl App {
             }
 
             // Load sessions
-            println!("Load sessions..");
+            println!("Loading sessions..");
             let mut sessions = Trie::new();
             let mut times = Vec::<(u64, SessionToken)>::new();
             let session_count = filesystem.session_count()?;
@@ -83,14 +85,14 @@ impl App {
             // Organize sessions by most recent
             let mut session_time = Chain::new();
             times.sort_by(|(a, _), (b, _)| {
-                if a < b { std::cmp::Ordering::Greater } else { std::cmp::Ordering::Less }
+                if a > b { std::cmp::Ordering::Greater } else { std::cmp::Ordering::Less }
             });
             for (_, token) in times {
                 let id = session_time.add(token);
                 sessions.get_mut(&token).unwrap().chain_id = id;
             }
 
-            println!("Done.");
+            println!("App data ready.");
             Ok(Self {
                 filesystem:filesystem,
 

server/src/main.rs

@@ -12,7 +12,14 @@ mod manager;
 use app::App;
 use hyper::body::Bytes;
 use hyper_util::rt::TokioIo;
-use system::{cache::WebCache, net::Stream};
+use system::{
+    cache::WebCache,
+    net::{
+        Server, Stream,
+        tcp::*,
+        tls::*,
+    },
+};
 
 #[derive(Clone)]
 struct HttpServiceArgs {
@@ -65,7 +72,8 @@ async fn service_http(mut request:hyper::Request<hyper::body::Incoming>, args:Ht
     }
 }
 
-async fn handle_http(stream:system::net::tls::TlsStream, addr:SocketAddr, args:HttpServiceArgs) -> Result<(),()>
+async fn handle_http<S>(stream:S, addr:SocketAddr, args:HttpServiceArgs) -> Result<(),()>
+where S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static
 // Hand off socket connection to Hyper server.
 //
 {
@@ -74,7 +82,7 @@ async fn handle_http(stream:system::net::tls::TlsStream, addr:SocketAddr, args:H
 
     println!("Connection from {}", addr.to_string());
 
-    let io = TokioIo::new(stream.to_stream());
+    let io = TokioIo::new(stream);
 
     let conn = http1::Builder::new()
         .serve_connection(io, service_fn(move |req| {
@@ -85,15 +93,21 @@ async fn handle_http(stream:system::net::tls::TlsStream, addr:SocketAddr, args:H
     Ok(())
 }
 
+async fn handle_tcp(stream:TcpStream, addr:SocketAddr, args:HttpServiceArgs) -> Result<(),()>
+{
+    handle_http(stream.to_stream(), addr, args).await
+}
+
+async fn handle_tls(stream:TlsStream, addr:SocketAddr, args:HttpServiceArgs) -> Result<(),()>
+{
+    handle_http(stream.to_stream(), addr, args).await
+}
+
+
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 12)]
 async fn main()
 {
-    use system::net::{
-        Server,
-        tls::*,
-    };
-
     // Initialize application data.
     let app;
     if let Ok(result) = App::init() {
@@ -171,22 +185,40 @@ async fn main()
                 }
             }
 
-            let mut server = TlsServer::new();
+            let mut tcp_server = TcpServer::new();
-            if server.add_cert("omen.kirisame.com", "cert/fullchain.pem", "cert/privkey.pem").await.is_ok() {
+            match tcp_server.bind("127.0.0.1:38611").await {
-                println!("Loaded cert file.");
-            }
-            match server.bind("0.0.0.0:38612").await {
                 Ok(_) => {
-                    println!("Listener bind successful.");
+                    let b = bus.connect().unwrap();
+                    let c = cache.clone();
                     tokio::spawn(async move {
-                        while server.accept(handle_http, HttpServiceArgs {
+                        while tcp_server.accept(handle_tcp, HttpServiceArgs {
-                            bus:bus.connect().unwrap(),
+                            bus:b.connect().unwrap(),
-                            cache:cache.clone(),
+                            cache:c.clone(),
                         }).await.is_ok() { }
                     });
                 }
                 Err(_) => {
-                    println!("error: failed to bind port 38612.");
+                    println!("error: failed to bind TCP port 38611.");
+                }
+            }
+
+            let mut tls_server = TlsServer::new();
+            if tls_server.add_cert("omen.kirisame.com", "cert/fullchain.pem", "cert/privkey.pem").await.is_err() {
+                println!("error: failed to load TLS certificates.");
+            }
+            match tls_server.bind("0.0.0.0:38612").await {
+                Ok(_) => {
+                    let b = bus.connect().unwrap();
+                    let c = cache.clone();
+                    tokio::spawn(async move {
+                        while tls_server.accept(handle_tls, HttpServiceArgs {
+                            bus:b.connect().unwrap(),
+                            cache:c.clone(),
+                        }).await.is_ok() { }
+                    });
+                }
+                Err(_) => {
+                    println!("error: failed to bind TLS port 38612.");
                 }
             }
         }