moon-driver-utils 0.1.0

Windows Kernel Utils
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

use core::ffi::c_void;

use wdk::println;
use wdk_sys::{
    ntddk::{
        ExAllocatePool, ExFreePool, KeCancelTimer, KeInitializeDpc, KeInitializeTimerEx,
        KeInsertQueueDpc, KeSetTimerEx,
    },
    KDPC, KTIMER, LARGE_INTEGER, PKDEFERRED_ROUTINE,
    _POOL_TYPE::NonPagedPool,
    _TIMER_TYPE::SynchronizationTimer,
};

pub struct Timer {
    timer: *mut KTIMER,
    dpc: *mut KDPC,
    started: bool,
}

impl Timer {
    /// # Safety
    ///
    /// arg
    pub unsafe fn new(callback: PKDEFERRED_ROUTINE, arg: *mut c_void) -> Self {
        let mut r = Timer {
            timer: core::ptr::null_mut(),
            dpc: core::ptr::null_mut(),
            started: false,
        };

        unsafe {
            r.timer = ExAllocatePool(NonPagedPool, core::mem::size_of::<KTIMER>() as _) as _;
            r.dpc = ExAllocatePool(NonPagedPool, core::mem::size_of::<KDPC>() as _) as _;
        }

        // println!("{:p},{:p}", r.timer, r.dpc);

        unsafe {
            KeInitializeDpc(r.dpc, callback, arg);
            KeInsertQueueDpc(r.dpc, core::ptr::null_mut(), core::ptr::null_mut());
            KeInitializeTimerEx(r.timer, SynchronizationTimer);
        };

        r
    }

    pub fn start(&mut self, sec: i64) {
        if self.started {
            return;
        }

        println!("start timer");

        let mut interval = LARGE_INTEGER::default();
        interval.QuadPart = sec * -10000; // 5 seconds

        unsafe {
            KeSetTimerEx(self.timer, interval, sec as _, self.dpc);
            self.started = true;
        };
    }

    pub fn stop(&mut self) {
        if !self.started {
            return;
        }

        unsafe {
            KeCancelTimer(self.timer);
            self.started = false;
        }
    }
}

impl Drop for Timer {
    fn drop(&mut self) {
        println!("drop timer");

        if self.started {
            unsafe {
                KeCancelTimer(self.timer);
            }
        }

        if !self.timer.is_null() {
            unsafe {
                ExFreePool(self.timer as _);
            }
        }

        if !self.dpc.is_null() {
            unsafe {
                ExFreePool(self.dpc as _);
            }
        }
    }
}