From 035b4f919555197d41718cefacb9279a84990c6a Mon Sep 17 00:00:00 2001
From: Vecna <vvecna@uwaterloo.ca>
Date: Sun, 5 Feb 2023 21:26:13 -0500
Subject: [PATCH] Work on lox_auth handling requests

(Client side still needs to be implemented)
---
 Cargo.toml          |  1 +
 src/bin/bridgedb.rs |  8 +++----
 src/bin/lox_auth.rs | 55 ++++++++++++++++++++++++++++++++++++++++-----
 src/request_type.rs | 29 ++++++++++++++++++++++++
 4 files changed, 82 insertions(+), 11 deletions(-)
 create mode 100644 src/request_type.rs

diff --git a/Cargo.toml b/Cargo.toml
index 0fff586..e88ec6d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2021"
 lox = { git = "https://git-crysp.uwaterloo.ca/iang/lox.git", branch = "vvecna/lox_test" }
 ed25519-dalek = { version = "1", features = ["serde"] }
 serde = "1"
+bincode = "1"
 serde_json = "1.0"
 # TODO: reduce feature set to just the ones needed
 tokio = { version = "1.20", features = ["full"] }
diff --git a/src/bin/bridgedb.rs b/src/bin/bridgedb.rs
index 577c59f..4b19adb 100644
--- a/src/bin/bridgedb.rs
+++ b/src/bin/bridgedb.rs
@@ -49,13 +49,11 @@ async fn main() {
         .expect("Failed to write to bridgedb pubkey file");
     }
 
-    let mut cmd_lambda = |cmd: Vec<u8>| perform_command(cmd, &bridgedb);
-
-    listen(addr, &mut cmd_lambda).await;
+    listen(addr, &mut |request: Vec<u8>| handle_request(request, &mut bridgedb)).await;
 }
 
-fn perform_command(cmd: Vec<u8>, bridgedb: &BridgeDb) -> Vec<u8> {
-    if cmd[0] == 1 {
+fn handle_request(request: Vec<u8>, bridgedb: &mut BridgeDb) -> Vec<u8> {
+    if request[0] == 1 {
         // note, the bridgedb currently has no buckets
         return bridgedb.invite().to_vec();
     }
diff --git a/src/bin/lox_auth.rs b/src/bin/lox_auth.rs
index 3ab52c6..2b34085 100644
--- a/src/bin/lox_auth.rs
+++ b/src/bin/lox_auth.rs
@@ -3,7 +3,12 @@
 mod server_net;
 use crate::server_net::listen;
 
+#[path = "../request_type.rs"]
+mod request_type;
+use crate::request_type::RequestType;
+
 use lox::BridgeAuth;
+use lox::proto::*;
 use std::env::args;
 use std::fs::File;
 use std::io::Write;
@@ -65,12 +70,50 @@ async fn main() {
         .expect("Failed to write to lox_auth pubkeys file");
     }
 
-    let mut cmd_lambda = |cmd: Vec<u8>| perform_command(cmd, &lox_auth);
-
-    listen(addr, &mut cmd_lambda).await;
+    listen(addr, &mut |request: Vec<u8>| handle_request(request, &mut lox_auth)).await;
 }
 
-fn perform_command(cmd: Vec<u8>, lox_auth: &BridgeAuth) -> Vec<u8> {
-    // just send something back for now
-    "ACK".into()
+fn handle_request(request: Vec<u8>, lox_auth: &mut BridgeAuth) -> Vec<u8> {
+    match RequestType::try_from(request[0]).unwrap() {
+        RequestType::BlockageMigration => {
+            let decoded: blockage_migration::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_blockage_migration(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::CheckBlockage => {
+            let decoded: check_blockage::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_check_blockage(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::IssueInvite => {
+            let decoded: issue_invite::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_issue_invite(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::LevelUp => {
+            let decoded: level_up::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_level_up(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::Migration => {
+            let decoded: migration::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_migration(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::OpenInvite => {
+            let decoded: open_invite::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_open_invite(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::RedeemInvite => {
+            let decoded: redeem_invite::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_redeem_invite(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+        RequestType::TrustPromotion => {
+            let decoded: trust_promotion::Request = bincode::deserialize(&request[1..]).unwrap();
+            let resp = lox_auth.handle_trust_promotion(decoded).unwrap();
+            bincode::serialize(&resp).unwrap()
+        },
+    }
 }
diff --git a/src/request_type.rs b/src/request_type.rs
new file mode 100644
index 0000000..1a7e993
--- /dev/null
+++ b/src/request_type.rs
@@ -0,0 +1,29 @@
+/*! Types of requests we might encounter. */
+pub enum RequestType {
+    BlockageMigration,
+    CheckBlockage,
+    IssueInvite,
+    LevelUp,
+    Migration,
+    OpenInvite,
+    RedeemInvite,
+    TrustPromotion,
+}
+
+impl TryFrom<u8> for RequestType {
+    type Error = &'static str;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(RequestType::BlockageMigration),
+            2 => Ok(RequestType::CheckBlockage),
+            3 => Ok(RequestType::IssueInvite),
+            4 => Ok(RequestType::LevelUp),
+            5 => Ok(RequestType::Migration),
+            6 => Ok(RequestType::OpenInvite),
+            7 => Ok(RequestType::RedeemInvite),
+            8 => Ok(RequestType::TrustPromotion),
+            _ => Err("Byte given does not represent a valid request type."),
+        }
+    }
+}