How to use 'distance ssh2'

[TheBlindM]

Can you improve the document or provide a demo?

	let mut  ssh = Ssh::connect(format!("{}:{}", ssh_session.ip, ssh_session.port), )?;
	ssh.authenticate();
	let x = ssh.launch_and_connect().await?;

[TheBlindM]

	impl SshAuthHandler for MySshAuthHandler{
		async fn on_authenticate(&self, event: SshAuthEvent) -> std::io::Result<Vec<String>> {



			todo!()
		}

		async fn on_verify_host(&self, host: &str) -> std::io::Result<bool> {
			todo!()
		}

		async fn on_banner(&self, text: &str) {
			todo!()
		}

		async fn on_error(&self, text: &str) {
			todo!()
		}
	}

My SSH user and password are stored in the database. How can I convert the data into the required parameters for 'distance ssh2' in MySshAuthHandler

[TheBlindM]

”Wezterm ssh "also has the same logic, but I don't quite understand

[chipsenkbeil]

Hey there! Your password will be requested within the on_authenticate function. Below is the implementation of that function for LocalSshAuthHandler.

• Your username is potentially included within the SshAuthEvent, which you can see is printed in this example.
• There may be additional instructions that can be printed.
• Everything else is within a prompt contained within the Vec<SshAuthPrompt>. This prompt is human-readable text like "Please enter your password:", so if you want to supply your password, you either need to detect that a password is being requested by parsing the prompt OR you can just return your password if you see your username is included, just assuming the prompt is for your password.

async fn on_authenticate(&self, event: SshAuthEvent) -> io::Result<Vec<String>> {
    trace!("[local] on_authenticate({event:?})");
    let task = tokio::task::spawn_blocking(move || {
        if !event.username.is_empty() {
            eprintln!("Authentication for {}", event.username);
        }

        if !event.instructions.is_empty() {
            eprintln!("{}", event.instructions);
        }

        let mut answers = Vec::new();
        for prompt in &event.prompts {
            // Contains all prompt lines including same line
            let mut prompt_lines = prompt.prompt.split('\n').collect::<Vec<_>>();

            // Line that is prompt on same line as answer
            let prompt_line = prompt_lines.pop().unwrap();

            // Go ahead and display all other lines
            for line in prompt_lines.into_iter() {
                eprintln!("{line}");
            }

            let answer = if prompt.echo {
                eprint!("{prompt_line}");
                std::io::stderr().lock().flush()?;

                let mut answer = String::new();
                std::io::stdin().read_line(&mut answer)?;
                answer
            } else {
                rpassword::prompt_password(prompt_line)?
            };

            answers.push(answer);
        }
        Ok(answers)
    });

    task.await
        .map_err(|x| io::Error::new(io::ErrorKind::Other, x))?
}

Just force the password

async fn on_authenticate(&self, event: SshAuthEvent) -> io::Result<Vec<String>> {
    let mut answers = Vec::new();
    if event.username.is_some() && event.username.unwrap() == "name" {
        // Fill in password for each prompt
        for prompt in &event.prompts {
            answers.push(String::from("password"));
        }
        Ok(answers)
    } else {
        // Unknown user (or maybe default if username not provided)
        Err(io::Error::new(io::ErrorKind::Other, "Unknown user"))
    }
}

[TheBlindM]

pub struct MySshAuthHandler{
	pwd:Option<String>
}

#[async_trait]
impl SshAuthHandler for MySshAuthHandler{
	async fn on_authenticate(&self, event: SshAuthEvent) -> std::io::Result<Vec<String>> {
		let mut answers = Vec::new();
		for prompt in &event.prompts {
			println!("{:?}", prompt);
			answers.push(self.pwd.clone().unwrap());
		}
		Ok(answers)
	}

	async fn on_verify_host(&self, host: &str) -> std::io::Result<bool> {
		println!("{:?}", "on_verify_host");
		Ok(true)
	}

