Version updates: getting rid of anyhow + moving to Tokio 1.0

Dependencies

• [2] MFMCIUMJ Fixing authentication with RSA
• [3] XEKZBXNI Fixing a bug with tokio::select
• [4] 2SFWWZ2R Rearm reading future on empty packet, and respond to server-initiated key re-exchange
• [5] HDEDMPBT Client example
• [6] 55M4M5YU Fake agent client on Windows
• [7] 432ETREA If tokio::select! returns an error, return it
• [8] DJT33BQE Version bump
• [9] BWU5BDAH Thrussh-keys 0.19.5
• [10] V3BRP7LQ Avoid polling the reading future again after disconnection
• [11] ELRPPXSG Fixing conflicts
• [12] LEYR5Q5G Typo in a documentation comment
• [13] LDEEJH5L Ignore key types instead of returning an error in the agent client
• [14] KNLLUDOI Correct usage of `tokio::select!`
• [15] TFYJ3P2A Version 0.30.8/0.19.4, and solving conflicts
• [16] E2SB74SV Version 0.30.3
• [17] SJBZKVM5 Debug messages
• [18] 634OYCNM Tokio 0.3
• [19] CQSPFH4H Version 0.30.4
• [20] ATANAS43 Fixing a test
• [21] 2Q2DF2RO Updating thrussh-config to make it usable in real projects
• [22] 7G5SGELG Compilation error on Windows
• [23] G3N4WNI6 Avoid polling the reading future again after disconnection
• [24] AEIVL6S4 Fixing key fingerprints for RSA keys
• [25] PDTFLA4Y Version 0.30.7
• [26] Y5HHIQXV Wait for the connection to be encrypted in `connect`
• [27] XCNFFN6Z Thrussh-keys, version 0.19.3
• [28] VYDCQWSF Version 0.30.6
• [29] 7FRJYUI6 Reboot because of a bad change
• [30] JBFDZQ46 Formatting
• [31] HYM2DGVE Making thrussh::client::connect_stream public, to handle ProxyCommand
• [32] QYSLQBP3 Feature-gating UDS in agent client
• [33] OGPWDWHU Compilation error on Windows
• [34] ORMM2ACM Update packets sent for password auth
• [35] F2FHFNIK Fixing the return value of session::data_noqueue

Change contents

