231 lines
8.2 KiB
Rust
231 lines
8.2 KiB
Rust
 
|
//! The disposable cache store, `cache.sqlite`.
|
||
|
|
//!
|
||
|
|
//! Everything here is recoverable. A missing cache is recreated, a corrupt one
|
||
|
|
//! is thrown away and recreated, and a stale one is simply wrong data that the
|
||
|
|
//! rest of the system is expected to tolerate.
|
||
|
|
//!
|
||
|
|
//! Crucially, a stale cache never bypasses identity or network authentication:
|
||
|
|
//! cached hints only produce *candidates*, which still have to pass the
|
||
|
|
//! handshake.
|
||
|
|
|
||
|
|
use std::path::{Path, PathBuf};
|
||
|
|
|
||
|
|
use rusqlite::{Connection, params};
|
||
|
|
|
||
|
|
use crate::error::{Error, Result};
|
||
|
|
use crate::identity::NetworkId;
|
||
|
|
|
||
|
|
/// Schema version written by this build.
|
||
|
|
pub const SCHEMA_VERSION: i64 = 1;
|
||
|
|
|
||
|
|
/// A cached address hint for one peer in one network.
|
||
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
|
|
pub struct AddressHint {
|
||
|
|
/// Network the hint belongs to.
|
||
|
|
pub network_id: NetworkId,
|
||
|
|
/// Peer endpoint id, 32 bytes.
|
||
|
|
pub endpoint_id: [u8; 32],
|
||
|
|
/// Serialised address, currently `ip:<socketaddr>` or `relay:<url>`.
|
||
|
|
pub addr: String,
|
||
|
|
/// Unix seconds when this hint was last confirmed.
|
||
|
|
pub last_seen: i64,
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Why the cache had to be recreated, if it did.
|
||
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
|
|
pub enum CacheOutcome {
|
||
|
|
/// Opened normally.
|
||
|
|
Opened,
|
||
|
|
/// Created because nothing was there.
|
||
|
|
Created,
|
||
|
|
/// Discarded and recreated. The reason is free of secrets.
|
||
|
|
Reset(String),
|
||
|
|
}
|
||
|
|
|
||
|
|
/// The disposable cache store.
|
||
|
|
#[derive(Debug)]
|
||
|
|
pub struct CacheStore {
|
||
|
|
conn: Connection,
|
||
|
|
path: PathBuf,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl CacheStore {
|
||
|
|
/// Opens the cache, discarding and recreating it if it is unusable.
|
||
|
|
pub fn open_or_reset(path: impl AsRef<Path>) -> Result<(Self, CacheOutcome)> {
|
||
|
|
let path = path.as_ref().to_path_buf();
|
||
|
|
let existed = path.exists();
|
||
|
|
|
||
|
|
match Self::try_open(&path, existed) {
|
||
|
|
Ok(store) => Ok((
|
||
|
|
store,
|
||
|
|
if existed {
|
||
|
|
CacheOutcome::Opened
|
||
|
|
} else {
|
||
|
|
CacheOutcome::Created
|
||
|
|
},
|
||
|
|
)),
|
||
|
|
Err(reason) => {
|
||
|
|
tracing::warn!(path = %path.display(), %reason, "discarding unusable cache");
|
||
|
|
Self::remove_files(&path);
|
||
|
|
let store = Self::try_open(&path, false)
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot recreate cache: {err}")))?;
|
||
|
|
Ok((store, CacheOutcome::Reset(reason)))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn try_open(path: &Path, check_integrity: bool) -> std::result::Result<Self, String> {
|
||
|
|
if let Some(parent) = path.parent() {
|
||
|
|
std::fs::create_dir_all(parent)
|
||
|
|
.map_err(|err| format!("cannot create cache directory: {err}"))?;
|
||
|
|
}
|
||
|
|
let conn = Connection::open(path).map_err(|err| format!("cannot open: {err}"))?;
|
||
|
|
super::restrict_path_permissions(path).map_err(|err| format!("{err}"))?;
|
||
|
|
super::apply_common_pragmas(&conn).map_err(|err| format!("cannot configure: {err}"))?;
|
||
|
|
|
||
|
|
if check_integrity {
|
||
|
|
let integrity: String = conn
|
||
|
|
.query_row("PRAGMA integrity_check", [], |row| row.get(0))
|
||
|
|
.map_err(|err| format!("integrity check failed: {err}"))?;
|
||
|
|
if integrity != "ok" {
|
||
|
|
return Err(format!("integrity check reported: {integrity}"));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let found: i64 = conn
|
||
|
|
.query_row("PRAGMA user_version", [], |row| row.get(0))
|
||
|
|
.map_err(|err| format!("cannot read schema version: {err}"))?;
|
||
|
|
if found > SCHEMA_VERSION {
|
||
|
|
return Err(format!(
|
||
|
|
"cache schema version {found} is newer than {SCHEMA_VERSION}"
|
||
|
|
));
|
||
|
|
}
|
||
|
|
if found < SCHEMA_VERSION {
|
||
|
|
conn.execute_batch(
|
||
|
|
"BEGIN;
|
||
|
|
DROP TABLE IF EXISTS address_hints;
|
||
|
|
CREATE TABLE address_hints (
|
||
|
|
network_id BLOB NOT NULL,
|
||
|
|
endpoint_id BLOB NOT NULL,
|
||
|
|
addr TEXT NOT NULL,
|
||
|
|
last_seen INTEGER NOT NULL,
|
||
|
|
PRIMARY KEY (network_id, endpoint_id, addr)
|
||
|
|
);
|
||
|
|
PRAGMA user_version = 1;
|
||
|
|
COMMIT;",
|
||
|
|
)
|
||
|
|
.map_err(|err| format!("cannot create cache schema: {err}"))?;
|
||
|
|
} else {
|
||
|
|
conn.query_row("SELECT count(*) FROM address_hints", [], |row| {
|
||
|
|
row.get::<_, i64>(0)
|
||
|
|
})
|
||
|
|
.map_err(|err| format!("cache schema is unusable: {err}"))?;
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(Self {
|
||
|
|
conn,
|
||
|
|
path: path.to_path_buf(),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
fn remove_files(path: &Path) {
|
||
|
|
for suffix in ["", "-wal", "-shm", "-journal"] {
|
||
|
|
let mut name = path.as_os_str().to_os_string();
|
||
|
|
name.push(suffix);
|
||
|
|
let _ = std::fs::remove_file(PathBuf::from(name));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Path of the underlying file.
|
||
|
|
pub fn path(&self) -> &Path {
|
||
|
|
&self.path
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Records an address hint, keeping at most `max_per_peer` newest entries.
|
||
|
|
pub fn record_hint(
|
||
|
|
&self,
|
||
|
|
network_id: NetworkId,
|
||
|
|
endpoint_id: &[u8; 32],
|
||
|
|
addr: &str,
|
||
|
|
max_per_peer: usize,
|
||
|
|
) -> Result<()> {
|
||
|
|
self.conn
|
||
|
|
.execute(
|
||
|
|
"INSERT INTO address_hints (network_id, endpoint_id, addr, last_seen)
|
||
|
|
VALUES (?1, ?2, ?3, ?4)
|
||
|
|
ON CONFLICT(network_id, endpoint_id, addr)
|
||
|
|
DO UPDATE SET last_seen = excluded.last_seen",
|
||
|
|
params![
|
||
|
|
network_id.as_bytes().as_slice(),
|
||
|
|
endpoint_id.as_slice(),
|
||
|
|
addr,
|
||
|
|
super::state::now_unix()
|
||
|
|
],
|
||
|
|
)
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot record address hint: {err}")))?;
|
||
|
|
|
||
|
|
self.conn
|
||
|
|
.execute(
|
||
|
|
"DELETE FROM address_hints
|
||
|
|
WHERE network_id = ?1 AND endpoint_id = ?2 AND addr NOT IN (
|
||
|
|
SELECT addr FROM address_hints
|
||
|
|
WHERE network_id = ?1 AND endpoint_id = ?2
|
||
|
|
ORDER BY last_seen DESC LIMIT ?3
|
||
|
|
)",
|
||
|
|
params![
|
||
|
|
network_id.as_bytes().as_slice(),
|
||
|
|
endpoint_id.as_slice(),
|
||
|
|
max_per_peer as i64
|
||
|
|
],
|
||
|
|
)
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot prune address hints: {err}")))?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Returns every hint known for a network.
|
||
|
|
pub fn hints_for_network(&self, network_id: NetworkId) -> Result<Vec<AddressHint>> {
|
||
|
|
let mut stmt = self
|
||
|
|
.conn
|
||
|
|
.prepare(
|
||
|
|
"SELECT endpoint_id, addr, last_seen FROM address_hints
|
||
|
|
WHERE network_id = ?1 ORDER BY last_seen DESC",
|
||
|
|
)
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot read address hints: {err}")))?;
|
||
|
|
let rows = stmt
|
||
|
|
.query_map(params![network_id.as_bytes().as_slice()], |row| {
|
||
|
|
let endpoint_id: Vec<u8> = row.get(0)?;
|
||
|
|
let addr: String = row.get(1)?;
|
||
|
|
let last_seen: i64 = row.get(2)?;
|
||
|
|
Ok((endpoint_id, addr, last_seen))
|
||
|
|
})
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot read address hints: {err}")))?;
|
||
|
|
|
||
|
|
let mut out = Vec::new();
|
||
|
|
for row in rows {
|
||
|
|
let (endpoint_id, addr, last_seen) =
|
||
|
|
row.map_err(|err| Error::Storage(format!("cannot read hint row: {err}")))?;
|
||
|
|
// A malformed row in a disposable store is skipped, not fatal.
|
||
|
|
let Ok(endpoint_id) = <[u8; 32]>::try_from(endpoint_id.as_slice()) else {
|
||
|
|
continue;
|
||
|
|
};
|
||
|
|
out.push(AddressHint {
|
||
|
|
network_id,
|
||
|
|
endpoint_id,
|
||
|
|
addr,
|
||
|
|
last_seen,
|
||
|
|
});
|
||
|
|
}
|
||
|
|
Ok(out)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Drops all hints for a network.
|
||
|
|
pub fn forget_network(&self, network_id: NetworkId) -> Result<()> {
|
||
|
|
self.conn
|
||
|
|
.execute(
|
||
|
|
"DELETE FROM address_hints WHERE network_id = ?1",
|
||
|
|
params![network_id.as_bytes().as_slice()],
|
||
|
|
)
|
||
|
|
.map_err(|err| Error::Storage(format!("cannot clear address hints: {err}")))?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|