133 lines
3.4 KiB
Rust
133 lines
3.4 KiB
Rust
use std::{collections::HashMap, env, error::Error, fs, net::SocketAddr, path::PathBuf};
|
|
|
|
use log::{debug, info};
|
|
use tokio::{fs::File, io::BufWriter};
|
|
|
|
use crate::crypto;
|
|
|
|
const PUBLIC_IPV4: &str = "https://ipinfo.io/ip";
|
|
const PUBLIC_IPV6: &str = "https://ipv6.icanhazip.com";
|
|
|
|
#[derive(PartialEq, Eq)]
|
|
pub enum Ip {
|
|
V4,
|
|
V6,
|
|
Local,
|
|
}
|
|
|
|
impl Ip {
|
|
pub fn fetch(self, port: u16) -> Result<(SocketAddr, SocketAddr), Box<dyn Error>> {
|
|
let addr = match self {
|
|
Ip::V4 => PUBLIC_IPV4,
|
|
Ip::V6 => PUBLIC_IPV6,
|
|
Ip::Local => {
|
|
let addr_str = format!("127.0.0.1:{}", port);
|
|
let addr = addr_str.parse::<SocketAddr>()?;
|
|
return Ok((addr, addr));
|
|
}
|
|
};
|
|
|
|
info!("Fetching IP information from {}", addr);
|
|
|
|
let res = format!("{}:{}", ureq::get(addr).call()?.into_string()?.trim(), port);
|
|
let display_addr = res.parse::<SocketAddr>()?;
|
|
let bind_addr = format!("0.0.0.0:{}", port).parse::<SocketAddr>()?;
|
|
|
|
debug!("IP: {}", res);
|
|
|
|
Ok((display_addr, bind_addr))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct FileInfo {
|
|
pub name: String,
|
|
pub size: u64,
|
|
pub hash: String,
|
|
}
|
|
|
|
impl FileInfo {
|
|
pub fn new(name: String, size: u64, hash: String) -> Self {
|
|
Self { name, size, hash }
|
|
}
|
|
}
|
|
|
|
pub fn filepaths(
|
|
source: Option<PathBuf>,
|
|
files: Option<Vec<PathBuf>>,
|
|
) -> Result<Vec<PathBuf>, Box<dyn Error>> {
|
|
info!("Collecting filepaths");
|
|
|
|
let mut paths = Vec::new();
|
|
|
|
if let Some(source) = source {
|
|
let home = env::var("HOME")?;
|
|
let content = fs::read_to_string(source)?;
|
|
paths = content
|
|
.lines()
|
|
.into_iter()
|
|
.map(|p| PathBuf::from(p.replace('~', &home)))
|
|
.collect();
|
|
} else if let Some(files) = files {
|
|
paths = files;
|
|
}
|
|
|
|
debug!("Filepaths collection finished (total: {})", paths.len());
|
|
|
|
Ok(paths)
|
|
}
|
|
|
|
pub async fn metadata(
|
|
files: &Vec<PathBuf>,
|
|
) -> Result<(Vec<FileInfo>, HashMap<String, PathBuf>), Box<dyn Error>> {
|
|
info!("Collecting metadata");
|
|
|
|
let mut metadata = Vec::new();
|
|
let mut index = HashMap::new();
|
|
|
|
for path in files {
|
|
debug!("Collecting '{}' metadata", path.to_str().unwrap());
|
|
|
|
let split = path.to_str().unwrap().split('/').collect::<Vec<&str>>();
|
|
let name = split[split.len() - 1].to_string();
|
|
let handle = File::open(path).await?;
|
|
let size = handle.metadata().await?.len();
|
|
let hash = crypto::try_hash(path)?;
|
|
|
|
if size > 0 {
|
|
let info = FileInfo::new(name, size, hash.clone());
|
|
metadata.push(info);
|
|
index.insert(hash, path.clone());
|
|
}
|
|
}
|
|
|
|
debug!(
|
|
"Metadata collection successfully done (total: {})",
|
|
metadata.len()
|
|
);
|
|
|
|
Ok((metadata, index))
|
|
}
|
|
|
|
pub async fn new_file(
|
|
mut path: PathBuf,
|
|
name: &str,
|
|
) -> Result<(BufWriter<File>, PathBuf), Box<dyn Error + Send + Sync>> {
|
|
debug!("New file handle for '{}'", name);
|
|
|
|
path.push(name);
|
|
let handle = File::create(&path).await?;
|
|
|
|
Ok((BufWriter::new(handle), path))
|
|
}
|
|
|
|
pub fn ascii() {
|
|
let ascii = " __
|
|
_________ ____ / /____ ____ _____
|
|
/ ___/ __ \\/ __ \\/ __/ _ \\/ __ `/ __ \\
|
|
/ /__/ /_/ / / / / /_/ __/ /_/ / /_/ /
|
|
\\___/\\____/_/ /_/\\__/\\___/\\__, /\\____/
|
|
/____/ ";
|
|
println!("{}\n", ascii);
|
|
}
|