• replacement in thrussh-keys/src/signature.rs at line 53
  [10.7540]→[10.7540:7606](∅→∅)
  − pub fn from_base64(s: &[u8]) -> Result<Self, anyhow::Error> {
  [10.7540]

  [10.7606]
  + pub fn from_base64(s: &[u8]) -> Result<Self, Error> {
• edit in thrussh-keys/src/lib.rs at line 117
  [10.27374]

  [10.27374]
  + #[error(transparent)]

  + IO(#[from] std::io::Error),

  + #[error(transparent)]

  + Openssl(#[from] openssl::error::ErrorStack),

  + #[error("Base64 decoding error: {0}")]

  + Decode(#[from] data_encoding::DecodeError),

  + #[error("ASN1 decoding error: {0}")]

  + ASN1(#[from] yasna::ASN1Error),

  + #[error("Environment variable not found")]

  + EnvVar(&'static str),
• replacement in thrussh-keys/src/lib.rs at line 137
  [10.27647]→[10.27647:27738](∅→∅)
  − pub fn load_public_key<P: AsRef<Path>>(path: P) -> Result<key::PublicKey, anyhow::Error> {
  [10.27647]

  [10.27738]
  + pub fn load_public_key<P: AsRef<Path>>(path: P) -> Result<key::PublicKey, Error> {
• replacement in thrussh-keys/src/lib.rs at line 157
  [10.28445]→[10.28445:28530](∅→∅)
  − pub fn parse_public_key_base64(key: &str) -> Result<key::PublicKey, anyhow::Error> {
  [10.28445]

  [10.28530]
  + pub fn parse_public_key_base64(key: &str) -> Result<key::PublicKey, Error> {
• replacement in thrussh-keys/src/lib.rs at line 221
  [10.30526]→[10.30526:30559](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.30526]

  [10.30559]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/lib.rs at line 233
  [10.30889]→[10.30889:30932](∅→∅)
  − ) -> Result<key::KeyPair, anyhow::Error> {
  [10.30889]

  [10.30932]
  + ) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/lib.rs at line 255
  [10.31490]→[10.31490:31523](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.31490]

  [10.31523]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/lib.rs at line 295
  [10.32561]→[10.32561:32596](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.32561]

  [10.32596]
  + ) -> Result<bool, Error> {
• replacement in thrussh-keys/src/lib.rs at line 359
  [10.34462]→[10.34462:34581](∅→∅)
  − pub fn learn_known_hosts(

  − host: &str,

  − port: u16,

  − pubkey: &key::PublicKey,

  − ) -> Result<(), anyhow::Error> {
  [10.34462]

  [10.34581]
  + pub fn learn_known_hosts(host: &str, port: u16, pubkey: &key::PublicKey) -> Result<(), Error> {
• replacement in thrussh-keys/src/lib.rs at line 387
  [10.35434]→[10.35434:35555](∅→∅)
  − pub fn check_known_hosts(

  − host: &str,

  − port: u16,

  − pubkey: &key::PublicKey,

  − ) -> Result<bool, anyhow::Error> {
  [10.35434]

  [10.35555]
  + pub fn check_known_hosts(host: &str, port: u16, pubkey: &key::PublicKey) -> Result<bool, Error> {
• replacement in thrussh-keys/src/key.rs at line 124
  [10.60967]→[10.60967:61045](∅→∅)
  − pub fn parse(algo: &[u8], pubkey: &[u8]) -> Result<Self, anyhow::Error> {
  [10.60967]

  [10.61045]
  + pub fn parse(algo: &[u8], pubkey: &[u8]) -> Result<Self, Error> {
• replacement in thrussh-keys/src/key.rs at line 304
  [10.66785]→[10.66785:66871](∅→∅)
  − pub fn sign_detached(&self, to_sign: &[u8]) -> Result<Signature, anyhow::Error> {
  [10.66785]

  [10.66871]
  + pub fn sign_detached(&self, to_sign: &[u8]) -> Result<Signature, Error> {
• replacement in thrussh-keys/src/key.rs at line 324
  [10.67580]→[10.67580:67617](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.67580]

  [10.67617]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/key.rs at line 349
  [10.68674]→[10.68674:68766](∅→∅)
  − pub fn add_self_signature(&self, buffer: &mut CryptoVec) -> Result<(), anyhow::Error> {
  [10.68674]

  [10.68766]
  + pub fn add_self_signature(&self, buffer: &mut CryptoVec) -> Result<(), Error> {
• replacement in thrussh-keys/src/key.rs at line 374
  [10.69720]→[10.69720:69758](∅→∅)
  − ) -> Result<Vec<u8>, anyhow::Error> {
  [10.69720]

  [10.69758]
  + ) -> Result<Vec<u8>, Error> {
• replacement in thrussh-keys/src/key.rs at line 394
  [10.70362]→[10.70362:70434](∅→∅)
  − pub fn parse_public_key(p: &[u8]) -> Result<PublicKey, anyhow::Error> {
  [10.70362]

  [10.70434]
  + pub fn parse_public_key(p: &[u8]) -> Result<PublicKey, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 24
  [10.72106]→[10.72106:72222](∅→∅)
  − pub fn decode_pkcs8(

  − ciphertext: &[u8],

  − password: Option<&[u8]>,

  − ) -> Result<key::KeyPair, anyhow::Error> {
  [10.72106]

  [10.72222]
  + pub fn decode_pkcs8(ciphertext: &[u8], password: Option<&[u8]>) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 137
  [10.76089]→[10.76089:76172](∅→∅)
  − fn read_key_v1(reader: &mut BERReaderSeq) -> Result<key::KeyPair, anyhow::Error> {
  [10.76089]

  [10.76172]
  + fn read_key_v1(reader: &mut BERReaderSeq) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 204
  [10.78532]→[10.78532:78615](∅→∅)
  − fn read_key_v0(reader: &mut BERReaderSeq) -> Result<key::KeyPair, anyhow::Error> {
  [10.78532]

  [10.78615]
  + fn read_key_v0(reader: &mut BERReaderSeq) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 212
  [10.78866]→[10.78866:78954](∅→∅)
  − let rsa: Result<Rsa<Private>, anyhow::Error> = yasna::parse_der(seq, |reader| {
  [10.78866]

  [10.78954]
  + let rsa: Result<Rsa<Private>, Error> = yasna::parse_der(seq, |reader| {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 219
  [10.79215]→[10.79215:79294](∅→∅)
  − let mut read_key = || -> Result<Rsa<Private>, anyhow::Error> {
  [10.79215]

  [10.79294]
  + let mut read_key = || -> Result<Rsa<Private>, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 264
  [10.81061]→[10.81061:81099](∅→∅)
  − ) -> Result<Vec<u8>, anyhow::Error> {
  [10.81061]

  [10.81099]
  + ) -> Result<Vec<u8>, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 354
  [10.83840]→[10.83840:83930](∅→∅)
  − fn decrypt(&self, password: &[u8], cipher: &[u8]) -> Result<Vec<u8>, anyhow::Error> {
  [10.83840]

  [10.83930]
  + fn decrypt(&self, password: &[u8], cipher: &[u8]) -> Result<Vec<u8>, Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 367
  [10.84227]→[10.84227:84312](∅→∅)
  − fn derive(&self, password: &[u8], key: &mut [u8]) -> Result<(), anyhow::Error> {
  [10.84227]

  [10.84312]
  + fn derive(&self, password: &[u8], key: &mut [u8]) -> Result<(), Error> {
• replacement in thrussh-keys/src/format/pkcs8.rs at line 411
  [10.85206]→[10.85206:85295](∅→∅)
  − fn decrypt(&self, key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>, anyhow::Error> {
  [10.85206]

  [10.85295]
  + fn decrypt(&self, key: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>, Error> {
• replacement in thrussh-keys/src/format/pkcs5.rs at line 14
  [10.86114]→[10.86114:86157](∅→∅)
  − ) -> Result<key::KeyPair, anyhow::Error> {
  [10.86114]

  [10.86157]
  + ) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/openssh.rs at line 11
  [10.87137]→[10.87137:87251](∅→∅)
  − pub fn decode_openssh(

  − secret: &[u8],

  − password: Option<&[u8]>,

  − ) -> Result<key::KeyPair, anyhow::Error> {
  [10.87137]

  [10.87251]
  + pub fn decode_openssh(secret: &[u8], password: Option<&[u8]>) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/openssh.rs at line 87
  [10.90314]→[10.90314:90352](∅→∅)
  − ) -> Result<Vec<u8>, anyhow::Error> {
  [10.90314]

  [10.90352]
  + ) -> Result<Vec<u8>, Error> {
• replacement in thrussh-keys/src/format/mod.rs at line 38
  [10.92736]→[10.92736:92852](∅→∅)
  − pub fn decode_secret_key(

  − secret: &str,

  − password: Option<&[u8]>,

  − ) -> Result<key::KeyPair, anyhow::Error> {
  [10.92736]

  [10.92852]
  + pub fn decode_secret_key(secret: &str, password: Option<&[u8]>) -> Result<key::KeyPair, Error> {
• replacement in thrussh-keys/src/format/mod.rs at line 90
  [10.94827]→[10.94827:94922](∅→∅)
  − pub fn encode_pkcs8_pem<W: Write>(key: &key::KeyPair, mut w: W) -> Result<(), anyhow::Error> {
  [10.94827]

  [10.94922]
  + pub fn encode_pkcs8_pem<W: Write>(key: &key::KeyPair, mut w: W) -> Result<(), Error> {
• replacement in thrussh-keys/src/format/mod.rs at line 103
  [10.95254]→[10.95254:95287](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.95254]

  [10.95287]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/format/mod.rs at line 111
  [10.95547]→[10.95547:95617](∅→∅)
  − fn decode_rsa(secret: &[u8]) -> Result<key::KeyPair, anyhow::Error> {
  [10.95547]

  [10.95617]
  + fn decode_rsa(secret: &[u8]) -> Result<key::KeyPair, Error> {
• edit in thrussh-keys/src/agent/server.rs at line 7
  [10.125430]

  [10.125430]
  + use futures::stream::{Stream, StreamExt};
• edit in thrussh-keys/src/agent/server.rs at line 15
  [10.125632]→[10.125632:125672](∅→∅)
  − use tokio::stream::{Stream, StreamExt};
• replacement in thrussh-keys/src/agent/server.rs at line 88
  [10.127520]→[10.127520:127578](∅→∅)
  − async fn run(mut self) -> Result<(), anyhow::Error> {
  [10.127520]

  [10.127578]
  + async fn run(mut self) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 108
  [10.128213]→[10.128213:128302](∅→∅)
  − async fn respond(&mut self, writebuf: &mut CryptoVec) -> Result<(), anyhow::Error> {
  [10.128213]

  [10.128302]
  + async fn respond(&mut self, writebuf: &mut CryptoVec) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 201
  [10.131494]→[10.131494:131561](∅→∅)
  − fn lock(&self, mut r: Position) -> Result<(), anyhow::Error> {
  [10.131494]

  [10.131561]
  + fn lock(&self, mut r: Position) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 208
  [10.131708]→[10.131708:131779](∅→∅)
  − fn unlock(&self, mut r: Position) -> Result<bool, anyhow::Error> {
  [10.131708]

  [10.131779]
  + fn unlock(&self, mut r: Position) -> Result<bool, Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 219
  [10.132012]→[10.132012:132092](∅→∅)
  − fn remove_identity(&self, mut r: Position) -> Result<bool, anyhow::Error> {
  [10.132012]

  [10.132092]
  + fn remove_identity(&self, mut r: Position) -> Result<bool, Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 236
  [10.132474]→[10.132474:132513](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.132474]

  [10.132513]
  + ) -> Result<bool, Error> {
• replacement in thrussh-keys/src/agent/server.rs at line 347
  [10.136832]→[10.136832:136876](∅→∅)
  − ) -> Result<(A, bool), anyhow::Error> {
  [10.136832]

  [10.136876]
  + ) -> Result<(A, bool), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 34
  [10.140067]→[10.140067:140165](∅→∅)
  − pub async fn connect_uds<P: AsRef<std::path::Path>>(path: P) -> Result<Self, anyhow::Error> {
  [10.140067]

  [10.140165]
  + pub async fn connect_uds<P: AsRef<std::path::Path>>(path: P) -> Result<Self, Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 44
  [10.140456]→[10.140456:140571](∅→∅)
  − pub async fn connect_env() -> Result<Self, anyhow::Error> {

  − let var = std::env::var("SSH_AUTH_SOCK")?;
  [10.140456]

  [10.140571]
  + pub async fn connect_env() -> Result<Self, Error> {

  + let var = if let Ok(var) = std::env::var("SSH_AUTH_SOCK") {

  + var

  + } else {

  + return Err(Error::EnvVar("SSH_AUTH_SOCK"));

  + };
• replacement in thrussh-keys/src/agent/client.rs at line 58
  [6.187]→[6.187:291](∅→∅)
  − pub async fn connect_env() -> Result<Self, anyhow::Error> {

  − Err(Error::AgentFailure.into())
  [6.187]

  [6.291]
  + pub async fn connect_env() -> Result<Self, Error> {

  + Err(Error::AgentFailure)
• replacement in thrussh-keys/src/agent/client.rs at line 64
  [10.140674]→[10.140674:140743](∅→∅)
  − async fn read_response(&mut self) -> Result<(), anyhow::Error> {
  [10.140674]

  [10.140743]
  + async fn read_response(&mut self) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 89
  [10.141470]→[10.141470:141507](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.141470]

  [10.141507]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 158
  [10.144288]→[10.144288:144325](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.144288]

  [10.144325]
  + ) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 195
  [10.145709]→[10.145709:145792](∅→∅)
  − pub async fn lock(&mut self, passphrase: &[u8]) -> Result<(), anyhow::Error> {
  [10.145709]

  [10.145792]
  + pub async fn lock(&mut self, passphrase: &[u8]) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 207
  [10.146140]→[10.146140:146225](∅→∅)
  − pub async fn unlock(&mut self, passphrase: &[u8]) -> Result<(), anyhow::Error> {
  [10.146140]

  [10.146225]
  + pub async fn unlock(&mut self, passphrase: &[u8]) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 220
  [10.146604]→[10.146604:146694](∅→∅)
  − pub async fn request_identities(&mut self) -> Result<Vec<PublicKey>, anyhow::Error> {
  [10.146604]

  [10.146694]
  + pub async fn request_identities(&mut self) -> Result<Vec<PublicKey>, Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 274
  [10.148687]→[10.148687:148770](∅→∅)
  − ) -> impl futures::Future<Output = (Self, Result<CryptoVec, anyhow::Error>)> {
  [10.148687]

  [10.148770]
  + ) -> impl futures::Future<Output = (Self, Result<CryptoVec, Error>)> {
• replacement in thrussh-keys/src/agent/client.rs at line 320
  [10.150344]→[10.150344:150438](∅→∅)
  − fn write_signature(&self, hash: u32, data: &mut CryptoVec) -> Result<(), anyhow::Error> {
  [10.150344]

  [10.150438]
  + fn write_signature(&self, hash: u32, data: &mut CryptoVec) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 338
  [10.151048]→[10.151048:151128](∅→∅)
  − ) -> impl futures::Future<Output = (Self, Result<String, anyhow::Error>)> {
  [10.151048]

  [10.151128]
  + ) -> impl futures::Future<Output = (Self, Result<String, Error>)> {
• replacement in thrussh-keys/src/agent/client.rs at line 361
  [10.151859]→[10.151859:151964](∅→∅)
  − ) -> impl futures::Future<Output = Result<(Self, crate::signature::Signature), anyhow::Error>>

  − {
  [10.151859]

  [10.151964]
  + ) -> impl futures::Future<Output = Result<(Self, crate::signature::Signature), Error>> {
• replacement in thrussh-keys/src/agent/client.rs at line 368
  [10.152195]→[10.152195:152275](∅→∅)
  − let sig: Result<crate::signature::Signature, anyhow::Error> = {
  [10.152195]

  [10.152275]
  + let sig: Result<crate::signature::Signature, Error> = {
• replacement in thrussh-keys/src/agent/client.rs at line 404
  [10.153772]→[10.153772:153872](∅→∅)
  − pub async fn remove_identity(&mut self, public: &key::PublicKey) -> Result<(), anyhow::Error> {
  [10.153772]

  [10.153872]
  + pub async fn remove_identity(&mut self, public: &key::PublicKey) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 416
  [10.154232]→[10.154232:154365](∅→∅)
  − pub async fn remove_smartcard_key(

  − &mut self,

  − id: &str,

  − pin: &[u8],

  − ) -> Result<(), anyhow::Error> {
  [10.154232]

  [10.154365]
  + pub async fn remove_smartcard_key(&mut self, id: &str, pin: &[u8]) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 429
  [10.154768]→[10.154768:154849](∅→∅)
  − pub async fn remove_all_identities(&mut self) -> Result<(), anyhow::Error> {
  [10.154768]

  [10.154849]
  + pub async fn remove_all_identities(&mut self) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 439
  [10.155110]→[10.155110:155203](∅→∅)
  − pub async fn extension(&mut self, typ: &[u8], ext: &[u8]) -> Result<(), anyhow::Error> {
  [10.155110]

  [10.155203]
  + pub async fn extension(&mut self, typ: &[u8], ext: &[u8]) -> Result<(), Error> {
• replacement in thrussh-keys/src/agent/client.rs at line 452
  [10.155603]→[10.155603:155743](∅→∅)
  − pub async fn query_extension(

  − &mut self,

  − typ: &[u8],

  − mut ext: CryptoVec,

  − ) -> Result<bool, anyhow::Error> {
  [10.155603]

  [10.155743]
  + pub async fn query_extension(&mut self, typ: &[u8], mut ext: CryptoVec) -> Result<bool, Error> {
• replacement in thrussh-keys/Cargo.toml at line 3
  [10.157057]→[9.0:19](∅→∅)
  − version = "0.19.5"
  [10.157057]

  [10.157076]
  + version = "0.20.1"
• replacement in thrussh-keys/Cargo.toml at line 32
  [10.157754]→[10.157754:157776](∅→∅)
  − data-encoding = "2.1"
  [10.157754]

  [10.157776]
  + data-encoding = "2.3"
• replacement in thrussh-keys/Cargo.toml at line 34
  [10.157794]→[10.120:218](∅→∅)
  − tokio = { version = "0.3", features = [ "io-util", "rt-multi-thread", "time", "net", "stream" ] }
  [10.157794]

  [10.157888]
  + tokio = { version = "1.0", features = [ "io-util", "rt-multi-thread", "time", "net" ] }
• replacement in thrussh-keys/Cargo.toml at line 37
  [10.157924]→[10.157924:157994](∅→∅)
  − yasna = { version = "0.3.1", features = [ "bit-vec", "num-bigint" ] }
  [10.157924]

  [10.157994]
  + yasna = { version = "0.3.2", features = [ "bit-vec", "num-bigint" ] }
• replacement in thrussh-keys/Cargo.toml at line 45
  [10.158129]→[10.158129:158142](∅→∅)
  − dirs = "2.0"
  [10.158129]

  [10.158142]
  + dirs = "3.0"
• edit in thrussh-keys/Cargo.toml at line 47
  [10.158154]→[10.158154:158169](∅→∅)
  − anyhow = "1.0"
• replacement in thrussh-config/src/lib.rs at line 1
  [10.161114]→[10.161115:161204](∅→∅)
  − extern crate regex;

  − #[macro_use]

  − extern crate log;

  − #[macro_use]

  − extern crate thiserror;

  −
  [10.161114]

  [10.161204]
  + use log::debug;
• edit in thrussh-config/src/lib.rs at line 5
  [10.141]

  [10.161244]
  + use thiserror::*;
• replacement in thrussh-config/Cargo.toml at line 4
  [10.164932]→[10.164932:164950](∅→∅)
  − version = "0.2.1"
  [10.164932]

  [10.164950]
  + version = "0.5.0"
• edit in thrussh-config/Cargo.toml at line 13
  [10.165217]→[10.165217:165251](∅→∅)
  − regex = "1.0"

  − lazy_static = "1.0"
• replacement in thrussh-config/Cargo.toml at line 15
  [10.165281]→[10.662:742](∅→∅)
  − tokio = { version = "0.3", features = [ "io-util", "net" ] }

  − thrussh = "0.30.2"
  [10.165281]

  [10.165354]
  + tokio = { version = "1.0", features = [ "io-util", "net", "macros" ] }
• replacement in thrussh-config/Cargo.toml at line 17
  [10.165370]→[10.165370:165386](∅→∅)
  − thiserror = "*"
  [10.165370]
  + thiserror = "1.0"

  + whoami = "1.0"
• replacement in thrussh/src/ssh_read.rs at line 113
  [10.169710]→[10.169710:169784](∅→∅)
  − pub async fn read_ssh_id(&mut self) -> Result<&[u8], anyhow::Error> {
  [10.169710]

  [10.169784]
  + pub async fn read_ssh_id(&mut self) -> Result<&[u8], Error> {
• replacement in thrussh/src/session.rs at line 463
  [10.187287]→[10.187287:187329](∅→∅)
  − ) -> Result<NewKeys, anyhow::Error> {
  [10.187287]

  [10.187329]
  + ) -> Result<NewKeys, crate::Error> {
• replacement in thrussh/src/server/session.rs at line 144
  [10.192535]→[10.192535:192594](∅→∅)
  − pub fn flush(&mut self) -> Result<(), anyhow::Error> {
  [10.192535]

  [10.192594]
  + pub fn flush(&mut self) -> Result<(), Error> {
• edit in thrussh/src/server/mod.rs at line 21
  [10.204077]→[10.204077:204112](∅→∅)
  − use futures::stream::TryStreamExt;
• edit in thrussh/src/server/mod.rs at line 134
  [10.207704]

  [10.207704]
  + type Error: From<crate::Error> + Send;
• replacement in thrussh/src/server/mod.rs at line 137
  [10.207795]→[10.207795:207877](∅→∅)
  − type FutureAuth: Future<Output = Result<(Self, Auth), anyhow::Error>> + Send;
  [10.207795]

  [10.207877]
  + type FutureAuth: Future<Output = Result<(Self, Auth), Self::Error>> + Send;
• replacement in thrussh/src/server/mod.rs at line 140
  [10.207944]→[10.207944:208029](∅→∅)
  − type FutureUnit: Future<Output = Result<(Self, Session), anyhow::Error>> + Send;
  [10.207944]

  [10.208029]
  + type FutureUnit: Future<Output = Result<(Self, Session), Self::Error>> + Send;
• replacement in thrussh/src/server/mod.rs at line 143
  [10.208103]→[10.208103:208194](∅→∅)
  − type FutureBool: Future<Output = Result<(Self, Session, bool), anyhow::Error>> + Send;
  [10.208103]

  [10.208194]
  + type FutureBool: Future<Output = Result<(Self, Session, bool), Self::Error>> + Send;
• replacement in thrussh/src/server/mod.rs at line 417
  [10.217153]→[10.217153:217164](∅→∅),[10.217184]→[10.217184:217481](∅→∅)
  − socket

  − .try_for_each(move |socket| {

  − let config = config.clone();

  − let server = server.new(socket.peer_addr().ok());

  − async move {

  − tokio::spawn(run_stream(config, socket, server));

  − Ok(())

  − }

  − })

  − .await?;
  [10.217153]

  [10.217481]
  + while let Ok((socket, _)) = socket.accept().await {

  + let config = config.clone();

  + let server = server.new(socket.peer_addr().ok());

  + tokio::spawn(run_stream(config, socket, server));

  + }
• replacement in thrussh/src/server/mod.rs at line 443
  [10.913]→[10.913:965](∅→∅)
  − ) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
  [10.913]

  [10.475]
  + ) -> Result<(usize, R, SSHBuffer), Error> {
• replacement in thrussh/src/server/mod.rs at line 453
  [10.217974]→[10.217974:218004](∅→∅)
  − ) -> Result<H, anyhow::Error>
  [10.217974]

  [10.218004]
  + ) -> Result<H, H::Error>
• replacement in thrussh/src/server/mod.rs at line 463
  [10.218306]→[10.218306:218361](∅→∅)
  − stream.write_all(&write_buffer.buffer[..]).await?;
  [10.218306]

  [10.218361]
  + stream

  + .write_all(&write_buffer.buffer[..])

  + .await

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/mod.rs at line 481
  [10.218846]→[10.218846:218863](∅→∅)
  − .await?;
  [10.218846]

  [10.218863]
  + .await

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/mod.rs at line 496
  [7.163]→[7.163:207](∅→∅)
  − Err(e) => return Err(e)
  [7.163]

  [7.207]
  + Err(e) => return Err(e.into())
• replacement in thrussh/src/server/mod.rs at line 525
  [4.337]→[4.337:504](∅→∅)
  − Err(e) => {

  − error!("{:?}", e);

  − return Err(e)

  − }
  [4.337]

  [4.504]
  + Err(e) => return Err(e),
• replacement in thrussh/src/server/mod.rs at line 570
  [10.222069]→[10.222069:222090](∅→∅)
  − .await?;
  [10.222069]

  [10.222121]
  + .await

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/mod.rs at line 576
  [10.222223]→[10.989:1025](∅→∅)
  − stream_write.shutdown().await?;
  [10.222223]

  [10.1025]
  + stream_write.shutdown().await.map_err(crate::Error::from)?;
• replacement in thrussh/src/server/mod.rs at line 597
  [10.222528]→[10.222528:222585](∅→∅)
  − ) -> Result<CommonSession<Arc<Config>>, anyhow::Error> {
  [10.222528]

  [10.222585]
  + ) -> Result<CommonSession<Arc<Config>>, Error> {
• replacement in thrussh/src/server/mod.rs at line 636
  [10.223690]→[10.223690:223728](∅→∅)
  − ) -> Result<Session, anyhow::Error> {
  [10.223690]

  [10.223728]
  + ) -> Result<Session, H::Error> {
• replacement in thrussh/src/server/kex.rs at line 20
  [10.226200]→[10.226200:226238](∅→∅)
  − ) -> Result<Kex, anyhow::Error> {
  [10.226200]

  [10.226238]
  + ) -> Result<Kex, Error> {
• replacement in thrussh/src/server/kex.rs at line 56
  [10.227354]→[10.227354:227391](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.227354]

  [10.227391]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/server/kex.rs at line 73
  [10.227882]→[10.227882:227920](∅→∅)
  − ) -> Result<Kex, anyhow::Error> {
  [10.227882]

  [10.227920]
  + ) -> Result<Kex, Error> {
• replacement in thrussh/src/server/kex.rs at line 93
  [10.228752]→[10.228752:228851](∅→∅)
  − let hash: Result<openssl::hash::DigestBytes, anyhow::Error> = HASH_BUF.with(|buffer| {
  [10.228752]

  [10.228851]
  + let hash: Result<openssl::hash::DigestBytes, Error> = HASH_BUF.with(|buffer| {
• replacement in thrussh/src/server/encrypted.rs at line 34
  [10.231182]→[10.231182:231221](∅→∅)
  − ) -> Result<Self, anyhow::Error> {
  [10.231182]

  [10.231221]
  + ) -> Result<Self, H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 94
  [10.233570]→[10.233570:233618](∅→∅)
  − let request = r.read_string()?;
  [10.233570]

  [10.233618]
  + let request = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 179
  [10.236567]→[10.236567:236604](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.236567]

  [10.236604]
  + ) -> Result<(), H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 182
  [10.236696]→[10.236696:236864](∅→∅)
  − let user = r.read_string()?;

  − let user = std::str::from_utf8(user)?;

  − let service_name = r.read_string()?;

  − let method = r.read_string()?;
  [10.236696]

  [10.236864]
  + let user = r.read_string().map_err(crate::Error::from)?;

  + let user = std::str::from_utf8(user).map_err(crate::Error::from)?;

  + let service_name = r.read_string().map_err(crate::Error::from)?;

  + let method = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 203
  [10.237416]→[10.237416:237560](∅→∅)
  − r.read_byte()?;

  − let password = r.read_string()?;

  − let password = std::str::from_utf8(password)?;
  [10.237416]

  [10.237560]
  + r.read_byte().map_err(crate::Error::from)?;

  + let password = r.read_string().map_err(crate::Error::from)?;

  + let password = std::str::from_utf8(password).map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 231
  [10.238776]→[10.238776:238920](∅→∅)
  − let _ = r.read_string()?; // language_tag, deprecated.

  − let submethods = std::str::from_utf8(r.read_string()?)?;
  [10.238776]

  [10.238920]
  + let _ = r.read_string().map_err(crate::Error::from)?; // language_tag, deprecated.

  + let submethods = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 276
  [10.240414]→[10.240414:240451](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.240414]

  [10.240451]
  + ) -> Result<(), H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 282
  [10.240615]→[10.240615:240740](∅→∅)
  − let is_real = r.read_byte()?;

  − let pubkey_algo = r.read_string()?;

  − let pubkey_key = r.read_string()?;
  [10.240615]

  [10.240740]
  + let is_real = r.read_byte().map_err(crate::Error::from)?;

  + let pubkey_algo = r.read_string().map_err(crate::Error::from)?;

  + let pubkey_key = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 300
  [10.241308]→[10.241308:241362](∅→∅)
  − let signature = r.read_string()?;
  [10.241308]

  [10.241362]
  + let signature = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 303
  [10.241474]→[10.241474:241524](∅→∅)
  − let algo_ = s.read_string()?;
  [10.241474]

  [2.488]
  + let algo_ = s.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 306
  [10.241574]→[10.241574:241622](∅→∅)
  − let sig = s.read_string()?;
  [10.241574]

  [10.241622]
  + let sig = s.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 376
  [10.244837]→[10.244837:244924](∅→∅)
  − if let Some(thrussh_keys::Error::CouldNotReadKey) = e.downcast_ref() {
  [10.244837]

  [10.244924]
  + if let thrussh_keys::Error::CouldNotReadKey = e {
• replacement in thrussh/src/server/encrypted.rs at line 380
  [10.245061]→[10.245061:245088](∅→∅)
  − Err(e)
  [10.245061]

  [10.245088]
  + Err(crate::Error::from(e).into())
• replacement in thrussh/src/server/encrypted.rs at line 417
  [10.245979]→[10.245979:246014](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.245979]

  [10.246014]
  + ) -> Result<bool, H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 420
  [10.246144]→[10.246144:246175](∅→∅)
  − let n = r.read_u32()?;
  [10.246144]

  [10.246175]
  + let n = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 427
  [10.246414]→[10.246414:246491](∅→∅)
  − reply_userauth_info_response(until, auth_request, write, auth).await
  [10.246414]

  [10.246491]
  + reply_userauth_info_response(until, auth_request, write, auth)

  + .await

  + .map_err(|e| H::Error::from(crate::Error::from(e)))
• replacement in thrussh/src/server/encrypted.rs at line 441
  [10.246732]→[10.246732:246767](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.246732]

  [10.246767]
  + ) -> Result<bool, Error> {
• replacement in thrussh/src/server/encrypted.rs at line 479
  [10.247940]→[10.247940:247979](∅→∅)
  − ) -> Result<Self, anyhow::Error> {
  [10.247940]

  [10.247979]
  + ) -> Result<Self, H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 488
  [10.248284]→[10.248284:248344](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.248284]

  [10.248344]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/server/encrypted.rs at line 500
  [10.248821]→[10.248821:248881](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.248821]

  [10.248881]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/server/encrypted.rs at line 509
  [10.249244]→[10.249244:249304](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.249244]

  [10.249304]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/server/encrypted.rs at line 514
  [10.249414]→[10.249414:249454](∅→∅)
  − Some(r.read_u32()?)
  [10.249414]

  [10.249454]
  + Some(r.read_u32().map_err(crate::Error::from)?)
• replacement in thrussh/src/server/encrypted.rs at line 517
  [10.249541]→[10.249541:249586](∅→∅)
  − let data = r.read_string()?;
  [10.249541]

  [10.249586]
  + let data = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 541
  [10.250518]→[10.250518:250622](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let amount = r.read_u32()?;
  [10.250518]

  [10.250622]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let amount = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 563
  [10.251481]→[10.251481:251640](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let req_type = r.read_string()?;

  − let wants_reply = r.read_byte()?;
  [10.251481]

  [10.251640]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let req_type = r.read_string().map_err(crate::Error::from)?;

  + let wants_reply = r.read_byte().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 573
  [10.251960]→[10.251960:252257](∅→∅)
  − let term = std::str::from_utf8(r.read_string()?)?;

  − let col_width = r.read_u32()?;

  − let row_height = r.read_u32()?;

  − let pix_width = r.read_u32()?;

  − let pix_height = r.read_u32()?;
  [10.251960]

  [10.252257]
  + let term =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let col_width = r.read_u32().map_err(crate::Error::from)?;

  + let row_height = r.read_u32().map_err(crate::Error::from)?;

  + let pix_width = r.read_u32().map_err(crate::Error::from)?;

  + let pix_height = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 583
  [10.252391]→[10.252391:252455](∅→∅)
  − let mode_string = r.read_string()?;
  [10.252391]

  [10.252455]
  + let mode_string = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 617
  [10.253992]→[10.253992:254298](∅→∅)
  − let single_connection = r.read_byte()? != 0;

  − let x11_auth_protocol = std::str::from_utf8(r.read_string()?)?;

  − let x11_auth_cookie = std::str::from_utf8(r.read_string()?)?;

  − let x11_screen_number = r.read_u32()?;
  [10.253992]

  [10.254298]
  + let single_connection = r.read_byte().map_err(crate::Error::from)? != 0;

  + let x11_auth_protocol =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let x11_auth_cookie =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let x11_screen_number = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 641
  [10.254989]→[10.254989:255152](∅→∅)
  − let env_variable = std::str::from_utf8(r.read_string()?)?;

  − let env_value = std::str::from_utf8(r.read_string()?)?;
  [10.254989]

  [10.255152]
  + let env_variable =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let env_value =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 663
  [10.255914]→[10.255914:255966](∅→∅)
  − let req = r.read_string()?;
  [10.255914]

  [10.255966]
  + let req = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 672
  [10.256359]→[10.256359:256434](∅→∅)
  − let name = std::str::from_utf8(r.read_string()?)?;
  [10.256359]

  [10.256434]
  + let name =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 682
  [10.256798]→[10.256798:257020](∅→∅)
  − let col_width = r.read_u32()?;

  − let row_height = r.read_u32()?;

  − let pix_width = r.read_u32()?;

  − let pix_height = r.read_u32()?;
  [10.256798]

  [10.257020]
  + let col_width = r.read_u32().map_err(crate::Error::from)?;

  + let row_height = r.read_u32().map_err(crate::Error::from)?;

  + let pix_width = r.read_u32().map_err(crate::Error::from)?;

  + let pix_height = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 702
  [10.257698]→[10.257698:257831](∅→∅)
  − r.read_byte()?; // should be 0.

  − let signal_name = Sig::from_name(r.read_string()?)?;
  [10.257698]

  [10.257831]
  + r.read_byte().map_err(crate::Error::from)?; // should be 0.

  + let signal_name =

  + Sig::from_name(r.read_string().map_err(crate::Error::from)?)?;
• replacement in thrussh/src/server/encrypted.rs at line 729
  [10.258854]→[10.258854:258966](∅→∅)
  − let req_type = r.read_string()?;

  − self.common.wants_reply = r.read_byte()? != 0;
  [10.258854]

  [10.258966]
  + let req_type = r.read_string().map_err(crate::Error::from)?;

  + self.common.wants_reply = r.read_byte().map_err(crate::Error::from)? != 0;
• replacement in thrussh/src/server/encrypted.rs at line 733
  [10.259041]→[10.259041:259169](∅→∅)
  − let address = std::str::from_utf8(r.read_string()?)?;

  − let port = r.read_u32()?;
  [10.259041]

  [10.259169]
  + let address =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let port = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 751
  [10.259940]→[10.259940:260068](∅→∅)
  − let address = std::str::from_utf8(r.read_string()?)?;

  − let port = r.read_u32()?;
  [10.259940]

  [10.260068]
  + let address =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let port = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 790
  [10.261463]→[10.261463:261502](∅→∅)
  − ) -> Result<Self, anyhow::Error> {
  [10.261463]

  [10.261502]
  + ) -> Result<Self, H::Error> {
• replacement in thrussh/src/server/encrypted.rs at line 793
  [10.261596]→[10.261596:261743](∅→∅)
  − let typ = r.read_string()?;

  − let sender = r.read_u32()?;

  − let window = r.read_u32()?;

  − let maxpacket = r.read_u32()?;
  [10.261596]

  [10.261743]
  + let typ = r.read_string().map_err(crate::Error::from)?;

  + let sender = r.read_u32().map_err(crate::Error::from)?;

  + let window = r.read_u32().map_err(crate::Error::from)?;

  + let maxpacket = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 827
  [10.262876]→[10.262876:262979](∅→∅)
  − let a = std::str::from_utf8(r.read_string()?)?;

  − let b = r.read_u32()?;
  [10.262876]

  [10.262979]
  + let a = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let b = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/server/encrypted.rs at line 837
  [10.263269]→[10.263269:263475](∅→∅)
  − let a = std::str::from_utf8(r.read_string()?)?;

  − let b = r.read_u32()?;

  − let c = std::str::from_utf8(r.read_string()?)?;

  − let d = r.read_u32()?;
  [10.263269]

  [10.263475]
  + let a = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let b = r.read_u32().map_err(crate::Error::from)?;

  + let c = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let d = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/negotiation.rs at line 110
  [10.271508]→[10.271508:271591](∅→∅)
  − fn read_kex(buffer: &[u8], pref: &Preferred) -> Result<Names, anyhow::Error> {
  [10.271508]

  [10.271591]
  + fn read_kex(buffer: &[u8], pref: &Preferred) -> Result<Names, Error> {
• replacement in thrussh/src/negotiation.rs at line 224
  [10.275653]→[10.275653:275741](∅→∅)
  − pub fn write_kex(prefs: &Preferred, buf: &mut CryptoVec) -> Result<(), anyhow::Error> {
  [10.275653]

  [10.275741]
  + pub fn write_kex(prefs: &Preferred, buf: &mut CryptoVec) -> Result<(), Error> {
• edit in thrussh/src/lib.rs at line 315
  [10.290621]→[10.290621:290641](∅→∅)
  − /// anyhow::Errors.
• edit in thrussh/src/lib.rs at line 403
  [10.292928]

  [10.292928]
  +

  + #[error(transparent)]

  + Keys(#[from] thrussh_keys::Error),

  +

  + #[error(transparent)]

  + IO(#[from] std::io::Error),

  +

  + #[error(transparent)]

  + Utf8(#[from] std::str::Utf8Error),

  +

  + #[error(transparent)]

  + Compress(#[from] flate2::CompressError),

  +

  + #[error(transparent)]

  + Decompress(#[from] flate2::DecompressError),

  +

  + #[error(transparent)]

  + Join(#[from] tokio::task::JoinError),

  +

  + #[error(transparent)]

  + Openssl(#[from] openssl::error::ErrorStack),

  +

  + #[error(transparent)]

  + Elapsed(#[from] tokio::time::error::Elapsed),
• edit in thrussh/src/lib.rs at line 429
  [10.292931]

  [10.292931]
  + #[derive(Debug, Error)]

  + #[error("Could not reach the event loop")]

  + pub struct SendError {}

  +
• replacement in thrussh/src/lib.rs at line 434
  [10.293100]→[10.293100:293180](∅→∅)
  − pub trait FromFinished<T>: futures::Future<Output = Result<T, anyhow::Error>> {
  [10.293100]

  [10.293180]
  + pub trait FromFinished<T>: futures::Future<Output = Result<T, Error>> {
• replacement in thrussh/src/lib.rs at line 439
  [10.293273]→[10.293273:293352](∅→∅)
  − impl<T> FromFinished<T> for futures::future::Ready<Result<T, anyhow::Error>> {
  [10.293273]

  [10.293352]
  + impl<T> FromFinished<T> for futures::future::Ready<Result<T, Error>> {
• replacement in thrussh/src/lib.rs at line 445
  [10.293431]→[10.293431:293542](∅→∅)
  − impl<T: 'static> FromFinished<T>

  − for Box<dyn futures::Future<Output = Result<T, anyhow::Error>> + Unpin>

  − {
  [10.293431]

  [10.293542]
  + impl<T: 'static> FromFinished<T> for Box<dyn futures::Future<Output = Result<T, Error>> + Unpin> {
• replacement in thrussh/src/lib.rs at line 487
  [10.294730]→[10.294730:294755](∅→∅)
  − pub use auth::MethodSet;
  [10.294730]

  [10.294755]
  + pub use auth::{AgentAuthError, MethodSet, Signer};
• replacement in thrussh/src/lib.rs at line 552
  [10.296284]→[10.296284:296346](∅→∅)
  − fn from_name(name: &[u8]) -> Result<Sig, anyhow::Error> {
  [10.296284]

  [10.296346]
  + fn from_name(name: &[u8]) -> Result<Sig, Error> {
• replacement in thrussh/src/lib.rs at line 647
  [10.298747]→[10.298747:298786](∅→∅)
  − #[tokio::test(threaded_scheduler)]
  [10.298747]

  [10.298786]
  + #[tokio::test]
• edit in thrussh/src/lib.rs at line 650
  [10.298857]→[10.298857:298969](∅→∅)
  − }

  −

  − #[tokio::test(threaded_scheduler)]

  − async fn compress_test() {

  − test_compress(false).await
• replacement in thrussh/src/lib.rs at line 721
  [10.301661]→[10.301661:301942](∅→∅)
  − type FutureAuth = futures::future::Ready<Result<(Self, server::Auth), anyhow::Error>>;

  − type FutureUnit = futures::future::Ready<Result<(Self, Session), anyhow::Error>>;

  − type FutureBool = futures::future::Ready<Result<(Self, Session, bool), anyhow::Error>>;
  [10.301661]

  [10.301942]
  + type Error = super::Error;

  + type FutureAuth = futures::future::Ready<Result<(Self, server::Auth), Self::Error>>;

  + type FutureUnit = futures::future::Ready<Result<(Self, Session), Self::Error>>;

  + type FutureBool = futures::future::Ready<Result<(Self, Session, bool), Self::Error>>;
• replacement in thrussh/src/lib.rs at line 755
  [10.303108]→[10.303108:303293](∅→∅)
  − type FutureUnit = futures::future::Ready<Result<(Self, client::Session), anyhow::Error>>;

  − type FutureBool = futures::future::Ready<Result<(Self, bool), anyhow::Error>>;
  [10.303108]

  [10.303293]
  + type Error = super::Error;

  + type FutureUnit = futures::future::Ready<Result<(Self, client::Session), Self::Error>>;

  + type FutureBool = futures::future::Ready<Result<(Self, bool), Self::Error>>;
• replacement in thrussh/src/kex.rs at line 64
  [10.308792]→[10.308792:308836](∅→∅)
  − ) -> Result<Algorithm, anyhow::Error> {
  [10.308792]

  [10.308836]
  + ) -> Result<Algorithm, crate::Error> {
• replacement in thrussh/src/kex.rs at line 97
  [10.309892]→[10.309892:309936](∅→∅)
  − ) -> Result<Algorithm, anyhow::Error> {
  [10.309892]

  [10.309936]
  + ) -> Result<Algorithm, crate::Error> {
• replacement in thrussh/src/kex.rs at line 117
  [10.310476]→[10.310476:310574](∅→∅)
  − pub fn compute_shared_secret(&mut self, remote_pubkey_: &[u8]) -> Result<(), anyhow::Error> {
  [10.310476]

  [10.310574]
  + pub fn compute_shared_secret(&mut self, remote_pubkey_: &[u8]) -> Result<(), crate::Error> {
• replacement in thrussh/src/kex.rs at line 133
  [10.311080]→[10.311080:311141](∅→∅)
  − ) -> Result<openssl::hash::DigestBytes, anyhow::Error> {
  [10.311080]

  [10.311141]
  + ) -> Result<openssl::hash::DigestBytes, crate::Error> {
• replacement in thrussh/src/kex.rs at line 163
  [10.312145]→[10.312145:312205](∅→∅)
  − ) -> Result<super::cipher::CipherPair, anyhow::Error> {
  [10.312145]

  [10.312205]
  + ) -> Result<super::cipher::CipherPair, crate::Error> {
• replacement in thrussh/src/kex.rs at line 172
  [10.312504]→[10.312504:312599](∅→∅)
  − let compute_key = |c, key: &mut CryptoVec, len| -> Result<(), anyhow::Error> {
  [10.312504]

  [10.312599]
  + let compute_key = |c, key: &mut CryptoVec, len| -> Result<(), crate::Error> {
• replacement in thrussh/src/compression.rs at line 74
  [10.316549]→[10.316549:316592](∅→∅)
  − ) -> Result<&'a [u8], anyhow::Error> {
  [10.316549]

  [10.316592]
  + ) -> Result<&'a [u8], Error> {
• replacement in thrussh/src/compression.rs at line 85
  [10.316781]→[10.316781:316824](∅→∅)
  − ) -> Result<&'a [u8], anyhow::Error> {
  [10.316781]

  [10.316824]
  + ) -> Result<&'a [u8], Error> {
• replacement in thrussh/src/compression.rs at line 96
  [10.317009]→[10.317009:317052](∅→∅)
  − ) -> Result<&'a [u8], anyhow::Error> {
  [10.317009]

  [10.317052]
  + ) -> Result<&'a [u8], crate::Error> {
• replacement in thrussh/src/compression.rs at line 129
  [10.318180]→[10.318180:318223](∅→∅)
  − ) -> Result<&'a [u8], anyhow::Error> {
  [10.318180]

  [10.318223]
  + ) -> Result<&'a [u8], crate::Error> {
• replacement in thrussh/src/client/session.rs at line 4
  [10.319237]→[10.319237:319318](∅→∅)
  − pub fn channel_open_session(&mut self) -> Result<ChannelId, anyhow::Error> {
  [10.319237]

  [10.319318]
  + pub fn channel_open_session(&mut self) -> Result<ChannelId, Error> {
• replacement in thrussh/src/client/session.rs at line 41
  [10.320651]→[10.320651:320695](∅→∅)
  − ) -> Result<ChannelId, anyhow::Error> {
  [10.320651]

  [10.320695]
  + ) -> Result<ChannelId, Error> {
• replacement in thrussh/src/client/session.rs at line 83
  [10.322265]→[10.322265:322309](∅→∅)
  − ) -> Result<ChannelId, anyhow::Error> {
  [10.322265]

  [10.322309]
  + ) -> Result<ChannelId, Error> {
• replacement in thrussh/src/client/proxy.rs at line 24
  [10.333445]→[10.333445:333531](∅→∅)
  − pub fn proxy_connect(cmd: &str, args: &[&str]) -> Result<Stream, anyhow::Error> {
  [10.333445]

  [10.333531]
  + pub fn proxy_connect(cmd: &str, args: &[&str]) -> Result<Stream, std::io::Error> {
• replacement in thrussh/src/client/mod.rs at line 185
  [10.339256]→[10.339256:339276](∅→∅)
  − pub struct Handle {
  [10.339256]

  [10.339276]
  + pub struct Handle<H: Handler> {
• replacement in thrussh/src/client/mod.rs at line 188
  [10.339341]→[10.339341:339403](∅→∅)
  − join: tokio::task::JoinHandle<Result<(), anyhow::Error>>,
  [10.339341]

  [10.339403]
  + join: tokio::task::JoinHandle<Result<(), H::Error>>,
• replacement in thrussh/src/client/mod.rs at line 191
  [10.339406]→[10.339406:339429](∅→∅)
  − impl Drop for Handle {
  [10.339406]

  [10.339429]
  + impl<H: Handler> Drop for Handle<H> {
• replacement in thrussh/src/client/mod.rs at line 210
  [10.339732]→[10.339732:339746](∅→∅)
  − impl Handle {
  [10.339732]

  [10.339746]
  + impl<H: Handler> Handle<H> {
• replacement in thrussh/src/client/mod.rs at line 215
  [10.339877]→[10.339877:339916](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.339877]

  [10.339916]
  + ) -> Result<bool, Error> {
• replacement in thrussh/src/client/mod.rs at line 240
  [10.340630]→[10.340630:340669](∅→∅)
  − ) -> Result<bool, anyhow::Error> {
  [10.340630]

  [10.340669]
  + ) -> Result<bool, Error> {
• replacement in thrussh/src/client/mod.rs at line 264
  [10.341359]→[10.341359:341403](∅→∅)
  − ) -> Result<(S, bool), anyhow::Error> {
  [10.341359]

  [10.341403]
  + ) -> (S, Result<bool, S::Error>) {
• replacement in thrussh/src/client/mod.rs at line 266
  [10.341435]→[10.341435:341455](∅→∅)
  − self.sender
  [10.341435]

  [10.341455]
  + if let Err(_) = self

  + .sender
• replacement in thrussh/src/client/mod.rs at line 273
  [10.341612]→[10.341612:341657](∅→∅)
  − .map_err(|_| Error::SendError)?;
  [10.341612]

  [10.341657]
  + {

  + return (future, Err((crate::SendError {}).into()));

  + }
• replacement in thrussh/src/client/mod.rs at line 279
  [10.341750]→[10.341750:341893](∅→∅)
  − Some(Reply::AuthSuccess) => return Ok((future, true)),

  − Some(Reply::AuthFailure) => return Ok((future, false)),
  [10.341750]

  [10.341893]
  + Some(Reply::AuthSuccess) => return (future, Ok(true)),

  + Some(Reply::AuthFailure) => return (future, Ok(false)),
• replacement in thrussh/src/client/mod.rs at line 284
  [10.342067]→[10.342067:342277](∅→∅)
  − let data = data?;

  − self.sender

  − .send(Msg::Signed { data })

  − .await

  − .map_err(|_| Error::SendError)?;
  [10.342067]

  [10.342277]
  + let data = match data {

  + Ok(data) => data,

  + Err(e) => return (future, Err(e.into())),

  + };

  + if let Err(_) = self.sender.send(Msg::Signed { data }).await {

  + return (future, Err((crate::SendError {}).into()));

  + }
• replacement in thrussh/src/client/mod.rs at line 292
  [10.342295]→[10.342295:342347](∅→∅)
  − None => return Ok((future, false)),
  [10.342295]

  [10.342347]
  + None => return (future, Ok(false)),
• replacement in thrussh/src/client/mod.rs at line 301
  [10.342514]→[10.342514:342556](∅→∅)
  − ) -> Result<Channel, anyhow::Error> {
  [10.342514]

  [10.342556]
  + ) -> Result<Channel, Error> {
• replacement in thrussh/src/client/mod.rs at line 334
  [10.343678]→[10.343678:343763](∅→∅)
  − pub async fn channel_open_session(&mut self) -> Result<Channel, anyhow::Error> {
  [10.343678]

  [10.343763]
  + pub async fn channel_open_session(&mut self) -> Result<Channel, Error> {
• replacement in thrussh/src/client/mod.rs at line 348
  [10.344224]→[10.344224:344266](∅→∅)
  − ) -> Result<Channel, anyhow::Error> {
  [10.344224]

  [10.344266]
  + ) -> Result<Channel, Error> {
• replacement in thrussh/src/client/mod.rs at line 372
  [10.345151]→[10.345151:345193](∅→∅)
  − ) -> Result<Channel, anyhow::Error> {
  [10.345151]

  [10.345193]
  + ) -> Result<Channel, Error> {
• replacement in thrussh/src/client/mod.rs at line 393
  [10.345833]→[10.345833:345870](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.345833]

  [10.345870]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 427
  [10.346759]→[10.346759:346796](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.346759]

  [10.346796]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 446
  [10.347276]→[10.347276:347367](∅→∅)
  − pub async fn request_shell(&mut self, want_reply: bool) -> Result<(), anyhow::Error> {
  [10.347276]

  [10.347367]
  + pub async fn request_shell(&mut self, want_reply: bool) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 465
  [10.347890]→[10.347890:347927](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.347890]

  [10.347927]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 482
  [10.348307]→[10.348307:348386](∅→∅)
  − pub async fn signal(&mut self, signal: Sig) -> Result<(), anyhow::Error> {
  [10.348307]

  [10.348386]
  + pub async fn signal(&mut self, signal: Sig) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 499
  [10.348796]→[10.348796:348833](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.348796]

  [10.348833]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 520
  [10.349441]→[10.349441:349478](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.349441]

  [10.349478]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 539
  [10.349934]→[10.349934:349971](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.349934]

  [10.349971]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 563
  [10.350698]→[10.350698:350735](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.350698]

  [10.350735]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 585
  [10.351405]→[10.351405:351442](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.351405]

  [10.351442]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 606
  [10.351996]→[10.351996:352033](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.351996]

  [10.352033]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 625
  [10.352498]→[10.352498:352535](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.352498]

  [10.352535]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 636
  [10.352867]→[10.352867:352904](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.352867]

  [10.352904]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 644
  [10.353096]→[10.353096:353133](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.353096]

  [10.353133]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 683
  [10.354485]→[10.354485:354623](∅→∅)
  − async fn send_data_packet(

  − &mut self,

  − ext: Option<u32>,

  − data: CryptoVec,

  − ) -> Result<(), anyhow::Error> {
  [10.354485]

  [10.354623]
  + async fn send_data_packet(&mut self, ext: Option<u32>, data: CryptoVec) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 706
  [10.355152]→[10.355152:355215](∅→∅)
  − pub async fn eof(&mut self) -> Result<(), anyhow::Error> {
  [10.355152]

  [10.355215]
  + pub async fn eof(&mut self) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 731
  [10.355934]→[10.355934:356004](∅→∅)
  − impl Future for Handle {

  − type Output = Result<(), anyhow::Error>;
  [10.355934]

  [10.356004]
  + impl<H: Handler> Future for Handle<H> {

  + type Output = Result<(), H::Error>;
• replacement in thrussh/src/client/mod.rs at line 737
  [10.356231]→[10.356231:356272](∅→∅)
  − Err(e) => Err(e.into()),
  [10.356231]

  [10.356272]
  + Err(e) => Err(crate::Error::from(e).into()),
• replacement in thrussh/src/client/mod.rs at line 750
  [10.356541]→[10.356541:356684](∅→∅)
  − ) -> Result<Handle, anyhow::Error> {

  − let addr = addr.to_socket_addrs()?.next().unwrap();

  − let socket = TcpStream::connect(addr).await?;
  [10.356541]

  [10.356684]
  + ) -> Result<Handle<H>, H::Error> {

  + let addr = addr

  + .to_socket_addrs()

  + .map_err(crate::Error::from)?

  + .next()

  + .unwrap();

  + let socket = TcpStream::connect(addr).await.map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 764
  [10.356828]→[10.356828:356863](∅→∅)
  − ) -> Result<Handle, anyhow::Error>
  [10.356828]

  [10.356863]
  + ) -> Result<Handle<H>, H::Error>
• replacement in thrussh/src/client/mod.rs at line 772
  [10.357096]→[10.357096:357147](∅→∅)
  − stream.write_all(&write_buffer.buffer).await?;
  [10.357096]

  [10.357147]
  + stream

  + .write_all(&write_buffer.buffer)

  + .await

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 821
  [10.1127]→[10.1127:1179](∅→∅)
  − ) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
  [10.1127]

  [10.1420]
  + ) -> Result<(usize, R, SSHBuffer), Error> {
• replacement in thrussh/src/client/mod.rs at line 833
  [10.289]→[10.358451:358488](∅→∅),[10.358451]→[10.358451:358488](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.289]

  [10.358488]
  + ) -> Result<(), H::Error> {
• replacement in thrussh/src/client/mod.rs at line 837
  [10.358649]→[10.358649:358755](∅→∅)
  − stream.write_all(&self.common.write_buffer.buffer).await?;

  − stream.flush().await?;
  [10.358649]

  [10.358755]
  + stream

  + .write_all(&self.common.write_buffer.buffer)

  + .await

  + .map_err(crate::Error::from)?;

  + stream.flush().await.map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 857
  [7.402]→[7.402:450](∅→∅)
  − Err(e) => return Err(e)
  [7.402]

  [7.450]
  + Err(e) => return Err(e.into())
• replacement in thrussh/src/client/mod.rs at line 952
  [10.1428]→[10.1428:1457](∅→∅),[10.1457]→[10.2097:2142](∅→∅),[10.2097]→[10.2097:2142](∅→∅)
  − .await?;

  − stream_write.flush().await?;
  [10.1428]

  [10.364366]
  + .await

  + .map_err(crate::Error::from)?;

  + stream_write.flush().await.map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 966
  [10.364852]→[10.2143:2187](∅→∅)
  − stream_write.shutdown().await?;
  [10.364852]

  [10.365095]
  + stream_write.shutdown().await.map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 981
  [10.365318]→[10.365318:365393](∅→∅)
  − fn read_ssh_id(&mut self, sshid: &[u8]) -> Result<(), anyhow::Error> {
  [10.365318]

  [10.365393]
  + fn read_ssh_id(&mut self, sshid: &[u8]) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 1007
  [10.366248]→[10.366248:366303](∅→∅)
  − fn flush(&mut self) -> Result<(), anyhow::Error> {
  [10.366248]

  [10.366303]
  + fn flush(&mut self) -> Result<(), Error> {
• replacement in thrussh/src/client/mod.rs at line 1041
  [10.367457]→[10.367457:367495](∅→∅)
  − ) -> Result<Kex, anyhow::Error> {
  [10.367457]

  [10.367495]
  + ) -> Result<Kex, H::Error> {
• replacement in thrussh/src/client/mod.rs at line 1043
  [10.367535]→[10.367535:367649](∅→∅)
  − let pubkey = reader.read_string()?; // server public key.

  − let pubkey = parse_public_key(pubkey)?;
  [10.367535]

  [10.367649]
  + let pubkey = reader.read_string().map_err(crate::Error::from)?; // server public key.

  + let pubkey = parse_public_key(pubkey).map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 1058
  [10.368103]→[10.368103:368165](∅→∅)
  − let server_ephemeral = reader.read_string()?;
  [10.368103]

  [10.368165]
  + let server_ephemeral = reader.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 1060
  [10.368238]→[10.368238:368293](∅→∅)
  − let signature = reader.read_string()?;
  [10.368238]

  [10.368293]
  + let signature = reader.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 1071
  [10.368754]→[10.368754:368816](∅→∅)
  − let sig_type = sig_reader.read_string()?;
  [10.368754]

  [10.368816]
  + let sig_type = sig_reader.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/mod.rs at line 1073
  [10.368872]→[10.368872:368918](∅→∅)
  − sig_reader.read_string()?
  [10.368872]

  [10.368918]
  + sig_reader.read_string().map_err(crate::Error::from)?
• replacement in thrussh/src/client/mod.rs at line 1095
  [10.369529]→[10.369529:369567](∅→∅)
  − ) -> Result<Session, anyhow::Error> {
  [10.369529]

  [10.369567]
  + ) -> Result<Session, H::Error> {
• edit in thrussh/src/client/mod.rs at line 1194
  [10.373237]

  [10.373237]
  + type Error: From<crate::Error> + Send;
• replacement in thrussh/src/client/mod.rs at line 1197
  [10.373352]→[10.373352:373434](∅→∅)
  − type FutureBool: Future<Output = Result<(Self, bool), anyhow::Error>> + Send;
  [10.373352]

  [10.373434]
  + type FutureBool: Future<Output = Result<(Self, bool), Self::Error>> + Send;
• replacement in thrussh/src/client/mod.rs at line 1201
  [10.373545]→[10.373545:373630](∅→∅)
  − type FutureUnit: Future<Output = Result<(Self, Session), anyhow::Error>> + Send;
  [10.373545]

  [10.373630]
  + type FutureUnit: Future<Output = Result<(Self, Session), Self::Error>> + Send;
• replacement in thrussh/src/client/kex.rs at line 15
  [10.381845]→[10.381845:381889](∅→∅)
  − ) -> Result<KexDhDone, anyhow::Error> {
  [10.381845]

  [10.381889]
  + ) -> Result<KexDhDone, Error> {
• replacement in thrussh/src/client/kex.rs at line 61
  [10.383572]→[10.383572:383609](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.383572]

  [10.383609]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/client/encrypted.rs at line 37
  [10.385083]→[10.385083:385122](∅→∅)
  − ) -> Result<Self, anyhow::Error> {
  [10.385083]

  [10.385122]
  + ) -> Result<Self, C::Error> {
• replacement in thrussh/src/client/encrypted.rs at line 125
  [10.388930]→[10.388930:388995](∅→∅)
  − if r.read_string()? == b"ssh-userauth" {
  [10.388930]

  [10.388995]
  + if r.read_string().map_err(crate::Error::from)? == b"ssh-userauth" {
• replacement in thrussh/src/client/encrypted.rs at line 159
  [10.390809]→[10.390809:390864](∅→∅)
  − let banner = r.read_string()?;
  [10.390809]

  [10.390864]
  + let banner = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 172
  [10.391436]→[10.391436:391502](∅→∅)
  − let remaining_methods = r.read_string()?;
  [10.391436]

  [10.391502]
  + let remaining_methods = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 261
  [10.395711]→[10.395711:395750](∅→∅)
  − ) -> Result<Self, anyhow::Error> {
  [10.395711]

  [10.395750]
  + ) -> Result<Self, C::Error> {
• replacement in thrussh/src/client/encrypted.rs at line 266
  [10.395922]→[10.395922:396135](∅→∅)
  − let id_send = ChannelId(reader.read_u32()?);

  − let id_recv = reader.read_u32()?;

  − let window = reader.read_u32()?;

  − let max_packet = reader.read_u32()?;
  [10.395922]

  [10.396135]
  + let id_send = ChannelId(reader.read_u32().map_err(crate::Error::from)?);

  + let id_recv = reader.read_u32().map_err(crate::Error::from)?;

  + let window = reader.read_u32().map_err(crate::Error::from)?;

  + let max_packet = reader.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 294
  [10.397224]→[10.397224:397284](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.397224]

  [10.397284]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/client/encrypted.rs at line 306
  [10.397733]→[10.397733:397793](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.397733]

  [10.397793]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/client/encrypted.rs at line 315
  [10.398116]→[10.398116:398403](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let reason_code = ChannelOpenFailure::from_u32(r.read_u32()?).unwrap();

  − let descr = std::str::from_utf8(r.read_string()?)?;

  − let language = std::str::from_utf8(r.read_string()?)?;
  [10.398116]

  [10.398403]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let reason_code =

  + ChannelOpenFailure::from_u32(r.read_u32().map_err(crate::Error::from)?)

  + .unwrap();

  + let descr = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let language = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 336
  [10.398931]→[10.398931:399036](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let data = r.read_string()?;
  [10.398931]

  [10.399036]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let data = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 355
  [10.399842]→[10.399842:399998](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let extended_code = r.read_u32()?;

  − let data = r.read_string()?;
  [10.399842]

  [10.399998]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let extended_code = r.read_u32().map_err(crate::Error::from)?;

  + let data = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 376
  [10.400815]→[10.400815:400919](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let req = r.read_string()?;
  [10.400815]

  [10.400919]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let req = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 386
  [10.401224]→[10.401224:401462](∅→∅)
  − let a = std::str::from_utf8(r.read_string()?)?;

  − let b = r.read_u32()?;

  − let c = std::str::from_utf8(r.read_string()?)?;

  − let d = r.read_u32()?;
  [10.401224]

  [10.401462]
  + let a = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let b = r.read_u32().map_err(crate::Error::from)?;

  + let c = std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let d = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 396
  [10.401644]→[10.401644:401760](∅→∅)
  − r.read_byte()?; // should be 0.

  − let client_can_do = r.read_byte()?;
  [10.401644]

  [10.401760]
  + r.read_byte().map_err(crate::Error::from)?; // should be 0.

  + let client_can_do = r.read_byte().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 401
  [10.401904]→[10.401904:402017](∅→∅)
  − r.read_byte()?; // should be 0.

  − let exit_status = r.read_u32()?;
  [10.401904]

  [10.402017]
  + r.read_byte().map_err(crate::Error::from)?; // should be 0.

  + let exit_status = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 406
  [10.402157]→[10.402157:402511](∅→∅)
  − r.read_byte()?; // should be 0.

  − let signal_name = Sig::from_name(r.read_string()?)?;

  − let core_dumped = r.read_byte()?;

  − let error_message = std::str::from_utf8(r.read_string()?)?;

  − let lang_tag = std::str::from_utf8(r.read_string()?)?;
  [10.402157]

  [10.402511]
  + r.read_byte().map_err(crate::Error::from)?; // should be 0.

  + let signal_name =

  + Sig::from_name(r.read_string().map_err(crate::Error::from)?)?;

  + let core_dumped = r.read_byte().map_err(crate::Error::from)?;

  + let error_message =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;

  + let lang_tag =

  + std::str::from_utf8(r.read_string().map_err(crate::Error::from)?)

  + .map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 437
  [10.403273]→[10.403273:403377](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);

  − let amount = r.read_u32()?;
  [10.403273]

  [10.403377]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);

  + let amount = r.read_u32().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 456
  [10.404168]→[10.404168:404212](∅→∅)
  − let req = r.read_string()?;
  [10.404168]

  [10.404212]
  + let req = r.read_string().map_err(crate::Error::from)?;
• replacement in thrussh/src/client/encrypted.rs at line 462
  [10.404415]→[10.404415:404475](∅→∅)
  − let channel_num = ChannelId(r.read_u32()?);
  [10.404415]

  [10.404475]
  + let channel_num = ChannelId(r.read_u32().map_err(crate::Error::from)?);
• replacement in thrussh/src/client/encrypted.rs at line 574
  [10.408594]→[10.408594:408631](∅→∅)
  − ) -> Result<(), anyhow::Error> {
  [10.408594]

  [10.408631]
  + ) -> Result<(), Error> {
• replacement in thrussh/src/cipher/mod.rs at line 19
  [10.409800]→[10.409800:409826](∅→∅)
  − use tokio::io::AsyncRead;
  [10.409800]

  [10.409826]
  + use tokio::io::{AsyncRead, AsyncReadExt};
• edit in thrussh/src/cipher/mod.rs at line 22
  [10.409867]→[10.409867:409890](∅→∅)
  − use tokio::prelude::*;
• replacement in thrussh/src/cipher/mod.rs at line 109
  [10.412012]→[10.412012:412048](∅→∅)
  − ) -> Result<usize, anyhow::Error> {
  [10.412012]

  [3.50]
  + ) -> Result<usize, Error> {
• replacement in thrussh/src/auth.rs at line 64
  [10.423986]→[10.423986:424209](∅→∅)
  − fn auth_publickey_sign(

  − self,

  − key: &key::PublicKey,

  − to_sign: CryptoVec,

  − ) -> std::pin::Pin<

  − Box<dyn futures::Future<Output = (Self, Result<CryptoVec, anyhow::Error>)> + Send>,

  − >;
  [10.423986]

  [10.424209]
  + type Error: From<crate::SendError>;

  + type Future: futures::Future<Output = (Self, Result<CryptoVec, Self::Error>)> + Send;

  +

  + fn auth_publickey_sign(self, key: &key::PublicKey, to_sign: CryptoVec) -> Self::Future;

  + }

  +

  + #[derive(Debug, Error)]

  + pub enum AgentAuthError {

  + #[error(transparent)]

  + Send(#[from] crate::SendError),

  + #[error(transparent)]

  + Key(#[from] thrussh_keys::Error),
• replacement in thrussh/src/auth.rs at line 81
  [10.424330]→[10.424330:424554](∅→∅)
  − fn auth_publickey_sign(

  − self,

  − key: &key::PublicKey,

  − to_sign: CryptoVec,

  − ) -> std::pin::Pin<

  − Box<dyn futures::Future<Output = (Self, Result<CryptoVec, anyhow::Error>)> + Send>,

  − > {
  [10.424330]

  [10.424554]
  + type Error = AgentAuthError;

  + type Future = std::pin::Pin<

  + Box<dyn futures::Future<Output = (Self, Result<CryptoVec, Self::Error>)> + Send>,

  + >;

  + fn auth_publickey_sign(self, key: &key::PublicKey, to_sign: CryptoVec) -> Self::Future {
• replacement in thrussh/src/auth.rs at line 87
  [10.424605]→[10.424605:424665](∅→∅)
  − futures::FutureExt::boxed(async move { fut.await })
  [10.424605]

  [10.424665]
  + futures::FutureExt::boxed(async move {

  + let (a, b) = fut.await;

  + (a, b.map_err(AgentAuthError::Key))

  + })
• replacement in thrussh/examples/client.rs at line 14
  [5.272]→[5.272:449](∅→∅)
  − type FutureUnit = futures::future::Ready<Result<(Self, client::Session), anyhow::Error>>;

  − type FutureBool = futures::future::Ready<Result<(Self, bool), anyhow::Error>>;
  [5.272]

  [5.449]
  + type Error = thrussh::Error;

  + type FutureUnit = futures::future::Ready<Result<(Self, client::Session), Self::Error>>;

  + type FutureBool = futures::future::Ready<Result<(Self, bool), Self::Error>>;
• replacement in thrussh/Cargo.toml at line 5
  [10.426214]→[8.0:19](∅→∅)
  − version = "0.30.9"
  [10.426214]

  [10.426233]
  + version = "0.32.1"
• replacement in thrussh/Cargo.toml at line 46
  [10.427069]→[10.1620:1684](∅→∅),[10.1684]→[10.40:64](∅→∅)
  − log = { version = "0.4", features = ["release_max_level_off"] }

  − thrussh-keys = "0.19.4"
  [10.427069]

  [10.427105]
  + log = "0.4"

  + thrussh-keys = "0.20.0"
• replacement in thrussh/Cargo.toml at line 51
  [10.427168]→[10.1709:1825](∅→∅)
  − tokio = { version = "0.3", features = [ "io-util", "rt-multi-thread", "time", "stream", "net", "sync", "macros" ] }
  [10.427168]

  [10.427280]
  + tokio = { version = "1.0", features = [ "io-util", "rt-multi-thread", "time", "net", "sync", "macros" ] }
• edit in thrussh/Cargo.toml at line 54
  [10.427314]→[10.427314:427329](∅→∅)
  − anyhow = "1.0"
• replacement in thrussh/Cargo.toml at line 58
  [10.427414]→[10.1826:1942](∅→∅)
  − tokio = { version = "0.3", features = [ "io-util", "rt-multi-thread", "time", "stream", "net", "sync", "macros" ] }
  [10.427414]
  + tokio = { version = "1.0", features = [ "io-util", "rt-multi-thread", "time", "net", "sync", "macros" ] }

  + anyhow = "1.0"