spill 0.5.1

Modern torrent client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Descriptor-relative destinations using validated relative torrent paths.
//! Named destinations never overwrite existing payloads during creation.

use crate::protocol::metainfo::{FileKind, OwnedMetainfo};
use rustix::fs::{
    AtFlags, FileType, FlockOperation, Mode, OFlags, flock, openat, statat, unlinkat,
};
use std::{ffi::OsStr, fs::File, io};

mod verify;
use verify::{check_canceled, verify_content_cancellable};
mod file;
mod named;
pub(in crate::engine) mod paths;
use paths::PayloadPaths;

pub struct NamedDestination;

/// Opaque provisioned payload authority, consumed by torrent admission.
pub struct FileStorage {
    meta: OwnedMetainfo,
    files: file::Files,
    read_only: bool,
    binding: Option<DestinationBinding>,
    verified_resume: Option<Vec<u8>>,
}

/// Catalog record of payload paths and whether they were adopted read-only.
/// Paths are bytes so non-UTF-8 torrent names round-trip without loss.
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct DestinationBinding {
    read_only: bool,
    paths: Vec<Vec<u8>>,
}
impl DestinationBinding {
    pub fn new(meta: &OwnedMetainfo, read_only: bool) -> io::Result<Self> {
        let all = PayloadPaths::new(meta)?;
        Ok(Self {
            read_only,
            paths: all
                .paths
                .into_iter()
                .zip(meta.layout().files())
                .filter_map(|(path, entry)| (entry.kind() == FileKind::Data).then_some(path))
                .collect(),
        })
    }
    pub(in crate::engine) fn is_read_only(&self) -> bool {
        self.read_only
    }
    fn payload_paths(&self) -> io::Result<PayloadPaths> {
        PayloadPaths::validated(self.paths.clone())
    }
}

fn open_directory(root: &File, name: impl AsRef<OsStr>) -> io::Result<File> {
    Ok(openat(
        root,
        name.as_ref(),
        OFlags::RDONLY | OFlags::DIRECTORY | OFlags::NOFOLLOW | OFlags::CLOEXEC,
        Mode::empty(),
    )?
    .into())
}
fn open_file_mode(
    directory: &File,
    name: impl AsRef<OsStr>,
    create: bool,
    mode: Mode,
) -> io::Result<File> {
    let name = name.as_ref();
    if !create {
        let stat = statat(directory, name, AtFlags::SYMLINK_NOFOLLOW)?;
        if FileType::from_raw_mode(stat.st_mode) != FileType::RegularFile {
            return Err(invalid("destination requires regular files"));
        }
    }
    let flags =
        OFlags::RDWR | OFlags::NOFOLLOW | OFlags::CLOEXEC | OFlags::NONBLOCK | OFlags::NOCTTY;
    let flags = if create {
        flags | OFlags::CREATE | OFlags::EXCL
    } else {
        flags
    };
    let file: File = openat(directory, name, flags, mode)?.into();
    if !file.metadata()?.is_file() {
        return Err(invalid("destination requires regular files"));
    }
    Ok(file)
}
fn remove_file(directory: &File, name: impl AsRef<OsStr>) -> io::Result<()> {
    match unlinkat(directory, name.as_ref(), AtFlags::empty()) {
        Ok(()) | Err(rustix::io::Errno::NOENT) => Ok(()),
        Err(error) => Err(error.into()),
    }
}
fn check_file(file: &File, length: u64) -> io::Result<()> {
    let stat = file.metadata()?;
    if !stat.is_file() || stat.len() != length {
        return Err(invalid("destination type or length changed"));
    }
    Ok(())
}
fn lock(file: &File) -> io::Result<()> {
    flock(file, FlockOperation::NonBlockingLockExclusive).map_err(Into::into)
}
fn invalid(message: &'static str) -> io::Error {
    io::Error::new(io::ErrorKind::InvalidInput, message)
}