The user may have the data hashed as MD5 or SHA-1, so we should provide
both types for consumption.

Instead of using the libssh2 defines, provide our own, which eases usage
as we do not need to check whether libgit2 was built with libssh2 or not.

Instead of spreading the data in function arguments, some of which
aren't used for ssh and having a struct only for ssh, use a struct for
both, using a common parent to pass to the callback.

Test that the certificate check callback gets the right fingerprint from
the host we're connecting to.

This option make it easy to ignore anything about the server we're
connecting to, which is bad security practice. This was necessary as we
didn't use to expose detailed information about the certificate, but now
that we do, we should get rid of this.

If the user wants to ignore everything, they can still provide a
callback which ignores all the information passed.

This should make the mingw compiler happy.

If the user returns 0 from the certificate check and we had certificate issues, set the options to ignore certificate errors and resend the request.

We need to call WinHttpSendRequest() in three different places. Unify all in a single function to have a single place for the certificate check.

If we're not using SSL, don't call the user's certificate check callback.

On successful connection, still ask the user whether they accept the server's certificate, indicating that WinHTTP would let it though.

Returning 0 lets the certificate check succeed. An error code is bubbled
up to the user.

We know the host's key as soon as we connect, so we should perform the
check as soon as we can, before we bother with the user's credentials.

We should let the user decide whether to cancel the connection or not
regardless of whether our checks have decided that the certificate is
fine. We provide our own assessment to the callback to let the user fall
back to our checks if they so desire.

Instead of the parsed data, we can ask OpenSSL to give us the
DER-encoded version of the certificate, which the user can then parse
and validate.

If the certificate validation fails (or always in the case of ssh),
let the user decide whether to allow the connection.

The data structure passed to the user is the native certificate
information from the underlying implementation, namely OpenSSL or
WinHTTP.

Add Rust to the language bindings list

When auto follow tags, FETCH_HEAD should list only newly followed tags

signature: don't allow empty emails

A signature is made up of a non-empty name and a non-empty email so
let's validate that. This also brings us more in line with git, which
also rejects ident with an empty email.

Restrict which refs can be the default branch

ssh: store error message immediately after a failed agent call

When the call to the agent fails, we must retrieve the error message
just after the function call, as other calls may overwrite it.

As the agent authentication is the only one which has a teardown and
there does not seem to be a way to get the error message from a stored
error number, this tries to introduce some small changes to store the
error from the agent.

Clearing the error at the beginning of the loop lets us know whether the
agent has already set the libgit2 error message and we should skip it,
or if we should set it.

Clean up transport lookup

Teach repository to use relative paths for git symbolic links

Several CppCat warnings fixed

Teach git_repository_init_ext to use relative paths for the gitlink
to the work directory. This is used when creating a sub repository
where the sub repository resides in the parent repository's
.git directory.

.editorconfig added to repository

Skip SSH clone tests if libgit2 not built with GIT_SSH defined

When the fetch refspec does not include the remote's default branch, it
indicates an error in user expectations or programmer error. Error out
in that case.

This lets us get rid of the dummy refspec which can never work as its
zeroed out. In the cases where we did not find a default branch, we set
HEAD detached immediately, which lets us refactor the "normal" path,
removing `found_branch`.

If the remote does not advertise HEAD, then it is unborn and we cannot
checkout that branch. Handle it the same way as an empty repo.

When cloning, we may be asking for a particular branch or subset of
branches. Make sure we test for that.