use std::collections::{BTreeSet, HashMap};
use std::fs;
use std::path::Path;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, OnceLock, RwLock};
use std::time::{SystemTime, UNIX_EPOCH};
use crate::error::{Aria2Error, Result};
use crate::http::ns_cookie_parser::NsCookieParser;
use crate::http::sqlite_cookie_parser::{Sqlite3CookieParser, is_sqlite_file};
use super::Cookie;
pub const DOMAIN_EVICTION_TRIGGER: usize = 2000;
pub const DOMAIN_EVICTION_RATE: f64 = 0.1;
#[derive(Debug)]
struct DomainBucket {
cookies: Vec<Cookie>,
}
impl DomainBucket {
fn new() -> Self {
Self {
cookies: Vec::new(),
}
}
}
pub struct CookieStorage {
domains: RwLock<HashMap<String, DomainBucket>>,
lru_tracker: RwLock<BTreeSet<(u64, String)>>,
lru_seq: AtomicU64,
}
static SHARED_COOKIE_STORAGE: OnceLock<Arc<CookieStorage>> = OnceLock::new();
impl CookieStorage {
pub fn shared() -> Arc<Self> {
Arc::clone(SHARED_COOKIE_STORAGE.get_or_init(|| Arc::new(Self::new())))
}
pub fn new() -> Self {
Self {
domains: RwLock::new(HashMap::new()),
lru_tracker: RwLock::new(BTreeSet::new()),
lru_seq: AtomicU64::new(1),
}
}
fn next_lru_seq(&self) -> u64 {
self.lru_seq.fetch_add(1, Ordering::Relaxed)
}
pub fn add(&self, cookie: Cookie) {
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs() as i64;
self.evict_domains_if_needed();
let domain = cookie.domain.clone();
let mut domains = self.domains.write().unwrap_or_else(|e| e.into_inner());
if !domains.contains_key(&domain) {
domains.insert(domain.clone(), DomainBucket::new());
}
let bucket = domains.get_mut(&domain).unwrap();
if let Some(pos) = bucket.cookies.iter().position(|c| c == &cookie) {
if cookie.is_delete_cookie() {
bucket.cookies.remove(pos);
if bucket.cookies.is_empty() {
self.remove_from_lru(&domain);
domains.remove(&domain);
} else {
self.update_lru(&domain);
}
return;
}
let mut updated = cookie;
updated.creation_time = bucket.cookies[pos].creation_time;
bucket.cookies[pos] = updated;
self.update_lru(&domain);
return;
}
if cookie.is_delete_cookie() {
if bucket.cookies.is_empty() {
self.remove_from_lru(&domain);
domains.remove(&domain);
}
return;
}
if bucket.cookies.len() >= Cookie::max_cookie_per_domain() {
let before = bucket.cookies.len();
bucket.cookies.retain(|c| !c.is_expired(now));
if bucket.cookies.len() == before {
if let Some(lru_pos) = bucket
.cookies
.iter()
.enumerate()
.min_by_key(|(_, c)| c.last_access_time)
.map(|(i, _)| i)
{
bucket.cookies[lru_pos] = cookie;
self.update_lru(&domain);
return;
}
}
}
bucket.cookies.push(cookie);
self.update_lru(&domain);
}
fn evict_domains_if_needed(&self) {
let lru = self.lru_tracker.read().unwrap_or_else(|e| e.into_inner());
if lru.len() < DOMAIN_EVICTION_TRIGGER {
return;
}
drop(lru);
let lru = self.lru_tracker.read().unwrap_or_else(|e| e.into_inner());
let delnum = (lru.len() as f64 * DOMAIN_EVICTION_RATE) as usize;
drop(lru);
if delnum == 0 {
return;
}
self.evict_domains(delnum);
}
fn evict_domains(&self, delnum: usize) {
let mut lru = self.lru_tracker.write().unwrap_or_else(|e| e.into_inner());
let mut domains = self.domains.write().unwrap_or_else(|e| e.into_inner());
let mut evicted = 0;
while evicted < delnum {
let front = match lru.iter().next().cloned() {
Some(entry) => entry,
None => break,
};
lru.remove(&front);
let domain = &front.1;
domains.remove(domain);
evicted += 1;
}
}
fn update_lru(&self, domain: &str) {
let seq = self.next_lru_seq();
let mut lru = self.lru_tracker.write().unwrap_or_else(|e| e.into_inner());
if let Some(old) = lru.iter().find(|(_, d)| d == domain).cloned() {
lru.remove(&old);
}
lru.insert((seq, domain.to_string()));
}
fn remove_from_lru(&self, domain: &str) {
let mut lru = self.lru_tracker.write().unwrap_or_else(|e| e.into_inner());
if let Some(old) = lru.iter().find(|(_, d)| d == domain).cloned() {
lru.remove(&old);
}
}
pub fn find_cookies(
&self,
host: &str,
path: &str,
secure: bool,
is_cross_site: bool,
) -> Vec<Cookie> {
let date = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs() as i64;
let domains = self.domains.read().unwrap_or_else(|e| e.into_inner());
let mut matching: Vec<Cookie> = Vec::new();
let mut accessed_domains: Vec<String> = Vec::new();
for (domain_key, bucket) in domains.iter() {
let mut domain_accessed = false;
for c in &bucket.cookies {
if c.match_request(host, path, date, secure, is_cross_site) {
matching.push(c.clone());
domain_accessed = true;
}
}
if domain_accessed {
accessed_domains.push(domain_key.clone());
}
}
drop(domains);
{
let mut domains = self.domains.write().unwrap_or_else(|e| e.into_inner());
for domain_key in &accessed_domains {
if let Some(bucket) = domains.get_mut(domain_key) {
for c in &mut bucket.cookies {
if c.match_request(host, path, date, secure, is_cross_site) {
c.last_access_time = date;
}
}
}
}
}
for domain_key in &accessed_domains {
self.update_lru(domain_key);
}
matching.sort_by(|a, b| {
let depth_a = a.path.matches('/').count();
let depth_b = b.path.matches('/').count();
depth_b
.cmp(&depth_a)
.then_with(|| a.creation_time.cmp(&b.creation_time))
});
matching
}
pub fn find_cookies_for_url(&self, url: &reqwest::Url) -> Vec<Cookie> {
self.find_cookies_for_url_with_context(url, false)
}
pub fn find_cookies_for_url_with_context(
&self,
url: &reqwest::Url,
is_cross_site: bool,
) -> Vec<Cookie> {
let host = url.host_str().unwrap_or("");
let path = url.path();
let scheme = url.scheme();
let secure = scheme == "https";
self.find_cookies(host, path, secure, is_cross_site)
}
pub fn expire_cookies(&self, base_time: i64) -> usize {
let mut domains = self.domains.write().unwrap_or_else(|e| e.into_inner());
let mut removed_total = 0;
let mut empty_domains: Vec<String> = Vec::new();
for (domain_key, bucket) in domains.iter_mut() {
let before = bucket.cookies.len();
bucket.cookies.retain(|c| !c.is_expired(base_time));
removed_total += before - bucket.cookies.len();
if bucket.cookies.is_empty() {
empty_domains.push(domain_key.clone());
}
}
for domain_key in &empty_domains {
self.remove_from_lru(domain_key);
}
for domain_key in &empty_domains {
domains.remove(domain_key);
}
removed_total
}
pub fn count(&self) -> usize {
let domains = self.domains.read().unwrap_or_else(|e| e.into_inner());
domains.values().map(|b| b.cookies.len()).sum()
}
pub fn domain_count(&self) -> usize {
self.lru_tracker
.read()
.unwrap_or_else(|e| e.into_inner())
.len()
}
pub fn contains(&self, cookie: &Cookie) -> bool {
let domains = self.domains.read().unwrap_or_else(|e| e.into_inner());
if let Some(bucket) = domains.get(&cookie.domain) {
return bucket.cookies.iter().any(|c| c == cookie);
}
false
}
pub fn load_file(&self, path: &Path) -> Result<usize> {
let bytes = fs::read(path).map_err(|e| Aria2Error::Io(e.to_string()))?;
let parsed = if is_sqlite_file(&bytes) {
Sqlite3CookieParser::parse_auto(path)?
} else {
let text = String::from_utf8_lossy(&bytes);
NsCookieParser::parse_str(&text)?
};
let n = parsed.len();
for cookie in parsed {
self.add(cookie);
}
Ok(n)
}
pub fn save_file(&self, path: &Path) -> Result<()> {
let temp_path = {
let mut p = path.to_path_buf();
p.set_extension("tmp");
p
};
{
let domains = self.domains.read().unwrap_or_else(|e| e.into_inner());
let lru = self.lru_tracker.read().unwrap_or_else(|e| e.into_inner());
let mut lines = Vec::with_capacity(self.count() + 3);
lines.push("# Netscape HTTP Cookie File".to_string());
lines.push("# This file is generated by aria2-rust".to_string());
for (_, domain_key) in lru.iter() {
if let Some(bucket) = domains.get(domain_key) {
for c in &bucket.cookies {
lines.push(c.to_netscape_line());
}
}
}
fs::write(&temp_path, lines.join("\n")).map_err(|e| Aria2Error::Io(e.to_string()))?;
}
fs::rename(&temp_path, path).map_err(|e| Aria2Error::Io(e.to_string()))?;
Ok(())
}
pub fn clear(&self) {
self.domains
.write()
.unwrap_or_else(|e| e.into_inner())
.clear();
self.lru_tracker
.write()
.unwrap_or_else(|e| e.into_inner())
.clear();
}
pub fn to_header_string(&self, host: &str, path: &str, secure: bool) -> String {
self.to_header_string_with_context(host, path, secure, false)
}
pub fn to_header_string_with_context(
&self,
host: &str,
path: &str,
secure: bool,
is_cross_site: bool,
) -> String {
let cookies = self.find_cookies(host, path, secure, is_cross_site);
if cookies.is_empty() {
return String::new();
}
cookies
.iter()
.map(|c| format!("{}={}", c.name, c.value))
.collect::<Vec<_>>()
.join("; ")
}
pub fn is_empty(&self) -> bool {
self.domains
.read()
.unwrap_or_else(|e| e.into_inner())
.is_empty()
}
pub fn parse_and_store(
&self,
set_cookie_string: &str,
request_host: &str,
request_path: &str,
) -> bool {
let default_path = Cookie::default_path(request_path);
let cookie =
match Cookie::from_set_cookie_header(set_cookie_string, request_host, &default_path) {
Some(c) => c,
None => return false,
};
if cookie.is_delete_cookie() {
let mut domains = self.domains.write().unwrap_or_else(|e| e.into_inner());
if let Some(bucket) = domains.get_mut(&cookie.domain)
&& let Some(pos) = bucket.cookies.iter().position(|c| c == &cookie)
{
bucket.cookies.remove(pos);
if bucket.cookies.is_empty() {
let domain = cookie.domain.clone();
drop(domains);
self.remove_from_lru(&domain);
self.domains
.write()
.unwrap_or_else(|e| e.into_inner())
.remove(&domain);
}
return false; }
return false;
}
self.add(cookie);
true
}
pub fn evict_domains_for_test(&self, delnum: usize) {
self.evict_domains(delnum);
}
}
impl Default for CookieStorage {
fn default() -> Self {
CookieStorage::new()
}
}