Update to rust master

4 files changed, 51 insertions, 46 deletions

diff --git a/src/knownhosts.rs b/src/knownhosts.rs
index 12f562b..fe1acdd 100644
--- a/src/knownhosts.rs
+++ b/src/knownhosts.rs
@@ -11,7 +11,7 @@ use {raw, Session, Error, KnownHostFileKind, CheckResult};
 ///
 /// ```no_run
 /// use std::os;
-/// use ssh2;
+/// use ssh2::{mod, CheckResult, HostKeyType, KnownHostKeyFormat};
 ///
 /// fn check_known_host(session: &ssh2::Session, host: &str) {
 ///     let mut known_hosts = session.known_hosts().unwrap();
@@ -24,20 +24,20 @@ use {raw, Session, Error, KnownHostFileKind, CheckResult};
 ///     // hosts file
 ///     let (key, key_type) = session.host_key().unwrap();
 ///     match known_hosts.check(host, key) {
-///         ssh2::CheckMatch => return, // all good!
-///         ssh2::CheckNotFound => {}   // ok, we'll add it
-///         ssh2::CheckMismatch => {
+///         CheckResult::Match => return, // all good!
+///         CheckResult::NotFound => {}   // ok, we'll add it
+///         CheckResult::Mismatch => {
 ///             panic!("host mismatch, man in the middle attack?!")
 ///         }
-///         ssh2::CheckFailure => panic!("failed to check the known hosts"),
+///         CheckResult::Failure => panic!("failed to check the known hosts"),
 ///     }
 ///
 ///     println!("adding {} to the known hosts", host);
 ///
 ///     known_hosts.add(host, key, host, match key_type {
-///         ssh2::TypeRsa => ssh2::KeySshRsa,
-///         ssh2::TypeDss => ssh2::KeySshDss,
-///         ssh2::TypeUnknown => panic!("unknown type of key!"),
+///         HostKeyType::Rsa => KnownHostKeyFormat::SshRsa,
+///         HostKeyType::Dss => KnownHostKeyFormat::SshDss,
+///         HostKeyType::Unknown => panic!("unknown type of key!"),
 ///     }).unwrap();
 ///     known_hosts.write_file(&file, ssh2::OpenSSH).unwrap();
 /// }
@@ -179,10 +179,10 @@ impl<'a> KnownHosts<'a> {
                                                    flags,
                                                    0 as *mut _);
             match rc {
-                raw::LIBSSH2_KNOWNHOST_CHECK_MATCH => ::CheckMatch,
-                raw::LIBSSH2_KNOWNHOST_CHECK_MISMATCH => ::CheckMismatch,
-                raw::LIBSSH2_KNOWNHOST_CHECK_NOTFOUND => ::CheckNotFound,
-                _ => ::CheckFailure,
+                raw::LIBSSH2_KNOWNHOST_CHECK_MATCH => CheckResult::Match,
+                raw::LIBSSH2_KNOWNHOST_CHECK_MISMATCH => CheckResult::Mismatch,
+                raw::LIBSSH2_KNOWNHOST_CHECK_NOTFOUND => CheckResult::NotFound,
+                _ => CheckResult::Failure,
             }
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index a56632d..a212626 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -106,8 +106,14 @@ pub use knownhosts::{KnownHosts, Hosts, Host};
 pub use listener::Listener;
 pub use session::Session;
 pub use sftp::{Sftp, OpenFlags, READ, WRITE, APPEND, CREATE, TRUNCATE};
-pub use sftp::{EXCLUSIVE, OpenType, OpenFile, OpenDir, File, FileStat};
+pub use sftp::{EXCLUSIVE, OpenType, File, FileStat};
 pub use sftp::{RenameFlags, ATOMIC, OVERWRITE, NATIVE};
+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};
 
 mod agent;
 mod channel;
@@ -162,7 +168,6 @@ pub enum DisconnectCode {
     NoMoreAuthMethodsAvailable =
         raw::SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE as int,
     IllegalUserName = raw::SSH_DISCONNECT_ILLEGAL_USER_NAME as int,
-
 }
 
 /// Flags to be enabled/disabled on a Session
