readme = "README.md" travis-ci = { repository = "dtolnay/thiserror" }  [dependencies]-thiserror-impl = { version = "=1.0.11", path = "impl" }+thiserror-impl = { version = "=1.0.11", path = "impl", default-features = false }  [dev-dependencies] anyhow = "1.0" ref-cast = "1.0" rustversion = "1.0" trybuild = { version = "1.0.19", features = ["diff"] } +[features]+default = ["std"]

 impl<T: Clone + Integer + Signed> Signed for Ratio<T> { }  // String conversions-impl<T> fmt::Display for Ratio<T>-where-    T: fmt::Display + Eq + One,-{-    /// Renders as `numer/denom`. If denom=1, renders as numer.-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {-        if self.denom.is_one() {-            write!(f, "{}", self.numer)-        } else {-            write!(f, "{}/{}", self.numer, self.denom)+macro_rules! impl_formatting {+    ($fmt_trait:ident, $prefix:expr, $fmt_str:expr, $fmt_alt:expr) => {+        impl<T: $fmt_trait + PartialEq + One> $fmt_trait for Ratio<T> {

 mod test {         assert!(!_NEG1_2.is_integer());     } +    #[cfg(not(feature = "std"))]+    use core::fmt;+    #[cfg(not(feature = "std"))]+    use fmt::Write;+    #[cfg(not(feature = "std"))]+    const TESTER_BUF_SIZE: usize = 32;+    #[cfg(not(feature = "std"))]+    #[derive(Debug)]+    struct NoStdTester {+        cursor: usize,+        buf: [u8; TESTER_BUF_SIZE],+    }++    #[cfg(not(feature = "std"))]+    impl NoStdTester {+        fn new() -> NoStdTester {+            NoStdTester {+                buf: [0; TESTER_BUF_SIZE],+                cursor: 0,+            }+        }++        fn clear(&mut self) {+            self.cursor = 0;+        }+    }++    #[cfg(not(feature = "std"))]+    impl Write for NoStdTester {+        fn write_str(&mut self, s: &str) -> fmt::Result {+            for byte in s.bytes() {+                self.buf[self.cursor] = byte;+                self.cursor += 1;+                if self.cursor >= self.buf.len() {+                    return Err(fmt::Error {});+                }+            }+            Ok(())+        }+    }++    #[cfg(not(feature = "std"))]+    impl PartialEq<str> for NoStdTester {+        fn eq(&self, other: &str) -> bool {+            let other = other.as_bytes();+            for index in 0..self.cursor {+                if self.buf.get(index) != other.get(index) {+                    return false;+                }+            }+            true+        }+    }++    #[test]+    #[cfg(not(feature = "std"))]+    fn test_show() {+        let err_msg = "Formatted output too long";+        let mut tester = NoStdTester::new();+        write!(tester, "{:o}", _8).expect(err_msg);+        assert_eq!(tester, *"10");+        tester.clear();+    }+     #[test]     #[cfg(feature = "std")]     fn test_show() {-        use std::string::ToString;-        assert_eq!(format!("{}", _2), "2".to_string());-        assert_eq!(format!("{}", _1_2), "1/2".to_string());-        assert_eq!(format!("{}", _0), "0".to_string());-        assert_eq!(format!("{}", Ratio::from_integer(-2)), "-2".to_string());+        // Test:+        // :b :o :x, :X, :?+        // alternate or not (#)+        // positive and negative+        // padding+        // does not test precision (i.e. truncation)+        assert_eq!(&format!("{}", _2), "2");+        assert_eq!(&format!("{}", _1_2), "1/2");+        assert_eq!(&format!("{}", -_1_2), "-1/2"); // test negatives+        assert_eq!(&format!("{}", _0), "0");+        assert_eq!(&format!("{}", -_2), "-2");+        assert_eq!(&format!("{:b}", _2), "10");+        assert_eq!(&format!("{:b}", _1_2), "1/10");+        assert_eq!(&format!("{:b}", _0), "0");+        assert_eq!(&format!("{:#b}", _1_2), "0b1/0b10");+        assert_eq!(&format!("{:010b}", _1_2), "0000001/10");+        assert_eq!(&format!("{:#010b}", _1_2), "0b001/0b10");+        let half_i8: Ratio<i8> = Ratio::new(1_i8, 2_i8);+        assert_eq!(&format!("{:b}", -half_i8), "11111111/10");+        assert_eq!(&format!("{:#b}", -half_i8), "0b11111111/0b10");++        assert_eq!(&format!("{:o}", _8), "10");+        assert_eq!(&format!("{:o}", _1_8), "1/10");+        assert_eq!(&format!("{:o}", _0), "0");+        assert_eq!(&format!("{:#o}", _1_8), "0o1/0o10");+        assert_eq!(&format!("{:010o}", _1_8), "0000001/10");+        assert_eq!(&format!("{:#010o}", _1_8), "0o001/0o10");+        assert_eq!(&format!("{:o}", -half_i8), "377/2");+        assert_eq!(&format!("{:#o}", -half_i8), "0o377/0o2");++        assert_eq!(&format!("{:x}", _16), "10");+        assert_eq!(&format!("{:x}", _15), "f");+        assert_eq!(&format!("{:x}", _1_16), "1/10");+        assert_eq!(&format!("{:x}", _1_15), "1/f");+        assert_eq!(&format!("{:x}", _0), "0");+        assert_eq!(&format!("{:#x}", _1_16), "0x1/0x10");+        assert_eq!(&format!("{:010x}", _1_16), "0000001/10");+        assert_eq!(&format!("{:#010x}", _1_16), "0x001/0x10");+        assert_eq!(&format!("{:x}", -half_i8), "ff/2");+        assert_eq!(&format!("{:#x}", -half_i8), "0xff/0x2");++        assert_eq!(&format!("{:X}", _16), "10");+        assert_eq!(&format!("{:X}", _15), "F");+        assert_eq!(&format!("{:X}", _1_16), "1/10");+        assert_eq!(&format!("{:X}", _1_15), "1/F");+        assert_eq!(&format!("{:X}", _0), "0");+        assert_eq!(&format!("{:#X}", _1_16), "0x1/0x10");+        assert_eq!(&format!("{:010X}", _1_16), "0000001/10");+        assert_eq!(&format!("{:#010X}", _1_16), "0x001/0x10");+        assert_eq!(&format!("{:X}", -half_i8), "FF/2");+        assert_eq!(&format!("{:#X}", -half_i8), "0xFF/0x2");++        let _one_tehth_1_f = Ratio {

 mod test {         assert!(!_NEG1_2.is_integer());     } +    #[cfg(not(feature = "std"))]+    use core::fmt;+    #[cfg(not(feature = "std"))]+    use fmt::Write;

