try build against 1.8.x

Signed-off-by: Jeff Carr <jcarr@wit.com>

.github/workflows/backport.yml

@@ -1,54 +0,0 @@
-name: Backport to older releases
-on:
-  push:
-    branches:
-    - main
-
-jobs:
-
-  backport:
-    name: Backport change to branch ${{ matrix.branch }}
-    continue-on-error: true
-    strategy:
-      fail-fast: false
-      matrix:
-        branch: [ 'release-0.28', 'release-0.27' ]
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Check out code
-      uses: actions/checkout@v1
-      with:
-        fetch-depth: 0
-    - name: Create a cherry-pick PR
-      run: |
-        if ! git diff --quiet HEAD^ HEAD -- vendor/libgit2; then
-          echo '::warning::Skipping cherry-pick since it is a vendored libgit2 bump'
-          exit 0
-        fi
-
-        BRANCH_NAME="cherry-pick-${{ github.run_id }}-${{ matrix.branch }}"
-
-        # Setup usernames and authentication
-        git config --global user.name "${{ github.actor }}"
-        git config --global user.email "${{ github.actor }}@users.noreply.github.com"
-        cat <<- EOF > $HOME/.netrc
-        machine github.com
-        login ${{ github.actor }}
-        password ${{ secrets.GITHUB_TOKEN }}
-        machine api.github.com
-        login ${{ github.actor }}
-        password ${{ secrets.GITHUB_TOKEN }}
-        EOF
-        chmod 600 $HOME/.netrc
-
-        # Create the cherry-pick commit and create the PR for it.
-        git checkout "${{ matrix.branch }}"
-        git switch -c "${BRANCH_NAME}"
-        git cherry-pick -x "${{ github.sha }}"
-        git push --set-upstream origin "${BRANCH_NAME}"
-        GITHUB_TOKEN="${{ secrets.GITHUB_TOKEN }}" gh pr create \
-          --base "${{ matrix.branch }}" \
-          --title "$(git --no-pager show --format="%s" --no-patch HEAD)" \
-          --body "$(git --no-pager show --format="%b" --no-patch HEAD)"

.github/workflows/ci.yml

@@ -1,133 +0,0 @@
-name: git2go CI
-on:
-  pull_request:
-  push:
-    branches:
-    - main
-    - release-*
-    - v*
-
-jobs:
-
-  build-static:
-    strategy:
-      fail-fast: false
-      matrix:
-        go: [ '1.11', '1.12', '1.13', '1.14', '1.15', '1.16', '1.17' ]
-    name: Go ${{ matrix.go }}
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Set up Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: ${{ matrix.go }}
-      id: go
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v1
-    - name: Build
-      run: |
-        git submodule update --init
-        sudo apt-get install -y --no-install-recommends libssh2-1-dev
-        make build-libgit2-static
-    - name: Test
-      run:  make TEST_ARGS=-test.v test-static
-
-  build-dynamic:
-    strategy:
-      fail-fast: false
-    name: Go (dynamic)
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Set up Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: '1.17'
-      id: go
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v1
-    - name: Build
-      run: |
-        git submodule update --init
-        sudo apt-get install -y --no-install-recommends libssh2-1-dev
-        make build-libgit2-dynamic
-    - name: Test
-      run: make TEST_ARGS=-test.v test-dynamic
-
-  build-system-dynamic:
-    strategy:
-      fail-fast: false
-      matrix:
-        libgit2:
-          - 'v1.0.0'
-          - 'v1.1.0'
-          - 'v1.2.0'
-          - 'v1.3.0'
-    name: Go (system-wide, dynamic)
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Set up Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: '1.17'
-      id: go
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v1
-    - name: Build libgit2 ${{ matrix.libgit2 }}
-      run: |
-        git submodule update --init
-        sudo apt-get install -y --no-install-recommends libssh2-1-dev
-        sudo env BUILD_LIBGIT_REF=${{ matrix.libgit2 }} ./script/build-libgit2.sh --dynamic --system
-    - name: Test
-      run: make TEST_ARGS=-test.v test
-
-  build-system-static:
-    strategy:
-      fail-fast: false
-    name: Go (system-wide, static)
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Set up Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: '1.17'
-      id: go
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v1
-    - name: Build libgit2
-      run: |
-        git submodule update --init
-        sudo apt-get install -y --no-install-recommends libssh2-1-dev
-        sudo ./script/build-libgit2.sh --static --system
-    - name: Test
-      run: go test --count=1 --tags "static,system_libgit2" ./...
-
-  check-generate:
-    name: Check generated files were not modified
-    runs-on: ubuntu-20.04
-    steps:
-    - name: Set up Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: '1.17'
-      id: go
-    - name: Check out code into the Go module directory
-      uses: actions/checkout@v2
-    - name: Install libgit2 build dependencies
-      run: |
-        git submodule update --init
-        sudo apt-get install -y --no-install-recommends libssh2-1-dev
-        go install golang.org/x/tools/cmd/stringer@latest
-    - name: Generate files
-      run: |
-        export PATH=$(go env GOPATH)/bin:$PATH
-        make generate
-    - name: Check nothing changed
-      run: git diff --quiet --exit-code || (echo "detected changes after generate" ; git status ; exit 1)

.github/workflows/tag.yml

@@ -1,28 +0,0 @@
-name: Tag new releases
-on:
-  push:
-    branches:
-    - main
-    - release-*
-
-jobs:
-
-  tag-release:
-    name: Bump tag in ${{ github.ref }}
-
-    runs-on: ubuntu-20.04
-
-    steps:
-    - name: Check out code
-      uses: actions/checkout@v1
-      with:
-        fetch-depth: 0
-    - name: Bump version and push tag
-      id: bump-version
-      uses: anothrNick/github-tag-action@43ed073f5c1445ca8b80d920ce2f8fa550ae4e8d
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        WITH_V: true
-        DEFAULT_BUMP: patch
-        TAG_CONTEXT: branch
-        RELEASE_BRANCHES: .*

.gitignore

@@ -1,2 +1,4 @@
 /static-build/
 /dynamic-build/
+
+go.*

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "vendor/libgit2"]
-	path = vendor/libgit2
-	url = https://github.com/libgit2/libgit2

Build_bundled_static.go

@@ -1,3 +1,4 @@
+//go:build static && !system_libgit2
 // +build static,!system_libgit2
 
 package git
@@ -9,8 +10,8 @@ package git
 #cgo CFLAGS: -DLIBGIT2_STATIC
 #include <git2.h>
 
-#if LIBGIT2_VER_MAJOR != 1 || LIBGIT2_VER_MINOR < 0 || LIBGIT2_VER_MINOR > 3
-# error "Invalid libgit2 version; this git2go supports libgit2 between v1.0.0 and v1.3.0".
+#if LIBGIT2_VER_MAJOR != 1 || LIBGIT2_VER_MINOR < 5 || LIBGIT2_VER_MINOR > 5
+# error "Invalid libgit2 version; this libgit2 supports libgit2 between v1.5.0 and v1.5.0"
 #endif
 */
 import "C"

Build_system_dynamic.go

@@ -1,14 +1,14 @@
+//go:build !static
 // +build !static
 
 package git
 
 /*
 #cgo pkg-config: libgit2
-#cgo CFLAGS: -DLIBGIT2_DYNAMIC
+#cgo CFLAGS: -DLIBGIT2_DYNAMIC -I/opt/libgit2/include
+#cgo LDFLAGS: -L/opt/libgit2 -lgit2
 #include <git2.h>
 
-#if LIBGIT2_VER_MAJOR != 1 || LIBGIT2_VER_MINOR < 0 || LIBGIT2_VER_MINOR > 3
-# error "Invalid libgit2 version; this git2go supports libgit2 between v1.0.0 and v1.3.0".
-#endif
+
 */
 import "C"

Build_system_static.go

@@ -1,3 +1,4 @@
+//go:build static && system_libgit2
 // +build static,system_libgit2
 
 package git
@@ -7,8 +8,8 @@ package git
 #cgo CFLAGS: -DLIBGIT2_STATIC
 #include <git2.h>
 
-#if LIBGIT2_VER_MAJOR != 1 || LIBGIT2_VER_MINOR < 0 || LIBGIT2_VER_MINOR > 3
-# error "Invalid libgit2 version; this git2go supports libgit2 between v1.0.0 and v1.3.0".
+#if LIBGIT2_VER_MAJOR != 1 || LIBGIT2_VER_MINOR < 5 || LIBGIT2_VER_MINOR > 5
+# error "Invalid libgit2 version; this libgit2 supports libgit2 between v1.5.0 and v1.5.0"
 #endif
 */
 import "C"

LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2013 The git2go contributors
+Copyright (c) 2013 The libgit2 contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,7 +1,11 @@
 TEST_ARGS ?= --count=1
 
-default: test
+PKG_CONFIG_PATH=/opt/libgit2/
 
+default: goimports test
+
+goimports:
+	goimports -w *.go
 
 generate: static-build/install/lib/libgit2.a
 	go generate --tags "static" ./...
@@ -10,12 +14,19 @@ generate: static-build/install/lib/libgit2.a
 # ==============
 # This uses whatever version of libgit2 can be found in the system.
 test:
+	-go-mod-clean # go install go.wit.com/apps/go-mod-clean@latest
 	go run script/check-MakeGitError-thread-lock.go
-	go test $(TEST_ARGS) ./...
+	PKG_CONFIG_PATH=/opt/libgit2/ go test -v -x $(TEST_ARGS) ./...
+
+add-remote:
+	git remote add git2go https://github.com/libgit2/git2go.git
 
 install:
 	go install ./...
 
+clean:
+	rm go.*
+
 # Bundled dynamic library
 # =======================
 # In order to avoid having to manipulate `git_dynamic.go`, which would prevent

README.md

@@ -1,87 +1,48 @@
-git2go
+GO libgit2
 ======