@@ -179,23 +184,23 @@ pub enum SessionFlag {
 
 #[allow(missing_docs)]
 pub enum HostKeyType {
-    TypeUnknown = raw::LIBSSH2_HOSTKEY_TYPE_UNKNOWN as int,
-    TypeRsa = raw::LIBSSH2_HOSTKEY_TYPE_RSA as int,
-    TypeDss = raw::LIBSSH2_HOSTKEY_TYPE_DSS as int,
+    Unknown = raw::LIBSSH2_HOSTKEY_TYPE_UNKNOWN as int,
+    Rsa = raw::LIBSSH2_HOSTKEY_TYPE_RSA as int,
+    Dss = raw::LIBSSH2_HOSTKEY_TYPE_DSS as int,
 }
 
 #[allow(missing_docs)]
 pub enum MethodType {
-    MethodKex = raw::LIBSSH2_METHOD_KEX as int,
-    MethodHostKey = raw::LIBSSH2_METHOD_HOSTKEY as int,
-    MethodCryptCs = raw::LIBSSH2_METHOD_CRYPT_CS as int,
-    MethodCryptSc = raw::LIBSSH2_METHOD_CRYPT_SC as int,
-    MethodMacCs = raw::LIBSSH2_METHOD_MAC_CS as int,
-    MethodMacSc = raw::LIBSSH2_METHOD_MAC_SC as int,
-    MethodCompCs = raw::LIBSSH2_METHOD_COMP_CS as int,
-    MethodCompSc = raw::LIBSSH2_METHOD_COMP_SC as int,
-    MethodLangCs = raw::LIBSSH2_METHOD_LANG_CS as int,
-    MethodLangSc = raw::LIBSSH2_METHOD_LANG_SC as int,
+    Kex = raw::LIBSSH2_METHOD_KEX as int,
+    HostKey = raw::LIBSSH2_METHOD_HOSTKEY as int,
+    CryptCs = raw::LIBSSH2_METHOD_CRYPT_CS as int,
+    CryptSc = raw::LIBSSH2_METHOD_CRYPT_SC as int,
+    MacCs = raw::LIBSSH2_METHOD_MAC_CS as int,
+    MacSc = raw::LIBSSH2_METHOD_MAC_SC as int,
+    CompCs = raw::LIBSSH2_METHOD_COMP_CS as int,
+    CompSc = raw::LIBSSH2_METHOD_COMP_SC as int,
+    LangCs = raw::LIBSSH2_METHOD_LANG_CS as int,
+    LangSc = raw::LIBSSH2_METHOD_LANG_SC as int,
 }
 
 /// When passed to `Channel::flush_stream`, flushes all extended data
@@ -208,8 +213,8 @@ pub static EXTENDED_DATA_STDERR: uint = 1;
 
 #[allow(missing_docs)]
 pub enum HashType {
-    HashMd5 = raw::LIBSSH2_HOSTKEY_HASH_MD5 as int,
-    HashSha1 = raw:: LIBSSH2_HOSTKEY_HASH_SHA1 as int,
+    Md5 = raw::LIBSSH2_HOSTKEY_HASH_MD5 as int,
+    Sha1 = raw:: LIBSSH2_HOSTKEY_HASH_SHA1 as int,
 }
 
 #[allow(missing_docs)]
@@ -220,18 +225,18 @@ pub enum KnownHostFileKind {
 /// Possible results of a call to `KnownHosts::check`
 pub enum CheckResult {
     /// Hosts and keys match
-    CheckMatch = raw::LIBSSH2_KNOWNHOST_CHECK_MATCH as int,
+    Match = raw::LIBSSH2_KNOWNHOST_CHECK_MATCH as int,
     /// Host was found, but the keys didn't match!
-    CheckMismatch = raw::LIBSSH2_KNOWNHOST_CHECK_MISMATCH as int,
+    Mismatch = raw::LIBSSH2_KNOWNHOST_CHECK_MISMATCH as int,
     /// No host match was found
-    CheckNotFound = raw::LIBSSH2_KNOWNHOST_CHECK_NOTFOUND as int,
+    NotFound = raw::LIBSSH2_KNOWNHOST_CHECK_NOTFOUND as int,
     /// Something prevented the check to be made
-    CheckFailure = raw::LIBSSH2_KNOWNHOST_CHECK_FAILURE as int,
+    Failure = raw::LIBSSH2_KNOWNHOST_CHECK_FAILURE as int,
 }
 
 #[allow(missing_docs)]
 pub enum KnownHostKeyFormat {
-    KeyRsa1 = raw::LIBSSH2_KNOWNHOST_KEY_RSA1 as int,
-    KeySshRsa = raw::LIBSSH2_KNOWNHOST_KEY_SSHRSA as int,
-    KeySshDss = raw::LIBSSH2_KNOWNHOST_KEY_SSHDSS as int,
+    Rsa1 = raw::LIBSSH2_KNOWNHOST_KEY_RSA1 as int,
+    SshRsa = raw::LIBSSH2_KNOWNHOST_KEY_SSHRSA as int,
+    SshDss = raw::LIBSSH2_KNOWNHOST_KEY_SSHDSS as int,
 }
diff --git a/src/session.rs b/src/session.rs
index 96f8a32..18d5a23 100644
--- a/src/session.rs
+++ b/src/session.rs
@@ -153,9 +153,9 @@ impl Session {
                 len: len as uint,
             });
             let kind = match kind {
-                raw::LIBSSH2_HOSTKEY_TYPE_RSA => ::TypeRsa,
-                raw::LIBSSH2_HOSTKEY_TYPE_DSS => ::TypeDss,
-                _ => ::TypeUnknown,
+                raw::LIBSSH2_HOSTKEY_TYPE_RSA => HostKeyType::Rsa,
+                raw::LIBSSH2_HOSTKEY_TYPE_DSS => HostKeyType::Dss,
+                _ => HostKeyType::Unknown,
             };
             Some((data, kind))
         }
