Rust语言从入门到精通系列 - 零基础入门Win32 API开发(上)

Rust 语言是一种快速、安全、并发的系统编程语言。它的设计目标是为了提供更好的内存安全和线程安全，同时保持高性能。而 winapi 模块则是 Rust 语言的一个重要组成部分，它提供了与 Windows 操作系统 API 的交互能力。本教程将介绍 winapi 模块的基础用法和进阶用法，以及最佳实践。

本篇主要介绍 Win32 API 基础用法，进阶相关的内容在 Rust语言从入门到精通系列 - 零基础入门Win32 API开发(下)

基础用法#

Cargo.toml 文件引入依赖。

1
[target.'cfg(windows)'.dependencies]
2
winapi = { version = "0.3.9", features = ["winuser"] }

获取系统错误信息#

1
use winapi::um::errhandlingapi::GetLastError;
2

3
fn main() {
4
    let error_code = unsafe { GetLastError() };
5
    println!("Error code: {}", error_code);
6
}

获取桌面窗口句柄#

1
use winapi::um::winuser::GetDesktopWindow;
2
use winapi::um::winuser::HWND;
3

4
fn main() {
5
    let hwnd: HWND = unsafe { GetDesktopWindow() };
6
    println!("{:?}", hwnd);
7
}

在代码中，使用 GetDesktopWindow 函数获取桌面窗口句柄。使用 unsafe 关键字调用该函数，因为该函数是一个裸指针函数，需要手动管理内存安全。

创建窗口#

1
use std::ptr::null_mut;
2
use winapi::um::winuser::{CreateWindowExW, DefWindowProcW, RegisterClassW, CW_USEDEFAULT, MSG, WM_DESTROY, WNDCLASSW};
3

4
fn main() {
5
    let class_name = "MyWindowClass".to_wide_null();
6
    let window_name = "My Window".to_wide_null();
7
    let h_instance = unsafe { winapi::um::libloaderapi::GetModuleHandleW(null_mut()) };
8
    let wnd_class = WNDCLASSW {
9
        style: 0,
10
        lpfnWndProc: Some(DefWindowProcW),
11
        hInstance: h_instance,
12
        lpszClassName: class_name.as_ptr(),
13
        cbClsExtra: 0,
14
        cbWndExtra: 0,
15
        hIcon: null_mut(),
16
        hCursor: null_mut(),
17
        hbrBackground: null_mut(),
18
        lpszMenuName: null_mut(),
19
    };
20
    let class_atom = unsafe { RegisterClassW(&wnd_class) };
21
    let hwnd = unsafe {
22
        CreateWindowExW(
23
            0,
24
            class_atom as *const _,
25
            window_name.as_ptr(),
26
            0,
27
            CW_USEDEFAULT,
28
            CW_USEDEFAULT,
29
            CW_USEDEFAULT,
30
            CW_USEDEFAULT,
31
            null_mut(),
32
            null_mut(),
33
            h_instance,
34
            null_mut(),
35
        )
36
    };
37
    let mut msg = MSG::default();
38
    loop {
39
        let ret = unsafe { winapi::um::winuser::GetMessageW(&mut msg, null_mut(), 0, 0) };
40
        if ret > 0 {
41
            unsafe {
42
                winapi::um::winuser::TranslateMessage(&msg);
43
                winapi::um::winuser::DispatchMessageW(&msg);
44
            }
45
        } else {
46
            break;
47
        }
48
    }
49
}

打开文件对话框#

1
use std::ptr::null_mut;
2
use winapi::um::commdlg::{GetOpenFileNameW, OPENFILENAMEW};
3
use winapi::um::winuser::HWND;
4

5
fn main() {
6
    let mut ofn = OPENFILENAMEW {
7
        lStructSize: std::mem::size_of::<OPENFILENAMEW>() as u32,
8
        hwndOwner: HWND(null_mut()),
9
        lpstrFilter: "Text Files\0*.txt\0All Files\0*.*\0\0".to_wide_null().as_ptr(),
10
        lpstrFile: [0; 260].as_mut_ptr(),
11
        nMaxFile: 260,
12
        Flags: 0,
13
        lpstrDefExt: "txt\0".to_wide_null().as_ptr(),
14
        ..Default::default()
15
    };
16
    let ret = unsafe { GetOpenFileNameW(&mut ofn) };
17
    if ret != 0 {
18
        let file_name = ofn.lpstrFile.to_string_lossy();
19
        println!("Selected file: {}", file_name);
20
    }
21
}