	async fn on_banner(&self, text: &str) {
		trace!("[local] on_banner({text})");
	}

	async fn on_error(&self, text: &str) {
		trace!("[local] on_error({text})");
	}
}

pub async fn initConnection<R: Runtime>(initConnectDto: InitConnectDto, window: Window<R>) -> Result<()> {
	let sessionId = initConnectDto.sessionId;
	let ssh_session = ssh_session_service::find(sessionId).await?.expect("当前会话不存在");
	println!("{}", format!("{:?}:{:?}", ssh_session.ip, ssh_session.port));

	let opts = SshOpts {
		backend: Default::default(),
		identity_files: vec![],
		identities_only: None,
		port: Some(ssh_session.port as u16),
		proxy_command: None,
		user: Some(ssh_session.username),
		user_known_hosts_files: vec![],
		verbose: false,
		other: Default::default(),
	};

	let mut  ssh = Ssh::connect(ssh_session.ip,opts)?;
	ssh.authenticate(MySshAuthHandler{ pwd: ssh_session.pwd }).await.expect("authenticate err");
	let client = ssh.launch_and_connect(Default::default()).await?;
	
	
	Ok(())
}

How can I achieve real-time communication with SSH now.
like ssh2

let mut sess = Session::new()?;
    sess.set_tcp_stream(TcpStream::connect("127.0.0.1:22")?);
    sess.handshake()?;
    sess.userauth_password("u0_a36", "123456")?;

    let mut channel = sess.channel_session()?;
    let mut mode = ssh2::PtyModes::new();
    mode.set_u32(ssh2::PtyModeOpcode::TTY_OP_ISPEED, 115200);
    mode.set_u32(ssh2::PtyModeOpcode::TTY_OP_OSPEED, 115200);
    channel.request_pty("xterm-256color", Some(mode), Some((80, 24, 0, 0)))?;
    channel.shell()?;
    channel.handle_extended_data(ssh2::ExtendedData::Merge)?;
    loop {
    channel.read(&mut buf).expect("read err");
    }

   ------------------------------------------------
   channel.write(msg);

[chipsenkbeil]

After authentication, if you just want to use ssh and not the distant server, which would need to be on your remote machine, then just use let client = ssh.into_distant_client().await.unwrap();.

From there, you can use any of the high-level methods available from DistantChannelExt.

If you want to spawn a shell, you can see how this is done here: https://github.com/chipsenkbeil/distant/blob/master/src/cli/commands/client/shell.rs#L24

[TheBlindM]

This is my current code

pub struct MySshAuthHandler{
	pwd:Option<String>
}

#[async_trait]
impl SshAuthHandler for MySshAuthHandler{
	async fn on_authenticate(&self, event: SshAuthEvent) -> std::io::Result<Vec<String>> {
		let mut answers = Vec::new();
		for prompt in &event.prompts {
			println!("{:?}", prompt);
			answers.push(self.pwd.clone().unwrap());
		}
		Ok(answers)
	}

	async fn on_verify_host(&self, host: &str) -> std::io::Result<bool> {
		println!("{:?}", "on_verify_host");
		Ok(true)
	}

	async fn on_banner(&self, text: &str) {
		trace!("[local] on_banner({text})");
	}

	async fn on_error(&self, text: &str) {
		trace!("[local] on_error({text})");
	}
}

