1 #![unstable(feature = "process_internals", issue = "none")]
7 use crate::collections
::BTreeMap
;
9 use crate::env
::consts
::{EXE_EXTENSION, EXE_SUFFIX}
;
10 use crate::ffi
::{OsStr, OsString}
;
12 use crate::io
::{self, Error, ErrorKind}
;
14 use crate::num
::NonZeroI32
;
15 use crate::os
::windows
::ffi
::{OsStrExt, OsStringExt}
;
16 use crate::os
::windows
::io
::{AsHandle, AsRawHandle, BorrowedHandle, FromRawHandle, IntoRawHandle}
;
17 use crate::path
::{Path, PathBuf}
;
19 use crate::sync
::Mutex
;
20 use crate::sys
::args
::{self, Arg}
;
22 use crate::sys
::c
::NonZeroDWORD
;
24 use crate::sys
::fs
::{File, OpenOptions}
;
25 use crate::sys
::handle
::Handle
;
27 use crate::sys
::pipe
::{self, AnonPipe}
;
28 use crate::sys
::stdio
;
29 use crate::sys_common
::process
::{CommandEnv, CommandEnvs}
;
30 use crate::sys_common
::IntoInner
;
32 use libc
::{c_void, EXIT_FAILURE, EXIT_SUCCESS}
;
34 ////////////////////////////////////////////////////////////////////////////////
36 ////////////////////////////////////////////////////////////////////////////////
38 #[derive(Clone, Debug, Eq)]
42 // This stores a UTF-16 encoded string to workaround the mismatch between
43 // Rust's OsString (WTF-8) and the Windows API string type (UTF-16).
44 // Normally converting on every API call is acceptable but here
45 // `c::CompareStringOrdinal` will be called for every use of `==`.
50 fn new
<T
: Into
<OsString
>>(key
: T
) -> Self {
51 EnvKey
::from(key
.into())
55 // Comparing Windows environment variable keys[1] are behaviourally the
56 // composition of two operations[2]:
58 // 1. Case-fold both strings. This is done using a language-independent
59 // uppercase mapping that's unique to Windows (albeit based on data from an
60 // older Unicode spec). It only operates on individual UTF-16 code units so
61 // surrogates are left unchanged. This uppercase mapping can potentially change
62 // between Windows versions.
64 // 2. Perform an ordinal comparison of the strings. A comparison using ordinal
65 // is just a comparison based on the numerical value of each UTF-16 code unit[3].
67 // Because the case-folding mapping is unique to Windows and not guaranteed to
68 // be stable, we ask the OS to compare the strings for us. This is done by
69 // calling `CompareStringOrdinal`[4] with `bIgnoreCase` set to `TRUE`.
71 // [1] https://docs.microsoft.com/en-us/dotnet/standard/base-types/best-practices-strings#choosing-a-stringcomparison-member-for-your-method-call
72 // [2] https://docs.microsoft.com/en-us/dotnet/standard/base-types/best-practices-strings#stringtoupper-and-stringtolower
73 // [3] https://docs.microsoft.com/en-us/dotnet/api/system.stringcomparison?view=net-5.0#System_StringComparison_Ordinal
74 // [4] https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-comparestringordinal
76 fn cmp(&self, other
: &Self) -> cmp
::Ordering
{
78 let result
= c
::CompareStringOrdinal(
80 self.utf16
.len() as _
,
82 other
.utf16
.len() as _
,
86 c
::CSTR_LESS_THAN
=> cmp
::Ordering
::Less
,
87 c
::CSTR_EQUAL
=> cmp
::Ordering
::Equal
,
88 c
::CSTR_GREATER_THAN
=> cmp
::Ordering
::Greater
,
89 // `CompareStringOrdinal` should never fail so long as the parameters are correct.
90 _
=> panic
!("comparing environment keys failed: {}", Error
::last_os_error()),
95 impl PartialOrd
for EnvKey
{
96 fn partial_cmp(&self, other
: &Self) -> Option
<cmp
::Ordering
> {
100 impl PartialEq
for EnvKey
{
101 fn eq(&self, other
: &Self) -> bool
{
102 if self.utf16
.len() != other
.utf16
.len() {
105 self.cmp(other
) == cmp
::Ordering
::Equal
109 impl PartialOrd
<str> for EnvKey
{
110 fn partial_cmp(&self, other
: &str) -> Option
<cmp
::Ordering
> {
111 Some(self.cmp(&EnvKey
::new(other
)))
114 impl PartialEq
<str> for EnvKey
{
115 fn eq(&self, other
: &str) -> bool
{
116 if self.os_string
.len() != other
.len() {
119 self.cmp(&EnvKey
::new(other
)) == cmp
::Ordering
::Equal
124 // Environment variable keys should preserve their original case even though
125 // they are compared using a caseless string mapping.
126 impl From
<OsString
> for EnvKey
{
127 fn from(k
: OsString
) -> Self {
128 EnvKey { utf16: k.encode_wide().collect(), os_string: k }
132 impl From
<EnvKey
> for OsString
{
133 fn from(k
: EnvKey
) -> Self {
138 impl From
<&OsStr
> for EnvKey
{
139 fn from(k
: &OsStr
) -> Self {
140 Self::from(k
.to_os_string())
144 impl AsRef
<OsStr
> for EnvKey
{
145 fn as_ref(&self) -> &OsStr
{
150 pub(crate) fn ensure_no_nuls
<T
: AsRef
<OsStr
>>(str: T
) -> io
::Result
<T
> {
151 if str.as_ref().encode_wide().any(|b
| b
== 0) {
152 Err(io
::const_io_error
!(ErrorKind
::InvalidInput
, "nul byte found in provided data"))
162 cwd
: Option
<OsString
>,
164 detach
: bool
, // not currently exposed in std::process
165 stdin
: Option
<Stdio
>,
166 stdout
: Option
<Stdio
>,
167 stderr
: Option
<Stdio
>,
168 force_quotes_enabled
: bool
,
179 pub struct StdioPipes
{
180 pub stdin
: Option
<AnonPipe
>,
181 pub stdout
: Option
<AnonPipe
>,
182 pub stderr
: Option
<AnonPipe
>,
186 pub fn new(program
: &OsStr
) -> Command
{
188 program
: program
.to_os_string(),
190 env
: Default
::default(),
197 force_quotes_enabled
: false,
201 pub fn arg(&mut self, arg
: &OsStr
) {
202 self.args
.push(Arg
::Regular(arg
.to_os_string()))
204 pub fn env_mut(&mut self) -> &mut CommandEnv
{
207 pub fn cwd(&mut self, dir
: &OsStr
) {
208 self.cwd
= Some(dir
.to_os_string())
210 pub fn stdin(&mut self, stdin
: Stdio
) {
211 self.stdin
= Some(stdin
);
213 pub fn stdout(&mut self, stdout
: Stdio
) {
214 self.stdout
= Some(stdout
);
216 pub fn stderr(&mut self, stderr
: Stdio
) {
217 self.stderr
= Some(stderr
);
219 pub fn creation_flags(&mut self, flags
: u32) {
223 pub fn force_quotes(&mut self, enabled
: bool
) {
224 self.force_quotes_enabled
= enabled
;
227 pub fn raw_arg(&mut self, command_str_to_append
: &OsStr
) {
228 self.args
.push(Arg
::Raw(command_str_to_append
.to_os_string()))
231 pub fn get_program(&self) -> &OsStr
{
235 pub fn get_args(&self) -> CommandArgs
<'_
> {
236 let iter
= self.args
.iter();
240 pub fn get_envs(&self) -> CommandEnvs
<'_
> {
244 pub fn get_current_dir(&self) -> Option
<&Path
> {
245 self.cwd
.as_ref().map(|cwd
| Path
::new(cwd
))
252 ) -> io
::Result
<(Process
, StdioPipes
)> {
253 let maybe_env
= self.env
.capture_if_changed();
255 let mut si
= zeroed_startupinfo();
256 si
.cb
= mem
::size_of
::<c
::STARTUPINFO
>() as c
::DWORD
;
257 si
.dwFlags
= c
::STARTF_USESTDHANDLES
;
259 let child_paths
= if let Some(env
) = maybe_env
.as_ref() {
260 env
.get(&EnvKey
::new("PATH")).map(|s
| s
.as_os_str())
264 let program
= resolve_exe(&self.program
, || env
::var_os("PATH"), child_paths
)?
;
265 // Case insensitive "ends_with" of UTF-16 encoded ".bat" or ".cmd"
266 let is_batch_file
= matches
!(
267 program
.len().checked_sub(5).and_then(|i
| program
.get(i
..)),
268 Some([46, 98 | 66, 97 | 65, 116 | 84, 0] | [46, 99 | 67, 109 | 77, 100 | 68, 0])
270 let (program
, mut cmd_str
) = if is_batch_file
{
273 args
::make_bat_command_line(
274 &args
::to_user_path(program
)?
,
276 self.force_quotes_enabled
,
280 let cmd_str
= make_command_line(&self.program
, &self.args
, self.force_quotes_enabled
)?
;
283 cmd_str
.push(0); // add null terminator
285 // stolen from the libuv code.
286 let mut flags
= self.flags
| c
::CREATE_UNICODE_ENVIRONMENT
;
288 flags
|= c
::DETACHED_PROCESS
| c
::CREATE_NEW_PROCESS_GROUP
;
291 let (envp
, _data
) = make_envp(maybe_env
)?
;
292 let (dirp
, _data
) = make_dirp(self.cwd
.as_ref())?
;
293 let mut pi
= zeroed_process_information();
295 // Prepare all stdio handles to be inherited by the child. This
296 // currently involves duplicating any existing ones with the ability to
297 // be inherited by child processes. Note, however, that once an
298 // inheritable handle is created, *any* spawned child will inherit that
299 // handle. We only want our own child to inherit this handle, so we wrap
300 // the remaining portion of this spawn in a mutex.
302 // For more information, msdn also has an article about this race:
303 // https://support.microsoft.com/kb/315939
304 static CREATE_PROCESS_LOCK
: Mutex
<()> = Mutex
::new(());
306 let _guard
= CREATE_PROCESS_LOCK
.lock();
308 let mut pipes
= StdioPipes { stdin: None, stdout: None, stderr: None }
;
309 let null
= Stdio
::Null
;
310 let default_stdin
= if needs_stdin { &default }
else { &null }
;
311 let stdin
= self.stdin
.as_ref().unwrap_or(default_stdin
);
312 let stdout
= self.stdout
.as_ref().unwrap_or(&default);
313 let stderr
= self.stderr
.as_ref().unwrap_or(&default);
314 let stdin
= stdin
.to_handle(c
::STD_INPUT_HANDLE
, &mut pipes
.stdin
)?
;
315 let stdout
= stdout
.to_handle(c
::STD_OUTPUT_HANDLE
, &mut pipes
.stdout
)?
;
316 let stderr
= stderr
.to_handle(c
::STD_ERROR_HANDLE
, &mut pipes
.stderr
)?
;
317 si
.hStdInput
= stdin
.as_raw_handle();
318 si
.hStdOutput
= stdout
.as_raw_handle();
319 si
.hStdError
= stderr
.as_raw_handle();
322 cvt(c
::CreateProcessW(
324 cmd_str
.as_mut_ptr(),
339 handle
: Handle
::from_raw_handle(pi
.hProcess
),
340 main_thread_handle
: Handle
::from_raw_handle(pi
.hThread
),
348 impl fmt
::Debug
for Command
{
349 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
350 self.program
.fmt(f
)?
;
351 for arg
in &self.args
{
354 Arg
::Regular(s
) => s
.fmt(f
),
355 Arg
::Raw(s
) => f
.write_str(&s
.to_string_lossy()),
362 // Resolve `exe_path` to the executable name.
364 // * If the path is simply a file name then use the paths given by `search_paths` to find the executable.
365 // * Otherwise use the `exe_path` as given.
367 // This function may also append `.exe` to the name. The rationale for doing so is as follows:
369 // It is a very strong convention that Windows executables have the `exe` extension.
370 // In Rust, it is common to omit this extension.
371 // Therefore this functions first assumes `.exe` was intended.
372 // It falls back to the plain file name if a full path is given and the extension is omitted
373 // or if only a file name is given and it already contains an extension.
376 parent_paths
: impl FnOnce() -> Option
<OsString
>,
377 child_paths
: Option
<&OsStr
>,
378 ) -> io
::Result
<Vec
<u16>> {
379 // Early return if there is no filename.
380 if exe_path
.is_empty() || path
::has_trailing_slash(exe_path
) {
381 return Err(io
::const_io_error
!(
382 io
::ErrorKind
::InvalidInput
,
383 "program path has no file name",
386 // Test if the file name has the `exe` extension.
387 // This does a case-insensitive `ends_with`.
388 let has_exe_suffix
= if exe_path
.len() >= EXE_SUFFIX
.len() {
389 exe_path
.bytes()[exe_path
.len() - EXE_SUFFIX
.len()..]
390 .eq_ignore_ascii_case(EXE_SUFFIX
.as_bytes())
395 // If `exe_path` is an absolute path or a sub-path then don't search `PATH` for it.
396 if !path
::is_file_name(exe_path
) {
398 // The application name is a path to a `.exe` file.
399 // Let `CreateProcessW` figure out if it exists or not.
400 return path
::maybe_verbatim(Path
::new(exe_path
));
402 let mut path
= PathBuf
::from(exe_path
);
404 // Append `.exe` if not already there.
405 path
= path
::append_suffix(path
, EXE_SUFFIX
.as_ref());
406 if let Some(path
) = program_exists(&path
) {
409 // It's ok to use `set_extension` here because the intent is to
410 // remove the extension that was just added.
411 path
.set_extension("");
412 return path
::maybe_verbatim(&path
);
415 ensure_no_nuls(exe_path
)?
;
416 // From the `CreateProcessW` docs:
417 // > If the file name does not contain an extension, .exe is appended.
418 // Note that this rule only applies when searching paths.
419 let has_extension
= exe_path
.bytes().contains(&b'
.'
);
421 // Search the directories given by `search_paths`.
422 let result
= search_paths(parent_paths
, child_paths
, |mut path
| {
423 path
.push(&exe_path
);
425 path
.set_extension(EXE_EXTENSION
);
427 program_exists(&path
)
429 if let Some(path
) = result
{
433 // If we get here then the executable cannot be found.
434 Err(io
::const_io_error
!(io
::ErrorKind
::NotFound
, "program not found"))
437 // Calls `f` for every path that should be used to find an executable.
438 // Returns once `f` returns the path to an executable or all paths have been searched.
439 fn search_paths
<Paths
, Exists
>(
441 child_paths
: Option
<&OsStr
>,
443 ) -> Option
<Vec
<u16>>
445 Paths
: FnOnce() -> Option
<OsString
>,
446 Exists
: FnMut(PathBuf
) -> Option
<Vec
<u16>>,
449 // This is for consistency with Rust's historic behaviour.
450 if let Some(paths
) = child_paths
{
451 for path
in env
::split_paths(paths
).filter(|p
| !p
.as_os_str().is_empty()) {
452 if let Some(path
) = exists(path
) {
458 // 2. Application path
459 if let Ok(mut app_path
) = env
::current_exe() {
461 if let Some(path
) = exists(app_path
) {
466 // 3 & 4. System paths
467 // SAFETY: This uses `fill_utf16_buf` to safely call the OS functions.
469 if let Ok(Some(path
)) = super::fill_utf16_buf(
470 |buf
, size
| c
::GetSystemDirectoryW(buf
, size
),
471 |buf
| exists(PathBuf
::from(OsString
::from_wide(buf
))),
475 #[cfg(not(target_vendor = "uwp"))]
477 if let Ok(Some(path
)) = super::fill_utf16_buf(
478 |buf
, size
| c
::GetWindowsDirectoryW(buf
, size
),
479 |buf
| exists(PathBuf
::from(OsString
::from_wide(buf
))),
487 if let Some(parent_paths
) = parent_paths() {
488 for path
in env
::split_paths(&parent_paths
).filter(|p
| !p
.as_os_str().is_empty()) {
489 if let Some(path
) = exists(path
) {
497 /// Check if a file exists without following symlinks.
498 fn program_exists(path
: &Path
) -> Option
<Vec
<u16>> {
500 let path
= path
::maybe_verbatim(path
).ok()?
;
501 // Getting attributes using `GetFileAttributesW` does not follow symlinks
502 // and it will almost always be successful if the link exists.
503 // There are some exceptions for special system files (e.g. the pagefile)
504 // but these are not executable.
505 if c
::GetFileAttributesW(path
.as_ptr()) == c
::INVALID_FILE_ATTRIBUTES
{
514 fn to_handle(&self, stdio_id
: c
::DWORD
, pipe
: &mut Option
<AnonPipe
>) -> io
::Result
<Handle
> {
516 // If no stdio handle is available, then inherit means that it
517 // should still be unavailable so propagate the
518 // INVALID_HANDLE_VALUE.
519 Stdio
::Inherit
=> match stdio
::get_handle(stdio_id
) {
521 let io
= Handle
::from_raw_handle(io
);
522 let ret
= io
.duplicate(0, true, c
::DUPLICATE_SAME_ACCESS
);
523 io
.into_raw_handle();
526 Err(..) => unsafe { Ok(Handle::from_raw_handle(c::INVALID_HANDLE_VALUE)) }
,
530 let ours_readable
= stdio_id
!= c
::STD_INPUT_HANDLE
;
531 let pipes
= pipe
::anon_pipe(ours_readable
, true)?
;
532 *pipe
= Some(pipes
.ours
);
533 Ok(pipes
.theirs
.into_handle())
536 Stdio
::Pipe(ref source
) => {
537 let ours_readable
= stdio_id
!= c
::STD_INPUT_HANDLE
;
538 pipe
::spawn_pipe_relay(source
, ours_readable
, true).map(AnonPipe
::into_handle
)
541 Stdio
::Handle(ref handle
) => handle
.duplicate(0, true, c
::DUPLICATE_SAME_ACCESS
),
543 // Open up a reference to NUL with appropriate read/write
544 // permissions as well as the ability to be inherited to child
545 // processes (as this is about to be inherited).
547 let size
= mem
::size_of
::<c
::SECURITY_ATTRIBUTES
>();
548 let mut sa
= c
::SECURITY_ATTRIBUTES
{
549 nLength
: size
as c
::DWORD
,
550 lpSecurityDescriptor
: ptr
::null_mut(),
553 let mut opts
= OpenOptions
::new();
554 opts
.read(stdio_id
== c
::STD_INPUT_HANDLE
);
555 opts
.write(stdio_id
!= c
::STD_INPUT_HANDLE
);
556 opts
.security_attributes(&mut sa
);
557 File
::open(Path
::new("NUL"), &opts
).map(|file
| file
.into_inner())
563 impl From
<AnonPipe
> for Stdio
{
564 fn from(pipe
: AnonPipe
) -> Stdio
{
569 impl From
<File
> for Stdio
{
570 fn from(file
: File
) -> Stdio
{
571 Stdio
::Handle(file
.into_inner())
575 ////////////////////////////////////////////////////////////////////////////////
577 ////////////////////////////////////////////////////////////////////////////////
579 /// A value representing a child process.
581 /// The lifetime of this value is linked to the lifetime of the actual
582 /// process - the Process destructor calls self.finish() which waits
583 /// for the process to terminate.
586 main_thread_handle
: Handle
,
590 pub fn kill(&mut self) -> io
::Result
<()> {
591 cvt(unsafe { c::TerminateProcess(self.handle.as_raw_handle(), 1) }
)?
;
595 pub fn id(&self) -> u32 {
596 unsafe { c::GetProcessId(self.handle.as_raw_handle()) as u32 }
599 pub fn main_thread_handle(&self) -> BorrowedHandle
<'_
> {
600 self.main_thread_handle
.as_handle()
603 pub fn wait(&mut self) -> io
::Result
<ExitStatus
> {
605 let res
= c
::WaitForSingleObject(self.handle
.as_raw_handle(), c
::INFINITE
);
606 if res
!= c
::WAIT_OBJECT_0
{
607 return Err(Error
::last_os_error());
610 cvt(c
::GetExitCodeProcess(self.handle
.as_raw_handle(), &mut status
))?
;
611 Ok(ExitStatus(status
))
615 pub fn try_wait(&mut self) -> io
::Result
<Option
<ExitStatus
>> {
617 match c
::WaitForSingleObject(self.handle
.as_raw_handle(), 0) {
618 c
::WAIT_OBJECT_0
=> {}
622 _
=> return Err(io
::Error
::last_os_error()),
625 cvt(c
::GetExitCodeProcess(self.handle
.as_raw_handle(), &mut status
))?
;
626 Ok(Some(ExitStatus(status
)))
630 pub fn handle(&self) -> &Handle
{
634 pub fn into_handle(self) -> Handle
{
639 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
640 pub struct ExitStatus(c
::DWORD
);
643 pub fn exit_ok(&self) -> Result
<(), ExitStatusError
> {
644 match NonZeroDWORD
::try_from(self.0) {
645 /* was nonzero */ Ok(failure
) => Err(ExitStatusError(failure
)),
646 /* was zero, couldn't convert */ Err(_
) => Ok(()),
649 pub fn code(&self) -> Option
<i32> {
654 /// Converts a raw `c::DWORD` to a type-safe `ExitStatus` by wrapping it without copying.
655 impl From
<c
::DWORD
> for ExitStatus
{
656 fn from(u
: c
::DWORD
) -> ExitStatus
{
661 impl fmt
::Display
for ExitStatus
{
662 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
663 // Windows exit codes with the high bit set typically mean some form of
664 // unhandled exception or warning. In this scenario printing the exit
665 // code in decimal doesn't always make sense because it's a very large
666 // and somewhat gibberish number. The hex code is a bit more
667 // recognizable and easier to search for, so print that.
668 if self.0 & 0x80000000 != 0 {
669 write
!(f
, "exit code: {:#x}", self.0)
671 write
!(f
, "exit code: {}", self.0)
676 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
677 pub struct ExitStatusError(c
::NonZeroDWORD
);
679 impl Into
<ExitStatus
> for ExitStatusError
{
680 fn into(self) -> ExitStatus
{
681 ExitStatus(self.0.into
())
685 impl ExitStatusError
{
686 pub fn code(self) -> Option
<NonZeroI32
> {
687 Some((u32::from(self.0) as i32).try_into().unwrap())
691 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
692 pub struct ExitCode(c
::DWORD
);
695 pub const SUCCESS
: ExitCode
= ExitCode(EXIT_SUCCESS
as _
);
696 pub const FAILURE
: ExitCode
= ExitCode(EXIT_FAILURE
as _
);
699 pub fn as_i32(&self) -> i32 {
704 impl From
<u8> for ExitCode
{
705 fn from(code
: u8) -> Self {
706 ExitCode(c
::DWORD
::from(code
))
710 impl From
<u32> for ExitCode
{
711 fn from(code
: u32) -> Self {
712 ExitCode(c
::DWORD
::from(code
))
716 fn zeroed_startupinfo() -> c
::STARTUPINFO
{
719 lpReserved
: ptr
::null_mut(),
720 lpDesktop
: ptr
::null_mut(),
721 lpTitle
: ptr
::null_mut(),
732 lpReserved2
: ptr
::null_mut(),
733 hStdInput
: c
::INVALID_HANDLE_VALUE
,
734 hStdOutput
: c
::INVALID_HANDLE_VALUE
,
735 hStdError
: c
::INVALID_HANDLE_VALUE
,
739 fn zeroed_process_information() -> c
::PROCESS_INFORMATION
{
740 c
::PROCESS_INFORMATION
{
741 hProcess
: ptr
::null_mut(),
742 hThread
: ptr
::null_mut(),
748 // Produces a wide string *without terminating null*; returns an error if
749 // `prog` or any of the `args` contain a nul.
750 fn make_command_line(argv0
: &OsStr
, args
: &[Arg
], force_quotes
: bool
) -> io
::Result
<Vec
<u16>> {
751 // Encode the command and arguments in a command line string such
752 // that the spawned process may recover them using CommandLineToArgvW.
753 let mut cmd
: Vec
<u16> = Vec
::new();
755 // Always quote the program name so CreateProcess to avoid ambiguity when
756 // the child process parses its arguments.
757 // Note that quotes aren't escaped here because they can't be used in arg0.
758 // But that's ok because file paths can't contain quotes.
759 cmd
.push(b'
"' as u16);
760 cmd.extend(argv0.encode_wide());
761 cmd.push(b'"'
as u16);
764 cmd
.push(' '
as u16);
765 args
::append_arg(&mut cmd
, arg
, force_quotes
)?
;
770 // Get `cmd.exe` for use with bat scripts, encoded as a UTF-16 string.
771 fn command_prompt() -> io
::Result
<Vec
<u16>> {
772 let mut system
: Vec
<u16> = super::fill_utf16_buf(
773 |buf
, size
| unsafe { c::GetSystemDirectoryW(buf, size) }
,
776 system
.extend("\\cmd.exe".encode_utf16().chain([0]));
780 fn make_envp(maybe_env
: Option
<BTreeMap
<EnvKey
, OsString
>>) -> io
::Result
<(*mut c_void
, Vec
<u16>)> {
781 // On Windows we pass an "environment block" which is not a char**, but
782 // rather a concatenation of null-terminated k=v\0 sequences, with a final
784 if let Some(env
) = maybe_env
{
785 let mut blk
= Vec
::new();
787 // If there are no environment variables to set then signal this by
794 ensure_no_nuls(k
.os_string
)?
;
796 blk
.push('
='
as u16);
797 blk
.extend(ensure_no_nuls(v
)?
.encode_wide());
801 Ok((blk
.as_mut_ptr() as *mut c_void
, blk
))
803 Ok((ptr
::null_mut(), Vec
::new()))
807 fn make_dirp(d
: Option
<&OsString
>) -> io
::Result
<(*const u16, Vec
<u16>)> {
810 let mut dir_str
: Vec
<u16> = ensure_no_nuls(dir
)?
.encode_wide().collect();
812 Ok((dir_str
.as_ptr(), dir_str
))
814 None
=> Ok((ptr
::null(), Vec
::new())),
818 pub struct CommandArgs
<'a
> {
819 iter
: crate::slice
::Iter
<'a
, Arg
>,
822 impl<'a
> Iterator
for CommandArgs
<'a
> {
823 type Item
= &'a OsStr
;
824 fn next(&mut self) -> Option
<&'a OsStr
> {
825 self.iter
.next().map(|arg
| match arg
{
826 Arg
::Regular(s
) | Arg
::Raw(s
) => s
.as_ref(),
829 fn size_hint(&self) -> (usize, Option
<usize>) {
830 self.iter
.size_hint()
834 impl<'a
> ExactSizeIterator
for CommandArgs
<'a
> {
835 fn len(&self) -> usize {
838 fn is_empty(&self) -> bool
{
843 impl<'a
> fmt
::Debug
for CommandArgs
<'a
> {
844 fn fmt(&self, f
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
845 f
.debug_list().entries(self.iter
.clone()).finish()