Reformat source code

Author: wiktor-k

examples/key_storage.rs

@@ -1,87 +1,84 @@
 use log::info;
 
-use ssh_agent::proto::{from_bytes, to_bytes};
+use ssh_agent::agent::Agent;
 use ssh_agent::proto::message::{self, Message, SignRequest};
-use ssh_agent::proto::signature::{self, Signature};
-use ssh_agent::proto::public_key::PublicKey;
 use ssh_agent::proto::private_key::{PrivateKey, RsaPrivateKey};
-use ssh_agent::agent::Agent;
+use ssh_agent::proto::public_key::PublicKey;
+use ssh_agent::proto::signature::{self, Signature};
+use ssh_agent::proto::{from_bytes, to_bytes};
 
-use std::sync::RwLock;
 use std::error::Error;
 use std::fs::remove_file;
+use std::sync::RwLock;
 
-use openssl::sign::Signer;
-use openssl::rsa::Rsa;
-use openssl::pkey::PKey;
-use openssl::hash::MessageDigest;
 use openssl::bn::BigNum;
+use openssl::hash::MessageDigest;
+use openssl::pkey::PKey;
 use openssl::pkey::Private;
+use openssl::rsa::Rsa;
+use openssl::sign::Signer;
 
 #[derive(Clone, PartialEq, Debug)]
 struct Identity {
     pubkey: PublicKey,
     privkey: PrivateKey,
-    comment: String
+    comment: String,
 }
 
 struct KeyStorage {
-    identities: RwLock<Vec<Identity>>
+    identities: RwLock<Vec<Identity>>,
 }
 
 impl KeyStorage {
     fn new() -> Self {
         Self {
-            identities: RwLock::new(vec![])
+            identities: RwLock::new(vec![]),
         }
     }
-    
-    fn identity_index_from_pubkey(
-        identities: &Vec<Identity>,
-        pubkey: &PublicKey
-    ) -> Option<usize> {
+
+    fn identity_index_from_pubkey(identities: &Vec<Identity>, pubkey: &PublicKey) -> Option<usize> {
         for (index, identity) in identities.iter().enumerate() {
             if &identity.pubkey == pubkey {
                 return Some(index);
             }
         }
         return None;
     }
-    
+
     fn identity_from_pubkey(&self, pubkey: &PublicKey) -> Option<Identity> {
         let identities = self.identities.read().unwrap();
-        
+
         let index = Self::identity_index_from_pubkey(&identities, pubkey)?;
         Some(identities[index].clone())
     }
-    
+
     fn identity_add(&self, identity: Identity) {
         let mut identities = self.identities.write().unwrap();
         if Self::identity_index_from_pubkey(&identities, &identity.pubkey) == None {
             identities.push(identity);
         }
     }
-    
+
     fn identity_remove(&self, pubkey: &PublicKey) -> Result<(), Box<dyn Error>> {
         let mut identities = self.identities.write().unwrap();
-        
+
         if let Some(index) = Self::identity_index_from_pubkey(&identities, &pubkey) {
             identities.remove(index);
             Ok(())
         } else {
             Err(From::from("Failed to remove identity: identity not found"))
         }
     }
-    
+
     fn sign(&self, sign_request: &SignRequest) -> Result<Signature, Box<dyn Error>> {
         let pubkey: PublicKey = from_bytes(&sign_request.pubkey_blob)?;
-        
+
         if let Some(identity) = self.identity_from_pubkey(&pubkey) {
             match identity.privkey {
                 PrivateKey::Rsa(ref key) => {
                     let algorithm;
                     let digest;
-                    
+
                     if sign_request.flags & signature::RSA_SHA2_512 != 0 {
                         algorithm = "rsa-sha2-512";
                         digest = MessageDigest::sha512();
@@ -92,54 +89,54 @@ impl KeyStorage {
                         algorithm = "ssh-rsa";
                         digest = MessageDigest::sha1();
                     }
-                    
+
                     let keypair = PKey::from_rsa(rsa_openssl_from_ssh(key)?)?;
                     let mut signer = Signer::new(digest, &keypair)?;
                     signer.update(&sign_request.data)?;
-                    
+
                     Ok(Signature {
                         algorithm: algorithm.to_string(),
-                        blob: signer.sign_to_vec()?
+                        blob: signer.sign_to_vec()?,
                     })
-                },
-                _ => Err(From::from("Signature for key type not implemented"))
+                }
+                _ => Err(From::from("Signature for key type not implemented")),
             }
         } else {
             Err(From::from("Failed to create signature: identity not found"))
         }
     }
-    
-    fn handle_message(&self, request: Message) -> Result<Message, Box<dyn Error>>  {
+
+    fn handle_message(&self, request: Message) -> Result<Message, Box<dyn Error>> {
         info!("Request: {:?}", request);
         let response = match request {
             Message::RequestIdentities => {
                 let mut identities = vec![];
                 for identity in self.identities.read().unwrap().iter() {
                     identities.push(message::Identity {
                         pubkey_blob: to_bytes(&identity.pubkey)?,
-                        comment: identity.comment.clone()
+                        comment: identity.comment.clone(),
                     })
                 }
                 Ok(Message::IdentitiesAnswer(identities))
-            },
+            }
             Message::RemoveIdentity(identity) => {
                 let pubkey: PublicKey = from_bytes(&identity.pubkey_blob)?;
                 self.identity_remove(&pubkey)?;
                 Ok(Message::Success)
-            },
+            }
             Message::AddIdentity(identity) => {
                 self.identity_add(Identity {
                     pubkey: PublicKey::from(&identity.privkey),
                     privkey: identity.privkey,
-                    comment: identity.comment
+                    comment: identity.comment,
                 });
                 Ok(Message::Success)
-            },
+            }
             Message::SignRequest(request) => {
                 let signature = to_bytes(&self.sign(&request)?)?;
                 Ok(Message::SignResponse(signature))
-            },
-            _ => Err(From::from(format!("Unknown message: {:?}", request)))
+            }
+            _ => Err(From::from(format!("Unknown message: {:?}", request))),
         };
         info!("Response {:?}", response);
         return response;