读取注册表#

1
use std::ptr::null_mut;
2
use winapi::um::winreg::{RegCloseKey, RegOpenKeyExW, HKEY_LOCAL_MACHINE, KEY_READ, LPDWORD, REG_SZ};
3
use widestring::U16CString;
4

5
fn main() {
6
    let sub_key = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion".to_wide_null();
7
    let mut h_key = null_mut();
8
    let ret = unsafe { RegOpenKeyExW(HKEY_LOCAL_MACHINE, sub_key.as_ptr(), 0, KEY_READ, &mut h_key) };
9
    if ret == 0 {
10
        let mut buffer = [0u16; 1024];
11
        let mut buffer_size = (buffer.len() * 2) as u32;
12
        let mut value_type = REG_SZ;
13
        let ret = unsafe {
14
            winapi::um::winreg::RegQueryValueExW(
15
                h_key,
16
                "ProductName".to_wide_null().as_ptr(),
17
                null_mut(),
18
                &mut value_type,
19
                buffer.as_mut_ptr() as *mut _,
20
                &mut buffer_size,
21
            )
22
        };
23
        if ret == 0 {
24
            let value = U16CString::from_vec_with_nul(&buffer[..(buffer_size as usize)]).unwrap();
25
            println!("Product name: {}", value.to_string_lossy());
26
        }
27
        unsafe { RegCloseKey(h_key) };
28
    }
29
}

注册热键#

1
use winapi::um::winuser::{RegisterHotKey, UnregisterHotKey};
2
use winapi::um::winuser::{HWND, WM_HOTKEY};
3

4
fn main() {
5
    let hwnd: HWND = std::ptr::null_mut();
6
    let id: i32 = 1;
7
    let modifiers: u32 = 0x0002; // MOD_CONTROL
8
    let vk: u32 = 0x43; // 'C'
9
    let result: i32 = unsafe { RegisterHotKey(hwnd, id, modifiers, vk) };
10
    if result == 0 {
11
        println!("Failed to register hotkey.");
12
        return;
13
    }
14
    loop {
15
        let mut msg = std::mem::zeroed();
16
        let result = unsafe { winapi::um::winuser::GetMessageW(&mut msg, hwnd, 0, 0) };
17
        if result == -1 {
18
            println!("Failed to get message.");
19
            break;
20
        }
21
        if msg.message == WM_HOTKEY {
22
            println!("Hotkey pressed.");
23
            break;
24
        }
25
        unsafe { winapi::um::winuser::TranslateMessage(&msg) };
26
        unsafe { winapi::um::winuser::DispatchMessageW(&msg) };
27
    }
28
    unsafe { UnregisterHotKey(hwnd, id) };
29
}

在代码中，使用 RegisterHotKey 函数注册一个热键，当用户按下 Ctrl+C 时，会收到 WM_HOTKEY 消息。使用 GetMessageW 函数获取消息，使用 TranslateMessage 函数翻译消息，使用 DispatchMessageW 函数分发消息。使用 UnregisterHotKey 函数注销热键。

创建进程#

在 Windows 系统中，可以使用 CreateProcess 函数创建一个进程。使用 winapi 模块可以方便地调用 CreateProcess 函数。

1
use winapi::um::processthreadsapi::CreateProcessA;
2
use winapi::um::winbase::CREATE_NEW_CONSOLE;
3
use winapi::um::winnt::{PROCESS_INFORMATION, STARTUPINFOA};
4
use std::ffi::CString;
5
use std::mem::{size_of, zeroed};
6
use std::ptr::null_mut;
7