-[![GoDoc](https://godoc.org/github.com/libgit2/git2go?status.svg)](http://godoc.org/github.com/libgit2/git2go/v30) [![Build Status](https://travis-ci.org/libgit2/git2go.svg?branch=main)](https://travis-ci.org/libgit2/git2go)
+[![GoDoc](https://godoc.org/go.wit.com/lib/libgit2?status.svg)](http://godoc.org/go.wit.com/lib/libgit2) [![Build Status](https://travis-ci.org/libgit2/libgit2.svg?branch=main)](https://travis-ci.org/libgit2/libgit2)
 
 Go bindings for [libgit2](http://libgit2.github.com/).
 
+### Updated 2024/12/16
+
 ### Which Go version to use
 
-Due to the fact that Go 1.11 module versions have semantic meaning and don't necessarily align with libgit2's release schedule, please consult the following table for a mapping between libgit2 and git2go module versions:
-
-| libgit2 | git2go        |
-|---------|---------------|
-| main    | (will be v31) |
-| 1.0     | v30           |
-| 0.99    | v29           |
-| 0.28    | v28           |
-| 0.27    | v27           |
-
-You can import them in your project with the version's major number as a suffix. For example, if you have libgit2 v1.0 installed, you'd import git2go v30 with
+* This package is updated to work against libgit2 version 1.8 on Debian sid
+* There is one line commented out which needs to be fixed in remote.go
+* some of the tests seem to run
 
 ```sh
-go get github.com/libgit2/git2go/v30
-```
-```go
-import "github.com/libgit2/git2go/v30"
+go install go.wit.com/apps/go-clone@latest
+go install go.wit.com/apps/go-mod-clean@latest
+go-clone --recusive go.wit.com/lib/libgit2
 ```
 
-which will ensure there are no sudden changes to the API.
-
-The `main` branch follows the tip of libgit2 itself (with some lag) and as such has no guarantees on the stability of libgit2's API. Thus this only supports statically linking against libgit2.
 
 ### Which branch to send Pull requests to
 
-If there's something version-specific that you'd want to contribute to, you can send them to the `release-${MAJOR}.${MINOR}` branches, which follow libgit2's releases.
+TODO: not sure yet
 
 Installing
 ----------
 
 This project wraps the functionality provided by libgit2. It thus needs it in order to perform the work.
 
-This project wraps the functionality provided by libgit2. If you're using a versioned branch, install it to your system via your system's package manager and then install git2go.
+This project wraps the functionality provided by libgit2. If you're using a versioned branch, install it to your system via your system's package manager and then install libgit2.
 
 
 ### Versioned branch, dynamic linking
 
-When linking dynamically against a released version of libgit2, install it via your system's package manager. CGo will take care of finding its pkg-config file and set up the linking. Import via Go modules, e.g. to work against libgit2 v1.0
+When linking dynamically against a released version of libgit2, install it via your system's package manager. CGo will take care of finding its pkg-config file and set up the linking. Import via Go modules, e.g. to work against libgit2 v1.2
 
 ```go
-import "github.com/libgit2/git2go/v30"
+    goimports -w *.go
 ```
 
-### Versioned branch, static linking
-
-Follow the instructions for [Versioned branch, dynamic linking](#versioned-branch-dynamic-linking), but pass the `-tags static,system_libgit2` flag to all `go` commands that build any binaries. For instance:
-
-    go build -tags static,system_libgit2 github.com/my/project/...
-    go test -tags static,system_libgit2 github.com/my/project/...
-    go install -tags static,system_libgit2 github.com/my/project/...
-
-### `main` branch, or vendored static linking
-
-If using `main` or building a branch with the vendored libgit2 statically, we need to build libgit2 first. In order to build it, you need `cmake`, `pkg-config` and a C compiler. You will also need the development packages for OpenSSL (outside of Windows or macOS) and LibSSH2 installed if you want libgit2 to support HTTPS and SSH respectively. Note that even if libgit2 is included in the resulting binary, its dependencies will not be.
-
-Run `go get -d github.com/libgit2/git2go` to download the code and go to your `$GOPATH/src/github.com/libgit2/git2go` directory. From there, we need to build the C code and put it into the resulting go binary.
-
-    git submodule update --init # get libgit2
-    make install-static
-
-will compile libgit2, link it into git2go and install it. The `main` branch is set up to follow the specific libgit2 version that is vendored, so trying dynamic linking may or may not work depending on the exact versions involved.
-
-In order to let Go pass the correct flags to `pkg-config`, `-tags static` needs to be passed to all `go` commands that build any binaries. For instance:
-
-    go build -tags static github.com/my/project/...
-    go test -tags static github.com/my/project/...
-    go install -tags static github.com/my/project/...
-
-One thing to take into account is that since Go expects the `pkg-config` file to be within the same directory where `make install-static` was called, so the `go.mod` file may need to have a [`replace` directive](https://github.com/golang/go/wiki/Modules#when-should-i-use-the-replace-directive) so that the correct setup is achieved. So if `git2go` is checked out at `$GOPATH/src/github.com/libgit2/git2go` and your project at `$GOPATH/src/github.com/my/project`, the `go.mod` file of `github.com/my/project` might need to have a line like
-
-    replace github.com/libgit2/git2go/v30 => ../../libgit2/git2go
-
 Parallelism and network operations
 ----------------------------------
 
-libgit2 may use OpenSSL and LibSSH2 for performing encrypted network connections. For now, git2go asks libgit2 to set locking for OpenSSL. This makes HTTPS connections thread-safe, but it is fragile and will likely stop doing it soon. This may also make SSH connections thread-safe if your copy of libssh2 is linked against OpenSSL. Check libgit2's `THREADSAFE.md` for more information.
+libgit2 may use OpenSSL and LibSSH2 for performing encrypted network connections. For now, libgit2 asks libgit2 to set locking for OpenSSL. This makes HTTPS connections thread-safe, but it is fragile and will likely stop doing it soon. This may also make SSH connections thread-safe if your copy of libssh2 is linked against OpenSSL. Check libgit2's `THREADSAFE.md` for more information.
 
 Running the tests
 -----------------
@@ -103,6 +64,6 @@ M to the I to the T. See the LICENSE file if you've never seen an MIT license be
 Authors
 -------
 
-- Carlos Martín (@carlosmn)
-- Vicent Martí (@vmg)
+- Carlos Martín (github@carlosmn)
+- Vicent Martí (github@vmg)
 

blame.go

@@ -48,6 +48,7 @@ const (
 	BlameTrackCopiesAnyCommitCopies  BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES
 	BlameFirstParent                 BlameOptionsFlag = C.GIT_BLAME_FIRST_PARENT
 	BlameUseMailmap                  BlameOptionsFlag = C.GIT_BLAME_USE_MAILMAP
+	BlameIgnoreWhitespace            BlameOptionsFlag = C.GIT_BLAME_IGNORE_WHITESPACE
 )
 
 func (v *Repository) BlameFile(path string, opts *BlameOptions) (*Blame, error) {

checkout.go

@@ -7,7 +7,6 @@ extern void _go_git_populate_checkout_callbacks(git_checkout_options *opts);
 */
 import "C"
 import (
-	"errors"
 	"os"
 	"runtime"
 	"unsafe"
@@ -49,8 +48,8 @@ const (
 	CheckoutUpdateSubmodulesIfChanged CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED // Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED)
 )
 
-type CheckoutNotifyCallback func(why CheckoutNotifyType, path string, baseline, target, workdir DiffFile) ErrorCode
-type CheckoutProgressCallback func(path string, completed, total uint) ErrorCode
+type CheckoutNotifyCallback func(why CheckoutNotifyType, path string, baseline, target, workdir DiffFile) error
+type CheckoutProgressCallback func(path string, completed, total uint)
 
 type CheckoutOptions struct {
 	Strategy         CheckoutStrategy   // Default will be a dry run
@@ -116,9 +115,9 @@ func checkoutNotifyCallback(
 	if data.options.NotifyCallback == nil {
 		return C.int(ErrorCodeOK)
 	}
-	ret := data.options.NotifyCallback(CheckoutNotifyType(why), path, baseline, target, workdir)
-	if ret < 0 {
-		*data.errorTarget = errors.New(ErrorCode(ret).String())
+	err := data.options.NotifyCallback(CheckoutNotifyType(why), path, baseline, target, workdir)
+	if err != nil {
+		*data.errorTarget = err
 		return C.int(ErrorCodeUser)
 	}
 	return C.int(ErrorCodeOK)

cherrypick.go

@@ -9,18 +9,16 @@ import (
 )
 
 type CherrypickOptions struct {
-	Version      uint
-	Mainline     uint
-	MergeOpts    MergeOptions
-	CheckoutOpts CheckoutOptions
+	Mainline        uint
+	MergeOptions    MergeOptions
+	CheckoutOptions CheckoutOptions
 }
 
 func cherrypickOptionsFromC(c *C.git_cherrypick_options) CherrypickOptions {
 	opts := CherrypickOptions{
-		Version:      uint(c.version),
-		Mainline:     uint(c.mainline),
-		MergeOpts:    mergeOptionsFromC(&c.merge_opts),
-		CheckoutOpts: checkoutOptionsFromC(&c.checkout_opts),
+		Mainline:        uint(c.mainline),
+		MergeOptions:    mergeOptionsFromC(&c.merge_opts),
+		CheckoutOptions: checkoutOptionsFromC(&c.checkout_opts),
 	}
 	return opts
 }
@@ -31,8 +29,8 @@ func populateCherrypickOptions(copts *C.git_cherrypick_options, opts *Cherrypick
 		return nil
 	}
 	copts.mainline = C.uint(opts.Mainline)
-	populateMergeOptions(&copts.merge_opts, &opts.MergeOpts)
-	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOpts, errorTarget)
+	populateMergeOptions(&copts.merge_opts, &opts.MergeOptions)
+	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOptions, errorTarget)
 	return copts
 }
 
@@ -82,7 +80,7 @@ func (r *Repository) CherrypickCommit(pick, our *Commit, opts CherrypickOptions)
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	cOpts := populateMergeOptions(&C.git_merge_options{}, &opts.MergeOpts)
+	cOpts := populateMergeOptions(&C.git_merge_options{}, &opts.MergeOptions)
 	defer freeMergeOptions(cOpts)
 
 	var ptr *C.git_index

clone.go

@@ -7,16 +7,15 @@ extern void _go_git_populate_clone_callbacks(git_clone_options *opts);
 */
 import "C"
 import (
-	"errors"
 	"runtime"
 	"unsafe"
 )
 
-type RemoteCreateCallback func(repo *Repository, name, url string) (*Remote, ErrorCode)
+type RemoteCreateCallback func(repo *Repository, name, url string) (*Remote, error)
 
 type CloneOptions struct {
-	*CheckoutOpts
-	*FetchOptions
+	CheckoutOptions      CheckoutOptions
+	FetchOptions         FetchOptions
 	Bare                 bool
 	CheckoutBranch       string
 	RemoteCreateCallback RemoteCreateCallback
@@ -71,9 +70,10 @@ func remoteCreateCallback(
 		panic("invalid remote create callback")
 	}
 
-	remote, ret := data.options.RemoteCreateCallback(repo, name, url)
-	if ret < 0 {
-		*data.errorTarget = errors.New(ErrorCode(ret).String())
+	remote, err := data.options.RemoteCreateCallback(repo, name, url)
+
+	if err != nil {
+		*data.errorTarget = err
 		return C.int(ErrorCodeUser)
 	}
 	if remote == nil {
@@ -100,8 +100,8 @@ func populateCloneOptions(copts *C.git_clone_options, opts *CloneOptions, errorT
 	if opts == nil {
 		return nil
 	}
-	populateCheckoutOptions(&copts.checkout_opts, opts.CheckoutOpts, errorTarget)
-	populateFetchOptions(&copts.fetch_opts, opts.FetchOptions, errorTarget)
+	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOptions, errorTarget)
+	populateFetchOptions(&copts.fetch_opts, &opts.FetchOptions, errorTarget)
 	copts.bare = cbool(opts.Bare)
 
 	if opts.RemoteCreateCallback != nil {

clone_test.go

@@ -50,15 +50,9 @@ func TestCloneWithCallback(t *testing.T) {
 
 	opts := CloneOptions{
 		Bare: true,
-		RemoteCreateCallback: func(r *Repository, name, url string) (*Remote, ErrorCode) {
+		RemoteCreateCallback: func(r *Repository, name, url string) (*Remote, error) {
 			testPayload += 1
-
-			remote, err := r.Remotes.Create(REMOTENAME, url)
-			if err != nil {
-				return nil, ErrorCodeGeneric
-			}
-
-			return remote, ErrorCodeOK
+			return r.Remotes.Create(REMOTENAME, url)
 		},
 	}
 

commit.go

@@ -37,10 +37,14 @@ func (c *Commit) Message() string {
 	return ret
 }
 
-func (c *Commit) MessageEncoding() string {
-	ret := C.GoString(C.git_commit_message_encoding(c.cast_ptr))
+func (c *Commit) MessageEncoding() MessageEncoding {
+	ptr := C.git_commit_message_encoding(c.cast_ptr)
+	if ptr == nil {
+		return MessageEncodingUTF8
+	}
+	ret := C.GoString(ptr)
 	runtime.KeepAlive(c)
-	return ret
+	return MessageEncoding(ret)
 }
 
 func (c *Commit) RawMessage() string {
@@ -64,6 +68,19 @@ func (c *Commit) ContentToSign() string {
 // CommitSigningCallback defines a function type that takes some data to sign and returns (signature, signature_field, error)
 type CommitSigningCallback func(string) (signature, signatureField string, err error)
 
+// CommitCreateCallback defines a function type that is called when another
+// function is going to create commits (for example, Rebase) to allow callers
+// to override the commit creation behavior. For example, users may wish to
+// sign commits by providing this information to Repository.CreateCommitBuffer,
+// signing that buffer, then calling Repository.CreateCommitWithSignature.
+type CommitCreateCallback func(
+	author, committer *Signature,
+	messageEncoding MessageEncoding,
+	message string,
+	tree *Tree,
+	parents ...*Commit,
+) (oid *Oid, err error)
+
 // WithSignatureUsing creates a new signed commit from this one using the given signing callback
 func (c *Commit) WithSignatureUsing(f CommitSigningCallback) (*Oid, error) {
 	signature, signatureField, err := f(c.ContentToSign())

deprecated.go

@@ -230,7 +230,27 @@ func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer)
 	if !ok {
 		panic("invalid submodule visitor callback")
 	}
-	return (C.int)(callback(sub, C.GoString(name)))
+	err := callback(sub, C.GoString(name))
+	if err != nil {
+		return C.int(ErrorCodeUser)
+	}
+	return C.int(ErrorCodeOK)
+}
+
+// reference.go
+
+// Deprecated: ReferenceIsValidName is a deprecated alias of ReferenceNameIsValid.
+func ReferenceIsValidName(name string) bool {
+	valid, _ := ReferenceNameIsValid(name)
+	return valid
+}
+
+// remote.go
+
+// Deprecated: RemoteIsValidName is a deprecated alias of RemoteNameIsValid.
+func RemoteIsValidName(name string) bool {
+	valid, _ := RemoteNameIsValid(name)
+	return valid
 }
 
 // tree.go
@@ -239,9 +259,13 @@ func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer)
 func CallbackGitTreeWalk(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer) C.int {
 	root := C.GoString(_root)
 
-	if callback, ok := pointerHandles.Get(ptr).(TreeWalkCallback); ok {
-		return C.int(callback(root, newTreeEntry(entry)))
-	} else {
+	callback, ok := pointerHandles.Get(ptr).(TreeWalkCallback)
+	if !ok {
 		panic("invalid treewalk callback")
 	}
+	err := callback(root, newTreeEntry(entry))
+	if err != nil {
+		return C.int(ErrorCodeUser)
+	}
+	return C.int(ErrorCodeOK)
 }

git.go

@@ -171,7 +171,7 @@ func initLibGit2() {
 }
 
 // Shutdown frees all the resources acquired by libgit2. Make sure no
-// references to any git2go objects are live before calling this.
+// references to any libgit2 go objects are live before calling this.
 // After this is called, invoking any function from this library will result in
 // undefined behavior, so make sure this is called carefully.
 func Shutdown() {
@@ -229,7 +229,7 @@ func NewOid(s string) (*Oid, error) {
 	}
 
 	if len(slice) != 20 {
-		return nil, &GitError{"Invalid Oid", ErrorClassNone, ErrGeneric}
+		return nil, &GitError{"invalid oid", ErrorClassNone, ErrorCodeGeneric}
 	}
 
 	copy(o[:], slice[:20])

go.mod

@@ -1,9 +0,0 @@
-module github.com/libgit2/git2go/v30
-
-go 1.13
-
-require (
-	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
-	golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c
-	golang.org/x/sys v0.0.0-20201204225414-ed752295db88 // indirect
-)

go.sum

@@ -1,13 +0,0 @@
-github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
-github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c h1:9HhBz5L/UjnK9XLtiZhYAdue5BVKep3PMmS2LuPDt8k=
-golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88 h1:KmZPnMocC93w341XZp26yTJg8Za7lhb2KhkYmixoeso=
-golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221 h1:/ZHdbVpdR/jk3g30/d4yUL0JU9kksj8+F/bnQUVLGDM=
-golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

graph.go

@@ -40,3 +40,30 @@ func (repo *Repository) AheadBehind(local, upstream *Oid) (ahead, behind int, er
 
 	return int(aheadT), int(behindT), nil
 }
+
+// ReachableFromAny returns whether a commit is reachable from any of a list of
+// commits by following parent edges.
+func (repo *Repository) ReachableFromAny(commit *Oid, descendants []*Oid) (bool, error) {
+	if len(descendants) == 0 {
+		return false, nil
+	}
+
+	coids := make([]C.git_oid, len(descendants))
+	for i := 0; i < len(descendants); i++ {
+		coids[i] = *descendants[i].toC()
+	}
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_graph_reachable_from_any(repo.ptr, commit.toC(), &coids[0], C.size_t(len(descendants)))
+	runtime.KeepAlive(repo)
+	runtime.KeepAlive(commit)
+	runtime.KeepAlive(coids)
+	runtime.KeepAlive(descendants)
+	if ret < 0 {
+		return false, MakeGitError(ret)
+	}
+
+	return (ret > 0), nil
+}

graph_test.go

@@ -0,0 +1,75 @@
+package git
+
+import (
+	"testing"
+)
+
+func TestReachableFromAny(t *testing.T) {
+	repo, err := OpenRepository("testdata/TestGitRepository.git")
+	checkFatal(t, err)
+	defer repo.Free()
+
+	for name, tc := range map[string]struct {
+		reachable   bool
+		commit      string
+		descendants []string
+	}{
+		"empty": {
+			reachable: false,
+			commit:    "49322bb17d3acc9146f98c97d078513228bbf3c0",
+		},
+		"same": {
+			reachable:   true,
+			commit:      "49322bb17d3acc9146f98c97d078513228bbf3c0",
+			descendants: []string{"49322bb17d3acc9146f98c97d078513228bbf3c0"},
+		},
+		"unreachable": {
+			reachable:   false,
+			commit:      "ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+			descendants: []string{"58be4659bb571194ed4562d04b359d26216f526e"},
+		},
+		"unreachable-reverse": {
+			reachable:   false,
+			commit:      "58be4659bb571194ed4562d04b359d26216f526e",
+			descendants: []string{"ac7e7e44c1885efb472ad54a78327d66bfc4ecef"},
+		},
+		"root": {
+			reachable: false,
+			commit:    "42e4e7c5e507e113ebbb7801b16b52cf867b7ce1",
+			descendants: []string{
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"d86a2aada2f5e7ccf6f11880bfb9ab404e8a8864",
+				"f73b95671f326616d66b2afb3bdfcdbbce110b44",
+				"d0114ab8ac326bab30e3a657a0397578c5a1af88",
+			},
+		},
+		"head": {
+			reachable: false,
+			commit:    "49322bb17d3acc9146f98c97d078513228bbf3c0",
+			descendants: []string{
+				"ac7e7e44c1885efb472ad54a78327d66bfc4ecef",
+				"d86a2aada2f5e7ccf6f11880bfb9ab404e8a8864",
+				"f73b95671f326616d66b2afb3bdfcdbbce110b44",
+				"d0114ab8ac326bab30e3a657a0397578c5a1af88",
+			},
+		},
+	} {
+		tc := tc
+		t.Run(name, func(t *testing.T) {
+			commit, err := NewOid(tc.commit)
+			checkFatal(t, err)
+
+			descendants := make([]*Oid, len(tc.descendants))
+			for i, o := range tc.descendants {
+				descendants[i], err = NewOid(o)
+				checkFatal(t, err)
+			}
+			reachable, err := repo.ReachableFromAny(commit, descendants)
+			checkFatal(t, err)
+
+			if reachable != tc.reachable {
+				t.Errorf("ReachableFromAny(%s, %v) = %v, wanted %v", tc.commit, tc.descendants, reachable, tc.reachable)
+			}
+		})
+	}
+}

http.go

@@ -38,17 +38,17 @@ func registerManagedHTTP() error {
 
 func httpSmartSubtransportFactory(remote *Remote, transport *Transport) (SmartSubtransport, error) {
 	var proxyFn func(*http.Request) (*url.URL, error)
-	proxyOpts, err := transport.SmartProxyOptions()
+	remoteConnectOpts, err := transport.SmartRemoteConnectOptions()
 	if err != nil {
 		return nil, err
 	}
-	switch proxyOpts.Type {
+	switch remoteConnectOpts.ProxyOptions.Type {
 	case ProxyTypeNone:
 		proxyFn = nil
 	case ProxyTypeAuto:
 		proxyFn = http.ProxyFromEnvironment
 	case ProxyTypeSpecified:
-		parsedUrl, err := url.Parse(proxyOpts.Url)
+		parsedUrl, err := url.Parse(remoteConnectOpts.ProxyOptions.Url)
 		if err != nil {
 			return nil, err
 		}
@@ -103,7 +103,7 @@ func (t *httpSmartSubtransport) Action(url string, action SmartServiceAction) (S
 		return nil, err
 	}
 
-	req.Header.Set("User-Agent", "git/2.0 (git2go)")
+	req.Header.Set("User-Agent", "git/2.0 (libgit2)")
 
 	stream := newManagedHttpStream(t, req)
 	if req.Method == "POST" {
@@ -203,7 +203,9 @@ func (self *httpSmartSubtransportStream) sendRequest() error {
 			req.ContentLength = -1
 		}
 
-		req.SetBasicAuth(userName, password)
+		if userName != "" && password != "" {
+			req.SetBasicAuth(userName, password)
+		}
 		resp, err = http.DefaultClient.Do(req)
 		if err != nil {
 			return err

index.go

@@ -10,13 +10,12 @@ extern int _go_git_index_remove_all(git_index*, const git_strarray*, void*);
 */
 import "C"
 import (
-	"errors"
 	"fmt"
 	"runtime"
 	"unsafe"
 )
 
-type IndexMatchedPathCallback func(string, string) int
+type IndexMatchedPathCallback func(string, string) error
 type indexMatchedPathCallbackData struct {
 	callback    IndexMatchedPathCallback
 	errorTarget *error
@@ -343,9 +342,9 @@ func indexMatchedPathCallback(cPath, cMatchedPathspec *C.char, payload unsafe.Po
 		panic("invalid matched path callback")
 	}
 
-	ret := data.callback(C.GoString(cPath), C.GoString(cMatchedPathspec))
-	if ret < 0 {
-		*data.errorTarget = errors.New(ErrorCode(ret).String())
+	err := data.callback(C.GoString(cPath), C.GoString(cMatchedPathspec))
+	if err != nil {
+		*data.errorTarget = err
 		return C.int(ErrorCodeUser)
 	}
 

index_test.go

@@ -223,9 +223,9 @@ func TestIndexAddAllCallback(t *testing.T) {
 	checkFatal(t, err)
 
 	cbPath := ""
-	err = idx.AddAll([]string{}, IndexAddDefault, func(p, mP string) int {
+	err = idx.AddAll([]string{}, IndexAddDefault, func(p, mP string) error {
 		cbPath = p
-		return 0
+		return nil
 	})
 	checkFatal(t, err)
 	if cbPath != "README" {

indexer_test.go

@@ -33,9 +33,9 @@ func TestIndexerOutOfOrder(t *testing.T) {
 	defer os.RemoveAll(tmpPath)
 
 	var finalStats TransferProgress
-	idx, err := NewIndexer(tmpPath, nil, func(stats TransferProgress) ErrorCode {
+	idx, err := NewIndexer(tmpPath, nil, func(stats TransferProgress) error {
 		finalStats = stats
-		return ErrorCodeOK
+		return nil
 	})
 	checkFatal(t, err)
 	defer idx.Free()

merge.go

@@ -138,7 +138,6 @@ const (
 )
 
 type MergeOptions struct {
-	Version   uint
 	TreeFlags MergeTreeFlag
 
 	RenameThreshold uint
@@ -151,7 +150,6 @@ type MergeOptions struct {
 
 func mergeOptionsFromC(opts *C.git_merge_options) MergeOptions {
 	return MergeOptions{
-		Version:         uint(opts.version),
 		TreeFlags:       MergeTreeFlag(opts.flags),
 		RenameThreshold: uint(opts.rename_threshold),
 		TargetLimit:     uint(opts.target_limit),

odb.go

@@ -176,6 +176,32 @@ func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) {
 	return obj, nil
 }
 
+func (odb *Odb) Refresh() error {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_odb_refresh(odb.ptr)
+	runtime.KeepAlive(odb)
+	if ret < 0 {
+		return MakeGitError(ret)
+	}
+
+	return nil
+}
+
+func (odb *Odb) WriteMultiPackIndex() error {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	ret := C.git_odb_write_multi_pack_index(odb.ptr)
+	runtime.KeepAlive(odb)
+	if ret < 0 {
+		return MakeGitError(ret)
+	}
+
+	return nil
+}
+
 type OdbForEachCallback func(id *Oid) error
 type odbForEachCallbackData struct {
 	callback    OdbForEachCallback

odb_test.go

@@ -167,9 +167,9 @@ func TestOdbWritepack(t *testing.T) {
 	checkFatal(t, err)
 
 	var finalStats TransferProgress
-	writepack, err := odb.NewWritePack(func(stats TransferProgress) ErrorCode {
+	writepack, err := odb.NewWritePack(func(stats TransferProgress) error {
 		finalStats = stats
-		return ErrorCodeOK
+		return nil
 	})
 	checkFatal(t, err)
 	defer writepack.Free()

rebase.go

@@ -9,6 +9,7 @@ import "C"
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"runtime"
 	"unsafe"
 )
@@ -71,76 +72,140 @@ func newRebaseOperationFromC(c *C.git_rebase_operation) *RebaseOperation {
 	return operation
 }
 
-//export commitSigningCallback
-func commitSigningCallback(errorMessage **C.char, _signature *C.git_buf, _signature_field *C.git_buf, _commit_content *C.char, handle unsafe.Pointer) C.int {
+//export commitCreateCallback
+func commitCreateCallback(
+	errorMessage **C.char,
+	_out *C.git_oid,
+	_author, _committer *C.git_signature,
+	_message_encoding, _message *C.char,
+	_tree *C.git_tree,
+	_parent_count C.size_t,
+	_parents **C.git_commit,
+	handle unsafe.Pointer,
+) C.int {
 	data, ok := pointerHandles.Get(handle).(*rebaseOptionsData)
 	if !ok {
 		panic("invalid sign payload")
 	}
 
-	if data.options.CommitSigningCallback == nil {
+	if data.options.CommitCreateCallback == nil && data.options.CommitSigningCallback == nil {
 		return C.int(ErrorCodePassthrough)
 	}
 
-	commitContent := C.GoString(_commit_content)
-
-	signature, signatureField, err := data.options.CommitSigningCallback(commitContent)
-	if err != nil {
-		if data.errorTarget != nil {
-			*data.errorTarget = err
-		}
-		return setCallbackError(errorMessage, err)
+	messageEncoding := MessageEncodingUTF8
+	if _message_encoding != nil {
+		messageEncoding = MessageEncoding(C.GoString(_message_encoding))
+	}
+	tree := &Tree{
+		Object: Object{
+			ptr:  (*C.git_object)(_tree),
+			repo: data.repo,
+		},
+		cast_ptr: _tree,
 	}
 
-	fillBuf := func(bufData string, buf *C.git_buf) error {
-		clen := C.size_t(len(bufData))
-		cstr := unsafe.Pointer(C.CString(bufData))
-		defer C.free(cstr)
-
-		// libgit2 requires the contents of the buffer to be NULL-terminated.
-		// C.CString() guarantees that the returned buffer will be
-		// NULL-terminated, so we can safely copy the terminator.
-		if int(C.git_buf_set(buf, cstr, clen+1)) != 0 {
-			return errors.New("could not set buffer")
+	var goParents []*C.git_commit
+	if _parent_count > 0 {
+		hdr := reflect.SliceHeader{
+			Data: uintptr(unsafe.Pointer(_parents)),
+			Len:  int(_parent_count),
+			Cap:  int(_parent_count),
 		}
-
-		return nil
+		goParents = *(*[]*C.git_commit)(unsafe.Pointer(&hdr))
 	}
 
-	if signatureField != "" {
-		err := fillBuf(signatureField, _signature_field)
+	parents := make([]*Commit, int(_parent_count))
+	for i, p := range goParents {
+		parents[i] = &Commit{
+			Object: Object{
+				ptr:  (*C.git_object)(p),
+				repo: data.repo,
+			},
+			cast_ptr: p,
+		}
+	}
+
+	if data.options.CommitCreateCallback != nil {
+		oid, err := data.options.CommitCreateCallback(
+			newSignatureFromC(_author),
+			newSignatureFromC(_committer),
+			messageEncoding,
+			C.GoString(_message),
+			tree,
+			parents...,
+		)
 		if err != nil {
 			if data.errorTarget != nil {
 				*data.errorTarget = err
 			}
 			return setCallbackError(errorMessage, err)
 		}
-	}
-
-	err = fillBuf(signature, _signature)
-	if err != nil {
-		if data.errorTarget != nil {
-			*data.errorTarget = err
+		if oid == nil {
+			return C.int(ErrorCodePassthrough)
 		}
-		return setCallbackError(errorMessage, err)
+		*_out = *oid.toC()
+	} else if data.options.CommitSigningCallback != nil {
+		commitContent, err := data.repo.CreateCommitBuffer(
+			newSignatureFromC(_author),
+			newSignatureFromC(_committer),
+			messageEncoding,
+			C.GoString(_message),
+			tree,
+			parents...,
+		)
+		if err != nil {
+			if data.errorTarget != nil {
+				*data.errorTarget = err
+			}
+			return setCallbackError(errorMessage, err)
+		}
+
+		signature, signatureField, err := data.options.CommitSigningCallback(string(commitContent))
+		if err != nil {
+			if data.errorTarget != nil {
+				*data.errorTarget = err
+			}
+			return setCallbackError(errorMessage, err)
+		}
+
+		oid, err := data.repo.CreateCommitWithSignature(string(commitContent), signature, signatureField)
+		if err != nil {
+			if data.errorTarget != nil {
+				*data.errorTarget = err
+			}
+			return setCallbackError(errorMessage, err)
+		}
+		*_out = *oid.toC()
 	}
 
 	return C.int(ErrorCodeOK)
 }
 
-// RebaseOptions are used to tell the rebase machinery how to operate
+// RebaseOptions are used to tell the rebase machinery how to operate.
 type RebaseOptions struct {
-	Version               uint
-	Quiet                 int
-	InMemory              int
-	RewriteNotesRef       string
-	MergeOptions          MergeOptions
-	CheckoutOptions       CheckoutOptions
+	Quiet           int
+	InMemory        int
+	RewriteNotesRef string
+	MergeOptions    MergeOptions
+	CheckoutOptions CheckoutOptions
+	// CommitCreateCallback is an optional callback that allows users to override
+	// commit creation when rebasing. If specified, users can create
+	// their own commit and provide the commit ID, which may be useful for
+	// signing commits or otherwise customizing the commit creation. If this
+	// callback returns a nil Oid, then the rebase will continue to create the
+	// commit.
+	CommitCreateCallback CommitCreateCallback
+	// Deprecated: CommitSigningCallback is an optional callback that will be
+	// called with the commit content, allowing a signature to be added to the
+	// rebase commit. This field is only used when rebasing.  This callback is
+	// not invoked if a CommitCreateCallback is specified.  CommitCreateCallback
+	// should be used instead of this.
 	CommitSigningCallback CommitSigningCallback
 }
 
 type rebaseOptionsData struct {
 	options     *RebaseOptions
+	repo        *Repository
 	errorTarget *error
 }
 
@@ -160,7 +225,6 @@ func DefaultRebaseOptions() (RebaseOptions, error) {
 
 func rebaseOptionsFromC(opts *C.git_rebase_options) RebaseOptions {
 	return RebaseOptions{
-		Version:         uint(opts.version),
 		Quiet:           int(opts.quiet),
 		InMemory:        int(opts.inmemory),
 		RewriteNotesRef: C.GoString(opts.rewrite_notes_ref),
@@ -169,7 +233,7 @@ func rebaseOptionsFromC(opts *C.git_rebase_options) RebaseOptions {
 	}
 }
 
-func populateRebaseOptions(copts *C.git_rebase_options, opts *RebaseOptions, errorTarget *error) *C.git_rebase_options {
+func populateRebaseOptions(copts *C.git_rebase_options, opts *RebaseOptions, repo *Repository, errorTarget *error) *C.git_rebase_options {
 	C.git_rebase_options_init(copts, C.GIT_REBASE_OPTIONS_VERSION)
 	if opts == nil {
 		return nil
@@ -181,9 +245,10 @@ func populateRebaseOptions(copts *C.git_rebase_options, opts *RebaseOptions, err
 	populateMergeOptions(&copts.merge_options, &opts.MergeOptions)
 	populateCheckoutOptions(&copts.checkout_options, &opts.CheckoutOptions, errorTarget)
 
-	if opts.CommitSigningCallback != nil {
+	if opts.CommitCreateCallback != nil || opts.CommitSigningCallback != nil {
 		data := &rebaseOptionsData{
 			options:     opts,
+			repo:        repo,
 			errorTarget: errorTarget,
 		}
 		C._go_git_populate_rebase_callbacks(copts)
@@ -239,7 +304,7 @@ func (r *Repository) InitRebase(branch *AnnotatedCommit, upstream *AnnotatedComm
 
 	var ptr *C.git_rebase
 	var err error
-	cOpts := populateRebaseOptions(&C.git_rebase_options{}, opts, &err)
+	cOpts := populateRebaseOptions(&C.git_rebase_options{}, opts, r, &err)
 	ret := C.git_rebase_init(&ptr, r.ptr, branch.ptr, upstream.ptr, onto.ptr, cOpts)
 	runtime.KeepAlive(branch)
 	runtime.KeepAlive(upstream)
@@ -263,7 +328,7 @@ func (r *Repository) OpenRebase(opts *RebaseOptions) (*Rebase, error) {
 
 	var ptr *C.git_rebase
 	var err error
-	cOpts := populateRebaseOptions(&C.git_rebase_options{}, opts, &err)
+	cOpts := populateRebaseOptions(&C.git_rebase_options{}, opts, r, &err)
 	ret := C.git_rebase_open(&ptr, r.ptr, cOpts)
 	runtime.KeepAlive(r)
 	if ret == C.int(ErrorCodeUser) && err != nil {
@@ -414,7 +479,7 @@ func (r *Rebase) Free() {
 }
 
 func newRebaseFromC(ptr *C.git_rebase, repo *Repository, opts *C.git_rebase_options) *Rebase {
-    rebase := &Rebase{ptr: ptr, r: repo, options: opts}
+	rebase := &Rebase{ptr: ptr, r: repo, options: opts}
 	runtime.SetFinalizer(rebase, (*Rebase).Free)
 	return rebase
 }

rebase_test.go

@@ -8,8 +8,8 @@ import (
 	"testing"
 	"time"
 
-	"golang.org/x/crypto/openpgp"
-	"golang.org/x/crypto/openpgp/packet"
+	"github.com/ProtonMail/go-crypto/openpgp"
+	"github.com/ProtonMail/go-crypto/openpgp/packet"
 )
 
 // Tests
@@ -19,73 +19,73 @@ func TestRebaseInMemoryWithConflict(t *testing.T) {
 	defer cleanupTestRepo(t, repo)
 	seedTestRepo(t, repo)
 
-    // Create two branches with common history, where both modify "common-file"
-    // in a conflicting way.
-    _, err := commitSomething(repo, "common-file", "a\nb\nc\n", commitOptions{})
-    checkFatal(t, err)
+	// Create two branches with common history, where both modify "common-file"
+	// in a conflicting way.
+	_, err := commitSomething(repo, "common-file", "a\nb\nc\n", commitOptions{})
+	checkFatal(t, err)
 	checkFatal(t, createBranch(repo, "branch-a"))
 	checkFatal(t, createBranch(repo, "branch-b"))
 
 	checkFatal(t, repo.SetHead("refs/heads/branch-a"))
-    _, err = commitSomething(repo, "common-file", "1\nb\nc\n", commitOptions{})
-    checkFatal(t, err)
+	_, err = commitSomething(repo, "common-file", "1\nb\nc\n", commitOptions{})
+	checkFatal(t, err)
 
 	checkFatal(t, repo.SetHead("refs/heads/branch-b"))
-    _, err = commitSomething(repo, "common-file", "x\nb\nc\n", commitOptions{})
-    checkFatal(t, err)
+	_, err = commitSomething(repo, "common-file", "x\nb\nc\n", commitOptions{})
+	checkFatal(t, err)
 
 	branchA, err := repo.LookupBranch("branch-a", BranchLocal)
-    checkFatal(t, err)
+	checkFatal(t, err)
 	onto, err := repo.AnnotatedCommitFromRef(branchA.Reference)
-    checkFatal(t, err)
-
-    // We then rebase "branch-b" onto "branch-a" in-memory, which should result
-    // in a conflict.
-    rebase, err := repo.InitRebase(nil, nil, onto, &RebaseOptions{InMemory: 1})
-    checkFatal(t, err)
-
-    _, err = rebase.Next()
 	checkFatal(t, err)
 
-    index, err := rebase.InmemoryIndex()
+	// We then rebase "branch-b" onto "branch-a" in-memory, which should result
+	// in a conflict.
+	rebase, err := repo.InitRebase(nil, nil, onto, &RebaseOptions{InMemory: 1})
 	checkFatal(t, err)
 
-    // We simply resolve the conflict and commit the rebase.
-    if !index.HasConflicts() {
-        t.Fatal("expected index to have conflicts")
-    }
+	_, err = rebase.Next()
+	checkFatal(t, err)
 
-    conflict, err := index.Conflict("common-file")
-    checkFatal(t, err)
+	index, err := rebase.InmemoryIndex()
+	checkFatal(t, err)
 
-    resolvedBlobID, err := repo.CreateBlobFromBuffer([]byte("resolved contents"))
-    checkFatal(t, err)
+	// We simply resolve the conflict and commit the rebase.
+	if !index.HasConflicts() {
+		t.Fatal("expected index to have conflicts")
+	}
 
-    resolvedEntry := *conflict.Our
-    resolvedEntry.Id = resolvedBlobID
-    checkFatal(t, index.Add(&resolvedEntry))
-    checkFatal(t, index.RemoveConflict("common-file"))
+	conflict, err := index.Conflict("common-file")
+	checkFatal(t, err)
 
-    var commitID Oid
-    checkFatal(t, rebase.Commit(&commitID, signature(), signature(), "rebased message"))
-    checkFatal(t, rebase.Finish())
+	resolvedBlobID, err := repo.CreateBlobFromBuffer([]byte("resolved contents"))
+	checkFatal(t, err)
 
-    // And then assert that we can look up the new merge commit, and that the
-    // "common-file" has the expected contents.
-    commit, err := repo.LookupCommit(&commitID)
-    checkFatal(t, err)
-    if commit.Message() != "rebased message" {
-        t.Fatalf("unexpected commit message %q", commit.Message())
-    }
+	resolvedEntry := *conflict.Our
+	resolvedEntry.Id = resolvedBlobID
+	checkFatal(t, index.Add(&resolvedEntry))
+	checkFatal(t, index.RemoveConflict("common-file"))
 
-    tree, err := commit.Tree()
-    checkFatal(t, err)
+	var commitID Oid
+	checkFatal(t, rebase.Commit(&commitID, signature(), signature(), "rebased message"))
+	checkFatal(t, rebase.Finish())
 
-    blob, err := repo.LookupBlob(tree.EntryByName("common-file").Id)
-    checkFatal(t, err)
-    if string(blob.Contents()) != "resolved contents" {
-        t.Fatalf("unexpected resolved blob contents %q", string(blob.Contents()))
-    }
+	// And then assert that we can look up the new merge commit, and that the
+	// "common-file" has the expected contents.
+	commit, err := repo.LookupCommit(&commitID)
+	checkFatal(t, err)
+	if commit.Message() != "rebased message" {
+		t.Fatalf("unexpected commit message %q", commit.Message())
+	}
+
+	tree, err := commit.Tree()
+	checkFatal(t, err)
+
+	blob, err := repo.LookupBlob(tree.EntryByName("common-file").Id)
+	checkFatal(t, err)
+	if string(blob.Contents()) != "resolved contents" {
+		t.Fatalf("unexpected resolved blob contents %q", string(blob.Contents()))
+	}
 }
 
 func TestRebaseAbort(t *testing.T) {
@@ -319,7 +319,7 @@ func checkCommitSigned(t *testing.T, entity *openpgp.Entity, commit *Commit) err
 		return err
 	}
 
-	_, err = openpgp.CheckArmoredDetachedSignature(openpgp.EntityList{entity}, strings.NewReader(signedData), bytes.NewBufferString(signature))
+	_, err = openpgp.CheckArmoredDetachedSignature(openpgp.EntityList{entity}, strings.NewReader(signedData), bytes.NewBufferString(signature), nil)
 	if err != nil {
 		t.Logf("Commit is not signed correctly\n%s", commit.ContentToSign())
 		return err

reference.go

@@ -476,7 +476,7 @@ func (v *ReferenceIterator) Free() {
 	C.git_reference_iterator_free(v.ptr)
 }
 
-// ReferenceIsValidName returns whether the reference name is well-formed.
+// ReferenceNameIsValid returns whether the reference name is well-formed.
 //
 // Valid reference names must follow one of two patterns:
 //
@@ -486,11 +486,19 @@ func (v *ReferenceIterator) Free() {
 // 2. Names prefixed with "refs/" can be almost anything. You must avoid
 // the characters '~', '^', ':', ' \ ', '?', '[', and '*', and the sequences
 // ".." and " @ {" which have special meaning to revparse.
-func ReferenceIsValidName(name string) bool {
+func ReferenceNameIsValid(name string) (bool, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
-	return C.git_reference_is_valid_name(cname) == 1
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var valid C.int
+	ret := C.git_reference_name_is_valid(&valid, cname)
+	if ret < 0 {
+		return false, MakeGitError(ret)
+	}
+	return valid == 1, nil
 }
 
 const (

reference_test.go

@@ -214,12 +214,16 @@ func TestIsNote(t *testing.T) {
 	}
 }
 
-func TestReferenceIsValidName(t *testing.T) {
+func TestReferenceNameIsValid(t *testing.T) {
 	t.Parallel()
-	if !ReferenceIsValidName("HEAD") {
+	valid, err := ReferenceNameIsValid("HEAD")
+	checkFatal(t, err)
+	if !valid {
 		t.Errorf("HEAD should be a valid reference name")
 	}
-	if ReferenceIsValidName("HEAD1") {
+	valid, err = ReferenceNameIsValid("HEAD1")
+	checkFatal(t, err)
+	if valid {
 		t.Errorf("HEAD1 should not be a valid reference name")
 	}
 }

remote.go

@@ -12,6 +12,7 @@ import "C"
 import (
 	"crypto/x509"
 	"errors"
+	"fmt"
 	"reflect"
 	"runtime"
 	"strings"
@@ -69,15 +70,15 @@ const (
 	ConnectDirectionPush  ConnectDirection = C.GIT_DIRECTION_PUSH
 )
 
-type TransportMessageCallback func(str string) ErrorCode
-type CompletionCallback func(RemoteCompletion) ErrorCode
+type TransportMessageCallback func(str string) error
+type CompletionCallback func(RemoteCompletion) error
 type CredentialsCallback func(url string, username_from_url string, allowed_types CredentialType) (*Credential, error)
-type TransferProgressCallback func(stats TransferProgress) ErrorCode
-type UpdateTipsCallback func(refname string, a *Oid, b *Oid) ErrorCode
-type CertificateCheckCallback func(cert *Certificate, valid bool, hostname string) ErrorCode
-type PackbuilderProgressCallback func(stage int32, current, total uint32) ErrorCode
-type PushTransferProgressCallback func(current, total uint32, bytes uint) ErrorCode
-type PushUpdateReferenceCallback func(refname, status string) ErrorCode
+type TransferProgressCallback func(stats TransferProgress) error
+type UpdateTipsCallback func(refname string, a *Oid, b *Oid) error
+type CertificateCheckCallback func(cert *Certificate, valid bool, hostname string) error
+type PackbuilderProgressCallback func(stage int32, current, total uint32) error
+type PushTransferProgressCallback func(current, total uint32, bytes uint) error
+type PushUpdateReferenceCallback func(refname, status string) error
 
 type RemoteCallbacks struct {
 	SidebandProgressCallback TransportMessageCallback
@@ -146,6 +147,17 @@ type FetchOptions struct {
 	ProxyOptions ProxyOptions
 }
 
+type RemoteConnectOptions struct {
+	// Proxy options to use for this fetch operation
+	ProxyOptions ProxyOptions
+}
+
+func remoteConnectOptionsFromC(copts *C.git_remote_connect_options) *RemoteConnectOptions {
+	return &RemoteConnectOptions{
+		ProxyOptions: proxyOptionsFromC(&copts.proxy_opts),
+	}
+}
+
 type ProxyType uint
 
 const (
@@ -170,8 +182,8 @@ type ProxyOptions struct {
 	Url string
 }
 
-func proxyOptionsFromC(copts *C.git_proxy_options) *ProxyOptions {
-	return &ProxyOptions{
+func proxyOptionsFromC(copts *C.git_proxy_options) ProxyOptions {
+	return ProxyOptions{
 		Type: ProxyType(copts._type),
 		Url:  C.GoString(copts.url),
 	}
@@ -255,7 +267,7 @@ const (
 // Certificate represents the two possible certificates which libgit2
 // knows it might find. If Kind is CertficateX509 then the X509 field
 // will be filled. If Kind is CertificateHostkey then the Hostkey
-// field will be fille.d
+// field will be filled.
 type Certificate struct {
 	Kind    CertificateKind
 	X509    *x509.Certificate
@@ -269,7 +281,7 @@ const (
 	HostkeyMD5    HostkeyKind = C.GIT_CERT_SSH_MD5
 	HostkeySHA1   HostkeyKind = C.GIT_CERT_SSH_SHA1
 	HostkeySHA256 HostkeyKind = C.GIT_CERT_SSH_SHA256
-	HostkeyRaw    HostkeyKind = 1 << 3
+	HostkeyRaw    HostkeyKind = C.GIT_CERT_SSH_RAW
 )
 
 // Server host key information. A bitmask containing the available fields.
@@ -335,10 +347,8 @@ func sidebandProgressCallback(errorMessage **C.char, _str *C.char, _len C.int, h
 	if data.callbacks.SidebandProgressCallback == nil {
 		return C.int(ErrorCodeOK)
 	}
-	str := C.GoStringN(_str, _len)
-	ret := data.callbacks.SidebandProgressCallback(str)
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.SidebandProgressCallback(C.GoStringN(_str, _len))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -348,14 +358,13 @@ func sidebandProgressCallback(errorMessage **C.char, _str *C.char, _len C.int, h
 }
 
 //export completionCallback
-func completionCallback(errorMessage **C.char, completion_type C.git_remote_completion_type, handle unsafe.Pointer) C.int {
+func completionCallback(errorMessage **C.char, completionType C.git_remote_completion_type, handle unsafe.Pointer) C.int {
 	data := pointerHandles.Get(handle).(*remoteCallbacksData)
 	if data.callbacks.CompletionCallback == nil {
 		return C.int(ErrorCodeOK)
 	}
-	ret := data.callbacks.CompletionCallback(RemoteCompletion(completion_type))
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.CompletionCallback(RemoteCompletion(completionType))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -402,9 +411,8 @@ func transferProgressCallback(errorMessage **C.char, stats *C.git_transfer_progr
 	if data.callbacks.TransferProgressCallback == nil {
 		return C.int(ErrorCodeOK)
 	}
-	ret := data.callbacks.TransferProgressCallback(newTransferProgressFromC(stats))
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.TransferProgressCallback(newTransferProgressFromC(stats))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -428,9 +436,8 @@ func updateTipsCallback(
 	refname := C.GoString(_refname)
 	a := newOidFromC(_a)
 	b := newOidFromC(_b)
-	ret := data.callbacks.UpdateTipsCallback(refname, a, b)
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.UpdateTipsCallback(refname, a, b)
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -487,6 +494,17 @@ func certificateCheckCallback(
 		C.memcpy(unsafe.Pointer(&cert.Hostkey.HashMD5[0]), unsafe.Pointer(&ccert.hash_md5[0]), C.size_t(len(cert.Hostkey.HashMD5)))
 		C.memcpy(unsafe.Pointer(&cert.Hostkey.HashSHA1[0]), unsafe.Pointer(&ccert.hash_sha1[0]), C.size_t(len(cert.Hostkey.HashSHA1)))
 		C.memcpy(unsafe.Pointer(&cert.Hostkey.HashSHA256[0]), unsafe.Pointer(&ccert.hash_sha256[0]), C.size_t(len(cert.Hostkey.HashSHA256)))
+		if (cert.Hostkey.Kind & HostkeyRaw) == HostkeyRaw {
+			cert.Hostkey.Hostkey = C.GoBytes(unsafe.Pointer(ccert.hostkey), C.int(ccert.hostkey_len))
+			var err error
+			cert.Hostkey.SSHPublicKey, err = ssh.ParsePublicKey(cert.Hostkey.Hostkey)
+			if err != nil {
+				if data.errorTarget != nil {
+					*data.errorTarget = err
+				}
+				return setCallbackError(errorMessage, err)
+			}
+		}
 	} else {
 		err := errors.New("unsupported certificate type")
 		if data.errorTarget != nil {
@@ -495,9 +513,8 @@ func certificateCheckCallback(
 		return setCallbackError(errorMessage, err)
 	}
 
-	ret := data.callbacks.CertificateCheckCallback(&cert, valid, host)
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.CertificateCheckCallback(&cert, valid, host)
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -513,9 +530,8 @@ func packProgressCallback(errorMessage **C.char, stage C.int, current, total C.u
 		return C.int(ErrorCodeOK)
 	}
 
-	ret := data.callbacks.PackProgressCallback(int32(stage), uint32(current), uint32(total))
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.PackProgressCallback(int32(stage), uint32(current), uint32(total))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -531,9 +547,8 @@ func pushTransferProgressCallback(errorMessage **C.char, current, total C.uint,
 		return C.int(ErrorCodeOK)
 	}
 
-	ret := data.callbacks.PushTransferProgressCallback(uint32(current), uint32(total), uint(bytes))
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.PushTransferProgressCallback(uint32(current), uint32(total), uint(bytes))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -549,9 +564,8 @@ func pushUpdateReferenceCallback(errorMessage **C.char, refname, status *C.char,
 		return C.int(ErrorCodeOK)
 	}
 
-	ret := data.callbacks.PushUpdateReferenceCallback(C.GoString(refname), C.GoString(status))
-	if ret < 0 {
-		err := errors.New(ErrorCode(ret).String())
+	err := data.callbacks.PushUpdateReferenceCallback(C.GoString(refname), C.GoString(status))
+	if err != nil {
 		if data.errorTarget != nil {
 			*data.errorTarget = err
 		}
@@ -579,12 +593,20 @@ func freeProxyOptions(copts *C.git_proxy_options) {
 	C.free(unsafe.Pointer(copts.url))
 }
 
-// RemoteIsValidName returns whether the remote name is well-formed.
-func RemoteIsValidName(name string) bool {
+// RemoteNameIsValid returns whether the remote name is well-formed.
+func RemoteNameIsValid(name string) (bool, error) {
 	cname := C.CString(name)
 	defer C.free(unsafe.Pointer(cname))
 
-	return C.git_remote_is_valid_name(cname) == 1
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	var valid C.int
+	ret := C.git_remote_name_is_valid(&valid, cname)
+	if ret < 0 {
+		return false, MakeGitError(ret)
+	}
+	return valid == 1, nil
 }
 
 // free releases the resources of the Remote.
@@ -639,7 +661,7 @@ func (c *RemoteCollection) List() ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&r)
+	defer C.git_strarray_dispose(&r)
 
 	remotes := makeStringsFromCStrings(r.strings, int(r.count))
 	return remotes, nil
@@ -664,7 +686,7 @@ func (c *RemoteCollection) Create(name string, url string) (*Remote, error) {
 	return remote, nil
 }
 
-//CreateWithOptions Creates a repository object with extended options.
+// CreateWithOptions Creates a repository object with extended options.
 func (c *RemoteCollection) CreateWithOptions(url string, option *RemoteCreateOptions) (*Remote, error) {
 	remote := &Remote{repo: c.repo}
 
@@ -909,7 +931,7 @@ func (o *Remote) FetchRefspecs() ([]string, error) {
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
-	defer C.git_strarray_free(&crefspecs)
+	defer C.git_strarray_dispose(&crefspecs)
 
 	refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))
 	return refspecs, nil
@@ -942,7 +964,7 @@ func (o *Remote) PushRefspecs() ([]string, error) {
 	if ret < 0 {
 		return nil, MakeGitError(ret)
 	}
-	defer C.git_strarray_free(&crefspecs)
+	defer C.git_strarray_dispose(&crefspecs)
 	runtime.KeepAlive(o)
 
 	refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))
@@ -962,7 +984,9 @@ func populateFetchOptions(copts *C.git_fetch_options, opts *FetchOptions, errorT
 	}
 	populateRemoteCallbacks(&copts.callbacks, &opts.RemoteCallbacks, errorTarget)
 	copts.prune = C.git_fetch_prune_t(opts.Prune)
-	copts.update_fetchhead = cbool(opts.UpdateFetchhead)
+	fmt.Println("populateFetchOptions() is broken. fixme!")
+	// fix this line: ./remote.go:988:27: cannot use cbool(opts.UpdateFetchhead) (value of type _Ctype_int) as _Ctype_uint value in assignment
+	// copts.update_fetchhead = cbool(opts.UpdateFetchhead)
 	copts.download_tags = C.git_remote_autotag_option_t(opts.DownloadTags)
 
 	copts.custom_headers = C.git_strarray{

remote_test.go

@@ -38,13 +38,13 @@ func TestListRemotes(t *testing.T) {
 	compareStringList(t, expected, actual)
 }
 
-func assertHostname(cert *Certificate, valid bool, hostname string, t *testing.T) ErrorCode {
+func assertHostname(cert *Certificate, valid bool, hostname string, t *testing.T) error {
 	if hostname != "github.com" {
-		t.Fatal("Hostname does not match")
-		return ErrorCodeUser
+		t.Fatal("hostname does not match")
+		return errors.New("hostname does not match")
 	}
 
-	return ErrorCodeOK
+	return nil
 }
 
 func TestCertificateCheck(t *testing.T) {
@@ -58,7 +58,7 @@ func TestCertificateCheck(t *testing.T) {
 
 	options := FetchOptions{
 		RemoteCallbacks: RemoteCallbacks{
-			CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) ErrorCode {
+			CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) error {
 				return assertHostname(cert, valid, hostname, t)
 			},
 		},
@@ -479,14 +479,13 @@ func TestRemoteSSH(t *testing.T) {
 	certificateCheckCallbackCalled := false
 	fetchOpts := FetchOptions{
 		RemoteCallbacks: RemoteCallbacks{
-			CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) ErrorCode {
+			CertificateCheckCallback: func(cert *Certificate, valid bool, hostname string) error {
 				hostkeyFingerprint := fmt.Sprintf("%x", cert.Hostkey.HashMD5[:])
 				if hostkeyFingerprint != publicKeyFingerprint {
-					t.Logf("server hostkey %q, want %q", hostkeyFingerprint, publicKeyFingerprint)
-					return ErrorCodeAuth
+					return fmt.Errorf("server hostkey %q, want %q", hostkeyFingerprint, publicKeyFingerprint)
 				}
 				certificateCheckCallbackCalled = true
-				return ErrorCodeOK
+				return nil
 			},
 			CredentialsCallback: func(url, username string, allowedTypes CredentialType) (*Credential, error) {
 				if allowedTypes&(CredentialTypeSSHKey|CredentialTypeSSHCustom|CredentialTypeSSHMemory) != 0 {

revert.go

@@ -10,9 +10,9 @@ import (
 
 // RevertOptions contains options for performing a revert
 type RevertOptions struct {
-	Mainline     uint
-	MergeOpts    MergeOptions
-	CheckoutOpts CheckoutOptions
+	Mainline        uint
+	MergeOptions    MergeOptions
+	CheckoutOptions CheckoutOptions
 }
 
 func populateRevertOptions(copts *C.git_revert_options, opts *RevertOptions, errorTarget *error) *C.git_revert_options {
@@ -21,16 +21,16 @@ func populateRevertOptions(copts *C.git_revert_options, opts *RevertOptions, err
 		return nil
 	}
 	copts.mainline = C.uint(opts.Mainline)
-	populateMergeOptions(&copts.merge_opts, &opts.MergeOpts)
-	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOpts, errorTarget)
+	populateMergeOptions(&copts.merge_opts, &opts.MergeOptions)
+	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOptions, errorTarget)
 	return copts
 }
 
 func revertOptionsFromC(copts *C.git_revert_options) RevertOptions {
 	return RevertOptions{
-		Mainline:     uint(copts.mainline),
-		MergeOpts:    mergeOptionsFromC(&copts.merge_opts),
-		CheckoutOpts: checkoutOptionsFromC(&copts.checkout_opts),
+		Mainline:        uint(copts.mainline),
+		MergeOptions:    mergeOptionsFromC(&copts.merge_opts),
+		CheckoutOptions: checkoutOptionsFromC(&copts.checkout_opts),
 	}
 }
 

revert_test.go

@@ -60,11 +60,11 @@ func TestRevertCommit(t *testing.T) {
 	revertOptions, err := DefaultRevertOptions()
 	checkFatal(t, err)
 
-	index, err := repo.RevertCommit(commit, commit, 0, &revertOptions.MergeOpts)
+	index, err := repo.RevertCommit(commit, commit, 0, &revertOptions.MergeOptions)
 	checkFatal(t, err)
 	defer index.Free()
 
-	err = repo.CheckoutIndex(index, &revertOptions.CheckoutOpts)
+	err = repo.CheckoutIndex(index, &revertOptions.CheckoutOptions)
 	checkFatal(t, err)
 
 	actualReadmeContents := readReadme(t, repo)

script/build-libgit2.sh

@@ -51,8 +51,11 @@ if [ -n "${BUILD_LIBGIT_REF}" ]; then
 	trap "git submodule update --init" EXIT
 fi
 
+BUILD_DEPRECATED_HARD="ON"
 if [ "${BUILD_SYSTEM}" = "ON" ]; then
 	BUILD_INSTALL_PREFIX=${SYSTEM_INSTALL_PREFIX-"/usr"}
+	# Most system-wide installations won't intentionally omit deprecated symbols.
+	BUILD_DEPRECATED_HARD="OFF"
 else
 	BUILD_INSTALL_PREFIX="${BUILD_PATH}/install"
 	mkdir -p "${BUILD_PATH}/install/lib"
@@ -76,6 +79,7 @@ cmake -DTHREADSAFE=ON \
       -DCMAKE_BUILD_TYPE="RelWithDebInfo" \
       -DCMAKE_INSTALL_PREFIX="${BUILD_INSTALL_PREFIX}" \
       -DCMAKE_INSTALL_LIBDIR="lib" \
+      -DDEPRECATE_HARD="${BUILD_DEPRECATE_HARD}" \
       "${VENDORED_PATH}"
 
 if which make nproc >/dev/null && [ -f Makefile ]; then

script/install-libgit2.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Install libgit2 to git2go in dynamic mode on Travis
+# Install libgit2 to go libgit2 in dynamic mode on Travis
 #
 
 set -ex

submodule.go

@@ -8,15 +8,14 @@ extern int _go_git_visit_submodule(git_repository *repo, void *fct);
 import "C"
 
 import (
-	"errors"
 	"runtime"
 	"unsafe"
 )
 
 // SubmoduleUpdateOptions
 type SubmoduleUpdateOptions struct {
-	*CheckoutOpts
-	*FetchOptions
+	CheckoutOptions CheckoutOptions
+	FetchOptions    FetchOptions
 }
 
 // Submodule
@@ -111,7 +110,7 @@ func (c *SubmoduleCollection) Lookup(name string) (*Submodule, error) {
 }
 
 // SubmoduleCallback is a function that is called for every submodule found in SubmoduleCollection.Foreach.
-type SubmoduleCallback func(sub *Submodule, name string) int
+type SubmoduleCallback func(sub *Submodule, name string) error
 type submoduleCallbackData struct {
 	callback    SubmoduleCallback
 	errorTarget *error
@@ -126,9 +125,9 @@ func submoduleCallback(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer)
 		panic("invalid submodule visitor callback")
 	}
 
-	ret := data.callback(sub, C.GoString(name))
-	if ret < 0 {
-		*data.errorTarget = errors.New(ErrorCode(ret).String())
+	err := data.callback(sub, C.GoString(name))
+	if err != nil {
+		*data.errorTarget = err
 		return C.int(ErrorCodeUser)
 	}
 
@@ -391,8 +390,8 @@ func populateSubmoduleUpdateOptions(copts *C.git_submodule_update_options, opts
 		return nil
 	}
 
-	populateCheckoutOptions(&copts.checkout_opts, opts.CheckoutOpts, errorTarget)
-	populateFetchOptions(&copts.fetch_opts, opts.FetchOptions, errorTarget)
+	populateCheckoutOptions(&copts.checkout_opts, &opts.CheckoutOptions, errorTarget)
+	populateFetchOptions(&copts.fetch_opts, &opts.FetchOptions, errorTarget)
 
 	return copts
 }

submodule_test.go

@@ -15,9 +15,9 @@ func TestSubmoduleForeach(t *testing.T) {
 	checkFatal(t, err)
 
 	i := 0
-	err = repo.Submodules.Foreach(func(sub *Submodule, name string) int {
+	err = repo.Submodules.Foreach(func(sub *Submodule, name string) error {
 		i++
-		return 0
+		return nil
 	})
 	checkFatal(t, err)
 

tag.go

@@ -161,7 +161,7 @@ func (c *TagsCollection) List() ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&strC)
+	defer C.git_strarray_dispose(&strC)
 
 	tags := makeStringsFromCStrings(strC.strings, int(strC.count))
 	return tags, nil
@@ -185,7 +185,7 @@ func (c *TagsCollection) ListWithMatch(pattern string) ([]string, error) {
 	if ecode < 0 {
 		return nil, MakeGitError(ecode)
 	}
-	defer C.git_strarray_free(&strC)
+	defer C.git_strarray_dispose(&strC)
 
 	tags := makeStringsFromCStrings(strC.strings, int(strC.count))
 	return tags, nil

transport.go

@@ -31,7 +31,7 @@ import (
 )
 
 var (
-	// globalRegisteredSmartTransports is a mapping of global, git2go-managed
+	// globalRegisteredSmartTransports is a mapping of global, libgit2 go-managed
 	// transports.
 	globalRegisteredSmartTransports = struct {
 		sync.Mutex
@@ -41,7 +41,7 @@ var (
 	}
 )
 
-// unregisterManagedTransports unregisters all git2go-managed transports.
+// unregisterManagedTransports unregisters all libgit2 go-managed transports.
 func unregisterManagedTransports() error {
 	globalRegisteredSmartTransports.Lock()
 	originalTransports := globalRegisteredSmartTransports.transports
@@ -84,17 +84,17 @@ type Transport struct {
 	ptr *C.git_transport
 }
 
-// SmartProxyOptions gets a copy of the proxy options for this transport.
-func (t *Transport) SmartProxyOptions() (*ProxyOptions, error) {
+// SmartRemoteConnectOptions gets a copy of the proxy options for this transport.
+func (t *Transport) SmartRemoteConnectOptions() (*RemoteConnectOptions, error) {
 	runtime.LockOSThread()
 	defer runtime.UnlockOSThread()
 
-	var cpopts C.git_proxy_options
-	if ret := C.git_transport_smart_proxy_options(&cpopts, t.ptr); ret < 0 {
+	var copts C.git_remote_connect_options
+	if ret := C.git_transport_remote_connect_options(&copts, t.ptr); ret < 0 {
 		return nil, MakeGitError(ret)
 	}
 
-	return proxyOptionsFromC(&cpopts), nil
+	return remoteConnectOptionsFromC(&copts), nil
 }
 
 // SmartCredentials calls the credentials callback for this transport.
@@ -127,11 +127,21 @@ func (t *Transport) SmartCertificateCheck(cert *Certificate, valid bool, hostnam
 			parent: C.git_cert{
 				cert_type: C.GIT_CERT_HOSTKEY_LIBSSH2,
 			},
-			_type: C.git_cert_ssh_t(cert.Kind),
+			_type:       C.git_cert_ssh_t(cert.Kind),
+			hostkey:     (*C.char)(C.CBytes(cert.Hostkey.Hostkey)),
+			hostkey_len: C.size_t(len(cert.Hostkey.Hostkey)),
 		}
+		defer C.free(unsafe.Pointer(chostkeyCert.hostkey))
 		C.memcpy(unsafe.Pointer(&chostkeyCert.hash_md5[0]), unsafe.Pointer(&cert.Hostkey.HashMD5[0]), C.size_t(len(cert.Hostkey.HashMD5)))
 		C.memcpy(unsafe.Pointer(&chostkeyCert.hash_sha1[0]), unsafe.Pointer(&cert.Hostkey.HashSHA1[0]), C.size_t(len(cert.Hostkey.HashSHA1)))
 		C.memcpy(unsafe.Pointer(&chostkeyCert.hash_sha256[0]), unsafe.Pointer(&cert.Hostkey.HashSHA256[0]), C.size_t(len(cert.Hostkey.HashSHA256)))
+		if cert.Hostkey.SSHPublicKey.Type() == "ssh-rsa" {
+			chostkeyCert.raw_type = C.GIT_CERT_SSH_RAW_TYPE_RSA
+		} else if cert.Hostkey.SSHPublicKey.Type() == "ssh-dss" {
+			chostkeyCert.raw_type = C.GIT_CERT_SSH_RAW_TYPE_DSS
+		} else {
+			chostkeyCert.raw_type = C.GIT_CERT_SSH_RAW_TYPE_UNKNOWN
+		}
 		ccert = (*C.git_cert)(unsafe.Pointer(&chostkeyCert))
 
 	case CertificateX509:

tree.go

@@ -121,7 +121,7 @@ func (t *Tree) EntryCount() uint64 {
 	return uint64(num)
 }
 
-type TreeWalkCallback func(string, *TreeEntry) int
+type TreeWalkCallback func(string, *TreeEntry) error
 type treeWalkCallbackData struct {
 	callback    TreeWalkCallback
 	errorTarget *error
@@ -134,15 +134,30 @@ func treeWalkCallback(_root *C.char, entry *C.git_tree_entry, ptr unsafe.Pointer
 		panic("invalid treewalk callback")
 	}
 
-	ret := data.callback(C.GoString(_root), newTreeEntry(entry))
-	if ret < 0 {
-		*data.errorTarget = errors.New(ErrorCode(ret).String())
+	err := data.callback(C.GoString(_root), newTreeEntry(entry))
+	if err == TreeWalkSkip {
+		return C.int(1)
+	} else if err != nil {
+		*data.errorTarget = err
 		return C.int(ErrorCodeUser)
 	}
 
 	return C.int(ErrorCodeOK)
 }
 
+// TreeWalkSkip is an error that can be returned form TreeWalkCallback to skip
+// a subtree from being expanded.
+var TreeWalkSkip = errors.New("skip")
+
+// Walk traverses the entries in a tree and its subtrees in pre order.
+//
+// The entries will be traversed in the pre order, children subtrees will be
+// automatically loaded as required, and the callback will be called once per
+// entry with the current (relative) root for the entry and the entry data
+// itself.
+//
+// If the callback returns TreeWalkSkip, the passed entry will be skipped on
+// the traversal. Any other non-nil error stops the walk.
 func (t *Tree) Walk(callback TreeWalkCallback) error {
 	var err error
 	data := treeWalkCallbackData{

tree_test.go

@@ -1,6 +1,9 @@
 package git
 
-import "testing"
+import (
+	"errors"
+	"testing"
+)
 
 func TestTreeEntryById(t *testing.T) {
 	t.Parallel()
@@ -63,3 +66,72 @@ func TestTreeBuilderInsert(t *testing.T) {
 		t.Fatalf("got oid %v, want %v", entry.Id, blobId)
 	}
 }
+
+func TestTreeWalk(t *testing.T) {
+	t.Parallel()
+	repo, err := OpenRepository("testdata/TestGitRepository.git")
+	checkFatal(t, err)
+	treeID, err := NewOid("6020a3b8d5d636e549ccbd0c53e2764684bb3125")
+	checkFatal(t, err)
+
+	tree, err := repo.LookupTree(treeID)
+	checkFatal(t, err)
+
+	var callCount int
+	err = tree.Walk(func(name string, entry *TreeEntry) error {
+		callCount++
+
+		return nil
+	})
+	checkFatal(t, err)
+	if callCount != 11 {
+		t.Fatalf("got called %v times, want %v", callCount, 11)
+	}
+}
+
+func TestTreeWalkSkip(t *testing.T) {
+	t.Parallel()
+	repo, err := OpenRepository("testdata/TestGitRepository.git")
+	checkFatal(t, err)
+	treeID, err := NewOid("6020a3b8d5d636e549ccbd0c53e2764684bb3125")
+	checkFatal(t, err)
+
+	tree, err := repo.LookupTree(treeID)
+	checkFatal(t, err)
+
+	var callCount int
+	err = tree.Walk(func(name string, entry *TreeEntry) error {
+		callCount++
+
+		return TreeWalkSkip
+	})
+	checkFatal(t, err)
+	if callCount != 4 {
+		t.Fatalf("got called %v times, want %v", callCount, 4)
+	}
+}
+
+func TestTreeWalkStop(t *testing.T) {
+	t.Parallel()
+	repo, err := OpenRepository("testdata/TestGitRepository.git")
+	checkFatal(t, err)
+	treeID, err := NewOid("6020a3b8d5d636e549ccbd0c53e2764684bb3125")
+	checkFatal(t, err)
+
+	tree, err := repo.LookupTree(treeID)
+	checkFatal(t, err)
+
+	var callCount int
+	stopError := errors.New("stop")
+	err = tree.Walk(func(name string, entry *TreeEntry) error {
+		callCount++
+
+		return stopError
+	})
+	if err != stopError {
+		t.Fatalf("got error %v, want %v", err, stopError)
+	}
+	if callCount != 1 {
+		t.Fatalf("got called %v times, want %v", callCount, 1)
+	}
+}

vendor/libgit2

@@ -1 +0,0 @@
-Subproject commit 7d3c7057f0e774aecd6fc4ef8333e69e5c4873e0

wrapper.c

@@ -104,7 +104,7 @@ static int set_callback_error(char *error_message, int ret)
 {
 	if (error_message != NULL) {
 		if (ret < 0)
-			git_error_set_str(GIT_ERROR_CALLBACK, error_message);
+			giterr_set_str(GIT_ERROR_CALLBACK, error_message);
 		free(error_message);
 	}
 	return ret;
@@ -116,18 +116,28 @@ void _go_git_populate_apply_callbacks(git_apply_options *options)
 	options->hunk_cb = (git_apply_hunk_cb)&hunkApplyCallback;
 }
 
-static int commit_signing_callback(
-		git_buf *signature,
-		git_buf *signature_field,
-		const char *commit_contents,
+static int commit_create_callback(
+		git_oid *out,
+		const git_signature *author,
+		const git_signature *committer,
+		const char *message_encoding,
+		const char *message,
+		const git_tree *tree,
+		size_t parent_count,
+		const git_commit *parents[],
 		void *payload)
 {
 	char *error_message = NULL;
-	const int ret = commitSigningCallback(
+	const int ret = commitCreateCallback(
 			&error_message,
-			signature,
-			signature_field,
-			(char *)commit_contents,
+			out,
+			(git_signature *)author,
+			(git_signature *)committer,
+			(char *)message_encoding,
+			(char *)message,
+			(git_tree *)tree,
+			parent_count,
+			(git_commit **)parents,
 			payload
 	);
 	return set_callback_error(error_message, ret);
@@ -135,7 +145,7 @@ static int commit_signing_callback(
 
 void _go_git_populate_rebase_callbacks(git_rebase_options *opts)
 {
-	opts->signing_cb = commit_signing_callback;
+	opts->commit_create_cb = commit_create_callback;
 }
 
 void _go_git_populate_clone_callbacks(git_clone_options *opts)