@@ -148,7 +145,7 @@ impl KeyStorage {
 
 impl Agent for KeyStorage {
     type Error = ();
-    
+
     fn handle(&self, message: Message) -> Result<Message, ()> {
         self.handle_message(message).or_else(|error| {
             println!("Error handling message - {:?}", error);
@@ -157,7 +154,6 @@ impl Agent for KeyStorage {
     }
 }
 
-
 fn rsa_openssl_from_ssh(ssh_rsa: &RsaPrivateKey) -> Result<Rsa<Private>, Box<dyn Error>> {
     let n = BigNum::from_slice(&ssh_rsa.n)?;
     let e = BigNum::from_slice(&ssh_rsa.e)?;
@@ -167,15 +163,15 @@ fn rsa_openssl_from_ssh(ssh_rsa: &RsaPrivateKey) -> Result<Rsa<Private>, Box<dyn
     let q = BigNum::from_slice(&ssh_rsa.q)?;
     let dp = &d % &(&p - &BigNum::from_u32(1)?);
     let dq = &d % &(&q - &BigNum::from_u32(1)?);
-    
+
     Ok(Rsa::from_private_components(n, e, d, p, q, dp, dq, qi)?)
 }
 
 fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let agent = KeyStorage::new();
     let socket = "connect.sock";
     let _ = remove_file(socket);
-    
+
     env_logger::init();
     agent.run_unix(socket)?;
     Ok(())

src/agent.rs

@@ -1,8 +1,8 @@
 use byteorder::{BigEndian, ReadBytesExt};
-use bytes::{BytesMut, BufMut};
+use bytes::{BufMut, BytesMut};
 use futures::future::FutureResult;
 use log::{error, info};
-use tokio::codec::{Framed, Encoder, Decoder};
+use tokio::codec::{Decoder, Encoder, Framed};
 use tokio::net::TcpListener;
 use tokio::prelude::*;
 use tokio_uds::UnixListener;
@@ -23,20 +23,20 @@ struct MessageCodec;
 impl Decoder for MessageCodec {
     type Item = Message;
     type Error = AgentError;
-    
+
     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
         let mut bytes = &src[..];
-        
+
         if bytes.len() < size_of::<u32>() {
             return Ok(None);
         }
-        
+
         let length = bytes.read_u32::<BigEndian>()? as usize;
-        
+
         if bytes.len() < length {
             return Ok(None);
         }
-        
+
         let message: Message = from_bytes(bytes)?;
         src.advance(size_of::<u32>() + length);
         Ok(Some(message))
@@ -46,7 +46,7 @@ impl Decoder for MessageCodec {
 impl Encoder for MessageCodec {
     type Item = Message;
     type Error = AgentError;
-    
+
     fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
         let bytes = to_bytes(&to_bytes(&item)?)?;
         dst.put(bytes);
@@ -58,35 +58,39 @@ macro_rules! handle_clients {
     ($self:ident, $socket:ident) => {{
         info!("Listening; socket = {:?}", $socket);
         let arc_self = Arc::new($self);
-        $socket.incoming()
+        $socket
+            .incoming()
             .map_err(|e| error!("Failed to accept socket; error = {:?}", e))
             .for_each(move |socket| {
                 let (write, read) = Framed::new(socket, MessageCodec).split();
                 let arc_self = arc_self.clone();
-                let connection = write.send_all(read.and_then(move |message| {
-                    arc_self.handle_async(message).map_err(|e| {
-                        error!("Error handling message; error = {:?}", e);
-                        AgentError::User
-                    })
-                })).map(|_| ())
-                   .map_err(|e| error!("Error while handling message; error = {:?}", e));
+                let connection = write
+                    .send_all(read.and_then(move |message| {
+                        arc_self.handle_async(message).map_err(|e| {
+                            error!("Error handling message; error = {:?}", e);
+                            AgentError::User
+                        })
+                    }))
+                    .map(|_| ())
+                    .map_err(|e| error!("Error while handling message; error = {:?}", e));
                 tokio::spawn(connection)
-            }).map_err(|e| e.into())
+            })
+            .map_err(|e| e.into())
     }};
 }
 
 pub trait Agent: 'static + Sync + Send + Sized {
     type Error: Debug + Send + Sync;
-    
+
     fn handle(&self, message: Message) -> Result<Message, Self::Error>;
-    
+
     fn handle_async(
         &self,
-        message: Message
+        message: Message,
     ) -> Box<dyn Future<Item = Message, Error = Self::Error> + Send + Sync> {
         Box::new(FutureResult::from(self.handle(message)))
     }
-    
+
     fn run_listener(self, socket: UnixListener) -> Result<(), Box<dyn Error + Send + Sync>> {
         Ok(tokio::run(handle_clients!(self, socket)))
     }

src/error.rs

@@ -1,11 +1,11 @@
-use std::io;
 use super::proto::error::ProtoError;
+use std::io;
 
 #[derive(Debug)]
 pub enum AgentError {
     User,
     Proto(ProtoError),
-    IO(io::Error)
+    IO(io::Error),
 }
 
 impl From<ProtoError> for AgentError {
@@ -18,4 +18,4 @@ impl From<io::Error> for AgentError {
     fn from(e: io::Error) -> AgentError {
         AgentError::IO(e)
     }
-}
+}