pub struct ProcThreadAttributeListBuilder<'a> { /* private fields */ }
windows_process_extensions_raw_attribute #114854)
Builder for constructing a ProcThreadAttributeList.
impl<'a> ProcThreadAttributeListBuilder<'a>
pub fn attribute<T>(self, attribute: usize, value: &'a T) -> Self
windows_process_extensions_raw_attribute #114854)
Sets an attribute on the attribute list.
The attribute parameter specifies the raw attribute to be set, while the value parameter holds the value associated with that attribute. Please refer to the Windows documentation for a list of valid attributes.
The maximum number of attributes is the value of u32::MAX. If this limit is exceeded, the call to Self::finish will return an Error indicating that the maximum number of attributes has been exceeded.
Remember that improper use of attributes can lead to undefined behavior or security vulnerabilities. Always consult the documentation and ensure proper attribute values are used.
pub unsafe fn raw_attribute<T>(
self,
attribute: usize,
value_ptr: *const T,
value_size: usize,
) -> Selfwindows_process_extensions_raw_attribute #114854)
Sets a raw attribute on the attribute list.
This function is useful for setting attributes with pointers or sizes that cannot be derived directly from their values.
This function is marked as unsafe because it deals with raw pointers and sizes. It is the responsibility of the caller to ensure the value lives longer than the resulting ProcThreadAttributeList as well as the validity of the size parameter.
#![feature(windows_process_extensions_raw_attribute)]
use std::ffi::c_void;
use std::os::windows::process::{CommandExt, ProcThreadAttributeList};
use std::os::windows::raw::HANDLE;
use std::process::Command;
#[repr(C)]
pub struct COORD {
pub X: i16,
pub Y: i16,
}
unsafe extern "system" {
fn CreatePipe(
hreadpipe: *mut HANDLE,
hwritepipe: *mut HANDLE,
lppipeattributes: *const c_void,
nsize: u32,
) -> i32;
fn CreatePseudoConsole(
size: COORD,
hinput: HANDLE,
houtput: HANDLE,
dwflags: u32,
phpc: *mut isize,
) -> i32;
fn CloseHandle(hobject: HANDLE) -> i32;
}
let [mut input_read_side, mut output_write_side, mut output_read_side, mut input_write_side] =
[unsafe { std::mem::zeroed::<HANDLE>() }; 4];
unsafe {
CreatePipe(&mut input_read_side, &mut input_write_side, std::ptr::null(), 0);
CreatePipe(&mut output_read_side, &mut output_write_side, std::ptr::null(), 0);
}
let size = COORD { X: 60, Y: 40 };
let mut h_pc = unsafe { std::mem::zeroed() };
unsafe { CreatePseudoConsole(size, input_read_side, output_write_side, 0, &mut h_pc) };
unsafe { CloseHandle(input_read_side) };
unsafe { CloseHandle(output_write_side) };
const PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE: usize = 131094;
let attribute_list = unsafe {
ProcThreadAttributeList::build()
.raw_attribute(
PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
h_pc as *const c_void,
size_of::<isize>(),
)
.finish()?
};
let mut child = Command::new("cmd").spawn_with_attributes(&attribute_list)?;pub fn finish(&self) -> Result<ProcThreadAttributeList<'a>>
windows_process_extensions_raw_attribute #114854)
Finalizes the construction of the ProcThreadAttributeList.
Returns an error if the maximum number of attributes is exceeded or if there is an I/O error during initialization.
impl<'a> Clone for ProcThreadAttributeListBuilder<'a>
fn clone(&self) -> ProcThreadAttributeListBuilder<'a>
fn clone_from(&mut self, source: &Self)
source. Read more
impl<'a> Debug for ProcThreadAttributeListBuilder<'a>
impl<'a> Freeze for ProcThreadAttributeListBuilder<'a>
impl<'a> RefUnwindSafe for ProcThreadAttributeListBuilder<'a>
impl<'a> !Send for ProcThreadAttributeListBuilder<'a>
impl<'a> !Sync for ProcThreadAttributeListBuilder<'a>
impl<'a> Unpin for ProcThreadAttributeListBuilder<'a>
impl<'a> UnwindSafe for ProcThreadAttributeListBuilder<'a>
impl<T> Any for Twhere
T: 'static + ?Sized,impl<T> Borrow<T> for Twhere
T: ?Sized,impl<T> BorrowMut<T> for Twhere
T: ?Sized,impl<T> CloneToUninit for Twhere
T: Clone,unsafe fn clone_to_uninit(&self, dest: *mut u8)
clone_to_uninit #126799)
impl<T> From<T> for T
fn from(t: T) -> T
Returns the argument unchanged.
impl<T, U> Into<U> for Twhere
U: From<T>,fn into(self) -> U
Calls U::from(self).
That is, this conversion is whatever the implementation of From<T> for U chooses to do.
impl<T> ToOwned for Twhere
T: Clone,type Owned = T
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)
impl<T, U> TryFrom<U> for Twhere
U: Into<T>,type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/os/windows/process/struct.ProcThreadAttributeListBuilder.html