Fix server websocket.

server/Cargo.toml

@@ -9,6 +9,7 @@ tokio-stream = "0.1.15"
 tokio-tungstenite = "0.23.1"
 tokio-rustls = "0.26.0"
 tokio-util = { version = "0.7.11", features = ["compat"] }
+hyper-tungstenite = "0.14.0"
 rustls = "0.23.5"
 rustls-pemfile = "2.1.2"
 webpki-roots = "0.26"

server/src/main.rs

@@ -8,13 +8,13 @@ mod system;
 mod protocol;
 
 use app::App;
-use hyper::body::Bytes;
+use hyper::{body::Bytes, upgrade::Upgraded};
 use system::{cache::WebCache, net::Stream};
 use tokio_stream::StreamExt;
 use tokio_tungstenite::WebSocketStream;
 use hyper_util::rt::TokioIo;
-use tokio_rustls::server::TlsStream;
+//use tokio_rustls::server::TlsStream;
-use tokio::net::TcpStream;
+//use tokio::net::TcpStream;
 
 async fn thread_datasystem(mut _app:App, bus:Bus<protocol::QRPacket>)
 {
@@ -51,7 +51,7 @@ struct HttpServiceArgs {
     cache:WebCache,
 }
 
-async fn handle_ws(mut ws_stream:WebSocketStream<TlsStream<TcpStream>>, args:HttpServiceArgs)
+async fn handle_ws(mut ws_stream:WebSocketStream<TokioIo<Upgraded>>, args:HttpServiceArgs)
 {
     use tokio_tungstenite::tungstenite::protocol::Message;
     use game::util::unpack_u16;
@@ -105,12 +105,12 @@ async fn handle_ws(mut ws_stream:WebSocketStream<TlsStream<TcpStream>>, args:Htt
     ws_stream.close(None).await.ok();
 }
 
-async fn service_http(request:hyper::Request<hyper::body::Incoming>, args:HttpServiceArgs) -> Result<hyper::Response<http_body_util::Full<Bytes>>, std::convert::Infallible>
+async fn service_http(mut request:hyper::Request<hyper::body::Incoming>, args:HttpServiceArgs) -> Result<hyper::Response<http_body_util::Full<Bytes>>, std::convert::Infallible>
 {
-    use hyper::{Response, body::Bytes, header::{CONTENT_TYPE, CACHE_CONTROL, UPGRADE}};
+    use hyper::{Response, body::Bytes, header::{CONTENT_TYPE, CACHE_CONTROL}}; //SEC_WEBSOCKET_ACCEPT, SEC_WEBSOCKET_KEY, UPGRADE
     use http_body_util::Full;
-    use tokio_tungstenite::accept_async;
+    //use tokio_tungstenite::accept_async;
-    use tokio_tungstenite::tungstenite::handshake::server::create_response_with_body;
+    //use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
 
     println!("Serving: {}", request.uri().path());
 
@@ -130,30 +130,55 @@ async fn service_http(request:hyper::Request<hyper::body::Incoming>, args:HttpSe
             .body(Full::new(Bytes::from(args.cache.favicon()))).unwrap()),
 
         _ => {
-            if request.headers().get(UPGRADE).map(|h| h == "websocket").unwrap_or(false) {
+            if hyper_tungstenite::is_upgrade_request(&request) {
-                let response = create_response_with_body(&request, || Full::new(Bytes::new())).unwrap();
+            //if request.headers().get(UPGRADE).map(|h| h == "websocket").unwrap_or(false) {
+                //let response = create_response_with_body(&request, || Full::new(Bytes::new())).unwrap();
 
-                tokio::task::spawn(async move {
+                //let key = request.headers().get(SEC_WEBSOCKET_KEY)
-                    match hyper::upgrade::on(request).await {
+                //    .and_then(|v| v.to_str().ok())
-                        Ok(upgraded) => {
+                //    .map(|k| derive_accept_key(k.as_bytes()))
-                            match upgraded.downcast::<TokioIo<TlsStream<TcpStream>>>() {
+                //    .unwrap_or_default();
-                                Ok(parts) => {
+
-                                    match accept_async(parts.io.into_inner()).await {
+                if let Ok((response, websocket)) = hyper_tungstenite::upgrade(&mut request, None) {
-                                        Ok(ws_stream) => {
+                    tokio::task::spawn(async move {
-                                            println!("here");
+                        match websocket.await {
-                                            handle_ws(ws_stream, args).await
+                            Ok(websocket) => handle_ws(websocket, args).await,
-                                        }
+                            Err(_) => { }
-                                        Err(e) => { println!("ws not accepted: {}", e.to_string()); }
-                                    }
-                                }
-                                Err(_) => { println!("transfer error"); }
-                            }
                         }
-                        Err(e) => { println!("upgrade error: {}", e.to_string()); }
+                        //match hyper::upgrade::on(request).await {
-                    }
+                            /*Ok(upgraded) => {
-                });
+                                match upgraded.downcast::<TokioIo<TlsStream<TcpStream>>>() {
+                                    Ok(parts) => {
+                                        match accept_async(parts.io.into_inner()).await {
+                                            Ok(ws_stream) => {
+                                                println!("here");
+                                                handle_ws(ws_stream, args).await
+                                            }
+                                            Err(e) => { println!("ws not accepted: {}", e.to_string()); }
+                                        }
+                                    }
+                                    Err(_) => { println!("transfer error"); }
+                                }
+                            }
+                            Er(e) => { println!("upgrade error: {}", e.to_string()); }*/
+                        //}
+                    });
 
-                Ok(response)
+                    Ok(response)
+                } else {
+                    Ok(Response::builder()
+                        .status(401)
+                        .body(Full::new(Bytes::new()))
+                            .unwrap())
+                }
+
+                //Ok(Response::builder()
+                //    .status(101)
+                //    .header(CONNECTION, "Upgrade")
+                //    .header(UPGRADE, "websocket")
+                //    .header(SEC_WEBSOCKET_ACCEPT, key)
+                //    .body(Full::new(Bytes::new()))
+                //    .unwrap())
             } else {
                 Ok(Response::builder()
                     .header(CONTENT_TYPE, "text/html")

www/.js

@@ -85,20 +85,20 @@ function RECONNECT() {
         console.log("Connecting..");
         SOCKET = new WebSocket("wss://omen.kirisame.com:38612");
         SOCKET.binaryType = 'blob';
-        SOCKET.addEventListener("error", function(e) {
+        SOCKET.addEventListener("error", (event) => {
-            console.log("Failed");
+            console.log("Failed: " + event.reason);
             SOCKET = null;
         });
-        SOCKET.addEventListener("open", function(e) {
+        SOCKET.addEventListener("open", (event) => {
             if(SOCKET.readyState === WebSocket.OPEN) {
                 console.log("Connected.");
 
-                SOCKET.addEventListener("message", function(e) {
+                SOCKET.addEventListener("message", (event) => {
-                    MESSAGE(e.data);
+                    MESSAGE(event.data);
                 });
 
-                SOCKET.addEventListener("close", function(e) {
+                SOCKET.addEventListener("close", (event) => {
-                    console.log("Closed.");
+                    console.log("Closed (" + event.wasClean + ":" + event.code + "): " + event.reason);
                     SOCKET = null;
                     RECONNECT();
                 });