8
fn main() {
9
    let command_line = CString::new("notepad.exe").unwrap();
10
    let mut startup_info: STARTUPINFOA = unsafe { zeroed() };
11
    startup_info.cb = size_of::<STARTUPINFOA>() as u32;
12
    let mut process_info: PROCESS_INFORMATION = unsafe { zeroed() };
13
    let result = unsafe {
14
        CreateProcessA(
15
            null_mut(),
16
            command_line.as_ptr() as *mut _,
17
            null_mut(),
18
            null_mut(),
19
            0,
20
            CREATE_NEW_CONSOLE,
21
            null_mut(),
22
            null_mut(),
23
            &mut startup_info,
24
            &mut process_info,
25
        )
26
    };
27
    if result == 0 {
28
        println!("Failed to create process");
29
    } else {
30
        println!("Process created successfully");
31
    }
32
}

上述代码中，首先使用 CString 将字符串转换为 C 类型的字符串，然后使用 CreateProcessA 函数创建进程。CreateProcessA 函数的第一个参数是可执行文件的路径，第二个参数是命令行参数，第三个参数是进程的安全属性，第四个参数是主线程的安全属性，第五个参数是是否继承句柄，第六个参数是创建进程的标志，第七个参数是环境变量，第八个参数是当前目录，第九个参数是启动信息，第十个参数是进程信息。在这个示例中，使用了 null_mut()表示不设置进程和主线程的安全属性，使用了 CREATE_NEW_CONSOLE 表示创建一个新的控制台窗口。如果 CreateProcessA 函数返回 0，则说明创建进程失败。否则，创建进程成功。

创建线程#

1
use std::ptr::null_mut;
2
use std::thread;
3
use winapi::um::processthreadsapi::{CreateThread, GetCurrentThreadId, GetExitCodeThread, TerminateThread};
4
use winapi::um::synchapi::WaitForSingleObject;
5
use winapi::um::winbase::{INFINITE, WAIT_OBJECT_0};
6

7
fn thread_proc() -> u32 {
8
    println!("Thread ID: {}", unsafe { GetCurrentThreadId() });
9
    0
10
}
11

12
fn main() {
13
    let handle = unsafe { CreateThread(null_mut(), 0, Some(thread_proc), null_mut(), 0, null_mut()) };
14
    let ret = unsafe { WaitForSingleObject(handle, INFINITE) };
15
    if ret == WAIT_OBJECT_0 {
16
        let mut exit_code = 0;
17
        unsafe { GetExitCodeThread(handle, &mut exit_code) };
18
        println!("Exit code: {}", exit_code);
19
    }
20
    unsafe { TerminateThread(handle, 0) };
21
}

创建共享内存#

1
use std::ptr::null_mut;
2
use winapi::um::handleapi::{CloseHandle, INVALID_HANDLE_VALUE};
3
use winapi::um::memoryapi::{MapViewOfFile, UnmapViewOfFile, CreateFileMappingW, FILE_MAP_ALL_ACCESS};
4
use winapi::um::winnt::{HANDLE, PAGE_READWRITE, SECTION_ALL_ACCESS};
5

6
fn main() {
7
    let file_name = "Global\\MySharedMemory".to_wide_null();
8
    let file_size = 4096;
9
    let h_file_mapping = unsafe {
10
        CreateFileMappingW(
11
            INVALID_HANDLE_VALUE,
12
            null_mut(),
13
            PAGE_READWRITE,
14
            0,
15
            file_size,
16
            file_name.as_ptr(),
17
        )
18
    };
19
    let mut p_shared_memory = null_mut();
20
    if !h_file_mapping.is_null() {
21
        p_shared_memory = unsafe {
22
            MapViewOfFile(
23
                h_file_mapping,
24
                FILE_MAP_ALL_ACCESS,
25
                0,
26
                0,
27
                file_size,
28
            )
29
        };
30
    }
31
    if !p_shared_memory.is_null() {
32
        let p_data = p_shared_memory as *mut u8;
33
        for i in 0..file_size {
34
            unsafe { *p_data.offset(i as isize) = i as u8 };
35
        }
36
        unsafe { UnmapViewOfFile(p_shared_memory) };
37
    }
38
    if !h_file_mapping.is_null() {
39
        unsafe { CloseHandle(h_file_mapping) };
40
    }
41
}

