pseudoterminal 0.2.1

A cross-platform pseudoterminal implementation with async support
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use std::io;
use std::os::windows;
use std::os::windows::io::AsRawHandle;
use std::os::windows::process::CommandExt;
use std::process::{Child as ChildProcess, Command};

use crate::TerminalSize;

pub struct Terminal {
    handle: HPCON,
}

pub type TerminalIn = io::PipeWriter;
pub type TerminalOut = io::PipeReader;

pub struct TerminalIo {
    pub input: Option<TerminalIn>,
    pub output: Option<TerminalOut>,
}

// Core Terminal implementation
impl Terminal {
    pub fn spawn_terminal(
        cmd: &mut Command,
        initial_size: TerminalSize,
    ) -> io::Result<(Self, ChildProcess, TerminalIo)> {
        let (input_read, input_write) = io::pipe()?;
        let (output_read, output_write) = io::pipe()?;

        let mut handle = unsafe { core::mem::zeroed() };

        unsafe extern "system" {
            fn CreatePseudoConsole(
                size: COORD,
                hinput: windows::raw::HANDLE,
                houtput: windows::raw::HANDLE,
                dwflags: u32,
                phpc: *mut HPCON,
            ) -> HRESULT;
        }

        cvt(unsafe {
            CreatePseudoConsole(
                COORD::from(initial_size),
                input_read.as_raw_handle(),
                output_write.as_raw_handle(),
                0,
                &mut handle,
            )
        })?;

        const PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE: usize = 131094;

        let proc_attrs = unsafe {
            windows::process::ProcThreadAttributeList::build()
                .raw_attribute(
                    PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE as usize,
                    handle as *const core::ffi::c_void,
                    std::mem::size_of::<isize>(),
                )
                .finish()?
        };

        let child_proc = cmd.spawn_with_attributes(&proc_attrs)?;

        Ok((
            Self { handle },
            child_proc,
            TerminalIo {
                input: Some(input_write),
                output: Some(output_read),
            },
        ))
    }

    pub fn set_term_size(&self, new_size: TerminalSize) -> io::Result<()> {
        unsafe extern "system" {
            fn ResizePseudoConsole(hpc: HPCON, size: COORD) -> HRESULT;
        }

        unsafe { cvt(ResizePseudoConsole(self.handle, COORD::from(new_size))) }
    }
}

impl Drop for Terminal {
    fn drop(&mut self) {
        unsafe extern "system" {
            fn ClosePseudoConsole(hpc: HPCON);
        }

        unsafe { ClosePseudoConsole(self.handle) }
    }
}

type HPCON = isize;
type HRESULT = i32;

#[repr(C)]
#[allow(non_snake_case)]
pub struct COORD {
    pub X: i16,
    pub Y: i16,
}

impl From<TerminalSize> for COORD {
    fn from(size: TerminalSize) -> Self {
        COORD {
            X: size.rows as i16,
            Y: size.columns as i16,
        }
    }
}

pub fn cvt(res: HRESULT) -> io::Result<()> {
    if res < 0 {
        Err(io::Error::last_os_error())
    } else {
        Ok(())
    }
}