libssh 0.0.1 

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

#![allow(unused_imports)]
#![allow(missing_copy_implementations)]

extern crate libc;

use libssh_server::*;
use ssh_key;
use ssh_session::SSHSession;
use ssh_message;

use std::mem;
use std::ptr;
use self::libc::types::common::c95::c_void;

pub struct SSHBind {
	_bind: *mut ssh_bind_struct
}

impl SSHBind {
	pub fn new(priv_key_file: &str, host: Option<&str>, port: Option<&str>)
		-> Result<SSHBind, &'static str>
	{
		let ptr = unsafe { ssh_bind_new() };
		assert!(ptr.is_not_null());

		let bind = SSHBind { _bind: ptr };
		
		if host.is_some() {
			try!(bind.set_host(host.unwrap()));
		}
		try!(bind.set_port(port.unwrap_or("22")));

		try!(bind.set_private_key_file(priv_key_file));

		Ok(bind)
	}

	pub fn set_host(&self, host: &str) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());

		let opt = ssh_bind_options_e::SSH_BIND_OPTIONS_BINDADDR as u32;
		let res = host.with_c_str(|h| {
			unsafe { ssh_bind_options_set(self._bind, opt, h as *const c_void) }
		});

		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_bind_options_set() failed for setting host")
		}
	}

	pub fn set_port(&self, port: &str) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());

		let opt = ssh_bind_options_e::SSH_BIND_OPTIONS_BINDPORT as u32;
		let res = port.with_c_str(|p| unsafe {
			ssh_bind_options_set(self._bind, opt, p as *const c_void)
		});

		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_bind_options_set() failed for setting port")
		}
	}

	pub fn set_private_key_file(&self, key_file: &str) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());

		let opt_type = ssh_bind_options_e::SSH_BIND_OPTIONS_HOSTKEY as u32;
		let res = "ssh-rsa".with_c_str(|typ| unsafe {
			ssh_bind_options_set(self._bind, opt_type, typ as *const c_void)
		});
		if res != SSH_OK {
			return Err("ssh_bind_options_set() failed for private key (HOSTKEY)");
		}

		let opt_key = ssh_bind_options_e::SSH_BIND_OPTIONS_RSAKEY as u32;
		let res = key_file.with_c_str(|pkey_file| unsafe {
			ssh_bind_options_set(self._bind, opt_key, pkey_file as *const c_void)
		});

		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_bind_options_set() failed for private key (RSAKEY)")
		}
	}

	pub fn listen(&self) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());

		let res = unsafe { ssh_bind_listen(self._bind) };
		debug!("listen={}", res);
		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_bind_listen() failed")
		}
	}

	pub fn accept(&self, session: &SSHSession) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());

		let res = unsafe { ssh_bind_accept(self._bind, mem::transmute(session.raw())) };
		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_bind_accept() failed")
		}
	}

	pub fn set_log_level(&self, level: i32) -> Result<(),&'static str> {
		assert!(self._bind.is_not_null());
		let res = unsafe { ssh_set_log_level(level) };
		match res {
			SSH_OK => Ok(()),
			_              => Err("ssh_set_log_level() failed")
		}
	}
}