winapi-util-0.1.6/.cargo_vcs_info.json0000644000000001360000000000100133020ustar { "git": { "sha1": "9453203cc11d5cadd73aa5fa0e5e5825d2e19b0f" }, "path_in_vcs": "" }winapi-util-0.1.6/.github/workflows/ci.yml000064400000000000000000000050161046102023000166070ustar 00000000000000name: ci on: pull_request: branches: - master push: branches: - master schedule: - cron: '00 01 * * *' # The section is needed to drop write-all permissions that are granted on # `schedule` event. By specifying any permission explicitly all others are set # to none. By using the principle of least privilege the damage a compromised # workflow can do (because of an injection or compromised third party tool or # action) is restricted. Currently the worklow doesn't need any additional # permission except for pulling the code. Adding labels to issues, commenting # on pull-requests, etc. may need additional permissions: # # Syntax for this section: # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#permissions # # Reference for how to assign permissions on a job-by-job basis: # https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs # # Reference for available permissions that we can enable if needed: # https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token permissions: # to fetch code (actions/checkout) contents: read jobs: test: name: test runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: include: - build: pinned os: windows-latest rust: 1.72.0 - build: stable os: windows-latest rust: stable - build: beta os: windows-latest rust: beta - build: nightly os: windows-latest rust: nightly - build: win-gnu os: windows-latest rust: stable-x86_64-gnu - build: linux os: ubuntu-latest rust: stable - build: macos os: macos-latest rust: stable steps: - name: Checkout repository uses: actions/checkout@v4 - name: Install Rust uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.rust }} - run: cargo build --verbose - run: cargo doc --verbose - run: cargo test --verbose - name: Show all computer names run: cargo test --lib sysinfo::tests::itworks -- --nocapture rustfmt: name: rustfmt runs-on: ubuntu-latest steps: - name: Checkout repository uses: actions/checkout@v4 - name: Install Rust uses: dtolnay/rust-toolchain@master with: toolchain: stable components: rustfmt - name: Check formatting run: | cargo fmt --all -- --check winapi-util-0.1.6/.gitignore000064400000000000000000000000431046102023000140570ustar 00000000000000/target **/*.rs.bk Cargo.lock tags winapi-util-0.1.6/COPYING000064400000000000000000000001761046102023000131310ustar 00000000000000This project is dual-licensed under the Unlicense and MIT licenses. You may use this code under the terms of either license. winapi-util-0.1.6/Cargo.toml0000644000000024450000000000100113050ustar # 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 are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" name = "winapi-util" version = "0.1.6" authors = ["Andrew Gallant "] description = "A dumping ground for high level safe wrappers over winapi." homepage = "https://github.com/BurntSushi/winapi-util" documentation = "https://docs.rs/winapi-util" readme = "README.md" keywords = [ "windows", "winapi", "util", "win", ] categories = [ "os::windows-apis", "external-ffi-bindings", ] license = "Unlicense/MIT" repository = "https://github.com/BurntSushi/winapi-util" [package.metadata.docs.rs] targets = ["x86_64-pc-windows-msvc"] [target."cfg(windows)".dependencies.winapi] version = "0.3" features = [ "std", "consoleapi", "errhandlingapi", "fileapi", "minwindef", "processenv", "sysinfoapi", "winbase", "wincon", "winerror", "winnt", ] winapi-util-0.1.6/Cargo.toml.orig000064400000000000000000000014511046102023000147620ustar 00000000000000[package] name = "winapi-util" version = "0.1.6" #:version authors = ["Andrew Gallant "] description = "A dumping ground for high level safe wrappers over winapi." documentation = "https://docs.rs/winapi-util" homepage = "https://github.com/BurntSushi/winapi-util" repository = "https://github.com/BurntSushi/winapi-util" readme = "README.md" keywords = ["windows", "winapi", "util", "win"] license = "Unlicense/MIT" categories = ["os::windows-apis", "external-ffi-bindings"] edition = "2021" [target.'cfg(windows)'.dependencies.winapi] version = "0.3" features = [ "std", "consoleapi", "errhandlingapi", "fileapi", "minwindef", "processenv", "sysinfoapi", "winbase", "wincon", "winerror", "winnt", ] [package.metadata.docs.rs] targets = ["x86_64-pc-windows-msvc"] winapi-util-0.1.6/LICENSE-MIT000064400000000000000000000020711046102023000135260ustar 00000000000000The MIT License (MIT) Copyright (c) 2017 Andrew Gallant 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. winapi-util-0.1.6/README.md000064400000000000000000000037351046102023000133610ustar 00000000000000winapi-util =========== This crate provides a smattering of safe wrappers around various parts of the [winapi](https://crates.io/crates/winapi) crate. [![Build status](https://github.com/BurntSushi/winapi-util/workflows/ci/badge.svg)](https://github.com/BurntSushi/winapi-util/actions) [![](http://meritbadge.herokuapp.com/winapi-util)](https://crates.io/crates/winapi-util) Dual-licensed under MIT or the [UNLICENSE](http://unlicense.org). ### Documentation https://docs.rs/winapi-util ### Usage Run `cargo add winapi-util` to add this dependency to your `Cargo.toml` file. ### Notes This crate was born out of frustration with having to write lots of little ffi utility bindings in a variety of crates in order to get Windows support. Eventually, I started needing to copy & paste a lot of those utility routines. Since they are utility routines, they often don't make sense to expose directly in the crate in which they are defined. Instead of continuing this process, I decided to make a crate instead. Normally, I'm not a huge fan of "utility" crates like this that don't have a well defined scope, but this is primarily a practical endeavor to make it easier to isolate Windows specific ffi code. While I don't have a long term vision for this crate, I will welcome additional PRs that add more high level routines/types on an as-needed basis. **WARNING:** I am not a Windows developer, so extra review to make sure I've got things right is most appreciated. ### Minimum Rust version policy This crate's minimum supported `rustc` version is `1.72.0`. The current policy is that the minimum Rust version required to use this crate can be increased in non-breaking version updates. For example, if `crate 1.0` requires Rust 1.20.0, then `crate 1.0.z` for all values of `z` will also require Rust 1.20.0 or newer. However, `crate 1.y` for `y > 0` may require a newer minimum version of Rust. In general, this crate will be conservative with respect to the minimum supported version of Rust. winapi-util-0.1.6/UNLICENSE000064400000000000000000000022731046102023000133460ustar 00000000000000This is free and unencumbered software released into the public domain. Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means. In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law. 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 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. For more information, please refer to winapi-util-0.1.6/rustfmt.toml000064400000000000000000000000541046102023000144720ustar 00000000000000max_width = 79 use_small_heuristics = "max" winapi-util-0.1.6/src/console.rs000064400000000000000000000274141046102023000147010ustar 00000000000000use std::{io, mem}; use winapi::{ shared::minwindef::WORD, um::{ consoleapi::{GetConsoleMode, SetConsoleMode}, wincon::{ self, GetConsoleScreenBufferInfo, SetConsoleTextAttribute, CONSOLE_SCREEN_BUFFER_INFO, FOREGROUND_BLUE as FG_BLUE, FOREGROUND_GREEN as FG_GREEN, FOREGROUND_INTENSITY as FG_INTENSITY, FOREGROUND_RED as FG_RED, }, }, }; use crate::{AsHandleRef, HandleRef}; const FG_CYAN: WORD = FG_BLUE | FG_GREEN; const FG_MAGENTA: WORD = FG_BLUE | FG_RED; const FG_YELLOW: WORD = FG_GREEN | FG_RED; const FG_WHITE: WORD = FG_BLUE | FG_GREEN | FG_RED; /// Query the given handle for information about the console's screen buffer. /// /// The given handle should represent a console. Otherwise, an error is /// returned. /// /// This corresponds to calling [`GetConsoleScreenBufferInfo`]. /// /// [`GetConsoleScreenBufferInfo`]: https://docs.microsoft.com/en-us/windows/console/getconsolescreenbufferinfo pub fn screen_buffer_info( h: H, ) -> io::Result { unsafe { let mut info: CONSOLE_SCREEN_BUFFER_INFO = mem::zeroed(); let rc = GetConsoleScreenBufferInfo(h.as_raw(), &mut info); if rc == 0 { return Err(io::Error::last_os_error()); } Ok(ScreenBufferInfo(info)) } } /// Set the text attributes of the console represented by the given handle. /// /// This corresponds to calling [`SetConsoleTextAttribute`]. /// /// [`SetConsoleTextAttribute`]: https://docs.microsoft.com/en-us/windows/console/setconsoletextattribute pub fn set_text_attributes( h: H, attributes: u16, ) -> io::Result<()> { if unsafe { SetConsoleTextAttribute(h.as_raw(), attributes) } == 0 { Err(io::Error::last_os_error()) } else { Ok(()) } } /// Query the mode of the console represented by the given handle. /// /// This corresponds to calling [`GetConsoleMode`], which describes the return /// value. /// /// [`GetConsoleMode`]: https://docs.microsoft.com/en-us/windows/console/getconsolemode pub fn mode(h: H) -> io::Result { let mut mode = 0; if unsafe { GetConsoleMode(h.as_raw(), &mut mode) } == 0 { Err(io::Error::last_os_error()) } else { Ok(mode) } } /// Set the mode of the console represented by the given handle. /// /// This corresponds to calling [`SetConsoleMode`], which describes the format /// of the mode parameter. /// /// [`SetConsoleMode`]: https://docs.microsoft.com/en-us/windows/console/setconsolemode pub fn set_mode(h: H, mode: u32) -> io::Result<()> { if unsafe { SetConsoleMode(h.as_raw(), mode) } == 0 { Err(io::Error::last_os_error()) } else { Ok(()) } } /// Represents console screen buffer information such as size, cursor position /// and styling attributes. /// /// This wraps a [`CONSOLE_SCREEN_BUFFER_INFO`]. /// /// [`CONSOLE_SCREEN_BUFFER_INFO`]: https://docs.microsoft.com/en-us/windows/console/console-screen-buffer-info-str #[derive(Clone)] pub struct ScreenBufferInfo(CONSOLE_SCREEN_BUFFER_INFO); impl ScreenBufferInfo { /// Returns the size of the console screen buffer, in character columns and /// rows. /// /// This corresponds to `dwSize`. pub fn size(&self) -> (i16, i16) { (self.0.dwSize.X, self.0.dwSize.Y) } /// Returns the position of the cursor in terms of column and row /// coordinates of the console screen buffer. /// /// This corresponds to `dwCursorPosition`. pub fn cursor_position(&self) -> (i16, i16) { (self.0.dwCursorPosition.X, self.0.dwCursorPosition.Y) } /// Returns the character attributes associated with this console. /// /// This corresponds to `wAttributes`. /// /// See [`char info`] for more details. /// /// [`char info`]: https://docs.microsoft.com/en-us/windows/console/char-info-str pub fn attributes(&self) -> u16 { self.0.wAttributes } /// Returns the maximum size of the console window, in character columns /// and rows, given the current screen buffer size and font and the screen /// size. pub fn max_window_size(&self) -> (i16, i16) { (self.0.dwMaximumWindowSize.X, self.0.dwMaximumWindowSize.Y) } /// Returns the console screen buffer coordinates of the upper-left and /// lower-right corners of the display window. /// /// This corresponds to `srWindow`. pub fn window_rect(&self) -> SmallRect { SmallRect { left: self.0.srWindow.Left, top: self.0.srWindow.Top, right: self.0.srWindow.Right, bottom: self.0.srWindow.Bottom, } } } /// Defines the coordinates of the upper left and lower right corners of a rectangle. /// /// This corresponds to [`SMALL_RECT`]. /// /// [`SMALL_RECT`]: https://docs.microsoft.com/en-us/windows/console/small-rect-str pub struct SmallRect { pub left: i16, pub top: i16, pub right: i16, pub bottom: i16, } /// A Windows console. /// /// This represents a very limited set of functionality available to a Windows /// console. In particular, it can only change text attributes such as color /// and intensity. This may grow over time. If you need more routines, please /// file an issue and/or PR. /// /// There is no way to "write" to this console. Simply write to /// stdout or stderr instead, while interleaving instructions to the console /// to change text attributes. /// /// A common pitfall when using a console is to forget to flush writes to /// stdout before setting new text attributes. /// /// # Example /// ```no_run /// # #[cfg(windows)] /// # { /// use winapi_util::console::{Console, Color, Intense}; /// /// let mut con = Console::stdout().unwrap(); /// con.fg(Intense::Yes, Color::Cyan).unwrap(); /// println!("This text will be intense cyan."); /// con.reset().unwrap(); /// println!("This text will be normal."); /// # } /// ``` #[derive(Debug)] pub struct Console { kind: HandleKind, start_attr: TextAttributes, cur_attr: TextAttributes, } #[derive(Clone, Copy, Debug)] enum HandleKind { Stdout, Stderr, } impl HandleKind { fn handle(&self) -> HandleRef { match *self { HandleKind::Stdout => HandleRef::stdout(), HandleKind::Stderr => HandleRef::stderr(), } } } impl Console { /// Get a console for a standard I/O stream. fn create_for_stream(kind: HandleKind) -> io::Result { let h = kind.handle(); let info = screen_buffer_info(&h)?; let attr = TextAttributes::from_word(info.attributes()); Ok(Console { kind, start_attr: attr, cur_attr: attr }) } /// Create a new Console to stdout. /// /// If there was a problem creating the console, then an error is returned. pub fn stdout() -> io::Result { Self::create_for_stream(HandleKind::Stdout) } /// Create a new Console to stderr. /// /// If there was a problem creating the console, then an error is returned. pub fn stderr() -> io::Result { Self::create_for_stream(HandleKind::Stderr) } /// Applies the current text attributes. fn set(&mut self) -> io::Result<()> { set_text_attributes(self.kind.handle(), self.cur_attr.to_word()) } /// Apply the given intensity and color attributes to the console /// foreground. /// /// If there was a problem setting attributes on the console, then an error /// is returned. pub fn fg(&mut self, intense: Intense, color: Color) -> io::Result<()> { self.cur_attr.fg_color = color; self.cur_attr.fg_intense = intense; self.set() } /// Apply the given intensity and color attributes to the console /// background. /// /// If there was a problem setting attributes on the console, then an error /// is returned. pub fn bg(&mut self, intense: Intense, color: Color) -> io::Result<()> { self.cur_attr.bg_color = color; self.cur_attr.bg_intense = intense; self.set() } /// Reset the console text attributes to their original settings. /// /// The original settings correspond to the text attributes on the console /// when this `Console` value was created. /// /// If there was a problem setting attributes on the console, then an error /// is returned. pub fn reset(&mut self) -> io::Result<()> { self.cur_attr = self.start_attr; self.set() } /// Toggle virtual terminal processing. /// /// This method attempts to toggle virtual terminal processing for this /// console. If there was a problem toggling it, then an error returned. /// On success, the caller may assume that toggling it was successful. /// /// When virtual terminal processing is enabled, characters emitted to the /// console are parsed for VT100 and similar control character sequences /// that control color and other similar operations. pub fn set_virtual_terminal_processing( &mut self, yes: bool, ) -> io::Result<()> { let vt = wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING; let handle = self.kind.handle(); let old_mode = mode(&handle)?; let new_mode = if yes { old_mode | vt } else { old_mode & !vt }; if old_mode == new_mode { return Ok(()); } set_mode(&handle, new_mode) } } /// A representation of text attributes for the Windows console. #[derive(Copy, Clone, Debug, Eq, PartialEq)] struct TextAttributes { fg_color: Color, fg_intense: Intense, bg_color: Color, bg_intense: Intense, } impl TextAttributes { fn to_word(&self) -> WORD { let mut w = 0; w |= self.fg_color.to_fg(); w |= self.fg_intense.to_fg(); w |= self.bg_color.to_bg(); w |= self.bg_intense.to_bg(); w } fn from_word(word: WORD) -> TextAttributes { TextAttributes { fg_color: Color::from_fg(word), fg_intense: Intense::from_fg(word), bg_color: Color::from_bg(word), bg_intense: Intense::from_bg(word), } } } /// Whether to use intense colors or not. #[allow(missing_docs)] #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum Intense { Yes, No, } impl Intense { fn to_bg(&self) -> WORD { self.to_fg() << 4 } fn from_bg(word: WORD) -> Intense { Intense::from_fg(word >> 4) } fn to_fg(&self) -> WORD { match *self { Intense::No => 0, Intense::Yes => FG_INTENSITY, } } fn from_fg(word: WORD) -> Intense { if word & FG_INTENSITY > 0 { Intense::Yes } else { Intense::No } } } /// The set of available colors for use with a Windows console. #[allow(missing_docs)] #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum Color { Black, Blue, Green, Red, Cyan, Magenta, Yellow, White, } impl Color { fn to_bg(&self) -> WORD { self.to_fg() << 4 } fn from_bg(word: WORD) -> Color { Color::from_fg(word >> 4) } fn to_fg(&self) -> WORD { match *self { Color::Black => 0, Color::Blue => FG_BLUE, Color::Green => FG_GREEN, Color::Red => FG_RED, Color::Cyan => FG_CYAN, Color::Magenta => FG_MAGENTA, Color::Yellow => FG_YELLOW, Color::White => FG_WHITE, } } fn from_fg(word: WORD) -> Color { match word & 0b111 { FG_BLUE => Color::Blue, FG_GREEN => Color::Green, FG_RED => Color::Red, FG_CYAN => Color::Cyan, FG_MAGENTA => Color::Magenta, FG_YELLOW => Color::Yellow, FG_WHITE => Color::White, _ => Color::Black, } } } winapi-util-0.1.6/src/file.rs000064400000000000000000000122441046102023000141510ustar 00000000000000use std::{io, mem}; use winapi::{ shared::{minwindef::FILETIME, winerror::NO_ERROR}, um::{ errhandlingapi::GetLastError, fileapi::{ GetFileInformationByHandle, GetFileType, BY_HANDLE_FILE_INFORMATION, }, winnt, }, }; use crate::AsHandleRef; /// Return various pieces of information about a file. /// /// This includes information such as a file's size, unique identifier and /// time related fields. /// /// This corresponds to calling [`GetFileInformationByHandle`]. /// /// [`GetFileInformationByHandle`]: https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-getfileinformationbyhandle pub fn information(h: H) -> io::Result { unsafe { let mut info: BY_HANDLE_FILE_INFORMATION = mem::zeroed(); let rc = GetFileInformationByHandle(h.as_raw(), &mut info); if rc == 0 { return Err(io::Error::last_os_error()); }; Ok(Information(info)) } } /// Returns the file type of the given handle. /// /// If there was a problem querying the file type, then an error is returned. /// /// This corresponds to calling [`GetFileType`]. /// /// [`GetFileType`]: https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-getfiletype pub fn typ(h: H) -> io::Result { unsafe { let rc = GetFileType(h.as_raw()); if rc == 0 && GetLastError() != NO_ERROR { return Err(io::Error::last_os_error()); } Ok(Type(rc)) } } /// Returns true if and only if the given file attributes contain the /// `FILE_ATTRIBUTE_HIDDEN` attribute. pub fn is_hidden(file_attributes: u64) -> bool { file_attributes & (winnt::FILE_ATTRIBUTE_HIDDEN as u64) > 0 } /// Represents file information such as creation time, file size, etc. /// /// This wraps a [`BY_HANDLE_FILE_INFORMATION`]. /// /// [`BY_HANDLE_FILE_INFORMATION`]: https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/ns-fileapi-_by_handle_file_information #[derive(Clone)] pub struct Information(BY_HANDLE_FILE_INFORMATION); impl Information { /// Returns file attributes. /// /// This corresponds to `dwFileAttributes`. pub fn file_attributes(&self) -> u64 { self.0.dwFileAttributes as u64 } /// Returns true if and only if this file information has the /// `FILE_ATTRIBUTE_HIDDEN` attribute. pub fn is_hidden(&self) -> bool { is_hidden(self.file_attributes()) } /// Return the creation time, if one exists. /// /// This corresponds to `ftCreationTime`. pub fn creation_time(&self) -> Option { filetime_to_u64(self.0.ftCreationTime) } /// Return the last access time, if one exists. /// /// This corresponds to `ftLastAccessTime`. pub fn last_access_time(&self) -> Option { filetime_to_u64(self.0.ftLastAccessTime) } /// Return the last write time, if one exists. /// /// This corresponds to `ftLastWriteTime`. pub fn last_write_time(&self) -> Option { filetime_to_u64(self.0.ftLastWriteTime) } /// Return the serial number of the volume that the file is on. /// /// This corresponds to `dwVolumeSerialNumber`. pub fn volume_serial_number(&self) -> u64 { self.0.dwVolumeSerialNumber as u64 } /// Return the file size, in bytes. /// /// This corresponds to `nFileSizeHigh` and `nFileSizeLow`. pub fn file_size(&self) -> u64 { ((self.0.nFileSizeHigh as u64) << 32) | (self.0.nFileSizeLow as u64) } /// Return the number of links to this file. /// /// This corresponds to `nNumberOfLinks`. pub fn number_of_links(&self) -> u64 { self.0.nNumberOfLinks as u64 } /// Return the index of this file. The index of a file is a purpotedly /// unique identifier for a file within a particular volume. pub fn file_index(&self) -> u64 { ((self.0.nFileIndexHigh as u64) << 32) | (self.0.nFileIndexLow as u64) } } /// Represents a Windows file type. /// /// This wraps the result of [`GetFileType`]. /// /// [`GetFileType`]: https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-getfiletype #[derive(Clone)] pub struct Type(u32); impl Type { /// Returns true if this type represents a character file, which is /// typically an LPT device or a console. pub fn is_char(&self) -> bool { self.0 == ::winapi::um::winbase::FILE_TYPE_CHAR } /// Returns true if this type represents a disk file. pub fn is_disk(&self) -> bool { self.0 == ::winapi::um::winbase::FILE_TYPE_DISK } /// Returns true if this type represents a sock, named pipe or an /// anonymous pipe. pub fn is_pipe(&self) -> bool { self.0 == ::winapi::um::winbase::FILE_TYPE_PIPE } /// Returns true if this type is not known. /// /// Note that this never corresponds to a failure. pub fn is_unknown(&self) -> bool { self.0 == ::winapi::um::winbase::FILE_TYPE_UNKNOWN } } fn filetime_to_u64(t: FILETIME) -> Option { let v = ((t.dwHighDateTime as u64) << 32) | (t.dwLowDateTime as u64); if v == 0 { None } else { Some(v) } } winapi-util-0.1.6/src/lib.rs000064400000000000000000000024271046102023000140020ustar 00000000000000/*! This crate provides a smattering of safe routines for parts of winapi. The primary purpose of this crate is to serve as a dumping ground for various utility functions that make interactions with winapi safe. This permits the centralization of `unsafe` when dealing with Windows APIs, and thus makes it easier to audit. A key abstraction in this crate is the combination of the [`Handle`](struct.Handle.html) and [`HandleRef`](struct.HandleRef.html) types. Both represent a valid Windows handle to an I/O-like object, where `Handle` is owned (the resource is closed when the handle is dropped) and `HandleRef` is borrowed (the resource is not closed when the handle is dropped). Many of the routines in this crate work on handles and accept anything that can be safely converted into a `HandleRef`. This includes standard library types such as `File`, `Stdin`, `Stdout` and `Stderr`. Note that this crate is completely empty on non-Windows platforms. */ #[cfg(windows)] pub use win::*; /// Safe routines for dealing with the Windows console. #[cfg(windows)] pub mod console; /// Safe routines for dealing with files and handles on Windows. #[cfg(windows)] pub mod file; #[cfg(windows)] /// Safe routines for querying various Windows specific properties. pub mod sysinfo; #[cfg(windows)] mod win; winapi-util-0.1.6/src/sysinfo.rs000064400000000000000000000145501046102023000147260ustar 00000000000000use std::{ffi::OsString, io}; use winapi::um::sysinfoapi::{GetComputerNameExW, COMPUTER_NAME_FORMAT}; /// The type of name to be retrieved by [`get_computer_name`]. #[derive(Clone, Copy, Debug)] #[non_exhaustive] pub enum ComputerNameKind { /// The name of the DNS domain assigned to the local computer. If the local /// computer is a node in a cluster, lpBuffer receives the DNS domain name /// of the cluster virtual server. DnsDomain, /// The fully qualified DNS name that uniquely identifies the local /// computer. This name is a combination of the DNS host name and the DNS /// domain name, using the form HostName.DomainName. If the local computer /// is a node in a cluster, lpBuffer receives the fully qualified DNS name /// of the cluster virtual server. DnsFullyQualified, /// The DNS host name of the local computer. If the local computer is a /// node in a cluster, lpBuffer receives the DNS host name of the cluster /// virtual server. DnsHostname, /// The NetBIOS name of the local computer. If the local computer is a node /// in a cluster, lpBuffer receives the NetBIOS name of the cluster virtual /// server. NetBios, /// The name of the DNS domain assigned to the local computer. If the local /// computer is a node in a cluster, lpBuffer receives the DNS domain name /// of the local computer, not the name of the cluster virtual server. PhysicalDnsDomain, /// The fully qualified DNS name that uniquely identifies the computer. If /// the local computer is a node in a cluster, lpBuffer receives the fully /// qualified DNS name of the local computer, not the name of the cluster /// virtual server. /// /// The fully qualified DNS name is a combination of the DNS host name and /// the DNS domain name, using the form HostName.DomainName. PhysicalDnsFullyQualified, /// The DNS host name of the local computer. If the local computer is a /// node in a cluster, lpBuffer receives the DNS host name of the local /// computer, not the name of the cluster virtual server. PhysicalDnsHostname, /// The NetBIOS name of the local computer. If the local computer is a node /// in a cluster, lpBuffer receives the NetBIOS name of the local computer, /// not the name of the cluster virtual server. PhysicalNetBios, } impl ComputerNameKind { fn to_format(&self) -> COMPUTER_NAME_FORMAT { use self::ComputerNameKind::*; use winapi::um::sysinfoapi; match *self { DnsDomain => sysinfoapi::ComputerNameDnsDomain, DnsFullyQualified => sysinfoapi::ComputerNameDnsFullyQualified, DnsHostname => sysinfoapi::ComputerNameDnsHostname, NetBios => sysinfoapi::ComputerNameNetBIOS, PhysicalDnsDomain => sysinfoapi::ComputerNamePhysicalDnsDomain, PhysicalDnsFullyQualified => { sysinfoapi::ComputerNamePhysicalDnsFullyQualified } PhysicalDnsHostname => sysinfoapi::ComputerNamePhysicalDnsHostname, PhysicalNetBios => sysinfoapi::ComputerNamePhysicalNetBIOS, } } } /// Retrieves a NetBIOS or DNS name associated with the local computer. /// /// The names are established at system startup, when the system reads them /// from the registry. /// /// This corresponds to calling [`GetComputerNameExW`]. /// /// [`GetComputerNameExW`]: https://learn.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getcomputernameexw pub fn get_computer_name(kind: ComputerNameKind) -> io::Result { use std::os::windows::ffi::OsStringExt; let format = kind.to_format(); let mut len1 = 0; // SAFETY: As documented, we call this with a null pointer which will in // turn cause this routine to write the required buffer size fo `len1`. // Also, we explicitly ignore the return value since we expect this call to // fail given that the destination buffer is too small by design. let _ = unsafe { GetComputerNameExW(format, std::ptr::null_mut(), &mut len1) }; let len = match usize::try_from(len1) { Ok(len) => len, Err(_) => { return Err(io::Error::new( io::ErrorKind::Other, "GetComputerNameExW buffer length overflowed usize", )) } }; let mut buf = vec![0; len]; let mut len2 = len1; // SAFETY: We pass a valid pointer to an appropriately sized Vec. let rc = unsafe { GetComputerNameExW(format, buf.as_mut_ptr(), &mut len2) }; if rc == 0 { return Err(io::Error::last_os_error()); } // Apparently, the subsequent call writes the number of characters written // to the buffer to `len2` but not including the NUL terminator. Notice // that in the first call above, the length written to `len1` *does* // include the NUL terminator. Therefore, we expect `len1` to be at least // one greater than `len2`. If not, then something weird has happened and // we report an error. if len1 <= len2 { let msg = format!( "GetComputerNameExW buffer length mismatch, \ expected length strictly less than {} \ but got {}", len1, len2, ); return Err(io::Error::new(io::ErrorKind::Other, msg)); } let len = usize::try_from(len2).expect("len1 fits implies len2 fits"); Ok(OsString::from_wide(&buf[..len])) } #[cfg(test)] mod tests { use super::*; // This test doesn't really check anything other than that we can // successfully query all kinds of computer names. We just print them out // since there aren't really any properties about the names that we can // assert. // // We specifically run this test in CI with --nocapture so that we can see // the output. #[test] fn itworks() { let kinds = [ ComputerNameKind::DnsDomain, ComputerNameKind::DnsFullyQualified, ComputerNameKind::DnsHostname, ComputerNameKind::NetBios, ComputerNameKind::PhysicalDnsDomain, ComputerNameKind::PhysicalDnsFullyQualified, ComputerNameKind::PhysicalDnsHostname, ComputerNameKind::PhysicalNetBios, ]; for kind in kinds { let result = get_computer_name(kind); let name = result.unwrap(); println!("{kind:?}: {name:?}"); } } } winapi-util-0.1.6/src/win.rs000064400000000000000000000164471046102023000140400ustar 00000000000000use std::{ fs::File, io, os::windows::io::{AsRawHandle, FromRawHandle, IntoRawHandle, RawHandle}, path::Path, process, }; /// A handle represents an owned and valid Windows handle to a file-like /// object. /// /// When an owned handle is dropped, then the underlying raw handle is closed. /// To get a borrowed handle, use `HandleRef`. #[derive(Debug)] pub struct Handle(File); impl AsRawHandle for Handle { fn as_raw_handle(&self) -> RawHandle { self.0.as_raw_handle() } } impl FromRawHandle for Handle { unsafe fn from_raw_handle(handle: RawHandle) -> Handle { Handle(File::from_raw_handle(handle)) } } impl IntoRawHandle for Handle { fn into_raw_handle(self) -> RawHandle { self.0.into_raw_handle() } } impl Handle { /// Create an owned handle to the given file. /// /// When the returned handle is dropped, the file is closed. /// /// Note that if the given file represents a handle to a directory, then /// it is generally required that it have been opened with the /// [`FILE_FLAG_BACKUP_SEMANTICS`] flag in order to use it in various /// calls such as `information` or `typ`. To have this done automatically /// for you, use the `from_path_any` constructor. /// /// [`FILE_FLAG_BACKUP_SEMANTICS`]: https://docs.microsoft.com/en-us/windows/desktop/api/FileAPI/nf-fileapi-createfilea pub fn from_file(file: File) -> Handle { Handle(file) } /// Open a file to the given file path, and return an owned handle to that /// file. /// /// When the returned handle is dropped, the file is closed. /// /// If there was a problem opening the file, then the corresponding error /// is returned. pub fn from_path>(path: P) -> io::Result { Ok(Handle::from_file(File::open(path)?)) } /// Like `from_path`, but supports opening directory handles as well. /// /// If you use `from_path` on a directory, then subsequent queries using /// that handle will fail. pub fn from_path_any>(path: P) -> io::Result { use std::fs::OpenOptions; use std::os::windows::fs::OpenOptionsExt; use winapi::um::winbase::FILE_FLAG_BACKUP_SEMANTICS; let file = OpenOptions::new() .read(true) .custom_flags(FILE_FLAG_BACKUP_SEMANTICS) .open(path)?; Ok(Handle::from_file(file)) } /// Return this handle as a standard `File` reference. pub fn as_file(&self) -> &File { &self.0 } /// Return this handle as a standard `File` mutable reference. pub fn as_file_mut(&mut self) -> &mut File { &mut self.0 } } /// Represents a borrowed and valid Windows handle to a file-like object, such /// as stdin/stdout/stderr or an actual file. /// /// When a borrowed handle is dropped, then the underlying raw handle is /// **not** closed. To get an owned handle, use `Handle`. #[derive(Debug)] pub struct HandleRef(HandleRefInner); /// The representation of a HandleRef, on which we define a custom Drop impl /// that avoids closing the underlying raw handle. #[derive(Debug)] struct HandleRefInner(Option); impl Drop for HandleRefInner { fn drop(&mut self) { self.0.take().unwrap().into_raw_handle(); } } impl AsRawHandle for HandleRef { fn as_raw_handle(&self) -> RawHandle { self.as_file().as_raw_handle() } } impl Clone for HandleRef { fn clone(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl HandleRef { /// Create a borrowed handle to stdin. /// /// When the returned handle is dropped, stdin is not closed. pub fn stdin() -> HandleRef { unsafe { HandleRef::from_raw_handle(io::stdin().as_raw_handle()) } } /// Create a handle to stdout. /// /// When the returned handle is dropped, stdout is not closed. pub fn stdout() -> HandleRef { unsafe { HandleRef::from_raw_handle(io::stdout().as_raw_handle()) } } /// Create a handle to stderr. /// /// When the returned handle is dropped, stderr is not closed. pub fn stderr() -> HandleRef { unsafe { HandleRef::from_raw_handle(io::stderr().as_raw_handle()) } } /// Create a borrowed handle to the given file. /// /// When the returned handle is dropped, the file is not closed. pub fn from_file(file: &File) -> HandleRef { unsafe { HandleRef::from_raw_handle(file.as_raw_handle()) } } /// Create a borrowed handle from the given raw handle. /// /// Note that unlike the `FromRawHandle` trait, this constructor does /// **not** consume ownership of the given handle. That is, when the /// borrowed handle created by this constructor is dropped, the underlying /// handle will not be closed. /// /// # Safety /// /// This is unsafe because there is no guarantee that the given raw handle /// is a valid handle. The caller must ensure this is true before invoking /// this constructor. pub unsafe fn from_raw_handle(handle: RawHandle) -> HandleRef { HandleRef(HandleRefInner(Some(File::from_raw_handle(handle)))) } /// Return this handle as a standard `File` reference. pub fn as_file(&self) -> &File { (self.0).0.as_ref().unwrap() } /// Return this handle as a standard `File` mutable reference. pub fn as_file_mut(&mut self) -> &mut File { (self.0).0.as_mut().unwrap() } } /// Construct borrowed and valid Windows handles from file-like objects. pub trait AsHandleRef { /// A borrowed handle that wraps the raw handle of the `Self` object. fn as_handle_ref(&self) -> HandleRef; /// A convenience routine for extracting a `HandleRef` from `Self`, and /// then extracting a raw handle from the `HandleRef`. fn as_raw(&self) -> RawHandle { self.as_handle_ref().as_raw_handle() } } impl<'a, T: AsHandleRef> AsHandleRef for &'a T { fn as_handle_ref(&self) -> HandleRef { (**self).as_handle_ref() } } impl AsHandleRef for Handle { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for HandleRef { fn as_handle_ref(&self) -> HandleRef { self.clone() } } impl AsHandleRef for File { fn as_handle_ref(&self) -> HandleRef { HandleRef::from_file(self) } } impl AsHandleRef for io::Stdin { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for io::Stdout { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for io::Stderr { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for process::ChildStdin { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for process::ChildStdout { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } } impl AsHandleRef for process::ChildStderr { fn as_handle_ref(&self) -> HandleRef { unsafe { HandleRef::from_raw_handle(self.as_raw_handle()) } } }