ib-shell-item 0.2.0

A library for operating file system files / Windows Shell items.
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
110
111
112
113
114
115
116
117
118

use std::{
    fs,
    path::PathBuf,
    process::exit,
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    },
    thread,
    time::Duration,
};

use clap::Parser;
use ib_shell_item::hook::{
    HookConfig,
    display_name::DisplayNameHookConfig,
    folder::FolderHookConfig,
    inject::ShellItemHooks,
    prop::{PropertyHookConfig, system::PropertySystemHookConfig},
};
use tracing::{error, info};

#[derive(Parser)]
#[command(name = "inject-hook")]
#[command(about = "Inject shell item hooks into the process", long_about = None)]
struct Args {
    /// Build profile (debug or release)
    #[arg(short, long)]
    profile: String,
}

fn main() {
    tracing_subscriber::fmt::init();

    let args = Args::parse();

    let dll_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .unwrap()
        .join("target")
        .join(&args.profile)
        .join("examples")
        .join("hook.dll");

    let log_path = std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .join("hook.log");
    _ = fs::remove_file(&log_path);

    let mut hooks = match ShellItemHooks::inject()
        .dll_path(&dll_path)
        .config(
            HookConfig::builder()
                .enabled(true)
                .display_name(
                    DisplayNameHookConfig::builder()
                        .display_prefix(widestring::u16str!("😭").as_slice())
                        .edit_prefix(widestring::u16str!("😭").as_slice())
                        .build(),
                )
                .folder({
                    let folder = FolderHookConfig::builder();
                    #[cfg(feature = "everything")]
                    let folder = folder.compare_size_from_everything(true);
                    folder.build()
                })
                .property({
                    let property = PropertyHookConfig::builder()
                        .str_prefix(widestring::u16str!("💢").as_slice())
                        .system(
                            PropertySystemHookConfig::builder()
                                .size_no_alwayskb(true)
                                .size_max_bar(true)
                                .build(),
                        );
                    #[cfg(feature = "everything")]
                    let property = property.size_from_everything(true);
                    property.build()
                })
                .log(log_path)
                .build(),
        )
        .call()
    {
        Ok(hooks) => hooks,
        Err(e) => {
            error!("Error: {}", e);
            exit(1);
        }
    };

    info!("Press Ctrl+C to eject and exit...");

    // Set up signal handler for Ctrl+C
    let running = Arc::new(AtomicBool::new(true));
    let r = Arc::clone(&running);

    ctrlc::set_handler(move || {
        r.store(false, Ordering::SeqCst);
    })
    .expect("Error setting Ctrl-C handler");

    // Wait for Ctrl+C
    while running.load(Ordering::SeqCst) {
        thread::sleep(Duration::from_secs(1));
    }

    info!("Disabling hooks and ejecting DLL...");

    if let Err(e) = hooks.eject() {
        error!("Error ejecting: {}", e);
        exit(1);
    }

    info!("Successfully ejected DLL");
}