diff --git a/.changes/persist-cookies.md b/.changes/persist-cookies.md new file mode 100644 index 000000000..7160fb7b2 --- /dev/null +++ b/.changes/persist-cookies.md @@ -0,0 +1,7 @@ +--- +"http": "patch" +"http-js": "patch" +--- + +Persist cookies to disk and load it on next app start. + diff --git a/Cargo.lock b/Cargo.lock index 144ee6ab6..a7bc742c4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6620,6 +6620,8 @@ dependencies = [ name = "tauri-plugin-http" version = "2.0.4" dependencies = [ + "bytes", + "cookie_store", "data-url", "http", "regex", diff --git a/plugins/http/Cargo.toml b/plugins/http/Cargo.toml index e4303f196..c88dc77c7 100644 --- a/plugins/http/Cargo.toml +++ b/plugins/http/Cargo.toml @@ -41,6 +41,8 @@ http = "1" reqwest = { version = "0.12", default-features = false } url = { workspace = true } data-url = "0.3" +cookie_store = { version = "0.21.1", optional = true, features = ["serde"] } +bytes = { version = "1.9", optional = true } tracing = { workspace = true, optional = true } [features] @@ -62,7 +64,7 @@ rustls-tls-manual-roots = ["reqwest/rustls-tls-manual-roots"] rustls-tls-webpki-roots = ["reqwest/rustls-tls-webpki-roots"] rustls-tls-native-roots = ["reqwest/rustls-tls-native-roots"] blocking = ["reqwest/blocking"] -cookies = ["reqwest/cookies"] +cookies = ["reqwest/cookies", "dep:cookie_store", "dep:bytes"] gzip = ["reqwest/gzip"] brotli = ["reqwest/brotli"] deflate = ["reqwest/deflate"] diff --git a/plugins/http/src/lib.rs b/plugins/http/src/lib.rs index d775760cd..131d10d45 100644 --- a/plugins/http/src/lib.rs +++ b/plugins/http/src/lib.rs @@ -14,25 +14,68 @@ pub use error::{Error, Result}; mod commands; mod error; +#[cfg(feature = "cookies")] +mod reqwest_cookie_store; mod scope; pub(crate) struct Http { #[cfg(feature = "cookies")] - cookies_jar: std::sync::Arc, + cookies_jar_path: std::path::PathBuf, + #[cfg(feature = "cookies")] + cookies_jar: std::sync::Arc, } pub fn init() -> TauriPlugin { Builder::::new("http") .setup(|app, _| { + #[cfg(feature = "cookies")] + let (cookies_jar_path, cookies_jar) = { + use crate::reqwest_cookie_store::*; + use std::fs::File; + use std::io::BufReader; + use std::sync::Arc; + + let cache_dir = app.path().app_cache_dir()?; + std::fs::create_dir_all(&cache_dir)?; + + let path = cache_dir.join("Cookies"); + let file = File::options() + .create(true) + .append(true) + .read(true) + .open(&path)?; + + let reader = BufReader::new(file); + let store = CookieStoreMutex::load(reader).map_err(|e| e.to_string())?; + + (path, Arc::new(store)) + }; + let state = Http { #[cfg(feature = "cookies")] - cookies_jar: std::sync::Arc::new(reqwest::cookie::Jar::default()), + cookies_jar_path, + #[cfg(feature = "cookies")] + cookies_jar, }; app.manage(state); Ok(()) }) + .on_event(|app, event| { + #[cfg(feature = "cookies")] + if let tauri::RunEvent::Exit = event { + use std::fs::File; + use std::io::BufWriter; + + let state = app.state::(); + + if let Ok(file) = File::create(&state.cookies_jar_path) { + let mut writer = BufWriter::new(file); + let _ = state.cookies_jar.save(&mut writer); + } + } + }) .invoke_handler(tauri::generate_handler![ commands::fetch, commands::fetch_cancel, diff --git a/plugins/http/src/reqwest_cookie_store.rs b/plugins/http/src/reqwest_cookie_store.rs new file mode 100644 index 000000000..dab24cfe4 --- /dev/null +++ b/plugins/http/src/reqwest_cookie_store.rs @@ -0,0 +1,87 @@ +// Copyright 2019-2023 Tauri Programme within The Commons Conservancy +// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: MIT + +// taken from https://github.com/pfernie/reqwest_cookie_store/blob/2ec4afabcd55e24d3afe3f0626ee6dc97bed938d/src/lib.rs + +use std::sync::{Mutex, MutexGuard, PoisonError}; + +use cookie_store::{CookieStore, RawCookie, RawCookieParseError}; +use reqwest::header::HeaderValue; +use serde::{Deserialize, Serialize}; + +fn set_cookies( + cookie_store: &mut CookieStore, + cookie_headers: &mut dyn Iterator, + url: &url::Url, +) { + let cookies = cookie_headers.filter_map(|val| { + std::str::from_utf8(val.as_bytes()) + .map_err(RawCookieParseError::from) + .and_then(RawCookie::parse) + .map(|c| c.into_owned()) + .ok() + }); + cookie_store.store_response_cookies(cookies, url); +} + +fn cookies(cookie_store: &CookieStore, url: &url::Url) -> Option { + let s = cookie_store + .get_request_values(url) + .map(|(name, value)| format!("{}={}", name, value)) + .collect::>() + .join("; "); + + if s.is_empty() { + return None; + } + + HeaderValue::from_maybe_shared(bytes::Bytes::from(s)).ok() +} + +/// A [`cookie_store::CookieStore`] wrapped internally by a [`std::sync::Mutex`], suitable for use in +/// async/concurrent contexts. +#[derive(Debug, Serialize, Deserialize)] +pub struct CookieStoreMutex(Mutex); + +impl Default for CookieStoreMutex { + /// Create a new, empty [`CookieStoreMutex`] + fn default() -> Self { + CookieStoreMutex::new(CookieStore::default()) + } +} + +impl CookieStoreMutex { + /// Create a new [`CookieStoreMutex`] from an existing [`cookie_store::CookieStore`]. + pub const fn new(cookie_store: CookieStore) -> CookieStoreMutex { + CookieStoreMutex(Mutex::new(cookie_store)) + } + + /// Lock and get a handle to the contained [`cookie_store::CookieStore`]. + pub fn lock( + &self, + ) -> Result, PoisonError>> { + self.0.lock() + } + + pub fn load(reader: R) -> cookie_store::Result { + cookie_store::serde::load(reader, |c| serde_json::from_str(c)).map(CookieStoreMutex::new) + } + + pub fn save(&self, writer: &mut W) -> cookie_store::Result<()> { + let store = self.lock().expect("poisoned cookie jar mutex"); + cookie_store::serde::save(&store, writer, serde_json::to_string) + } +} + +impl reqwest::cookie::CookieStore for CookieStoreMutex { + fn set_cookies(&self, cookie_headers: &mut dyn Iterator, url: &url::Url) { + let mut store = self.0.lock().unwrap(); + set_cookies(&mut store, cookie_headers, url); + } + + fn cookies(&self, url: &url::Url) -> Option { + let store = self.0.lock().unwrap(); + cookies(&store, url) + } +}