2081 lines
67 KiB
Rust
2081 lines
67 KiB
Rust
#![allow(clippy::missing_errors_doc)]
|
|
|
|
mod path_validation;
|
|
mod peer;
|
|
|
|
use std::{
|
|
collections::{HashMap, VecDeque},
|
|
net::{IpAddr, SocketAddr},
|
|
path::{Path, PathBuf},
|
|
sync::Arc,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use bytes::BytesMut;
|
|
use if_addrs::{IfAddr, Interface, get_if_addrs};
|
|
use lanspread_db::db::{Game, GameDB, GameFileDescription};
|
|
use lanspread_mdns::{LANSPREAD_SERVICE_TYPE, MdnsAdvertiser, discover_service};
|
|
use lanspread_proto::{Message, Request, Response};
|
|
use s2n_quic::{
|
|
Client as QuicClient,
|
|
Connection,
|
|
Server,
|
|
client::Connect,
|
|
provider::limits::Limits,
|
|
stream::BidirectionalStream,
|
|
};
|
|
use tokio::{
|
|
fs::OpenOptions,
|
|
io::{AsyncSeekExt, AsyncWriteExt},
|
|
sync::{
|
|
RwLock,
|
|
mpsc::{UnboundedReceiver, UnboundedSender},
|
|
},
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
use crate::{
|
|
path_validation::validate_game_file_path,
|
|
peer::{send_game_file_chunk, send_game_file_data},
|
|
};
|
|
|
|
/// Custom error types for peer operations
|
|
#[derive(Debug)]
|
|
pub enum PeerError {
|
|
FileSizeDetermination {
|
|
path: String,
|
|
source: std::io::Error,
|
|
},
|
|
GameDirNotSet,
|
|
Other(eyre::Report),
|
|
}
|
|
|
|
impl std::fmt::Display for PeerError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
PeerError::FileSizeDetermination { path, source } => {
|
|
write!(f, "Failed to determine file size for {path}: {source}")
|
|
}
|
|
PeerError::GameDirNotSet => write!(f, "Game directory not set"),
|
|
PeerError::Other(err) => write!(f, "General error: {err}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for PeerError {
|
|
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
|
|
match self {
|
|
PeerError::FileSizeDetermination { source, .. } => Some(source),
|
|
PeerError::Other(err) => Some(err.root_cause()),
|
|
PeerError::GameDirNotSet => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<eyre::Report> for PeerError {
|
|
fn from(err: eyre::Report) -> Self {
|
|
PeerError::Other(err)
|
|
}
|
|
}
|
|
|
|
/// Initialize and start the peer system
|
|
/// This function replaces the main.rs entry point and allows the peer to be started from other crates
|
|
pub fn start_peer(
|
|
game_dir: String,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
) -> eyre::Result<UnboundedSender<PeerCommand>> {
|
|
log::info!("Starting peer system with game directory: {game_dir}");
|
|
|
|
let (tx_control, rx_control) = tokio::sync::mpsc::unbounded_channel();
|
|
|
|
// Start the peer in a background task
|
|
let tx_control_clone = tx_control.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = run_peer(rx_control, tx_notify_ui).await {
|
|
log::error!("Peer system failed: {e}");
|
|
}
|
|
});
|
|
|
|
// Set the game directory
|
|
tx_control.send(PeerCommand::SetGameDir(game_dir))?;
|
|
|
|
Ok(tx_control_clone)
|
|
}
|
|
|
|
static CERT_PEM: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../cert.pem"));
|
|
static KEY_PEM: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../key.pem"));
|
|
|
|
#[derive(Debug)]
|
|
pub enum PeerEvent {
|
|
ListGames(Vec<Game>),
|
|
GotGameFiles {
|
|
id: String,
|
|
file_descriptions: Vec<GameFileDescription>,
|
|
},
|
|
DownloadGameFilesBegin {
|
|
id: String,
|
|
},
|
|
DownloadGameFilesFinished {
|
|
id: String,
|
|
},
|
|
DownloadGameFilesFailed {
|
|
id: String,
|
|
},
|
|
NoPeersHaveGame {
|
|
id: String,
|
|
},
|
|
PeerConnected(SocketAddr),
|
|
PeerDisconnected(SocketAddr),
|
|
PeerDiscovered(SocketAddr),
|
|
PeerLost(SocketAddr),
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct PeerInfo {
|
|
pub addr: SocketAddr,
|
|
pub last_seen: Instant,
|
|
pub games: HashMap<String, Game>,
|
|
pub files: HashMap<String, Vec<GameFileDescription>>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct PeerGameDB {
|
|
peers: HashMap<SocketAddr, PeerInfo>,
|
|
}
|
|
|
|
impl Default for PeerGameDB {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl PeerGameDB {
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self {
|
|
peers: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
pub fn add_peer(&mut self, addr: SocketAddr) {
|
|
let peer_info = PeerInfo {
|
|
addr,
|
|
last_seen: Instant::now(),
|
|
games: HashMap::new(),
|
|
files: HashMap::new(),
|
|
};
|
|
self.peers.insert(addr, peer_info);
|
|
log::info!("Added peer: {addr}");
|
|
}
|
|
|
|
pub fn remove_peer(&mut self, addr: &SocketAddr) -> Option<PeerInfo> {
|
|
self.peers.remove(addr)
|
|
}
|
|
|
|
pub fn update_peer_games(&mut self, addr: SocketAddr, games: Vec<Game>) {
|
|
if let Some(peer) = self.peers.get_mut(&addr) {
|
|
let mut map = HashMap::with_capacity(games.len());
|
|
for game in games {
|
|
map.insert(game.id.clone(), game);
|
|
}
|
|
peer.games = map;
|
|
peer.last_seen = Instant::now();
|
|
log::info!("Updated games for peer: {addr}");
|
|
}
|
|
}
|
|
|
|
pub fn update_peer_game_files(
|
|
&mut self,
|
|
addr: SocketAddr,
|
|
game_id: &str,
|
|
files: Vec<GameFileDescription>,
|
|
) {
|
|
if let Some(peer) = self.peers.get_mut(&addr) {
|
|
peer.files.insert(game_id.to_string(), files);
|
|
peer.last_seen = Instant::now();
|
|
}
|
|
}
|
|
|
|
pub fn update_last_seen(&mut self, addr: &SocketAddr) {
|
|
if let Some(peer) = self.peers.get_mut(addr) {
|
|
peer.last_seen = Instant::now();
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn get_all_games(&self) -> Vec<Game> {
|
|
let mut aggregated: HashMap<String, Game> = HashMap::new();
|
|
let mut peer_counts: HashMap<String, u32> = HashMap::new();
|
|
|
|
// Count peers per game
|
|
for peer in self.peers.values() {
|
|
for game_id in peer.games.keys() {
|
|
*peer_counts.entry(game_id.clone()).or_insert(0) += 1;
|
|
}
|
|
}
|
|
|
|
// Aggregate games with peer counts
|
|
for peer in self.peers.values() {
|
|
for game in peer.games.values() {
|
|
aggregated
|
|
.entry(game.id.clone())
|
|
.and_modify(|existing| {
|
|
if let (Some(new_version), Some(current)) =
|
|
(&game.eti_game_version, &existing.eti_game_version)
|
|
{
|
|
if new_version > current {
|
|
existing.eti_game_version = Some(new_version.clone());
|
|
}
|
|
} else if existing.eti_game_version.is_none() {
|
|
existing.eti_game_version.clone_from(&game.eti_game_version);
|
|
}
|
|
// Update peer count
|
|
existing.peer_count = peer_counts[&game.id];
|
|
})
|
|
.or_insert_with(|| {
|
|
let mut game_clone = game.clone();
|
|
game_clone.peer_count = peer_counts[&game.id];
|
|
game_clone
|
|
});
|
|
}
|
|
}
|
|
|
|
let mut games: Vec<Game> = aggregated.into_values().collect();
|
|
games.sort_by(|a, b| a.name.cmp(&b.name));
|
|
games
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn get_latest_version_for_game(&self, game_id: &str) -> Option<String> {
|
|
let mut latest_version: Option<String> = None;
|
|
|
|
for peer in self.peers.values() {
|
|
if let Some(game) = peer.games.get(game_id)
|
|
&& let Some(ref version) = game.eti_game_version
|
|
{
|
|
match &latest_version {
|
|
None => latest_version = Some(version.clone()),
|
|
Some(current_latest) => {
|
|
if version > current_latest {
|
|
latest_version = Some(version.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
latest_version
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn get_peer_addresses(&self) -> Vec<SocketAddr> {
|
|
self.peers.keys().copied().collect()
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn peers_with_game(&self, game_id: &str) -> Vec<SocketAddr> {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| peer.games.contains_key(game_id))
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn peers_with_latest_version(&self, game_id: &str) -> Vec<SocketAddr> {
|
|
let latest_version = self.get_latest_version_for_game(game_id);
|
|
|
|
if let Some(ref latest) = latest_version {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| {
|
|
if let Some(game) = peer.games.get(game_id) {
|
|
if let Some(ref version) = game.eti_game_version {
|
|
version == latest
|
|
} else {
|
|
false
|
|
}
|
|
} else {
|
|
false
|
|
}
|
|
})
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
} else {
|
|
// If no version info is available, fall back to all peers with the game
|
|
self.peers_with_game(game_id)
|
|
}
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn game_files_for(&self, game_id: &str) -> Vec<(SocketAddr, Vec<GameFileDescription>)> {
|
|
self.peers
|
|
.iter()
|
|
.filter_map(|(addr, peer)| peer.files.get(game_id).cloned().map(|files| (*addr, files)))
|
|
.collect()
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn aggregated_game_files(&self, game_id: &str) -> Vec<GameFileDescription> {
|
|
let mut seen: HashMap<String, GameFileDescription> = HashMap::new();
|
|
for (_, files) in self.game_files_for(game_id) {
|
|
for file in files {
|
|
seen.entry(file.relative_path.clone()).or_insert(file);
|
|
}
|
|
}
|
|
seen.into_values().collect()
|
|
}
|
|
|
|
/// Validates file sizes across all peers and returns only the files with majority consensus
|
|
/// Returns a tuple of (`validated_files`, `peer_whitelist`) where `peer_whitelist` contains
|
|
/// only peers that have the majority-approved file sizes
|
|
pub fn validate_file_sizes_majority(
|
|
&self,
|
|
game_id: &str,
|
|
) -> eyre::Result<(Vec<GameFileDescription>, Vec<SocketAddr>)> {
|
|
let game_files = self.game_files_for(game_id);
|
|
if game_files.is_empty() {
|
|
return Ok((Vec::new(), Vec::new()));
|
|
}
|
|
|
|
let (file_size_map, _peer_files) = collect_file_sizes(&game_files);
|
|
let (validated_files, peer_scores) =
|
|
self.validate_each_file_consensus(game_id, file_size_map)?;
|
|
let peer_whitelist = create_peer_whitelist(peer_scores);
|
|
|
|
Ok((validated_files, peer_whitelist))
|
|
}
|
|
|
|
/// Validates consensus for each file and returns validated files with peer scores
|
|
fn validate_each_file_consensus(
|
|
&self,
|
|
game_id: &str,
|
|
file_size_map: FileSizeMap,
|
|
) -> eyre::Result<(Vec<GameFileDescription>, HashMap<SocketAddr, usize>)> {
|
|
let mut validated_files = Vec::new();
|
|
let mut peer_whitelist_scores: HashMap<SocketAddr, usize> = HashMap::new();
|
|
|
|
for (relative_path, size_map) in file_size_map {
|
|
let total_peers: usize = size_map.values().map(Vec::len).sum();
|
|
|
|
if total_peers == 0 {
|
|
continue; // Skip files with no size information
|
|
}
|
|
|
|
let (consensus_size, consensus_peers) =
|
|
self.determine_size_consensus(&size_map, total_peers, &relative_path)?;
|
|
update_peer_scores(&consensus_peers, &mut peer_whitelist_scores);
|
|
|
|
if let Some((size, peers)) = consensus_size
|
|
&& let Some(file_desc) =
|
|
self.create_validated_file_description(game_id, &relative_path, size, &peers)
|
|
{
|
|
validated_files.push(file_desc);
|
|
}
|
|
}
|
|
|
|
Ok((validated_files, peer_whitelist_scores))
|
|
}
|
|
|
|
/// Determines the consensus size for a file based on peer reports
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics if `size_map.iter().next()` returns None when `total_peers` == 1
|
|
#[allow(clippy::unused_self)]
|
|
fn determine_size_consensus(
|
|
&self,
|
|
size_map: &HashMap<u64, Vec<SocketAddr>>,
|
|
total_peers: usize,
|
|
relative_path: &str,
|
|
) -> eyre::Result<(ConsensusResult, Vec<SocketAddr>)> {
|
|
if total_peers == 1 {
|
|
// Only one peer has this file - trust it
|
|
let (&size, peers) = size_map
|
|
.iter()
|
|
.next()
|
|
.expect("size_map should have at least one entry when total_peers == 1");
|
|
return Ok((Some((size, peers.clone())), peers.clone()));
|
|
}
|
|
|
|
let (majority_size, _majority_count) = find_majority_size(size_map);
|
|
|
|
if let Some(size) = majority_size {
|
|
let majority_peers = &size_map[&size];
|
|
let is_majority = majority_peers.len() > total_peers / 2;
|
|
|
|
if is_majority {
|
|
// We have a clear majority
|
|
Ok((Some((size, majority_peers.clone())), majority_peers.clone()))
|
|
} else if total_peers == 2 {
|
|
// Two peers with different sizes - ambiguous, fail
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': two peers report different sizes, cannot determine majority",
|
|
relative_path
|
|
);
|
|
}
|
|
// If no majority and more than 2 peers, we fall back to plurality (largest group)
|
|
else {
|
|
Ok((Some((size, majority_peers.clone())), majority_peers.clone()))
|
|
}
|
|
} else {
|
|
// No clear majority and it's a tie between different sizes
|
|
if total_peers == 2 {
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': two peers report different sizes, cannot determine majority",
|
|
relative_path
|
|
);
|
|
}
|
|
// For more than 2 peers, we could fall back to plurality, but for now let's be strict
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': no clear majority among {} peers",
|
|
relative_path,
|
|
total_peers
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Creates a validated file description from consensus data
|
|
fn create_validated_file_description(
|
|
&self,
|
|
game_id: &str,
|
|
relative_path: &str,
|
|
size: u64,
|
|
peers: &[SocketAddr],
|
|
) -> Option<GameFileDescription> {
|
|
if let Some(first_peer) = peers.first()
|
|
&& let Some(files) = self
|
|
.peers
|
|
.get(first_peer)
|
|
.and_then(|p| p.files.get(game_id))
|
|
&& let Some(file_desc) = files
|
|
.iter()
|
|
.find(|f| f.relative_path == relative_path && f.size == size)
|
|
{
|
|
return Some(file_desc.clone());
|
|
}
|
|
None
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn get_stale_peers(&self, timeout: Duration) -> Vec<SocketAddr> {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| peer.last_seen.elapsed() > timeout)
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
/// Type alias for file size mapping: path -> size -> peers
|
|
type FileSizeMap = HashMap<String, HashMap<u64, Vec<SocketAddr>>>;
|
|
|
|
/// Type alias for peer file mapping: peer -> path -> size
|
|
type PeerFileMap = HashMap<SocketAddr, HashMap<String, u64>>;
|
|
|
|
/// Type alias for consensus result: (size, peers) or None
|
|
type ConsensusResult = Option<(u64, Vec<SocketAddr>)>;
|
|
|
|
/// Collects file sizes from all peers and organizes them by path and size
|
|
fn collect_file_sizes(
|
|
game_files: &[(SocketAddr, Vec<GameFileDescription>)],
|
|
) -> (FileSizeMap, PeerFileMap) {
|
|
let mut file_size_map: FileSizeMap = HashMap::new();
|
|
let mut peer_files: PeerFileMap = HashMap::new();
|
|
|
|
for (peer_addr, files) in game_files {
|
|
let mut peer_file_sizes = HashMap::new();
|
|
for file in files {
|
|
if !file.is_dir {
|
|
let size = file.size;
|
|
file_size_map
|
|
.entry(file.relative_path.clone())
|
|
.or_default()
|
|
.entry(size)
|
|
.or_default()
|
|
.push(*peer_addr);
|
|
peer_file_sizes.insert(file.relative_path.clone(), size);
|
|
}
|
|
}
|
|
peer_files.insert(*peer_addr, peer_file_sizes);
|
|
}
|
|
|
|
(file_size_map, peer_files)
|
|
}
|
|
|
|
/// Finds the majority size from a map of sizes to peer lists
|
|
fn find_majority_size(size_map: &HashMap<u64, Vec<SocketAddr>>) -> (Option<u64>, usize) {
|
|
let mut majority_size = None;
|
|
let mut majority_count = 0;
|
|
|
|
for (&size, peers) in size_map {
|
|
let count = peers.len();
|
|
if count > majority_count {
|
|
majority_count = count;
|
|
majority_size = Some(size);
|
|
} else if count == majority_count {
|
|
// Tie between different sizes - ambiguous, fail
|
|
majority_size = None;
|
|
break;
|
|
}
|
|
}
|
|
|
|
(majority_size, majority_count)
|
|
}
|
|
|
|
/// Updates peer scores based on consensus participation
|
|
fn update_peer_scores(
|
|
peers: &[SocketAddr],
|
|
peer_whitelist_scores: &mut HashMap<SocketAddr, usize>,
|
|
) {
|
|
for &peer in peers {
|
|
*peer_whitelist_scores.entry(peer).or_insert(0) += 1;
|
|
}
|
|
}
|
|
|
|
/// Creates a peer whitelist from scores, including peers with the highest scores
|
|
fn create_peer_whitelist(peer_scores: HashMap<SocketAddr, usize>) -> Vec<SocketAddr> {
|
|
if peer_scores.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
|
|
let max_score = *peer_scores
|
|
.values()
|
|
.max()
|
|
.expect("peer_scores should not be empty here");
|
|
let threshold = max_score.max(1); // At least 1 file, or match the highest score
|
|
|
|
peer_scores
|
|
.into_iter()
|
|
.filter_map(|(peer, score)| if score >= threshold { Some(peer) } else { None })
|
|
.collect()
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum PeerCommand {
|
|
ListGames,
|
|
GetGame(String),
|
|
DownloadGameFiles {
|
|
id: String,
|
|
file_descriptions: Vec<GameFileDescription>,
|
|
},
|
|
SetGameDir(String),
|
|
}
|
|
|
|
async fn initial_peer_alive_check(conn: &mut Connection) -> bool {
|
|
let stream = match conn.open_bidirectional_stream().await {
|
|
Ok(stream) => stream,
|
|
Err(e) => {
|
|
log::error!("failed to open stream: {e}");
|
|
return false;
|
|
}
|
|
};
|
|
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
// send ping
|
|
if let Err(e) = tx.send(Request::Ping.encode()).await {
|
|
log::error!("failed to send ping to peer: {e}");
|
|
return false;
|
|
}
|
|
let _ = tx.close().await;
|
|
|
|
// receive pong
|
|
if let Ok(Some(response)) = rx.receive().await {
|
|
let response = Response::decode(response);
|
|
match response {
|
|
Response::Pong => {
|
|
log::info!("peer is alive");
|
|
return true;
|
|
}
|
|
_ => {
|
|
log::error!("peer sent invalid response to ping: {response:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
const CHUNK_SIZE: u64 = 512 * 1024;
|
|
const MAX_RETRY_COUNT: usize = 3;
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct DownloadChunk {
|
|
relative_path: String,
|
|
offset: u64,
|
|
length: u64,
|
|
retry_count: usize,
|
|
last_peer: Option<SocketAddr>,
|
|
}
|
|
|
|
#[derive(Debug, Default)]
|
|
struct PeerDownloadPlan {
|
|
chunks: Vec<DownloadChunk>,
|
|
whole_files: Vec<GameFileDescription>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct ChunkDownloadResult {
|
|
chunk: DownloadChunk,
|
|
result: eyre::Result<()>,
|
|
peer_addr: SocketAddr,
|
|
}
|
|
|
|
async fn prepare_game_storage(
|
|
games_folder: &Path,
|
|
file_descs: &[GameFileDescription],
|
|
) -> eyre::Result<()> {
|
|
for desc in file_descs {
|
|
// Validate the path to prevent directory traversal
|
|
let validated_path = validate_game_file_path(games_folder, &desc.relative_path)?;
|
|
|
|
if desc.is_dir {
|
|
tokio::fs::create_dir_all(&validated_path).await?;
|
|
} else {
|
|
if let Some(parent) = validated_path.parent() {
|
|
tokio::fs::create_dir_all(parent).await?;
|
|
}
|
|
|
|
// Create and pre-allocate the file with the expected size
|
|
let file = OpenOptions::new()
|
|
.create(true)
|
|
.truncate(true)
|
|
.write(true)
|
|
.open(&validated_path)
|
|
.await?;
|
|
|
|
// Pre-allocate the file with the expected size
|
|
let size = desc.size;
|
|
if let Err(e) = file.set_len(size).await {
|
|
log::warn!(
|
|
"Failed to pre-allocate file {} (size: {}): {}",
|
|
desc.relative_path,
|
|
size,
|
|
e
|
|
);
|
|
// Continue without pre-allocation - the file will grow as chunks are written
|
|
} else {
|
|
log::debug!(
|
|
"Pre-allocated file {} with {} bytes",
|
|
desc.relative_path,
|
|
size
|
|
);
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn build_peer_plans(
|
|
peers: &[SocketAddr],
|
|
file_descs: &[GameFileDescription],
|
|
) -> HashMap<SocketAddr, PeerDownloadPlan> {
|
|
let mut plans: HashMap<SocketAddr, PeerDownloadPlan> = HashMap::new();
|
|
if peers.is_empty() {
|
|
return plans;
|
|
}
|
|
|
|
let mut peer_index = 0usize;
|
|
|
|
for desc in file_descs.iter().filter(|d| !d.is_dir) {
|
|
let size = desc.file_size();
|
|
if size == 0 {
|
|
let peer = peers[peer_index % peers.len()];
|
|
peer_index += 1;
|
|
plans.entry(peer).or_default().chunks.push(DownloadChunk {
|
|
relative_path: desc.relative_path.clone(),
|
|
offset: 0,
|
|
length: 0,
|
|
retry_count: 0,
|
|
last_peer: Some(peer),
|
|
});
|
|
continue;
|
|
}
|
|
|
|
let mut offset = 0u64;
|
|
while offset < size {
|
|
let length = std::cmp::min(CHUNK_SIZE, size - offset);
|
|
let peer = peers[peer_index % peers.len()];
|
|
peer_index += 1;
|
|
plans.entry(peer).or_default().chunks.push(DownloadChunk {
|
|
relative_path: desc.relative_path.clone(),
|
|
offset,
|
|
length,
|
|
retry_count: 0,
|
|
last_peer: Some(peer),
|
|
});
|
|
offset += length;
|
|
}
|
|
}
|
|
|
|
plans
|
|
}
|
|
|
|
async fn download_chunk(
|
|
conn: &mut Connection,
|
|
base_dir: &Path,
|
|
game_id: &str,
|
|
chunk: &DownloadChunk,
|
|
) -> eyre::Result<()> {
|
|
let stream = conn.open_bidirectional_stream().await?;
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
let request = Request::GetGameFileChunk {
|
|
game_id: game_id.to_string(),
|
|
relative_path: chunk.relative_path.clone(),
|
|
offset: chunk.offset,
|
|
length: chunk.length,
|
|
};
|
|
tx.write_all(&request.encode()).await?;
|
|
|
|
tx.close().await?;
|
|
|
|
// Validate the path to prevent directory traversal
|
|
let validated_path = validate_game_file_path(base_dir, &chunk.relative_path)?;
|
|
let mut file = OpenOptions::new()
|
|
.create(true)
|
|
.write(true)
|
|
.truncate(false)
|
|
.open(&validated_path)
|
|
.await?;
|
|
if chunk.length == 0 && chunk.offset == 0 {
|
|
// fallback-to-whole-file path replaces any existing partial data
|
|
file.set_len(0).await?;
|
|
}
|
|
file.seek(std::io::SeekFrom::Start(chunk.offset)).await?;
|
|
|
|
let mut remaining = chunk.length;
|
|
let mut received_bytes = 0u64;
|
|
|
|
while let Some(bytes) = rx.receive().await? {
|
|
file.write_all(&bytes).await?;
|
|
received_bytes += bytes.len() as u64;
|
|
|
|
if remaining == 0 {
|
|
continue;
|
|
}
|
|
remaining = remaining.saturating_sub(bytes.len() as u64);
|
|
if remaining == 0 {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Verify we received the expected amount of data
|
|
if chunk.length > 0 && received_bytes != chunk.length {
|
|
eyre::bail!(
|
|
"Incomplete chunk download: expected {} bytes, received {} bytes for file {} at offset {}",
|
|
chunk.length,
|
|
received_bytes,
|
|
chunk.relative_path,
|
|
chunk.offset
|
|
);
|
|
}
|
|
|
|
file.flush().await?;
|
|
|
|
// Verify file integrity by checking the file size
|
|
verify_chunk_integrity(&validated_path, chunk.offset, chunk.length).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn verify_chunk_integrity(
|
|
file_path: &Path,
|
|
offset: u64,
|
|
expected_length: u64,
|
|
) -> eyre::Result<()> {
|
|
if expected_length == 0 {
|
|
return Ok(()); // Skip verification for whole files or zero-length chunks
|
|
}
|
|
|
|
let metadata = tokio::fs::metadata(file_path).await?;
|
|
let file_size = metadata.len();
|
|
|
|
if file_size < offset + expected_length {
|
|
eyre::bail!(
|
|
"File integrity check failed: file size {} is less than expected {} (offset: {})",
|
|
file_size,
|
|
offset + expected_length,
|
|
offset
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn download_whole_file(
|
|
conn: &mut Connection,
|
|
base_dir: &Path,
|
|
desc: &GameFileDescription,
|
|
) -> eyre::Result<()> {
|
|
let stream = conn.open_bidirectional_stream().await?;
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
tx.write_all(&Request::GetGameFileData(desc.clone()).encode())
|
|
.await?;
|
|
tx.close().await?;
|
|
|
|
// Validate the path to prevent directory traversal
|
|
let validated_path = validate_game_file_path(base_dir, &desc.relative_path)?;
|
|
let mut file = OpenOptions::new()
|
|
.create(true)
|
|
.truncate(true)
|
|
.write(true)
|
|
.open(&validated_path)
|
|
.await?;
|
|
file.seek(std::io::SeekFrom::Start(0)).await?;
|
|
|
|
while let Some(bytes) = rx.receive().await? {
|
|
file.write_all(&bytes).await?;
|
|
}
|
|
|
|
file.flush().await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn download_from_peer(
|
|
peer_addr: SocketAddr,
|
|
game_id: &str,
|
|
plan: PeerDownloadPlan,
|
|
games_folder: PathBuf,
|
|
) -> eyre::Result<Vec<ChunkDownloadResult>> {
|
|
if plan.chunks.is_empty() && plan.whole_files.is_empty() {
|
|
return Ok(Vec::new());
|
|
}
|
|
|
|
let limits = Limits::default().with_max_handshake_duration(Duration::from_secs(3))?;
|
|
|
|
let client = QuicClient::builder()
|
|
.with_tls(CERT_PEM)?
|
|
.with_io("0.0.0.0:0")?
|
|
.with_limits(limits)?
|
|
.start()?;
|
|
|
|
let conn = Connect::new(peer_addr).with_server_name("localhost");
|
|
let mut conn = client.connect(conn).await?;
|
|
conn.keep_alive(true)?;
|
|
|
|
let base_dir = games_folder;
|
|
let mut results = Vec::new();
|
|
|
|
// Download chunks with error handling
|
|
for chunk in &plan.chunks {
|
|
let result = download_chunk(&mut conn, &base_dir, game_id, chunk).await;
|
|
results.push(ChunkDownloadResult {
|
|
chunk: chunk.clone(),
|
|
result,
|
|
peer_addr,
|
|
});
|
|
}
|
|
|
|
// Download whole files
|
|
for desc in &plan.whole_files {
|
|
let chunk = DownloadChunk {
|
|
relative_path: desc.relative_path.clone(),
|
|
offset: 0,
|
|
length: 0, // Indicates whole file
|
|
retry_count: 0,
|
|
last_peer: Some(peer_addr),
|
|
};
|
|
|
|
let result = download_whole_file(&mut conn, &base_dir, desc).await;
|
|
results.push(ChunkDownloadResult {
|
|
chunk,
|
|
result,
|
|
peer_addr,
|
|
});
|
|
}
|
|
|
|
Ok(results)
|
|
}
|
|
|
|
async fn download_game_files(
|
|
game_id: &str,
|
|
game_file_descs: Vec<GameFileDescription>,
|
|
games_folder: String,
|
|
peers: Vec<SocketAddr>,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
) -> eyre::Result<()> {
|
|
if peers.is_empty() {
|
|
eyre::bail!("no peers available for game {game_id}");
|
|
}
|
|
|
|
let base_dir = PathBuf::from(&games_folder);
|
|
prepare_game_storage(&base_dir, &game_file_descs).await?;
|
|
|
|
tx_notify_ui.send(PeerEvent::DownloadGameFilesBegin {
|
|
id: game_id.to_string(),
|
|
})?;
|
|
|
|
let plans = build_peer_plans(&peers, &game_file_descs);
|
|
|
|
let mut tasks = Vec::new();
|
|
for (peer_addr, plan) in plans {
|
|
let base_dir = base_dir.clone();
|
|
let game_id = game_id.to_string();
|
|
tasks.push(tokio::spawn(async move {
|
|
download_from_peer(peer_addr, &game_id, plan, base_dir).await
|
|
}));
|
|
}
|
|
|
|
let mut failed_chunks: Vec<DownloadChunk> = Vec::new();
|
|
let mut last_err: Option<eyre::Report> = None;
|
|
|
|
for handle in tasks {
|
|
match handle.await {
|
|
Ok(Ok(results)) => {
|
|
for chunk_result in results {
|
|
if let Err(e) = chunk_result.result {
|
|
log::warn!(
|
|
"Failed to download chunk from {}: {e}",
|
|
chunk_result.peer_addr
|
|
);
|
|
if chunk_result.chunk.retry_count < MAX_RETRY_COUNT {
|
|
let mut retry_chunk = chunk_result.chunk;
|
|
retry_chunk.retry_count += 1;
|
|
retry_chunk.last_peer = Some(chunk_result.peer_addr);
|
|
failed_chunks.push(retry_chunk);
|
|
} else {
|
|
last_err = Some(eyre::eyre!(
|
|
"Max retries exceeded for chunk: {}",
|
|
chunk_result.chunk.relative_path
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(Err(e)) => last_err = Some(e),
|
|
Err(e) => last_err = Some(eyre::eyre!("task join error: {e}")),
|
|
}
|
|
}
|
|
|
|
// Retry failed chunks if any
|
|
if !failed_chunks.is_empty() && !peers.is_empty() {
|
|
log::info!("Retrying {} failed chunks", failed_chunks.len());
|
|
|
|
let retry_results = retry_failed_chunks(failed_chunks, &peers, &base_dir, game_id).await;
|
|
|
|
for chunk_result in retry_results {
|
|
if let Err(e) = chunk_result.result {
|
|
log::error!("Retry failed for chunk: {e}");
|
|
last_err = Some(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(err) = last_err {
|
|
tx_notify_ui.send(PeerEvent::DownloadGameFilesFailed {
|
|
id: game_id.to_string(),
|
|
})?;
|
|
return Err(err);
|
|
}
|
|
|
|
log::info!("all files downloaded for game: {game_id}");
|
|
tx_notify_ui.send(PeerEvent::DownloadGameFilesFinished {
|
|
id: game_id.to_string(),
|
|
})?;
|
|
Ok(())
|
|
}
|
|
|
|
fn select_retry_peer(
|
|
peers: &[SocketAddr],
|
|
last_peer: Option<SocketAddr>,
|
|
attempt_offset: usize,
|
|
) -> Option<SocketAddr> {
|
|
if peers.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
if peers.len() > 1
|
|
&& let Some(last) = last_peer
|
|
&& let Some(pos) = peers.iter().position(|addr| *addr == last)
|
|
{
|
|
let next_index = (pos + 1 + attempt_offset) % peers.len();
|
|
return Some(peers[next_index]);
|
|
}
|
|
|
|
Some(peers[attempt_offset % peers.len()])
|
|
}
|
|
|
|
fn fallback_peer_addr(peers: &[SocketAddr], last_peer: Option<SocketAddr>) -> SocketAddr {
|
|
last_peer
|
|
.or_else(|| peers.first().copied())
|
|
.unwrap_or_else(|| SocketAddr::from(([0, 0, 0, 0], 0)))
|
|
}
|
|
|
|
async fn retry_failed_chunks(
|
|
failed_chunks: Vec<DownloadChunk>,
|
|
peers: &[SocketAddr],
|
|
base_dir: &Path,
|
|
game_id: &str,
|
|
) -> Vec<ChunkDownloadResult> {
|
|
let mut exhausted = Vec::new();
|
|
let mut queue: VecDeque<DownloadChunk> = failed_chunks.into_iter().collect();
|
|
|
|
while let Some(mut chunk) = queue.pop_front() {
|
|
if chunk.retry_count >= MAX_RETRY_COUNT {
|
|
exhausted.push(ChunkDownloadResult {
|
|
chunk: chunk.clone(),
|
|
result: Err(eyre::eyre!(
|
|
"Retry budget exhausted for chunk: {}",
|
|
chunk.relative_path
|
|
)),
|
|
peer_addr: fallback_peer_addr(peers, chunk.last_peer),
|
|
});
|
|
continue;
|
|
}
|
|
|
|
let retry_offset = chunk.retry_count.saturating_sub(1);
|
|
let Some(peer_addr) = select_retry_peer(peers, chunk.last_peer, retry_offset) else {
|
|
exhausted.push(ChunkDownloadResult {
|
|
chunk: chunk.clone(),
|
|
result: Err(eyre::eyre!(
|
|
"No peers available to retry chunk: {}",
|
|
chunk.relative_path
|
|
)),
|
|
peer_addr: fallback_peer_addr(peers, chunk.last_peer),
|
|
});
|
|
continue;
|
|
};
|
|
|
|
let mut attempt_chunk = chunk.clone();
|
|
attempt_chunk.last_peer = Some(peer_addr);
|
|
|
|
let plan = PeerDownloadPlan {
|
|
chunks: vec![attempt_chunk.clone()],
|
|
whole_files: Vec::new(),
|
|
};
|
|
|
|
match download_from_peer(peer_addr, game_id, plan, base_dir.to_path_buf()).await {
|
|
Ok(results) => {
|
|
for result in results {
|
|
match result.result {
|
|
Ok(()) => {}
|
|
Err(e) => {
|
|
let mut retry_chunk = result.chunk.clone();
|
|
retry_chunk.retry_count = chunk.retry_count + 1;
|
|
retry_chunk.last_peer = Some(result.peer_addr);
|
|
|
|
if retry_chunk.retry_count >= MAX_RETRY_COUNT {
|
|
let context = format!(
|
|
"Retry budget exhausted for chunk: {}",
|
|
result.chunk.relative_path
|
|
);
|
|
exhausted.push(ChunkDownloadResult {
|
|
chunk: retry_chunk,
|
|
result: Err(e.wrap_err(context)),
|
|
peer_addr: result.peer_addr,
|
|
});
|
|
} else {
|
|
queue.push_back(retry_chunk);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
chunk.retry_count += 1;
|
|
chunk.last_peer = Some(peer_addr);
|
|
|
|
if chunk.retry_count >= MAX_RETRY_COUNT {
|
|
exhausted.push(ChunkDownloadResult {
|
|
chunk: chunk.clone(),
|
|
result: Err(e.wrap_err(format!(
|
|
"Retry budget exhausted for chunk after connection failure: {}",
|
|
chunk.relative_path
|
|
))),
|
|
peer_addr: fallback_peer_addr(peers, chunk.last_peer),
|
|
});
|
|
} else {
|
|
queue.push_back(chunk);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
exhausted
|
|
}
|
|
|
|
/// Load local game database combining locally installed games
|
|
async fn load_local_game_db(game_dir: &str) -> eyre::Result<GameDB> {
|
|
let game_path = PathBuf::from(game_dir);
|
|
let mut games = Vec::new();
|
|
|
|
// Scan game directory and create entries for installed games
|
|
let mut entries = tokio::fs::read_dir(&game_path).await?;
|
|
while let Some(entry) = entries.next_entry().await? {
|
|
let path = entry.path();
|
|
if path.is_dir()
|
|
&& let Some(game_id) = path.file_name().and_then(|n| n.to_str())
|
|
{
|
|
// Check if this game has a version.ini file
|
|
if let Ok(version) = lanspread_db::db::read_version_from_ini(&path) {
|
|
let size = calculate_directory_size(&path).await?;
|
|
let game = Game {
|
|
id: game_id.to_string(),
|
|
name: game_id.to_string(),
|
|
description: String::new(),
|
|
release_year: String::new(),
|
|
publisher: String::new(),
|
|
max_players: 1,
|
|
version: "1.0".to_string(),
|
|
genre: String::new(),
|
|
size,
|
|
thumbnail: None,
|
|
installed: true,
|
|
eti_game_version: version.clone(),
|
|
local_version: version,
|
|
peer_count: 0, // Local games start with 0 peers
|
|
};
|
|
games.push(game);
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(GameDB::from(games))
|
|
}
|
|
|
|
async fn calculate_directory_size(dir: &Path) -> eyre::Result<u64> {
|
|
let mut total_size = 0u64;
|
|
let mut entries = tokio::fs::read_dir(dir).await?;
|
|
|
|
while let Some(entry) = entries.next_entry().await? {
|
|
let path = entry.path();
|
|
let metadata = tokio::fs::metadata(&path).await?;
|
|
|
|
if metadata.is_dir() {
|
|
total_size += Box::pin(calculate_directory_size(&path)).await?;
|
|
} else {
|
|
total_size += metadata.len();
|
|
}
|
|
}
|
|
|
|
Ok(total_size)
|
|
}
|
|
|
|
struct Ctx {
|
|
game_dir: Arc<RwLock<Option<String>>>,
|
|
local_game_db: Arc<RwLock<Option<GameDB>>>,
|
|
peer_game_db: Arc<RwLock<PeerGameDB>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct PeerCtx {
|
|
game_dir: Arc<RwLock<Option<String>>>,
|
|
local_game_db: Arc<RwLock<Option<GameDB>>>,
|
|
}
|
|
|
|
impl std::fmt::Debug for PeerCtx {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_struct("PeerCtx")
|
|
.field("game_dir", &"...")
|
|
.field("local_game_db", &"...")
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
/// Main peer execution loop that handles peer commands and manages the peer system.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// This function will panic if the games folder is None after being checked for None.
|
|
/// The panic occurs at line 908 where `games_folder.expect("checked above")` is called.
|
|
pub async fn run_peer(
|
|
mut rx_control: UnboundedReceiver<PeerCommand>,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
) -> eyre::Result<()> {
|
|
// peer context
|
|
let ctx = Ctx {
|
|
game_dir: Arc::new(RwLock::new(None)),
|
|
local_game_db: Arc::new(RwLock::new(None)),
|
|
peer_game_db: Arc::new(RwLock::new(PeerGameDB::new())),
|
|
};
|
|
|
|
let peer_ctx = PeerCtx {
|
|
game_dir: ctx.game_dir.clone(),
|
|
local_game_db: ctx.local_game_db.clone(),
|
|
};
|
|
|
|
// Start server component
|
|
let server_addr = "0.0.0.0:0".parse::<SocketAddr>()?;
|
|
let tx_notify_ui_clone = tx_notify_ui.clone();
|
|
let peer_ctx_clone = peer_ctx.clone();
|
|
|
|
tokio::spawn(async move {
|
|
if let Err(e) = run_server_component(server_addr, peer_ctx_clone, tx_notify_ui_clone).await
|
|
{
|
|
log::error!("Server component error: {e}");
|
|
}
|
|
});
|
|
|
|
// Start peer discovery task
|
|
let tx_notify_ui_discovery = tx_notify_ui.clone();
|
|
let peer_game_db_discovery = ctx.peer_game_db.clone();
|
|
tokio::spawn(async move {
|
|
run_peer_discovery(tx_notify_ui_discovery, peer_game_db_discovery).await;
|
|
});
|
|
|
|
// Start ping service task
|
|
let tx_notify_ui_ping = tx_notify_ui.clone();
|
|
let peer_game_db_ping = ctx.peer_game_db.clone();
|
|
tokio::spawn(async move {
|
|
run_ping_service(tx_notify_ui_ping, peer_game_db_ping).await;
|
|
});
|
|
|
|
// Handle client commands
|
|
loop {
|
|
let Some(cmd) = rx_control.recv().await else {
|
|
break;
|
|
};
|
|
|
|
match cmd {
|
|
PeerCommand::ListGames => {
|
|
handle_list_games_command(&ctx, &tx_notify_ui).await;
|
|
}
|
|
PeerCommand::GetGame(id) => {
|
|
handle_get_game_command(&ctx, &tx_notify_ui, id).await;
|
|
}
|
|
PeerCommand::DownloadGameFiles {
|
|
id,
|
|
file_descriptions,
|
|
} => {
|
|
handle_download_game_files_command(&ctx, &tx_notify_ui, id, file_descriptions)
|
|
.await;
|
|
}
|
|
PeerCommand::SetGameDir(game_dir) => {
|
|
handle_set_game_dir_command(&ctx, game_dir).await;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_server_component(
|
|
addr: SocketAddr,
|
|
ctx: PeerCtx,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
) -> eyre::Result<()> {
|
|
let limits = Limits::default()
|
|
.with_max_handshake_duration(Duration::from_secs(3))?
|
|
.with_max_idle_timeout(Duration::from_secs(3))?;
|
|
|
|
let mut server = Server::builder()
|
|
.with_tls((CERT_PEM, KEY_PEM))?
|
|
.with_io(addr)?
|
|
.with_limits(limits)?
|
|
.start()?;
|
|
|
|
let server_addr = server.local_addr()?;
|
|
log::info!("Peer server listening on {server_addr}");
|
|
|
|
let advertise_ip = select_advertise_ip()?;
|
|
let advertise_addr = SocketAddr::new(advertise_ip, server_addr.port());
|
|
log::info!("Advertising peer via mDNS from {advertise_addr}");
|
|
|
|
// Start mDNS advertising for peer discovery
|
|
let peer_id = Uuid::now_v7().simple().to_string();
|
|
let hostname = gethostname::gethostname();
|
|
let hostname_str = hostname.to_str().unwrap_or("");
|
|
|
|
// Calculate maximum hostname length that fits with UUID in 63 char limit
|
|
let max_hostname_len = 63usize.saturating_sub(peer_id.len() + 1);
|
|
let truncated_hostname = if hostname_str.len() > max_hostname_len {
|
|
hostname_str.get(..max_hostname_len).unwrap_or(hostname_str)
|
|
} else {
|
|
hostname_str
|
|
};
|
|
|
|
let combined_str = if truncated_hostname.is_empty() {
|
|
peer_id
|
|
} else {
|
|
format!("{truncated_hostname}-{peer_id}")
|
|
};
|
|
|
|
let mdns = tokio::task::spawn_blocking(move || {
|
|
MdnsAdvertiser::new(LANSPREAD_SERVICE_TYPE, &combined_str, advertise_addr)
|
|
})
|
|
.await??;
|
|
|
|
// Monitor mDNS events
|
|
let _tx_notify_ui_mdns = tx_notify_ui.clone();
|
|
let hostname = truncated_hostname.to_string();
|
|
tokio::spawn(async move {
|
|
log::info!("Registering mDNS service with hostname: {hostname}");
|
|
while let Ok(event) = mdns.monitor.recv() {
|
|
match event {
|
|
lanspread_mdns::DaemonEvent::Error(e) => {
|
|
log::error!("mDNS error: {e}");
|
|
tokio::time::sleep(Duration::from_secs(1)).await;
|
|
}
|
|
_ => {
|
|
log::trace!("mDNS event: {event:?}");
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
while let Some(connection) = server.accept().await {
|
|
let ctx = ctx.clone();
|
|
let tx_notify_ui = tx_notify_ui.clone();
|
|
|
|
tokio::spawn(async move {
|
|
if let Err(e) = handle_peer_connection(connection, ctx, tx_notify_ui).await {
|
|
log::error!("Peer connection error: {e}");
|
|
}
|
|
});
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
async fn handle_list_games_command(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>) {
|
|
log::info!("ListGames command received");
|
|
let all_games = { ctx.peer_game_db.read().await.get_all_games() };
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::ListGames(all_games)) {
|
|
log::error!("Failed to send ListGames event: {e}");
|
|
}
|
|
}
|
|
|
|
async fn handle_get_game_command(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>, id: String) {
|
|
log::info!("Requesting game from peers: {id}");
|
|
let peers = { ctx.peer_game_db.read().await.peers_with_game(&id) };
|
|
if peers.is_empty() {
|
|
log::warn!("No peers have game {id}");
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::NoPeersHaveGame { id: id.clone() }) {
|
|
log::error!("Failed to send NoPeersHaveGame event: {e}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
let peer_game_db = ctx.peer_game_db.clone();
|
|
let tx_notify_ui = tx_notify_ui.clone();
|
|
tokio::spawn(async move {
|
|
let mut fetched_any = false;
|
|
for peer_addr in peers {
|
|
match request_game_details_from_peer(peer_addr, &id, peer_game_db.clone()).await {
|
|
Ok(_) => {
|
|
log::info!("Fetched game file list for {id} from peer {peer_addr}");
|
|
fetched_any = true;
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to fetch game files for {id} from {peer_addr}: {e}");
|
|
}
|
|
}
|
|
}
|
|
|
|
if fetched_any {
|
|
let aggregated_files = { peer_game_db.read().await.aggregated_game_files(&id) };
|
|
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::GotGameFiles {
|
|
id: id.clone(),
|
|
file_descriptions: aggregated_files,
|
|
}) {
|
|
log::error!("Failed to send GotGameFiles event: {e}");
|
|
}
|
|
} else {
|
|
log::warn!("Failed to retrieve game files for {id} from any peer");
|
|
}
|
|
});
|
|
}
|
|
|
|
async fn handle_download_game_files_command(
|
|
ctx: &Ctx,
|
|
tx_notify_ui: &UnboundedSender<PeerEvent>,
|
|
id: String,
|
|
file_descriptions: Vec<GameFileDescription>,
|
|
) {
|
|
log::info!("Got PeerCommand::DownloadGameFiles");
|
|
let games_folder = { ctx.game_dir.read().await.clone() };
|
|
if games_folder.is_none() {
|
|
log::error!("Cannot handle game file descriptions: games_folder is not set");
|
|
return;
|
|
}
|
|
|
|
let games_folder = games_folder.expect("checked above");
|
|
|
|
// Use majority validation to get trusted file descriptions and peer whitelist
|
|
let (validated_descriptions, peer_whitelist) = {
|
|
match ctx
|
|
.peer_game_db
|
|
.read()
|
|
.await
|
|
.validate_file_sizes_majority(&id)
|
|
{
|
|
Ok((files, peers)) => {
|
|
log::info!(
|
|
"Majority validation: {} validated files, {} trusted peers for game {id}",
|
|
files.len(),
|
|
peers.len()
|
|
);
|
|
(files, peers)
|
|
}
|
|
Err(e) => {
|
|
log::error!("File size majority validation failed for {id}: {e}");
|
|
if let Err(send_err) =
|
|
tx_notify_ui.send(PeerEvent::DownloadGameFilesFailed { id: id.clone() })
|
|
{
|
|
log::error!("Failed to send DownloadGameFilesFailed event: {send_err}");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
let resolved_descriptions = if file_descriptions.is_empty() {
|
|
validated_descriptions
|
|
} else {
|
|
// If user provided specific descriptions, still validate them against majority
|
|
// but keep user's selection (they might want specific files)
|
|
file_descriptions
|
|
};
|
|
|
|
if resolved_descriptions.is_empty() {
|
|
log::error!(
|
|
"No validated file descriptions available to download game {id}; request metadata first"
|
|
);
|
|
return;
|
|
}
|
|
|
|
if peer_whitelist.is_empty() {
|
|
log::error!("No trusted peers available after majority validation for game {id}");
|
|
return;
|
|
}
|
|
|
|
let tx_notify_ui = tx_notify_ui.clone();
|
|
tokio::spawn(async move {
|
|
match download_game_files(
|
|
&id,
|
|
resolved_descriptions,
|
|
games_folder,
|
|
peer_whitelist,
|
|
tx_notify_ui.clone(),
|
|
)
|
|
.await
|
|
{
|
|
Ok(()) => {}
|
|
Err(e) => {
|
|
log::error!("Download failed for {id}: {e}");
|
|
if let Err(send_err) =
|
|
tx_notify_ui.send(PeerEvent::DownloadGameFilesFailed { id: id.clone() })
|
|
{
|
|
log::error!("Failed to send DownloadGameFilesFailed event: {send_err}");
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
async fn handle_set_game_dir_command(ctx: &Ctx, game_dir: String) {
|
|
*ctx.game_dir.write().await = Some(game_dir.clone());
|
|
log::info!("Game directory set to: {game_dir}");
|
|
|
|
// Load local game database when game directory is set
|
|
let game_dir = game_dir.clone();
|
|
let local_game_db = ctx.local_game_db.clone();
|
|
tokio::spawn(async move {
|
|
match load_local_game_db(&game_dir).await {
|
|
Ok(db) => {
|
|
*local_game_db.write().await = Some(db);
|
|
log::info!("Local game database loaded successfully");
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to load local game database: {e}");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
async fn handle_peer_connection(
|
|
mut connection: Connection,
|
|
ctx: PeerCtx,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
) -> eyre::Result<()> {
|
|
let remote_addr = connection.remote_addr()?;
|
|
log::info!("{remote_addr} peer connected");
|
|
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::PeerConnected(remote_addr)) {
|
|
log::error!("Failed to send PeerConnected event: {e}");
|
|
}
|
|
|
|
// handle streams
|
|
while let Ok(Some(stream)) = connection.accept_bidirectional_stream().await {
|
|
let ctx = ctx.clone();
|
|
let remote_addr = Some(remote_addr);
|
|
|
|
tokio::spawn(async move {
|
|
if let Err(e) = handle_peer_stream(stream, ctx, remote_addr).await {
|
|
log::error!("{remote_addr:?} peer stream error: {e}");
|
|
}
|
|
});
|
|
}
|
|
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::PeerDisconnected(remote_addr)) {
|
|
log::error!("Failed to send PeerDisconnected event: {e}");
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[allow(clippy::too_many_lines)]
|
|
async fn handle_peer_stream(
|
|
stream: BidirectionalStream,
|
|
ctx: PeerCtx,
|
|
remote_addr: Option<SocketAddr>,
|
|
) -> eyre::Result<()> {
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
log::trace!("{remote_addr:?} peer stream opened");
|
|
|
|
// handle streams
|
|
loop {
|
|
match rx.receive().await {
|
|
Ok(Some(data)) => {
|
|
log::trace!(
|
|
"{:?} msg: (raw): {}",
|
|
remote_addr,
|
|
String::from_utf8_lossy(&data)
|
|
);
|
|
|
|
let request = Request::decode(data);
|
|
log::debug!("{remote_addr:?} msg: {request:?}");
|
|
|
|
match request {
|
|
Request::Ping => {
|
|
// Respond with pong
|
|
if let Err(e) = tx.send(Response::Pong.encode()).await {
|
|
log::error!("Failed to send pong: {e}");
|
|
}
|
|
}
|
|
Request::ListGames => {
|
|
// Return list of games from this peer
|
|
log::info!("Received ListGames request from peer");
|
|
let games = if let Some(ref db) = *ctx.local_game_db.read().await {
|
|
db.all_games().into_iter().cloned().collect()
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
|
|
if let Err(e) = tx.send(Response::ListGames(games).encode()).await {
|
|
log::error!("Failed to send ListGames response: {e}");
|
|
}
|
|
}
|
|
Request::GetGame { id } => {
|
|
log::info!("Received GetGame request for {id} from peer");
|
|
let response = if let Some(ref game_dir) = *ctx.game_dir.read().await {
|
|
if let Some(ref db) = *ctx.local_game_db.read().await {
|
|
if db.get_game_by_id(&id).is_some() {
|
|
match get_game_file_descriptions(&id, game_dir).await {
|
|
Ok(file_descriptions) => Response::GetGame {
|
|
id,
|
|
file_descriptions,
|
|
},
|
|
Err(PeerError::FileSizeDetermination { path, source }) => {
|
|
let error_msg = format!(
|
|
"Failed to determine file size for {path}: {source}"
|
|
);
|
|
log::error!(
|
|
"File size determination error for game {id}: {error_msg}"
|
|
);
|
|
Response::InternalPeerError(error_msg)
|
|
}
|
|
Err(e) => {
|
|
log::error!(
|
|
"Failed to get game file descriptions for {id}: {e}"
|
|
);
|
|
Response::GameNotFound(id)
|
|
}
|
|
}
|
|
} else {
|
|
Response::GameNotFound(id)
|
|
}
|
|
} else {
|
|
Response::GameNotFound(id)
|
|
}
|
|
} else {
|
|
Response::GameNotFound(id)
|
|
};
|
|
|
|
if let Err(e) = tx.send(response.encode()).await {
|
|
log::error!("Failed to send GetGame response: {e}");
|
|
}
|
|
}
|
|
Request::GetGameFileData(desc) => {
|
|
log::info!(
|
|
"Received GetGameFileData request for {} from peer",
|
|
desc.relative_path
|
|
);
|
|
|
|
let maybe_game_dir = ctx.game_dir.read().await.clone();
|
|
if let Some(game_dir) = maybe_game_dir {
|
|
let base_dir = PathBuf::from(game_dir);
|
|
send_game_file_data(&desc, &mut tx, &base_dir).await;
|
|
} else if let Err(e) = tx
|
|
.send(
|
|
Response::InvalidRequest(
|
|
desc.relative_path.as_bytes().to_vec().into(),
|
|
"Game directory not set".to_string(),
|
|
)
|
|
.encode(),
|
|
)
|
|
.await
|
|
{
|
|
log::error!("Failed to send GetGameFileData error: {e}");
|
|
}
|
|
}
|
|
Request::GetGameFileChunk {
|
|
game_id,
|
|
relative_path,
|
|
offset,
|
|
length,
|
|
} => {
|
|
log::info!(
|
|
"Received GetGameFileChunk request for {relative_path} from peer"
|
|
);
|
|
|
|
let maybe_game_dir = ctx.game_dir.read().await.clone();
|
|
if let Some(game_dir) = maybe_game_dir {
|
|
let base_dir = PathBuf::from(game_dir);
|
|
send_game_file_chunk(
|
|
&game_id,
|
|
&relative_path,
|
|
offset,
|
|
length,
|
|
&mut tx,
|
|
&base_dir,
|
|
)
|
|
.await;
|
|
} else if let Err(e) = tx
|
|
.send(
|
|
Response::InvalidRequest(
|
|
relative_path.as_bytes().to_vec().into(),
|
|
"Game directory not set".to_string(),
|
|
)
|
|
.encode(),
|
|
)
|
|
.await
|
|
{
|
|
log::error!("Failed to send GetGameFileChunk error: {e}");
|
|
}
|
|
}
|
|
Request::Invalid(_, _) => {
|
|
log::error!("Received invalid request from peer");
|
|
}
|
|
}
|
|
}
|
|
Ok(None) => {
|
|
log::trace!("{remote_addr:?} peer stream closed");
|
|
break;
|
|
}
|
|
Err(e) => {
|
|
log::error!("{remote_addr:?} peer stream error: {e}");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn run_peer_discovery(
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
peer_game_db: Arc<RwLock<PeerGameDB>>,
|
|
) {
|
|
log::info!("Starting peer discovery task");
|
|
|
|
loop {
|
|
let discovery_result = discover_service(LANSPREAD_SERVICE_TYPE);
|
|
|
|
match discovery_result {
|
|
Ok(peer_addr) => {
|
|
log::info!("Discovered peer at: {peer_addr}");
|
|
|
|
// Add peer to database
|
|
let is_new_peer = {
|
|
let mut db = peer_game_db.write().await;
|
|
let peer_addresses = db.get_peer_addresses();
|
|
if peer_addresses.contains(&peer_addr) {
|
|
false
|
|
} else {
|
|
db.add_peer(peer_addr);
|
|
true
|
|
}
|
|
};
|
|
|
|
if is_new_peer {
|
|
// Notify UI about new peer
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::PeerDiscovered(peer_addr)) {
|
|
log::error!("Failed to send PeerDiscovered event: {e}");
|
|
}
|
|
|
|
// Request games from this peer
|
|
let tx_notify_ui_clone = tx_notify_ui.clone();
|
|
let peer_game_db_clone = peer_game_db.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = request_games_from_peer(
|
|
peer_addr,
|
|
tx_notify_ui_clone,
|
|
peer_game_db_clone,
|
|
)
|
|
.await
|
|
{
|
|
log::error!("Failed to request games from peer {peer_addr}: {e}");
|
|
}
|
|
});
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::debug!("Peer discovery error: {e}");
|
|
tokio::time::sleep(Duration::from_secs(5)).await;
|
|
}
|
|
}
|
|
// Wait before next discovery cycle
|
|
tokio::time::sleep(Duration::from_secs(10)).await;
|
|
}
|
|
}
|
|
|
|
async fn request_games_from_peer(
|
|
peer_addr: SocketAddr,
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
peer_game_db: Arc<RwLock<PeerGameDB>>,
|
|
) -> eyre::Result<()> {
|
|
let limits = Limits::default().with_max_handshake_duration(Duration::from_secs(3))?;
|
|
|
|
let client = QuicClient::builder()
|
|
.with_tls(CERT_PEM)?
|
|
.with_io("0.0.0.0:0")?
|
|
.with_limits(limits)?
|
|
.start()?;
|
|
|
|
let conn = Connect::new(peer_addr).with_server_name("localhost");
|
|
let mut conn = client.connect(conn).await?;
|
|
|
|
let stream = conn.open_bidirectional_stream().await?;
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
// Send ListGames request
|
|
tx.send(Request::ListGames.encode()).await?;
|
|
let _ = tx.close().await;
|
|
|
|
// Receive response
|
|
let mut data = BytesMut::new();
|
|
while let Ok(Some(bytes)) = rx.receive().await {
|
|
data.extend_from_slice(&bytes);
|
|
}
|
|
|
|
let response = Response::decode(data.freeze());
|
|
match response {
|
|
Response::ListGames(games) => {
|
|
log::info!("Received {} games from peer {peer_addr}", games.len());
|
|
|
|
let aggregated_games = {
|
|
let mut db = peer_game_db.write().await;
|
|
db.update_peer_games(peer_addr, games);
|
|
db.get_all_games()
|
|
};
|
|
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::ListGames(aggregated_games)) {
|
|
log::error!("Failed to send ListGames event: {e}");
|
|
}
|
|
}
|
|
_ => {
|
|
log::warn!("Unexpected response from peer {peer_addr}: {response:?}");
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn request_game_details_from_peer(
|
|
peer_addr: SocketAddr,
|
|
game_id: &str,
|
|
peer_game_db: Arc<RwLock<PeerGameDB>>,
|
|
) -> eyre::Result<Vec<GameFileDescription>> {
|
|
let limits = Limits::default().with_max_handshake_duration(Duration::from_secs(3))?;
|
|
|
|
let client = QuicClient::builder()
|
|
.with_tls(CERT_PEM)?
|
|
.with_io("0.0.0.0:0")?
|
|
.with_limits(limits)?
|
|
.start()?;
|
|
|
|
let conn = Connect::new(peer_addr).with_server_name("localhost");
|
|
let mut conn = client.connect(conn).await?;
|
|
|
|
let stream = conn.open_bidirectional_stream().await?;
|
|
let (mut rx, mut tx) = stream.split();
|
|
|
|
tx.send(
|
|
Request::GetGame {
|
|
id: game_id.to_string(),
|
|
}
|
|
.encode(),
|
|
)
|
|
.await?;
|
|
tx.close().await?;
|
|
|
|
let mut data = BytesMut::new();
|
|
while let Ok(Some(bytes)) = rx.receive().await {
|
|
data.extend_from_slice(&bytes);
|
|
}
|
|
|
|
let response = Response::decode(data.freeze());
|
|
match response {
|
|
Response::GetGame {
|
|
id,
|
|
file_descriptions,
|
|
} => {
|
|
if id != game_id {
|
|
eyre::bail!("peer {peer_addr} responded with mismatched game id {id}");
|
|
}
|
|
|
|
{
|
|
let mut db = peer_game_db.write().await;
|
|
db.update_peer_game_files(peer_addr, game_id, file_descriptions.clone());
|
|
}
|
|
|
|
Ok(file_descriptions)
|
|
}
|
|
Response::GameNotFound(_) => {
|
|
eyre::bail!("peer {peer_addr} does not have game {game_id}")
|
|
}
|
|
Response::InternalPeerError(error_msg) => {
|
|
eyre::bail!("peer {peer_addr} reported internal error: {error_msg}")
|
|
}
|
|
_ => eyre::bail!("unexpected response from {peer_addr}: {response:?}"),
|
|
}
|
|
}
|
|
|
|
async fn run_ping_service(
|
|
tx_notify_ui: UnboundedSender<PeerEvent>,
|
|
peer_game_db: Arc<RwLock<PeerGameDB>>,
|
|
) {
|
|
log::info!("Starting ping service (10s interval)");
|
|
|
|
let mut interval = tokio::time::interval(Duration::from_secs(10));
|
|
|
|
loop {
|
|
interval.tick().await;
|
|
|
|
let peer_addresses = { peer_game_db.read().await.get_peer_addresses() };
|
|
|
|
for peer_addr in peer_addresses {
|
|
let tx_notify_ui_clone = tx_notify_ui.clone();
|
|
let peer_game_db_clone = peer_game_db.clone();
|
|
|
|
tokio::spawn(async move {
|
|
match ping_peer(peer_addr).await {
|
|
Ok(is_alive) => {
|
|
if is_alive {
|
|
// Update last seen time
|
|
peer_game_db_clone
|
|
.write()
|
|
.await
|
|
.update_last_seen(&peer_addr);
|
|
} else {
|
|
log::warn!("Peer {peer_addr} failed ping check");
|
|
|
|
// Remove stale peer
|
|
let removed_peer =
|
|
peer_game_db_clone.write().await.remove_peer(&peer_addr);
|
|
if removed_peer.is_some() {
|
|
log::info!("Removed stale peer: {peer_addr}");
|
|
if let Err(e) =
|
|
tx_notify_ui_clone.send(PeerEvent::PeerLost(peer_addr))
|
|
{
|
|
log::error!("Failed to send PeerLost event: {e}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
log::error!("Failed to ping peer {peer_addr}: {e}");
|
|
|
|
// Remove peer on error
|
|
let removed_peer = peer_game_db_clone.write().await.remove_peer(&peer_addr);
|
|
if removed_peer.is_some() {
|
|
log::info!("Removed peer due to ping error: {peer_addr}");
|
|
if let Err(e) = tx_notify_ui_clone.send(PeerEvent::PeerLost(peer_addr))
|
|
{
|
|
log::error!("Failed to send PeerLost event: {e}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Also clean up stale peers
|
|
let stale_peers = {
|
|
peer_game_db
|
|
.read()
|
|
.await
|
|
.get_stale_peers(Duration::from_secs(30))
|
|
};
|
|
for stale_addr in stale_peers {
|
|
let removed_peer = peer_game_db.write().await.remove_peer(&stale_addr);
|
|
if removed_peer.is_some() {
|
|
log::info!("Removed stale peer: {stale_addr}");
|
|
if let Err(e) = tx_notify_ui.send(PeerEvent::PeerLost(stale_addr)) {
|
|
log::error!("Failed to send PeerLost event: {e}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn ping_peer(peer_addr: SocketAddr) -> eyre::Result<bool> {
|
|
let limits = Limits::default().with_max_handshake_duration(Duration::from_secs(3))?;
|
|
|
|
let client = QuicClient::builder()
|
|
.with_tls(CERT_PEM)?
|
|
.with_io("0.0.0.0:0")?
|
|
.with_limits(limits)?
|
|
.start()?;
|
|
|
|
let conn = Connect::new(peer_addr).with_server_name("localhost");
|
|
let mut conn = client.connect(conn).await?;
|
|
|
|
let is_alive = initial_peer_alive_check(&mut conn).await;
|
|
Ok(is_alive)
|
|
}
|
|
|
|
fn select_advertise_ip() -> eyre::Result<IpAddr> {
|
|
let mut best_candidate: Option<(u8, IpAddr)> = None;
|
|
let mut loopback_fallback = None;
|
|
|
|
for interface in get_if_addrs()? {
|
|
if interface.is_loopback() {
|
|
loopback_fallback.get_or_insert(interface.ip());
|
|
continue;
|
|
}
|
|
|
|
if let Some(candidate) = classify_interface(&interface)
|
|
&& best_candidate
|
|
.as_ref()
|
|
.is_none_or(|(rank, _)| candidate.0 < *rank)
|
|
{
|
|
best_candidate = Some(candidate);
|
|
}
|
|
}
|
|
|
|
if let Some((_, ip)) = best_candidate {
|
|
return Ok(ip);
|
|
}
|
|
|
|
if let Some(ip) = loopback_fallback {
|
|
log::warn!(
|
|
"No non-loopback interface suitable for mDNS advertisement; falling back to {ip}"
|
|
);
|
|
return Ok(ip);
|
|
}
|
|
|
|
eyre::bail!("No usable network interface found for mDNS advertisement");
|
|
}
|
|
|
|
fn classify_interface(interface: &Interface) -> Option<(u8, IpAddr)> {
|
|
match interface.addr {
|
|
IfAddr::V4(ref v4) => {
|
|
let ip = v4.ip;
|
|
|
|
if ip.is_unspecified() || ip.is_link_local() {
|
|
return None;
|
|
}
|
|
|
|
let mut rank = if ip.is_private() { 0 } else { 2 };
|
|
|
|
if is_virtual_interface(&interface.name) {
|
|
rank += 2;
|
|
}
|
|
|
|
Some((rank, IpAddr::V4(ip)))
|
|
}
|
|
IfAddr::V6(_) => None,
|
|
}
|
|
}
|
|
|
|
fn is_virtual_interface(name: &str) -> bool {
|
|
const VIRTUAL_HINTS: &[&str] = &[
|
|
"awdl",
|
|
"br-",
|
|
"bridge",
|
|
"docker",
|
|
"ham",
|
|
"llw",
|
|
"tap",
|
|
"tailscale",
|
|
"tun",
|
|
"utun",
|
|
"vbox",
|
|
"veth",
|
|
"virbr",
|
|
"vmnet",
|
|
"wg",
|
|
"zt",
|
|
];
|
|
|
|
let lower = name.to_ascii_lowercase();
|
|
VIRTUAL_HINTS.iter().any(|hint| lower.contains(hint))
|
|
}
|
|
|
|
async fn get_game_file_descriptions(
|
|
game_id: &str,
|
|
game_dir: &str,
|
|
) -> Result<Vec<GameFileDescription>, PeerError> {
|
|
let base_dir = PathBuf::from(game_dir);
|
|
let game_path = base_dir.join(game_id);
|
|
|
|
if !game_path.exists() {
|
|
return Err(PeerError::Other(eyre::eyre!(
|
|
"Game directory does not exist: {}",
|
|
game_path.display()
|
|
)));
|
|
}
|
|
|
|
let mut file_descriptions = Vec::new();
|
|
|
|
for entry in walkdir::WalkDir::new(&game_path)
|
|
.into_iter()
|
|
.filter_map(std::result::Result::ok)
|
|
{
|
|
let relative_path = match entry.path().strip_prefix(&base_dir) {
|
|
Ok(path) => path.to_string_lossy().to_string(),
|
|
Err(e) => {
|
|
log::error!(
|
|
"Failed to get relative path for {}: {}",
|
|
entry.path().display(),
|
|
e
|
|
);
|
|
continue;
|
|
}
|
|
};
|
|
|
|
let is_dir = entry.file_type().is_dir();
|
|
let size = if is_dir {
|
|
0
|
|
} else {
|
|
match tokio::fs::metadata(entry.path()).await {
|
|
Ok(metadata) => metadata.len(),
|
|
Err(e) => {
|
|
log::error!("Failed to read metadata for {relative_path}: {e}");
|
|
return Err(PeerError::FileSizeDetermination {
|
|
path: relative_path.clone(),
|
|
source: e,
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
let file_desc = GameFileDescription {
|
|
game_id: game_id.to_string(),
|
|
relative_path,
|
|
is_dir,
|
|
size,
|
|
};
|
|
|
|
file_descriptions.push(file_desc);
|
|
}
|
|
|
|
Ok(file_descriptions)
|
|
}
|