获取系统时间#

获取系统时间是一个常见的操作，可以用于记录日志或计算时间差等。下面是一个使用 winapi 模块获取系统时间的示例：

1
use winapi::um::sysinfoapi::GetSystemTime;
2
use winapi::um::winbase::SYSTEMTIME;
3

4
fn main() {
5
    unsafe {
6
        let mut st: SYSTEMTIME = std::mem::zeroed();
7
        GetSystemTime(&mut st as *mut SYSTEMTIME);
8
        println!("{}-{}-{} {}:{}:{}", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
9
    }
10
}

在这个示例中，我们使用了 sysinfoapi 模块中的 GetSystemTime 函数来获取系统时间。该函数的参数为一个 SYSTEMTIME 结构体指针，用于存储系统时间。我们使用 std::mem::zeroed()创建了一个空的 SYSTEMTIME 结构体，然后将其地址传递给 GetSystemTime 函数。最后，我们将获取到的系统时间打印出来。

使用 COM 组件#

1
use std::ptr::null_mut;
2
use winapi::um::combaseapi::{CoInitializeEx, CoCreateInstance, CoUninitialize};
3
use winapi::um::objbase::COINIT_APARTMENTTHREADED;
4
use winapi::um::objidl::ISequentialStream;
5
use winapi::um::unknwnbase::IUnknown;
6
use winapi::um::winnt::{HRESULT, S_OK};
7
use winapi::um::winuser::MessageBoxW;
8
use winapi::Interface;
9

10
const CLSID_XMLHTTPREQUEST: winapi::CLSID = winapi::CLSID {
11
    Data1: 0xED8C108E,
12
    Data2: 0x4349,
13
    Data3: 0x11D2,
14
    Data4: [0x91, 0xA4, 0x00, 0xC0, 0x4F, 0x79, 0xF8, 0x06],
15
};
16

17
const IID_IUNKNOWN: winapi::IID = winapi::IID {
18
    Data1: 0x00000000,
19
    Data2: 0x0000,
20
    Data3: 0x0000,
21
    Data4: [0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46],
22
};
23

24
fn main() {
25
    unsafe {
26
        CoInitializeEx(null_mut(), COINIT_APARTMENTTHREADED);
27
        let mut p_xml_http_request: *mut IUnknown = null_mut();
28
        let hr = CoCreateInstance(
29
            &CLSID_XMLHTTPREQUEST,
30
            null_mut(),
31
            winapi::um::combaseapi::CLSCTX_INPROC_SERVER,
32
            &IID_IUNKNOWN,
33
            &mut p_xml_http_request as *mut _ as *mut *mut _,
34
        );
35
        if hr == S_OK {
36
            let mut p_stream: *mut ISequentialStream = null_mut();
37
            let hr = (*p_xml_http_request).QueryInterface(
38
                &ISequentialStream::uuidof(),
39
                &mut p_stream as *mut _ as *mut *mut _,
40
            );
41
            if hr == S_OK {
42
                let message = "Hello, world!".to_wide_null();
43
                let mut bytes_written = 0;
44
                let hr = (*p_stream).Write(
45
                    message.as_ptr() as *const _,
46
                    (message.len() * 2) as u32,
47
                    &mut bytes_written as *mut _,
48
                );
49
                if hr == S_OK {
50
                    MessageBoxW(
51
                        null_mut(),
52
                        "Data written successfully!".to_wide_null().as_ptr(),
53
                        "Success\0".to_wide_null().as_ptr(),
54
                        0,
55
                    );
56
                }
57
            }
58
            (*p_stream).Release();
59
        }
60
        (*p_xml_http_request).Release();
61
        CoUninitialize();
62
    }
63
}

结论#

本教程介绍了 winapi 模块的基础用法和进阶用法，并提供了示例代码。在使用 winapi 模块时，需要注意数据类型、结构体、常量和指针类型的正确使用。通过使用 winapi 模块，Rust 程序可以访问 Windows 操作系统的核心功能，实现更加丰富的功能。

音乐

音乐