Bump versions and update to master

9 files changed, 54 insertions, 44 deletions

diff --git a/Cargo.toml b/Cargo.toml
index caf5f3c..99a6925 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ssh2"
-version = "0.1.10"
+version = "0.1.11"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 license = "MIT/Apache-2.0"
 keywords = ["ssh"]
diff --git a/libssh2-sys/Cargo.toml b/libssh2-sys/Cargo.toml
index 9576bc0..a91df02 100644
--- a/libssh2-sys/Cargo.toml
+++ b/libssh2-sys/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "libssh2-sys"
-version = "0.1.7"
+version = "0.1.8"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 links = "ssh2"
 build = "build.rs"
@@ -36,4 +36,4 @@ openssl-sys = "0.4.0"
 openssl-sys = "0.4.0"
 
 [build-dependencies]
-pkg-config = "0.1.0"
+pkg-config = "0.2"
diff --git a/libssh2-sys/build.rs b/libssh2-sys/build.rs
index 6a8facc..9cab3b0 100644
--- a/libssh2-sys/build.rs
+++ b/libssh2-sys/build.rs
@@ -9,7 +9,7 @@ use std::old_io::fs::PathExtensions;
 
 fn main() {
     match pkg_config::find_library("libssh2") {
-        Ok(()) => return,
+        Ok(..) => return,
         Err(..) => {}
     }
 
diff --git a/src/agent.rs b/src/agent.rs
index 710cd98..0e042ab 100644
--- a/src/agent.rs
+++ b/src/agent.rs
@@ -23,7 +23,7 @@ pub struct Identities<'agent> {
 /// A public key which is extracted from an SSH agent.
 pub struct PublicKey<'agent> {
     raw: *mut raw::libssh2_agent_publickey,
-    marker: marker::ContravariantLifetime<'agent>,
+    _marker: marker::PhantomData<&'agent [u8]>,
 }
 
 impl<'sess> Agent<'sess> {
@@ -53,7 +53,7 @@ impl<'sess> Agent<'sess> {
     /// Attempt public key authentication with the help of ssh-agent.
     pub fn userauth(&self, username: &str, identity: &PublicKey)
                     -> Result<(), Error>{
-        let username = CString::from_slice(username.as_bytes());
+        let username = try!(CString::new(username));
         unsafe {
             self.sess.rc(raw::libssh2_agent_userauth(self.raw,
                                                      username.as_ptr(),
@@ -119,7 +119,7 @@ impl<'agent> Binding for PublicKey<'agent> {
 
     unsafe fn from_raw(raw: *mut raw::libssh2_agent_publickey)
                        -> PublicKey<'agent> {
-        PublicKey { raw: raw, marker: marker::ContravariantLifetime }
+        PublicKey { raw: raw, _marker: marker::PhantomData }
     }
 
     fn raw(&self) -> *mut raw::libssh2_agent_publickey { self.raw }
diff --git a/src/error.rs b/src/error.rs
index 24946ad..fe37c48 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,4 +1,5 @@
-use std::error::Error as StdError;
+use std::error::{self, FromError};
+use std::ffi::NulError;
 use std::fmt;
 use std::str;
 use libc;
@@ -109,6 +110,14 @@ impl fmt::Display for Error {
     }
 }
 
-impl StdError for Error {
+impl error::Error for Error {
     fn description(&self) -> &str { self.message() }
 }
+
+impl FromError<NulError> for Error {
+    fn from_error(_: NulError) -> Error {
+        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 70f5f4f..171c758 100644
--- a/src/knownhosts.rs
+++ b/src/knownhosts.rs
@@ -60,7 +60,7 @@ pub struct Hosts<'kh> {
 /// Structure representing a known host as part of a `KnownHosts` structure.
 pub struct Host<'kh> {
     raw: *mut raw::libssh2_knownhost,
-    marker: marker::ContravariantLifetime<'kh>,
+    _marker: marker::PhantomData<&'kh str>,
 }
 
 impl<'sess> KnownHosts<'sess> {
@@ -68,7 +68,7 @@ impl<'sess> KnownHosts<'sess> {
     /// the collection of known hosts.
     pub fn read_file(&mut self, file: &Path, kind: KnownHostFileKind)
                      -> Result<u32, Error> {
-        let file = CString::from_slice(file.as_vec());
+        let file = try!(CString::new(file.as_vec()));
         let n = unsafe {
             raw::libssh2_knownhost_readfile(self.raw, file.as_ptr(),
                                             kind as c_int)
@@ -92,7 +92,7 @@ impl<'sess> KnownHosts<'sess> {
     /// file format.
     pub fn write_file(&self, file: &Path, kind: KnownHostFileKind)
                       -> Result<(), Error> {
-        let file = CString::from_slice(file.as_vec());
+        let file = try!(CString::new(file.as_vec()));
         let n = unsafe {
             raw::libssh2_knownhost_writefile(self.raw, file.as_ptr(),
                                              kind as c_int)
@@ -154,7 +154,7 @@ impl<'sess> KnownHosts<'sess> {
     }
 
     fn check_port_(&self, host: &str, port: i32, key: &[u8]) -> CheckResult {
-        let host = CString::from_slice(host.as_bytes());
+        let host = CString::new(host).unwrap();
         let flags = raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN |
                     raw::LIBSSH2_KNOWNHOST_KEYENC_RAW;
         unsafe {
@@ -187,7 +187,7 @@ impl<'sess> KnownHosts<'sess> {
     pub fn add(&mut self, host: &str, key: &[u8], comment: &str,
                fmt: ::KnownHostKeyFormat)
                -> Result<(), Error> {
-        let host = CString::from_slice(host.as_bytes());
+        let host = try!(CString::new(host));
         let flags = raw::LIBSSH2_KNOWNHOST_TYPE_PLAIN |
                     raw::LIBSSH2_KNOWNHOST_KEYENC_RAW |
                     (fmt as c_int);
@@ -265,10 +265,7 @@ 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::ContravariantLifetime,
-        }
+        Host { raw: raw, _marker: marker::PhantomData }
     }
     fn raw(&self) -> *mut raw::libssh2_knownhost { self.raw }
 }
diff --git a/src/lib.rs b/src/lib.rs
index eea8a77..d53c641 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,7 +114,7 @@
 //! let contents = remote_file.read_to_end();
 //! ```
 
-#![feature(unsafe_destructor, std_misc, collections, old_io, core, old_path, hash)]
+#![feature(unsafe_destructor, std_misc, collections, old_io, core, old_path)]
 #![feature(io)]
 #![deny(missing_docs, unused_results)]
 #![cfg_attr(test, deny(warnings))]
@@ -123,8 +123,7 @@ extern crate "libssh2-sys" as raw;
 extern crate libc;
 #[macro_use] extern crate bitflags;
 
-use std::ffi;
-use std::mem;
+use std::ffi::CStr;
 use std::sync::{Once, ONCE_INIT};
 
 pub use agent::{Agent, Identities, PublicKey};
@@ -169,8 +168,7 @@ unsafe fn opt_bytes<'a, T>(_: &'a T,
     if c.is_null() {
         None
     } else {
-        let s = ffi::c_str_to_bytes(&c);
-        Some(mem::transmute(s))
+        Some(CStr::from_ptr(c).to_bytes())
     }
 }
 
diff --git a/src/session.rs b/src/session.rs
index 66ad1ee..81ed002 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -43,7 +43,7 @@ impl Session {
     /// corresponding to the protocol and libssh2 version will be sent by
     /// default.
     pub fn set_banner(&self, banner: &str) -> Result<(), Error> {
-        let banner = CString::from_slice(banner.as_bytes());
+        let banner = try!(CString::new(banner));
         unsafe {
             self.rc(raw::libssh2_session_banner_set(self.raw, banner.as_ptr()))
         }
@@ -192,9 +192,15 @@ impl Session {
                                 pubkey: Option<&Path>,
                                 privatekey: &Path,
                                 passphrase: Option<&str>) -> Result<(), Error> {
-        let pubkey = pubkey.map(|s| CString::from_slice(s.as_vec()));
-        let privatekey = CString::from_slice(privatekey.as_vec());
-        let passphrase = passphrase.map(|s| CString::from_slice(s.as_bytes()));
+        let pubkey = match pubkey {
+            Some(s) => Some(try!(CString::new(s.as_vec()))),
+            None => None,
+        };
+        let privatekey = try!(CString::new(privatekey.as_vec()));
+        let passphrase = match passphrase {
+            Some(s) => Some(try!(CString::new(s))),
+            None => None,
+        };
         self.rc(unsafe {
             raw::libssh2_userauth_publickey_fromfile_ex(self.raw,
                     username.as_ptr() as *const _,
@@ -216,9 +222,12 @@ impl Session {
                                    hostname: &str,
                                    local_username: Option<&str>)
                                    -> Result<(), Error> {
-        let publickey = CString::from_slice(publickey.as_vec());
-        let privatekey = CString::from_slice(privatekey.as_vec());
-        let passphrase = passphrase.map(|s| CString::from_slice(s.as_bytes()));
+        let publickey = try!(CString::new(publickey.as_vec()));
+        let privatekey = try!(CString::new(privatekey.as_vec()));
+        let passphrase = match passphrase {
+            Some(s) => Some(try!(CString::new(s))),
+            None => None,
+        };
         let local_username = match local_username {
             Some(local) => local,
             None => username,
@@ -256,7 +265,7 @@ impl Session {
     /// The return value is a comma-separated string of supported auth schemes.
     pub fn auth_methods(&self, username: &str) -> Result<&str, Error> {
         let len = username.len();
-        let username = CString::from_slice(username.as_bytes());
+        let username = try!(CString::new(username));
         unsafe {
             let ret = raw::libssh2_userauth_list(self.raw, username.as_ptr(),
                                                  len as c_uint);
@@ -278,7 +287,7 @@ impl Session {
     pub fn method_pref(&self,
                        method_type: MethodType,
                        prefs: &str) -> Result<(), Error> {
-        let prefs = CString::from_slice(prefs.as_bytes());
+        let prefs = try!(CString::new(prefs));
         unsafe {
             self.rc(raw::libssh2_session_method_pref(self.raw,
                                                      method_type as c_int,
@@ -365,8 +374,8 @@ impl Session {
                                 src: Option<(&str, u16)>)
                                 -> Result<Channel, Error> {
         let (shost, sport) = src.unwrap_or(("127.0.0.1", 22));
-        let host = CString::from_slice(host.as_bytes());
-        let shost = CString::from_slice(shost.as_bytes());
+        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(),
@@ -407,7 +416,7 @@ impl Session {
     /// about the remote file to prepare for receiving the file.
     pub fn scp_recv(&self, path: &Path)
                     -> Result<(Channel, old_io::FileStat), Error> {
-        let path = CString::from_slice(path.as_vec());
+        let path = try!(CString::new(path.as_vec()));
         unsafe {
             let mut sb: libc::stat = mem::zeroed();
             let ret = raw::libssh2_scp_recv(self.raw, path.as_ptr(), &mut sb);
@@ -434,7 +443,7 @@ impl Session {
     pub fn scp_send(&self, remote_path: &Path, mode: old_io::FilePermission,
                     size: u64, times: Option<(u64, u64)>)
                     -> Result<Channel, Error> {
-        let path = CString::from_slice(remote_path.as_vec());
+        let path = try!(CString::new(remote_path.as_vec()));
         let (mtime, atime) = times.unwrap_or((0, 0));
         unsafe {
             let ret = raw::libssh2_scp_send64(self.raw,
@@ -577,8 +586,8 @@ impl Session {
                       description: &str,
                       lang: Option<&str>) -> Result<(), Error> {
         let reason = reason.unwrap_or(ByApplication) as c_int;
-        let description = CString::from_slice(description.as_bytes());
-        let lang = CString::from_slice(lang.unwrap_or("").as_bytes());
+        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,
diff --git a/src/sftp.rs b/src/sftp.rs
index 038917a..d39fc33 100644
--- a/src/sftp.rs
+++ b/src/sftp.rs
@@ -3,7 +3,7 @@ use std::mem;
 use std::old_io;
 use libc::{c_int, c_ulong, c_long, c_uint, size_t};
 
-use {raw, Session, Error};
+use {raw, Session, Error, Channel};
 use util::SessionBinding;
 
 /// A handle to a remote filesystem over SFTP.
@@ -11,7 +11,7 @@ use util::SessionBinding;
 /// Instances are created through the `sftp` method on a `Session`.
 pub struct Sftp<'sess> {
     raw: *mut raw::LIBSSH2_SFTP,
-    marker: marker::ContravariantLifetime<'sess>,
+    _marker: marker::PhantomData<Channel<'sess>>,
 }
 
 /// A file handle to an SFTP connection.
@@ -315,10 +315,7 @@ impl<'sess> SessionBinding<'sess> for Sftp<'sess> {
 
     unsafe fn from_raw(_sess: &'sess Session,
                        raw: *mut raw::LIBSSH2_SFTP) -> Sftp<'sess> {
-        Sftp {
-            raw: raw,
-            marker: marker::ContravariantLifetime,
-        }
+        Sftp { raw: raw, _marker: marker::PhantomData }
     }
     fn raw(&self) -> *mut raw::LIBSSH2_SFTP { self.raw }
 }