@@ -167,8 +167,8 @@ impl Session {
     /// is not yet available `None` is returned.
     pub fn host_key_hash(&self, hash: HashType) -> Option<&[u8]> {
         let len = match hash {
-            ::HashMd5 => 16,
-            ::HashSha1 => 20,
+            HashType::Md5 => 16,
+            HashType::Sha1 => 20,
         };
         unsafe {
             let ret = raw::libssh2_hostkey_hash(self.raw, hash as c_int);
diff --git a/src/sftp.rs b/src/sftp.rs
index 40b8c59..f5d042f 100644
--- a/src/sftp.rs
+++ b/src/sftp.rs
@@ -90,9 +90,9 @@ bitflags! {
 /// How to open a file handle with libssh2.
 pub enum OpenType {
     /// Specify that a file shoud be opened.
-    OpenFile = raw::LIBSSH2_SFTP_OPENFILE as int,
+    File = raw::LIBSSH2_SFTP_OPENFILE as int,
     /// Specify that a directory should be opened.
-    OpenDir = raw::LIBSSH2_SFTP_OPENDIR as int,
+    Dir = raw::LIBSSH2_SFTP_OPENDIR as int,
 }
 
 impl<'a> Sftp<'a> {
@@ -132,17 +132,17 @@ impl<'a> Sftp<'a> {
 
     /// Helper to open a file in the `Read` mode.
     pub fn open(&self, filename: &Path) -> Result<File, Error> {
-        self.open_mode(filename, READ, io::USER_FILE, OpenFile)
+        self.open_mode(filename, READ, io::USER_FILE, OpenType::File)
     }
 
     /// Helper to create a file in write-only mode with truncation.
     pub fn create(&self, filename: &Path) -> Result<File, Error> {
-        self.open_mode(filename, WRITE | TRUNCATE, io::USER_FILE, OpenFile)
+        self.open_mode(filename, WRITE | TRUNCATE, io::USER_FILE, OpenType::File)
     }
 
     /// Helper to open a directory for reading its contents.
     pub fn opendir(&self, dirname: &Path) -> Result<File, Error> {
-        self.open_mode(dirname, READ, io::USER_FILE, OpenDir)
+        self.open_mode(dirname, READ, io::USER_FILE, OpenType::Dir)
     }
 
     /// Convenience function to read the files in a directory.