russh client: channel.signal(Sig::INT) not working, but sending \x03 raw data works

[haohanyuzmx]

I am trying to send an interrupt signal to a remote process running via sudo using russh.

The Problem:

When I send the raw byte \x03 using c.data(&b"\x03"[..]), the remote process catches the interrupt as expected (prints "kill" and exits).

When I use c.signal(russh::Sig::INT), the signal seems to be ignored, and the remote process continues until it finishes (prints "end").

Code:

use russh::{ChannelMsg, Error};
use russh::Sig::INT;
use russh::client::Handler;
use russh::keys::ssh_key;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::time::sleep;

#[tokio::main]
async fn main() {
    let config = russh::client::Config::default();
    let mut session = russh::client::connect(Arc::new(config), "ip:22", Client {})
        .await
        .unwrap();
    let now=Instant::now();

    session
        .authenticate_password("user", "pass")
        .await
        .unwrap();

    let mut c = session.channel_open_session().await.unwrap();

    c.request_pty(false, "xterm", 0, 0, 0, 0, &[])
        .await
        .unwrap();
    c.exec(true, r#"sudo bash -c 'trap "echo kill; exit 1" INT; sleep 30; echo end'"#).await.unwrap();
    sleep(Duration::from_secs(1)).await;
    c.data(&b"\x03"[..]).await.unwrap(); //key line
    //c.signal(INT).await.unwrap();
    loop {
        let msg=dbg!(c.wait().await);
        if msg.is_none(){
            return;
        }
        if let Some(ChannelMsg::Data { data }) =msg{
            println!("{} {:?}", String::from_utf8_lossy(&data),now.elapsed());
        }
    }
}

struct Client {}

impl Handler for Client {
    type Error = Error;

    async fn check_server_key(&mut self, _: &ssh_key::PublicKey) -> Result<bool, Self::Error> {
        Ok(true)
    }
}