Crate winreg 

Crate for accessing MS Windows registry

Usage

Basic usage

# Cargo.toml
[dependencies]
winreg = "0.56"

use std::io;
use std::path::Path;
use winreg::enums::*;
use winreg::{HKCU, HKLM};

fn main() -> io::Result<()> {
    println!("Reading some system info...");
    let cur_ver = HKLM.open_subkey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion")?;
    let pf: String = cur_ver.get_value("ProgramFilesDir")?;
    let dp: String = cur_ver.get_value("DevicePath")?;
    println!("ProgramFiles = {}\nDevicePath = {}", pf, dp);
    let info = cur_ver.query_info()?;
    println!("info = {:?}", info);
    let mt = info.get_last_write_time_system();
    println!(
        "last_write_time as windows_sys::Win32::Foundation::SYSTEMTIME = {}-{:02}-{:02} {:02}:{:02}:{:02}",
        mt.wYear, mt.wMonth, mt.wDay, mt.wHour, mt.wMinute, mt.wSecond
    );

    // enable `chrono` feature on `winreg` to make this work
    // println!(
    //     "last_write_time as chrono::NaiveDateTime = {}",
    //     info.get_last_write_time_chrono()
    // );

    println!("And now lets write something...");
    let path = Path::new("Software").join("WinregRsExample1");
    let (key, disp) = HKCU.create_subkey(&path)?;

    match disp {
        REG_CREATED_NEW_KEY => println!("A new key has been created"),
        REG_OPENED_EXISTING_KEY => println!("An existing key has been opened"),
    }

    key.set_value("TestSZ", &"written by Rust")?;
    let sz_val: String = key.get_value("TestSZ")?;
    key.delete_value("TestSZ")?;
    println!("TestSZ = {}", sz_val);

    key.set_value("TestMultiSZ", &vec!["written", "by", "Rust"])?;
    let multi_sz_val: Vec<String> = key.get_value("TestMultiSZ")?;
    key.delete_value("TestMultiSZ")?;
    println!("TestMultiSZ = {:?}", multi_sz_val);

    key.set_value("TestDWORD", &1234567890u32)?;
    let dword_val: u32 = key.get_value("TestDWORD")?;
    println!("TestDWORD = {}", dword_val);

    key.set_value("TestQWORD", &1234567891011121314u64)?;
    let qword_val: u64 = key.get_value("TestQWORD")?;
    println!("TestQWORD = {}", qword_val);

    key.create_subkey("sub\\key")?;
    HKCU.delete_subkey_all(&path)?;

    println!("Trying to open nonexistent key...");
    HKCU.open_subkey(&path).unwrap_or_else(|e| match e.kind() {
        io::ErrorKind::NotFound => panic!("Key doesn't exist"),
        io::ErrorKind::PermissionDenied => panic!("Access denied"),
        _ => panic!("{:?}", e),
    });
    Ok(())
}

Iterators

use std::io;
use winreg::{HKCR, HKLM};

fn main() -> io::Result<()> {
    println!("File extensions, registered in system:");
    for i in HKCR.enum_keys().map(|x| x.unwrap())
        .filter(|x| x.starts_with("."))
    {
        println!("{}", i);
    }

    let system = HKLM.open_subkey("HARDWARE\\DESCRIPTION\\System")?;
    for (name, value) in system.enum_values().map(|x| x.unwrap()) {
        println!("{} = {:?}", name, value);
    }

    Ok(())
}

Re-exports

pub use crate::reg_key::RegKey;

pub use crate::reg_key::HKCC;

pub use crate::reg_key::HKCR;

pub use crate::reg_key::HKCU;

pub use crate::reg_key::HKLM;

pub use crate::reg_key::HKU;

pub use crate::enum_keys::EnumKeys;

pub use crate::enum_keys_os_string::EnumKeysOsString;

pub use crate::enum_values::EnumValues;

pub use crate::enum_values_os_string::EnumValuesOsString;

pub use crate::reg_key_metadata::RegKeyMetadata;

pub use crate::reg_value::RegValue;

Modules

decoder

encoder

enum_keys

enum_keys_os_string

enum_values

enum_values_os_string

enums

use winreg::enums::*; to import all needed enumerations and constants

reg_key

reg_key_metadata

reg_value

transaction

Structure for a registry transaction. Part of transactions feature.

types

Traits for loading/saving Registry values

Type Aliases

HKEY