akv-cli 0.4.0

The Azure Key Vault CLI can be used to read secrets, pass them securely to other commands, or inject them into configuration files.
Documentation 
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

// Copyright 2024 Heath Stewart.
// Licensed under the MIT License. See LICENSE.txt in the project root for license information.

// cspell:disable
use libc::{fcntl, openpty, F_GETFL, F_SETFL, O_NONBLOCK};
use std::{
    io::{self, IsTerminal as _, Read},
    os::fd::{AsRawFd, BorrowedFd, FromRawFd, OwnedFd},
    process::{Child, Command, Stdio},
    ptr,
};

impl super::CommandExt for Command {
    type Output = Child;

    fn spawn_pty<'a>(&mut self) -> crate::Result<(Self::Output, super::Pty<'a>)> {
        let mut pty = 0;
        let mut pts = 0;
        unsafe {
            let ret = openpty(
                &mut pty,
                &mut pts,
                ptr::null_mut(),
                ptr::null_mut(),
                ptr::null_mut(),
            );
            if ret != 0 {
                Err(io::Error::last_os_error())?;
            }

            let mut flags = fcntl(pty, F_GETFL);
            flags |= O_NONBLOCK;
            let ret = fcntl(pty, F_SETFL, flags);
            if ret != 0 {
                Err(io::Error::last_os_error())?;
            }

            let pty = Pty::Owned(OwnedFd::from_raw_fd(pty));
            let pts = Pts(OwnedFd::from_raw_fd(pts));

            if io::stdout().is_terminal() {
                self.stdout::<Stdio>(pts.0.try_clone()?.into());
            }
            if io::stderr().is_terminal() {
                self.stderr::<Stdio>(pts.0.try_clone()?.into());
            }

            Ok((self.spawn()?, super::Pty(pty)))
        }
    }
}

/// A pseudoterminal.
#[derive(Debug)]
pub enum Pty<'a> {
    Owned(OwnedFd),
    Borrowed(BorrowedFd<'a>),
}

impl AsRawFd for Pty<'_> {
    fn as_raw_fd(&self) -> std::os::fd::RawFd {
        match self {
            Self::Owned(fd) => fd.as_raw_fd(),
            Self::Borrowed(fd) => fd.as_raw_fd(),
        }
    }
}

impl Clone for Pty<'_> {
    fn clone(&self) -> Self {
        unsafe { Self::Borrowed(BorrowedFd::borrow_raw(self.as_raw_fd())) }
    }
}

impl Read for Pty<'_> {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        let len = unsafe {
            libc::read(
                self.as_raw_fd(),
                buf.as_mut_ptr() as *mut libc::c_void,
                buf.len(),
            )
        };

        if len == -1 {
            let err = io::Error::last_os_error();
            tracing::trace!("read error {err:?}");

            if let Some(libc::EBADF) = err.raw_os_error() {
                return Ok(0);
            }

            return Err(err);
        }

        Ok(len as usize)
    }
}

/// The child end of a pseudoterminal.
#[derive(Debug)]
pub struct Pts(OwnedFd);