+use super::plumbing::*;+use super::*;+use std::iter;+use std::usize;++/// `StepBy` is an iterator that skip `n` element between each yield. where `n` is the given step+/// This struct is created by the [`step_by()`] method on [`IndexedParallelIterator`]+///+/// [`step_by()`]: trait.IndexedParallelIterator.html#method.step_by+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]+#[derive(Debug, Clone)]+pub struct StepBy<I: IndexedParallelIterator> {+    base: I,+    step: usize,+}++impl<I> StepBy<I>+    where+        I: IndexedParallelIterator,+{+    /// Create a new `StepBy` iterator.+    pub(super) fn new(base: I, step: usize) -> Self {+        StepBy { base, step }+    }+}++impl<I> ParallelIterator for StepBy<I>+    where+        I: IndexedParallelIterator,+{+    type Item = I::Item;++    fn drive_unindexed<C>(self, consumer: C) -> C::Result+        where+            C: UnindexedConsumer<Self::Item>, {+        bridge(self, consumer)+    }+}++impl<I> IndexedParallelIterator for StepBy<I>+    where+        I: IndexedParallelIterator,+{+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {+        bridge(self, consumer)+    }++    fn len(&self) -> usize {+        if (self.base.len() % self.step) == 0 {+            self.base.len() / self.step+        }+        else {+            //the addition is needed because the first element is always yielded+            (self.base.len() / self.step) + 1+        }+    }++    fn with_producer<CB>(self, callback: CB) -> CB::Output+        where+            CB: ProducerCallback<Self::Item>,+    {+        return self.base.with_producer(Callback {callback, step: self.step});++        struct Callback<CB> {+            callback: CB,+            step: usize,+        }++        impl<T, CB> ProducerCallback<T> for Callback<CB>+            where+                CB: ProducerCallback<T>,+        {+            type Output = CB::Output;+            fn callback<P>(self, base: P) -> CB::Output+                where+                    P: Producer<Item = T>,+            {+                let producer = StepByProducer { base, step: self.step };+                self.callback.callback(producer)+            }+        }+    }+}++/// ////////////////////////////////////////////////////////////////////////+/// Producer implementation++struct StepByProducer<P> {+    base: P,+    step: usize,+}++impl<P> Producer for StepByProducer<P>+    where+        P: Producer,+{+    type Item = P::Item;+    type IntoIter = iter::StepBy<P::IntoIter>;++    fn into_iter(self) -> Self::IntoIter {+        self.base.into_iter().step_by(self.step)+    }++    fn split_at(self, index: usize) -> (Self, Self) {+        let (left, right) = self.base.split_at(index * self.step);+        (+            StepByProducer {+                base: left,+                step: self.step,+            },+            StepByProducer {+                base: right,+                step: self.step,+            },+        )+    }+}