pub async fn initConnection<R: Runtime>(initConnectDto: InitConnectDto, window: Window<R>) -> Result<()> {
	let sessionId = initConnectDto.sessionId;
	let ssh_session = ssh_session_service::find(sessionId).await?.expect("当前会话不存在");
	println!("{}", format!("{:?}:{:?}", ssh_session.ip, ssh_session.port));

	let opts = SshOpts {
		backend: Default::default(),
		identity_files: vec![],
		identities_only: None,
		port: Some(ssh_session.port as u16),
		proxy_command: None,
		user: Some(ssh_session.username),
		user_known_hosts_files: vec![],
		verbose: false,
		other: Default::default(),
	};

	let mut  ssh = Ssh::connect(ssh_session.ip,opts)?;
	ssh.authenticate(MySshAuthHandler{ pwd: ssh_session.pwd }).await.expect("authenticate err");
	let client = ssh.launch_and_connect(Default::default()).await.expect("launch_and_connect err");

	let mut  environment = Environment::new();
	environment.insert("TERM".to_string(), "xterm-256color".to_string());
	let mut proc = RemoteCommand::new()
		.environment(environment)
		.pty(
			Option::from(PtySize::from_rows_and_cols(initConnectDto.ttySize.lines as u16, initConnectDto.ttySize.columns as u16)),
		)
		.spawn(client.clone_channel(), "shell")
		.await
		.with_context(|| format!("Failed to spawn shell")).expect("RemoteCommand err");

	loop {
		println!("{:?}", proc.stdout.take().unwrap().try_read()?.expect("try red err"));
	}


	Ok(())
}

I have two questions now

1.The error I encountered while executing 'launch_and_connect()'
err_msg

thread 'tokio-runtime-worker' panicked at 'launch_and_connect err: Custom { kind: BrokenPipe, error: "Failed to spawn server: ''Last login: Fri Aug  4 13:25:55 2023 from 192.168.110.243\r\r\ndistant server listen --daemon --host ssh\r\n\r\n(base) ]0;beavers@beavers-deploy: ~[01;32mbeavers@beavers-deploy[00m:[01;34m~[00m$ distant server listen --daemon --host ssh\r\ndistant\r\n(base) ]0;beavers@beavers-deploy: ~[01;32mbeavers@beavers-deploy[00m:[01;34m~[00m$ \r\n(base) ]0;beavers@beavers-deploy: ~[01;32mbeavers@beavers-deploy[00m:[01;34m~[00m$ ''" }', D:\study\T-Shell-Plus\src-tauri\src\service\terminal_service.rs:73:67
stack backtrace:
   0: std::panicking::begin_panic_handler
             at /rustc/f0411ffcebcd7f75ac02ed45feb53ffd07b75398/library\std\src\panicking.rs:593
   1: core::panicking::panic_fmt
             at /rustc/f0411ffcebcd7f75ac02ed45feb53ffd07b75398/library\core\src\panicking.rs:67
   2: core::result::unwrap_failed
             at /rustc/f0411ffcebcd7f75ac02ed45feb53ffd07b75398/library\core\src\result.rs:1651
   3: enum2$<core::result::Result<distant_net::client::Client<enum2$<distant_protocol::msg::Msg<enum2$<distant_protocol::request::Request> > >,enum2$<distant_protocol::msg::Msg<enum2$<distant_protocol::response::Response> > > >,std::io::error::Error> >::expect<
             at /rustc/f0411ffcebcd7f75ac02ed45feb53ffd07b75398\library\core\src\result.rs:1033
   4: app::service::terminal_service::initConnection::async_fn$0<tauri_runtime_wry::Wry<enum2$<tauri::EventLoopMessage> > >
             at .\src\service\terminal_service.rs:73

2.I have looked at your shellClient, can I just call RemoteCommand to implement the shell

[chipsenkbeil]

@TheBlindM are you trying to use an ssh server, or a distant server? The launch_and_connect function will try to start distant on your remote server. The error you are getting is related to running distant, and it looks like nothing may have been printed as a result of running the server.

As for using RemoteCommand, that is only on the CLI's code. You would want to spawn a process using the DistantChannelExt, and you need to figure out the shell to run first, which is done here:

If you want to spawn the default shell, then you would first retrieve system information. If the shell is included, you use that as the command. If it is not, you default to either cmd.exe (or powershell) on Windows if the system info says the remote machine is Windows, otherwise just use /bin/sh.

This is something that could be added to DistantChannelExt to do for you to make it easier in the future.

[TheBlindM]

Okay, thank you. I'm researching