From 83dc773b1058034e6a18386af0acba741b254d69 Mon Sep 17 00:00:00 2001 From: quexeky Date: Tue, 9 Sep 2025 16:13:16 +1000 Subject: [PATCH] chore: Remove unwraps from auth.rs Signed-off-by: quexeky --- src-tauri/src/remote/auth.rs | 59 ++++++++++++++------------ src-tauri/src/remote/commands.rs | 11 ++--- src-tauri/src/remote/fetch_object.rs | 6 +-- src-tauri/src/remote/server_proto.rs | 31 ++++++++------ src-tauri/src/utils/app_emit.rs | 9 +--- src-tauri/src/utils/mod.rs | 1 + src-tauri/src/utils/webbrowser_open.rs | 7 +++ 7 files changed, 67 insertions(+), 57 deletions(-) create mode 100644 src-tauri/src/utils/webbrowser_open.rs diff --git a/src-tauri/src/remote/auth.rs b/src-tauri/src/remote/auth.rs index 8963029..9d97921 100644 --- a/src-tauri/src/remote/auth.rs +++ b/src-tauri/src/remote/auth.rs @@ -12,7 +12,10 @@ use crate::{ app_emit, database::{ db::{borrow_db_checked, borrow_db_mut_checked}, models::data::DatabaseAuth, - }, error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError}, remote::{requests::make_authenticated_get, utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC}}, AppState, AppStatus, User + }, error::{drop_server_error::DropServerError, remote_access_error::RemoteAccessError}, remote::{ + requests::make_authenticated_get, + utils::{DROP_CLIENT_ASYNC, DROP_CLIENT_SYNC}, + }, state_lock, AppState, AppStatus, User }; use super::{ @@ -51,12 +54,13 @@ struct HandshakeResponse { pub fn generate_authorization_header() -> String { let certs = { let db = borrow_db_checked(); - db.auth.clone().unwrap() + db.auth.clone().expect("Authorisation not initialised") }; let nonce = Utc::now().timestamp_millis().to_string(); - let signature = sign_nonce(certs.private, nonce.clone()).unwrap(); + let signature = + sign_nonce(certs.private, nonce.clone()).expect("Failed to generate authorisation header"); format!("Nonce {} {} {}", certs.client_id, nonce, signature) } @@ -94,11 +98,15 @@ async fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), Re Url::parse(handle.base_url.as_str())? }; - let client_id = path_chunks.get(1).unwrap(); - let token = path_chunks.get(2).unwrap(); + let client_id = path_chunks + .get(1) + .expect("Failed to get client id from path chunks"); + let token = path_chunks + .get(2) + .expect("Failed to get token from path chunks"); let body = HandshakeRequestBody { - client_id: (*client_id).to_string(), - token: (*token).to_string(), + client_id: (client_id).to_string(), + token: (token).to_string(), }; let endpoint = base_url.join("/api/v1/client/auth/handshake")?; @@ -110,31 +118,24 @@ async fn recieve_handshake_logic(app: &AppHandle, path: String) -> Result<(), Re } let response_struct: HandshakeResponse = response.json().await?; - { - let mut handle = borrow_db_mut_checked(); - handle.auth = Some(DatabaseAuth { - private: response_struct.private, - cert: response_struct.certificate, - client_id: response_struct.id, - web_token: None, // gets created later - }); - } - let web_token = { let header = generate_authorization_header(); let token = client - .post(base_url.join("/api/v1/client/user/webtoken").unwrap()) + .post(base_url.join("/api/v1/client/user/webtoken")?) .header("Authorization", header) .send() - .await - .unwrap(); + .await?; - token.text().await.unwrap() + token.text().await? }; let mut handle = borrow_db_mut_checked(); - let mut_auth = handle.auth.as_mut().unwrap(); - mut_auth.web_token = Some(web_token); + handle.auth = Some(DatabaseAuth { + private: response_struct.private, + cert: response_struct.certificate, + client_id: response_struct.id, + web_token: Some(web_token), // gets created later + }); Ok(()) } @@ -154,7 +155,7 @@ pub async fn recieve_handshake(app: AppHandle, path: String) { let (app_status, user) = setup().await; - let mut state_lock = app_state.lock().unwrap(); + let mut state_lock = state_lock!(app_state); state_lock.status = app_status; state_lock.user = user; @@ -174,7 +175,7 @@ pub fn auth_initiate_logic(mode: String) -> Result { let endpoint = base_url.join("/api/v1/client/auth/initiate")?; let body = InitiateRequestBody { - name: format!("{} (Desktop)", hostname.into_string().unwrap()), + name: format!("{} (Desktop)", hostname.display()), platform: env::consts::OS.to_string(), capabilities: HashMap::from([ ("peerAPI".to_owned(), CapabilityConfiguration {}), @@ -208,12 +209,14 @@ pub async fn setup() -> (AppStatus, Option) { let user_result = match fetch_user().await { Ok(data) => data, Err(RemoteAccessError::FetchError(_)) => { - let user = get_cached_object::("user").unwrap(); - return (AppStatus::Offline, Some(user)); + let user = get_cached_object::("user").ok(); + return (AppStatus::Offline, user); } Err(_) => return (AppStatus::SignedInNeedsReauth, None), }; - cache_object("user", &user_result).unwrap(); + if let Err(e) = cache_object("user", &user_result) { + warn!("Could not cache user object with error {e}"); + } return (AppStatus::SignedIn, Some(user_result)); } diff --git a/src-tauri/src/remote/commands.rs b/src-tauri/src/remote/commands.rs index 4346aca..43c57a2 100644 --- a/src-tauri/src/remote/commands.rs +++ b/src-tauri/src/remote/commands.rs @@ -12,7 +12,7 @@ use crate::{ auth::generate_authorization_header, requests::generate_url, utils::{DROP_CLIENT_SYNC, DROP_CLIENT_WS_CLIENT}, - }, AppState, AppStatus + }, state_lock, utils::webbrowser_open::webbrowser_open, AppState, AppStatus }; use super::{ @@ -37,7 +37,7 @@ pub fn gen_drop_url(path: String) -> Result { Url::parse(&handle.base_url).map_err(RemoteAccessError::ParsingError)? }; - let url = base_url.join(&path).unwrap(); + let url = base_url.join(&path)?; Ok(url.to_string()) } @@ -74,7 +74,7 @@ pub fn sign_out(app: AppHandle) { // Update app state { let app_state = app.state::>(); - let mut app_state_handle = app_state.lock().unwrap(); + let mut app_state_handle = state_lock!(app_state); app_state_handle.status = AppStatus::SignedOut; app_state_handle.user = None; } @@ -87,7 +87,7 @@ pub fn sign_out(app: AppHandle) { pub async fn retry_connect(state: tauri::State<'_, Mutex>>) -> Result<(), ()> { let (app_status, user) = setup().await; - let mut guard = state.lock().unwrap(); + let mut guard = state_lock!(state); guard.status = app_status; guard.user = user; drop(guard); @@ -106,7 +106,7 @@ pub fn auth_initiate() -> Result<(), RemoteAccessError> { let complete_redir_url = base_url.join(&redir_url)?; debug!("opening web browser to continue authentication"); - webbrowser::open(complete_redir_url.as_ref()).unwrap(); + webbrowser_open(complete_redir_url.as_ref()); Ok(()) } @@ -123,6 +123,7 @@ pub fn auth_initiate_code(app: AppHandle) -> Result { let db_lock = borrow_db_checked(); Url::parse(&db_lock.base_url.clone())? }; + let code = auth_initiate_logic("code".to_string())?; let header_code = code.clone(); diff --git a/src-tauri/src/remote/fetch_object.rs b/src-tauri/src/remote/fetch_object.rs index e3eaa3f..500dc9d 100644 --- a/src-tauri/src/remote/fetch_object.rs +++ b/src-tauri/src/remote/fetch_object.rs @@ -36,7 +36,7 @@ pub async fn fetch_object(request: http::Request>) -> Result { let resp_builder = ResponseBuilder::new().header( CONTENT_TYPE, @@ -59,10 +59,10 @@ pub async fn fetch_object(request: http::Request>) -> Result { - debug!("Object fetch failed with error {}. Attempting to download from cache", e); + debug!("Object fetch failed with error {e}. Attempting to download from cache"); match cache_result { Ok(cache_result) => Ok(cache_result.into()), Err(e) => { diff --git a/src-tauri/src/remote/server_proto.rs b/src-tauri/src/remote/server_proto.rs index c9c65e4..54af4e5 100644 --- a/src-tauri/src/remote/server_proto.rs +++ b/src-tauri/src/remote/server_proto.rs @@ -1,15 +1,15 @@ use std::str::FromStr; use http::{uri::PathAndQuery, Request, Response, StatusCode, Uri}; -use log::warn; +use log::{error, warn}; use tauri::UriSchemeResponder; -use crate::{database::db::borrow_db_checked, remote::utils::DROP_CLIENT_SYNC}; +use crate::{database::db::borrow_db_checked, remote::utils::DROP_CLIENT_SYNC, utils::webbrowser_open::webbrowser_open}; pub async fn handle_server_proto_offline_wrapper(request: Request>, responder: UriSchemeResponder) { responder.respond(match handle_server_proto_offline(request).await { Ok(res) => res, - Err(e) => unreachable!() + Err(_) => unreachable!() }); } @@ -33,9 +33,16 @@ pub async fn handle_server_proto_wrapper(request: Request>, responder: U async fn handle_server_proto(request: Request>) -> Result>, StatusCode> { let db_handle = borrow_db_checked(); - let web_token = match &db_handle.auth.as_ref().unwrap().web_token { - Some(e) => e, - None => return Err(StatusCode::BAD_REQUEST), + let auth = match db_handle.auth.as_ref() { + Some(auth) => auth, + None => { + error!("Could not find auth in database"); + return Err(StatusCode::UNAUTHORIZED) + } + }; + let web_token = match &auth.web_token { + Some(token) => token, + None => return Err(StatusCode::UNAUTHORIZED), }; let remote_uri = db_handle.base_url.parse::().expect("Failed to parse base url"); @@ -46,18 +53,14 @@ async fn handle_server_proto(request: Request>) -> Result Ok(Response::new(Vec::new())), - Err(e) => { - warn!("Could not open web browser to link {new_uri} with error {e}"); - Ok(Response::new(Vec::new())) - } - } + webbrowser_open(new_uri.to_string()); + return Ok(Response::new(Vec::new())) } let client = DROP_CLIENT_SYNC.clone(); diff --git a/src-tauri/src/utils/app_emit.rs b/src-tauri/src/utils/app_emit.rs index c7e4161..0402b2d 100644 --- a/src-tauri/src/utils/app_emit.rs +++ b/src-tauri/src/utils/app_emit.rs @@ -1,11 +1,6 @@ #[macro_export] macro_rules! app_emit { ($app:expr, $event:expr, $p:expr) => { - match $app.emit($event, $p) { - Ok(_) => (), - Err(e) => { - log::error!("Failed to emit event {} with error {}", $event, e); - } - }; + $app.emit($event, $p).expect(&format!("Failed to emit event {}", $event)); }; -} \ No newline at end of file +} diff --git a/src-tauri/src/utils/mod.rs b/src-tauri/src/utils/mod.rs index 80e975b..449be44 100644 --- a/src-tauri/src/utils/mod.rs +++ b/src-tauri/src/utils/mod.rs @@ -1,2 +1,3 @@ mod app_emit; mod state_lock; +pub mod webbrowser_open; diff --git a/src-tauri/src/utils/webbrowser_open.rs b/src-tauri/src/utils/webbrowser_open.rs new file mode 100644 index 0000000..9cbec6c --- /dev/null +++ b/src-tauri/src/utils/webbrowser_open.rs @@ -0,0 +1,7 @@ +use log::warn; + +pub fn webbrowser_open>(url: T) { + if let Err(e) = webbrowser::open(url.as_ref()) { + warn!("Could not open web browser to url {} with error {}", url.as_ref(), e); + }; +} \ No newline at end of file