{"componentChunkName":"component---src-templates-post-template-js","path":"/rust-winapi-createfilepapping-en","result":{"data":{"markdownRemark":{"id":"e051b360-f3d1-5f3e-a195-8b036d746e47","html":"
\n

This page has been machine-translated from the original page.

\n
\n

Continuing from the previous articles, this time I tried implementing a program in Rust that uses APIs such as CreateFileMapping through the windows crate.

\n\n

Table of Contents

\n\n

The code I created

\n

In the following program, I create file-mapping objects in process memory using both the paging file and a text file, and then write data to them.

\n
// cargo run --bin CreateFileMap\n\nuse windows::Win32::{\n    Foundation::{ HANDLE, INVALID_HANDLE_VALUE, CloseHandle },\n    System::Memory::{ CreateFileMappingW, MapViewOfFile, UnmapViewOfFile, FILE_MAP_ALL_ACCESS, PAGE_READWRITE}\n};\n\nuse std::{\n    fs::OpenOptions,\n    io::stdin,\n    os::windows::io::AsRawHandle,\n    ptr::{ copy_nonoverlapping, null_mut }\n};\n\nfn get_input(input_string: &str) {\n    println!(\"{}\", input_string);\n    let mut input = String::new();\n    stdin().read_line(&mut input).expect(\"Failed to read input.\");\n    return;\n}\n\nfn create_memory_mapping() {\n        unsafe {\n        let size: usize = 1024;\n\n        let h_mapping = CreateFileMappingW(\n            INVALID_HANDLE_VALUE,\n            Some(null_mut()),\n            PAGE_READWRITE,\n            0,\n            size as u32,\n            None,\n        ).unwrap();\n\n        if h_mapping == INVALID_HANDLE_VALUE {\n            eprintln!(\"CreateFileMappingW failed\");\n        } else {\n            println!(\"Mapping handle created: {:?}.\", h_mapping);\n        }\n\n        get_input(\"Please enter the key...\");\n\n        let p_view = MapViewOfFile(h_mapping, FILE_MAP_ALL_ACCESS, 0, 0, size);\n        if p_view.Value.is_null() {\n            eprintln!(\"MapViewOfFile failed\");\n        } else {\n            println!(\"MapViewOfFile created: {:?}.\", p_view);\n        }\n\n        get_input(\"Please enter the key...\");\n\n        let data = b\"Hello from Rust!\";\n        std::ptr::copy_nonoverlapping(data.as_ptr(), p_view.Value as *mut u8, data.len());\n        println!(\"Data written to shared memory: {:?}\", &data);\n\n        get_input(\"create_memory_mapping finished.\");\n\n        let _ = UnmapViewOfFile(p_view);\n        let _ = CloseHandle(h_mapping);\n\n    }\n\n    return;\n\n}\n\n\nfn read_file_and_create_file_maipping() {\n\n    let size: usize = 32;\n    let path = \"C:\\\\Users\\\\kash1064\\\\Documents\\\\Dev\\\\WinAPITest\\\\test.txt\";\n    let file = OpenOptions::new().read(true).write(true).create(true).open(path).unwrap();\n    // let file_size = file.metadata().unwrap().len();\n    let h_file = HANDLE(file.as_raw_handle());\n\n    unsafe {\n\n        let h_mapping = CreateFileMappingW(\n            h_file,\n            Some(null_mut()),\n            PAGE_READWRITE,\n            0,\n            size as u32,\n            None,\n        ).unwrap();\n\n        if h_mapping == INVALID_HANDLE_VALUE {\n            eprintln!(\"CreateFileMappingW failed\");\n        } else {\n            println!(\"Mapping handle created: {:?}.\", h_mapping);\n        }\n\n\n        get_input(\"Please enter the key...\");\n\n        let p_view = MapViewOfFile(h_mapping, FILE_MAP_ALL_ACCESS, 0, 0, size);\n        if p_view.Value.is_null() {\n            eprintln!(\"MapViewOfFile failed\");\n        } else {\n            println!(\"MapViewOfFile created: {:?}.\", p_view);\n        }\n\n        get_input(\"Please enter the key...\");\n\n        let data = b\"Hello from Rust!\";\n        copy_nonoverlapping(data.as_ptr(), p_view.Value as *mut u8, data.len());\n        println!(\"Data written to shared memory: {:?}\", &data);\n\n        get_input(\"read_file_and_create_file_maipping finished.\");\n    \n        let _ = UnmapViewOfFile(p_view);\n        let _ = CloseHandle(h_mapping);\n\n    }\n\n    return;\n}\n\n\nfn main() {\n\n    create_memory_mapping();\n\n    read_file_and_create_file_maipping();\n\n    return;\n\n}
\n

Loaded modules

\n

For this example, I load the following modules.

\n

I also use several standard library modules.

\n
use windows::Win32::{\n    Foundation::{ HANDLE, INVALID_HANDLE_VALUE, CloseHandle },\n    System::Memory::{ CreateFileMappingW, MapViewOfFile, UnmapViewOfFile, FILE_MAP_ALL_ACCESS, PAGE_READWRITE}\n};\n\nuse std::{\n    fs::OpenOptions,\n    io::stdin,\n    os::windows::io::AsRawHandle,\n    ptr::null_mut\n};
\n

Receiving standard input

\n

For this example, I created the following function to receive standard input.

\n
fn get_input(input_string: &str) {\n    println!(\"{}\", input_string);\n    let mut input = String::new();\n    stdin().read_line(&mut input).expect(\"Failed to read input.\");\n    return;\n}
\n

My impression was that Rust requires slightly more code than other languages to receive standard input.

\n

I wanted to do something like Python’s input(\"Please input: \"), but there did not seem to be a library function that could be used with exactly the same feel, so I defined it myself as the get_input function.

\n

The input itself is received with stdin().read_line(&mut input).

\n

Because this returns Result<usize>, I use expect to customize the error message when a panic occurs.

\n

Reference: Stdin in std::io - Rust

\n

Using the CreateFileMappingW API

\n

In this program, I created two functions that use the CreateFileMappingW API.

\n

One sets the first argument of the CreateFileMappingW function to INVALID_HANDLE_VALUE and uses the paging file, while the other uses a file named test.txt in local storage.

\n

Reference: CreateFileMappingW function (memoryapi.h) - Win32 apps | Microsoft Learn

\n

Reference: Creating Named Shared Memory - Win32 apps | Microsoft Learn

\n

Creating a page-file mapping

\n

In the create_memory_mapping function, I implemented the following code.

\n

The CreateFileMappingW function in the windows crate returns Result<HANDLE>, so I use unwrap() to obtain the HANDLE object.

\n

Also, because INVALID_HANDLE_VALUE is specified for the first argument at this point, the returned HANDLE should be a handle to a paging file mapped into memory.

\n
let size: usize = 1024;\n\nlet h_mapping = CreateFileMappingW(\n    INVALID_HANDLE_VALUE,\n    Some(null_mut()),\n    PAGE_READWRITE,\n    0,\n    size as u32,\n    None,\n).unwrap();\n\nif h_mapping == INVALID_HANDLE_VALUE {\n    eprintln!(\"CreateFileMappingW failed\");\n} else {\n    println!(\"Mapping handle created: {:?}.\", h_mapping);\n}
\n

The second argument to CreateFileMappingW must be an LPSECURITY_ATTRIBUTES that specifies whether child processes can inherit the returned handle, but that is unnecessary here, so I specify NULL.

\n

In the windows crate, CreateFileMappingW expects this argument as Option<*const SECURITY_ATTRIBUTES>, so to pass a NULL pointer as an Option, I wrap the standard library function null_mut() in Some().

\n

\n \n \n \n \n \n \n \n \n

\n

Reference: CreateFileMappingW in windows::Win32::System::Memory - Rust

\n

Mapping a file into memory

\n

In the other function, read_file_and_create_file_maipping, I obtain a file handle for test.txt located at C:\\Folder\\test.txt on the local machine, and use CreateFileMappingW to create a mapping for it in process memory.

\n
let size: usize = 32;\nlet path = \"C:\\\\Folder\\\\test.txt\";\nlet file = OpenOptions::new().read(true).write(true).create(true).open(path).unwrap();\n// let file_size = file.metadata().unwrap().len();\nlet h_file = HANDLE(file.as_raw_handle());\n\n\nlet h_mapping = CreateFileMappingW(\n    h_file,\n    Some(null_mut()),\n    PAGE_READWRITE,\n    0,\n    size as u32,\n    None,\n).unwrap();\n\nif h_mapping == INVALID_HANDLE_VALUE {\n    eprintln!(\"CreateFileMappingW failed\");\n} else {\n    println!(\"Mapping handle created: {:?}.\", h_mapping);\n}
\n

To obtain the file handle, I use the standard library functions std::fs::OpenOptions and std::os::windows::io::AsRawHandle.

\n

With OpenOptions, you can open a file after specifying options as in the following example.

\n

Because OpenOptions::new().open(path) returns Result<File>, I use unwrap() to extract the File object.

\n

\n \n \n \n \n \n \n \n \n

\n

Reference: AsRawHandle in std::os::windows::io - Rust

\n

This HANDLE object can be used as-is as an argument to the CreateFileMappingW function in the windows crate, so I use it to obtain a handle to the mapping object for test.txt.

\n

Loading the file mapping into process memory with MapViewOfFile

\n

Using the handle to the file-mapping object obtained in the code above as an argument, I load it into process memory with MapViewOfFile and obtain its address.

\n
let p_view = MapViewOfFile(h_mapping, FILE_MAP_ALL_ACCESS, 0, 0, size);\nif p_view.Value.is_null() {\n    eprintln!(\"MapViewOfFile failed\");\n} else {\n    println!(\"MapViewOfFile created: {:?}.\", p_view);\n}
\n

Reference: MapViewOfFile in windows::Win32::System::Memory - Rust

\n

For the access rights, I specify FILE_MAP_ALL_ACCESS, which allows reading and writing.

\n

Reference: MapViewOfFile function (memoryapi.h) - Win32 apps | Microsoft Learn

\n

Writing data to the mapped memory

\n

Finally, I write data to the region mapped into process memory with copy_nonoverlapping.

\n
let data = b\"Hello from Rust!\";\ncopy_nonoverlapping(data.as_ptr(), p_view.Value as *mut u8, data.len());\nprintln!(\"Data written to shared memory: {:?}\", &data);
\n

The copy_nonoverlapping function copies an arbitrary amount of data to a specified address, so it can perform an operation equivalent to C’s memcpy.

\n

Therefore, I write data into process memory by passing the pointer to the hard-coded text and the pointer address obtained by casting the *mut c_void extracted with .Value from the MEMORY_MAPPED_VIEW_ADDRESS returned by MapViewOfFile to *mut u8.

\n

Reference: copy_nonoverlapping in std::ptr - Rust

\n

By running this code, the specified text is written to the mapped region of process memory.

\n

\n \n \n \n \n \n \n \n \n

\n

Also, by writing data to the region mapped from the test.txt file, you can confirm that 32 bytes of data including Hello from Rust! are written to the target file.

\n

\n \n \n \n \n \n \n \n \n

\n

Summary

\n

I am using various Windows APIs while also learning Rust.

\n

I am happy that they are gradually starting to feel more familiar.

","fields":{"slug":"/rust-winapi-createfilepapping-en","tagSlugs":["/tag/rust/","/tag/windows/","/tag/rust-win-api/","/tag/english/"]},"frontmatter":{"date":"2025-04-12","description":"I used Windows APIs in Rust to perform file mapping.","tags":["Rust","Windows","Rust-WinAPI","English"],"title":"Using Windows APIs for File Mapping in Rust","socialImage":{"publicURL":"/static/526bc59ae3199973998e54d34d91ac6d/rust-winapi-createfilepapping.png"}}}},"pageContext":{"slug":"/rust-winapi-createfilepapping-en"}},"staticQueryHashes":["251939775","401334301","825871152"]}