architecture changes

1 files changed, 65 insertions, 16 deletions

diff --git a/src/server/mod.rs b/src/server/mod.rs
index 01a686d..5b7aedb 100644
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -1,30 +1,79 @@
-use std::vec::Vec;
+use crate::server::response::Response;
+use openssl::ssl::{SslAcceptor, SslFiletype, SslMethod, SslStream};
 use std::collections::HashMap;
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::thread;
+use std::vec::Vec;
+use std::sync::Arc;
 use url::Url;
 
-mod handler;
-mod response;
+pub mod response;
+pub mod handler;
+
+#[derive(Clone)]
+pub struct ServerConfig {
+    defaultHost: Url,
+}
 
 pub struct Server {
-    handlers: Vec<Box<dyn handler::Handler>>,
+    acceptor: std::sync::Arc<SslAcceptor>,
+    config: ServerConfig,
 }
 
 impl Server {
-    pub fn new() -> Server {
-        Server{handlers: Vec::<Box<dyn handler::Handler>>::new()}
+    pub fn new(host: &str) -> Server {
+        let config = ServerConfig{defaultHost: Url::parse(host).unwrap()};
+
+        Server {
+            acceptor: build_acceptor(),
+            config: config,
+        }
     }
-}
 
-pub fn register(host: &str, server: Server) {
-////    servers.insert(
-////        host.to_string(),
-////        server,
-////    );
-}
+    pub fn serve(&self) {
+        let addrs = [SocketAddr::from(([127, 0, 0, 1], 1965))];
+        let listener = TcpListener::bind(&addrs[..]).unwrap();
 
-pub fn handle(url: &Url) -> Vec<u8> {
-    return Vec::new();
+        for stream in listener.incoming() {
+            match stream {
+                Ok(stream) => {
+                    let acceptor = self.acceptor.clone();
+                    let config = self.config.clone();
+                    thread::spawn(move || {
+                        let stream = acceptor.accept(stream).unwrap();
+                        handle_client(&config, stream);
+                    });
+                }
+                Err(e) => { /* connection failed */ }
+            }
+        }
+    }
 }
 
-//static mut servers : HashMap<String, Server> = HashMap::new();
+fn handle_client(config: &ServerConfig, mut stream: SslStream<TcpStream>) {
+    let mut buffer = [0; 1026];
+    stream.ssl_read(&mut buffer);
+    let request = String::from_utf8(buffer.to_vec()).unwrap();
+
+    let location = match Url::parse(&request) {
+        Ok(url) => url,
+        Err(e) => config.defaultHost.join(&request).unwrap(),
+    };
+
+    let response = match handler::handle(config, location) {
+        Some(response) => response,
+        None => response::internal_error(),
+    };
 
+    stream.ssl_write(&response.format());
+}
+
+fn build_acceptor() -> std::sync::Arc<SslAcceptor> {
+    let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
+    acceptor
+        .set_private_key_file("doc/key.pem", SslFiletype::PEM)
+        .unwrap();
+    acceptor.set_certificate_chain_file("doc/cert.pem").unwrap();
+    acceptor.check_private_key().unwrap();
+    return Arc::new(acceptor.build());
+}