summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/agent.rs62
-rw-r--r--src/channel.rs190
-rw-r--r--src/error.rs33
-rw-r--r--src/knownhosts.rs159
-rw-r--r--src/lib.rs37
-rw-r--r--src/listener.rs10
-rw-r--r--src/session.rs368
-rw-r--r--src/sftp.rs304
-rw-r--r--src/util.rs21
9 files changed, 661 insertions, 523 deletions
diff --git a/src/agent.rs b/src/agent.rs
index 79b939a..b1f35f5 100644
--- a/src/agent.rs
+++ b/src/agent.rs
@@ -3,8 +3,8 @@ use std::marker;
use std::slice;
use std::str;
-use {raw, Session, Error};
use util::{Binding, SessionBinding};
+use {raw, Error, Session};
/// A structure representing a connection to an SSH agent.
///
@@ -47,18 +47,21 @@ impl<'sess> Agent<'sess> {
/// Get an iterator over the identities of this agent.
pub fn identities(&self) -> Identities {
- Identities { prev: 0 as *mut _, agent: self }
+ Identities {
+ prev: 0 as *mut _,
+ agent: self,
+ }
}
/// Attempt public key authentication with the help of ssh-agent.
- pub fn userauth(&self, username: &str, identity: &PublicKey)
- -> Result<(), Error>{
+ pub fn userauth(&self, username: &str, identity: &PublicKey) -> Result<(), Error> {
let username = try!(CString::new(username));
unsafe {
- self.sess.rc(raw::libssh2_agent_userauth(self.raw,
- username.as_ptr(),
- identity.raw))
-
+ self.sess.rc(raw::libssh2_agent_userauth(
+ self.raw,
+ username.as_ptr(),
+ identity.raw,
+ ))
}
}
}
@@ -66,11 +69,15 @@ impl<'sess> Agent<'sess> {
impl<'sess> SessionBinding<'sess> for Agent<'sess> {
type Raw = raw::LIBSSH2_AGENT;
- unsafe fn from_raw(sess: &'sess Session,
- raw: *mut raw::LIBSSH2_AGENT) -> Agent<'sess> {
- Agent { raw: raw, sess: sess }
+ unsafe fn from_raw(sess: &'sess Session, raw: *mut raw::LIBSSH2_AGENT) -> Agent<'sess> {
+ Agent {
+ raw: raw,
+ sess: sess,
+ }
+ }
+ fn raw(&self) -> *mut raw::LIBSSH2_AGENT {
+ self.raw
}
- fn raw(&self) -> *mut raw::LIBSSH2_AGENT { self.raw }
}
impl<'a> Drop for Agent<'a> {
@@ -84,10 +91,11 @@ impl<'agent> Iterator for Identities<'agent> {
fn next(&mut self) -> Option<Result<PublicKey<'agent>, Error>> {
unsafe {
let mut next = 0 as *mut _;
- match raw::libssh2_agent_get_identity(self.agent.raw,
- &mut next,
- self.prev) {
- 0 => { self.prev = next; Some(Ok(Binding::from_raw(next))) }
+ match raw::libssh2_agent_get_identity(self.agent.raw, &mut next, self.prev) {
+ 0 => {
+ self.prev = next;
+ Some(Ok(Binding::from_raw(next)))
+ }
1 => None,
rc => Some(Err(self.agent.sess.rc(rc).err().unwrap())),
}
@@ -98,28 +106,26 @@ impl<'agent> Iterator for Identities<'agent> {
impl<'agent> PublicKey<'agent> {
/// Return the data of this public key.
pub fn blob(&self) -> &[u8] {
- unsafe {
- slice::from_raw_parts_mut((*self.raw).blob,
- (*self.raw).blob_len as usize)
- }
+ unsafe { slice::from_raw_parts_mut((*self.raw).blob, (*self.raw).blob_len as usize) }
}
/// Returns the comment in a printable format
pub fn comment(&self) -> &str {
- unsafe {
- str::from_utf8(::opt_bytes(self, (*self.raw).comment).unwrap())
- .unwrap()
- }
+ unsafe { str::from_utf8(::opt_bytes(self, (*self.raw).comment).unwrap()).unwrap() }
}
}
impl<'agent> Binding for PublicKey<'agent> {
type Raw = *mut raw::libssh2_agent_publickey;
- unsafe fn from_raw(raw: *mut raw::libssh2_agent_publickey)
- -> PublicKey<'agent> {
- PublicKey { raw: raw, _marker: marker::PhantomData }
+ unsafe fn from_raw(raw: *mut raw::libssh2_agent_publickey) -> PublicKey<'agent> {
+ PublicKey {
+ raw: raw,
+ _marker: marker::PhantomData,
+ }
}
- fn raw(&self) -> *mut raw::libssh2_agent_publickey { self.raw }
+ fn raw(&self) -> *mut raw::libssh2_agent_publickey {
+ self.raw
+ }
}
diff --git a/src/channel.rs b/src/channel.rs
index 32930d8..6328938 100644
--- a/src/channel.rs
+++ b/src/channel.rs
@@ -1,11 +1,11 @@
+use libc::{c_char, c_int, c_uchar, c_uint, c_ulong, c_void, size_t};
use std::cmp;
use std::io::prelude::*;
use std::io::{self, ErrorKind};
use std::slice;
-use libc::{c_uint, c_int, size_t, c_char, c_void, c_uchar, c_ulong};
-use {raw, Session, Error};
use util::{Binding, SessionBinding};
+use {raw, Error, Session};
/// A channel represents a portion of an SSH connection on which data can be
/// read and written.
@@ -68,11 +68,13 @@ impl<'sess> Channel<'sess> {
/// ignored by the server despite returning success.
pub fn setenv(&mut self, var: &str, val: &str) -> Result<(), Error> {
unsafe {
- self.sess.rc(raw::libssh2_channel_setenv_ex(self.raw,
- var.as_ptr() as *const _,
- var.len() as c_uint,
- val.as_ptr() as *const _,
- val.len() as c_uint))
+ self.sess.rc(raw::libssh2_channel_setenv_ex(
+ self.raw,
+ var.as_ptr() as *const _,
+ var.len() as c_uint,
+ val.as_ptr() as *const _,
+ val.len() as c_uint,
+ ))
}
}
@@ -83,40 +85,46 @@ impl<'sess> Channel<'sess> {
///
/// The dimensions argument is a tuple of (width, height, width_px,
/// height_px)
- pub fn request_pty(&mut self, term: &str,
- mode: Option<&str>,
- dim: Option<(u32, u32, u32, u32)>)
- -> Result<(), Error>{
+ pub fn request_pty(
+ &mut self,
+ term: &str,
+ mode: Option<&str>,
+ dim: Option<(u32, u32, u32, u32)>,
+ ) -> Result<(), Error> {
self.sess.rc(unsafe {
- let (width, height, width_px, height_px) =
- dim.unwrap_or((80, 24, 0, 0));
- raw::libssh2_channel_request_pty_ex(self.raw,
- term.as_ptr() as *const _,
- term.len() as c_uint,
- mode.map(|s| s.as_ptr())
- .unwrap_or(0 as *const _)
- as *const _,
- mode.map(|s| s.len())
- .unwrap_or(0) as c_uint,
- width as c_int,
- height as c_int,
- width_px as c_int,
- height_px as c_int)
+ let (width, height, width_px, height_px) = dim.unwrap_or((80, 24, 0, 0));
+ raw::libssh2_channel_request_pty_ex(
+ self.raw,
+ term.as_ptr() as *const _,
+ term.len() as c_uint,
+ mode.map(|s| s.as_ptr()).unwrap_or(0 as *const _) as *const _,
+ mode.map(|s| s.len()).unwrap_or(0) as c_uint,
+ width as c_int,
+ height as c_int,
+ width_px as c_int,
+ height_px as c_int,
+ )
})
}
/// Request a PTY of a specified size
- pub fn request_pty_size(&mut self, width: u32, height: u32,
- width_px: Option<u32>, height_px: Option<u32>)
- -> Result<(), Error> {
+ pub fn request_pty_size(
+ &mut self,
+ width: u32,
+ height: u32,
+ width_px: Option<u32>,
+ height_px: Option<u32>,
+ ) -> Result<(), Error> {
let width_px = width_px.unwrap_or(0);
let height_px = height_px.unwrap_or(0);
self.sess.rc(unsafe {
- raw::libssh2_channel_request_pty_size_ex(self.raw,
- width as c_int,
- height as c_int,
- width_px as c_int,
- height_px as c_int)
+ raw::libssh2_channel_request_pty_size_ex(
+ self.raw,
+ width as c_int,
+ height as c_int,
+ width_px as c_int,
+ height_px as c_int,
+ )
})
}
@@ -161,14 +169,17 @@ impl<'sess> Channel<'sess> {
///
/// The SSH2 protocol currently defines shell, exec, and subsystem as
/// standard process services.
- pub fn process_startup(&mut self, request: &str, message: Option<&str>)
- -> Result<(), Error> {
+ pub fn process_startup(&mut self, request: &str, message: Option<&str>) -> Result<(), Error> {
let message_len = message.map(|s| s.len()).unwrap_or(0);
let message = message.map(|s| s.as_ptr()).unwrap_or(0 as *const _);
unsafe {
- let rc = raw::libssh2_channel_process_startup(self.raw,
- request.as_ptr() as *const _, request.len() as c_uint,
- message as *const _, message_len as c_uint);
+ let rc = raw::libssh2_channel_process_startup(
+ self.raw,
+ request.as_ptr() as *const _,
+ request.len() as c_uint,
+ message as *const _,
+ message_len as c_uint,
+ );
self.sess.rc(rc)
}
}
@@ -190,7 +201,10 @@ impl<'sess> Channel<'sess> {
/// * FLUSH_EXTENDED_DATA - Flush all extended data substreams
/// * FLUSH_ALL - Flush all substreams
pub fn stream<'a>(&'a mut self, stream_id: i32) -> Stream<'a, 'sess> {
- Stream { channel: self, id: stream_id }
+ Stream {
+ channel: self,
+ id: stream_id,
+ }
}
/// Returns the exit code raised by the process running on the remote host
@@ -215,22 +229,27 @@ impl<'sess> Channel<'sess> {
let mut msglen = 0;
let mut lang = 0 as *mut _;
let mut langlen = 0;
- let rc = raw::libssh2_channel_get_exit_signal(self.raw,
- &mut sig, &mut siglen,
- &mut msg, &mut msglen,
- &mut lang,
- &mut langlen);
+ let rc = raw::libssh2_channel_get_exit_signal(
+ self.raw,
+ &mut sig,
+ &mut siglen,
+ &mut msg,
+ &mut msglen,
+ &mut lang,
+ &mut langlen,
+ );
try!(self.sess.rc(rc));
return Ok(ExitSignal {
exit_signal: convert(self, sig, siglen),
error_message: convert(self, msg, msglen),
lang_tag: convert(self, lang, langlen),
- })
+ });
}
- unsafe fn convert(chan: &Channel, ptr: *mut c_char,
- len: size_t) -> Option<String> {
- if ptr.is_null() { return None }
+ unsafe fn convert(chan: &Channel, ptr: *mut c_char, len: size_t) -> Option<String> {
+ if ptr.is_null() {
+ return None;
+ }
let slice = slice::from_raw_parts(ptr as *const u8, len as usize);
let ret = slice.to_vec();
raw::libssh2_free(chan.sess.raw(), ptr as *mut c_void);
@@ -243,9 +262,7 @@ impl<'sess> Channel<'sess> {
unsafe {
let mut avail = 0;
let mut init = 0;
- let remaining = raw::libssh2_channel_window_read_ex(self.raw,
- &mut avail,
- &mut init);
+ let remaining = raw::libssh2_channel_window_read_ex(self.raw, &mut avail, &mut init);
ReadWindow {
remaining: remaining as u32,
available: avail as u32,
@@ -258,8 +275,7 @@ impl<'sess> Channel<'sess> {
pub fn write_window(&self) -> WriteWindow {
unsafe {
let mut init = 0;
- let remaining = raw::libssh2_channel_window_write_ex(self.raw,
- &mut init);
+ let remaining = raw::libssh2_channel_window_write_ex(self.raw, &mut init);
WriteWindow {
remaining: remaining as u32,
window_size_initial: init as u32,
@@ -274,14 +290,15 @@ impl<'sess> Channel<'sess> {
///
/// This function returns the new size of the receive window (as understood
/// by remote end) on success.
- pub fn adjust_receive_window(&mut self, adjust: u64, force: bool)
- -> Result<u64, Error> {
+ pub fn adjust_receive_window(&mut self, adjust: u64, force: bool) -> Result<u64, Error> {
let mut ret = 0;
let rc = unsafe {
- raw::libssh2_channel_receive_window_adjust2(self.raw,
- adjust as c_ulong,
- force as c_uchar,
- &mut ret)
+ raw::libssh2_channel_receive_window_adjust2(
+ self.raw,
+ adjust as c_ulong,
+ force as c_uchar,
+ &mut ret,
+ )
};
try!(self.sess.rc(rc));
Ok(ret as u64)
@@ -296,8 +313,7 @@ impl<'sess> Channel<'sess> {
/// Check if the remote host has sent an EOF status for the selected stream.
pub fn eof(&self) -> bool {
- self.read_limit == Some(0) ||
- unsafe { raw::libssh2_channel_eof(self.raw) != 0 }
+ self.read_limit == Some(0) || unsafe { raw::libssh2_channel_eof(self.raw) != 0 }
}
/// Tell the remote host that no further data will be sent on the specified
@@ -305,9 +321,7 @@ impl<'sess> Channel<'sess> {
///
/// Processes typically interpret this as a closed stdin descriptor.
pub fn send_eof(&mut self) -> Result<(), Error> {
- unsafe {
- self.sess.rc(raw::libssh2_channel_send_eof(self.raw))
- }
+ unsafe { self.sess.rc(raw::libssh2_channel_send_eof(self.raw)) }
}
/// Wait for the remote end to send EOF.
@@ -325,9 +339,7 @@ impl<'sess> Channel<'sess> {
/// To wait for the remote end to close its connection as well, follow this
/// command with `wait_closed`
pub fn close(&mut self) -> Result<(), Error> {
- unsafe {
- self.sess.rc(raw::libssh2_channel_close(self.raw))
- }
+ unsafe { self.sess.rc(raw::libssh2_channel_close(self.raw)) }
}
/// Enter a temporary blocking state until the remote host closes the named
@@ -342,15 +354,16 @@ impl<'sess> Channel<'sess> {
impl<'sess> SessionBinding<'sess> for Channel<'sess> {
type Raw = raw::LIBSSH2_CHANNEL;
- unsafe fn from_raw(sess: &'sess Session,
- raw: *mut raw::LIBSSH2_CHANNEL) -> Channel<'sess> {
+ unsafe fn from_raw(sess: &'sess Session, raw: *mut raw::LIBSSH2_CHANNEL) -> Channel<'sess> {
Channel {
raw: raw,
sess: sess,
read_limit: None,
}
}
- fn raw(&self) -> *mut raw::LIBSSH2_CHANNEL { self.raw }
+ fn raw(&self) -> *mut raw::LIBSSH2_CHANNEL {
+ self.raw
+ }
}
impl<'sess> Write for Channel<'sess> {
@@ -379,7 +392,9 @@ impl<'sess> Drop for Channel<'sess> {
impl<'channel, 'sess> Read for Stream<'channel, 'sess> {
fn read(&mut self, data: &mut [u8]) -> io::Result<usize> {
- if self.channel.eof() { return Ok(0) }
+ if self.channel.eof() {
+ return Ok(0);
+ }
let data = match self.channel.read_limit {
Some(amt) => {
@@ -389,10 +404,12 @@ impl<'channel, 'sess> Read for Stream<'channel, 'sess> {
None => data,
};
let ret = unsafe {
- let rc = raw::libssh2_channel_read_ex(self.channel.raw,
- self.id as c_int,
- data.as_mut_ptr() as *mut _,
- data.len() as size_t);
+ let rc = raw::libssh2_channel_read_ex(
+ self.channel.raw,
+ self.id as c_int,
+ data.as_mut_ptr() as *mut _,
+ data.len() as size_t,
+ );
self.channel.sess.rc(rc as c_int).map(|()| rc as usize)
};
match ret {
@@ -410,23 +427,22 @@ impl<'channel, 'sess> Read for Stream<'channel, 'sess> {
impl<'channel, 'sess> Write for Stream<'channel, 'sess> {
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
unsafe {
- let rc = raw::libssh2_channel_write_ex(self.channel.raw,
- self.id as c_int,
- data.as_ptr() as *mut _,
- data.len() as size_t);
+ let rc = raw::libssh2_channel_write_ex(
+ self.channel.raw,
+ self.id as c_int,
+ data.as_ptr() as *mut _,
+ data.len() as size_t,
+ );
self.channel.sess.rc(rc as c_int).map(|()| rc as usize)
- }.map_err(|e| {
- io::Error::new(ErrorKind::Other, e)
- })
+ }
+ .map_err(|e| io::Error::new(ErrorKind::Other, e))
}
fn flush(&mut self) -> io::Result<()> {
unsafe {
- let rc = raw::libssh2_channel_flush_ex(self.channel.raw,
- self.id as c_int);
+ let rc = raw::libssh2_channel_flush_ex(self.channel.raw, self.id as c_int);
self.channel.sess.rc(rc)
- }.map_err(|e| {
- io::Error::new(ErrorKind::Other, e)
- })
+ }
+ .map_err(|e| io::Error::new(ErrorKind::Other, e))
}
}
diff --git a/src/error.rs b/src/error.rs
index 0911e57..1d2c5da 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,11 +1,11 @@
+use libc;
use std::error;
use std::ffi::NulError;
use std::fmt;
use std::str;
-use libc;
-use {raw, Session};
use util::Binding;
+use {raw, Session};
/// Representation of an error that can occur within libssh2
#[derive(Debug)]
@@ -23,9 +23,10 @@ impl Error {
static STATIC: () = ();
unsafe {
let mut msg = 0 as *mut _;
- let rc = raw::libssh2_session_last_error(sess.raw(), &mut msg,
- 0 as *mut _, 0);
- if rc == 0 { return None }
+ let rc = raw::libssh2_session_last_error(sess.raw(), &mut msg, 0 as *mut _, 0);
+ if rc == 0 {
+ return None;
+ }
let s = ::opt_bytes(&STATIC, msg).unwrap();
Some(Error::new(rc, str::from_utf8(s).unwrap()))
}
@@ -118,16 +119,20 @@ impl Error {
raw::LIBSSH2_FX_NOT_A_DIRECTORY => "not a directory",
raw::LIBSSH2_FX_INVALID_FILENAME => "invalid filename",
raw::LIBSSH2_FX_LINK_LOOP => "link loop",
- _ => "unknown error"
+ _ => "unknown error",
};
Error::new(code, msg)
}
/// Get the message corresponding to this error
- pub fn message(&self) -> &str { self.msg }
+ pub fn message(&self) -> &str {
+ self.msg
+ }
/// Return the code for this error
- pub fn code(&self) -> libc::c_int { self.code }
+ pub fn code(&self) -> libc::c_int {
+ self.code
+ }
}
impl fmt::Display for Error {
@@ -137,13 +142,17 @@ impl fmt::Display for Error {
}
impl error::Error for Error {
- fn description(&self) -> &str { self.message() }
+ fn description(&self) -> &str {
+ self.message()
+ }
}
impl From<NulError> for Error {
fn from(_: NulError) -> Error {
- Error::new(raw::LIBSSH2_ERROR_INVAL,
- "provided data contained a nul byte and could not be used \
- as as string")
+ Error::new(
+ raw::LIBSSH2_ERROR_INVAL,
+ "provided data contained a nul byte and could not be used \
+ as as string",
+ )
}
}
diff --git a/src/knownhosts.rs b/src/knownhosts.rs
index d5d93c5..737ff52 100644
--- a/src/knownhosts.rs
+++ b/src/knownhosts.rs
@@ -1,11 +1,11 @@
+use libc::{c_int, size_t};
use std::ffi::CString;
use std::marker;
use std::path::Path;
use std::str;
-use libc::{c_int, size_t};
-use {raw, Session, Error, KnownHostFileKind, CheckResult};
use util::{self, Binding, SessionBinding};
+use {raw, CheckResult, Error, KnownHostFileKind, Session};
/// A set of known hosts which can be used to verify the identity of a remote
/// server.
@@ -63,62 +63,57 @@ pub struct Host<'kh> {
impl<'sess> KnownHosts<'sess> {
/// Reads a collection of known hosts from a specified file and adds them to
/// the collection of known hosts.
- pub fn read_file(&mut self, file: &Path, kind: KnownHostFileKind)
- -> Result<u32, Error> {
+ pub fn read_file(&mut self, file: &Path, kind: KnownHostFileKind) -> Result<u32, Error> {
let file = try!(CString::new(try!(util::path2bytes(file))));
- let n = unsafe {
- raw::libssh2_knownhost_readfile(self.raw, file.as_ptr(),
- kind as c_int)
- };
- if n < 0 { try!(self.sess.rc(n)) }
+ let n = unsafe { raw::libssh2_knownhost_readfile(self.raw, file.as_ptr(), kind as c_int) };
+ if n < 0 {
+ try!(self.sess.rc(n))
+ }
Ok(n as u32)
}
/// Read a line as if it were from a known hosts file.
- pub fn read_str(&mut self, s: &str, kind: KnownHostFileKind)
- -> Result<(), Error> {
+ pub fn read_str(&mut self, s: &str, kind: KnownHostFileKind) -> Result<(), Error> {
self.sess.rc(unsafe {
- raw::libssh2_knownhost_readline(self.raw,
- s.as_ptr() as *const _,
- s.len() as size_t,
- kind as c_int)
+ raw::libssh2_knownhost_readline(
+ self.raw,
+ s.as_ptr() as *const _,
+ s.len() as size_t,
+ kind as c_int,
+ )
})
}
/// Writes all the known hosts to the specified file using the specified
/// file format.
- pub fn write_file(&self, file: &Path, kind: KnownHostFileKind)
- -> Result<(), Error> {
+ pub fn write_file(&self, file: &Path, kind: KnownHostFileKind) -> Result<(), Error> {
let file = try!(CString::new(try!(util::path2bytes(file))));
- let n = unsafe {
- raw::libssh2_knownhost_writefile(self.raw, file.as_ptr(),
- kind as c_int)
- };
+ let n = unsafe { raw::libssh2_knownhost_writefile(self.raw, file.as_ptr(), kind as c_int) };
self.sess.rc(n)
}
/// Converts a single known host to a single line of output for storage,
/// using the 'type' output format.
- pub fn write_string(&self, host: &Host, kind: KnownHostFileKind)
- -> Result<String, Error> {
+ pub fn write_string(&self, host: &Host, kind: KnownHostFileKind) -> Result<String, Error> {
let mut v = Vec::with_capacity(128);
loop {
let mut outlen = 0;
unsafe {
- let rc = raw::libssh2_knownhost_writeline(self.raw,
- host.raw,
- v.as_mut_ptr()
- as *mut _,
- v.capacity() as size_t,
- &mut outlen,
- kind as c_int);
+ let rc = raw::libssh2_knownhost_writeline(
+ self.raw,
+ host.raw,
+ v.as_mut_ptr() as *mut _,
+ v.capacity() as size_t,
+ &mut outlen,
+ kind as c_int,
+ );
if rc == raw::LIBSSH2_ERROR_BUFFER_TOO_SMALL {
// + 1 for the trailing zero
v.reserve(outlen as usize + 1);
} else {
try!(self.sess.rc(rc));
v.set_len(outlen as usize);
- break
+ break;
}
}
}
@@ -127,14 +122,16 @@ impl<'sess> KnownHosts<'sess> {
/// Create an iterator over all of the known hosts in this structure.
pub fn iter(&self) -> Hosts {
- Hosts { prev: 0 as *mut _, hosts: self }
+ Hosts {
+ prev: 0 as *mut _,
+ hosts: self,
+ }
}
/// Delete a known host entry from the collection of known hosts.
pub fn remove(&self, host: Host) -> Result<(), Error> {
- self.sess.rc(unsafe {
- raw::libssh2_knownhost_del(self.raw, host.raw)
- })
+ self.sess
+ .rc(unsafe { raw::libssh2_knownhost_del(self.raw, host.raw) })
}
/// Checks a host and its associated key against the collection of known
@@ -153,16 +150,17 @@ impl<'sess> KnownHosts<'sess> {
fn check_port_(&self, host: &str, port: i32, key: &[u8]) -> CheckResult {
let host = CString::new(host).unwrap();
- let flags = raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN |
- raw::LIBSSH2_KNOWNHOST_KEYENC_RAW;
+ let flags = raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN | raw::LIBSSH2_KNOWNHOST_KEYENC_RAW;
unsafe {
- let rc = raw::libssh2_knownhost_checkp(self.raw,
- host.as_ptr(),
- port as c_int,
- key.as_ptr() as *const _,
- key.len() as size_t,
- flags,
- 0 as *mut _);
+ let rc = raw::libssh2_knownhost_checkp(
+ self.raw,
+ host.as_ptr(),
+ port as c_int,
+ key.as_ptr() as *const _,
+ key.len() as size_t,
+ flags,
+ 0 as *mut _,
+ );
match rc {
raw::LIBSSH2_KNOWNHOST_CHECK_MATCH => CheckResult::Match,
raw::LIBSSH2_KNOWNHOST_CHECK_MISMATCH => CheckResult::Mismatch,
@@ -182,23 +180,28 @@ impl<'sess> KnownHosts<'sess> {
/// For example: "[host.example.com]:222".
///
/// The key provided must be the raw key for the host.
- pub fn add(&mut self, host: &str, key: &[u8], comment: &str,
- fmt: ::KnownHostKeyFormat)
- -> Result<(), Error> {
+ pub fn add(
+ &mut self,
+ host: &str,
+ key: &[u8],
+ comment: &str,
+ fmt: ::KnownHostKeyFormat,
+ ) -> Result<(), Error> {
let host = try!(CString::new(host));
- let flags = raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN |
- raw::LIBSSH2_KNOWNHOST_KEYENC_RAW |
- (fmt as c_int);
+ let flags =
+ raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN | raw::LIBSSH2_KNOWNHOST_KEYENC_RAW | (fmt as c_int);
unsafe {
- let rc = raw::libssh2_knownhost_addc(self.raw,
- host.as_ptr() as *mut _,
- 0 as *mut _,
- key.as_ptr() as *mut _,
- key.len() as size_t,
- comment.as_ptr() as *const _,
- comment.len() as size_t,
- flags,
- 0 as *mut _);
+ let rc = raw::libssh2_knownhost_addc(
+ self.raw,
+ host.as_ptr() as *mut _,
+ 0 as *mut _,
+ key.as_ptr() as *mut _,
+ key.len() as size_t,
+ comment.as_ptr() as *const _,
+ comment.len() as size_t,
+ flags,
+ 0 as *mut _,
+ );
self.sess.rc(rc)
}
}
@@ -207,17 +210,20 @@ impl<'sess> KnownHosts<'sess> {
impl<'sess> SessionBinding<'sess> for KnownHosts<'sess> {
type Raw = raw::LIBSSH2_KNOWNHOSTS;
- unsafe fn from_raw(sess: &'sess Session, raw: *mut raw::LIBSSH2_KNOWNHOSTS)
- -> KnownHosts<'sess> {
+ unsafe fn from_raw(
+ sess: &'sess Session,
+ raw: *mut raw::LIBSSH2_KNOWNHOSTS,
+ ) -> KnownHosts<'sess> {
KnownHosts {
raw: raw,
sess: sess,
}
}
- fn raw(&self) -> *mut raw::LIBSSH2_KNOWNHOSTS { self.raw }
+ fn raw(&self) -> *mut raw::LIBSSH2_KNOWNHOSTS {
+ self.raw
+ }
}
-
impl<'sess> Drop for KnownHosts<'sess> {
fn drop(&mut self) {
unsafe { raw::libssh2_knownhost_free(self.raw) }
@@ -229,10 +235,11 @@ impl<'kh> Iterator for Hosts<'kh> {
fn next(&mut self) -> Option<Result<Host<'kh>, Error>> {
unsafe {
let mut next = 0 as *mut _;
- match raw::libssh2_knownhost_get(self.hosts.raw,
- &mut next,
- self.prev) {
- 0 => { self.prev = next; Some(Ok(Binding::from_raw(next))) }
+ match raw::libssh2_knownhost_get(self.hosts.raw, &mut next, self.prev) {
+ 0 => {
+ self.prev = next;
+ Some(Ok(Binding::from_raw(next)))
+ }
1 => None,
rc => Some(Err(self.hosts.sess.rc(rc).err().unwrap())),
}
@@ -243,17 +250,12 @@ impl<'kh> Iterator for Hosts<'kh> {
impl<'kh> Host<'kh> {
/// This is `None` if no plain text host name exists.
pub fn name(&self) -> Option<&str> {
- unsafe {
- ::opt_bytes(self, (*self.raw).name)
- .and_then(|s| str::from_utf8(s).ok())
- }
+ unsafe { ::opt_bytes(self, (*self.raw).name).and_then(|s| str::from_utf8(s).ok()) }
}
/// Returns the key in base64/printable format
pub fn key(&self) -> &str {
- let bytes = unsafe {
- ::opt_bytes(self, (*self.raw).key).unwrap()
- };
+ let bytes = unsafe { ::opt_bytes(self, (*self.raw).key).unwrap() };
str::from_utf8(bytes).unwrap()
}
}
@@ -262,7 +264,12 @@ impl<'kh> Binding for Host<'kh> {
type Raw = *mut raw::libssh2_knownhost;
unsafe fn from_raw(raw: *mut raw::libssh2_knownhost) -> Host<'kh> {
- Host { raw: raw, _marker: marker::PhantomData }
+ Host {
+ raw: raw,
+ _marker: marker::PhantomData,
+ }
+ }
+ fn raw(&self) -> *mut raw::libssh2_knownhost {
+ self.raw
}
- fn raw(&self) -> *mut raw::libssh2_knownhost { self.raw }
}
diff --git a/src/lib.rs b/src/lib.rs
index cd98d1a..b02b77d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -129,26 +129,27 @@
#![deny(missing_docs, unused_results)]
#![cfg_attr(test, deny(warnings))]
-extern crate libssh2_sys as raw;
extern crate libc;
-#[macro_use] extern crate bitflags;
+extern crate libssh2_sys as raw;
+#[macro_use]
+extern crate bitflags;
use std::ffi::CStr;
pub use agent::{Agent, Identities, PublicKey};
-pub use channel::{Channel, ExitSignal, ReadWindow, WriteWindow, Stream};
+pub use channel::{Channel, ExitSignal, ReadWindow, Stream, WriteWindow};
pub use error::Error;
-pub use knownhosts::{KnownHosts, Hosts, Host};
+pub use knownhosts::{Host, Hosts, KnownHosts};
pub use listener::Listener;
-pub use session::{Session, ScpFileStat};
-pub use sftp::{Sftp, OpenFlags, RenameFlags};
-pub use sftp::{OpenType, File, FileStat, FileType};
+pub use session::{ScpFileStat, Session};
+pub use sftp::{File, FileStat, FileType, OpenType};
+pub use sftp::{OpenFlags, RenameFlags, Sftp};
+pub use DisconnectCode::{AuthCancelledByUser, TooManyConnections};
+pub use DisconnectCode::{ByApplication, ConnectionLost, HostKeyNotVerifiable};
+pub use DisconnectCode::{CompressionError, KeyExchangeFailed, MacError, Reserved};
pub use DisconnectCode::{HostNotAllowedToConnect, ProtocolError};
-pub use DisconnectCode::{KeyExchangeFailed, Reserved, MacError, CompressionError};
-pub use DisconnectCode::{ServiceNotAvailable, ProtocolVersionNotSupported};
-pub use DisconnectCode::{HostKeyNotVerifiable, ConnectionLost, ByApplication};
-pub use DisconnectCode::{TooManyConnections, AuthCancelledByUser};
-pub use DisconnectCode::{NoMoreAuthMethodsAvailable, IllegalUserName};
+pub use DisconnectCode::{IllegalUserName, NoMoreAuthMethodsAvailable};
+pub use DisconnectCode::{ProtocolVersionNotSupported, ServiceNotAvailable};
mod agent;
mod channel;
@@ -166,8 +167,7 @@ pub fn init() {
raw::init();
}
-unsafe fn opt_bytes<'a, T>(_: &'a T,
- c: *const libc::c_char) -> Option<&'a [u8]> {
+unsafe fn opt_bytes<'a, T>(_: &'a T, c: *const libc::c_char) -> Option<&'a [u8]> {
if c.is_null() {
None
} else {
@@ -178,23 +178,20 @@ unsafe fn opt_bytes<'a, T>(_: &'a T,
#[allow(missing_docs)]
#[derive(Copy, Clone)]
pub enum DisconnectCode {
- HostNotAllowedToConnect =
- raw::SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT as isize,
+ HostNotAllowedToConnect = raw::SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT as isize,
ProtocolError = raw::SSH_DISCONNECT_PROTOCOL_ERROR as isize,
KeyExchangeFailed = raw::SSH_DISCONNECT_KEY_EXCHANGE_FAILED as isize,
Reserved = raw::SSH_DISCONNECT_RESERVED as isize,
MacError = raw::SSH_DISCONNECT_MAC_ERROR as isize,
CompressionError = raw::SSH_DISCONNECT_COMPRESSION_ERROR as isize,
ServiceNotAvailable = raw::SSH_DISCONNECT_SERVICE_NOT_AVAILABLE as isize,
- ProtocolVersionNotSupported =
- raw::SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED as isize,
+ ProtocolVersionNotSupported = raw::SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED as isize,
HostKeyNotVerifiable = raw::SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE as isize,
ConnectionLost = raw::SSH_DISCONNECT_CONNECTION_LOST as isize,
ByApplication = raw::SSH_DISCONNECT_BY_APPLICATION as isize,
TooManyConnections = raw::SSH_DISCONNECT_TOO_MANY_CONNECTIONS as isize,
AuthCancelledByUser = raw::SSH_DISCONNECT_AUTH_CANCELLED_BY_USER as isize,
- NoMoreAuthMethodsAvailable =
- raw::SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE as isize,
+ NoMoreAuthMethodsAvailable = raw::SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE as isize,
IllegalUserName = raw::SSH_DISCONNECT_ILLEGAL_USER_NAME as isize,
}
diff --git a/src/listener.rs b/src/listener.rs
index f9dab07..33a8d5c 100644
--- a/src/listener.rs
+++ b/src/listener.rs
@@ -1,5 +1,5 @@
-use {raw, Session, Error, Channel};
use util::SessionBinding;
+use {raw, Channel, Error, Session};
/// A listener represents a forwarding port from the remote server.
///
@@ -23,14 +23,15 @@ impl<'sess> Listener<'sess> {
impl<'sess> SessionBinding<'sess> for Listener<'sess> {
type Raw = raw::LIBSSH2_LISTENER;
- unsafe fn from_raw(sess: &'sess Session,
- raw: *mut raw::LIBSSH2_LISTENER) -> Listener<'sess> {
+ unsafe fn from_raw(sess: &'sess Session, raw: *mut raw::LIBSSH2_LISTENER) -> Listener<'sess> {
Listener {
raw: raw,
sess: sess,
}
}
- fn raw(&self) -> *mut raw::LIBSSH2_LISTENER { self.raw }
+ fn raw(&self) -> *mut raw::LIBSSH2_LISTENER {
+ self.raw
+ }
}
impl<'sess> Drop for Listener<'sess> {
@@ -40,4 +41,3 @@ impl<'sess> Drop for Listener<'sess> {
}
}
}
-
diff --git a/src/session.rs b/src/session.rs
index 4465eb0..71af745 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -1,16 +1,16 @@
+#[cfg(unix)]
+use libc::size_t;
+use libc::{self, c_int, c_long, c_uint, c_void};
use std::ffi::CString;
use std::mem;
use std::net::TcpStream;
use std::path::Path;
use std::slice;
use std::str;
-use libc::{self, c_uint, c_int, c_void, c_long};
-#[cfg(unix)]
-use libc::size_t;
-use {raw, Error, DisconnectCode, ByApplication, HostKeyType};
-use {MethodType, Agent, Channel, Listener, HashType, KnownHosts, Sftp};
use util::{self, Binding, SessionBinding};
+use {raw, ByApplication, DisconnectCode, Error, HostKeyType};
+use {Agent, Channel, HashType, KnownHosts, Listener, MethodType, Sftp};
/// An SSH session, typically representing one TCP connection.
///
@@ -39,9 +39,12 @@ impl Session {
pub fn new() -> Option<Session> {
::init();
unsafe {
- let ret = raw::libssh2_session_init_ex(None, None, None,
- 0 as *mut _);
- if ret.is_null() {None} else {Some(Binding::from_raw(ret))}
+ let ret = raw::libssh2_session_init_ex(None, None, None, 0 as *mut _);
+ if ret.is_null() {
+ None
+ } else {
+ Some(Binding::from_raw(ret))
+ }
}
}
@@ -53,9 +56,7 @@ impl Session {
/// default.
pub fn set_banner(&self, banner: &str) -> Result<(), Error> {
let banner = try!(CString::new(banner));
- unsafe {
- self.rc(raw::libssh2_session_banner_set(self.raw, banner.as_ptr()))
- }
+ unsafe { self.rc(raw::libssh2_session_banner_set(self.raw, banner.as_ptr())) }
}
/// Flag indicating whether SIGPIPE signals will be allowed or blocked.
@@ -66,9 +67,11 @@ impl Session {
/// layer.
pub fn set_allow_sigpipe(&self, block: bool) {
let res = unsafe {
- self.rc(raw::libssh2_session_flag(self.raw,
- raw::LIBSSH2_FLAG_SIGPIPE as c_int,
- block as c_int))
+ self.rc(raw::libssh2_session_flag(
+ self.raw,
+ raw::LIBSSH2_FLAG_SIGPIPE as c_int,
+ block as c_int,
+ ))
};
res.unwrap();
}
@@ -81,9 +84,11 @@ impl Session {
/// libssh2 will not attempt to use compression.
pub fn set_compress(&self, compress: bool) {
let res = unsafe {
- self.rc(raw::libssh2_session_flag(self.raw,
- raw::LIBSSH2_FLAG_COMPRESS as c_int,
- compress as c_int))
+ self.rc(raw::libssh2_session_flag(
+ self.raw,
+ raw::LIBSSH2_FLAG_COMPRESS as c_int,
+ compress as c_int,
+ ))
};
res.unwrap();
}
@@ -98,9 +103,7 @@ impl Session {
/// a blocking session will wait for room. A non-blocking session will
/// return immediately without writing anything.
pub fn set_blocking(&self, blocking: bool) {
- unsafe {
- raw::libssh2_session_set_blocking(self.raw, blocking as c_int)
- }
+ unsafe { raw::libssh2_session_set_blocking(self.raw, blocking as c_int) }
}
/// Returns whether the session was previously set to nonblocking.
@@ -144,15 +147,13 @@ impl Session {
}
#[cfg(windows)]
- unsafe fn handshake(raw: *mut raw::LIBSSH2_SESSION, stream: &TcpStream)
- -> libc::c_int {
+ unsafe fn handshake(raw: *mut raw::LIBSSH2_SESSION, stream: &TcpStream) -> libc::c_int {
use std::os::windows::prelude::*;
raw::libssh2_session_handshake(raw, stream.as_raw_socket())
}
#[cfg(unix)]
- unsafe fn handshake(raw: *mut raw::LIBSSH2_SESSION, stream: &TcpStream)
- -> libc::c_int {
+ unsafe fn handshake(raw: *mut raw::LIBSSH2_SESSION, stream: &TcpStream) -> libc::c_int {
use std::os::unix::prelude::*;
raw::libssh2_session_handshake(raw, stream.as_raw_fd())
}
@@ -164,15 +165,16 @@ impl Session {
/// authentication actually have it disabled and use Keyboard Interactive
/// authentication (routed via PAM or another authentication backed)
/// instead.
- pub fn userauth_password(&self, username: &str, password: &str)
- -> Result<(), Error> {
+ pub fn userauth_password(&self, username: &str, password: &str) -> Result<(), Error> {
self.rc(unsafe {
- raw::libssh2_userauth_password_ex(self.raw,
- username.as_ptr() as *const _,
- username.len() as c_uint,
- password.as_ptr() as *const _,
- password.len() as c_uint,
- None)
+ raw::libssh2_userauth_password_ex(
+ self.raw,
+ username.as_ptr() as *const _,
+ username.len() as c_uint,
+ password.as_ptr() as *const _,
+ password.len() as c_uint,
+ None,
+ )
})
}
@@ -188,19 +190,25 @@ impl Session {
try!(agent.list_identities());
let identity = match agent.identities().next() {
Some(identity) => try!(identity),
- None => return Err(Error::new(raw::LIBSSH2_ERROR_INVAL as c_int,
- "no identities found in the ssh agent"))
+ None => {
+ return Err(Error::new(
+ raw::LIBSSH2_ERROR_INVAL as c_int,
+ "no identities found in the ssh agent",
+ ))
+ }
};
agent.userauth(username, &identity)
}
/// Attempt public key authentication using a PEM encoded private key file
/// stored on disk.
- pub fn userauth_pubkey_file(&self,
- username: &str,
- pubkey: Option<&Path>,
- privatekey: &Path,
- passphrase: Option<&str>) -> Result<(), Error> {
+ pub fn userauth_pubkey_file(
+ &self,
+ username: &str,
+ pubkey: Option<&Path>,
+ privatekey: &Path,
+ passphrase: Option<&str>,
+ ) -> Result<(), Error> {
let pubkey = match pubkey {
Some(s) => Some(try!(CString::new(try!(util::path2bytes(s))))),
None => None,
@@ -211,13 +219,17 @@ impl Session {
None => None,
};
self.rc(unsafe {
- raw::libssh2_userauth_publickey_fromfile_ex(self.raw,
- username.as_ptr() as *const _,
- username.len() as c_uint,
- pubkey.as_ref().map(|s| s.as_ptr()).unwrap_or(0 as *const _),
- privatekey.as_ptr(),
- passphrase.as_ref().map(|s| s.as_ptr())
- .unwrap_or(0 as *const _))
+ raw::libssh2_userauth_publickey_fromfile_ex(
+ self.raw,
+ username.as_ptr() as *const _,
+ username.len() as c_uint,
+ pubkey.as_ref().map(|s| s.as_ptr()).unwrap_or(0 as *const _),
+ privatekey.as_ptr(),
+ passphrase
+ .as_ref()
+ .map(|s| s.as_ptr())
+ .unwrap_or(0 as *const _),
+ )
})
}
@@ -227,11 +239,13 @@ impl Session {
/// It is therefore recommended to use `#[cfg(unix)]` or otherwise test for
/// the `unix` compliation target when using this function.
#[cfg(unix)]
- pub fn userauth_pubkey_memory(&self,
- username: &str,
- pubkeydata: Option<&str>,
- privatekeydata: &str,
- passphrase: Option<&str>) -> Result<(), Error> {
+ pub fn userauth_pubkey_memory(
+ &self,
+ username: &str,
+ pubkeydata: Option<&str>,
+ privatekeydata: &str,
+ passphrase: Option<&str>,
+ ) -> Result<(), Error> {
let (pubkeydata, pubkeydata_len) = match pubkeydata {
Some(s) => (Some(try!(CString::new(s))), s.len()),
None => (None, 0),
@@ -243,28 +257,36 @@ impl Session {
None => None,
};
self.rc(unsafe {
- raw::libssh2_userauth_publickey_frommemory(self.raw,
- username.as_ptr() as *const _,
- username.len() as size_t,
- pubkeydata.as_ref().map(|s| s.as_ptr()).unwrap_or(0 as *const _),
- pubkeydata_len as size_t,
- privatekeydata.as_ptr(),
- privatekeydata_len as size_t,
- passphrase.as_ref().map(|s| s.as_ptr())
- .unwrap_or(0 as *const _))
+ raw::libssh2_userauth_publickey_frommemory(
+ self.raw,
+ username.as_ptr() as *const _,
+ username.len() as size_t,
+ pubkeydata
+ .as_ref()
+ .map(|s| s.as_ptr())
+ .unwrap_or(0 as *const _),
+ pubkeydata_len as size_t,
+ privatekeydata.as_ptr(),
+ privatekeydata_len as size_t,
+ passphrase
+ .as_ref()
+ .map(|s| s.as_ptr())
+ .unwrap_or(0 as *const _),
+ )
})
}
// Umm... I wish this were documented in libssh2?
#[allow(missing_docs)]
- pub fn userauth_hostbased_file(&self,
- username: &str,
- publickey: &Path,
- privatekey: &Path,
- passphrase: Option<&str>,
- hostname: &str,
- local_username: Option<&str>)
- -> Result<(), Error> {
+ pub fn userauth_hostbased_file(
+ &self,
+ username: &str,
+ publickey: &Path,
+ privatekey: &Path,
+ passphrase: Option<&str>,
+ hostname: &str,
+ local_username: Option<&str>,
+ ) -> Result<(), Error> {
let publickey = try!(CString::new(try!(util::path2bytes(publickey))));
let privatekey = try!(CString::new(try!(util::path2bytes(privatekey))));
let passphrase = match passphrase {
@@ -276,17 +298,21 @@ impl Session {
None => username,
};
self.rc(unsafe {
- raw::libssh2_userauth_hostbased_fromfile_ex(self.raw,
- username.as_ptr() as *const _,
- username.len() as c_uint,
- publickey.as_ptr(),
- privatekey.as_ptr(),
- passphrase.as_ref().map(|s| s.as_ptr())
- .unwrap_or(0 as *const _),
- hostname.as_ptr() as *const _,
- hostname.len() as c_uint,
- local_username.as_ptr() as *const _,
- local_username.len() as c_uint)
+ raw::libssh2_userauth_hostbased_fromfile_ex(
+ self.raw,
+ username.as_ptr() as *const _,
+ username.len() as c_uint,
+ publickey.as_ptr(),
+ privatekey.as_ptr(),
+ passphrase
+ .as_ref()
+ .map(|s| s.as_ptr())
+ .unwrap_or(0 as *const _),
+ hostname.as_ptr() as *const _,
+ hostname.len() as c_uint,
+ local_username.as_ptr() as *const _,
+ local_username.len() as c_uint,
+ )
})
}
@@ -310,8 +336,7 @@ impl Session {
let len = username.len();
let username = try!(CString::new(username));
unsafe {
- let ret = raw::libssh2_userauth_list(self.raw, username.as_ptr(),
- len as c_uint);
+ let ret = raw::libssh2_userauth_list(self.raw, username.as_ptr(), len as c_uint);
if ret.is_null() {
Err(Error::last_error(self).unwrap())
} else {
@@ -327,14 +352,14 @@ impl Session {
/// listed last. If a method is listed which is not supported by libssh2 it
/// will be ignored and not sent to the remote host during protocol
/// negotiation.
- pub fn method_pref(&self,
- method_type: MethodType,
- prefs: &str) -> Result<(), Error> {
+ pub fn method_pref(&self, method_type: MethodType, prefs: &str) -> Result<(), Error> {
let prefs = try!(CString::new(prefs));
unsafe {
- self.rc(raw::libssh2_session_method_pref(self.raw,
- method_type as c_int,
- prefs.as_ptr()))
+ self.rc(raw::libssh2_session_method_pref(
+ self.raw,
+ method_type as c_int,
+ prefs.as_ptr(),
+ ))
}
}
@@ -344,23 +369,22 @@ impl Session {
/// parameter. May return `None` if the session has not yet been started.
pub fn methods(&self, method_type: MethodType) -> Option<&str> {
unsafe {
- let ptr = raw::libssh2_session_methods(self.raw,
- method_type as c_int);
+ let ptr = raw::libssh2_session_methods(self.raw, method_type as c_int);
::opt_bytes(self, ptr).and_then(|s| str::from_utf8(s).ok())
}
}
/// Get list of supported algorithms.
- pub fn supported_algs(&self, method_type: MethodType)
- -> Result<Vec<&'static str>, Error> {
+ pub fn supported_algs(&self, method_type: MethodType) -> Result<Vec<&'static str>, Error> {
static STATIC: () = ();
let method_type = method_type as c_int;
let mut ret = Vec::new();
unsafe {
let mut ptr = 0 as *mut _;
- let rc = raw::libssh2_session_supported_algs(self.raw, method_type,
- &mut ptr);
- if rc <= 0 { try!(self.rc(rc)) }
+ let rc = raw::libssh2_session_supported_algs(self.raw, method_type, &mut ptr);
+ if rc <= 0 {
+ try!(self.rc(rc))
+ }
for i in 0..(rc as isize) {
let s = ::opt_bytes(&STATIC, *ptr.offset(i)).unwrap();;
let s = str::from_utf8(s).unwrap();
@@ -375,9 +399,7 @@ impl Session {
///
/// The returned agent will still need to be connected manually before use.
pub fn agent(&self) -> Result<Agent, Error> {
- unsafe {
- SessionBinding::from_raw_opt(self, raw::libssh2_agent_init(self.raw))
- }
+ unsafe { SessionBinding::from_raw_opt(self, raw::libssh2_agent_init(self.raw)) }
}
/// Init a collection of known hosts for this session.
@@ -396,9 +418,12 @@ impl Session {
/// This method is commonly used to create a channel to execute commands
/// over or create a new login shell.
pub fn channel_session(&self) -> Result<Channel, Error> {
- self.channel_open("session",
- raw::LIBSSH2_CHANNEL_WINDOW_DEFAULT as u32,
- raw::LIBSSH2_CHANNEL_PACKET_DEFAULT as u32, None)
+ self.channel_open(
+ "session",
+ raw::LIBSSH2_CHANNEL_WINDOW_DEFAULT as u32,
+ raw::LIBSSH2_CHANNEL_PACKET_DEFAULT as u32,
+ None,
+ )
}
/// Tunnel a TCP connection through an SSH session.
@@ -413,18 +438,23 @@ impl Session {
///
/// The `Channel` returned represents a connection between this host and the
/// specified remote host.
- pub fn channel_direct_tcpip(&self, host: &str, port: u16,
- src: Option<(&str, u16)>)
- -> Result<Channel, Error> {
+ pub fn channel_direct_tcpip(
+ &self,
+ host: &str,
+ port: u16,
+ src: Option<(&str, u16)>,
+ ) -> Result<Channel, Error> {
let (shost, sport) = src.unwrap_or(("127.0.0.1", 22));
let host = try!(CString::new(host));
let shost = try!(CString::new(shost));
unsafe {
- let ret = raw::libssh2_channel_direct_tcpip_ex(self.raw,
- host.as_ptr(),
- port as c_int,
- shost.as_ptr(),
- sport as c_int);
+ let ret = raw::libssh2_channel_direct_tcpip_ex(
+ self.raw,
+ host.as_ptr(),
+ port as c_int,
+ shost.as_ptr(),
+ sport as c_int,
+ );
SessionBinding::from_raw_opt(self, ret)
}
}
@@ -434,20 +464,21 @@ impl Session {
///
/// New connections will be queued by the library until accepted by the
/// `accept` method on the returned `Listener`.
- pub fn channel_forward_listen(&self,
- remote_port: u16,
- host: Option<&str>,
- queue_maxsize: Option<u32>)
- -> Result<(Listener, u16), Error> {
+ pub fn channel_forward_listen(
+ &self,
+ remote_port: u16,
+ host: Option<&str>,
+ queue_maxsize: Option<u32>,
+ ) -> Result<(Listener, u16), Error> {
let mut bound_port = 0;
unsafe {
let ret = raw::libssh2_channel_forward_listen_ex(
- self.raw,
- host.map(|s| s.as_ptr()).unwrap_or(0 as *const _)
- as *mut _,
- remote_port as c_int,
- &mut bound_port,
- queue_maxsize.unwrap_or(0) as c_int);
+ self.raw,
+ host.map(|s| s.as_ptr()).unwrap_or(0 as *const _) as *mut _,
+ remote_port as c_int,
+ &mut bound_port,
+ queue_maxsize.unwrap_or(0) as c_int,
+ );
SessionBinding::from_raw_opt(self, ret).map(|l| (l, bound_port as u16))
}
}
@@ -457,8 +488,7 @@ impl Session {
/// The path specified is a path on the remote host which will attempt to be
/// sent over the returned channel. Some stat information is also returned
/// about the remote file to prepare for receiving the file.
- pub fn scp_recv(&self, path: &Path)
- -> Result<(Channel, ScpFileStat), Error> {
+ pub fn scp_recv(&self, path: &Path) -> Result<(Channel, ScpFileStat), Error> {
let path = try!(CString::new(try!(util::path2bytes(path))));
unsafe {
let mut sb: libc::stat = mem::zeroed();
@@ -483,18 +513,24 @@ impl Session {
///
/// The size of the file, `size`, must be known ahead of time before
/// transmission.
- pub fn scp_send(&self, remote_path: &Path, mode: i32,
- size: u64, times: Option<(u64, u64)>)
- -> Result<Channel, Error> {
+ pub fn scp_send(
+ &self,
+ remote_path: &Path,
+ mode: i32,
+ size: u64,
+ times: Option<(u64, u64)>,
+ ) -> Result<Channel, Error> {
let path = try!(CString::new(try!(util::path2bytes(remote_path))));
let (mtime, atime) = times.unwrap_or((0, 0));
unsafe {
- let ret = raw::libssh2_scp_send64(self.raw,
- path.as_ptr(),
- mode as c_int,
- size as i64,
- mtime as libc::time_t,
- atime as libc::time_t);
+ let ret = raw::libssh2_scp_send64(
+ self.raw,
+ path.as_ptr(),
+ mode as c_int,
+ size as i64,
+ mtime as libc::time_t,
+ atime as libc::time_t,
+ );
SessionBinding::from_raw_opt(self, ret)
}
}
@@ -516,20 +552,27 @@ impl Session {
///
/// This is typically not called directly but rather through
/// `channel_session`, `channel_direct_tcpip`, or `channel_forward_listen`.
- pub fn channel_open(&self, channel_type: &str,
- window_size: u32, packet_size: u32,
- message: Option<&str>) -> Result<Channel, Error> {
+ pub fn channel_open(
+ &self,
+ channel_type: &str,
+ window_size: u32,
+ packet_size: u32,
+ message: Option<&str>,
+ ) -> Result<Channel, Error> {
let message_len = message.map(|s| s.len()).unwrap_or(0);
unsafe {
- let ret = raw::libssh2_channel_open_ex(self.raw,
- channel_type.as_ptr() as *const _,
- channel_type.len() as c_uint,
- window_size as c_uint,
- packet_size as c_uint,
- message.as_ref().map(|s| s.as_ptr())
- .unwrap_or(0 as *const _)
- as *const _,
- message_len as c_uint);
+ let ret = raw::libssh2_channel_open_ex(
+ self.raw,
+ channel_type.as_ptr() as *const _,
+ channel_type.len() as c_uint,
+ window_size as c_uint,
+ packet_size as c_uint,
+ message
+ .as_ref()
+ .map(|s| s.as_ptr())
+ .unwrap_or(0 as *const _) as *const _,
+ message_len as c_uint,
+ );
SessionBinding::from_raw_opt(self, ret)
}
}
@@ -560,7 +603,9 @@ impl Session {
let mut kind = 0;
unsafe {
let ret = raw::libssh2_session_hostkey(self.raw, &mut len, &mut kind);
- if ret.is_null() { return None }
+ if ret.is_null() {
+ return None;
+ }
let data = slice::from_raw_parts(ret as *const u8, len as usize);
let kind = match kind {
raw::LIBSSH2_HOSTKEY_TYPE_RSA => HostKeyType::Rsa,
@@ -606,10 +651,7 @@ impl Session {
/// I/O, use 0 (the default) to disable keepalives. To avoid some busy-loop
/// corner-cases, if you specify an interval of 1 it will be treated as 2.
pub fn set_keepalive(&self, want_reply: bool, interval: u32) {
- unsafe {
- raw::libssh2_keepalive_config(self.raw, want_reply as c_int,
- interval as c_uint)
- }
+ unsafe { raw::libssh2_keepalive_config(self.raw, want_reply as c_int, interval as c_uint) }
}
/// Send a keepalive message if needed.
@@ -629,18 +671,22 @@ impl Session {
/// along with a reason symbol and a verbose description.
///
/// Note that this does *not* close the underlying socket.
- pub fn disconnect(&self,
- reason: Option<DisconnectCode>,
- description: &str,
- lang: Option<&str>) -> Result<(), Error> {
+ pub fn disconnect(
+ &self,
+ reason: Option<DisconnectCode>,
+ description: &str,
+ lang: Option<&str>,
+ ) -> Result<(), Error> {
let reason = reason.unwrap_or(ByApplication) as c_int;
let description = try!(CString::new(description));
let lang = try!(CString::new(lang.unwrap_or("")));
unsafe {
- self.rc(raw::libssh2_session_disconnect_ex(self.raw,
- reason,
- description.as_ptr(),
- lang.as_ptr()))
+ self.rc(raw::libssh2_session_disconnect_ex(
+ self.raw,
+ reason,
+ description.as_ptr(),
+ lang.as_ptr(),
+ ))
}
}
@@ -663,7 +709,9 @@ impl Binding for Session {
unsafe fn from_raw(raw: *mut raw::LIBSSH2_SESSION) -> Session {
Session { raw: raw }
}
- fn raw(&self) -> *mut raw::LIBSSH2_SESSION { self.raw }
+ fn raw(&self) -> *mut raw::LIBSSH2_SESSION {
+ self.raw
+ }
}
impl Drop for Session {
@@ -676,9 +724,13 @@ impl Drop for Session {
impl ScpFileStat {
/// Returns the size of the remote file.
- pub fn size(&self) -> u64 { self.stat.st_size as u64 }
+ pub fn size(&self) -> u64 {
+ self.stat.st_size as u64
+ }
/// Returns the listed mode of the remote file.
- pub fn mode(&self) -> i32 { self.stat.st_mode as i32 }
+ pub fn mode(&self) -> i32 {
+ self.stat.st_mode as i32
+ }
/// Returns whether the remote file is a directory.
pub fn is_dir(&self) -> bool {
self.mode() & (libc::S_IFMT as i32) == (libc::S_IFDIR as i32)
diff --git a/src/sftp.rs b/src/sftp.rs
index 4e1eb56..a02c4db 100644
--- a/src/sftp.rs
+++ b/src/sftp.rs
@@ -1,12 +1,12 @@
+use libc::{c_int, c_long, c_uint, c_ulong, size_t};
use std::io::prelude::*;
use std::io::{self, ErrorKind, SeekFrom};
use std::marker;
use std::mem;
use std::path::{Path, PathBuf};
-use libc::{c_int, c_ulong, c_long, c_uint, size_t};
-use {raw, Session, Error, Channel};
use util::{self, SessionBinding};
+use {raw, Channel, Error, Session};
/// A handle to a remote filesystem over SFTP.
///
@@ -104,16 +104,23 @@ pub enum OpenType {
impl<'sess> Sftp<'sess> {
/// Open a handle to a file.
- pub fn open_mode(&self, filename: &Path, flags: OpenFlags,
- mode: i32, open_type: OpenType) -> Result<File, Error> {
+ pub fn open_mode(
+ &self,
+ filename: &Path,
+ flags: OpenFlags,
+ mode: i32,
+ open_type: OpenType,
+ ) -> Result<File, Error> {
let filename = try!(util::path2bytes(filename));
unsafe {
- let ret = raw::libssh2_sftp_open_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint,
- flags.bits() as c_ulong,
- mode as c_long,
- open_type as c_int);
+ let ret = raw::libssh2_sftp_open_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ flags.bits() as c_ulong,
+ mode as c_long,
+ open_type as c_int,
+ );
if ret.is_null() {
Err(self.last_error())
} else {
@@ -129,7 +136,12 @@ impl<'sess> Sftp<'sess> {
/// Helper to create a file in write-only mode with truncation.
pub fn create(&self, filename: &Path) -> Result<File, Error> {
- self.open_mode(filename, OpenFlags::WRITE | OpenFlags::TRUNCATE, 0o644, OpenType::File)
+ self.open_mode(
+ filename,
+ OpenFlags::WRITE | OpenFlags::TRUNCATE,
+ 0o644,
+ OpenType::File,
+ )
}
/// Helper to open a directory for reading its contents.
@@ -141,15 +153,15 @@ impl<'sess> Sftp<'sess> {
///
/// The returned paths are all joined with `dirname` when returned, and the
/// paths `.` and `..` are filtered out of the returned list.
- pub fn readdir(&self, dirname: &Path)
- -> Result<Vec<(PathBuf, FileStat)>, Error> {
+ pub fn readdir(&self, dirname: &Path) -> Result<Vec<(PathBuf, FileStat)>, Error> {
let mut dir = try!(self.opendir(dirname));
let mut ret = Vec::new();
loop {
match dir.readdir() {
Ok((filename, stat)) => {
- if &*filename == Path::new(".") ||
- &*filename == Path::new("..") { continue }
+ if &*filename == Path::new(".") || &*filename == Path::new("..") {
+ continue;
+ }
ret.push((dirname.join(&filename), stat))
}
@@ -161,14 +173,15 @@ impl<'sess> Sftp<'sess> {
}
/// Create a directory on the remote file system.
- pub fn mkdir(&self, filename: &Path, mode: i32)
- -> Result<(), Error> {
+ pub fn mkdir(&self, filename: &Path, mode: i32) -> Result<(), Error> {
let filename = try!(util::path2bytes(filename));
self.rc(unsafe {
- raw::libssh2_sftp_mkdir_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint,
- mode as c_long)
+ raw::libssh2_sftp_mkdir_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ mode as c_long,
+ )
})
}
@@ -176,9 +189,11 @@ impl<'sess> Sftp<'sess> {
pub fn rmdir(&self, filename: &Path) -> Result<(), Error> {
let filename = try!(util::path2bytes(filename));
self.rc(unsafe {
- raw::libssh2_sftp_rmdir_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint)
+ raw::libssh2_sftp_rmdir_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ )
})
}
@@ -187,11 +202,13 @@ impl<'sess> Sftp<'sess> {
let filename = try!(util::path2bytes(filename));
unsafe {
let mut ret = mem::zeroed();
- let rc = raw::libssh2_sftp_stat_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint,
- raw::LIBSSH2_SFTP_STAT,
- &mut ret);
+ let rc = raw::libssh2_sftp_stat_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ raw::LIBSSH2_SFTP_STAT,
+ &mut ret,
+ );
try!(self.rc(rc));
Ok(FileStat::from_raw(&ret))
}
@@ -202,11 +219,13 @@ impl<'sess> Sftp<'sess> {
let filename = try!(util::path2bytes(filename));
unsafe {
let mut ret = mem::zeroed();
- let rc = raw::libssh2_sftp_stat_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint,
- raw::LIBSSH2_SFTP_LSTAT,
- &mut ret);
+ let rc = raw::libssh2_sftp_stat_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ raw::LIBSSH2_SFTP_LSTAT,
+ &mut ret,
+ );
try!(self.rc(rc));
Ok(FileStat::from_raw(&ret))
}
@@ -217,11 +236,13 @@ impl<'sess> Sftp<'sess> {
let filename = try!(util::path2bytes(filename));
self.rc(unsafe {
let mut raw = stat.raw();
- raw::libssh2_sftp_stat_ex(self.raw,
- filename.as_ptr() as *const _,
- filename.len() as c_uint,
- raw::LIBSSH2_SFTP_SETSTAT,
- &mut raw)
+ raw::libssh2_sftp_stat_ex(
+ self.raw,
+ filename.as_ptr() as *const _,
+ filename.len() as c_uint,
+ raw::LIBSSH2_SFTP_SETSTAT,
+ &mut raw,
+ )
})
}
@@ -230,12 +251,14 @@ impl<'sess> Sftp<'sess> {
let path = try!(util::path2bytes(path));
let target = try!(util::path2bytes(target));
self.rc(unsafe {
- raw::libssh2_sftp_symlink_ex(self.raw,
- path.as_ptr() as *const _,
- path.len() as c_uint,
- target.as_ptr() as *mut _,
- target.len() as c_uint,
- raw::LIBSSH2_SFTP_SYMLINK)
+ raw::libssh2_sftp_symlink_ex(
+ self.raw,
+ path.as_ptr() as *const _,
+ path.len() as c_uint,
+ target.as_ptr() as *mut _,
+ target.len() as c_uint,
+ raw::LIBSSH2_SFTP_SYMLINK,
+ )
})
}
@@ -255,18 +278,20 @@ impl<'sess> Sftp<'sess> {
let mut rc;
loop {
rc = unsafe {
- raw::libssh2_sftp_symlink_ex(self.raw,
- path.as_ptr() as *const _,
- path.len() as c_uint,
- ret.as_ptr() as *mut _,
- ret.capacity() as c_uint,
- op)
+ raw::libssh2_sftp_symlink_ex(
+ self.raw,
+ path.as_ptr() as *const _,
+ path.len() as c_uint,
+ ret.as_ptr() as *mut _,
+ ret.capacity() as c_uint,
+ op,
+ )
};
if rc == raw::LIBSSH2_ERROR_BUFFER_TOO_SMALL {
let cap = ret.capacity();
ret.reserve(cap);
} else {
- break
+ break;
}
}
if rc < 0 {
@@ -289,20 +314,20 @@ impl<'sess> Sftp<'sess> {
/// operation and/or using native system calls when possible.
///
/// If no flags are specified then all flags are used.
- pub fn rename(&self, src: &Path, dst: &Path, flags: Option<RenameFlags>)
- -> Result<(), Error> {
- let flags = flags.unwrap_or(
- RenameFlags::ATOMIC | RenameFlags::OVERWRITE | RenameFlags::NATIVE
- );
+ pub fn rename(&self, src: &Path, dst: &Path, flags: Option<RenameFlags>) -> Result<(), Error> {
+ let flags =
+ flags.unwrap_or(RenameFlags::ATOMIC | RenameFlags::OVERWRITE | RenameFlags::NATIVE);
let src = try!(util::path2bytes(src));
let dst = try!(util::path2bytes(dst));
self.rc(unsafe {
- raw::libssh2_sftp_rename_ex(self.raw,
- src.as_ptr() as *const _,
- src.len() as c_uint,
- dst.as_ptr() as *const _,
- dst.len() as c_uint,
- flags.bits())
+ raw::libssh2_sftp_rename_ex(
+ self.raw,
+ src.as_ptr() as *const _,
+ src.len() as c_uint,
+ dst.as_ptr() as *const _,
+ dst.len() as c_uint,
+ flags.bits(),
+ )
})
}
@@ -310,9 +335,7 @@ impl<'sess> Sftp<'sess> {
pub fn unlink(&self, file: &Path) -> Result<(), Error> {
let file = try!(util::path2bytes(file));
self.rc(unsafe {
- raw::libssh2_sftp_unlink_ex(self.raw,
- file.as_ptr() as *const _,
- file.len() as c_uint)
+ raw::libssh2_sftp_unlink_ex(self.raw, file.as_ptr() as *const _, file.len() as c_uint)
})
}
@@ -324,21 +347,28 @@ impl<'sess> Sftp<'sess> {
/// Translates a return code into a Rust-`Result`
pub fn rc(&self, rc: c_int) -> Result<(), Error> {
- if rc == 0 {Ok(())} else {Err(self.last_error())}
+ if rc == 0 {
+ Ok(())
+ } else {
+ Err(self.last_error())
+ }
}
}
impl<'sess> SessionBinding<'sess> for Sftp<'sess> {
type Raw = raw::LIBSSH2_SFTP;
- unsafe fn from_raw(_sess: &'sess Session,
- raw: *mut raw::LIBSSH2_SFTP) -> Sftp<'sess> {
- Sftp { raw: raw, _marker: marker::PhantomData }
+ unsafe fn from_raw(_sess: &'sess Session, raw: *mut raw::LIBSSH2_SFTP) -> Sftp<'sess> {
+ Sftp {
+ raw: raw,
+ _marker: marker::PhantomData,
+ }
+ }
+ fn raw(&self) -> *mut raw::LIBSSH2_SFTP {
+ self.raw
}
- fn raw(&self) -> *mut raw::LIBSSH2_SFTP { self.raw }
}
-
impl<'sess> Drop for Sftp<'sess> {
fn drop(&mut self) {
unsafe { assert_eq!(raw::libssh2_sftp_shutdown(self.raw), 0) }
@@ -350,8 +380,10 @@ impl<'sftp> File<'sftp> {
/// given session.
///
/// This consumes ownership of `raw`.
- unsafe fn from_raw(sftp: &'sftp Sftp<'sftp>,
- raw: *mut raw::LIBSSH2_SFTP_HANDLE) -> File<'sftp> {
+ unsafe fn from_raw(
+ sftp: &'sftp Sftp<'sftp>,
+ raw: *mut raw::LIBSSH2_SFTP_HANDLE,
+ ) -> File<'sftp> {
File {
raw: raw,
sftp: sftp,
@@ -370,7 +402,9 @@ impl<'sftp> File<'sftp> {
pub fn stat(&mut self) -> Result<FileStat, Error> {
unsafe {
let mut ret = mem::zeroed();
- try!(self.sftp.rc(raw::libssh2_sftp_fstat_ex(self.raw, &mut ret, 0)));
+ try!(self
+ .sftp
+ .rc(raw::libssh2_sftp_fstat_ex(self.raw, &mut ret, 0)));
Ok(FileStat::from_raw(&ret))
}
}
@@ -400,25 +434,30 @@ impl<'sftp> File<'sftp> {
let mut rc;
loop {
rc = unsafe {
- raw::libssh2_sftp_readdir_ex(self.raw,
- buf.as_mut_ptr() as *mut _,
- buf.capacity() as size_t,
- 0 as *mut _, 0,
- &mut stat)
+ raw::libssh2_sftp_readdir_ex(
+ self.raw,
+ buf.as_mut_ptr() as *mut _,
+ buf.capacity() as size_t,
+ 0 as *mut _,
+ 0,
+ &mut stat,
+ )
};
if rc == raw::LIBSSH2_ERROR_BUFFER_TOO_SMALL {
let cap = buf.capacity();
buf.reserve(cap);
} else {
- break
+ break;
}
}
if rc < 0 {
- return Err(self.sftp.last_error())
+ return Err(self.sftp.last_error());
} else if rc == 0 {
- return Err(Error::new(raw::LIBSSH2_ERROR_FILE, "no more files"))
+ return Err(Error::new(raw::LIBSSH2_ERROR_FILE, "no more files"));
} else {
- unsafe { buf.set_len(rc as usize); }
+ unsafe {
+ buf.set_len(rc as usize);
+ }
}
Ok((mkpath(buf), FileStat::from_raw(&stat)))
}
@@ -435,13 +474,11 @@ impl<'sftp> File<'sftp> {
impl<'sftp> Read for File<'sftp> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
unsafe {
- let rc = raw::libssh2_sftp_read(self.raw,
- buf.as_mut_ptr() as *mut _,
- buf.len() as size_t);
+ let rc =
+ raw::libssh2_sftp_read(self.raw, buf.as_mut_ptr() as *mut _, buf.len() as size_t);
match rc {
- n if n < 0 => Err(io::Error::new(ErrorKind::Other,
- self.sftp.last_error())),
- n => Ok(n as usize)
+ n if n < 0 => Err(io::Error::new(ErrorKind::Other, self.sftp.last_error())),
+ n => Ok(n as usize),
}
}
}
@@ -450,9 +487,7 @@ impl<'sftp> Read for File<'sftp> {
impl<'sftp> Write for File<'sftp> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let rc = unsafe {
- raw::libssh2_sftp_write(self.raw,
- buf.as_ptr() as *const _,
- buf.len() as size_t)
+ raw::libssh2_sftp_write(self.raw, buf.as_ptr() as *const _, buf.len() as size_t)
};
if rc < 0 {
Err(io::Error::new(ErrorKind::Other, self.sftp.last_error()))
@@ -460,7 +495,9 @@ impl<'sftp> Write for File<'sftp> {
Ok(rc as usize)
}
}
- fn flush(&mut self) -> io::Result<()> { Ok(()) }
+ fn flush(&mut self) -> io::Result<()> {
+ Ok(())
+ }
}
impl<'sftp> Seek for File<'sftp> {
@@ -484,15 +521,10 @@ impl<'sftp> Seek for File<'sftp> {
SeekFrom::End(offset) => match self.stat() {
Ok(s) => match s.size {
Some(size) => (size as i64 + offset) as u64,
- None => {
- return Err(io::Error::new(ErrorKind::Other,
- "no file size available"))
- }
+ None => return Err(io::Error::new(ErrorKind::Other, "no file size available")),
},
- Err(e) => {
- return Err(io::Error::new(ErrorKind::Other, e))
- }
- }
+ Err(e) => return Err(io::Error::new(ErrorKind::Other, e)),
+ },
};
unsafe { raw::libssh2_sftp_seek64(self.raw, next) }
Ok(next)
@@ -508,50 +540,58 @@ impl<'sftp> Drop for File<'sftp> {
impl FileStat {
/// Returns the file type for this filestat.
pub fn file_type(&self) -> FileType {
- FileType { perm: self.perm.unwrap_or(0) as c_ulong }
+ FileType {
+ perm: self.perm.unwrap_or(0) as c_ulong,
+ }
}
/// Returns whether this metadata is for a directory.
- pub fn is_dir(&self) -> bool { self.file_type().is_dir() }
+ pub fn is_dir(&self) -> bool {
+ self.file_type().is_dir()
+ }
/// Returns whether this metadata is for a regular file.
- pub fn is_file(&self) -> bool { self.file_type().is_file() }
+ pub fn is_file(&self) -> bool {
+ self.file_type().is_file()
+ }
/// Creates a new instance of a stat from a raw instance.
pub fn from_raw(raw: &raw::LIBSSH2_SFTP_ATTRIBUTES) -> FileStat {
- fn val<T: Copy>(raw: &raw::LIBSSH2_SFTP_ATTRIBUTES, t: &T,
- flag: c_ulong) -> Option<T> {
- if raw.flags & flag != 0 {Some(*t)} else {None}
+ fn val<T: Copy>(raw: &raw::LIBSSH2_SFTP_ATTRIBUTES, t: &T, flag: c_ulong) -> Option<T> {
+ if raw.flags & flag != 0 {
+ Some(*t)
+ } else {
+ None
+ }
}
FileStat {
size: val(raw, &raw.filesize, raw::LIBSSH2_SFTP_ATTR_SIZE),
- uid: val(raw, &raw.uid, raw::LIBSSH2_SFTP_ATTR_UIDGID)
- .map(|s| s as u32),
- gid: val(raw, &raw.gid, raw::LIBSSH2_SFTP_ATTR_UIDGID)
- .map(|s| s as u32),
- perm: val(raw, &raw.permissions, raw::LIBSSH2_SFTP_ATTR_PERMISSIONS)
- .map(|s| s as u32),
- mtime: val(raw, &raw.mtime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME)
- .map(|s| s as u64),
- atime: val(raw, &raw.atime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME)
- .map(|s| s as u64),
+ uid: val(raw, &raw.uid, raw::LIBSSH2_SFTP_ATTR_UIDGID).map(|s| s as u32),
+ gid: val(raw, &raw.gid, raw::LIBSSH2_SFTP_ATTR_UIDGID).map(|s| s as u32),
+ perm: val(raw, &raw.permissions, raw::LIBSSH2_SFTP_ATTR_PERMISSIONS).map(|s| s as u32),
+ mtime: val(raw, &raw.mtime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME).map(|s| s as u64),
+ atime: val(raw, &raw.atime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME).map(|s| s as u64),
}
}
/// Convert this stat structure to its raw representation.
pub fn raw(&self) -> raw::LIBSSH2_SFTP_ATTRIBUTES {
fn flag<T>(o: &Option<T>, flag: c_ulong) -> c_ulong {
- if o.is_some() {flag} else {0}
+ if o.is_some() {
+ flag
+ } else {
+ 0
+ }
}
raw::LIBSSH2_SFTP_ATTRIBUTES {
- flags: flag(&self.size, raw::LIBSSH2_SFTP_ATTR_SIZE) |
- flag(&self.uid, raw::LIBSSH2_SFTP_ATTR_UIDGID) |
- flag(&self.gid, raw::LIBSSH2_SFTP_ATTR_UIDGID) |
- flag(&self.perm, raw::LIBSSH2_SFTP_ATTR_PERMISSIONS) |
- flag(&self.atime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME) |
- flag(&self.mtime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME),
+ flags: flag(&self.size, raw::LIBSSH2_SFTP_ATTR_SIZE)
+ | flag(&self.uid, raw::LIBSSH2_SFTP_ATTR_UIDGID)
+ | flag(&self.gid, raw::LIBSSH2_SFTP_ATTR_UIDGID)
+ | flag(&self.perm, raw::LIBSSH2_SFTP_ATTR_PERMISSIONS)
+ | flag(&self.atime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME)
+ | flag(&self.mtime, raw::LIBSSH2_SFTP_ATTR_ACMODTIME),
filesize: self.size.unwrap_or(0),
uid: self.uid.unwrap_or(0) as c_ulong,
gid: self.gid.unwrap_or(0) as c_ulong,
@@ -564,13 +604,19 @@ impl FileStat {
impl FileType {
/// Test whether this file type represents a directory.
- pub fn is_dir(&self) -> bool { self.is(raw::LIBSSH2_SFTP_S_IFDIR) }
+ pub fn is_dir(&self) -> bool {
+ self.is(raw::LIBSSH2_SFTP_S_IFDIR)
+ }
/// Test whether this file type represents a regular file.
- pub fn is_file(&self) -> bool { self.is(raw::LIBSSH2_SFTP_S_IFREG) }
+ pub fn is_file(&self) -> bool {
+ self.is(raw::LIBSSH2_SFTP_S_IFREG)
+ }
/// Test whether this file type represents a symbolic link.
- pub fn is_symlink(&self) -> bool { self.is(raw::LIBSSH2_SFTP_S_IFLNK) }
+ pub fn is_symlink(&self) -> bool {
+ self.is(raw::LIBSSH2_SFTP_S_IFLNK)
+ }
fn is(&self, perm: c_ulong) -> bool {
(self.perm & raw::LIBSSH2_SFTP_S_IFMT) == perm
@@ -579,8 +625,8 @@ impl FileType {
#[cfg(unix)]
fn mkpath(v: Vec<u8>) -> PathBuf {
- use std::os::unix::prelude::*;
use std::ffi::OsStr;
+ use std::os::unix::prelude::*;
PathBuf::from(OsStr::from_bytes(&v))
}
#[cfg(windows)]
diff --git a/src/util.rs b/src/util.rs
index 414bbb2..ac6c722 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,7 +1,7 @@
use std::borrow::Cow;
use std::path::Path;
-use {raw, Session, Error};
+use {raw, Error, Session};
#[doc(hidden)]
pub trait Binding: Sized {
@@ -18,8 +18,7 @@ pub trait SessionBinding<'sess>: Sized {
unsafe fn from_raw(sess: &'sess Session, raw: *mut Self::Raw) -> Self;
fn raw(&self) -> *mut Self::Raw;
- unsafe fn from_raw_opt(sess: &'sess Session, raw: *mut Self::Raw)
- -> Result<Self, Error> {
+ unsafe fn from_raw_opt(sess: &'sess Session, raw: *mut Self::Raw) -> Result<Self, Error> {
if raw.is_null() {
Err(Error::last_error(sess).unwrap_or_else(Error::unknown))
} else {
@@ -30,8 +29,8 @@ pub trait SessionBinding<'sess>: Sized {
#[cfg(unix)]
pub fn path2bytes(p: &Path) -> Result<Cow<[u8]>, Error> {
- use std::os::unix::prelude::*;
use std::ffi::OsStr;
+ use std::os::unix::prelude::*;
let s: &OsStr = p.as_ref();
check(Cow::Borrowed(s.as_bytes()))
}
@@ -39,8 +38,12 @@ pub fn path2bytes(p: &Path) -> Result<Cow<[u8]>, Error> {
pub fn path2bytes(p: &Path) -> Result<Cow<[u8]>, Error> {
p.to_str()
.map(|s| s.as_bytes())
- .ok_or_else(|| Error::new(raw::LIBSSH2_ERROR_INVAL,
- "only unicode paths on windows may be used"))
+ .ok_or_else(|| {
+ Error::new(
+ raw::LIBSSH2_ERROR_INVAL,
+ "only unicode paths on windows may be used",
+ )
+ })
.map(|bytes| {
if bytes.contains(&b'\\') {
// Normalize to Unix-style path separators
@@ -60,8 +63,10 @@ pub fn path2bytes(p: &Path) -> Result<Cow<[u8]>, Error> {
fn check(b: Cow<[u8]>) -> Result<Cow<[u8]>, Error> {
if b.iter().any(|b| *b == 0) {
- Err(Error::new(raw::LIBSSH2_ERROR_INVAL,
- "path provided contains a 0 byte"))
+ Err(Error::new(
+ raw::LIBSSH2_ERROR_INVAL,
+ "path provided contains a 0 byte",
+ ))
} else {
Ok(b)
}