rust/chg/src/attachio.rs

hg: don't attempt to extend `sys.path` with the user site without `APPDATA`

This variable is created by the system and *should* be available, but
test-lfs-bundle.t has a test where it is explicitly unset.  It wasn't caught
before because prior to 95af358fcdfe, it was limited to the py2exe binary.  As a
precaution, fix both that and the pyoxidizer case that was causing the test to
fail.

Differential Revision: https://phab.mercurial-scm.org/D11354

// Copyright 2018 Yuya Nishihara <[e-mail]>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

//! Functions to send client-side fds over the command server channel.

use std::io;
use std::os::unix::io::AsRawFd;
use tokio_hglib::codec::ChannelMessage;
use tokio_hglib::{Connection, Protocol};

use crate::message;
use crate::procutil;

/// Sends client-side fds over the command server channel.
///
/// This works as follows:
/// 1. Client sends "attachio" request.
/// 2. Server sends back 1-byte input request.
/// 3. Client sends fds with 1-byte dummy payload in response.
/// 4. Server returns the number of the fds received.
///
/// The client-side fds may be dropped once duplicated to the server.
pub async fn attach_io(
    proto: &mut Protocol<impl Connection + AsRawFd>,
    stdin: &impl AsRawFd,
    stdout: &impl AsRawFd,
    stderr: &impl AsRawFd,
) -> io::Result<()> {
    proto.send_command("attachio").await?;
    loop {
        match proto.fetch_response().await? {
            ChannelMessage::Data(b'r', data) => {
                let fd_cnt = message::parse_result_code(data)?;
                if fd_cnt == 3 {
                    return Ok(());
                } else {
                    return Err(io::Error::new(
                        io::ErrorKind::InvalidData,
                        "unexpected attachio result",
                    ));
                }
            }
            ChannelMessage::Data(..) => {
                // just ignore data sent to uninteresting (optional) channel
            }
            ChannelMessage::InputRequest(1) => {
                // this may fail with EWOULDBLOCK in theory, but the
                // payload is quite small, and the send buffer should
                // be empty so the operation will complete immediately
                let sock_fd = proto.as_raw_fd();
                let ifd = stdin.as_raw_fd();
                let ofd = stdout.as_raw_fd();
                let efd = stderr.as_raw_fd();
                procutil::send_raw_fds(sock_fd, &[ifd, ofd, efd])?;
            }
            ChannelMessage::InputRequest(..)
            | ChannelMessage::LineRequest(..)
            | ChannelMessage::SystemRequest(..) => {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    "unsupported request while attaching io",
                ));
            }
        }
    }
}