Robin_Jadoul/testing - Change 2WEO7OZLWJJPUYK4WXLT5FD46G2MAEIHEYMDW5GASCBUNKOPXCVAC

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

Created by pmeunier on January 5, 2021

2WEO7OZLWJJPUYK4WXLT5FD46G2MAEIHEYMDW5GASCBUNKOPXCVAC

Dependencies

In channels

main

Change contents

Replacement in thrussh-keys/src/signature.rs at line 53 [10.5821]

B:BD[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> {

Insertion in thrussh-keys/src/lib.rs at line 117 [10.21590]

[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.21590]

B:BD[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.21590]

B:BD[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.21590]
B:BD[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.21590]
B:BD[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.21590]
B:BD[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.21590]
B:BD[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.21590]

B:BD[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.21590]

B:BD[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.57451]

B:BD[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.57451]

B:BD[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.57451]
B:BD[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.57451]

B:BD[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.57451]
B:BD[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.57451]

B:BD[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.71340]

B:BD[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.71340]

B:BD[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.71340]

B:BD[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.71340]

B:BD[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.71340]

B:BD[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.71340]
B:BD[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.71340]

B:BD[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.71340]

B:BD[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.71340]

B:BD[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.85753]
B:BD[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.86809]

B:BD[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.86809]
B:BD[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.92032]

B:BD[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.92032]

B:BD[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.92032]
B:BD[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.92032]

B:BD[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> {

Insertion in thrussh-keys/src/agent/server.rs at line 7 [10.125237]
[10.125430]
[10.125430]
```
use futures::stream::{Stream, StreamExt};
```
Deletion in thrussh-keys/src/agent/server.rs at line 15 [10.125237]
B:BD[10.125632] → [10.125632:125672]
```
use tokio::stream::{Stream, StreamExt};
```
Replacement in thrussh-keys/src/agent/server.rs at line 88 [10.125237]
B:BD[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.125237]

B:BD[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.125237]

B:BD[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.125237]

B:BD[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.125237]

B:BD[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.125237]
B:BD[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.125237]
B:BD[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.139093]

B:BD[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.139093]

B:BD[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 [10.139093]

B:BD[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.139093]

B:BD[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.139093]
B:BD[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.139093]
B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.139093]

B:BD[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.157024]
B:BD[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.157024]
B:BD[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.157024]

B:BD[10.157794] → [11.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.157024]

B:BD[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.157024]
B:BD[10.158129] → [10.158129:158142]
```
dirs = "2.0"
```
[10.158129]
[10.158142]
```
dirs = "3.0"
```
Deletion in thrussh-keys/Cargo.toml at line 47 [10.157024]
B:BD[10.158154] → [10.158154:158169]
```
anyhow = "1.0"
```
Replacement in thrussh-config/src/lib.rs at line 1 [10.161114]
B:BD[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;
```
Insertion in thrussh-config/src/lib.rs at line 5 [10.161114]
[12.141]
[10.161244]
```
use thiserror::*;
```
Replacement in thrussh-config/Cargo.toml at line 4 [10.164787]
B:BD[10.164932] → [10.164932:164950]
```
version = "0.2.1"
```
[10.164932]
[10.164950]
```
version = "0.5.0"
```
Deletion in thrussh-config/Cargo.toml at line 13 [10.164787]
B:BD[10.165217] → [10.165217:165251]
```
regex = "1.0"
lazy_static = "1.0"
```

Replacement in thrussh-config/Cargo.toml at line 15 [10.164787]

B:BD[10.165281] → [11.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.164787]
B:BD[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.166688]

B:BD[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.171602]
B:BD[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.188192]
B:BD[10.192535] → [10.192535:192594]
```
    pub fn flush(&mut self) -> Result<(), anyhow::Error> {
```
[10.192535]
[10.192594]
```
    pub fn flush(&mut self) -> Result<(), Error> {
```
Deletion in thrussh/src/server/mod.rs at line 21 [10.203388]
B:BD[10.204077] → [10.204077:204112]
```
use futures::stream::TryStreamExt;
```
Insertion in thrussh/src/server/mod.rs at line 134 [10.203388]
[10.207704]
[10.207704]
```
    type Error: From<crate::Error> + Send;
```

Replacement in thrussh/src/server/mod.rs at line 137 [10.203388]

B:BD[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.203388]

B:BD[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.203388]

B:BD[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.203388]

B:BD[10.217153] → [10.217153:217164]

B:BD[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.203388]
B:BD[12.913] → [12.913:965]
```
) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
```
[12.913]
[13.475]
```
) -> Result<(usize, R, SSHBuffer), Error> {
```
Replacement in thrussh/src/server/mod.rs at line 453 [10.203388]
B:BD[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.203388]

B:BD[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.203388]
B:BD[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 [10.203388]

B:BD[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 [10.203388]

B:BD[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.203388]
B:BD[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.203388]
B:BD[10.222223] → [13.989:1025]
```
    stream_write.shutdown().await?;
```
[10.222223]
[13.1025]
```
    stream_write.shutdown().await.map_err(crate::Error::from)?;
```
Replacement in thrussh/src/server/mod.rs at line 597 [10.203388]
B:BD[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.203388]
B:BD[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.225726]
B:BD[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.225726]
B:BD[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.225726]
B:BD[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.225726]

B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]
B:BD[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.230083]
B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]
B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]
B:BD[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.230083]

B:BD[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.230083]

B:BD[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.230083]

B:BD[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.268386]

B:BD[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.268386]

B:BD[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> {

Deletion in thrussh/src/lib.rs at line 315 [10.278640]
B:BD[10.290621] → [10.290621:290641]
```
/// anyhow::Errors.
```

Insertion in thrussh/src/lib.rs at line 403 [10.278640]

[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),

Insertion in thrussh/src/lib.rs at line 429 [10.278640]

[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.278640]

B:BD[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.278640]

B:BD[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.278640]

B:BD[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.278640]
B:BD[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.278640]

B:BD[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.278640]
B:BD[10.298747] → [10.298747:298786]
```
    #[tokio::test(threaded_scheduler)]
```
[10.298747]
[10.298786]
```
    #[tokio::test]
```

Deletion in thrussh/src/lib.rs at line 650 [10.278640]

B:BD[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.278640]

B:BD[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.278640]

B:BD[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.306916]
B:BD[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.306916]
B:BD[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.306916]

B:BD[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.306916]

B:BD[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.306916]

B:BD[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.306916]

B:BD[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.314851]
B:BD[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.314851]
B:BD[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.314851]
B:BD[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.314851]
B:BD[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.319206]

B:BD[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.319206]
B:BD[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.319206]
B:BD[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.332746]

B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]
B:BD[12.1127] → [12.1127:1179]
```
) -> Result<(usize, R, SSHBuffer), anyhow::Error> {
```
[12.1127]
[13.1420]
```
) -> Result<(usize, R, SSHBuffer), Error> {
```
Replacement in thrussh/src/client/mod.rs at line 833 [10.334998]
∅:D[14.289] → [10.358451:358488]
B:BD[10.358451] → [10.358451:358488]
```
    ) -> Result<(), anyhow::Error> {
```
[14.289]
[10.358488]
```
    ) -> Result<(), H::Error> {
```

Replacement in thrussh/src/client/mod.rs at line 837 [10.334998]

B:BD[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 [10.334998]

B:BD[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.334998]

B:BD[12.1428] → [12.1428:1457]

∅:D[12.1457] → [13.2097:2142]

B:BD[13.2097] → [13.2097:2142]

                    .await?;
                stream_write.flush().await?;

[12.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.334998]

B:BD[10.364852] → [13.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.334998]

B:BD[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.334998]
B:BD[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.334998]
B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]

B:BD[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.334998]
B:BD[10.369529] → [10.369529:369567]
```
) -> Result<Session, anyhow::Error> {
```
[10.369529]
[10.369567]
```
) -> Result<Session, H::Error> {
```
Insertion in thrussh/src/client/mod.rs at line 1194 [10.334998]
[10.373237]
[10.373237]
```
    type Error: From<crate::Error> + Send;
```

Replacement in thrussh/src/client/mod.rs at line 1197 [10.334998]

B:BD[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.334998]

B:BD[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.381546]
B:BD[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.381546]
B:BD[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.383877]
B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]
B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]

B:BD[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.383877]
B:BD[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.409086]
B:BD[10.409800] → [10.409800:409826]
```
use tokio::io::AsyncRead;
```
[10.409800]
[10.409826]
```
use tokio::io::{AsyncRead, AsyncReadExt};
```
Deletion in thrussh/src/cipher/mod.rs at line 22 [10.409086]
B:BD[10.409867] → [10.409867:409890]
```
use tokio::prelude::*;
```
Replacement in thrussh/src/cipher/mod.rs at line 109 [10.409086]
B:BD[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.421956]

B:BD[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.421956]

B:BD[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.421956]

B:BD[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.24]

B:BD[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.426118]
B:BD[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.426118]
B:BD[10.427069] → [11.1620:1684]
B:BD[11.1684] → [15.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.426118]

B:BD[10.427168] → [11.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" ] }

Deletion in thrussh/Cargo.toml at line 54 [10.426118]
B:BD[10.427314] → [10.427314:427329]
```
anyhow = "1.0"
```

Replacement in thrussh/Cargo.toml at line 58 [10.426118]

B:BD[10.427414] → [11.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"

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

Dependencies

In channels

Change contents

Replacement in thrussh-keys/src/signature.rs at line 53 [10.5821]

Insertion in thrussh-keys/src/lib.rs at line 117 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 137 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 157 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 221 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 233 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 255 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 295 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 359 [10.21590]

Replacement in thrussh-keys/src/lib.rs at line 387 [10.21590]

Replacement in thrussh-keys/src/key.rs at line 124 [10.57451]

Replacement in thrussh-keys/src/key.rs at line 304 [10.57451]

Replacement in thrussh-keys/src/key.rs at line 324 [10.57451]

Replacement in thrussh-keys/src/key.rs at line 349 [10.57451]

Replacement in thrussh-keys/src/key.rs at line 374 [10.57451]

Replacement in thrussh-keys/src/key.rs at line 394 [10.57451]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 24 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 137 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 204 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 212 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 219 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 264 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 354 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 367 [10.71340]

Replacement in thrussh-keys/src/format/pkcs8.rs at line 411 [10.71340]

Replacement in thrussh-keys/src/format/pkcs5.rs at line 14 [10.85753]

Replacement in thrussh-keys/src/format/openssh.rs at line 11 [10.86809]

Replacement in thrussh-keys/src/format/openssh.rs at line 87 [10.86809]

Replacement in thrussh-keys/src/format/mod.rs at line 38 [10.92032]

Replacement in thrussh-keys/src/format/mod.rs at line 90 [10.92032]

Replacement in thrussh-keys/src/format/mod.rs at line 103 [10.92032]

Replacement in thrussh-keys/src/format/mod.rs at line 111 [10.92032]

Insertion in thrussh-keys/src/agent/server.rs at line 7 [10.125237]

Deletion in thrussh-keys/src/agent/server.rs at line 15 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 88 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 108 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 201 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 208 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 219 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 236 [10.125237]

Replacement in thrussh-keys/src/agent/server.rs at line 347 [10.125237]

Replacement in thrussh-keys/src/agent/client.rs at line 34 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 44 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 58 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 64 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 89 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 158 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 195 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 207 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 220 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 274 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 320 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 338 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 361 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 368 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 404 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 416 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 429 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 439 [10.139093]

Replacement in thrussh-keys/src/agent/client.rs at line 452 [10.139093]

Replacement in thrussh-keys/Cargo.toml at line 3 [10.157024]

Replacement in thrussh-keys/Cargo.toml at line 32 [10.157024]

Replacement in thrussh-keys/Cargo.toml at line 34 [10.157024]

Replacement in thrussh-keys/Cargo.toml at line 37 [10.157024]

Replacement in thrussh-keys/Cargo.toml at line 45 [10.157024]

Deletion in thrussh-keys/Cargo.toml at line 47 [10.157024]

Replacement in thrussh-config/src/lib.rs at line 1 [10.161114]

Insertion in thrussh-config/src/lib.rs at line 5 [10.161114]

Replacement in thrussh-config/Cargo.toml at line 4 [10.164787]

Deletion in thrussh-config/Cargo.toml at line 13 [10.164787]

Replacement in thrussh-config/Cargo.toml at line 15 [10.164787]

Replacement in thrussh-config/Cargo.toml at line 17 [10.164787]

Replacement in thrussh/src/ssh_read.rs at line 113 [10.166688]

Replacement in thrussh/src/session.rs at line 463 [10.171602]

Replacement in thrussh/src/server/session.rs at line 144 [10.188192]

Deletion in thrussh/src/server/mod.rs at line 21 [10.203388]