+use super::plumbing::*;+use super::*;+use std::iter;+use std::usize;++/// `StepBy` is an iterator that skip `n` element between each yield. where `n` is the given step+/// This struct is created by the [`step_by()`] method on [`IndexedParallelIterator`]+///+/// [`step_by()`]: trait.IndexedParallelIterator.html#method.step_by+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]+#[derive(Debug, Clone)]+pub struct StepBy<I: IndexedParallelIterator> {+    base: I,+    step: usize,+}++impl<I> StepBy<I>+    where+        I: IndexedParallelIterator,+{+    /// Create a new `StepBy` iterator.+    pub(super) fn new(base: I, step: usize) -> Self {+        StepBy { base, step }+    }+}++impl<I> ParallelIterator for StepBy<I>+    where+        I: IndexedParallelIterator,+{+    type Item = I::Item;++    fn drive_unindexed<C>(self, consumer: C) -> C::Result+        where+            C: UnindexedConsumer<Self::Item>, {+        bridge(self, consumer)+    }+}

+use super::plumbing::*;+use super::*;+use std::iter;+use std::usize;++/// `StepBy` is an iterator that skip `n` element between each yield. where `n` is the given step+/// This struct is created by the [`step_by()`] method on [`IndexedParallelIterator`]+///+/// [`step_by()`]: trait.IndexedParallelIterator.html#method.step_by+/// [`IndexedParallelIterator`]: trait.IndexedParallelIterator.html+#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]+#[derive(Debug, Clone)]+pub struct StepBy<I: IndexedParallelIterator> {+    base: I,+    step: usize,+}++impl<I> StepBy<I>+    where+        I: IndexedParallelIterator,+{+    /// Create a new `StepBy` iterator.+    pub(super) fn new(base: I, step: usize) -> Self {+        StepBy { base, step }+    }+}++impl<I> ParallelIterator for StepBy<I>+    where+        I: IndexedParallelIterator,+{+    type Item = I::Item;++    fn drive_unindexed<C>(self, consumer: C) -> C::Result+        where+            C: UnindexedConsumer<Self::Item>, {+        bridge(self, consumer)+    }+}++impl<I> IndexedParallelIterator for StepBy<I>+    where+        I: IndexedParallelIterator,+{+    fn drive<C: Consumer<Self::Item>>(self, consumer: C) -> C::Result {+        bridge(self, consumer)+    }++    fn len(&self) -> usize {+        if (self.base.len() % self.step) == 0 {+            self.base.len() / self.step+        }+        else {+            //the addition is needed because the first element is always yielded+            (self.base.len() / self.step) + 1+        }+    }

 impl<T: Clone + Integer + Signed> Signed for Ratio<T> { }  // String conversions-impl<T> fmt::Display for Ratio<T>-where-    T: fmt::Display + Eq + One,-{-    /// Renders as `numer/denom`. If denom=1, renders as numer.-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {-        if self.denom.is_one() {-            write!(f, "{}", self.numer)-        } else {-            write!(f, "{}/{}", self.numer, self.denom)+macro_rules! impl_formatting {+    ($fmt_trait:ident, $prefix:expr, $fmt_str:expr, $fmt_alt:expr) => {+        impl<T: $fmt_trait + PartialEq + One> $fmt_trait for Ratio<T> {

 mod test {         assert!(!_NEG1_2.is_integer());     } +    #[cfg(not(feature = "std"))]+    use core::fmt;+    #[cfg(not(feature = "std"))]+    use fmt::Write;+    #[cfg(not(feature = "std"))]+    const TESTER_BUF_SIZE: usize = 32;+    #[cfg(not(feature = "std"))]+    #[derive(Debug)]+    struct NoStdTester {+        cursor: usize,+        buf: [u8; TESTER_BUF_SIZE],+    }++    #[cfg(not(feature = "std"))]+    impl NoStdTester {+        fn new() -> NoStdTester {+            NoStdTester {+                buf: [0; TESTER_BUF_SIZE],+                cursor: 0,+            }+        }++        fn clear(&mut self) {+            self.cursor = 0;+        }+    }++    #[cfg(not(feature = "std"))]+    impl Write for NoStdTester {+        fn write_str(&mut self, s: &str) -> fmt::Result {+            for byte in s.bytes() {+                self.buf[self.cursor] = byte;+                self.cursor += 1;+                if self.cursor >= self.buf.len() {+                    return Err(fmt::Error {});+                }+            }+            Ok(())+        }+    }++    #[cfg(not(feature = "std"))]+    impl PartialEq<str> for NoStdTester {+        fn eq(&self, other: &str) -> bool {+            let other = other.as_bytes();+            for index in 0..self.cursor {+                if self.buf.get(index) != other.get(index) {+                    return false;+                }+            }+            true+        }+    }++    #[test]+    #[cfg(not(feature = "std"))]+    fn test_show() {+        let err_msg = "Formatted output too long";+        let mut tester = NoStdTester::new();+        write!(tester, "{:o}", _8).expect(err_msg);+        assert_eq!(tester, *"10");

 impl<T: Clone + Integer + Signed> Signed for Ratio<T> { }  // String conversions-impl<T> fmt::Display for Ratio<T>-where-    T: fmt::Display + Eq + One,-{-    /// Renders as `numer/denom`. If denom=1, renders as numer.-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {-        if self.denom.is_one() {-            write!(f, "{}", self.numer)-        } else {-            write!(f, "{}/{}", self.numer, self.denom)+macro_rules! impl_formatting {+    ($fmt_trait:ident, $prefix:expr, $fmt_str:expr, $fmt_alt:expr) => {+        impl<T: $fmt_trait + PartialEq + One> $fmt_trait for Ratio<T> {

 mod test {         assert!(!_NEG1_2.is_integer());     } +    #[cfg(not(feature = "std"))]+    use core::fmt;+    #[cfg(not(feature = "std"))]+    use fmt::Write;+    #[cfg(not(feature = "std"))]+    const TESTER_BUF_SIZE: usize = 32;+    #[cfg(not(feature = "std"))]+    #[derive(Debug)]+    struct NoStdTester {+        cursor: usize,+        buf: [u8; TESTER_BUF_SIZE],+    }++    #[cfg(not(feature = "std"))]+    impl NoStdTester {+        fn new() -> NoStdTester {+            NoStdTester {+                buf: [0; TESTER_BUF_SIZE],+                cursor: 0,+            }+        }++        fn clear(&mut self) {+            self.cursor = 0;+        }+    }++    #[cfg(not(feature = "std"))]+    impl Write for NoStdTester {+        fn write_str(&mut self, s: &str) -> fmt::Result {+            for byte in s.bytes() {+                self.buf[self.cursor] = byte;+                self.cursor += 1;+                if self.cursor >= self.buf.len() {+                    return Err(fmt::Error {});+                }+            }+            Ok(())+        }+    }++    #[cfg(not(feature = "std"))]+    impl PartialEq<str> for NoStdTester {+        fn eq(&self, other: &str) -> bool {+            let other = other.as_bytes();+            for index in 0..self.cursor {+                if self.buf.get(index) != other.get(index) {+                    return false;+                }+            }+            true+        }+    }++    #[test]+    #[cfg(not(feature = "std"))]+    fn test_show() {+        let err_msg = "Formatted output too long";+        let mut tester = NoStdTester::new();+        write!(tester, "{:o}", _8).expect(err_msg);+        assert_eq!(tester, *"10");+        tester.clear();+    }+     #[test]     #[cfg(feature = "std")]     fn test_show() {-        use std::string::ToString;-        assert_eq!(format!("{}", _2), "2".to_string());-        assert_eq!(format!("{}", _1_2), "1/2".to_string());-        assert_eq!(format!("{}", _0), "0".to_string());-        assert_eq!(format!("{}", Ratio::from_integer(-2)), "-2".to_string());+        // Test:+        // :b :o :x, :X, :?+        // alternate or not (#)+        // positive and negative+        // padding+        // does not test precision (i.e. truncation)+        assert_eq!(&format!("{}", _2), "2");+        assert_eq!(&format!("{}", _1_2), "1/2");+        assert_eq!(&format!("{}", -_1_2), "-1/2"); // test negatives+        assert_eq!(&format!("{}", _0), "0");+        assert_eq!(&format!("{}", -_2), "-2");+        assert_eq!(&format!("{:b}", _2), "10");+        assert_eq!(&format!("{:b}", _1_2), "1/10");+        assert_eq!(&format!("{:b}", _0), "0");+        assert_eq!(&format!("{:#b}", _1_2), "0b1/0b10");+        assert_eq!(&format!("{:010b}", _1_2), "0000001/10");+        assert_eq!(&format!("{:#010b}", _1_2), "0b001/0b10");+        let half_i8: Ratio<i8> = Ratio::new(1_i8, 2_i8);+        assert_eq!(&format!("{:b}", -half_i8), "11111111/10");+        assert_eq!(&format!("{:#b}", -half_i8), "0b11111111/0b10");++        assert_eq!(&format!("{:o}", _8), "10");+        assert_eq!(&format!("{:o}", _1_8), "1/10");+        assert_eq!(&format!("{:o}", _0), "0");+        assert_eq!(&format!("{:#o}", _1_8), "0o1/0o10");+        assert_eq!(&format!("{:010o}", _1_8), "0000001/10");+        assert_eq!(&format!("{:#010o}", _1_8), "0o001/0o10");+        assert_eq!(&format!("{:o}", -half_i8), "377/2");+        assert_eq!(&format!("{:#o}", -half_i8), "0o377/0o2");++        assert_eq!(&format!("{:x}", _16), "10");+        assert_eq!(&format!("{:x}", _15), "f");+        assert_eq!(&format!("{:x}", _1_16), "1/10");+        assert_eq!(&format!("{:x}", _1_15), "1/f");+        assert_eq!(&format!("{:x}", _0), "0");+        assert_eq!(&format!("{:#x}", _1_16), "0x1/0x10");+        assert_eq!(&format!("{:010x}", _1_16), "0000001/10");+        assert_eq!(&format!("{:#010x}", _1_16), "0x001/0x10");+        assert_eq!(&format!("{:x}", -half_i8), "ff/2");+        assert_eq!(&format!("{:#x}", -half_i8), "0xff/0x2");++        assert_eq!(&format!("{:X}", _16), "10");+        assert_eq!(&format!("{:X}", _15), "F");+        assert_eq!(&format!("{:X}", _1_16), "1/10");+        assert_eq!(&format!("{:X}", _1_15), "1/F");+        assert_eq!(&format!("{:X}", _0), "0");+        assert_eq!(&format!("{:#X}", _1_16), "0x1/0x10");+        assert_eq!(&format!("{:010X}", _1_16), "0000001/10");+        assert_eq!(&format!("{:#010X}", _1_16), "0x001/0x10");+        assert_eq!(&format!("{:X}", -half_i8), "FF/2");+        assert_eq!(&format!("{:#X}", -half_i8), "0xFF/0x2");++        let _one_tehth_1_f = Ratio {

