1 files changed, 148 insertions, 0 deletions
diff --git a/server/client-lib/src/network/sync.rs b/server/client-lib/src/network/sync.rs
new file mode 100644
index 00000000..e8aa08de
--- /dev/null
+++ b/server/client-lib/src/network/sync.rs
@@ -0,0 +1,148 @@
+/*
+    Hurry Curry! - a game about cooking
+    Copyright 2024 metamuffin
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, version 3 of the License only.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+*/
+use anyhow::Result;
+use hurrycurry_protocol::{PacketC, PacketS, BINCODE_CONFIG, VERSION};
+use log::{debug, info, warn};
+use std::{collections::VecDeque, net::TcpStream};
+use tungstenite::{
+    client::{uri_mode, IntoClientRequest},
+    client_tls_with_config,
+    handshake::client::Request,
+    stream::{MaybeTlsStream, Mode},
+    util::NonBlockingError,
+    Message, WebSocket,
+};
+
+pub struct Network {
+    sock: WebSocket<MaybeTlsStream<TcpStream>>,
+    pub queue_in: VecDeque<PacketC>,
+    pub queue_out: VecDeque<PacketS>,
+    use_bincode: bool,
+}
+
+impl Network {
+    pub fn connect(addr: &str) -> Result<Self> {
+        let (parts, _) = addr.into_client_request().unwrap().into_parts();
+        let mut builder = Request::builder()
+            .uri(parts.uri.clone().clone())
+            .method(parts.method.clone())
+            .version(parts.version);
+        *builder.headers_mut().unwrap() = parts.headers.clone();
+        let request = builder.body(()).unwrap();
+
+        let host = request.uri().host().unwrap();
+        let host = if host.starts_with('[') {
+            &host[1..host.len() - 1]
+        } else {
+            host
+        };
+        let port = request
+            .uri()
+            .port_u16()
+            .unwrap_or(match uri_mode(request.uri())? {
+                Mode::Plain => 27032,
+                Mode::Tls => 443,
+            });
+
+        info!("Connecting: host={host:?} port={port}");
+        let stream = TcpStream::connect((host, port))?;
+        stream.set_nodelay(true).unwrap();
+
+        let (mut sock, _) = client_tls_with_config(request, stream, None, None).unwrap();
+
+        match sock.get_mut() {
+            MaybeTlsStream::Plain(s) => s.set_nonblocking(true).unwrap(),
+            MaybeTlsStream::Rustls(s) => s.sock.set_nonblocking(true).unwrap(),
+            _ => todo!(),
+        };
+
+        info!("Handshake complete.");
+        Ok(Self {
+            sock,
+            use_bincode: false,
+            queue_in: VecDeque::new(),
+            queue_out: VecDeque::new(),
+        })
+    }
+
+    pub fn poll(&mut self) {
+        loop {
+            self.queue_in.extend(match self.sock.read() {
+                Ok(Message::Text(packet)) => match serde_json::from_str(&packet) {
+                    Ok(packet) => {
+                        debug!("<- {packet:?}");
+                        if let PacketC::Version {
+                            minor,
+                            major,
+                            supports_bincode,
+                        } = &packet
+                        {
+                            if *minor == VERSION.0 && *major == VERSION.1 && *supports_bincode {
+                                info!("Binary protocol format enabled.");
+                                self.use_bincode = true;
+                            }
+                        }
+                        Some(packet)
+                    }
+                    Err(e) => {
+                        warn!("invalid json packet: {e:?}");
+                        None
+                    }
+                },
+                Ok(Message::Binary(packet)) => {
+                    match bincode::decode_from_slice(&packet, BINCODE_CONFIG) {
+                        Ok((packet, _)) => {
+                            debug!("<- {packet:?}");
+                            Some(packet)
+                        }
+                        Err(e) => {
+                            warn!("invalid bincode packet: {e:?}");
+                            None
+                        }
+                    }
+                }
+                Ok(_) => None,
+                Err(e) => {
+                    if let Some(e) = e.into_non_blocking() {
+                        warn!("{e:?}");
+                        None
+                    } else {
+                        break;
+                    }
+                }
+            });
+        }
+
+        for packet in self.queue_out.drain(..) {
+            debug!("-> {packet:?}");
+            if self.use_bincode {
+                self.sock
+                    .write(Message::Binary(
+                        bincode::encode_to_vec(&packet, BINCODE_CONFIG).unwrap(),
+                    ))
+                    .unwrap();
+            } else {
+                self.sock
+                    .write(Message::Text(serde_json::to_string(&packet).unwrap()))
+                    .unwrap();
+            }
+        }
+
+        self.sock.flush().unwrap();
+    }
+}