udisks2 0.3.1

Unofficial crate for interacting with the UDisks2 API
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

use std::{
    collections::HashMap,
    fs,
    os::{linux::fs::MetadataExt, unix::fs::FileTypeExt},
    process::ExitCode,
};

// https://github.com/storaged-project/udisks/blob/master/tools/umount-udisks.c

#[tokio::main]
async fn main() -> ExitCode {
    let mut args = std::env::args();
    let bin_name = args.next().unwrap();

    let Some(path) = args.next() else {
        eprintln!(
            "{}: this program is only supposed to be invoked by umount(8).",
            bin_name
        );
        return ExitCode::FAILURE;
    };

    let block_device = match fs::metadata(&path) {
        Ok(data) if data.file_type().is_block_device() => data.st_rdev(),
        Ok(data) => data.st_dev(),
        Err(err) => {
            eprintln!("{}: error calling stat on {}: {}).", bin_name, path, err);
            return ExitCode::FAILURE;
        }
    };

    let Ok(client) = udisks2::Client::new().await else {
        eprintln!("Error connecting to the udisks daemon");
        return ExitCode::FAILURE;
    };

    let Some(object) = lookup_object_for_block(&client, block_device).await else {
        eprintln!(
            "Error finding object for block device {}:{}",
            major(block_device),
            minor(block_device)
        );
        return ExitCode::FAILURE;
    };

    let Ok(filesystem) = object.filesystem().await else {
        eprintln!(
            "Block device {}:{} is not a mountable filesystem",
            major(block_device),
            minor(block_device)
        );
        return ExitCode::FAILURE;
    };

    if let Err(err) = filesystem.unmount(HashMap::new()).await {
        eprintln!(
            "Error unmounting block device {}:{}: {}",
            major(block_device),
            minor(block_device),
            err
        );
        return ExitCode::FAILURE;
    }

    return ExitCode::SUCCESS;
}

async fn lookup_object_for_block(
    client: &udisks2::Client,
    block_device: u64,
) -> Option<udisks2::Object> {
    for object in client
        .object_manager()
        .get_managed_objects()
        .await
        .into_iter()
        .flatten()
        .filter_map(|(object_path, _)| client.object(object_path).ok())
    {
        if let Ok(block) = object.block().await {
            if Ok(block_device) == block.device_number().await {
                return Some(object);
            }
        };
    }
    None
}
pub fn major(dev: u64) -> u32 {
    let mut major = 0;
    major |= (dev & 0x00000000000fff00) >> 8;
    major |= (dev & 0xfffff00000000000) >> 32;
    major as u32
}

pub fn minor(dev: u64) -> u32 {
    let mut minor = 0;
    minor |= (dev & 0x00000000000000ff) >> 0;
    minor |= (dev & 0x00000ffffff00000) >> 12;
    minor as u32
}