+/*+ * Copyright (C) the libgit2 contributors. All rights reserved.+ *+ * This file is part of libgit2, distributed under the GNU GPL v2 with+ * a Linking Exception. For full terms see the included COPYING file.+ */++#include "common.h"+#include "../transports/ssh.h"+#include "git2/sys/cred.h"++#if defined(GIT_SSH) && defined(GIT_LIBSSH2)++void git__ssh_error(git_ssh_session *s, const char *errmsg)+{+	char *ssherr;+	libssh2_session_last_error(s->session, &ssherr, NULL, 0);++	git_error_set(GIT_ERROR_SSH, "%s: %s", errmsg, ssherr);+}++void git_ssh__session_free(git_ssh_session *s)+{+	if (!s)+		return;++	libssh2_session_free(s->session);+	git__free(s);+}++int git_ssh__session_create(+	git_ssh_session **out_session,+	git_stream *io)+{+	int rc = 0;+	git_ssh_session *s;+	git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent);++	assert(out_session);++	s = git__calloc(1, sizeof(*s));+	if (!s) {+		git_error_set_oom();+		return -1;+	}++	s->session = git_ssh_session_new();+	if (!s->session) {+		git_error_set(GIT_ERROR_NET, "failed to initialize SSH session");+		goto cleanup;+	}++	do {+		rc = libssh2_session_handshake(s->session, socket->s);+	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);++	if (rc != GIT_SSH_ERROR_NONE) {+		git__ssh_error(s, "failed to start SSH session");+		goto cleanup;+	}++	libssh2_session_set_blocking(s->session, 1);++	*out_session = s;++	return 0;++cleanup:+	git_ssh__session_free(s);++	return -1;+}++git_ssh_channel *git_ssh_channel_open(git_ssh_session *s)+{+	git_ssh_channel *channel;++	channel = git__calloc(1, sizeof(*channel));+	if (!channel) {+		git_error_set_oom();+		return NULL;+	}++	channel->channel = libssh2_channel_open_session(s->session);++	if (channel->channel)+		libssh2_channel_set_blocking(channel->channel, 1);++	return channel;+}++int git_ssh_channel_read(char *buffer, size_t size, int is_stderr, git_ssh_channel *c)+{+	if (is_stderr)+		return libssh2_channel_read_stderr(c->channel, buffer, size);+	return libssh2_channel_read(c->channel, buffer, size);+}++int git_ssh_channel_write(git_ssh_channel *c, const char *buffer, size_t size)+{+	return libssh2_channel_write(c->channel, buffer, size);+}++int git_ssh_channel_exec(git_ssh_channel *c, const char *request)+{+	return libssh2_channel_exec(c->channel, request);+}++int git_ssh_session_server_hostkey(git_ssh_session *s, git_cert_hostkey *cert)+{+	const char *key;++	key = libssh2_hostkey_hash(s->session, LIBSSH2_HOSTKEY_HASH_SHA1);+	if (key != NULL) {+		cert->type |= GIT_CERT_SSH_SHA1;+		memcpy(&cert->hash_sha1, key, 20);+	}++	key = libssh2_hostkey_hash(s->session, LIBSSH2_HOSTKEY_HASH_MD5);+	if (key != NULL) {+		cert->type |= GIT_CERT_SSH_MD5;+		memcpy(&cert->hash_md5, key, 16);+	}++	if (cert->type == 0) {+		git_error_set(GIT_ERROR_SSH, "unable to get the host key");+		return -1;+	}++	return 0;+}++#define SSH_AUTH_PUBLICKEY "publickey"+#define SSH_AUTH_PASSWORD "password"+#define SSH_AUTH_KEYBOARD_INTERACTIVE "keyboard-interactive"++int git__ssh_list_auth_methods(int *out, git_ssh_session *s, const char *username)+{+	const char *list, *ptr;++	*out = 0;++	list = libssh2_userauth_list(s->session, username, strlen(username));++	/* either error, or the remote accepts NONE auth, which is bizarre, let's punt */+	if (list == NULL && !libssh2_userauth_authenticated(s->session)) {+		git__ssh_error(s, "Failed to retrieve list of SSH authentication methods");+		return -1;+	}++	ptr = list;+	while (ptr) {+		if (*ptr == ',')+			ptr++;++		if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) {+			*out |= GIT_CREDTYPE_SSH_KEY;+			*out |= GIT_CREDTYPE_SSH_CUSTOM;+#ifdef GIT_SSH_MEMORY_CREDENTIALS+			*out |= GIT_CREDTYPE_SSH_MEMORY;+#endif+			ptr += strlen(SSH_AUTH_PUBLICKEY);+			continue;+		}++		if (!git__prefixcmp(ptr, SSH_AUTH_PASSWORD)) {+			*out |= GIT_CREDTYPE_USERPASS_PLAINTEXT;+			ptr += strlen(SSH_AUTH_PASSWORD);+			continue;+		}++		if (!git__prefixcmp(ptr, SSH_AUTH_KEYBOARD_INTERACTIVE)) {+			*out |= GIT_CREDTYPE_SSH_INTERACTIVE;+			ptr += strlen(SSH_AUTH_KEYBOARD_INTERACTIVE);+			continue;+		}++		/* Skipt it if we don't know it */+		ptr = strchr(ptr, ',');+	}++	return 0;+}++int git__ssh_agent_auth(git_ssh_session *s, git_cred_ssh_key *c)+{+	int rc = GIT_SSH_ERROR_NONE;++	struct libssh2_agent_publickey *curr, *prev = NULL;++	LIBSSH2_AGENT *agent = libssh2_agent_init(s->session);++	if (agent == NULL)+		return -1;++	rc = libssh2_agent_connect(agent);++	if (rc != LIBSSH2_ERROR_NONE)+		goto shutdown;++	rc = libssh2_agent_list_identities(agent);++	if (rc != LIBSSH2_ERROR_NONE)+		goto shutdown;++	while (1) {+		rc = libssh2_agent_get_identity(agent, &curr, prev);++		if (rc < 0)+			goto shutdown;++		/* rc is set to 1 whenever the ssh agent ran out of keys to check.+		 * Set the error code to authentication failure rather than erroring+		 * out with an untranslatable error code.+		 */+		if (rc == 1) {+			rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;+			goto shutdown;+		}++		rc = libssh2_agent_userauth(agent, c->username, curr);++		if (rc == 0)+			break;++		prev = curr;+	}++shutdown:++	if (rc != LIBSSH2_ERROR_NONE)+		git__ssh_error(s, "error authenticating");++	libssh2_agent_disconnect(agent);+	libssh2_agent_free(agent);++	return rc;+}++struct git_ssh__sign_payload+{+	git_cred_sign_cb sign_cb;+	void *user_payload;+};++static inline LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC(git_ssh__sign_cb)+{+	struct git_ssh__sign_payload *payload = *abstract;++	return payload->sign_cb((git_ssh_session *)session,+							sig, sig_len,+							data, data_len, payload->user_payload);+}++struct git_ssh__kbdint_payload+{+	LIBSSH2_SESSION *session;+	git_cred_ssh_interactive_cb kbdint_cb;+	void *user_payload;+};++static inline LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(git_ssh__kbdint_cb)+{+	struct git_ssh__kbdint_payload *payload = *abstract;++	GIT_UNUSED(prompts);+	GIT_UNUSED(responses);++	return payload->kbdint_cb((git_ssh_session *)payload->session,+							  name, name_len,+							  instruction, instruction_len,+							  num_prompts, NULL, NULL,+							  payload->user_payload);+}++int _git_ssh_authenticate_session(git_ssh_session *s, git_cred *cred)+{+	int rc;++	do {+		git_error_clear();+		switch (cred->credtype) {+			case GIT_CREDTYPE_USERPASS_PLAINTEXT: {+				git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;+				rc = libssh2_userauth_password(s->session, c->username, c->password);+				break;+			}+			case GIT_CREDTYPE_SSH_KEY: {+				git_cred_ssh_key *c = (git_cred_ssh_key *)cred;++				if (c->privatekey) {+					rc = libssh2_userauth_publickey_fromfile(+						s->session, c->username, c->publickey,+						c->privatekey, c->passphrase);+				} else+					rc = git__ssh_agent_auth(s, c);++				break;+			}+			case GIT_CREDTYPE_SSH_CUSTOM: {+				git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;+				struct git_ssh__sign_payload payload = { c->sign_callback, &c->payload };++				rc = libssh2_userauth_publickey(+					s->session, c->username, (const unsigned char *)c->publickey,+					c->publickey_len, git_ssh__sign_cb, (void **)&payload);+				break;+			}+			case GIT_CREDTYPE_SSH_INTERACTIVE: {+				git_cred_ssh_interactive *c = (git_cred_ssh_interactive *)cred;+				void **abstract = libssh2_session_abstract(s->session);+				struct git_ssh__kbdint_payload payload;+				payload.kbdint_cb = c->prompt_callback;+				payload.session = s->session;+				payload.user_payload = c->payload;++				/* ideally, we should be able to set this by calling+				 * libssh2_session_init_ex() instead of libssh2_session_init().+				 * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey()+				 * allows you to pass the `abstract` as part of the call, whereas+				 * libssh2_userauth_keyboard_interactive() does not!+				 *+				 * The only way to set the `abstract` pointer is by calling+				 * libssh2_session_abstract(), which will replace the existing+				 * pointer as is done below. This is safe for now (at time of writing),+				 * but may not be valid in future.+				 */+				*abstract = &payload;++				rc = libssh2_userauth_keyboard_interactive(+					s->session, c->username, git_ssh__kbdint_cb);++				*abstract = old_abstract;

 #define INCLUDE_transports_ssh_h__  #include "common.h"+#include "../streams/socket.h"  int git_transport_ssh_global_init(void); +#ifdef GIT_SSH++#ifdef GIT_LIBSSH2++#include <libssh2.h>++#define GIT_SSH_ERROR_NONE LIBSSH2_ERROR_NONE++struct git_ssh_session {+	LIBSSH2_SESSION *session;+};++#define git_ssh_session_new() libssh2_session_init()+#define git_ssh_session_disconnect(s, msg) \+	libssh2_session_disconnect(s->session, msg);++struct git_ssh_channel {+	LIBSSH2_CHANNEL *channel;+};++#define git_ssh_channel_close(c) libssh2_channel_close(c->channel)+#define git_ssh_channel_free(c) libssh2_channel_free(c->channel)

 #define INCLUDE_transports_ssh_h__  #include "common.h"+#include "../streams/socket.h"  int git_transport_ssh_global_init(void); +#ifdef GIT_SSH++#ifdef GIT_LIBSSH2++#include <libssh2.h>++#define GIT_SSH_ERROR_NONE LIBSSH2_ERROR_NONE++struct git_ssh_session {+	LIBSSH2_SESSION *session;+};++#define git_ssh_session_new() libssh2_session_init()+#define git_ssh_session_disconnect(s, msg) \+	libssh2_session_disconnect(s->session, msg);++struct git_ssh_channel {+	LIBSSH2_CHANNEL *channel;+};++#define git_ssh_channel_close(c) libssh2_channel_close(c->channel)

 OPTION(TAGS				"Generate tags"						OFF) OPTION(PROFILE				"Generate profiling information"			OFF) OPTION(ENABLE_TRACE			"Enables tracing support"				OFF) OPTION(LIBGIT2_FILENAME			"Name of the produced binary"				OFF)-OPTION(USE_SSH				"Link with libssh2 to enable SSH support"		 ON)+OPTION(USE_SSH				"Enable SSH support. Can be set to a specific backend (libssh2)" ON)

 mod test {         assert!(!_NEG1_2.is_integer());     } +    #[cfg(not(feature = "std"))]+    use core::fmt;+    #[cfg(not(feature = "std"))]+    use fmt::Write;