diff options
Diffstat (limited to 'third_party/rust/winreg')
23 files changed, 4135 insertions, 0 deletions
diff --git a/third_party/rust/winreg/.cargo-checksum.json b/third_party/rust/winreg/.cargo-checksum.json new file mode 100644 index 0000000000..c0feadd1a0 --- /dev/null +++ b/third_party/rust/winreg/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"Cargo.lock":"818308f83f82333925a5c79a33070576296820a9ca6f619b3be3b89918916f22","Cargo.toml":"7462003029eaddf0220e48731744d83b9e91b40a71c33ee13543b65995c4fb52","LICENSE":"ea021d8c6383c84d19c15ce90d3b1602cf448fdcc0bf3772c98e43c7bf1bf1d1","README.md":"37ad193ded0a105eecea15743a76249c6ec735b82a06b78312052648564eccb5","appveyor.yml":"92f6bab3b9609448c48983d6c418fb9061dbd851a9d804ccd923f7e34ab742f1","build.rs":"3d34e0c23f6c21e6da11fb0fc3aff792b8f30f3ecfbb6b4f536d0a70394e13e7","examples/basic_usage.rs":"e7dd3af233d3aca6a92676eab2ac55414af1477d4214e7c1c2cdbdf583c83fa1","examples/enum.rs":"9be94d7dde12fc49a3fbe5c7810a6a9ad28eaac9319271e1cabda121301e08f3","examples/installed_apps.rs":"595709b6453b1efb5c613e69795d6f6576d45762867de1ee7247f2c3e988edbb","examples/load_app_key.rs":"16275c44efa22519101c199903c53e0cdca5ad4ebdcb39939c5a285de2fa006c","examples/map_key_serialization.rs":"82b102a36c91f99e8eeb2d1cfde13131f087457de1c84db3af31097fdb4541b0","examples/serialization.rs":"7f5c0e7e50872c9655cf4e54b4efb54a8bc19113dc645279496b8e3d20109295","examples/transactions.rs":"8094aa5dcecedae3acef58ece3ed264a44e908c12cfd4a65ff8c90254dbc7225","src/decoder/mod.rs":"75318907ca32ff0aa3af9bf63be9d728a76d7a75f7d1fdb88bcb3a9df4abeb01","src/decoder/serialization_serde.rs":"3f7cc4249dbff8255ed40cd4a3b4416779ddbad4bd476032094259a8668d0cd2","src/encoder/mod.rs":"a5331802cbe374e0c511aa1335fa32d7bbb3aa972cb136df3fc585b3f3855cf5","src/encoder/serialization_serde.rs":"d63037eb017fd2ece03ed4a140baf2a75516a3ef0315bf10a3eb16d5455880d6","src/enums.rs":"d69acf7106672a1cf2b43091faa12de98d5cf400872e1fcbe6e1891ba5d185ae","src/lib.rs":"130872ae9e213c8705592f3e1eac3245029f93e2c22c8f2337e3ecea25152d49","src/transaction.rs":"adaeecac01dc5886b90ab4ef03889ddd136ce26206dfa8f8da7410f0db80a742","src/types.rs":"d0c3ebc2aaab2f0fac426e60701acefa435c91812540d52dba1532664a0301ee","tests/reg_key.rs":"8a59b554230545e15a3affa82fb6d9061b45ac15e777df6cc383b725b8f4ad93"},"package":"80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"}
\ No newline at end of file diff --git a/third_party/rust/winreg/Cargo.lock b/third_party/rust/winreg/Cargo.lock new file mode 100644 index 0000000000..e021632fd1 --- /dev/null +++ b/third_party/rust/winreg/Cargo.lock @@ -0,0 +1,350 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "autocfg" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2" + +[[package]] +name = "autocfg" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a" + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "cfg-if" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" + +[[package]] +name = "chrono" +version = "0.4.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73" +dependencies = [ + "libc", + "num-integer", + "num-traits", + "time", + "winapi", +] + +[[package]] +name = "cloudabi" +version = "0.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f" +dependencies = [ + "bitflags", +] + +[[package]] +name = "fuchsia-cprng" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" + +[[package]] +name = "libc" +version = "0.2.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21" + +[[package]] +name = "num-integer" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db" +dependencies = [ + "autocfg 1.0.1", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290" +dependencies = [ + "autocfg 1.0.1", +] + +[[package]] +name = "proc-macro2" +version = "1.0.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rand" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64ac302d8f83c0c1974bf758f6b041c6c8ada916fbb44a609158ca8b064cc76c" +dependencies = [ + "libc", + "rand 0.4.6", +] + +[[package]] +name = "rand" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293" +dependencies = [ + "fuchsia-cprng", + "libc", + "rand_core 0.3.1", + "rdrand", + "winapi", +] + +[[package]] +name = "rand" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d71dacdc3c88c1fde3885a3be3fbab9f35724e6ce99467f7d9c5026132184ca" +dependencies = [ + "autocfg 0.1.7", + "libc", + "rand_chacha", + "rand_core 0.4.2", + "rand_hc", + "rand_isaac", + "rand_jitter", + "rand_os", + "rand_pcg", + "rand_xorshift", + "winapi", +] + +[[package]] +name = "rand_chacha" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "556d3a1ca6600bfcbab7c7c91ccb085ac7fbbcd70e008a98742e7847f4f7bcef" +dependencies = [ + "autocfg 0.1.7", + "rand_core 0.3.1", +] + +[[package]] +name = "rand_core" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b" +dependencies = [ + "rand_core 0.4.2", +] + +[[package]] +name = "rand_core" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc" + +[[package]] +name = "rand_hc" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b40677c7be09ae76218dc623efbf7b18e34bced3f38883af07bb75630a21bc4" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rand_isaac" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ded997c9d5f13925be2a6fd7e66bf1872597f759fd9dd93513dd7e92e5a5ee08" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rand_jitter" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b" +dependencies = [ + "libc", + "rand_core 0.4.2", + "winapi", +] + +[[package]] +name = "rand_os" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b75f676a1e053fc562eafbb47838d67c84801e38fc1ba459e8f180deabd5071" +dependencies = [ + "cloudabi", + "fuchsia-cprng", + "libc", + "rand_core 0.4.2", + "rdrand", + "winapi", +] + +[[package]] +name = "rand_pcg" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abf9b09b01790cfe0364f52bf32995ea3c39f4d2dd011eac241d2914146d0b44" +dependencies = [ + "autocfg 0.1.7", + "rand_core 0.4.2", +] + +[[package]] +name = "rand_xorshift" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbf7e9e623549b0e21f6e97cf8ecf247c1a8fd2e8a992ae265314300b2455d5c" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "rdrand" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2" +dependencies = [ + "rand_core 0.3.1", +] + +[[package]] +name = "redox_syscall" +version = "0.1.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce" + +[[package]] +name = "remove_dir_all" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7" +dependencies = [ + "winapi", +] + +[[package]] +name = "serde" +version = "1.0.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913" + +[[package]] +name = "serde_derive" +version = "1.0.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "syn" +version = "1.0.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f107db402c2c2055242dbf4d2af0e69197202e9faacbef9571bbe47f5a1b84" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "tempfile" +version = "3.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dc4738f2e68ed2855de5ac9cdbe05c9216773ecde4739b2f095002ab03a13ef" +dependencies = [ + "cfg-if", + "libc", + "rand 0.6.5", + "redox_syscall", + "remove_dir_all", + "winapi", +] + +[[package]] +name = "time" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255" +dependencies = [ + "libc", + "wasi", + "winapi", +] + +[[package]] +name = "unicode-xid" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" + +[[package]] +name = "wasi" +version = "0.10.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f" + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "winreg" +version = "0.10.1" +dependencies = [ + "chrono", + "rand 0.3.23", + "serde", + "serde_derive", + "tempfile", + "winapi", +] diff --git a/third_party/rust/winreg/Cargo.toml b/third_party/rust/winreg/Cargo.toml new file mode 100644 index 0000000000..adb2e88655 --- /dev/null +++ b/third_party/rust/winreg/Cargo.toml @@ -0,0 +1,75 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies +# +# If you believe there's an error in this file please file an +# issue against the rust-lang/cargo repository. If you're +# editing this file be aware that the upstream Cargo.toml +# will likely look very different (and much more reasonable) + +[package] +name = "winreg" +version = "0.10.1" +authors = ["Igor Shaula <gentoo90@gmail.com>"] +description = "Rust bindings to MS Windows Registry API" +documentation = "https://docs.rs/winreg" +readme = "README.md" +keywords = ["Windows", "WinSDK", "Registry"] +categories = ["api-bindings", "os::windows-apis"] +license = "MIT" +repository = "https://github.com/gentoo90/winreg-rs" +[package.metadata.docs.rs] +all-features = true +targets = ["x86_64-pc-windows-msvc", "i686-pc-windows-msvc"] + +[[example]] +name = "basic_usage" +required-features = ["chrono"] + +[[example]] +name = "enum" + +[[example]] +name = "load_app_key" + +[[example]] +name = "transactions" +required-features = ["transactions"] + +[[example]] +name = "serialization" +required-features = ["serialization-serde"] + +[[example]] +name = "map_key_serialization" +required-features = ["serialization-serde"] + +[[example]] +name = "installed_apps" +required-features = ["serialization-serde"] +[dependencies.chrono] +version = "0.4.6" +optional = true + +[dependencies.serde] +version = "1" +optional = true + +[dependencies.winapi] +version = "0.3.9" +features = ["impl-default", "impl-debug", "minwindef", "minwinbase", "timezoneapi", "winerror", "winnt", "winreg", "handleapi"] +[dev-dependencies.rand] +version = "0.3" + +[dev-dependencies.serde_derive] +version = "1" + +[dev-dependencies.tempfile] +version = "~3.0" + +[features] +serialization-serde = ["transactions", "serde"] +transactions = ["winapi/ktmw32"] diff --git a/third_party/rust/winreg/LICENSE b/third_party/rust/winreg/LICENSE new file mode 100644 index 0000000000..b9d358e3e7 --- /dev/null +++ b/third_party/rust/winreg/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2015 Igor Shaula + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/third_party/rust/winreg/README.md b/third_party/rust/winreg/README.md new file mode 100644 index 0000000000..2683a0619f --- /dev/null +++ b/third_party/rust/winreg/README.md @@ -0,0 +1,381 @@ +winreg +[![Winreg on Appveyor][appveyor-image]][appveyor] +[![Winreg on crates.io][cratesio-image]][cratesio] +[![Winreg on docs.rs][docsrs-image]][docsrs] +====== + +[appveyor-image]: https://ci.appveyor.com/api/projects/status/f3lwrt67ghrf5omd?svg=true +[appveyor]: https://ci.appveyor.com/project/gentoo90/winreg-rs +[cratesio-image]: https://img.shields.io/crates/v/winreg.svg +[cratesio]: https://crates.io/crates/winreg +[docsrs-image]: https://docs.rs/winreg/badge.svg +[docsrs]: https://docs.rs/winreg + +Rust bindings to MS Windows Registry API. Work in progress. + +Current features: +* Basic registry operations: + * open/create/delete keys + * load application hive from a file + * read and write values + * seamless conversion between `REG_*` types and rust primitives + * `String` and `OsString` <= `REG_SZ`, `REG_EXPAND_SZ` or `REG_MULTI_SZ` + * `String`, `&str`, `OsString`, `&OsStr` => `REG_SZ` + * `Vec<String>`, `Vec<OsString>` <= `REG_MULTI_SZ` + * `Vec<String>`, `Vec<&str>`, `Vec<OsString>`, `Vec<&OsStr>` => `REG_MULTI_SZ` + * `u32` <=> `REG_DWORD` + * `u64` <=> `REG_QWORD` +* Iteration through key names and through values +* Transactions +* Transacted serialization of rust types into/from registry (only primitives, structures and maps for now) + +## Usage + +### Basic usage + +```toml +# Cargo.toml +[dependencies] +winreg = "0.10" +``` + +```rust +extern crate winreg; +use std::io; +use std::path::Path; +use winreg::enums::*; +use winreg::RegKey; + +fn main() -> io::Result<()> { + println!("Reading some system info..."); + let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + 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 winapi::um::minwinbase::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 hkcu = RegKey::predef(HKEY_CURRENT_USER); + 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 + +```rust +extern crate winreg; +use std::io; +use winreg::RegKey; +use winreg::enums::*; + +fn main() -> io::Result<()> { + println!("File extensions, registered in system:"); + for i in RegKey::predef(HKEY_CLASSES_ROOT) + .enum_keys().map(|x| x.unwrap()) + .filter(|x| x.starts_with(".")) + { + println!("{}", i); + } + + let system = RegKey::predef(HKEY_LOCAL_MACHINE) + .open_subkey("HARDWARE\\DESCRIPTION\\System")?; + for (name, value) in system.enum_values().map(|x| x.unwrap()) { + println!("{} = {:?}", name, value); + } + + Ok(()) +} +``` + +### Transactions + +```toml +# Cargo.toml +[dependencies] +winreg = { version = "0.10", features = ["transactions"] } +``` + +```rust +extern crate winreg; +use std::io; +use winreg::RegKey; +use winreg::enums::*; +use winreg::transaction::Transaction; + +fn main() -> io::Result<()> { + let t = Transaction::new()?; + let hkcu = RegKey::predef(HKEY_CURRENT_USER); + let (key, _disp) = hkcu.create_subkey_transacted("Software\\RustTransaction", &t)?; + key.set_value("TestQWORD", &1234567891011121314u64)?; + key.set_value("TestDWORD", &1234567890u32)?; + + println!("Commit transaction? [y/N]:"); + let mut input = String::new(); + io::stdin().read_line(&mut input)?; + input = input.trim_right().to_owned(); + if input == "y" || input == "Y" { + t.commit()?; + println!("Transaction committed."); + } + else { + // this is optional, if transaction wasn't committed, + // it will be rolled back on disposal + t.rollback()?; + + println!("Transaction wasn't committed, it will be rolled back."); + } + + Ok(()) +} +``` + +### Serialization + +```toml +# Cargo.toml +[dependencies] +winreg = { version = "0.10", features = ["serialization-serde"] } +serde = "1" +serde_derive = "1" +``` + +```rust +#[macro_use] +extern crate serde_derive; +extern crate winreg; +use std::collections::HashMap; +use std::error::Error; +use winreg::enums::*; + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Coords { + x: u32, + y: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Size { + w: u32, + h: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Rectangle { + coords: Coords, + size: Size, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Test { + t_bool: bool, + t_u8: u8, + t_u16: u16, + t_u32: u32, + t_u64: u64, + t_usize: usize, + t_struct: Rectangle, + t_map: HashMap<String, u32>, + t_string: String, + #[serde(rename = "")] // empty name becomes the (Default) value in the registry + t_char: char, + t_i8: i8, + t_i16: i16, + t_i32: i32, + t_i64: i64, + t_isize: isize, + t_f64: f64, + t_f32: f32, +} + +fn main() -> Result<(), Box<dyn Error>> { + let hkcu = winreg::RegKey::predef(HKEY_CURRENT_USER); + let (key, _disp) = hkcu.create_subkey("Software\\RustEncode")?; + + let mut map = HashMap::new(); + map.insert("".to_owned(), 0); // empty name becomes the (Default) value in the registry + map.insert("v1".to_owned(), 1); + map.insert("v2".to_owned(), 2); + map.insert("v3".to_owned(), 3); + + let v1 = Test { + t_bool: false, + t_u8: 127, + t_u16: 32768, + t_u32: 123_456_789, + t_u64: 123_456_789_101_112, + t_usize: 1_234_567_891, + t_struct: Rectangle { + coords: Coords { x: 55, y: 77 }, + size: Size { w: 500, h: 300 }, + }, + t_map: map, + t_string: "test 123!".to_owned(), + t_char: 'a', + t_i8: -123, + t_i16: -2049, + t_i32: 20100, + t_i64: -12_345_678_910, + t_isize: -1_234_567_890, + t_f64: -0.01, + t_f32: 3.15, + }; + + key.encode(&v1)?; + + let v2: Test = key.decode()?; + println!("Decoded {:?}", v2); + + println!("Equal to encoded: {:?}", v1 == v2); + Ok(()) +} +``` + +## Changelog + +### 0.10.1 + +* Bump minimal required version of `winapi` to `0.3.9` (required for `load_app_key`) +* Reexport `REG_PROCESS_APPKEY` and use it in the `load_app_key` example + +### 0.10.0 + +* Add `RegKey::load_app_key()` and `RegKey::load_app_key_with_flags()` ([#30](https://github.com/gentoo90/winreg-rs/issues/30)) +* Update dev dependency `rand` to `0.8` +* Add Github actions +* Fix some clippy warnings + +### 0.9.0 + +* Breaking change: `OsStr` and `OsString` registry values are not `NULL`-terminated any more ([#34](https://github.com/gentoo90/winreg-rs/issues/34), [#42](https://github.com/gentoo90/winreg-rs/issues/42)) +* Refactoring: use macros for `ToRegValue` impls and tests for string values +* Fix `bare_trait_objects` warning in the doctests +* Add `impl ToRegValue for OsString` +* Add conversion between `REG_MULTI_SZ` and vectors of strings ([#16](https://github.com/gentoo90/winreg-rs/issues/16)) +* Fix: set minimal `winapi` version to 0.3.7 (earlier versions don't have `impl-default` and `impl-debug` features which we use) +* Appveyor now checks the crate against `rust-1.31.1` too + +### 0.8.0 + +* Implement serialization of `char` and maps +* Implement `std::fmt::Display` for `RegValue` +* Make `RegKey::{predef,raw_handle,enum_keys,enum_values}` functions `const` +* Give a better error message when compiling on platforms other than Windows ([#38](https://github.com/gentoo90/winreg-rs/pull/38)) +* Tests are moved from `src/lib.rs` to `tests/reg_key.rs` + +### 0.7.0 + +* Breaking change: remove deprecated `Error::description` ([#28](https://github.com/gentoo90/winreg-rs/pull/28)) +* Optimize `Iterator::nth()` for the `Enum*` iterators ([#29](https://github.com/gentoo90/winreg-rs/pull/29)) + +### 0.6.2 + +* Add `RegKey::delete_subkey_with_flags()` ([#27](https://github.com/gentoo90/winreg-rs/pull/27)) + +### 0.6.1 + +* Add `last_write_time` field to `RegKeyMetadata` (returned by `RegKey::query_info()`) ([#25](https://github.com/gentoo90/winreg-rs/pull/25)). +* Add `get_last_write_time_system()` and `get_last_write_time_chrono()` (under `chrono` feature) methods to `RegKeyMetadata`. + +### 0.6.0 + +* Breaking change: `create_subkey`, `create_subkey_with_flags`, `create_subkey_transacted` and +`create_subkey_transacted_with_flags` now return a tuple which contains the subkey and its disposition +which can be `REG_CREATED_NEW_KEY` or `REG_OPENED_EXISTING_KEY` ([#21](https://github.com/gentoo90/winreg-rs/issues/21)). +* Examples fixed to not use `unwrap` according to [Rust API guidelines](https://rust-lang-nursery.github.io/api-guidelines/documentation.html#examples-use--not-try-not-unwrap-c-question-mark). + +### 0.5.1 + +* Reexport `HKEY` ([#15](https://github.com/gentoo90/winreg-rs/issues/15)). +* Add `raw_handle` method ([#18](https://github.com/gentoo90/winreg-rs/pull/18)). + +### 0.5.0 + +* Breaking change: `open_subkey` now opens a key with readonly permissions. +Use `create_subkey` or `open_subkey_with_flags` to open with read-write permissins. +* Breaking change: features `transactions` and `serialization-serde` are now disabled by default. +* Breaking change: serialization now uses `serde` instead of `rustc-serialize`. +* `winapi` updated to `0.3`. +* Documentation fixes ([#14](https://github.com/gentoo90/winreg-rs/pull/14)) + +### 0.4.0 + +* Make transactions and serialization otional features +* Update dependensies + minor fixes ([#12](https://github.com/gentoo90/winreg-rs/pull/12)) + +### 0.3.5 + +* Implement `FromRegValue` for `OsString` and `ToRegValue` for `OsStr` ([#8](https://github.com/gentoo90/winreg-rs/issues/8)) +* Minor fixes + +### 0.3.4 + +* Add `copy_tree` method to `RegKey` +* Now checked with [rust-clippy](https://github.com/Manishearth/rust-clippy) + * no more `unwrap`s + * replaced `to_string` with `to_owned` +* Fix: reading strings longer than 2048 characters ([#6](https://github.com/gentoo90/winreg-rs/pull/6)) + +### 0.3.3 + +* Fix: now able to read values longer than 2048 bytes ([#3](https://github.com/gentoo90/winreg-rs/pull/3)) + +### 0.3.2 + +* Fix: `FromRegValue` trait now requires `Sized` (fixes build with rust 1.4) + +### 0.3.1 + +* Fix: bump `winapi` version to fix build + +### 0.3.0 + +* Add transactions support and make serialization transacted +* Breaking change: use `std::io::{Error,Result}` instead of own `RegError` and `RegResult` diff --git a/third_party/rust/winreg/appveyor.yml b/third_party/rust/winreg/appveyor.yml new file mode 100644 index 0000000000..b690b6a0cb --- /dev/null +++ b/third_party/rust/winreg/appveyor.yml @@ -0,0 +1,37 @@ +version: 0.10.{build} +pull_requests: + do_not_increment_build_number: true + +branches: + except: + - github-actions + +os: Visual Studio 2015 + +environment: + matrix: + - TARGET: x86_64-pc-windows-msvc + CHANNEL: 1.31.1 + - TARGET: x86_64-pc-windows-gnu + CHANNEL: stable + - TARGET: x86_64-pc-windows-msvc + CHANNEL: stable + - TARGET: i686-pc-windows-gnu + CHANNEL: stable + - TARGET: i686-pc-windows-msvc + CHANNEL: stable + +install: + - curl -sSf -o rustup-init.exe https://win.rustup.rs + - rustup-init.exe --profile=minimal --component rustfmt,clippy --default-host %TARGET% --default-toolchain %CHANNEL% -y + - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin + - rustc -Vv + - cargo -V + +build: false + +test_script: + - if not "%CHANNEL%"=="1.31.1" cargo fmt --all -- --check + - if not "%CHANNEL%"=="1.31.1" cargo clippy --all-features --all-targets + - cargo test --release --no-default-features + - cargo test --release --all-features diff --git a/third_party/rust/winreg/build.rs b/third_party/rust/winreg/build.rs new file mode 100644 index 0000000000..7acab76640 --- /dev/null +++ b/third_party/rust/winreg/build.rs @@ -0,0 +1,11 @@ +fn main() { + if std::env::var("CARGO_CFG_WINDOWS").is_err() { + eprintln!("error: winreg is only supported on Windows platforms"); + eprintln!( + "help: if your application is multi-platform, use \ + `[target.'cfg(windows)'.dependencies] winreg = \"...\"`" + ); + eprintln!("help: if your application is only supported on Windows, use `--target x86_64-pc-windows-gnu` or some other windows platform"); + std::process::exit(1); + } +} diff --git a/third_party/rust/winreg/examples/basic_usage.rs b/third_party/rust/winreg/examples/basic_usage.rs new file mode 100644 index 0000000000..6422e9eeb2 --- /dev/null +++ b/third_party/rust/winreg/examples/basic_usage.rs @@ -0,0 +1,69 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +extern crate winreg; +use std::io; +use std::path::Path; +use winreg::enums::*; +use winreg::RegKey; + +fn main() -> io::Result<()> { + println!("Reading some system info..."); + let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + 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 winapi::um::minwinbase::SYSTEMTIME = {}-{:02}-{:02} {:02}:{:02}:{:02}", + mt.wYear, mt.wMonth, mt.wDay, mt.wHour, mt.wMinute, mt.wSecond + ); + println!( + "last_write_time as chrono::NaiveDateTime = {}", + info.get_last_write_time_chrono() + ); + + println!("And now lets write something..."); + let hkcu = RegKey::predef(HKEY_CURRENT_USER); + 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", &1_234_567_890u32)?; + let dword_val: u32 = key.get_value("TestDWORD")?; + println!("TestDWORD = {}", dword_val); + + key.set_value("TestQWORD", &1_234_567_891_011_121_314u64)?; + 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(()) +} diff --git a/third_party/rust/winreg/examples/enum.rs b/third_party/rust/winreg/examples/enum.rs new file mode 100644 index 0000000000..dd1a78d870 --- /dev/null +++ b/third_party/rust/winreg/examples/enum.rs @@ -0,0 +1,27 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +extern crate winreg; +use std::io; +use winreg::enums::*; +use winreg::RegKey; + +fn main() -> io::Result<()> { + println!("File extensions, registered in system:"); + for i in RegKey::predef(HKEY_CLASSES_ROOT) + .enum_keys() + .map(|x| x.unwrap()) + .filter(|x| x.starts_with('.')) + { + println!("{}", i); + } + + let system = RegKey::predef(HKEY_LOCAL_MACHINE).open_subkey("HARDWARE\\DESCRIPTION\\System")?; + for (name, value) in system.enum_values().map(|x| x.unwrap()) { + println!("{} = {:?}", name, value); + } + + Ok(()) +} diff --git a/third_party/rust/winreg/examples/installed_apps.rs b/third_party/rust/winreg/examples/installed_apps.rs new file mode 100644 index 0000000000..a7546847db --- /dev/null +++ b/third_party/rust/winreg/examples/installed_apps.rs @@ -0,0 +1,50 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +#[macro_use] +extern crate serde_derive; +extern crate winreg; +use std::collections::HashMap; +use std::fmt; +use winreg::enums::*; + +#[allow(non_snake_case)] +#[derive(Debug, Serialize, Deserialize)] +struct InstalledApp { + DisplayName: Option<String>, + DisplayVersion: Option<String>, + UninstallString: Option<String>, +} + +macro_rules! str_from_opt { + ($s:expr) => { + $s.as_ref().map(|x| &**x).unwrap_or("") + }; +} + +impl fmt::Display for InstalledApp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "{}-{}", + str_from_opt!(self.DisplayName), + str_from_opt!(self.DisplayVersion) + ) + } +} + +fn main() { + let hklm = winreg::RegKey::predef(HKEY_LOCAL_MACHINE); + let uninstall_key = hklm + .open_subkey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall") + .expect("key is missing"); + + let apps: HashMap<String, InstalledApp> = + uninstall_key.decode().expect("deserialization failed"); + + for v in apps.values() { + println!("{}", v); + } +} diff --git a/third_party/rust/winreg/examples/load_app_key.rs b/third_party/rust/winreg/examples/load_app_key.rs new file mode 100644 index 0000000000..2340c82b59 --- /dev/null +++ b/third_party/rust/winreg/examples/load_app_key.rs @@ -0,0 +1,26 @@ +// Copyright 2021, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +extern crate winreg; +use std::io; +use winreg::enums::*; +use winreg::RegKey; + +fn main() -> io::Result<()> { + { + // put this in a block so app_key_1 gets out of scope and doesn't prevent us + // from loading the key again later + let app_key_1 = RegKey::load_app_key("myhive.dat", true)?; + app_key_1.set_value("answer", &42u32)?; + } + let answer: u32 = { + // NOTE: on Windows 7 this fails with ERROR_ALREADY_EXISTS + let app_key_2 = + RegKey::load_app_key_with_flags("myhive.dat", KEY_READ, REG_PROCESS_APPKEY)?; + app_key_2.get_value("answer")? + }; + println!("The Answer is {}", answer); + Ok(()) +} diff --git a/third_party/rust/winreg/examples/map_key_serialization.rs b/third_party/rust/winreg/examples/map_key_serialization.rs new file mode 100644 index 0000000000..c0be704913 --- /dev/null +++ b/third_party/rust/winreg/examples/map_key_serialization.rs @@ -0,0 +1,57 @@ +// Copyright 2020, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +#[macro_use] +extern crate serde_derive; +extern crate winreg; +use std::collections::HashMap; +use std::error::Error; +use winreg::enums::*; + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Coords { + x: u32, + y: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Size { + w: u32, + h: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Rectangle { + coords: Coords, + size: Size, +} + +fn main() -> Result<(), Box<dyn Error>> { + let hkcu = winreg::RegKey::predef(HKEY_CURRENT_USER); + let (key, _disp) = hkcu.create_subkey("Software\\RustEncodeMapKey")?; + let mut v1 = HashMap::new(); + v1.insert( + "first".to_owned(), + Rectangle { + coords: Coords { x: 55, y: 77 }, + size: Size { w: 500, h: 300 }, + }, + ); + v1.insert( + "second".to_owned(), + Rectangle { + coords: Coords { x: 11, y: 22 }, + size: Size { w: 1000, h: 600 }, + }, + ); + + key.encode(&v1)?; + + let v2: HashMap<String, Rectangle> = key.decode()?; + println!("Decoded {:?}", v2); + + println!("Equal to encoded: {:?}", v1 == v2); + Ok(()) +} diff --git a/third_party/rust/winreg/examples/serialization.rs b/third_party/rust/winreg/examples/serialization.rs new file mode 100644 index 0000000000..462813291a --- /dev/null +++ b/third_party/rust/winreg/examples/serialization.rs @@ -0,0 +1,93 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +#[macro_use] +extern crate serde_derive; +extern crate winreg; +use std::collections::HashMap; +use std::error::Error; +use winreg::enums::*; + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Coords { + x: u32, + y: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Size { + w: u32, + h: u32, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Rectangle { + coords: Coords, + size: Size, +} + +#[derive(Debug, Serialize, Deserialize, PartialEq)] +struct Test { + t_bool: bool, + t_u8: u8, + t_u16: u16, + t_u32: u32, + t_u64: u64, + t_usize: usize, + t_struct: Rectangle, + t_map: HashMap<String, u32>, + t_string: String, + #[serde(rename = "")] // empty name becomes the (Default) value in the registry + t_char: char, + t_i8: i8, + t_i16: i16, + t_i32: i32, + t_i64: i64, + t_isize: isize, + t_f64: f64, + t_f32: f32, +} + +fn main() -> Result<(), Box<dyn Error>> { + let hkcu = winreg::RegKey::predef(HKEY_CURRENT_USER); + let (key, _disp) = hkcu.create_subkey("Software\\RustEncode")?; + + let mut map = HashMap::new(); + map.insert("".to_owned(), 0); // empty name becomes the (Default) value in the registry + map.insert("v1".to_owned(), 1); + map.insert("v2".to_owned(), 2); + map.insert("v3".to_owned(), 3); + + let v1 = Test { + t_bool: false, + t_u8: 127, + t_u16: 32768, + t_u32: 123_456_789, + t_u64: 123_456_789_101_112, + t_usize: 1_234_567_891, + t_struct: Rectangle { + coords: Coords { x: 55, y: 77 }, + size: Size { w: 500, h: 300 }, + }, + t_map: map, + t_string: "test 123!".to_owned(), + t_char: 'a', + t_i8: -123, + t_i16: -2049, + t_i32: 20100, + t_i64: -12_345_678_910, + t_isize: -1_234_567_890, + t_f64: -0.01, + t_f32: 3.15, + }; + + key.encode(&v1)?; + + let v2: Test = key.decode()?; + println!("Decoded {:?}", v2); + + println!("Equal to encoded: {:?}", v1 == v2); + Ok(()) +} diff --git a/third_party/rust/winreg/examples/transactions.rs b/third_party/rust/winreg/examples/transactions.rs new file mode 100644 index 0000000000..4cc91b7c9f --- /dev/null +++ b/third_party/rust/winreg/examples/transactions.rs @@ -0,0 +1,35 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +extern crate winreg; +use std::io; +use winreg::enums::*; +use winreg::transaction::Transaction; +use winreg::RegKey; + +fn main() -> io::Result<()> { + let t = Transaction::new()?; + let hkcu = RegKey::predef(HKEY_CURRENT_USER); + let (key, _disp) = hkcu.create_subkey_transacted("Software\\RustTransaction", &t)?; + key.set_value("TestQWORD", &1_234_567_891_011_121_314u64)?; + key.set_value("TestDWORD", &1_234_567_890u32)?; + + println!("Commit transaction? [y/N]:"); + let mut input = String::new(); + io::stdin().read_line(&mut input)?; + input = input.trim_end().to_owned(); + if input == "y" || input == "Y" { + t.commit()?; + println!("Transaction committed."); + } else { + // this is optional, if transaction wasn't committed, + // it will be rolled back on disposal + t.rollback()?; + + println!("Transaction wasn't committed, it will be rolled back."); + } + + Ok(()) +} diff --git a/third_party/rust/winreg/src/decoder/mod.rs b/third_party/rust/winreg/src/decoder/mod.rs new file mode 100644 index 0000000000..82493b846d --- /dev/null +++ b/third_party/rust/winreg/src/decoder/mod.rs @@ -0,0 +1,101 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +use super::enums::*; +use super::RegKey; +use std::error::Error; +use std::fmt; +use std::io; +use winapi::shared::minwindef::DWORD; + +macro_rules! read_value { + ($s:ident) => { + match mem::replace(&mut $s.f_name, None) { + Some(ref s) => $s.key.get_value(s).map_err(DecoderError::IoError), + None => Err(DecoderError::NoFieldName), + } + }; +} + +macro_rules! parse_string { + ($s:ident) => {{ + let s: String = read_value!($s)?; + s.parse() + .map_err(|e| DecoderError::ParseError(format!("{:?}", e))) + }}; +} + +macro_rules! no_impl { + ($e:expr) => { + Err(DecoderError::DecodeNotImplemented($e.to_owned())) + }; +} + +#[cfg(feature = "serialization-serde")] +mod serialization_serde; + +#[derive(Debug)] +pub enum DecoderError { + DecodeNotImplemented(String), + DeserializerError(String), + IoError(io::Error), + ParseError(String), + NoFieldName, +} + +impl fmt::Display for DecoderError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +impl Error for DecoderError {} + +impl From<io::Error> for DecoderError { + fn from(err: io::Error) -> DecoderError { + DecoderError::IoError(err) + } +} + +pub type DecodeResult<T> = Result<T, DecoderError>; + +#[derive(Debug)] +enum DecoderReadingState { + WaitingForKey, + WaitingForValue, +} + +#[derive(Debug)] +enum DecoderEnumerationState { + EnumeratingKeys(DWORD), + EnumeratingValues(DWORD), +} + +#[derive(Debug)] +pub struct Decoder { + key: RegKey, + f_name: Option<String>, + reading_state: DecoderReadingState, + enumeration_state: DecoderEnumerationState, +} + +const DECODER_SAM: DWORD = KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS; + +impl Decoder { + pub fn from_key(key: &RegKey) -> DecodeResult<Decoder> { + key.open_subkey_with_flags("", DECODER_SAM) + .map(Decoder::new) + .map_err(DecoderError::IoError) + } + + fn new(key: RegKey) -> Decoder { + Decoder { + key, + f_name: None, + reading_state: DecoderReadingState::WaitingForKey, + enumeration_state: DecoderEnumerationState::EnumeratingKeys(0), + } + } +} diff --git a/third_party/rust/winreg/src/decoder/serialization_serde.rs b/third_party/rust/winreg/src/decoder/serialization_serde.rs new file mode 100644 index 0000000000..1287540448 --- /dev/null +++ b/third_party/rust/winreg/src/decoder/serialization_serde.rs @@ -0,0 +1,331 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +use super::super::FromRegValue; +use super::{ + DecodeResult, Decoder, DecoderEnumerationState, DecoderError, DecoderReadingState, DECODER_SAM, +}; +use serde::de::*; +use std::fmt; +use std::mem; + +impl Error for DecoderError { + fn custom<T: fmt::Display>(msg: T) -> Self { + DecoderError::DeserializerError(format!("{}", msg)) + } +} + +impl<'de, 'a> Deserializer<'de> for &'a mut Decoder { + type Error = DecoderError; + fn deserialize_any<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(..) => no_impl!("deserialize_any for keys"), + EnumeratingValues(..) => { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + let v = self.key.get_raw_value(s)?; + use RegType::*; + match v.vtype { + REG_SZ | REG_EXPAND_SZ | REG_MULTI_SZ => { + visitor.visit_string(String::from_reg_value(&v)?) + } + REG_DWORD => visitor.visit_u32(u32::from_reg_value(&v)?), + REG_QWORD => visitor.visit_u64(u64::from_reg_value(&v)?), + _ => Err(DecoderError::DecodeNotImplemented( + "value type deserialization not implemented".to_owned(), + )), + } + } + } + } + + fn deserialize_bool<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_bool(read_value!(self).map(|v: u32| v > 0)?) + } + + fn deserialize_u8<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + self.deserialize_u32(visitor) + } + + fn deserialize_u16<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + self.deserialize_u32(visitor) + } + + fn deserialize_u32<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_u32(read_value!(self)?) + } + + fn deserialize_u64<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_u64(read_value!(self)?) + } + + fn deserialize_i8<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_i8(parse_string!(self)?) + } + + fn deserialize_i16<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_i16(parse_string!(self)?) + } + + fn deserialize_i32<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_i32(parse_string!(self)?) + } + + fn deserialize_i64<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_i64(parse_string!(self)?) + } + + fn deserialize_f32<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_f32(parse_string!(self)?) + } + + fn deserialize_f64<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_f64(parse_string!(self)?) + } + + fn deserialize_char<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + self.deserialize_string(visitor) + } + + fn deserialize_str<V>(self, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_str") + } + + fn deserialize_string<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + use self::DecoderReadingState::*; + match self.reading_state { + WaitingForKey => { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + visitor.visit_string(s.clone()) + } + WaitingForValue => visitor.visit_string(read_value!(self)?), + } + } + + fn deserialize_bytes<V>(self, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_bytes") + } + + fn deserialize_byte_buf<V>(self, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_byte_buf") + } + + fn deserialize_option<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + let v = { + let s = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + self.key.get_raw_value(s) + }; + match v { + Ok(..) => visitor.visit_some(&mut *self), + Err(..) => visitor.visit_none(), + } + } + + fn deserialize_unit<V>(self, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_unit") + } + + fn deserialize_unit_struct<V>(self, _name: &'static str, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_unit_struct") + } + + fn deserialize_newtype_struct<V>( + self, + _name: &'static str, + _visitor: V, + ) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_newtype_struct") + } + + fn deserialize_seq<V>(self, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_seq") + } + + fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_tuple") + } + + fn deserialize_tuple_struct<V>( + self, + _name: &'static str, + _len: usize, + _visitor: V, + ) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_tuple_struct") + } + + fn deserialize_map<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_map(self) + } + + fn deserialize_struct<V>( + self, + _name: &'static str, + _fields: &'static [&'static str], + visitor: V, + ) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + visitor.visit_map(self) + } + + fn deserialize_identifier<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + self.deserialize_string(visitor) + } + + fn deserialize_enum<V>( + self, + _name: &'static str, + _variants: &'static [&'static str], + _visitor: V, + ) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + no_impl!("deserialize_enum") + } + + fn deserialize_ignored_any<V>(self, visitor: V) -> DecodeResult<V::Value> + where + V: Visitor<'de>, + { + self.deserialize_any(visitor) + } +} + +impl<'de, 'a> MapAccess<'de> for Decoder { + type Error = DecoderError; + fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error> + where + K: DeserializeSeed<'de>, + { + self.reading_state = DecoderReadingState::WaitingForKey; + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(index) => match self.key.enum_key(index) { + Some(res) => { + self.f_name = Some(res?); + self.enumeration_state = EnumeratingKeys(index + 1); + seed.deserialize(&mut *self).map(Some) + } + None => { + self.enumeration_state = EnumeratingValues(0); + self.next_key_seed(seed) + } + }, + EnumeratingValues(index) => { + let next_value = self.key.enum_value(index); + match next_value { + Some(res) => { + self.f_name = Some(res?.0); + self.enumeration_state = EnumeratingValues(index + 1); + seed.deserialize(&mut *self).map(Some) + } + None => Ok(None), + } + } + } + } + + fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error> + where + V: DeserializeSeed<'de>, + { + self.reading_state = DecoderReadingState::WaitingForValue; + use self::DecoderEnumerationState::*; + match self.enumeration_state { + EnumeratingKeys(..) => { + let f_name = self.f_name.as_ref().ok_or(DecoderError::NoFieldName)?; + match self.key.open_subkey_with_flags(f_name, DECODER_SAM) { + Ok(subkey) => { + let mut nested = Decoder::new(subkey); + seed.deserialize(&mut nested) + } + Err(err) => Err(DecoderError::IoError(err)), + } + } + EnumeratingValues(..) => seed.deserialize(&mut *self), + } + } +} diff --git a/third_party/rust/winreg/src/encoder/mod.rs b/third_party/rust/winreg/src/encoder/mod.rs new file mode 100644 index 0000000000..f552dc05df --- /dev/null +++ b/third_party/rust/winreg/src/encoder/mod.rs @@ -0,0 +1,97 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +use self::EncoderState::*; +use super::enums::*; +use super::transaction::Transaction; +use super::RegKey; +use std::error::Error; +use std::fmt; +use std::io; +use winapi::shared::minwindef::DWORD; + +macro_rules! emit_value { + ($s:ident, $v:ident) => { + match mem::replace(&mut $s.state, Start) { + NextKey(ref s) => $s.keys[$s.keys.len() - 1] + .set_value(s, &$v) + .map_err(EncoderError::IoError), + Start => Err(EncoderError::NoFieldName), + } + }; +} + +macro_rules! no_impl { + ($e:expr) => { + Err(EncoderError::EncodeNotImplemented($e.to_owned())) + }; +} + +#[cfg(feature = "serialization-serde")] +mod serialization_serde; + +#[derive(Debug)] +pub enum EncoderError { + EncodeNotImplemented(String), + SerializerError(String), + IoError(io::Error), + NoFieldName, + KeyMustBeAString, +} + +impl fmt::Display for EncoderError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{:?}", self) + } +} + +impl Error for EncoderError {} + +pub type EncodeResult<T> = Result<T, EncoderError>; + +impl From<io::Error> for EncoderError { + fn from(err: io::Error) -> EncoderError { + EncoderError::IoError(err) + } +} + +#[derive(Debug)] +enum EncoderState { + Start, + NextKey(String), + // NextMapKey, +} + +#[derive(Debug)] +pub struct Encoder { + keys: Vec<RegKey>, + tr: Transaction, + state: EncoderState, +} + +const ENCODER_SAM: DWORD = KEY_CREATE_SUB_KEY | KEY_SET_VALUE; + +impl Encoder { + pub fn from_key(key: &RegKey) -> EncodeResult<Encoder> { + let tr = Transaction::new()?; + key.open_subkey_transacted_with_flags("", &tr, ENCODER_SAM) + .map(|k| Encoder::new(k, tr)) + .map_err(EncoderError::IoError) + } + + fn new(key: RegKey, tr: Transaction) -> Encoder { + let mut keys = Vec::with_capacity(5); + keys.push(key); + Encoder { + keys, + tr, + state: Start, + } + } + + pub fn commit(&mut self) -> EncodeResult<()> { + self.tr.commit().map_err(EncoderError::IoError) + } +} diff --git a/third_party/rust/winreg/src/encoder/serialization_serde.rs b/third_party/rust/winreg/src/encoder/serialization_serde.rs new file mode 100644 index 0000000000..f764cce6ec --- /dev/null +++ b/third_party/rust/winreg/src/encoder/serialization_serde.rs @@ -0,0 +1,513 @@ +// Copyright 2017, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. +use super::EncoderState::*; +use super::{EncodeResult, Encoder, EncoderError, ENCODER_SAM}; +use serde::ser::*; +use std::fmt; +use std::mem; + +impl Error for EncoderError { + fn custom<T: fmt::Display>(msg: T) -> Self { + EncoderError::SerializerError(format!("{}", msg)) + } +} + +impl<'a> Serializer for &'a mut Encoder { + type Ok = (); + type Error = EncoderError; + + type SerializeSeq = SeqEncoder; + type SerializeTuple = TupleEncoder; + type SerializeTupleStruct = TupleStructEncoder; + type SerializeTupleVariant = TupleVariantEncoder; + type SerializeMap = StructMapEncoder<'a>; + type SerializeStruct = StructMapEncoder<'a>; + type SerializeStructVariant = StructVariantEncoder; + + fn serialize_bool(self, value: bool) -> EncodeResult<Self::Ok> { + self.serialize_u32(value as u32) + } + + fn serialize_i8(self, value: i8) -> EncodeResult<Self::Ok> { + self.serialize_i64(value as i64) + } + + fn serialize_i16(self, value: i16) -> EncodeResult<Self::Ok> { + self.serialize_i64(value as i64) + } + + fn serialize_i32(self, value: i32) -> EncodeResult<Self::Ok> { + self.serialize_i64(value as i64) + } + + fn serialize_i64(self, value: i64) -> EncodeResult<Self::Ok> { + let s = value.to_string(); + emit_value!(self, s) + } + + fn serialize_u8(self, value: u8) -> EncodeResult<Self::Ok> { + self.serialize_u32(value as u32) + } + + fn serialize_u16(self, value: u16) -> EncodeResult<Self::Ok> { + self.serialize_u32(value as u32) + } + + fn serialize_u32(self, value: u32) -> EncodeResult<Self::Ok> { + emit_value!(self, value) + } + + fn serialize_u64(self, value: u64) -> EncodeResult<Self::Ok> { + emit_value!(self, value) + } + + fn serialize_f32(self, value: f32) -> EncodeResult<Self::Ok> { + let s = value.to_string(); + emit_value!(self, s) + } + + fn serialize_f64(self, value: f64) -> EncodeResult<Self::Ok> { + let s = value.to_string(); + emit_value!(self, s) + } + + fn serialize_char(self, value: char) -> EncodeResult<Self::Ok> { + let mut s = String::new(); + s.push(value); + emit_value!(self, s) + } + + fn serialize_str(self, value: &str) -> EncodeResult<Self::Ok> { + emit_value!(self, value) + } + + fn serialize_bytes(self, _value: &[u8]) -> EncodeResult<Self::Ok> { + no_impl!("serialize_bytes") + } + + fn serialize_none(self) -> EncodeResult<Self::Ok> { + no_impl!("serialize_none") + } + + fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> EncodeResult<Self::Ok> { + no_impl!("serialize_some") + } + + fn serialize_unit(self) -> EncodeResult<Self::Ok> { + no_impl!("serialize_unit") + } + + fn serialize_unit_struct(self, _name: &'static str) -> EncodeResult<Self::Ok> { + no_impl!("serialize_unit_struct") + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + ) -> EncodeResult<Self::Ok> { + no_impl!("serialize_unit_variant") + } + + fn serialize_newtype_struct<T: ?Sized + Serialize>( + self, + _name: &'static str, + _value: &T, + ) -> EncodeResult<Self::Ok> { + no_impl!("serialize_newtype_struct") + } + + fn serialize_newtype_variant<T: ?Sized + Serialize>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> EncodeResult<Self::Ok> { + no_impl!("serialize_newtype_variant") + } + + fn serialize_seq(self, _len: Option<usize>) -> EncodeResult<Self::SerializeSeq> { + no_impl!("serialize_seq") + } + + fn serialize_tuple(self, _len: usize) -> EncodeResult<Self::SerializeTuple> { + no_impl!("serialize_tuple") + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeTupleStruct> { + no_impl!("serialize_tuple_struct") + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeTupleVariant> { + no_impl!("serialize_tuple_variant") + } + + fn serialize_map(self, _len: Option<usize>) -> EncodeResult<Self::SerializeMap> { + match mem::replace(&mut self.state, Start) { + // --- + Start => { + // root structure + Ok(StructMapEncoder { + enc: self, + is_root: true, + }) + } + NextKey(ref s) => { + // nested structure + match self.keys[self.keys.len() - 1].create_subkey_transacted_with_flags( + &s, + &self.tr, + ENCODER_SAM, + ) { + Ok((subkey, _disp)) => { + self.keys.push(subkey); + Ok(StructMapEncoder { + enc: self, + is_root: true, + }) + } + Err(err) => Err(EncoderError::IoError(err)), + } + } + } + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeStruct> { + self.serialize_map(Some(_len)) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeStructVariant> { + no_impl!("serialize_struct_variant") + } +} + +pub struct SeqEncoder {} + +impl SerializeSeq for SeqEncoder { + type Ok = (); + type Error = EncoderError; + fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> { + no_impl!("SerializeSeq::serialize_element") + } + fn end(self) -> EncodeResult<Self::Ok> { + no_impl!("SerializeSeq::end") + } +} + +pub struct TupleEncoder {} + +impl SerializeTuple for TupleEncoder { + type Ok = (); + type Error = EncoderError; + + fn serialize_element<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTuple::serialize_element") + } + + fn end(self) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTuple::end") + } +} + +pub struct TupleStructEncoder {} + +impl SerializeTupleStruct for TupleStructEncoder { + type Ok = (); + type Error = EncoderError; + + fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTupleStruct::serialize_field") + } + + fn end(self) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTupleStruct::end") + } +} + +pub struct TupleVariantEncoder {} + +impl SerializeTupleVariant for TupleVariantEncoder { + type Ok = (); + type Error = EncoderError; + + fn serialize_field<T: ?Sized + Serialize>(&mut self, _value: &T) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTupleVariant::serialize_field") + } + + fn end(self) -> EncodeResult<Self::Ok> { + no_impl!("SerializeTupleVariant::end") + } +} + +struct MapKeySerializer; + +impl serde::Serializer for MapKeySerializer { + type Ok = String; + type Error = EncoderError; + + type SerializeSeq = Impossible<String, EncoderError>; + type SerializeTuple = Impossible<String, EncoderError>; + type SerializeTupleStruct = Impossible<String, EncoderError>; + type SerializeTupleVariant = Impossible<String, EncoderError>; + type SerializeMap = Impossible<String, EncoderError>; + type SerializeStruct = Impossible<String, EncoderError>; + type SerializeStructVariant = Impossible<String, EncoderError>; + + #[inline] + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + ) -> EncodeResult<Self::Ok> { + Ok(variant.to_owned()) + } + + #[inline] + fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> EncodeResult<Self::Ok> + where + T: ?Sized + Serialize, + { + value.serialize(self) + } + + fn serialize_bool(self, _value: bool) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_i8(self, value: i8) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_i16(self, value: i16) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_i32(self, value: i32) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_i64(self, value: i64) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_u8(self, value: u8) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_u16(self, value: u16) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_u32(self, value: u32) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_u64(self, value: u64) -> EncodeResult<Self::Ok> { + Ok(value.to_string()) + } + + fn serialize_f32(self, _value: f32) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_f64(self, _value: f64) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + #[inline] + fn serialize_char(self, value: char) -> EncodeResult<Self::Ok> { + Ok({ + let mut s = String::new(); + s.push(value); + s + }) + } + + #[inline] + fn serialize_str(self, value: &str) -> EncodeResult<Self::Ok> { + Ok(value.to_owned()) + } + + fn serialize_bytes(self, _value: &[u8]) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_unit(self) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_unit_struct(self, _name: &'static str) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_newtype_variant<T>( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _value: &T, + ) -> EncodeResult<Self::Ok> + where + T: ?Sized + Serialize, + { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_none(self) -> EncodeResult<Self::Ok> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_some<T>(self, _value: &T) -> EncodeResult<Self::Ok> + where + T: ?Sized + Serialize, + { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_seq(self, _len: Option<usize>) -> EncodeResult<Self::SerializeSeq> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_tuple(self, _len: usize) -> EncodeResult<Self::SerializeTuple> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeTupleStruct> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeTupleVariant> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_map(self, _len: Option<usize>) -> EncodeResult<Self::SerializeMap> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_struct( + self, + _name: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeStruct> { + Err(EncoderError::KeyMustBeAString) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> EncodeResult<Self::SerializeStructVariant> { + Err(EncoderError::KeyMustBeAString) + } + + fn collect_str<T: ?Sized>(self, value: &T) -> EncodeResult<String> + where + T: fmt::Display, + { + Ok(value.to_string()) + } +} + +pub struct StructMapEncoder<'a> { + enc: &'a mut Encoder, + is_root: bool, +} + +impl<'a> SerializeStruct for StructMapEncoder<'a> { + type Ok = (); + type Error = EncoderError; + + fn serialize_field<T: ?Sized + Serialize>( + &mut self, + key: &'static str, + value: &T, + ) -> EncodeResult<Self::Ok> { + self.enc.state = NextKey(String::from(key)); + value.serialize(&mut *self.enc) + } + + fn end(self) -> EncodeResult<Self::Ok> { + if self.is_root { + self.enc.keys.pop(); + } + Ok(()) + } +} + +impl<'a> SerializeMap for StructMapEncoder<'a> { + type Ok = (); + type Error = EncoderError; + + fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> EncodeResult<Self::Ok> { + self.enc.state = NextKey(key.serialize(MapKeySerializer)?); + Ok(()) + } + + fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> EncodeResult<Self::Ok> { + value.serialize(&mut *self.enc) + } + + fn end(self) -> EncodeResult<Self::Ok> { + if self.is_root { + self.enc.keys.pop(); + } + Ok(()) + } +} + +pub struct StructVariantEncoder {} + +impl SerializeStructVariant for StructVariantEncoder { + type Ok = (); + type Error = EncoderError; + + fn serialize_field<T: ?Sized + Serialize>( + &mut self, + _key: &'static str, + _value: &T, + ) -> EncodeResult<Self::Ok> { + no_impl!("SerializeStructVariant::serialize_field") + } + + fn end(self) -> EncodeResult<Self::Ok> { + no_impl!("SerializeStructVariant::end") + } +} diff --git a/third_party/rust/winreg/src/enums.rs b/third_party/rust/winreg/src/enums.rs new file mode 100644 index 0000000000..b537b287c2 --- /dev/null +++ b/third_party/rust/winreg/src/enums.rs @@ -0,0 +1,51 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. + +//! `use winreg::enums::*;` to import all needed enumerations and constants +use super::winapi; +pub use winapi::um::winnt::{ + KEY_ALL_ACCESS, KEY_CREATE_LINK, KEY_CREATE_SUB_KEY, KEY_ENUMERATE_SUB_KEYS, KEY_EXECUTE, + KEY_NOTIFY, KEY_QUERY_VALUE, KEY_READ, KEY_SET_VALUE, KEY_WOW64_32KEY, KEY_WOW64_64KEY, + KEY_WOW64_RES, KEY_WRITE, +}; +pub use winapi::um::winreg::{ + HKEY_CLASSES_ROOT, HKEY_CURRENT_CONFIG, HKEY_CURRENT_USER, HKEY_CURRENT_USER_LOCAL_SETTINGS, + HKEY_DYN_DATA, HKEY_LOCAL_MACHINE, HKEY_PERFORMANCE_DATA, HKEY_PERFORMANCE_NLSTEXT, + HKEY_PERFORMANCE_TEXT, HKEY_USERS, REG_PROCESS_APPKEY, +}; + +macro_rules! winapi_enum{ + ($t:ident, $doc:expr => [$($v:ident),*]) => ( + #[doc=$doc] + #[allow(non_camel_case_types)] + #[derive(Debug,Clone,PartialEq)] + pub enum $t { + $( $v = winapi::um::winnt::$v as isize ),* + } + ) +} + +winapi_enum!(RegType, "Enumeration of possible registry value types" => [ +REG_NONE, +REG_SZ, +REG_EXPAND_SZ, +REG_BINARY, +REG_DWORD, +REG_DWORD_BIG_ENDIAN, +REG_LINK, +REG_MULTI_SZ, +REG_RESOURCE_LIST, +REG_FULL_RESOURCE_DESCRIPTOR, +REG_RESOURCE_REQUIREMENTS_LIST, +REG_QWORD +]); +pub use self::RegType::*; + +winapi_enum!(RegDisposition, "Enumeration of possible disposition values" => [ +REG_CREATED_NEW_KEY, +REG_OPENED_EXISTING_KEY +]); +pub use self::RegDisposition::*; diff --git a/third_party/rust/winreg/src/lib.rs b/third_party/rust/winreg/src/lib.rs new file mode 100644 index 0000000000..784976c5c8 --- /dev/null +++ b/third_party/rust/winreg/src/lib.rs @@ -0,0 +1,1143 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. + +//! Crate for accessing MS Windows registry +//! +//!## Usage +//! +//!### Basic usage +//! +//!```toml,ignore +//!# Cargo.toml +//![dependencies] +//!winreg = "0.10" +//!``` +//! +//!```no_run +//!extern crate winreg; +//!use std::io; +//!use std::path::Path; +//!use winreg::enums::*; +//!use winreg::RegKey; +//! +//!fn main() -> io::Result<()> { +//! println!("Reading some system info..."); +//! let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); +//! 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 winapi::um::minwinbase::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 hkcu = RegKey::predef(HKEY_CURRENT_USER); +//! 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 +//! +//!```no_run +//!extern crate winreg; +//!use std::io; +//!use winreg::RegKey; +//!use winreg::enums::*; +//! +//!fn main() -> io::Result<()> { +//! println!("File extensions, registered in system:"); +//! for i in RegKey::predef(HKEY_CLASSES_ROOT) +//! .enum_keys().map(|x| x.unwrap()) +//! .filter(|x| x.starts_with(".")) +//! { +//! println!("{}", i); +//! } +//! +//! let system = RegKey::predef(HKEY_LOCAL_MACHINE) +//! .open_subkey("HARDWARE\\DESCRIPTION\\System")?; +//! for (name, value) in system.enum_values().map(|x| x.unwrap()) { +//! println!("{} = {:?}", name, value); +//! } +//! +//! Ok(()) +//!} +//!``` +//! +#[cfg(feature = "chrono")] +extern crate chrono; +#[cfg(feature = "serialization-serde")] +extern crate serde; +extern crate winapi; +use enums::*; +use std::default::Default; +use std::ffi::OsStr; +use std::fmt; +use std::io; +use std::mem::transmute; +use std::os::windows::ffi::OsStrExt; +use std::ptr; +use std::slice; +#[cfg(feature = "transactions")] +use transaction::Transaction; +use types::{FromRegValue, ToRegValue}; +pub use winapi::shared::minwindef::HKEY; +use winapi::shared::minwindef::{BYTE, DWORD, FILETIME, LPBYTE}; +use winapi::shared::winerror; +use winapi::um::minwinbase::SYSTEMTIME; +use winapi::um::timezoneapi::FileTimeToSystemTime; +use winapi::um::winnt::{self, WCHAR}; +use winapi::um::winreg as winapi_reg; + +macro_rules! werr { + ($e:expr) => { + Err(io::Error::from_raw_os_error($e as i32)) + }; +} + +#[cfg(feature = "serialization-serde")] +mod decoder; +#[cfg(feature = "serialization-serde")] +mod encoder; +pub mod enums; +#[cfg(feature = "transactions")] +pub mod transaction; +pub mod types; + +/// Metadata returned by `RegKey::query_info` +#[derive(Debug, Default)] +pub struct RegKeyMetadata { + // pub Class: winapi::LPWSTR, + // pub ClassLen: DWORD, + pub sub_keys: DWORD, + pub max_sub_key_len: DWORD, + pub max_class_len: DWORD, + pub values: DWORD, + pub max_value_name_len: DWORD, + pub max_value_len: DWORD, + // pub SecurityDescriptor: DWORD, + pub last_write_time: FILETIME, +} + +impl RegKeyMetadata { + /// Returns `last_write_time` field as `winapi::um::minwinbase::SYSTEMTIME` + pub fn get_last_write_time_system(&self) -> SYSTEMTIME { + let mut st: SYSTEMTIME = unsafe { ::std::mem::zeroed() }; + unsafe { + FileTimeToSystemTime(&self.last_write_time, &mut st); + } + st + } + + /// Returns `last_write_time` field as `chrono::NaiveDateTime`. + /// Part of `chrono` feature. + #[cfg(feature = "chrono")] + pub fn get_last_write_time_chrono(&self) -> chrono::NaiveDateTime { + let st = self.get_last_write_time_system(); + + chrono::NaiveDate::from_ymd(st.wYear.into(), st.wMonth.into(), st.wDay.into()).and_hms( + st.wHour.into(), + st.wMinute.into(), + st.wSecond.into(), + ) + } +} + +/// Raw registry value +#[derive(PartialEq)] +pub struct RegValue { + pub bytes: Vec<u8>, + pub vtype: RegType, +} + +macro_rules! format_reg_value { + ($e:expr => $t:ident) => { + match $t::from_reg_value($e) { + Ok(val) => format!("{:?}", val), + Err(_) => return Err(fmt::Error), + } + }; +} + +impl fmt::Display for RegValue { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let f_val = match self.vtype { + REG_SZ | REG_EXPAND_SZ | REG_MULTI_SZ => format_reg_value!(self => String), + REG_DWORD => format_reg_value!(self => u32), + REG_QWORD => format_reg_value!(self => u64), + _ => format!("{:?}", self.bytes), //TODO: implement more types + }; + write!(f, "{}", f_val) + } +} + +impl fmt::Debug for RegValue { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "RegValue({:?}: {})", self.vtype, self) + } +} + +/// Handle of opened registry key +#[derive(Debug)] +pub struct RegKey { + hkey: HKEY, +} + +unsafe impl Send for RegKey {} + +impl RegKey { + /// Open one of predefined keys: + /// + /// * `HKEY_CLASSES_ROOT` + /// * `HKEY_CURRENT_USER` + /// * `HKEY_LOCAL_MACHINE` + /// * `HKEY_USERS` + /// * `HKEY_PERFORMANCE_DATA` + /// * `HKEY_PERFORMANCE_TEXT` + /// * `HKEY_PERFORMANCE_NLSTEXT` + /// * `HKEY_CURRENT_CONFIG` + /// * `HKEY_DYN_DATA` + /// * `HKEY_CURRENT_USER_LOCAL_SETTINGS` + /// + /// # Examples + /// + /// ```no_run + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + /// ``` + pub const fn predef(hkey: HKEY) -> RegKey { + RegKey { hkey } + } + + /// Load a registry hive from a file as an application hive. + /// If `lock` is set to `true`, then the hive cannot be loaded again until + /// it's unloaded (i.e. all keys from it go out of scope). + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let handle = RegKey::load_app_key("C:\\myhive.dat", false)?; + /// # Ok(()) + /// # } + /// ``` + pub fn load_app_key<N: AsRef<OsStr>>(filename: N, lock: bool) -> io::Result<RegKey> { + let options = if lock { + winapi_reg::REG_PROCESS_APPKEY + } else { + 0 + }; + RegKey::load_app_key_with_flags(filename, enums::KEY_ALL_ACCESS, options) + } + + /// Load a registry hive from a file as an application hive with desired + /// permissions and options. If `options` is set to `REG_PROCESS_APPKEY`, + /// then the hive cannot be loaded again until it's unloaded (i.e. all keys + /// from it go out of scope). + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let handle = RegKey::load_app_key_with_flags("C:\\myhive.dat", KEY_READ, 0)?; + /// # Ok(()) + /// # } + /// ``` + pub fn load_app_key_with_flags<N: AsRef<OsStr>>( + filename: N, + perms: winapi_reg::REGSAM, + options: DWORD, + ) -> io::Result<RegKey> { + let c_filename = to_utf16(filename); + let mut new_hkey: HKEY = ptr::null_mut(); + match unsafe { + winapi_reg::RegLoadAppKeyW(c_filename.as_ptr(), &mut new_hkey, perms, options, 0) + as DWORD + } { + 0 => Ok(RegKey { hkey: new_hkey }), + err => werr!(err), + } + } + + /// Return inner winapi HKEY of a key: + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + /// let soft = hklm.open_subkey("SOFTWARE")?; + /// let handle = soft.raw_handle(); + /// # Ok(()) + /// # } + /// ``` + pub const fn raw_handle(&self) -> HKEY { + self.hkey + } + + /// Open subkey with `KEY_READ` permissions. + /// Will open another handle to itself if `path` is an empty string. + /// To open with different permissions use `open_subkey_with_flags`. + /// You can also use `create_subkey` to open with `KEY_ALL_ACCESS` permissions. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let soft = RegKey::predef(HKEY_CURRENT_USER) + /// .open_subkey("Software")?; + /// # Ok(()) + /// # } + /// ``` + pub fn open_subkey<P: AsRef<OsStr>>(&self, path: P) -> io::Result<RegKey> { + self.open_subkey_with_flags(path, enums::KEY_READ) + } + + /// Open subkey with desired permissions. + /// Will open another handle to itself if `path` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + /// hklm.open_subkey_with_flags("SOFTWARE\\Microsoft", KEY_READ)?; + /// # Ok(()) + /// # } + /// ``` + pub fn open_subkey_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + perms: winapi_reg::REGSAM, + ) -> io::Result<RegKey> { + let c_path = to_utf16(path); + let mut new_hkey: HKEY = ptr::null_mut(); + match unsafe { + winapi_reg::RegOpenKeyExW(self.hkey, c_path.as_ptr(), 0, perms, &mut new_hkey) as DWORD + } { + 0 => Ok(RegKey { hkey: new_hkey }), + err => werr!(err), + } + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn open_subkey_transacted<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + ) -> io::Result<RegKey> { + self.open_subkey_transacted_with_flags(path, t, winnt::KEY_READ) + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn open_subkey_transacted_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + perms: winapi_reg::REGSAM, + ) -> io::Result<RegKey> { + let c_path = to_utf16(path); + let mut new_hkey: HKEY = ptr::null_mut(); + match unsafe { + winapi_reg::RegOpenKeyTransactedW( + self.hkey, + c_path.as_ptr(), + 0, + perms, + &mut new_hkey, + t.handle, + ptr::null_mut(), + ) as DWORD + } { + 0 => Ok(RegKey { hkey: new_hkey }), + err => werr!(err), + } + } + + /// Create subkey (and all missing parent keys) + /// and open it with `KEY_ALL_ACCESS` permissions. + /// Will just open key if it already exists. + /// If succeeds returns a tuple with the created subkey and its disposition, + /// which can be `REG_CREATED_NEW_KEY` or `REG_OPENED_EXISTING_KEY`. + /// Will open another handle to itself if `path` is an empty string. + /// To create with different permissions use `create_subkey_with_flags`. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let (settings, disp) = hkcu.create_subkey("Software\\MyProduct\\Settings")?; + /// + /// match disp { + /// REG_CREATED_NEW_KEY => println!("A new key has been created"), + /// REG_OPENED_EXISTING_KEY => println!("An existing key has been opened") + /// } + /// # Ok(()) + /// # } + /// ``` + pub fn create_subkey<P: AsRef<OsStr>>(&self, path: P) -> io::Result<(RegKey, RegDisposition)> { + self.create_subkey_with_flags(path, enums::KEY_ALL_ACCESS) + } + + pub fn create_subkey_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + perms: winapi_reg::REGSAM, + ) -> io::Result<(RegKey, RegDisposition)> { + let c_path = to_utf16(path); + let mut new_hkey: HKEY = ptr::null_mut(); + let mut disp_buf: DWORD = 0; + match unsafe { + winapi_reg::RegCreateKeyExW( + self.hkey, + c_path.as_ptr(), + 0, + ptr::null_mut(), + winnt::REG_OPTION_NON_VOLATILE, + perms, + ptr::null_mut(), + &mut new_hkey, + &mut disp_buf, + ) + } { + 0 => { + let disp: RegDisposition = unsafe { transmute(disp_buf as u8) }; + Ok((RegKey { hkey: new_hkey }, disp)) + } + err => werr!(err), + } + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn create_subkey_transacted<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + ) -> io::Result<(RegKey, RegDisposition)> { + self.create_subkey_transacted_with_flags(path, t, winnt::KEY_ALL_ACCESS) + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn create_subkey_transacted_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + perms: winapi_reg::REGSAM, + ) -> io::Result<(RegKey, RegDisposition)> { + let c_path = to_utf16(path); + let mut new_hkey: HKEY = ptr::null_mut(); + let mut disp_buf: DWORD = 0; + match unsafe { + winapi_reg::RegCreateKeyTransactedW( + self.hkey, + c_path.as_ptr(), + 0, + ptr::null_mut(), + winnt::REG_OPTION_NON_VOLATILE, + perms, + ptr::null_mut(), + &mut new_hkey, + &mut disp_buf, + t.handle, + ptr::null_mut(), + ) as DWORD + } { + 0 => { + let disp: RegDisposition = unsafe { transmute(disp_buf as u8) }; + Ok((RegKey { hkey: new_hkey }, disp)) + } + err => werr!(err), + } + } + + /// Copy all the values and subkeys from `path` to `dest` key. + /// WIll copy the content of `self` if `path` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let src = hkcu.open_subkey_with_flags("Software\\MyProduct", KEY_READ)?; + /// let (dst, dst_disp) = hkcu.create_subkey("Software\\MyProduct\\Section2")?; + /// src.copy_tree("Section1", &dst)?; + /// # Ok(()) + /// # } + /// ``` + pub fn copy_tree<P: AsRef<OsStr>>(&self, path: P, dest: &RegKey) -> io::Result<()> { + let c_path = to_utf16(path); + match unsafe { winapi_reg::RegCopyTreeW(self.hkey, c_path.as_ptr(), dest.hkey) } { + 0 => Ok(()), + err => werr!(err), + } + } + + pub fn query_info(&self) -> io::Result<RegKeyMetadata> { + let mut info: RegKeyMetadata = Default::default(); + match unsafe { + winapi_reg::RegQueryInfoKeyW( + self.hkey, + ptr::null_mut(), // Class: winapi::LPWSTR, + ptr::null_mut(), // ClassLen: DWORD, + ptr::null_mut(), // Reserved + &mut info.sub_keys, + &mut info.max_sub_key_len, + &mut info.max_class_len, + &mut info.values, + &mut info.max_value_name_len, + &mut info.max_value_len, + ptr::null_mut(), // lpcbSecurityDescriptor: winapi::LPDWORD, + &mut info.last_write_time, + ) as DWORD + } { + 0 => Ok(info), + err => werr!(err), + } + } + + /// Return an iterator over subkeys names. + /// + /// # Examples + /// + /// ```no_run + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// println!("File extensions, registered in this system:"); + /// for i in RegKey::predef(HKEY_CLASSES_ROOT) + /// .enum_keys().map(|x| x.unwrap()) + /// .filter(|x| x.starts_with(".")) + /// { + /// println!("{}", i); + /// } + /// ``` + pub const fn enum_keys(&self) -> EnumKeys { + EnumKeys { + key: self, + index: 0, + } + } + + /// Return an iterator over values. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let system = RegKey::predef(HKEY_LOCAL_MACHINE) + /// .open_subkey_with_flags("HARDWARE\\DESCRIPTION\\System", KEY_READ)?; + /// for (name, value) in system.enum_values().map(|x| x.unwrap()) { + /// println!("{} = {:?}", name, value); + /// } + /// # Ok(()) + /// # } + /// ``` + pub const fn enum_values(&self) -> EnumValues { + EnumValues { + key: self, + index: 0, + } + } + + /// Delete key. Key names are not case sensitive. + /// Cannot delete if it has subkeys. + /// Use `delete_subkey_all` for that. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// RegKey::predef(HKEY_CURRENT_USER) + /// .delete_subkey(r"Software\MyProduct\History")?; + /// # Ok(()) + /// # } + /// ``` + pub fn delete_subkey<P: AsRef<OsStr>>(&self, path: P) -> io::Result<()> { + self.delete_subkey_with_flags(path, 0) + } + + /// Delete key from the desired platform-specific view of the registry. + /// Key names are not case sensitive. + /// + /// # Examples + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// // delete the key from the 32-bit registry view + /// RegKey::predef(HKEY_LOCAL_MACHINE) + /// .delete_subkey_with_flags(r"Software\MyProduct\History", KEY_WOW64_32KEY)?; + /// # Ok(()) + /// # } + /// ``` + pub fn delete_subkey_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + perms: winapi_reg::REGSAM, + ) -> io::Result<()> { + let c_path = to_utf16(path); + match unsafe { + winapi_reg::RegDeleteKeyExW( + self.hkey, + c_path.as_ptr(), // This parameter cannot be NULL. + perms, + 0, + ) + } { + 0 => Ok(()), + err => werr!(err), + } + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn delete_subkey_transacted<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + ) -> io::Result<()> { + self.delete_subkey_transacted_with_flags(path, t, 0) + } + + /// Part of `transactions` feature. + #[cfg(feature = "transactions")] + pub fn delete_subkey_transacted_with_flags<P: AsRef<OsStr>>( + &self, + path: P, + t: &Transaction, + perms: winapi_reg::REGSAM, + ) -> io::Result<()> { + let c_path = to_utf16(path); + match unsafe { + winapi_reg::RegDeleteKeyTransactedW( + self.hkey, + c_path.as_ptr(), // This parameter cannot be NULL. + perms, + 0, + t.handle, + ptr::null_mut(), + ) + } { + 0 => Ok(()), + err => werr!(err), + } + } + + /// Recursively delete subkey with all its subkeys and values. + /// If `path` is an empty string, the subkeys and values of this key are deleted. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// RegKey::predef(HKEY_CURRENT_USER) + /// .delete_subkey_all("Software\\MyProduct")?; + /// # Ok(()) + /// # } + /// ``` + pub fn delete_subkey_all<P: AsRef<OsStr>>(&self, path: P) -> io::Result<()> { + let c_path; + let path_ptr = if path.as_ref().is_empty() { + ptr::null() + } else { + c_path = to_utf16(path); + c_path.as_ptr() + }; + match unsafe { + winapi_reg::RegDeleteTreeW( + self.hkey, + path_ptr, //If this parameter is NULL, the subkeys and values of this key are deleted. + ) as DWORD + } { + 0 => Ok(()), + err => werr!(err), + } + } + + /// Get a value from registry and seamlessly convert it to the specified rust type + /// with `FromRegValue` implemented (currently `String`, `u32` and `u64`). + /// Will get the `Default` value if `name` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let settings = hkcu.open_subkey("Software\\MyProduct\\Settings")?; + /// let server: String = settings.get_value("server")?; + /// let port: u32 = settings.get_value("port")?; + /// # Ok(()) + /// # } + /// ``` + pub fn get_value<T: FromRegValue, N: AsRef<OsStr>>(&self, name: N) -> io::Result<T> { + match self.get_raw_value(name) { + Ok(ref val) => FromRegValue::from_reg_value(val), + Err(err) => Err(err), + } + } + + /// Get raw bytes from registry value. + /// Will get the `Default` value if `name` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let settings = hkcu.open_subkey("Software\\MyProduct\\Settings")?; + /// let data = settings.get_raw_value("data")?; + /// println!("Bytes: {:?}", data.bytes); + /// # Ok(()) + /// # } + /// ``` + pub fn get_raw_value<N: AsRef<OsStr>>(&self, name: N) -> io::Result<RegValue> { + let c_name = to_utf16(name); + let mut buf_len: DWORD = 2048; + let mut buf_type: DWORD = 0; + let mut buf: Vec<u8> = Vec::with_capacity(buf_len as usize); + loop { + match unsafe { + winapi_reg::RegQueryValueExW( + self.hkey, + c_name.as_ptr() as *const u16, + ptr::null_mut(), + &mut buf_type, + buf.as_mut_ptr() as LPBYTE, + &mut buf_len, + ) as DWORD + } { + 0 => { + unsafe { + buf.set_len(buf_len as usize); + } + // minimal check before transmute to RegType + if buf_type > winnt::REG_QWORD { + return werr!(winerror::ERROR_BAD_FILE_TYPE); + } + let t: RegType = unsafe { transmute(buf_type as u8) }; + return Ok(RegValue { + bytes: buf, + vtype: t, + }); + } + winerror::ERROR_MORE_DATA => { + buf.reserve(buf_len as usize); + } + err => return werr!(err), + } + } + } + + /// Seamlessly convert a value from a rust type and write it to the registry value + /// with `ToRegValue` trait implemented (currently `String`, `&str`, `u32` and `u64`). + /// Will set the `Default` value if `name` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let (settings, disp) = hkcu.create_subkey("Software\\MyProduct\\Settings")?; + /// settings.set_value("server", &"www.example.com")?; + /// settings.set_value("port", &8080u32)?; + /// # Ok(()) + /// # } + /// ``` + pub fn set_value<T: ToRegValue, N: AsRef<OsStr>>(&self, name: N, value: &T) -> io::Result<()> { + self.set_raw_value(name, &value.to_reg_value()) + } + + /// Write raw bytes from `RegValue` struct to a registry value. + /// Will set the `Default` value if `name` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// use winreg::{RegKey, RegValue}; + /// use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let settings = hkcu.open_subkey("Software\\MyProduct\\Settings")?; + /// let bytes: Vec<u8> = vec![1, 2, 3, 5, 8, 13, 21, 34, 55, 89]; + /// let data = RegValue{ vtype: REG_BINARY, bytes: bytes}; + /// settings.set_raw_value("data", &data)?; + /// println!("Bytes: {:?}", data.bytes); + /// # Ok(()) + /// # } + /// ``` + pub fn set_raw_value<N: AsRef<OsStr>>(&self, name: N, value: &RegValue) -> io::Result<()> { + let c_name = to_utf16(name); + let t = value.vtype.clone() as DWORD; + match unsafe { + winapi_reg::RegSetValueExW( + self.hkey, + c_name.as_ptr(), + 0, + t, + value.bytes.as_ptr() as *const BYTE, + value.bytes.len() as u32, + ) as DWORD + } { + 0 => Ok(()), + err => werr!(err), + } + } + + /// Delete specified value from registry. + /// Will delete the `Default` value if `name` is an empty string. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// # use winreg::RegKey; + /// # use winreg::enums::*; + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let hkcu = RegKey::predef(HKEY_CURRENT_USER); + /// let settings = hkcu.open_subkey("Software\\MyProduct\\Settings")?; + /// settings.delete_value("data")?; + /// # Ok(()) + /// # } + /// ``` + pub fn delete_value<N: AsRef<OsStr>>(&self, name: N) -> io::Result<()> { + let c_name = to_utf16(name); + match unsafe { winapi_reg::RegDeleteValueW(self.hkey, c_name.as_ptr()) as DWORD } { + 0 => Ok(()), + err => werr!(err), + } + } + + /// Save `Encodable` type to a registry key. + /// Part of `serialization-serde` feature. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// #[macro_use] + /// extern crate serde_derive; + /// extern crate winreg; + /// use winreg::RegKey; + /// use winreg::enums::*; + /// + /// #[derive(Serialize)] + /// struct Rectangle{ + /// x: u32, + /// y: u32, + /// w: u32, + /// h: u32, + /// } + /// + /// #[derive(Serialize)] + /// struct Settings{ + /// current_dir: String, + /// window_pos: Rectangle, + /// show_in_tray: bool, + /// } + /// + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let s: Settings = Settings{ + /// current_dir: "C:\\".to_owned(), + /// window_pos: Rectangle{ x:200, y: 100, w: 800, h: 500 }, + /// show_in_tray: false, + /// }; + /// let s_key = RegKey::predef(HKEY_CURRENT_USER) + /// .open_subkey("Software\\MyProduct\\Settings")?; + /// s_key.encode(&s)?; + /// # Ok(()) + /// # } + /// ``` + #[cfg(feature = "serialization-serde")] + pub fn encode<T: serde::Serialize>(&self, value: &T) -> encoder::EncodeResult<()> { + let mut encoder = encoder::Encoder::from_key(self)?; + value.serialize(&mut encoder)?; + encoder.commit() + } + + /// Load `Decodable` type from a registry key. + /// Part of `serialization-serde` feature. + /// + /// # Examples + /// + /// ```no_run + /// # use std::error::Error; + /// #[macro_use] + /// extern crate serde_derive; + /// extern crate winreg; + /// use winreg::RegKey; + /// use winreg::enums::*; + /// + /// #[derive(Deserialize)] + /// struct Rectangle{ + /// x: u32, + /// y: u32, + /// w: u32, + /// h: u32, + /// } + /// + /// #[derive(Deserialize)] + /// struct Settings{ + /// current_dir: String, + /// window_pos: Rectangle, + /// show_in_tray: bool, + /// } + /// + /// # fn main() -> Result<(), Box<dyn Error>> { + /// let s_key = RegKey::predef(HKEY_CURRENT_USER) + /// .open_subkey("Software\\MyProduct\\Settings")?; + /// let s: Settings = s_key.decode()?; + /// # Ok(()) + /// # } + /// ``` + #[cfg(feature = "serialization-serde")] + pub fn decode<'de, T: serde::Deserialize<'de>>(&self) -> decoder::DecodeResult<T> { + let mut decoder = decoder::Decoder::from_key(self)?; + T::deserialize(&mut decoder) + } + + fn close_(&mut self) -> io::Result<()> { + // don't try to close predefined keys + if self.hkey >= enums::HKEY_CLASSES_ROOT { + return Ok(()); + }; + match unsafe { winapi_reg::RegCloseKey(self.hkey) as DWORD } { + 0 => Ok(()), + err => werr!(err), + } + } + + fn enum_key(&self, index: DWORD) -> Option<io::Result<String>> { + let mut name_len = 2048; + #[allow(clippy::unnecessary_cast)] + let mut name = [0 as WCHAR; 2048]; + match unsafe { + winapi_reg::RegEnumKeyExW( + self.hkey, + index, + name.as_mut_ptr(), + &mut name_len, + ptr::null_mut(), // reserved + ptr::null_mut(), // lpClass: LPWSTR, + ptr::null_mut(), // lpcClass: LPDWORD, + ptr::null_mut(), // lpftLastWriteTime: PFILETIME, + ) as DWORD + } { + 0 => match String::from_utf16(&name[..name_len as usize]) { + Ok(s) => Some(Ok(s)), + Err(_) => Some(werr!(winerror::ERROR_INVALID_BLOCK)), + }, + winerror::ERROR_NO_MORE_ITEMS => None, + err => Some(werr!(err)), + } + } + + fn enum_value(&self, index: DWORD) -> Option<io::Result<(String, RegValue)>> { + let mut name_len = 2048; + #[allow(clippy::unnecessary_cast)] + let mut name = [0 as WCHAR; 2048]; + + let mut buf_len: DWORD = 2048; + let mut buf_type: DWORD = 0; + let mut buf: Vec<u8> = Vec::with_capacity(buf_len as usize); + loop { + match unsafe { + winapi_reg::RegEnumValueW( + self.hkey, + index, + name.as_mut_ptr(), + &mut name_len, + ptr::null_mut(), // reserved + &mut buf_type, + buf.as_mut_ptr() as LPBYTE, + &mut buf_len, + ) as DWORD + } { + 0 => { + let name = match String::from_utf16(&name[..name_len as usize]) { + Ok(s) => s, + Err(_) => return Some(werr!(winerror::ERROR_INVALID_DATA)), + }; + unsafe { + buf.set_len(buf_len as usize); + } + // minimal check before transmute to RegType + if buf_type > winnt::REG_QWORD { + return Some(werr!(winerror::ERROR_BAD_FILE_TYPE)); + } + let t: RegType = unsafe { transmute(buf_type as u8) }; + let value = RegValue { + bytes: buf, + vtype: t, + }; + return Some(Ok((name, value))); + } + winerror::ERROR_MORE_DATA => { + name_len += 1; //for NULL char + buf.reserve(buf_len as usize); + } + winerror::ERROR_NO_MORE_ITEMS => return None, + err => return Some(werr!(err)), + } + } + } +} + +impl Drop for RegKey { + fn drop(&mut self) { + self.close_().unwrap_or(()); + } +} + +/// Iterator over subkeys names +pub struct EnumKeys<'key> { + key: &'key RegKey, + index: DWORD, +} + +impl<'key> Iterator for EnumKeys<'key> { + type Item = io::Result<String>; + + fn next(&mut self) -> Option<io::Result<String>> { + match self.key.enum_key(self.index) { + v @ Some(_) => { + self.index += 1; + v + } + e @ None => e, + } + } + + fn nth(&mut self, n: usize) -> Option<Self::Item> { + self.index += n as DWORD; + self.next() + } +} + +/// Iterator over values +pub struct EnumValues<'key> { + key: &'key RegKey, + index: DWORD, +} + +impl<'key> Iterator for EnumValues<'key> { + type Item = io::Result<(String, RegValue)>; + + fn next(&mut self) -> Option<io::Result<(String, RegValue)>> { + match self.key.enum_value(self.index) { + v @ Some(_) => { + self.index += 1; + v + } + e @ None => e, + } + } + + fn nth(&mut self, n: usize) -> Option<Self::Item> { + self.index += n as DWORD; + self.next() + } +} + +fn to_utf16<P: AsRef<OsStr>>(s: P) -> Vec<u16> { + s.as_ref() + .encode_wide() + .chain(Some(0).into_iter()) + .collect() +} + +fn v16_to_v8(v: &[u16]) -> Vec<u8> { + unsafe { slice::from_raw_parts(v.as_ptr() as *const u8, v.len() * 2).to_vec() } +} diff --git a/third_party/rust/winreg/src/transaction.rs b/third_party/rust/winreg/src/transaction.rs new file mode 100644 index 0000000000..e63e3ea17c --- /dev/null +++ b/third_party/rust/winreg/src/transaction.rs @@ -0,0 +1,105 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. + +//! Structure for a registry transaction. +//! Part of `transactions` feature. +//! +//!```no_run +//!extern crate winreg; +//!use std::io; +//!use winreg::RegKey; +//!use winreg::enums::*; +//!use winreg::transaction::Transaction; +//! +//!fn main() { +//! let t = Transaction::new().unwrap(); +//! let hkcu = RegKey::predef(HKEY_CURRENT_USER); +//! let (key, _disp) = hkcu.create_subkey_transacted("Software\\RustTransaction", &t).unwrap(); +//! key.set_value("TestQWORD", &1234567891011121314u64).unwrap(); +//! key.set_value("TestDWORD", &1234567890u32).unwrap(); +//! +//! println!("Commit transaction? [y/N]:"); +//! let mut input = String::new(); +//! io::stdin().read_line(&mut input).unwrap(); +//! input = input.trim_right().to_owned(); +//! if input == "y" || input == "Y" { +//! t.commit().unwrap(); +//! println!("Transaction committed."); +//! } +//! else { +//! // this is optional, if transaction wasn't committed, +//! // it will be rolled back on disposal +//! t.rollback().unwrap(); +//! +//! println!("Transaction wasn't committed, it will be rolled back."); +//! } +//!} +//!``` +#![cfg(feature = "transactions")] +use std::io; +use std::ptr; +use winapi::um::handleapi; +use winapi::um::ktmw32; +use winapi::um::winnt; + +#[derive(Debug)] +pub struct Transaction { + pub handle: winnt::HANDLE, +} + +impl Transaction { + //TODO: add arguments + pub fn new() -> io::Result<Transaction> { + unsafe { + let handle = ktmw32::CreateTransaction( + ptr::null_mut(), + ptr::null_mut(), + 0, + 0, + 0, + 0, + ptr::null_mut(), + ); + if handle == handleapi::INVALID_HANDLE_VALUE { + return Err(io::Error::last_os_error()); + }; + Ok(Transaction { handle }) + } + } + + pub fn commit(&self) -> io::Result<()> { + unsafe { + match ktmw32::CommitTransaction(self.handle) { + 0 => Err(io::Error::last_os_error()), + _ => Ok(()), + } + } + } + + pub fn rollback(&self) -> io::Result<()> { + unsafe { + match ktmw32::RollbackTransaction(self.handle) { + 0 => Err(io::Error::last_os_error()), + _ => Ok(()), + } + } + } + + fn close_(&mut self) -> io::Result<()> { + unsafe { + match handleapi::CloseHandle(self.handle) { + 0 => Err(io::Error::last_os_error()), + _ => Ok(()), + } + } + } +} + +impl Drop for Transaction { + fn drop(&mut self) { + self.close_().unwrap_or(()); + } +} diff --git a/third_party/rust/winreg/src/types.rs b/third_party/rust/winreg/src/types.rs new file mode 100644 index 0000000000..37439354eb --- /dev/null +++ b/third_party/rust/winreg/src/types.rs @@ -0,0 +1,199 @@ +// Copyright 2015, Igor Shaula +// Licensed under the MIT License <LICENSE or +// http://opensource.org/licenses/MIT>. This file +// may not be copied, modified, or distributed +// except according to those terms. + +//! Traits for loading/saving Registry values +use super::enums::*; +use super::winapi::shared::winerror; +use super::RegValue; +use super::{to_utf16, v16_to_v8}; +use std::ffi::{OsStr, OsString}; +use std::io; +use std::os::windows::ffi::OsStringExt; +use std::slice; + +/// A trait for types that can be loaded from registry values. +/// +/// **NOTE:** Uses `from_utf16_lossy` when converting to `String`. +/// +/// **NOTE:** When converting to `String` or `OsString`, trailing `NULL` characters are trimmed +/// and line separating `NULL` characters in `REG_MULTI_SZ` are replaced by `\n` +/// effectively representing the value as a multiline string. +/// When converting to `Vec<String>` or `Vec<OsString>` `NULL` is used as a strings separator. +pub trait FromRegValue: Sized { + fn from_reg_value(val: &RegValue) -> io::Result<Self>; +} + +impl FromRegValue for String { + fn from_reg_value(val: &RegValue) -> io::Result<String> { + match val.vtype { + REG_SZ | REG_EXPAND_SZ | REG_MULTI_SZ => { + let words = unsafe { + #[allow(clippy::cast_ptr_alignment)] + slice::from_raw_parts(val.bytes.as_ptr() as *const u16, val.bytes.len() / 2) + }; + let mut s = String::from_utf16_lossy(words); + while s.ends_with('\u{0}') { + s.pop(); + } + if val.vtype == REG_MULTI_SZ { + return Ok(s.replace("\u{0}", "\n")); + } + Ok(s) + } + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +impl FromRegValue for Vec<String> { + fn from_reg_value(val: &RegValue) -> io::Result<Vec<String>> { + match val.vtype { + REG_MULTI_SZ => { + let words = unsafe { + slice::from_raw_parts(val.bytes.as_ptr() as *const u16, val.bytes.len() / 2) + }; + let mut s = String::from_utf16_lossy(words); + while s.ends_with('\u{0}') { + s.pop(); + } + let v: Vec<String> = s.split('\u{0}').map(|x| x.to_owned()).collect(); + Ok(v) + } + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +impl FromRegValue for OsString { + fn from_reg_value(val: &RegValue) -> io::Result<OsString> { + match val.vtype { + REG_SZ | REG_EXPAND_SZ | REG_MULTI_SZ => { + let mut words = unsafe { + #[allow(clippy::cast_ptr_alignment)] + slice::from_raw_parts(val.bytes.as_ptr() as *const u16, val.bytes.len() / 2) + }; + while let Some(0) = words.last() { + words = &words[0..words.len() - 1]; + } + let s = OsString::from_wide(words); + Ok(s) + } + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +impl FromRegValue for Vec<OsString> { + fn from_reg_value(val: &RegValue) -> io::Result<Vec<OsString>> { + match val.vtype { + REG_MULTI_SZ => { + let mut words = unsafe { + slice::from_raw_parts(val.bytes.as_ptr() as *const u16, val.bytes.len() / 2) + }; + while let Some(0) = words.last() { + words = &words[0..words.len() - 1]; + } + let v: Vec<OsString> = words + .split(|ch| *ch == 0u16) + .map(|x| OsString::from_wide(x)) + .collect(); + Ok(v) + } + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +impl FromRegValue for u32 { + fn from_reg_value(val: &RegValue) -> io::Result<u32> { + match val.vtype { + #[allow(clippy::cast_ptr_alignment)] + REG_DWORD => Ok(unsafe { *(val.bytes.as_ptr() as *const u32) }), + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +impl FromRegValue for u64 { + fn from_reg_value(val: &RegValue) -> io::Result<u64> { + match val.vtype { + #[allow(clippy::cast_ptr_alignment)] + REG_QWORD => Ok(unsafe { *(val.bytes.as_ptr() as *const u64) }), + _ => werr!(winerror::ERROR_BAD_FILE_TYPE), + } + } +} + +/// A trait for types that can be written into registry values. +/// +/// **NOTE:** Adds trailing `NULL` character to `str`, `String`, `OsStr` and `OsString` values +pub trait ToRegValue { + fn to_reg_value(&self) -> RegValue; +} + +macro_rules! to_reg_value_sz { + ($t:ty$(, $l:lifetime)*) => { + impl<$($l,)*> ToRegValue for $t { + fn to_reg_value(&self) -> RegValue { + RegValue { + bytes: v16_to_v8(&to_utf16(self)), + vtype: REG_SZ, + } + } + } + } +} + +to_reg_value_sz!(String); +to_reg_value_sz!(&'a str, 'a); +to_reg_value_sz!(OsString); +to_reg_value_sz!(&'a OsStr, 'a); + +macro_rules! to_reg_value_multi_sz { + ($t:ty$(, $l:lifetime)*) => { + impl<$($l,)*> ToRegValue for Vec<$t> { + fn to_reg_value(&self) -> RegValue { + let mut os_strings = self + .into_iter() + .map(to_utf16) + .collect::<Vec<_>>() + .concat(); + os_strings.push(0); + RegValue { + bytes: v16_to_v8(&os_strings), + vtype: REG_MULTI_SZ, + } + } + } + } +} + +to_reg_value_multi_sz!(String); +to_reg_value_multi_sz!(&'a str, 'a); +to_reg_value_multi_sz!(OsString); +to_reg_value_multi_sz!(&'a OsStr, 'a); + +impl ToRegValue for u32 { + fn to_reg_value(&self) -> RegValue { + let bytes: Vec<u8> = + unsafe { slice::from_raw_parts((self as *const u32) as *const u8, 4).to_vec() }; + RegValue { + bytes, + vtype: REG_DWORD, + } + } +} + +impl ToRegValue for u64 { + fn to_reg_value(&self) -> RegValue { + let bytes: Vec<u8> = + unsafe { slice::from_raw_parts((self as *const u64) as *const u8, 8).to_vec() }; + RegValue { + bytes, + vtype: REG_QWORD, + } + } +} diff --git a/third_party/rust/winreg/tests/reg_key.rs b/third_party/rust/winreg/tests/reg_key.rs new file mode 100644 index 0000000000..0a79300424 --- /dev/null +++ b/third_party/rust/winreg/tests/reg_key.rs @@ -0,0 +1,364 @@ +extern crate rand; +extern crate tempfile; +extern crate winapi; +extern crate winreg; +#[cfg(feature = "serialization-serde")] +#[macro_use] +extern crate serde_derive; +use self::rand::Rng; +use std::collections::HashMap; +use std::ffi::{OsStr, OsString}; +use tempfile::tempdir; +use winapi::shared::winerror; +use winreg::enums::*; +use winreg::types::FromRegValue; +use winreg::{RegKey, RegValue}; + +#[test] +fn test_raw_handle() { + let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + let handle = hklm.raw_handle(); + assert_eq!(HKEY_LOCAL_MACHINE, handle); +} + +#[test] +fn test_load_appkey() { + let val_name = "LoadKeyTest"; + let dir = tempdir().unwrap(); + let file_path = dir.path().join("RustLoadAppkeyTest.dat"); + let val1 = "Test123".to_owned(); + { + let key1 = RegKey::load_app_key(&file_path, true).unwrap(); + key1.set_value(val_name, &val1).unwrap(); + // this fails on Windows 7 with ERROR_ALREADY_EXISTS + let key_err = RegKey::load_app_key_with_flags(&file_path, KEY_READ, 0).unwrap_err(); + assert_eq!( + key_err.raw_os_error(), + Some(winerror::ERROR_SHARING_VIOLATION as i32) + ); + } + let val2: String = { + // this fails on Windows 7 with ERROR_ALREADY_EXISTS + let key2 = RegKey::load_app_key_with_flags(&file_path, KEY_READ, 1).unwrap(); + key2.get_value(val_name).unwrap() + }; + assert_eq!(val1, val2); +} + +#[test] +fn test_open_subkey_with_flags_query_info() { + let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); + let win = hklm + .open_subkey_with_flags("Software\\Microsoft\\Windows", KEY_READ) + .unwrap(); + + let info = win.query_info().unwrap(); + info.get_last_write_time_system(); + #[cfg(feature = "chrono")] + info.get_last_write_time_chrono(); + + assert!(win + .open_subkey_with_flags("CurrentVersion\\", KEY_READ) + .is_ok()); + assert!(hklm + .open_subkey_with_flags("i\\just\\hope\\nobody\\created\\that\\key", KEY_READ) + .is_err()); +} + +#[test] +fn test_create_subkey_disposition() { + let hkcu = RegKey::predef(HKEY_CURRENT_USER); + let path = "Software\\WinRegRsTestCreateSubkey"; + let (_subkey, disp) = hkcu.create_subkey(path).unwrap(); + assert_eq!(disp, REG_CREATED_NEW_KEY); + let (_subkey2, disp2) = hkcu.create_subkey(path).unwrap(); + assert_eq!(disp2, REG_OPENED_EXISTING_KEY); + hkcu.delete_subkey_all(&path).unwrap(); +} + +macro_rules! with_key { + ($k:ident, $path:expr => $b:block) => {{ + let mut path = "Software\\WinRegRsTest".to_owned(); + path.push_str($path); + let ($k, _disp) = RegKey::predef(HKEY_CURRENT_USER) + .create_subkey(&path).unwrap(); + $b + RegKey::predef(HKEY_CURRENT_USER) + .delete_subkey_all(path).unwrap(); + }} +} + +#[test] +fn test_delete_subkey() { + let path = "Software\\WinRegRsTestDeleteSubkey"; + RegKey::predef(HKEY_CURRENT_USER) + .create_subkey(path) + .unwrap(); + assert!(RegKey::predef(HKEY_CURRENT_USER) + .delete_subkey(path) + .is_ok()); +} + +#[test] +fn test_delete_subkey_with_flags() { + let path = "Software\\Classes\\WinRegRsTestDeleteSubkeyWithFlags"; + RegKey::predef(HKEY_CURRENT_USER) + .create_subkey_with_flags(path, KEY_WOW64_32KEY) + .unwrap(); + assert!(RegKey::predef(HKEY_CURRENT_USER) + .delete_subkey_with_flags(path, KEY_WOW64_32KEY) + .is_ok()); +} + +#[test] +fn test_copy_tree() { + with_key!(key, "CopyTree" => { + let (sub_tree, _sub_tree_disp) = key.create_subkey("Src\\Sub\\Tree").unwrap(); + for v in &["one", "two", "three"] { + sub_tree.set_value(v, v).unwrap(); + } + let (dst, _dst_disp) = key.create_subkey("Dst").unwrap(); + assert!(key.copy_tree("Src", &dst).is_ok()); + }); +} + +#[test] +fn test_long_value() { + with_key!(key, "LongValue" => { + let name = "RustLongVal"; + let val1 = RegValue { vtype: REG_BINARY, bytes: (0..6000).map(|_| rand::random::<u8>()).collect() }; + key.set_raw_value(name, &val1).unwrap(); + let val2 = key.get_raw_value(name).unwrap(); + assert_eq!(val1, val2); + }); +} + +macro_rules! test_value_sz { + ($fname:ident, $kname:expr, $conv:expr => $tout:ty) => { + #[test] + fn $fname() { + with_key!(key, $kname => { + let name = "RustSzVal"; + let val1 = $conv("Test123 \n$%^&|+-*/\\()"); + key.set_value(name, &val1).unwrap(); + let val2: $tout = key.get_value(name).unwrap(); + assert_eq!(val1, val2); + }); + } + } +} + +test_value_sz!(test_string_value, "StringValue", str::to_owned => String); +test_value_sz!(test_str_value, "StrValue", |x|x => String); +test_value_sz!(test_os_string_value, "OsStringValue", OsString::from => OsString); +test_value_sz!(test_os_str_value, "OsStrValue", OsStr::new => OsString); + +#[test] +fn test_long_string_value() { + with_key!(key, "LongStringValue" => { + let name = "RustLongStringVal"; + let val1 : String = rand::thread_rng().gen_ascii_chars().take(7000).collect(); + key.set_value(name, &val1).unwrap(); + let val2: String = key.get_value(name).unwrap(); + assert_eq!(val1, val2); + }); +} + +#[test] +fn test_long_os_string_value() { + with_key!(key, "LongOsStringValue" => { + let name = "RustLongOsStringVal"; + let val1 = rand::thread_rng().gen_ascii_chars().take(7000).collect::<String>(); + let val1 = OsStr::new(&val1); + key.set_value(name, &val1).unwrap(); + let val2: OsString = key.get_value(name).unwrap(); + assert_eq!(val1, val2); + }); +} + +macro_rules! test_value_multi_sz { + ($fname:ident, $kname:expr, $conv:expr => $tout:ty) => { + #[test] + fn $fname() { + with_key!(key, $kname => { + let name = "RustMultiSzVal"; + + let val1 = vec![ + $conv("lorem ipsum\ndolor"), + $conv("sit amet") + ]; + key.set_value(name, &val1).unwrap(); + let val2: Vec<$tout> = key.get_value(name).unwrap(); + + assert_eq!(val1, val2); + }); + } + } +} + +test_value_multi_sz!(test_vec_string_value, "StringVectorValue", str::to_owned => String); +test_value_multi_sz!(test_vec_str_value, "StrVectorValue", |x|x => String); +test_value_multi_sz!(test_vec_os_string_value, "OsStringVectorValue", OsString::from => OsString); +test_value_multi_sz!(test_vec_os_str_value, "OsStrVectorValue", OsStr::new => OsString); + +#[test] +fn test_u32_value() { + with_key!(key, "U32Value" => { + let name = "RustU32Val"; + let val1 = 1_234_567_890u32; + key.set_value(name, &val1).unwrap(); + let val2: u32 = key.get_value(name).unwrap(); + assert_eq!(val1, val2); + }); +} + +#[test] +fn test_u64_value() { + with_key!(key, "U64Value" => { + let name = "RustU64Val"; + let val1 = 1_234_567_891_011_121_314u64; + key.set_value(name, &val1).unwrap(); + let val2: u64 = key.get_value(name).unwrap(); + assert_eq!(val1, val2); + }); +} + +#[test] +fn test_delete_value() { + with_key!(key, "DeleteValue" => { + let name = "WinregRsTestVal"; + key.set_value(name, &"Qwerty123").unwrap(); + assert!(key.delete_value(name).is_ok()); + }); +} + +#[test] +fn test_enum_keys() { + with_key!(key, "EnumKeys" => { + let mut keys1 = vec!("qwerty", "asdf", "1", "2", "3", "5", "8", "йцукен"); + keys1.sort_unstable(); + for i in &keys1 { + key.create_subkey(i).unwrap(); + } + let keys2: Vec<_> = key.enum_keys().map(|x| x.unwrap()).collect(); + assert_eq!(keys1, keys2); + }); +} + +#[test] +fn test_enum_values() { + with_key!(key, "EnumValues" => { + let mut vals1 = vec!("qwerty", "asdf", "1", "2", "3", "5", "8", "йцукен"); + vals1.sort_unstable(); + for i in &vals1 { + key.set_value(i,i).unwrap(); + } + let mut vals2: Vec<String> = Vec::with_capacity(vals1.len()); + let mut vals3: Vec<String> = Vec::with_capacity(vals1.len()); + for (name, val) in key.enum_values() + .map(|x| x.unwrap()) + { + vals2.push(name); + vals3.push(String::from_reg_value(&val).unwrap()); + } + assert_eq!(vals1, vals2); + assert_eq!(vals1, vals3); + }); +} + +#[test] +fn test_enum_long_values() { + with_key!(key, "EnumLongValues" => { + let mut vals = HashMap::with_capacity(3); + + for i in &[5500, 9500, 15000] { + let name: String = format!("val{}", i); + let val = RegValue { vtype: REG_BINARY, bytes: (0..*i).map(|_| rand::random::<u8>()).collect() }; + vals.insert(name, val); + } + + for (name, val) in key.enum_values() + .map(|x| x.unwrap()) + { + assert_eq!(val.bytes, vals[&name].bytes); + } + }); +} + +#[cfg(feature = "serialization-serde")] +#[test] +fn test_serialization() { + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct Rectangle { + x: u32, + y: u32, + w: u32, + h: u32, + } + + #[derive(Debug, PartialEq, Serialize, Deserialize)] + struct Test { + t_bool: bool, + t_u8: u8, + t_u16: u16, + t_u32: u32, + t_u64: u64, + t_usize: usize, + t_struct: Rectangle, + t_string: String, + t_map: HashMap<String, HashMap<String, u32>>, + t_i8: i8, + t_i16: i16, + t_i32: i32, + t_i64: i64, + t_isize: isize, + t_f64: f64, + t_f32: f32, + t_char: char, + } + + let mut k1 = HashMap::new(); + k1.insert("val1".to_owned(), 32); + k1.insert("val2".to_owned(), 64); + k1.insert("val3".to_owned(), 128); + + let mut k2 = HashMap::new(); + k2.insert("val1".to_owned(), 256); + k2.insert("val2".to_owned(), 512); + k2.insert("val3".to_owned(), 1024); + + let mut map = HashMap::new(); + map.insert("key1".to_owned(), k1); + map.insert("key2".to_owned(), k2); + + let v1 = Test { + t_bool: false, + t_u8: 127, + t_u16: 32768, + t_u32: 123_456_789, + t_u64: 123_456_789_101_112, + t_usize: 1_234_567_891, + t_struct: Rectangle { + x: 55, + y: 77, + w: 500, + h: 300, + }, + t_map: map, + t_string: "Test123 \n$%^&|+-*/\\()".to_owned(), + t_i8: -123, + t_i16: -2049, + t_i32: 20100, + t_i64: -12_345_678_910, + t_isize: -1_234_567_890, + t_f64: -0.01, + t_f32: 3.15, + t_char: 'a', + }; + + with_key!(key, "Serialization" => { + key.encode(&v1).unwrap(); + let v2: Test = key.decode().unwrap(); + assert_eq!(v1, v2); + }); +} |