Run cargo fmt

.travis.yml

@@ -1,5 +1,27 @@
+sudo: false
 language: rust
 rust:
   - stable
   - beta
   - nightly
+cache: cargo
+addons:
+  apt:
+    packages:
+      - libcurl4-openssl-dev
+      - libelf-dev
+      - libdw-dev
+before_script:
+  - |
+    pip install 'travis-cargo<0.2' --user &&
+    export PATH=$HOME/.local/bin:/usr/local/bin:$PATH
+  - export PATH="$PATH:$HOME/.cargo/bin"
+  - which rustfmt || cargo install rustfmt
+script:
+  - cargo fmt -- --write-mode=diff
+  - travis-cargo build
+  - travis-cargo test
+  - travis-cargo --only stable doc
+after_success:
+  - travis-cargo --only stable doc-upload
+  - travis-cargo coveralls --no-sudo --verify

src/algorithm.rs

@@ -1,8 +1,9 @@
-use std::str::FromStr;
 use std::fmt;
+use std::str::FromStr;
 
 /// Slice of implemented key exchange algorithms, ordered by preference
-pub static KEY_EXCHANGE: &[KeyExchangeAlgorithm] = &[
+pub static KEY_EXCHANGE: &[KeyExchangeAlgorithm] =
+    &[
     KeyExchangeAlgorithm::CURVE25519_SHA256,
 //  KeyExchangeAlgorithm::DH_GROUP_EXCHANGE_SHA1,
 ];
@@ -14,7 +15,8 @@ pub static HOST_KEY: &[PublicKeyAlgorithm] = &[
 ];
 
 /// Slice of implemented encryption algorithms, ordered by preference
-pub static ENCRYPTION: &[EncryptionAlgorithm] = &[EncryptionAlgorithm::AES256_CTR];
+pub static ENCRYPTION: &[EncryptionAlgorithm] =
+    &[EncryptionAlgorithm::AES256_CTR];
 
 /// Slice of implemented MAC algorithms, ordered by preference
 pub static MAC: &[MacAlgorithm] = &[MacAlgorithm::HMAC_SHA2_512];
@@ -54,12 +56,15 @@ impl FromStr for KeyExchangeAlgorithm {
     type Err = ();
     fn from_str(s: &str) -> Result<KeyExchangeAlgorithm, ()> {
         use self::KeyExchangeAlgorithm::*;
-        match s {
+        match s
+        {
             "curve25519-sha256" => Ok(CURVE25519_SHA256),
             "ecdh-sha2-nistp256" => Ok(ECDH_SHA2_NISTP256),
             "ecdh-sha2-nistp384" => Ok(ECDH_SHA2_NISTP384),
             "ecdh-sha2-nistp521" => Ok(ECDH_SHA2_NISTP521),
-            "diffie-hellman-group-exchange-sha256" => Ok(DH_GROUP_EXCHANGE_SHA256),
+            "diffie-hellman-group-exchange-sha256" => Ok(
+                DH_GROUP_EXCHANGE_SHA256,
+            ),
             "diffie-hellman-group-exchange-sha1" => Ok(DH_GROUP_EXCHANGE_SHA1),
             "diffie-hellman-group16-sha512" => Ok(DH_GROUP16_SHA512),
             "diffie-hellman-group18-sha512" => Ok(DH_GROUP18_SHA512),
@@ -77,7 +82,8 @@ impl FromStr for KeyExchangeAlgorithm {
 impl fmt::Display for KeyExchangeAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::KeyExchangeAlgorithm::*;
-        f.write_str(match self {
+        f.write_str(match self
+        {
             &CURVE25519_SHA256 => "curve25519-sha256",
             &ECDH_SHA2_NISTP256 => "ecdh-sha2-nistp256",
             &ECDH_SHA2_NISTP384 => "ecdh-sha2-nistp384",
@@ -109,7 +115,8 @@ impl FromStr for PublicKeyAlgorithm {
     type Err = ();
     fn from_str(s: &str) -> Result<PublicKeyAlgorithm, ()> {
         use self::PublicKeyAlgorithm::*;
-        match s {
+        match s
+        {
             "ssh-rsa" => Ok(SSH_RSA),
             "rsa-sha2-256" => Ok(RSA_SHA2_256),
             "rsa-sha2-512" => Ok(RSA_SHA2_512),
@@ -128,7 +135,8 @@ impl FromStr for PublicKeyAlgorithm {
 impl fmt::Display for PublicKeyAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::PublicKeyAlgorithm::*;
-        f.write_str(match self {
+        f.write_str(match self
+        {
             &SSH_RSA => "ssh-rsa",
             &RSA_SHA2_256 => "rsa-sha2-256",
             &RSA_SHA2_512 => "rsa-sha2-512",
@@ -156,7 +164,8 @@ impl FromStr for EncryptionAlgorithm {
     type Err = ();
     fn from_str(s: &str) -> Result<EncryptionAlgorithm, ()> {
         use self::EncryptionAlgorithm::*;
-        match s {
+        match s
+        {
             "aes128-ctr" => Ok(AES128_CTR),
             "aes128-cbc" => Ok(AES128_CBC),
             "aes192-ctr" => Ok(AES192_CTR),
@@ -175,7 +184,8 @@ impl FromStr for EncryptionAlgorithm {
 impl fmt::Display for EncryptionAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::EncryptionAlgorithm::*;
-        f.write_str(match self {
+        f.write_str(match self
+        {
             &AES128_CTR => "aes128-ctr",
             &AES128_CBC => "aes128-cbc",
             &AES192_CTR => "aes192-ctr",
@@ -200,7 +210,8 @@ impl FromStr for MacAlgorithm {
     type Err = ();
     fn from_str(s: &str) -> Result<MacAlgorithm, ()> {
         use self::MacAlgorithm::*;
-        match s {
+        match s
+        {
             "hmac-sha1" => Ok(MacAlgorithm::HMAC_SHA1),
             "hmac-sha2-256" => Ok(MacAlgorithm::HMAC_SHA2_256),
             "hmac-sha2-512" => Ok(MacAlgorithm::HMAC_SHA2_512),
@@ -215,7 +226,8 @@ impl FromStr for MacAlgorithm {
 impl fmt::Display for MacAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::MacAlgorithm::*;
-        f.write_str(match self {
+        f.write_str(match self
+        {
             &HMAC_SHA1 => "hmac-sha1",
             &HMAC_SHA2_256 => "hmac-sha2-256",
             &HMAC_SHA2_512 => "hmac-sha2-512",
@@ -233,7 +245,8 @@ pub enum CompressionAlgorithm {
 impl FromStr for CompressionAlgorithm {
     type Err = ();
     fn from_str(s: &str) -> Result<CompressionAlgorithm, ()> {
-        match s {
+        match s
+        {
             "zlib" => Ok(CompressionAlgorithm::Zlib),
             "none" => Ok(CompressionAlgorithm::None),
             _ => {
@@ -246,7 +259,8 @@ impl FromStr for CompressionAlgorithm {
 
 impl fmt::Display for CompressionAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match self {
+        f.write_str(match self
+        {
             &CompressionAlgorithm::Zlib => "zlib",
             &CompressionAlgorithm::None => "none",
         })

src/bin/ssh-keygen.rs

@@ -1,6 +1,6 @@
 extern crate ssh;
-use std::io::prelude::*;
 use std::fs::File;
+use std::io::prelude::*;
 
 use ssh::public_key;
 

src/key_exchange/dh_group_sha1.rs

@@ -32,14 +32,15 @@ impl DhGroupSha1 {
         DhGroupSha1 {
             g: None,
             p: None,
-            e: None
+            e: None,
         }
     }
 }
 
 impl KeyExchange for DhGroupSha1 {
     fn process(&mut self, packet: &Packet) -> KeyExchangeResult {
-        match packet.msg_type() {
+        match packet.msg_type()
+        {
             MessageType::KeyExchange(DH_GEX_REQUEST) => {
                 let mut reader = packet.reader();
                 let min = reader.read_uint32().unwrap();
@@ -52,7 +53,8 @@ impl KeyExchange for DhGroupSha1 {
                 let g = rng.gen_biguint(opt as usize).to_bigint().unwrap();
                 let p = rng.gen_biguint(opt as usize).to_bigint().unwrap();
 
-                let mut packet = Packet::new(MessageType::KeyExchange(DH_GEX_GROUP));
+                let mut packet =
+                    Packet::new(MessageType::KeyExchange(DH_GEX_GROUP));
                 packet.with_writer(&|w| {
                     w.write_mpint(g.clone())?;
                     w.write_mpint(p.clone())?;
@@ -63,14 +65,15 @@ impl KeyExchange for DhGroupSha1 {
                 self.p = Some(p);
 
                 KeyExchangeResult::Ok(Some(packet))
-            },
+            }
             MessageType::KeyExchange(DH_GEX_INIT) => {
                 let mut reader = packet.reader();
                 let e = reader.read_mpint().unwrap();
 
                 println!("Received e: {:?}", e);
 
-                let mut packet = Packet::new(MessageType::KeyExchange(DH_GEX_REPLY));
+                let mut packet =
+                    Packet::new(MessageType::KeyExchange(DH_GEX_REPLY));
                 packet.with_writer(&|w| {
                     w.write_string("HELLO WORLD")?;
                     w.write_mpint(e.clone())?;
@@ -81,7 +84,7 @@ impl KeyExchange for DhGroupSha1 {
                 self.e = Some(e);
 
                 KeyExchangeResult::Ok(Some(packet))
-            },
+            }
             _ => {
                 debug!("Unhandled key exchange packet: {:?}", packet);
                 KeyExchangeResult::Error(None)

src/key_exchange/mod.rs

@@ -9,7 +9,7 @@ use packet::Packet;
 pub enum KeyExchangeResult {
     Ok(Option<Packet>),
     Done(Option<Packet>),
-    Error(Option<Packet>)
+    Error(Option<Packet>),
 }
 
 pub trait KeyExchange {

src/message.rs

@@ -30,13 +30,14 @@ pub enum MessageType {
     ChannelRequest,
     ChannelSuccess,
     ChannelFailure,
-    Unknown
+    Unknown,
 }
 
 impl From<u8> for MessageType {
     fn from(id: u8) -> Self {
         use self::MessageType::*;
-        match id {
+        match id
+        {
             1 => Disconnect,
             2 => Ignore,
             3 => Unimplemented,
@@ -65,7 +66,7 @@ impl From<u8> for MessageType {
             98 => ChannelRequest,
             99 => ChannelSuccess,
             100 => ChannelFailure,
-            _ => Unknown
+            _ => Unknown,
         }
     }
 }
@@ -73,7 +74,8 @@ impl From<u8> for MessageType {
 impl Into<u8> for MessageType {
     fn into(self) -> u8 {
         use self::MessageType::*;
-        match self {
+        match self
+        {
             Disconnect => 1,
             Ignore => 2,
             Unimplemented => 3,
@@ -102,7 +104,7 @@ impl Into<u8> for MessageType {
             ChannelRequest => 98,
             ChannelSuccess => 99,
             ChannelFailure => 100,
-            Unknown => 255
+            Unknown => 255,
         }
     }
 }

src/packet.rs

@@ -1,13 +1,15 @@
 use std::fmt;
+use std::io::{self, BufReader, Read, Result, Write};
 use std::str::{self, FromStr};
 use std::string::ToString;
-use std::io::{self, BufReader, Write, Read, Result};
+
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+
 use message::MessageType;
-use byteorder::{ReadBytesExt, WriteBytesExt, BigEndian};
 use num_bigint::BigInt;
 
 pub struct Packet {
-    payload: Vec<u8>
+    payload: Vec<u8>,
 }
 
 impl Packet {
@@ -30,14 +32,14 @@ impl Packet {
 
         let mut payload = Vec::with_capacity(payload_len);
         let mut padding = Vec::with_capacity(padding_len);
-//        let mut mac = Vec::with_capacity(mac_len);
+        // let mut mac = Vec::with_capacity(mac_len);
 
         stream.take(payload_len as u64).read_to_end(&mut payload)?;
         stream.take(padding_len as u64).read_to_end(&mut padding)?;
 
-//        if mac_len > 0 {
+        // if mac_len > 0 {
-//            stream.take(mac_len as u64).read_to_end(&mut mac);
+        //     stream.take(mac_len as u64).read_to_end(&mut mac);
-//        }
+        // }
 
         Ok(Packet { payload: payload })
     }
@@ -49,7 +51,7 @@ impl Packet {
         stream.write_u32::<BigEndian>(packet_len as u32)?;
         stream.write_u8(padding_len as u8)?;
         stream.write(&self.payload)?;
-        stream.write(&[0u8;255][..padding_len])?;
+        stream.write(&[0u8; 255][..padding_len])?;
 
         Ok(())
     }
@@ -58,7 +60,10 @@ impl Packet {
         &mut self.payload
     }
 
-    pub fn with_writer(&mut self, f: &Fn(&mut Write) -> Result<()>) -> Result<()> {
+    pub fn with_writer(
+        &mut self,
+        f: &Fn(&mut Write) -> Result<()>,
+    ) -> Result<()> {
         f(&mut self.payload)
     }
 
@@ -71,8 +76,12 @@ impl Packet {
         let padding_len = 8 - ((self.payload.len() + 5) % 8);
 
         // The padding has to be at least 4 bytes long
-        if padding_len < 4 { padding_len + 8 }
+        if padding_len < 4 {
-        else { padding_len }
+            padding_len + 8
+        }
+        else {
+            padding_len
+        }
     }
 }
 
@@ -99,7 +108,11 @@ pub trait ReadPacketExt: ReadBytesExt {
     }
 
     fn read_utf8(&mut self) -> Result<String> {
-       Ok(str::from_utf8(self.read_string()?.as_slice()).unwrap_or("").to_owned())
+        Ok(
+            str::from_utf8(self.read_string()?.as_slice())
+                .unwrap_or("")
+                .to_owned(),
+        )
     }
 
     fn read_bool(&mut self) -> Result<bool> {
@@ -108,7 +121,12 @@ pub trait ReadPacketExt: ReadBytesExt {
 
     fn read_enum_list<T: FromStr>(&mut self) -> Result<Vec<T>> {
         let string = self.read_utf8()?;
-        Ok(string.split(",").filter_map(|l| T::from_str(&l).ok()).collect())
+        Ok(
+            string
+                .split(",")
+                .filter_map(|l| T::from_str(&l).ok())
+                .collect(),
+        )
     }
 
     fn read_name_list(&mut self) -> Result<Vec<String>> {
@@ -161,7 +179,7 @@ pub trait WritePacketExt: WriteBytesExt {
             }
             string += &*item.to_string();
         }
-       self.write_string(&*string)
+        self.write_string(&*string)
     }
 }
 
@@ -169,6 +187,11 @@ impl<R: WriteBytesExt + ?Sized> WritePacketExt for R {}
 
 impl fmt::Debug for Packet {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Packet({:?}, {} bytes)", self.msg_type(), self.payload.len())
+        write!(
+            f,
+            "Packet({:?}, {} bytes)",
+            self.msg_type(),
+            self.payload.len()
+        )
     }
 }

src/public_key/ed25519.rs

@@ -1,8 +1,9 @@
-use public_key::{KeyPair, CryptoSystem};
 use std::io::{self, Read, Write};
 use std::io::ErrorKind::InvalidData;
-use rand::{self, Rng};
+
 use crypto::ed25519;
+use public_key::{CryptoSystem, KeyPair};
+use rand::{self, Rng};
 
 pub static ED25519: CryptoSystem = CryptoSystem {
     id: "ed25519",
@@ -90,7 +91,8 @@ impl KeyPair for Ed25519KeyPair {
         if let Some(private_key) = self.private {
             let signature = ed25519::signature(data, &private_key);
             Ok(signature.to_vec())
-        } else {
+        }
+        else {
             Err(())
         }
     }

src/public_key/mod.rs

@@ -1,9 +1,10 @@
 use std::io::{self, Read, Write};
 
-//mod rsa;
+// mod rsa;
 mod ed25519;
 
-//pub use self::rsa::RSA;
+// pub use self::rsa::RSA;
+
 pub use self::ed25519::ED25519;
 
 pub trait KeyPair {
@@ -22,5 +23,5 @@ pub struct CryptoSystem {
     pub id: &'static str,
     pub generate_key_pair: fn(bits: Option<u32>) -> Box<KeyPair>,
     pub import: fn(r: &mut Read) -> io::Result<Box<KeyPair>>,
-    pub read_public: fn(r: &mut Read) -> io::Result<Box<KeyPair>>
+    pub read_public: fn(r: &mut Read) -> io::Result<Box<KeyPair>>,
 }

tests/public_key.rs

@@ -1,8 +1,9 @@
 extern crate ssh;
 extern crate rand;
 
-use rand::Rng;
 use std::io::Cursor;
+
+use rand::Rng;
 use ssh::public_key::{self, CryptoSystem, KeyPair};
 
 fn test_export_import(keypair: &Box<KeyPair>) -> Box<KeyPair> {
@@ -20,7 +21,7 @@ fn test_crypto_system(system: &CryptoSystem, key_size: Option<u32>) {
     let keypair2 = test_export_import(&keypair);
 
     // Generate a random message
-    let mut buffer = [0;4096];
+    let mut buffer = [0; 4096];
     let mut rng = rand::thread_rng();
     rng.fill_bytes(&mut buffer);
 
@@ -36,4 +37,6 @@ fn test_crypto_system(system: &CryptoSystem, key_size: Option<u32>) {
 }
 
 #[test]
-fn test_ed25519() { test_crypto_system(&public_key::ED25519, None); }
+fn test_ed25519() {
+    test_crypto_system(&public_key::ED25519, None);
+}