diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 7aa5dcccea93c746add7723cd809e1d9c7307f97..c58bc6f5d6a80b446a897b6f50a0efff1e8c9fd3 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -15,8 +15,8 @@
test 1.7:
<<: *test
- image: golang:1.7
+ image: lupine/golang-with-libgit2:1.7
test 1.8:
<<: *test
- image: golang:1.8
+ image: lupine/golang-with-libgit2:1.8
diff --git a/git/git2go.go b/git/git2go.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b61f20be583c2a3539cb39244037515c4275779
--- /dev/null
+++ b/git/git2go.go
@@ -0,0 +1,224 @@
+package git
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+
+ "gopkg.in/libgit2/git2go.v25"
+)
+
+var (
+ ZeroHash = &git.Oid{}
+ submoduleFilemode uint16 = 0160000
+)
+
+type git2GoRepository struct {
+ Repository *git.Repository
+
+ FromHash *git.Oid
+ ToHash *git.Oid
+
+ FromCommit *git.Commit
+ ToCommit *git.Commit
+}
+
+func NewGit2GoRepository(projectPath string, fromSHA string, toSHA string) (*git2GoRepository, error) {
+ out := &git2GoRepository{}
+
+ repo, err := git.OpenRepository(projectPath)
+ if err != nil {
+ return nil, err
+ }
+ out.Repository = repo
+
+ if fromSHA == "" {
+ fromSHA = ZeroHash.String()
+ }
+
+ out.FromHash, err = git.NewOid(fromSHA)
+ if err != nil {
+ return nil, err
+ }
+
+ if !out.FromHash.IsZero() {
+ commit, err := out.Repository.LookupCommit(out.FromHash)
+ if err != nil {
+ return nil, fmt.Errorf("Bad from SHA (%s): %s", out.FromHash, err)
+ }
+
+ out.FromCommit = commit
+ }
+
+ if toSHA == "" {
+ ref, err := out.Repository.Head()
+ if err != nil {
+ return nil, err
+ }
+
+ out.ToHash = ref.Target()
+ } else {
+ oid, err := git.NewOid(toSHA)
+ if err != nil {
+ return nil, err
+ }
+
+ out.ToHash = oid
+ }
+
+ commit, err := out.Repository.LookupCommit(out.ToHash)
+ if err != nil {
+ return nil, fmt.Errorf("Bad to SHA (%s): %s", out.ToHash, err)
+ }
+
+ out.ToCommit = commit
+
+ return out, nil
+}
+
+func (r *git2GoRepository) diff() (*git.Diff, error) {
+ var fromTree, toTree *git.Tree
+
+ if r.FromCommit != nil {
+ tree, err := r.FromCommit.Tree()
+ if err != nil {
+ return nil, err
+ }
+
+ fromTree = tree
+ }
+
+ toTree, err := r.ToCommit.Tree()
+ if err != nil {
+ return nil, err
+ }
+
+ defOpts, err := git.DefaultDiffOptions()
+ if err != nil {
+ return nil, err
+ }
+
+ opts := &defOpts
+ opts.IgnoreSubmodules = git.SubmoduleIgnoreAll
+ opts.Flags = defOpts.Flags | git.DiffIgnoreSubmodules
+
+ return r.Repository.DiffTreeToTree(fromTree, toTree, opts)
+}
+
+func git2GoBuildSignature(sig *git.Signature) Signature {
+ return Signature{
+ Name: sig.Name,
+ Email: sig.Email,
+ When: sig.When,
+ }
+}
+
+func (r *git2GoRepository) callout(file git.DiffFile, next FileFunc) error {
+ blob, err := r.Repository.LookupBlob(file.Oid)
+ if err != nil {
+ return err
+ }
+
+ f := &File{
+ Path: file.Path,
+ Oid: file.Oid.String(),
+ Blob: func() (io.ReadCloser, error) {
+ return ioutil.NopCloser(bytes.NewReader(blob.Contents())), nil
+ },
+ Size: blob.Size(),
+ }
+
+ return next(f, r.FromHash.String(), r.ToHash.String())
+}
+
+func (r *git2GoRepository) EachFileChange(ins, mod, del FileFunc) error {
+ diff, err := r.diff()
+ if err != nil {
+ return err
+ }
+
+ numDeltas, err := diff.NumDeltas()
+ if err != nil {
+ return err
+ }
+
+ for i := 0; i < numDeltas; i++ {
+ delta, err := diff.GetDelta(i)
+ if err != nil {
+ return err
+ }
+
+ if delta.OldFile.Mode == submoduleFilemode {
+ continue
+ }
+
+ if delta.NewFile.Mode == submoduleFilemode {
+ continue
+ }
+
+ switch delta.Status {
+ case git.DeltaAdded, git.DeltaCopied:
+ err = r.callout(delta.NewFile, ins)
+ case git.DeltaModified:
+ err = r.callout(delta.NewFile, mod)
+ case git.DeltaDeleted:
+ err = r.callout(delta.OldFile, del)
+ case git.DeltaRenamed:
+ err = r.callout(delta.OldFile, del)
+ if err == nil {
+ err = r.callout(delta.NewFile, ins)
+ }
+ default:
+ err = fmt.Errorf("Unrecognised change calculating diff: %+v", delta)
+ }
+
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (r *git2GoRepository) EachCommit(f CommitFunc) error {
+ rev, err := r.Repository.Walk()
+ if err != nil {
+ return err
+ }
+ // defer rev.Free()
+
+ if err := rev.Push(r.ToHash); err != nil {
+ return err
+ }
+
+ var outErr error
+ iterator := func(c *git.Commit) bool {
+ commit := &Commit{
+ Message: c.Message(),
+ Hash: c.Id().String(),
+ Author: git2GoBuildSignature(c.Author()),
+ Committer: git2GoBuildSignature(c.Committer()),
+ }
+
+ // abort walking due to reaching the termination point
+ if c.Id().Equal(r.FromHash) {
+ return false
+ }
+
+ outErr = f(commit)
+
+ // Abort walking due to an error
+ if outErr != nil {
+ return false
+ }
+
+ return true
+ }
+
+ if err := rev.Iterate(iterator); err != nil {
+ return fmt.Errorf("WalkCommitHistory: %s", err)
+ }
+
+ return outErr
+}
diff --git a/git/go-git.go b/git/go-git.go
deleted file mode 100644
index a030ba44f0dc69b478e0d9753f0cba35f9ab670e..0000000000000000000000000000000000000000
--- a/git/go-git.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package git
-
-import (
- "fmt"
-
- "gopkg.in/src-d/go-git.v4"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
- "gopkg.in/src-d/go-git.v4/utils/merkletrie"
-)
-
-var (
- endError = fmt.Errorf("Finished") // not really an error
-)
-
-type goGitRepository struct {
- *git.Repository
-
- FromHash plumbing.Hash
- ToHash plumbing.Hash
-
- FromCommit *object.Commit
- ToCommit *object.Commit
-}
-
-func NewGoGitRepository(projectPath string, fromSHA string, toSHA string) (*goGitRepository, error) {
- out := &goGitRepository{}
-
- repo, err := git.PlainOpen(projectPath)
- if err != nil {
- return nil, err
- }
- out.Repository = repo
- out.FromHash = plumbing.NewHash(fromSHA)
-
- if !out.FromHash.IsZero() {
- commit, err := repo.CommitObject(out.FromHash)
- if err != nil {
- return nil, fmt.Errorf("Bad from SHA (%s): %s", out.FromHash, err)
- }
-
- out.FromCommit = commit
- }
-
- if toSHA == "" {
- ref, err := out.Repository.Head()
- if err != nil {
- return nil, err
- }
-
- out.ToHash = ref.Hash()
- } else {
- out.ToHash = plumbing.NewHash(toSHA)
- }
-
- commit, err := out.Repository.CommitObject(out.ToHash)
- if err != nil {
- return nil, fmt.Errorf("Bad to SHA (%s): %s", out.ToHash, err)
- }
-
- out.ToCommit = commit
-
- return out, nil
-}
-
-func (r *goGitRepository) diff() (object.Changes, error) {
- var fromTree, toTree *object.Tree
-
- if r.FromCommit != nil {
- tree, err := r.FromCommit.Tree()
- if err != nil {
- return nil, err
- }
-
- fromTree = tree
- }
-
- toTree, err := r.ToCommit.Tree()
- if err != nil {
- return nil, err
- }
-
- return object.DiffTree(fromTree, toTree)
-}
-
-func goGitBuildSignature(sig object.Signature) Signature {
- return Signature{
- Name: sig.Name,
- Email: sig.Email,
- When: sig.When,
- }
-}
-
-func goGitBuildFile(change object.ChangeEntry, file *object.File) *File {
- return &File{
- Path: change.Name,
- Oid: file.ID().String(),
- Blob: file.Blob.Reader,
- Size: file.Size,
- }
-}
-
-func (r *goGitRepository) EachFileChange(ins, mod, del FileFunc) error {
- changes, err := r.diff()
- if err != nil {
- return err
- }
-
- fromCommitStr := r.FromHash.String()
- toCommitStr := r.ToHash.String()
-
- for _, change := range changes {
- // FIXME(nick): submodules may need better support
- // https://github.com/src-d/go-git/issues/317
- if change.From.TreeEntry.Mode == filemode.Submodule || change.To.TreeEntry.Mode == filemode.Submodule {
- continue
- }
-
- fromF, toF, err := change.Files()
- if err != nil {
- return err
- }
-
- action, err := change.Action()
- if err != nil {
- return err
- }
-
- switch action {
- case merkletrie.Insert:
- err = ins(goGitBuildFile(change.To, toF), fromCommitStr, toCommitStr)
- case merkletrie.Modify:
- err = mod(goGitBuildFile(change.To, toF), fromCommitStr, toCommitStr)
- case merkletrie.Delete:
- err = del(goGitBuildFile(change.From, fromF), fromCommitStr, toCommitStr)
- default:
- err = fmt.Errorf("Unrecognised change calculating diff: %+v", change)
- }
-
- if err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// EachCommit runs `f` for each commit within `fromSHA`..`toSHA`
-// go-git doesn't directly support ranges of revisions, so we emulate this by
-// walking the commit history between from and to
-func (r *goGitRepository) EachCommit(f CommitFunc) error {
- err := object.WalkCommitHistoryPost(r.ToCommit, func(c *object.Commit) error {
- if r.FromCommit != nil && c.ID() == r.FromCommit.ID() {
- return endError
- }
-
- commit := &Commit{
- Message: c.Message,
- Hash: c.Hash.String(),
- Author: goGitBuildSignature(c.Author),
- Committer: goGitBuildSignature(c.Committer),
- }
- if err := f(commit); err != nil {
- return err
- }
-
- return nil
- })
-
- if err != nil && err != endError {
- return fmt.Errorf("WalkCommitHistory: %s", err)
- }
-
- return nil
-}
diff --git a/git/repository_test.go b/git/repository_test.go
index 881d8656dc3e3887e9b0faa57573dee5ca5ac265..ebfc441b4a124eed98fe50c866747010cd1b0370 100644
--- a/git/repository_test.go
+++ b/git/repository_test.go
@@ -45,7 +45,7 @@ func runEachCommit(repo git.Repository) (map[string]*git.Commit, []string, error
func TestEachCommit(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "", headSHA)
assert.NoError(t, err)
commits, commitHashes, err := runEachCommit(repo)
@@ -118,7 +118,7 @@ func TestEachCommit(t *testing.T) {
func TestEachCommitGivenRangeOf3Commits(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "1b12f15a11fc6e62177bef08f47bc7b5ce50b141", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "1b12f15a11fc6e62177bef08f47bc7b5ce50b141", headSHA)
assert.NoError(t, err)
_, commitHashes, err := runEachCommit(repo)
@@ -134,7 +134,7 @@ func TestEachCommitGivenRangeOf3Commits(t *testing.T) {
func TestEachCommitGivenRangeOf2Commits(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", headSHA)
assert.NoError(t, err)
_, commitHashes, err := runEachCommit(repo)
@@ -146,7 +146,7 @@ func TestEachCommitGivenRangeOf2Commits(t *testing.T) {
func TestEachCommitGivenRangeOf1Commit(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, headSHA, headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, headSHA, headSHA)
assert.NoError(t, err)
_, commitHashes, err := runEachCommit(repo)
@@ -157,7 +157,7 @@ func TestEachCommitGivenRangeOf1Commit(t *testing.T) {
func TestEmptyToSHADefaultsToHeadSHA(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", "")
+ repo, err := git.NewGit2GoRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", "")
assert.NoError(t, err)
_, commitHashes, err := runEachCommit(repo)
@@ -183,7 +183,7 @@ func runEachFileChange(repo git.Repository) (map[string]*git.File, []string, err
func TestEachFileChangeMod(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "", headSHA)
assert.NoError(t, err)
files, filePaths, err := runEachFileChange(repo)
@@ -252,7 +252,7 @@ func TestEachFileChangeMod(t *testing.T) {
func TestEachFileChangeGivenRangeOfThreeCommits(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "1b12f15a11fc6e62177bef08f47bc7b5ce50b141", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "1b12f15a11fc6e62177bef08f47bc7b5ce50b141", headSHA)
assert.NoError(t, err)
_, filePaths, err := runEachFileChange(repo)
@@ -263,7 +263,7 @@ func TestEachFileChangeGivenRangeOfThreeCommits(t *testing.T) {
func TestEachFileChangeGivenRangeOfTwoCommits(t *testing.T) {
checkDeps(t)
- repo, err := git.NewGoGitRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", headSHA)
+ repo, err := git.NewGit2GoRepository(*testRepo, "498214de67004b1da3d820901307bed2a68a8ef6", headSHA)
assert.NoError(t, err)
_, filePaths, err := runEachFileChange(repo)
diff --git a/indexer/indexer.go b/indexer/indexer.go
index 1eb977bfe3f24498eed8bd7ad859d4ef594d17a7..f25b9a25d5a7601e8de4656354c7aa6744c9282e 100644
--- a/indexer/indexer.go
+++ b/indexer/indexer.go
@@ -24,6 +24,8 @@ type Indexer struct {
func (i *Indexer) SubmitCommit(c *git.Commit) error {
commit := BuildCommit(c, i.Submitter.ParentID())
+ // log.Print("Submitting commit: ", commit.Hash)
+
i.Submitter.Index(commit.ID, map[string]interface{}{"commit": commit})
return nil
}
@@ -38,6 +40,8 @@ func (i *Indexer) SubmitBlob(f *git.File, _, toCommit string) error {
return fmt.Errorf("Blob %s: %s", f.Path, err)
}
+ // log.Print("Submitting blob: ", f.Path)
+
i.Submitter.Index(blob.ID, map[string]interface{}{"blob": blob})
return nil
}
@@ -45,6 +49,8 @@ func (i *Indexer) SubmitBlob(f *git.File, _, toCommit string) error {
func (i *Indexer) RemoveBlob(file *git.File, _, _ string) error {
blobID := GenerateBlobID(i.Submitter.ParentID(), file.Path)
+ // log.Print("Removing blob: ", file.Path)
+
i.Submitter.Remove(blobID)
return nil
}
diff --git a/main.go b/main.go
index c843d2113fc01baeb6291e920ef894543807ebfd..ec49f00b92aa2fa02cb1b2ccedbb4f18a1f0cf37 100644
--- a/main.go
+++ b/main.go
@@ -19,7 +19,7 @@ func main() {
fromSHA := os.Getenv("FROM_SHA")
toSHA := os.Getenv("TO_SHA")
- repo, err := git.NewGoGitRepository(projectPath, fromSHA, toSHA)
+ repo, err := git.NewGit2GoRepository(projectPath, fromSHA, toSHA)
if err != nil {
log.Fatalf("Failed to open %s: %s", projectPath, err)
}
diff --git a/vendor/github.com/sergi/go-diff/LICENSE b/vendor/github.com/sergi/go-diff/LICENSE
deleted file mode 100644
index 937942c2b2c4cf2c0b3043210ac71e594ee4f5df..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2012-2016 The go-diff Authors. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/diff.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/diff.go
deleted file mode 100644
index 59b8851683f75416876e4ec36e1765d534f94bba..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/diff.go
+++ /dev/null
@@ -1,1339 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-import (
- "bytes"
- "errors"
- "fmt"
- "html"
- "math"
- "net/url"
- "regexp"
- "strconv"
- "strings"
- "time"
- "unicode/utf8"
-)
-
-// Operation defines the operation of a diff item.
-type Operation int8
-
-const (
- // DiffDelete item represents a delete diff.
- DiffDelete Operation = -1
- // DiffInsert item represents an insert diff.
- DiffInsert Operation = 1
- // DiffEqual item represents an equal diff.
- DiffEqual Operation = 0
-)
-
-// Diff represents one diff operation
-type Diff struct {
- Type Operation
- Text string
-}
-
-func splice(slice []Diff, index int, amount int, elements ...Diff) []Diff {
- return append(slice[:index], append(elements, slice[index+amount:]...)...)
-}
-
-// DiffMain finds the differences between two texts.
-// If an invalid UTF-8 sequence is encountered, it will be replaced by the Unicode replacement character.
-func (dmp *DiffMatchPatch) DiffMain(text1, text2 string, checklines bool) []Diff {
- return dmp.DiffMainRunes([]rune(text1), []rune(text2), checklines)
-}
-
-// DiffMainRunes finds the differences between two rune sequences.
-// If an invalid UTF-8 sequence is encountered, it will be replaced by the Unicode replacement character.
-func (dmp *DiffMatchPatch) DiffMainRunes(text1, text2 []rune, checklines bool) []Diff {
- var deadline time.Time
- if dmp.DiffTimeout > 0 {
- deadline = time.Now().Add(dmp.DiffTimeout)
- }
- return dmp.diffMainRunes(text1, text2, checklines, deadline)
-}
-
-func (dmp *DiffMatchPatch) diffMainRunes(text1, text2 []rune, checklines bool, deadline time.Time) []Diff {
- if runesEqual(text1, text2) {
- var diffs []Diff
- if len(text1) > 0 {
- diffs = append(diffs, Diff{DiffEqual, string(text1)})
- }
- return diffs
- }
- // Trim off common prefix (speedup).
- commonlength := commonPrefixLength(text1, text2)
- commonprefix := text1[:commonlength]
- text1 = text1[commonlength:]
- text2 = text2[commonlength:]
-
- // Trim off common suffix (speedup).
- commonlength = commonSuffixLength(text1, text2)
- commonsuffix := text1[len(text1)-commonlength:]
- text1 = text1[:len(text1)-commonlength]
- text2 = text2[:len(text2)-commonlength]
-
- // Compute the diff on the middle block.
- diffs := dmp.diffCompute(text1, text2, checklines, deadline)
-
- // Restore the prefix and suffix.
- if len(commonprefix) != 0 {
- diffs = append([]Diff{Diff{DiffEqual, string(commonprefix)}}, diffs...)
- }
- if len(commonsuffix) != 0 {
- diffs = append(diffs, Diff{DiffEqual, string(commonsuffix)})
- }
-
- return dmp.DiffCleanupMerge(diffs)
-}
-
-// diffCompute finds the differences between two rune slices. Assumes that the texts do not have any common prefix or suffix.
-func (dmp *DiffMatchPatch) diffCompute(text1, text2 []rune, checklines bool, deadline time.Time) []Diff {
- diffs := []Diff{}
- if len(text1) == 0 {
- // Just add some text (speedup).
- return append(diffs, Diff{DiffInsert, string(text2)})
- } else if len(text2) == 0 {
- // Just delete some text (speedup).
- return append(diffs, Diff{DiffDelete, string(text1)})
- }
-
- var longtext, shorttext []rune
- if len(text1) > len(text2) {
- longtext = text1
- shorttext = text2
- } else {
- longtext = text2
- shorttext = text1
- }
-
- if i := runesIndex(longtext, shorttext); i != -1 {
- op := DiffInsert
- // Swap insertions for deletions if diff is reversed.
- if len(text1) > len(text2) {
- op = DiffDelete
- }
- // Shorter text is inside the longer text (speedup).
- return []Diff{
- Diff{op, string(longtext[:i])},
- Diff{DiffEqual, string(shorttext)},
- Diff{op, string(longtext[i+len(shorttext):])},
- }
- } else if len(shorttext) == 1 {
- // Single character string.
- // After the previous speedup, the character can't be an equality.
- return []Diff{
- Diff{DiffDelete, string(text1)},
- Diff{DiffInsert, string(text2)},
- }
- // Check to see if the problem can be split in two.
- } else if hm := dmp.diffHalfMatch(text1, text2); hm != nil {
- // A half-match was found, sort out the return data.
- text1A := hm[0]
- text1B := hm[1]
- text2A := hm[2]
- text2B := hm[3]
- midCommon := hm[4]
- // Send both pairs off for separate processing.
- diffsA := dmp.diffMainRunes(text1A, text2A, checklines, deadline)
- diffsB := dmp.diffMainRunes(text1B, text2B, checklines, deadline)
- // Merge the results.
- return append(diffsA, append([]Diff{Diff{DiffEqual, string(midCommon)}}, diffsB...)...)
- } else if checklines && len(text1) > 100 && len(text2) > 100 {
- return dmp.diffLineMode(text1, text2, deadline)
- }
- return dmp.diffBisect(text1, text2, deadline)
-}
-
-// diffLineMode does a quick line-level diff on both []runes, then rediff the parts for greater accuracy. This speedup can produce non-minimal diffs.
-func (dmp *DiffMatchPatch) diffLineMode(text1, text2 []rune, deadline time.Time) []Diff {
- // Scan the text on a line-by-line basis first.
- text1, text2, linearray := dmp.diffLinesToRunes(text1, text2)
-
- diffs := dmp.diffMainRunes(text1, text2, false, deadline)
-
- // Convert the diff back to original text.
- diffs = dmp.DiffCharsToLines(diffs, linearray)
- // Eliminate freak matches (e.g. blank lines)
- diffs = dmp.DiffCleanupSemantic(diffs)
-
- // Rediff any replacement blocks, this time character-by-character.
- // Add a dummy entry at the end.
- diffs = append(diffs, Diff{DiffEqual, ""})
-
- pointer := 0
- countDelete := 0
- countInsert := 0
-
- // NOTE: Rune slices are slower than using strings in this case.
- textDelete := ""
- textInsert := ""
-
- for pointer < len(diffs) {
- switch diffs[pointer].Type {
- case DiffInsert:
- countInsert++
- textInsert += diffs[pointer].Text
- case DiffDelete:
- countDelete++
- textDelete += diffs[pointer].Text
- case DiffEqual:
- // Upon reaching an equality, check for prior redundancies.
- if countDelete >= 1 && countInsert >= 1 {
- // Delete the offending records and add the merged ones.
- diffs = splice(diffs, pointer-countDelete-countInsert,
- countDelete+countInsert)
-
- pointer = pointer - countDelete - countInsert
- a := dmp.diffMainRunes([]rune(textDelete), []rune(textInsert), false, deadline)
- for j := len(a) - 1; j >= 0; j-- {
- diffs = splice(diffs, pointer, 0, a[j])
- }
- pointer = pointer + len(a)
- }
-
- countInsert = 0
- countDelete = 0
- textDelete = ""
- textInsert = ""
- }
- pointer++
- }
-
- return diffs[:len(diffs)-1] // Remove the dummy entry at the end.
-}
-
-// DiffBisect finds the 'middle snake' of a diff, split the problem in two and return the recursively constructed diff.
-// If an invalid UTF-8 sequence is encountered, it will be replaced by the Unicode replacement character.
-// See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
-func (dmp *DiffMatchPatch) DiffBisect(text1, text2 string, deadline time.Time) []Diff {
- // Unused in this code, but retained for interface compatibility.
- return dmp.diffBisect([]rune(text1), []rune(text2), deadline)
-}
-
-// diffBisect finds the 'middle snake' of a diff, splits the problem in two and returns the recursively constructed diff.
-// See Myers's 1986 paper: An O(ND) Difference Algorithm and Its Variations.
-func (dmp *DiffMatchPatch) diffBisect(runes1, runes2 []rune, deadline time.Time) []Diff {
- // Cache the text lengths to prevent multiple calls.
- runes1Len, runes2Len := len(runes1), len(runes2)
-
- maxD := (runes1Len + runes2Len + 1) / 2
- vOffset := maxD
- vLength := 2 * maxD
-
- v1 := make([]int, vLength)
- v2 := make([]int, vLength)
- for i := range v1 {
- v1[i] = -1
- v2[i] = -1
- }
- v1[vOffset+1] = 0
- v2[vOffset+1] = 0
-
- delta := runes1Len - runes2Len
- // If the total number of characters is odd, then the front path will collide with the reverse path.
- front := (delta%2 != 0)
- // Offsets for start and end of k loop. Prevents mapping of space beyond the grid.
- k1start := 0
- k1end := 0
- k2start := 0
- k2end := 0
- for d := 0; d < maxD; d++ {
- // Bail out if deadline is reached.
- if !deadline.IsZero() && time.Now().After(deadline) {
- break
- }
-
- // Walk the front path one step.
- for k1 := -d + k1start; k1 <= d-k1end; k1 += 2 {
- k1Offset := vOffset + k1
- var x1 int
-
- if k1 == -d || (k1 != d && v1[k1Offset-1] < v1[k1Offset+1]) {
- x1 = v1[k1Offset+1]
- } else {
- x1 = v1[k1Offset-1] + 1
- }
-
- y1 := x1 - k1
- for x1 < runes1Len && y1 < runes2Len {
- if runes1[x1] != runes2[y1] {
- break
- }
- x1++
- y1++
- }
- v1[k1Offset] = x1
- if x1 > runes1Len {
- // Ran off the right of the graph.
- k1end += 2
- } else if y1 > runes2Len {
- // Ran off the bottom of the graph.
- k1start += 2
- } else if front {
- k2Offset := vOffset + delta - k1
- if k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] != -1 {
- // Mirror x2 onto top-left coordinate system.
- x2 := runes1Len - v2[k2Offset]
- if x1 >= x2 {
- // Overlap detected.
- return dmp.diffBisectSplit(runes1, runes2, x1, y1, deadline)
- }
- }
- }
- }
- // Walk the reverse path one step.
- for k2 := -d + k2start; k2 <= d-k2end; k2 += 2 {
- k2Offset := vOffset + k2
- var x2 int
- if k2 == -d || (k2 != d && v2[k2Offset-1] < v2[k2Offset+1]) {
- x2 = v2[k2Offset+1]
- } else {
- x2 = v2[k2Offset-1] + 1
- }
- var y2 = x2 - k2
- for x2 < runes1Len && y2 < runes2Len {
- if runes1[runes1Len-x2-1] != runes2[runes2Len-y2-1] {
- break
- }
- x2++
- y2++
- }
- v2[k2Offset] = x2
- if x2 > runes1Len {
- // Ran off the left of the graph.
- k2end += 2
- } else if y2 > runes2Len {
- // Ran off the top of the graph.
- k2start += 2
- } else if !front {
- k1Offset := vOffset + delta - k2
- if k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] != -1 {
- x1 := v1[k1Offset]
- y1 := vOffset + x1 - k1Offset
- // Mirror x2 onto top-left coordinate system.
- x2 = runes1Len - x2
- if x1 >= x2 {
- // Overlap detected.
- return dmp.diffBisectSplit(runes1, runes2, x1, y1, deadline)
- }
- }
- }
- }
- }
- // Diff took too long and hit the deadline or number of diffs equals number of characters, no commonality at all.
- return []Diff{
- Diff{DiffDelete, string(runes1)},
- Diff{DiffInsert, string(runes2)},
- }
-}
-
-func (dmp *DiffMatchPatch) diffBisectSplit(runes1, runes2 []rune, x, y int,
- deadline time.Time) []Diff {
- runes1a := runes1[:x]
- runes2a := runes2[:y]
- runes1b := runes1[x:]
- runes2b := runes2[y:]
-
- // Compute both diffs serially.
- diffs := dmp.diffMainRunes(runes1a, runes2a, false, deadline)
- diffsb := dmp.diffMainRunes(runes1b, runes2b, false, deadline)
-
- return append(diffs, diffsb...)
-}
-
-// DiffLinesToChars splits two texts into a list of strings, and educes the texts to a string of hashes where each Unicode character represents one line.
-// It's slightly faster to call DiffLinesToRunes first, followed by DiffMainRunes.
-func (dmp *DiffMatchPatch) DiffLinesToChars(text1, text2 string) (string, string, []string) {
- chars1, chars2, lineArray := dmp.DiffLinesToRunes(text1, text2)
- return string(chars1), string(chars2), lineArray
-}
-
-// DiffLinesToRunes splits two texts into a list of runes. Each rune represents one line.
-func (dmp *DiffMatchPatch) DiffLinesToRunes(text1, text2 string) ([]rune, []rune, []string) {
- // '\x00' is a valid character, but various debuggers don't like it. So we'll insert a junk entry to avoid generating a null character.
- lineArray := []string{""} // e.g. lineArray[4] == 'Hello\n'
- lineHash := map[string]int{} // e.g. lineHash['Hello\n'] == 4
-
- chars1 := dmp.diffLinesToRunesMunge(text1, &lineArray, lineHash)
- chars2 := dmp.diffLinesToRunesMunge(text2, &lineArray, lineHash)
-
- return chars1, chars2, lineArray
-}
-
-func (dmp *DiffMatchPatch) diffLinesToRunes(text1, text2 []rune) ([]rune, []rune, []string) {
- return dmp.DiffLinesToRunes(string(text1), string(text2))
-}
-
-// diffLinesToRunesMunge splits a text into an array of strings, and reduces the texts to a []rune where each Unicode character represents one line.
-// We use strings instead of []runes as input mainly because you can't use []rune as a map key.
-func (dmp *DiffMatchPatch) diffLinesToRunesMunge(text string, lineArray *[]string, lineHash map[string]int) []rune {
- // Walk the text, pulling out a substring for each line. text.split('\n') would would temporarily double our memory footprint. Modifying text would create many large strings to garbage collect.
- lineStart := 0
- lineEnd := -1
- runes := []rune{}
-
- for lineEnd < len(text)-1 {
- lineEnd = indexOf(text, "\n", lineStart)
-
- if lineEnd == -1 {
- lineEnd = len(text) - 1
- }
-
- line := text[lineStart : lineEnd+1]
- lineStart = lineEnd + 1
- lineValue, ok := lineHash[line]
-
- if ok {
- runes = append(runes, rune(lineValue))
- } else {
- *lineArray = append(*lineArray, line)
- lineHash[line] = len(*lineArray) - 1
- runes = append(runes, rune(len(*lineArray)-1))
- }
- }
-
- return runes
-}
-
-// DiffCharsToLines rehydrates the text in a diff from a string of line hashes to real lines of text.
-func (dmp *DiffMatchPatch) DiffCharsToLines(diffs []Diff, lineArray []string) []Diff {
- hydrated := make([]Diff, 0, len(diffs))
- for _, aDiff := range diffs {
- chars := aDiff.Text
- text := make([]string, len(chars))
-
- for i, r := range chars {
- text[i] = lineArray[r]
- }
-
- aDiff.Text = strings.Join(text, "")
- hydrated = append(hydrated, aDiff)
- }
- return hydrated
-}
-
-// DiffCommonPrefix determines the common prefix length of two strings.
-func (dmp *DiffMatchPatch) DiffCommonPrefix(text1, text2 string) int {
- // Unused in this code, but retained for interface compatibility.
- return commonPrefixLength([]rune(text1), []rune(text2))
-}
-
-// DiffCommonSuffix determines the common suffix length of two strings.
-func (dmp *DiffMatchPatch) DiffCommonSuffix(text1, text2 string) int {
- // Unused in this code, but retained for interface compatibility.
- return commonSuffixLength([]rune(text1), []rune(text2))
-}
-
-// commonPrefixLength returns the length of the common prefix of two rune slices.
-func commonPrefixLength(text1, text2 []rune) int {
- short, long := text1, text2
- if len(short) > len(long) {
- short, long = long, short
- }
- for i, r := range short {
- if r != long[i] {
- return i
- }
- }
- return len(short)
-}
-
-// commonSuffixLength returns the length of the common suffix of two rune slices.
-func commonSuffixLength(text1, text2 []rune) int {
- n := min(len(text1), len(text2))
- for i := 0; i < n; i++ {
- if text1[len(text1)-i-1] != text2[len(text2)-i-1] {
- return i
- }
- }
- return n
-
- // TODO research and benchmark this, why is it not activated? https://github.com/sergi/go-diff/issues/54
- // Binary search.
- // Performance analysis: http://neil.fraser.name/news/2007/10/09/
- /*
- pointermin := 0
- pointermax := math.Min(len(text1), len(text2))
- pointermid := pointermax
- pointerend := 0
- for pointermin < pointermid {
- if text1[len(text1)-pointermid:len(text1)-pointerend] ==
- text2[len(text2)-pointermid:len(text2)-pointerend] {
- pointermin = pointermid
- pointerend = pointermin
- } else {
- pointermax = pointermid
- }
- pointermid = math.Floor((pointermax-pointermin)/2 + pointermin)
- }
- return pointermid
- */
-}
-
-// DiffCommonOverlap determines if the suffix of one string is the prefix of another.
-func (dmp *DiffMatchPatch) DiffCommonOverlap(text1 string, text2 string) int {
- // Cache the text lengths to prevent multiple calls.
- text1Length := len(text1)
- text2Length := len(text2)
- // Eliminate the null case.
- if text1Length == 0 || text2Length == 0 {
- return 0
- }
- // Truncate the longer string.
- if text1Length > text2Length {
- text1 = text1[text1Length-text2Length:]
- } else if text1Length < text2Length {
- text2 = text2[0:text1Length]
- }
- textLength := int(math.Min(float64(text1Length), float64(text2Length)))
- // Quick check for the worst case.
- if text1 == text2 {
- return textLength
- }
-
- // Start by looking for a single character match and increase length until no match is found. Performance analysis: http://neil.fraser.name/news/2010/11/04/
- best := 0
- length := 1
- for {
- pattern := text1[textLength-length:]
- found := strings.Index(text2, pattern)
- if found == -1 {
- break
- }
- length += found
- if found == 0 || text1[textLength-length:] == text2[0:length] {
- best = length
- length++
- }
- }
-
- return best
-}
-
-// DiffHalfMatch checks whether the two texts share a substring which is at least half the length of the longer text. This speedup can produce non-minimal diffs.
-func (dmp *DiffMatchPatch) DiffHalfMatch(text1, text2 string) []string {
- // Unused in this code, but retained for interface compatibility.
- runeSlices := dmp.diffHalfMatch([]rune(text1), []rune(text2))
- if runeSlices == nil {
- return nil
- }
-
- result := make([]string, len(runeSlices))
- for i, r := range runeSlices {
- result[i] = string(r)
- }
- return result
-}
-
-func (dmp *DiffMatchPatch) diffHalfMatch(text1, text2 []rune) [][]rune {
- if dmp.DiffTimeout <= 0 {
- // Don't risk returning a non-optimal diff if we have unlimited time.
- return nil
- }
-
- var longtext, shorttext []rune
- if len(text1) > len(text2) {
- longtext = text1
- shorttext = text2
- } else {
- longtext = text2
- shorttext = text1
- }
-
- if len(longtext) < 4 || len(shorttext)*2 < len(longtext) {
- return nil // Pointless.
- }
-
- // First check if the second quarter is the seed for a half-match.
- hm1 := dmp.diffHalfMatchI(longtext, shorttext, int(float64(len(longtext)+3)/4))
-
- // Check again based on the third quarter.
- hm2 := dmp.diffHalfMatchI(longtext, shorttext, int(float64(len(longtext)+1)/2))
-
- hm := [][]rune{}
- if hm1 == nil && hm2 == nil {
- return nil
- } else if hm2 == nil {
- hm = hm1
- } else if hm1 == nil {
- hm = hm2
- } else {
- // Both matched. Select the longest.
- if len(hm1[4]) > len(hm2[4]) {
- hm = hm1
- } else {
- hm = hm2
- }
- }
-
- // A half-match was found, sort out the return data.
- if len(text1) > len(text2) {
- return hm
- }
-
- return [][]rune{hm[2], hm[3], hm[0], hm[1], hm[4]}
-}
-
-// diffHalfMatchI checks if a substring of shorttext exist within longtext such that the substring is at least half the length of longtext?
-// Returns a slice containing the prefix of longtext, the suffix of longtext, the prefix of shorttext, the suffix of shorttext and the common middle, or null if there was no match.
-func (dmp *DiffMatchPatch) diffHalfMatchI(l, s []rune, i int) [][]rune {
- var bestCommonA []rune
- var bestCommonB []rune
- var bestCommonLen int
- var bestLongtextA []rune
- var bestLongtextB []rune
- var bestShorttextA []rune
- var bestShorttextB []rune
-
- // Start with a 1/4 length substring at position i as a seed.
- seed := l[i : i+len(l)/4]
-
- for j := runesIndexOf(s, seed, 0); j != -1; j = runesIndexOf(s, seed, j+1) {
- prefixLength := commonPrefixLength(l[i:], s[j:])
- suffixLength := commonSuffixLength(l[:i], s[:j])
-
- if bestCommonLen < suffixLength+prefixLength {
- bestCommonA = s[j-suffixLength : j]
- bestCommonB = s[j : j+prefixLength]
- bestCommonLen = len(bestCommonA) + len(bestCommonB)
- bestLongtextA = l[:i-suffixLength]
- bestLongtextB = l[i+prefixLength:]
- bestShorttextA = s[:j-suffixLength]
- bestShorttextB = s[j+prefixLength:]
- }
- }
-
- if bestCommonLen*2 < len(l) {
- return nil
- }
-
- return [][]rune{
- bestLongtextA,
- bestLongtextB,
- bestShorttextA,
- bestShorttextB,
- append(bestCommonA, bestCommonB...),
- }
-}
-
-// DiffCleanupSemantic reduces the number of edits by eliminating semantically trivial equalities.
-func (dmp *DiffMatchPatch) DiffCleanupSemantic(diffs []Diff) []Diff {
- changes := false
- // Stack of indices where equalities are found.
- type equality struct {
- data int
- next *equality
- }
- var equalities *equality
-
- var lastequality string
- // Always equal to diffs[equalities[equalitiesLength - 1]][1]
- var pointer int // Index of current position.
- // Number of characters that changed prior to the equality.
- var lengthInsertions1, lengthDeletions1 int
- // Number of characters that changed after the equality.
- var lengthInsertions2, lengthDeletions2 int
-
- for pointer < len(diffs) {
- if diffs[pointer].Type == DiffEqual {
- // Equality found.
-
- equalities = &equality{
- data: pointer,
- next: equalities,
- }
- lengthInsertions1 = lengthInsertions2
- lengthDeletions1 = lengthDeletions2
- lengthInsertions2 = 0
- lengthDeletions2 = 0
- lastequality = diffs[pointer].Text
- } else {
- // An insertion or deletion.
-
- if diffs[pointer].Type == DiffInsert {
- lengthInsertions2 += len(diffs[pointer].Text)
- } else {
- lengthDeletions2 += len(diffs[pointer].Text)
- }
- // Eliminate an equality that is smaller or equal to the edits on both sides of it.
- difference1 := int(math.Max(float64(lengthInsertions1), float64(lengthDeletions1)))
- difference2 := int(math.Max(float64(lengthInsertions2), float64(lengthDeletions2)))
- if len(lastequality) > 0 &&
- (len(lastequality) <= difference1) &&
- (len(lastequality) <= difference2) {
- // Duplicate record.
- insPoint := equalities.data
- diffs = append(
- diffs[:insPoint],
- append([]Diff{Diff{DiffDelete, lastequality}}, diffs[insPoint:]...)...)
-
- // Change second copy to insert.
- diffs[insPoint+1].Type = DiffInsert
- // Throw away the equality we just deleted.
- equalities = equalities.next
-
- if equalities != nil {
- equalities = equalities.next
- }
- if equalities != nil {
- pointer = equalities.data
- } else {
- pointer = -1
- }
-
- lengthInsertions1 = 0 // Reset the counters.
- lengthDeletions1 = 0
- lengthInsertions2 = 0
- lengthDeletions2 = 0
- lastequality = ""
- changes = true
- }
- }
- pointer++
- }
-
- // Normalize the diff.
- if changes {
- diffs = dmp.DiffCleanupMerge(diffs)
- }
- diffs = dmp.DiffCleanupSemanticLossless(diffs)
- // Find any overlaps between deletions and insertions.
- // e.g: <del>abcxxx</del><ins>xxxdef</ins>
- // -> <del>abc</del>xxx<ins>def</ins>
- // e.g: <del>xxxabc</del><ins>defxxx</ins>
- // -> <ins>def</ins>xxx<del>abc</del>
- // Only extract an overlap if it is as big as the edit ahead or behind it.
- pointer = 1
- for pointer < len(diffs) {
- if diffs[pointer-1].Type == DiffDelete &&
- diffs[pointer].Type == DiffInsert {
- deletion := diffs[pointer-1].Text
- insertion := diffs[pointer].Text
- overlapLength1 := dmp.DiffCommonOverlap(deletion, insertion)
- overlapLength2 := dmp.DiffCommonOverlap(insertion, deletion)
- if overlapLength1 >= overlapLength2 {
- if float64(overlapLength1) >= float64(len(deletion))/2 ||
- float64(overlapLength1) >= float64(len(insertion))/2 {
-
- // Overlap found. Insert an equality and trim the surrounding edits.
- diffs = append(
- diffs[:pointer],
- append([]Diff{Diff{DiffEqual, insertion[:overlapLength1]}}, diffs[pointer:]...)...)
-
- diffs[pointer-1].Text =
- deletion[0 : len(deletion)-overlapLength1]
- diffs[pointer+1].Text = insertion[overlapLength1:]
- pointer++
- }
- } else {
- if float64(overlapLength2) >= float64(len(deletion))/2 ||
- float64(overlapLength2) >= float64(len(insertion))/2 {
- // Reverse overlap found. Insert an equality and swap and trim the surrounding edits.
- overlap := Diff{DiffEqual, deletion[:overlapLength2]}
- diffs = append(
- diffs[:pointer],
- append([]Diff{overlap}, diffs[pointer:]...)...)
-
- diffs[pointer-1].Type = DiffInsert
- diffs[pointer-1].Text = insertion[0 : len(insertion)-overlapLength2]
- diffs[pointer+1].Type = DiffDelete
- diffs[pointer+1].Text = deletion[overlapLength2:]
- pointer++
- }
- }
- pointer++
- }
- pointer++
- }
-
- return diffs
-}
-
-// Define some regex patterns for matching boundaries.
-var (
- nonAlphaNumericRegex = regexp.MustCompile(`[^a-zA-Z0-9]`)
- whitespaceRegex = regexp.MustCompile(`\s`)
- linebreakRegex = regexp.MustCompile(`[\r\n]`)
- blanklineEndRegex = regexp.MustCompile(`\n\r?\n$`)
- blanklineStartRegex = regexp.MustCompile(`^\r?\n\r?\n`)
-)
-
-// diffCleanupSemanticScore computes a score representing whether the internal boundary falls on logical boundaries.
-// Scores range from 6 (best) to 0 (worst). Closure, but does not reference any external variables.
-func diffCleanupSemanticScore(one, two string) int {
- if len(one) == 0 || len(two) == 0 {
- // Edges are the best.
- return 6
- }
-
- // Each port of this function behaves slightly differently due to subtle differences in each language's definition of things like 'whitespace'. Since this function's purpose is largely cosmetic, the choice has been made to use each language's native features rather than force total conformity.
- rune1, _ := utf8.DecodeLastRuneInString(one)
- rune2, _ := utf8.DecodeRuneInString(two)
- char1 := string(rune1)
- char2 := string(rune2)
-
- nonAlphaNumeric1 := nonAlphaNumericRegex.MatchString(char1)
- nonAlphaNumeric2 := nonAlphaNumericRegex.MatchString(char2)
- whitespace1 := nonAlphaNumeric1 && whitespaceRegex.MatchString(char1)
- whitespace2 := nonAlphaNumeric2 && whitespaceRegex.MatchString(char2)
- lineBreak1 := whitespace1 && linebreakRegex.MatchString(char1)
- lineBreak2 := whitespace2 && linebreakRegex.MatchString(char2)
- blankLine1 := lineBreak1 && blanklineEndRegex.MatchString(one)
- blankLine2 := lineBreak2 && blanklineEndRegex.MatchString(two)
-
- if blankLine1 || blankLine2 {
- // Five points for blank lines.
- return 5
- } else if lineBreak1 || lineBreak2 {
- // Four points for line breaks.
- return 4
- } else if nonAlphaNumeric1 && !whitespace1 && whitespace2 {
- // Three points for end of sentences.
- return 3
- } else if whitespace1 || whitespace2 {
- // Two points for whitespace.
- return 2
- } else if nonAlphaNumeric1 || nonAlphaNumeric2 {
- // One point for non-alphanumeric.
- return 1
- }
- return 0
-}
-
-// DiffCleanupSemanticLossless looks for single edits surrounded on both sides by equalities which can be shifted sideways to align the edit to a word boundary.
-// E.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
-func (dmp *DiffMatchPatch) DiffCleanupSemanticLossless(diffs []Diff) []Diff {
- pointer := 1
-
- // Intentionally ignore the first and last element (don't need checking).
- for pointer < len(diffs)-1 {
- if diffs[pointer-1].Type == DiffEqual &&
- diffs[pointer+1].Type == DiffEqual {
-
- // This is a single edit surrounded by equalities.
- equality1 := diffs[pointer-1].Text
- edit := diffs[pointer].Text
- equality2 := diffs[pointer+1].Text
-
- // First, shift the edit as far left as possible.
- commonOffset := dmp.DiffCommonSuffix(equality1, edit)
- if commonOffset > 0 {
- commonString := edit[len(edit)-commonOffset:]
- equality1 = equality1[0 : len(equality1)-commonOffset]
- edit = commonString + edit[:len(edit)-commonOffset]
- equality2 = commonString + equality2
- }
-
- // Second, step character by character right, looking for the best fit.
- bestEquality1 := equality1
- bestEdit := edit
- bestEquality2 := equality2
- bestScore := diffCleanupSemanticScore(equality1, edit) +
- diffCleanupSemanticScore(edit, equality2)
-
- for len(edit) != 0 && len(equality2) != 0 {
- _, sz := utf8.DecodeRuneInString(edit)
- if len(equality2) < sz || edit[:sz] != equality2[:sz] {
- break
- }
- equality1 += edit[:sz]
- edit = edit[sz:] + equality2[:sz]
- equality2 = equality2[sz:]
- score := diffCleanupSemanticScore(equality1, edit) +
- diffCleanupSemanticScore(edit, equality2)
- // The >= encourages trailing rather than leading whitespace on edits.
- if score >= bestScore {
- bestScore = score
- bestEquality1 = equality1
- bestEdit = edit
- bestEquality2 = equality2
- }
- }
-
- if diffs[pointer-1].Text != bestEquality1 {
- // We have an improvement, save it back to the diff.
- if len(bestEquality1) != 0 {
- diffs[pointer-1].Text = bestEquality1
- } else {
- diffs = splice(diffs, pointer-1, 1)
- pointer--
- }
-
- diffs[pointer].Text = bestEdit
- if len(bestEquality2) != 0 {
- diffs[pointer+1].Text = bestEquality2
- } else {
- diffs = append(diffs[:pointer+1], diffs[pointer+2:]...)
- pointer--
- }
- }
- }
- pointer++
- }
-
- return diffs
-}
-
-// DiffCleanupEfficiency reduces the number of edits by eliminating operationally trivial equalities.
-func (dmp *DiffMatchPatch) DiffCleanupEfficiency(diffs []Diff) []Diff {
- changes := false
- // Stack of indices where equalities are found.
- type equality struct {
- data int
- next *equality
- }
- var equalities *equality
- // Always equal to equalities[equalitiesLength-1][1]
- lastequality := ""
- pointer := 0 // Index of current position.
- // Is there an insertion operation before the last equality.
- preIns := false
- // Is there a deletion operation before the last equality.
- preDel := false
- // Is there an insertion operation after the last equality.
- postIns := false
- // Is there a deletion operation after the last equality.
- postDel := false
- for pointer < len(diffs) {
- if diffs[pointer].Type == DiffEqual { // Equality found.
- if len(diffs[pointer].Text) < dmp.DiffEditCost &&
- (postIns || postDel) {
- // Candidate found.
- equalities = &equality{
- data: pointer,
- next: equalities,
- }
- preIns = postIns
- preDel = postDel
- lastequality = diffs[pointer].Text
- } else {
- // Not a candidate, and can never become one.
- equalities = nil
- lastequality = ""
- }
- postIns = false
- postDel = false
- } else { // An insertion or deletion.
- if diffs[pointer].Type == DiffDelete {
- postDel = true
- } else {
- postIns = true
- }
-
- // Five types to be split:
- // <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
- // <ins>A</ins>X<ins>C</ins><del>D</del>
- // <ins>A</ins><del>B</del>X<ins>C</ins>
- // <ins>A</del>X<ins>C</ins><del>D</del>
- // <ins>A</ins><del>B</del>X<del>C</del>
- var sumPres int
- if preIns {
- sumPres++
- }
- if preDel {
- sumPres++
- }
- if postIns {
- sumPres++
- }
- if postDel {
- sumPres++
- }
- if len(lastequality) > 0 &&
- ((preIns && preDel && postIns && postDel) ||
- ((len(lastequality) < dmp.DiffEditCost/2) && sumPres == 3)) {
-
- insPoint := equalities.data
-
- // Duplicate record.
- diffs = append(diffs[:insPoint],
- append([]Diff{Diff{DiffDelete, lastequality}}, diffs[insPoint:]...)...)
-
- // Change second copy to insert.
- diffs[insPoint+1].Type = DiffInsert
- // Throw away the equality we just deleted.
- equalities = equalities.next
- lastequality = ""
-
- if preIns && preDel {
- // No changes made which could affect previous entry, keep going.
- postIns = true
- postDel = true
- equalities = nil
- } else {
- if equalities != nil {
- equalities = equalities.next
- }
- if equalities != nil {
- pointer = equalities.data
- } else {
- pointer = -1
- }
- postIns = false
- postDel = false
- }
- changes = true
- }
- }
- pointer++
- }
-
- if changes {
- diffs = dmp.DiffCleanupMerge(diffs)
- }
-
- return diffs
-}
-
-// DiffCleanupMerge reorders and merges like edit sections. Merge equalities.
-// Any edit section can move as long as it doesn't cross an equality.
-func (dmp *DiffMatchPatch) DiffCleanupMerge(diffs []Diff) []Diff {
- // Add a dummy entry at the end.
- diffs = append(diffs, Diff{DiffEqual, ""})
- pointer := 0
- countDelete := 0
- countInsert := 0
- commonlength := 0
- textDelete := []rune(nil)
- textInsert := []rune(nil)
-
- for pointer < len(diffs) {
- switch diffs[pointer].Type {
- case DiffInsert:
- countInsert++
- textInsert = append(textInsert, []rune(diffs[pointer].Text)...)
- pointer++
- break
- case DiffDelete:
- countDelete++
- textDelete = append(textDelete, []rune(diffs[pointer].Text)...)
- pointer++
- break
- case DiffEqual:
- // Upon reaching an equality, check for prior redundancies.
- if countDelete+countInsert > 1 {
- if countDelete != 0 && countInsert != 0 {
- // Factor out any common prefixies.
- commonlength = commonPrefixLength(textInsert, textDelete)
- if commonlength != 0 {
- x := pointer - countDelete - countInsert
- if x > 0 && diffs[x-1].Type == DiffEqual {
- diffs[x-1].Text += string(textInsert[:commonlength])
- } else {
- diffs = append([]Diff{Diff{DiffEqual, string(textInsert[:commonlength])}}, diffs...)
- pointer++
- }
- textInsert = textInsert[commonlength:]
- textDelete = textDelete[commonlength:]
- }
- // Factor out any common suffixies.
- commonlength = commonSuffixLength(textInsert, textDelete)
- if commonlength != 0 {
- insertIndex := len(textInsert) - commonlength
- deleteIndex := len(textDelete) - commonlength
- diffs[pointer].Text = string(textInsert[insertIndex:]) + diffs[pointer].Text
- textInsert = textInsert[:insertIndex]
- textDelete = textDelete[:deleteIndex]
- }
- }
- // Delete the offending records and add the merged ones.
- if countDelete == 0 {
- diffs = splice(diffs, pointer-countInsert,
- countDelete+countInsert,
- Diff{DiffInsert, string(textInsert)})
- } else if countInsert == 0 {
- diffs = splice(diffs, pointer-countDelete,
- countDelete+countInsert,
- Diff{DiffDelete, string(textDelete)})
- } else {
- diffs = splice(diffs, pointer-countDelete-countInsert,
- countDelete+countInsert,
- Diff{DiffDelete, string(textDelete)},
- Diff{DiffInsert, string(textInsert)})
- }
-
- pointer = pointer - countDelete - countInsert + 1
- if countDelete != 0 {
- pointer++
- }
- if countInsert != 0 {
- pointer++
- }
- } else if pointer != 0 && diffs[pointer-1].Type == DiffEqual {
- // Merge this equality with the previous one.
- diffs[pointer-1].Text += diffs[pointer].Text
- diffs = append(diffs[:pointer], diffs[pointer+1:]...)
- } else {
- pointer++
- }
- countInsert = 0
- countDelete = 0
- textDelete = nil
- textInsert = nil
- break
- }
- }
-
- if len(diffs[len(diffs)-1].Text) == 0 {
- diffs = diffs[0 : len(diffs)-1] // Remove the dummy entry at the end.
- }
-
- // Second pass: look for single edits surrounded on both sides by equalities which can be shifted sideways to eliminate an equality. E.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
- changes := false
- pointer = 1
- // Intentionally ignore the first and last element (don't need checking).
- for pointer < (len(diffs) - 1) {
- if diffs[pointer-1].Type == DiffEqual &&
- diffs[pointer+1].Type == DiffEqual {
- // This is a single edit surrounded by equalities.
- if strings.HasSuffix(diffs[pointer].Text, diffs[pointer-1].Text) {
- // Shift the edit over the previous equality.
- diffs[pointer].Text = diffs[pointer-1].Text +
- diffs[pointer].Text[:len(diffs[pointer].Text)-len(diffs[pointer-1].Text)]
- diffs[pointer+1].Text = diffs[pointer-1].Text + diffs[pointer+1].Text
- diffs = splice(diffs, pointer-1, 1)
- changes = true
- } else if strings.HasPrefix(diffs[pointer].Text, diffs[pointer+1].Text) {
- // Shift the edit over the next equality.
- diffs[pointer-1].Text += diffs[pointer+1].Text
- diffs[pointer].Text =
- diffs[pointer].Text[len(diffs[pointer+1].Text):] + diffs[pointer+1].Text
- diffs = splice(diffs, pointer+1, 1)
- changes = true
- }
- }
- pointer++
- }
-
- // If shifts were made, the diff needs reordering and another shift sweep.
- if changes {
- diffs = dmp.DiffCleanupMerge(diffs)
- }
-
- return diffs
-}
-
-// DiffXIndex returns the equivalent location in s2.
-func (dmp *DiffMatchPatch) DiffXIndex(diffs []Diff, loc int) int {
- chars1 := 0
- chars2 := 0
- lastChars1 := 0
- lastChars2 := 0
- lastDiff := Diff{}
- for i := 0; i < len(diffs); i++ {
- aDiff := diffs[i]
- if aDiff.Type != DiffInsert {
- // Equality or deletion.
- chars1 += len(aDiff.Text)
- }
- if aDiff.Type != DiffDelete {
- // Equality or insertion.
- chars2 += len(aDiff.Text)
- }
- if chars1 > loc {
- // Overshot the location.
- lastDiff = aDiff
- break
- }
- lastChars1 = chars1
- lastChars2 = chars2
- }
- if lastDiff.Type == DiffDelete {
- // The location was deleted.
- return lastChars2
- }
- // Add the remaining character length.
- return lastChars2 + (loc - lastChars1)
-}
-
-// DiffPrettyHtml converts a []Diff into a pretty HTML report.
-// It is intended as an example from which to write one's own display functions.
-func (dmp *DiffMatchPatch) DiffPrettyHtml(diffs []Diff) string {
- var buff bytes.Buffer
- for _, diff := range diffs {
- text := strings.Replace(html.EscapeString(diff.Text), "\n", "¶<br>", -1)
- switch diff.Type {
- case DiffInsert:
- _, _ = buff.WriteString("<ins style=\"background:#e6ffe6;\">")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("</ins>")
- case DiffDelete:
- _, _ = buff.WriteString("<del style=\"background:#ffe6e6;\">")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("</del>")
- case DiffEqual:
- _, _ = buff.WriteString("<span>")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("</span>")
- }
- }
- return buff.String()
-}
-
-// DiffPrettyText converts a []Diff into a colored text report.
-func (dmp *DiffMatchPatch) DiffPrettyText(diffs []Diff) string {
- var buff bytes.Buffer
- for _, diff := range diffs {
- text := diff.Text
-
- switch diff.Type {
- case DiffInsert:
- _, _ = buff.WriteString("\x1b[32m")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("\x1b[0m")
- case DiffDelete:
- _, _ = buff.WriteString("\x1b[31m")
- _, _ = buff.WriteString(text)
- _, _ = buff.WriteString("\x1b[0m")
- case DiffEqual:
- _, _ = buff.WriteString(text)
- }
- }
-
- return buff.String()
-}
-
-// DiffText1 computes and returns the source text (all equalities and deletions).
-func (dmp *DiffMatchPatch) DiffText1(diffs []Diff) string {
- //StringBuilder text = new StringBuilder()
- var text bytes.Buffer
-
- for _, aDiff := range diffs {
- if aDiff.Type != DiffInsert {
- _, _ = text.WriteString(aDiff.Text)
- }
- }
- return text.String()
-}
-
-// DiffText2 computes and returns the destination text (all equalities and insertions).
-func (dmp *DiffMatchPatch) DiffText2(diffs []Diff) string {
- var text bytes.Buffer
-
- for _, aDiff := range diffs {
- if aDiff.Type != DiffDelete {
- _, _ = text.WriteString(aDiff.Text)
- }
- }
- return text.String()
-}
-
-// DiffLevenshtein computes the Levenshtein distance that is the number of inserted, deleted or substituted characters.
-func (dmp *DiffMatchPatch) DiffLevenshtein(diffs []Diff) int {
- levenshtein := 0
- insertions := 0
- deletions := 0
-
- for _, aDiff := range diffs {
- switch aDiff.Type {
- case DiffInsert:
- insertions += len(aDiff.Text)
- case DiffDelete:
- deletions += len(aDiff.Text)
- case DiffEqual:
- // A deletion and an insertion is one substitution.
- levenshtein += max(insertions, deletions)
- insertions = 0
- deletions = 0
- }
- }
-
- levenshtein += max(insertions, deletions)
- return levenshtein
-}
-
-// DiffToDelta crushes the diff into an encoded string which describes the operations required to transform text1 into text2.
-// E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. Operations are tab-separated. Inserted text is escaped using %xx notation.
-func (dmp *DiffMatchPatch) DiffToDelta(diffs []Diff) string {
- var text bytes.Buffer
- for _, aDiff := range diffs {
- switch aDiff.Type {
- case DiffInsert:
- _, _ = text.WriteString("+")
- _, _ = text.WriteString(strings.Replace(url.QueryEscape(aDiff.Text), "+", " ", -1))
- _, _ = text.WriteString("\t")
- break
- case DiffDelete:
- _, _ = text.WriteString("-")
- _, _ = text.WriteString(strconv.Itoa(utf8.RuneCountInString(aDiff.Text)))
- _, _ = text.WriteString("\t")
- break
- case DiffEqual:
- _, _ = text.WriteString("=")
- _, _ = text.WriteString(strconv.Itoa(utf8.RuneCountInString(aDiff.Text)))
- _, _ = text.WriteString("\t")
- break
- }
- }
- delta := text.String()
- if len(delta) != 0 {
- // Strip off trailing tab character.
- delta = delta[0 : utf8.RuneCountInString(delta)-1]
- delta = unescaper.Replace(delta)
- }
- return delta
-}
-
-// DiffFromDelta given the original text1, and an encoded string which describes the operations required to transform text1 into text2, comAdde the full diff.
-func (dmp *DiffMatchPatch) DiffFromDelta(text1 string, delta string) (diffs []Diff, err error) {
- i := 0
-
- for _, token := range strings.Split(delta, "\t") {
- if len(token) == 0 {
- // Blank tokens are ok (from a trailing \t).
- continue
- }
-
- // Each token begins with a one character parameter which specifies the operation of this token (delete, insert, equality).
- param := token[1:]
-
- switch op := token[0]; op {
- case '+':
- // Decode would Diff all "+" to " "
- param = strings.Replace(param, "+", "%2b", -1)
- param, err = url.QueryUnescape(param)
- if err != nil {
- return nil, err
- }
- if !utf8.ValidString(param) {
- return nil, fmt.Errorf("invalid UTF-8 token: %q", param)
- }
-
- diffs = append(diffs, Diff{DiffInsert, param})
- case '=', '-':
- n, err := strconv.ParseInt(param, 10, 0)
- if err != nil {
- return nil, err
- } else if n < 0 {
- return nil, errors.New("Negative number in DiffFromDelta: " + param)
- }
-
- // Remember that string slicing is by byte - we want by rune here.
- text := string([]rune(text1)[i : i+int(n)])
- i += int(n)
-
- if op == '=' {
- diffs = append(diffs, Diff{DiffEqual, text})
- } else {
- diffs = append(diffs, Diff{DiffDelete, text})
- }
- default:
- // Anything else is an error.
- return nil, errors.New("Invalid diff operation in DiffFromDelta: " + string(token[0]))
- }
- }
-
- if i != len([]rune(text1)) {
- return nil, fmt.Errorf("Delta length (%v) smaller than source text length (%v)", i, len(text1))
- }
-
- return diffs, nil
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go
deleted file mode 100644
index d3acc32ce13a0439319b69db12c6f74d9854e4f1..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/diffmatchpatch.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-// Package diffmatchpatch offers robust algorithms to perform the operations required for synchronizing plain text.
-package diffmatchpatch
-
-import (
- "time"
-)
-
-// DiffMatchPatch holds the configuration for diff-match-patch operations.
-type DiffMatchPatch struct {
- // Number of seconds to map a diff before giving up (0 for infinity).
- DiffTimeout time.Duration
- // Cost of an empty edit operation in terms of edit characters.
- DiffEditCost int
- // How far to search for a match (0 = exact location, 1000+ = broad match). A match this many characters away from the expected location will add 1.0 to the score (0.0 is a perfect match).
- MatchDistance int
- // When deleting a large block of text (over ~64 characters), how close do the contents have to be to match the expected contents. (0.0 = perfection, 1.0 = very loose). Note that MatchThreshold controls how closely the end points of a delete need to match.
- PatchDeleteThreshold float64
- // Chunk size for context length.
- PatchMargin int
- // The number of bits in an int.
- MatchMaxBits int
- // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
- MatchThreshold float64
-}
-
-// New creates a new DiffMatchPatch object with default parameters.
-func New() *DiffMatchPatch {
- // Defaults.
- return &DiffMatchPatch{
- DiffTimeout: time.Second,
- DiffEditCost: 4,
- MatchThreshold: 0.5,
- MatchDistance: 1000,
- PatchDeleteThreshold: 0.5,
- PatchMargin: 4,
- MatchMaxBits: 32,
- }
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go
deleted file mode 100644
index 17374e109fef2d55431fe4a5e08a8b5259d203a7..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/match.go
+++ /dev/null
@@ -1,160 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-import (
- "math"
-)
-
-// MatchMain locates the best instance of 'pattern' in 'text' near 'loc'.
-// Returns -1 if no match found.
-func (dmp *DiffMatchPatch) MatchMain(text, pattern string, loc int) int {
- // Check for null inputs not needed since null can't be passed in C#.
-
- loc = int(math.Max(0, math.Min(float64(loc), float64(len(text)))))
- if text == pattern {
- // Shortcut (potentially not guaranteed by the algorithm)
- return 0
- } else if len(text) == 0 {
- // Nothing to match.
- return -1
- } else if loc+len(pattern) <= len(text) && text[loc:loc+len(pattern)] == pattern {
- // Perfect match at the perfect spot! (Includes case of null pattern)
- return loc
- }
- // Do a fuzzy compare.
- return dmp.MatchBitap(text, pattern, loc)
-}
-
-// MatchBitap locates the best instance of 'pattern' in 'text' near 'loc' using the Bitap algorithm.
-// Returns -1 if no match was found.
-func (dmp *DiffMatchPatch) MatchBitap(text, pattern string, loc int) int {
- // Initialise the alphabet.
- s := dmp.MatchAlphabet(pattern)
-
- // Highest score beyond which we give up.
- scoreThreshold := dmp.MatchThreshold
- // Is there a nearby exact match? (speedup)
- bestLoc := indexOf(text, pattern, loc)
- if bestLoc != -1 {
- scoreThreshold = math.Min(dmp.matchBitapScore(0, bestLoc, loc,
- pattern), scoreThreshold)
- // What about in the other direction? (speedup)
- bestLoc = lastIndexOf(text, pattern, loc+len(pattern))
- if bestLoc != -1 {
- scoreThreshold = math.Min(dmp.matchBitapScore(0, bestLoc, loc,
- pattern), scoreThreshold)
- }
- }
-
- // Initialise the bit arrays.
- matchmask := 1 << uint((len(pattern) - 1))
- bestLoc = -1
-
- var binMin, binMid int
- binMax := len(pattern) + len(text)
- lastRd := []int{}
- for d := 0; d < len(pattern); d++ {
- // Scan for the best match; each iteration allows for one more error. Run a binary search to determine how far from 'loc' we can stray at this error level.
- binMin = 0
- binMid = binMax
- for binMin < binMid {
- if dmp.matchBitapScore(d, loc+binMid, loc, pattern) <= scoreThreshold {
- binMin = binMid
- } else {
- binMax = binMid
- }
- binMid = (binMax-binMin)/2 + binMin
- }
- // Use the result from this iteration as the maximum for the next.
- binMax = binMid
- start := int(math.Max(1, float64(loc-binMid+1)))
- finish := int(math.Min(float64(loc+binMid), float64(len(text))) + float64(len(pattern)))
-
- rd := make([]int, finish+2)
- rd[finish+1] = (1 << uint(d)) - 1
-
- for j := finish; j >= start; j-- {
- var charMatch int
- if len(text) <= j-1 {
- // Out of range.
- charMatch = 0
- } else if _, ok := s[text[j-1]]; !ok {
- charMatch = 0
- } else {
- charMatch = s[text[j-1]]
- }
-
- if d == 0 {
- // First pass: exact match.
- rd[j] = ((rd[j+1] << 1) | 1) & charMatch
- } else {
- // Subsequent passes: fuzzy match.
- rd[j] = ((rd[j+1]<<1)|1)&charMatch | (((lastRd[j+1] | lastRd[j]) << 1) | 1) | lastRd[j+1]
- }
- if (rd[j] & matchmask) != 0 {
- score := dmp.matchBitapScore(d, j-1, loc, pattern)
- // This match will almost certainly be better than any existing match. But check anyway.
- if score <= scoreThreshold {
- // Told you so.
- scoreThreshold = score
- bestLoc = j - 1
- if bestLoc > loc {
- // When passing loc, don't exceed our current distance from loc.
- start = int(math.Max(1, float64(2*loc-bestLoc)))
- } else {
- // Already passed loc, downhill from here on in.
- break
- }
- }
- }
- }
- if dmp.matchBitapScore(d+1, loc, loc, pattern) > scoreThreshold {
- // No hope for a (better) match at greater error levels.
- break
- }
- lastRd = rd
- }
- return bestLoc
-}
-
-// matchBitapScore computes and returns the score for a match with e errors and x location.
-func (dmp *DiffMatchPatch) matchBitapScore(e, x, loc int, pattern string) float64 {
- accuracy := float64(e) / float64(len(pattern))
- proximity := math.Abs(float64(loc - x))
- if dmp.MatchDistance == 0 {
- // Dodge divide by zero error.
- if proximity == 0 {
- return accuracy
- }
-
- return 1.0
- }
- return accuracy + (proximity / float64(dmp.MatchDistance))
-}
-
-// MatchAlphabet initialises the alphabet for the Bitap algorithm.
-func (dmp *DiffMatchPatch) MatchAlphabet(pattern string) map[byte]int {
- s := map[byte]int{}
- charPattern := []byte(pattern)
- for _, c := range charPattern {
- _, ok := s[c]
- if !ok {
- s[c] = 0
- }
- }
- i := 0
-
- for _, c := range charPattern {
- value := s[c] | int(uint(1)<<uint((len(pattern)-i-1)))
- s[c] = value
- i++
- }
- return s
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/mathutil.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/mathutil.go
deleted file mode 100644
index aed242bc6e763e7bcea7bd139700e82753fc719d..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/mathutil.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-func min(x, y int) int {
- if x < y {
- return x
- }
- return y
-}
-
-func max(x, y int) int {
- if x > y {
- return x
- }
- return y
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/patch.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/patch.go
deleted file mode 100644
index 116c0434811208176b7af7658beef5b3cc06957f..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/patch.go
+++ /dev/null
@@ -1,556 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-import (
- "bytes"
- "errors"
- "math"
- "net/url"
- "regexp"
- "strconv"
- "strings"
-)
-
-// Patch represents one patch operation.
-type Patch struct {
- diffs []Diff
- start1 int
- start2 int
- length1 int
- length2 int
-}
-
-// String emulates GNU diff's format.
-// Header: @@ -382,8 +481,9 @@
-// Indicies are printed as 1-based, not 0-based.
-func (p *Patch) String() string {
- var coords1, coords2 string
-
- if p.length1 == 0 {
- coords1 = strconv.Itoa(p.start1) + ",0"
- } else if p.length1 == 1 {
- coords1 = strconv.Itoa(p.start1 + 1)
- } else {
- coords1 = strconv.Itoa(p.start1+1) + "," + strconv.Itoa(p.length1)
- }
-
- if p.length2 == 0 {
- coords2 = strconv.Itoa(p.start2) + ",0"
- } else if p.length2 == 1 {
- coords2 = strconv.Itoa(p.start2 + 1)
- } else {
- coords2 = strconv.Itoa(p.start2+1) + "," + strconv.Itoa(p.length2)
- }
-
- var text bytes.Buffer
- _, _ = text.WriteString("@@ -" + coords1 + " +" + coords2 + " @@\n")
-
- // Escape the body of the patch with %xx notation.
- for _, aDiff := range p.diffs {
- switch aDiff.Type {
- case DiffInsert:
- _, _ = text.WriteString("+")
- case DiffDelete:
- _, _ = text.WriteString("-")
- case DiffEqual:
- _, _ = text.WriteString(" ")
- }
-
- _, _ = text.WriteString(strings.Replace(url.QueryEscape(aDiff.Text), "+", " ", -1))
- _, _ = text.WriteString("\n")
- }
-
- return unescaper.Replace(text.String())
-}
-
-// PatchAddContext increases the context until it is unique, but doesn't let the pattern expand beyond MatchMaxBits.
-func (dmp *DiffMatchPatch) PatchAddContext(patch Patch, text string) Patch {
- if len(text) == 0 {
- return patch
- }
-
- pattern := text[patch.start2 : patch.start2+patch.length1]
- padding := 0
-
- // Look for the first and last matches of pattern in text. If two different matches are found, increase the pattern length.
- for strings.Index(text, pattern) != strings.LastIndex(text, pattern) &&
- len(pattern) < dmp.MatchMaxBits-2*dmp.PatchMargin {
- padding += dmp.PatchMargin
- maxStart := max(0, patch.start2-padding)
- minEnd := min(len(text), patch.start2+patch.length1+padding)
- pattern = text[maxStart:minEnd]
- }
- // Add one chunk for good luck.
- padding += dmp.PatchMargin
-
- // Add the prefix.
- prefix := text[max(0, patch.start2-padding):patch.start2]
- if len(prefix) != 0 {
- patch.diffs = append([]Diff{Diff{DiffEqual, prefix}}, patch.diffs...)
- }
- // Add the suffix.
- suffix := text[patch.start2+patch.length1 : min(len(text), patch.start2+patch.length1+padding)]
- if len(suffix) != 0 {
- patch.diffs = append(patch.diffs, Diff{DiffEqual, suffix})
- }
-
- // Roll back the start points.
- patch.start1 -= len(prefix)
- patch.start2 -= len(prefix)
- // Extend the lengths.
- patch.length1 += len(prefix) + len(suffix)
- patch.length2 += len(prefix) + len(suffix)
-
- return patch
-}
-
-// PatchMake computes a list of patches.
-func (dmp *DiffMatchPatch) PatchMake(opt ...interface{}) []Patch {
- if len(opt) == 1 {
- diffs, _ := opt[0].([]Diff)
- text1 := dmp.DiffText1(diffs)
- return dmp.PatchMake(text1, diffs)
- } else if len(opt) == 2 {
- text1 := opt[0].(string)
- switch t := opt[1].(type) {
- case string:
- diffs := dmp.DiffMain(text1, t, true)
- if len(diffs) > 2 {
- diffs = dmp.DiffCleanupSemantic(diffs)
- diffs = dmp.DiffCleanupEfficiency(diffs)
- }
- return dmp.PatchMake(text1, diffs)
- case []Diff:
- return dmp.patchMake2(text1, t)
- }
- } else if len(opt) == 3 {
- return dmp.PatchMake(opt[0], opt[2])
- }
- return []Patch{}
-}
-
-// patchMake2 computes a list of patches to turn text1 into text2.
-// text2 is not provided, diffs are the delta between text1 and text2.
-func (dmp *DiffMatchPatch) patchMake2(text1 string, diffs []Diff) []Patch {
- // Check for null inputs not needed since null can't be passed in C#.
- patches := []Patch{}
- if len(diffs) == 0 {
- return patches // Get rid of the null case.
- }
-
- patch := Patch{}
- charCount1 := 0 // Number of characters into the text1 string.
- charCount2 := 0 // Number of characters into the text2 string.
- // Start with text1 (prepatchText) and apply the diffs until we arrive at text2 (postpatchText). We recreate the patches one by one to determine context info.
- prepatchText := text1
- postpatchText := text1
-
- for i, aDiff := range diffs {
- if len(patch.diffs) == 0 && aDiff.Type != DiffEqual {
- // A new patch starts here.
- patch.start1 = charCount1
- patch.start2 = charCount2
- }
-
- switch aDiff.Type {
- case DiffInsert:
- patch.diffs = append(patch.diffs, aDiff)
- patch.length2 += len(aDiff.Text)
- postpatchText = postpatchText[:charCount2] +
- aDiff.Text + postpatchText[charCount2:]
- case DiffDelete:
- patch.length1 += len(aDiff.Text)
- patch.diffs = append(patch.diffs, aDiff)
- postpatchText = postpatchText[:charCount2] + postpatchText[charCount2+len(aDiff.Text):]
- case DiffEqual:
- if len(aDiff.Text) <= 2*dmp.PatchMargin &&
- len(patch.diffs) != 0 && i != len(diffs)-1 {
- // Small equality inside a patch.
- patch.diffs = append(patch.diffs, aDiff)
- patch.length1 += len(aDiff.Text)
- patch.length2 += len(aDiff.Text)
- }
- if len(aDiff.Text) >= 2*dmp.PatchMargin {
- // Time for a new patch.
- if len(patch.diffs) != 0 {
- patch = dmp.PatchAddContext(patch, prepatchText)
- patches = append(patches, patch)
- patch = Patch{}
- // Unlike Unidiff, our patch lists have a rolling context. http://code.google.com/p/google-diff-match-patch/wiki/Unidiff Update prepatch text & pos to reflect the application of the just completed patch.
- prepatchText = postpatchText
- charCount1 = charCount2
- }
- }
- }
-
- // Update the current character count.
- if aDiff.Type != DiffInsert {
- charCount1 += len(aDiff.Text)
- }
- if aDiff.Type != DiffDelete {
- charCount2 += len(aDiff.Text)
- }
- }
-
- // Pick up the leftover patch if not empty.
- if len(patch.diffs) != 0 {
- patch = dmp.PatchAddContext(patch, prepatchText)
- patches = append(patches, patch)
- }
-
- return patches
-}
-
-// PatchDeepCopy returns an array that is identical to a given an array of patches.
-func (dmp *DiffMatchPatch) PatchDeepCopy(patches []Patch) []Patch {
- patchesCopy := []Patch{}
- for _, aPatch := range patches {
- patchCopy := Patch{}
- for _, aDiff := range aPatch.diffs {
- patchCopy.diffs = append(patchCopy.diffs, Diff{
- aDiff.Type,
- aDiff.Text,
- })
- }
- patchCopy.start1 = aPatch.start1
- patchCopy.start2 = aPatch.start2
- patchCopy.length1 = aPatch.length1
- patchCopy.length2 = aPatch.length2
- patchesCopy = append(patchesCopy, patchCopy)
- }
- return patchesCopy
-}
-
-// PatchApply merges a set of patches onto the text. Returns a patched text, as well as an array of true/false values indicating which patches were applied.
-func (dmp *DiffMatchPatch) PatchApply(patches []Patch, text string) (string, []bool) {
- if len(patches) == 0 {
- return text, []bool{}
- }
-
- // Deep copy the patches so that no changes are made to originals.
- patches = dmp.PatchDeepCopy(patches)
-
- nullPadding := dmp.PatchAddPadding(patches)
- text = nullPadding + text + nullPadding
- patches = dmp.PatchSplitMax(patches)
-
- x := 0
- // delta keeps track of the offset between the expected and actual location of the previous patch. If there are patches expected at positions 10 and 20, but the first patch was found at 12, delta is 2 and the second patch has an effective expected position of 22.
- delta := 0
- results := make([]bool, len(patches))
- for _, aPatch := range patches {
- expectedLoc := aPatch.start2 + delta
- text1 := dmp.DiffText1(aPatch.diffs)
- var startLoc int
- endLoc := -1
- if len(text1) > dmp.MatchMaxBits {
- // PatchSplitMax will only provide an oversized pattern in the case of a monster delete.
- startLoc = dmp.MatchMain(text, text1[:dmp.MatchMaxBits], expectedLoc)
- if startLoc != -1 {
- endLoc = dmp.MatchMain(text,
- text1[len(text1)-dmp.MatchMaxBits:], expectedLoc+len(text1)-dmp.MatchMaxBits)
- if endLoc == -1 || startLoc >= endLoc {
- // Can't find valid trailing context. Drop this patch.
- startLoc = -1
- }
- }
- } else {
- startLoc = dmp.MatchMain(text, text1, expectedLoc)
- }
- if startLoc == -1 {
- // No match found. :(
- results[x] = false
- // Subtract the delta for this failed patch from subsequent patches.
- delta -= aPatch.length2 - aPatch.length1
- } else {
- // Found a match. :)
- results[x] = true
- delta = startLoc - expectedLoc
- var text2 string
- if endLoc == -1 {
- text2 = text[startLoc:int(math.Min(float64(startLoc+len(text1)), float64(len(text))))]
- } else {
- text2 = text[startLoc:int(math.Min(float64(endLoc+dmp.MatchMaxBits), float64(len(text))))]
- }
- if text1 == text2 {
- // Perfect match, just shove the Replacement text in.
- text = text[:startLoc] + dmp.DiffText2(aPatch.diffs) + text[startLoc+len(text1):]
- } else {
- // Imperfect match. Run a diff to get a framework of equivalent indices.
- diffs := dmp.DiffMain(text1, text2, false)
- if len(text1) > dmp.MatchMaxBits && float64(dmp.DiffLevenshtein(diffs))/float64(len(text1)) > dmp.PatchDeleteThreshold {
- // The end points match, but the content is unacceptably bad.
- results[x] = false
- } else {
- diffs = dmp.DiffCleanupSemanticLossless(diffs)
- index1 := 0
- for _, aDiff := range aPatch.diffs {
- if aDiff.Type != DiffEqual {
- index2 := dmp.DiffXIndex(diffs, index1)
- if aDiff.Type == DiffInsert {
- // Insertion
- text = text[:startLoc+index2] + aDiff.Text + text[startLoc+index2:]
- } else if aDiff.Type == DiffDelete {
- // Deletion
- startIndex := startLoc + index2
- text = text[:startIndex] +
- text[startIndex+dmp.DiffXIndex(diffs, index1+len(aDiff.Text))-index2:]
- }
- }
- if aDiff.Type != DiffDelete {
- index1 += len(aDiff.Text)
- }
- }
- }
- }
- }
- x++
- }
- // Strip the padding off.
- text = text[len(nullPadding) : len(nullPadding)+(len(text)-2*len(nullPadding))]
- return text, results
-}
-
-// PatchAddPadding adds some padding on text start and end so that edges can match something.
-// Intended to be called only from within patchApply.
-func (dmp *DiffMatchPatch) PatchAddPadding(patches []Patch) string {
- paddingLength := dmp.PatchMargin
- nullPadding := ""
- for x := 1; x <= paddingLength; x++ {
- nullPadding += string(x)
- }
-
- // Bump all the patches forward.
- for i := range patches {
- patches[i].start1 += paddingLength
- patches[i].start2 += paddingLength
- }
-
- // Add some padding on start of first diff.
- if len(patches[0].diffs) == 0 || patches[0].diffs[0].Type != DiffEqual {
- // Add nullPadding equality.
- patches[0].diffs = append([]Diff{Diff{DiffEqual, nullPadding}}, patches[0].diffs...)
- patches[0].start1 -= paddingLength // Should be 0.
- patches[0].start2 -= paddingLength // Should be 0.
- patches[0].length1 += paddingLength
- patches[0].length2 += paddingLength
- } else if paddingLength > len(patches[0].diffs[0].Text) {
- // Grow first equality.
- extraLength := paddingLength - len(patches[0].diffs[0].Text)
- patches[0].diffs[0].Text = nullPadding[len(patches[0].diffs[0].Text):] + patches[0].diffs[0].Text
- patches[0].start1 -= extraLength
- patches[0].start2 -= extraLength
- patches[0].length1 += extraLength
- patches[0].length2 += extraLength
- }
-
- // Add some padding on end of last diff.
- last := len(patches) - 1
- if len(patches[last].diffs) == 0 || patches[last].diffs[len(patches[last].diffs)-1].Type != DiffEqual {
- // Add nullPadding equality.
- patches[last].diffs = append(patches[last].diffs, Diff{DiffEqual, nullPadding})
- patches[last].length1 += paddingLength
- patches[last].length2 += paddingLength
- } else if paddingLength > len(patches[last].diffs[len(patches[last].diffs)-1].Text) {
- // Grow last equality.
- lastDiff := patches[last].diffs[len(patches[last].diffs)-1]
- extraLength := paddingLength - len(lastDiff.Text)
- patches[last].diffs[len(patches[last].diffs)-1].Text += nullPadding[:extraLength]
- patches[last].length1 += extraLength
- patches[last].length2 += extraLength
- }
-
- return nullPadding
-}
-
-// PatchSplitMax looks through the patches and breaks up any which are longer than the maximum limit of the match algorithm.
-// Intended to be called only from within patchApply.
-func (dmp *DiffMatchPatch) PatchSplitMax(patches []Patch) []Patch {
- patchSize := dmp.MatchMaxBits
- for x := 0; x < len(patches); x++ {
- if patches[x].length1 <= patchSize {
- continue
- }
- bigpatch := patches[x]
- // Remove the big old patch.
- patches = append(patches[:x], patches[x+1:]...)
- x--
-
- start1 := bigpatch.start1
- start2 := bigpatch.start2
- precontext := ""
- for len(bigpatch.diffs) != 0 {
- // Create one of several smaller patches.
- patch := Patch{}
- empty := true
- patch.start1 = start1 - len(precontext)
- patch.start2 = start2 - len(precontext)
- if len(precontext) != 0 {
- patch.length1 = len(precontext)
- patch.length2 = len(precontext)
- patch.diffs = append(patch.diffs, Diff{DiffEqual, precontext})
- }
- for len(bigpatch.diffs) != 0 && patch.length1 < patchSize-dmp.PatchMargin {
- diffType := bigpatch.diffs[0].Type
- diffText := bigpatch.diffs[0].Text
- if diffType == DiffInsert {
- // Insertions are harmless.
- patch.length2 += len(diffText)
- start2 += len(diffText)
- patch.diffs = append(patch.diffs, bigpatch.diffs[0])
- bigpatch.diffs = bigpatch.diffs[1:]
- empty = false
- } else if diffType == DiffDelete && len(patch.diffs) == 1 && patch.diffs[0].Type == DiffEqual && len(diffText) > 2*patchSize {
- // This is a large deletion. Let it pass in one chunk.
- patch.length1 += len(diffText)
- start1 += len(diffText)
- empty = false
- patch.diffs = append(patch.diffs, Diff{diffType, diffText})
- bigpatch.diffs = bigpatch.diffs[1:]
- } else {
- // Deletion or equality. Only take as much as we can stomach.
- diffText = diffText[:min(len(diffText), patchSize-patch.length1-dmp.PatchMargin)]
-
- patch.length1 += len(diffText)
- start1 += len(diffText)
- if diffType == DiffEqual {
- patch.length2 += len(diffText)
- start2 += len(diffText)
- } else {
- empty = false
- }
- patch.diffs = append(patch.diffs, Diff{diffType, diffText})
- if diffText == bigpatch.diffs[0].Text {
- bigpatch.diffs = bigpatch.diffs[1:]
- } else {
- bigpatch.diffs[0].Text =
- bigpatch.diffs[0].Text[len(diffText):]
- }
- }
- }
- // Compute the head context for the next patch.
- precontext = dmp.DiffText2(patch.diffs)
- precontext = precontext[max(0, len(precontext)-dmp.PatchMargin):]
-
- postcontext := ""
- // Append the end context for this patch.
- if len(dmp.DiffText1(bigpatch.diffs)) > dmp.PatchMargin {
- postcontext = dmp.DiffText1(bigpatch.diffs)[:dmp.PatchMargin]
- } else {
- postcontext = dmp.DiffText1(bigpatch.diffs)
- }
-
- if len(postcontext) != 0 {
- patch.length1 += len(postcontext)
- patch.length2 += len(postcontext)
- if len(patch.diffs) != 0 && patch.diffs[len(patch.diffs)-1].Type == DiffEqual {
- patch.diffs[len(patch.diffs)-1].Text += postcontext
- } else {
- patch.diffs = append(patch.diffs, Diff{DiffEqual, postcontext})
- }
- }
- if !empty {
- x++
- patches = append(patches[:x], append([]Patch{patch}, patches[x:]...)...)
- }
- }
- }
- return patches
-}
-
-// PatchToText takes a list of patches and returns a textual representation.
-func (dmp *DiffMatchPatch) PatchToText(patches []Patch) string {
- var text bytes.Buffer
- for _, aPatch := range patches {
- _, _ = text.WriteString(aPatch.String())
- }
- return text.String()
-}
-
-// PatchFromText parses a textual representation of patches and returns a List of Patch objects.
-func (dmp *DiffMatchPatch) PatchFromText(textline string) ([]Patch, error) {
- patches := []Patch{}
- if len(textline) == 0 {
- return patches, nil
- }
- text := strings.Split(textline, "\n")
- textPointer := 0
- patchHeader := regexp.MustCompile("^@@ -(\\d+),?(\\d*) \\+(\\d+),?(\\d*) @@$")
-
- var patch Patch
- var sign uint8
- var line string
- for textPointer < len(text) {
-
- if !patchHeader.MatchString(text[textPointer]) {
- return patches, errors.New("Invalid patch string: " + text[textPointer])
- }
-
- patch = Patch{}
- m := patchHeader.FindStringSubmatch(text[textPointer])
-
- patch.start1, _ = strconv.Atoi(m[1])
- if len(m[2]) == 0 {
- patch.start1--
- patch.length1 = 1
- } else if m[2] == "0" {
- patch.length1 = 0
- } else {
- patch.start1--
- patch.length1, _ = strconv.Atoi(m[2])
- }
-
- patch.start2, _ = strconv.Atoi(m[3])
-
- if len(m[4]) == 0 {
- patch.start2--
- patch.length2 = 1
- } else if m[4] == "0" {
- patch.length2 = 0
- } else {
- patch.start2--
- patch.length2, _ = strconv.Atoi(m[4])
- }
- textPointer++
-
- for textPointer < len(text) {
- if len(text[textPointer]) > 0 {
- sign = text[textPointer][0]
- } else {
- textPointer++
- continue
- }
-
- line = text[textPointer][1:]
- line = strings.Replace(line, "+", "%2b", -1)
- line, _ = url.QueryUnescape(line)
- if sign == '-' {
- // Deletion.
- patch.diffs = append(patch.diffs, Diff{DiffDelete, line})
- } else if sign == '+' {
- // Insertion.
- patch.diffs = append(patch.diffs, Diff{DiffInsert, line})
- } else if sign == ' ' {
- // Minor equality.
- patch.diffs = append(patch.diffs, Diff{DiffEqual, line})
- } else if sign == '@' {
- // Start of next patch.
- break
- } else {
- // WTF?
- return patches, errors.New("Invalid patch mode '" + string(sign) + "' in: " + string(line))
- }
- textPointer++
- }
-
- patches = append(patches, patch)
- }
- return patches, nil
-}
diff --git a/vendor/github.com/sergi/go-diff/diffmatchpatch/stringutil.go b/vendor/github.com/sergi/go-diff/diffmatchpatch/stringutil.go
deleted file mode 100644
index 265f29cc7e595ef097d6733587cc49636f637ba2..0000000000000000000000000000000000000000
--- a/vendor/github.com/sergi/go-diff/diffmatchpatch/stringutil.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
-// https://github.com/sergi/go-diff
-// See the included LICENSE file for license details.
-//
-// go-diff is a Go implementation of Google's Diff, Match, and Patch library
-// Original library is Copyright (c) 2006 Google Inc.
-// http://code.google.com/p/google-diff-match-patch/
-
-package diffmatchpatch
-
-import (
- "strings"
- "unicode/utf8"
-)
-
-// unescaper unescapes selected chars for compatibility with JavaScript's encodeURI.
-// In speed critical applications this could be dropped since the receiving application will certainly decode these fine. Note that this function is case-sensitive. Thus "%3F" would not be unescaped. But this is ok because it is only called with the output of HttpUtility.UrlEncode which returns lowercase hex. Example: "%3f" -> "?", "%24" -> "$", etc.
-var unescaper = strings.NewReplacer(
- "%21", "!", "%7E", "~", "%27", "'",
- "%28", "(", "%29", ")", "%3B", ";",
- "%2F", "/", "%3F", "?", "%3A", ":",
- "%40", "@", "%26", "&", "%3D", "=",
- "%2B", "+", "%24", "$", "%2C", ",", "%23", "#", "%2A", "*")
-
-// indexOf returns the first index of pattern in str, starting at str[i].
-func indexOf(str string, pattern string, i int) int {
- if i > len(str)-1 {
- return -1
- }
- if i <= 0 {
- return strings.Index(str, pattern)
- }
- ind := strings.Index(str[i:], pattern)
- if ind == -1 {
- return -1
- }
- return ind + i
-}
-
-// lastIndexOf returns the last index of pattern in str, starting at str[i].
-func lastIndexOf(str string, pattern string, i int) int {
- if i < 0 {
- return -1
- }
- if i >= len(str) {
- return strings.LastIndex(str, pattern)
- }
- _, size := utf8.DecodeRuneInString(str[i:])
- return strings.LastIndex(str[:i+size], pattern)
-}
-
-// runesIndexOf returns the index of pattern in target, starting at target[i].
-func runesIndexOf(target, pattern []rune, i int) int {
- if i > len(target)-1 {
- return -1
- }
- if i <= 0 {
- return runesIndex(target, pattern)
- }
- ind := runesIndex(target[i:], pattern)
- if ind == -1 {
- return -1
- }
- return ind + i
-}
-
-func runesEqual(r1, r2 []rune) bool {
- if len(r1) != len(r2) {
- return false
- }
- for i, c := range r1 {
- if c != r2[i] {
- return false
- }
- }
- return true
-}
-
-// runesIndex is the equivalent of strings.Index for rune slices.
-func runesIndex(r1, r2 []rune) int {
- last := len(r1) - len(r2)
- for i := 0; i <= last; i++ {
- if runesEqual(r1[i:i+len(r2)], r2) {
- return i
- }
- }
- return -1
-}
diff --git a/vendor/github.com/src-d/gcfg/LICENSE b/vendor/github.com/src-d/gcfg/LICENSE
deleted file mode 100644
index 87a5cede33929e3d2aedebbe7a2497b16c14f23b..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/LICENSE
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright (c) 2012 Péter Surányi. Portions Copyright (c) 2009 The Go
-Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/src-d/gcfg/README b/vendor/github.com/src-d/gcfg/README
deleted file mode 100644
index 1ff233a529dd25eb6c6870b4287f05d477cd683b..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/README
+++ /dev/null
@@ -1,4 +0,0 @@
-Gcfg reads INI-style configuration files into Go structs;
-supports user-defined types and subsections.
-
-Package docs: https://godoc.org/gopkg.in/gcfg.v1
diff --git a/vendor/github.com/src-d/gcfg/doc.go b/vendor/github.com/src-d/gcfg/doc.go
deleted file mode 100644
index 2edcb41a0818504624f1f7cf4d16fc40e96cc121..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/doc.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Package gcfg reads "INI-style" text-based configuration files with
-// "name=value" pairs grouped into sections (gcfg files).
-//
-// This package is still a work in progress; see the sections below for planned
-// changes.
-//
-// Syntax
-//
-// The syntax is based on that used by git config:
-// http://git-scm.com/docs/git-config#_syntax .
-// There are some (planned) differences compared to the git config format:
-// - improve data portability:
-// - must be encoded in UTF-8 (for now) and must not contain the 0 byte
-// - include and "path" type is not supported
-// (path type may be implementable as a user-defined type)
-// - internationalization
-// - section and variable names can contain unicode letters, unicode digits
-// (as defined in http://golang.org/ref/spec#Characters ) and hyphens
-// (U+002D), starting with a unicode letter
-// - disallow potentially ambiguous or misleading definitions:
-// - `[sec.sub]` format is not allowed (deprecated in gitconfig)
-// - `[sec ""]` is not allowed
-// - use `[sec]` for section name "sec" and empty subsection name
-// - (planned) within a single file, definitions must be contiguous for each:
-// - section: '[secA]' -> '[secB]' -> '[secA]' is an error
-// - subsection: '[sec "A"]' -> '[sec "B"]' -> '[sec "A"]' is an error
-// - multivalued variable: 'multi=a' -> 'other=x' -> 'multi=b' is an error
-//
-// Data structure
-//
-// The functions in this package read values into a user-defined struct.
-// Each section corresponds to a struct field in the config struct, and each
-// variable in a section corresponds to a data field in the section struct.
-// The mapping of each section or variable name to fields is done either based
-// on the "gcfg" struct tag or by matching the name of the section or variable,
-// ignoring case. In the latter case, hyphens '-' in section and variable names
-// correspond to underscores '_' in field names.
-// Fields must be exported; to use a section or variable name starting with a
-// letter that is neither upper- or lower-case, prefix the field name with 'X'.
-// (See https://code.google.com/p/go/issues/detail?id=5763#c4 .)
-//
-// For sections with subsections, the corresponding field in config must be a
-// map, rather than a struct, with string keys and pointer-to-struct values.
-// Values for subsection variables are stored in the map with the subsection
-// name used as the map key.
-// (Note that unlike section and variable names, subsection names are case
-// sensitive.)
-// When using a map, and there is a section with the same section name but
-// without a subsection name, its values are stored with the empty string used
-// as the key.
-// It is possible to provide default values for subsections in the section
-// "default-<sectionname>" (or by setting values in the corresponding struct
-// field "Default_<sectionname>").
-//
-// The functions in this package panic if config is not a pointer to a struct,
-// or when a field is not of a suitable type (either a struct or a map with
-// string keys and pointer-to-struct values).
-//
-// Parsing of values
-//
-// The section structs in the config struct may contain single-valued or
-// multi-valued variables. Variables of unnamed slice type (that is, a type
-// starting with `[]`) are treated as multi-value; all others (including named
-// slice types) are treated as single-valued variables.
-//
-// Single-valued variables are handled based on the type as follows.
-// Unnamed pointer types (that is, types starting with `*`) are dereferenced,
-// and if necessary, a new instance is allocated.
-//
-// For types implementing the encoding.TextUnmarshaler interface, the
-// UnmarshalText method is used to set the value. Implementing this method is
-// the recommended way for parsing user-defined types.
-//
-// For fields of string kind, the value string is assigned to the field, after
-// unquoting and unescaping as needed.
-// For fields of bool kind, the field is set to true if the value is "true",
-// "yes", "on" or "1", and set to false if the value is "false", "no", "off" or
-// "0", ignoring case. In addition, single-valued bool fields can be specified
-// with a "blank" value (variable name without equals sign and value); in such
-// case the value is set to true.
-//
-// Predefined integer types [u]int(|8|16|32|64) and big.Int are parsed as
-// decimal or hexadecimal (if having '0x' prefix). (This is to prevent
-// unintuitively handling zero-padded numbers as octal.) Other types having
-// [u]int* as the underlying type, such as os.FileMode and uintptr allow
-// decimal, hexadecimal, or octal values.
-// Parsing mode for integer types can be overridden using the struct tag option
-// ",int=mode" where mode is a combination of the 'd', 'h', and 'o' characters
-// (each standing for decimal, hexadecimal, and octal, respectively.)
-//
-// All other types are parsed using fmt.Sscanf with the "%v" verb.
-//
-// For multi-valued variables, each individual value is parsed as above and
-// appended to the slice. If the first value is specified as a "blank" value
-// (variable name without equals sign and value), a new slice is allocated;
-// that is any values previously set in the slice will be ignored.
-//
-// The types subpackage for provides helpers for parsing "enum-like" and integer
-// types.
-//
-// Error handling
-//
-// There are 3 types of errors:
-//
-// - programmer errors / panics:
-// - invalid configuration structure
-// - data errors:
-// - fatal errors:
-// - invalid configuration syntax
-// - warnings:
-// - data that doesn't belong to any part of the config structure
-//
-// Programmer errors trigger panics. These are should be fixed by the programmer
-// before releasing code that uses gcfg.
-//
-// Data errors cause gcfg to return a non-nil error value. This includes the
-// case when there are extra unknown key-value definitions in the configuration
-// data (extra data).
-// However, in some occasions it is desirable to be able to proceed in
-// situations when the only data error is that of extra data.
-// These errors are handled at a different (warning) priority and can be
-// filtered out programmatically. To ignore extra data warnings, wrap the
-// gcfg.Read*Into invocation into a call to gcfg.FatalOnly.
-//
-// TODO
-//
-// The following is a list of changes under consideration:
-// - documentation
-// - self-contained syntax documentation
-// - more practical examples
-// - move TODOs to issue tracker (eventually)
-// - syntax
-// - reconsider valid escape sequences
-// (gitconfig doesn't support \r in value, \t in subsection name, etc.)
-// - reading / parsing gcfg files
-// - define internal representation structure
-// - support multiple inputs (readers, strings, files)
-// - support declaring encoding (?)
-// - support varying fields sets for subsections (?)
-// - writing gcfg files
-// - error handling
-// - make error context accessible programmatically?
-// - limit input size?
-//
-package gcfg // import "github.com/src-d/gcfg"
diff --git a/vendor/github.com/src-d/gcfg/errors.go b/vendor/github.com/src-d/gcfg/errors.go
deleted file mode 100644
index 853c76021de43507c71475802de5836533773bde..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/errors.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package gcfg
-
-import (
- "gopkg.in/warnings.v0"
-)
-
-// FatalOnly filters the results of a Read*Into invocation and returns only
-// fatal errors. That is, errors (warnings) indicating data for unknown
-// sections / variables is ignored. Example invocation:
-//
-// err := gcfg.FatalOnly(gcfg.ReadFileInto(&cfg, configFile))
-// if err != nil {
-// ...
-//
-func FatalOnly(err error) error {
- return warnings.FatalOnly(err)
-}
-
-func isFatal(err error) bool {
- _, ok := err.(extraData)
- return !ok
-}
-
-type extraData struct {
- section string
- subsection *string
- variable *string
-}
-
-func (e extraData) Error() string {
- s := "can't store data at section \"" + e.section + "\""
- if e.subsection != nil {
- s += ", subsection \"" + *e.subsection + "\""
- }
- if e.variable != nil {
- s += ", variable \"" + *e.variable + "\""
- }
- return s
-}
-
-var _ error = extraData{}
diff --git a/vendor/github.com/src-d/gcfg/go1_0.go b/vendor/github.com/src-d/gcfg/go1_0.go
deleted file mode 100644
index 6670210791dd3bcdcc07aea49f5c2b6f734c4e1f..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/go1_0.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// +build !go1.2
-
-package gcfg
-
-type textUnmarshaler interface {
- UnmarshalText(text []byte) error
-}
diff --git a/vendor/github.com/src-d/gcfg/go1_2.go b/vendor/github.com/src-d/gcfg/go1_2.go
deleted file mode 100644
index 6f5843bc7cd963d17786081a91ff2f23957135aa..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/go1_2.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// +build go1.2
-
-package gcfg
-
-import (
- "encoding"
-)
-
-type textUnmarshaler encoding.TextUnmarshaler
diff --git a/vendor/github.com/src-d/gcfg/read.go b/vendor/github.com/src-d/gcfg/read.go
deleted file mode 100644
index ea014f1b3392223761d9b303788c396845f63e7e..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/read.go
+++ /dev/null
@@ -1,273 +0,0 @@
-package gcfg
-
-import (
- "fmt"
- "io"
- "io/ioutil"
- "os"
- "strings"
-
- "github.com/src-d/gcfg/scanner"
- "github.com/src-d/gcfg/token"
- "gopkg.in/warnings.v0"
-)
-
-var unescape = map[rune]rune{'\\': '\\', '"': '"', 'n': '\n', 't': '\t'}
-
-// no error: invalid literals should be caught by scanner
-func unquote(s string) string {
- u, q, esc := make([]rune, 0, len(s)), false, false
- for _, c := range s {
- if esc {
- uc, ok := unescape[c]
- switch {
- case ok:
- u = append(u, uc)
- fallthrough
- case !q && c == '\n':
- esc = false
- continue
- }
- panic("invalid escape sequence")
- }
- switch c {
- case '"':
- q = !q
- case '\\':
- esc = true
- default:
- u = append(u, c)
- }
- }
- if q {
- panic("missing end quote")
- }
- if esc {
- panic("invalid escape sequence")
- }
- return string(u)
-}
-
-func read(c *warnings.Collector, callback func(string,string,string,string,bool)error,
- fset *token.FileSet, file *token.File, src []byte) error {
- //
- var s scanner.Scanner
- var errs scanner.ErrorList
- s.Init(file, src, func(p token.Position, m string) { errs.Add(p, m) }, 0)
- sect, sectsub := "", ""
- pos, tok, lit := s.Scan()
- errfn := func(msg string) error {
- return fmt.Errorf("%s: %s", fset.Position(pos), msg)
- }
- for {
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- switch tok {
- case token.EOF:
- return nil
- case token.EOL, token.COMMENT:
- pos, tok, lit = s.Scan()
- case token.LBRACK:
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- if tok != token.IDENT {
- if err := c.Collect(errfn("expected section name")); err != nil {
- return err
- }
- }
- sect, sectsub = lit, ""
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- if tok == token.STRING {
- sectsub = unquote(lit)
- if sectsub == "" {
- if err := c.Collect(errfn("empty subsection name")); err != nil {
- return err
- }
- }
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- }
- if tok != token.RBRACK {
- if sectsub == "" {
- if err := c.Collect(errfn("expected subsection name or right bracket")); err != nil {
- return err
- }
- }
- if err := c.Collect(errfn("expected right bracket")); err != nil {
- return err
- }
- }
- pos, tok, lit = s.Scan()
- if tok != token.EOL && tok != token.EOF && tok != token.COMMENT {
- if err := c.Collect(errfn("expected EOL, EOF, or comment")); err != nil {
- return err
- }
- }
- // If a section/subsection header was found, ensure a
- // container object is created, even if there are no
- // variables further down.
- err := c.Collect(callback(sect, sectsub, "", "", true))
- if err != nil {
- return err
- }
- case token.IDENT:
- if sect == "" {
- if err := c.Collect(errfn("expected section header")); err != nil {
- return err
- }
- }
- n := lit
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- return errs.Err()
- }
- blank, v := tok == token.EOF || tok == token.EOL || tok == token.COMMENT, ""
- if !blank {
- if tok != token.ASSIGN {
- if err := c.Collect(errfn("expected '='")); err != nil {
- return err
- }
- }
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- if tok != token.STRING {
- if err := c.Collect(errfn("expected value")); err != nil {
- return err
- }
- }
- v = unquote(lit)
- pos, tok, lit = s.Scan()
- if errs.Len() > 0 {
- if err := c.Collect(errs.Err()); err != nil {
- return err
- }
- }
- if tok != token.EOL && tok != token.EOF && tok != token.COMMENT {
- if err := c.Collect(errfn("expected EOL, EOF, or comment")); err != nil {
- return err
- }
- }
- }
- err := c.Collect(callback(sect, sectsub, n, v, blank))
- if err != nil {
- return err
- }
- default:
- if sect == "" {
- if err := c.Collect(errfn("expected section header")); err != nil {
- return err
- }
- }
- if err := c.Collect(errfn("expected section header or variable declaration")); err != nil {
- return err
- }
- }
- }
- panic("never reached")
-}
-
-func readInto(config interface{}, fset *token.FileSet, file *token.File,
- src []byte) error {
- //
- c := warnings.NewCollector(isFatal)
- firstPassCallback := func(s string, ss string, k string, v string, bv bool) error {
- return set(c, config, s, ss, k, v, bv, false)
- }
- err := read(c, firstPassCallback, fset, file, src)
- if err != nil {
- return err
- }
- secondPassCallback := func(s string, ss string, k string, v string, bv bool) error {
- return set(c, config, s, ss, k, v, bv, true)
- }
- err = read(c, secondPassCallback, fset, file, src)
- if err != nil {
- return err
- }
- return c.Done()
-}
-
-// ReadWithCallback reads gcfg formatted data from reader and calls
-// callback with each section and option found.
-//
-// Callback is called with section, subsection, option key, option value
-// and blank value flag as arguments.
-//
-// When a section is found, callback is called with nil subsection, option key
-// and option value.
-//
-// When a subsection is found, callback is called with nil option key and
-// option value.
-//
-// If blank value flag is true, it means that the value was not set for an option
-// (as opposed to set to empty string).
-//
-// If callback returns an error, ReadWithCallback terminates with an error too.
-func ReadWithCallback(reader io.Reader, callback func(string,string,string,string,bool)error) error {
- src, err := ioutil.ReadAll(reader)
- if err != nil {
- return err
- }
-
- fset := token.NewFileSet()
- file := fset.AddFile("", fset.Base(), len(src))
- c := warnings.NewCollector(isFatal)
-
- return read(c, callback, fset, file, src)
-}
-
-// ReadInto reads gcfg formatted data from reader and sets the values into the
-// corresponding fields in config.
-func ReadInto(config interface{}, reader io.Reader) error {
- src, err := ioutil.ReadAll(reader)
- if err != nil {
- return err
- }
- fset := token.NewFileSet()
- file := fset.AddFile("", fset.Base(), len(src))
- return readInto(config, fset, file, src)
-}
-
-// ReadStringInto reads gcfg formatted data from str and sets the values into
-// the corresponding fields in config.
-func ReadStringInto(config interface{}, str string) error {
- r := strings.NewReader(str)
- return ReadInto(config, r)
-}
-
-// ReadFileInto reads gcfg formatted data from the file filename and sets the
-// values into the corresponding fields in config.
-func ReadFileInto(config interface{}, filename string) error {
- f, err := os.Open(filename)
- if err != nil {
- return err
- }
- defer f.Close()
- src, err := ioutil.ReadAll(f)
- if err != nil {
- return err
- }
- fset := token.NewFileSet()
- file := fset.AddFile(filename, fset.Base(), len(src))
- return readInto(config, fset, file, src)
-}
diff --git a/vendor/github.com/src-d/gcfg/scanner/errors.go b/vendor/github.com/src-d/gcfg/scanner/errors.go
deleted file mode 100644
index f3fcecacbb6150353a3c5401e0351dadc188fd00..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/scanner/errors.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package scanner
-
-import (
- "fmt"
- "io"
- "sort"
-)
-
-import (
- "github.com/src-d/gcfg/token"
-)
-
-// In an ErrorList, an error is represented by an *Error.
-// The position Pos, if valid, points to the beginning of
-// the offending token, and the error condition is described
-// by Msg.
-//
-type Error struct {
- Pos token.Position
- Msg string
-}
-
-// Error implements the error interface.
-func (e Error) Error() string {
- if e.Pos.Filename != "" || e.Pos.IsValid() {
- // don't print "<unknown position>"
- // TODO(gri) reconsider the semantics of Position.IsValid
- return e.Pos.String() + ": " + e.Msg
- }
- return e.Msg
-}
-
-// ErrorList is a list of *Errors.
-// The zero value for an ErrorList is an empty ErrorList ready to use.
-//
-type ErrorList []*Error
-
-// Add adds an Error with given position and error message to an ErrorList.
-func (p *ErrorList) Add(pos token.Position, msg string) {
- *p = append(*p, &Error{pos, msg})
-}
-
-// Reset resets an ErrorList to no errors.
-func (p *ErrorList) Reset() { *p = (*p)[0:0] }
-
-// ErrorList implements the sort Interface.
-func (p ErrorList) Len() int { return len(p) }
-func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-
-func (p ErrorList) Less(i, j int) bool {
- e := &p[i].Pos
- f := &p[j].Pos
- if e.Filename < f.Filename {
- return true
- }
- if e.Filename == f.Filename {
- return e.Offset < f.Offset
- }
- return false
-}
-
-// Sort sorts an ErrorList. *Error entries are sorted by position,
-// other errors are sorted by error message, and before any *Error
-// entry.
-//
-func (p ErrorList) Sort() {
- sort.Sort(p)
-}
-
-// RemoveMultiples sorts an ErrorList and removes all but the first error per line.
-func (p *ErrorList) RemoveMultiples() {
- sort.Sort(p)
- var last token.Position // initial last.Line is != any legal error line
- i := 0
- for _, e := range *p {
- if e.Pos.Filename != last.Filename || e.Pos.Line != last.Line {
- last = e.Pos
- (*p)[i] = e
- i++
- }
- }
- (*p) = (*p)[0:i]
-}
-
-// An ErrorList implements the error interface.
-func (p ErrorList) Error() string {
- switch len(p) {
- case 0:
- return "no errors"
- case 1:
- return p[0].Error()
- }
- return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
-}
-
-// Err returns an error equivalent to this error list.
-// If the list is empty, Err returns nil.
-func (p ErrorList) Err() error {
- if len(p) == 0 {
- return nil
- }
- return p
-}
-
-// PrintError is a utility function that prints a list of errors to w,
-// one error per line, if the err parameter is an ErrorList. Otherwise
-// it prints the err string.
-//
-func PrintError(w io.Writer, err error) {
- if list, ok := err.(ErrorList); ok {
- for _, e := range list {
- fmt.Fprintf(w, "%s\n", e)
- }
- } else if err != nil {
- fmt.Fprintf(w, "%s\n", err)
- }
-}
diff --git a/vendor/github.com/src-d/gcfg/scanner/scanner.go b/vendor/github.com/src-d/gcfg/scanner/scanner.go
deleted file mode 100644
index f15867648c59df14c5a467ab17b7248b10a74bfa..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/scanner/scanner.go
+++ /dev/null
@@ -1,342 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package scanner implements a scanner for gcfg configuration text.
-// It takes a []byte as source which can then be tokenized
-// through repeated calls to the Scan method.
-//
-// Note that the API for the scanner package may change to accommodate new
-// features or implementation changes in gcfg.
-//
-package scanner
-
-import (
- "fmt"
- "path/filepath"
- "unicode"
- "unicode/utf8"
-)
-
-import (
- "github.com/src-d/gcfg/token"
-)
-
-// An ErrorHandler may be provided to Scanner.Init. If a syntax error is
-// encountered and a handler was installed, the handler is called with a
-// position and an error message. The position points to the beginning of
-// the offending token.
-//
-type ErrorHandler func(pos token.Position, msg string)
-
-// A Scanner holds the scanner's internal state while processing
-// a given text. It can be allocated as part of another data
-// structure but must be initialized via Init before use.
-//
-type Scanner struct {
- // immutable state
- file *token.File // source file handle
- dir string // directory portion of file.Name()
- src []byte // source
- err ErrorHandler // error reporting; or nil
- mode Mode // scanning mode
-
- // scanning state
- ch rune // current character
- offset int // character offset
- rdOffset int // reading offset (position after current character)
- lineOffset int // current line offset
- nextVal bool // next token is expected to be a value
-
- // public state - ok to modify
- ErrorCount int // number of errors encountered
-}
-
-// Read the next Unicode char into s.ch.
-// s.ch < 0 means end-of-file.
-//
-func (s *Scanner) next() {
- if s.rdOffset < len(s.src) {
- s.offset = s.rdOffset
- if s.ch == '\n' {
- s.lineOffset = s.offset
- s.file.AddLine(s.offset)
- }
- r, w := rune(s.src[s.rdOffset]), 1
- switch {
- case r == 0:
- s.error(s.offset, "illegal character NUL")
- case r >= 0x80:
- // not ASCII
- r, w = utf8.DecodeRune(s.src[s.rdOffset:])
- if r == utf8.RuneError && w == 1 {
- s.error(s.offset, "illegal UTF-8 encoding")
- }
- }
- s.rdOffset += w
- s.ch = r
- } else {
- s.offset = len(s.src)
- if s.ch == '\n' {
- s.lineOffset = s.offset
- s.file.AddLine(s.offset)
- }
- s.ch = -1 // eof
- }
-}
-
-// A mode value is a set of flags (or 0).
-// They control scanner behavior.
-//
-type Mode uint
-
-const (
- ScanComments Mode = 1 << iota // return comments as COMMENT tokens
-)
-
-// Init prepares the scanner s to tokenize the text src by setting the
-// scanner at the beginning of src. The scanner uses the file set file
-// for position information and it adds line information for each line.
-// It is ok to re-use the same file when re-scanning the same file as
-// line information which is already present is ignored. Init causes a
-// panic if the file size does not match the src size.
-//
-// Calls to Scan will invoke the error handler err if they encounter a
-// syntax error and err is not nil. Also, for each error encountered,
-// the Scanner field ErrorCount is incremented by one. The mode parameter
-// determines how comments are handled.
-//
-// Note that Init may call err if there is an error in the first character
-// of the file.
-//
-func (s *Scanner) Init(file *token.File, src []byte, err ErrorHandler, mode Mode) {
- // Explicitly initialize all fields since a scanner may be reused.
- if file.Size() != len(src) {
- panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
- }
- s.file = file
- s.dir, _ = filepath.Split(file.Name())
- s.src = src
- s.err = err
- s.mode = mode
-
- s.ch = ' '
- s.offset = 0
- s.rdOffset = 0
- s.lineOffset = 0
- s.ErrorCount = 0
- s.nextVal = false
-
- s.next()
-}
-
-func (s *Scanner) error(offs int, msg string) {
- if s.err != nil {
- s.err(s.file.Position(s.file.Pos(offs)), msg)
- }
- s.ErrorCount++
-}
-
-func (s *Scanner) scanComment() string {
- // initial [;#] already consumed
- offs := s.offset - 1 // position of initial [;#]
-
- for s.ch != '\n' && s.ch >= 0 {
- s.next()
- }
- return string(s.src[offs:s.offset])
-}
-
-func isLetter(ch rune) bool {
- return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch >= 0x80 && unicode.IsLetter(ch)
-}
-
-func isDigit(ch rune) bool {
- return '0' <= ch && ch <= '9' || ch >= 0x80 && unicode.IsDigit(ch)
-}
-
-func (s *Scanner) scanIdentifier() string {
- offs := s.offset
- for isLetter(s.ch) || isDigit(s.ch) || s.ch == '-' {
- s.next()
- }
- return string(s.src[offs:s.offset])
-}
-
-func (s *Scanner) scanEscape(val bool) {
- offs := s.offset
- ch := s.ch
- s.next() // always make progress
- switch ch {
- case '\\', '"':
- // ok
- case 'n', 't':
- if val {
- break // ok
- }
- fallthrough
- default:
- s.error(offs, "unknown escape sequence")
- }
-}
-
-func (s *Scanner) scanString() string {
- // '"' opening already consumed
- offs := s.offset - 1
-
- for s.ch != '"' {
- ch := s.ch
- s.next()
- if ch == '\n' || ch < 0 {
- s.error(offs, "string not terminated")
- break
- }
- if ch == '\\' {
- s.scanEscape(false)
- }
- }
-
- s.next()
-
- return string(s.src[offs:s.offset])
-}
-
-func stripCR(b []byte) []byte {
- c := make([]byte, len(b))
- i := 0
- for _, ch := range b {
- if ch != '\r' {
- c[i] = ch
- i++
- }
- }
- return c[:i]
-}
-
-func (s *Scanner) scanValString() string {
- offs := s.offset
-
- hasCR := false
- end := offs
- inQuote := false
-loop:
- for inQuote || s.ch >= 0 && s.ch != '\n' && s.ch != ';' && s.ch != '#' {
- ch := s.ch
- s.next()
- switch {
- case inQuote && ch == '\\':
- s.scanEscape(true)
- case !inQuote && ch == '\\':
- if s.ch == '\r' {
- hasCR = true
- s.next()
- }
- if s.ch != '\n' {
- s.error(offs, "unquoted '\\' must be followed by new line")
- break loop
- }
- s.next()
- case ch == '"':
- inQuote = !inQuote
- case ch == '\r':
- hasCR = true
- case ch < 0 || inQuote && ch == '\n':
- s.error(offs, "string not terminated")
- break loop
- }
- if inQuote || !isWhiteSpace(ch) {
- end = s.offset
- }
- }
-
- lit := s.src[offs:end]
- if hasCR {
- lit = stripCR(lit)
- }
-
- return string(lit)
-}
-
-func isWhiteSpace(ch rune) bool {
- return ch == ' ' || ch == '\t' || ch == '\r'
-}
-
-func (s *Scanner) skipWhitespace() {
- for isWhiteSpace(s.ch) {
- s.next()
- }
-}
-
-// Scan scans the next token and returns the token position, the token,
-// and its literal string if applicable. The source end is indicated by
-// token.EOF.
-//
-// If the returned token is a literal (token.IDENT, token.STRING) or
-// token.COMMENT, the literal string has the corresponding value.
-//
-// If the returned token is token.ILLEGAL, the literal string is the
-// offending character.
-//
-// In all other cases, Scan returns an empty literal string.
-//
-// For more tolerant parsing, Scan will return a valid token if
-// possible even if a syntax error was encountered. Thus, even
-// if the resulting token sequence contains no illegal tokens,
-// a client may not assume that no error occurred. Instead it
-// must check the scanner's ErrorCount or the number of calls
-// of the error handler, if there was one installed.
-//
-// Scan adds line information to the file added to the file
-// set with Init. Token positions are relative to that file
-// and thus relative to the file set.
-//
-func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
-scanAgain:
- s.skipWhitespace()
-
- // current token start
- pos = s.file.Pos(s.offset)
-
- // determine token value
- switch ch := s.ch; {
- case s.nextVal:
- lit = s.scanValString()
- tok = token.STRING
- s.nextVal = false
- case isLetter(ch):
- lit = s.scanIdentifier()
- tok = token.IDENT
- default:
- s.next() // always make progress
- switch ch {
- case -1:
- tok = token.EOF
- case '\n':
- tok = token.EOL
- case '"':
- tok = token.STRING
- lit = s.scanString()
- case '[':
- tok = token.LBRACK
- case ']':
- tok = token.RBRACK
- case ';', '#':
- // comment
- lit = s.scanComment()
- if s.mode&ScanComments == 0 {
- // skip comment
- goto scanAgain
- }
- tok = token.COMMENT
- case '=':
- tok = token.ASSIGN
- s.nextVal = true
- default:
- s.error(s.file.Offset(pos), fmt.Sprintf("illegal character %#U", ch))
- tok = token.ILLEGAL
- lit = string(ch)
- }
- }
-
- return
-}
diff --git a/vendor/github.com/src-d/gcfg/set.go b/vendor/github.com/src-d/gcfg/set.go
deleted file mode 100644
index 771258f0ef2fed18037aa2978bc4b98de7129cb2..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/set.go
+++ /dev/null
@@ -1,332 +0,0 @@
-package gcfg
-
-import (
- "bytes"
- "encoding/gob"
- "fmt"
- "math/big"
- "reflect"
- "strings"
- "unicode"
- "unicode/utf8"
-
- "github.com/src-d/gcfg/types"
- "gopkg.in/warnings.v0"
-)
-
-type tag struct {
- ident string
- intMode string
-}
-
-func newTag(ts string) tag {
- t := tag{}
- s := strings.Split(ts, ",")
- t.ident = s[0]
- for _, tse := range s[1:] {
- if strings.HasPrefix(tse, "int=") {
- t.intMode = tse[len("int="):]
- }
- }
- return t
-}
-
-func fieldFold(v reflect.Value, name string) (reflect.Value, tag) {
- var n string
- r0, _ := utf8.DecodeRuneInString(name)
- if unicode.IsLetter(r0) && !unicode.IsLower(r0) && !unicode.IsUpper(r0) {
- n = "X"
- }
- n += strings.Replace(name, "-", "_", -1)
- f, ok := v.Type().FieldByNameFunc(func(fieldName string) bool {
- if !v.FieldByName(fieldName).CanSet() {
- return false
- }
- f, _ := v.Type().FieldByName(fieldName)
- t := newTag(f.Tag.Get("gcfg"))
- if t.ident != "" {
- return strings.EqualFold(t.ident, name)
- }
- return strings.EqualFold(n, fieldName)
- })
- if !ok {
- return reflect.Value{}, tag{}
- }
- return v.FieldByName(f.Name), newTag(f.Tag.Get("gcfg"))
-}
-
-type setter func(destp interface{}, blank bool, val string, t tag) error
-
-var errUnsupportedType = fmt.Errorf("unsupported type")
-var errBlankUnsupported = fmt.Errorf("blank value not supported for type")
-
-var setters = []setter{
- typeSetter, textUnmarshalerSetter, kindSetter, scanSetter,
-}
-
-func textUnmarshalerSetter(d interface{}, blank bool, val string, t tag) error {
- dtu, ok := d.(textUnmarshaler)
- if !ok {
- return errUnsupportedType
- }
- if blank {
- return errBlankUnsupported
- }
- return dtu.UnmarshalText([]byte(val))
-}
-
-func boolSetter(d interface{}, blank bool, val string, t tag) error {
- if blank {
- reflect.ValueOf(d).Elem().Set(reflect.ValueOf(true))
- return nil
- }
- b, err := types.ParseBool(val)
- if err == nil {
- reflect.ValueOf(d).Elem().Set(reflect.ValueOf(b))
- }
- return err
-}
-
-func intMode(mode string) types.IntMode {
- var m types.IntMode
- if strings.ContainsAny(mode, "dD") {
- m |= types.Dec
- }
- if strings.ContainsAny(mode, "hH") {
- m |= types.Hex
- }
- if strings.ContainsAny(mode, "oO") {
- m |= types.Oct
- }
- return m
-}
-
-var typeModes = map[reflect.Type]types.IntMode{
- reflect.TypeOf(int(0)): types.Dec | types.Hex,
- reflect.TypeOf(int8(0)): types.Dec | types.Hex,
- reflect.TypeOf(int16(0)): types.Dec | types.Hex,
- reflect.TypeOf(int32(0)): types.Dec | types.Hex,
- reflect.TypeOf(int64(0)): types.Dec | types.Hex,
- reflect.TypeOf(uint(0)): types.Dec | types.Hex,
- reflect.TypeOf(uint8(0)): types.Dec | types.Hex,
- reflect.TypeOf(uint16(0)): types.Dec | types.Hex,
- reflect.TypeOf(uint32(0)): types.Dec | types.Hex,
- reflect.TypeOf(uint64(0)): types.Dec | types.Hex,
- // use default mode (allow dec/hex/oct) for uintptr type
- reflect.TypeOf(big.Int{}): types.Dec | types.Hex,
-}
-
-func intModeDefault(t reflect.Type) types.IntMode {
- m, ok := typeModes[t]
- if !ok {
- m = types.Dec | types.Hex | types.Oct
- }
- return m
-}
-
-func intSetter(d interface{}, blank bool, val string, t tag) error {
- if blank {
- return errBlankUnsupported
- }
- mode := intMode(t.intMode)
- if mode == 0 {
- mode = intModeDefault(reflect.TypeOf(d).Elem())
- }
- return types.ParseInt(d, val, mode)
-}
-
-func stringSetter(d interface{}, blank bool, val string, t tag) error {
- if blank {
- return errBlankUnsupported
- }
- dsp, ok := d.(*string)
- if !ok {
- return errUnsupportedType
- }
- *dsp = val
- return nil
-}
-
-var kindSetters = map[reflect.Kind]setter{
- reflect.String: stringSetter,
- reflect.Bool: boolSetter,
- reflect.Int: intSetter,
- reflect.Int8: intSetter,
- reflect.Int16: intSetter,
- reflect.Int32: intSetter,
- reflect.Int64: intSetter,
- reflect.Uint: intSetter,
- reflect.Uint8: intSetter,
- reflect.Uint16: intSetter,
- reflect.Uint32: intSetter,
- reflect.Uint64: intSetter,
- reflect.Uintptr: intSetter,
-}
-
-var typeSetters = map[reflect.Type]setter{
- reflect.TypeOf(big.Int{}): intSetter,
-}
-
-func typeSetter(d interface{}, blank bool, val string, tt tag) error {
- t := reflect.ValueOf(d).Type().Elem()
- setter, ok := typeSetters[t]
- if !ok {
- return errUnsupportedType
- }
- return setter(d, blank, val, tt)
-}
-
-func kindSetter(d interface{}, blank bool, val string, tt tag) error {
- k := reflect.ValueOf(d).Type().Elem().Kind()
- setter, ok := kindSetters[k]
- if !ok {
- return errUnsupportedType
- }
- return setter(d, blank, val, tt)
-}
-
-func scanSetter(d interface{}, blank bool, val string, tt tag) error {
- if blank {
- return errBlankUnsupported
- }
- return types.ScanFully(d, val, 'v')
-}
-
-func newValue(c *warnings.Collector, sect string, vCfg reflect.Value,
- vType reflect.Type) (reflect.Value, error) {
- //
- pv := reflect.New(vType)
- dfltName := "default-" + sect
- dfltField, _ := fieldFold(vCfg, dfltName)
- var err error
- if dfltField.IsValid() {
- b := bytes.NewBuffer(nil)
- ge := gob.NewEncoder(b)
- if err = c.Collect(ge.EncodeValue(dfltField)); err != nil {
- return pv, err
- }
- gd := gob.NewDecoder(bytes.NewReader(b.Bytes()))
- if err = c.Collect(gd.DecodeValue(pv.Elem())); err != nil {
- return pv, err
- }
- }
- return pv, nil
-}
-
-func set(c *warnings.Collector, cfg interface{}, sect, sub, name string,
- value string, blankValue bool, subsectPass bool) error {
- //
- vPCfg := reflect.ValueOf(cfg)
- if vPCfg.Kind() != reflect.Ptr || vPCfg.Elem().Kind() != reflect.Struct {
- panic(fmt.Errorf("config must be a pointer to a struct"))
- }
- vCfg := vPCfg.Elem()
- vSect, _ := fieldFold(vCfg, sect)
- if !vSect.IsValid() {
- err := extraData{section: sect}
- return c.Collect(err)
- }
- isSubsect := vSect.Kind() == reflect.Map
- if subsectPass != isSubsect {
- return nil
- }
- if isSubsect {
- vst := vSect.Type()
- if vst.Key().Kind() != reflect.String ||
- vst.Elem().Kind() != reflect.Ptr ||
- vst.Elem().Elem().Kind() != reflect.Struct {
- panic(fmt.Errorf("map field for section must have string keys and "+
- " pointer-to-struct values: section %q", sect))
- }
- if vSect.IsNil() {
- vSect.Set(reflect.MakeMap(vst))
- }
- k := reflect.ValueOf(sub)
- pv := vSect.MapIndex(k)
- if !pv.IsValid() {
- vType := vSect.Type().Elem().Elem()
- var err error
- if pv, err = newValue(c, sect, vCfg, vType); err != nil {
- return err
- }
- vSect.SetMapIndex(k, pv)
- }
- vSect = pv.Elem()
- } else if vSect.Kind() != reflect.Struct {
- panic(fmt.Errorf("field for section must be a map or a struct: "+
- "section %q", sect))
- } else if sub != "" {
- err := extraData{section: sect, subsection: &sub}
- return c.Collect(err)
- }
- // Empty name is a special value, meaning that only the
- // section/subsection object is to be created, with no values set.
- if name == "" {
- return nil
- }
- vVar, t := fieldFold(vSect, name)
- if !vVar.IsValid() {
- var err error
- if isSubsect {
- err = extraData{section: sect, subsection: &sub, variable: &name}
- } else {
- err = extraData{section: sect, variable: &name}
- }
- return c.Collect(err)
- }
- // vVal is either single-valued var, or newly allocated value within multi-valued var
- var vVal reflect.Value
- // multi-value if unnamed slice type
- isMulti := vVar.Type().Name() == "" && vVar.Kind() == reflect.Slice ||
- vVar.Type().Name() == "" && vVar.Kind() == reflect.Ptr && vVar.Type().Elem().Name() == "" && vVar.Type().Elem().Kind() == reflect.Slice
- if isMulti && vVar.Kind() == reflect.Ptr {
- if vVar.IsNil() {
- vVar.Set(reflect.New(vVar.Type().Elem()))
- }
- vVar = vVar.Elem()
- }
- if isMulti && blankValue {
- vVar.Set(reflect.Zero(vVar.Type()))
- return nil
- }
- if isMulti {
- vVal = reflect.New(vVar.Type().Elem()).Elem()
- } else {
- vVal = vVar
- }
- isDeref := vVal.Type().Name() == "" && vVal.Type().Kind() == reflect.Ptr
- isNew := isDeref && vVal.IsNil()
- // vAddr is address of value to set (dereferenced & allocated as needed)
- var vAddr reflect.Value
- switch {
- case isNew:
- vAddr = reflect.New(vVal.Type().Elem())
- case isDeref && !isNew:
- vAddr = vVal
- default:
- vAddr = vVal.Addr()
- }
- vAddrI := vAddr.Interface()
- err, ok := error(nil), false
- for _, s := range setters {
- err = s(vAddrI, blankValue, value, t)
- if err == nil {
- ok = true
- break
- }
- if err != errUnsupportedType {
- return err
- }
- }
- if !ok {
- // in case all setters returned errUnsupportedType
- return err
- }
- if isNew { // set reference if it was dereferenced and newly allocated
- vVal.Set(vAddr)
- }
- if isMulti { // append if multi-valued
- vVar.Set(reflect.Append(vVar, vVal))
- }
- return nil
-}
diff --git a/vendor/github.com/src-d/gcfg/token/position.go b/vendor/github.com/src-d/gcfg/token/position.go
deleted file mode 100644
index fc45c1e7693efd56fc38784556f4c7e27d6602a3..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/token/position.go
+++ /dev/null
@@ -1,435 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TODO(gri) consider making this a separate package outside the go directory.
-
-package token
-
-import (
- "fmt"
- "sort"
- "sync"
-)
-
-// -----------------------------------------------------------------------------
-// Positions
-
-// Position describes an arbitrary source position
-// including the file, line, and column location.
-// A Position is valid if the line number is > 0.
-//
-type Position struct {
- Filename string // filename, if any
- Offset int // offset, starting at 0
- Line int // line number, starting at 1
- Column int // column number, starting at 1 (character count)
-}
-
-// IsValid returns true if the position is valid.
-func (pos *Position) IsValid() bool { return pos.Line > 0 }
-
-// String returns a string in one of several forms:
-//
-// file:line:column valid position with file name
-// line:column valid position without file name
-// file invalid position with file name
-// - invalid position without file name
-//
-func (pos Position) String() string {
- s := pos.Filename
- if pos.IsValid() {
- if s != "" {
- s += ":"
- }
- s += fmt.Sprintf("%d:%d", pos.Line, pos.Column)
- }
- if s == "" {
- s = "-"
- }
- return s
-}
-
-// Pos is a compact encoding of a source position within a file set.
-// It can be converted into a Position for a more convenient, but much
-// larger, representation.
-//
-// The Pos value for a given file is a number in the range [base, base+size],
-// where base and size are specified when adding the file to the file set via
-// AddFile.
-//
-// To create the Pos value for a specific source offset, first add
-// the respective file to the current file set (via FileSet.AddFile)
-// and then call File.Pos(offset) for that file. Given a Pos value p
-// for a specific file set fset, the corresponding Position value is
-// obtained by calling fset.Position(p).
-//
-// Pos values can be compared directly with the usual comparison operators:
-// If two Pos values p and q are in the same file, comparing p and q is
-// equivalent to comparing the respective source file offsets. If p and q
-// are in different files, p < q is true if the file implied by p was added
-// to the respective file set before the file implied by q.
-//
-type Pos int
-
-// The zero value for Pos is NoPos; there is no file and line information
-// associated with it, and NoPos().IsValid() is false. NoPos is always
-// smaller than any other Pos value. The corresponding Position value
-// for NoPos is the zero value for Position.
-//
-const NoPos Pos = 0
-
-// IsValid returns true if the position is valid.
-func (p Pos) IsValid() bool {
- return p != NoPos
-}
-
-// -----------------------------------------------------------------------------
-// File
-
-// A File is a handle for a file belonging to a FileSet.
-// A File has a name, size, and line offset table.
-//
-type File struct {
- set *FileSet
- name string // file name as provided to AddFile
- base int // Pos value range for this file is [base...base+size]
- size int // file size as provided to AddFile
-
- // lines and infos are protected by set.mutex
- lines []int
- infos []lineInfo
-}
-
-// Name returns the file name of file f as registered with AddFile.
-func (f *File) Name() string {
- return f.name
-}
-
-// Base returns the base offset of file f as registered with AddFile.
-func (f *File) Base() int {
- return f.base
-}
-
-// Size returns the size of file f as registered with AddFile.
-func (f *File) Size() int {
- return f.size
-}
-
-// LineCount returns the number of lines in file f.
-func (f *File) LineCount() int {
- f.set.mutex.RLock()
- n := len(f.lines)
- f.set.mutex.RUnlock()
- return n
-}
-
-// AddLine adds the line offset for a new line.
-// The line offset must be larger than the offset for the previous line
-// and smaller than the file size; otherwise the line offset is ignored.
-//
-func (f *File) AddLine(offset int) {
- f.set.mutex.Lock()
- if i := len(f.lines); (i == 0 || f.lines[i-1] < offset) && offset < f.size {
- f.lines = append(f.lines, offset)
- }
- f.set.mutex.Unlock()
-}
-
-// SetLines sets the line offsets for a file and returns true if successful.
-// The line offsets are the offsets of the first character of each line;
-// for instance for the content "ab\nc\n" the line offsets are {0, 3}.
-// An empty file has an empty line offset table.
-// Each line offset must be larger than the offset for the previous line
-// and smaller than the file size; otherwise SetLines fails and returns
-// false.
-//
-func (f *File) SetLines(lines []int) bool {
- // verify validity of lines table
- size := f.size
- for i, offset := range lines {
- if i > 0 && offset <= lines[i-1] || size <= offset {
- return false
- }
- }
-
- // set lines table
- f.set.mutex.Lock()
- f.lines = lines
- f.set.mutex.Unlock()
- return true
-}
-
-// SetLinesForContent sets the line offsets for the given file content.
-func (f *File) SetLinesForContent(content []byte) {
- var lines []int
- line := 0
- for offset, b := range content {
- if line >= 0 {
- lines = append(lines, line)
- }
- line = -1
- if b == '\n' {
- line = offset + 1
- }
- }
-
- // set lines table
- f.set.mutex.Lock()
- f.lines = lines
- f.set.mutex.Unlock()
-}
-
-// A lineInfo object describes alternative file and line number
-// information (such as provided via a //line comment in a .go
-// file) for a given file offset.
-type lineInfo struct {
- // fields are exported to make them accessible to gob
- Offset int
- Filename string
- Line int
-}
-
-// AddLineInfo adds alternative file and line number information for
-// a given file offset. The offset must be larger than the offset for
-// the previously added alternative line info and smaller than the
-// file size; otherwise the information is ignored.
-//
-// AddLineInfo is typically used to register alternative position
-// information for //line filename:line comments in source files.
-//
-func (f *File) AddLineInfo(offset int, filename string, line int) {
- f.set.mutex.Lock()
- if i := len(f.infos); i == 0 || f.infos[i-1].Offset < offset && offset < f.size {
- f.infos = append(f.infos, lineInfo{offset, filename, line})
- }
- f.set.mutex.Unlock()
-}
-
-// Pos returns the Pos value for the given file offset;
-// the offset must be <= f.Size().
-// f.Pos(f.Offset(p)) == p.
-//
-func (f *File) Pos(offset int) Pos {
- if offset > f.size {
- panic("illegal file offset")
- }
- return Pos(f.base + offset)
-}
-
-// Offset returns the offset for the given file position p;
-// p must be a valid Pos value in that file.
-// f.Offset(f.Pos(offset)) == offset.
-//
-func (f *File) Offset(p Pos) int {
- if int(p) < f.base || int(p) > f.base+f.size {
- panic("illegal Pos value")
- }
- return int(p) - f.base
-}
-
-// Line returns the line number for the given file position p;
-// p must be a Pos value in that file or NoPos.
-//
-func (f *File) Line(p Pos) int {
- // TODO(gri) this can be implemented much more efficiently
- return f.Position(p).Line
-}
-
-func searchLineInfos(a []lineInfo, x int) int {
- return sort.Search(len(a), func(i int) bool { return a[i].Offset > x }) - 1
-}
-
-// info returns the file name, line, and column number for a file offset.
-func (f *File) info(offset int) (filename string, line, column int) {
- filename = f.name
- if i := searchInts(f.lines, offset); i >= 0 {
- line, column = i+1, offset-f.lines[i]+1
- }
- if len(f.infos) > 0 {
- // almost no files have extra line infos
- if i := searchLineInfos(f.infos, offset); i >= 0 {
- alt := &f.infos[i]
- filename = alt.Filename
- if i := searchInts(f.lines, alt.Offset); i >= 0 {
- line += alt.Line - i - 1
- }
- }
- }
- return
-}
-
-func (f *File) position(p Pos) (pos Position) {
- offset := int(p) - f.base
- pos.Offset = offset
- pos.Filename, pos.Line, pos.Column = f.info(offset)
- return
-}
-
-// Position returns the Position value for the given file position p;
-// p must be a Pos value in that file or NoPos.
-//
-func (f *File) Position(p Pos) (pos Position) {
- if p != NoPos {
- if int(p) < f.base || int(p) > f.base+f.size {
- panic("illegal Pos value")
- }
- pos = f.position(p)
- }
- return
-}
-
-// -----------------------------------------------------------------------------
-// FileSet
-
-// A FileSet represents a set of source files.
-// Methods of file sets are synchronized; multiple goroutines
-// may invoke them concurrently.
-//
-type FileSet struct {
- mutex sync.RWMutex // protects the file set
- base int // base offset for the next file
- files []*File // list of files in the order added to the set
- last *File // cache of last file looked up
-}
-
-// NewFileSet creates a new file set.
-func NewFileSet() *FileSet {
- s := new(FileSet)
- s.base = 1 // 0 == NoPos
- return s
-}
-
-// Base returns the minimum base offset that must be provided to
-// AddFile when adding the next file.
-//
-func (s *FileSet) Base() int {
- s.mutex.RLock()
- b := s.base
- s.mutex.RUnlock()
- return b
-
-}
-
-// AddFile adds a new file with a given filename, base offset, and file size
-// to the file set s and returns the file. Multiple files may have the same
-// name. The base offset must not be smaller than the FileSet's Base(), and
-// size must not be negative.
-//
-// Adding the file will set the file set's Base() value to base + size + 1
-// as the minimum base value for the next file. The following relationship
-// exists between a Pos value p for a given file offset offs:
-//
-// int(p) = base + offs
-//
-// with offs in the range [0, size] and thus p in the range [base, base+size].
-// For convenience, File.Pos may be used to create file-specific position
-// values from a file offset.
-//
-func (s *FileSet) AddFile(filename string, base, size int) *File {
- s.mutex.Lock()
- defer s.mutex.Unlock()
- if base < s.base || size < 0 {
- panic("illegal base or size")
- }
- // base >= s.base && size >= 0
- f := &File{s, filename, base, size, []int{0}, nil}
- base += size + 1 // +1 because EOF also has a position
- if base < 0 {
- panic("token.Pos offset overflow (> 2G of source code in file set)")
- }
- // add the file to the file set
- s.base = base
- s.files = append(s.files, f)
- s.last = f
- return f
-}
-
-// Iterate calls f for the files in the file set in the order they were added
-// until f returns false.
-//
-func (s *FileSet) Iterate(f func(*File) bool) {
- for i := 0; ; i++ {
- var file *File
- s.mutex.RLock()
- if i < len(s.files) {
- file = s.files[i]
- }
- s.mutex.RUnlock()
- if file == nil || !f(file) {
- break
- }
- }
-}
-
-func searchFiles(a []*File, x int) int {
- return sort.Search(len(a), func(i int) bool { return a[i].base > x }) - 1
-}
-
-func (s *FileSet) file(p Pos) *File {
- // common case: p is in last file
- if f := s.last; f != nil && f.base <= int(p) && int(p) <= f.base+f.size {
- return f
- }
- // p is not in last file - search all files
- if i := searchFiles(s.files, int(p)); i >= 0 {
- f := s.files[i]
- // f.base <= int(p) by definition of searchFiles
- if int(p) <= f.base+f.size {
- s.last = f
- return f
- }
- }
- return nil
-}
-
-// File returns the file that contains the position p.
-// If no such file is found (for instance for p == NoPos),
-// the result is nil.
-//
-func (s *FileSet) File(p Pos) (f *File) {
- if p != NoPos {
- s.mutex.RLock()
- f = s.file(p)
- s.mutex.RUnlock()
- }
- return
-}
-
-// Position converts a Pos in the fileset into a general Position.
-func (s *FileSet) Position(p Pos) (pos Position) {
- if p != NoPos {
- s.mutex.RLock()
- if f := s.file(p); f != nil {
- pos = f.position(p)
- }
- s.mutex.RUnlock()
- }
- return
-}
-
-// -----------------------------------------------------------------------------
-// Helper functions
-
-func searchInts(a []int, x int) int {
- // This function body is a manually inlined version of:
- //
- // return sort.Search(len(a), func(i int) bool { return a[i] > x }) - 1
- //
- // With better compiler optimizations, this may not be needed in the
- // future, but at the moment this change improves the go/printer
- // benchmark performance by ~30%. This has a direct impact on the
- // speed of gofmt and thus seems worthwhile (2011-04-29).
- // TODO(gri): Remove this when compilers have caught up.
- i, j := 0, len(a)
- for i < j {
- h := i + (j-i)/2 // avoid overflow when computing h
- // i ≤ h < j
- if a[h] <= x {
- i = h + 1
- } else {
- j = h
- }
- }
- return i - 1
-}
diff --git a/vendor/github.com/src-d/gcfg/token/serialize.go b/vendor/github.com/src-d/gcfg/token/serialize.go
deleted file mode 100644
index 4adc8f9e33422f656039c98a50c65713b3734698..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/token/serialize.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package token
-
-type serializedFile struct {
- // fields correspond 1:1 to fields with same (lower-case) name in File
- Name string
- Base int
- Size int
- Lines []int
- Infos []lineInfo
-}
-
-type serializedFileSet struct {
- Base int
- Files []serializedFile
-}
-
-// Read calls decode to deserialize a file set into s; s must not be nil.
-func (s *FileSet) Read(decode func(interface{}) error) error {
- var ss serializedFileSet
- if err := decode(&ss); err != nil {
- return err
- }
-
- s.mutex.Lock()
- s.base = ss.Base
- files := make([]*File, len(ss.Files))
- for i := 0; i < len(ss.Files); i++ {
- f := &ss.Files[i]
- files[i] = &File{s, f.Name, f.Base, f.Size, f.Lines, f.Infos}
- }
- s.files = files
- s.last = nil
- s.mutex.Unlock()
-
- return nil
-}
-
-// Write calls encode to serialize the file set s.
-func (s *FileSet) Write(encode func(interface{}) error) error {
- var ss serializedFileSet
-
- s.mutex.Lock()
- ss.Base = s.base
- files := make([]serializedFile, len(s.files))
- for i, f := range s.files {
- files[i] = serializedFile{f.name, f.base, f.size, f.lines, f.infos}
- }
- ss.Files = files
- s.mutex.Unlock()
-
- return encode(ss)
-}
diff --git a/vendor/github.com/src-d/gcfg/token/token.go b/vendor/github.com/src-d/gcfg/token/token.go
deleted file mode 100644
index b3c7c83fa9e6c67f59bc4ddfbf66164e9ba3b819..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/token/token.go
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package token defines constants representing the lexical tokens of the gcfg
-// configuration syntax and basic operations on tokens (printing, predicates).
-//
-// Note that the API for the token package may change to accommodate new
-// features or implementation changes in gcfg.
-//
-package token
-
-import "strconv"
-
-// Token is the set of lexical tokens of the gcfg configuration syntax.
-type Token int
-
-// The list of tokens.
-const (
- // Special tokens
- ILLEGAL Token = iota
- EOF
- COMMENT
-
- literal_beg
- // Identifiers and basic type literals
- // (these tokens stand for classes of literals)
- IDENT // section-name, variable-name
- STRING // "subsection-name", variable value
- literal_end
-
- operator_beg
- // Operators and delimiters
- ASSIGN // =
- LBRACK // [
- RBRACK // ]
- EOL // \n
- operator_end
-)
-
-var tokens = [...]string{
- ILLEGAL: "ILLEGAL",
-
- EOF: "EOF",
- COMMENT: "COMMENT",
-
- IDENT: "IDENT",
- STRING: "STRING",
-
- ASSIGN: "=",
- LBRACK: "[",
- RBRACK: "]",
- EOL: "\n",
-}
-
-// String returns the string corresponding to the token tok.
-// For operators and delimiters, the string is the actual token character
-// sequence (e.g., for the token ASSIGN, the string is "="). For all other
-// tokens the string corresponds to the token constant name (e.g. for the
-// token IDENT, the string is "IDENT").
-//
-func (tok Token) String() string {
- s := ""
- if 0 <= tok && tok < Token(len(tokens)) {
- s = tokens[tok]
- }
- if s == "" {
- s = "token(" + strconv.Itoa(int(tok)) + ")"
- }
- return s
-}
-
-// Predicates
-
-// IsLiteral returns true for tokens corresponding to identifiers
-// and basic type literals; it returns false otherwise.
-//
-func (tok Token) IsLiteral() bool { return literal_beg < tok && tok < literal_end }
-
-// IsOperator returns true for tokens corresponding to operators and
-// delimiters; it returns false otherwise.
-//
-func (tok Token) IsOperator() bool { return operator_beg < tok && tok < operator_end }
diff --git a/vendor/github.com/src-d/gcfg/types/bool.go b/vendor/github.com/src-d/gcfg/types/bool.go
deleted file mode 100644
index 8dcae0d8cfd1dfc115e9234d87ea7f7c5246ba71..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/types/bool.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package types
-
-// BoolValues defines the name and value mappings for ParseBool.
-var BoolValues = map[string]interface{}{
- "true": true, "yes": true, "on": true, "1": true,
- "false": false, "no": false, "off": false, "0": false,
-}
-
-var boolParser = func() *EnumParser {
- ep := &EnumParser{}
- ep.AddVals(BoolValues)
- return ep
-}()
-
-// ParseBool parses bool values according to the definitions in BoolValues.
-// Parsing is case-insensitive.
-func ParseBool(s string) (bool, error) {
- v, err := boolParser.Parse(s)
- if err != nil {
- return false, err
- }
- return v.(bool), nil
-}
diff --git a/vendor/github.com/src-d/gcfg/types/doc.go b/vendor/github.com/src-d/gcfg/types/doc.go
deleted file mode 100644
index 9f9c345f6eab92e782476eef2a0319e7fd85710f..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/types/doc.go
+++ /dev/null
@@ -1,4 +0,0 @@
-// Package types defines helpers for type conversions.
-//
-// The API for this package is not finalized yet.
-package types
diff --git a/vendor/github.com/src-d/gcfg/types/enum.go b/vendor/github.com/src-d/gcfg/types/enum.go
deleted file mode 100644
index 1a0c7ef453dbacf08ddfa05f898c3149734da1ea..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/types/enum.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package types
-
-import (
- "fmt"
- "reflect"
- "strings"
-)
-
-// EnumParser parses "enum" values; i.e. a predefined set of strings to
-// predefined values.
-type EnumParser struct {
- Type string // type name; if not set, use type of first value added
- CaseMatch bool // if true, matching of strings is case-sensitive
- // PrefixMatch bool
- vals map[string]interface{}
-}
-
-// AddVals adds strings and values to an EnumParser.
-func (ep *EnumParser) AddVals(vals map[string]interface{}) {
- if ep.vals == nil {
- ep.vals = make(map[string]interface{})
- }
- for k, v := range vals {
- if ep.Type == "" {
- ep.Type = reflect.TypeOf(v).Name()
- }
- if !ep.CaseMatch {
- k = strings.ToLower(k)
- }
- ep.vals[k] = v
- }
-}
-
-// Parse parses the string and returns the value or an error.
-func (ep EnumParser) Parse(s string) (interface{}, error) {
- if !ep.CaseMatch {
- s = strings.ToLower(s)
- }
- v, ok := ep.vals[s]
- if !ok {
- return false, fmt.Errorf("failed to parse %s %#q", ep.Type, s)
- }
- return v, nil
-}
diff --git a/vendor/github.com/src-d/gcfg/types/int.go b/vendor/github.com/src-d/gcfg/types/int.go
deleted file mode 100644
index af7e75c1250c5a15c5b7dc0eaa4b330c3d0cb1b7..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/types/int.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package types
-
-import (
- "fmt"
- "strings"
-)
-
-// An IntMode is a mode for parsing integer values, representing a set of
-// accepted bases.
-type IntMode uint8
-
-// IntMode values for ParseInt; can be combined using binary or.
-const (
- Dec IntMode = 1 << iota
- Hex
- Oct
-)
-
-// String returns a string representation of IntMode; e.g. `IntMode(Dec|Hex)`.
-func (m IntMode) String() string {
- var modes []string
- if m&Dec != 0 {
- modes = append(modes, "Dec")
- }
- if m&Hex != 0 {
- modes = append(modes, "Hex")
- }
- if m&Oct != 0 {
- modes = append(modes, "Oct")
- }
- return "IntMode(" + strings.Join(modes, "|") + ")"
-}
-
-var errIntAmbig = fmt.Errorf("ambiguous integer value; must include '0' prefix")
-
-func prefix0(val string) bool {
- return strings.HasPrefix(val, "0") || strings.HasPrefix(val, "-0")
-}
-
-func prefix0x(val string) bool {
- return strings.HasPrefix(val, "0x") || strings.HasPrefix(val, "-0x")
-}
-
-// ParseInt parses val using mode into intptr, which must be a pointer to an
-// integer kind type. Non-decimal value require prefix `0` or `0x` in the cases
-// when mode permits ambiguity of base; otherwise the prefix can be omitted.
-func ParseInt(intptr interface{}, val string, mode IntMode) error {
- val = strings.TrimSpace(val)
- verb := byte(0)
- switch mode {
- case Dec:
- verb = 'd'
- case Dec + Hex:
- if prefix0x(val) {
- verb = 'v'
- } else {
- verb = 'd'
- }
- case Dec + Oct:
- if prefix0(val) && !prefix0x(val) {
- verb = 'v'
- } else {
- verb = 'd'
- }
- case Dec + Hex + Oct:
- verb = 'v'
- case Hex:
- if prefix0x(val) {
- verb = 'v'
- } else {
- verb = 'x'
- }
- case Oct:
- verb = 'o'
- case Hex + Oct:
- if prefix0(val) {
- verb = 'v'
- } else {
- return errIntAmbig
- }
- }
- if verb == 0 {
- panic("unsupported mode")
- }
- return ScanFully(intptr, val, verb)
-}
diff --git a/vendor/github.com/src-d/gcfg/types/scan.go b/vendor/github.com/src-d/gcfg/types/scan.go
deleted file mode 100644
index db2f6ed3caf622ce811c5d31b64b73d3bfe2f4c3..0000000000000000000000000000000000000000
--- a/vendor/github.com/src-d/gcfg/types/scan.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package types
-
-import (
- "fmt"
- "io"
- "reflect"
-)
-
-// ScanFully uses fmt.Sscanf with verb to fully scan val into ptr.
-func ScanFully(ptr interface{}, val string, verb byte) error {
- t := reflect.ValueOf(ptr).Elem().Type()
- // attempt to read extra bytes to make sure the value is consumed
- var b []byte
- n, err := fmt.Sscanf(val, "%"+string(verb)+"%s", ptr, &b)
- switch {
- case n < 1 || n == 1 && err != io.EOF:
- return fmt.Errorf("failed to parse %q as %v: %v", val, t, err)
- case n > 1:
- return fmt.Errorf("failed to parse %q as %v: extra characters %q", val, t, string(b))
- }
- // n == 1 && err == io.EOF
- return nil
-}
diff --git a/vendor/golang.org/x/crypto/LICENSE b/vendor/golang.org/x/crypto/LICENSE
deleted file mode 100644
index 6a66aea5eafe0ca6a688840c47219556c552488e..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
- * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/crypto/PATENTS b/vendor/golang.org/x/crypto/PATENTS
deleted file mode 100644
index 733099041f84fa1e58611ab2e11af51c1f26d1d2..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the Go project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of Go, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of Go. This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation. If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of Go or any code incorporated within this
-implementation of Go constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of Go
-shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/crypto/curve25519/const_amd64.h b/vendor/golang.org/x/crypto/curve25519/const_amd64.h
deleted file mode 100644
index 80ad2220fde81cee134b1a018b6ffcc90868d183..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/const_amd64.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-#define REDMASK51 0x0007FFFFFFFFFFFF
diff --git a/vendor/golang.org/x/crypto/curve25519/const_amd64.s b/vendor/golang.org/x/crypto/curve25519/const_amd64.s
deleted file mode 100644
index 0ad539885b7bad7cc5b3c70fdeaf5e344d1e65d8..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/const_amd64.s
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-// These constants cannot be encoded in non-MOVQ immediates.
-// We access them directly from memory instead.
-
-DATA ·_121666_213(SB)/8, $996687872
-GLOBL ·_121666_213(SB), 8, $8
-
-DATA ·_2P0(SB)/8, $0xFFFFFFFFFFFDA
-GLOBL ·_2P0(SB), 8, $8
-
-DATA ·_2P1234(SB)/8, $0xFFFFFFFFFFFFE
-GLOBL ·_2P1234(SB), 8, $8
diff --git a/vendor/golang.org/x/crypto/curve25519/cswap_amd64.s b/vendor/golang.org/x/crypto/curve25519/cswap_amd64.s
deleted file mode 100644
index 45484d1b596f07092c1db2f3b33bdb13dd95551d..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/cswap_amd64.s
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-// func cswap(inout *[5]uint64, v uint64)
-TEXT ·cswap(SB),7,$0
- MOVQ inout+0(FP),DI
- MOVQ v+8(FP),SI
-
- CMPQ SI,$1
- MOVQ 0(DI),SI
- MOVQ 80(DI),DX
- MOVQ 8(DI),CX
- MOVQ 88(DI),R8
- MOVQ SI,R9
- CMOVQEQ DX,SI
- CMOVQEQ R9,DX
- MOVQ CX,R9
- CMOVQEQ R8,CX
- CMOVQEQ R9,R8
- MOVQ SI,0(DI)
- MOVQ DX,80(DI)
- MOVQ CX,8(DI)
- MOVQ R8,88(DI)
- MOVQ 16(DI),SI
- MOVQ 96(DI),DX
- MOVQ 24(DI),CX
- MOVQ 104(DI),R8
- MOVQ SI,R9
- CMOVQEQ DX,SI
- CMOVQEQ R9,DX
- MOVQ CX,R9
- CMOVQEQ R8,CX
- CMOVQEQ R9,R8
- MOVQ SI,16(DI)
- MOVQ DX,96(DI)
- MOVQ CX,24(DI)
- MOVQ R8,104(DI)
- MOVQ 32(DI),SI
- MOVQ 112(DI),DX
- MOVQ 40(DI),CX
- MOVQ 120(DI),R8
- MOVQ SI,R9
- CMOVQEQ DX,SI
- CMOVQEQ R9,DX
- MOVQ CX,R9
- CMOVQEQ R8,CX
- CMOVQEQ R9,R8
- MOVQ SI,32(DI)
- MOVQ DX,112(DI)
- MOVQ CX,40(DI)
- MOVQ R8,120(DI)
- MOVQ 48(DI),SI
- MOVQ 128(DI),DX
- MOVQ 56(DI),CX
- MOVQ 136(DI),R8
- MOVQ SI,R9
- CMOVQEQ DX,SI
- CMOVQEQ R9,DX
- MOVQ CX,R9
- CMOVQEQ R8,CX
- CMOVQEQ R9,R8
- MOVQ SI,48(DI)
- MOVQ DX,128(DI)
- MOVQ CX,56(DI)
- MOVQ R8,136(DI)
- MOVQ 64(DI),SI
- MOVQ 144(DI),DX
- MOVQ 72(DI),CX
- MOVQ 152(DI),R8
- MOVQ SI,R9
- CMOVQEQ DX,SI
- CMOVQEQ R9,DX
- MOVQ CX,R9
- CMOVQEQ R8,CX
- CMOVQEQ R9,R8
- MOVQ SI,64(DI)
- MOVQ DX,144(DI)
- MOVQ CX,72(DI)
- MOVQ R8,152(DI)
- MOVQ DI,AX
- MOVQ SI,DX
- RET
diff --git a/vendor/golang.org/x/crypto/curve25519/curve25519.go b/vendor/golang.org/x/crypto/curve25519/curve25519.go
deleted file mode 100644
index 6918c47fc2eceeaf07a08dc0251efcb2e9af5958..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/curve25519.go
+++ /dev/null
@@ -1,841 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// We have a implementation in amd64 assembly so this code is only run on
-// non-amd64 platforms. The amd64 assembly does not support gccgo.
-// +build !amd64 gccgo appengine
-
-package curve25519
-
-// This code is a port of the public domain, "ref10" implementation of
-// curve25519 from SUPERCOP 20130419 by D. J. Bernstein.
-
-// fieldElement represents an element of the field GF(2^255 - 19). An element
-// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
-// t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on
-// context.
-type fieldElement [10]int32
-
-func feZero(fe *fieldElement) {
- for i := range fe {
- fe[i] = 0
- }
-}
-
-func feOne(fe *fieldElement) {
- feZero(fe)
- fe[0] = 1
-}
-
-func feAdd(dst, a, b *fieldElement) {
- for i := range dst {
- dst[i] = a[i] + b[i]
- }
-}
-
-func feSub(dst, a, b *fieldElement) {
- for i := range dst {
- dst[i] = a[i] - b[i]
- }
-}
-
-func feCopy(dst, src *fieldElement) {
- for i := range dst {
- dst[i] = src[i]
- }
-}
-
-// feCSwap replaces (f,g) with (g,f) if b == 1; replaces (f,g) with (f,g) if b == 0.
-//
-// Preconditions: b in {0,1}.
-func feCSwap(f, g *fieldElement, b int32) {
- var x fieldElement
- b = -b
- for i := range x {
- x[i] = b & (f[i] ^ g[i])
- }
-
- for i := range f {
- f[i] ^= x[i]
- }
- for i := range g {
- g[i] ^= x[i]
- }
-}
-
-// load3 reads a 24-bit, little-endian value from in.
-func load3(in []byte) int64 {
- var r int64
- r = int64(in[0])
- r |= int64(in[1]) << 8
- r |= int64(in[2]) << 16
- return r
-}
-
-// load4 reads a 32-bit, little-endian value from in.
-func load4(in []byte) int64 {
- var r int64
- r = int64(in[0])
- r |= int64(in[1]) << 8
- r |= int64(in[2]) << 16
- r |= int64(in[3]) << 24
- return r
-}
-
-func feFromBytes(dst *fieldElement, src *[32]byte) {
- h0 := load4(src[:])
- h1 := load3(src[4:]) << 6
- h2 := load3(src[7:]) << 5
- h3 := load3(src[10:]) << 3
- h4 := load3(src[13:]) << 2
- h5 := load4(src[16:])
- h6 := load3(src[20:]) << 7
- h7 := load3(src[23:]) << 5
- h8 := load3(src[26:]) << 4
- h9 := load3(src[29:]) << 2
-
- var carry [10]int64
- carry[9] = (h9 + 1<<24) >> 25
- h0 += carry[9] * 19
- h9 -= carry[9] << 25
- carry[1] = (h1 + 1<<24) >> 25
- h2 += carry[1]
- h1 -= carry[1] << 25
- carry[3] = (h3 + 1<<24) >> 25
- h4 += carry[3]
- h3 -= carry[3] << 25
- carry[5] = (h5 + 1<<24) >> 25
- h6 += carry[5]
- h5 -= carry[5] << 25
- carry[7] = (h7 + 1<<24) >> 25
- h8 += carry[7]
- h7 -= carry[7] << 25
-
- carry[0] = (h0 + 1<<25) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
- carry[2] = (h2 + 1<<25) >> 26
- h3 += carry[2]
- h2 -= carry[2] << 26
- carry[4] = (h4 + 1<<25) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
- carry[6] = (h6 + 1<<25) >> 26
- h7 += carry[6]
- h6 -= carry[6] << 26
- carry[8] = (h8 + 1<<25) >> 26
- h9 += carry[8]
- h8 -= carry[8] << 26
-
- dst[0] = int32(h0)
- dst[1] = int32(h1)
- dst[2] = int32(h2)
- dst[3] = int32(h3)
- dst[4] = int32(h4)
- dst[5] = int32(h5)
- dst[6] = int32(h6)
- dst[7] = int32(h7)
- dst[8] = int32(h8)
- dst[9] = int32(h9)
-}
-
-// feToBytes marshals h to s.
-// Preconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Write p=2^255-19; q=floor(h/p).
-// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
-//
-// Proof:
-// Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
-// Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
-//
-// Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
-// Then 0<y<1.
-//
-// Write r=h-pq.
-// Have 0<=r<=p-1=2^255-20.
-// Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
-//
-// Write x=r+19(2^-255)r+y.
-// Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
-//
-// Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
-// so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
-func feToBytes(s *[32]byte, h *fieldElement) {
- var carry [10]int32
-
- q := (19*h[9] + (1 << 24)) >> 25
- q = (h[0] + q) >> 26
- q = (h[1] + q) >> 25
- q = (h[2] + q) >> 26
- q = (h[3] + q) >> 25
- q = (h[4] + q) >> 26
- q = (h[5] + q) >> 25
- q = (h[6] + q) >> 26
- q = (h[7] + q) >> 25
- q = (h[8] + q) >> 26
- q = (h[9] + q) >> 25
-
- // Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
- h[0] += 19 * q
- // Goal: Output h-2^255 q, which is between 0 and 2^255-20.
-
- carry[0] = h[0] >> 26
- h[1] += carry[0]
- h[0] -= carry[0] << 26
- carry[1] = h[1] >> 25
- h[2] += carry[1]
- h[1] -= carry[1] << 25
- carry[2] = h[2] >> 26
- h[3] += carry[2]
- h[2] -= carry[2] << 26
- carry[3] = h[3] >> 25
- h[4] += carry[3]
- h[3] -= carry[3] << 25
- carry[4] = h[4] >> 26
- h[5] += carry[4]
- h[4] -= carry[4] << 26
- carry[5] = h[5] >> 25
- h[6] += carry[5]
- h[5] -= carry[5] << 25
- carry[6] = h[6] >> 26
- h[7] += carry[6]
- h[6] -= carry[6] << 26
- carry[7] = h[7] >> 25
- h[8] += carry[7]
- h[7] -= carry[7] << 25
- carry[8] = h[8] >> 26
- h[9] += carry[8]
- h[8] -= carry[8] << 26
- carry[9] = h[9] >> 25
- h[9] -= carry[9] << 25
- // h10 = carry9
-
- // Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
- // Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
- // evidently 2^255 h10-2^255 q = 0.
- // Goal: Output h[0]+...+2^230 h[9].
-
- s[0] = byte(h[0] >> 0)
- s[1] = byte(h[0] >> 8)
- s[2] = byte(h[0] >> 16)
- s[3] = byte((h[0] >> 24) | (h[1] << 2))
- s[4] = byte(h[1] >> 6)
- s[5] = byte(h[1] >> 14)
- s[6] = byte((h[1] >> 22) | (h[2] << 3))
- s[7] = byte(h[2] >> 5)
- s[8] = byte(h[2] >> 13)
- s[9] = byte((h[2] >> 21) | (h[3] << 5))
- s[10] = byte(h[3] >> 3)
- s[11] = byte(h[3] >> 11)
- s[12] = byte((h[3] >> 19) | (h[4] << 6))
- s[13] = byte(h[4] >> 2)
- s[14] = byte(h[4] >> 10)
- s[15] = byte(h[4] >> 18)
- s[16] = byte(h[5] >> 0)
- s[17] = byte(h[5] >> 8)
- s[18] = byte(h[5] >> 16)
- s[19] = byte((h[5] >> 24) | (h[6] << 1))
- s[20] = byte(h[6] >> 7)
- s[21] = byte(h[6] >> 15)
- s[22] = byte((h[6] >> 23) | (h[7] << 3))
- s[23] = byte(h[7] >> 5)
- s[24] = byte(h[7] >> 13)
- s[25] = byte((h[7] >> 21) | (h[8] << 4))
- s[26] = byte(h[8] >> 4)
- s[27] = byte(h[8] >> 12)
- s[28] = byte((h[8] >> 20) | (h[9] << 6))
- s[29] = byte(h[9] >> 2)
- s[30] = byte(h[9] >> 10)
- s[31] = byte(h[9] >> 18)
-}
-
-// feMul calculates h = f * g
-// Can overlap h with f or g.
-//
-// Preconditions:
-// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-// |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Notes on implementation strategy:
-//
-// Using schoolbook multiplication.
-// Karatsuba would save a little in some cost models.
-//
-// Most multiplications by 2 and 19 are 32-bit precomputations;
-// cheaper than 64-bit postcomputations.
-//
-// There is one remaining multiplication by 19 in the carry chain;
-// one *19 precomputation can be merged into this,
-// but the resulting data flow is considerably less clean.
-//
-// There are 12 carries below.
-// 10 of them are 2-way parallelizable and vectorizable.
-// Can get away with 11 carries, but then data flow is much deeper.
-//
-// With tighter constraints on inputs can squeeze carries into int32.
-func feMul(h, f, g *fieldElement) {
- f0 := f[0]
- f1 := f[1]
- f2 := f[2]
- f3 := f[3]
- f4 := f[4]
- f5 := f[5]
- f6 := f[6]
- f7 := f[7]
- f8 := f[8]
- f9 := f[9]
- g0 := g[0]
- g1 := g[1]
- g2 := g[2]
- g3 := g[3]
- g4 := g[4]
- g5 := g[5]
- g6 := g[6]
- g7 := g[7]
- g8 := g[8]
- g9 := g[9]
- g1_19 := 19 * g1 // 1.4*2^29
- g2_19 := 19 * g2 // 1.4*2^30; still ok
- g3_19 := 19 * g3
- g4_19 := 19 * g4
- g5_19 := 19 * g5
- g6_19 := 19 * g6
- g7_19 := 19 * g7
- g8_19 := 19 * g8
- g9_19 := 19 * g9
- f1_2 := 2 * f1
- f3_2 := 2 * f3
- f5_2 := 2 * f5
- f7_2 := 2 * f7
- f9_2 := 2 * f9
- f0g0 := int64(f0) * int64(g0)
- f0g1 := int64(f0) * int64(g1)
- f0g2 := int64(f0) * int64(g2)
- f0g3 := int64(f0) * int64(g3)
- f0g4 := int64(f0) * int64(g4)
- f0g5 := int64(f0) * int64(g5)
- f0g6 := int64(f0) * int64(g6)
- f0g7 := int64(f0) * int64(g7)
- f0g8 := int64(f0) * int64(g8)
- f0g9 := int64(f0) * int64(g9)
- f1g0 := int64(f1) * int64(g0)
- f1g1_2 := int64(f1_2) * int64(g1)
- f1g2 := int64(f1) * int64(g2)
- f1g3_2 := int64(f1_2) * int64(g3)
- f1g4 := int64(f1) * int64(g4)
- f1g5_2 := int64(f1_2) * int64(g5)
- f1g6 := int64(f1) * int64(g6)
- f1g7_2 := int64(f1_2) * int64(g7)
- f1g8 := int64(f1) * int64(g8)
- f1g9_38 := int64(f1_2) * int64(g9_19)
- f2g0 := int64(f2) * int64(g0)
- f2g1 := int64(f2) * int64(g1)
- f2g2 := int64(f2) * int64(g2)
- f2g3 := int64(f2) * int64(g3)
- f2g4 := int64(f2) * int64(g4)
- f2g5 := int64(f2) * int64(g5)
- f2g6 := int64(f2) * int64(g6)
- f2g7 := int64(f2) * int64(g7)
- f2g8_19 := int64(f2) * int64(g8_19)
- f2g9_19 := int64(f2) * int64(g9_19)
- f3g0 := int64(f3) * int64(g0)
- f3g1_2 := int64(f3_2) * int64(g1)
- f3g2 := int64(f3) * int64(g2)
- f3g3_2 := int64(f3_2) * int64(g3)
- f3g4 := int64(f3) * int64(g4)
- f3g5_2 := int64(f3_2) * int64(g5)
- f3g6 := int64(f3) * int64(g6)
- f3g7_38 := int64(f3_2) * int64(g7_19)
- f3g8_19 := int64(f3) * int64(g8_19)
- f3g9_38 := int64(f3_2) * int64(g9_19)
- f4g0 := int64(f4) * int64(g0)
- f4g1 := int64(f4) * int64(g1)
- f4g2 := int64(f4) * int64(g2)
- f4g3 := int64(f4) * int64(g3)
- f4g4 := int64(f4) * int64(g4)
- f4g5 := int64(f4) * int64(g5)
- f4g6_19 := int64(f4) * int64(g6_19)
- f4g7_19 := int64(f4) * int64(g7_19)
- f4g8_19 := int64(f4) * int64(g8_19)
- f4g9_19 := int64(f4) * int64(g9_19)
- f5g0 := int64(f5) * int64(g0)
- f5g1_2 := int64(f5_2) * int64(g1)
- f5g2 := int64(f5) * int64(g2)
- f5g3_2 := int64(f5_2) * int64(g3)
- f5g4 := int64(f5) * int64(g4)
- f5g5_38 := int64(f5_2) * int64(g5_19)
- f5g6_19 := int64(f5) * int64(g6_19)
- f5g7_38 := int64(f5_2) * int64(g7_19)
- f5g8_19 := int64(f5) * int64(g8_19)
- f5g9_38 := int64(f5_2) * int64(g9_19)
- f6g0 := int64(f6) * int64(g0)
- f6g1 := int64(f6) * int64(g1)
- f6g2 := int64(f6) * int64(g2)
- f6g3 := int64(f6) * int64(g3)
- f6g4_19 := int64(f6) * int64(g4_19)
- f6g5_19 := int64(f6) * int64(g5_19)
- f6g6_19 := int64(f6) * int64(g6_19)
- f6g7_19 := int64(f6) * int64(g7_19)
- f6g8_19 := int64(f6) * int64(g8_19)
- f6g9_19 := int64(f6) * int64(g9_19)
- f7g0 := int64(f7) * int64(g0)
- f7g1_2 := int64(f7_2) * int64(g1)
- f7g2 := int64(f7) * int64(g2)
- f7g3_38 := int64(f7_2) * int64(g3_19)
- f7g4_19 := int64(f7) * int64(g4_19)
- f7g5_38 := int64(f7_2) * int64(g5_19)
- f7g6_19 := int64(f7) * int64(g6_19)
- f7g7_38 := int64(f7_2) * int64(g7_19)
- f7g8_19 := int64(f7) * int64(g8_19)
- f7g9_38 := int64(f7_2) * int64(g9_19)
- f8g0 := int64(f8) * int64(g0)
- f8g1 := int64(f8) * int64(g1)
- f8g2_19 := int64(f8) * int64(g2_19)
- f8g3_19 := int64(f8) * int64(g3_19)
- f8g4_19 := int64(f8) * int64(g4_19)
- f8g5_19 := int64(f8) * int64(g5_19)
- f8g6_19 := int64(f8) * int64(g6_19)
- f8g7_19 := int64(f8) * int64(g7_19)
- f8g8_19 := int64(f8) * int64(g8_19)
- f8g9_19 := int64(f8) * int64(g9_19)
- f9g0 := int64(f9) * int64(g0)
- f9g1_38 := int64(f9_2) * int64(g1_19)
- f9g2_19 := int64(f9) * int64(g2_19)
- f9g3_38 := int64(f9_2) * int64(g3_19)
- f9g4_19 := int64(f9) * int64(g4_19)
- f9g5_38 := int64(f9_2) * int64(g5_19)
- f9g6_19 := int64(f9) * int64(g6_19)
- f9g7_38 := int64(f9_2) * int64(g7_19)
- f9g8_19 := int64(f9) * int64(g8_19)
- f9g9_38 := int64(f9_2) * int64(g9_19)
- h0 := f0g0 + f1g9_38 + f2g8_19 + f3g7_38 + f4g6_19 + f5g5_38 + f6g4_19 + f7g3_38 + f8g2_19 + f9g1_38
- h1 := f0g1 + f1g0 + f2g9_19 + f3g8_19 + f4g7_19 + f5g6_19 + f6g5_19 + f7g4_19 + f8g3_19 + f9g2_19
- h2 := f0g2 + f1g1_2 + f2g0 + f3g9_38 + f4g8_19 + f5g7_38 + f6g6_19 + f7g5_38 + f8g4_19 + f9g3_38
- h3 := f0g3 + f1g2 + f2g1 + f3g0 + f4g9_19 + f5g8_19 + f6g7_19 + f7g6_19 + f8g5_19 + f9g4_19
- h4 := f0g4 + f1g3_2 + f2g2 + f3g1_2 + f4g0 + f5g9_38 + f6g8_19 + f7g7_38 + f8g6_19 + f9g5_38
- h5 := f0g5 + f1g4 + f2g3 + f3g2 + f4g1 + f5g0 + f6g9_19 + f7g8_19 + f8g7_19 + f9g6_19
- h6 := f0g6 + f1g5_2 + f2g4 + f3g3_2 + f4g2 + f5g1_2 + f6g0 + f7g9_38 + f8g8_19 + f9g7_38
- h7 := f0g7 + f1g6 + f2g5 + f3g4 + f4g3 + f5g2 + f6g1 + f7g0 + f8g9_19 + f9g8_19
- h8 := f0g8 + f1g7_2 + f2g6 + f3g5_2 + f4g4 + f5g3_2 + f6g2 + f7g1_2 + f8g0 + f9g9_38
- h9 := f0g9 + f1g8 + f2g7 + f3g6 + f4g5 + f5g4 + f6g3 + f7g2 + f8g1 + f9g0
- var carry [10]int64
-
- // |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
- // i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
- // |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
- // i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
-
- carry[0] = (h0 + (1 << 25)) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
- carry[4] = (h4 + (1 << 25)) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
- // |h0| <= 2^25
- // |h4| <= 2^25
- // |h1| <= 1.51*2^58
- // |h5| <= 1.51*2^58
-
- carry[1] = (h1 + (1 << 24)) >> 25
- h2 += carry[1]
- h1 -= carry[1] << 25
- carry[5] = (h5 + (1 << 24)) >> 25
- h6 += carry[5]
- h5 -= carry[5] << 25
- // |h1| <= 2^24; from now on fits into int32
- // |h5| <= 2^24; from now on fits into int32
- // |h2| <= 1.21*2^59
- // |h6| <= 1.21*2^59
-
- carry[2] = (h2 + (1 << 25)) >> 26
- h3 += carry[2]
- h2 -= carry[2] << 26
- carry[6] = (h6 + (1 << 25)) >> 26
- h7 += carry[6]
- h6 -= carry[6] << 26
- // |h2| <= 2^25; from now on fits into int32 unchanged
- // |h6| <= 2^25; from now on fits into int32 unchanged
- // |h3| <= 1.51*2^58
- // |h7| <= 1.51*2^58
-
- carry[3] = (h3 + (1 << 24)) >> 25
- h4 += carry[3]
- h3 -= carry[3] << 25
- carry[7] = (h7 + (1 << 24)) >> 25
- h8 += carry[7]
- h7 -= carry[7] << 25
- // |h3| <= 2^24; from now on fits into int32 unchanged
- // |h7| <= 2^24; from now on fits into int32 unchanged
- // |h4| <= 1.52*2^33
- // |h8| <= 1.52*2^33
-
- carry[4] = (h4 + (1 << 25)) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
- carry[8] = (h8 + (1 << 25)) >> 26
- h9 += carry[8]
- h8 -= carry[8] << 26
- // |h4| <= 2^25; from now on fits into int32 unchanged
- // |h8| <= 2^25; from now on fits into int32 unchanged
- // |h5| <= 1.01*2^24
- // |h9| <= 1.51*2^58
-
- carry[9] = (h9 + (1 << 24)) >> 25
- h0 += carry[9] * 19
- h9 -= carry[9] << 25
- // |h9| <= 2^24; from now on fits into int32 unchanged
- // |h0| <= 1.8*2^37
-
- carry[0] = (h0 + (1 << 25)) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
- // |h0| <= 2^25; from now on fits into int32 unchanged
- // |h1| <= 1.01*2^24
-
- h[0] = int32(h0)
- h[1] = int32(h1)
- h[2] = int32(h2)
- h[3] = int32(h3)
- h[4] = int32(h4)
- h[5] = int32(h5)
- h[6] = int32(h6)
- h[7] = int32(h7)
- h[8] = int32(h8)
- h[9] = int32(h9)
-}
-
-// feSquare calculates h = f*f. Can overlap h with f.
-//
-// Preconditions:
-// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func feSquare(h, f *fieldElement) {
- f0 := f[0]
- f1 := f[1]
- f2 := f[2]
- f3 := f[3]
- f4 := f[4]
- f5 := f[5]
- f6 := f[6]
- f7 := f[7]
- f8 := f[8]
- f9 := f[9]
- f0_2 := 2 * f0
- f1_2 := 2 * f1
- f2_2 := 2 * f2
- f3_2 := 2 * f3
- f4_2 := 2 * f4
- f5_2 := 2 * f5
- f6_2 := 2 * f6
- f7_2 := 2 * f7
- f5_38 := 38 * f5 // 1.31*2^30
- f6_19 := 19 * f6 // 1.31*2^30
- f7_38 := 38 * f7 // 1.31*2^30
- f8_19 := 19 * f8 // 1.31*2^30
- f9_38 := 38 * f9 // 1.31*2^30
- f0f0 := int64(f0) * int64(f0)
- f0f1_2 := int64(f0_2) * int64(f1)
- f0f2_2 := int64(f0_2) * int64(f2)
- f0f3_2 := int64(f0_2) * int64(f3)
- f0f4_2 := int64(f0_2) * int64(f4)
- f0f5_2 := int64(f0_2) * int64(f5)
- f0f6_2 := int64(f0_2) * int64(f6)
- f0f7_2 := int64(f0_2) * int64(f7)
- f0f8_2 := int64(f0_2) * int64(f8)
- f0f9_2 := int64(f0_2) * int64(f9)
- f1f1_2 := int64(f1_2) * int64(f1)
- f1f2_2 := int64(f1_2) * int64(f2)
- f1f3_4 := int64(f1_2) * int64(f3_2)
- f1f4_2 := int64(f1_2) * int64(f4)
- f1f5_4 := int64(f1_2) * int64(f5_2)
- f1f6_2 := int64(f1_2) * int64(f6)
- f1f7_4 := int64(f1_2) * int64(f7_2)
- f1f8_2 := int64(f1_2) * int64(f8)
- f1f9_76 := int64(f1_2) * int64(f9_38)
- f2f2 := int64(f2) * int64(f2)
- f2f3_2 := int64(f2_2) * int64(f3)
- f2f4_2 := int64(f2_2) * int64(f4)
- f2f5_2 := int64(f2_2) * int64(f5)
- f2f6_2 := int64(f2_2) * int64(f6)
- f2f7_2 := int64(f2_2) * int64(f7)
- f2f8_38 := int64(f2_2) * int64(f8_19)
- f2f9_38 := int64(f2) * int64(f9_38)
- f3f3_2 := int64(f3_2) * int64(f3)
- f3f4_2 := int64(f3_2) * int64(f4)
- f3f5_4 := int64(f3_2) * int64(f5_2)
- f3f6_2 := int64(f3_2) * int64(f6)
- f3f7_76 := int64(f3_2) * int64(f7_38)
- f3f8_38 := int64(f3_2) * int64(f8_19)
- f3f9_76 := int64(f3_2) * int64(f9_38)
- f4f4 := int64(f4) * int64(f4)
- f4f5_2 := int64(f4_2) * int64(f5)
- f4f6_38 := int64(f4_2) * int64(f6_19)
- f4f7_38 := int64(f4) * int64(f7_38)
- f4f8_38 := int64(f4_2) * int64(f8_19)
- f4f9_38 := int64(f4) * int64(f9_38)
- f5f5_38 := int64(f5) * int64(f5_38)
- f5f6_38 := int64(f5_2) * int64(f6_19)
- f5f7_76 := int64(f5_2) * int64(f7_38)
- f5f8_38 := int64(f5_2) * int64(f8_19)
- f5f9_76 := int64(f5_2) * int64(f9_38)
- f6f6_19 := int64(f6) * int64(f6_19)
- f6f7_38 := int64(f6) * int64(f7_38)
- f6f8_38 := int64(f6_2) * int64(f8_19)
- f6f9_38 := int64(f6) * int64(f9_38)
- f7f7_38 := int64(f7) * int64(f7_38)
- f7f8_38 := int64(f7_2) * int64(f8_19)
- f7f9_76 := int64(f7_2) * int64(f9_38)
- f8f8_19 := int64(f8) * int64(f8_19)
- f8f9_38 := int64(f8) * int64(f9_38)
- f9f9_38 := int64(f9) * int64(f9_38)
- h0 := f0f0 + f1f9_76 + f2f8_38 + f3f7_76 + f4f6_38 + f5f5_38
- h1 := f0f1_2 + f2f9_38 + f3f8_38 + f4f7_38 + f5f6_38
- h2 := f0f2_2 + f1f1_2 + f3f9_76 + f4f8_38 + f5f7_76 + f6f6_19
- h3 := f0f3_2 + f1f2_2 + f4f9_38 + f5f8_38 + f6f7_38
- h4 := f0f4_2 + f1f3_4 + f2f2 + f5f9_76 + f6f8_38 + f7f7_38
- h5 := f0f5_2 + f1f4_2 + f2f3_2 + f6f9_38 + f7f8_38
- h6 := f0f6_2 + f1f5_4 + f2f4_2 + f3f3_2 + f7f9_76 + f8f8_19
- h7 := f0f7_2 + f1f6_2 + f2f5_2 + f3f4_2 + f8f9_38
- h8 := f0f8_2 + f1f7_4 + f2f6_2 + f3f5_4 + f4f4 + f9f9_38
- h9 := f0f9_2 + f1f8_2 + f2f7_2 + f3f6_2 + f4f5_2
- var carry [10]int64
-
- carry[0] = (h0 + (1 << 25)) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
- carry[4] = (h4 + (1 << 25)) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
-
- carry[1] = (h1 + (1 << 24)) >> 25
- h2 += carry[1]
- h1 -= carry[1] << 25
- carry[5] = (h5 + (1 << 24)) >> 25
- h6 += carry[5]
- h5 -= carry[5] << 25
-
- carry[2] = (h2 + (1 << 25)) >> 26
- h3 += carry[2]
- h2 -= carry[2] << 26
- carry[6] = (h6 + (1 << 25)) >> 26
- h7 += carry[6]
- h6 -= carry[6] << 26
-
- carry[3] = (h3 + (1 << 24)) >> 25
- h4 += carry[3]
- h3 -= carry[3] << 25
- carry[7] = (h7 + (1 << 24)) >> 25
- h8 += carry[7]
- h7 -= carry[7] << 25
-
- carry[4] = (h4 + (1 << 25)) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
- carry[8] = (h8 + (1 << 25)) >> 26
- h9 += carry[8]
- h8 -= carry[8] << 26
-
- carry[9] = (h9 + (1 << 24)) >> 25
- h0 += carry[9] * 19
- h9 -= carry[9] << 25
-
- carry[0] = (h0 + (1 << 25)) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
-
- h[0] = int32(h0)
- h[1] = int32(h1)
- h[2] = int32(h2)
- h[3] = int32(h3)
- h[4] = int32(h4)
- h[5] = int32(h5)
- h[6] = int32(h6)
- h[7] = int32(h7)
- h[8] = int32(h8)
- h[9] = int32(h9)
-}
-
-// feMul121666 calculates h = f * 121666. Can overlap h with f.
-//
-// Preconditions:
-// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func feMul121666(h, f *fieldElement) {
- h0 := int64(f[0]) * 121666
- h1 := int64(f[1]) * 121666
- h2 := int64(f[2]) * 121666
- h3 := int64(f[3]) * 121666
- h4 := int64(f[4]) * 121666
- h5 := int64(f[5]) * 121666
- h6 := int64(f[6]) * 121666
- h7 := int64(f[7]) * 121666
- h8 := int64(f[8]) * 121666
- h9 := int64(f[9]) * 121666
- var carry [10]int64
-
- carry[9] = (h9 + (1 << 24)) >> 25
- h0 += carry[9] * 19
- h9 -= carry[9] << 25
- carry[1] = (h1 + (1 << 24)) >> 25
- h2 += carry[1]
- h1 -= carry[1] << 25
- carry[3] = (h3 + (1 << 24)) >> 25
- h4 += carry[3]
- h3 -= carry[3] << 25
- carry[5] = (h5 + (1 << 24)) >> 25
- h6 += carry[5]
- h5 -= carry[5] << 25
- carry[7] = (h7 + (1 << 24)) >> 25
- h8 += carry[7]
- h7 -= carry[7] << 25
-
- carry[0] = (h0 + (1 << 25)) >> 26
- h1 += carry[0]
- h0 -= carry[0] << 26
- carry[2] = (h2 + (1 << 25)) >> 26
- h3 += carry[2]
- h2 -= carry[2] << 26
- carry[4] = (h4 + (1 << 25)) >> 26
- h5 += carry[4]
- h4 -= carry[4] << 26
- carry[6] = (h6 + (1 << 25)) >> 26
- h7 += carry[6]
- h6 -= carry[6] << 26
- carry[8] = (h8 + (1 << 25)) >> 26
- h9 += carry[8]
- h8 -= carry[8] << 26
-
- h[0] = int32(h0)
- h[1] = int32(h1)
- h[2] = int32(h2)
- h[3] = int32(h3)
- h[4] = int32(h4)
- h[5] = int32(h5)
- h[6] = int32(h6)
- h[7] = int32(h7)
- h[8] = int32(h8)
- h[9] = int32(h9)
-}
-
-// feInvert sets out = z^-1.
-func feInvert(out, z *fieldElement) {
- var t0, t1, t2, t3 fieldElement
- var i int
-
- feSquare(&t0, z)
- for i = 1; i < 1; i++ {
- feSquare(&t0, &t0)
- }
- feSquare(&t1, &t0)
- for i = 1; i < 2; i++ {
- feSquare(&t1, &t1)
- }
- feMul(&t1, z, &t1)
- feMul(&t0, &t0, &t1)
- feSquare(&t2, &t0)
- for i = 1; i < 1; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t1, &t1, &t2)
- feSquare(&t2, &t1)
- for i = 1; i < 5; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t1, &t2, &t1)
- feSquare(&t2, &t1)
- for i = 1; i < 10; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t2, &t2, &t1)
- feSquare(&t3, &t2)
- for i = 1; i < 20; i++ {
- feSquare(&t3, &t3)
- }
- feMul(&t2, &t3, &t2)
- feSquare(&t2, &t2)
- for i = 1; i < 10; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t1, &t2, &t1)
- feSquare(&t2, &t1)
- for i = 1; i < 50; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t2, &t2, &t1)
- feSquare(&t3, &t2)
- for i = 1; i < 100; i++ {
- feSquare(&t3, &t3)
- }
- feMul(&t2, &t3, &t2)
- feSquare(&t2, &t2)
- for i = 1; i < 50; i++ {
- feSquare(&t2, &t2)
- }
- feMul(&t1, &t2, &t1)
- feSquare(&t1, &t1)
- for i = 1; i < 5; i++ {
- feSquare(&t1, &t1)
- }
- feMul(out, &t1, &t0)
-}
-
-func scalarMult(out, in, base *[32]byte) {
- var e [32]byte
-
- copy(e[:], in[:])
- e[0] &= 248
- e[31] &= 127
- e[31] |= 64
-
- var x1, x2, z2, x3, z3, tmp0, tmp1 fieldElement
- feFromBytes(&x1, base)
- feOne(&x2)
- feCopy(&x3, &x1)
- feOne(&z3)
-
- swap := int32(0)
- for pos := 254; pos >= 0; pos-- {
- b := e[pos/8] >> uint(pos&7)
- b &= 1
- swap ^= int32(b)
- feCSwap(&x2, &x3, swap)
- feCSwap(&z2, &z3, swap)
- swap = int32(b)
-
- feSub(&tmp0, &x3, &z3)
- feSub(&tmp1, &x2, &z2)
- feAdd(&x2, &x2, &z2)
- feAdd(&z2, &x3, &z3)
- feMul(&z3, &tmp0, &x2)
- feMul(&z2, &z2, &tmp1)
- feSquare(&tmp0, &tmp1)
- feSquare(&tmp1, &x2)
- feAdd(&x3, &z3, &z2)
- feSub(&z2, &z3, &z2)
- feMul(&x2, &tmp1, &tmp0)
- feSub(&tmp1, &tmp1, &tmp0)
- feSquare(&z2, &z2)
- feMul121666(&z3, &tmp1)
- feSquare(&x3, &x3)
- feAdd(&tmp0, &tmp0, &z3)
- feMul(&z3, &x1, &z2)
- feMul(&z2, &tmp1, &tmp0)
- }
-
- feCSwap(&x2, &x3, swap)
- feCSwap(&z2, &z3, swap)
-
- feInvert(&z2, &z2)
- feMul(&x2, &x2, &z2)
- feToBytes(out, &x2)
-}
diff --git a/vendor/golang.org/x/crypto/curve25519/doc.go b/vendor/golang.org/x/crypto/curve25519/doc.go
deleted file mode 100644
index ebeea3c2d6a58be6357daa32d8f54a0cae76cd88..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/doc.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package curve25519 provides an implementation of scalar multiplication on
-// the elliptic curve known as curve25519. See http://cr.yp.to/ecdh.html
-package curve25519 // import "golang.org/x/crypto/curve25519"
-
-// basePoint is the x coordinate of the generator of the curve.
-var basePoint = [32]byte{9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-
-// ScalarMult sets dst to the product in*base where dst and base are the x
-// coordinates of group points and all values are in little-endian form.
-func ScalarMult(dst, in, base *[32]byte) {
- scalarMult(dst, in, base)
-}
-
-// ScalarBaseMult sets dst to the product in*base where dst and base are the x
-// coordinates of group points, base is the standard generator and all values
-// are in little-endian form.
-func ScalarBaseMult(dst, in *[32]byte) {
- ScalarMult(dst, in, &basePoint)
-}
diff --git a/vendor/golang.org/x/crypto/curve25519/freeze_amd64.s b/vendor/golang.org/x/crypto/curve25519/freeze_amd64.s
deleted file mode 100644
index 536479bf626c488fe51eda21e672532fbc56aca1..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/freeze_amd64.s
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-#include "const_amd64.h"
-
-// func freeze(inout *[5]uint64)
-TEXT ·freeze(SB),7,$0-8
- MOVQ inout+0(FP), DI
-
- MOVQ 0(DI),SI
- MOVQ 8(DI),DX
- MOVQ 16(DI),CX
- MOVQ 24(DI),R8
- MOVQ 32(DI),R9
- MOVQ $REDMASK51,AX
- MOVQ AX,R10
- SUBQ $18,R10
- MOVQ $3,R11
-REDUCELOOP:
- MOVQ SI,R12
- SHRQ $51,R12
- ANDQ AX,SI
- ADDQ R12,DX
- MOVQ DX,R12
- SHRQ $51,R12
- ANDQ AX,DX
- ADDQ R12,CX
- MOVQ CX,R12
- SHRQ $51,R12
- ANDQ AX,CX
- ADDQ R12,R8
- MOVQ R8,R12
- SHRQ $51,R12
- ANDQ AX,R8
- ADDQ R12,R9
- MOVQ R9,R12
- SHRQ $51,R12
- ANDQ AX,R9
- IMUL3Q $19,R12,R12
- ADDQ R12,SI
- SUBQ $1,R11
- JA REDUCELOOP
- MOVQ $1,R12
- CMPQ R10,SI
- CMOVQLT R11,R12
- CMPQ AX,DX
- CMOVQNE R11,R12
- CMPQ AX,CX
- CMOVQNE R11,R12
- CMPQ AX,R8
- CMOVQNE R11,R12
- CMPQ AX,R9
- CMOVQNE R11,R12
- NEGQ R12
- ANDQ R12,AX
- ANDQ R12,R10
- SUBQ R10,SI
- SUBQ AX,DX
- SUBQ AX,CX
- SUBQ AX,R8
- SUBQ AX,R9
- MOVQ SI,0(DI)
- MOVQ DX,8(DI)
- MOVQ CX,16(DI)
- MOVQ R8,24(DI)
- MOVQ R9,32(DI)
- RET
diff --git a/vendor/golang.org/x/crypto/curve25519/ladderstep_amd64.s b/vendor/golang.org/x/crypto/curve25519/ladderstep_amd64.s
deleted file mode 100644
index 7074e5cd9dcd4b1d01c3906b5459f6b042237445..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/ladderstep_amd64.s
+++ /dev/null
@@ -1,1377 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-#include "const_amd64.h"
-
-// func ladderstep(inout *[5][5]uint64)
-TEXT ·ladderstep(SB),0,$296-8
- MOVQ inout+0(FP),DI
-
- MOVQ 40(DI),SI
- MOVQ 48(DI),DX
- MOVQ 56(DI),CX
- MOVQ 64(DI),R8
- MOVQ 72(DI),R9
- MOVQ SI,AX
- MOVQ DX,R10
- MOVQ CX,R11
- MOVQ R8,R12
- MOVQ R9,R13
- ADDQ ·_2P0(SB),AX
- ADDQ ·_2P1234(SB),R10
- ADDQ ·_2P1234(SB),R11
- ADDQ ·_2P1234(SB),R12
- ADDQ ·_2P1234(SB),R13
- ADDQ 80(DI),SI
- ADDQ 88(DI),DX
- ADDQ 96(DI),CX
- ADDQ 104(DI),R8
- ADDQ 112(DI),R9
- SUBQ 80(DI),AX
- SUBQ 88(DI),R10
- SUBQ 96(DI),R11
- SUBQ 104(DI),R12
- SUBQ 112(DI),R13
- MOVQ SI,0(SP)
- MOVQ DX,8(SP)
- MOVQ CX,16(SP)
- MOVQ R8,24(SP)
- MOVQ R9,32(SP)
- MOVQ AX,40(SP)
- MOVQ R10,48(SP)
- MOVQ R11,56(SP)
- MOVQ R12,64(SP)
- MOVQ R13,72(SP)
- MOVQ 40(SP),AX
- MULQ 40(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 40(SP),AX
- SHLQ $1,AX
- MULQ 48(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 40(SP),AX
- SHLQ $1,AX
- MULQ 56(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 40(SP),AX
- SHLQ $1,AX
- MULQ 64(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 40(SP),AX
- SHLQ $1,AX
- MULQ 72(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 48(SP),AX
- MULQ 48(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 48(SP),AX
- SHLQ $1,AX
- MULQ 56(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 48(SP),AX
- SHLQ $1,AX
- MULQ 64(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 48(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 72(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 56(SP),AX
- MULQ 56(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 56(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 64(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 56(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 72(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 64(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 64(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 64(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 72(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 72(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 72(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- ANDQ DX,SI
- MOVQ CX,R8
- SHRQ $51,CX
- ADDQ R10,CX
- ANDQ DX,R8
- MOVQ CX,R9
- SHRQ $51,CX
- ADDQ R12,CX
- ANDQ DX,R9
- MOVQ CX,AX
- SHRQ $51,CX
- ADDQ R14,CX
- ANDQ DX,AX
- MOVQ CX,R10
- SHRQ $51,CX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,80(SP)
- MOVQ R8,88(SP)
- MOVQ R9,96(SP)
- MOVQ AX,104(SP)
- MOVQ R10,112(SP)
- MOVQ 0(SP),AX
- MULQ 0(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 0(SP),AX
- SHLQ $1,AX
- MULQ 8(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 0(SP),AX
- SHLQ $1,AX
- MULQ 16(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 0(SP),AX
- SHLQ $1,AX
- MULQ 24(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 0(SP),AX
- SHLQ $1,AX
- MULQ 32(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 8(SP),AX
- MULQ 8(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SP),AX
- SHLQ $1,AX
- MULQ 16(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 8(SP),AX
- SHLQ $1,AX
- MULQ 24(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 8(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 16(SP),AX
- MULQ 16(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 16(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 24(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 16(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 24(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 24(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 24(SP),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 32(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 32(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- ANDQ DX,SI
- MOVQ CX,R8
- SHRQ $51,CX
- ADDQ R10,CX
- ANDQ DX,R8
- MOVQ CX,R9
- SHRQ $51,CX
- ADDQ R12,CX
- ANDQ DX,R9
- MOVQ CX,AX
- SHRQ $51,CX
- ADDQ R14,CX
- ANDQ DX,AX
- MOVQ CX,R10
- SHRQ $51,CX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,120(SP)
- MOVQ R8,128(SP)
- MOVQ R9,136(SP)
- MOVQ AX,144(SP)
- MOVQ R10,152(SP)
- MOVQ SI,SI
- MOVQ R8,DX
- MOVQ R9,CX
- MOVQ AX,R8
- MOVQ R10,R9
- ADDQ ·_2P0(SB),SI
- ADDQ ·_2P1234(SB),DX
- ADDQ ·_2P1234(SB),CX
- ADDQ ·_2P1234(SB),R8
- ADDQ ·_2P1234(SB),R9
- SUBQ 80(SP),SI
- SUBQ 88(SP),DX
- SUBQ 96(SP),CX
- SUBQ 104(SP),R8
- SUBQ 112(SP),R9
- MOVQ SI,160(SP)
- MOVQ DX,168(SP)
- MOVQ CX,176(SP)
- MOVQ R8,184(SP)
- MOVQ R9,192(SP)
- MOVQ 120(DI),SI
- MOVQ 128(DI),DX
- MOVQ 136(DI),CX
- MOVQ 144(DI),R8
- MOVQ 152(DI),R9
- MOVQ SI,AX
- MOVQ DX,R10
- MOVQ CX,R11
- MOVQ R8,R12
- MOVQ R9,R13
- ADDQ ·_2P0(SB),AX
- ADDQ ·_2P1234(SB),R10
- ADDQ ·_2P1234(SB),R11
- ADDQ ·_2P1234(SB),R12
- ADDQ ·_2P1234(SB),R13
- ADDQ 160(DI),SI
- ADDQ 168(DI),DX
- ADDQ 176(DI),CX
- ADDQ 184(DI),R8
- ADDQ 192(DI),R9
- SUBQ 160(DI),AX
- SUBQ 168(DI),R10
- SUBQ 176(DI),R11
- SUBQ 184(DI),R12
- SUBQ 192(DI),R13
- MOVQ SI,200(SP)
- MOVQ DX,208(SP)
- MOVQ CX,216(SP)
- MOVQ R8,224(SP)
- MOVQ R9,232(SP)
- MOVQ AX,240(SP)
- MOVQ R10,248(SP)
- MOVQ R11,256(SP)
- MOVQ R12,264(SP)
- MOVQ R13,272(SP)
- MOVQ 224(SP),SI
- IMUL3Q $19,SI,AX
- MOVQ AX,280(SP)
- MULQ 56(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 232(SP),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,288(SP)
- MULQ 48(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 200(SP),AX
- MULQ 40(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 200(SP),AX
- MULQ 48(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 200(SP),AX
- MULQ 56(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 200(SP),AX
- MULQ 64(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 200(SP),AX
- MULQ 72(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 208(SP),AX
- MULQ 40(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 208(SP),AX
- MULQ 48(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 208(SP),AX
- MULQ 56(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 208(SP),AX
- MULQ 64(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 208(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 72(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 216(SP),AX
- MULQ 40(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 216(SP),AX
- MULQ 48(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 216(SP),AX
- MULQ 56(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 216(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 64(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 216(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 72(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 224(SP),AX
- MULQ 40(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 224(SP),AX
- MULQ 48(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 280(SP),AX
- MULQ 64(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 280(SP),AX
- MULQ 72(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 232(SP),AX
- MULQ 40(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 288(SP),AX
- MULQ 56(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 288(SP),AX
- MULQ 64(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 288(SP),AX
- MULQ 72(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $51,CX
- ANDQ DX,SI
- ADDQ R10,CX
- MOVQ CX,R9
- SHRQ $51,CX
- ANDQ DX,R8
- ADDQ R12,CX
- MOVQ CX,AX
- SHRQ $51,CX
- ANDQ DX,R9
- ADDQ R14,CX
- MOVQ CX,R10
- SHRQ $51,CX
- ANDQ DX,AX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,40(SP)
- MOVQ R8,48(SP)
- MOVQ R9,56(SP)
- MOVQ AX,64(SP)
- MOVQ R10,72(SP)
- MOVQ 264(SP),SI
- IMUL3Q $19,SI,AX
- MOVQ AX,200(SP)
- MULQ 16(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 272(SP),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,208(SP)
- MULQ 8(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 240(SP),AX
- MULQ 0(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 240(SP),AX
- MULQ 8(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 240(SP),AX
- MULQ 16(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 240(SP),AX
- MULQ 24(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 240(SP),AX
- MULQ 32(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 248(SP),AX
- MULQ 0(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 248(SP),AX
- MULQ 8(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 248(SP),AX
- MULQ 16(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 248(SP),AX
- MULQ 24(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 248(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 32(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 256(SP),AX
- MULQ 0(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 256(SP),AX
- MULQ 8(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 256(SP),AX
- MULQ 16(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 256(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 24(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 256(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 32(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 264(SP),AX
- MULQ 0(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 264(SP),AX
- MULQ 8(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 200(SP),AX
- MULQ 24(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 200(SP),AX
- MULQ 32(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 272(SP),AX
- MULQ 0(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 208(SP),AX
- MULQ 16(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 208(SP),AX
- MULQ 24(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 208(SP),AX
- MULQ 32(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $51,CX
- ANDQ DX,SI
- ADDQ R10,CX
- MOVQ CX,R9
- SHRQ $51,CX
- ANDQ DX,R8
- ADDQ R12,CX
- MOVQ CX,AX
- SHRQ $51,CX
- ANDQ DX,R9
- ADDQ R14,CX
- MOVQ CX,R10
- SHRQ $51,CX
- ANDQ DX,AX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,DX
- MOVQ R8,CX
- MOVQ R9,R11
- MOVQ AX,R12
- MOVQ R10,R13
- ADDQ ·_2P0(SB),DX
- ADDQ ·_2P1234(SB),CX
- ADDQ ·_2P1234(SB),R11
- ADDQ ·_2P1234(SB),R12
- ADDQ ·_2P1234(SB),R13
- ADDQ 40(SP),SI
- ADDQ 48(SP),R8
- ADDQ 56(SP),R9
- ADDQ 64(SP),AX
- ADDQ 72(SP),R10
- SUBQ 40(SP),DX
- SUBQ 48(SP),CX
- SUBQ 56(SP),R11
- SUBQ 64(SP),R12
- SUBQ 72(SP),R13
- MOVQ SI,120(DI)
- MOVQ R8,128(DI)
- MOVQ R9,136(DI)
- MOVQ AX,144(DI)
- MOVQ R10,152(DI)
- MOVQ DX,160(DI)
- MOVQ CX,168(DI)
- MOVQ R11,176(DI)
- MOVQ R12,184(DI)
- MOVQ R13,192(DI)
- MOVQ 120(DI),AX
- MULQ 120(DI)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 120(DI),AX
- SHLQ $1,AX
- MULQ 128(DI)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 120(DI),AX
- SHLQ $1,AX
- MULQ 136(DI)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 120(DI),AX
- SHLQ $1,AX
- MULQ 144(DI)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 120(DI),AX
- SHLQ $1,AX
- MULQ 152(DI)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 128(DI),AX
- MULQ 128(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 128(DI),AX
- SHLQ $1,AX
- MULQ 136(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 128(DI),AX
- SHLQ $1,AX
- MULQ 144(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 128(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 152(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 136(DI),AX
- MULQ 136(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 136(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 144(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 136(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 152(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 144(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 144(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 144(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 152(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 152(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 152(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- ANDQ DX,SI
- MOVQ CX,R8
- SHRQ $51,CX
- ADDQ R10,CX
- ANDQ DX,R8
- MOVQ CX,R9
- SHRQ $51,CX
- ADDQ R12,CX
- ANDQ DX,R9
- MOVQ CX,AX
- SHRQ $51,CX
- ADDQ R14,CX
- ANDQ DX,AX
- MOVQ CX,R10
- SHRQ $51,CX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,120(DI)
- MOVQ R8,128(DI)
- MOVQ R9,136(DI)
- MOVQ AX,144(DI)
- MOVQ R10,152(DI)
- MOVQ 160(DI),AX
- MULQ 160(DI)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 160(DI),AX
- SHLQ $1,AX
- MULQ 168(DI)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 160(DI),AX
- SHLQ $1,AX
- MULQ 176(DI)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 160(DI),AX
- SHLQ $1,AX
- MULQ 184(DI)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 160(DI),AX
- SHLQ $1,AX
- MULQ 192(DI)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 168(DI),AX
- MULQ 168(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 168(DI),AX
- SHLQ $1,AX
- MULQ 176(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 168(DI),AX
- SHLQ $1,AX
- MULQ 184(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 168(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 192(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 176(DI),AX
- MULQ 176(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 176(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 184(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 176(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 192(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 184(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 184(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 184(DI),DX
- IMUL3Q $38,DX,AX
- MULQ 192(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 192(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 192(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- ANDQ DX,SI
- MOVQ CX,R8
- SHRQ $51,CX
- ADDQ R10,CX
- ANDQ DX,R8
- MOVQ CX,R9
- SHRQ $51,CX
- ADDQ R12,CX
- ANDQ DX,R9
- MOVQ CX,AX
- SHRQ $51,CX
- ADDQ R14,CX
- ANDQ DX,AX
- MOVQ CX,R10
- SHRQ $51,CX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,160(DI)
- MOVQ R8,168(DI)
- MOVQ R9,176(DI)
- MOVQ AX,184(DI)
- MOVQ R10,192(DI)
- MOVQ 184(DI),SI
- IMUL3Q $19,SI,AX
- MOVQ AX,0(SP)
- MULQ 16(DI)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 192(DI),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,8(SP)
- MULQ 8(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 160(DI),AX
- MULQ 0(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 160(DI),AX
- MULQ 8(DI)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 160(DI),AX
- MULQ 16(DI)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 160(DI),AX
- MULQ 24(DI)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 160(DI),AX
- MULQ 32(DI)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 168(DI),AX
- MULQ 0(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 168(DI),AX
- MULQ 8(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 168(DI),AX
- MULQ 16(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 168(DI),AX
- MULQ 24(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 168(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 32(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 176(DI),AX
- MULQ 0(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 176(DI),AX
- MULQ 8(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 176(DI),AX
- MULQ 16(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 176(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 24(DI)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 176(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 32(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 184(DI),AX
- MULQ 0(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 184(DI),AX
- MULQ 8(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 0(SP),AX
- MULQ 24(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 0(SP),AX
- MULQ 32(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 192(DI),AX
- MULQ 0(DI)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 8(SP),AX
- MULQ 16(DI)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 8(SP),AX
- MULQ 24(DI)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SP),AX
- MULQ 32(DI)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $51,CX
- ANDQ DX,SI
- ADDQ R10,CX
- MOVQ CX,R9
- SHRQ $51,CX
- ANDQ DX,R8
- ADDQ R12,CX
- MOVQ CX,AX
- SHRQ $51,CX
- ANDQ DX,R9
- ADDQ R14,CX
- MOVQ CX,R10
- SHRQ $51,CX
- ANDQ DX,AX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,160(DI)
- MOVQ R8,168(DI)
- MOVQ R9,176(DI)
- MOVQ AX,184(DI)
- MOVQ R10,192(DI)
- MOVQ 144(SP),SI
- IMUL3Q $19,SI,AX
- MOVQ AX,0(SP)
- MULQ 96(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 152(SP),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,8(SP)
- MULQ 88(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 120(SP),AX
- MULQ 80(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 120(SP),AX
- MULQ 88(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 120(SP),AX
- MULQ 96(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 120(SP),AX
- MULQ 104(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 120(SP),AX
- MULQ 112(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 128(SP),AX
- MULQ 80(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 128(SP),AX
- MULQ 88(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 128(SP),AX
- MULQ 96(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 128(SP),AX
- MULQ 104(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 128(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 112(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 136(SP),AX
- MULQ 80(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 136(SP),AX
- MULQ 88(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 136(SP),AX
- MULQ 96(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 136(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 104(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 136(SP),DX
- IMUL3Q $19,DX,AX
- MULQ 112(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 144(SP),AX
- MULQ 80(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 144(SP),AX
- MULQ 88(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 0(SP),AX
- MULQ 104(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 0(SP),AX
- MULQ 112(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 152(SP),AX
- MULQ 80(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 8(SP),AX
- MULQ 96(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 8(SP),AX
- MULQ 104(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SP),AX
- MULQ 112(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $51,CX
- ANDQ DX,SI
- ADDQ R10,CX
- MOVQ CX,R9
- SHRQ $51,CX
- ANDQ DX,R8
- ADDQ R12,CX
- MOVQ CX,AX
- SHRQ $51,CX
- ANDQ DX,R9
- ADDQ R14,CX
- MOVQ CX,R10
- SHRQ $51,CX
- ANDQ DX,AX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,40(DI)
- MOVQ R8,48(DI)
- MOVQ R9,56(DI)
- MOVQ AX,64(DI)
- MOVQ R10,72(DI)
- MOVQ 160(SP),AX
- MULQ ·_121666_213(SB)
- SHRQ $13,AX
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 168(SP),AX
- MULQ ·_121666_213(SB)
- SHRQ $13,AX
- ADDQ AX,CX
- MOVQ DX,R8
- MOVQ 176(SP),AX
- MULQ ·_121666_213(SB)
- SHRQ $13,AX
- ADDQ AX,R8
- MOVQ DX,R9
- MOVQ 184(SP),AX
- MULQ ·_121666_213(SB)
- SHRQ $13,AX
- ADDQ AX,R9
- MOVQ DX,R10
- MOVQ 192(SP),AX
- MULQ ·_121666_213(SB)
- SHRQ $13,AX
- ADDQ AX,R10
- IMUL3Q $19,DX,DX
- ADDQ DX,SI
- ADDQ 80(SP),SI
- ADDQ 88(SP),CX
- ADDQ 96(SP),R8
- ADDQ 104(SP),R9
- ADDQ 112(SP),R10
- MOVQ SI,80(DI)
- MOVQ CX,88(DI)
- MOVQ R8,96(DI)
- MOVQ R9,104(DI)
- MOVQ R10,112(DI)
- MOVQ 104(DI),SI
- IMUL3Q $19,SI,AX
- MOVQ AX,0(SP)
- MULQ 176(SP)
- MOVQ AX,SI
- MOVQ DX,CX
- MOVQ 112(DI),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,8(SP)
- MULQ 168(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 80(DI),AX
- MULQ 160(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 80(DI),AX
- MULQ 168(SP)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 80(DI),AX
- MULQ 176(SP)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 80(DI),AX
- MULQ 184(SP)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 80(DI),AX
- MULQ 192(SP)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 88(DI),AX
- MULQ 160(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 88(DI),AX
- MULQ 168(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 88(DI),AX
- MULQ 176(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 88(DI),AX
- MULQ 184(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 88(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 192(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 96(DI),AX
- MULQ 160(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 96(DI),AX
- MULQ 168(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 96(DI),AX
- MULQ 176(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 96(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 184(SP)
- ADDQ AX,SI
- ADCQ DX,CX
- MOVQ 96(DI),DX
- IMUL3Q $19,DX,AX
- MULQ 192(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 104(DI),AX
- MULQ 160(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 104(DI),AX
- MULQ 168(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 0(SP),AX
- MULQ 184(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 0(SP),AX
- MULQ 192(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 112(DI),AX
- MULQ 160(SP)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 8(SP),AX
- MULQ 176(SP)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 8(SP),AX
- MULQ 184(SP)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SP),AX
- MULQ 192(SP)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ $REDMASK51,DX
- SHLQ $13,CX:SI
- ANDQ DX,SI
- SHLQ $13,R9:R8
- ANDQ DX,R8
- ADDQ CX,R8
- SHLQ $13,R11:R10
- ANDQ DX,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ DX,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ DX,R14
- ADDQ R13,R14
- IMUL3Q $19,R15,CX
- ADDQ CX,SI
- MOVQ SI,CX
- SHRQ $51,CX
- ADDQ R8,CX
- MOVQ CX,R8
- SHRQ $51,CX
- ANDQ DX,SI
- ADDQ R10,CX
- MOVQ CX,R9
- SHRQ $51,CX
- ANDQ DX,R8
- ADDQ R12,CX
- MOVQ CX,AX
- SHRQ $51,CX
- ANDQ DX,R9
- ADDQ R14,CX
- MOVQ CX,R10
- SHRQ $51,CX
- ANDQ DX,AX
- IMUL3Q $19,CX,CX
- ADDQ CX,SI
- ANDQ DX,R10
- MOVQ SI,80(DI)
- MOVQ R8,88(DI)
- MOVQ R9,96(DI)
- MOVQ AX,104(DI)
- MOVQ R10,112(DI)
- RET
diff --git a/vendor/golang.org/x/crypto/curve25519/mont25519_amd64.go b/vendor/golang.org/x/crypto/curve25519/mont25519_amd64.go
deleted file mode 100644
index 5822bd53383495f484075e14cdc5c18dc658101a..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/mont25519_amd64.go
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build amd64,!gccgo,!appengine
-
-package curve25519
-
-// These functions are implemented in the .s files. The names of the functions
-// in the rest of the file are also taken from the SUPERCOP sources to help
-// people following along.
-
-//go:noescape
-
-func cswap(inout *[5]uint64, v uint64)
-
-//go:noescape
-
-func ladderstep(inout *[5][5]uint64)
-
-//go:noescape
-
-func freeze(inout *[5]uint64)
-
-//go:noescape
-
-func mul(dest, a, b *[5]uint64)
-
-//go:noescape
-
-func square(out, in *[5]uint64)
-
-// mladder uses a Montgomery ladder to calculate (xr/zr) *= s.
-func mladder(xr, zr *[5]uint64, s *[32]byte) {
- var work [5][5]uint64
-
- work[0] = *xr
- setint(&work[1], 1)
- setint(&work[2], 0)
- work[3] = *xr
- setint(&work[4], 1)
-
- j := uint(6)
- var prevbit byte
-
- for i := 31; i >= 0; i-- {
- for j < 8 {
- bit := ((*s)[i] >> j) & 1
- swap := bit ^ prevbit
- prevbit = bit
- cswap(&work[1], uint64(swap))
- ladderstep(&work)
- j--
- }
- j = 7
- }
-
- *xr = work[1]
- *zr = work[2]
-}
-
-func scalarMult(out, in, base *[32]byte) {
- var e [32]byte
- copy(e[:], (*in)[:])
- e[0] &= 248
- e[31] &= 127
- e[31] |= 64
-
- var t, z [5]uint64
- unpack(&t, base)
- mladder(&t, &z, &e)
- invert(&z, &z)
- mul(&t, &t, &z)
- pack(out, &t)
-}
-
-func setint(r *[5]uint64, v uint64) {
- r[0] = v
- r[1] = 0
- r[2] = 0
- r[3] = 0
- r[4] = 0
-}
-
-// unpack sets r = x where r consists of 5, 51-bit limbs in little-endian
-// order.
-func unpack(r *[5]uint64, x *[32]byte) {
- r[0] = uint64(x[0]) |
- uint64(x[1])<<8 |
- uint64(x[2])<<16 |
- uint64(x[3])<<24 |
- uint64(x[4])<<32 |
- uint64(x[5])<<40 |
- uint64(x[6]&7)<<48
-
- r[1] = uint64(x[6])>>3 |
- uint64(x[7])<<5 |
- uint64(x[8])<<13 |
- uint64(x[9])<<21 |
- uint64(x[10])<<29 |
- uint64(x[11])<<37 |
- uint64(x[12]&63)<<45
-
- r[2] = uint64(x[12])>>6 |
- uint64(x[13])<<2 |
- uint64(x[14])<<10 |
- uint64(x[15])<<18 |
- uint64(x[16])<<26 |
- uint64(x[17])<<34 |
- uint64(x[18])<<42 |
- uint64(x[19]&1)<<50
-
- r[3] = uint64(x[19])>>1 |
- uint64(x[20])<<7 |
- uint64(x[21])<<15 |
- uint64(x[22])<<23 |
- uint64(x[23])<<31 |
- uint64(x[24])<<39 |
- uint64(x[25]&15)<<47
-
- r[4] = uint64(x[25])>>4 |
- uint64(x[26])<<4 |
- uint64(x[27])<<12 |
- uint64(x[28])<<20 |
- uint64(x[29])<<28 |
- uint64(x[30])<<36 |
- uint64(x[31]&127)<<44
-}
-
-// pack sets out = x where out is the usual, little-endian form of the 5,
-// 51-bit limbs in x.
-func pack(out *[32]byte, x *[5]uint64) {
- t := *x
- freeze(&t)
-
- out[0] = byte(t[0])
- out[1] = byte(t[0] >> 8)
- out[2] = byte(t[0] >> 16)
- out[3] = byte(t[0] >> 24)
- out[4] = byte(t[0] >> 32)
- out[5] = byte(t[0] >> 40)
- out[6] = byte(t[0] >> 48)
-
- out[6] ^= byte(t[1]<<3) & 0xf8
- out[7] = byte(t[1] >> 5)
- out[8] = byte(t[1] >> 13)
- out[9] = byte(t[1] >> 21)
- out[10] = byte(t[1] >> 29)
- out[11] = byte(t[1] >> 37)
- out[12] = byte(t[1] >> 45)
-
- out[12] ^= byte(t[2]<<6) & 0xc0
- out[13] = byte(t[2] >> 2)
- out[14] = byte(t[2] >> 10)
- out[15] = byte(t[2] >> 18)
- out[16] = byte(t[2] >> 26)
- out[17] = byte(t[2] >> 34)
- out[18] = byte(t[2] >> 42)
- out[19] = byte(t[2] >> 50)
-
- out[19] ^= byte(t[3]<<1) & 0xfe
- out[20] = byte(t[3] >> 7)
- out[21] = byte(t[3] >> 15)
- out[22] = byte(t[3] >> 23)
- out[23] = byte(t[3] >> 31)
- out[24] = byte(t[3] >> 39)
- out[25] = byte(t[3] >> 47)
-
- out[25] ^= byte(t[4]<<4) & 0xf0
- out[26] = byte(t[4] >> 4)
- out[27] = byte(t[4] >> 12)
- out[28] = byte(t[4] >> 20)
- out[29] = byte(t[4] >> 28)
- out[30] = byte(t[4] >> 36)
- out[31] = byte(t[4] >> 44)
-}
-
-// invert calculates r = x^-1 mod p using Fermat's little theorem.
-func invert(r *[5]uint64, x *[5]uint64) {
- var z2, z9, z11, z2_5_0, z2_10_0, z2_20_0, z2_50_0, z2_100_0, t [5]uint64
-
- square(&z2, x) /* 2 */
- square(&t, &z2) /* 4 */
- square(&t, &t) /* 8 */
- mul(&z9, &t, x) /* 9 */
- mul(&z11, &z9, &z2) /* 11 */
- square(&t, &z11) /* 22 */
- mul(&z2_5_0, &t, &z9) /* 2^5 - 2^0 = 31 */
-
- square(&t, &z2_5_0) /* 2^6 - 2^1 */
- for i := 1; i < 5; i++ { /* 2^20 - 2^10 */
- square(&t, &t)
- }
- mul(&z2_10_0, &t, &z2_5_0) /* 2^10 - 2^0 */
-
- square(&t, &z2_10_0) /* 2^11 - 2^1 */
- for i := 1; i < 10; i++ { /* 2^20 - 2^10 */
- square(&t, &t)
- }
- mul(&z2_20_0, &t, &z2_10_0) /* 2^20 - 2^0 */
-
- square(&t, &z2_20_0) /* 2^21 - 2^1 */
- for i := 1; i < 20; i++ { /* 2^40 - 2^20 */
- square(&t, &t)
- }
- mul(&t, &t, &z2_20_0) /* 2^40 - 2^0 */
-
- square(&t, &t) /* 2^41 - 2^1 */
- for i := 1; i < 10; i++ { /* 2^50 - 2^10 */
- square(&t, &t)
- }
- mul(&z2_50_0, &t, &z2_10_0) /* 2^50 - 2^0 */
-
- square(&t, &z2_50_0) /* 2^51 - 2^1 */
- for i := 1; i < 50; i++ { /* 2^100 - 2^50 */
- square(&t, &t)
- }
- mul(&z2_100_0, &t, &z2_50_0) /* 2^100 - 2^0 */
-
- square(&t, &z2_100_0) /* 2^101 - 2^1 */
- for i := 1; i < 100; i++ { /* 2^200 - 2^100 */
- square(&t, &t)
- }
- mul(&t, &t, &z2_100_0) /* 2^200 - 2^0 */
-
- square(&t, &t) /* 2^201 - 2^1 */
- for i := 1; i < 50; i++ { /* 2^250 - 2^50 */
- square(&t, &t)
- }
- mul(&t, &t, &z2_50_0) /* 2^250 - 2^0 */
-
- square(&t, &t) /* 2^251 - 2^1 */
- square(&t, &t) /* 2^252 - 2^2 */
- square(&t, &t) /* 2^253 - 2^3 */
-
- square(&t, &t) /* 2^254 - 2^4 */
-
- square(&t, &t) /* 2^255 - 2^5 */
- mul(r, &t, &z11) /* 2^255 - 21 */
-}
diff --git a/vendor/golang.org/x/crypto/curve25519/mul_amd64.s b/vendor/golang.org/x/crypto/curve25519/mul_amd64.s
deleted file mode 100644
index b162e6515984ea83ebcdca8d96479fb9ab5780ad..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/mul_amd64.s
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-#include "const_amd64.h"
-
-// func mul(dest, a, b *[5]uint64)
-TEXT ·mul(SB),0,$16-24
- MOVQ dest+0(FP), DI
- MOVQ a+8(FP), SI
- MOVQ b+16(FP), DX
-
- MOVQ DX,CX
- MOVQ 24(SI),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,0(SP)
- MULQ 16(CX)
- MOVQ AX,R8
- MOVQ DX,R9
- MOVQ 32(SI),DX
- IMUL3Q $19,DX,AX
- MOVQ AX,8(SP)
- MULQ 8(CX)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 0(SI),AX
- MULQ 0(CX)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 0(SI),AX
- MULQ 8(CX)
- MOVQ AX,R10
- MOVQ DX,R11
- MOVQ 0(SI),AX
- MULQ 16(CX)
- MOVQ AX,R12
- MOVQ DX,R13
- MOVQ 0(SI),AX
- MULQ 24(CX)
- MOVQ AX,R14
- MOVQ DX,R15
- MOVQ 0(SI),AX
- MULQ 32(CX)
- MOVQ AX,BX
- MOVQ DX,BP
- MOVQ 8(SI),AX
- MULQ 0(CX)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SI),AX
- MULQ 8(CX)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 8(SI),AX
- MULQ 16(CX)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 8(SI),AX
- MULQ 24(CX)
- ADDQ AX,BX
- ADCQ DX,BP
- MOVQ 8(SI),DX
- IMUL3Q $19,DX,AX
- MULQ 32(CX)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 16(SI),AX
- MULQ 0(CX)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 16(SI),AX
- MULQ 8(CX)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 16(SI),AX
- MULQ 16(CX)
- ADDQ AX,BX
- ADCQ DX,BP
- MOVQ 16(SI),DX
- IMUL3Q $19,DX,AX
- MULQ 24(CX)
- ADDQ AX,R8
- ADCQ DX,R9
- MOVQ 16(SI),DX
- IMUL3Q $19,DX,AX
- MULQ 32(CX)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 24(SI),AX
- MULQ 0(CX)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ 24(SI),AX
- MULQ 8(CX)
- ADDQ AX,BX
- ADCQ DX,BP
- MOVQ 0(SP),AX
- MULQ 24(CX)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 0(SP),AX
- MULQ 32(CX)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 32(SI),AX
- MULQ 0(CX)
- ADDQ AX,BX
- ADCQ DX,BP
- MOVQ 8(SP),AX
- MULQ 16(CX)
- ADDQ AX,R10
- ADCQ DX,R11
- MOVQ 8(SP),AX
- MULQ 24(CX)
- ADDQ AX,R12
- ADCQ DX,R13
- MOVQ 8(SP),AX
- MULQ 32(CX)
- ADDQ AX,R14
- ADCQ DX,R15
- MOVQ $REDMASK51,SI
- SHLQ $13,R9:R8
- ANDQ SI,R8
- SHLQ $13,R11:R10
- ANDQ SI,R10
- ADDQ R9,R10
- SHLQ $13,R13:R12
- ANDQ SI,R12
- ADDQ R11,R12
- SHLQ $13,R15:R14
- ANDQ SI,R14
- ADDQ R13,R14
- SHLQ $13,BP:BX
- ANDQ SI,BX
- ADDQ R15,BX
- IMUL3Q $19,BP,DX
- ADDQ DX,R8
- MOVQ R8,DX
- SHRQ $51,DX
- ADDQ R10,DX
- MOVQ DX,CX
- SHRQ $51,DX
- ANDQ SI,R8
- ADDQ R12,DX
- MOVQ DX,R9
- SHRQ $51,DX
- ANDQ SI,CX
- ADDQ R14,DX
- MOVQ DX,AX
- SHRQ $51,DX
- ANDQ SI,R9
- ADDQ BX,DX
- MOVQ DX,R10
- SHRQ $51,DX
- ANDQ SI,AX
- IMUL3Q $19,DX,DX
- ADDQ DX,R8
- ANDQ SI,R10
- MOVQ R8,0(DI)
- MOVQ CX,8(DI)
- MOVQ R9,16(DI)
- MOVQ AX,24(DI)
- MOVQ R10,32(DI)
- RET
diff --git a/vendor/golang.org/x/crypto/curve25519/square_amd64.s b/vendor/golang.org/x/crypto/curve25519/square_amd64.s
deleted file mode 100644
index 4e864a83ef5ecd751c900f12fd74f9828b803804..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/curve25519/square_amd64.s
+++ /dev/null
@@ -1,132 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This code was translated into a form compatible with 6a from the public
-// domain sources in SUPERCOP: http://bench.cr.yp.to/supercop.html
-
-// +build amd64,!gccgo,!appengine
-
-#include "const_amd64.h"
-
-// func square(out, in *[5]uint64)
-TEXT ·square(SB),7,$0-16
- MOVQ out+0(FP), DI
- MOVQ in+8(FP), SI
-
- MOVQ 0(SI),AX
- MULQ 0(SI)
- MOVQ AX,CX
- MOVQ DX,R8
- MOVQ 0(SI),AX
- SHLQ $1,AX
- MULQ 8(SI)
- MOVQ AX,R9
- MOVQ DX,R10
- MOVQ 0(SI),AX
- SHLQ $1,AX
- MULQ 16(SI)
- MOVQ AX,R11
- MOVQ DX,R12
- MOVQ 0(SI),AX
- SHLQ $1,AX
- MULQ 24(SI)
- MOVQ AX,R13
- MOVQ DX,R14
- MOVQ 0(SI),AX
- SHLQ $1,AX
- MULQ 32(SI)
- MOVQ AX,R15
- MOVQ DX,BX
- MOVQ 8(SI),AX
- MULQ 8(SI)
- ADDQ AX,R11
- ADCQ DX,R12
- MOVQ 8(SI),AX
- SHLQ $1,AX
- MULQ 16(SI)
- ADDQ AX,R13
- ADCQ DX,R14
- MOVQ 8(SI),AX
- SHLQ $1,AX
- MULQ 24(SI)
- ADDQ AX,R15
- ADCQ DX,BX
- MOVQ 8(SI),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SI)
- ADDQ AX,CX
- ADCQ DX,R8
- MOVQ 16(SI),AX
- MULQ 16(SI)
- ADDQ AX,R15
- ADCQ DX,BX
- MOVQ 16(SI),DX
- IMUL3Q $38,DX,AX
- MULQ 24(SI)
- ADDQ AX,CX
- ADCQ DX,R8
- MOVQ 16(SI),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SI)
- ADDQ AX,R9
- ADCQ DX,R10
- MOVQ 24(SI),DX
- IMUL3Q $19,DX,AX
- MULQ 24(SI)
- ADDQ AX,R9
- ADCQ DX,R10
- MOVQ 24(SI),DX
- IMUL3Q $38,DX,AX
- MULQ 32(SI)
- ADDQ AX,R11
- ADCQ DX,R12
- MOVQ 32(SI),DX
- IMUL3Q $19,DX,AX
- MULQ 32(SI)
- ADDQ AX,R13
- ADCQ DX,R14
- MOVQ $REDMASK51,SI
- SHLQ $13,R8:CX
- ANDQ SI,CX
- SHLQ $13,R10:R9
- ANDQ SI,R9
- ADDQ R8,R9
- SHLQ $13,R12:R11
- ANDQ SI,R11
- ADDQ R10,R11
- SHLQ $13,R14:R13
- ANDQ SI,R13
- ADDQ R12,R13
- SHLQ $13,BX:R15
- ANDQ SI,R15
- ADDQ R14,R15
- IMUL3Q $19,BX,DX
- ADDQ DX,CX
- MOVQ CX,DX
- SHRQ $51,DX
- ADDQ R9,DX
- ANDQ SI,CX
- MOVQ DX,R8
- SHRQ $51,DX
- ADDQ R11,DX
- ANDQ SI,R8
- MOVQ DX,R9
- SHRQ $51,DX
- ADDQ R13,DX
- ANDQ SI,R9
- MOVQ DX,AX
- SHRQ $51,DX
- ADDQ R15,DX
- ANDQ SI,AX
- MOVQ DX,R10
- SHRQ $51,DX
- IMUL3Q $19,DX,DX
- ADDQ DX,CX
- ANDQ SI,R10
- MOVQ CX,0(DI)
- MOVQ R8,8(DI)
- MOVQ R9,16(DI)
- MOVQ AX,24(DI)
- MOVQ R10,32(DI)
- RET
diff --git a/vendor/golang.org/x/crypto/ed25519/ed25519.go b/vendor/golang.org/x/crypto/ed25519/ed25519.go
deleted file mode 100644
index f1d95674ac3f7562ee613705d0ff281ac97e9772..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ed25519/ed25519.go
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package ed25519 implements the Ed25519 signature algorithm. See
-// http://ed25519.cr.yp.to/.
-//
-// These functions are also compatible with the “Ed25519†function defined in
-// https://tools.ietf.org/html/draft-irtf-cfrg-eddsa-05.
-package ed25519
-
-// This code is a port of the public domain, “ref10†implementation of ed25519
-// from SUPERCOP.
-
-import (
- "crypto"
- cryptorand "crypto/rand"
- "crypto/sha512"
- "crypto/subtle"
- "errors"
- "io"
- "strconv"
-
- "golang.org/x/crypto/ed25519/internal/edwards25519"
-)
-
-const (
- // PublicKeySize is the size, in bytes, of public keys as used in this package.
- PublicKeySize = 32
- // PrivateKeySize is the size, in bytes, of private keys as used in this package.
- PrivateKeySize = 64
- // SignatureSize is the size, in bytes, of signatures generated and verified by this package.
- SignatureSize = 64
-)
-
-// PublicKey is the type of Ed25519 public keys.
-type PublicKey []byte
-
-// PrivateKey is the type of Ed25519 private keys. It implements crypto.Signer.
-type PrivateKey []byte
-
-// Public returns the PublicKey corresponding to priv.
-func (priv PrivateKey) Public() crypto.PublicKey {
- publicKey := make([]byte, PublicKeySize)
- copy(publicKey, priv[32:])
- return PublicKey(publicKey)
-}
-
-// Sign signs the given message with priv.
-// Ed25519 performs two passes over messages to be signed and therefore cannot
-// handle pre-hashed messages. Thus opts.HashFunc() must return zero to
-// indicate the message hasn't been hashed. This can be achieved by passing
-// crypto.Hash(0) as the value for opts.
-func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error) {
- if opts.HashFunc() != crypto.Hash(0) {
- return nil, errors.New("ed25519: cannot sign hashed message")
- }
-
- return Sign(priv, message), nil
-}
-
-// GenerateKey generates a public/private key pair using entropy from rand.
-// If rand is nil, crypto/rand.Reader will be used.
-func GenerateKey(rand io.Reader) (publicKey PublicKey, privateKey PrivateKey, err error) {
- if rand == nil {
- rand = cryptorand.Reader
- }
-
- privateKey = make([]byte, PrivateKeySize)
- publicKey = make([]byte, PublicKeySize)
- _, err = io.ReadFull(rand, privateKey[:32])
- if err != nil {
- return nil, nil, err
- }
-
- digest := sha512.Sum512(privateKey[:32])
- digest[0] &= 248
- digest[31] &= 127
- digest[31] |= 64
-
- var A edwards25519.ExtendedGroupElement
- var hBytes [32]byte
- copy(hBytes[:], digest[:])
- edwards25519.GeScalarMultBase(&A, &hBytes)
- var publicKeyBytes [32]byte
- A.ToBytes(&publicKeyBytes)
-
- copy(privateKey[32:], publicKeyBytes[:])
- copy(publicKey, publicKeyBytes[:])
-
- return publicKey, privateKey, nil
-}
-
-// Sign signs the message with privateKey and returns a signature. It will
-// panic if len(privateKey) is not PrivateKeySize.
-func Sign(privateKey PrivateKey, message []byte) []byte {
- if l := len(privateKey); l != PrivateKeySize {
- panic("ed25519: bad private key length: " + strconv.Itoa(l))
- }
-
- h := sha512.New()
- h.Write(privateKey[:32])
-
- var digest1, messageDigest, hramDigest [64]byte
- var expandedSecretKey [32]byte
- h.Sum(digest1[:0])
- copy(expandedSecretKey[:], digest1[:])
- expandedSecretKey[0] &= 248
- expandedSecretKey[31] &= 63
- expandedSecretKey[31] |= 64
-
- h.Reset()
- h.Write(digest1[32:])
- h.Write(message)
- h.Sum(messageDigest[:0])
-
- var messageDigestReduced [32]byte
- edwards25519.ScReduce(&messageDigestReduced, &messageDigest)
- var R edwards25519.ExtendedGroupElement
- edwards25519.GeScalarMultBase(&R, &messageDigestReduced)
-
- var encodedR [32]byte
- R.ToBytes(&encodedR)
-
- h.Reset()
- h.Write(encodedR[:])
- h.Write(privateKey[32:])
- h.Write(message)
- h.Sum(hramDigest[:0])
- var hramDigestReduced [32]byte
- edwards25519.ScReduce(&hramDigestReduced, &hramDigest)
-
- var s [32]byte
- edwards25519.ScMulAdd(&s, &hramDigestReduced, &expandedSecretKey, &messageDigestReduced)
-
- signature := make([]byte, SignatureSize)
- copy(signature[:], encodedR[:])
- copy(signature[32:], s[:])
-
- return signature
-}
-
-// Verify reports whether sig is a valid signature of message by publicKey. It
-// will panic if len(publicKey) is not PublicKeySize.
-func Verify(publicKey PublicKey, message, sig []byte) bool {
- if l := len(publicKey); l != PublicKeySize {
- panic("ed25519: bad public key length: " + strconv.Itoa(l))
- }
-
- if len(sig) != SignatureSize || sig[63]&224 != 0 {
- return false
- }
-
- var A edwards25519.ExtendedGroupElement
- var publicKeyBytes [32]byte
- copy(publicKeyBytes[:], publicKey)
- if !A.FromBytes(&publicKeyBytes) {
- return false
- }
- edwards25519.FeNeg(&A.X, &A.X)
- edwards25519.FeNeg(&A.T, &A.T)
-
- h := sha512.New()
- h.Write(sig[:32])
- h.Write(publicKey[:])
- h.Write(message)
- var digest [64]byte
- h.Sum(digest[:0])
-
- var hReduced [32]byte
- edwards25519.ScReduce(&hReduced, &digest)
-
- var R edwards25519.ProjectiveGroupElement
- var b [32]byte
- copy(b[:], sig[32:])
- edwards25519.GeDoubleScalarMultVartime(&R, &hReduced, &A, &b)
-
- var checkR [32]byte
- R.ToBytes(&checkR)
- return subtle.ConstantTimeCompare(sig[:32], checkR[:]) == 1
-}
diff --git a/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/const.go b/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/const.go
deleted file mode 100644
index e39f086c1d87dbedcb0cd0ccb4d302bae2c04dbc..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/const.go
+++ /dev/null
@@ -1,1422 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package edwards25519
-
-// These values are from the public domain, “ref10†implementation of ed25519
-// from SUPERCOP.
-
-// d is a constant in the Edwards curve equation.
-var d = FieldElement{
- -10913610, 13857413, -15372611, 6949391, 114729, -8787816, -6275908, -3247719, -18696448, -12055116,
-}
-
-// d2 is 2*d.
-var d2 = FieldElement{
- -21827239, -5839606, -30745221, 13898782, 229458, 15978800, -12551817, -6495438, 29715968, 9444199,
-}
-
-// SqrtM1 is the square-root of -1 in the field.
-var SqrtM1 = FieldElement{
- -32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
-}
-
-// A is a constant in the Montgomery-form of curve25519.
-var A = FieldElement{
- 486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-}
-
-// bi contains precomputed multiples of the base-point. See the Ed25519 paper
-// for a discussion about how these values are used.
-var bi = [8]PreComputedGroupElement{
- {
- FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
- FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
- FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
- },
- {
- FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
- FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
- FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
- },
- {
- FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
- FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
- FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
- },
- {
- FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
- FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
- FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
- },
- {
- FieldElement{-22518993, -6692182, 14201702, -8745502, -23510406, 8844726, 18474211, -1361450, -13062696, 13821877},
- FieldElement{-6455177, -7839871, 3374702, -4740862, -27098617, -10571707, 31655028, -7212327, 18853322, -14220951},
- FieldElement{4566830, -12963868, -28974889, -12240689, -7602672, -2830569, -8514358, -10431137, 2207753, -3209784},
- },
- {
- FieldElement{-25154831, -4185821, 29681144, 7868801, -6854661, -9423865, -12437364, -663000, -31111463, -16132436},
- FieldElement{25576264, -2703214, 7349804, -11814844, 16472782, 9300885, 3844789, 15725684, 171356, 6466918},
- FieldElement{23103977, 13316479, 9739013, -16149481, 817875, -15038942, 8965339, -14088058, -30714912, 16193877},
- },
- {
- FieldElement{-33521811, 3180713, -2394130, 14003687, -16903474, -16270840, 17238398, 4729455, -18074513, 9256800},
- FieldElement{-25182317, -4174131, 32336398, 5036987, -21236817, 11360617, 22616405, 9761698, -19827198, 630305},
- FieldElement{-13720693, 2639453, -24237460, -7406481, 9494427, -5774029, -6554551, -15960994, -2449256, -14291300},
- },
- {
- FieldElement{-3151181, -5046075, 9282714, 6866145, -31907062, -863023, -18940575, 15033784, 25105118, -7894876},
- FieldElement{-24326370, 15950226, -31801215, -14592823, -11662737, -5090925, 1573892, -2625887, 2198790, -15804619},
- FieldElement{-3099351, 10324967, -2241613, 7453183, -5446979, -2735503, -13812022, -16236442, -32461234, -12290683},
- },
-}
-
-// base contains precomputed multiples of the base-point. See the Ed25519 paper
-// for a discussion about how these values are used.
-var base = [32][8]PreComputedGroupElement{
- {
- {
- FieldElement{25967493, -14356035, 29566456, 3660896, -12694345, 4014787, 27544626, -11754271, -6079156, 2047605},
- FieldElement{-12545711, 934262, -2722910, 3049990, -727428, 9406986, 12720692, 5043384, 19500929, -15469378},
- FieldElement{-8738181, 4489570, 9688441, -14785194, 10184609, -12363380, 29287919, 11864899, -24514362, -4438546},
- },
- {
- FieldElement{-12815894, -12976347, -21581243, 11784320, -25355658, -2750717, -11717903, -3814571, -358445, -10211303},
- FieldElement{-21703237, 6903825, 27185491, 6451973, -29577724, -9554005, -15616551, 11189268, -26829678, -5319081},
- FieldElement{26966642, 11152617, 32442495, 15396054, 14353839, -12752335, -3128826, -9541118, -15472047, -4166697},
- },
- {
- FieldElement{15636291, -9688557, 24204773, -7912398, 616977, -16685262, 27787600, -14772189, 28944400, -1550024},
- FieldElement{16568933, 4717097, -11556148, -1102322, 15682896, -11807043, 16354577, -11775962, 7689662, 11199574},
- FieldElement{30464156, -5976125, -11779434, -15670865, 23220365, 15915852, 7512774, 10017326, -17749093, -9920357},
- },
- {
- FieldElement{-17036878, 13921892, 10945806, -6033431, 27105052, -16084379, -28926210, 15006023, 3284568, -6276540},
- FieldElement{23599295, -8306047, -11193664, -7687416, 13236774, 10506355, 7464579, 9656445, 13059162, 10374397},
- FieldElement{7798556, 16710257, 3033922, 2874086, 28997861, 2835604, 32406664, -3839045, -641708, -101325},
- },
- {
- FieldElement{10861363, 11473154, 27284546, 1981175, -30064349, 12577861, 32867885, 14515107, -15438304, 10819380},
- FieldElement{4708026, 6336745, 20377586, 9066809, -11272109, 6594696, -25653668, 12483688, -12668491, 5581306},
- FieldElement{19563160, 16186464, -29386857, 4097519, 10237984, -4348115, 28542350, 13850243, -23678021, -15815942},
- },
- {
- FieldElement{-15371964, -12862754, 32573250, 4720197, -26436522, 5875511, -19188627, -15224819, -9818940, -12085777},
- FieldElement{-8549212, 109983, 15149363, 2178705, 22900618, 4543417, 3044240, -15689887, 1762328, 14866737},
- FieldElement{-18199695, -15951423, -10473290, 1707278, -17185920, 3916101, -28236412, 3959421, 27914454, 4383652},
- },
- {
- FieldElement{5153746, 9909285, 1723747, -2777874, 30523605, 5516873, 19480852, 5230134, -23952439, -15175766},
- FieldElement{-30269007, -3463509, 7665486, 10083793, 28475525, 1649722, 20654025, 16520125, 30598449, 7715701},
- FieldElement{28881845, 14381568, 9657904, 3680757, -20181635, 7843316, -31400660, 1370708, 29794553, -1409300},
- },
- {
- FieldElement{14499471, -2729599, -33191113, -4254652, 28494862, 14271267, 30290735, 10876454, -33154098, 2381726},
- FieldElement{-7195431, -2655363, -14730155, 462251, -27724326, 3941372, -6236617, 3696005, -32300832, 15351955},
- FieldElement{27431194, 8222322, 16448760, -3907995, -18707002, 11938355, -32961401, -2970515, 29551813, 10109425},
- },
- },
- {
- {
- FieldElement{-13657040, -13155431, -31283750, 11777098, 21447386, 6519384, -2378284, -1627556, 10092783, -4764171},
- FieldElement{27939166, 14210322, 4677035, 16277044, -22964462, -12398139, -32508754, 12005538, -17810127, 12803510},
- FieldElement{17228999, -15661624, -1233527, 300140, -1224870, -11714777, 30364213, -9038194, 18016357, 4397660},
- },
- {
- FieldElement{-10958843, -7690207, 4776341, -14954238, 27850028, -15602212, -26619106, 14544525, -17477504, 982639},
- FieldElement{29253598, 15796703, -2863982, -9908884, 10057023, 3163536, 7332899, -4120128, -21047696, 9934963},
- FieldElement{5793303, 16271923, -24131614, -10116404, 29188560, 1206517, -14747930, 4559895, -30123922, -10897950},
- },
- {
- FieldElement{-27643952, -11493006, 16282657, -11036493, 28414021, -15012264, 24191034, 4541697, -13338309, 5500568},
- FieldElement{12650548, -1497113, 9052871, 11355358, -17680037, -8400164, -17430592, 12264343, 10874051, 13524335},
- FieldElement{25556948, -3045990, 714651, 2510400, 23394682, -10415330, 33119038, 5080568, -22528059, 5376628},
- },
- {
- FieldElement{-26088264, -4011052, -17013699, -3537628, -6726793, 1920897, -22321305, -9447443, 4535768, 1569007},
- FieldElement{-2255422, 14606630, -21692440, -8039818, 28430649, 8775819, -30494562, 3044290, 31848280, 12543772},
- FieldElement{-22028579, 2943893, -31857513, 6777306, 13784462, -4292203, -27377195, -2062731, 7718482, 14474653},
- },
- {
- FieldElement{2385315, 2454213, -22631320, 46603, -4437935, -15680415, 656965, -7236665, 24316168, -5253567},
- FieldElement{13741529, 10911568, -33233417, -8603737, -20177830, -1033297, 33040651, -13424532, -20729456, 8321686},
- FieldElement{21060490, -2212744, 15712757, -4336099, 1639040, 10656336, 23845965, -11874838, -9984458, 608372},
- },
- {
- FieldElement{-13672732, -15087586, -10889693, -7557059, -6036909, 11305547, 1123968, -6780577, 27229399, 23887},
- FieldElement{-23244140, -294205, -11744728, 14712571, -29465699, -2029617, 12797024, -6440308, -1633405, 16678954},
- FieldElement{-29500620, 4770662, -16054387, 14001338, 7830047, 9564805, -1508144, -4795045, -17169265, 4904953},
- },
- {
- FieldElement{24059557, 14617003, 19037157, -15039908, 19766093, -14906429, 5169211, 16191880, 2128236, -4326833},
- FieldElement{-16981152, 4124966, -8540610, -10653797, 30336522, -14105247, -29806336, 916033, -6882542, -2986532},
- FieldElement{-22630907, 12419372, -7134229, -7473371, -16478904, 16739175, 285431, 2763829, 15736322, 4143876},
- },
- {
- FieldElement{2379352, 11839345, -4110402, -5988665, 11274298, 794957, 212801, -14594663, 23527084, -16458268},
- FieldElement{33431127, -11130478, -17838966, -15626900, 8909499, 8376530, -32625340, 4087881, -15188911, -14416214},
- FieldElement{1767683, 7197987, -13205226, -2022635, -13091350, 448826, 5799055, 4357868, -4774191, -16323038},
- },
- },
- {
- {
- FieldElement{6721966, 13833823, -23523388, -1551314, 26354293, -11863321, 23365147, -3949732, 7390890, 2759800},
- FieldElement{4409041, 2052381, 23373853, 10530217, 7676779, -12885954, 21302353, -4264057, 1244380, -12919645},
- FieldElement{-4421239, 7169619, 4982368, -2957590, 30256825, -2777540, 14086413, 9208236, 15886429, 16489664},
- },
- {
- FieldElement{1996075, 10375649, 14346367, 13311202, -6874135, -16438411, -13693198, 398369, -30606455, -712933},
- FieldElement{-25307465, 9795880, -2777414, 14878809, -33531835, 14780363, 13348553, 12076947, -30836462, 5113182},
- FieldElement{-17770784, 11797796, 31950843, 13929123, -25888302, 12288344, -30341101, -7336386, 13847711, 5387222},
- },
- {
- FieldElement{-18582163, -3416217, 17824843, -2340966, 22744343, -10442611, 8763061, 3617786, -19600662, 10370991},
- FieldElement{20246567, -14369378, 22358229, -543712, 18507283, -10413996, 14554437, -8746092, 32232924, 16763880},
- FieldElement{9648505, 10094563, 26416693, 14745928, -30374318, -6472621, 11094161, 15689506, 3140038, -16510092},
- },
- {
- FieldElement{-16160072, 5472695, 31895588, 4744994, 8823515, 10365685, -27224800, 9448613, -28774454, 366295},
- FieldElement{19153450, 11523972, -11096490, -6503142, -24647631, 5420647, 28344573, 8041113, 719605, 11671788},
- FieldElement{8678025, 2694440, -6808014, 2517372, 4964326, 11152271, -15432916, -15266516, 27000813, -10195553},
- },
- {
- FieldElement{-15157904, 7134312, 8639287, -2814877, -7235688, 10421742, 564065, 5336097, 6750977, -14521026},
- FieldElement{11836410, -3979488, 26297894, 16080799, 23455045, 15735944, 1695823, -8819122, 8169720, 16220347},
- FieldElement{-18115838, 8653647, 17578566, -6092619, -8025777, -16012763, -11144307, -2627664, -5990708, -14166033},
- },
- {
- FieldElement{-23308498, -10968312, 15213228, -10081214, -30853605, -11050004, 27884329, 2847284, 2655861, 1738395},
- FieldElement{-27537433, -14253021, -25336301, -8002780, -9370762, 8129821, 21651608, -3239336, -19087449, -11005278},
- FieldElement{1533110, 3437855, 23735889, 459276, 29970501, 11335377, 26030092, 5821408, 10478196, 8544890},
- },
- {
- FieldElement{32173121, -16129311, 24896207, 3921497, 22579056, -3410854, 19270449, 12217473, 17789017, -3395995},
- FieldElement{-30552961, -2228401, -15578829, -10147201, 13243889, 517024, 15479401, -3853233, 30460520, 1052596},
- FieldElement{-11614875, 13323618, 32618793, 8175907, -15230173, 12596687, 27491595, -4612359, 3179268, -9478891},
- },
- {
- FieldElement{31947069, -14366651, -4640583, -15339921, -15125977, -6039709, -14756777, -16411740, 19072640, -9511060},
- FieldElement{11685058, 11822410, 3158003, -13952594, 33402194, -4165066, 5977896, -5215017, 473099, 5040608},
- FieldElement{-20290863, 8198642, -27410132, 11602123, 1290375, -2799760, 28326862, 1721092, -19558642, -3131606},
- },
- },
- {
- {
- FieldElement{7881532, 10687937, 7578723, 7738378, -18951012, -2553952, 21820786, 8076149, -27868496, 11538389},
- FieldElement{-19935666, 3899861, 18283497, -6801568, -15728660, -11249211, 8754525, 7446702, -5676054, 5797016},
- FieldElement{-11295600, -3793569, -15782110, -7964573, 12708869, -8456199, 2014099, -9050574, -2369172, -5877341},
- },
- {
- FieldElement{-22472376, -11568741, -27682020, 1146375, 18956691, 16640559, 1192730, -3714199, 15123619, 10811505},
- FieldElement{14352098, -3419715, -18942044, 10822655, 32750596, 4699007, -70363, 15776356, -28886779, -11974553},
- FieldElement{-28241164, -8072475, -4978962, -5315317, 29416931, 1847569, -20654173, -16484855, 4714547, -9600655},
- },
- {
- FieldElement{15200332, 8368572, 19679101, 15970074, -31872674, 1959451, 24611599, -4543832, -11745876, 12340220},
- FieldElement{12876937, -10480056, 33134381, 6590940, -6307776, 14872440, 9613953, 8241152, 15370987, 9608631},
- FieldElement{-4143277, -12014408, 8446281, -391603, 4407738, 13629032, -7724868, 15866074, -28210621, -8814099},
- },
- {
- FieldElement{26660628, -15677655, 8393734, 358047, -7401291, 992988, -23904233, 858697, 20571223, 8420556},
- FieldElement{14620715, 13067227, -15447274, 8264467, 14106269, 15080814, 33531827, 12516406, -21574435, -12476749},
- FieldElement{236881, 10476226, 57258, -14677024, 6472998, 2466984, 17258519, 7256740, 8791136, 15069930},
- },
- {
- FieldElement{1276410, -9371918, 22949635, -16322807, -23493039, -5702186, 14711875, 4874229, -30663140, -2331391},
- FieldElement{5855666, 4990204, -13711848, 7294284, -7804282, 1924647, -1423175, -7912378, -33069337, 9234253},
- FieldElement{20590503, -9018988, 31529744, -7352666, -2706834, 10650548, 31559055, -11609587, 18979186, 13396066},
- },
- {
- FieldElement{24474287, 4968103, 22267082, 4407354, 24063882, -8325180, -18816887, 13594782, 33514650, 7021958},
- FieldElement{-11566906, -6565505, -21365085, 15928892, -26158305, 4315421, -25948728, -3916677, -21480480, 12868082},
- FieldElement{-28635013, 13504661, 19988037, -2132761, 21078225, 6443208, -21446107, 2244500, -12455797, -8089383},
- },
- {
- FieldElement{-30595528, 13793479, -5852820, 319136, -25723172, -6263899, 33086546, 8957937, -15233648, 5540521},
- FieldElement{-11630176, -11503902, -8119500, -7643073, 2620056, 1022908, -23710744, -1568984, -16128528, -14962807},
- FieldElement{23152971, 775386, 27395463, 14006635, -9701118, 4649512, 1689819, 892185, -11513277, -15205948},
- },
- {
- FieldElement{9770129, 9586738, 26496094, 4324120, 1556511, -3550024, 27453819, 4763127, -19179614, 5867134},
- FieldElement{-32765025, 1927590, 31726409, -4753295, 23962434, -16019500, 27846559, 5931263, -29749703, -16108455},
- FieldElement{27461885, -2977536, 22380810, 1815854, -23033753, -3031938, 7283490, -15148073, -19526700, 7734629},
- },
- },
- {
- {
- FieldElement{-8010264, -9590817, -11120403, 6196038, 29344158, -13430885, 7585295, -3176626, 18549497, 15302069},
- FieldElement{-32658337, -6171222, -7672793, -11051681, 6258878, 13504381, 10458790, -6418461, -8872242, 8424746},
- FieldElement{24687205, 8613276, -30667046, -3233545, 1863892, -1830544, 19206234, 7134917, -11284482, -828919},
- },
- {
- FieldElement{11334899, -9218022, 8025293, 12707519, 17523892, -10476071, 10243738, -14685461, -5066034, 16498837},
- FieldElement{8911542, 6887158, -9584260, -6958590, 11145641, -9543680, 17303925, -14124238, 6536641, 10543906},
- FieldElement{-28946384, 15479763, -17466835, 568876, -1497683, 11223454, -2669190, -16625574, -27235709, 8876771},
- },
- {
- FieldElement{-25742899, -12566864, -15649966, -846607, -33026686, -796288, -33481822, 15824474, -604426, -9039817},
- FieldElement{10330056, 70051, 7957388, -9002667, 9764902, 15609756, 27698697, -4890037, 1657394, 3084098},
- FieldElement{10477963, -7470260, 12119566, -13250805, 29016247, -5365589, 31280319, 14396151, -30233575, 15272409},
- },
- {
- FieldElement{-12288309, 3169463, 28813183, 16658753, 25116432, -5630466, -25173957, -12636138, -25014757, 1950504},
- FieldElement{-26180358, 9489187, 11053416, -14746161, -31053720, 5825630, -8384306, -8767532, 15341279, 8373727},
- FieldElement{28685821, 7759505, -14378516, -12002860, -31971820, 4079242, 298136, -10232602, -2878207, 15190420},
- },
- {
- FieldElement{-32932876, 13806336, -14337485, -15794431, -24004620, 10940928, 8669718, 2742393, -26033313, -6875003},
- FieldElement{-1580388, -11729417, -25979658, -11445023, -17411874, -10912854, 9291594, -16247779, -12154742, 6048605},
- FieldElement{-30305315, 14843444, 1539301, 11864366, 20201677, 1900163, 13934231, 5128323, 11213262, 9168384},
- },
- {
- FieldElement{-26280513, 11007847, 19408960, -940758, -18592965, -4328580, -5088060, -11105150, 20470157, -16398701},
- FieldElement{-23136053, 9282192, 14855179, -15390078, -7362815, -14408560, -22783952, 14461608, 14042978, 5230683},
- FieldElement{29969567, -2741594, -16711867, -8552442, 9175486, -2468974, 21556951, 3506042, -5933891, -12449708},
- },
- {
- FieldElement{-3144746, 8744661, 19704003, 4581278, -20430686, 6830683, -21284170, 8971513, -28539189, 15326563},
- FieldElement{-19464629, 10110288, -17262528, -3503892, -23500387, 1355669, -15523050, 15300988, -20514118, 9168260},
- FieldElement{-5353335, 4488613, -23803248, 16314347, 7780487, -15638939, -28948358, 9601605, 33087103, -9011387},
- },
- {
- FieldElement{-19443170, -15512900, -20797467, -12445323, -29824447, 10229461, -27444329, -15000531, -5996870, 15664672},
- FieldElement{23294591, -16632613, -22650781, -8470978, 27844204, 11461195, 13099750, -2460356, 18151676, 13417686},
- FieldElement{-24722913, -4176517, -31150679, 5988919, -26858785, 6685065, 1661597, -12551441, 15271676, -15452665},
- },
- },
- {
- {
- FieldElement{11433042, -13228665, 8239631, -5279517, -1985436, -725718, -18698764, 2167544, -6921301, -13440182},
- FieldElement{-31436171, 15575146, 30436815, 12192228, -22463353, 9395379, -9917708, -8638997, 12215110, 12028277},
- FieldElement{14098400, 6555944, 23007258, 5757252, -15427832, -12950502, 30123440, 4617780, -16900089, -655628},
- },
- {
- FieldElement{-4026201, -15240835, 11893168, 13718664, -14809462, 1847385, -15819999, 10154009, 23973261, -12684474},
- FieldElement{-26531820, -3695990, -1908898, 2534301, -31870557, -16550355, 18341390, -11419951, 32013174, -10103539},
- FieldElement{-25479301, 10876443, -11771086, -14625140, -12369567, 1838104, 21911214, 6354752, 4425632, -837822},
- },
- {
- FieldElement{-10433389, -14612966, 22229858, -3091047, -13191166, 776729, -17415375, -12020462, 4725005, 14044970},
- FieldElement{19268650, -7304421, 1555349, 8692754, -21474059, -9910664, 6347390, -1411784, -19522291, -16109756},
- FieldElement{-24864089, 12986008, -10898878, -5558584, -11312371, -148526, 19541418, 8180106, 9282262, 10282508},
- },
- {
- FieldElement{-26205082, 4428547, -8661196, -13194263, 4098402, -14165257, 15522535, 8372215, 5542595, -10702683},
- FieldElement{-10562541, 14895633, 26814552, -16673850, -17480754, -2489360, -2781891, 6993761, -18093885, 10114655},
- FieldElement{-20107055, -929418, 31422704, 10427861, -7110749, 6150669, -29091755, -11529146, 25953725, -106158},
- },
- {
- FieldElement{-4234397, -8039292, -9119125, 3046000, 2101609, -12607294, 19390020, 6094296, -3315279, 12831125},
- FieldElement{-15998678, 7578152, 5310217, 14408357, -33548620, -224739, 31575954, 6326196, 7381791, -2421839},
- FieldElement{-20902779, 3296811, 24736065, -16328389, 18374254, 7318640, 6295303, 8082724, -15362489, 12339664},
- },
- {
- FieldElement{27724736, 2291157, 6088201, -14184798, 1792727, 5857634, 13848414, 15768922, 25091167, 14856294},
- FieldElement{-18866652, 8331043, 24373479, 8541013, -701998, -9269457, 12927300, -12695493, -22182473, -9012899},
- FieldElement{-11423429, -5421590, 11632845, 3405020, 30536730, -11674039, -27260765, 13866390, 30146206, 9142070},
- },
- {
- FieldElement{3924129, -15307516, -13817122, -10054960, 12291820, -668366, -27702774, 9326384, -8237858, 4171294},
- FieldElement{-15921940, 16037937, 6713787, 16606682, -21612135, 2790944, 26396185, 3731949, 345228, -5462949},
- FieldElement{-21327538, 13448259, 25284571, 1143661, 20614966, -8849387, 2031539, -12391231, -16253183, -13582083},
- },
- {
- FieldElement{31016211, -16722429, 26371392, -14451233, -5027349, 14854137, 17477601, 3842657, 28012650, -16405420},
- FieldElement{-5075835, 9368966, -8562079, -4600902, -15249953, 6970560, -9189873, 16292057, -8867157, 3507940},
- FieldElement{29439664, 3537914, 23333589, 6997794, -17555561, -11018068, -15209202, -15051267, -9164929, 6580396},
- },
- },
- {
- {
- FieldElement{-12185861, -7679788, 16438269, 10826160, -8696817, -6235611, 17860444, -9273846, -2095802, 9304567},
- FieldElement{20714564, -4336911, 29088195, 7406487, 11426967, -5095705, 14792667, -14608617, 5289421, -477127},
- FieldElement{-16665533, -10650790, -6160345, -13305760, 9192020, -1802462, 17271490, 12349094, 26939669, -3752294},
- },
- {
- FieldElement{-12889898, 9373458, 31595848, 16374215, 21471720, 13221525, -27283495, -12348559, -3698806, 117887},
- FieldElement{22263325, -6560050, 3984570, -11174646, -15114008, -566785, 28311253, 5358056, -23319780, 541964},
- FieldElement{16259219, 3261970, 2309254, -15534474, -16885711, -4581916, 24134070, -16705829, -13337066, -13552195},
- },
- {
- FieldElement{9378160, -13140186, -22845982, -12745264, 28198281, -7244098, -2399684, -717351, 690426, 14876244},
- FieldElement{24977353, -314384, -8223969, -13465086, 28432343, -1176353, -13068804, -12297348, -22380984, 6618999},
- FieldElement{-1538174, 11685646, 12944378, 13682314, -24389511, -14413193, 8044829, -13817328, 32239829, -5652762},
- },
- {
- FieldElement{-18603066, 4762990, -926250, 8885304, -28412480, -3187315, 9781647, -10350059, 32779359, 5095274},
- FieldElement{-33008130, -5214506, -32264887, -3685216, 9460461, -9327423, -24601656, 14506724, 21639561, -2630236},
- FieldElement{-16400943, -13112215, 25239338, 15531969, 3987758, -4499318, -1289502, -6863535, 17874574, 558605},
- },
- {
- FieldElement{-13600129, 10240081, 9171883, 16131053, -20869254, 9599700, 33499487, 5080151, 2085892, 5119761},
- FieldElement{-22205145, -2519528, -16381601, 414691, -25019550, 2170430, 30634760, -8363614, -31999993, -5759884},
- FieldElement{-6845704, 15791202, 8550074, -1312654, 29928809, -12092256, 27534430, -7192145, -22351378, 12961482},
- },
- {
- FieldElement{-24492060, -9570771, 10368194, 11582341, -23397293, -2245287, 16533930, 8206996, -30194652, -5159638},
- FieldElement{-11121496, -3382234, 2307366, 6362031, -135455, 8868177, -16835630, 7031275, 7589640, 8945490},
- FieldElement{-32152748, 8917967, 6661220, -11677616, -1192060, -15793393, 7251489, -11182180, 24099109, -14456170},
- },
- {
- FieldElement{5019558, -7907470, 4244127, -14714356, -26933272, 6453165, -19118182, -13289025, -6231896, -10280736},
- FieldElement{10853594, 10721687, 26480089, 5861829, -22995819, 1972175, -1866647, -10557898, -3363451, -6441124},
- FieldElement{-17002408, 5906790, 221599, -6563147, 7828208, -13248918, 24362661, -2008168, -13866408, 7421392},
- },
- {
- FieldElement{8139927, -6546497, 32257646, -5890546, 30375719, 1886181, -21175108, 15441252, 28826358, -4123029},
- FieldElement{6267086, 9695052, 7709135, -16603597, -32869068, -1886135, 14795160, -7840124, 13746021, -1742048},
- FieldElement{28584902, 7787108, -6732942, -15050729, 22846041, -7571236, -3181936, -363524, 4771362, -8419958},
- },
- },
- {
- {
- FieldElement{24949256, 6376279, -27466481, -8174608, -18646154, -9930606, 33543569, -12141695, 3569627, 11342593},
- FieldElement{26514989, 4740088, 27912651, 3697550, 19331575, -11472339, 6809886, 4608608, 7325975, -14801071},
- FieldElement{-11618399, -14554430, -24321212, 7655128, -1369274, 5214312, -27400540, 10258390, -17646694, -8186692},
- },
- {
- FieldElement{11431204, 15823007, 26570245, 14329124, 18029990, 4796082, -31446179, 15580664, 9280358, -3973687},
- FieldElement{-160783, -10326257, -22855316, -4304997, -20861367, -13621002, -32810901, -11181622, -15545091, 4387441},
- FieldElement{-20799378, 12194512, 3937617, -5805892, -27154820, 9340370, -24513992, 8548137, 20617071, -7482001},
- },
- {
- FieldElement{-938825, -3930586, -8714311, 16124718, 24603125, -6225393, -13775352, -11875822, 24345683, 10325460},
- FieldElement{-19855277, -1568885, -22202708, 8714034, 14007766, 6928528, 16318175, -1010689, 4766743, 3552007},
- FieldElement{-21751364, -16730916, 1351763, -803421, -4009670, 3950935, 3217514, 14481909, 10988822, -3994762},
- },
- {
- FieldElement{15564307, -14311570, 3101243, 5684148, 30446780, -8051356, 12677127, -6505343, -8295852, 13296005},
- FieldElement{-9442290, 6624296, -30298964, -11913677, -4670981, -2057379, 31521204, 9614054, -30000824, 12074674},
- FieldElement{4771191, -135239, 14290749, -13089852, 27992298, 14998318, -1413936, -1556716, 29832613, -16391035},
- },
- {
- FieldElement{7064884, -7541174, -19161962, -5067537, -18891269, -2912736, 25825242, 5293297, -27122660, 13101590},
- FieldElement{-2298563, 2439670, -7466610, 1719965, -27267541, -16328445, 32512469, -5317593, -30356070, -4190957},
- FieldElement{-30006540, 10162316, -33180176, 3981723, -16482138, -13070044, 14413974, 9515896, 19568978, 9628812},
- },
- {
- FieldElement{33053803, 199357, 15894591, 1583059, 27380243, -4580435, -17838894, -6106839, -6291786, 3437740},
- FieldElement{-18978877, 3884493, 19469877, 12726490, 15913552, 13614290, -22961733, 70104, 7463304, 4176122},
- FieldElement{-27124001, 10659917, 11482427, -16070381, 12771467, -6635117, -32719404, -5322751, 24216882, 5944158},
- },
- {
- FieldElement{8894125, 7450974, -2664149, -9765752, -28080517, -12389115, 19345746, 14680796, 11632993, 5847885},
- FieldElement{26942781, -2315317, 9129564, -4906607, 26024105, 11769399, -11518837, 6367194, -9727230, 4782140},
- FieldElement{19916461, -4828410, -22910704, -11414391, 25606324, -5972441, 33253853, 8220911, 6358847, -1873857},
- },
- {
- FieldElement{801428, -2081702, 16569428, 11065167, 29875704, 96627, 7908388, -4480480, -13538503, 1387155},
- FieldElement{19646058, 5720633, -11416706, 12814209, 11607948, 12749789, 14147075, 15156355, -21866831, 11835260},
- FieldElement{19299512, 1155910, 28703737, 14890794, 2925026, 7269399, 26121523, 15467869, -26560550, 5052483},
- },
- },
- {
- {
- FieldElement{-3017432, 10058206, 1980837, 3964243, 22160966, 12322533, -6431123, -12618185, 12228557, -7003677},
- FieldElement{32944382, 14922211, -22844894, 5188528, 21913450, -8719943, 4001465, 13238564, -6114803, 8653815},
- FieldElement{22865569, -4652735, 27603668, -12545395, 14348958, 8234005, 24808405, 5719875, 28483275, 2841751},
- },
- {
- FieldElement{-16420968, -1113305, -327719, -12107856, 21886282, -15552774, -1887966, -315658, 19932058, -12739203},
- FieldElement{-11656086, 10087521, -8864888, -5536143, -19278573, -3055912, 3999228, 13239134, -4777469, -13910208},
- FieldElement{1382174, -11694719, 17266790, 9194690, -13324356, 9720081, 20403944, 11284705, -14013818, 3093230},
- },
- {
- FieldElement{16650921, -11037932, -1064178, 1570629, -8329746, 7352753, -302424, 16271225, -24049421, -6691850},
- FieldElement{-21911077, -5927941, -4611316, -5560156, -31744103, -10785293, 24123614, 15193618, -21652117, -16739389},
- FieldElement{-9935934, -4289447, -25279823, 4372842, 2087473, 10399484, 31870908, 14690798, 17361620, 11864968},
- },
- {
- FieldElement{-11307610, 6210372, 13206574, 5806320, -29017692, -13967200, -12331205, -7486601, -25578460, -16240689},
- FieldElement{14668462, -12270235, 26039039, 15305210, 25515617, 4542480, 10453892, 6577524, 9145645, -6443880},
- FieldElement{5974874, 3053895, -9433049, -10385191, -31865124, 3225009, -7972642, 3936128, -5652273, -3050304},
- },
- {
- FieldElement{30625386, -4729400, -25555961, -12792866, -20484575, 7695099, 17097188, -16303496, -27999779, 1803632},
- FieldElement{-3553091, 9865099, -5228566, 4272701, -5673832, -16689700, 14911344, 12196514, -21405489, 7047412},
- FieldElement{20093277, 9920966, -11138194, -5343857, 13161587, 12044805, -32856851, 4124601, -32343828, -10257566},
- },
- {
- FieldElement{-20788824, 14084654, -13531713, 7842147, 19119038, -13822605, 4752377, -8714640, -21679658, 2288038},
- FieldElement{-26819236, -3283715, 29965059, 3039786, -14473765, 2540457, 29457502, 14625692, -24819617, 12570232},
- FieldElement{-1063558, -11551823, 16920318, 12494842, 1278292, -5869109, -21159943, -3498680, -11974704, 4724943},
- },
- {
- FieldElement{17960970, -11775534, -4140968, -9702530, -8876562, -1410617, -12907383, -8659932, -29576300, 1903856},
- FieldElement{23134274, -14279132, -10681997, -1611936, 20684485, 15770816, -12989750, 3190296, 26955097, 14109738},
- FieldElement{15308788, 5320727, -30113809, -14318877, 22902008, 7767164, 29425325, -11277562, 31960942, 11934971},
- },
- {
- FieldElement{-27395711, 8435796, 4109644, 12222639, -24627868, 14818669, 20638173, 4875028, 10491392, 1379718},
- FieldElement{-13159415, 9197841, 3875503, -8936108, -1383712, -5879801, 33518459, 16176658, 21432314, 12180697},
- FieldElement{-11787308, 11500838, 13787581, -13832590, -22430679, 10140205, 1465425, 12689540, -10301319, -13872883},
- },
- },
- {
- {
- FieldElement{5414091, -15386041, -21007664, 9643570, 12834970, 1186149, -2622916, -1342231, 26128231, 6032912},
- FieldElement{-26337395, -13766162, 32496025, -13653919, 17847801, -12669156, 3604025, 8316894, -25875034, -10437358},
- FieldElement{3296484, 6223048, 24680646, -12246460, -23052020, 5903205, -8862297, -4639164, 12376617, 3188849},
- },
- {
- FieldElement{29190488, -14659046, 27549113, -1183516, 3520066, -10697301, 32049515, -7309113, -16109234, -9852307},
- FieldElement{-14744486, -9309156, 735818, -598978, -20407687, -5057904, 25246078, -15795669, 18640741, -960977},
- FieldElement{-6928835, -16430795, 10361374, 5642961, 4910474, 12345252, -31638386, -494430, 10530747, 1053335},
- },
- {
- FieldElement{-29265967, -14186805, -13538216, -12117373, -19457059, -10655384, -31462369, -2948985, 24018831, 15026644},
- FieldElement{-22592535, -3145277, -2289276, 5953843, -13440189, 9425631, 25310643, 13003497, -2314791, -15145616},
- FieldElement{-27419985, -603321, -8043984, -1669117, -26092265, 13987819, -27297622, 187899, -23166419, -2531735},
- },
- {
- FieldElement{-21744398, -13810475, 1844840, 5021428, -10434399, -15911473, 9716667, 16266922, -5070217, 726099},
- FieldElement{29370922, -6053998, 7334071, -15342259, 9385287, 2247707, -13661962, -4839461, 30007388, -15823341},
- FieldElement{-936379, 16086691, 23751945, -543318, -1167538, -5189036, 9137109, 730663, 9835848, 4555336},
- },
- {
- FieldElement{-23376435, 1410446, -22253753, -12899614, 30867635, 15826977, 17693930, 544696, -11985298, 12422646},
- FieldElement{31117226, -12215734, -13502838, 6561947, -9876867, -12757670, -5118685, -4096706, 29120153, 13924425},
- FieldElement{-17400879, -14233209, 19675799, -2734756, -11006962, -5858820, -9383939, -11317700, 7240931, -237388},
- },
- {
- FieldElement{-31361739, -11346780, -15007447, -5856218, -22453340, -12152771, 1222336, 4389483, 3293637, -15551743},
- FieldElement{-16684801, -14444245, 11038544, 11054958, -13801175, -3338533, -24319580, 7733547, 12796905, -6335822},
- FieldElement{-8759414, -10817836, -25418864, 10783769, -30615557, -9746811, -28253339, 3647836, 3222231, -11160462},
- },
- {
- FieldElement{18606113, 1693100, -25448386, -15170272, 4112353, 10045021, 23603893, -2048234, -7550776, 2484985},
- FieldElement{9255317, -3131197, -12156162, -1004256, 13098013, -9214866, 16377220, -2102812, -19802075, -3034702},
- FieldElement{-22729289, 7496160, -5742199, 11329249, 19991973, -3347502, -31718148, 9936966, -30097688, -10618797},
- },
- {
- FieldElement{21878590, -5001297, 4338336, 13643897, -3036865, 13160960, 19708896, 5415497, -7360503, -4109293},
- FieldElement{27736861, 10103576, 12500508, 8502413, -3413016, -9633558, 10436918, -1550276, -23659143, -8132100},
- FieldElement{19492550, -12104365, -29681976, -852630, -3208171, 12403437, 30066266, 8367329, 13243957, 8709688},
- },
- },
- {
- {
- FieldElement{12015105, 2801261, 28198131, 10151021, 24818120, -4743133, -11194191, -5645734, 5150968, 7274186},
- FieldElement{2831366, -12492146, 1478975, 6122054, 23825128, -12733586, 31097299, 6083058, 31021603, -9793610},
- FieldElement{-2529932, -2229646, 445613, 10720828, -13849527, -11505937, -23507731, 16354465, 15067285, -14147707},
- },
- {
- FieldElement{7840942, 14037873, -33364863, 15934016, -728213, -3642706, 21403988, 1057586, -19379462, -12403220},
- FieldElement{915865, -16469274, 15608285, -8789130, -24357026, 6060030, -17371319, 8410997, -7220461, 16527025},
- FieldElement{32922597, -556987, 20336074, -16184568, 10903705, -5384487, 16957574, 52992, 23834301, 6588044},
- },
- {
- FieldElement{32752030, 11232950, 3381995, -8714866, 22652988, -10744103, 17159699, 16689107, -20314580, -1305992},
- FieldElement{-4689649, 9166776, -25710296, -10847306, 11576752, 12733943, 7924251, -2752281, 1976123, -7249027},
- FieldElement{21251222, 16309901, -2983015, -6783122, 30810597, 12967303, 156041, -3371252, 12331345, -8237197},
- },
- {
- FieldElement{8651614, -4477032, -16085636, -4996994, 13002507, 2950805, 29054427, -5106970, 10008136, -4667901},
- FieldElement{31486080, 15114593, -14261250, 12951354, 14369431, -7387845, 16347321, -13662089, 8684155, -10532952},
- FieldElement{19443825, 11385320, 24468943, -9659068, -23919258, 2187569, -26263207, -6086921, 31316348, 14219878},
- },
- {
- FieldElement{-28594490, 1193785, 32245219, 11392485, 31092169, 15722801, 27146014, 6992409, 29126555, 9207390},
- FieldElement{32382935, 1110093, 18477781, 11028262, -27411763, -7548111, -4980517, 10843782, -7957600, -14435730},
- FieldElement{2814918, 7836403, 27519878, -7868156, -20894015, -11553689, -21494559, 8550130, 28346258, 1994730},
- },
- {
- FieldElement{-19578299, 8085545, -14000519, -3948622, 2785838, -16231307, -19516951, 7174894, 22628102, 8115180},
- FieldElement{-30405132, 955511, -11133838, -15078069, -32447087, -13278079, -25651578, 3317160, -9943017, 930272},
- FieldElement{-15303681, -6833769, 28856490, 1357446, 23421993, 1057177, 24091212, -1388970, -22765376, -10650715},
- },
- {
- FieldElement{-22751231, -5303997, -12907607, -12768866, -15811511, -7797053, -14839018, -16554220, -1867018, 8398970},
- FieldElement{-31969310, 2106403, -4736360, 1362501, 12813763, 16200670, 22981545, -6291273, 18009408, -15772772},
- FieldElement{-17220923, -9545221, -27784654, 14166835, 29815394, 7444469, 29551787, -3727419, 19288549, 1325865},
- },
- {
- FieldElement{15100157, -15835752, -23923978, -1005098, -26450192, 15509408, 12376730, -3479146, 33166107, -8042750},
- FieldElement{20909231, 13023121, -9209752, 16251778, -5778415, -8094914, 12412151, 10018715, 2213263, -13878373},
- FieldElement{32529814, -11074689, 30361439, -16689753, -9135940, 1513226, 22922121, 6382134, -5766928, 8371348},
- },
- },
- {
- {
- FieldElement{9923462, 11271500, 12616794, 3544722, -29998368, -1721626, 12891687, -8193132, -26442943, 10486144},
- FieldElement{-22597207, -7012665, 8587003, -8257861, 4084309, -12970062, 361726, 2610596, -23921530, -11455195},
- FieldElement{5408411, -1136691, -4969122, 10561668, 24145918, 14240566, 31319731, -4235541, 19985175, -3436086},
- },
- {
- FieldElement{-13994457, 16616821, 14549246, 3341099, 32155958, 13648976, -17577068, 8849297, 65030, 8370684},
- FieldElement{-8320926, -12049626, 31204563, 5839400, -20627288, -1057277, -19442942, 6922164, 12743482, -9800518},
- FieldElement{-2361371, 12678785, 28815050, 4759974, -23893047, 4884717, 23783145, 11038569, 18800704, 255233},
- },
- {
- FieldElement{-5269658, -1773886, 13957886, 7990715, 23132995, 728773, 13393847, 9066957, 19258688, -14753793},
- FieldElement{-2936654, -10827535, -10432089, 14516793, -3640786, 4372541, -31934921, 2209390, -1524053, 2055794},
- FieldElement{580882, 16705327, 5468415, -2683018, -30926419, -14696000, -7203346, -8994389, -30021019, 7394435},
- },
- {
- FieldElement{23838809, 1822728, -15738443, 15242727, 8318092, -3733104, -21672180, -3492205, -4821741, 14799921},
- FieldElement{13345610, 9759151, 3371034, -16137791, 16353039, 8577942, 31129804, 13496856, -9056018, 7402518},
- FieldElement{2286874, -4435931, -20042458, -2008336, -13696227, 5038122, 11006906, -15760352, 8205061, 1607563},
- },
- {
- FieldElement{14414086, -8002132, 3331830, -3208217, 22249151, -5594188, 18364661, -2906958, 30019587, -9029278},
- FieldElement{-27688051, 1585953, -10775053, 931069, -29120221, -11002319, -14410829, 12029093, 9944378, 8024},
- FieldElement{4368715, -3709630, 29874200, -15022983, -20230386, -11410704, -16114594, -999085, -8142388, 5640030},
- },
- {
- FieldElement{10299610, 13746483, 11661824, 16234854, 7630238, 5998374, 9809887, -16694564, 15219798, -14327783},
- FieldElement{27425505, -5719081, 3055006, 10660664, 23458024, 595578, -15398605, -1173195, -18342183, 9742717},
- FieldElement{6744077, 2427284, 26042789, 2720740, -847906, 1118974, 32324614, 7406442, 12420155, 1994844},
- },
- {
- FieldElement{14012521, -5024720, -18384453, -9578469, -26485342, -3936439, -13033478, -10909803, 24319929, -6446333},
- FieldElement{16412690, -4507367, 10772641, 15929391, -17068788, -4658621, 10555945, -10484049, -30102368, -4739048},
- FieldElement{22397382, -7767684, -9293161, -12792868, 17166287, -9755136, -27333065, 6199366, 21880021, -12250760},
- },
- {
- FieldElement{-4283307, 5368523, -31117018, 8163389, -30323063, 3209128, 16557151, 8890729, 8840445, 4957760},
- FieldElement{-15447727, 709327, -6919446, -10870178, -29777922, 6522332, -21720181, 12130072, -14796503, 5005757},
- FieldElement{-2114751, -14308128, 23019042, 15765735, -25269683, 6002752, 10183197, -13239326, -16395286, -2176112},
- },
- },
- {
- {
- FieldElement{-19025756, 1632005, 13466291, -7995100, -23640451, 16573537, -32013908, -3057104, 22208662, 2000468},
- FieldElement{3065073, -1412761, -25598674, -361432, -17683065, -5703415, -8164212, 11248527, -3691214, -7414184},
- FieldElement{10379208, -6045554, 8877319, 1473647, -29291284, -12507580, 16690915, 2553332, -3132688, 16400289},
- },
- {
- FieldElement{15716668, 1254266, -18472690, 7446274, -8448918, 6344164, -22097271, -7285580, 26894937, 9132066},
- FieldElement{24158887, 12938817, 11085297, -8177598, -28063478, -4457083, -30576463, 64452, -6817084, -2692882},
- FieldElement{13488534, 7794716, 22236231, 5989356, 25426474, -12578208, 2350710, -3418511, -4688006, 2364226},
- },
- {
- FieldElement{16335052, 9132434, 25640582, 6678888, 1725628, 8517937, -11807024, -11697457, 15445875, -7798101},
- FieldElement{29004207, -7867081, 28661402, -640412, -12794003, -7943086, 31863255, -4135540, -278050, -15759279},
- FieldElement{-6122061, -14866665, -28614905, 14569919, -10857999, -3591829, 10343412, -6976290, -29828287, -10815811},
- },
- {
- FieldElement{27081650, 3463984, 14099042, -4517604, 1616303, -6205604, 29542636, 15372179, 17293797, 960709},
- FieldElement{20263915, 11434237, -5765435, 11236810, 13505955, -10857102, -16111345, 6493122, -19384511, 7639714},
- FieldElement{-2830798, -14839232, 25403038, -8215196, -8317012, -16173699, 18006287, -16043750, 29994677, -15808121},
- },
- {
- FieldElement{9769828, 5202651, -24157398, -13631392, -28051003, -11561624, -24613141, -13860782, -31184575, 709464},
- FieldElement{12286395, 13076066, -21775189, -1176622, -25003198, 4057652, -32018128, -8890874, 16102007, 13205847},
- FieldElement{13733362, 5599946, 10557076, 3195751, -5557991, 8536970, -25540170, 8525972, 10151379, 10394400},
- },
- {
- FieldElement{4024660, -16137551, 22436262, 12276534, -9099015, -2686099, 19698229, 11743039, -33302334, 8934414},
- FieldElement{-15879800, -4525240, -8580747, -2934061, 14634845, -698278, -9449077, 3137094, -11536886, 11721158},
- FieldElement{17555939, -5013938, 8268606, 2331751, -22738815, 9761013, 9319229, 8835153, -9205489, -1280045},
- },
- {
- FieldElement{-461409, -7830014, 20614118, 16688288, -7514766, -4807119, 22300304, 505429, 6108462, -6183415},
- FieldElement{-5070281, 12367917, -30663534, 3234473, 32617080, -8422642, 29880583, -13483331, -26898490, -7867459},
- FieldElement{-31975283, 5726539, 26934134, 10237677, -3173717, -605053, 24199304, 3795095, 7592688, -14992079},
- },
- {
- FieldElement{21594432, -14964228, 17466408, -4077222, 32537084, 2739898, 6407723, 12018833, -28256052, 4298412},
- FieldElement{-20650503, -11961496, -27236275, 570498, 3767144, -1717540, 13891942, -1569194, 13717174, 10805743},
- FieldElement{-14676630, -15644296, 15287174, 11927123, 24177847, -8175568, -796431, 14860609, -26938930, -5863836},
- },
- },
- {
- {
- FieldElement{12962541, 5311799, -10060768, 11658280, 18855286, -7954201, 13286263, -12808704, -4381056, 9882022},
- FieldElement{18512079, 11319350, -20123124, 15090309, 18818594, 5271736, -22727904, 3666879, -23967430, -3299429},
- FieldElement{-6789020, -3146043, 16192429, 13241070, 15898607, -14206114, -10084880, -6661110, -2403099, 5276065},
- },
- {
- FieldElement{30169808, -5317648, 26306206, -11750859, 27814964, 7069267, 7152851, 3684982, 1449224, 13082861},
- FieldElement{10342826, 3098505, 2119311, 193222, 25702612, 12233820, 23697382, 15056736, -21016438, -8202000},
- FieldElement{-33150110, 3261608, 22745853, 7948688, 19370557, -15177665, -26171976, 6482814, -10300080, -11060101},
- },
- {
- FieldElement{32869458, -5408545, 25609743, 15678670, -10687769, -15471071, 26112421, 2521008, -22664288, 6904815},
- FieldElement{29506923, 4457497, 3377935, -9796444, -30510046, 12935080, 1561737, 3841096, -29003639, -6657642},
- FieldElement{10340844, -6630377, -18656632, -2278430, 12621151, -13339055, 30878497, -11824370, -25584551, 5181966},
- },
- {
- FieldElement{25940115, -12658025, 17324188, -10307374, -8671468, 15029094, 24396252, -16450922, -2322852, -12388574},
- FieldElement{-21765684, 9916823, -1300409, 4079498, -1028346, 11909559, 1782390, 12641087, 20603771, -6561742},
- FieldElement{-18882287, -11673380, 24849422, 11501709, 13161720, -4768874, 1925523, 11914390, 4662781, 7820689},
- },
- {
- FieldElement{12241050, -425982, 8132691, 9393934, 32846760, -1599620, 29749456, 12172924, 16136752, 15264020},
- FieldElement{-10349955, -14680563, -8211979, 2330220, -17662549, -14545780, 10658213, 6671822, 19012087, 3772772},
- FieldElement{3753511, -3421066, 10617074, 2028709, 14841030, -6721664, 28718732, -15762884, 20527771, 12988982},
- },
- {
- FieldElement{-14822485, -5797269, -3707987, 12689773, -898983, -10914866, -24183046, -10564943, 3299665, -12424953},
- FieldElement{-16777703, -15253301, -9642417, 4978983, 3308785, 8755439, 6943197, 6461331, -25583147, 8991218},
- FieldElement{-17226263, 1816362, -1673288, -6086439, 31783888, -8175991, -32948145, 7417950, -30242287, 1507265},
- },
- {
- FieldElement{29692663, 6829891, -10498800, 4334896, 20945975, -11906496, -28887608, 8209391, 14606362, -10647073},
- FieldElement{-3481570, 8707081, 32188102, 5672294, 22096700, 1711240, -33020695, 9761487, 4170404, -2085325},
- FieldElement{-11587470, 14855945, -4127778, -1531857, -26649089, 15084046, 22186522, 16002000, -14276837, -8400798},
- },
- {
- FieldElement{-4811456, 13761029, -31703877, -2483919, -3312471, 7869047, -7113572, -9620092, 13240845, 10965870},
- FieldElement{-7742563, -8256762, -14768334, -13656260, -23232383, 12387166, 4498947, 14147411, 29514390, 4302863},
- FieldElement{-13413405, -12407859, 20757302, -13801832, 14785143, 8976368, -5061276, -2144373, 17846988, -13971927},
- },
- },
- {
- {
- FieldElement{-2244452, -754728, -4597030, -1066309, -6247172, 1455299, -21647728, -9214789, -5222701, 12650267},
- FieldElement{-9906797, -16070310, 21134160, 12198166, -27064575, 708126, 387813, 13770293, -19134326, 10958663},
- FieldElement{22470984, 12369526, 23446014, -5441109, -21520802, -9698723, -11772496, -11574455, -25083830, 4271862},
- },
- {
- FieldElement{-25169565, -10053642, -19909332, 15361595, -5984358, 2159192, 75375, -4278529, -32526221, 8469673},
- FieldElement{15854970, 4148314, -8893890, 7259002, 11666551, 13824734, -30531198, 2697372, 24154791, -9460943},
- FieldElement{15446137, -15806644, 29759747, 14019369, 30811221, -9610191, -31582008, 12840104, 24913809, 9815020},
- },
- {
- FieldElement{-4709286, -5614269, -31841498, -12288893, -14443537, 10799414, -9103676, 13438769, 18735128, 9466238},
- FieldElement{11933045, 9281483, 5081055, -5183824, -2628162, -4905629, -7727821, -10896103, -22728655, 16199064},
- FieldElement{14576810, 379472, -26786533, -8317236, -29426508, -10812974, -102766, 1876699, 30801119, 2164795},
- },
- {
- FieldElement{15995086, 3199873, 13672555, 13712240, -19378835, -4647646, -13081610, -15496269, -13492807, 1268052},
- FieldElement{-10290614, -3659039, -3286592, 10948818, 23037027, 3794475, -3470338, -12600221, -17055369, 3565904},
- FieldElement{29210088, -9419337, -5919792, -4952785, 10834811, -13327726, -16512102, -10820713, -27162222, -14030531},
- },
- {
- FieldElement{-13161890, 15508588, 16663704, -8156150, -28349942, 9019123, -29183421, -3769423, 2244111, -14001979},
- FieldElement{-5152875, -3800936, -9306475, -6071583, 16243069, 14684434, -25673088, -16180800, 13491506, 4641841},
- FieldElement{10813417, 643330, -19188515, -728916, 30292062, -16600078, 27548447, -7721242, 14476989, -12767431},
- },
- {
- FieldElement{10292079, 9984945, 6481436, 8279905, -7251514, 7032743, 27282937, -1644259, -27912810, 12651324},
- FieldElement{-31185513, -813383, 22271204, 11835308, 10201545, 15351028, 17099662, 3988035, 21721536, -3148940},
- FieldElement{10202177, -6545839, -31373232, -9574638, -32150642, -8119683, -12906320, 3852694, 13216206, 14842320},
- },
- {
- FieldElement{-15815640, -10601066, -6538952, -7258995, -6984659, -6581778, -31500847, 13765824, -27434397, 9900184},
- FieldElement{14465505, -13833331, -32133984, -14738873, -27443187, 12990492, 33046193, 15796406, -7051866, -8040114},
- FieldElement{30924417, -8279620, 6359016, -12816335, 16508377, 9071735, -25488601, 15413635, 9524356, -7018878},
- },
- {
- FieldElement{12274201, -13175547, 32627641, -1785326, 6736625, 13267305, 5237659, -5109483, 15663516, 4035784},
- FieldElement{-2951309, 8903985, 17349946, 601635, -16432815, -4612556, -13732739, -15889334, -22258478, 4659091},
- FieldElement{-16916263, -4952973, -30393711, -15158821, 20774812, 15897498, 5736189, 15026997, -2178256, -13455585},
- },
- },
- {
- {
- FieldElement{-8858980, -2219056, 28571666, -10155518, -474467, -10105698, -3801496, 278095, 23440562, -290208},
- FieldElement{10226241, -5928702, 15139956, 120818, -14867693, 5218603, 32937275, 11551483, -16571960, -7442864},
- FieldElement{17932739, -12437276, -24039557, 10749060, 11316803, 7535897, 22503767, 5561594, -3646624, 3898661},
- },
- {
- FieldElement{7749907, -969567, -16339731, -16464, -25018111, 15122143, -1573531, 7152530, 21831162, 1245233},
- FieldElement{26958459, -14658026, 4314586, 8346991, -5677764, 11960072, -32589295, -620035, -30402091, -16716212},
- FieldElement{-12165896, 9166947, 33491384, 13673479, 29787085, 13096535, 6280834, 14587357, -22338025, 13987525},
- },
- {
- FieldElement{-24349909, 7778775, 21116000, 15572597, -4833266, -5357778, -4300898, -5124639, -7469781, -2858068},
- FieldElement{9681908, -6737123, -31951644, 13591838, -6883821, 386950, 31622781, 6439245, -14581012, 4091397},
- FieldElement{-8426427, 1470727, -28109679, -1596990, 3978627, -5123623, -19622683, 12092163, 29077877, -14741988},
- },
- {
- FieldElement{5269168, -6859726, -13230211, -8020715, 25932563, 1763552, -5606110, -5505881, -20017847, 2357889},
- FieldElement{32264008, -15407652, -5387735, -1160093, -2091322, -3946900, 23104804, -12869908, 5727338, 189038},
- FieldElement{14609123, -8954470, -6000566, -16622781, -14577387, -7743898, -26745169, 10942115, -25888931, -14884697},
- },
- {
- FieldElement{20513500, 5557931, -15604613, 7829531, 26413943, -2019404, -21378968, 7471781, 13913677, -5137875},
- FieldElement{-25574376, 11967826, 29233242, 12948236, -6754465, 4713227, -8940970, 14059180, 12878652, 8511905},
- FieldElement{-25656801, 3393631, -2955415, -7075526, -2250709, 9366908, -30223418, 6812974, 5568676, -3127656},
- },
- {
- FieldElement{11630004, 12144454, 2116339, 13606037, 27378885, 15676917, -17408753, -13504373, -14395196, 8070818},
- FieldElement{27117696, -10007378, -31282771, -5570088, 1127282, 12772488, -29845906, 10483306, -11552749, -1028714},
- FieldElement{10637467, -5688064, 5674781, 1072708, -26343588, -6982302, -1683975, 9177853, -27493162, 15431203},
- },
- {
- FieldElement{20525145, 10892566, -12742472, 12779443, -29493034, 16150075, -28240519, 14943142, -15056790, -7935931},
- FieldElement{-30024462, 5626926, -551567, -9981087, 753598, 11981191, 25244767, -3239766, -3356550, 9594024},
- FieldElement{-23752644, 2636870, -5163910, -10103818, 585134, 7877383, 11345683, -6492290, 13352335, -10977084},
- },
- {
- FieldElement{-1931799, -5407458, 3304649, -12884869, 17015806, -4877091, -29783850, -7752482, -13215537, -319204},
- FieldElement{20239939, 6607058, 6203985, 3483793, -18386976, -779229, -20723742, 15077870, -22750759, 14523817},
- FieldElement{27406042, -6041657, 27423596, -4497394, 4996214, 10002360, -28842031, -4545494, -30172742, -4805667},
- },
- },
- {
- {
- FieldElement{11374242, 12660715, 17861383, -12540833, 10935568, 1099227, -13886076, -9091740, -27727044, 11358504},
- FieldElement{-12730809, 10311867, 1510375, 10778093, -2119455, -9145702, 32676003, 11149336, -26123651, 4985768},
- FieldElement{-19096303, 341147, -6197485, -239033, 15756973, -8796662, -983043, 13794114, -19414307, -15621255},
- },
- {
- FieldElement{6490081, 11940286, 25495923, -7726360, 8668373, -8751316, 3367603, 6970005, -1691065, -9004790},
- FieldElement{1656497, 13457317, 15370807, 6364910, 13605745, 8362338, -19174622, -5475723, -16796596, -5031438},
- FieldElement{-22273315, -13524424, -64685, -4334223, -18605636, -10921968, -20571065, -7007978, -99853, -10237333},
- },
- {
- FieldElement{17747465, 10039260, 19368299, -4050591, -20630635, -16041286, 31992683, -15857976, -29260363, -5511971},
- FieldElement{31932027, -4986141, -19612382, 16366580, 22023614, 88450, 11371999, -3744247, 4882242, -10626905},
- FieldElement{29796507, 37186, 19818052, 10115756, -11829032, 3352736, 18551198, 3272828, -5190932, -4162409},
- },
- {
- FieldElement{12501286, 4044383, -8612957, -13392385, -32430052, 5136599, -19230378, -3529697, 330070, -3659409},
- FieldElement{6384877, 2899513, 17807477, 7663917, -2358888, 12363165, 25366522, -8573892, -271295, 12071499},
- FieldElement{-8365515, -4042521, 25133448, -4517355, -6211027, 2265927, -32769618, 1936675, -5159697, 3829363},
- },
- {
- FieldElement{28425966, -5835433, -577090, -4697198, -14217555, 6870930, 7921550, -6567787, 26333140, 14267664},
- FieldElement{-11067219, 11871231, 27385719, -10559544, -4585914, -11189312, 10004786, -8709488, -21761224, 8930324},
- FieldElement{-21197785, -16396035, 25654216, -1725397, 12282012, 11008919, 1541940, 4757911, -26491501, -16408940},
- },
- {
- FieldElement{13537262, -7759490, -20604840, 10961927, -5922820, -13218065, -13156584, 6217254, -15943699, 13814990},
- FieldElement{-17422573, 15157790, 18705543, 29619, 24409717, -260476, 27361681, 9257833, -1956526, -1776914},
- FieldElement{-25045300, -10191966, 15366585, 15166509, -13105086, 8423556, -29171540, 12361135, -18685978, 4578290},
- },
- {
- FieldElement{24579768, 3711570, 1342322, -11180126, -27005135, 14124956, -22544529, 14074919, 21964432, 8235257},
- FieldElement{-6528613, -2411497, 9442966, -5925588, 12025640, -1487420, -2981514, -1669206, 13006806, 2355433},
- FieldElement{-16304899, -13605259, -6632427, -5142349, 16974359, -10911083, 27202044, 1719366, 1141648, -12796236},
- },
- {
- FieldElement{-12863944, -13219986, -8318266, -11018091, -6810145, -4843894, 13475066, -3133972, 32674895, 13715045},
- FieldElement{11423335, -5468059, 32344216, 8962751, 24989809, 9241752, -13265253, 16086212, -28740881, -15642093},
- FieldElement{-1409668, 12530728, -6368726, 10847387, 19531186, -14132160, -11709148, 7791794, -27245943, 4383347},
- },
- },
- {
- {
- FieldElement{-28970898, 5271447, -1266009, -9736989, -12455236, 16732599, -4862407, -4906449, 27193557, 6245191},
- FieldElement{-15193956, 5362278, -1783893, 2695834, 4960227, 12840725, 23061898, 3260492, 22510453, 8577507},
- FieldElement{-12632451, 11257346, -32692994, 13548177, -721004, 10879011, 31168030, 13952092, -29571492, -3635906},
- },
- {
- FieldElement{3877321, -9572739, 32416692, 5405324, -11004407, -13656635, 3759769, 11935320, 5611860, 8164018},
- FieldElement{-16275802, 14667797, 15906460, 12155291, -22111149, -9039718, 32003002, -8832289, 5773085, -8422109},
- FieldElement{-23788118, -8254300, 1950875, 8937633, 18686727, 16459170, -905725, 12376320, 31632953, 190926},
- },
- {
- FieldElement{-24593607, -16138885, -8423991, 13378746, 14162407, 6901328, -8288749, 4508564, -25341555, -3627528},
- FieldElement{8884438, -5884009, 6023974, 10104341, -6881569, -4941533, 18722941, -14786005, -1672488, 827625},
- FieldElement{-32720583, -16289296, -32503547, 7101210, 13354605, 2659080, -1800575, -14108036, -24878478, 1541286},
- },
- {
- FieldElement{2901347, -1117687, 3880376, -10059388, -17620940, -3612781, -21802117, -3567481, 20456845, -1885033},
- FieldElement{27019610, 12299467, -13658288, -1603234, -12861660, -4861471, -19540150, -5016058, 29439641, 15138866},
- FieldElement{21536104, -6626420, -32447818, -10690208, -22408077, 5175814, -5420040, -16361163, 7779328, 109896},
- },
- {
- FieldElement{30279744, 14648750, -8044871, 6425558, 13639621, -743509, 28698390, 12180118, 23177719, -554075},
- FieldElement{26572847, 3405927, -31701700, 12890905, -19265668, 5335866, -6493768, 2378492, 4439158, -13279347},
- FieldElement{-22716706, 3489070, -9225266, -332753, 18875722, -1140095, 14819434, -12731527, -17717757, -5461437},
- },
- {
- FieldElement{-5056483, 16566551, 15953661, 3767752, -10436499, 15627060, -820954, 2177225, 8550082, -15114165},
- FieldElement{-18473302, 16596775, -381660, 15663611, 22860960, 15585581, -27844109, -3582739, -23260460, -8428588},
- FieldElement{-32480551, 15707275, -8205912, -5652081, 29464558, 2713815, -22725137, 15860482, -21902570, 1494193},
- },
- {
- FieldElement{-19562091, -14087393, -25583872, -9299552, 13127842, 759709, 21923482, 16529112, 8742704, 12967017},
- FieldElement{-28464899, 1553205, 32536856, -10473729, -24691605, -406174, -8914625, -2933896, -29903758, 15553883},
- FieldElement{21877909, 3230008, 9881174, 10539357, -4797115, 2841332, 11543572, 14513274, 19375923, -12647961},
- },
- {
- FieldElement{8832269, -14495485, 13253511, 5137575, 5037871, 4078777, 24880818, -6222716, 2862653, 9455043},
- FieldElement{29306751, 5123106, 20245049, -14149889, 9592566, 8447059, -2077124, -2990080, 15511449, 4789663},
- FieldElement{-20679756, 7004547, 8824831, -9434977, -4045704, -3750736, -5754762, 108893, 23513200, 16652362},
- },
- },
- {
- {
- FieldElement{-33256173, 4144782, -4476029, -6579123, 10770039, -7155542, -6650416, -12936300, -18319198, 10212860},
- FieldElement{2756081, 8598110, 7383731, -6859892, 22312759, -1105012, 21179801, 2600940, -9988298, -12506466},
- FieldElement{-24645692, 13317462, -30449259, -15653928, 21365574, -10869657, 11344424, 864440, -2499677, -16710063},
- },
- {
- FieldElement{-26432803, 6148329, -17184412, -14474154, 18782929, -275997, -22561534, 211300, 2719757, 4940997},
- FieldElement{-1323882, 3911313, -6948744, 14759765, -30027150, 7851207, 21690126, 8518463, 26699843, 5276295},
- FieldElement{-13149873, -6429067, 9396249, 365013, 24703301, -10488939, 1321586, 149635, -15452774, 7159369},
- },
- {
- FieldElement{9987780, -3404759, 17507962, 9505530, 9731535, -2165514, 22356009, 8312176, 22477218, -8403385},
- FieldElement{18155857, -16504990, 19744716, 9006923, 15154154, -10538976, 24256460, -4864995, -22548173, 9334109},
- FieldElement{2986088, -4911893, 10776628, -3473844, 10620590, -7083203, -21413845, 14253545, -22587149, 536906},
- },
- {
- FieldElement{4377756, 8115836, 24567078, 15495314, 11625074, 13064599, 7390551, 10589625, 10838060, -15420424},
- FieldElement{-19342404, 867880, 9277171, -3218459, -14431572, -1986443, 19295826, -15796950, 6378260, 699185},
- FieldElement{7895026, 4057113, -7081772, -13077756, -17886831, -323126, -716039, 15693155, -5045064, -13373962},
- },
- {
- FieldElement{-7737563, -5869402, -14566319, -7406919, 11385654, 13201616, 31730678, -10962840, -3918636, -9669325},
- FieldElement{10188286, -15770834, -7336361, 13427543, 22223443, 14896287, 30743455, 7116568, -21786507, 5427593},
- FieldElement{696102, 13206899, 27047647, -10632082, 15285305, -9853179, 10798490, -4578720, 19236243, 12477404},
- },
- {
- FieldElement{-11229439, 11243796, -17054270, -8040865, -788228, -8167967, -3897669, 11180504, -23169516, 7733644},
- FieldElement{17800790, -14036179, -27000429, -11766671, 23887827, 3149671, 23466177, -10538171, 10322027, 15313801},
- FieldElement{26246234, 11968874, 32263343, -5468728, 6830755, -13323031, -15794704, -101982, -24449242, 10890804},
- },
- {
- FieldElement{-31365647, 10271363, -12660625, -6267268, 16690207, -13062544, -14982212, 16484931, 25180797, -5334884},
- FieldElement{-586574, 10376444, -32586414, -11286356, 19801893, 10997610, 2276632, 9482883, 316878, 13820577},
- FieldElement{-9882808, -4510367, -2115506, 16457136, -11100081, 11674996, 30756178, -7515054, 30696930, -3712849},
- },
- {
- FieldElement{32988917, -9603412, 12499366, 7910787, -10617257, -11931514, -7342816, -9985397, -32349517, 7392473},
- FieldElement{-8855661, 15927861, 9866406, -3649411, -2396914, -16655781, -30409476, -9134995, 25112947, -2926644},
- FieldElement{-2504044, -436966, 25621774, -5678772, 15085042, -5479877, -24884878, -13526194, 5537438, -13914319},
- },
- },
- {
- {
- FieldElement{-11225584, 2320285, -9584280, 10149187, -33444663, 5808648, -14876251, -1729667, 31234590, 6090599},
- FieldElement{-9633316, 116426, 26083934, 2897444, -6364437, -2688086, 609721, 15878753, -6970405, -9034768},
- FieldElement{-27757857, 247744, -15194774, -9002551, 23288161, -10011936, -23869595, 6503646, 20650474, 1804084},
- },
- {
- FieldElement{-27589786, 15456424, 8972517, 8469608, 15640622, 4439847, 3121995, -10329713, 27842616, -202328},
- FieldElement{-15306973, 2839644, 22530074, 10026331, 4602058, 5048462, 28248656, 5031932, -11375082, 12714369},
- FieldElement{20807691, -7270825, 29286141, 11421711, -27876523, -13868230, -21227475, 1035546, -19733229, 12796920},
- },
- {
- FieldElement{12076899, -14301286, -8785001, -11848922, -25012791, 16400684, -17591495, -12899438, 3480665, -15182815},
- FieldElement{-32361549, 5457597, 28548107, 7833186, 7303070, -11953545, -24363064, -15921875, -33374054, 2771025},
- FieldElement{-21389266, 421932, 26597266, 6860826, 22486084, -6737172, -17137485, -4210226, -24552282, 15673397},
- },
- {
- FieldElement{-20184622, 2338216, 19788685, -9620956, -4001265, -8740893, -20271184, 4733254, 3727144, -12934448},
- FieldElement{6120119, 814863, -11794402, -622716, 6812205, -15747771, 2019594, 7975683, 31123697, -10958981},
- FieldElement{30069250, -11435332, 30434654, 2958439, 18399564, -976289, 12296869, 9204260, -16432438, 9648165},
- },
- {
- FieldElement{32705432, -1550977, 30705658, 7451065, -11805606, 9631813, 3305266, 5248604, -26008332, -11377501},
- FieldElement{17219865, 2375039, -31570947, -5575615, -19459679, 9219903, 294711, 15298639, 2662509, -16297073},
- FieldElement{-1172927, -7558695, -4366770, -4287744, -21346413, -8434326, 32087529, -1222777, 32247248, -14389861},
- },
- {
- FieldElement{14312628, 1221556, 17395390, -8700143, -4945741, -8684635, -28197744, -9637817, -16027623, -13378845},
- FieldElement{-1428825, -9678990, -9235681, 6549687, -7383069, -468664, 23046502, 9803137, 17597934, 2346211},
- FieldElement{18510800, 15337574, 26171504, 981392, -22241552, 7827556, -23491134, -11323352, 3059833, -11782870},
- },
- {
- FieldElement{10141598, 6082907, 17829293, -1947643, 9830092, 13613136, -25556636, -5544586, -33502212, 3592096},
- FieldElement{33114168, -15889352, -26525686, -13343397, 33076705, 8716171, 1151462, 1521897, -982665, -6837803},
- FieldElement{-32939165, -4255815, 23947181, -324178, -33072974, -12305637, -16637686, 3891704, 26353178, 693168},
- },
- {
- FieldElement{30374239, 1595580, -16884039, 13186931, 4600344, 406904, 9585294, -400668, 31375464, 14369965},
- FieldElement{-14370654, -7772529, 1510301, 6434173, -18784789, -6262728, 32732230, -13108839, 17901441, 16011505},
- FieldElement{18171223, -11934626, -12500402, 15197122, -11038147, -15230035, -19172240, -16046376, 8764035, 12309598},
- },
- },
- {
- {
- FieldElement{5975908, -5243188, -19459362, -9681747, -11541277, 14015782, -23665757, 1228319, 17544096, -10593782},
- FieldElement{5811932, -1715293, 3442887, -2269310, -18367348, -8359541, -18044043, -15410127, -5565381, 12348900},
- FieldElement{-31399660, 11407555, 25755363, 6891399, -3256938, 14872274, -24849353, 8141295, -10632534, -585479},
- },
- {
- FieldElement{-12675304, 694026, -5076145, 13300344, 14015258, -14451394, -9698672, -11329050, 30944593, 1130208},
- FieldElement{8247766, -6710942, -26562381, -7709309, -14401939, -14648910, 4652152, 2488540, 23550156, -271232},
- FieldElement{17294316, -3788438, 7026748, 15626851, 22990044, 113481, 2267737, -5908146, -408818, -137719},
- },
- {
- FieldElement{16091085, -16253926, 18599252, 7340678, 2137637, -1221657, -3364161, 14550936, 3260525, -7166271},
- FieldElement{-4910104, -13332887, 18550887, 10864893, -16459325, -7291596, -23028869, -13204905, -12748722, 2701326},
- FieldElement{-8574695, 16099415, 4629974, -16340524, -20786213, -6005432, -10018363, 9276971, 11329923, 1862132},
- },
- {
- FieldElement{14763076, -15903608, -30918270, 3689867, 3511892, 10313526, -21951088, 12219231, -9037963, -940300},
- FieldElement{8894987, -3446094, 6150753, 3013931, 301220, 15693451, -31981216, -2909717, -15438168, 11595570},
- FieldElement{15214962, 3537601, -26238722, -14058872, 4418657, -15230761, 13947276, 10730794, -13489462, -4363670},
- },
- {
- FieldElement{-2538306, 7682793, 32759013, 263109, -29984731, -7955452, -22332124, -10188635, 977108, 699994},
- FieldElement{-12466472, 4195084, -9211532, 550904, -15565337, 12917920, 19118110, -439841, -30534533, -14337913},
- FieldElement{31788461, -14507657, 4799989, 7372237, 8808585, -14747943, 9408237, -10051775, 12493932, -5409317},
- },
- {
- FieldElement{-25680606, 5260744, -19235809, -6284470, -3695942, 16566087, 27218280, 2607121, 29375955, 6024730},
- FieldElement{842132, -2794693, -4763381, -8722815, 26332018, -12405641, 11831880, 6985184, -9940361, 2854096},
- FieldElement{-4847262, -7969331, 2516242, -5847713, 9695691, -7221186, 16512645, 960770, 12121869, 16648078},
- },
- {
- FieldElement{-15218652, 14667096, -13336229, 2013717, 30598287, -464137, -31504922, -7882064, 20237806, 2838411},
- FieldElement{-19288047, 4453152, 15298546, -16178388, 22115043, -15972604, 12544294, -13470457, 1068881, -12499905},
- FieldElement{-9558883, -16518835, 33238498, 13506958, 30505848, -1114596, -8486907, -2630053, 12521378, 4845654},
- },
- {
- FieldElement{-28198521, 10744108, -2958380, 10199664, 7759311, -13088600, 3409348, -873400, -6482306, -12885870},
- FieldElement{-23561822, 6230156, -20382013, 10655314, -24040585, -11621172, 10477734, -1240216, -3113227, 13974498},
- FieldElement{12966261, 15550616, -32038948, -1615346, 21025980, -629444, 5642325, 7188737, 18895762, 12629579},
- },
- },
- {
- {
- FieldElement{14741879, -14946887, 22177208, -11721237, 1279741, 8058600, 11758140, 789443, 32195181, 3895677},
- FieldElement{10758205, 15755439, -4509950, 9243698, -4879422, 6879879, -2204575, -3566119, -8982069, 4429647},
- FieldElement{-2453894, 15725973, -20436342, -10410672, -5803908, -11040220, -7135870, -11642895, 18047436, -15281743},
- },
- {
- FieldElement{-25173001, -11307165, 29759956, 11776784, -22262383, -15820455, 10993114, -12850837, -17620701, -9408468},
- FieldElement{21987233, 700364, -24505048, 14972008, -7774265, -5718395, 32155026, 2581431, -29958985, 8773375},
- FieldElement{-25568350, 454463, -13211935, 16126715, 25240068, 8594567, 20656846, 12017935, -7874389, -13920155},
- },
- {
- FieldElement{6028182, 6263078, -31011806, -11301710, -818919, 2461772, -31841174, -5468042, -1721788, -2776725},
- FieldElement{-12278994, 16624277, 987579, -5922598, 32908203, 1248608, 7719845, -4166698, 28408820, 6816612},
- FieldElement{-10358094, -8237829, 19549651, -12169222, 22082623, 16147817, 20613181, 13982702, -10339570, 5067943},
- },
- {
- FieldElement{-30505967, -3821767, 12074681, 13582412, -19877972, 2443951, -19719286, 12746132, 5331210, -10105944},
- FieldElement{30528811, 3601899, -1957090, 4619785, -27361822, -15436388, 24180793, -12570394, 27679908, -1648928},
- FieldElement{9402404, -13957065, 32834043, 10838634, -26580150, -13237195, 26653274, -8685565, 22611444, -12715406},
- },
- {
- FieldElement{22190590, 1118029, 22736441, 15130463, -30460692, -5991321, 19189625, -4648942, 4854859, 6622139},
- FieldElement{-8310738, -2953450, -8262579, -3388049, -10401731, -271929, 13424426, -3567227, 26404409, 13001963},
- FieldElement{-31241838, -15415700, -2994250, 8939346, 11562230, -12840670, -26064365, -11621720, -15405155, 11020693},
- },
- {
- FieldElement{1866042, -7949489, -7898649, -10301010, 12483315, 13477547, 3175636, -12424163, 28761762, 1406734},
- FieldElement{-448555, -1777666, 13018551, 3194501, -9580420, -11161737, 24760585, -4347088, 25577411, -13378680},
- FieldElement{-24290378, 4759345, -690653, -1852816, 2066747, 10693769, -29595790, 9884936, -9368926, 4745410},
- },
- {
- FieldElement{-9141284, 6049714, -19531061, -4341411, -31260798, 9944276, -15462008, -11311852, 10931924, -11931931},
- FieldElement{-16561513, 14112680, -8012645, 4817318, -8040464, -11414606, -22853429, 10856641, -20470770, 13434654},
- FieldElement{22759489, -10073434, -16766264, -1871422, 13637442, -10168091, 1765144, -12654326, 28445307, -5364710},
- },
- {
- FieldElement{29875063, 12493613, 2795536, -3786330, 1710620, 15181182, -10195717, -8788675, 9074234, 1167180},
- FieldElement{-26205683, 11014233, -9842651, -2635485, -26908120, 7532294, -18716888, -9535498, 3843903, 9367684},
- FieldElement{-10969595, -6403711, 9591134, 9582310, 11349256, 108879, 16235123, 8601684, -139197, 4242895},
- },
- },
- {
- {
- FieldElement{22092954, -13191123, -2042793, -11968512, 32186753, -11517388, -6574341, 2470660, -27417366, 16625501},
- FieldElement{-11057722, 3042016, 13770083, -9257922, 584236, -544855, -7770857, 2602725, -27351616, 14247413},
- FieldElement{6314175, -10264892, -32772502, 15957557, -10157730, 168750, -8618807, 14290061, 27108877, -1180880},
- },
- {
- FieldElement{-8586597, -7170966, 13241782, 10960156, -32991015, -13794596, 33547976, -11058889, -27148451, 981874},
- FieldElement{22833440, 9293594, -32649448, -13618667, -9136966, 14756819, -22928859, -13970780, -10479804, -16197962},
- FieldElement{-7768587, 3326786, -28111797, 10783824, 19178761, 14905060, 22680049, 13906969, -15933690, 3797899},
- },
- {
- FieldElement{21721356, -4212746, -12206123, 9310182, -3882239, -13653110, 23740224, -2709232, 20491983, -8042152},
- FieldElement{9209270, -15135055, -13256557, -6167798, -731016, 15289673, 25947805, 15286587, 30997318, -6703063},
- FieldElement{7392032, 16618386, 23946583, -8039892, -13265164, -1533858, -14197445, -2321576, 17649998, -250080},
- },
- {
- FieldElement{-9301088, -14193827, 30609526, -3049543, -25175069, -1283752, -15241566, -9525724, -2233253, 7662146},
- FieldElement{-17558673, 1763594, -33114336, 15908610, -30040870, -12174295, 7335080, -8472199, -3174674, 3440183},
- FieldElement{-19889700, -5977008, -24111293, -9688870, 10799743, -16571957, 40450, -4431835, 4862400, 1133},
- },
- {
- FieldElement{-32856209, -7873957, -5422389, 14860950, -16319031, 7956142, 7258061, 311861, -30594991, -7379421},
- FieldElement{-3773428, -1565936, 28985340, 7499440, 24445838, 9325937, 29727763, 16527196, 18278453, 15405622},
- FieldElement{-4381906, 8508652, -19898366, -3674424, -5984453, 15149970, -13313598, 843523, -21875062, 13626197},
- },
- {
- FieldElement{2281448, -13487055, -10915418, -2609910, 1879358, 16164207, -10783882, 3953792, 13340839, 15928663},
- FieldElement{31727126, -7179855, -18437503, -8283652, 2875793, -16390330, -25269894, -7014826, -23452306, 5964753},
- FieldElement{4100420, -5959452, -17179337, 6017714, -18705837, 12227141, -26684835, 11344144, 2538215, -7570755},
- },
- {
- FieldElement{-9433605, 6123113, 11159803, -2156608, 30016280, 14966241, -20474983, 1485421, -629256, -15958862},
- FieldElement{-26804558, 4260919, 11851389, 9658551, -32017107, 16367492, -20205425, -13191288, 11659922, -11115118},
- FieldElement{26180396, 10015009, -30844224, -8581293, 5418197, 9480663, 2231568, -10170080, 33100372, -1306171},
- },
- {
- FieldElement{15121113, -5201871, -10389905, 15427821, -27509937, -15992507, 21670947, 4486675, -5931810, -14466380},
- FieldElement{16166486, -9483733, -11104130, 6023908, -31926798, -1364923, 2340060, -16254968, -10735770, -10039824},
- FieldElement{28042865, -3557089, -12126526, 12259706, -3717498, -6945899, 6766453, -8689599, 18036436, 5803270},
- },
- },
- {
- {
- FieldElement{-817581, 6763912, 11803561, 1585585, 10958447, -2671165, 23855391, 4598332, -6159431, -14117438},
- FieldElement{-31031306, -14256194, 17332029, -2383520, 31312682, -5967183, 696309, 50292, -20095739, 11763584},
- FieldElement{-594563, -2514283, -32234153, 12643980, 12650761, 14811489, 665117, -12613632, -19773211, -10713562},
- },
- {
- FieldElement{30464590, -11262872, -4127476, -12734478, 19835327, -7105613, -24396175, 2075773, -17020157, 992471},
- FieldElement{18357185, -6994433, 7766382, 16342475, -29324918, 411174, 14578841, 8080033, -11574335, -10601610},
- FieldElement{19598397, 10334610, 12555054, 2555664, 18821899, -10339780, 21873263, 16014234, 26224780, 16452269},
- },
- {
- FieldElement{-30223925, 5145196, 5944548, 16385966, 3976735, 2009897, -11377804, -7618186, -20533829, 3698650},
- FieldElement{14187449, 3448569, -10636236, -10810935, -22663880, -3433596, 7268410, -10890444, 27394301, 12015369},
- FieldElement{19695761, 16087646, 28032085, 12999827, 6817792, 11427614, 20244189, -1312777, -13259127, -3402461},
- },
- {
- FieldElement{30860103, 12735208, -1888245, -4699734, -16974906, 2256940, -8166013, 12298312, -8550524, -10393462},
- FieldElement{-5719826, -11245325, -1910649, 15569035, 26642876, -7587760, -5789354, -15118654, -4976164, 12651793},
- FieldElement{-2848395, 9953421, 11531313, -5282879, 26895123, -12697089, -13118820, -16517902, 9768698, -2533218},
- },
- {
- FieldElement{-24719459, 1894651, -287698, -4704085, 15348719, -8156530, 32767513, 12765450, 4940095, 10678226},
- FieldElement{18860224, 15980149, -18987240, -1562570, -26233012, -11071856, -7843882, 13944024, -24372348, 16582019},
- FieldElement{-15504260, 4970268, -29893044, 4175593, -20993212, -2199756, -11704054, 15444560, -11003761, 7989037},
- },
- {
- FieldElement{31490452, 5568061, -2412803, 2182383, -32336847, 4531686, -32078269, 6200206, -19686113, -14800171},
- FieldElement{-17308668, -15879940, -31522777, -2831, -32887382, 16375549, 8680158, -16371713, 28550068, -6857132},
- FieldElement{-28126887, -5688091, 16837845, -1820458, -6850681, 12700016, -30039981, 4364038, 1155602, 5988841},
- },
- {
- FieldElement{21890435, -13272907, -12624011, 12154349, -7831873, 15300496, 23148983, -4470481, 24618407, 8283181},
- FieldElement{-33136107, -10512751, 9975416, 6841041, -31559793, 16356536, 3070187, -7025928, 1466169, 10740210},
- FieldElement{-1509399, -15488185, -13503385, -10655916, 32799044, 909394, -13938903, -5779719, -32164649, -15327040},
- },
- {
- FieldElement{3960823, -14267803, -28026090, -15918051, -19404858, 13146868, 15567327, 951507, -3260321, -573935},
- FieldElement{24740841, 5052253, -30094131, 8961361, 25877428, 6165135, -24368180, 14397372, -7380369, -6144105},
- FieldElement{-28888365, 3510803, -28103278, -1158478, -11238128, -10631454, -15441463, -14453128, -1625486, -6494814},
- },
- },
- {
- {
- FieldElement{793299, -9230478, 8836302, -6235707, -27360908, -2369593, 33152843, -4885251, -9906200, -621852},
- FieldElement{5666233, 525582, 20782575, -8038419, -24538499, 14657740, 16099374, 1468826, -6171428, -15186581},
- FieldElement{-4859255, -3779343, -2917758, -6748019, 7778750, 11688288, -30404353, -9871238, -1558923, -9863646},
- },
- {
- FieldElement{10896332, -7719704, 824275, 472601, -19460308, 3009587, 25248958, 14783338, -30581476, -15757844},
- FieldElement{10566929, 12612572, -31944212, 11118703, -12633376, 12362879, 21752402, 8822496, 24003793, 14264025},
- FieldElement{27713862, -7355973, -11008240, 9227530, 27050101, 2504721, 23886875, -13117525, 13958495, -5732453},
- },
- {
- FieldElement{-23481610, 4867226, -27247128, 3900521, 29838369, -8212291, -31889399, -10041781, 7340521, -15410068},
- FieldElement{4646514, -8011124, -22766023, -11532654, 23184553, 8566613, 31366726, -1381061, -15066784, -10375192},
- FieldElement{-17270517, 12723032, -16993061, 14878794, 21619651, -6197576, 27584817, 3093888, -8843694, 3849921},
- },
- {
- FieldElement{-9064912, 2103172, 25561640, -15125738, -5239824, 9582958, 32477045, -9017955, 5002294, -15550259},
- FieldElement{-12057553, -11177906, 21115585, -13365155, 8808712, -12030708, 16489530, 13378448, -25845716, 12741426},
- FieldElement{-5946367, 10645103, -30911586, 15390284, -3286982, -7118677, 24306472, 15852464, 28834118, -7646072},
- },
- {
- FieldElement{-17335748, -9107057, -24531279, 9434953, -8472084, -583362, -13090771, 455841, 20461858, 5491305},
- FieldElement{13669248, -16095482, -12481974, -10203039, -14569770, -11893198, -24995986, 11293807, -28588204, -9421832},
- FieldElement{28497928, 6272777, -33022994, 14470570, 8906179, -1225630, 18504674, -14165166, 29867745, -8795943},
- },
- {
- FieldElement{-16207023, 13517196, -27799630, -13697798, 24009064, -6373891, -6367600, -13175392, 22853429, -4012011},
- FieldElement{24191378, 16712145, -13931797, 15217831, 14542237, 1646131, 18603514, -11037887, 12876623, -2112447},
- FieldElement{17902668, 4518229, -411702, -2829247, 26878217, 5258055, -12860753, 608397, 16031844, 3723494},
- },
- {
- FieldElement{-28632773, 12763728, -20446446, 7577504, 33001348, -13017745, 17558842, -7872890, 23896954, -4314245},
- FieldElement{-20005381, -12011952, 31520464, 605201, 2543521, 5991821, -2945064, 7229064, -9919646, -8826859},
- FieldElement{28816045, 298879, -28165016, -15920938, 19000928, -1665890, -12680833, -2949325, -18051778, -2082915},
- },
- {
- FieldElement{16000882, -344896, 3493092, -11447198, -29504595, -13159789, 12577740, 16041268, -19715240, 7847707},
- FieldElement{10151868, 10572098, 27312476, 7922682, 14825339, 4723128, -32855931, -6519018, -10020567, 3852848},
- FieldElement{-11430470, 15697596, -21121557, -4420647, 5386314, 15063598, 16514493, -15932110, 29330899, -15076224},
- },
- },
- {
- {
- FieldElement{-25499735, -4378794, -15222908, -6901211, 16615731, 2051784, 3303702, 15490, -27548796, 12314391},
- FieldElement{15683520, -6003043, 18109120, -9980648, 15337968, -5997823, -16717435, 15921866, 16103996, -3731215},
- FieldElement{-23169824, -10781249, 13588192, -1628807, -3798557, -1074929, -19273607, 5402699, -29815713, -9841101},
- },
- {
- FieldElement{23190676, 2384583, -32714340, 3462154, -29903655, -1529132, -11266856, 8911517, -25205859, 2739713},
- FieldElement{21374101, -3554250, -33524649, 9874411, 15377179, 11831242, -33529904, 6134907, 4931255, 11987849},
- FieldElement{-7732, -2978858, -16223486, 7277597, 105524, -322051, -31480539, 13861388, -30076310, 10117930},
- },
- {
- FieldElement{-29501170, -10744872, -26163768, 13051539, -25625564, 5089643, -6325503, 6704079, 12890019, 15728940},
- FieldElement{-21972360, -11771379, -951059, -4418840, 14704840, 2695116, 903376, -10428139, 12885167, 8311031},
- FieldElement{-17516482, 5352194, 10384213, -13811658, 7506451, 13453191, 26423267, 4384730, 1888765, -5435404},
- },
- {
- FieldElement{-25817338, -3107312, -13494599, -3182506, 30896459, -13921729, -32251644, -12707869, -19464434, -3340243},
- FieldElement{-23607977, -2665774, -526091, 4651136, 5765089, 4618330, 6092245, 14845197, 17151279, -9854116},
- FieldElement{-24830458, -12733720, -15165978, 10367250, -29530908, -265356, 22825805, -7087279, -16866484, 16176525},
- },
- {
- FieldElement{-23583256, 6564961, 20063689, 3798228, -4740178, 7359225, 2006182, -10363426, -28746253, -10197509},
- FieldElement{-10626600, -4486402, -13320562, -5125317, 3432136, -6393229, 23632037, -1940610, 32808310, 1099883},
- FieldElement{15030977, 5768825, -27451236, -2887299, -6427378, -15361371, -15277896, -6809350, 2051441, -15225865},
- },
- {
- FieldElement{-3362323, -7239372, 7517890, 9824992, 23555850, 295369, 5148398, -14154188, -22686354, 16633660},
- FieldElement{4577086, -16752288, 13249841, -15304328, 19958763, -14537274, 18559670, -10759549, 8402478, -9864273},
- FieldElement{-28406330, -1051581, -26790155, -907698, -17212414, -11030789, 9453451, -14980072, 17983010, 9967138},
- },
- {
- FieldElement{-25762494, 6524722, 26585488, 9969270, 24709298, 1220360, -1677990, 7806337, 17507396, 3651560},
- FieldElement{-10420457, -4118111, 14584639, 15971087, -15768321, 8861010, 26556809, -5574557, -18553322, -11357135},
- FieldElement{2839101, 14284142, 4029895, 3472686, 14402957, 12689363, -26642121, 8459447, -5605463, -7621941},
- },
- {
- FieldElement{-4839289, -3535444, 9744961, 2871048, 25113978, 3187018, -25110813, -849066, 17258084, -7977739},
- FieldElement{18164541, -10595176, -17154882, -1542417, 19237078, -9745295, 23357533, -15217008, 26908270, 12150756},
- FieldElement{-30264870, -7647865, 5112249, -7036672, -1499807, -6974257, 43168, -5537701, -32302074, 16215819},
- },
- },
- {
- {
- FieldElement{-6898905, 9824394, -12304779, -4401089, -31397141, -6276835, 32574489, 12532905, -7503072, -8675347},
- FieldElement{-27343522, -16515468, -27151524, -10722951, 946346, 16291093, 254968, 7168080, 21676107, -1943028},
- FieldElement{21260961, -8424752, -16831886, -11920822, -23677961, 3968121, -3651949, -6215466, -3556191, -7913075},
- },
- {
- FieldElement{16544754, 13250366, -16804428, 15546242, -4583003, 12757258, -2462308, -8680336, -18907032, -9662799},
- FieldElement{-2415239, -15577728, 18312303, 4964443, -15272530, -12653564, 26820651, 16690659, 25459437, -4564609},
- FieldElement{-25144690, 11425020, 28423002, -11020557, -6144921, -15826224, 9142795, -2391602, -6432418, -1644817},
- },
- {
- FieldElement{-23104652, 6253476, 16964147, -3768872, -25113972, -12296437, -27457225, -16344658, 6335692, 7249989},
- FieldElement{-30333227, 13979675, 7503222, -12368314, -11956721, -4621693, -30272269, 2682242, 25993170, -12478523},
- FieldElement{4364628, 5930691, 32304656, -10044554, -8054781, 15091131, 22857016, -10598955, 31820368, 15075278},
- },
- {
- FieldElement{31879134, -8918693, 17258761, 90626, -8041836, -4917709, 24162788, -9650886, -17970238, 12833045},
- FieldElement{19073683, 14851414, -24403169, -11860168, 7625278, 11091125, -19619190, 2074449, -9413939, 14905377},
- FieldElement{24483667, -11935567, -2518866, -11547418, -1553130, 15355506, -25282080, 9253129, 27628530, -7555480},
- },
- {
- FieldElement{17597607, 8340603, 19355617, 552187, 26198470, -3176583, 4593324, -9157582, -14110875, 15297016},
- FieldElement{510886, 14337390, -31785257, 16638632, 6328095, 2713355, -20217417, -11864220, 8683221, 2921426},
- FieldElement{18606791, 11874196, 27155355, -5281482, -24031742, 6265446, -25178240, -1278924, 4674690, 13890525},
- },
- {
- FieldElement{13609624, 13069022, -27372361, -13055908, 24360586, 9592974, 14977157, 9835105, 4389687, 288396},
- FieldElement{9922506, -519394, 13613107, 5883594, -18758345, -434263, -12304062, 8317628, 23388070, 16052080},
- FieldElement{12720016, 11937594, -31970060, -5028689, 26900120, 8561328, -20155687, -11632979, -14754271, -10812892},
- },
- {
- FieldElement{15961858, 14150409, 26716931, -665832, -22794328, 13603569, 11829573, 7467844, -28822128, 929275},
- FieldElement{11038231, -11582396, -27310482, -7316562, -10498527, -16307831, -23479533, -9371869, -21393143, 2465074},
- FieldElement{20017163, -4323226, 27915242, 1529148, 12396362, 15675764, 13817261, -9658066, 2463391, -4622140},
- },
- {
- FieldElement{-16358878, -12663911, -12065183, 4996454, -1256422, 1073572, 9583558, 12851107, 4003896, 12673717},
- FieldElement{-1731589, -15155870, -3262930, 16143082, 19294135, 13385325, 14741514, -9103726, 7903886, 2348101},
- FieldElement{24536016, -16515207, 12715592, -3862155, 1511293, 10047386, -3842346, -7129159, -28377538, 10048127},
- },
- },
- {
- {
- FieldElement{-12622226, -6204820, 30718825, 2591312, -10617028, 12192840, 18873298, -7297090, -32297756, 15221632},
- FieldElement{-26478122, -11103864, 11546244, -1852483, 9180880, 7656409, -21343950, 2095755, 29769758, 6593415},
- FieldElement{-31994208, -2907461, 4176912, 3264766, 12538965, -868111, 26312345, -6118678, 30958054, 8292160},
- },
- {
- FieldElement{31429822, -13959116, 29173532, 15632448, 12174511, -2760094, 32808831, 3977186, 26143136, -3148876},
- FieldElement{22648901, 1402143, -22799984, 13746059, 7936347, 365344, -8668633, -1674433, -3758243, -2304625},
- FieldElement{-15491917, 8012313, -2514730, -12702462, -23965846, -10254029, -1612713, -1535569, -16664475, 8194478},
- },
- {
- FieldElement{27338066, -7507420, -7414224, 10140405, -19026427, -6589889, 27277191, 8855376, 28572286, 3005164},
- FieldElement{26287124, 4821776, 25476601, -4145903, -3764513, -15788984, -18008582, 1182479, -26094821, -13079595},
- FieldElement{-7171154, 3178080, 23970071, 6201893, -17195577, -4489192, -21876275, -13982627, 32208683, -1198248},
- },
- {
- FieldElement{-16657702, 2817643, -10286362, 14811298, 6024667, 13349505, -27315504, -10497842, -27672585, -11539858},
- FieldElement{15941029, -9405932, -21367050, 8062055, 31876073, -238629, -15278393, -1444429, 15397331, -4130193},
- FieldElement{8934485, -13485467, -23286397, -13423241, -32446090, 14047986, 31170398, -1441021, -27505566, 15087184},
- },
- {
- FieldElement{-18357243, -2156491, 24524913, -16677868, 15520427, -6360776, -15502406, 11461896, 16788528, -5868942},
- FieldElement{-1947386, 16013773, 21750665, 3714552, -17401782, -16055433, -3770287, -10323320, 31322514, -11615635},
- FieldElement{21426655, -5650218, -13648287, -5347537, -28812189, -4920970, -18275391, -14621414, 13040862, -12112948},
- },
- {
- FieldElement{11293895, 12478086, -27136401, 15083750, -29307421, 14748872, 14555558, -13417103, 1613711, 4896935},
- FieldElement{-25894883, 15323294, -8489791, -8057900, 25967126, -13425460, 2825960, -4897045, -23971776, -11267415},
- FieldElement{-15924766, -5229880, -17443532, 6410664, 3622847, 10243618, 20615400, 12405433, -23753030, -8436416},
- },
- {
- FieldElement{-7091295, 12556208, -20191352, 9025187, -17072479, 4333801, 4378436, 2432030, 23097949, -566018},
- FieldElement{4565804, -16025654, 20084412, -7842817, 1724999, 189254, 24767264, 10103221, -18512313, 2424778},
- FieldElement{366633, -11976806, 8173090, -6890119, 30788634, 5745705, -7168678, 1344109, -3642553, 12412659},
- },
- {
- FieldElement{-24001791, 7690286, 14929416, -168257, -32210835, -13412986, 24162697, -15326504, -3141501, 11179385},
- FieldElement{18289522, -14724954, 8056945, 16430056, -21729724, 7842514, -6001441, -1486897, -18684645, -11443503},
- FieldElement{476239, 6601091, -6152790, -9723375, 17503545, -4863900, 27672959, 13403813, 11052904, 5219329},
- },
- },
- {
- {
- FieldElement{20678546, -8375738, -32671898, 8849123, -5009758, 14574752, 31186971, -3973730, 9014762, -8579056},
- FieldElement{-13644050, -10350239, -15962508, 5075808, -1514661, -11534600, -33102500, 9160280, 8473550, -3256838},
- FieldElement{24900749, 14435722, 17209120, -15292541, -22592275, 9878983, -7689309, -16335821, -24568481, 11788948},
- },
- {
- FieldElement{-3118155, -11395194, -13802089, 14797441, 9652448, -6845904, -20037437, 10410733, -24568470, -1458691},
- FieldElement{-15659161, 16736706, -22467150, 10215878, -9097177, 7563911, 11871841, -12505194, -18513325, 8464118},
- FieldElement{-23400612, 8348507, -14585951, -861714, -3950205, -6373419, 14325289, 8628612, 33313881, -8370517},
- },
- {
- FieldElement{-20186973, -4967935, 22367356, 5271547, -1097117, -4788838, -24805667, -10236854, -8940735, -5818269},
- FieldElement{-6948785, -1795212, -32625683, -16021179, 32635414, -7374245, 15989197, -12838188, 28358192, -4253904},
- FieldElement{-23561781, -2799059, -32351682, -1661963, -9147719, 10429267, -16637684, 4072016, -5351664, 5596589},
- },
- {
- FieldElement{-28236598, -3390048, 12312896, 6213178, 3117142, 16078565, 29266239, 2557221, 1768301, 15373193},
- FieldElement{-7243358, -3246960, -4593467, -7553353, -127927, -912245, -1090902, -4504991, -24660491, 3442910},
- FieldElement{-30210571, 5124043, 14181784, 8197961, 18964734, -11939093, 22597931, 7176455, -18585478, 13365930},
- },
- {
- FieldElement{-7877390, -1499958, 8324673, 4690079, 6261860, 890446, 24538107, -8570186, -9689599, -3031667},
- FieldElement{25008904, -10771599, -4305031, -9638010, 16265036, 15721635, 683793, -11823784, 15723479, -15163481},
- FieldElement{-9660625, 12374379, -27006999, -7026148, -7724114, -12314514, 11879682, 5400171, 519526, -1235876},
- },
- {
- FieldElement{22258397, -16332233, -7869817, 14613016, -22520255, -2950923, -20353881, 7315967, 16648397, 7605640},
- FieldElement{-8081308, -8464597, -8223311, 9719710, 19259459, -15348212, 23994942, -5281555, -9468848, 4763278},
- FieldElement{-21699244, 9220969, -15730624, 1084137, -25476107, -2852390, 31088447, -7764523, -11356529, 728112},
- },
- {
- FieldElement{26047220, -11751471, -6900323, -16521798, 24092068, 9158119, -4273545, -12555558, -29365436, -5498272},
- FieldElement{17510331, -322857, 5854289, 8403524, 17133918, -3112612, -28111007, 12327945, 10750447, 10014012},
- FieldElement{-10312768, 3936952, 9156313, -8897683, 16498692, -994647, -27481051, -666732, 3424691, 7540221},
- },
- {
- FieldElement{30322361, -6964110, 11361005, -4143317, 7433304, 4989748, -7071422, -16317219, -9244265, 15258046},
- FieldElement{13054562, -2779497, 19155474, 469045, -12482797, 4566042, 5631406, 2711395, 1062915, -5136345},
- FieldElement{-19240248, -11254599, -29509029, -7499965, -5835763, 13005411, -6066489, 12194497, 32960380, 1459310},
- },
- },
- {
- {
- FieldElement{19852034, 7027924, 23669353, 10020366, 8586503, -6657907, 394197, -6101885, 18638003, -11174937},
- FieldElement{31395534, 15098109, 26581030, 8030562, -16527914, -5007134, 9012486, -7584354, -6643087, -5442636},
- FieldElement{-9192165, -2347377, -1997099, 4529534, 25766844, 607986, -13222, 9677543, -32294889, -6456008},
- },
- {
- FieldElement{-2444496, -149937, 29348902, 8186665, 1873760, 12489863, -30934579, -7839692, -7852844, -8138429},
- FieldElement{-15236356, -15433509, 7766470, 746860, 26346930, -10221762, -27333451, 10754588, -9431476, 5203576},
- FieldElement{31834314, 14135496, -770007, 5159118, 20917671, -16768096, -7467973, -7337524, 31809243, 7347066},
- },
- {
- FieldElement{-9606723, -11874240, 20414459, 13033986, 13716524, -11691881, 19797970, -12211255, 15192876, -2087490},
- FieldElement{-12663563, -2181719, 1168162, -3804809, 26747877, -14138091, 10609330, 12694420, 33473243, -13382104},
- FieldElement{33184999, 11180355, 15832085, -11385430, -1633671, 225884, 15089336, -11023903, -6135662, 14480053},
- },
- {
- FieldElement{31308717, -5619998, 31030840, -1897099, 15674547, -6582883, 5496208, 13685227, 27595050, 8737275},
- FieldElement{-20318852, -15150239, 10933843, -16178022, 8335352, -7546022, -31008351, -12610604, 26498114, 66511},
- FieldElement{22644454, -8761729, -16671776, 4884562, -3105614, -13559366, 30540766, -4286747, -13327787, -7515095},
- },
- {
- FieldElement{-28017847, 9834845, 18617207, -2681312, -3401956, -13307506, 8205540, 13585437, -17127465, 15115439},
- FieldElement{23711543, -672915, 31206561, -8362711, 6164647, -9709987, -33535882, -1426096, 8236921, 16492939},
- FieldElement{-23910559, -13515526, -26299483, -4503841, 25005590, -7687270, 19574902, 10071562, 6708380, -6222424},
- },
- {
- FieldElement{2101391, -4930054, 19702731, 2367575, -15427167, 1047675, 5301017, 9328700, 29955601, -11678310},
- FieldElement{3096359, 9271816, -21620864, -15521844, -14847996, -7592937, -25892142, -12635595, -9917575, 6216608},
- FieldElement{-32615849, 338663, -25195611, 2510422, -29213566, -13820213, 24822830, -6146567, -26767480, 7525079},
- },
- {
- FieldElement{-23066649, -13985623, 16133487, -7896178, -3389565, 778788, -910336, -2782495, -19386633, 11994101},
- FieldElement{21691500, -13624626, -641331, -14367021, 3285881, -3483596, -25064666, 9718258, -7477437, 13381418},
- FieldElement{18445390, -4202236, 14979846, 11622458, -1727110, -3582980, 23111648, -6375247, 28535282, 15779576},
- },
- {
- FieldElement{30098053, 3089662, -9234387, 16662135, -21306940, 11308411, -14068454, 12021730, 9955285, -16303356},
- FieldElement{9734894, -14576830, -7473633, -9138735, 2060392, 11313496, -18426029, 9924399, 20194861, 13380996},
- FieldElement{-26378102, -7965207, -22167821, 15789297, -18055342, -6168792, -1984914, 15707771, 26342023, 10146099},
- },
- },
- {
- {
- FieldElement{-26016874, -219943, 21339191, -41388, 19745256, -2878700, -29637280, 2227040, 21612326, -545728},
- FieldElement{-13077387, 1184228, 23562814, -5970442, -20351244, -6348714, 25764461, 12243797, -20856566, 11649658},
- FieldElement{-10031494, 11262626, 27384172, 2271902, 26947504, -15997771, 39944, 6114064, 33514190, 2333242},
- },
- {
- FieldElement{-21433588, -12421821, 8119782, 7219913, -21830522, -9016134, -6679750, -12670638, 24350578, -13450001},
- FieldElement{-4116307, -11271533, -23886186, 4843615, -30088339, 690623, -31536088, -10406836, 8317860, 12352766},
- FieldElement{18200138, -14475911, -33087759, -2696619, -23702521, -9102511, -23552096, -2287550, 20712163, 6719373},
- },
- {
- FieldElement{26656208, 6075253, -7858556, 1886072, -28344043, 4262326, 11117530, -3763210, 26224235, -3297458},
- FieldElement{-17168938, -14854097, -3395676, -16369877, -19954045, 14050420, 21728352, 9493610, 18620611, -16428628},
- FieldElement{-13323321, 13325349, 11432106, 5964811, 18609221, 6062965, -5269471, -9725556, -30701573, -16479657},
- },
- {
- FieldElement{-23860538, -11233159, 26961357, 1640861, -32413112, -16737940, 12248509, -5240639, 13735342, 1934062},
- FieldElement{25089769, 6742589, 17081145, -13406266, 21909293, -16067981, -15136294, -3765346, -21277997, 5473616},
- FieldElement{31883677, -7961101, 1083432, -11572403, 22828471, 13290673, -7125085, 12469656, 29111212, -5451014},
- },
- {
- FieldElement{24244947, -15050407, -26262976, 2791540, -14997599, 16666678, 24367466, 6388839, -10295587, 452383},
- FieldElement{-25640782, -3417841, 5217916, 16224624, 19987036, -4082269, -24236251, -5915248, 15766062, 8407814},
- FieldElement{-20406999, 13990231, 15495425, 16395525, 5377168, 15166495, -8917023, -4388953, -8067909, 2276718},
- },
- {
- FieldElement{30157918, 12924066, -17712050, 9245753, 19895028, 3368142, -23827587, 5096219, 22740376, -7303417},
- FieldElement{2041139, -14256350, 7783687, 13876377, -25946985, -13352459, 24051124, 13742383, -15637599, 13295222},
- FieldElement{33338237, -8505733, 12532113, 7977527, 9106186, -1715251, -17720195, -4612972, -4451357, -14669444},
- },
- {
- FieldElement{-20045281, 5454097, -14346548, 6447146, 28862071, 1883651, -2469266, -4141880, 7770569, 9620597},
- FieldElement{23208068, 7979712, 33071466, 8149229, 1758231, -10834995, 30945528, -1694323, -33502340, -14767970},
- FieldElement{1439958, -16270480, -1079989, -793782, 4625402, 10647766, -5043801, 1220118, 30494170, -11440799},
- },
- {
- FieldElement{-5037580, -13028295, -2970559, -3061767, 15640974, -6701666, -26739026, 926050, -1684339, -13333647},
- FieldElement{13908495, -3549272, 30919928, -6273825, -21521863, 7989039, 9021034, 9078865, 3353509, 4033511},
- FieldElement{-29663431, -15113610, 32259991, -344482, 24295849, -12912123, 23161163, 8839127, 27485041, 7356032},
- },
- },
- {
- {
- FieldElement{9661027, 705443, 11980065, -5370154, -1628543, 14661173, -6346142, 2625015, 28431036, -16771834},
- FieldElement{-23839233, -8311415, -25945511, 7480958, -17681669, -8354183, -22545972, 14150565, 15970762, 4099461},
- FieldElement{29262576, 16756590, 26350592, -8793563, 8529671, -11208050, 13617293, -9937143, 11465739, 8317062},
- },
- {
- FieldElement{-25493081, -6962928, 32500200, -9419051, -23038724, -2302222, 14898637, 3848455, 20969334, -5157516},
- FieldElement{-20384450, -14347713, -18336405, 13884722, -33039454, 2842114, -21610826, -3649888, 11177095, 14989547},
- FieldElement{-24496721, -11716016, 16959896, 2278463, 12066309, 10137771, 13515641, 2581286, -28487508, 9930240},
- },
- {
- FieldElement{-17751622, -2097826, 16544300, -13009300, -15914807, -14949081, 18345767, -13403753, 16291481, -5314038},
- FieldElement{-33229194, 2553288, 32678213, 9875984, 8534129, 6889387, -9676774, 6957617, 4368891, 9788741},
- FieldElement{16660756, 7281060, -10830758, 12911820, 20108584, -8101676, -21722536, -8613148, 16250552, -11111103},
- },
- {
- FieldElement{-19765507, 2390526, -16551031, 14161980, 1905286, 6414907, 4689584, 10604807, -30190403, 4782747},
- FieldElement{-1354539, 14736941, -7367442, -13292886, 7710542, -14155590, -9981571, 4383045, 22546403, 437323},
- FieldElement{31665577, -12180464, -16186830, 1491339, -18368625, 3294682, 27343084, 2786261, -30633590, -14097016},
- },
- {
- FieldElement{-14467279, -683715, -33374107, 7448552, 19294360, 14334329, -19690631, 2355319, -19284671, -6114373},
- FieldElement{15121312, -15796162, 6377020, -6031361, -10798111, -12957845, 18952177, 15496498, -29380133, 11754228},
- FieldElement{-2637277, -13483075, 8488727, -14303896, 12728761, -1622493, 7141596, 11724556, 22761615, -10134141},
- },
- {
- FieldElement{16918416, 11729663, -18083579, 3022987, -31015732, -13339659, -28741185, -12227393, 32851222, 11717399},
- FieldElement{11166634, 7338049, -6722523, 4531520, -29468672, -7302055, 31474879, 3483633, -1193175, -4030831},
- FieldElement{-185635, 9921305, 31456609, -13536438, -12013818, 13348923, 33142652, 6546660, -19985279, -3948376},
- },
- {
- FieldElement{-32460596, 11266712, -11197107, -7899103, 31703694, 3855903, -8537131, -12833048, -30772034, -15486313},
- FieldElement{-18006477, 12709068, 3991746, -6479188, -21491523, -10550425, -31135347, -16049879, 10928917, 3011958},
- FieldElement{-6957757, -15594337, 31696059, 334240, 29576716, 14796075, -30831056, -12805180, 18008031, 10258577},
- },
- {
- FieldElement{-22448644, 15655569, 7018479, -4410003, -30314266, -1201591, -1853465, 1367120, 25127874, 6671743},
- FieldElement{29701166, -14373934, -10878120, 9279288, -17568, 13127210, 21382910, 11042292, 25838796, 4642684},
- FieldElement{-20430234, 14955537, -24126347, 8124619, -5369288, -5990470, 30468147, -13900640, 18423289, 4177476},
- },
- },
-}
diff --git a/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/edwards25519.go b/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/edwards25519.go
deleted file mode 100644
index 5f8b9947872716c50edb0392432670240973ce3b..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ed25519/internal/edwards25519/edwards25519.go
+++ /dev/null
@@ -1,1771 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package edwards25519
-
-// This code is a port of the public domain, “ref10†implementation of ed25519
-// from SUPERCOP.
-
-// FieldElement represents an element of the field GF(2^255 - 19). An element
-// t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77
-// t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on
-// context.
-type FieldElement [10]int32
-
-var zero FieldElement
-
-func FeZero(fe *FieldElement) {
- copy(fe[:], zero[:])
-}
-
-func FeOne(fe *FieldElement) {
- FeZero(fe)
- fe[0] = 1
-}
-
-func FeAdd(dst, a, b *FieldElement) {
- dst[0] = a[0] + b[0]
- dst[1] = a[1] + b[1]
- dst[2] = a[2] + b[2]
- dst[3] = a[3] + b[3]
- dst[4] = a[4] + b[4]
- dst[5] = a[5] + b[5]
- dst[6] = a[6] + b[6]
- dst[7] = a[7] + b[7]
- dst[8] = a[8] + b[8]
- dst[9] = a[9] + b[9]
-}
-
-func FeSub(dst, a, b *FieldElement) {
- dst[0] = a[0] - b[0]
- dst[1] = a[1] - b[1]
- dst[2] = a[2] - b[2]
- dst[3] = a[3] - b[3]
- dst[4] = a[4] - b[4]
- dst[5] = a[5] - b[5]
- dst[6] = a[6] - b[6]
- dst[7] = a[7] - b[7]
- dst[8] = a[8] - b[8]
- dst[9] = a[9] - b[9]
-}
-
-func FeCopy(dst, src *FieldElement) {
- copy(dst[:], src[:])
-}
-
-// Replace (f,g) with (g,g) if b == 1;
-// replace (f,g) with (f,g) if b == 0.
-//
-// Preconditions: b in {0,1}.
-func FeCMove(f, g *FieldElement, b int32) {
- b = -b
- f[0] ^= b & (f[0] ^ g[0])
- f[1] ^= b & (f[1] ^ g[1])
- f[2] ^= b & (f[2] ^ g[2])
- f[3] ^= b & (f[3] ^ g[3])
- f[4] ^= b & (f[4] ^ g[4])
- f[5] ^= b & (f[5] ^ g[5])
- f[6] ^= b & (f[6] ^ g[6])
- f[7] ^= b & (f[7] ^ g[7])
- f[8] ^= b & (f[8] ^ g[8])
- f[9] ^= b & (f[9] ^ g[9])
-}
-
-func load3(in []byte) int64 {
- var r int64
- r = int64(in[0])
- r |= int64(in[1]) << 8
- r |= int64(in[2]) << 16
- return r
-}
-
-func load4(in []byte) int64 {
- var r int64
- r = int64(in[0])
- r |= int64(in[1]) << 8
- r |= int64(in[2]) << 16
- r |= int64(in[3]) << 24
- return r
-}
-
-func FeFromBytes(dst *FieldElement, src *[32]byte) {
- h0 := load4(src[:])
- h1 := load3(src[4:]) << 6
- h2 := load3(src[7:]) << 5
- h3 := load3(src[10:]) << 3
- h4 := load3(src[13:]) << 2
- h5 := load4(src[16:])
- h6 := load3(src[20:]) << 7
- h7 := load3(src[23:]) << 5
- h8 := load3(src[26:]) << 4
- h9 := (load3(src[29:]) & 8388607) << 2
-
- FeCombine(dst, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
-}
-
-// FeToBytes marshals h to s.
-// Preconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Write p=2^255-19; q=floor(h/p).
-// Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
-//
-// Proof:
-// Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
-// Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.
-//
-// Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
-// Then 0<y<1.
-//
-// Write r=h-pq.
-// Have 0<=r<=p-1=2^255-20.
-// Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
-//
-// Write x=r+19(2^-255)r+y.
-// Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
-//
-// Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
-// so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
-func FeToBytes(s *[32]byte, h *FieldElement) {
- var carry [10]int32
-
- q := (19*h[9] + (1 << 24)) >> 25
- q = (h[0] + q) >> 26
- q = (h[1] + q) >> 25
- q = (h[2] + q) >> 26
- q = (h[3] + q) >> 25
- q = (h[4] + q) >> 26
- q = (h[5] + q) >> 25
- q = (h[6] + q) >> 26
- q = (h[7] + q) >> 25
- q = (h[8] + q) >> 26
- q = (h[9] + q) >> 25
-
- // Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20.
- h[0] += 19 * q
- // Goal: Output h-2^255 q, which is between 0 and 2^255-20.
-
- carry[0] = h[0] >> 26
- h[1] += carry[0]
- h[0] -= carry[0] << 26
- carry[1] = h[1] >> 25
- h[2] += carry[1]
- h[1] -= carry[1] << 25
- carry[2] = h[2] >> 26
- h[3] += carry[2]
- h[2] -= carry[2] << 26
- carry[3] = h[3] >> 25
- h[4] += carry[3]
- h[3] -= carry[3] << 25
- carry[4] = h[4] >> 26
- h[5] += carry[4]
- h[4] -= carry[4] << 26
- carry[5] = h[5] >> 25
- h[6] += carry[5]
- h[5] -= carry[5] << 25
- carry[6] = h[6] >> 26
- h[7] += carry[6]
- h[6] -= carry[6] << 26
- carry[7] = h[7] >> 25
- h[8] += carry[7]
- h[7] -= carry[7] << 25
- carry[8] = h[8] >> 26
- h[9] += carry[8]
- h[8] -= carry[8] << 26
- carry[9] = h[9] >> 25
- h[9] -= carry[9] << 25
- // h10 = carry9
-
- // Goal: Output h[0]+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
- // Have h[0]+...+2^230 h[9] between 0 and 2^255-1;
- // evidently 2^255 h10-2^255 q = 0.
- // Goal: Output h[0]+...+2^230 h[9].
-
- s[0] = byte(h[0] >> 0)
- s[1] = byte(h[0] >> 8)
- s[2] = byte(h[0] >> 16)
- s[3] = byte((h[0] >> 24) | (h[1] << 2))
- s[4] = byte(h[1] >> 6)
- s[5] = byte(h[1] >> 14)
- s[6] = byte((h[1] >> 22) | (h[2] << 3))
- s[7] = byte(h[2] >> 5)
- s[8] = byte(h[2] >> 13)
- s[9] = byte((h[2] >> 21) | (h[3] << 5))
- s[10] = byte(h[3] >> 3)
- s[11] = byte(h[3] >> 11)
- s[12] = byte((h[3] >> 19) | (h[4] << 6))
- s[13] = byte(h[4] >> 2)
- s[14] = byte(h[4] >> 10)
- s[15] = byte(h[4] >> 18)
- s[16] = byte(h[5] >> 0)
- s[17] = byte(h[5] >> 8)
- s[18] = byte(h[5] >> 16)
- s[19] = byte((h[5] >> 24) | (h[6] << 1))
- s[20] = byte(h[6] >> 7)
- s[21] = byte(h[6] >> 15)
- s[22] = byte((h[6] >> 23) | (h[7] << 3))
- s[23] = byte(h[7] >> 5)
- s[24] = byte(h[7] >> 13)
- s[25] = byte((h[7] >> 21) | (h[8] << 4))
- s[26] = byte(h[8] >> 4)
- s[27] = byte(h[8] >> 12)
- s[28] = byte((h[8] >> 20) | (h[9] << 6))
- s[29] = byte(h[9] >> 2)
- s[30] = byte(h[9] >> 10)
- s[31] = byte(h[9] >> 18)
-}
-
-func FeIsNegative(f *FieldElement) byte {
- var s [32]byte
- FeToBytes(&s, f)
- return s[0] & 1
-}
-
-func FeIsNonZero(f *FieldElement) int32 {
- var s [32]byte
- FeToBytes(&s, f)
- var x uint8
- for _, b := range s {
- x |= b
- }
- x |= x >> 4
- x |= x >> 2
- x |= x >> 1
- return int32(x & 1)
-}
-
-// FeNeg sets h = -f
-//
-// Preconditions:
-// |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func FeNeg(h, f *FieldElement) {
- h[0] = -f[0]
- h[1] = -f[1]
- h[2] = -f[2]
- h[3] = -f[3]
- h[4] = -f[4]
- h[5] = -f[5]
- h[6] = -f[6]
- h[7] = -f[7]
- h[8] = -f[8]
- h[9] = -f[9]
-}
-
-func FeCombine(h *FieldElement, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
- var c0, c1, c2, c3, c4, c5, c6, c7, c8, c9 int64
-
- /*
- |h0| <= (1.1*1.1*2^52*(1+19+19+19+19)+1.1*1.1*2^50*(38+38+38+38+38))
- i.e. |h0| <= 1.2*2^59; narrower ranges for h2, h4, h6, h8
- |h1| <= (1.1*1.1*2^51*(1+1+19+19+19+19+19+19+19+19))
- i.e. |h1| <= 1.5*2^58; narrower ranges for h3, h5, h7, h9
- */
-
- c0 = (h0 + (1 << 25)) >> 26
- h1 += c0
- h0 -= c0 << 26
- c4 = (h4 + (1 << 25)) >> 26
- h5 += c4
- h4 -= c4 << 26
- /* |h0| <= 2^25 */
- /* |h4| <= 2^25 */
- /* |h1| <= 1.51*2^58 */
- /* |h5| <= 1.51*2^58 */
-
- c1 = (h1 + (1 << 24)) >> 25
- h2 += c1
- h1 -= c1 << 25
- c5 = (h5 + (1 << 24)) >> 25
- h6 += c5
- h5 -= c5 << 25
- /* |h1| <= 2^24; from now on fits into int32 */
- /* |h5| <= 2^24; from now on fits into int32 */
- /* |h2| <= 1.21*2^59 */
- /* |h6| <= 1.21*2^59 */
-
- c2 = (h2 + (1 << 25)) >> 26
- h3 += c2
- h2 -= c2 << 26
- c6 = (h6 + (1 << 25)) >> 26
- h7 += c6
- h6 -= c6 << 26
- /* |h2| <= 2^25; from now on fits into int32 unchanged */
- /* |h6| <= 2^25; from now on fits into int32 unchanged */
- /* |h3| <= 1.51*2^58 */
- /* |h7| <= 1.51*2^58 */
-
- c3 = (h3 + (1 << 24)) >> 25
- h4 += c3
- h3 -= c3 << 25
- c7 = (h7 + (1 << 24)) >> 25
- h8 += c7
- h7 -= c7 << 25
- /* |h3| <= 2^24; from now on fits into int32 unchanged */
- /* |h7| <= 2^24; from now on fits into int32 unchanged */
- /* |h4| <= 1.52*2^33 */
- /* |h8| <= 1.52*2^33 */
-
- c4 = (h4 + (1 << 25)) >> 26
- h5 += c4
- h4 -= c4 << 26
- c8 = (h8 + (1 << 25)) >> 26
- h9 += c8
- h8 -= c8 << 26
- /* |h4| <= 2^25; from now on fits into int32 unchanged */
- /* |h8| <= 2^25; from now on fits into int32 unchanged */
- /* |h5| <= 1.01*2^24 */
- /* |h9| <= 1.51*2^58 */
-
- c9 = (h9 + (1 << 24)) >> 25
- h0 += c9 * 19
- h9 -= c9 << 25
- /* |h9| <= 2^24; from now on fits into int32 unchanged */
- /* |h0| <= 1.8*2^37 */
-
- c0 = (h0 + (1 << 25)) >> 26
- h1 += c0
- h0 -= c0 << 26
- /* |h0| <= 2^25; from now on fits into int32 unchanged */
- /* |h1| <= 1.01*2^24 */
-
- h[0] = int32(h0)
- h[1] = int32(h1)
- h[2] = int32(h2)
- h[3] = int32(h3)
- h[4] = int32(h4)
- h[5] = int32(h5)
- h[6] = int32(h6)
- h[7] = int32(h7)
- h[8] = int32(h8)
- h[9] = int32(h9)
-}
-
-// FeMul calculates h = f * g
-// Can overlap h with f or g.
-//
-// Preconditions:
-// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-// |g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-//
-// Notes on implementation strategy:
-//
-// Using schoolbook multiplication.
-// Karatsuba would save a little in some cost models.
-//
-// Most multiplications by 2 and 19 are 32-bit precomputations;
-// cheaper than 64-bit postcomputations.
-//
-// There is one remaining multiplication by 19 in the carry chain;
-// one *19 precomputation can be merged into this,
-// but the resulting data flow is considerably less clean.
-//
-// There are 12 carries below.
-// 10 of them are 2-way parallelizable and vectorizable.
-// Can get away with 11 carries, but then data flow is much deeper.
-//
-// With tighter constraints on inputs, can squeeze carries into int32.
-func FeMul(h, f, g *FieldElement) {
- f0 := int64(f[0])
- f1 := int64(f[1])
- f2 := int64(f[2])
- f3 := int64(f[3])
- f4 := int64(f[4])
- f5 := int64(f[5])
- f6 := int64(f[6])
- f7 := int64(f[7])
- f8 := int64(f[8])
- f9 := int64(f[9])
-
- f1_2 := int64(2 * f[1])
- f3_2 := int64(2 * f[3])
- f5_2 := int64(2 * f[5])
- f7_2 := int64(2 * f[7])
- f9_2 := int64(2 * f[9])
-
- g0 := int64(g[0])
- g1 := int64(g[1])
- g2 := int64(g[2])
- g3 := int64(g[3])
- g4 := int64(g[4])
- g5 := int64(g[5])
- g6 := int64(g[6])
- g7 := int64(g[7])
- g8 := int64(g[8])
- g9 := int64(g[9])
-
- g1_19 := int64(19 * g[1]) /* 1.4*2^29 */
- g2_19 := int64(19 * g[2]) /* 1.4*2^30; still ok */
- g3_19 := int64(19 * g[3])
- g4_19 := int64(19 * g[4])
- g5_19 := int64(19 * g[5])
- g6_19 := int64(19 * g[6])
- g7_19 := int64(19 * g[7])
- g8_19 := int64(19 * g[8])
- g9_19 := int64(19 * g[9])
-
- h0 := f0*g0 + f1_2*g9_19 + f2*g8_19 + f3_2*g7_19 + f4*g6_19 + f5_2*g5_19 + f6*g4_19 + f7_2*g3_19 + f8*g2_19 + f9_2*g1_19
- h1 := f0*g1 + f1*g0 + f2*g9_19 + f3*g8_19 + f4*g7_19 + f5*g6_19 + f6*g5_19 + f7*g4_19 + f8*g3_19 + f9*g2_19
- h2 := f0*g2 + f1_2*g1 + f2*g0 + f3_2*g9_19 + f4*g8_19 + f5_2*g7_19 + f6*g6_19 + f7_2*g5_19 + f8*g4_19 + f9_2*g3_19
- h3 := f0*g3 + f1*g2 + f2*g1 + f3*g0 + f4*g9_19 + f5*g8_19 + f6*g7_19 + f7*g6_19 + f8*g5_19 + f9*g4_19
- h4 := f0*g4 + f1_2*g3 + f2*g2 + f3_2*g1 + f4*g0 + f5_2*g9_19 + f6*g8_19 + f7_2*g7_19 + f8*g6_19 + f9_2*g5_19
- h5 := f0*g5 + f1*g4 + f2*g3 + f3*g2 + f4*g1 + f5*g0 + f6*g9_19 + f7*g8_19 + f8*g7_19 + f9*g6_19
- h6 := f0*g6 + f1_2*g5 + f2*g4 + f3_2*g3 + f4*g2 + f5_2*g1 + f6*g0 + f7_2*g9_19 + f8*g8_19 + f9_2*g7_19
- h7 := f0*g7 + f1*g6 + f2*g5 + f3*g4 + f4*g3 + f5*g2 + f6*g1 + f7*g0 + f8*g9_19 + f9*g8_19
- h8 := f0*g8 + f1_2*g7 + f2*g6 + f3_2*g5 + f4*g4 + f5_2*g3 + f6*g2 + f7_2*g1 + f8*g0 + f9_2*g9_19
- h9 := f0*g9 + f1*g8 + f2*g7 + f3*g6 + f4*g5 + f5*g4 + f6*g3 + f7*g2 + f8*g1 + f9*g0
-
- FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
-}
-
-func feSquare(f *FieldElement) (h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64) {
- f0 := int64(f[0])
- f1 := int64(f[1])
- f2 := int64(f[2])
- f3 := int64(f[3])
- f4 := int64(f[4])
- f5 := int64(f[5])
- f6 := int64(f[6])
- f7 := int64(f[7])
- f8 := int64(f[8])
- f9 := int64(f[9])
- f0_2 := int64(2 * f[0])
- f1_2 := int64(2 * f[1])
- f2_2 := int64(2 * f[2])
- f3_2 := int64(2 * f[3])
- f4_2 := int64(2 * f[4])
- f5_2 := int64(2 * f[5])
- f6_2 := int64(2 * f[6])
- f7_2 := int64(2 * f[7])
- f5_38 := 38 * f5 // 1.31*2^30
- f6_19 := 19 * f6 // 1.31*2^30
- f7_38 := 38 * f7 // 1.31*2^30
- f8_19 := 19 * f8 // 1.31*2^30
- f9_38 := 38 * f9 // 1.31*2^30
-
- h0 = f0*f0 + f1_2*f9_38 + f2_2*f8_19 + f3_2*f7_38 + f4_2*f6_19 + f5*f5_38
- h1 = f0_2*f1 + f2*f9_38 + f3_2*f8_19 + f4*f7_38 + f5_2*f6_19
- h2 = f0_2*f2 + f1_2*f1 + f3_2*f9_38 + f4_2*f8_19 + f5_2*f7_38 + f6*f6_19
- h3 = f0_2*f3 + f1_2*f2 + f4*f9_38 + f5_2*f8_19 + f6*f7_38
- h4 = f0_2*f4 + f1_2*f3_2 + f2*f2 + f5_2*f9_38 + f6_2*f8_19 + f7*f7_38
- h5 = f0_2*f5 + f1_2*f4 + f2_2*f3 + f6*f9_38 + f7_2*f8_19
- h6 = f0_2*f6 + f1_2*f5_2 + f2_2*f4 + f3_2*f3 + f7_2*f9_38 + f8*f8_19
- h7 = f0_2*f7 + f1_2*f6 + f2_2*f5 + f3_2*f4 + f8*f9_38
- h8 = f0_2*f8 + f1_2*f7_2 + f2_2*f6 + f3_2*f5_2 + f4*f4 + f9*f9_38
- h9 = f0_2*f9 + f1_2*f8 + f2_2*f7 + f3_2*f6 + f4_2*f5
-
- return
-}
-
-// FeSquare calculates h = f*f. Can overlap h with f.
-//
-// Preconditions:
-// |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
-func FeSquare(h, f *FieldElement) {
- h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
- FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
-}
-
-// FeSquare2 sets h = 2 * f * f
-//
-// Can overlap h with f.
-//
-// Preconditions:
-// |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
-//
-// Postconditions:
-// |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
-// See fe_mul.c for discussion of implementation strategy.
-func FeSquare2(h, f *FieldElement) {
- h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 := feSquare(f)
-
- h0 += h0
- h1 += h1
- h2 += h2
- h3 += h3
- h4 += h4
- h5 += h5
- h6 += h6
- h7 += h7
- h8 += h8
- h9 += h9
-
- FeCombine(h, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9)
-}
-
-func FeInvert(out, z *FieldElement) {
- var t0, t1, t2, t3 FieldElement
- var i int
-
- FeSquare(&t0, z) // 2^1
- FeSquare(&t1, &t0) // 2^2
- for i = 1; i < 2; i++ { // 2^3
- FeSquare(&t1, &t1)
- }
- FeMul(&t1, z, &t1) // 2^3 + 2^0
- FeMul(&t0, &t0, &t1) // 2^3 + 2^1 + 2^0
- FeSquare(&t2, &t0) // 2^4 + 2^2 + 2^1
- FeMul(&t1, &t1, &t2) // 2^4 + 2^3 + 2^2 + 2^1 + 2^0
- FeSquare(&t2, &t1) // 5,4,3,2,1
- for i = 1; i < 5; i++ { // 9,8,7,6,5
- FeSquare(&t2, &t2)
- }
- FeMul(&t1, &t2, &t1) // 9,8,7,6,5,4,3,2,1,0
- FeSquare(&t2, &t1) // 10..1
- for i = 1; i < 10; i++ { // 19..10
- FeSquare(&t2, &t2)
- }
- FeMul(&t2, &t2, &t1) // 19..0
- FeSquare(&t3, &t2) // 20..1
- for i = 1; i < 20; i++ { // 39..20
- FeSquare(&t3, &t3)
- }
- FeMul(&t2, &t3, &t2) // 39..0
- FeSquare(&t2, &t2) // 40..1
- for i = 1; i < 10; i++ { // 49..10
- FeSquare(&t2, &t2)
- }
- FeMul(&t1, &t2, &t1) // 49..0
- FeSquare(&t2, &t1) // 50..1
- for i = 1; i < 50; i++ { // 99..50
- FeSquare(&t2, &t2)
- }
- FeMul(&t2, &t2, &t1) // 99..0
- FeSquare(&t3, &t2) // 100..1
- for i = 1; i < 100; i++ { // 199..100
- FeSquare(&t3, &t3)
- }
- FeMul(&t2, &t3, &t2) // 199..0
- FeSquare(&t2, &t2) // 200..1
- for i = 1; i < 50; i++ { // 249..50
- FeSquare(&t2, &t2)
- }
- FeMul(&t1, &t2, &t1) // 249..0
- FeSquare(&t1, &t1) // 250..1
- for i = 1; i < 5; i++ { // 254..5
- FeSquare(&t1, &t1)
- }
- FeMul(out, &t1, &t0) // 254..5,3,1,0
-}
-
-func fePow22523(out, z *FieldElement) {
- var t0, t1, t2 FieldElement
- var i int
-
- FeSquare(&t0, z)
- for i = 1; i < 1; i++ {
- FeSquare(&t0, &t0)
- }
- FeSquare(&t1, &t0)
- for i = 1; i < 2; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t1, z, &t1)
- FeMul(&t0, &t0, &t1)
- FeSquare(&t0, &t0)
- for i = 1; i < 1; i++ {
- FeSquare(&t0, &t0)
- }
- FeMul(&t0, &t1, &t0)
- FeSquare(&t1, &t0)
- for i = 1; i < 5; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t0, &t1, &t0)
- FeSquare(&t1, &t0)
- for i = 1; i < 10; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t1, &t1, &t0)
- FeSquare(&t2, &t1)
- for i = 1; i < 20; i++ {
- FeSquare(&t2, &t2)
- }
- FeMul(&t1, &t2, &t1)
- FeSquare(&t1, &t1)
- for i = 1; i < 10; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t0, &t1, &t0)
- FeSquare(&t1, &t0)
- for i = 1; i < 50; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t1, &t1, &t0)
- FeSquare(&t2, &t1)
- for i = 1; i < 100; i++ {
- FeSquare(&t2, &t2)
- }
- FeMul(&t1, &t2, &t1)
- FeSquare(&t1, &t1)
- for i = 1; i < 50; i++ {
- FeSquare(&t1, &t1)
- }
- FeMul(&t0, &t1, &t0)
- FeSquare(&t0, &t0)
- for i = 1; i < 2; i++ {
- FeSquare(&t0, &t0)
- }
- FeMul(out, &t0, z)
-}
-
-// Group elements are members of the elliptic curve -x^2 + y^2 = 1 + d * x^2 *
-// y^2 where d = -121665/121666.
-//
-// Several representations are used:
-// ProjectiveGroupElement: (X:Y:Z) satisfying x=X/Z, y=Y/Z
-// ExtendedGroupElement: (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
-// CompletedGroupElement: ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
-// PreComputedGroupElement: (y+x,y-x,2dxy)
-
-type ProjectiveGroupElement struct {
- X, Y, Z FieldElement
-}
-
-type ExtendedGroupElement struct {
- X, Y, Z, T FieldElement
-}
-
-type CompletedGroupElement struct {
- X, Y, Z, T FieldElement
-}
-
-type PreComputedGroupElement struct {
- yPlusX, yMinusX, xy2d FieldElement
-}
-
-type CachedGroupElement struct {
- yPlusX, yMinusX, Z, T2d FieldElement
-}
-
-func (p *ProjectiveGroupElement) Zero() {
- FeZero(&p.X)
- FeOne(&p.Y)
- FeOne(&p.Z)
-}
-
-func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement) {
- var t0 FieldElement
-
- FeSquare(&r.X, &p.X)
- FeSquare(&r.Z, &p.Y)
- FeSquare2(&r.T, &p.Z)
- FeAdd(&r.Y, &p.X, &p.Y)
- FeSquare(&t0, &r.Y)
- FeAdd(&r.Y, &r.Z, &r.X)
- FeSub(&r.Z, &r.Z, &r.X)
- FeSub(&r.X, &t0, &r.Y)
- FeSub(&r.T, &r.T, &r.Z)
-}
-
-func (p *ProjectiveGroupElement) ToBytes(s *[32]byte) {
- var recip, x, y FieldElement
-
- FeInvert(&recip, &p.Z)
- FeMul(&x, &p.X, &recip)
- FeMul(&y, &p.Y, &recip)
- FeToBytes(s, &y)
- s[31] ^= FeIsNegative(&x) << 7
-}
-
-func (p *ExtendedGroupElement) Zero() {
- FeZero(&p.X)
- FeOne(&p.Y)
- FeOne(&p.Z)
- FeZero(&p.T)
-}
-
-func (p *ExtendedGroupElement) Double(r *CompletedGroupElement) {
- var q ProjectiveGroupElement
- p.ToProjective(&q)
- q.Double(r)
-}
-
-func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement) {
- FeAdd(&r.yPlusX, &p.Y, &p.X)
- FeSub(&r.yMinusX, &p.Y, &p.X)
- FeCopy(&r.Z, &p.Z)
- FeMul(&r.T2d, &p.T, &d2)
-}
-
-func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement) {
- FeCopy(&r.X, &p.X)
- FeCopy(&r.Y, &p.Y)
- FeCopy(&r.Z, &p.Z)
-}
-
-func (p *ExtendedGroupElement) ToBytes(s *[32]byte) {
- var recip, x, y FieldElement
-
- FeInvert(&recip, &p.Z)
- FeMul(&x, &p.X, &recip)
- FeMul(&y, &p.Y, &recip)
- FeToBytes(s, &y)
- s[31] ^= FeIsNegative(&x) << 7
-}
-
-func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool {
- var u, v, v3, vxx, check FieldElement
-
- FeFromBytes(&p.Y, s)
- FeOne(&p.Z)
- FeSquare(&u, &p.Y)
- FeMul(&v, &u, &d)
- FeSub(&u, &u, &p.Z) // y = y^2-1
- FeAdd(&v, &v, &p.Z) // v = dy^2+1
-
- FeSquare(&v3, &v)
- FeMul(&v3, &v3, &v) // v3 = v^3
- FeSquare(&p.X, &v3)
- FeMul(&p.X, &p.X, &v)
- FeMul(&p.X, &p.X, &u) // x = uv^7
-
- fePow22523(&p.X, &p.X) // x = (uv^7)^((q-5)/8)
- FeMul(&p.X, &p.X, &v3)
- FeMul(&p.X, &p.X, &u) // x = uv^3(uv^7)^((q-5)/8)
-
- var tmpX, tmp2 [32]byte
-
- FeSquare(&vxx, &p.X)
- FeMul(&vxx, &vxx, &v)
- FeSub(&check, &vxx, &u) // vx^2-u
- if FeIsNonZero(&check) == 1 {
- FeAdd(&check, &vxx, &u) // vx^2+u
- if FeIsNonZero(&check) == 1 {
- return false
- }
- FeMul(&p.X, &p.X, &SqrtM1)
-
- FeToBytes(&tmpX, &p.X)
- for i, v := range tmpX {
- tmp2[31-i] = v
- }
- }
-
- if FeIsNegative(&p.X) != (s[31] >> 7) {
- FeNeg(&p.X, &p.X)
- }
-
- FeMul(&p.T, &p.X, &p.Y)
- return true
-}
-
-func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement) {
- FeMul(&r.X, &p.X, &p.T)
- FeMul(&r.Y, &p.Y, &p.Z)
- FeMul(&r.Z, &p.Z, &p.T)
-}
-
-func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement) {
- FeMul(&r.X, &p.X, &p.T)
- FeMul(&r.Y, &p.Y, &p.Z)
- FeMul(&r.Z, &p.Z, &p.T)
- FeMul(&r.T, &p.X, &p.Y)
-}
-
-func (p *PreComputedGroupElement) Zero() {
- FeOne(&p.yPlusX)
- FeOne(&p.yMinusX)
- FeZero(&p.xy2d)
-}
-
-func geAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
- var t0 FieldElement
-
- FeAdd(&r.X, &p.Y, &p.X)
- FeSub(&r.Y, &p.Y, &p.X)
- FeMul(&r.Z, &r.X, &q.yPlusX)
- FeMul(&r.Y, &r.Y, &q.yMinusX)
- FeMul(&r.T, &q.T2d, &p.T)
- FeMul(&r.X, &p.Z, &q.Z)
- FeAdd(&t0, &r.X, &r.X)
- FeSub(&r.X, &r.Z, &r.Y)
- FeAdd(&r.Y, &r.Z, &r.Y)
- FeAdd(&r.Z, &t0, &r.T)
- FeSub(&r.T, &t0, &r.T)
-}
-
-func geSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *CachedGroupElement) {
- var t0 FieldElement
-
- FeAdd(&r.X, &p.Y, &p.X)
- FeSub(&r.Y, &p.Y, &p.X)
- FeMul(&r.Z, &r.X, &q.yMinusX)
- FeMul(&r.Y, &r.Y, &q.yPlusX)
- FeMul(&r.T, &q.T2d, &p.T)
- FeMul(&r.X, &p.Z, &q.Z)
- FeAdd(&t0, &r.X, &r.X)
- FeSub(&r.X, &r.Z, &r.Y)
- FeAdd(&r.Y, &r.Z, &r.Y)
- FeSub(&r.Z, &t0, &r.T)
- FeAdd(&r.T, &t0, &r.T)
-}
-
-func geMixedAdd(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
- var t0 FieldElement
-
- FeAdd(&r.X, &p.Y, &p.X)
- FeSub(&r.Y, &p.Y, &p.X)
- FeMul(&r.Z, &r.X, &q.yPlusX)
- FeMul(&r.Y, &r.Y, &q.yMinusX)
- FeMul(&r.T, &q.xy2d, &p.T)
- FeAdd(&t0, &p.Z, &p.Z)
- FeSub(&r.X, &r.Z, &r.Y)
- FeAdd(&r.Y, &r.Z, &r.Y)
- FeAdd(&r.Z, &t0, &r.T)
- FeSub(&r.T, &t0, &r.T)
-}
-
-func geMixedSub(r *CompletedGroupElement, p *ExtendedGroupElement, q *PreComputedGroupElement) {
- var t0 FieldElement
-
- FeAdd(&r.X, &p.Y, &p.X)
- FeSub(&r.Y, &p.Y, &p.X)
- FeMul(&r.Z, &r.X, &q.yMinusX)
- FeMul(&r.Y, &r.Y, &q.yPlusX)
- FeMul(&r.T, &q.xy2d, &p.T)
- FeAdd(&t0, &p.Z, &p.Z)
- FeSub(&r.X, &r.Z, &r.Y)
- FeAdd(&r.Y, &r.Z, &r.Y)
- FeSub(&r.Z, &t0, &r.T)
- FeAdd(&r.T, &t0, &r.T)
-}
-
-func slide(r *[256]int8, a *[32]byte) {
- for i := range r {
- r[i] = int8(1 & (a[i>>3] >> uint(i&7)))
- }
-
- for i := range r {
- if r[i] != 0 {
- for b := 1; b <= 6 && i+b < 256; b++ {
- if r[i+b] != 0 {
- if r[i]+(r[i+b]<<uint(b)) <= 15 {
- r[i] += r[i+b] << uint(b)
- r[i+b] = 0
- } else if r[i]-(r[i+b]<<uint(b)) >= -15 {
- r[i] -= r[i+b] << uint(b)
- for k := i + b; k < 256; k++ {
- if r[k] == 0 {
- r[k] = 1
- break
- }
- r[k] = 0
- }
- } else {
- break
- }
- }
- }
- }
- }
-}
-
-// GeDoubleScalarMultVartime sets r = a*A + b*B
-// where a = a[0]+256*a[1]+...+256^31 a[31].
-// and b = b[0]+256*b[1]+...+256^31 b[31].
-// B is the Ed25519 base point (x,4/5) with x positive.
-func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte) {
- var aSlide, bSlide [256]int8
- var Ai [8]CachedGroupElement // A,3A,5A,7A,9A,11A,13A,15A
- var t CompletedGroupElement
- var u, A2 ExtendedGroupElement
- var i int
-
- slide(&aSlide, a)
- slide(&bSlide, b)
-
- A.ToCached(&Ai[0])
- A.Double(&t)
- t.ToExtended(&A2)
-
- for i := 0; i < 7; i++ {
- geAdd(&t, &A2, &Ai[i])
- t.ToExtended(&u)
- u.ToCached(&Ai[i+1])
- }
-
- r.Zero()
-
- for i = 255; i >= 0; i-- {
- if aSlide[i] != 0 || bSlide[i] != 0 {
- break
- }
- }
-
- for ; i >= 0; i-- {
- r.Double(&t)
-
- if aSlide[i] > 0 {
- t.ToExtended(&u)
- geAdd(&t, &u, &Ai[aSlide[i]/2])
- } else if aSlide[i] < 0 {
- t.ToExtended(&u)
- geSub(&t, &u, &Ai[(-aSlide[i])/2])
- }
-
- if bSlide[i] > 0 {
- t.ToExtended(&u)
- geMixedAdd(&t, &u, &bi[bSlide[i]/2])
- } else if bSlide[i] < 0 {
- t.ToExtended(&u)
- geMixedSub(&t, &u, &bi[(-bSlide[i])/2])
- }
-
- t.ToProjective(r)
- }
-}
-
-// equal returns 1 if b == c and 0 otherwise, assuming that b and c are
-// non-negative.
-func equal(b, c int32) int32 {
- x := uint32(b ^ c)
- x--
- return int32(x >> 31)
-}
-
-// negative returns 1 if b < 0 and 0 otherwise.
-func negative(b int32) int32 {
- return (b >> 31) & 1
-}
-
-func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32) {
- FeCMove(&t.yPlusX, &u.yPlusX, b)
- FeCMove(&t.yMinusX, &u.yMinusX, b)
- FeCMove(&t.xy2d, &u.xy2d, b)
-}
-
-func selectPoint(t *PreComputedGroupElement, pos int32, b int32) {
- var minusT PreComputedGroupElement
- bNegative := negative(b)
- bAbs := b - (((-bNegative) & b) << 1)
-
- t.Zero()
- for i := int32(0); i < 8; i++ {
- PreComputedGroupElementCMove(t, &base[pos][i], equal(bAbs, i+1))
- }
- FeCopy(&minusT.yPlusX, &t.yMinusX)
- FeCopy(&minusT.yMinusX, &t.yPlusX)
- FeNeg(&minusT.xy2d, &t.xy2d)
- PreComputedGroupElementCMove(t, &minusT, bNegative)
-}
-
-// GeScalarMultBase computes h = a*B, where
-// a = a[0]+256*a[1]+...+256^31 a[31]
-// B is the Ed25519 base point (x,4/5) with x positive.
-//
-// Preconditions:
-// a[31] <= 127
-func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte) {
- var e [64]int8
-
- for i, v := range a {
- e[2*i] = int8(v & 15)
- e[2*i+1] = int8((v >> 4) & 15)
- }
-
- // each e[i] is between 0 and 15 and e[63] is between 0 and 7.
-
- carry := int8(0)
- for i := 0; i < 63; i++ {
- e[i] += carry
- carry = (e[i] + 8) >> 4
- e[i] -= carry << 4
- }
- e[63] += carry
- // each e[i] is between -8 and 8.
-
- h.Zero()
- var t PreComputedGroupElement
- var r CompletedGroupElement
- for i := int32(1); i < 64; i += 2 {
- selectPoint(&t, i/2, int32(e[i]))
- geMixedAdd(&r, h, &t)
- r.ToExtended(h)
- }
-
- var s ProjectiveGroupElement
-
- h.Double(&r)
- r.ToProjective(&s)
- s.Double(&r)
- r.ToProjective(&s)
- s.Double(&r)
- r.ToProjective(&s)
- s.Double(&r)
- r.ToExtended(h)
-
- for i := int32(0); i < 64; i += 2 {
- selectPoint(&t, i/2, int32(e[i]))
- geMixedAdd(&r, h, &t)
- r.ToExtended(h)
- }
-}
-
-// The scalars are GF(2^252 + 27742317777372353535851937790883648493).
-
-// Input:
-// a[0]+256*a[1]+...+256^31*a[31] = a
-// b[0]+256*b[1]+...+256^31*b[31] = b
-// c[0]+256*c[1]+...+256^31*c[31] = c
-//
-// Output:
-// s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
-// where l = 2^252 + 27742317777372353535851937790883648493.
-func ScMulAdd(s, a, b, c *[32]byte) {
- a0 := 2097151 & load3(a[:])
- a1 := 2097151 & (load4(a[2:]) >> 5)
- a2 := 2097151 & (load3(a[5:]) >> 2)
- a3 := 2097151 & (load4(a[7:]) >> 7)
- a4 := 2097151 & (load4(a[10:]) >> 4)
- a5 := 2097151 & (load3(a[13:]) >> 1)
- a6 := 2097151 & (load4(a[15:]) >> 6)
- a7 := 2097151 & (load3(a[18:]) >> 3)
- a8 := 2097151 & load3(a[21:])
- a9 := 2097151 & (load4(a[23:]) >> 5)
- a10 := 2097151 & (load3(a[26:]) >> 2)
- a11 := (load4(a[28:]) >> 7)
- b0 := 2097151 & load3(b[:])
- b1 := 2097151 & (load4(b[2:]) >> 5)
- b2 := 2097151 & (load3(b[5:]) >> 2)
- b3 := 2097151 & (load4(b[7:]) >> 7)
- b4 := 2097151 & (load4(b[10:]) >> 4)
- b5 := 2097151 & (load3(b[13:]) >> 1)
- b6 := 2097151 & (load4(b[15:]) >> 6)
- b7 := 2097151 & (load3(b[18:]) >> 3)
- b8 := 2097151 & load3(b[21:])
- b9 := 2097151 & (load4(b[23:]) >> 5)
- b10 := 2097151 & (load3(b[26:]) >> 2)
- b11 := (load4(b[28:]) >> 7)
- c0 := 2097151 & load3(c[:])
- c1 := 2097151 & (load4(c[2:]) >> 5)
- c2 := 2097151 & (load3(c[5:]) >> 2)
- c3 := 2097151 & (load4(c[7:]) >> 7)
- c4 := 2097151 & (load4(c[10:]) >> 4)
- c5 := 2097151 & (load3(c[13:]) >> 1)
- c6 := 2097151 & (load4(c[15:]) >> 6)
- c7 := 2097151 & (load3(c[18:]) >> 3)
- c8 := 2097151 & load3(c[21:])
- c9 := 2097151 & (load4(c[23:]) >> 5)
- c10 := 2097151 & (load3(c[26:]) >> 2)
- c11 := (load4(c[28:]) >> 7)
- var carry [23]int64
-
- s0 := c0 + a0*b0
- s1 := c1 + a0*b1 + a1*b0
- s2 := c2 + a0*b2 + a1*b1 + a2*b0
- s3 := c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0
- s4 := c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0
- s5 := c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0
- s6 := c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0
- s7 := c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0
- s8 := c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0
- s9 := c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0
- s10 := c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0
- s11 := c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0
- s12 := a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1
- s13 := a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2
- s14 := a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3
- s15 := a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4
- s16 := a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5
- s17 := a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6
- s18 := a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7
- s19 := a8*b11 + a9*b10 + a10*b9 + a11*b8
- s20 := a9*b11 + a10*b10 + a11*b9
- s21 := a10*b11 + a11*b10
- s22 := a11 * b11
- s23 := int64(0)
-
- carry[0] = (s0 + (1 << 20)) >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[2] = (s2 + (1 << 20)) >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[4] = (s4 + (1 << 20)) >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[6] = (s6 + (1 << 20)) >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[8] = (s8 + (1 << 20)) >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[10] = (s10 + (1 << 20)) >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
- carry[12] = (s12 + (1 << 20)) >> 21
- s13 += carry[12]
- s12 -= carry[12] << 21
- carry[14] = (s14 + (1 << 20)) >> 21
- s15 += carry[14]
- s14 -= carry[14] << 21
- carry[16] = (s16 + (1 << 20)) >> 21
- s17 += carry[16]
- s16 -= carry[16] << 21
- carry[18] = (s18 + (1 << 20)) >> 21
- s19 += carry[18]
- s18 -= carry[18] << 21
- carry[20] = (s20 + (1 << 20)) >> 21
- s21 += carry[20]
- s20 -= carry[20] << 21
- carry[22] = (s22 + (1 << 20)) >> 21
- s23 += carry[22]
- s22 -= carry[22] << 21
-
- carry[1] = (s1 + (1 << 20)) >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[3] = (s3 + (1 << 20)) >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[5] = (s5 + (1 << 20)) >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[7] = (s7 + (1 << 20)) >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[9] = (s9 + (1 << 20)) >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[11] = (s11 + (1 << 20)) >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
- carry[13] = (s13 + (1 << 20)) >> 21
- s14 += carry[13]
- s13 -= carry[13] << 21
- carry[15] = (s15 + (1 << 20)) >> 21
- s16 += carry[15]
- s15 -= carry[15] << 21
- carry[17] = (s17 + (1 << 20)) >> 21
- s18 += carry[17]
- s17 -= carry[17] << 21
- carry[19] = (s19 + (1 << 20)) >> 21
- s20 += carry[19]
- s19 -= carry[19] << 21
- carry[21] = (s21 + (1 << 20)) >> 21
- s22 += carry[21]
- s21 -= carry[21] << 21
-
- s11 += s23 * 666643
- s12 += s23 * 470296
- s13 += s23 * 654183
- s14 -= s23 * 997805
- s15 += s23 * 136657
- s16 -= s23 * 683901
- s23 = 0
-
- s10 += s22 * 666643
- s11 += s22 * 470296
- s12 += s22 * 654183
- s13 -= s22 * 997805
- s14 += s22 * 136657
- s15 -= s22 * 683901
- s22 = 0
-
- s9 += s21 * 666643
- s10 += s21 * 470296
- s11 += s21 * 654183
- s12 -= s21 * 997805
- s13 += s21 * 136657
- s14 -= s21 * 683901
- s21 = 0
-
- s8 += s20 * 666643
- s9 += s20 * 470296
- s10 += s20 * 654183
- s11 -= s20 * 997805
- s12 += s20 * 136657
- s13 -= s20 * 683901
- s20 = 0
-
- s7 += s19 * 666643
- s8 += s19 * 470296
- s9 += s19 * 654183
- s10 -= s19 * 997805
- s11 += s19 * 136657
- s12 -= s19 * 683901
- s19 = 0
-
- s6 += s18 * 666643
- s7 += s18 * 470296
- s8 += s18 * 654183
- s9 -= s18 * 997805
- s10 += s18 * 136657
- s11 -= s18 * 683901
- s18 = 0
-
- carry[6] = (s6 + (1 << 20)) >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[8] = (s8 + (1 << 20)) >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[10] = (s10 + (1 << 20)) >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
- carry[12] = (s12 + (1 << 20)) >> 21
- s13 += carry[12]
- s12 -= carry[12] << 21
- carry[14] = (s14 + (1 << 20)) >> 21
- s15 += carry[14]
- s14 -= carry[14] << 21
- carry[16] = (s16 + (1 << 20)) >> 21
- s17 += carry[16]
- s16 -= carry[16] << 21
-
- carry[7] = (s7 + (1 << 20)) >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[9] = (s9 + (1 << 20)) >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[11] = (s11 + (1 << 20)) >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
- carry[13] = (s13 + (1 << 20)) >> 21
- s14 += carry[13]
- s13 -= carry[13] << 21
- carry[15] = (s15 + (1 << 20)) >> 21
- s16 += carry[15]
- s15 -= carry[15] << 21
-
- s5 += s17 * 666643
- s6 += s17 * 470296
- s7 += s17 * 654183
- s8 -= s17 * 997805
- s9 += s17 * 136657
- s10 -= s17 * 683901
- s17 = 0
-
- s4 += s16 * 666643
- s5 += s16 * 470296
- s6 += s16 * 654183
- s7 -= s16 * 997805
- s8 += s16 * 136657
- s9 -= s16 * 683901
- s16 = 0
-
- s3 += s15 * 666643
- s4 += s15 * 470296
- s5 += s15 * 654183
- s6 -= s15 * 997805
- s7 += s15 * 136657
- s8 -= s15 * 683901
- s15 = 0
-
- s2 += s14 * 666643
- s3 += s14 * 470296
- s4 += s14 * 654183
- s5 -= s14 * 997805
- s6 += s14 * 136657
- s7 -= s14 * 683901
- s14 = 0
-
- s1 += s13 * 666643
- s2 += s13 * 470296
- s3 += s13 * 654183
- s4 -= s13 * 997805
- s5 += s13 * 136657
- s6 -= s13 * 683901
- s13 = 0
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = (s0 + (1 << 20)) >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[2] = (s2 + (1 << 20)) >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[4] = (s4 + (1 << 20)) >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[6] = (s6 + (1 << 20)) >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[8] = (s8 + (1 << 20)) >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[10] = (s10 + (1 << 20)) >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
-
- carry[1] = (s1 + (1 << 20)) >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[3] = (s3 + (1 << 20)) >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[5] = (s5 + (1 << 20)) >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[7] = (s7 + (1 << 20)) >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[9] = (s9 + (1 << 20)) >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[11] = (s11 + (1 << 20)) >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = s0 >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[1] = s1 >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[2] = s2 >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[3] = s3 >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[4] = s4 >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[5] = s5 >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[6] = s6 >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[7] = s7 >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[8] = s8 >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[9] = s9 >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[10] = s10 >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
- carry[11] = s11 >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = s0 >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[1] = s1 >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[2] = s2 >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[3] = s3 >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[4] = s4 >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[5] = s5 >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[6] = s6 >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[7] = s7 >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[8] = s8 >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[9] = s9 >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[10] = s10 >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
-
- s[0] = byte(s0 >> 0)
- s[1] = byte(s0 >> 8)
- s[2] = byte((s0 >> 16) | (s1 << 5))
- s[3] = byte(s1 >> 3)
- s[4] = byte(s1 >> 11)
- s[5] = byte((s1 >> 19) | (s2 << 2))
- s[6] = byte(s2 >> 6)
- s[7] = byte((s2 >> 14) | (s3 << 7))
- s[8] = byte(s3 >> 1)
- s[9] = byte(s3 >> 9)
- s[10] = byte((s3 >> 17) | (s4 << 4))
- s[11] = byte(s4 >> 4)
- s[12] = byte(s4 >> 12)
- s[13] = byte((s4 >> 20) | (s5 << 1))
- s[14] = byte(s5 >> 7)
- s[15] = byte((s5 >> 15) | (s6 << 6))
- s[16] = byte(s6 >> 2)
- s[17] = byte(s6 >> 10)
- s[18] = byte((s6 >> 18) | (s7 << 3))
- s[19] = byte(s7 >> 5)
- s[20] = byte(s7 >> 13)
- s[21] = byte(s8 >> 0)
- s[22] = byte(s8 >> 8)
- s[23] = byte((s8 >> 16) | (s9 << 5))
- s[24] = byte(s9 >> 3)
- s[25] = byte(s9 >> 11)
- s[26] = byte((s9 >> 19) | (s10 << 2))
- s[27] = byte(s10 >> 6)
- s[28] = byte((s10 >> 14) | (s11 << 7))
- s[29] = byte(s11 >> 1)
- s[30] = byte(s11 >> 9)
- s[31] = byte(s11 >> 17)
-}
-
-// Input:
-// s[0]+256*s[1]+...+256^63*s[63] = s
-//
-// Output:
-// s[0]+256*s[1]+...+256^31*s[31] = s mod l
-// where l = 2^252 + 27742317777372353535851937790883648493.
-func ScReduce(out *[32]byte, s *[64]byte) {
- s0 := 2097151 & load3(s[:])
- s1 := 2097151 & (load4(s[2:]) >> 5)
- s2 := 2097151 & (load3(s[5:]) >> 2)
- s3 := 2097151 & (load4(s[7:]) >> 7)
- s4 := 2097151 & (load4(s[10:]) >> 4)
- s5 := 2097151 & (load3(s[13:]) >> 1)
- s6 := 2097151 & (load4(s[15:]) >> 6)
- s7 := 2097151 & (load3(s[18:]) >> 3)
- s8 := 2097151 & load3(s[21:])
- s9 := 2097151 & (load4(s[23:]) >> 5)
- s10 := 2097151 & (load3(s[26:]) >> 2)
- s11 := 2097151 & (load4(s[28:]) >> 7)
- s12 := 2097151 & (load4(s[31:]) >> 4)
- s13 := 2097151 & (load3(s[34:]) >> 1)
- s14 := 2097151 & (load4(s[36:]) >> 6)
- s15 := 2097151 & (load3(s[39:]) >> 3)
- s16 := 2097151 & load3(s[42:])
- s17 := 2097151 & (load4(s[44:]) >> 5)
- s18 := 2097151 & (load3(s[47:]) >> 2)
- s19 := 2097151 & (load4(s[49:]) >> 7)
- s20 := 2097151 & (load4(s[52:]) >> 4)
- s21 := 2097151 & (load3(s[55:]) >> 1)
- s22 := 2097151 & (load4(s[57:]) >> 6)
- s23 := (load4(s[60:]) >> 3)
-
- s11 += s23 * 666643
- s12 += s23 * 470296
- s13 += s23 * 654183
- s14 -= s23 * 997805
- s15 += s23 * 136657
- s16 -= s23 * 683901
- s23 = 0
-
- s10 += s22 * 666643
- s11 += s22 * 470296
- s12 += s22 * 654183
- s13 -= s22 * 997805
- s14 += s22 * 136657
- s15 -= s22 * 683901
- s22 = 0
-
- s9 += s21 * 666643
- s10 += s21 * 470296
- s11 += s21 * 654183
- s12 -= s21 * 997805
- s13 += s21 * 136657
- s14 -= s21 * 683901
- s21 = 0
-
- s8 += s20 * 666643
- s9 += s20 * 470296
- s10 += s20 * 654183
- s11 -= s20 * 997805
- s12 += s20 * 136657
- s13 -= s20 * 683901
- s20 = 0
-
- s7 += s19 * 666643
- s8 += s19 * 470296
- s9 += s19 * 654183
- s10 -= s19 * 997805
- s11 += s19 * 136657
- s12 -= s19 * 683901
- s19 = 0
-
- s6 += s18 * 666643
- s7 += s18 * 470296
- s8 += s18 * 654183
- s9 -= s18 * 997805
- s10 += s18 * 136657
- s11 -= s18 * 683901
- s18 = 0
-
- var carry [17]int64
-
- carry[6] = (s6 + (1 << 20)) >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[8] = (s8 + (1 << 20)) >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[10] = (s10 + (1 << 20)) >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
- carry[12] = (s12 + (1 << 20)) >> 21
- s13 += carry[12]
- s12 -= carry[12] << 21
- carry[14] = (s14 + (1 << 20)) >> 21
- s15 += carry[14]
- s14 -= carry[14] << 21
- carry[16] = (s16 + (1 << 20)) >> 21
- s17 += carry[16]
- s16 -= carry[16] << 21
-
- carry[7] = (s7 + (1 << 20)) >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[9] = (s9 + (1 << 20)) >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[11] = (s11 + (1 << 20)) >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
- carry[13] = (s13 + (1 << 20)) >> 21
- s14 += carry[13]
- s13 -= carry[13] << 21
- carry[15] = (s15 + (1 << 20)) >> 21
- s16 += carry[15]
- s15 -= carry[15] << 21
-
- s5 += s17 * 666643
- s6 += s17 * 470296
- s7 += s17 * 654183
- s8 -= s17 * 997805
- s9 += s17 * 136657
- s10 -= s17 * 683901
- s17 = 0
-
- s4 += s16 * 666643
- s5 += s16 * 470296
- s6 += s16 * 654183
- s7 -= s16 * 997805
- s8 += s16 * 136657
- s9 -= s16 * 683901
- s16 = 0
-
- s3 += s15 * 666643
- s4 += s15 * 470296
- s5 += s15 * 654183
- s6 -= s15 * 997805
- s7 += s15 * 136657
- s8 -= s15 * 683901
- s15 = 0
-
- s2 += s14 * 666643
- s3 += s14 * 470296
- s4 += s14 * 654183
- s5 -= s14 * 997805
- s6 += s14 * 136657
- s7 -= s14 * 683901
- s14 = 0
-
- s1 += s13 * 666643
- s2 += s13 * 470296
- s3 += s13 * 654183
- s4 -= s13 * 997805
- s5 += s13 * 136657
- s6 -= s13 * 683901
- s13 = 0
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = (s0 + (1 << 20)) >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[2] = (s2 + (1 << 20)) >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[4] = (s4 + (1 << 20)) >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[6] = (s6 + (1 << 20)) >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[8] = (s8 + (1 << 20)) >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[10] = (s10 + (1 << 20)) >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
-
- carry[1] = (s1 + (1 << 20)) >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[3] = (s3 + (1 << 20)) >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[5] = (s5 + (1 << 20)) >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[7] = (s7 + (1 << 20)) >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[9] = (s9 + (1 << 20)) >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[11] = (s11 + (1 << 20)) >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = s0 >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[1] = s1 >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[2] = s2 >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[3] = s3 >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[4] = s4 >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[5] = s5 >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[6] = s6 >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[7] = s7 >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[8] = s8 >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[9] = s9 >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[10] = s10 >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
- carry[11] = s11 >> 21
- s12 += carry[11]
- s11 -= carry[11] << 21
-
- s0 += s12 * 666643
- s1 += s12 * 470296
- s2 += s12 * 654183
- s3 -= s12 * 997805
- s4 += s12 * 136657
- s5 -= s12 * 683901
- s12 = 0
-
- carry[0] = s0 >> 21
- s1 += carry[0]
- s0 -= carry[0] << 21
- carry[1] = s1 >> 21
- s2 += carry[1]
- s1 -= carry[1] << 21
- carry[2] = s2 >> 21
- s3 += carry[2]
- s2 -= carry[2] << 21
- carry[3] = s3 >> 21
- s4 += carry[3]
- s3 -= carry[3] << 21
- carry[4] = s4 >> 21
- s5 += carry[4]
- s4 -= carry[4] << 21
- carry[5] = s5 >> 21
- s6 += carry[5]
- s5 -= carry[5] << 21
- carry[6] = s6 >> 21
- s7 += carry[6]
- s6 -= carry[6] << 21
- carry[7] = s7 >> 21
- s8 += carry[7]
- s7 -= carry[7] << 21
- carry[8] = s8 >> 21
- s9 += carry[8]
- s8 -= carry[8] << 21
- carry[9] = s9 >> 21
- s10 += carry[9]
- s9 -= carry[9] << 21
- carry[10] = s10 >> 21
- s11 += carry[10]
- s10 -= carry[10] << 21
-
- out[0] = byte(s0 >> 0)
- out[1] = byte(s0 >> 8)
- out[2] = byte((s0 >> 16) | (s1 << 5))
- out[3] = byte(s1 >> 3)
- out[4] = byte(s1 >> 11)
- out[5] = byte((s1 >> 19) | (s2 << 2))
- out[6] = byte(s2 >> 6)
- out[7] = byte((s2 >> 14) | (s3 << 7))
- out[8] = byte(s3 >> 1)
- out[9] = byte(s3 >> 9)
- out[10] = byte((s3 >> 17) | (s4 << 4))
- out[11] = byte(s4 >> 4)
- out[12] = byte(s4 >> 12)
- out[13] = byte((s4 >> 20) | (s5 << 1))
- out[14] = byte(s5 >> 7)
- out[15] = byte((s5 >> 15) | (s6 << 6))
- out[16] = byte(s6 >> 2)
- out[17] = byte(s6 >> 10)
- out[18] = byte((s6 >> 18) | (s7 << 3))
- out[19] = byte(s7 >> 5)
- out[20] = byte(s7 >> 13)
- out[21] = byte(s8 >> 0)
- out[22] = byte(s8 >> 8)
- out[23] = byte((s8 >> 16) | (s9 << 5))
- out[24] = byte(s9 >> 3)
- out[25] = byte(s9 >> 11)
- out[26] = byte((s9 >> 19) | (s10 << 2))
- out[27] = byte(s10 >> 6)
- out[28] = byte((s10 >> 14) | (s11 << 7))
- out[29] = byte(s11 >> 1)
- out[30] = byte(s11 >> 9)
- out[31] = byte(s11 >> 17)
-}
diff --git a/vendor/golang.org/x/crypto/ssh/agent/client.go b/vendor/golang.org/x/crypto/ssh/agent/client.go
deleted file mode 100644
index ecfd7c58d134f9d1e3feb34d1f050573d12cb2ea..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/agent/client.go
+++ /dev/null
@@ -1,659 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package agent implements the ssh-agent protocol, and provides both
-// a client and a server. The client can talk to a standard ssh-agent
-// that uses UNIX sockets, and one could implement an alternative
-// ssh-agent process using the sample server.
-//
-// References:
-// [PROTOCOL.agent]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.agent?rev=HEAD
-package agent // import "golang.org/x/crypto/ssh/agent"
-
-import (
- "bytes"
- "crypto/dsa"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rsa"
- "encoding/base64"
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "math/big"
- "sync"
-
- "golang.org/x/crypto/ed25519"
- "golang.org/x/crypto/ssh"
-)
-
-// Agent represents the capabilities of an ssh-agent.
-type Agent interface {
- // List returns the identities known to the agent.
- List() ([]*Key, error)
-
- // Sign has the agent sign the data using a protocol 2 key as defined
- // in [PROTOCOL.agent] section 2.6.2.
- Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error)
-
- // Add adds a private key to the agent.
- Add(key AddedKey) error
-
- // Remove removes all identities with the given public key.
- Remove(key ssh.PublicKey) error
-
- // RemoveAll removes all identities.
- RemoveAll() error
-
- // Lock locks the agent. Sign and Remove will fail, and List will empty an empty list.
- Lock(passphrase []byte) error
-
- // Unlock undoes the effect of Lock
- Unlock(passphrase []byte) error
-
- // Signers returns signers for all the known keys.
- Signers() ([]ssh.Signer, error)
-}
-
-// AddedKey describes an SSH key to be added to an Agent.
-type AddedKey struct {
- // PrivateKey must be a *rsa.PrivateKey, *dsa.PrivateKey or
- // *ecdsa.PrivateKey, which will be inserted into the agent.
- PrivateKey interface{}
- // Certificate, if not nil, is communicated to the agent and will be
- // stored with the key.
- Certificate *ssh.Certificate
- // Comment is an optional, free-form string.
- Comment string
- // LifetimeSecs, if not zero, is the number of seconds that the
- // agent will store the key for.
- LifetimeSecs uint32
- // ConfirmBeforeUse, if true, requests that the agent confirm with the
- // user before each use of this key.
- ConfirmBeforeUse bool
-}
-
-// See [PROTOCOL.agent], section 3.
-const (
- agentRequestV1Identities = 1
- agentRemoveAllV1Identities = 9
-
- // 3.2 Requests from client to agent for protocol 2 key operations
- agentAddIdentity = 17
- agentRemoveIdentity = 18
- agentRemoveAllIdentities = 19
- agentAddIdConstrained = 25
-
- // 3.3 Key-type independent requests from client to agent
- agentAddSmartcardKey = 20
- agentRemoveSmartcardKey = 21
- agentLock = 22
- agentUnlock = 23
- agentAddSmartcardKeyConstrained = 26
-
- // 3.7 Key constraint identifiers
- agentConstrainLifetime = 1
- agentConstrainConfirm = 2
-)
-
-// maxAgentResponseBytes is the maximum agent reply size that is accepted. This
-// is a sanity check, not a limit in the spec.
-const maxAgentResponseBytes = 16 << 20
-
-// Agent messages:
-// These structures mirror the wire format of the corresponding ssh agent
-// messages found in [PROTOCOL.agent].
-
-// 3.4 Generic replies from agent to client
-const agentFailure = 5
-
-type failureAgentMsg struct{}
-
-const agentSuccess = 6
-
-type successAgentMsg struct{}
-
-// See [PROTOCOL.agent], section 2.5.2.
-const agentRequestIdentities = 11
-
-type requestIdentitiesAgentMsg struct{}
-
-// See [PROTOCOL.agent], section 2.5.2.
-const agentIdentitiesAnswer = 12
-
-type identitiesAnswerAgentMsg struct {
- NumKeys uint32 `sshtype:"12"`
- Keys []byte `ssh:"rest"`
-}
-
-// See [PROTOCOL.agent], section 2.6.2.
-const agentSignRequest = 13
-
-type signRequestAgentMsg struct {
- KeyBlob []byte `sshtype:"13"`
- Data []byte
- Flags uint32
-}
-
-// See [PROTOCOL.agent], section 2.6.2.
-
-// 3.6 Replies from agent to client for protocol 2 key operations
-const agentSignResponse = 14
-
-type signResponseAgentMsg struct {
- SigBlob []byte `sshtype:"14"`
-}
-
-type publicKey struct {
- Format string
- Rest []byte `ssh:"rest"`
-}
-
-// Key represents a protocol 2 public key as defined in
-// [PROTOCOL.agent], section 2.5.2.
-type Key struct {
- Format string
- Blob []byte
- Comment string
-}
-
-func clientErr(err error) error {
- return fmt.Errorf("agent: client error: %v", err)
-}
-
-// String returns the storage form of an agent key with the format, base64
-// encoded serialized key, and the comment if it is not empty.
-func (k *Key) String() string {
- s := string(k.Format) + " " + base64.StdEncoding.EncodeToString(k.Blob)
-
- if k.Comment != "" {
- s += " " + k.Comment
- }
-
- return s
-}
-
-// Type returns the public key type.
-func (k *Key) Type() string {
- return k.Format
-}
-
-// Marshal returns key blob to satisfy the ssh.PublicKey interface.
-func (k *Key) Marshal() []byte {
- return k.Blob
-}
-
-// Verify satisfies the ssh.PublicKey interface.
-func (k *Key) Verify(data []byte, sig *ssh.Signature) error {
- pubKey, err := ssh.ParsePublicKey(k.Blob)
- if err != nil {
- return fmt.Errorf("agent: bad public key: %v", err)
- }
- return pubKey.Verify(data, sig)
-}
-
-type wireKey struct {
- Format string
- Rest []byte `ssh:"rest"`
-}
-
-func parseKey(in []byte) (out *Key, rest []byte, err error) {
- var record struct {
- Blob []byte
- Comment string
- Rest []byte `ssh:"rest"`
- }
-
- if err := ssh.Unmarshal(in, &record); err != nil {
- return nil, nil, err
- }
-
- var wk wireKey
- if err := ssh.Unmarshal(record.Blob, &wk); err != nil {
- return nil, nil, err
- }
-
- return &Key{
- Format: wk.Format,
- Blob: record.Blob,
- Comment: record.Comment,
- }, record.Rest, nil
-}
-
-// client is a client for an ssh-agent process.
-type client struct {
- // conn is typically a *net.UnixConn
- conn io.ReadWriter
- // mu is used to prevent concurrent access to the agent
- mu sync.Mutex
-}
-
-// NewClient returns an Agent that talks to an ssh-agent process over
-// the given connection.
-func NewClient(rw io.ReadWriter) Agent {
- return &client{conn: rw}
-}
-
-// call sends an RPC to the agent. On success, the reply is
-// unmarshaled into reply and replyType is set to the first byte of
-// the reply, which contains the type of the message.
-func (c *client) call(req []byte) (reply interface{}, err error) {
- c.mu.Lock()
- defer c.mu.Unlock()
-
- msg := make([]byte, 4+len(req))
- binary.BigEndian.PutUint32(msg, uint32(len(req)))
- copy(msg[4:], req)
- if _, err = c.conn.Write(msg); err != nil {
- return nil, clientErr(err)
- }
-
- var respSizeBuf [4]byte
- if _, err = io.ReadFull(c.conn, respSizeBuf[:]); err != nil {
- return nil, clientErr(err)
- }
- respSize := binary.BigEndian.Uint32(respSizeBuf[:])
- if respSize > maxAgentResponseBytes {
- return nil, clientErr(err)
- }
-
- buf := make([]byte, respSize)
- if _, err = io.ReadFull(c.conn, buf); err != nil {
- return nil, clientErr(err)
- }
- reply, err = unmarshal(buf)
- if err != nil {
- return nil, clientErr(err)
- }
- return reply, err
-}
-
-func (c *client) simpleCall(req []byte) error {
- resp, err := c.call(req)
- if err != nil {
- return err
- }
- if _, ok := resp.(*successAgentMsg); ok {
- return nil
- }
- return errors.New("agent: failure")
-}
-
-func (c *client) RemoveAll() error {
- return c.simpleCall([]byte{agentRemoveAllIdentities})
-}
-
-func (c *client) Remove(key ssh.PublicKey) error {
- req := ssh.Marshal(&agentRemoveIdentityMsg{
- KeyBlob: key.Marshal(),
- })
- return c.simpleCall(req)
-}
-
-func (c *client) Lock(passphrase []byte) error {
- req := ssh.Marshal(&agentLockMsg{
- Passphrase: passphrase,
- })
- return c.simpleCall(req)
-}
-
-func (c *client) Unlock(passphrase []byte) error {
- req := ssh.Marshal(&agentUnlockMsg{
- Passphrase: passphrase,
- })
- return c.simpleCall(req)
-}
-
-// List returns the identities known to the agent.
-func (c *client) List() ([]*Key, error) {
- // see [PROTOCOL.agent] section 2.5.2.
- req := []byte{agentRequestIdentities}
-
- msg, err := c.call(req)
- if err != nil {
- return nil, err
- }
-
- switch msg := msg.(type) {
- case *identitiesAnswerAgentMsg:
- if msg.NumKeys > maxAgentResponseBytes/8 {
- return nil, errors.New("agent: too many keys in agent reply")
- }
- keys := make([]*Key, msg.NumKeys)
- data := msg.Keys
- for i := uint32(0); i < msg.NumKeys; i++ {
- var key *Key
- var err error
- if key, data, err = parseKey(data); err != nil {
- return nil, err
- }
- keys[i] = key
- }
- return keys, nil
- case *failureAgentMsg:
- return nil, errors.New("agent: failed to list keys")
- }
- panic("unreachable")
-}
-
-// Sign has the agent sign the data using a protocol 2 key as defined
-// in [PROTOCOL.agent] section 2.6.2.
-func (c *client) Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error) {
- req := ssh.Marshal(signRequestAgentMsg{
- KeyBlob: key.Marshal(),
- Data: data,
- })
-
- msg, err := c.call(req)
- if err != nil {
- return nil, err
- }
-
- switch msg := msg.(type) {
- case *signResponseAgentMsg:
- var sig ssh.Signature
- if err := ssh.Unmarshal(msg.SigBlob, &sig); err != nil {
- return nil, err
- }
-
- return &sig, nil
- case *failureAgentMsg:
- return nil, errors.New("agent: failed to sign challenge")
- }
- panic("unreachable")
-}
-
-// unmarshal parses an agent message in packet, returning the parsed
-// form and the message type of packet.
-func unmarshal(packet []byte) (interface{}, error) {
- if len(packet) < 1 {
- return nil, errors.New("agent: empty packet")
- }
- var msg interface{}
- switch packet[0] {
- case agentFailure:
- return new(failureAgentMsg), nil
- case agentSuccess:
- return new(successAgentMsg), nil
- case agentIdentitiesAnswer:
- msg = new(identitiesAnswerAgentMsg)
- case agentSignResponse:
- msg = new(signResponseAgentMsg)
- case agentV1IdentitiesAnswer:
- msg = new(agentV1IdentityMsg)
- default:
- return nil, fmt.Errorf("agent: unknown type tag %d", packet[0])
- }
- if err := ssh.Unmarshal(packet, msg); err != nil {
- return nil, err
- }
- return msg, nil
-}
-
-type rsaKeyMsg struct {
- Type string `sshtype:"17|25"`
- N *big.Int
- E *big.Int
- D *big.Int
- Iqmp *big.Int // IQMP = Inverse Q Mod P
- P *big.Int
- Q *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type dsaKeyMsg struct {
- Type string `sshtype:"17|25"`
- P *big.Int
- Q *big.Int
- G *big.Int
- Y *big.Int
- X *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type ecdsaKeyMsg struct {
- Type string `sshtype:"17|25"`
- Curve string
- KeyBytes []byte
- D *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type ed25519KeyMsg struct {
- Type string `sshtype:"17|25"`
- Pub []byte
- Priv []byte
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-// Insert adds a private key to the agent.
-func (c *client) insertKey(s interface{}, comment string, constraints []byte) error {
- var req []byte
- switch k := s.(type) {
- case *rsa.PrivateKey:
- if len(k.Primes) != 2 {
- return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes))
- }
- k.Precompute()
- req = ssh.Marshal(rsaKeyMsg{
- Type: ssh.KeyAlgoRSA,
- N: k.N,
- E: big.NewInt(int64(k.E)),
- D: k.D,
- Iqmp: k.Precomputed.Qinv,
- P: k.Primes[0],
- Q: k.Primes[1],
- Comments: comment,
- Constraints: constraints,
- })
- case *dsa.PrivateKey:
- req = ssh.Marshal(dsaKeyMsg{
- Type: ssh.KeyAlgoDSA,
- P: k.P,
- Q: k.Q,
- G: k.G,
- Y: k.Y,
- X: k.X,
- Comments: comment,
- Constraints: constraints,
- })
- case *ecdsa.PrivateKey:
- nistID := fmt.Sprintf("nistp%d", k.Params().BitSize)
- req = ssh.Marshal(ecdsaKeyMsg{
- Type: "ecdsa-sha2-" + nistID,
- Curve: nistID,
- KeyBytes: elliptic.Marshal(k.Curve, k.X, k.Y),
- D: k.D,
- Comments: comment,
- Constraints: constraints,
- })
- case *ed25519.PrivateKey:
- req = ssh.Marshal(ed25519KeyMsg{
- Type: ssh.KeyAlgoED25519,
- Pub: []byte(*k)[32:],
- Priv: []byte(*k),
- Comments: comment,
- Constraints: constraints,
- })
- default:
- return fmt.Errorf("agent: unsupported key type %T", s)
- }
-
- // if constraints are present then the message type needs to be changed.
- if len(constraints) != 0 {
- req[0] = agentAddIdConstrained
- }
-
- resp, err := c.call(req)
- if err != nil {
- return err
- }
- if _, ok := resp.(*successAgentMsg); ok {
- return nil
- }
- return errors.New("agent: failure")
-}
-
-type rsaCertMsg struct {
- Type string `sshtype:"17|25"`
- CertBytes []byte
- D *big.Int
- Iqmp *big.Int // IQMP = Inverse Q Mod P
- P *big.Int
- Q *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type dsaCertMsg struct {
- Type string `sshtype:"17|25"`
- CertBytes []byte
- X *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type ecdsaCertMsg struct {
- Type string `sshtype:"17|25"`
- CertBytes []byte
- D *big.Int
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-type ed25519CertMsg struct {
- Type string `sshtype:"17|25"`
- CertBytes []byte
- Pub []byte
- Priv []byte
- Comments string
- Constraints []byte `ssh:"rest"`
-}
-
-// Add adds a private key to the agent. If a certificate is given,
-// that certificate is added instead as public key.
-func (c *client) Add(key AddedKey) error {
- var constraints []byte
-
- if secs := key.LifetimeSecs; secs != 0 {
- constraints = append(constraints, agentConstrainLifetime)
-
- var secsBytes [4]byte
- binary.BigEndian.PutUint32(secsBytes[:], secs)
- constraints = append(constraints, secsBytes[:]...)
- }
-
- if key.ConfirmBeforeUse {
- constraints = append(constraints, agentConstrainConfirm)
- }
-
- if cert := key.Certificate; cert == nil {
- return c.insertKey(key.PrivateKey, key.Comment, constraints)
- } else {
- return c.insertCert(key.PrivateKey, cert, key.Comment, constraints)
- }
-}
-
-func (c *client) insertCert(s interface{}, cert *ssh.Certificate, comment string, constraints []byte) error {
- var req []byte
- switch k := s.(type) {
- case *rsa.PrivateKey:
- if len(k.Primes) != 2 {
- return fmt.Errorf("agent: unsupported RSA key with %d primes", len(k.Primes))
- }
- k.Precompute()
- req = ssh.Marshal(rsaCertMsg{
- Type: cert.Type(),
- CertBytes: cert.Marshal(),
- D: k.D,
- Iqmp: k.Precomputed.Qinv,
- P: k.Primes[0],
- Q: k.Primes[1],
- Comments: comment,
- Constraints: constraints,
- })
- case *dsa.PrivateKey:
- req = ssh.Marshal(dsaCertMsg{
- Type: cert.Type(),
- CertBytes: cert.Marshal(),
- X: k.X,
- Comments: comment,
- Constraints: constraints,
- })
- case *ecdsa.PrivateKey:
- req = ssh.Marshal(ecdsaCertMsg{
- Type: cert.Type(),
- CertBytes: cert.Marshal(),
- D: k.D,
- Comments: comment,
- Constraints: constraints,
- })
- case *ed25519.PrivateKey:
- req = ssh.Marshal(ed25519CertMsg{
- Type: cert.Type(),
- CertBytes: cert.Marshal(),
- Pub: []byte(*k)[32:],
- Priv: []byte(*k),
- Comments: comment,
- Constraints: constraints,
- })
- default:
- return fmt.Errorf("agent: unsupported key type %T", s)
- }
-
- // if constraints are present then the message type needs to be changed.
- if len(constraints) != 0 {
- req[0] = agentAddIdConstrained
- }
-
- signer, err := ssh.NewSignerFromKey(s)
- if err != nil {
- return err
- }
- if bytes.Compare(cert.Key.Marshal(), signer.PublicKey().Marshal()) != 0 {
- return errors.New("agent: signer and cert have different public key")
- }
-
- resp, err := c.call(req)
- if err != nil {
- return err
- }
- if _, ok := resp.(*successAgentMsg); ok {
- return nil
- }
- return errors.New("agent: failure")
-}
-
-// Signers provides a callback for client authentication.
-func (c *client) Signers() ([]ssh.Signer, error) {
- keys, err := c.List()
- if err != nil {
- return nil, err
- }
-
- var result []ssh.Signer
- for _, k := range keys {
- result = append(result, &agentKeyringSigner{c, k})
- }
- return result, nil
-}
-
-type agentKeyringSigner struct {
- agent *client
- pub ssh.PublicKey
-}
-
-func (s *agentKeyringSigner) PublicKey() ssh.PublicKey {
- return s.pub
-}
-
-func (s *agentKeyringSigner) Sign(rand io.Reader, data []byte) (*ssh.Signature, error) {
- // The agent has its own entropy source, so the rand argument is ignored.
- return s.agent.Sign(s.pub, data)
-}
diff --git a/vendor/golang.org/x/crypto/ssh/agent/forward.go b/vendor/golang.org/x/crypto/ssh/agent/forward.go
deleted file mode 100644
index fd24ba900d2541ff523678b62b424086d5ee853d..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/agent/forward.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package agent
-
-import (
- "errors"
- "io"
- "net"
- "sync"
-
- "golang.org/x/crypto/ssh"
-)
-
-// RequestAgentForwarding sets up agent forwarding for the session.
-// ForwardToAgent or ForwardToRemote should be called to route
-// the authentication requests.
-func RequestAgentForwarding(session *ssh.Session) error {
- ok, err := session.SendRequest("auth-agent-req@openssh.com", true, nil)
- if err != nil {
- return err
- }
- if !ok {
- return errors.New("forwarding request denied")
- }
- return nil
-}
-
-// ForwardToAgent routes authentication requests to the given keyring.
-func ForwardToAgent(client *ssh.Client, keyring Agent) error {
- channels := client.HandleChannelOpen(channelType)
- if channels == nil {
- return errors.New("agent: already have handler for " + channelType)
- }
-
- go func() {
- for ch := range channels {
- channel, reqs, err := ch.Accept()
- if err != nil {
- continue
- }
- go ssh.DiscardRequests(reqs)
- go func() {
- ServeAgent(keyring, channel)
- channel.Close()
- }()
- }
- }()
- return nil
-}
-
-const channelType = "auth-agent@openssh.com"
-
-// ForwardToRemote routes authentication requests to the ssh-agent
-// process serving on the given unix socket.
-func ForwardToRemote(client *ssh.Client, addr string) error {
- channels := client.HandleChannelOpen(channelType)
- if channels == nil {
- return errors.New("agent: already have handler for " + channelType)
- }
- conn, err := net.Dial("unix", addr)
- if err != nil {
- return err
- }
- conn.Close()
-
- go func() {
- for ch := range channels {
- channel, reqs, err := ch.Accept()
- if err != nil {
- continue
- }
- go ssh.DiscardRequests(reqs)
- go forwardUnixSocket(channel, addr)
- }
- }()
- return nil
-}
-
-func forwardUnixSocket(channel ssh.Channel, addr string) {
- conn, err := net.Dial("unix", addr)
- if err != nil {
- return
- }
-
- var wg sync.WaitGroup
- wg.Add(2)
- go func() {
- io.Copy(conn, channel)
- conn.(*net.UnixConn).CloseWrite()
- wg.Done()
- }()
- go func() {
- io.Copy(channel, conn)
- channel.CloseWrite()
- wg.Done()
- }()
-
- wg.Wait()
- conn.Close()
- channel.Close()
-}
diff --git a/vendor/golang.org/x/crypto/ssh/agent/keyring.go b/vendor/golang.org/x/crypto/ssh/agent/keyring.go
deleted file mode 100644
index a6ba06ab3011916bee1737fe20fc8fc24e9b5382..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/agent/keyring.go
+++ /dev/null
@@ -1,215 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package agent
-
-import (
- "bytes"
- "crypto/rand"
- "crypto/subtle"
- "errors"
- "fmt"
- "sync"
- "time"
-
- "golang.org/x/crypto/ssh"
-)
-
-type privKey struct {
- signer ssh.Signer
- comment string
- expire *time.Time
-}
-
-type keyring struct {
- mu sync.Mutex
- keys []privKey
-
- locked bool
- passphrase []byte
-}
-
-var errLocked = errors.New("agent: locked")
-
-// NewKeyring returns an Agent that holds keys in memory. It is safe
-// for concurrent use by multiple goroutines.
-func NewKeyring() Agent {
- return &keyring{}
-}
-
-// RemoveAll removes all identities.
-func (r *keyring) RemoveAll() error {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return errLocked
- }
-
- r.keys = nil
- return nil
-}
-
-// removeLocked does the actual key removal. The caller must already be holding the
-// keyring mutex.
-func (r *keyring) removeLocked(want []byte) error {
- found := false
- for i := 0; i < len(r.keys); {
- if bytes.Equal(r.keys[i].signer.PublicKey().Marshal(), want) {
- found = true
- r.keys[i] = r.keys[len(r.keys)-1]
- r.keys = r.keys[:len(r.keys)-1]
- continue
- } else {
- i++
- }
- }
-
- if !found {
- return errors.New("agent: key not found")
- }
- return nil
-}
-
-// Remove removes all identities with the given public key.
-func (r *keyring) Remove(key ssh.PublicKey) error {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return errLocked
- }
-
- return r.removeLocked(key.Marshal())
-}
-
-// Lock locks the agent. Sign and Remove will fail, and List will return an empty list.
-func (r *keyring) Lock(passphrase []byte) error {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return errLocked
- }
-
- r.locked = true
- r.passphrase = passphrase
- return nil
-}
-
-// Unlock undoes the effect of Lock
-func (r *keyring) Unlock(passphrase []byte) error {
- r.mu.Lock()
- defer r.mu.Unlock()
- if !r.locked {
- return errors.New("agent: not locked")
- }
- if len(passphrase) != len(r.passphrase) || 1 != subtle.ConstantTimeCompare(passphrase, r.passphrase) {
- return fmt.Errorf("agent: incorrect passphrase")
- }
-
- r.locked = false
- r.passphrase = nil
- return nil
-}
-
-// expireKeysLocked removes expired keys from the keyring. If a key was added
-// with a lifetimesecs contraint and seconds >= lifetimesecs seconds have
-// ellapsed, it is removed. The caller *must* be holding the keyring mutex.
-func (r *keyring) expireKeysLocked() {
- for _, k := range r.keys {
- if k.expire != nil && time.Now().After(*k.expire) {
- r.removeLocked(k.signer.PublicKey().Marshal())
- }
- }
-}
-
-// List returns the identities known to the agent.
-func (r *keyring) List() ([]*Key, error) {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- // section 2.7: locked agents return empty.
- return nil, nil
- }
-
- r.expireKeysLocked()
- var ids []*Key
- for _, k := range r.keys {
- pub := k.signer.PublicKey()
- ids = append(ids, &Key{
- Format: pub.Type(),
- Blob: pub.Marshal(),
- Comment: k.comment})
- }
- return ids, nil
-}
-
-// Insert adds a private key to the keyring. If a certificate
-// is given, that certificate is added as public key. Note that
-// any constraints given are ignored.
-func (r *keyring) Add(key AddedKey) error {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return errLocked
- }
- signer, err := ssh.NewSignerFromKey(key.PrivateKey)
-
- if err != nil {
- return err
- }
-
- if cert := key.Certificate; cert != nil {
- signer, err = ssh.NewCertSigner(cert, signer)
- if err != nil {
- return err
- }
- }
-
- p := privKey{
- signer: signer,
- comment: key.Comment,
- }
-
- if key.LifetimeSecs > 0 {
- t := time.Now().Add(time.Duration(key.LifetimeSecs) * time.Second)
- p.expire = &t
- }
-
- r.keys = append(r.keys, p)
-
- return nil
-}
-
-// Sign returns a signature for the data.
-func (r *keyring) Sign(key ssh.PublicKey, data []byte) (*ssh.Signature, error) {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return nil, errLocked
- }
-
- r.expireKeysLocked()
- wanted := key.Marshal()
- for _, k := range r.keys {
- if bytes.Equal(k.signer.PublicKey().Marshal(), wanted) {
- return k.signer.Sign(rand.Reader, data)
- }
- }
- return nil, errors.New("not found")
-}
-
-// Signers returns signers for all the known keys.
-func (r *keyring) Signers() ([]ssh.Signer, error) {
- r.mu.Lock()
- defer r.mu.Unlock()
- if r.locked {
- return nil, errLocked
- }
-
- r.expireKeysLocked()
- s := make([]ssh.Signer, 0, len(r.keys))
- for _, k := range r.keys {
- s = append(s, k.signer)
- }
- return s, nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/agent/server.go b/vendor/golang.org/x/crypto/ssh/agent/server.go
deleted file mode 100644
index 68a333fa5d8b62a8a8d2f3d233b05bb32094bf4e..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/agent/server.go
+++ /dev/null
@@ -1,451 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package agent
-
-import (
- "crypto/dsa"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rsa"
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "log"
- "math/big"
-
- "golang.org/x/crypto/ed25519"
- "golang.org/x/crypto/ssh"
-)
-
-// Server wraps an Agent and uses it to implement the agent side of
-// the SSH-agent, wire protocol.
-type server struct {
- agent Agent
-}
-
-func (s *server) processRequestBytes(reqData []byte) []byte {
- rep, err := s.processRequest(reqData)
- if err != nil {
- if err != errLocked {
- // TODO(hanwen): provide better logging interface?
- log.Printf("agent %d: %v", reqData[0], err)
- }
- return []byte{agentFailure}
- }
-
- if err == nil && rep == nil {
- return []byte{agentSuccess}
- }
-
- return ssh.Marshal(rep)
-}
-
-func marshalKey(k *Key) []byte {
- var record struct {
- Blob []byte
- Comment string
- }
- record.Blob = k.Marshal()
- record.Comment = k.Comment
-
- return ssh.Marshal(&record)
-}
-
-// See [PROTOCOL.agent], section 2.5.1.
-const agentV1IdentitiesAnswer = 2
-
-type agentV1IdentityMsg struct {
- Numkeys uint32 `sshtype:"2"`
-}
-
-type agentRemoveIdentityMsg struct {
- KeyBlob []byte `sshtype:"18"`
-}
-
-type agentLockMsg struct {
- Passphrase []byte `sshtype:"22"`
-}
-
-type agentUnlockMsg struct {
- Passphrase []byte `sshtype:"23"`
-}
-
-func (s *server) processRequest(data []byte) (interface{}, error) {
- switch data[0] {
- case agentRequestV1Identities:
- return &agentV1IdentityMsg{0}, nil
-
- case agentRemoveAllV1Identities:
- return nil, nil
-
- case agentRemoveIdentity:
- var req agentRemoveIdentityMsg
- if err := ssh.Unmarshal(data, &req); err != nil {
- return nil, err
- }
-
- var wk wireKey
- if err := ssh.Unmarshal(req.KeyBlob, &wk); err != nil {
- return nil, err
- }
-
- return nil, s.agent.Remove(&Key{Format: wk.Format, Blob: req.KeyBlob})
-
- case agentRemoveAllIdentities:
- return nil, s.agent.RemoveAll()
-
- case agentLock:
- var req agentLockMsg
- if err := ssh.Unmarshal(data, &req); err != nil {
- return nil, err
- }
-
- return nil, s.agent.Lock(req.Passphrase)
-
- case agentUnlock:
- var req agentLockMsg
- if err := ssh.Unmarshal(data, &req); err != nil {
- return nil, err
- }
- return nil, s.agent.Unlock(req.Passphrase)
-
- case agentSignRequest:
- var req signRequestAgentMsg
- if err := ssh.Unmarshal(data, &req); err != nil {
- return nil, err
- }
-
- var wk wireKey
- if err := ssh.Unmarshal(req.KeyBlob, &wk); err != nil {
- return nil, err
- }
-
- k := &Key{
- Format: wk.Format,
- Blob: req.KeyBlob,
- }
-
- sig, err := s.agent.Sign(k, req.Data) // TODO(hanwen): flags.
- if err != nil {
- return nil, err
- }
- return &signResponseAgentMsg{SigBlob: ssh.Marshal(sig)}, nil
-
- case agentRequestIdentities:
- keys, err := s.agent.List()
- if err != nil {
- return nil, err
- }
-
- rep := identitiesAnswerAgentMsg{
- NumKeys: uint32(len(keys)),
- }
- for _, k := range keys {
- rep.Keys = append(rep.Keys, marshalKey(k)...)
- }
- return rep, nil
-
- case agentAddIdConstrained, agentAddIdentity:
- return nil, s.insertIdentity(data)
- }
-
- return nil, fmt.Errorf("unknown opcode %d", data[0])
-}
-
-func parseRSAKey(req []byte) (*AddedKey, error) {
- var k rsaKeyMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
- if k.E.BitLen() > 30 {
- return nil, errors.New("agent: RSA public exponent too large")
- }
- priv := &rsa.PrivateKey{
- PublicKey: rsa.PublicKey{
- E: int(k.E.Int64()),
- N: k.N,
- },
- D: k.D,
- Primes: []*big.Int{k.P, k.Q},
- }
- priv.Precompute()
-
- return &AddedKey{PrivateKey: priv, Comment: k.Comments}, nil
-}
-
-func parseEd25519Key(req []byte) (*AddedKey, error) {
- var k ed25519KeyMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
- priv := ed25519.PrivateKey(k.Priv)
- return &AddedKey{PrivateKey: &priv, Comment: k.Comments}, nil
-}
-
-func parseDSAKey(req []byte) (*AddedKey, error) {
- var k dsaKeyMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
- priv := &dsa.PrivateKey{
- PublicKey: dsa.PublicKey{
- Parameters: dsa.Parameters{
- P: k.P,
- Q: k.Q,
- G: k.G,
- },
- Y: k.Y,
- },
- X: k.X,
- }
-
- return &AddedKey{PrivateKey: priv, Comment: k.Comments}, nil
-}
-
-func unmarshalECDSA(curveName string, keyBytes []byte, privScalar *big.Int) (priv *ecdsa.PrivateKey, err error) {
- priv = &ecdsa.PrivateKey{
- D: privScalar,
- }
-
- switch curveName {
- case "nistp256":
- priv.Curve = elliptic.P256()
- case "nistp384":
- priv.Curve = elliptic.P384()
- case "nistp521":
- priv.Curve = elliptic.P521()
- default:
- return nil, fmt.Errorf("agent: unknown curve %q", curveName)
- }
-
- priv.X, priv.Y = elliptic.Unmarshal(priv.Curve, keyBytes)
- if priv.X == nil || priv.Y == nil {
- return nil, errors.New("agent: point not on curve")
- }
-
- return priv, nil
-}
-
-func parseEd25519Cert(req []byte) (*AddedKey, error) {
- var k ed25519CertMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
- pubKey, err := ssh.ParsePublicKey(k.CertBytes)
- if err != nil {
- return nil, err
- }
- priv := ed25519.PrivateKey(k.Priv)
- cert, ok := pubKey.(*ssh.Certificate)
- if !ok {
- return nil, errors.New("agent: bad ED25519 certificate")
- }
- return &AddedKey{PrivateKey: &priv, Certificate: cert, Comment: k.Comments}, nil
-}
-
-func parseECDSAKey(req []byte) (*AddedKey, error) {
- var k ecdsaKeyMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
-
- priv, err := unmarshalECDSA(k.Curve, k.KeyBytes, k.D)
- if err != nil {
- return nil, err
- }
-
- return &AddedKey{PrivateKey: priv, Comment: k.Comments}, nil
-}
-
-func parseRSACert(req []byte) (*AddedKey, error) {
- var k rsaCertMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
-
- pubKey, err := ssh.ParsePublicKey(k.CertBytes)
- if err != nil {
- return nil, err
- }
-
- cert, ok := pubKey.(*ssh.Certificate)
- if !ok {
- return nil, errors.New("agent: bad RSA certificate")
- }
-
- // An RSA publickey as marshaled by rsaPublicKey.Marshal() in keys.go
- var rsaPub struct {
- Name string
- E *big.Int
- N *big.Int
- }
- if err := ssh.Unmarshal(cert.Key.Marshal(), &rsaPub); err != nil {
- return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
- }
-
- if rsaPub.E.BitLen() > 30 {
- return nil, errors.New("agent: RSA public exponent too large")
- }
-
- priv := rsa.PrivateKey{
- PublicKey: rsa.PublicKey{
- E: int(rsaPub.E.Int64()),
- N: rsaPub.N,
- },
- D: k.D,
- Primes: []*big.Int{k.Q, k.P},
- }
- priv.Precompute()
-
- return &AddedKey{PrivateKey: &priv, Certificate: cert, Comment: k.Comments}, nil
-}
-
-func parseDSACert(req []byte) (*AddedKey, error) {
- var k dsaCertMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
- pubKey, err := ssh.ParsePublicKey(k.CertBytes)
- if err != nil {
- return nil, err
- }
- cert, ok := pubKey.(*ssh.Certificate)
- if !ok {
- return nil, errors.New("agent: bad DSA certificate")
- }
-
- // A DSA publickey as marshaled by dsaPublicKey.Marshal() in keys.go
- var w struct {
- Name string
- P, Q, G, Y *big.Int
- }
- if err := ssh.Unmarshal(cert.Key.Marshal(), &w); err != nil {
- return nil, fmt.Errorf("agent: Unmarshal failed to parse public key: %v", err)
- }
-
- priv := &dsa.PrivateKey{
- PublicKey: dsa.PublicKey{
- Parameters: dsa.Parameters{
- P: w.P,
- Q: w.Q,
- G: w.G,
- },
- Y: w.Y,
- },
- X: k.X,
- }
-
- return &AddedKey{PrivateKey: priv, Certificate: cert, Comment: k.Comments}, nil
-}
-
-func parseECDSACert(req []byte) (*AddedKey, error) {
- var k ecdsaCertMsg
- if err := ssh.Unmarshal(req, &k); err != nil {
- return nil, err
- }
-
- pubKey, err := ssh.ParsePublicKey(k.CertBytes)
- if err != nil {
- return nil, err
- }
- cert, ok := pubKey.(*ssh.Certificate)
- if !ok {
- return nil, errors.New("agent: bad ECDSA certificate")
- }
-
- // An ECDSA publickey as marshaled by ecdsaPublicKey.Marshal() in keys.go
- var ecdsaPub struct {
- Name string
- ID string
- Key []byte
- }
- if err := ssh.Unmarshal(cert.Key.Marshal(), &ecdsaPub); err != nil {
- return nil, err
- }
-
- priv, err := unmarshalECDSA(ecdsaPub.ID, ecdsaPub.Key, k.D)
- if err != nil {
- return nil, err
- }
-
- return &AddedKey{PrivateKey: priv, Certificate: cert, Comment: k.Comments}, nil
-}
-
-func (s *server) insertIdentity(req []byte) error {
- var record struct {
- Type string `sshtype:"17|25"`
- Rest []byte `ssh:"rest"`
- }
-
- if err := ssh.Unmarshal(req, &record); err != nil {
- return err
- }
-
- var addedKey *AddedKey
- var err error
-
- switch record.Type {
- case ssh.KeyAlgoRSA:
- addedKey, err = parseRSAKey(req)
- case ssh.KeyAlgoDSA:
- addedKey, err = parseDSAKey(req)
- case ssh.KeyAlgoECDSA256, ssh.KeyAlgoECDSA384, ssh.KeyAlgoECDSA521:
- addedKey, err = parseECDSAKey(req)
- case ssh.KeyAlgoED25519:
- addedKey, err = parseEd25519Key(req)
- case ssh.CertAlgoRSAv01:
- addedKey, err = parseRSACert(req)
- case ssh.CertAlgoDSAv01:
- addedKey, err = parseDSACert(req)
- case ssh.CertAlgoECDSA256v01, ssh.CertAlgoECDSA384v01, ssh.CertAlgoECDSA521v01:
- addedKey, err = parseECDSACert(req)
- case ssh.CertAlgoED25519v01:
- addedKey, err = parseEd25519Cert(req)
- default:
- return fmt.Errorf("agent: not implemented: %q", record.Type)
- }
-
- if err != nil {
- return err
- }
- return s.agent.Add(*addedKey)
-}
-
-// ServeAgent serves the agent protocol on the given connection. It
-// returns when an I/O error occurs.
-func ServeAgent(agent Agent, c io.ReadWriter) error {
- s := &server{agent}
-
- var length [4]byte
- for {
- if _, err := io.ReadFull(c, length[:]); err != nil {
- return err
- }
- l := binary.BigEndian.Uint32(length[:])
- if l > maxAgentResponseBytes {
- // We also cap requests.
- return fmt.Errorf("agent: request too large: %d", l)
- }
-
- req := make([]byte, l)
- if _, err := io.ReadFull(c, req); err != nil {
- return err
- }
-
- repData := s.processRequestBytes(req)
- if len(repData) > maxAgentResponseBytes {
- return fmt.Errorf("agent: reply too large: %d bytes", len(repData))
- }
-
- binary.BigEndian.PutUint32(length[:], uint32(len(repData)))
- if _, err := c.Write(length[:]); err != nil {
- return err
- }
- if _, err := c.Write(repData); err != nil {
- return err
- }
- }
-}
diff --git a/vendor/golang.org/x/crypto/ssh/buffer.go b/vendor/golang.org/x/crypto/ssh/buffer.go
deleted file mode 100644
index 6931b5114fe8301e1ee955e6a2878ff10e43d4df..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/buffer.go
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "io"
- "sync"
-)
-
-// buffer provides a linked list buffer for data exchange
-// between producer and consumer. Theoretically the buffer is
-// of unlimited capacity as it does no allocation of its own.
-type buffer struct {
- // protects concurrent access to head, tail and closed
- *sync.Cond
-
- head *element // the buffer that will be read first
- tail *element // the buffer that will be read last
-
- closed bool
-}
-
-// An element represents a single link in a linked list.
-type element struct {
- buf []byte
- next *element
-}
-
-// newBuffer returns an empty buffer that is not closed.
-func newBuffer() *buffer {
- e := new(element)
- b := &buffer{
- Cond: newCond(),
- head: e,
- tail: e,
- }
- return b
-}
-
-// write makes buf available for Read to receive.
-// buf must not be modified after the call to write.
-func (b *buffer) write(buf []byte) {
- b.Cond.L.Lock()
- e := &element{buf: buf}
- b.tail.next = e
- b.tail = e
- b.Cond.Signal()
- b.Cond.L.Unlock()
-}
-
-// eof closes the buffer. Reads from the buffer once all
-// the data has been consumed will receive os.EOF.
-func (b *buffer) eof() error {
- b.Cond.L.Lock()
- b.closed = true
- b.Cond.Signal()
- b.Cond.L.Unlock()
- return nil
-}
-
-// Read reads data from the internal buffer in buf. Reads will block
-// if no data is available, or until the buffer is closed.
-func (b *buffer) Read(buf []byte) (n int, err error) {
- b.Cond.L.Lock()
- defer b.Cond.L.Unlock()
-
- for len(buf) > 0 {
- // if there is data in b.head, copy it
- if len(b.head.buf) > 0 {
- r := copy(buf, b.head.buf)
- buf, b.head.buf = buf[r:], b.head.buf[r:]
- n += r
- continue
- }
- // if there is a next buffer, make it the head
- if len(b.head.buf) == 0 && b.head != b.tail {
- b.head = b.head.next
- continue
- }
-
- // if at least one byte has been copied, return
- if n > 0 {
- break
- }
-
- // if nothing was read, and there is nothing outstanding
- // check to see if the buffer is closed.
- if b.closed {
- err = io.EOF
- break
- }
- // out of buffers, wait for producer
- b.Cond.Wait()
- }
- return
-}
diff --git a/vendor/golang.org/x/crypto/ssh/certs.go b/vendor/golang.org/x/crypto/ssh/certs.go
deleted file mode 100644
index 6331c94d53bc991332064fb0cfbd62075337f6a5..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/certs.go
+++ /dev/null
@@ -1,503 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
- "net"
- "sort"
- "time"
-)
-
-// These constants from [PROTOCOL.certkeys] represent the algorithm names
-// for certificate types supported by this package.
-const (
- CertAlgoRSAv01 = "ssh-rsa-cert-v01@openssh.com"
- CertAlgoDSAv01 = "ssh-dss-cert-v01@openssh.com"
- CertAlgoECDSA256v01 = "ecdsa-sha2-nistp256-cert-v01@openssh.com"
- CertAlgoECDSA384v01 = "ecdsa-sha2-nistp384-cert-v01@openssh.com"
- CertAlgoECDSA521v01 = "ecdsa-sha2-nistp521-cert-v01@openssh.com"
- CertAlgoED25519v01 = "ssh-ed25519-cert-v01@openssh.com"
-)
-
-// Certificate types distinguish between host and user
-// certificates. The values can be set in the CertType field of
-// Certificate.
-const (
- UserCert = 1
- HostCert = 2
-)
-
-// Signature represents a cryptographic signature.
-type Signature struct {
- Format string
- Blob []byte
-}
-
-// CertTimeInfinity can be used for OpenSSHCertV01.ValidBefore to indicate that
-// a certificate does not expire.
-const CertTimeInfinity = 1<<64 - 1
-
-// An Certificate represents an OpenSSH certificate as defined in
-// [PROTOCOL.certkeys]?rev=1.8.
-type Certificate struct {
- Nonce []byte
- Key PublicKey
- Serial uint64
- CertType uint32
- KeyId string
- ValidPrincipals []string
- ValidAfter uint64
- ValidBefore uint64
- Permissions
- Reserved []byte
- SignatureKey PublicKey
- Signature *Signature
-}
-
-// genericCertData holds the key-independent part of the certificate data.
-// Overall, certificates contain an nonce, public key fields and
-// key-independent fields.
-type genericCertData struct {
- Serial uint64
- CertType uint32
- KeyId string
- ValidPrincipals []byte
- ValidAfter uint64
- ValidBefore uint64
- CriticalOptions []byte
- Extensions []byte
- Reserved []byte
- SignatureKey []byte
- Signature []byte
-}
-
-func marshalStringList(namelist []string) []byte {
- var to []byte
- for _, name := range namelist {
- s := struct{ N string }{name}
- to = append(to, Marshal(&s)...)
- }
- return to
-}
-
-type optionsTuple struct {
- Key string
- Value []byte
-}
-
-type optionsTupleValue struct {
- Value string
-}
-
-// serialize a map of critical options or extensions
-// issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
-// we need two length prefixes for a non-empty string value
-func marshalTuples(tups map[string]string) []byte {
- keys := make([]string, 0, len(tups))
- for key := range tups {
- keys = append(keys, key)
- }
- sort.Strings(keys)
-
- var ret []byte
- for _, key := range keys {
- s := optionsTuple{Key: key}
- if value := tups[key]; len(value) > 0 {
- s.Value = Marshal(&optionsTupleValue{value})
- }
- ret = append(ret, Marshal(&s)...)
- }
- return ret
-}
-
-// issue #10569 - per [PROTOCOL.certkeys] and SSH implementation,
-// we need two length prefixes for a non-empty option value
-func parseTuples(in []byte) (map[string]string, error) {
- tups := map[string]string{}
- var lastKey string
- var haveLastKey bool
-
- for len(in) > 0 {
- var key, val, extra []byte
- var ok bool
-
- if key, in, ok = parseString(in); !ok {
- return nil, errShortRead
- }
- keyStr := string(key)
- // according to [PROTOCOL.certkeys], the names must be in
- // lexical order.
- if haveLastKey && keyStr <= lastKey {
- return nil, fmt.Errorf("ssh: certificate options are not in lexical order")
- }
- lastKey, haveLastKey = keyStr, true
- // the next field is a data field, which if non-empty has a string embedded
- if val, in, ok = parseString(in); !ok {
- return nil, errShortRead
- }
- if len(val) > 0 {
- val, extra, ok = parseString(val)
- if !ok {
- return nil, errShortRead
- }
- if len(extra) > 0 {
- return nil, fmt.Errorf("ssh: unexpected trailing data after certificate option value")
- }
- tups[keyStr] = string(val)
- } else {
- tups[keyStr] = ""
- }
- }
- return tups, nil
-}
-
-func parseCert(in []byte, privAlgo string) (*Certificate, error) {
- nonce, rest, ok := parseString(in)
- if !ok {
- return nil, errShortRead
- }
-
- key, rest, err := parsePubKey(rest, privAlgo)
- if err != nil {
- return nil, err
- }
-
- var g genericCertData
- if err := Unmarshal(rest, &g); err != nil {
- return nil, err
- }
-
- c := &Certificate{
- Nonce: nonce,
- Key: key,
- Serial: g.Serial,
- CertType: g.CertType,
- KeyId: g.KeyId,
- ValidAfter: g.ValidAfter,
- ValidBefore: g.ValidBefore,
- }
-
- for principals := g.ValidPrincipals; len(principals) > 0; {
- principal, rest, ok := parseString(principals)
- if !ok {
- return nil, errShortRead
- }
- c.ValidPrincipals = append(c.ValidPrincipals, string(principal))
- principals = rest
- }
-
- c.CriticalOptions, err = parseTuples(g.CriticalOptions)
- if err != nil {
- return nil, err
- }
- c.Extensions, err = parseTuples(g.Extensions)
- if err != nil {
- return nil, err
- }
- c.Reserved = g.Reserved
- k, err := ParsePublicKey(g.SignatureKey)
- if err != nil {
- return nil, err
- }
-
- c.SignatureKey = k
- c.Signature, rest, ok = parseSignatureBody(g.Signature)
- if !ok || len(rest) > 0 {
- return nil, errors.New("ssh: signature parse error")
- }
-
- return c, nil
-}
-
-type openSSHCertSigner struct {
- pub *Certificate
- signer Signer
-}
-
-// NewCertSigner returns a Signer that signs with the given Certificate, whose
-// private key is held by signer. It returns an error if the public key in cert
-// doesn't match the key used by signer.
-func NewCertSigner(cert *Certificate, signer Signer) (Signer, error) {
- if bytes.Compare(cert.Key.Marshal(), signer.PublicKey().Marshal()) != 0 {
- return nil, errors.New("ssh: signer and cert have different public key")
- }
-
- return &openSSHCertSigner{cert, signer}, nil
-}
-
-func (s *openSSHCertSigner) Sign(rand io.Reader, data []byte) (*Signature, error) {
- return s.signer.Sign(rand, data)
-}
-
-func (s *openSSHCertSigner) PublicKey() PublicKey {
- return s.pub
-}
-
-const sourceAddressCriticalOption = "source-address"
-
-// CertChecker does the work of verifying a certificate. Its methods
-// can be plugged into ClientConfig.HostKeyCallback and
-// ServerConfig.PublicKeyCallback. For the CertChecker to work,
-// minimally, the IsAuthority callback should be set.
-type CertChecker struct {
- // SupportedCriticalOptions lists the CriticalOptions that the
- // server application layer understands. These are only used
- // for user certificates.
- SupportedCriticalOptions []string
-
- // IsAuthority should return true if the key is recognized as
- // an authority. This allows for certificates to be signed by other
- // certificates.
- IsAuthority func(auth PublicKey) bool
-
- // Clock is used for verifying time stamps. If nil, time.Now
- // is used.
- Clock func() time.Time
-
- // UserKeyFallback is called when CertChecker.Authenticate encounters a
- // public key that is not a certificate. It must implement validation
- // of user keys or else, if nil, all such keys are rejected.
- UserKeyFallback func(conn ConnMetadata, key PublicKey) (*Permissions, error)
-
- // HostKeyFallback is called when CertChecker.CheckHostKey encounters a
- // public key that is not a certificate. It must implement host key
- // validation or else, if nil, all such keys are rejected.
- HostKeyFallback func(addr string, remote net.Addr, key PublicKey) error
-
- // IsRevoked is called for each certificate so that revocation checking
- // can be implemented. It should return true if the given certificate
- // is revoked and false otherwise. If nil, no certificates are
- // considered to have been revoked.
- IsRevoked func(cert *Certificate) bool
-}
-
-// CheckHostKey checks a host key certificate. This method can be
-// plugged into ClientConfig.HostKeyCallback.
-func (c *CertChecker) CheckHostKey(addr string, remote net.Addr, key PublicKey) error {
- cert, ok := key.(*Certificate)
- if !ok {
- if c.HostKeyFallback != nil {
- return c.HostKeyFallback(addr, remote, key)
- }
- return errors.New("ssh: non-certificate host key")
- }
- if cert.CertType != HostCert {
- return fmt.Errorf("ssh: certificate presented as a host key has type %d", cert.CertType)
- }
-
- return c.CheckCert(addr, cert)
-}
-
-// Authenticate checks a user certificate. Authenticate can be used as
-// a value for ServerConfig.PublicKeyCallback.
-func (c *CertChecker) Authenticate(conn ConnMetadata, pubKey PublicKey) (*Permissions, error) {
- cert, ok := pubKey.(*Certificate)
- if !ok {
- if c.UserKeyFallback != nil {
- return c.UserKeyFallback(conn, pubKey)
- }
- return nil, errors.New("ssh: normal key pairs not accepted")
- }
-
- if cert.CertType != UserCert {
- return nil, fmt.Errorf("ssh: cert has type %d", cert.CertType)
- }
-
- if err := c.CheckCert(conn.User(), cert); err != nil {
- return nil, err
- }
-
- return &cert.Permissions, nil
-}
-
-// CheckCert checks CriticalOptions, ValidPrincipals, revocation, timestamp and
-// the signature of the certificate.
-func (c *CertChecker) CheckCert(principal string, cert *Certificate) error {
- if c.IsRevoked != nil && c.IsRevoked(cert) {
- return fmt.Errorf("ssh: certicate serial %d revoked", cert.Serial)
- }
-
- for opt, _ := range cert.CriticalOptions {
- // sourceAddressCriticalOption will be enforced by
- // serverAuthenticate
- if opt == sourceAddressCriticalOption {
- continue
- }
-
- found := false
- for _, supp := range c.SupportedCriticalOptions {
- if supp == opt {
- found = true
- break
- }
- }
- if !found {
- return fmt.Errorf("ssh: unsupported critical option %q in certificate", opt)
- }
- }
-
- if len(cert.ValidPrincipals) > 0 {
- // By default, certs are valid for all users/hosts.
- found := false
- for _, p := range cert.ValidPrincipals {
- if p == principal {
- found = true
- break
- }
- }
- if !found {
- return fmt.Errorf("ssh: principal %q not in the set of valid principals for given certificate: %q", principal, cert.ValidPrincipals)
- }
- }
-
- if !c.IsAuthority(cert.SignatureKey) {
- return fmt.Errorf("ssh: certificate signed by unrecognized authority")
- }
-
- clock := c.Clock
- if clock == nil {
- clock = time.Now
- }
-
- unixNow := clock().Unix()
- if after := int64(cert.ValidAfter); after < 0 || unixNow < int64(cert.ValidAfter) {
- return fmt.Errorf("ssh: cert is not yet valid")
- }
- if before := int64(cert.ValidBefore); cert.ValidBefore != uint64(CertTimeInfinity) && (unixNow >= before || before < 0) {
- return fmt.Errorf("ssh: cert has expired")
- }
- if err := cert.SignatureKey.Verify(cert.bytesForSigning(), cert.Signature); err != nil {
- return fmt.Errorf("ssh: certificate signature does not verify")
- }
-
- return nil
-}
-
-// SignCert sets c.SignatureKey to the authority's public key and stores a
-// Signature, by authority, in the certificate.
-func (c *Certificate) SignCert(rand io.Reader, authority Signer) error {
- c.Nonce = make([]byte, 32)
- if _, err := io.ReadFull(rand, c.Nonce); err != nil {
- return err
- }
- c.SignatureKey = authority.PublicKey()
-
- sig, err := authority.Sign(rand, c.bytesForSigning())
- if err != nil {
- return err
- }
- c.Signature = sig
- return nil
-}
-
-var certAlgoNames = map[string]string{
- KeyAlgoRSA: CertAlgoRSAv01,
- KeyAlgoDSA: CertAlgoDSAv01,
- KeyAlgoECDSA256: CertAlgoECDSA256v01,
- KeyAlgoECDSA384: CertAlgoECDSA384v01,
- KeyAlgoECDSA521: CertAlgoECDSA521v01,
- KeyAlgoED25519: CertAlgoED25519v01,
-}
-
-// certToPrivAlgo returns the underlying algorithm for a certificate algorithm.
-// Panics if a non-certificate algorithm is passed.
-func certToPrivAlgo(algo string) string {
- for privAlgo, pubAlgo := range certAlgoNames {
- if pubAlgo == algo {
- return privAlgo
- }
- }
- panic("unknown cert algorithm")
-}
-
-func (cert *Certificate) bytesForSigning() []byte {
- c2 := *cert
- c2.Signature = nil
- out := c2.Marshal()
- // Drop trailing signature length.
- return out[:len(out)-4]
-}
-
-// Marshal serializes c into OpenSSH's wire format. It is part of the
-// PublicKey interface.
-func (c *Certificate) Marshal() []byte {
- generic := genericCertData{
- Serial: c.Serial,
- CertType: c.CertType,
- KeyId: c.KeyId,
- ValidPrincipals: marshalStringList(c.ValidPrincipals),
- ValidAfter: uint64(c.ValidAfter),
- ValidBefore: uint64(c.ValidBefore),
- CriticalOptions: marshalTuples(c.CriticalOptions),
- Extensions: marshalTuples(c.Extensions),
- Reserved: c.Reserved,
- SignatureKey: c.SignatureKey.Marshal(),
- }
- if c.Signature != nil {
- generic.Signature = Marshal(c.Signature)
- }
- genericBytes := Marshal(&generic)
- keyBytes := c.Key.Marshal()
- _, keyBytes, _ = parseString(keyBytes)
- prefix := Marshal(&struct {
- Name string
- Nonce []byte
- Key []byte `ssh:"rest"`
- }{c.Type(), c.Nonce, keyBytes})
-
- result := make([]byte, 0, len(prefix)+len(genericBytes))
- result = append(result, prefix...)
- result = append(result, genericBytes...)
- return result
-}
-
-// Type returns the key name. It is part of the PublicKey interface.
-func (c *Certificate) Type() string {
- algo, ok := certAlgoNames[c.Key.Type()]
- if !ok {
- panic("unknown cert key type " + c.Key.Type())
- }
- return algo
-}
-
-// Verify verifies a signature against the certificate's public
-// key. It is part of the PublicKey interface.
-func (c *Certificate) Verify(data []byte, sig *Signature) error {
- return c.Key.Verify(data, sig)
-}
-
-func parseSignatureBody(in []byte) (out *Signature, rest []byte, ok bool) {
- format, in, ok := parseString(in)
- if !ok {
- return
- }
-
- out = &Signature{
- Format: string(format),
- }
-
- if out.Blob, in, ok = parseString(in); !ok {
- return
- }
-
- return out, in, ok
-}
-
-func parseSignature(in []byte) (out *Signature, rest []byte, ok bool) {
- sigBytes, rest, ok := parseString(in)
- if !ok {
- return
- }
-
- out, trailing, ok := parseSignatureBody(sigBytes)
- if !ok || len(trailing) > 0 {
- return nil, nil, false
- }
- return
-}
diff --git a/vendor/golang.org/x/crypto/ssh/channel.go b/vendor/golang.org/x/crypto/ssh/channel.go
deleted file mode 100644
index 195530ea0da2fc9b602f8a17c7b514cb98263166..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/channel.go
+++ /dev/null
@@ -1,633 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "log"
- "sync"
-)
-
-const (
- minPacketLength = 9
- // channelMaxPacket contains the maximum number of bytes that will be
- // sent in a single packet. As per RFC 4253, section 6.1, 32k is also
- // the minimum.
- channelMaxPacket = 1 << 15
- // We follow OpenSSH here.
- channelWindowSize = 64 * channelMaxPacket
-)
-
-// NewChannel represents an incoming request to a channel. It must either be
-// accepted for use by calling Accept, or rejected by calling Reject.
-type NewChannel interface {
- // Accept accepts the channel creation request. It returns the Channel
- // and a Go channel containing SSH requests. The Go channel must be
- // serviced otherwise the Channel will hang.
- Accept() (Channel, <-chan *Request, error)
-
- // Reject rejects the channel creation request. After calling
- // this, no other methods on the Channel may be called.
- Reject(reason RejectionReason, message string) error
-
- // ChannelType returns the type of the channel, as supplied by the
- // client.
- ChannelType() string
-
- // ExtraData returns the arbitrary payload for this channel, as supplied
- // by the client. This data is specific to the channel type.
- ExtraData() []byte
-}
-
-// A Channel is an ordered, reliable, flow-controlled, duplex stream
-// that is multiplexed over an SSH connection.
-type Channel interface {
- // Read reads up to len(data) bytes from the channel.
- Read(data []byte) (int, error)
-
- // Write writes len(data) bytes to the channel.
- Write(data []byte) (int, error)
-
- // Close signals end of channel use. No data may be sent after this
- // call.
- Close() error
-
- // CloseWrite signals the end of sending in-band
- // data. Requests may still be sent, and the other side may
- // still send data
- CloseWrite() error
-
- // SendRequest sends a channel request. If wantReply is true,
- // it will wait for a reply and return the result as a
- // boolean, otherwise the return value will be false. Channel
- // requests are out-of-band messages so they may be sent even
- // if the data stream is closed or blocked by flow control.
- // If the channel is closed before a reply is returned, io.EOF
- // is returned.
- SendRequest(name string, wantReply bool, payload []byte) (bool, error)
-
- // Stderr returns an io.ReadWriter that writes to this channel
- // with the extended data type set to stderr. Stderr may
- // safely be read and written from a different goroutine than
- // Read and Write respectively.
- Stderr() io.ReadWriter
-}
-
-// Request is a request sent outside of the normal stream of
-// data. Requests can either be specific to an SSH channel, or they
-// can be global.
-type Request struct {
- Type string
- WantReply bool
- Payload []byte
-
- ch *channel
- mux *mux
-}
-
-// Reply sends a response to a request. It must be called for all requests
-// where WantReply is true and is a no-op otherwise. The payload argument is
-// ignored for replies to channel-specific requests.
-func (r *Request) Reply(ok bool, payload []byte) error {
- if !r.WantReply {
- return nil
- }
-
- if r.ch == nil {
- return r.mux.ackRequest(ok, payload)
- }
-
- return r.ch.ackRequest(ok)
-}
-
-// RejectionReason is an enumeration used when rejecting channel creation
-// requests. See RFC 4254, section 5.1.
-type RejectionReason uint32
-
-const (
- Prohibited RejectionReason = iota + 1
- ConnectionFailed
- UnknownChannelType
- ResourceShortage
-)
-
-// String converts the rejection reason to human readable form.
-func (r RejectionReason) String() string {
- switch r {
- case Prohibited:
- return "administratively prohibited"
- case ConnectionFailed:
- return "connect failed"
- case UnknownChannelType:
- return "unknown channel type"
- case ResourceShortage:
- return "resource shortage"
- }
- return fmt.Sprintf("unknown reason %d", int(r))
-}
-
-func min(a uint32, b int) uint32 {
- if a < uint32(b) {
- return a
- }
- return uint32(b)
-}
-
-type channelDirection uint8
-
-const (
- channelInbound channelDirection = iota
- channelOutbound
-)
-
-// channel is an implementation of the Channel interface that works
-// with the mux class.
-type channel struct {
- // R/O after creation
- chanType string
- extraData []byte
- localId, remoteId uint32
-
- // maxIncomingPayload and maxRemotePayload are the maximum
- // payload sizes of normal and extended data packets for
- // receiving and sending, respectively. The wire packet will
- // be 9 or 13 bytes larger (excluding encryption overhead).
- maxIncomingPayload uint32
- maxRemotePayload uint32
-
- mux *mux
-
- // decided is set to true if an accept or reject message has been sent
- // (for outbound channels) or received (for inbound channels).
- decided bool
-
- // direction contains either channelOutbound, for channels created
- // locally, or channelInbound, for channels created by the peer.
- direction channelDirection
-
- // Pending internal channel messages.
- msg chan interface{}
-
- // Since requests have no ID, there can be only one request
- // with WantReply=true outstanding. This lock is held by a
- // goroutine that has such an outgoing request pending.
- sentRequestMu sync.Mutex
-
- incomingRequests chan *Request
-
- sentEOF bool
-
- // thread-safe data
- remoteWin window
- pending *buffer
- extPending *buffer
-
- // windowMu protects myWindow, the flow-control window.
- windowMu sync.Mutex
- myWindow uint32
-
- // writeMu serializes calls to mux.conn.writePacket() and
- // protects sentClose and packetPool. This mutex must be
- // different from windowMu, as writePacket can block if there
- // is a key exchange pending.
- writeMu sync.Mutex
- sentClose bool
-
- // packetPool has a buffer for each extended channel ID to
- // save allocations during writes.
- packetPool map[uint32][]byte
-}
-
-// writePacket sends a packet. If the packet is a channel close, it updates
-// sentClose. This method takes the lock c.writeMu.
-func (c *channel) writePacket(packet []byte) error {
- c.writeMu.Lock()
- if c.sentClose {
- c.writeMu.Unlock()
- return io.EOF
- }
- c.sentClose = (packet[0] == msgChannelClose)
- err := c.mux.conn.writePacket(packet)
- c.writeMu.Unlock()
- return err
-}
-
-func (c *channel) sendMessage(msg interface{}) error {
- if debugMux {
- log.Printf("send(%d): %#v", c.mux.chanList.offset, msg)
- }
-
- p := Marshal(msg)
- binary.BigEndian.PutUint32(p[1:], c.remoteId)
- return c.writePacket(p)
-}
-
-// WriteExtended writes data to a specific extended stream. These streams are
-// used, for example, for stderr.
-func (c *channel) WriteExtended(data []byte, extendedCode uint32) (n int, err error) {
- if c.sentEOF {
- return 0, io.EOF
- }
- // 1 byte message type, 4 bytes remoteId, 4 bytes data length
- opCode := byte(msgChannelData)
- headerLength := uint32(9)
- if extendedCode > 0 {
- headerLength += 4
- opCode = msgChannelExtendedData
- }
-
- c.writeMu.Lock()
- packet := c.packetPool[extendedCode]
- // We don't remove the buffer from packetPool, so
- // WriteExtended calls from different goroutines will be
- // flagged as errors by the race detector.
- c.writeMu.Unlock()
-
- for len(data) > 0 {
- space := min(c.maxRemotePayload, len(data))
- if space, err = c.remoteWin.reserve(space); err != nil {
- return n, err
- }
- if want := headerLength + space; uint32(cap(packet)) < want {
- packet = make([]byte, want)
- } else {
- packet = packet[:want]
- }
-
- todo := data[:space]
-
- packet[0] = opCode
- binary.BigEndian.PutUint32(packet[1:], c.remoteId)
- if extendedCode > 0 {
- binary.BigEndian.PutUint32(packet[5:], uint32(extendedCode))
- }
- binary.BigEndian.PutUint32(packet[headerLength-4:], uint32(len(todo)))
- copy(packet[headerLength:], todo)
- if err = c.writePacket(packet); err != nil {
- return n, err
- }
-
- n += len(todo)
- data = data[len(todo):]
- }
-
- c.writeMu.Lock()
- c.packetPool[extendedCode] = packet
- c.writeMu.Unlock()
-
- return n, err
-}
-
-func (c *channel) handleData(packet []byte) error {
- headerLen := 9
- isExtendedData := packet[0] == msgChannelExtendedData
- if isExtendedData {
- headerLen = 13
- }
- if len(packet) < headerLen {
- // malformed data packet
- return parseError(packet[0])
- }
-
- var extended uint32
- if isExtendedData {
- extended = binary.BigEndian.Uint32(packet[5:])
- }
-
- length := binary.BigEndian.Uint32(packet[headerLen-4 : headerLen])
- if length == 0 {
- return nil
- }
- if length > c.maxIncomingPayload {
- // TODO(hanwen): should send Disconnect?
- return errors.New("ssh: incoming packet exceeds maximum payload size")
- }
-
- data := packet[headerLen:]
- if length != uint32(len(data)) {
- return errors.New("ssh: wrong packet length")
- }
-
- c.windowMu.Lock()
- if c.myWindow < length {
- c.windowMu.Unlock()
- // TODO(hanwen): should send Disconnect with reason?
- return errors.New("ssh: remote side wrote too much")
- }
- c.myWindow -= length
- c.windowMu.Unlock()
-
- if extended == 1 {
- c.extPending.write(data)
- } else if extended > 0 {
- // discard other extended data.
- } else {
- c.pending.write(data)
- }
- return nil
-}
-
-func (c *channel) adjustWindow(n uint32) error {
- c.windowMu.Lock()
- // Since myWindow is managed on our side, and can never exceed
- // the initial window setting, we don't worry about overflow.
- c.myWindow += uint32(n)
- c.windowMu.Unlock()
- return c.sendMessage(windowAdjustMsg{
- AdditionalBytes: uint32(n),
- })
-}
-
-func (c *channel) ReadExtended(data []byte, extended uint32) (n int, err error) {
- switch extended {
- case 1:
- n, err = c.extPending.Read(data)
- case 0:
- n, err = c.pending.Read(data)
- default:
- return 0, fmt.Errorf("ssh: extended code %d unimplemented", extended)
- }
-
- if n > 0 {
- err = c.adjustWindow(uint32(n))
- // sendWindowAdjust can return io.EOF if the remote
- // peer has closed the connection, however we want to
- // defer forwarding io.EOF to the caller of Read until
- // the buffer has been drained.
- if n > 0 && err == io.EOF {
- err = nil
- }
- }
-
- return n, err
-}
-
-func (c *channel) close() {
- c.pending.eof()
- c.extPending.eof()
- close(c.msg)
- close(c.incomingRequests)
- c.writeMu.Lock()
- // This is not necessary for a normal channel teardown, but if
- // there was another error, it is.
- c.sentClose = true
- c.writeMu.Unlock()
- // Unblock writers.
- c.remoteWin.close()
-}
-
-// responseMessageReceived is called when a success or failure message is
-// received on a channel to check that such a message is reasonable for the
-// given channel.
-func (c *channel) responseMessageReceived() error {
- if c.direction == channelInbound {
- return errors.New("ssh: channel response message received on inbound channel")
- }
- if c.decided {
- return errors.New("ssh: duplicate response received for channel")
- }
- c.decided = true
- return nil
-}
-
-func (c *channel) handlePacket(packet []byte) error {
- switch packet[0] {
- case msgChannelData, msgChannelExtendedData:
- return c.handleData(packet)
- case msgChannelClose:
- c.sendMessage(channelCloseMsg{PeersId: c.remoteId})
- c.mux.chanList.remove(c.localId)
- c.close()
- return nil
- case msgChannelEOF:
- // RFC 4254 is mute on how EOF affects dataExt messages but
- // it is logical to signal EOF at the same time.
- c.extPending.eof()
- c.pending.eof()
- return nil
- }
-
- decoded, err := decode(packet)
- if err != nil {
- return err
- }
-
- switch msg := decoded.(type) {
- case *channelOpenFailureMsg:
- if err := c.responseMessageReceived(); err != nil {
- return err
- }
- c.mux.chanList.remove(msg.PeersId)
- c.msg <- msg
- case *channelOpenConfirmMsg:
- if err := c.responseMessageReceived(); err != nil {
- return err
- }
- if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 {
- return fmt.Errorf("ssh: invalid MaxPacketSize %d from peer", msg.MaxPacketSize)
- }
- c.remoteId = msg.MyId
- c.maxRemotePayload = msg.MaxPacketSize
- c.remoteWin.add(msg.MyWindow)
- c.msg <- msg
- case *windowAdjustMsg:
- if !c.remoteWin.add(msg.AdditionalBytes) {
- return fmt.Errorf("ssh: invalid window update for %d bytes", msg.AdditionalBytes)
- }
- case *channelRequestMsg:
- req := Request{
- Type: msg.Request,
- WantReply: msg.WantReply,
- Payload: msg.RequestSpecificData,
- ch: c,
- }
-
- c.incomingRequests <- &req
- default:
- c.msg <- msg
- }
- return nil
-}
-
-func (m *mux) newChannel(chanType string, direction channelDirection, extraData []byte) *channel {
- ch := &channel{
- remoteWin: window{Cond: newCond()},
- myWindow: channelWindowSize,
- pending: newBuffer(),
- extPending: newBuffer(),
- direction: direction,
- incomingRequests: make(chan *Request, chanSize),
- msg: make(chan interface{}, chanSize),
- chanType: chanType,
- extraData: extraData,
- mux: m,
- packetPool: make(map[uint32][]byte),
- }
- ch.localId = m.chanList.add(ch)
- return ch
-}
-
-var errUndecided = errors.New("ssh: must Accept or Reject channel")
-var errDecidedAlready = errors.New("ssh: can call Accept or Reject only once")
-
-type extChannel struct {
- code uint32
- ch *channel
-}
-
-func (e *extChannel) Write(data []byte) (n int, err error) {
- return e.ch.WriteExtended(data, e.code)
-}
-
-func (e *extChannel) Read(data []byte) (n int, err error) {
- return e.ch.ReadExtended(data, e.code)
-}
-
-func (c *channel) Accept() (Channel, <-chan *Request, error) {
- if c.decided {
- return nil, nil, errDecidedAlready
- }
- c.maxIncomingPayload = channelMaxPacket
- confirm := channelOpenConfirmMsg{
- PeersId: c.remoteId,
- MyId: c.localId,
- MyWindow: c.myWindow,
- MaxPacketSize: c.maxIncomingPayload,
- }
- c.decided = true
- if err := c.sendMessage(confirm); err != nil {
- return nil, nil, err
- }
-
- return c, c.incomingRequests, nil
-}
-
-func (ch *channel) Reject(reason RejectionReason, message string) error {
- if ch.decided {
- return errDecidedAlready
- }
- reject := channelOpenFailureMsg{
- PeersId: ch.remoteId,
- Reason: reason,
- Message: message,
- Language: "en",
- }
- ch.decided = true
- return ch.sendMessage(reject)
-}
-
-func (ch *channel) Read(data []byte) (int, error) {
- if !ch.decided {
- return 0, errUndecided
- }
- return ch.ReadExtended(data, 0)
-}
-
-func (ch *channel) Write(data []byte) (int, error) {
- if !ch.decided {
- return 0, errUndecided
- }
- return ch.WriteExtended(data, 0)
-}
-
-func (ch *channel) CloseWrite() error {
- if !ch.decided {
- return errUndecided
- }
- ch.sentEOF = true
- return ch.sendMessage(channelEOFMsg{
- PeersId: ch.remoteId})
-}
-
-func (ch *channel) Close() error {
- if !ch.decided {
- return errUndecided
- }
-
- return ch.sendMessage(channelCloseMsg{
- PeersId: ch.remoteId})
-}
-
-// Extended returns an io.ReadWriter that sends and receives data on the given,
-// SSH extended stream. Such streams are used, for example, for stderr.
-func (ch *channel) Extended(code uint32) io.ReadWriter {
- if !ch.decided {
- return nil
- }
- return &extChannel{code, ch}
-}
-
-func (ch *channel) Stderr() io.ReadWriter {
- return ch.Extended(1)
-}
-
-func (ch *channel) SendRequest(name string, wantReply bool, payload []byte) (bool, error) {
- if !ch.decided {
- return false, errUndecided
- }
-
- if wantReply {
- ch.sentRequestMu.Lock()
- defer ch.sentRequestMu.Unlock()
- }
-
- msg := channelRequestMsg{
- PeersId: ch.remoteId,
- Request: name,
- WantReply: wantReply,
- RequestSpecificData: payload,
- }
-
- if err := ch.sendMessage(msg); err != nil {
- return false, err
- }
-
- if wantReply {
- m, ok := (<-ch.msg)
- if !ok {
- return false, io.EOF
- }
- switch m.(type) {
- case *channelRequestFailureMsg:
- return false, nil
- case *channelRequestSuccessMsg:
- return true, nil
- default:
- return false, fmt.Errorf("ssh: unexpected response to channel request: %#v", m)
- }
- }
-
- return false, nil
-}
-
-// ackRequest either sends an ack or nack to the channel request.
-func (ch *channel) ackRequest(ok bool) error {
- if !ch.decided {
- return errUndecided
- }
-
- var msg interface{}
- if !ok {
- msg = channelRequestFailureMsg{
- PeersId: ch.remoteId,
- }
- } else {
- msg = channelRequestSuccessMsg{
- PeersId: ch.remoteId,
- }
- }
- return ch.sendMessage(msg)
-}
-
-func (ch *channel) ChannelType() string {
- return ch.chanType
-}
-
-func (ch *channel) ExtraData() []byte {
- return ch.extraData
-}
diff --git a/vendor/golang.org/x/crypto/ssh/cipher.go b/vendor/golang.org/x/crypto/ssh/cipher.go
deleted file mode 100644
index 13484ab4b3901905fa5add775dee8d4674199c1c..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/cipher.go
+++ /dev/null
@@ -1,627 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "crypto/aes"
- "crypto/cipher"
- "crypto/des"
- "crypto/rc4"
- "crypto/subtle"
- "encoding/binary"
- "errors"
- "fmt"
- "hash"
- "io"
- "io/ioutil"
-)
-
-const (
- packetSizeMultiple = 16 // TODO(huin) this should be determined by the cipher.
-
- // RFC 4253 section 6.1 defines a minimum packet size of 32768 that implementations
- // MUST be able to process (plus a few more kilobytes for padding and mac). The RFC
- // indicates implementations SHOULD be able to handle larger packet sizes, but then
- // waffles on about reasonable limits.
- //
- // OpenSSH caps their maxPacket at 256kB so we choose to do
- // the same. maxPacket is also used to ensure that uint32
- // length fields do not overflow, so it should remain well
- // below 4G.
- maxPacket = 256 * 1024
-)
-
-// noneCipher implements cipher.Stream and provides no encryption. It is used
-// by the transport before the first key-exchange.
-type noneCipher struct{}
-
-func (c noneCipher) XORKeyStream(dst, src []byte) {
- copy(dst, src)
-}
-
-func newAESCTR(key, iv []byte) (cipher.Stream, error) {
- c, err := aes.NewCipher(key)
- if err != nil {
- return nil, err
- }
- return cipher.NewCTR(c, iv), nil
-}
-
-func newRC4(key, iv []byte) (cipher.Stream, error) {
- return rc4.NewCipher(key)
-}
-
-type streamCipherMode struct {
- keySize int
- ivSize int
- skip int
- createFunc func(key, iv []byte) (cipher.Stream, error)
-}
-
-func (c *streamCipherMode) createStream(key, iv []byte) (cipher.Stream, error) {
- if len(key) < c.keySize {
- panic("ssh: key length too small for cipher")
- }
- if len(iv) < c.ivSize {
- panic("ssh: iv too small for cipher")
- }
-
- stream, err := c.createFunc(key[:c.keySize], iv[:c.ivSize])
- if err != nil {
- return nil, err
- }
-
- var streamDump []byte
- if c.skip > 0 {
- streamDump = make([]byte, 512)
- }
-
- for remainingToDump := c.skip; remainingToDump > 0; {
- dumpThisTime := remainingToDump
- if dumpThisTime > len(streamDump) {
- dumpThisTime = len(streamDump)
- }
- stream.XORKeyStream(streamDump[:dumpThisTime], streamDump[:dumpThisTime])
- remainingToDump -= dumpThisTime
- }
-
- return stream, nil
-}
-
-// cipherModes documents properties of supported ciphers. Ciphers not included
-// are not supported and will not be negotiated, even if explicitly requested in
-// ClientConfig.Crypto.Ciphers.
-var cipherModes = map[string]*streamCipherMode{
- // Ciphers from RFC4344, which introduced many CTR-based ciphers. Algorithms
- // are defined in the order specified in the RFC.
- "aes128-ctr": {16, aes.BlockSize, 0, newAESCTR},
- "aes192-ctr": {24, aes.BlockSize, 0, newAESCTR},
- "aes256-ctr": {32, aes.BlockSize, 0, newAESCTR},
-
- // Ciphers from RFC4345, which introduces security-improved arcfour ciphers.
- // They are defined in the order specified in the RFC.
- "arcfour128": {16, 0, 1536, newRC4},
- "arcfour256": {32, 0, 1536, newRC4},
-
- // Cipher defined in RFC 4253, which describes SSH Transport Layer Protocol.
- // Note that this cipher is not safe, as stated in RFC 4253: "Arcfour (and
- // RC4) has problems with weak keys, and should be used with caution."
- // RFC4345 introduces improved versions of Arcfour.
- "arcfour": {16, 0, 0, newRC4},
-
- // AES-GCM is not a stream cipher, so it is constructed with a
- // special case. If we add any more non-stream ciphers, we
- // should invest a cleaner way to do this.
- gcmCipherID: {16, 12, 0, nil},
-
- // CBC mode is insecure and so is not included in the default config.
- // (See http://www.isg.rhul.ac.uk/~kp/SandPfinal.pdf). If absolutely
- // needed, it's possible to specify a custom Config to enable it.
- // You should expect that an active attacker can recover plaintext if
- // you do.
- aes128cbcID: {16, aes.BlockSize, 0, nil},
-
- // 3des-cbc is insecure and is disabled by default.
- tripledescbcID: {24, des.BlockSize, 0, nil},
-}
-
-// prefixLen is the length of the packet prefix that contains the packet length
-// and number of padding bytes.
-const prefixLen = 5
-
-// streamPacketCipher is a packetCipher using a stream cipher.
-type streamPacketCipher struct {
- mac hash.Hash
- cipher cipher.Stream
- etm bool
-
- // The following members are to avoid per-packet allocations.
- prefix [prefixLen]byte
- seqNumBytes [4]byte
- padding [2 * packetSizeMultiple]byte
- packetData []byte
- macResult []byte
-}
-
-// readPacket reads and decrypt a single packet from the reader argument.
-func (s *streamPacketCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) {
- if _, err := io.ReadFull(r, s.prefix[:]); err != nil {
- return nil, err
- }
-
- var encryptedPaddingLength [1]byte
- if s.mac != nil && s.etm {
- copy(encryptedPaddingLength[:], s.prefix[4:5])
- s.cipher.XORKeyStream(s.prefix[4:5], s.prefix[4:5])
- } else {
- s.cipher.XORKeyStream(s.prefix[:], s.prefix[:])
- }
-
- length := binary.BigEndian.Uint32(s.prefix[0:4])
- paddingLength := uint32(s.prefix[4])
-
- var macSize uint32
- if s.mac != nil {
- s.mac.Reset()
- binary.BigEndian.PutUint32(s.seqNumBytes[:], seqNum)
- s.mac.Write(s.seqNumBytes[:])
- if s.etm {
- s.mac.Write(s.prefix[:4])
- s.mac.Write(encryptedPaddingLength[:])
- } else {
- s.mac.Write(s.prefix[:])
- }
- macSize = uint32(s.mac.Size())
- }
-
- if length <= paddingLength+1 {
- return nil, errors.New("ssh: invalid packet length, packet too small")
- }
-
- if length > maxPacket {
- return nil, errors.New("ssh: invalid packet length, packet too large")
- }
-
- // the maxPacket check above ensures that length-1+macSize
- // does not overflow.
- if uint32(cap(s.packetData)) < length-1+macSize {
- s.packetData = make([]byte, length-1+macSize)
- } else {
- s.packetData = s.packetData[:length-1+macSize]
- }
-
- if _, err := io.ReadFull(r, s.packetData); err != nil {
- return nil, err
- }
- mac := s.packetData[length-1:]
- data := s.packetData[:length-1]
-
- if s.mac != nil && s.etm {
- s.mac.Write(data)
- }
-
- s.cipher.XORKeyStream(data, data)
-
- if s.mac != nil {
- if !s.etm {
- s.mac.Write(data)
- }
- s.macResult = s.mac.Sum(s.macResult[:0])
- if subtle.ConstantTimeCompare(s.macResult, mac) != 1 {
- return nil, errors.New("ssh: MAC failure")
- }
- }
-
- return s.packetData[:length-paddingLength-1], nil
-}
-
-// writePacket encrypts and sends a packet of data to the writer argument
-func (s *streamPacketCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
- if len(packet) > maxPacket {
- return errors.New("ssh: packet too large")
- }
-
- aadlen := 0
- if s.mac != nil && s.etm {
- // packet length is not encrypted for EtM modes
- aadlen = 4
- }
-
- paddingLength := packetSizeMultiple - (prefixLen+len(packet)-aadlen)%packetSizeMultiple
- if paddingLength < 4 {
- paddingLength += packetSizeMultiple
- }
-
- length := len(packet) + 1 + paddingLength
- binary.BigEndian.PutUint32(s.prefix[:], uint32(length))
- s.prefix[4] = byte(paddingLength)
- padding := s.padding[:paddingLength]
- if _, err := io.ReadFull(rand, padding); err != nil {
- return err
- }
-
- if s.mac != nil {
- s.mac.Reset()
- binary.BigEndian.PutUint32(s.seqNumBytes[:], seqNum)
- s.mac.Write(s.seqNumBytes[:])
-
- if s.etm {
- // For EtM algorithms, the packet length must stay unencrypted,
- // but the following data (padding length) must be encrypted
- s.cipher.XORKeyStream(s.prefix[4:5], s.prefix[4:5])
- }
-
- s.mac.Write(s.prefix[:])
-
- if !s.etm {
- // For non-EtM algorithms, the algorithm is applied on unencrypted data
- s.mac.Write(packet)
- s.mac.Write(padding)
- }
- }
-
- if !(s.mac != nil && s.etm) {
- // For EtM algorithms, the padding length has already been encrypted
- // and the packet length must remain unencrypted
- s.cipher.XORKeyStream(s.prefix[:], s.prefix[:])
- }
-
- s.cipher.XORKeyStream(packet, packet)
- s.cipher.XORKeyStream(padding, padding)
-
- if s.mac != nil && s.etm {
- // For EtM algorithms, packet and padding must be encrypted
- s.mac.Write(packet)
- s.mac.Write(padding)
- }
-
- if _, err := w.Write(s.prefix[:]); err != nil {
- return err
- }
- if _, err := w.Write(packet); err != nil {
- return err
- }
- if _, err := w.Write(padding); err != nil {
- return err
- }
-
- if s.mac != nil {
- s.macResult = s.mac.Sum(s.macResult[:0])
- if _, err := w.Write(s.macResult); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-type gcmCipher struct {
- aead cipher.AEAD
- prefix [4]byte
- iv []byte
- buf []byte
-}
-
-func newGCMCipher(iv, key, macKey []byte) (packetCipher, error) {
- c, err := aes.NewCipher(key)
- if err != nil {
- return nil, err
- }
-
- aead, err := cipher.NewGCM(c)
- if err != nil {
- return nil, err
- }
-
- return &gcmCipher{
- aead: aead,
- iv: iv,
- }, nil
-}
-
-const gcmTagSize = 16
-
-func (c *gcmCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
- // Pad out to multiple of 16 bytes. This is different from the
- // stream cipher because that encrypts the length too.
- padding := byte(packetSizeMultiple - (1+len(packet))%packetSizeMultiple)
- if padding < 4 {
- padding += packetSizeMultiple
- }
-
- length := uint32(len(packet) + int(padding) + 1)
- binary.BigEndian.PutUint32(c.prefix[:], length)
- if _, err := w.Write(c.prefix[:]); err != nil {
- return err
- }
-
- if cap(c.buf) < int(length) {
- c.buf = make([]byte, length)
- } else {
- c.buf = c.buf[:length]
- }
-
- c.buf[0] = padding
- copy(c.buf[1:], packet)
- if _, err := io.ReadFull(rand, c.buf[1+len(packet):]); err != nil {
- return err
- }
- c.buf = c.aead.Seal(c.buf[:0], c.iv, c.buf, c.prefix[:])
- if _, err := w.Write(c.buf); err != nil {
- return err
- }
- c.incIV()
-
- return nil
-}
-
-func (c *gcmCipher) incIV() {
- for i := 4 + 7; i >= 4; i-- {
- c.iv[i]++
- if c.iv[i] != 0 {
- break
- }
- }
-}
-
-func (c *gcmCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) {
- if _, err := io.ReadFull(r, c.prefix[:]); err != nil {
- return nil, err
- }
- length := binary.BigEndian.Uint32(c.prefix[:])
- if length > maxPacket {
- return nil, errors.New("ssh: max packet length exceeded.")
- }
-
- if cap(c.buf) < int(length+gcmTagSize) {
- c.buf = make([]byte, length+gcmTagSize)
- } else {
- c.buf = c.buf[:length+gcmTagSize]
- }
-
- if _, err := io.ReadFull(r, c.buf); err != nil {
- return nil, err
- }
-
- plain, err := c.aead.Open(c.buf[:0], c.iv, c.buf, c.prefix[:])
- if err != nil {
- return nil, err
- }
- c.incIV()
-
- padding := plain[0]
- if padding < 4 || padding >= 20 {
- return nil, fmt.Errorf("ssh: illegal padding %d", padding)
- }
-
- if int(padding+1) >= len(plain) {
- return nil, fmt.Errorf("ssh: padding %d too large", padding)
- }
- plain = plain[1 : length-uint32(padding)]
- return plain, nil
-}
-
-// cbcCipher implements aes128-cbc cipher defined in RFC 4253 section 6.1
-type cbcCipher struct {
- mac hash.Hash
- macSize uint32
- decrypter cipher.BlockMode
- encrypter cipher.BlockMode
-
- // The following members are to avoid per-packet allocations.
- seqNumBytes [4]byte
- packetData []byte
- macResult []byte
-
- // Amount of data we should still read to hide which
- // verification error triggered.
- oracleCamouflage uint32
-}
-
-func newCBCCipher(c cipher.Block, iv, key, macKey []byte, algs directionAlgorithms) (packetCipher, error) {
- cbc := &cbcCipher{
- mac: macModes[algs.MAC].new(macKey),
- decrypter: cipher.NewCBCDecrypter(c, iv),
- encrypter: cipher.NewCBCEncrypter(c, iv),
- packetData: make([]byte, 1024),
- }
- if cbc.mac != nil {
- cbc.macSize = uint32(cbc.mac.Size())
- }
-
- return cbc, nil
-}
-
-func newAESCBCCipher(iv, key, macKey []byte, algs directionAlgorithms) (packetCipher, error) {
- c, err := aes.NewCipher(key)
- if err != nil {
- return nil, err
- }
-
- cbc, err := newCBCCipher(c, iv, key, macKey, algs)
- if err != nil {
- return nil, err
- }
-
- return cbc, nil
-}
-
-func newTripleDESCBCCipher(iv, key, macKey []byte, algs directionAlgorithms) (packetCipher, error) {
- c, err := des.NewTripleDESCipher(key)
- if err != nil {
- return nil, err
- }
-
- cbc, err := newCBCCipher(c, iv, key, macKey, algs)
- if err != nil {
- return nil, err
- }
-
- return cbc, nil
-}
-
-func maxUInt32(a, b int) uint32 {
- if a > b {
- return uint32(a)
- }
- return uint32(b)
-}
-
-const (
- cbcMinPacketSizeMultiple = 8
- cbcMinPacketSize = 16
- cbcMinPaddingSize = 4
-)
-
-// cbcError represents a verification error that may leak information.
-type cbcError string
-
-func (e cbcError) Error() string { return string(e) }
-
-func (c *cbcCipher) readPacket(seqNum uint32, r io.Reader) ([]byte, error) {
- p, err := c.readPacketLeaky(seqNum, r)
- if err != nil {
- if _, ok := err.(cbcError); ok {
- // Verification error: read a fixed amount of
- // data, to make distinguishing between
- // failing MAC and failing length check more
- // difficult.
- io.CopyN(ioutil.Discard, r, int64(c.oracleCamouflage))
- }
- }
- return p, err
-}
-
-func (c *cbcCipher) readPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error) {
- blockSize := c.decrypter.BlockSize()
-
- // Read the header, which will include some of the subsequent data in the
- // case of block ciphers - this is copied back to the payload later.
- // How many bytes of payload/padding will be read with this first read.
- firstBlockLength := uint32((prefixLen + blockSize - 1) / blockSize * blockSize)
- firstBlock := c.packetData[:firstBlockLength]
- if _, err := io.ReadFull(r, firstBlock); err != nil {
- return nil, err
- }
-
- c.oracleCamouflage = maxPacket + 4 + c.macSize - firstBlockLength
-
- c.decrypter.CryptBlocks(firstBlock, firstBlock)
- length := binary.BigEndian.Uint32(firstBlock[:4])
- if length > maxPacket {
- return nil, cbcError("ssh: packet too large")
- }
- if length+4 < maxUInt32(cbcMinPacketSize, blockSize) {
- // The minimum size of a packet is 16 (or the cipher block size, whichever
- // is larger) bytes.
- return nil, cbcError("ssh: packet too small")
- }
- // The length of the packet (including the length field but not the MAC) must
- // be a multiple of the block size or 8, whichever is larger.
- if (length+4)%maxUInt32(cbcMinPacketSizeMultiple, blockSize) != 0 {
- return nil, cbcError("ssh: invalid packet length multiple")
- }
-
- paddingLength := uint32(firstBlock[4])
- if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
- return nil, cbcError("ssh: invalid packet length")
- }
-
- // Positions within the c.packetData buffer:
- macStart := 4 + length
- paddingStart := macStart - paddingLength
-
- // Entire packet size, starting before length, ending at end of mac.
- entirePacketSize := macStart + c.macSize
-
- // Ensure c.packetData is large enough for the entire packet data.
- if uint32(cap(c.packetData)) < entirePacketSize {
- // Still need to upsize and copy, but this should be rare at runtime, only
- // on upsizing the packetData buffer.
- c.packetData = make([]byte, entirePacketSize)
- copy(c.packetData, firstBlock)
- } else {
- c.packetData = c.packetData[:entirePacketSize]
- }
-
- if n, err := io.ReadFull(r, c.packetData[firstBlockLength:]); err != nil {
- return nil, err
- } else {
- c.oracleCamouflage -= uint32(n)
- }
-
- remainingCrypted := c.packetData[firstBlockLength:macStart]
- c.decrypter.CryptBlocks(remainingCrypted, remainingCrypted)
-
- mac := c.packetData[macStart:]
- if c.mac != nil {
- c.mac.Reset()
- binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
- c.mac.Write(c.seqNumBytes[:])
- c.mac.Write(c.packetData[:macStart])
- c.macResult = c.mac.Sum(c.macResult[:0])
- if subtle.ConstantTimeCompare(c.macResult, mac) != 1 {
- return nil, cbcError("ssh: MAC failure")
- }
- }
-
- return c.packetData[prefixLen:paddingStart], nil
-}
-
-func (c *cbcCipher) writePacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
- effectiveBlockSize := maxUInt32(cbcMinPacketSizeMultiple, c.encrypter.BlockSize())
-
- // Length of encrypted portion of the packet (header, payload, padding).
- // Enforce minimum padding and packet size.
- encLength := maxUInt32(prefixLen+len(packet)+cbcMinPaddingSize, cbcMinPaddingSize)
- // Enforce block size.
- encLength = (encLength + effectiveBlockSize - 1) / effectiveBlockSize * effectiveBlockSize
-
- length := encLength - 4
- paddingLength := int(length) - (1 + len(packet))
-
- // Overall buffer contains: header, payload, padding, mac.
- // Space for the MAC is reserved in the capacity but not the slice length.
- bufferSize := encLength + c.macSize
- if uint32(cap(c.packetData)) < bufferSize {
- c.packetData = make([]byte, encLength, bufferSize)
- } else {
- c.packetData = c.packetData[:encLength]
- }
-
- p := c.packetData
-
- // Packet header.
- binary.BigEndian.PutUint32(p, length)
- p = p[4:]
- p[0] = byte(paddingLength)
-
- // Payload.
- p = p[1:]
- copy(p, packet)
-
- // Padding.
- p = p[len(packet):]
- if _, err := io.ReadFull(rand, p); err != nil {
- return err
- }
-
- if c.mac != nil {
- c.mac.Reset()
- binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
- c.mac.Write(c.seqNumBytes[:])
- c.mac.Write(c.packetData)
- // The MAC is now appended into the capacity reserved for it earlier.
- c.packetData = c.mac.Sum(c.packetData)
- }
-
- c.encrypter.CryptBlocks(c.packetData[:encLength], c.packetData[:encLength])
-
- if _, err := w.Write(c.packetData); err != nil {
- return err
- }
-
- return nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/client.go b/vendor/golang.org/x/crypto/ssh/client.go
deleted file mode 100644
index c97f2978e8f6c61a771d0e36ddc5ab8f9daf6758..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/client.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "errors"
- "fmt"
- "net"
- "sync"
- "time"
-)
-
-// Client implements a traditional SSH client that supports shells,
-// subprocesses, port forwarding and tunneled dialing.
-type Client struct {
- Conn
-
- forwards forwardList // forwarded tcpip connections from the remote side
- mu sync.Mutex
- channelHandlers map[string]chan NewChannel
-}
-
-// HandleChannelOpen returns a channel on which NewChannel requests
-// for the given type are sent. If the type already is being handled,
-// nil is returned. The channel is closed when the connection is closed.
-func (c *Client) HandleChannelOpen(channelType string) <-chan NewChannel {
- c.mu.Lock()
- defer c.mu.Unlock()
- if c.channelHandlers == nil {
- // The SSH channel has been closed.
- c := make(chan NewChannel)
- close(c)
- return c
- }
-
- ch := c.channelHandlers[channelType]
- if ch != nil {
- return nil
- }
-
- ch = make(chan NewChannel, chanSize)
- c.channelHandlers[channelType] = ch
- return ch
-}
-
-// NewClient creates a Client on top of the given connection.
-func NewClient(c Conn, chans <-chan NewChannel, reqs <-chan *Request) *Client {
- conn := &Client{
- Conn: c,
- channelHandlers: make(map[string]chan NewChannel, 1),
- }
-
- go conn.handleGlobalRequests(reqs)
- go conn.handleChannelOpens(chans)
- go func() {
- conn.Wait()
- conn.forwards.closeAll()
- }()
- go conn.forwards.handleChannels(conn.HandleChannelOpen("forwarded-tcpip"))
- return conn
-}
-
-// NewClientConn establishes an authenticated SSH connection using c
-// as the underlying transport. The Request and NewChannel channels
-// must be serviced or the connection will hang.
-func NewClientConn(c net.Conn, addr string, config *ClientConfig) (Conn, <-chan NewChannel, <-chan *Request, error) {
- fullConf := *config
- fullConf.SetDefaults()
- conn := &connection{
- sshConn: sshConn{conn: c},
- }
-
- if err := conn.clientHandshake(addr, &fullConf); err != nil {
- c.Close()
- return nil, nil, nil, fmt.Errorf("ssh: handshake failed: %v", err)
- }
- conn.mux = newMux(conn.transport)
- return conn, conn.mux.incomingChannels, conn.mux.incomingRequests, nil
-}
-
-// clientHandshake performs the client side key exchange. See RFC 4253 Section
-// 7.
-func (c *connection) clientHandshake(dialAddress string, config *ClientConfig) error {
- if config.ClientVersion != "" {
- c.clientVersion = []byte(config.ClientVersion)
- } else {
- c.clientVersion = []byte(packageVersion)
- }
- var err error
- c.serverVersion, err = exchangeVersions(c.sshConn.conn, c.clientVersion)
- if err != nil {
- return err
- }
-
- c.transport = newClientTransport(
- newTransport(c.sshConn.conn, config.Rand, true /* is client */),
- c.clientVersion, c.serverVersion, config, dialAddress, c.sshConn.RemoteAddr())
- if err := c.transport.waitSession(); err != nil {
- return err
- }
-
- c.sessionID = c.transport.getSessionID()
- return c.clientAuthenticate(config)
-}
-
-// verifyHostKeySignature verifies the host key obtained in the key
-// exchange.
-func verifyHostKeySignature(hostKey PublicKey, result *kexResult) error {
- sig, rest, ok := parseSignatureBody(result.Signature)
- if len(rest) > 0 || !ok {
- return errors.New("ssh: signature parse error")
- }
-
- return hostKey.Verify(result.H, sig)
-}
-
-// NewSession opens a new Session for this client. (A session is a remote
-// execution of a program.)
-func (c *Client) NewSession() (*Session, error) {
- ch, in, err := c.OpenChannel("session", nil)
- if err != nil {
- return nil, err
- }
- return newSession(ch, in)
-}
-
-func (c *Client) handleGlobalRequests(incoming <-chan *Request) {
- for r := range incoming {
- // This handles keepalive messages and matches
- // the behaviour of OpenSSH.
- r.Reply(false, nil)
- }
-}
-
-// handleChannelOpens channel open messages from the remote side.
-func (c *Client) handleChannelOpens(in <-chan NewChannel) {
- for ch := range in {
- c.mu.Lock()
- handler := c.channelHandlers[ch.ChannelType()]
- c.mu.Unlock()
-
- if handler != nil {
- handler <- ch
- } else {
- ch.Reject(UnknownChannelType, fmt.Sprintf("unknown channel type: %v", ch.ChannelType()))
- }
- }
-
- c.mu.Lock()
- for _, ch := range c.channelHandlers {
- close(ch)
- }
- c.channelHandlers = nil
- c.mu.Unlock()
-}
-
-// Dial starts a client connection to the given SSH server. It is a
-// convenience function that connects to the given network address,
-// initiates the SSH handshake, and then sets up a Client. For access
-// to incoming channels and requests, use net.Dial with NewClientConn
-// instead.
-func Dial(network, addr string, config *ClientConfig) (*Client, error) {
- conn, err := net.DialTimeout(network, addr, config.Timeout)
- if err != nil {
- return nil, err
- }
- c, chans, reqs, err := NewClientConn(conn, addr, config)
- if err != nil {
- return nil, err
- }
- return NewClient(c, chans, reqs), nil
-}
-
-// A ClientConfig structure is used to configure a Client. It must not be
-// modified after having been passed to an SSH function.
-type ClientConfig struct {
- // Config contains configuration that is shared between clients and
- // servers.
- Config
-
- // User contains the username to authenticate as.
- User string
-
- // Auth contains possible authentication methods to use with the
- // server. Only the first instance of a particular RFC 4252 method will
- // be used during authentication.
- Auth []AuthMethod
-
- // HostKeyCallback, if not nil, is called during the cryptographic
- // handshake to validate the server's host key. A nil HostKeyCallback
- // implies that all host keys are accepted.
- HostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error
-
- // ClientVersion contains the version identification string that will
- // be used for the connection. If empty, a reasonable default is used.
- ClientVersion string
-
- // HostKeyAlgorithms lists the key types that the client will
- // accept from the server as host key, in order of
- // preference. If empty, a reasonable default is used. Any
- // string returned from PublicKey.Type method may be used, or
- // any of the CertAlgoXxxx and KeyAlgoXxxx constants.
- HostKeyAlgorithms []string
-
- // Timeout is the maximum amount of time for the TCP connection to establish.
- //
- // A Timeout of zero means no timeout.
- Timeout time.Duration
-}
diff --git a/vendor/golang.org/x/crypto/ssh/client_auth.go b/vendor/golang.org/x/crypto/ssh/client_auth.go
deleted file mode 100644
index fd1ec5dda6e6e06cdb46aee18e750358f1ca80aa..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/client_auth.go
+++ /dev/null
@@ -1,475 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
-)
-
-// clientAuthenticate authenticates with the remote server. See RFC 4252.
-func (c *connection) clientAuthenticate(config *ClientConfig) error {
- // initiate user auth session
- if err := c.transport.writePacket(Marshal(&serviceRequestMsg{serviceUserAuth})); err != nil {
- return err
- }
- packet, err := c.transport.readPacket()
- if err != nil {
- return err
- }
- var serviceAccept serviceAcceptMsg
- if err := Unmarshal(packet, &serviceAccept); err != nil {
- return err
- }
-
- // during the authentication phase the client first attempts the "none" method
- // then any untried methods suggested by the server.
- tried := make(map[string]bool)
- var lastMethods []string
-
- sessionID := c.transport.getSessionID()
- for auth := AuthMethod(new(noneAuth)); auth != nil; {
- ok, methods, err := auth.auth(sessionID, config.User, c.transport, config.Rand)
- if err != nil {
- return err
- }
- if ok {
- // success
- return nil
- }
- tried[auth.method()] = true
- if methods == nil {
- methods = lastMethods
- }
- lastMethods = methods
-
- auth = nil
-
- findNext:
- for _, a := range config.Auth {
- candidateMethod := a.method()
- if tried[candidateMethod] {
- continue
- }
- for _, meth := range methods {
- if meth == candidateMethod {
- auth = a
- break findNext
- }
- }
- }
- }
- return fmt.Errorf("ssh: unable to authenticate, attempted methods %v, no supported methods remain", keys(tried))
-}
-
-func keys(m map[string]bool) []string {
- s := make([]string, 0, len(m))
-
- for key := range m {
- s = append(s, key)
- }
- return s
-}
-
-// An AuthMethod represents an instance of an RFC 4252 authentication method.
-type AuthMethod interface {
- // auth authenticates user over transport t.
- // Returns true if authentication is successful.
- // If authentication is not successful, a []string of alternative
- // method names is returned. If the slice is nil, it will be ignored
- // and the previous set of possible methods will be reused.
- auth(session []byte, user string, p packetConn, rand io.Reader) (bool, []string, error)
-
- // method returns the RFC 4252 method name.
- method() string
-}
-
-// "none" authentication, RFC 4252 section 5.2.
-type noneAuth int
-
-func (n *noneAuth) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) {
- if err := c.writePacket(Marshal(&userAuthRequestMsg{
- User: user,
- Service: serviceSSH,
- Method: "none",
- })); err != nil {
- return false, nil, err
- }
-
- return handleAuthResponse(c)
-}
-
-func (n *noneAuth) method() string {
- return "none"
-}
-
-// passwordCallback is an AuthMethod that fetches the password through
-// a function call, e.g. by prompting the user.
-type passwordCallback func() (password string, err error)
-
-func (cb passwordCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) {
- type passwordAuthMsg struct {
- User string `sshtype:"50"`
- Service string
- Method string
- Reply bool
- Password string
- }
-
- pw, err := cb()
- // REVIEW NOTE: is there a need to support skipping a password attempt?
- // The program may only find out that the user doesn't have a password
- // when prompting.
- if err != nil {
- return false, nil, err
- }
-
- if err := c.writePacket(Marshal(&passwordAuthMsg{
- User: user,
- Service: serviceSSH,
- Method: cb.method(),
- Reply: false,
- Password: pw,
- })); err != nil {
- return false, nil, err
- }
-
- return handleAuthResponse(c)
-}
-
-func (cb passwordCallback) method() string {
- return "password"
-}
-
-// Password returns an AuthMethod using the given password.
-func Password(secret string) AuthMethod {
- return passwordCallback(func() (string, error) { return secret, nil })
-}
-
-// PasswordCallback returns an AuthMethod that uses a callback for
-// fetching a password.
-func PasswordCallback(prompt func() (secret string, err error)) AuthMethod {
- return passwordCallback(prompt)
-}
-
-type publickeyAuthMsg struct {
- User string `sshtype:"50"`
- Service string
- Method string
- // HasSig indicates to the receiver packet that the auth request is signed and
- // should be used for authentication of the request.
- HasSig bool
- Algoname string
- PubKey []byte
- // Sig is tagged with "rest" so Marshal will exclude it during
- // validateKey
- Sig []byte `ssh:"rest"`
-}
-
-// publicKeyCallback is an AuthMethod that uses a set of key
-// pairs for authentication.
-type publicKeyCallback func() ([]Signer, error)
-
-func (cb publicKeyCallback) method() string {
- return "publickey"
-}
-
-func (cb publicKeyCallback) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) {
- // Authentication is performed in two stages. The first stage sends an
- // enquiry to test if each key is acceptable to the remote. The second
- // stage attempts to authenticate with the valid keys obtained in the
- // first stage.
-
- signers, err := cb()
- if err != nil {
- return false, nil, err
- }
- var validKeys []Signer
- for _, signer := range signers {
- if ok, err := validateKey(signer.PublicKey(), user, c); ok {
- validKeys = append(validKeys, signer)
- } else {
- if err != nil {
- return false, nil, err
- }
- }
- }
-
- // methods that may continue if this auth is not successful.
- var methods []string
- for _, signer := range validKeys {
- pub := signer.PublicKey()
-
- pubKey := pub.Marshal()
- sign, err := signer.Sign(rand, buildDataSignedForAuth(session, userAuthRequestMsg{
- User: user,
- Service: serviceSSH,
- Method: cb.method(),
- }, []byte(pub.Type()), pubKey))
- if err != nil {
- return false, nil, err
- }
-
- // manually wrap the serialized signature in a string
- s := Marshal(sign)
- sig := make([]byte, stringLength(len(s)))
- marshalString(sig, s)
- msg := publickeyAuthMsg{
- User: user,
- Service: serviceSSH,
- Method: cb.method(),
- HasSig: true,
- Algoname: pub.Type(),
- PubKey: pubKey,
- Sig: sig,
- }
- p := Marshal(&msg)
- if err := c.writePacket(p); err != nil {
- return false, nil, err
- }
- var success bool
- success, methods, err = handleAuthResponse(c)
- if err != nil {
- return false, nil, err
- }
- if success {
- return success, methods, err
- }
- }
- return false, methods, nil
-}
-
-// validateKey validates the key provided is acceptable to the server.
-func validateKey(key PublicKey, user string, c packetConn) (bool, error) {
- pubKey := key.Marshal()
- msg := publickeyAuthMsg{
- User: user,
- Service: serviceSSH,
- Method: "publickey",
- HasSig: false,
- Algoname: key.Type(),
- PubKey: pubKey,
- }
- if err := c.writePacket(Marshal(&msg)); err != nil {
- return false, err
- }
-
- return confirmKeyAck(key, c)
-}
-
-func confirmKeyAck(key PublicKey, c packetConn) (bool, error) {
- pubKey := key.Marshal()
- algoname := key.Type()
-
- for {
- packet, err := c.readPacket()
- if err != nil {
- return false, err
- }
- switch packet[0] {
- case msgUserAuthBanner:
- // TODO(gpaul): add callback to present the banner to the user
- case msgUserAuthPubKeyOk:
- var msg userAuthPubKeyOkMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return false, err
- }
- if msg.Algo != algoname || !bytes.Equal(msg.PubKey, pubKey) {
- return false, nil
- }
- return true, nil
- case msgUserAuthFailure:
- return false, nil
- default:
- return false, unexpectedMessageError(msgUserAuthSuccess, packet[0])
- }
- }
-}
-
-// PublicKeys returns an AuthMethod that uses the given key
-// pairs.
-func PublicKeys(signers ...Signer) AuthMethod {
- return publicKeyCallback(func() ([]Signer, error) { return signers, nil })
-}
-
-// PublicKeysCallback returns an AuthMethod that runs the given
-// function to obtain a list of key pairs.
-func PublicKeysCallback(getSigners func() (signers []Signer, err error)) AuthMethod {
- return publicKeyCallback(getSigners)
-}
-
-// handleAuthResponse returns whether the preceding authentication request succeeded
-// along with a list of remaining authentication methods to try next and
-// an error if an unexpected response was received.
-func handleAuthResponse(c packetConn) (bool, []string, error) {
- for {
- packet, err := c.readPacket()
- if err != nil {
- return false, nil, err
- }
-
- switch packet[0] {
- case msgUserAuthBanner:
- // TODO: add callback to present the banner to the user
- case msgUserAuthFailure:
- var msg userAuthFailureMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return false, nil, err
- }
- return false, msg.Methods, nil
- case msgUserAuthSuccess:
- return true, nil, nil
- default:
- return false, nil, unexpectedMessageError(msgUserAuthSuccess, packet[0])
- }
- }
-}
-
-// KeyboardInteractiveChallenge should print questions, optionally
-// disabling echoing (e.g. for passwords), and return all the answers.
-// Challenge may be called multiple times in a single session. After
-// successful authentication, the server may send a challenge with no
-// questions, for which the user and instruction messages should be
-// printed. RFC 4256 section 3.3 details how the UI should behave for
-// both CLI and GUI environments.
-type KeyboardInteractiveChallenge func(user, instruction string, questions []string, echos []bool) (answers []string, err error)
-
-// KeyboardInteractive returns a AuthMethod using a prompt/response
-// sequence controlled by the server.
-func KeyboardInteractive(challenge KeyboardInteractiveChallenge) AuthMethod {
- return challenge
-}
-
-func (cb KeyboardInteractiveChallenge) method() string {
- return "keyboard-interactive"
-}
-
-func (cb KeyboardInteractiveChallenge) auth(session []byte, user string, c packetConn, rand io.Reader) (bool, []string, error) {
- type initiateMsg struct {
- User string `sshtype:"50"`
- Service string
- Method string
- Language string
- Submethods string
- }
-
- if err := c.writePacket(Marshal(&initiateMsg{
- User: user,
- Service: serviceSSH,
- Method: "keyboard-interactive",
- })); err != nil {
- return false, nil, err
- }
-
- for {
- packet, err := c.readPacket()
- if err != nil {
- return false, nil, err
- }
-
- // like handleAuthResponse, but with less options.
- switch packet[0] {
- case msgUserAuthBanner:
- // TODO: Print banners during userauth.
- continue
- case msgUserAuthInfoRequest:
- // OK
- case msgUserAuthFailure:
- var msg userAuthFailureMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return false, nil, err
- }
- return false, msg.Methods, nil
- case msgUserAuthSuccess:
- return true, nil, nil
- default:
- return false, nil, unexpectedMessageError(msgUserAuthInfoRequest, packet[0])
- }
-
- var msg userAuthInfoRequestMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return false, nil, err
- }
-
- // Manually unpack the prompt/echo pairs.
- rest := msg.Prompts
- var prompts []string
- var echos []bool
- for i := 0; i < int(msg.NumPrompts); i++ {
- prompt, r, ok := parseString(rest)
- if !ok || len(r) == 0 {
- return false, nil, errors.New("ssh: prompt format error")
- }
- prompts = append(prompts, string(prompt))
- echos = append(echos, r[0] != 0)
- rest = r[1:]
- }
-
- if len(rest) != 0 {
- return false, nil, errors.New("ssh: extra data following keyboard-interactive pairs")
- }
-
- answers, err := cb(msg.User, msg.Instruction, prompts, echos)
- if err != nil {
- return false, nil, err
- }
-
- if len(answers) != len(prompts) {
- return false, nil, errors.New("ssh: not enough answers from keyboard-interactive callback")
- }
- responseLength := 1 + 4
- for _, a := range answers {
- responseLength += stringLength(len(a))
- }
- serialized := make([]byte, responseLength)
- p := serialized
- p[0] = msgUserAuthInfoResponse
- p = p[1:]
- p = marshalUint32(p, uint32(len(answers)))
- for _, a := range answers {
- p = marshalString(p, []byte(a))
- }
-
- if err := c.writePacket(serialized); err != nil {
- return false, nil, err
- }
- }
-}
-
-type retryableAuthMethod struct {
- authMethod AuthMethod
- maxTries int
-}
-
-func (r *retryableAuthMethod) auth(session []byte, user string, c packetConn, rand io.Reader) (ok bool, methods []string, err error) {
- for i := 0; r.maxTries <= 0 || i < r.maxTries; i++ {
- ok, methods, err = r.authMethod.auth(session, user, c, rand)
- if ok || err != nil { // either success or error terminate
- return ok, methods, err
- }
- }
- return ok, methods, err
-}
-
-func (r *retryableAuthMethod) method() string {
- return r.authMethod.method()
-}
-
-// RetryableAuthMethod is a decorator for other auth methods enabling them to
-// be retried up to maxTries before considering that AuthMethod itself failed.
-// If maxTries is <= 0, will retry indefinitely
-//
-// This is useful for interactive clients using challenge/response type
-// authentication (e.g. Keyboard-Interactive, Password, etc) where the user
-// could mistype their response resulting in the server issuing a
-// SSH_MSG_USERAUTH_FAILURE (rfc4252 #8 [password] and rfc4256 #3.4
-// [keyboard-interactive]); Without this decorator, the non-retryable
-// AuthMethod would be removed from future consideration, and never tried again
-// (and so the user would never be able to retry their entry).
-func RetryableAuthMethod(auth AuthMethod, maxTries int) AuthMethod {
- return &retryableAuthMethod{authMethod: auth, maxTries: maxTries}
-}
diff --git a/vendor/golang.org/x/crypto/ssh/common.go b/vendor/golang.org/x/crypto/ssh/common.go
deleted file mode 100644
index 8656d0f85d2cb9c2428a8a2306220ba55f9a6625..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/common.go
+++ /dev/null
@@ -1,371 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "crypto"
- "crypto/rand"
- "fmt"
- "io"
- "sync"
-
- _ "crypto/sha1"
- _ "crypto/sha256"
- _ "crypto/sha512"
-)
-
-// These are string constants in the SSH protocol.
-const (
- compressionNone = "none"
- serviceUserAuth = "ssh-userauth"
- serviceSSH = "ssh-connection"
-)
-
-// supportedCiphers specifies the supported ciphers in preference order.
-var supportedCiphers = []string{
- "aes128-ctr", "aes192-ctr", "aes256-ctr",
- "aes128-gcm@openssh.com",
- "arcfour256", "arcfour128",
-}
-
-// supportedKexAlgos specifies the supported key-exchange algorithms in
-// preference order.
-var supportedKexAlgos = []string{
- kexAlgoCurve25519SHA256,
- // P384 and P521 are not constant-time yet, but since we don't
- // reuse ephemeral keys, using them for ECDH should be OK.
- kexAlgoECDH256, kexAlgoECDH384, kexAlgoECDH521,
- kexAlgoDH14SHA1, kexAlgoDH1SHA1,
-}
-
-// supportedKexAlgos specifies the supported host-key algorithms (i.e. methods
-// of authenticating servers) in preference order.
-var supportedHostKeyAlgos = []string{
- CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01,
- CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoED25519v01,
-
- KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521,
- KeyAlgoRSA, KeyAlgoDSA,
-
- KeyAlgoED25519,
-}
-
-// supportedMACs specifies a default set of MAC algorithms in preference order.
-// This is based on RFC 4253, section 6.4, but with hmac-md5 variants removed
-// because they have reached the end of their useful life.
-var supportedMACs = []string{
- "hmac-sha2-256-etm@openssh.com", "hmac-sha2-256", "hmac-sha1", "hmac-sha1-96",
-}
-
-var supportedCompressions = []string{compressionNone}
-
-// hashFuncs keeps the mapping of supported algorithms to their respective
-// hashes needed for signature verification.
-var hashFuncs = map[string]crypto.Hash{
- KeyAlgoRSA: crypto.SHA1,
- KeyAlgoDSA: crypto.SHA1,
- KeyAlgoECDSA256: crypto.SHA256,
- KeyAlgoECDSA384: crypto.SHA384,
- KeyAlgoECDSA521: crypto.SHA512,
- CertAlgoRSAv01: crypto.SHA1,
- CertAlgoDSAv01: crypto.SHA1,
- CertAlgoECDSA256v01: crypto.SHA256,
- CertAlgoECDSA384v01: crypto.SHA384,
- CertAlgoECDSA521v01: crypto.SHA512,
-}
-
-// unexpectedMessageError results when the SSH message that we received didn't
-// match what we wanted.
-func unexpectedMessageError(expected, got uint8) error {
- return fmt.Errorf("ssh: unexpected message type %d (expected %d)", got, expected)
-}
-
-// parseError results from a malformed SSH message.
-func parseError(tag uint8) error {
- return fmt.Errorf("ssh: parse error in message type %d", tag)
-}
-
-func findCommon(what string, client []string, server []string) (common string, err error) {
- for _, c := range client {
- for _, s := range server {
- if c == s {
- return c, nil
- }
- }
- }
- return "", fmt.Errorf("ssh: no common algorithm for %s; client offered: %v, server offered: %v", what, client, server)
-}
-
-type directionAlgorithms struct {
- Cipher string
- MAC string
- Compression string
-}
-
-// rekeyBytes returns a rekeying intervals in bytes.
-func (a *directionAlgorithms) rekeyBytes() int64 {
- // According to RFC4344 block ciphers should rekey after
- // 2^(BLOCKSIZE/4) blocks. For all AES flavors BLOCKSIZE is
- // 128.
- switch a.Cipher {
- case "aes128-ctr", "aes192-ctr", "aes256-ctr", gcmCipherID, aes128cbcID:
- return 16 * (1 << 32)
-
- }
-
- // For others, stick with RFC4253 recommendation to rekey after 1 Gb of data.
- return 1 << 30
-}
-
-type algorithms struct {
- kex string
- hostKey string
- w directionAlgorithms
- r directionAlgorithms
-}
-
-func findAgreedAlgorithms(clientKexInit, serverKexInit *kexInitMsg) (algs *algorithms, err error) {
- result := &algorithms{}
-
- result.kex, err = findCommon("key exchange", clientKexInit.KexAlgos, serverKexInit.KexAlgos)
- if err != nil {
- return
- }
-
- result.hostKey, err = findCommon("host key", clientKexInit.ServerHostKeyAlgos, serverKexInit.ServerHostKeyAlgos)
- if err != nil {
- return
- }
-
- result.w.Cipher, err = findCommon("client to server cipher", clientKexInit.CiphersClientServer, serverKexInit.CiphersClientServer)
- if err != nil {
- return
- }
-
- result.r.Cipher, err = findCommon("server to client cipher", clientKexInit.CiphersServerClient, serverKexInit.CiphersServerClient)
- if err != nil {
- return
- }
-
- result.w.MAC, err = findCommon("client to server MAC", clientKexInit.MACsClientServer, serverKexInit.MACsClientServer)
- if err != nil {
- return
- }
-
- result.r.MAC, err = findCommon("server to client MAC", clientKexInit.MACsServerClient, serverKexInit.MACsServerClient)
- if err != nil {
- return
- }
-
- result.w.Compression, err = findCommon("client to server compression", clientKexInit.CompressionClientServer, serverKexInit.CompressionClientServer)
- if err != nil {
- return
- }
-
- result.r.Compression, err = findCommon("server to client compression", clientKexInit.CompressionServerClient, serverKexInit.CompressionServerClient)
- if err != nil {
- return
- }
-
- return result, nil
-}
-
-// If rekeythreshold is too small, we can't make any progress sending
-// stuff.
-const minRekeyThreshold uint64 = 256
-
-// Config contains configuration data common to both ServerConfig and
-// ClientConfig.
-type Config struct {
- // Rand provides the source of entropy for cryptographic
- // primitives. If Rand is nil, the cryptographic random reader
- // in package crypto/rand will be used.
- Rand io.Reader
-
- // The maximum number of bytes sent or received after which a
- // new key is negotiated. It must be at least 256. If
- // unspecified, 1 gigabyte is used.
- RekeyThreshold uint64
-
- // The allowed key exchanges algorithms. If unspecified then a
- // default set of algorithms is used.
- KeyExchanges []string
-
- // The allowed cipher algorithms. If unspecified then a sensible
- // default is used.
- Ciphers []string
-
- // The allowed MAC algorithms. If unspecified then a sensible default
- // is used.
- MACs []string
-}
-
-// SetDefaults sets sensible values for unset fields in config. This is
-// exported for testing: Configs passed to SSH functions are copied and have
-// default values set automatically.
-func (c *Config) SetDefaults() {
- if c.Rand == nil {
- c.Rand = rand.Reader
- }
- if c.Ciphers == nil {
- c.Ciphers = supportedCiphers
- }
- var ciphers []string
- for _, c := range c.Ciphers {
- if cipherModes[c] != nil {
- // reject the cipher if we have no cipherModes definition
- ciphers = append(ciphers, c)
- }
- }
- c.Ciphers = ciphers
-
- if c.KeyExchanges == nil {
- c.KeyExchanges = supportedKexAlgos
- }
-
- if c.MACs == nil {
- c.MACs = supportedMACs
- }
-
- if c.RekeyThreshold == 0 {
- // RFC 4253, section 9 suggests rekeying after 1G.
- c.RekeyThreshold = 1 << 30
- }
- if c.RekeyThreshold < minRekeyThreshold {
- c.RekeyThreshold = minRekeyThreshold
- }
-}
-
-// buildDataSignedForAuth returns the data that is signed in order to prove
-// possession of a private key. See RFC 4252, section 7.
-func buildDataSignedForAuth(sessionId []byte, req userAuthRequestMsg, algo, pubKey []byte) []byte {
- data := struct {
- Session []byte
- Type byte
- User string
- Service string
- Method string
- Sign bool
- Algo []byte
- PubKey []byte
- }{
- sessionId,
- msgUserAuthRequest,
- req.User,
- req.Service,
- req.Method,
- true,
- algo,
- pubKey,
- }
- return Marshal(data)
-}
-
-func appendU16(buf []byte, n uint16) []byte {
- return append(buf, byte(n>>8), byte(n))
-}
-
-func appendU32(buf []byte, n uint32) []byte {
- return append(buf, byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
-}
-
-func appendU64(buf []byte, n uint64) []byte {
- return append(buf,
- byte(n>>56), byte(n>>48), byte(n>>40), byte(n>>32),
- byte(n>>24), byte(n>>16), byte(n>>8), byte(n))
-}
-
-func appendInt(buf []byte, n int) []byte {
- return appendU32(buf, uint32(n))
-}
-
-func appendString(buf []byte, s string) []byte {
- buf = appendU32(buf, uint32(len(s)))
- buf = append(buf, s...)
- return buf
-}
-
-func appendBool(buf []byte, b bool) []byte {
- if b {
- return append(buf, 1)
- }
- return append(buf, 0)
-}
-
-// newCond is a helper to hide the fact that there is no usable zero
-// value for sync.Cond.
-func newCond() *sync.Cond { return sync.NewCond(new(sync.Mutex)) }
-
-// window represents the buffer available to clients
-// wishing to write to a channel.
-type window struct {
- *sync.Cond
- win uint32 // RFC 4254 5.2 says the window size can grow to 2^32-1
- writeWaiters int
- closed bool
-}
-
-// add adds win to the amount of window available
-// for consumers.
-func (w *window) add(win uint32) bool {
- // a zero sized window adjust is a noop.
- if win == 0 {
- return true
- }
- w.L.Lock()
- if w.win+win < win {
- w.L.Unlock()
- return false
- }
- w.win += win
- // It is unusual that multiple goroutines would be attempting to reserve
- // window space, but not guaranteed. Use broadcast to notify all waiters
- // that additional window is available.
- w.Broadcast()
- w.L.Unlock()
- return true
-}
-
-// close sets the window to closed, so all reservations fail
-// immediately.
-func (w *window) close() {
- w.L.Lock()
- w.closed = true
- w.Broadcast()
- w.L.Unlock()
-}
-
-// reserve reserves win from the available window capacity.
-// If no capacity remains, reserve will block. reserve may
-// return less than requested.
-func (w *window) reserve(win uint32) (uint32, error) {
- var err error
- w.L.Lock()
- w.writeWaiters++
- w.Broadcast()
- for w.win == 0 && !w.closed {
- w.Wait()
- }
- w.writeWaiters--
- if w.win < win {
- win = w.win
- }
- w.win -= win
- if w.closed {
- err = io.EOF
- }
- w.L.Unlock()
- return win, err
-}
-
-// waitWriterBlocked waits until some goroutine is blocked for further
-// writes. It is used in tests only.
-func (w *window) waitWriterBlocked() {
- w.Cond.L.Lock()
- for w.writeWaiters == 0 {
- w.Cond.Wait()
- }
- w.Cond.L.Unlock()
-}
diff --git a/vendor/golang.org/x/crypto/ssh/connection.go b/vendor/golang.org/x/crypto/ssh/connection.go
deleted file mode 100644
index e786f2f9a20562511a303d451aef07486c143569..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/connection.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "fmt"
- "net"
-)
-
-// OpenChannelError is returned if the other side rejects an
-// OpenChannel request.
-type OpenChannelError struct {
- Reason RejectionReason
- Message string
-}
-
-func (e *OpenChannelError) Error() string {
- return fmt.Sprintf("ssh: rejected: %s (%s)", e.Reason, e.Message)
-}
-
-// ConnMetadata holds metadata for the connection.
-type ConnMetadata interface {
- // User returns the user ID for this connection.
- User() string
-
- // SessionID returns the sesson hash, also denoted by H.
- SessionID() []byte
-
- // ClientVersion returns the client's version string as hashed
- // into the session ID.
- ClientVersion() []byte
-
- // ServerVersion returns the server's version string as hashed
- // into the session ID.
- ServerVersion() []byte
-
- // RemoteAddr returns the remote address for this connection.
- RemoteAddr() net.Addr
-
- // LocalAddr returns the local address for this connection.
- LocalAddr() net.Addr
-}
-
-// Conn represents an SSH connection for both server and client roles.
-// Conn is the basis for implementing an application layer, such
-// as ClientConn, which implements the traditional shell access for
-// clients.
-type Conn interface {
- ConnMetadata
-
- // SendRequest sends a global request, and returns the
- // reply. If wantReply is true, it returns the response status
- // and payload. See also RFC4254, section 4.
- SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error)
-
- // OpenChannel tries to open an channel. If the request is
- // rejected, it returns *OpenChannelError. On success it returns
- // the SSH Channel and a Go channel for incoming, out-of-band
- // requests. The Go channel must be serviced, or the
- // connection will hang.
- OpenChannel(name string, data []byte) (Channel, <-chan *Request, error)
-
- // Close closes the underlying network connection
- Close() error
-
- // Wait blocks until the connection has shut down, and returns the
- // error causing the shutdown.
- Wait() error
-
- // TODO(hanwen): consider exposing:
- // RequestKeyChange
- // Disconnect
-}
-
-// DiscardRequests consumes and rejects all requests from the
-// passed-in channel.
-func DiscardRequests(in <-chan *Request) {
- for req := range in {
- if req.WantReply {
- req.Reply(false, nil)
- }
- }
-}
-
-// A connection represents an incoming connection.
-type connection struct {
- transport *handshakeTransport
- sshConn
-
- // The connection protocol.
- *mux
-}
-
-func (c *connection) Close() error {
- return c.sshConn.conn.Close()
-}
-
-// sshconn provides net.Conn metadata, but disallows direct reads and
-// writes.
-type sshConn struct {
- conn net.Conn
-
- user string
- sessionID []byte
- clientVersion []byte
- serverVersion []byte
-}
-
-func dup(src []byte) []byte {
- dst := make([]byte, len(src))
- copy(dst, src)
- return dst
-}
-
-func (c *sshConn) User() string {
- return c.user
-}
-
-func (c *sshConn) RemoteAddr() net.Addr {
- return c.conn.RemoteAddr()
-}
-
-func (c *sshConn) Close() error {
- return c.conn.Close()
-}
-
-func (c *sshConn) LocalAddr() net.Addr {
- return c.conn.LocalAddr()
-}
-
-func (c *sshConn) SessionID() []byte {
- return dup(c.sessionID)
-}
-
-func (c *sshConn) ClientVersion() []byte {
- return dup(c.clientVersion)
-}
-
-func (c *sshConn) ServerVersion() []byte {
- return dup(c.serverVersion)
-}
diff --git a/vendor/golang.org/x/crypto/ssh/doc.go b/vendor/golang.org/x/crypto/ssh/doc.go
deleted file mode 100644
index d6be8946629210740906a38f1f00fd9bff358122..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/doc.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Package ssh implements an SSH client and server.
-
-SSH is a transport security protocol, an authentication protocol and a
-family of application protocols. The most typical application level
-protocol is a remote shell and this is specifically implemented. However,
-the multiplexed nature of SSH is exposed to users that wish to support
-others.
-
-References:
- [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
- [SSH-PARAMETERS]: http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
-*/
-package ssh // import "golang.org/x/crypto/ssh"
diff --git a/vendor/golang.org/x/crypto/ssh/handshake.go b/vendor/golang.org/x/crypto/ssh/handshake.go
deleted file mode 100644
index 8de650644a5ba818ae13fad5a01d6a62fe093e5d..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/handshake.go
+++ /dev/null
@@ -1,625 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "crypto/rand"
- "errors"
- "fmt"
- "io"
- "log"
- "net"
- "sync"
-)
-
-// debugHandshake, if set, prints messages sent and received. Key
-// exchange messages are printed as if DH were used, so the debug
-// messages are wrong when using ECDH.
-const debugHandshake = false
-
-// chanSize sets the amount of buffering SSH connections. This is
-// primarily for testing: setting chanSize=0 uncovers deadlocks more
-// quickly.
-const chanSize = 16
-
-// keyingTransport is a packet based transport that supports key
-// changes. It need not be thread-safe. It should pass through
-// msgNewKeys in both directions.
-type keyingTransport interface {
- packetConn
-
- // prepareKeyChange sets up a key change. The key change for a
- // direction will be effected if a msgNewKeys message is sent
- // or received.
- prepareKeyChange(*algorithms, *kexResult) error
-}
-
-// handshakeTransport implements rekeying on top of a keyingTransport
-// and offers a thread-safe writePacket() interface.
-type handshakeTransport struct {
- conn keyingTransport
- config *Config
-
- serverVersion []byte
- clientVersion []byte
-
- // hostKeys is non-empty if we are the server. In that case,
- // it contains all host keys that can be used to sign the
- // connection.
- hostKeys []Signer
-
- // hostKeyAlgorithms is non-empty if we are the client. In that case,
- // we accept these key types from the server as host key.
- hostKeyAlgorithms []string
-
- // On read error, incoming is closed, and readError is set.
- incoming chan []byte
- readError error
-
- mu sync.Mutex
- writeError error
- sentInitPacket []byte
- sentInitMsg *kexInitMsg
- pendingPackets [][]byte // Used when a key exchange is in progress.
-
- // If the read loop wants to schedule a kex, it pings this
- // channel, and the write loop will send out a kex
- // message.
- requestKex chan struct{}
-
- // If the other side requests or confirms a kex, its kexInit
- // packet is sent here for the write loop to find it.
- startKex chan *pendingKex
-
- // data for host key checking
- hostKeyCallback func(hostname string, remote net.Addr, key PublicKey) error
- dialAddress string
- remoteAddr net.Addr
-
- // Algorithms agreed in the last key exchange.
- algorithms *algorithms
-
- readPacketsLeft uint32
- readBytesLeft int64
-
- writePacketsLeft uint32
- writeBytesLeft int64
-
- // The session ID or nil if first kex did not complete yet.
- sessionID []byte
-}
-
-type pendingKex struct {
- otherInit []byte
- done chan error
-}
-
-func newHandshakeTransport(conn keyingTransport, config *Config, clientVersion, serverVersion []byte) *handshakeTransport {
- t := &handshakeTransport{
- conn: conn,
- serverVersion: serverVersion,
- clientVersion: clientVersion,
- incoming: make(chan []byte, chanSize),
- requestKex: make(chan struct{}, 1),
- startKex: make(chan *pendingKex, 1),
-
- config: config,
- }
-
- // We always start with a mandatory key exchange.
- t.requestKex <- struct{}{}
- return t
-}
-
-func newClientTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ClientConfig, dialAddr string, addr net.Addr) *handshakeTransport {
- t := newHandshakeTransport(conn, &config.Config, clientVersion, serverVersion)
- t.dialAddress = dialAddr
- t.remoteAddr = addr
- t.hostKeyCallback = config.HostKeyCallback
- if config.HostKeyAlgorithms != nil {
- t.hostKeyAlgorithms = config.HostKeyAlgorithms
- } else {
- t.hostKeyAlgorithms = supportedHostKeyAlgos
- }
- go t.readLoop()
- go t.kexLoop()
- return t
-}
-
-func newServerTransport(conn keyingTransport, clientVersion, serverVersion []byte, config *ServerConfig) *handshakeTransport {
- t := newHandshakeTransport(conn, &config.Config, clientVersion, serverVersion)
- t.hostKeys = config.hostKeys
- go t.readLoop()
- go t.kexLoop()
- return t
-}
-
-func (t *handshakeTransport) getSessionID() []byte {
- return t.sessionID
-}
-
-// waitSession waits for the session to be established. This should be
-// the first thing to call after instantiating handshakeTransport.
-func (t *handshakeTransport) waitSession() error {
- p, err := t.readPacket()
- if err != nil {
- return err
- }
- if p[0] != msgNewKeys {
- return fmt.Errorf("ssh: first packet should be msgNewKeys")
- }
-
- return nil
-}
-
-func (t *handshakeTransport) id() string {
- if len(t.hostKeys) > 0 {
- return "server"
- }
- return "client"
-}
-
-func (t *handshakeTransport) printPacket(p []byte, write bool) {
- action := "got"
- if write {
- action = "sent"
- }
-
- if p[0] == msgChannelData || p[0] == msgChannelExtendedData {
- log.Printf("%s %s data (packet %d bytes)", t.id(), action, len(p))
- } else {
- msg, err := decode(p)
- log.Printf("%s %s %T %v (%v)", t.id(), action, msg, msg, err)
- }
-}
-
-func (t *handshakeTransport) readPacket() ([]byte, error) {
- p, ok := <-t.incoming
- if !ok {
- return nil, t.readError
- }
- return p, nil
-}
-
-func (t *handshakeTransport) readLoop() {
- first := true
- for {
- p, err := t.readOnePacket(first)
- first = false
- if err != nil {
- t.readError = err
- close(t.incoming)
- break
- }
- if p[0] == msgIgnore || p[0] == msgDebug {
- continue
- }
- t.incoming <- p
- }
-
- // Stop writers too.
- t.recordWriteError(t.readError)
-
- // Unblock the writer should it wait for this.
- close(t.startKex)
-
- // Don't close t.requestKex; it's also written to from writePacket.
-}
-
-func (t *handshakeTransport) pushPacket(p []byte) error {
- if debugHandshake {
- t.printPacket(p, true)
- }
- return t.conn.writePacket(p)
-}
-
-func (t *handshakeTransport) getWriteError() error {
- t.mu.Lock()
- defer t.mu.Unlock()
- return t.writeError
-}
-
-func (t *handshakeTransport) recordWriteError(err error) {
- t.mu.Lock()
- defer t.mu.Unlock()
- if t.writeError == nil && err != nil {
- t.writeError = err
- }
-}
-
-func (t *handshakeTransport) requestKeyExchange() {
- select {
- case t.requestKex <- struct{}{}:
- default:
- // something already requested a kex, so do nothing.
- }
-}
-
-func (t *handshakeTransport) kexLoop() {
-
-write:
- for t.getWriteError() == nil {
- var request *pendingKex
- var sent bool
-
- for request == nil || !sent {
- var ok bool
- select {
- case request, ok = <-t.startKex:
- if !ok {
- break write
- }
- case <-t.requestKex:
- break
- }
-
- if !sent {
- if err := t.sendKexInit(); err != nil {
- t.recordWriteError(err)
- break
- }
- sent = true
- }
- }
-
- if err := t.getWriteError(); err != nil {
- if request != nil {
- request.done <- err
- }
- break
- }
-
- // We're not servicing t.requestKex, but that is OK:
- // we never block on sending to t.requestKex.
-
- // We're not servicing t.startKex, but the remote end
- // has just sent us a kexInitMsg, so it can't send
- // another key change request, until we close the done
- // channel on the pendingKex request.
-
- err := t.enterKeyExchange(request.otherInit)
-
- t.mu.Lock()
- t.writeError = err
- t.sentInitPacket = nil
- t.sentInitMsg = nil
- t.writePacketsLeft = packetRekeyThreshold
- if t.config.RekeyThreshold > 0 {
- t.writeBytesLeft = int64(t.config.RekeyThreshold)
- } else if t.algorithms != nil {
- t.writeBytesLeft = t.algorithms.w.rekeyBytes()
- }
-
- // we have completed the key exchange. Since the
- // reader is still blocked, it is safe to clear out
- // the requestKex channel. This avoids the situation
- // where: 1) we consumed our own request for the
- // initial kex, and 2) the kex from the remote side
- // caused another send on the requestKex channel,
- clear:
- for {
- select {
- case <-t.requestKex:
- //
- default:
- break clear
- }
- }
-
- request.done <- t.writeError
-
- // kex finished. Push packets that we received while
- // the kex was in progress. Don't look at t.startKex
- // and don't increment writtenSinceKex: if we trigger
- // another kex while we are still busy with the last
- // one, things will become very confusing.
- for _, p := range t.pendingPackets {
- t.writeError = t.pushPacket(p)
- if t.writeError != nil {
- break
- }
- }
- t.pendingPackets = t.pendingPackets[:0]
- t.mu.Unlock()
- }
-
- // drain startKex channel. We don't service t.requestKex
- // because nobody does blocking sends there.
- go func() {
- for init := range t.startKex {
- init.done <- t.writeError
- }
- }()
-
- // Unblock reader.
- t.conn.Close()
-}
-
-// The protocol uses uint32 for packet counters, so we can't let them
-// reach 1<<32. We will actually read and write more packets than
-// this, though: the other side may send more packets, and after we
-// hit this limit on writing we will send a few more packets for the
-// key exchange itself.
-const packetRekeyThreshold = (1 << 31)
-
-func (t *handshakeTransport) readOnePacket(first bool) ([]byte, error) {
- p, err := t.conn.readPacket()
- if err != nil {
- return nil, err
- }
-
- if t.readPacketsLeft > 0 {
- t.readPacketsLeft--
- } else {
- t.requestKeyExchange()
- }
-
- if t.readBytesLeft > 0 {
- t.readBytesLeft -= int64(len(p))
- } else {
- t.requestKeyExchange()
- }
-
- if debugHandshake {
- t.printPacket(p, false)
- }
-
- if first && p[0] != msgKexInit {
- return nil, fmt.Errorf("ssh: first packet should be msgKexInit")
- }
-
- if p[0] != msgKexInit {
- return p, nil
- }
-
- firstKex := t.sessionID == nil
-
- kex := pendingKex{
- done: make(chan error, 1),
- otherInit: p,
- }
- t.startKex <- &kex
- err = <-kex.done
-
- if debugHandshake {
- log.Printf("%s exited key exchange (first %v), err %v", t.id(), firstKex, err)
- }
-
- if err != nil {
- return nil, err
- }
-
- t.readPacketsLeft = packetRekeyThreshold
- if t.config.RekeyThreshold > 0 {
- t.readBytesLeft = int64(t.config.RekeyThreshold)
- } else {
- t.readBytesLeft = t.algorithms.r.rekeyBytes()
- }
-
- // By default, a key exchange is hidden from higher layers by
- // translating it into msgIgnore.
- successPacket := []byte{msgIgnore}
- if firstKex {
- // sendKexInit() for the first kex waits for
- // msgNewKeys so the authentication process is
- // guaranteed to happen over an encrypted transport.
- successPacket = []byte{msgNewKeys}
- }
-
- return successPacket, nil
-}
-
-// sendKexInit sends a key change message.
-func (t *handshakeTransport) sendKexInit() error {
- t.mu.Lock()
- defer t.mu.Unlock()
- if t.sentInitMsg != nil {
- // kexInits may be sent either in response to the other side,
- // or because our side wants to initiate a key change, so we
- // may have already sent a kexInit. In that case, don't send a
- // second kexInit.
- return nil
- }
-
- msg := &kexInitMsg{
- KexAlgos: t.config.KeyExchanges,
- CiphersClientServer: t.config.Ciphers,
- CiphersServerClient: t.config.Ciphers,
- MACsClientServer: t.config.MACs,
- MACsServerClient: t.config.MACs,
- CompressionClientServer: supportedCompressions,
- CompressionServerClient: supportedCompressions,
- }
- io.ReadFull(rand.Reader, msg.Cookie[:])
-
- if len(t.hostKeys) > 0 {
- for _, k := range t.hostKeys {
- msg.ServerHostKeyAlgos = append(
- msg.ServerHostKeyAlgos, k.PublicKey().Type())
- }
- } else {
- msg.ServerHostKeyAlgos = t.hostKeyAlgorithms
- }
- packet := Marshal(msg)
-
- // writePacket destroys the contents, so save a copy.
- packetCopy := make([]byte, len(packet))
- copy(packetCopy, packet)
-
- if err := t.pushPacket(packetCopy); err != nil {
- return err
- }
-
- t.sentInitMsg = msg
- t.sentInitPacket = packet
-
- return nil
-}
-
-func (t *handshakeTransport) writePacket(p []byte) error {
- switch p[0] {
- case msgKexInit:
- return errors.New("ssh: only handshakeTransport can send kexInit")
- case msgNewKeys:
- return errors.New("ssh: only handshakeTransport can send newKeys")
- }
-
- t.mu.Lock()
- defer t.mu.Unlock()
- if t.writeError != nil {
- return t.writeError
- }
-
- if t.sentInitMsg != nil {
- // Copy the packet so the writer can reuse the buffer.
- cp := make([]byte, len(p))
- copy(cp, p)
- t.pendingPackets = append(t.pendingPackets, cp)
- return nil
- }
-
- if t.writeBytesLeft > 0 {
- t.writeBytesLeft -= int64(len(p))
- } else {
- t.requestKeyExchange()
- }
-
- if t.writePacketsLeft > 0 {
- t.writePacketsLeft--
- } else {
- t.requestKeyExchange()
- }
-
- if err := t.pushPacket(p); err != nil {
- t.writeError = err
- }
-
- return nil
-}
-
-func (t *handshakeTransport) Close() error {
- return t.conn.Close()
-}
-
-func (t *handshakeTransport) enterKeyExchange(otherInitPacket []byte) error {
- if debugHandshake {
- log.Printf("%s entered key exchange", t.id())
- }
-
- otherInit := &kexInitMsg{}
- if err := Unmarshal(otherInitPacket, otherInit); err != nil {
- return err
- }
-
- magics := handshakeMagics{
- clientVersion: t.clientVersion,
- serverVersion: t.serverVersion,
- clientKexInit: otherInitPacket,
- serverKexInit: t.sentInitPacket,
- }
-
- clientInit := otherInit
- serverInit := t.sentInitMsg
- if len(t.hostKeys) == 0 {
- clientInit, serverInit = serverInit, clientInit
-
- magics.clientKexInit = t.sentInitPacket
- magics.serverKexInit = otherInitPacket
- }
-
- var err error
- t.algorithms, err = findAgreedAlgorithms(clientInit, serverInit)
- if err != nil {
- return err
- }
-
- // We don't send FirstKexFollows, but we handle receiving it.
- //
- // RFC 4253 section 7 defines the kex and the agreement method for
- // first_kex_packet_follows. It states that the guessed packet
- // should be ignored if the "kex algorithm and/or the host
- // key algorithm is guessed wrong (server and client have
- // different preferred algorithm), or if any of the other
- // algorithms cannot be agreed upon". The other algorithms have
- // already been checked above so the kex algorithm and host key
- // algorithm are checked here.
- if otherInit.FirstKexFollows && (clientInit.KexAlgos[0] != serverInit.KexAlgos[0] || clientInit.ServerHostKeyAlgos[0] != serverInit.ServerHostKeyAlgos[0]) {
- // other side sent a kex message for the wrong algorithm,
- // which we have to ignore.
- if _, err := t.conn.readPacket(); err != nil {
- return err
- }
- }
-
- kex, ok := kexAlgoMap[t.algorithms.kex]
- if !ok {
- return fmt.Errorf("ssh: unexpected key exchange algorithm %v", t.algorithms.kex)
- }
-
- var result *kexResult
- if len(t.hostKeys) > 0 {
- result, err = t.server(kex, t.algorithms, &magics)
- } else {
- result, err = t.client(kex, t.algorithms, &magics)
- }
-
- if err != nil {
- return err
- }
-
- if t.sessionID == nil {
- t.sessionID = result.H
- }
- result.SessionID = t.sessionID
-
- t.conn.prepareKeyChange(t.algorithms, result)
- if err = t.conn.writePacket([]byte{msgNewKeys}); err != nil {
- return err
- }
- if packet, err := t.conn.readPacket(); err != nil {
- return err
- } else if packet[0] != msgNewKeys {
- return unexpectedMessageError(msgNewKeys, packet[0])
- }
-
- return nil
-}
-
-func (t *handshakeTransport) server(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error) {
- var hostKey Signer
- for _, k := range t.hostKeys {
- if algs.hostKey == k.PublicKey().Type() {
- hostKey = k
- }
- }
-
- r, err := kex.Server(t.conn, t.config.Rand, magics, hostKey)
- return r, err
-}
-
-func (t *handshakeTransport) client(kex kexAlgorithm, algs *algorithms, magics *handshakeMagics) (*kexResult, error) {
- result, err := kex.Client(t.conn, t.config.Rand, magics)
- if err != nil {
- return nil, err
- }
-
- hostKey, err := ParsePublicKey(result.HostKey)
- if err != nil {
- return nil, err
- }
-
- if err := verifyHostKeySignature(hostKey, result); err != nil {
- return nil, err
- }
-
- if t.hostKeyCallback != nil {
- err = t.hostKeyCallback(t.dialAddress, t.remoteAddr, hostKey)
- if err != nil {
- return nil, err
- }
- }
-
- return result, nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/kex.go b/vendor/golang.org/x/crypto/ssh/kex.go
deleted file mode 100644
index c87fbebfde88a2be08fdd9440241cb1a3c4c145a..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/kex.go
+++ /dev/null
@@ -1,540 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "crypto"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rand"
- "crypto/subtle"
- "errors"
- "io"
- "math/big"
-
- "golang.org/x/crypto/curve25519"
-)
-
-const (
- kexAlgoDH1SHA1 = "diffie-hellman-group1-sha1"
- kexAlgoDH14SHA1 = "diffie-hellman-group14-sha1"
- kexAlgoECDH256 = "ecdh-sha2-nistp256"
- kexAlgoECDH384 = "ecdh-sha2-nistp384"
- kexAlgoECDH521 = "ecdh-sha2-nistp521"
- kexAlgoCurve25519SHA256 = "curve25519-sha256@libssh.org"
-)
-
-// kexResult captures the outcome of a key exchange.
-type kexResult struct {
- // Session hash. See also RFC 4253, section 8.
- H []byte
-
- // Shared secret. See also RFC 4253, section 8.
- K []byte
-
- // Host key as hashed into H.
- HostKey []byte
-
- // Signature of H.
- Signature []byte
-
- // A cryptographic hash function that matches the security
- // level of the key exchange algorithm. It is used for
- // calculating H, and for deriving keys from H and K.
- Hash crypto.Hash
-
- // The session ID, which is the first H computed. This is used
- // to derive key material inside the transport.
- SessionID []byte
-}
-
-// handshakeMagics contains data that is always included in the
-// session hash.
-type handshakeMagics struct {
- clientVersion, serverVersion []byte
- clientKexInit, serverKexInit []byte
-}
-
-func (m *handshakeMagics) write(w io.Writer) {
- writeString(w, m.clientVersion)
- writeString(w, m.serverVersion)
- writeString(w, m.clientKexInit)
- writeString(w, m.serverKexInit)
-}
-
-// kexAlgorithm abstracts different key exchange algorithms.
-type kexAlgorithm interface {
- // Server runs server-side key agreement, signing the result
- // with a hostkey.
- Server(p packetConn, rand io.Reader, magics *handshakeMagics, s Signer) (*kexResult, error)
-
- // Client runs the client-side key agreement. Caller is
- // responsible for verifying the host key signature.
- Client(p packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error)
-}
-
-// dhGroup is a multiplicative group suitable for implementing Diffie-Hellman key agreement.
-type dhGroup struct {
- g, p, pMinus1 *big.Int
-}
-
-func (group *dhGroup) diffieHellman(theirPublic, myPrivate *big.Int) (*big.Int, error) {
- if theirPublic.Cmp(bigOne) <= 0 || theirPublic.Cmp(group.pMinus1) >= 0 {
- return nil, errors.New("ssh: DH parameter out of bounds")
- }
- return new(big.Int).Exp(theirPublic, myPrivate, group.p), nil
-}
-
-func (group *dhGroup) Client(c packetConn, randSource io.Reader, magics *handshakeMagics) (*kexResult, error) {
- hashFunc := crypto.SHA1
-
- var x *big.Int
- for {
- var err error
- if x, err = rand.Int(randSource, group.pMinus1); err != nil {
- return nil, err
- }
- if x.Sign() > 0 {
- break
- }
- }
-
- X := new(big.Int).Exp(group.g, x, group.p)
- kexDHInit := kexDHInitMsg{
- X: X,
- }
- if err := c.writePacket(Marshal(&kexDHInit)); err != nil {
- return nil, err
- }
-
- packet, err := c.readPacket()
- if err != nil {
- return nil, err
- }
-
- var kexDHReply kexDHReplyMsg
- if err = Unmarshal(packet, &kexDHReply); err != nil {
- return nil, err
- }
-
- kInt, err := group.diffieHellman(kexDHReply.Y, x)
- if err != nil {
- return nil, err
- }
-
- h := hashFunc.New()
- magics.write(h)
- writeString(h, kexDHReply.HostKey)
- writeInt(h, X)
- writeInt(h, kexDHReply.Y)
- K := make([]byte, intLength(kInt))
- marshalInt(K, kInt)
- h.Write(K)
-
- return &kexResult{
- H: h.Sum(nil),
- K: K,
- HostKey: kexDHReply.HostKey,
- Signature: kexDHReply.Signature,
- Hash: crypto.SHA1,
- }, nil
-}
-
-func (group *dhGroup) Server(c packetConn, randSource io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
- hashFunc := crypto.SHA1
- packet, err := c.readPacket()
- if err != nil {
- return
- }
- var kexDHInit kexDHInitMsg
- if err = Unmarshal(packet, &kexDHInit); err != nil {
- return
- }
-
- var y *big.Int
- for {
- if y, err = rand.Int(randSource, group.pMinus1); err != nil {
- return
- }
- if y.Sign() > 0 {
- break
- }
- }
-
- Y := new(big.Int).Exp(group.g, y, group.p)
- kInt, err := group.diffieHellman(kexDHInit.X, y)
- if err != nil {
- return nil, err
- }
-
- hostKeyBytes := priv.PublicKey().Marshal()
-
- h := hashFunc.New()
- magics.write(h)
- writeString(h, hostKeyBytes)
- writeInt(h, kexDHInit.X)
- writeInt(h, Y)
-
- K := make([]byte, intLength(kInt))
- marshalInt(K, kInt)
- h.Write(K)
-
- H := h.Sum(nil)
-
- // H is already a hash, but the hostkey signing will apply its
- // own key-specific hash algorithm.
- sig, err := signAndMarshal(priv, randSource, H)
- if err != nil {
- return nil, err
- }
-
- kexDHReply := kexDHReplyMsg{
- HostKey: hostKeyBytes,
- Y: Y,
- Signature: sig,
- }
- packet = Marshal(&kexDHReply)
-
- err = c.writePacket(packet)
- return &kexResult{
- H: H,
- K: K,
- HostKey: hostKeyBytes,
- Signature: sig,
- Hash: crypto.SHA1,
- }, nil
-}
-
-// ecdh performs Elliptic Curve Diffie-Hellman key exchange as
-// described in RFC 5656, section 4.
-type ecdh struct {
- curve elliptic.Curve
-}
-
-func (kex *ecdh) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) {
- ephKey, err := ecdsa.GenerateKey(kex.curve, rand)
- if err != nil {
- return nil, err
- }
-
- kexInit := kexECDHInitMsg{
- ClientPubKey: elliptic.Marshal(kex.curve, ephKey.PublicKey.X, ephKey.PublicKey.Y),
- }
-
- serialized := Marshal(&kexInit)
- if err := c.writePacket(serialized); err != nil {
- return nil, err
- }
-
- packet, err := c.readPacket()
- if err != nil {
- return nil, err
- }
-
- var reply kexECDHReplyMsg
- if err = Unmarshal(packet, &reply); err != nil {
- return nil, err
- }
-
- x, y, err := unmarshalECKey(kex.curve, reply.EphemeralPubKey)
- if err != nil {
- return nil, err
- }
-
- // generate shared secret
- secret, _ := kex.curve.ScalarMult(x, y, ephKey.D.Bytes())
-
- h := ecHash(kex.curve).New()
- magics.write(h)
- writeString(h, reply.HostKey)
- writeString(h, kexInit.ClientPubKey)
- writeString(h, reply.EphemeralPubKey)
- K := make([]byte, intLength(secret))
- marshalInt(K, secret)
- h.Write(K)
-
- return &kexResult{
- H: h.Sum(nil),
- K: K,
- HostKey: reply.HostKey,
- Signature: reply.Signature,
- Hash: ecHash(kex.curve),
- }, nil
-}
-
-// unmarshalECKey parses and checks an EC key.
-func unmarshalECKey(curve elliptic.Curve, pubkey []byte) (x, y *big.Int, err error) {
- x, y = elliptic.Unmarshal(curve, pubkey)
- if x == nil {
- return nil, nil, errors.New("ssh: elliptic.Unmarshal failure")
- }
- if !validateECPublicKey(curve, x, y) {
- return nil, nil, errors.New("ssh: public key not on curve")
- }
- return x, y, nil
-}
-
-// validateECPublicKey checks that the point is a valid public key for
-// the given curve. See [SEC1], 3.2.2
-func validateECPublicKey(curve elliptic.Curve, x, y *big.Int) bool {
- if x.Sign() == 0 && y.Sign() == 0 {
- return false
- }
-
- if x.Cmp(curve.Params().P) >= 0 {
- return false
- }
-
- if y.Cmp(curve.Params().P) >= 0 {
- return false
- }
-
- if !curve.IsOnCurve(x, y) {
- return false
- }
-
- // We don't check if N * PubKey == 0, since
- //
- // - the NIST curves have cofactor = 1, so this is implicit.
- // (We don't foresee an implementation that supports non NIST
- // curves)
- //
- // - for ephemeral keys, we don't need to worry about small
- // subgroup attacks.
- return true
-}
-
-func (kex *ecdh) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
- packet, err := c.readPacket()
- if err != nil {
- return nil, err
- }
-
- var kexECDHInit kexECDHInitMsg
- if err = Unmarshal(packet, &kexECDHInit); err != nil {
- return nil, err
- }
-
- clientX, clientY, err := unmarshalECKey(kex.curve, kexECDHInit.ClientPubKey)
- if err != nil {
- return nil, err
- }
-
- // We could cache this key across multiple users/multiple
- // connection attempts, but the benefit is small. OpenSSH
- // generates a new key for each incoming connection.
- ephKey, err := ecdsa.GenerateKey(kex.curve, rand)
- if err != nil {
- return nil, err
- }
-
- hostKeyBytes := priv.PublicKey().Marshal()
-
- serializedEphKey := elliptic.Marshal(kex.curve, ephKey.PublicKey.X, ephKey.PublicKey.Y)
-
- // generate shared secret
- secret, _ := kex.curve.ScalarMult(clientX, clientY, ephKey.D.Bytes())
-
- h := ecHash(kex.curve).New()
- magics.write(h)
- writeString(h, hostKeyBytes)
- writeString(h, kexECDHInit.ClientPubKey)
- writeString(h, serializedEphKey)
-
- K := make([]byte, intLength(secret))
- marshalInt(K, secret)
- h.Write(K)
-
- H := h.Sum(nil)
-
- // H is already a hash, but the hostkey signing will apply its
- // own key-specific hash algorithm.
- sig, err := signAndMarshal(priv, rand, H)
- if err != nil {
- return nil, err
- }
-
- reply := kexECDHReplyMsg{
- EphemeralPubKey: serializedEphKey,
- HostKey: hostKeyBytes,
- Signature: sig,
- }
-
- serialized := Marshal(&reply)
- if err := c.writePacket(serialized); err != nil {
- return nil, err
- }
-
- return &kexResult{
- H: H,
- K: K,
- HostKey: reply.HostKey,
- Signature: sig,
- Hash: ecHash(kex.curve),
- }, nil
-}
-
-var kexAlgoMap = map[string]kexAlgorithm{}
-
-func init() {
- // This is the group called diffie-hellman-group1-sha1 in RFC
- // 4253 and Oakley Group 2 in RFC 2409.
- p, _ := new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381FFFFFFFFFFFFFFFF", 16)
- kexAlgoMap[kexAlgoDH1SHA1] = &dhGroup{
- g: new(big.Int).SetInt64(2),
- p: p,
- pMinus1: new(big.Int).Sub(p, bigOne),
- }
-
- // This is the group called diffie-hellman-group14-sha1 in RFC
- // 4253 and Oakley Group 14 in RFC 3526.
- p, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF", 16)
-
- kexAlgoMap[kexAlgoDH14SHA1] = &dhGroup{
- g: new(big.Int).SetInt64(2),
- p: p,
- pMinus1: new(big.Int).Sub(p, bigOne),
- }
-
- kexAlgoMap[kexAlgoECDH521] = &ecdh{elliptic.P521()}
- kexAlgoMap[kexAlgoECDH384] = &ecdh{elliptic.P384()}
- kexAlgoMap[kexAlgoECDH256] = &ecdh{elliptic.P256()}
- kexAlgoMap[kexAlgoCurve25519SHA256] = &curve25519sha256{}
-}
-
-// curve25519sha256 implements the curve25519-sha256@libssh.org key
-// agreement protocol, as described in
-// https://git.libssh.org/projects/libssh.git/tree/doc/curve25519-sha256@libssh.org.txt
-type curve25519sha256 struct{}
-
-type curve25519KeyPair struct {
- priv [32]byte
- pub [32]byte
-}
-
-func (kp *curve25519KeyPair) generate(rand io.Reader) error {
- if _, err := io.ReadFull(rand, kp.priv[:]); err != nil {
- return err
- }
- curve25519.ScalarBaseMult(&kp.pub, &kp.priv)
- return nil
-}
-
-// curve25519Zeros is just an array of 32 zero bytes so that we have something
-// convenient to compare against in order to reject curve25519 points with the
-// wrong order.
-var curve25519Zeros [32]byte
-
-func (kex *curve25519sha256) Client(c packetConn, rand io.Reader, magics *handshakeMagics) (*kexResult, error) {
- var kp curve25519KeyPair
- if err := kp.generate(rand); err != nil {
- return nil, err
- }
- if err := c.writePacket(Marshal(&kexECDHInitMsg{kp.pub[:]})); err != nil {
- return nil, err
- }
-
- packet, err := c.readPacket()
- if err != nil {
- return nil, err
- }
-
- var reply kexECDHReplyMsg
- if err = Unmarshal(packet, &reply); err != nil {
- return nil, err
- }
- if len(reply.EphemeralPubKey) != 32 {
- return nil, errors.New("ssh: peer's curve25519 public value has wrong length")
- }
-
- var servPub, secret [32]byte
- copy(servPub[:], reply.EphemeralPubKey)
- curve25519.ScalarMult(&secret, &kp.priv, &servPub)
- if subtle.ConstantTimeCompare(secret[:], curve25519Zeros[:]) == 1 {
- return nil, errors.New("ssh: peer's curve25519 public value has wrong order")
- }
-
- h := crypto.SHA256.New()
- magics.write(h)
- writeString(h, reply.HostKey)
- writeString(h, kp.pub[:])
- writeString(h, reply.EphemeralPubKey)
-
- kInt := new(big.Int).SetBytes(secret[:])
- K := make([]byte, intLength(kInt))
- marshalInt(K, kInt)
- h.Write(K)
-
- return &kexResult{
- H: h.Sum(nil),
- K: K,
- HostKey: reply.HostKey,
- Signature: reply.Signature,
- Hash: crypto.SHA256,
- }, nil
-}
-
-func (kex *curve25519sha256) Server(c packetConn, rand io.Reader, magics *handshakeMagics, priv Signer) (result *kexResult, err error) {
- packet, err := c.readPacket()
- if err != nil {
- return
- }
- var kexInit kexECDHInitMsg
- if err = Unmarshal(packet, &kexInit); err != nil {
- return
- }
-
- if len(kexInit.ClientPubKey) != 32 {
- return nil, errors.New("ssh: peer's curve25519 public value has wrong length")
- }
-
- var kp curve25519KeyPair
- if err := kp.generate(rand); err != nil {
- return nil, err
- }
-
- var clientPub, secret [32]byte
- copy(clientPub[:], kexInit.ClientPubKey)
- curve25519.ScalarMult(&secret, &kp.priv, &clientPub)
- if subtle.ConstantTimeCompare(secret[:], curve25519Zeros[:]) == 1 {
- return nil, errors.New("ssh: peer's curve25519 public value has wrong order")
- }
-
- hostKeyBytes := priv.PublicKey().Marshal()
-
- h := crypto.SHA256.New()
- magics.write(h)
- writeString(h, hostKeyBytes)
- writeString(h, kexInit.ClientPubKey)
- writeString(h, kp.pub[:])
-
- kInt := new(big.Int).SetBytes(secret[:])
- K := make([]byte, intLength(kInt))
- marshalInt(K, kInt)
- h.Write(K)
-
- H := h.Sum(nil)
-
- sig, err := signAndMarshal(priv, rand, H)
- if err != nil {
- return nil, err
- }
-
- reply := kexECDHReplyMsg{
- EphemeralPubKey: kp.pub[:],
- HostKey: hostKeyBytes,
- Signature: sig,
- }
- if err := c.writePacket(Marshal(&reply)); err != nil {
- return nil, err
- }
- return &kexResult{
- H: H,
- K: K,
- HostKey: hostKeyBytes,
- Signature: sig,
- Hash: crypto.SHA256,
- }, nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/keys.go b/vendor/golang.org/x/crypto/ssh/keys.go
deleted file mode 100644
index f38de9898ca2c0258085c6fe301e2ee8aea6bf4e..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/keys.go
+++ /dev/null
@@ -1,905 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bytes"
- "crypto"
- "crypto/dsa"
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/md5"
- "crypto/rsa"
- "crypto/sha256"
- "crypto/x509"
- "encoding/asn1"
- "encoding/base64"
- "encoding/hex"
- "encoding/pem"
- "errors"
- "fmt"
- "io"
- "math/big"
- "strings"
-
- "golang.org/x/crypto/ed25519"
-)
-
-// These constants represent the algorithm names for key types supported by this
-// package.
-const (
- KeyAlgoRSA = "ssh-rsa"
- KeyAlgoDSA = "ssh-dss"
- KeyAlgoECDSA256 = "ecdsa-sha2-nistp256"
- KeyAlgoECDSA384 = "ecdsa-sha2-nistp384"
- KeyAlgoECDSA521 = "ecdsa-sha2-nistp521"
- KeyAlgoED25519 = "ssh-ed25519"
-)
-
-// parsePubKey parses a public key of the given algorithm.
-// Use ParsePublicKey for keys with prepended algorithm.
-func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err error) {
- switch algo {
- case KeyAlgoRSA:
- return parseRSA(in)
- case KeyAlgoDSA:
- return parseDSA(in)
- case KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521:
- return parseECDSA(in)
- case KeyAlgoED25519:
- return parseED25519(in)
- case CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoED25519v01:
- cert, err := parseCert(in, certToPrivAlgo(algo))
- if err != nil {
- return nil, nil, err
- }
- return cert, nil, nil
- }
- return nil, nil, fmt.Errorf("ssh: unknown key algorithm: %v", algo)
-}
-
-// parseAuthorizedKey parses a public key in OpenSSH authorized_keys format
-// (see sshd(8) manual page) once the options and key type fields have been
-// removed.
-func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error) {
- in = bytes.TrimSpace(in)
-
- i := bytes.IndexAny(in, " \t")
- if i == -1 {
- i = len(in)
- }
- base64Key := in[:i]
-
- key := make([]byte, base64.StdEncoding.DecodedLen(len(base64Key)))
- n, err := base64.StdEncoding.Decode(key, base64Key)
- if err != nil {
- return nil, "", err
- }
- key = key[:n]
- out, err = ParsePublicKey(key)
- if err != nil {
- return nil, "", err
- }
- comment = string(bytes.TrimSpace(in[i:]))
- return out, comment, nil
-}
-
-// ParseKnownHosts parses an entry in the format of the known_hosts file.
-//
-// The known_hosts format is documented in the sshd(8) manual page. This
-// function will parse a single entry from in. On successful return, marker
-// will contain the optional marker value (i.e. "cert-authority" or "revoked")
-// or else be empty, hosts will contain the hosts that this entry matches,
-// pubKey will contain the public key and comment will contain any trailing
-// comment at the end of the line. See the sshd(8) manual page for the various
-// forms that a host string can take.
-//
-// The unparsed remainder of the input will be returned in rest. This function
-// can be called repeatedly to parse multiple entries.
-//
-// If no entries were found in the input then err will be io.EOF. Otherwise a
-// non-nil err value indicates a parse error.
-func ParseKnownHosts(in []byte) (marker string, hosts []string, pubKey PublicKey, comment string, rest []byte, err error) {
- for len(in) > 0 {
- end := bytes.IndexByte(in, '\n')
- if end != -1 {
- rest = in[end+1:]
- in = in[:end]
- } else {
- rest = nil
- }
-
- end = bytes.IndexByte(in, '\r')
- if end != -1 {
- in = in[:end]
- }
-
- in = bytes.TrimSpace(in)
- if len(in) == 0 || in[0] == '#' {
- in = rest
- continue
- }
-
- i := bytes.IndexAny(in, " \t")
- if i == -1 {
- in = rest
- continue
- }
-
- // Strip out the beginning of the known_host key.
- // This is either an optional marker or a (set of) hostname(s).
- keyFields := bytes.Fields(in)
- if len(keyFields) < 3 || len(keyFields) > 5 {
- return "", nil, nil, "", nil, errors.New("ssh: invalid entry in known_hosts data")
- }
-
- // keyFields[0] is either "@cert-authority", "@revoked" or a comma separated
- // list of hosts
- marker := ""
- if keyFields[0][0] == '@' {
- marker = string(keyFields[0][1:])
- keyFields = keyFields[1:]
- }
-
- hosts := string(keyFields[0])
- // keyFields[1] contains the key type (e.g. “ssh-rsaâ€).
- // However, that information is duplicated inside the
- // base64-encoded key and so is ignored here.
-
- key := bytes.Join(keyFields[2:], []byte(" "))
- if pubKey, comment, err = parseAuthorizedKey(key); err != nil {
- return "", nil, nil, "", nil, err
- }
-
- return marker, strings.Split(hosts, ","), pubKey, comment, rest, nil
- }
-
- return "", nil, nil, "", nil, io.EOF
-}
-
-// ParseAuthorizedKeys parses a public key from an authorized_keys
-// file used in OpenSSH according to the sshd(8) manual page.
-func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []string, rest []byte, err error) {
- for len(in) > 0 {
- end := bytes.IndexByte(in, '\n')
- if end != -1 {
- rest = in[end+1:]
- in = in[:end]
- } else {
- rest = nil
- }
-
- end = bytes.IndexByte(in, '\r')
- if end != -1 {
- in = in[:end]
- }
-
- in = bytes.TrimSpace(in)
- if len(in) == 0 || in[0] == '#' {
- in = rest
- continue
- }
-
- i := bytes.IndexAny(in, " \t")
- if i == -1 {
- in = rest
- continue
- }
-
- if out, comment, err = parseAuthorizedKey(in[i:]); err == nil {
- return out, comment, options, rest, nil
- }
-
- // No key type recognised. Maybe there's an options field at
- // the beginning.
- var b byte
- inQuote := false
- var candidateOptions []string
- optionStart := 0
- for i, b = range in {
- isEnd := !inQuote && (b == ' ' || b == '\t')
- if (b == ',' && !inQuote) || isEnd {
- if i-optionStart > 0 {
- candidateOptions = append(candidateOptions, string(in[optionStart:i]))
- }
- optionStart = i + 1
- }
- if isEnd {
- break
- }
- if b == '"' && (i == 0 || (i > 0 && in[i-1] != '\\')) {
- inQuote = !inQuote
- }
- }
- for i < len(in) && (in[i] == ' ' || in[i] == '\t') {
- i++
- }
- if i == len(in) {
- // Invalid line: unmatched quote
- in = rest
- continue
- }
-
- in = in[i:]
- i = bytes.IndexAny(in, " \t")
- if i == -1 {
- in = rest
- continue
- }
-
- if out, comment, err = parseAuthorizedKey(in[i:]); err == nil {
- options = candidateOptions
- return out, comment, options, rest, nil
- }
-
- in = rest
- continue
- }
-
- return nil, "", nil, nil, errors.New("ssh: no key found")
-}
-
-// ParsePublicKey parses an SSH public key formatted for use in
-// the SSH wire protocol according to RFC 4253, section 6.6.
-func ParsePublicKey(in []byte) (out PublicKey, err error) {
- algo, in, ok := parseString(in)
- if !ok {
- return nil, errShortRead
- }
- var rest []byte
- out, rest, err = parsePubKey(in, string(algo))
- if len(rest) > 0 {
- return nil, errors.New("ssh: trailing junk in public key")
- }
-
- return out, err
-}
-
-// MarshalAuthorizedKey serializes key for inclusion in an OpenSSH
-// authorized_keys file. The return value ends with newline.
-func MarshalAuthorizedKey(key PublicKey) []byte {
- b := &bytes.Buffer{}
- b.WriteString(key.Type())
- b.WriteByte(' ')
- e := base64.NewEncoder(base64.StdEncoding, b)
- e.Write(key.Marshal())
- e.Close()
- b.WriteByte('\n')
- return b.Bytes()
-}
-
-// PublicKey is an abstraction of different types of public keys.
-type PublicKey interface {
- // Type returns the key's type, e.g. "ssh-rsa".
- Type() string
-
- // Marshal returns the serialized key data in SSH wire format,
- // with the name prefix.
- Marshal() []byte
-
- // Verify that sig is a signature on the given data using this
- // key. This function will hash the data appropriately first.
- Verify(data []byte, sig *Signature) error
-}
-
-// CryptoPublicKey, if implemented by a PublicKey,
-// returns the underlying crypto.PublicKey form of the key.
-type CryptoPublicKey interface {
- CryptoPublicKey() crypto.PublicKey
-}
-
-// A Signer can create signatures that verify against a public key.
-type Signer interface {
- // PublicKey returns an associated PublicKey instance.
- PublicKey() PublicKey
-
- // Sign returns raw signature for the given data. This method
- // will apply the hash specified for the keytype to the data.
- Sign(rand io.Reader, data []byte) (*Signature, error)
-}
-
-type rsaPublicKey rsa.PublicKey
-
-func (r *rsaPublicKey) Type() string {
- return "ssh-rsa"
-}
-
-// parseRSA parses an RSA key according to RFC 4253, section 6.6.
-func parseRSA(in []byte) (out PublicKey, rest []byte, err error) {
- var w struct {
- E *big.Int
- N *big.Int
- Rest []byte `ssh:"rest"`
- }
- if err := Unmarshal(in, &w); err != nil {
- return nil, nil, err
- }
-
- if w.E.BitLen() > 24 {
- return nil, nil, errors.New("ssh: exponent too large")
- }
- e := w.E.Int64()
- if e < 3 || e&1 == 0 {
- return nil, nil, errors.New("ssh: incorrect exponent")
- }
-
- var key rsa.PublicKey
- key.E = int(e)
- key.N = w.N
- return (*rsaPublicKey)(&key), w.Rest, nil
-}
-
-func (r *rsaPublicKey) Marshal() []byte {
- e := new(big.Int).SetInt64(int64(r.E))
- // RSA publickey struct layout should match the struct used by
- // parseRSACert in the x/crypto/ssh/agent package.
- wirekey := struct {
- Name string
- E *big.Int
- N *big.Int
- }{
- KeyAlgoRSA,
- e,
- r.N,
- }
- return Marshal(&wirekey)
-}
-
-func (r *rsaPublicKey) Verify(data []byte, sig *Signature) error {
- if sig.Format != r.Type() {
- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, r.Type())
- }
- h := crypto.SHA1.New()
- h.Write(data)
- digest := h.Sum(nil)
- return rsa.VerifyPKCS1v15((*rsa.PublicKey)(r), crypto.SHA1, digest, sig.Blob)
-}
-
-func (r *rsaPublicKey) CryptoPublicKey() crypto.PublicKey {
- return (*rsa.PublicKey)(r)
-}
-
-type dsaPublicKey dsa.PublicKey
-
-func (r *dsaPublicKey) Type() string {
- return "ssh-dss"
-}
-
-// parseDSA parses an DSA key according to RFC 4253, section 6.6.
-func parseDSA(in []byte) (out PublicKey, rest []byte, err error) {
- var w struct {
- P, Q, G, Y *big.Int
- Rest []byte `ssh:"rest"`
- }
- if err := Unmarshal(in, &w); err != nil {
- return nil, nil, err
- }
-
- key := &dsaPublicKey{
- Parameters: dsa.Parameters{
- P: w.P,
- Q: w.Q,
- G: w.G,
- },
- Y: w.Y,
- }
- return key, w.Rest, nil
-}
-
-func (k *dsaPublicKey) Marshal() []byte {
- // DSA publickey struct layout should match the struct used by
- // parseDSACert in the x/crypto/ssh/agent package.
- w := struct {
- Name string
- P, Q, G, Y *big.Int
- }{
- k.Type(),
- k.P,
- k.Q,
- k.G,
- k.Y,
- }
-
- return Marshal(&w)
-}
-
-func (k *dsaPublicKey) Verify(data []byte, sig *Signature) error {
- if sig.Format != k.Type() {
- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
- }
- h := crypto.SHA1.New()
- h.Write(data)
- digest := h.Sum(nil)
-
- // Per RFC 4253, section 6.6,
- // The value for 'dss_signature_blob' is encoded as a string containing
- // r, followed by s (which are 160-bit integers, without lengths or
- // padding, unsigned, and in network byte order).
- // For DSS purposes, sig.Blob should be exactly 40 bytes in length.
- if len(sig.Blob) != 40 {
- return errors.New("ssh: DSA signature parse error")
- }
- r := new(big.Int).SetBytes(sig.Blob[:20])
- s := new(big.Int).SetBytes(sig.Blob[20:])
- if dsa.Verify((*dsa.PublicKey)(k), digest, r, s) {
- return nil
- }
- return errors.New("ssh: signature did not verify")
-}
-
-func (k *dsaPublicKey) CryptoPublicKey() crypto.PublicKey {
- return (*dsa.PublicKey)(k)
-}
-
-type dsaPrivateKey struct {
- *dsa.PrivateKey
-}
-
-func (k *dsaPrivateKey) PublicKey() PublicKey {
- return (*dsaPublicKey)(&k.PrivateKey.PublicKey)
-}
-
-func (k *dsaPrivateKey) Sign(rand io.Reader, data []byte) (*Signature, error) {
- h := crypto.SHA1.New()
- h.Write(data)
- digest := h.Sum(nil)
- r, s, err := dsa.Sign(rand, k.PrivateKey, digest)
- if err != nil {
- return nil, err
- }
-
- sig := make([]byte, 40)
- rb := r.Bytes()
- sb := s.Bytes()
-
- copy(sig[20-len(rb):20], rb)
- copy(sig[40-len(sb):], sb)
-
- return &Signature{
- Format: k.PublicKey().Type(),
- Blob: sig,
- }, nil
-}
-
-type ecdsaPublicKey ecdsa.PublicKey
-
-func (key *ecdsaPublicKey) Type() string {
- return "ecdsa-sha2-" + key.nistID()
-}
-
-func (key *ecdsaPublicKey) nistID() string {
- switch key.Params().BitSize {
- case 256:
- return "nistp256"
- case 384:
- return "nistp384"
- case 521:
- return "nistp521"
- }
- panic("ssh: unsupported ecdsa key size")
-}
-
-type ed25519PublicKey ed25519.PublicKey
-
-func (key ed25519PublicKey) Type() string {
- return KeyAlgoED25519
-}
-
-func parseED25519(in []byte) (out PublicKey, rest []byte, err error) {
- var w struct {
- KeyBytes []byte
- Rest []byte `ssh:"rest"`
- }
-
- if err := Unmarshal(in, &w); err != nil {
- return nil, nil, err
- }
-
- key := ed25519.PublicKey(w.KeyBytes)
-
- return (ed25519PublicKey)(key), w.Rest, nil
-}
-
-func (key ed25519PublicKey) Marshal() []byte {
- w := struct {
- Name string
- KeyBytes []byte
- }{
- KeyAlgoED25519,
- []byte(key),
- }
- return Marshal(&w)
-}
-
-func (key ed25519PublicKey) Verify(b []byte, sig *Signature) error {
- if sig.Format != key.Type() {
- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, key.Type())
- }
-
- edKey := (ed25519.PublicKey)(key)
- if ok := ed25519.Verify(edKey, b, sig.Blob); !ok {
- return errors.New("ssh: signature did not verify")
- }
-
- return nil
-}
-
-func (k ed25519PublicKey) CryptoPublicKey() crypto.PublicKey {
- return ed25519.PublicKey(k)
-}
-
-func supportedEllipticCurve(curve elliptic.Curve) bool {
- return curve == elliptic.P256() || curve == elliptic.P384() || curve == elliptic.P521()
-}
-
-// ecHash returns the hash to match the given elliptic curve, see RFC
-// 5656, section 6.2.1
-func ecHash(curve elliptic.Curve) crypto.Hash {
- bitSize := curve.Params().BitSize
- switch {
- case bitSize <= 256:
- return crypto.SHA256
- case bitSize <= 384:
- return crypto.SHA384
- }
- return crypto.SHA512
-}
-
-// parseECDSA parses an ECDSA key according to RFC 5656, section 3.1.
-func parseECDSA(in []byte) (out PublicKey, rest []byte, err error) {
- var w struct {
- Curve string
- KeyBytes []byte
- Rest []byte `ssh:"rest"`
- }
-
- if err := Unmarshal(in, &w); err != nil {
- return nil, nil, err
- }
-
- key := new(ecdsa.PublicKey)
-
- switch w.Curve {
- case "nistp256":
- key.Curve = elliptic.P256()
- case "nistp384":
- key.Curve = elliptic.P384()
- case "nistp521":
- key.Curve = elliptic.P521()
- default:
- return nil, nil, errors.New("ssh: unsupported curve")
- }
-
- key.X, key.Y = elliptic.Unmarshal(key.Curve, w.KeyBytes)
- if key.X == nil || key.Y == nil {
- return nil, nil, errors.New("ssh: invalid curve point")
- }
- return (*ecdsaPublicKey)(key), w.Rest, nil
-}
-
-func (key *ecdsaPublicKey) Marshal() []byte {
- // See RFC 5656, section 3.1.
- keyBytes := elliptic.Marshal(key.Curve, key.X, key.Y)
- // ECDSA publickey struct layout should match the struct used by
- // parseECDSACert in the x/crypto/ssh/agent package.
- w := struct {
- Name string
- ID string
- Key []byte
- }{
- key.Type(),
- key.nistID(),
- keyBytes,
- }
-
- return Marshal(&w)
-}
-
-func (key *ecdsaPublicKey) Verify(data []byte, sig *Signature) error {
- if sig.Format != key.Type() {
- return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, key.Type())
- }
-
- h := ecHash(key.Curve).New()
- h.Write(data)
- digest := h.Sum(nil)
-
- // Per RFC 5656, section 3.1.2,
- // The ecdsa_signature_blob value has the following specific encoding:
- // mpint r
- // mpint s
- var ecSig struct {
- R *big.Int
- S *big.Int
- }
-
- if err := Unmarshal(sig.Blob, &ecSig); err != nil {
- return err
- }
-
- if ecdsa.Verify((*ecdsa.PublicKey)(key), digest, ecSig.R, ecSig.S) {
- return nil
- }
- return errors.New("ssh: signature did not verify")
-}
-
-func (k *ecdsaPublicKey) CryptoPublicKey() crypto.PublicKey {
- return (*ecdsa.PublicKey)(k)
-}
-
-// NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey,
-// *ecdsa.PrivateKey or any other crypto.Signer and returns a corresponding
-// Signer instance. ECDSA keys must use P-256, P-384 or P-521.
-func NewSignerFromKey(key interface{}) (Signer, error) {
- switch key := key.(type) {
- case crypto.Signer:
- return NewSignerFromSigner(key)
- case *dsa.PrivateKey:
- return &dsaPrivateKey{key}, nil
- default:
- return nil, fmt.Errorf("ssh: unsupported key type %T", key)
- }
-}
-
-type wrappedSigner struct {
- signer crypto.Signer
- pubKey PublicKey
-}
-
-// NewSignerFromSigner takes any crypto.Signer implementation and
-// returns a corresponding Signer interface. This can be used, for
-// example, with keys kept in hardware modules.
-func NewSignerFromSigner(signer crypto.Signer) (Signer, error) {
- pubKey, err := NewPublicKey(signer.Public())
- if err != nil {
- return nil, err
- }
-
- return &wrappedSigner{signer, pubKey}, nil
-}
-
-func (s *wrappedSigner) PublicKey() PublicKey {
- return s.pubKey
-}
-
-func (s *wrappedSigner) Sign(rand io.Reader, data []byte) (*Signature, error) {
- var hashFunc crypto.Hash
-
- switch key := s.pubKey.(type) {
- case *rsaPublicKey, *dsaPublicKey:
- hashFunc = crypto.SHA1
- case *ecdsaPublicKey:
- hashFunc = ecHash(key.Curve)
- case ed25519PublicKey:
- default:
- return nil, fmt.Errorf("ssh: unsupported key type %T", key)
- }
-
- var digest []byte
- if hashFunc != 0 {
- h := hashFunc.New()
- h.Write(data)
- digest = h.Sum(nil)
- } else {
- digest = data
- }
-
- signature, err := s.signer.Sign(rand, digest, hashFunc)
- if err != nil {
- return nil, err
- }
-
- // crypto.Signer.Sign is expected to return an ASN.1-encoded signature
- // for ECDSA and DSA, but that's not the encoding expected by SSH, so
- // re-encode.
- switch s.pubKey.(type) {
- case *ecdsaPublicKey, *dsaPublicKey:
- type asn1Signature struct {
- R, S *big.Int
- }
- asn1Sig := new(asn1Signature)
- _, err := asn1.Unmarshal(signature, asn1Sig)
- if err != nil {
- return nil, err
- }
-
- switch s.pubKey.(type) {
- case *ecdsaPublicKey:
- signature = Marshal(asn1Sig)
-
- case *dsaPublicKey:
- signature = make([]byte, 40)
- r := asn1Sig.R.Bytes()
- s := asn1Sig.S.Bytes()
- copy(signature[20-len(r):20], r)
- copy(signature[40-len(s):40], s)
- }
- }
-
- return &Signature{
- Format: s.pubKey.Type(),
- Blob: signature,
- }, nil
-}
-
-// NewPublicKey takes an *rsa.PublicKey, *dsa.PublicKey, *ecdsa.PublicKey,
-// or ed25519.PublicKey returns a corresponding PublicKey instance.
-// ECDSA keys must use P-256, P-384 or P-521.
-func NewPublicKey(key interface{}) (PublicKey, error) {
- switch key := key.(type) {
- case *rsa.PublicKey:
- return (*rsaPublicKey)(key), nil
- case *ecdsa.PublicKey:
- if !supportedEllipticCurve(key.Curve) {
- return nil, errors.New("ssh: only P-256, P-384 and P-521 EC keys are supported.")
- }
- return (*ecdsaPublicKey)(key), nil
- case *dsa.PublicKey:
- return (*dsaPublicKey)(key), nil
- case ed25519.PublicKey:
- return (ed25519PublicKey)(key), nil
- default:
- return nil, fmt.Errorf("ssh: unsupported key type %T", key)
- }
-}
-
-// ParsePrivateKey returns a Signer from a PEM encoded private key. It supports
-// the same keys as ParseRawPrivateKey.
-func ParsePrivateKey(pemBytes []byte) (Signer, error) {
- key, err := ParseRawPrivateKey(pemBytes)
- if err != nil {
- return nil, err
- }
-
- return NewSignerFromKey(key)
-}
-
-// encryptedBlock tells whether a private key is
-// encrypted by examining its Proc-Type header
-// for a mention of ENCRYPTED
-// according to RFC 1421 Section 4.6.1.1.
-func encryptedBlock(block *pem.Block) bool {
- return strings.Contains(block.Headers["Proc-Type"], "ENCRYPTED")
-}
-
-// ParseRawPrivateKey returns a private key from a PEM encoded private key. It
-// supports RSA (PKCS#1), DSA (OpenSSL), and ECDSA private keys.
-func ParseRawPrivateKey(pemBytes []byte) (interface{}, error) {
- block, _ := pem.Decode(pemBytes)
- if block == nil {
- return nil, errors.New("ssh: no key found")
- }
-
- if encryptedBlock(block) {
- return nil, errors.New("ssh: cannot decode encrypted private keys")
- }
-
- switch block.Type {
- case "RSA PRIVATE KEY":
- return x509.ParsePKCS1PrivateKey(block.Bytes)
- case "EC PRIVATE KEY":
- return x509.ParseECPrivateKey(block.Bytes)
- case "DSA PRIVATE KEY":
- return ParseDSAPrivateKey(block.Bytes)
- case "OPENSSH PRIVATE KEY":
- return parseOpenSSHPrivateKey(block.Bytes)
- default:
- return nil, fmt.Errorf("ssh: unsupported key type %q", block.Type)
- }
-}
-
-// ParseDSAPrivateKey returns a DSA private key from its ASN.1 DER encoding, as
-// specified by the OpenSSL DSA man page.
-func ParseDSAPrivateKey(der []byte) (*dsa.PrivateKey, error) {
- var k struct {
- Version int
- P *big.Int
- Q *big.Int
- G *big.Int
- Pub *big.Int
- Priv *big.Int
- }
- rest, err := asn1.Unmarshal(der, &k)
- if err != nil {
- return nil, errors.New("ssh: failed to parse DSA key: " + err.Error())
- }
- if len(rest) > 0 {
- return nil, errors.New("ssh: garbage after DSA key")
- }
-
- return &dsa.PrivateKey{
- PublicKey: dsa.PublicKey{
- Parameters: dsa.Parameters{
- P: k.P,
- Q: k.Q,
- G: k.G,
- },
- Y: k.Pub,
- },
- X: k.Priv,
- }, nil
-}
-
-// Implemented based on the documentation at
-// https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key
-func parseOpenSSHPrivateKey(key []byte) (*ed25519.PrivateKey, error) {
- magic := append([]byte("openssh-key-v1"), 0)
- if !bytes.Equal(magic, key[0:len(magic)]) {
- return nil, errors.New("ssh: invalid openssh private key format")
- }
- remaining := key[len(magic):]
-
- var w struct {
- CipherName string
- KdfName string
- KdfOpts string
- NumKeys uint32
- PubKey []byte
- PrivKeyBlock []byte
- }
-
- if err := Unmarshal(remaining, &w); err != nil {
- return nil, err
- }
-
- pk1 := struct {
- Check1 uint32
- Check2 uint32
- Keytype string
- Pub []byte
- Priv []byte
- Comment string
- Pad []byte `ssh:"rest"`
- }{}
-
- if err := Unmarshal(w.PrivKeyBlock, &pk1); err != nil {
- return nil, err
- }
-
- if pk1.Check1 != pk1.Check2 {
- return nil, errors.New("ssh: checkint mismatch")
- }
-
- // we only handle ed25519 keys currently
- if pk1.Keytype != KeyAlgoED25519 {
- return nil, errors.New("ssh: unhandled key type")
- }
-
- for i, b := range pk1.Pad {
- if int(b) != i+1 {
- return nil, errors.New("ssh: padding not as expected")
- }
- }
-
- if len(pk1.Priv) != ed25519.PrivateKeySize {
- return nil, errors.New("ssh: private key unexpected length")
- }
-
- pk := ed25519.PrivateKey(make([]byte, ed25519.PrivateKeySize))
- copy(pk, pk1.Priv)
- return &pk, nil
-}
-
-// FingerprintLegacyMD5 returns the user presentation of the key's
-// fingerprint as described by RFC 4716 section 4.
-func FingerprintLegacyMD5(pubKey PublicKey) string {
- md5sum := md5.Sum(pubKey.Marshal())
- hexarray := make([]string, len(md5sum))
- for i, c := range md5sum {
- hexarray[i] = hex.EncodeToString([]byte{c})
- }
- return strings.Join(hexarray, ":")
-}
-
-// FingerprintSHA256 returns the user presentation of the key's
-// fingerprint as unpadded base64 encoded sha256 hash.
-// This format was introduced from OpenSSH 6.8.
-// https://www.openssh.com/txt/release-6.8
-// https://tools.ietf.org/html/rfc4648#section-3.2 (unpadded base64 encoding)
-func FingerprintSHA256(pubKey PublicKey) string {
- sha256sum := sha256.Sum256(pubKey.Marshal())
- hash := base64.RawStdEncoding.EncodeToString(sha256sum[:])
- return "SHA256:" + hash
-}
diff --git a/vendor/golang.org/x/crypto/ssh/mac.go b/vendor/golang.org/x/crypto/ssh/mac.go
deleted file mode 100644
index c07a06285e66617febc7bac604e91ba10a967e34..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/mac.go
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-// Message authentication support
-
-import (
- "crypto/hmac"
- "crypto/sha1"
- "crypto/sha256"
- "hash"
-)
-
-type macMode struct {
- keySize int
- etm bool
- new func(key []byte) hash.Hash
-}
-
-// truncatingMAC wraps around a hash.Hash and truncates the output digest to
-// a given size.
-type truncatingMAC struct {
- length int
- hmac hash.Hash
-}
-
-func (t truncatingMAC) Write(data []byte) (int, error) {
- return t.hmac.Write(data)
-}
-
-func (t truncatingMAC) Sum(in []byte) []byte {
- out := t.hmac.Sum(in)
- return out[:len(in)+t.length]
-}
-
-func (t truncatingMAC) Reset() {
- t.hmac.Reset()
-}
-
-func (t truncatingMAC) Size() int {
- return t.length
-}
-
-func (t truncatingMAC) BlockSize() int { return t.hmac.BlockSize() }
-
-var macModes = map[string]*macMode{
- "hmac-sha2-256-etm@openssh.com": {32, true, func(key []byte) hash.Hash {
- return hmac.New(sha256.New, key)
- }},
- "hmac-sha2-256": {32, false, func(key []byte) hash.Hash {
- return hmac.New(sha256.New, key)
- }},
- "hmac-sha1": {20, false, func(key []byte) hash.Hash {
- return hmac.New(sha1.New, key)
- }},
- "hmac-sha1-96": {20, false, func(key []byte) hash.Hash {
- return truncatingMAC{12, hmac.New(sha1.New, key)}
- }},
-}
diff --git a/vendor/golang.org/x/crypto/ssh/messages.go b/vendor/golang.org/x/crypto/ssh/messages.go
deleted file mode 100644
index e6ecd3afa5adc5843de6f7819f540d07e1ca8a67..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/messages.go
+++ /dev/null
@@ -1,758 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bytes"
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "math/big"
- "reflect"
- "strconv"
- "strings"
-)
-
-// These are SSH message type numbers. They are scattered around several
-// documents but many were taken from [SSH-PARAMETERS].
-const (
- msgIgnore = 2
- msgUnimplemented = 3
- msgDebug = 4
- msgNewKeys = 21
-
- // Standard authentication messages
- msgUserAuthSuccess = 52
- msgUserAuthBanner = 53
-)
-
-// SSH messages:
-//
-// These structures mirror the wire format of the corresponding SSH messages.
-// They are marshaled using reflection with the marshal and unmarshal functions
-// in this file. The only wrinkle is that a final member of type []byte with a
-// ssh tag of "rest" receives the remainder of a packet when unmarshaling.
-
-// See RFC 4253, section 11.1.
-const msgDisconnect = 1
-
-// disconnectMsg is the message that signals a disconnect. It is also
-// the error type returned from mux.Wait()
-type disconnectMsg struct {
- Reason uint32 `sshtype:"1"`
- Message string
- Language string
-}
-
-func (d *disconnectMsg) Error() string {
- return fmt.Sprintf("ssh: disconnect, reason %d: %s", d.Reason, d.Message)
-}
-
-// See RFC 4253, section 7.1.
-const msgKexInit = 20
-
-type kexInitMsg struct {
- Cookie [16]byte `sshtype:"20"`
- KexAlgos []string
- ServerHostKeyAlgos []string
- CiphersClientServer []string
- CiphersServerClient []string
- MACsClientServer []string
- MACsServerClient []string
- CompressionClientServer []string
- CompressionServerClient []string
- LanguagesClientServer []string
- LanguagesServerClient []string
- FirstKexFollows bool
- Reserved uint32
-}
-
-// See RFC 4253, section 8.
-
-// Diffie-Helman
-const msgKexDHInit = 30
-
-type kexDHInitMsg struct {
- X *big.Int `sshtype:"30"`
-}
-
-const msgKexECDHInit = 30
-
-type kexECDHInitMsg struct {
- ClientPubKey []byte `sshtype:"30"`
-}
-
-const msgKexECDHReply = 31
-
-type kexECDHReplyMsg struct {
- HostKey []byte `sshtype:"31"`
- EphemeralPubKey []byte
- Signature []byte
-}
-
-const msgKexDHReply = 31
-
-type kexDHReplyMsg struct {
- HostKey []byte `sshtype:"31"`
- Y *big.Int
- Signature []byte
-}
-
-// See RFC 4253, section 10.
-const msgServiceRequest = 5
-
-type serviceRequestMsg struct {
- Service string `sshtype:"5"`
-}
-
-// See RFC 4253, section 10.
-const msgServiceAccept = 6
-
-type serviceAcceptMsg struct {
- Service string `sshtype:"6"`
-}
-
-// See RFC 4252, section 5.
-const msgUserAuthRequest = 50
-
-type userAuthRequestMsg struct {
- User string `sshtype:"50"`
- Service string
- Method string
- Payload []byte `ssh:"rest"`
-}
-
-// Used for debug printouts of packets.
-type userAuthSuccessMsg struct {
-}
-
-// See RFC 4252, section 5.1
-const msgUserAuthFailure = 51
-
-type userAuthFailureMsg struct {
- Methods []string `sshtype:"51"`
- PartialSuccess bool
-}
-
-// See RFC 4256, section 3.2
-const msgUserAuthInfoRequest = 60
-const msgUserAuthInfoResponse = 61
-
-type userAuthInfoRequestMsg struct {
- User string `sshtype:"60"`
- Instruction string
- DeprecatedLanguage string
- NumPrompts uint32
- Prompts []byte `ssh:"rest"`
-}
-
-// See RFC 4254, section 5.1.
-const msgChannelOpen = 90
-
-type channelOpenMsg struct {
- ChanType string `sshtype:"90"`
- PeersId uint32
- PeersWindow uint32
- MaxPacketSize uint32
- TypeSpecificData []byte `ssh:"rest"`
-}
-
-const msgChannelExtendedData = 95
-const msgChannelData = 94
-
-// Used for debug print outs of packets.
-type channelDataMsg struct {
- PeersId uint32 `sshtype:"94"`
- Length uint32
- Rest []byte `ssh:"rest"`
-}
-
-// See RFC 4254, section 5.1.
-const msgChannelOpenConfirm = 91
-
-type channelOpenConfirmMsg struct {
- PeersId uint32 `sshtype:"91"`
- MyId uint32
- MyWindow uint32
- MaxPacketSize uint32
- TypeSpecificData []byte `ssh:"rest"`
-}
-
-// See RFC 4254, section 5.1.
-const msgChannelOpenFailure = 92
-
-type channelOpenFailureMsg struct {
- PeersId uint32 `sshtype:"92"`
- Reason RejectionReason
- Message string
- Language string
-}
-
-const msgChannelRequest = 98
-
-type channelRequestMsg struct {
- PeersId uint32 `sshtype:"98"`
- Request string
- WantReply bool
- RequestSpecificData []byte `ssh:"rest"`
-}
-
-// See RFC 4254, section 5.4.
-const msgChannelSuccess = 99
-
-type channelRequestSuccessMsg struct {
- PeersId uint32 `sshtype:"99"`
-}
-
-// See RFC 4254, section 5.4.
-const msgChannelFailure = 100
-
-type channelRequestFailureMsg struct {
- PeersId uint32 `sshtype:"100"`
-}
-
-// See RFC 4254, section 5.3
-const msgChannelClose = 97
-
-type channelCloseMsg struct {
- PeersId uint32 `sshtype:"97"`
-}
-
-// See RFC 4254, section 5.3
-const msgChannelEOF = 96
-
-type channelEOFMsg struct {
- PeersId uint32 `sshtype:"96"`
-}
-
-// See RFC 4254, section 4
-const msgGlobalRequest = 80
-
-type globalRequestMsg struct {
- Type string `sshtype:"80"`
- WantReply bool
- Data []byte `ssh:"rest"`
-}
-
-// See RFC 4254, section 4
-const msgRequestSuccess = 81
-
-type globalRequestSuccessMsg struct {
- Data []byte `ssh:"rest" sshtype:"81"`
-}
-
-// See RFC 4254, section 4
-const msgRequestFailure = 82
-
-type globalRequestFailureMsg struct {
- Data []byte `ssh:"rest" sshtype:"82"`
-}
-
-// See RFC 4254, section 5.2
-const msgChannelWindowAdjust = 93
-
-type windowAdjustMsg struct {
- PeersId uint32 `sshtype:"93"`
- AdditionalBytes uint32
-}
-
-// See RFC 4252, section 7
-const msgUserAuthPubKeyOk = 60
-
-type userAuthPubKeyOkMsg struct {
- Algo string `sshtype:"60"`
- PubKey []byte
-}
-
-// typeTags returns the possible type bytes for the given reflect.Type, which
-// should be a struct. The possible values are separated by a '|' character.
-func typeTags(structType reflect.Type) (tags []byte) {
- tagStr := structType.Field(0).Tag.Get("sshtype")
-
- for _, tag := range strings.Split(tagStr, "|") {
- i, err := strconv.Atoi(tag)
- if err == nil {
- tags = append(tags, byte(i))
- }
- }
-
- return tags
-}
-
-func fieldError(t reflect.Type, field int, problem string) error {
- if problem != "" {
- problem = ": " + problem
- }
- return fmt.Errorf("ssh: unmarshal error for field %s of type %s%s", t.Field(field).Name, t.Name(), problem)
-}
-
-var errShortRead = errors.New("ssh: short read")
-
-// Unmarshal parses data in SSH wire format into a structure. The out
-// argument should be a pointer to struct. If the first member of the
-// struct has the "sshtype" tag set to a '|'-separated set of numbers
-// in decimal, the packet must start with one of those numbers. In
-// case of error, Unmarshal returns a ParseError or
-// UnexpectedMessageError.
-func Unmarshal(data []byte, out interface{}) error {
- v := reflect.ValueOf(out).Elem()
- structType := v.Type()
- expectedTypes := typeTags(structType)
-
- var expectedType byte
- if len(expectedTypes) > 0 {
- expectedType = expectedTypes[0]
- }
-
- if len(data) == 0 {
- return parseError(expectedType)
- }
-
- if len(expectedTypes) > 0 {
- goodType := false
- for _, e := range expectedTypes {
- if e > 0 && data[0] == e {
- goodType = true
- break
- }
- }
- if !goodType {
- return fmt.Errorf("ssh: unexpected message type %d (expected one of %v)", data[0], expectedTypes)
- }
- data = data[1:]
- }
-
- var ok bool
- for i := 0; i < v.NumField(); i++ {
- field := v.Field(i)
- t := field.Type()
- switch t.Kind() {
- case reflect.Bool:
- if len(data) < 1 {
- return errShortRead
- }
- field.SetBool(data[0] != 0)
- data = data[1:]
- case reflect.Array:
- if t.Elem().Kind() != reflect.Uint8 {
- return fieldError(structType, i, "array of unsupported type")
- }
- if len(data) < t.Len() {
- return errShortRead
- }
- for j, n := 0, t.Len(); j < n; j++ {
- field.Index(j).Set(reflect.ValueOf(data[j]))
- }
- data = data[t.Len():]
- case reflect.Uint64:
- var u64 uint64
- if u64, data, ok = parseUint64(data); !ok {
- return errShortRead
- }
- field.SetUint(u64)
- case reflect.Uint32:
- var u32 uint32
- if u32, data, ok = parseUint32(data); !ok {
- return errShortRead
- }
- field.SetUint(uint64(u32))
- case reflect.Uint8:
- if len(data) < 1 {
- return errShortRead
- }
- field.SetUint(uint64(data[0]))
- data = data[1:]
- case reflect.String:
- var s []byte
- if s, data, ok = parseString(data); !ok {
- return fieldError(structType, i, "")
- }
- field.SetString(string(s))
- case reflect.Slice:
- switch t.Elem().Kind() {
- case reflect.Uint8:
- if structType.Field(i).Tag.Get("ssh") == "rest" {
- field.Set(reflect.ValueOf(data))
- data = nil
- } else {
- var s []byte
- if s, data, ok = parseString(data); !ok {
- return errShortRead
- }
- field.Set(reflect.ValueOf(s))
- }
- case reflect.String:
- var nl []string
- if nl, data, ok = parseNameList(data); !ok {
- return errShortRead
- }
- field.Set(reflect.ValueOf(nl))
- default:
- return fieldError(structType, i, "slice of unsupported type")
- }
- case reflect.Ptr:
- if t == bigIntType {
- var n *big.Int
- if n, data, ok = parseInt(data); !ok {
- return errShortRead
- }
- field.Set(reflect.ValueOf(n))
- } else {
- return fieldError(structType, i, "pointer to unsupported type")
- }
- default:
- return fieldError(structType, i, fmt.Sprintf("unsupported type: %v", t))
- }
- }
-
- if len(data) != 0 {
- return parseError(expectedType)
- }
-
- return nil
-}
-
-// Marshal serializes the message in msg to SSH wire format. The msg
-// argument should be a struct or pointer to struct. If the first
-// member has the "sshtype" tag set to a number in decimal, that
-// number is prepended to the result. If the last of member has the
-// "ssh" tag set to "rest", its contents are appended to the output.
-func Marshal(msg interface{}) []byte {
- out := make([]byte, 0, 64)
- return marshalStruct(out, msg)
-}
-
-func marshalStruct(out []byte, msg interface{}) []byte {
- v := reflect.Indirect(reflect.ValueOf(msg))
- msgTypes := typeTags(v.Type())
- if len(msgTypes) > 0 {
- out = append(out, msgTypes[0])
- }
-
- for i, n := 0, v.NumField(); i < n; i++ {
- field := v.Field(i)
- switch t := field.Type(); t.Kind() {
- case reflect.Bool:
- var v uint8
- if field.Bool() {
- v = 1
- }
- out = append(out, v)
- case reflect.Array:
- if t.Elem().Kind() != reflect.Uint8 {
- panic(fmt.Sprintf("array of non-uint8 in field %d: %T", i, field.Interface()))
- }
- for j, l := 0, t.Len(); j < l; j++ {
- out = append(out, uint8(field.Index(j).Uint()))
- }
- case reflect.Uint32:
- out = appendU32(out, uint32(field.Uint()))
- case reflect.Uint64:
- out = appendU64(out, uint64(field.Uint()))
- case reflect.Uint8:
- out = append(out, uint8(field.Uint()))
- case reflect.String:
- s := field.String()
- out = appendInt(out, len(s))
- out = append(out, s...)
- case reflect.Slice:
- switch t.Elem().Kind() {
- case reflect.Uint8:
- if v.Type().Field(i).Tag.Get("ssh") != "rest" {
- out = appendInt(out, field.Len())
- }
- out = append(out, field.Bytes()...)
- case reflect.String:
- offset := len(out)
- out = appendU32(out, 0)
- if n := field.Len(); n > 0 {
- for j := 0; j < n; j++ {
- f := field.Index(j)
- if j != 0 {
- out = append(out, ',')
- }
- out = append(out, f.String()...)
- }
- // overwrite length value
- binary.BigEndian.PutUint32(out[offset:], uint32(len(out)-offset-4))
- }
- default:
- panic(fmt.Sprintf("slice of unknown type in field %d: %T", i, field.Interface()))
- }
- case reflect.Ptr:
- if t == bigIntType {
- var n *big.Int
- nValue := reflect.ValueOf(&n)
- nValue.Elem().Set(field)
- needed := intLength(n)
- oldLength := len(out)
-
- if cap(out)-len(out) < needed {
- newOut := make([]byte, len(out), 2*(len(out)+needed))
- copy(newOut, out)
- out = newOut
- }
- out = out[:oldLength+needed]
- marshalInt(out[oldLength:], n)
- } else {
- panic(fmt.Sprintf("pointer to unknown type in field %d: %T", i, field.Interface()))
- }
- }
- }
-
- return out
-}
-
-var bigOne = big.NewInt(1)
-
-func parseString(in []byte) (out, rest []byte, ok bool) {
- if len(in) < 4 {
- return
- }
- length := binary.BigEndian.Uint32(in)
- in = in[4:]
- if uint32(len(in)) < length {
- return
- }
- out = in[:length]
- rest = in[length:]
- ok = true
- return
-}
-
-var (
- comma = []byte{','}
- emptyNameList = []string{}
-)
-
-func parseNameList(in []byte) (out []string, rest []byte, ok bool) {
- contents, rest, ok := parseString(in)
- if !ok {
- return
- }
- if len(contents) == 0 {
- out = emptyNameList
- return
- }
- parts := bytes.Split(contents, comma)
- out = make([]string, len(parts))
- for i, part := range parts {
- out[i] = string(part)
- }
- return
-}
-
-func parseInt(in []byte) (out *big.Int, rest []byte, ok bool) {
- contents, rest, ok := parseString(in)
- if !ok {
- return
- }
- out = new(big.Int)
-
- if len(contents) > 0 && contents[0]&0x80 == 0x80 {
- // This is a negative number
- notBytes := make([]byte, len(contents))
- for i := range notBytes {
- notBytes[i] = ^contents[i]
- }
- out.SetBytes(notBytes)
- out.Add(out, bigOne)
- out.Neg(out)
- } else {
- // Positive number
- out.SetBytes(contents)
- }
- ok = true
- return
-}
-
-func parseUint32(in []byte) (uint32, []byte, bool) {
- if len(in) < 4 {
- return 0, nil, false
- }
- return binary.BigEndian.Uint32(in), in[4:], true
-}
-
-func parseUint64(in []byte) (uint64, []byte, bool) {
- if len(in) < 8 {
- return 0, nil, false
- }
- return binary.BigEndian.Uint64(in), in[8:], true
-}
-
-func intLength(n *big.Int) int {
- length := 4 /* length bytes */
- if n.Sign() < 0 {
- nMinus1 := new(big.Int).Neg(n)
- nMinus1.Sub(nMinus1, bigOne)
- bitLen := nMinus1.BitLen()
- if bitLen%8 == 0 {
- // The number will need 0xff padding
- length++
- }
- length += (bitLen + 7) / 8
- } else if n.Sign() == 0 {
- // A zero is the zero length string
- } else {
- bitLen := n.BitLen()
- if bitLen%8 == 0 {
- // The number will need 0x00 padding
- length++
- }
- length += (bitLen + 7) / 8
- }
-
- return length
-}
-
-func marshalUint32(to []byte, n uint32) []byte {
- binary.BigEndian.PutUint32(to, n)
- return to[4:]
-}
-
-func marshalUint64(to []byte, n uint64) []byte {
- binary.BigEndian.PutUint64(to, n)
- return to[8:]
-}
-
-func marshalInt(to []byte, n *big.Int) []byte {
- lengthBytes := to
- to = to[4:]
- length := 0
-
- if n.Sign() < 0 {
- // A negative number has to be converted to two's-complement
- // form. So we'll subtract 1 and invert. If the
- // most-significant-bit isn't set then we'll need to pad the
- // beginning with 0xff in order to keep the number negative.
- nMinus1 := new(big.Int).Neg(n)
- nMinus1.Sub(nMinus1, bigOne)
- bytes := nMinus1.Bytes()
- for i := range bytes {
- bytes[i] ^= 0xff
- }
- if len(bytes) == 0 || bytes[0]&0x80 == 0 {
- to[0] = 0xff
- to = to[1:]
- length++
- }
- nBytes := copy(to, bytes)
- to = to[nBytes:]
- length += nBytes
- } else if n.Sign() == 0 {
- // A zero is the zero length string
- } else {
- bytes := n.Bytes()
- if len(bytes) > 0 && bytes[0]&0x80 != 0 {
- // We'll have to pad this with a 0x00 in order to
- // stop it looking like a negative number.
- to[0] = 0
- to = to[1:]
- length++
- }
- nBytes := copy(to, bytes)
- to = to[nBytes:]
- length += nBytes
- }
-
- lengthBytes[0] = byte(length >> 24)
- lengthBytes[1] = byte(length >> 16)
- lengthBytes[2] = byte(length >> 8)
- lengthBytes[3] = byte(length)
- return to
-}
-
-func writeInt(w io.Writer, n *big.Int) {
- length := intLength(n)
- buf := make([]byte, length)
- marshalInt(buf, n)
- w.Write(buf)
-}
-
-func writeString(w io.Writer, s []byte) {
- var lengthBytes [4]byte
- lengthBytes[0] = byte(len(s) >> 24)
- lengthBytes[1] = byte(len(s) >> 16)
- lengthBytes[2] = byte(len(s) >> 8)
- lengthBytes[3] = byte(len(s))
- w.Write(lengthBytes[:])
- w.Write(s)
-}
-
-func stringLength(n int) int {
- return 4 + n
-}
-
-func marshalString(to []byte, s []byte) []byte {
- to[0] = byte(len(s) >> 24)
- to[1] = byte(len(s) >> 16)
- to[2] = byte(len(s) >> 8)
- to[3] = byte(len(s))
- to = to[4:]
- copy(to, s)
- return to[len(s):]
-}
-
-var bigIntType = reflect.TypeOf((*big.Int)(nil))
-
-// Decode a packet into its corresponding message.
-func decode(packet []byte) (interface{}, error) {
- var msg interface{}
- switch packet[0] {
- case msgDisconnect:
- msg = new(disconnectMsg)
- case msgServiceRequest:
- msg = new(serviceRequestMsg)
- case msgServiceAccept:
- msg = new(serviceAcceptMsg)
- case msgKexInit:
- msg = new(kexInitMsg)
- case msgKexDHInit:
- msg = new(kexDHInitMsg)
- case msgKexDHReply:
- msg = new(kexDHReplyMsg)
- case msgUserAuthRequest:
- msg = new(userAuthRequestMsg)
- case msgUserAuthSuccess:
- return new(userAuthSuccessMsg), nil
- case msgUserAuthFailure:
- msg = new(userAuthFailureMsg)
- case msgUserAuthPubKeyOk:
- msg = new(userAuthPubKeyOkMsg)
- case msgGlobalRequest:
- msg = new(globalRequestMsg)
- case msgRequestSuccess:
- msg = new(globalRequestSuccessMsg)
- case msgRequestFailure:
- msg = new(globalRequestFailureMsg)
- case msgChannelOpen:
- msg = new(channelOpenMsg)
- case msgChannelData:
- msg = new(channelDataMsg)
- case msgChannelOpenConfirm:
- msg = new(channelOpenConfirmMsg)
- case msgChannelOpenFailure:
- msg = new(channelOpenFailureMsg)
- case msgChannelWindowAdjust:
- msg = new(windowAdjustMsg)
- case msgChannelEOF:
- msg = new(channelEOFMsg)
- case msgChannelClose:
- msg = new(channelCloseMsg)
- case msgChannelRequest:
- msg = new(channelRequestMsg)
- case msgChannelSuccess:
- msg = new(channelRequestSuccessMsg)
- case msgChannelFailure:
- msg = new(channelRequestFailureMsg)
- default:
- return nil, unexpectedMessageError(0, packet[0])
- }
- if err := Unmarshal(packet, msg); err != nil {
- return nil, err
- }
- return msg, nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/mux.go b/vendor/golang.org/x/crypto/ssh/mux.go
deleted file mode 100644
index 27a527c106bfbd6fd3aad6f8a8d2ceb3300fa8e3..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/mux.go
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "encoding/binary"
- "fmt"
- "io"
- "log"
- "sync"
- "sync/atomic"
-)
-
-// debugMux, if set, causes messages in the connection protocol to be
-// logged.
-const debugMux = false
-
-// chanList is a thread safe channel list.
-type chanList struct {
- // protects concurrent access to chans
- sync.Mutex
-
- // chans are indexed by the local id of the channel, which the
- // other side should send in the PeersId field.
- chans []*channel
-
- // This is a debugging aid: it offsets all IDs by this
- // amount. This helps distinguish otherwise identical
- // server/client muxes
- offset uint32
-}
-
-// Assigns a channel ID to the given channel.
-func (c *chanList) add(ch *channel) uint32 {
- c.Lock()
- defer c.Unlock()
- for i := range c.chans {
- if c.chans[i] == nil {
- c.chans[i] = ch
- return uint32(i) + c.offset
- }
- }
- c.chans = append(c.chans, ch)
- return uint32(len(c.chans)-1) + c.offset
-}
-
-// getChan returns the channel for the given ID.
-func (c *chanList) getChan(id uint32) *channel {
- id -= c.offset
-
- c.Lock()
- defer c.Unlock()
- if id < uint32(len(c.chans)) {
- return c.chans[id]
- }
- return nil
-}
-
-func (c *chanList) remove(id uint32) {
- id -= c.offset
- c.Lock()
- if id < uint32(len(c.chans)) {
- c.chans[id] = nil
- }
- c.Unlock()
-}
-
-// dropAll forgets all channels it knows, returning them in a slice.
-func (c *chanList) dropAll() []*channel {
- c.Lock()
- defer c.Unlock()
- var r []*channel
-
- for _, ch := range c.chans {
- if ch == nil {
- continue
- }
- r = append(r, ch)
- }
- c.chans = nil
- return r
-}
-
-// mux represents the state for the SSH connection protocol, which
-// multiplexes many channels onto a single packet transport.
-type mux struct {
- conn packetConn
- chanList chanList
-
- incomingChannels chan NewChannel
-
- globalSentMu sync.Mutex
- globalResponses chan interface{}
- incomingRequests chan *Request
-
- errCond *sync.Cond
- err error
-}
-
-// When debugging, each new chanList instantiation has a different
-// offset.
-var globalOff uint32
-
-func (m *mux) Wait() error {
- m.errCond.L.Lock()
- defer m.errCond.L.Unlock()
- for m.err == nil {
- m.errCond.Wait()
- }
- return m.err
-}
-
-// newMux returns a mux that runs over the given connection.
-func newMux(p packetConn) *mux {
- m := &mux{
- conn: p,
- incomingChannels: make(chan NewChannel, chanSize),
- globalResponses: make(chan interface{}, 1),
- incomingRequests: make(chan *Request, chanSize),
- errCond: newCond(),
- }
- if debugMux {
- m.chanList.offset = atomic.AddUint32(&globalOff, 1)
- }
-
- go m.loop()
- return m
-}
-
-func (m *mux) sendMessage(msg interface{}) error {
- p := Marshal(msg)
- if debugMux {
- log.Printf("send global(%d): %#v", m.chanList.offset, msg)
- }
- return m.conn.writePacket(p)
-}
-
-func (m *mux) SendRequest(name string, wantReply bool, payload []byte) (bool, []byte, error) {
- if wantReply {
- m.globalSentMu.Lock()
- defer m.globalSentMu.Unlock()
- }
-
- if err := m.sendMessage(globalRequestMsg{
- Type: name,
- WantReply: wantReply,
- Data: payload,
- }); err != nil {
- return false, nil, err
- }
-
- if !wantReply {
- return false, nil, nil
- }
-
- msg, ok := <-m.globalResponses
- if !ok {
- return false, nil, io.EOF
- }
- switch msg := msg.(type) {
- case *globalRequestFailureMsg:
- return false, msg.Data, nil
- case *globalRequestSuccessMsg:
- return true, msg.Data, nil
- default:
- return false, nil, fmt.Errorf("ssh: unexpected response to request: %#v", msg)
- }
-}
-
-// ackRequest must be called after processing a global request that
-// has WantReply set.
-func (m *mux) ackRequest(ok bool, data []byte) error {
- if ok {
- return m.sendMessage(globalRequestSuccessMsg{Data: data})
- }
- return m.sendMessage(globalRequestFailureMsg{Data: data})
-}
-
-func (m *mux) Close() error {
- return m.conn.Close()
-}
-
-// loop runs the connection machine. It will process packets until an
-// error is encountered. To synchronize on loop exit, use mux.Wait.
-func (m *mux) loop() {
- var err error
- for err == nil {
- err = m.onePacket()
- }
-
- for _, ch := range m.chanList.dropAll() {
- ch.close()
- }
-
- close(m.incomingChannels)
- close(m.incomingRequests)
- close(m.globalResponses)
-
- m.conn.Close()
-
- m.errCond.L.Lock()
- m.err = err
- m.errCond.Broadcast()
- m.errCond.L.Unlock()
-
- if debugMux {
- log.Println("loop exit", err)
- }
-}
-
-// onePacket reads and processes one packet.
-func (m *mux) onePacket() error {
- packet, err := m.conn.readPacket()
- if err != nil {
- return err
- }
-
- if debugMux {
- if packet[0] == msgChannelData || packet[0] == msgChannelExtendedData {
- log.Printf("decoding(%d): data packet - %d bytes", m.chanList.offset, len(packet))
- } else {
- p, _ := decode(packet)
- log.Printf("decoding(%d): %d %#v - %d bytes", m.chanList.offset, packet[0], p, len(packet))
- }
- }
-
- switch packet[0] {
- case msgChannelOpen:
- return m.handleChannelOpen(packet)
- case msgGlobalRequest, msgRequestSuccess, msgRequestFailure:
- return m.handleGlobalPacket(packet)
- }
-
- // assume a channel packet.
- if len(packet) < 5 {
- return parseError(packet[0])
- }
- id := binary.BigEndian.Uint32(packet[1:])
- ch := m.chanList.getChan(id)
- if ch == nil {
- return fmt.Errorf("ssh: invalid channel %d", id)
- }
-
- return ch.handlePacket(packet)
-}
-
-func (m *mux) handleGlobalPacket(packet []byte) error {
- msg, err := decode(packet)
- if err != nil {
- return err
- }
-
- switch msg := msg.(type) {
- case *globalRequestMsg:
- m.incomingRequests <- &Request{
- Type: msg.Type,
- WantReply: msg.WantReply,
- Payload: msg.Data,
- mux: m,
- }
- case *globalRequestSuccessMsg, *globalRequestFailureMsg:
- m.globalResponses <- msg
- default:
- panic(fmt.Sprintf("not a global message %#v", msg))
- }
-
- return nil
-}
-
-// handleChannelOpen schedules a channel to be Accept()ed.
-func (m *mux) handleChannelOpen(packet []byte) error {
- var msg channelOpenMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return err
- }
-
- if msg.MaxPacketSize < minPacketLength || msg.MaxPacketSize > 1<<31 {
- failMsg := channelOpenFailureMsg{
- PeersId: msg.PeersId,
- Reason: ConnectionFailed,
- Message: "invalid request",
- Language: "en_US.UTF-8",
- }
- return m.sendMessage(failMsg)
- }
-
- c := m.newChannel(msg.ChanType, channelInbound, msg.TypeSpecificData)
- c.remoteId = msg.PeersId
- c.maxRemotePayload = msg.MaxPacketSize
- c.remoteWin.add(msg.PeersWindow)
- m.incomingChannels <- c
- return nil
-}
-
-func (m *mux) OpenChannel(chanType string, extra []byte) (Channel, <-chan *Request, error) {
- ch, err := m.openChannel(chanType, extra)
- if err != nil {
- return nil, nil, err
- }
-
- return ch, ch.incomingRequests, nil
-}
-
-func (m *mux) openChannel(chanType string, extra []byte) (*channel, error) {
- ch := m.newChannel(chanType, channelOutbound, extra)
-
- ch.maxIncomingPayload = channelMaxPacket
-
- open := channelOpenMsg{
- ChanType: chanType,
- PeersWindow: ch.myWindow,
- MaxPacketSize: ch.maxIncomingPayload,
- TypeSpecificData: extra,
- PeersId: ch.localId,
- }
- if err := m.sendMessage(open); err != nil {
- return nil, err
- }
-
- switch msg := (<-ch.msg).(type) {
- case *channelOpenConfirmMsg:
- return ch, nil
- case *channelOpenFailureMsg:
- return nil, &OpenChannelError{msg.Reason, msg.Message}
- default:
- return nil, fmt.Errorf("ssh: unexpected packet in response to channel open: %T", msg)
- }
-}
diff --git a/vendor/golang.org/x/crypto/ssh/server.go b/vendor/golang.org/x/crypto/ssh/server.go
deleted file mode 100644
index 77c84d165caa5a7e202989121dab26264f8b5638..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/server.go
+++ /dev/null
@@ -1,491 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
- "net"
- "strings"
-)
-
-// The Permissions type holds fine-grained permissions that are
-// specific to a user or a specific authentication method for a
-// user. Permissions, except for "source-address", must be enforced in
-// the server application layer, after successful authentication. The
-// Permissions are passed on in ServerConn so a server implementation
-// can honor them.
-type Permissions struct {
- // Critical options restrict default permissions. Common
- // restrictions are "source-address" and "force-command". If
- // the server cannot enforce the restriction, or does not
- // recognize it, the user should not authenticate.
- CriticalOptions map[string]string
-
- // Extensions are extra functionality that the server may
- // offer on authenticated connections. Common extensions are
- // "permit-agent-forwarding", "permit-X11-forwarding". Lack of
- // support for an extension does not preclude authenticating a
- // user.
- Extensions map[string]string
-}
-
-// ServerConfig holds server specific configuration data.
-type ServerConfig struct {
- // Config contains configuration shared between client and server.
- Config
-
- hostKeys []Signer
-
- // NoClientAuth is true if clients are allowed to connect without
- // authenticating.
- NoClientAuth bool
-
- // PasswordCallback, if non-nil, is called when a user
- // attempts to authenticate using a password.
- PasswordCallback func(conn ConnMetadata, password []byte) (*Permissions, error)
-
- // PublicKeyCallback, if non-nil, is called when a client attempts public
- // key authentication. It must return true if the given public key is
- // valid for the given user. For example, see CertChecker.Authenticate.
- PublicKeyCallback func(conn ConnMetadata, key PublicKey) (*Permissions, error)
-
- // KeyboardInteractiveCallback, if non-nil, is called when
- // keyboard-interactive authentication is selected (RFC
- // 4256). The client object's Challenge function should be
- // used to query the user. The callback may offer multiple
- // Challenge rounds. To avoid information leaks, the client
- // should be presented a challenge even if the user is
- // unknown.
- KeyboardInteractiveCallback func(conn ConnMetadata, client KeyboardInteractiveChallenge) (*Permissions, error)
-
- // AuthLogCallback, if non-nil, is called to log all authentication
- // attempts.
- AuthLogCallback func(conn ConnMetadata, method string, err error)
-
- // ServerVersion is the version identification string to announce in
- // the public handshake.
- // If empty, a reasonable default is used.
- // Note that RFC 4253 section 4.2 requires that this string start with
- // "SSH-2.0-".
- ServerVersion string
-}
-
-// AddHostKey adds a private key as a host key. If an existing host
-// key exists with the same algorithm, it is overwritten. Each server
-// config must have at least one host key.
-func (s *ServerConfig) AddHostKey(key Signer) {
- for i, k := range s.hostKeys {
- if k.PublicKey().Type() == key.PublicKey().Type() {
- s.hostKeys[i] = key
- return
- }
- }
-
- s.hostKeys = append(s.hostKeys, key)
-}
-
-// cachedPubKey contains the results of querying whether a public key is
-// acceptable for a user.
-type cachedPubKey struct {
- user string
- pubKeyData []byte
- result error
- perms *Permissions
-}
-
-const maxCachedPubKeys = 16
-
-// pubKeyCache caches tests for public keys. Since SSH clients
-// will query whether a public key is acceptable before attempting to
-// authenticate with it, we end up with duplicate queries for public
-// key validity. The cache only applies to a single ServerConn.
-type pubKeyCache struct {
- keys []cachedPubKey
-}
-
-// get returns the result for a given user/algo/key tuple.
-func (c *pubKeyCache) get(user string, pubKeyData []byte) (cachedPubKey, bool) {
- for _, k := range c.keys {
- if k.user == user && bytes.Equal(k.pubKeyData, pubKeyData) {
- return k, true
- }
- }
- return cachedPubKey{}, false
-}
-
-// add adds the given tuple to the cache.
-func (c *pubKeyCache) add(candidate cachedPubKey) {
- if len(c.keys) < maxCachedPubKeys {
- c.keys = append(c.keys, candidate)
- }
-}
-
-// ServerConn is an authenticated SSH connection, as seen from the
-// server
-type ServerConn struct {
- Conn
-
- // If the succeeding authentication callback returned a
- // non-nil Permissions pointer, it is stored here.
- Permissions *Permissions
-}
-
-// NewServerConn starts a new SSH server with c as the underlying
-// transport. It starts with a handshake and, if the handshake is
-// unsuccessful, it closes the connection and returns an error. The
-// Request and NewChannel channels must be serviced, or the connection
-// will hang.
-func NewServerConn(c net.Conn, config *ServerConfig) (*ServerConn, <-chan NewChannel, <-chan *Request, error) {
- fullConf := *config
- fullConf.SetDefaults()
- s := &connection{
- sshConn: sshConn{conn: c},
- }
- perms, err := s.serverHandshake(&fullConf)
- if err != nil {
- c.Close()
- return nil, nil, nil, err
- }
- return &ServerConn{s, perms}, s.mux.incomingChannels, s.mux.incomingRequests, nil
-}
-
-// signAndMarshal signs the data with the appropriate algorithm,
-// and serializes the result in SSH wire format.
-func signAndMarshal(k Signer, rand io.Reader, data []byte) ([]byte, error) {
- sig, err := k.Sign(rand, data)
- if err != nil {
- return nil, err
- }
-
- return Marshal(sig), nil
-}
-
-// handshake performs key exchange and user authentication.
-func (s *connection) serverHandshake(config *ServerConfig) (*Permissions, error) {
- if len(config.hostKeys) == 0 {
- return nil, errors.New("ssh: server has no host keys")
- }
-
- if !config.NoClientAuth && config.PasswordCallback == nil && config.PublicKeyCallback == nil && config.KeyboardInteractiveCallback == nil {
- return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false")
- }
-
- if config.ServerVersion != "" {
- s.serverVersion = []byte(config.ServerVersion)
- } else {
- s.serverVersion = []byte(packageVersion)
- }
- var err error
- s.clientVersion, err = exchangeVersions(s.sshConn.conn, s.serverVersion)
- if err != nil {
- return nil, err
- }
-
- tr := newTransport(s.sshConn.conn, config.Rand, false /* not client */)
- s.transport = newServerTransport(tr, s.clientVersion, s.serverVersion, config)
-
- if err := s.transport.waitSession(); err != nil {
- return nil, err
- }
-
- // We just did the key change, so the session ID is established.
- s.sessionID = s.transport.getSessionID()
-
- var packet []byte
- if packet, err = s.transport.readPacket(); err != nil {
- return nil, err
- }
-
- var serviceRequest serviceRequestMsg
- if err = Unmarshal(packet, &serviceRequest); err != nil {
- return nil, err
- }
- if serviceRequest.Service != serviceUserAuth {
- return nil, errors.New("ssh: requested service '" + serviceRequest.Service + "' before authenticating")
- }
- serviceAccept := serviceAcceptMsg{
- Service: serviceUserAuth,
- }
- if err := s.transport.writePacket(Marshal(&serviceAccept)); err != nil {
- return nil, err
- }
-
- perms, err := s.serverAuthenticate(config)
- if err != nil {
- return nil, err
- }
- s.mux = newMux(s.transport)
- return perms, err
-}
-
-func isAcceptableAlgo(algo string) bool {
- switch algo {
- case KeyAlgoRSA, KeyAlgoDSA, KeyAlgoECDSA256, KeyAlgoECDSA384, KeyAlgoECDSA521, KeyAlgoED25519,
- CertAlgoRSAv01, CertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01:
- return true
- }
- return false
-}
-
-func checkSourceAddress(addr net.Addr, sourceAddrs string) error {
- if addr == nil {
- return errors.New("ssh: no address known for client, but source-address match required")
- }
-
- tcpAddr, ok := addr.(*net.TCPAddr)
- if !ok {
- return fmt.Errorf("ssh: remote address %v is not an TCP address when checking source-address match", addr)
- }
-
- for _, sourceAddr := range strings.Split(sourceAddrs, ",") {
- if allowedIP := net.ParseIP(sourceAddr); allowedIP != nil {
- if allowedIP.Equal(tcpAddr.IP) {
- return nil
- }
- } else {
- _, ipNet, err := net.ParseCIDR(sourceAddr)
- if err != nil {
- return fmt.Errorf("ssh: error parsing source-address restriction %q: %v", sourceAddr, err)
- }
-
- if ipNet.Contains(tcpAddr.IP) {
- return nil
- }
- }
- }
-
- return fmt.Errorf("ssh: remote address %v is not allowed because of source-address restriction", addr)
-}
-
-func (s *connection) serverAuthenticate(config *ServerConfig) (*Permissions, error) {
- sessionID := s.transport.getSessionID()
- var cache pubKeyCache
- var perms *Permissions
-
-userAuthLoop:
- for {
- var userAuthReq userAuthRequestMsg
- if packet, err := s.transport.readPacket(); err != nil {
- return nil, err
- } else if err = Unmarshal(packet, &userAuthReq); err != nil {
- return nil, err
- }
-
- if userAuthReq.Service != serviceSSH {
- return nil, errors.New("ssh: client attempted to negotiate for unknown service: " + userAuthReq.Service)
- }
-
- s.user = userAuthReq.User
- perms = nil
- authErr := errors.New("no auth passed yet")
-
- switch userAuthReq.Method {
- case "none":
- if config.NoClientAuth {
- authErr = nil
- }
- case "password":
- if config.PasswordCallback == nil {
- authErr = errors.New("ssh: password auth not configured")
- break
- }
- payload := userAuthReq.Payload
- if len(payload) < 1 || payload[0] != 0 {
- return nil, parseError(msgUserAuthRequest)
- }
- payload = payload[1:]
- password, payload, ok := parseString(payload)
- if !ok || len(payload) > 0 {
- return nil, parseError(msgUserAuthRequest)
- }
-
- perms, authErr = config.PasswordCallback(s, password)
- case "keyboard-interactive":
- if config.KeyboardInteractiveCallback == nil {
- authErr = errors.New("ssh: keyboard-interactive auth not configubred")
- break
- }
-
- prompter := &sshClientKeyboardInteractive{s}
- perms, authErr = config.KeyboardInteractiveCallback(s, prompter.Challenge)
- case "publickey":
- if config.PublicKeyCallback == nil {
- authErr = errors.New("ssh: publickey auth not configured")
- break
- }
- payload := userAuthReq.Payload
- if len(payload) < 1 {
- return nil, parseError(msgUserAuthRequest)
- }
- isQuery := payload[0] == 0
- payload = payload[1:]
- algoBytes, payload, ok := parseString(payload)
- if !ok {
- return nil, parseError(msgUserAuthRequest)
- }
- algo := string(algoBytes)
- if !isAcceptableAlgo(algo) {
- authErr = fmt.Errorf("ssh: algorithm %q not accepted", algo)
- break
- }
-
- pubKeyData, payload, ok := parseString(payload)
- if !ok {
- return nil, parseError(msgUserAuthRequest)
- }
-
- pubKey, err := ParsePublicKey(pubKeyData)
- if err != nil {
- return nil, err
- }
-
- candidate, ok := cache.get(s.user, pubKeyData)
- if !ok {
- candidate.user = s.user
- candidate.pubKeyData = pubKeyData
- candidate.perms, candidate.result = config.PublicKeyCallback(s, pubKey)
- if candidate.result == nil && candidate.perms != nil && candidate.perms.CriticalOptions != nil && candidate.perms.CriticalOptions[sourceAddressCriticalOption] != "" {
- candidate.result = checkSourceAddress(
- s.RemoteAddr(),
- candidate.perms.CriticalOptions[sourceAddressCriticalOption])
- }
- cache.add(candidate)
- }
-
- if isQuery {
- // The client can query if the given public key
- // would be okay.
- if len(payload) > 0 {
- return nil, parseError(msgUserAuthRequest)
- }
-
- if candidate.result == nil {
- okMsg := userAuthPubKeyOkMsg{
- Algo: algo,
- PubKey: pubKeyData,
- }
- if err = s.transport.writePacket(Marshal(&okMsg)); err != nil {
- return nil, err
- }
- continue userAuthLoop
- }
- authErr = candidate.result
- } else {
- sig, payload, ok := parseSignature(payload)
- if !ok || len(payload) > 0 {
- return nil, parseError(msgUserAuthRequest)
- }
- // Ensure the public key algo and signature algo
- // are supported. Compare the private key
- // algorithm name that corresponds to algo with
- // sig.Format. This is usually the same, but
- // for certs, the names differ.
- if !isAcceptableAlgo(sig.Format) {
- break
- }
- signedData := buildDataSignedForAuth(sessionID, userAuthReq, algoBytes, pubKeyData)
-
- if err := pubKey.Verify(signedData, sig); err != nil {
- return nil, err
- }
-
- authErr = candidate.result
- perms = candidate.perms
- }
- default:
- authErr = fmt.Errorf("ssh: unknown method %q", userAuthReq.Method)
- }
-
- if config.AuthLogCallback != nil {
- config.AuthLogCallback(s, userAuthReq.Method, authErr)
- }
-
- if authErr == nil {
- break userAuthLoop
- }
-
- var failureMsg userAuthFailureMsg
- if config.PasswordCallback != nil {
- failureMsg.Methods = append(failureMsg.Methods, "password")
- }
- if config.PublicKeyCallback != nil {
- failureMsg.Methods = append(failureMsg.Methods, "publickey")
- }
- if config.KeyboardInteractiveCallback != nil {
- failureMsg.Methods = append(failureMsg.Methods, "keyboard-interactive")
- }
-
- if len(failureMsg.Methods) == 0 {
- return nil, errors.New("ssh: no authentication methods configured but NoClientAuth is also false")
- }
-
- if err := s.transport.writePacket(Marshal(&failureMsg)); err != nil {
- return nil, err
- }
- }
-
- if err := s.transport.writePacket([]byte{msgUserAuthSuccess}); err != nil {
- return nil, err
- }
- return perms, nil
-}
-
-// sshClientKeyboardInteractive implements a ClientKeyboardInteractive by
-// asking the client on the other side of a ServerConn.
-type sshClientKeyboardInteractive struct {
- *connection
-}
-
-func (c *sshClientKeyboardInteractive) Challenge(user, instruction string, questions []string, echos []bool) (answers []string, err error) {
- if len(questions) != len(echos) {
- return nil, errors.New("ssh: echos and questions must have equal length")
- }
-
- var prompts []byte
- for i := range questions {
- prompts = appendString(prompts, questions[i])
- prompts = appendBool(prompts, echos[i])
- }
-
- if err := c.transport.writePacket(Marshal(&userAuthInfoRequestMsg{
- Instruction: instruction,
- NumPrompts: uint32(len(questions)),
- Prompts: prompts,
- })); err != nil {
- return nil, err
- }
-
- packet, err := c.transport.readPacket()
- if err != nil {
- return nil, err
- }
- if packet[0] != msgUserAuthInfoResponse {
- return nil, unexpectedMessageError(msgUserAuthInfoResponse, packet[0])
- }
- packet = packet[1:]
-
- n, packet, ok := parseUint32(packet)
- if !ok || int(n) != len(questions) {
- return nil, parseError(msgUserAuthInfoResponse)
- }
-
- for i := uint32(0); i < n; i++ {
- ans, rest, ok := parseString(packet)
- if !ok {
- return nil, parseError(msgUserAuthInfoResponse)
- }
-
- answers = append(answers, string(ans))
- packet = rest
- }
- if len(packet) != 0 {
- return nil, errors.New("ssh: junk at end of message")
- }
-
- return answers, nil
-}
diff --git a/vendor/golang.org/x/crypto/ssh/session.go b/vendor/golang.org/x/crypto/ssh/session.go
deleted file mode 100644
index 17e2aa85c1f9a450a8596cf09de3fb9945bd2861..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/session.go
+++ /dev/null
@@ -1,627 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-// Session implements an interactive session described in
-// "RFC 4254, section 6".
-
-import (
- "bytes"
- "encoding/binary"
- "errors"
- "fmt"
- "io"
- "io/ioutil"
- "sync"
-)
-
-type Signal string
-
-// POSIX signals as listed in RFC 4254 Section 6.10.
-const (
- SIGABRT Signal = "ABRT"
- SIGALRM Signal = "ALRM"
- SIGFPE Signal = "FPE"
- SIGHUP Signal = "HUP"
- SIGILL Signal = "ILL"
- SIGINT Signal = "INT"
- SIGKILL Signal = "KILL"
- SIGPIPE Signal = "PIPE"
- SIGQUIT Signal = "QUIT"
- SIGSEGV Signal = "SEGV"
- SIGTERM Signal = "TERM"
- SIGUSR1 Signal = "USR1"
- SIGUSR2 Signal = "USR2"
-)
-
-var signals = map[Signal]int{
- SIGABRT: 6,
- SIGALRM: 14,
- SIGFPE: 8,
- SIGHUP: 1,
- SIGILL: 4,
- SIGINT: 2,
- SIGKILL: 9,
- SIGPIPE: 13,
- SIGQUIT: 3,
- SIGSEGV: 11,
- SIGTERM: 15,
-}
-
-type TerminalModes map[uint8]uint32
-
-// POSIX terminal mode flags as listed in RFC 4254 Section 8.
-const (
- tty_OP_END = 0
- VINTR = 1
- VQUIT = 2
- VERASE = 3
- VKILL = 4
- VEOF = 5
- VEOL = 6
- VEOL2 = 7
- VSTART = 8
- VSTOP = 9
- VSUSP = 10
- VDSUSP = 11
- VREPRINT = 12
- VWERASE = 13
- VLNEXT = 14
- VFLUSH = 15
- VSWTCH = 16
- VSTATUS = 17
- VDISCARD = 18
- IGNPAR = 30
- PARMRK = 31
- INPCK = 32
- ISTRIP = 33
- INLCR = 34
- IGNCR = 35
- ICRNL = 36
- IUCLC = 37
- IXON = 38
- IXANY = 39
- IXOFF = 40
- IMAXBEL = 41
- ISIG = 50
- ICANON = 51
- XCASE = 52
- ECHO = 53
- ECHOE = 54
- ECHOK = 55
- ECHONL = 56
- NOFLSH = 57
- TOSTOP = 58
- IEXTEN = 59
- ECHOCTL = 60
- ECHOKE = 61
- PENDIN = 62
- OPOST = 70
- OLCUC = 71
- ONLCR = 72
- OCRNL = 73
- ONOCR = 74
- ONLRET = 75
- CS7 = 90
- CS8 = 91
- PARENB = 92
- PARODD = 93
- TTY_OP_ISPEED = 128
- TTY_OP_OSPEED = 129
-)
-
-// A Session represents a connection to a remote command or shell.
-type Session struct {
- // Stdin specifies the remote process's standard input.
- // If Stdin is nil, the remote process reads from an empty
- // bytes.Buffer.
- Stdin io.Reader
-
- // Stdout and Stderr specify the remote process's standard
- // output and error.
- //
- // If either is nil, Run connects the corresponding file
- // descriptor to an instance of ioutil.Discard. There is a
- // fixed amount of buffering that is shared for the two streams.
- // If either blocks it may eventually cause the remote
- // command to block.
- Stdout io.Writer
- Stderr io.Writer
-
- ch Channel // the channel backing this session
- started bool // true once Start, Run or Shell is invoked.
- copyFuncs []func() error
- errors chan error // one send per copyFunc
-
- // true if pipe method is active
- stdinpipe, stdoutpipe, stderrpipe bool
-
- // stdinPipeWriter is non-nil if StdinPipe has not been called
- // and Stdin was specified by the user; it is the write end of
- // a pipe connecting Session.Stdin to the stdin channel.
- stdinPipeWriter io.WriteCloser
-
- exitStatus chan error
-}
-
-// SendRequest sends an out-of-band channel request on the SSH channel
-// underlying the session.
-func (s *Session) SendRequest(name string, wantReply bool, payload []byte) (bool, error) {
- return s.ch.SendRequest(name, wantReply, payload)
-}
-
-func (s *Session) Close() error {
- return s.ch.Close()
-}
-
-// RFC 4254 Section 6.4.
-type setenvRequest struct {
- Name string
- Value string
-}
-
-// Setenv sets an environment variable that will be applied to any
-// command executed by Shell or Run.
-func (s *Session) Setenv(name, value string) error {
- msg := setenvRequest{
- Name: name,
- Value: value,
- }
- ok, err := s.ch.SendRequest("env", true, Marshal(&msg))
- if err == nil && !ok {
- err = errors.New("ssh: setenv failed")
- }
- return err
-}
-
-// RFC 4254 Section 6.2.
-type ptyRequestMsg struct {
- Term string
- Columns uint32
- Rows uint32
- Width uint32
- Height uint32
- Modelist string
-}
-
-// RequestPty requests the association of a pty with the session on the remote host.
-func (s *Session) RequestPty(term string, h, w int, termmodes TerminalModes) error {
- var tm []byte
- for k, v := range termmodes {
- kv := struct {
- Key byte
- Val uint32
- }{k, v}
-
- tm = append(tm, Marshal(&kv)...)
- }
- tm = append(tm, tty_OP_END)
- req := ptyRequestMsg{
- Term: term,
- Columns: uint32(w),
- Rows: uint32(h),
- Width: uint32(w * 8),
- Height: uint32(h * 8),
- Modelist: string(tm),
- }
- ok, err := s.ch.SendRequest("pty-req", true, Marshal(&req))
- if err == nil && !ok {
- err = errors.New("ssh: pty-req failed")
- }
- return err
-}
-
-// RFC 4254 Section 6.5.
-type subsystemRequestMsg struct {
- Subsystem string
-}
-
-// RequestSubsystem requests the association of a subsystem with the session on the remote host.
-// A subsystem is a predefined command that runs in the background when the ssh session is initiated
-func (s *Session) RequestSubsystem(subsystem string) error {
- msg := subsystemRequestMsg{
- Subsystem: subsystem,
- }
- ok, err := s.ch.SendRequest("subsystem", true, Marshal(&msg))
- if err == nil && !ok {
- err = errors.New("ssh: subsystem request failed")
- }
- return err
-}
-
-// RFC 4254 Section 6.9.
-type signalMsg struct {
- Signal string
-}
-
-// Signal sends the given signal to the remote process.
-// sig is one of the SIG* constants.
-func (s *Session) Signal(sig Signal) error {
- msg := signalMsg{
- Signal: string(sig),
- }
-
- _, err := s.ch.SendRequest("signal", false, Marshal(&msg))
- return err
-}
-
-// RFC 4254 Section 6.5.
-type execMsg struct {
- Command string
-}
-
-// Start runs cmd on the remote host. Typically, the remote
-// server passes cmd to the shell for interpretation.
-// A Session only accepts one call to Run, Start or Shell.
-func (s *Session) Start(cmd string) error {
- if s.started {
- return errors.New("ssh: session already started")
- }
- req := execMsg{
- Command: cmd,
- }
-
- ok, err := s.ch.SendRequest("exec", true, Marshal(&req))
- if err == nil && !ok {
- err = fmt.Errorf("ssh: command %v failed", cmd)
- }
- if err != nil {
- return err
- }
- return s.start()
-}
-
-// Run runs cmd on the remote host. Typically, the remote
-// server passes cmd to the shell for interpretation.
-// A Session only accepts one call to Run, Start, Shell, Output,
-// or CombinedOutput.
-//
-// The returned error is nil if the command runs, has no problems
-// copying stdin, stdout, and stderr, and exits with a zero exit
-// status.
-//
-// If the remote server does not send an exit status, an error of type
-// *ExitMissingError is returned. If the command completes
-// unsuccessfully or is interrupted by a signal, the error is of type
-// *ExitError. Other error types may be returned for I/O problems.
-func (s *Session) Run(cmd string) error {
- err := s.Start(cmd)
- if err != nil {
- return err
- }
- return s.Wait()
-}
-
-// Output runs cmd on the remote host and returns its standard output.
-func (s *Session) Output(cmd string) ([]byte, error) {
- if s.Stdout != nil {
- return nil, errors.New("ssh: Stdout already set")
- }
- var b bytes.Buffer
- s.Stdout = &b
- err := s.Run(cmd)
- return b.Bytes(), err
-}
-
-type singleWriter struct {
- b bytes.Buffer
- mu sync.Mutex
-}
-
-func (w *singleWriter) Write(p []byte) (int, error) {
- w.mu.Lock()
- defer w.mu.Unlock()
- return w.b.Write(p)
-}
-
-// CombinedOutput runs cmd on the remote host and returns its combined
-// standard output and standard error.
-func (s *Session) CombinedOutput(cmd string) ([]byte, error) {
- if s.Stdout != nil {
- return nil, errors.New("ssh: Stdout already set")
- }
- if s.Stderr != nil {
- return nil, errors.New("ssh: Stderr already set")
- }
- var b singleWriter
- s.Stdout = &b
- s.Stderr = &b
- err := s.Run(cmd)
- return b.b.Bytes(), err
-}
-
-// Shell starts a login shell on the remote host. A Session only
-// accepts one call to Run, Start, Shell, Output, or CombinedOutput.
-func (s *Session) Shell() error {
- if s.started {
- return errors.New("ssh: session already started")
- }
-
- ok, err := s.ch.SendRequest("shell", true, nil)
- if err == nil && !ok {
- return errors.New("ssh: could not start shell")
- }
- if err != nil {
- return err
- }
- return s.start()
-}
-
-func (s *Session) start() error {
- s.started = true
-
- type F func(*Session)
- for _, setupFd := range []F{(*Session).stdin, (*Session).stdout, (*Session).stderr} {
- setupFd(s)
- }
-
- s.errors = make(chan error, len(s.copyFuncs))
- for _, fn := range s.copyFuncs {
- go func(fn func() error) {
- s.errors <- fn()
- }(fn)
- }
- return nil
-}
-
-// Wait waits for the remote command to exit.
-//
-// The returned error is nil if the command runs, has no problems
-// copying stdin, stdout, and stderr, and exits with a zero exit
-// status.
-//
-// If the remote server does not send an exit status, an error of type
-// *ExitMissingError is returned. If the command completes
-// unsuccessfully or is interrupted by a signal, the error is of type
-// *ExitError. Other error types may be returned for I/O problems.
-func (s *Session) Wait() error {
- if !s.started {
- return errors.New("ssh: session not started")
- }
- waitErr := <-s.exitStatus
-
- if s.stdinPipeWriter != nil {
- s.stdinPipeWriter.Close()
- }
- var copyError error
- for _ = range s.copyFuncs {
- if err := <-s.errors; err != nil && copyError == nil {
- copyError = err
- }
- }
- if waitErr != nil {
- return waitErr
- }
- return copyError
-}
-
-func (s *Session) wait(reqs <-chan *Request) error {
- wm := Waitmsg{status: -1}
- // Wait for msg channel to be closed before returning.
- for msg := range reqs {
- switch msg.Type {
- case "exit-status":
- wm.status = int(binary.BigEndian.Uint32(msg.Payload))
- case "exit-signal":
- var sigval struct {
- Signal string
- CoreDumped bool
- Error string
- Lang string
- }
- if err := Unmarshal(msg.Payload, &sigval); err != nil {
- return err
- }
-
- // Must sanitize strings?
- wm.signal = sigval.Signal
- wm.msg = sigval.Error
- wm.lang = sigval.Lang
- default:
- // This handles keepalives and matches
- // OpenSSH's behaviour.
- if msg.WantReply {
- msg.Reply(false, nil)
- }
- }
- }
- if wm.status == 0 {
- return nil
- }
- if wm.status == -1 {
- // exit-status was never sent from server
- if wm.signal == "" {
- // signal was not sent either. RFC 4254
- // section 6.10 recommends against this
- // behavior, but it is allowed, so we let
- // clients handle it.
- return &ExitMissingError{}
- }
- wm.status = 128
- if _, ok := signals[Signal(wm.signal)]; ok {
- wm.status += signals[Signal(wm.signal)]
- }
- }
-
- return &ExitError{wm}
-}
-
-// ExitMissingError is returned if a session is torn down cleanly, but
-// the server sends no confirmation of the exit status.
-type ExitMissingError struct{}
-
-func (e *ExitMissingError) Error() string {
- return "wait: remote command exited without exit status or exit signal"
-}
-
-func (s *Session) stdin() {
- if s.stdinpipe {
- return
- }
- var stdin io.Reader
- if s.Stdin == nil {
- stdin = new(bytes.Buffer)
- } else {
- r, w := io.Pipe()
- go func() {
- _, err := io.Copy(w, s.Stdin)
- w.CloseWithError(err)
- }()
- stdin, s.stdinPipeWriter = r, w
- }
- s.copyFuncs = append(s.copyFuncs, func() error {
- _, err := io.Copy(s.ch, stdin)
- if err1 := s.ch.CloseWrite(); err == nil && err1 != io.EOF {
- err = err1
- }
- return err
- })
-}
-
-func (s *Session) stdout() {
- if s.stdoutpipe {
- return
- }
- if s.Stdout == nil {
- s.Stdout = ioutil.Discard
- }
- s.copyFuncs = append(s.copyFuncs, func() error {
- _, err := io.Copy(s.Stdout, s.ch)
- return err
- })
-}
-
-func (s *Session) stderr() {
- if s.stderrpipe {
- return
- }
- if s.Stderr == nil {
- s.Stderr = ioutil.Discard
- }
- s.copyFuncs = append(s.copyFuncs, func() error {
- _, err := io.Copy(s.Stderr, s.ch.Stderr())
- return err
- })
-}
-
-// sessionStdin reroutes Close to CloseWrite.
-type sessionStdin struct {
- io.Writer
- ch Channel
-}
-
-func (s *sessionStdin) Close() error {
- return s.ch.CloseWrite()
-}
-
-// StdinPipe returns a pipe that will be connected to the
-// remote command's standard input when the command starts.
-func (s *Session) StdinPipe() (io.WriteCloser, error) {
- if s.Stdin != nil {
- return nil, errors.New("ssh: Stdin already set")
- }
- if s.started {
- return nil, errors.New("ssh: StdinPipe after process started")
- }
- s.stdinpipe = true
- return &sessionStdin{s.ch, s.ch}, nil
-}
-
-// StdoutPipe returns a pipe that will be connected to the
-// remote command's standard output when the command starts.
-// There is a fixed amount of buffering that is shared between
-// stdout and stderr streams. If the StdoutPipe reader is
-// not serviced fast enough it may eventually cause the
-// remote command to block.
-func (s *Session) StdoutPipe() (io.Reader, error) {
- if s.Stdout != nil {
- return nil, errors.New("ssh: Stdout already set")
- }
- if s.started {
- return nil, errors.New("ssh: StdoutPipe after process started")
- }
- s.stdoutpipe = true
- return s.ch, nil
-}
-
-// StderrPipe returns a pipe that will be connected to the
-// remote command's standard error when the command starts.
-// There is a fixed amount of buffering that is shared between
-// stdout and stderr streams. If the StderrPipe reader is
-// not serviced fast enough it may eventually cause the
-// remote command to block.
-func (s *Session) StderrPipe() (io.Reader, error) {
- if s.Stderr != nil {
- return nil, errors.New("ssh: Stderr already set")
- }
- if s.started {
- return nil, errors.New("ssh: StderrPipe after process started")
- }
- s.stderrpipe = true
- return s.ch.Stderr(), nil
-}
-
-// newSession returns a new interactive session on the remote host.
-func newSession(ch Channel, reqs <-chan *Request) (*Session, error) {
- s := &Session{
- ch: ch,
- }
- s.exitStatus = make(chan error, 1)
- go func() {
- s.exitStatus <- s.wait(reqs)
- }()
-
- return s, nil
-}
-
-// An ExitError reports unsuccessful completion of a remote command.
-type ExitError struct {
- Waitmsg
-}
-
-func (e *ExitError) Error() string {
- return e.Waitmsg.String()
-}
-
-// Waitmsg stores the information about an exited remote command
-// as reported by Wait.
-type Waitmsg struct {
- status int
- signal string
- msg string
- lang string
-}
-
-// ExitStatus returns the exit status of the remote command.
-func (w Waitmsg) ExitStatus() int {
- return w.status
-}
-
-// Signal returns the exit signal of the remote command if
-// it was terminated violently.
-func (w Waitmsg) Signal() string {
- return w.signal
-}
-
-// Msg returns the exit message given by the remote command
-func (w Waitmsg) Msg() string {
- return w.msg
-}
-
-// Lang returns the language tag. See RFC 3066
-func (w Waitmsg) Lang() string {
- return w.lang
-}
-
-func (w Waitmsg) String() string {
- str := fmt.Sprintf("Process exited with status %v", w.status)
- if w.signal != "" {
- str += fmt.Sprintf(" from signal %v", w.signal)
- }
- if w.msg != "" {
- str += fmt.Sprintf(". Reason was: %v", w.msg)
- }
- return str
-}
diff --git a/vendor/golang.org/x/crypto/ssh/tcpip.go b/vendor/golang.org/x/crypto/ssh/tcpip.go
deleted file mode 100644
index 6151241ff08e3fd4d5b9ad6c66159ba044ced239..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/tcpip.go
+++ /dev/null
@@ -1,407 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "errors"
- "fmt"
- "io"
- "math/rand"
- "net"
- "strconv"
- "strings"
- "sync"
- "time"
-)
-
-// Listen requests the remote peer open a listening socket on
-// addr. Incoming connections will be available by calling Accept on
-// the returned net.Listener. The listener must be serviced, or the
-// SSH connection may hang.
-func (c *Client) Listen(n, addr string) (net.Listener, error) {
- laddr, err := net.ResolveTCPAddr(n, addr)
- if err != nil {
- return nil, err
- }
- return c.ListenTCP(laddr)
-}
-
-// Automatic port allocation is broken with OpenSSH before 6.0. See
-// also https://bugzilla.mindrot.org/show_bug.cgi?id=2017. In
-// particular, OpenSSH 5.9 sends a channelOpenMsg with port number 0,
-// rather than the actual port number. This means you can never open
-// two different listeners with auto allocated ports. We work around
-// this by trying explicit ports until we succeed.
-
-const openSSHPrefix = "OpenSSH_"
-
-var portRandomizer = rand.New(rand.NewSource(time.Now().UnixNano()))
-
-// isBrokenOpenSSHVersion returns true if the given version string
-// specifies a version of OpenSSH that is known to have a bug in port
-// forwarding.
-func isBrokenOpenSSHVersion(versionStr string) bool {
- i := strings.Index(versionStr, openSSHPrefix)
- if i < 0 {
- return false
- }
- i += len(openSSHPrefix)
- j := i
- for ; j < len(versionStr); j++ {
- if versionStr[j] < '0' || versionStr[j] > '9' {
- break
- }
- }
- version, _ := strconv.Atoi(versionStr[i:j])
- return version < 6
-}
-
-// autoPortListenWorkaround simulates automatic port allocation by
-// trying random ports repeatedly.
-func (c *Client) autoPortListenWorkaround(laddr *net.TCPAddr) (net.Listener, error) {
- var sshListener net.Listener
- var err error
- const tries = 10
- for i := 0; i < tries; i++ {
- addr := *laddr
- addr.Port = 1024 + portRandomizer.Intn(60000)
- sshListener, err = c.ListenTCP(&addr)
- if err == nil {
- laddr.Port = addr.Port
- return sshListener, err
- }
- }
- return nil, fmt.Errorf("ssh: listen on random port failed after %d tries: %v", tries, err)
-}
-
-// RFC 4254 7.1
-type channelForwardMsg struct {
- addr string
- rport uint32
-}
-
-// ListenTCP requests the remote peer open a listening socket
-// on laddr. Incoming connections will be available by calling
-// Accept on the returned net.Listener.
-func (c *Client) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) {
- if laddr.Port == 0 && isBrokenOpenSSHVersion(string(c.ServerVersion())) {
- return c.autoPortListenWorkaround(laddr)
- }
-
- m := channelForwardMsg{
- laddr.IP.String(),
- uint32(laddr.Port),
- }
- // send message
- ok, resp, err := c.SendRequest("tcpip-forward", true, Marshal(&m))
- if err != nil {
- return nil, err
- }
- if !ok {
- return nil, errors.New("ssh: tcpip-forward request denied by peer")
- }
-
- // If the original port was 0, then the remote side will
- // supply a real port number in the response.
- if laddr.Port == 0 {
- var p struct {
- Port uint32
- }
- if err := Unmarshal(resp, &p); err != nil {
- return nil, err
- }
- laddr.Port = int(p.Port)
- }
-
- // Register this forward, using the port number we obtained.
- ch := c.forwards.add(*laddr)
-
- return &tcpListener{laddr, c, ch}, nil
-}
-
-// forwardList stores a mapping between remote
-// forward requests and the tcpListeners.
-type forwardList struct {
- sync.Mutex
- entries []forwardEntry
-}
-
-// forwardEntry represents an established mapping of a laddr on a
-// remote ssh server to a channel connected to a tcpListener.
-type forwardEntry struct {
- laddr net.TCPAddr
- c chan forward
-}
-
-// forward represents an incoming forwarded tcpip connection. The
-// arguments to add/remove/lookup should be address as specified in
-// the original forward-request.
-type forward struct {
- newCh NewChannel // the ssh client channel underlying this forward
- raddr *net.TCPAddr // the raddr of the incoming connection
-}
-
-func (l *forwardList) add(addr net.TCPAddr) chan forward {
- l.Lock()
- defer l.Unlock()
- f := forwardEntry{
- addr,
- make(chan forward, 1),
- }
- l.entries = append(l.entries, f)
- return f.c
-}
-
-// See RFC 4254, section 7.2
-type forwardedTCPPayload struct {
- Addr string
- Port uint32
- OriginAddr string
- OriginPort uint32
-}
-
-// parseTCPAddr parses the originating address from the remote into a *net.TCPAddr.
-func parseTCPAddr(addr string, port uint32) (*net.TCPAddr, error) {
- if port == 0 || port > 65535 {
- return nil, fmt.Errorf("ssh: port number out of range: %d", port)
- }
- ip := net.ParseIP(string(addr))
- if ip == nil {
- return nil, fmt.Errorf("ssh: cannot parse IP address %q", addr)
- }
- return &net.TCPAddr{IP: ip, Port: int(port)}, nil
-}
-
-func (l *forwardList) handleChannels(in <-chan NewChannel) {
- for ch := range in {
- var payload forwardedTCPPayload
- if err := Unmarshal(ch.ExtraData(), &payload); err != nil {
- ch.Reject(ConnectionFailed, "could not parse forwarded-tcpip payload: "+err.Error())
- continue
- }
-
- // RFC 4254 section 7.2 specifies that incoming
- // addresses should list the address, in string
- // format. It is implied that this should be an IP
- // address, as it would be impossible to connect to it
- // otherwise.
- laddr, err := parseTCPAddr(payload.Addr, payload.Port)
- if err != nil {
- ch.Reject(ConnectionFailed, err.Error())
- continue
- }
- raddr, err := parseTCPAddr(payload.OriginAddr, payload.OriginPort)
- if err != nil {
- ch.Reject(ConnectionFailed, err.Error())
- continue
- }
-
- if ok := l.forward(*laddr, *raddr, ch); !ok {
- // Section 7.2, implementations MUST reject spurious incoming
- // connections.
- ch.Reject(Prohibited, "no forward for address")
- continue
- }
- }
-}
-
-// remove removes the forward entry, and the channel feeding its
-// listener.
-func (l *forwardList) remove(addr net.TCPAddr) {
- l.Lock()
- defer l.Unlock()
- for i, f := range l.entries {
- if addr.IP.Equal(f.laddr.IP) && addr.Port == f.laddr.Port {
- l.entries = append(l.entries[:i], l.entries[i+1:]...)
- close(f.c)
- return
- }
- }
-}
-
-// closeAll closes and clears all forwards.
-func (l *forwardList) closeAll() {
- l.Lock()
- defer l.Unlock()
- for _, f := range l.entries {
- close(f.c)
- }
- l.entries = nil
-}
-
-func (l *forwardList) forward(laddr, raddr net.TCPAddr, ch NewChannel) bool {
- l.Lock()
- defer l.Unlock()
- for _, f := range l.entries {
- if laddr.IP.Equal(f.laddr.IP) && laddr.Port == f.laddr.Port {
- f.c <- forward{ch, &raddr}
- return true
- }
- }
- return false
-}
-
-type tcpListener struct {
- laddr *net.TCPAddr
-
- conn *Client
- in <-chan forward
-}
-
-// Accept waits for and returns the next connection to the listener.
-func (l *tcpListener) Accept() (net.Conn, error) {
- s, ok := <-l.in
- if !ok {
- return nil, io.EOF
- }
- ch, incoming, err := s.newCh.Accept()
- if err != nil {
- return nil, err
- }
- go DiscardRequests(incoming)
-
- return &tcpChanConn{
- Channel: ch,
- laddr: l.laddr,
- raddr: s.raddr,
- }, nil
-}
-
-// Close closes the listener.
-func (l *tcpListener) Close() error {
- m := channelForwardMsg{
- l.laddr.IP.String(),
- uint32(l.laddr.Port),
- }
-
- // this also closes the listener.
- l.conn.forwards.remove(*l.laddr)
- ok, _, err := l.conn.SendRequest("cancel-tcpip-forward", true, Marshal(&m))
- if err == nil && !ok {
- err = errors.New("ssh: cancel-tcpip-forward failed")
- }
- return err
-}
-
-// Addr returns the listener's network address.
-func (l *tcpListener) Addr() net.Addr {
- return l.laddr
-}
-
-// Dial initiates a connection to the addr from the remote host.
-// The resulting connection has a zero LocalAddr() and RemoteAddr().
-func (c *Client) Dial(n, addr string) (net.Conn, error) {
- // Parse the address into host and numeric port.
- host, portString, err := net.SplitHostPort(addr)
- if err != nil {
- return nil, err
- }
- port, err := strconv.ParseUint(portString, 10, 16)
- if err != nil {
- return nil, err
- }
- // Use a zero address for local and remote address.
- zeroAddr := &net.TCPAddr{
- IP: net.IPv4zero,
- Port: 0,
- }
- ch, err := c.dial(net.IPv4zero.String(), 0, host, int(port))
- if err != nil {
- return nil, err
- }
- return &tcpChanConn{
- Channel: ch,
- laddr: zeroAddr,
- raddr: zeroAddr,
- }, nil
-}
-
-// DialTCP connects to the remote address raddr on the network net,
-// which must be "tcp", "tcp4", or "tcp6". If laddr is not nil, it is used
-// as the local address for the connection.
-func (c *Client) DialTCP(n string, laddr, raddr *net.TCPAddr) (net.Conn, error) {
- if laddr == nil {
- laddr = &net.TCPAddr{
- IP: net.IPv4zero,
- Port: 0,
- }
- }
- ch, err := c.dial(laddr.IP.String(), laddr.Port, raddr.IP.String(), raddr.Port)
- if err != nil {
- return nil, err
- }
- return &tcpChanConn{
- Channel: ch,
- laddr: laddr,
- raddr: raddr,
- }, nil
-}
-
-// RFC 4254 7.2
-type channelOpenDirectMsg struct {
- raddr string
- rport uint32
- laddr string
- lport uint32
-}
-
-func (c *Client) dial(laddr string, lport int, raddr string, rport int) (Channel, error) {
- msg := channelOpenDirectMsg{
- raddr: raddr,
- rport: uint32(rport),
- laddr: laddr,
- lport: uint32(lport),
- }
- ch, in, err := c.OpenChannel("direct-tcpip", Marshal(&msg))
- if err != nil {
- return nil, err
- }
- go DiscardRequests(in)
- return ch, err
-}
-
-type tcpChan struct {
- Channel // the backing channel
-}
-
-// tcpChanConn fulfills the net.Conn interface without
-// the tcpChan having to hold laddr or raddr directly.
-type tcpChanConn struct {
- Channel
- laddr, raddr net.Addr
-}
-
-// LocalAddr returns the local network address.
-func (t *tcpChanConn) LocalAddr() net.Addr {
- return t.laddr
-}
-
-// RemoteAddr returns the remote network address.
-func (t *tcpChanConn) RemoteAddr() net.Addr {
- return t.raddr
-}
-
-// SetDeadline sets the read and write deadlines associated
-// with the connection.
-func (t *tcpChanConn) SetDeadline(deadline time.Time) error {
- if err := t.SetReadDeadline(deadline); err != nil {
- return err
- }
- return t.SetWriteDeadline(deadline)
-}
-
-// SetReadDeadline sets the read deadline.
-// A zero value for t means Read will not time out.
-// After the deadline, the error from Read will implement net.Error
-// with Timeout() == true.
-func (t *tcpChanConn) SetReadDeadline(deadline time.Time) error {
- return errors.New("ssh: tcpChan: deadline not supported")
-}
-
-// SetWriteDeadline exists to satisfy the net.Conn interface
-// but is not implemented by this type. It always returns an error.
-func (t *tcpChanConn) SetWriteDeadline(deadline time.Time) error {
- return errors.New("ssh: tcpChan: deadline not supported")
-}
diff --git a/vendor/golang.org/x/crypto/ssh/transport.go b/vendor/golang.org/x/crypto/ssh/transport.go
deleted file mode 100644
index f9780e0ae702d155b18a5e305a4dd149c1aa2c72..0000000000000000000000000000000000000000
--- a/vendor/golang.org/x/crypto/ssh/transport.go
+++ /dev/null
@@ -1,375 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package ssh
-
-import (
- "bufio"
- "errors"
- "io"
- "log"
-)
-
-// debugTransport if set, will print packet types as they go over the
-// wire. No message decoding is done, to minimize the impact on timing.
-const debugTransport = false
-
-const (
- gcmCipherID = "aes128-gcm@openssh.com"
- aes128cbcID = "aes128-cbc"
- tripledescbcID = "3des-cbc"
-)
-
-// packetConn represents a transport that implements packet based
-// operations.
-type packetConn interface {
- // Encrypt and send a packet of data to the remote peer.
- writePacket(packet []byte) error
-
- // Read a packet from the connection. The read is blocking,
- // i.e. if error is nil, then the returned byte slice is
- // always non-empty.
- readPacket() ([]byte, error)
-
- // Close closes the write-side of the connection.
- Close() error
-}
-
-// transport is the keyingTransport that implements the SSH packet
-// protocol.
-type transport struct {
- reader connectionState
- writer connectionState
-
- bufReader *bufio.Reader
- bufWriter *bufio.Writer
- rand io.Reader
- isClient bool
- io.Closer
-}
-
-// packetCipher represents a combination of SSH encryption/MAC
-// protocol. A single instance should be used for one direction only.
-type packetCipher interface {
- // writePacket encrypts the packet and writes it to w. The
- // contents of the packet are generally scrambled.
- writePacket(seqnum uint32, w io.Writer, rand io.Reader, packet []byte) error
-
- // readPacket reads and decrypts a packet of data. The
- // returned packet may be overwritten by future calls of
- // readPacket.
- readPacket(seqnum uint32, r io.Reader) ([]byte, error)
-}
-
-// connectionState represents one side (read or write) of the
-// connection. This is necessary because each direction has its own
-// keys, and can even have its own algorithms
-type connectionState struct {
- packetCipher
- seqNum uint32
- dir direction
- pendingKeyChange chan packetCipher
-}
-
-// prepareKeyChange sets up key material for a keychange. The key changes in
-// both directions are triggered by reading and writing a msgNewKey packet
-// respectively.
-func (t *transport) prepareKeyChange(algs *algorithms, kexResult *kexResult) error {
- if ciph, err := newPacketCipher(t.reader.dir, algs.r, kexResult); err != nil {
- return err
- } else {
- t.reader.pendingKeyChange <- ciph
- }
-
- if ciph, err := newPacketCipher(t.writer.dir, algs.w, kexResult); err != nil {
- return err
- } else {
- t.writer.pendingKeyChange <- ciph
- }
-
- return nil
-}
-
-func (t *transport) printPacket(p []byte, write bool) {
- if len(p) == 0 {
- return
- }
- who := "server"
- if t.isClient {
- who = "client"
- }
- what := "read"
- if write {
- what = "write"
- }
-
- log.Println(what, who, p[0])
-}
-
-// Read and decrypt next packet.
-func (t *transport) readPacket() (p []byte, err error) {
- for {
- p, err = t.reader.readPacket(t.bufReader)
- if err != nil {
- break
- }
- if len(p) == 0 || (p[0] != msgIgnore && p[0] != msgDebug) {
- break
- }
- }
- if debugTransport {
- t.printPacket(p, false)
- }
-
- return p, err
-}
-
-func (s *connectionState) readPacket(r *bufio.Reader) ([]byte, error) {
- packet, err := s.packetCipher.readPacket(s.seqNum, r)
- s.seqNum++
- if err == nil && len(packet) == 0 {
- err = errors.New("ssh: zero length packet")
- }
-
- if len(packet) > 0 {
- switch packet[0] {
- case msgNewKeys:
- select {
- case cipher := <-s.pendingKeyChange:
- s.packetCipher = cipher
- default:
- return nil, errors.New("ssh: got bogus newkeys message.")
- }
-
- case msgDisconnect:
- // Transform a disconnect message into an
- // error. Since this is lowest level at which
- // we interpret message types, doing it here
- // ensures that we don't have to handle it
- // elsewhere.
- var msg disconnectMsg
- if err := Unmarshal(packet, &msg); err != nil {
- return nil, err
- }
- return nil, &msg
- }
- }
-
- // The packet may point to an internal buffer, so copy the
- // packet out here.
- fresh := make([]byte, len(packet))
- copy(fresh, packet)
-
- return fresh, err
-}
-
-func (t *transport) writePacket(packet []byte) error {
- if debugTransport {
- t.printPacket(packet, true)
- }
- return t.writer.writePacket(t.bufWriter, t.rand, packet)
-}
-
-func (s *connectionState) writePacket(w *bufio.Writer, rand io.Reader, packet []byte) error {
- changeKeys := len(packet) > 0 && packet[0] == msgNewKeys
-
- err := s.packetCipher.writePacket(s.seqNum, w, rand, packet)
- if err != nil {
- return err
- }
- if err = w.Flush(); err != nil {
- return err
- }
- s.seqNum++
- if changeKeys {
- select {
- case cipher := <-s.pendingKeyChange:
- s.packetCipher = cipher
- default:
- panic("ssh: no key material for msgNewKeys")
- }
- }
- return err
-}
-
-func newTransport(rwc io.ReadWriteCloser, rand io.Reader, isClient bool) *transport {
- t := &transport{
- bufReader: bufio.NewReader(rwc),
- bufWriter: bufio.NewWriter(rwc),
- rand: rand,
- reader: connectionState{
- packetCipher: &streamPacketCipher{cipher: noneCipher{}},
- pendingKeyChange: make(chan packetCipher, 1),
- },
- writer: connectionState{
- packetCipher: &streamPacketCipher{cipher: noneCipher{}},
- pendingKeyChange: make(chan packetCipher, 1),
- },
- Closer: rwc,
- }
- t.isClient = isClient
-
- if isClient {
- t.reader.dir = serverKeys
- t.writer.dir = clientKeys
- } else {
- t.reader.dir = clientKeys
- t.writer.dir = serverKeys
- }
-
- return t
-}
-
-type direction struct {
- ivTag []byte
- keyTag []byte
- macKeyTag []byte
-}
-
-var (
- serverKeys = direction{[]byte{'B'}, []byte{'D'}, []byte{'F'}}
- clientKeys = direction{[]byte{'A'}, []byte{'C'}, []byte{'E'}}
-)
-
-// generateKeys generates key material for IV, MAC and encryption.
-func generateKeys(d direction, algs directionAlgorithms, kex *kexResult) (iv, key, macKey []byte) {
- cipherMode := cipherModes[algs.Cipher]
- macMode := macModes[algs.MAC]
-
- iv = make([]byte, cipherMode.ivSize)
- key = make([]byte, cipherMode.keySize)
- macKey = make([]byte, macMode.keySize)
-
- generateKeyMaterial(iv, d.ivTag, kex)
- generateKeyMaterial(key, d.keyTag, kex)
- generateKeyMaterial(macKey, d.macKeyTag, kex)
- return
-}
-
-// setupKeys sets the cipher and MAC keys from kex.K, kex.H and sessionId, as
-// described in RFC 4253, section 6.4. direction should either be serverKeys
-// (to setup server->client keys) or clientKeys (for client->server keys).
-func newPacketCipher(d direction, algs directionAlgorithms, kex *kexResult) (packetCipher, error) {
- iv, key, macKey := generateKeys(d, algs, kex)
-
- if algs.Cipher == gcmCipherID {
- return newGCMCipher(iv, key, macKey)
- }
-
- if algs.Cipher == aes128cbcID {
- return newAESCBCCipher(iv, key, macKey, algs)
- }
-
- if algs.Cipher == tripledescbcID {
- return newTripleDESCBCCipher(iv, key, macKey, algs)
- }
-
- c := &streamPacketCipher{
- mac: macModes[algs.MAC].new(macKey),
- etm: macModes[algs.MAC].etm,
- }
- c.macResult = make([]byte, c.mac.Size())
-
- var err error
- c.cipher, err = cipherModes[algs.Cipher].createStream(key, iv)
- if err != nil {
- return nil, err
- }
-
- return c, nil
-}
-
-// generateKeyMaterial fills out with key material generated from tag, K, H
-// and sessionId, as specified in RFC 4253, section 7.2.
-func generateKeyMaterial(out, tag []byte, r *kexResult) {
- var digestsSoFar []byte
-
- h := r.Hash.New()
- for len(out) > 0 {
- h.Reset()
- h.Write(r.K)
- h.Write(r.H)
-
- if len(digestsSoFar) == 0 {
- h.Write(tag)
- h.Write(r.SessionID)
- } else {
- h.Write(digestsSoFar)
- }
-
- digest := h.Sum(nil)
- n := copy(out, digest)
- out = out[n:]
- if len(out) > 0 {
- digestsSoFar = append(digestsSoFar, digest...)
- }
- }
-}
-
-const packageVersion = "SSH-2.0-Go"
-
-// Sends and receives a version line. The versionLine string should
-// be US ASCII, start with "SSH-2.0-", and should not include a
-// newline. exchangeVersions returns the other side's version line.
-func exchangeVersions(rw io.ReadWriter, versionLine []byte) (them []byte, err error) {
- // Contrary to the RFC, we do not ignore lines that don't
- // start with "SSH-2.0-" to make the library usable with
- // nonconforming servers.
- for _, c := range versionLine {
- // The spec disallows non US-ASCII chars, and
- // specifically forbids null chars.
- if c < 32 {
- return nil, errors.New("ssh: junk character in version line")
- }
- }
- if _, err = rw.Write(append(versionLine, '\r', '\n')); err != nil {
- return
- }
-
- them, err = readVersion(rw)
- return them, err
-}
-
-// maxVersionStringBytes is the maximum number of bytes that we'll
-// accept as a version string. RFC 4253 section 4.2 limits this at 255
-// chars
-const maxVersionStringBytes = 255
-
-// Read version string as specified by RFC 4253, section 4.2.
-func readVersion(r io.Reader) ([]byte, error) {
- versionString := make([]byte, 0, 64)
- var ok bool
- var buf [1]byte
-
- for len(versionString) < maxVersionStringBytes {
- _, err := io.ReadFull(r, buf[:])
- if err != nil {
- return nil, err
- }
- // The RFC says that the version should be terminated with \r\n
- // but several SSH servers actually only send a \n.
- if buf[0] == '\n' {
- ok = true
- break
- }
-
- // non ASCII chars are disallowed, but we are lenient,
- // since Go doesn't use null-terminated strings.
-
- // The RFC allows a comment after a space, however,
- // all of it (version and comments) goes into the
- // session hash.
- versionString = append(versionString, buf[0])
- }
-
- if !ok {
- return nil, errors.New("ssh: overflow reading version string")
- }
-
- // There might be a '\r' on the end which we should remove.
- if len(versionString) > 0 && versionString[len(versionString)-1] == '\r' {
- versionString = versionString[:len(versionString)-1]
- }
- return versionString, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-billy.v2/LICENSE b/vendor/gopkg.in/libgit2/git2go.v25/LICENSE
similarity index 82%
rename from vendor/gopkg.in/src-d/go-billy.v2/LICENSE
rename to vendor/gopkg.in/libgit2/git2go.v25/LICENSE
index 853832aed69ee0116bda3d6500b7f1bd1eabf741..46a7407e71154388d31610232a3c596a1cc3e5d9 100644
--- a/vendor/gopkg.in/src-d/go-billy.v2/LICENSE
+++ b/vendor/gopkg.in/libgit2/git2go.v25/LICENSE
@@ -1,14 +1,16 @@
-Copyright (c) 2016 Sourced Technologies S.L.
+The MIT License
+
+Copyright (c) 2013 The git2go 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
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is furnished
-to do so, subject to the following conditions:
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/Makefile b/vendor/gopkg.in/libgit2/git2go.v25/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..acb57b0bd758ee64e62fb0b62e5e760026d6097f
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/Makefile
@@ -0,0 +1,21 @@
+default: test
+
+build-libgit2:
+ ./script/build-libgit2-static.sh
+
+test-static: build-libgit2
+ go run script/check-MakeGitError-thread-lock.go
+ go test -tags static ./...
+
+build-static: build-libgit2
+ go build -tags static ./...
+
+install-static: build-libgit2
+ go install -tags static ./...
+
+test:
+ go run script/check-MakeGitError-thread-lock.go
+ go test ./...
+
+install:
+ go install ./...
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/README.md b/vendor/gopkg.in/libgit2/git2go.v25/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bd918d6860e805ce9c5ec411b8f99b89cd3c9023
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/README.md
@@ -0,0 +1,66 @@
+git2go
+======
+[](http://godoc.org/github.com/libgit2/git2go) [](https://travis-ci.org/libgit2/git2go)
+
+
+Go bindings for [libgit2](http://libgit2.github.com/). The `master` branch follows the latest libgit2 release. The versioned branches indicate which libgit2 version they work against.
+
+Installing
+----------
+
+This project wraps the functionality provided by libgit2. If you're using a stable version, install it to your system via your system's package manager and then install git2go as usual.
+
+Otherwise (`next` which tracks an unstable version), we need to build libgit2 as well. In order to build it, you need `cmake`, `pkg-config` and a C compiler. You will also need the development packages for OpenSSL and LibSSH2 installed if you want libgit2 to support HTTPS and SSH respectively.
+
+### Stable version
+
+git2go has `master` which tracks the latest release of libgit2, and versioned branches which indicate which version of libgit2 they work against. Install the development package on your system via your favourite package manager or from source and you can use a service like gopkg.in to use the appropriate version. For the libgit2 v0.22 case, you can use
+
+ import "gopkg.in/libgit2/git2go.v22"
+
+to use a version of git2go which will work against libgit2 v0.22 and dynamically link to the library. You can use
+
+ import "github.com/libgit2/git2go"
+
+to use the 'master' branch, which works against the latest release of libgit2, whichever that one is at the time.
+
+### From `next`
+
+The `next` branch follows libgit2's master branch, which means there is no stable API or ABI to link against. git2go can statically link against a vendored version of libgit2.
+
+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 checkout next
+ git submodule update --init # get libgit2
+ make install
+
+will compile libgit2. Run `go install` so that it's statically linked to the git2go package.
+
+Parallelism and network operations
+----------------------------------
+
+libgit2 uses 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.
+
+Running the tests
+-----------------
+
+For the stable version, `go test` will work as usual. For the `next` branch, similarly to installing, running the tests requires building a local libgit2 library, so the Makefile provides a wrapper that makes sure it's built
+
+ make test
+
+Alternatively, you can build the library manually first and then run the tests
+
+ ./script/build-libgit2-static.sh
+ go test -v
+
+License
+-------
+
+M to the I to the T. See the LICENSE file if you've never seen a MIT license before.
+
+Authors
+-------
+
+- Carlos MartÃn (@carlosmn)
+- Vicent Martà (@vmg)
+
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/blame.go b/vendor/gopkg.in/libgit2/git2go.v25/blame.go
new file mode 100644
index 0000000000000000000000000000000000000000..b07d6bc686d0e8dd229b1aaa8f5f5005cf188975
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/blame.go
@@ -0,0 +1,157 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type BlameOptions struct {
+ Flags BlameOptionsFlag
+ MinMatchCharacters uint16
+ NewestCommit *Oid
+ OldestCommit *Oid
+ MinLine uint32
+ MaxLine uint32
+}
+
+func DefaultBlameOptions() (BlameOptions, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ opts := C.git_blame_options{}
+ ecode := C.git_blame_init_options(&opts, C.GIT_BLAME_OPTIONS_VERSION)
+ if ecode < 0 {
+ return BlameOptions{}, MakeGitError(ecode)
+ }
+
+ return BlameOptions{
+ Flags: BlameOptionsFlag(opts.flags),
+ MinMatchCharacters: uint16(opts.min_match_characters),
+ NewestCommit: newOidFromC(&opts.newest_commit),
+ OldestCommit: newOidFromC(&opts.oldest_commit),
+ MinLine: uint32(opts.min_line),
+ MaxLine: uint32(opts.max_line),
+ }, nil
+}
+
+type BlameOptionsFlag uint32
+
+const (
+ BlameNormal BlameOptionsFlag = C.GIT_BLAME_NORMAL
+ BlameTrackCopiesSameFile BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_FILE
+ BlameTrackCopiesSameCommitMoves BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES
+ BlameTrackCopiesSameCommitCopies BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES
+ BlameTrackCopiesAnyCommitCopies BlameOptionsFlag = C.GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES
+ BlameFirstParent BlameOptionsFlag = C.GIT_BLAME_FIRST_PARENT
+)
+
+func (v *Repository) BlameFile(path string, opts *BlameOptions) (*Blame, error) {
+ var blamePtr *C.git_blame
+
+ var copts *C.git_blame_options
+ if opts != nil {
+ copts = &C.git_blame_options{
+ version: C.GIT_BLAME_OPTIONS_VERSION,
+ flags: C.uint32_t(opts.Flags),
+ min_match_characters: C.uint16_t(opts.MinMatchCharacters),
+ min_line: C.size_t(opts.MinLine),
+ max_line: C.size_t(opts.MaxLine),
+ }
+ if opts.NewestCommit != nil {
+ copts.newest_commit = *opts.NewestCommit.toC()
+ }
+ if opts.OldestCommit != nil {
+ copts.oldest_commit = *opts.OldestCommit.toC()
+ }
+ }
+
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_blame_file(&blamePtr, v.ptr, cpath, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newBlameFromC(blamePtr), nil
+}
+
+type Blame struct {
+ ptr *C.git_blame
+}
+
+func (blame *Blame) HunkCount() int {
+ return int(C.git_blame_get_hunk_count(blame.ptr))
+}
+
+func (blame *Blame) HunkByIndex(index int) (BlameHunk, error) {
+ ptr := C.git_blame_get_hunk_byindex(blame.ptr, C.uint32_t(index))
+ if ptr == nil {
+ return BlameHunk{}, ErrInvalid
+ }
+ return blameHunkFromC(ptr), nil
+}
+
+func (blame *Blame) HunkByLine(lineno int) (BlameHunk, error) {
+ ptr := C.git_blame_get_hunk_byline(blame.ptr, C.size_t(lineno))
+ if ptr == nil {
+ return BlameHunk{}, ErrInvalid
+ }
+ return blameHunkFromC(ptr), nil
+}
+
+func newBlameFromC(ptr *C.git_blame) *Blame {
+ if ptr == nil {
+ return nil
+ }
+
+ blame := &Blame{
+ ptr: ptr,
+ }
+
+ runtime.SetFinalizer(blame, (*Blame).Free)
+ return blame
+}
+
+func (blame *Blame) Free() error {
+ if blame.ptr == nil {
+ return ErrInvalid
+ }
+ runtime.SetFinalizer(blame, nil)
+ C.git_blame_free(blame.ptr)
+ blame.ptr = nil
+ return nil
+}
+
+type BlameHunk struct {
+ LinesInHunk uint16
+ FinalCommitId *Oid
+ FinalStartLineNumber uint16
+ FinalSignature *Signature
+ OrigCommitId *Oid
+ OrigPath string
+ OrigStartLineNumber uint16
+ OrigSignature *Signature
+ Boundary bool
+}
+
+func blameHunkFromC(hunk *C.git_blame_hunk) BlameHunk {
+ return BlameHunk{
+ LinesInHunk: uint16(hunk.lines_in_hunk),
+ FinalCommitId: newOidFromC(&hunk.final_commit_id),
+ FinalStartLineNumber: uint16(hunk.final_start_line_number),
+ FinalSignature: newSignatureFromC(hunk.final_signature),
+ OrigCommitId: newOidFromC(&hunk.orig_commit_id),
+ OrigPath: C.GoString(hunk.orig_path),
+ OrigStartLineNumber: uint16(hunk.orig_start_line_number),
+ OrigSignature: newSignatureFromC(hunk.orig_signature),
+ Boundary: hunk.boundary == 1,
+ }
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/blob.go b/vendor/gopkg.in/libgit2/git2go.v25/blob.go
new file mode 100644
index 0000000000000000000000000000000000000000..73a4a19f2b386f51779745fd7038a5df8ece8b7a
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/blob.go
@@ -0,0 +1,155 @@
+package git
+
+/*
+#include <git2.h>
+#include <string.h>
+
+int _go_git_writestream_write(git_writestream *stream, const char *buffer, size_t len);
+void _go_git_writestream_free(git_writestream *stream);
+*/
+import "C"
+import (
+ "io"
+ "reflect"
+ "runtime"
+ "unsafe"
+)
+
+type Blob struct {
+ Object
+ cast_ptr *C.git_blob
+}
+
+func (v *Blob) Size() int64 {
+ return int64(C.git_blob_rawsize(v.cast_ptr))
+}
+
+func (v *Blob) Contents() []byte {
+ size := C.int(C.git_blob_rawsize(v.cast_ptr))
+ buffer := unsafe.Pointer(C.git_blob_rawcontent(v.cast_ptr))
+ return C.GoBytes(buffer, size)
+}
+
+func (repo *Repository) CreateBlobFromBuffer(data []byte) (*Oid, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var id C.git_oid
+ var size C.size_t
+
+ // Go 1.6 added some increased checking of passing pointer to
+ // C, but its check depends on its expectations of waht we
+ // pass to the C function, so unless we take the address of
+ // its contents at the call site itself, it can fail when
+ // 'data' is a slice of a slice.
+ //
+ // When we're given an empty slice, create a dummy one where 0
+ // isn't out of bounds.
+ if len(data) > 0 {
+ size = C.size_t(len(data))
+ } else {
+ data = []byte{0}
+ size = C.size_t(0)
+ }
+
+ ecode := C.git_blob_create_frombuffer(&id, repo.ptr, unsafe.Pointer(&data[0]), size)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ return newOidFromC(&id), nil
+}
+
+type BlobChunkCallback func(maxLen int) ([]byte, error)
+
+type BlobCallbackData struct {
+ Callback BlobChunkCallback
+ Error error
+}
+
+//export blobChunkCb
+func blobChunkCb(buffer *C.char, maxLen C.size_t, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*BlobCallbackData)
+ if !ok {
+ panic("could not retrieve blob callback data")
+ }
+
+ goBuf, err := data.Callback(int(maxLen))
+ if err == io.EOF {
+ return 0
+ } else if err != nil {
+ data.Error = err
+ return -1
+ }
+ C.memcpy(unsafe.Pointer(buffer), unsafe.Pointer(&goBuf[0]), C.size_t(len(goBuf)))
+ return len(goBuf)
+}
+
+func (repo *Repository) CreateFromStream(hintPath string) (*BlobWriteStream, error) {
+ var chintPath *C.char = nil
+ var stream *C.git_writestream
+
+ if len(hintPath) > 0 {
+ chintPath = C.CString(hintPath)
+ defer C.free(unsafe.Pointer(chintPath))
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_blob_create_fromstream(&stream, repo.ptr, chintPath)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newBlobWriteStreamFromC(stream), nil
+}
+
+type BlobWriteStream struct {
+ ptr *C.git_writestream
+}
+
+func newBlobWriteStreamFromC(ptr *C.git_writestream) *BlobWriteStream {
+ stream := &BlobWriteStream{
+ ptr: ptr,
+ }
+
+ runtime.SetFinalizer(stream, (*BlobWriteStream).Free)
+ return stream
+}
+
+// Implement io.Writer
+func (stream *BlobWriteStream) Write(p []byte) (int, error) {
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&p))
+ ptr := (*C.char)(unsafe.Pointer(header.Data))
+ size := C.size_t(header.Len)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C._go_git_writestream_write(stream.ptr, ptr, size)
+ if ecode < 0 {
+ return 0, MakeGitError(ecode)
+ }
+
+ return len(p), nil
+}
+
+func (stream *BlobWriteStream) Free() {
+ runtime.SetFinalizer(stream, nil)
+ C._go_git_writestream_free(stream.ptr)
+}
+
+func (stream *BlobWriteStream) Commit() (*Oid, error) {
+ oid := C.git_oid{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_blob_create_fromstream_commit(&oid, stream.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newOidFromC(&oid), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/branch.go b/vendor/gopkg.in/libgit2/git2go.v25/branch.go
new file mode 100644
index 0000000000000000000000000000000000000000..d381c232d3908ac7eb24b96a2514eb24ba455a43
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/branch.go
@@ -0,0 +1,250 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+type BranchType uint
+
+const (
+ BranchAll BranchType = C.GIT_BRANCH_ALL
+ BranchLocal BranchType = C.GIT_BRANCH_LOCAL
+ BranchRemote BranchType = C.GIT_BRANCH_REMOTE
+)
+
+type Branch struct {
+ *Reference
+}
+
+func (r *Reference) Branch() *Branch {
+ return &Branch{Reference: r}
+}
+
+type BranchIterator struct {
+ ptr *C.git_branch_iterator
+ repo *Repository
+}
+
+type BranchIteratorFunc func(*Branch, BranchType) error
+
+func newBranchIteratorFromC(repo *Repository, ptr *C.git_branch_iterator) *BranchIterator {
+ i := &BranchIterator{repo: repo, ptr: ptr}
+ runtime.SetFinalizer(i, (*BranchIterator).Free)
+ return i
+}
+
+func (i *BranchIterator) Next() (*Branch, BranchType, error) {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var refPtr *C.git_reference
+ var refType C.git_branch_t
+
+ ecode := C.git_branch_next(&refPtr, &refType, i.ptr)
+
+ if ecode < 0 {
+ return nil, BranchLocal, MakeGitError(ecode)
+ }
+
+ branch := newReferenceFromC(refPtr, i.repo).Branch()
+
+ return branch, BranchType(refType), nil
+}
+
+func (i *BranchIterator) Free() {
+ runtime.SetFinalizer(i, nil)
+ C.git_branch_iterator_free(i.ptr)
+}
+
+func (i *BranchIterator) ForEach(f BranchIteratorFunc) error {
+ b, t, err := i.Next()
+
+ for err == nil {
+ err = f(b, t)
+ if err == nil {
+ b, t, err = i.Next()
+ }
+ }
+
+ if err != nil && IsErrorCode(err, ErrIterOver) {
+ return nil
+ }
+
+ return err
+}
+
+func (repo *Repository) NewBranchIterator(flags BranchType) (*BranchIterator, error) {
+ refType := C.git_branch_t(flags)
+ var ptr *C.git_branch_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_branch_iterator_new(&ptr, repo.ptr, refType)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newBranchIteratorFromC(repo, ptr), nil
+}
+
+func (repo *Repository) CreateBranch(branchName string, target *Commit, force bool) (*Branch, error) {
+
+ var ptr *C.git_reference
+ cBranchName := C.CString(branchName)
+ defer C.free(unsafe.Pointer(cBranchName))
+ cForce := cbool(force)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_create(&ptr, repo.ptr, cBranchName, target.cast_ptr, cForce)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newReferenceFromC(ptr, repo).Branch(), nil
+}
+
+func (b *Branch) Delete() error {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ ret := C.git_branch_delete(b.Reference.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (b *Branch) Move(newBranchName string, force bool) (*Branch, error) {
+ var ptr *C.git_reference
+ cNewBranchName := C.CString(newBranchName)
+ defer C.free(unsafe.Pointer(cNewBranchName))
+ cForce := cbool(force)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_move(&ptr, b.Reference.ptr, cNewBranchName, cForce)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newReferenceFromC(ptr, b.repo).Branch(), nil
+}
+
+func (b *Branch) IsHead() (bool, error) {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_is_head(b.Reference.ptr)
+ switch ret {
+ case 1:
+ return true, nil
+ case 0:
+ return false, nil
+ }
+ return false, MakeGitError(ret)
+
+}
+
+func (repo *Repository) LookupBranch(branchName string, bt BranchType) (*Branch, error) {
+ var ptr *C.git_reference
+
+ cName := C.CString(branchName)
+ defer C.free(unsafe.Pointer(cName))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_lookup(&ptr, repo.ptr, cName, C.git_branch_t(bt))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newReferenceFromC(ptr, repo).Branch(), nil
+}
+
+func (b *Branch) Name() (string, error) {
+ var cName *C.char
+ defer C.free(unsafe.Pointer(cName))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_name(&cName, b.Reference.ptr)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(cName), nil
+}
+
+func (repo *Repository) RemoteName(canonicalBranchName string) (string, error) {
+ cName := C.CString(canonicalBranchName)
+ defer C.free(unsafe.Pointer(cName))
+
+ nameBuf := C.git_buf{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_remote_name(&nameBuf, repo.ptr, cName)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+ defer C.git_buf_free(&nameBuf)
+
+ return C.GoString(nameBuf.ptr), nil
+}
+
+func (b *Branch) SetUpstream(upstreamName string) error {
+ cName := C.CString(upstreamName)
+ defer C.free(unsafe.Pointer(cName))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_set_upstream(b.Reference.ptr, cName)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (b *Branch) Upstream() (*Reference, error) {
+
+ var ptr *C.git_reference
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_upstream(&ptr, b.Reference.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newReferenceFromC(ptr, b.repo), nil
+}
+
+func (repo *Repository) UpstreamName(canonicalBranchName string) (string, error) {
+ cName := C.CString(canonicalBranchName)
+ defer C.free(unsafe.Pointer(cName))
+
+ nameBuf := C.git_buf{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_branch_upstream_name(&nameBuf, repo.ptr, cName)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+ defer C.git_buf_free(&nameBuf)
+
+ return C.GoString(nameBuf.ptr), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/checkout.go b/vendor/gopkg.in/libgit2/git2go.v25/checkout.go
new file mode 100644
index 0000000000000000000000000000000000000000..f5822c975c7ea4366c6cc09b13b5c859adbafb0d
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/checkout.go
@@ -0,0 +1,234 @@
+package git
+
+/*
+#include <git2.h>
+
+extern void _go_git_populate_checkout_cb(git_checkout_options *opts);
+*/
+import "C"
+import (
+ "os"
+ "runtime"
+ "unsafe"
+)
+
+type CheckoutNotifyType uint
+type CheckoutStrategy uint
+
+const (
+ CheckoutNotifyNone CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_NONE
+ CheckoutNotifyConflict CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_CONFLICT
+ CheckoutNotifyDirty CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_DIRTY
+ CheckoutNotifyUpdated CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_UPDATED
+ CheckoutNotifyUntracked CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_UNTRACKED
+ CheckoutNotifyIgnored CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_IGNORED
+ CheckoutNotifyAll CheckoutNotifyType = C.GIT_CHECKOUT_NOTIFY_ALL
+
+ CheckoutNone CheckoutStrategy = C.GIT_CHECKOUT_NONE // Dry run, no actual updates
+ CheckoutSafe CheckoutStrategy = C.GIT_CHECKOUT_SAFE // Allow safe updates that cannot overwrite uncommitted data
+ CheckoutForce CheckoutStrategy = C.GIT_CHECKOUT_FORCE // Allow all updates to force working directory to look like index
+ CheckoutRecreateMissing CheckoutStrategy = C.GIT_CHECKOUT_RECREATE_MISSING // Allow checkout to recreate missing files
+ CheckoutAllowConflicts CheckoutStrategy = C.GIT_CHECKOUT_ALLOW_CONFLICTS // Allow checkout to make safe updates even if conflicts are found
+ CheckoutRemoveUntracked CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_UNTRACKED // Remove untracked files not in index (that are not ignored)
+ CheckoutRemoveIgnored CheckoutStrategy = C.GIT_CHECKOUT_REMOVE_IGNORED // Remove ignored files not in index
+ CheckoutUpdateOnly CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_ONLY // Only update existing files, don't create new ones
+ CheckoutDontUpdateIndex CheckoutStrategy = C.GIT_CHECKOUT_DONT_UPDATE_INDEX // Normally checkout updates index entries as it goes; this stops that
+ CheckoutNoRefresh CheckoutStrategy = C.GIT_CHECKOUT_NO_REFRESH // Don't refresh index/config/etc before doing checkout
+ CheckoutSkipUnmerged CheckoutStrategy = C.GIT_CHECKOUT_SKIP_UNMERGED // Allow checkout to skip unmerged files
+ CheckoutUserOurs CheckoutStrategy = C.GIT_CHECKOUT_USE_OURS // For unmerged files, checkout stage 2 from index
+ CheckoutUseTheirs CheckoutStrategy = C.GIT_CHECKOUT_USE_THEIRS // For unmerged files, checkout stage 3 from index
+ CheckoutDisablePathspecMatch CheckoutStrategy = C.GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH // Treat pathspec as simple list of exact match file paths
+ CheckoutSkipLockedDirectories CheckoutStrategy = C.GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES // Ignore directories in use, they will be left empty
+ CheckoutDontOverwriteIgnored CheckoutStrategy = C.GIT_CHECKOUT_DONT_OVERWRITE_IGNORED // Don't overwrite ignored files that exist in the checkout target
+ CheckoutConflictStyleMerge CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_MERGE // Write normal merge files for conflicts
+ CheckoutConflictStyleDiff3 CheckoutStrategy = C.GIT_CHECKOUT_CONFLICT_STYLE_DIFF3 // Include common ancestor data in diff3 format files for conflicts
+ CheckoutDontRemoveExisting CheckoutStrategy = C.GIT_CHECKOUT_DONT_REMOVE_EXISTING // Don't overwrite existing files or folders
+ CheckoutDontWriteIndex CheckoutStrategy = C.GIT_CHECKOUT_DONT_WRITE_INDEX // Normally checkout writes the index upon completion; this prevents that
+ CheckoutUpdateSubmodules CheckoutStrategy = C.GIT_CHECKOUT_UPDATE_SUBMODULES // Recursively checkout submodules with same options (NOT IMPLEMENTED)
+ 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 CheckoutOpts struct {
+ Strategy CheckoutStrategy // Default will be a dry run
+ DisableFilters bool // Don't apply filters like CRLF conversion
+ DirMode os.FileMode // Default is 0755
+ FileMode os.FileMode // Default is 0644 or 0755 as dictated by blob
+ FileOpenFlags int // Default is O_CREAT | O_TRUNC | O_WRONLY
+ NotifyFlags CheckoutNotifyType // Default will be none
+ NotifyCallback CheckoutNotifyCallback
+ ProgressCallback CheckoutProgressCallback
+ TargetDirectory string // Alternative checkout path to workdir
+ Paths []string
+ Baseline *Tree
+}
+
+func checkoutOptionsFromC(c *C.git_checkout_options) CheckoutOpts {
+ opts := CheckoutOpts{}
+ opts.Strategy = CheckoutStrategy(c.checkout_strategy)
+ opts.DisableFilters = c.disable_filters != 0
+ opts.DirMode = os.FileMode(c.dir_mode)
+ opts.FileMode = os.FileMode(c.file_mode)
+ opts.FileOpenFlags = int(c.file_open_flags)
+ opts.NotifyFlags = CheckoutNotifyType(c.notify_flags)
+ if c.notify_payload != nil {
+ opts.NotifyCallback = pointerHandles.Get(c.notify_payload).(*CheckoutOpts).NotifyCallback
+ }
+ if c.progress_payload != nil {
+ opts.ProgressCallback = pointerHandles.Get(c.progress_payload).(*CheckoutOpts).ProgressCallback
+ }
+ if c.target_directory != nil {
+ opts.TargetDirectory = C.GoString(c.target_directory)
+ }
+ return opts
+}
+
+func (opts *CheckoutOpts) toC() *C.git_checkout_options {
+ if opts == nil {
+ return nil
+ }
+ c := C.git_checkout_options{}
+ populateCheckoutOpts(&c, opts)
+ return &c
+}
+
+//export checkoutNotifyCallback
+func checkoutNotifyCallback(why C.git_checkout_notify_t, cpath *C.char, cbaseline, ctarget, cworkdir, data unsafe.Pointer) int {
+ if data == nil {
+ return 0
+ }
+ path := C.GoString(cpath)
+ var baseline, target, workdir DiffFile
+ if cbaseline != nil {
+ baseline = diffFileFromC((*C.git_diff_file)(cbaseline))
+ }
+ if ctarget != nil {
+ target = diffFileFromC((*C.git_diff_file)(ctarget))
+ }
+ if cworkdir != nil {
+ workdir = diffFileFromC((*C.git_diff_file)(cworkdir))
+ }
+ opts := pointerHandles.Get(data).(*CheckoutOpts)
+ if opts.NotifyCallback == nil {
+ return 0
+ }
+ return int(opts.NotifyCallback(CheckoutNotifyType(why), path, baseline, target, workdir))
+}
+
+//export checkoutProgressCallback
+func checkoutProgressCallback(path *C.char, completed_steps, total_steps C.size_t, data unsafe.Pointer) int {
+ opts := pointerHandles.Get(data).(*CheckoutOpts)
+ if opts.ProgressCallback == nil {
+ return 0
+ }
+ return int(opts.ProgressCallback(C.GoString(path), uint(completed_steps), uint(total_steps)))
+}
+
+// Convert the CheckoutOpts struct to the corresponding
+// C-struct. Returns a pointer to ptr, or nil if opts is nil, in order
+// to help with what to pass.
+func populateCheckoutOpts(ptr *C.git_checkout_options, opts *CheckoutOpts) *C.git_checkout_options {
+ if opts == nil {
+ return nil
+ }
+
+ C.git_checkout_init_options(ptr, 1)
+ ptr.checkout_strategy = C.uint(opts.Strategy)
+ ptr.disable_filters = cbool(opts.DisableFilters)
+ ptr.dir_mode = C.uint(opts.DirMode.Perm())
+ ptr.file_mode = C.uint(opts.FileMode.Perm())
+ ptr.notify_flags = C.uint(opts.NotifyFlags)
+ if opts.NotifyCallback != nil || opts.ProgressCallback != nil {
+ C._go_git_populate_checkout_cb(ptr)
+ }
+ payload := pointerHandles.Track(opts)
+ if opts.NotifyCallback != nil {
+ ptr.notify_payload = payload
+ }
+ if opts.ProgressCallback != nil {
+ ptr.progress_payload = payload
+ }
+ if opts.TargetDirectory != "" {
+ ptr.target_directory = C.CString(opts.TargetDirectory)
+ }
+ if len(opts.Paths) > 0 {
+ ptr.paths.strings = makeCStringsFromStrings(opts.Paths)
+ ptr.paths.count = C.size_t(len(opts.Paths))
+ }
+
+ if opts.Baseline != nil {
+ ptr.baseline = opts.Baseline.cast_ptr
+ }
+
+ return ptr
+}
+
+func freeCheckoutOpts(ptr *C.git_checkout_options) {
+ if ptr == nil {
+ return
+ }
+ C.free(unsafe.Pointer(ptr.target_directory))
+ if ptr.paths.count > 0 {
+ freeStrarray(&ptr.paths)
+ }
+ if ptr.notify_payload != nil {
+ pointerHandles.Untrack(ptr.notify_payload)
+ }
+}
+
+// Updates files in the index and the working tree to match the content of
+// the commit pointed at by HEAD. opts may be nil.
+func (v *Repository) CheckoutHead(opts *CheckoutOpts) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cOpts := opts.toC()
+ defer freeCheckoutOpts(cOpts)
+
+ ret := C.git_checkout_head(v.ptr, cOpts)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// Updates files in the working tree to match the content of the given
+// index. If index is nil, the repository's index will be used. opts
+// may be nil.
+func (v *Repository) CheckoutIndex(index *Index, opts *CheckoutOpts) error {
+ var iptr *C.git_index = nil
+ if index != nil {
+ iptr = index.ptr
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cOpts := opts.toC()
+ defer freeCheckoutOpts(cOpts)
+
+ ret := C.git_checkout_index(v.ptr, iptr, cOpts)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Repository) CheckoutTree(tree *Tree, opts *CheckoutOpts) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cOpts := opts.toC()
+ defer freeCheckoutOpts(cOpts)
+
+ ret := C.git_checkout_tree(v.ptr, tree.ptr, cOpts)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/cherrypick.go b/vendor/gopkg.in/libgit2/git2go.v25/cherrypick.go
new file mode 100644
index 0000000000000000000000000000000000000000..afc1b7efd7e05685c715deffaf3b4e35ab09764d
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/cherrypick.go
@@ -0,0 +1,73 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+)
+
+type CherrypickOptions struct {
+ Version uint
+ Mainline uint
+ MergeOpts MergeOptions
+ CheckoutOpts CheckoutOpts
+}
+
+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),
+ }
+ return opts
+}
+
+func (opts *CherrypickOptions) toC() *C.git_cherrypick_options {
+ if opts == nil {
+ return nil
+ }
+ c := C.git_cherrypick_options{}
+ c.version = C.uint(opts.Version)
+ c.mainline = C.uint(opts.Mainline)
+ c.merge_opts = *opts.MergeOpts.toC()
+ c.checkout_opts = *opts.CheckoutOpts.toC()
+ return &c
+}
+
+func freeCherrypickOpts(ptr *C.git_cherrypick_options) {
+ if ptr == nil {
+ return
+ }
+ freeCheckoutOpts(&ptr.checkout_opts)
+}
+
+func DefaultCherrypickOptions() (CherrypickOptions, error) {
+ c := C.git_cherrypick_options{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_cherrypick_init_options(&c, C.GIT_CHERRYPICK_OPTIONS_VERSION)
+ if ecode < 0 {
+ return CherrypickOptions{}, MakeGitError(ecode)
+ }
+ defer freeCherrypickOpts(&c)
+ return cherrypickOptionsFromC(&c), nil
+}
+
+func (v *Repository) Cherrypick(commit *Commit, opts CherrypickOptions) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cOpts := opts.toC()
+ defer freeCherrypickOpts(cOpts)
+
+ ecode := C.git_cherrypick(v.ptr, commit.cast_ptr, cOpts)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/clone.go b/vendor/gopkg.in/libgit2/git2go.v25/clone.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ff51245b3042ac58ef3647d0831063ae6989226
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/clone.go
@@ -0,0 +1,109 @@
+package git
+
+/*
+#include <git2.h>
+
+extern void _go_git_populate_remote_cb(git_clone_options *opts);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type RemoteCreateCallback func(repo *Repository, name, url string) (*Remote, ErrorCode)
+
+type CloneOptions struct {
+ *CheckoutOpts
+ *FetchOptions
+ Bare bool
+ CheckoutBranch string
+ RemoteCreateCallback RemoteCreateCallback
+}
+
+func Clone(url string, path string, options *CloneOptions) (*Repository, error) {
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ copts := (*C.git_clone_options)(C.calloc(1, C.size_t(unsafe.Sizeof(C.git_clone_options{}))))
+ populateCloneOptions(copts, options)
+ defer freeCloneOptions(copts)
+
+ if len(options.CheckoutBranch) != 0 {
+ copts.checkout_branch = C.CString(options.CheckoutBranch)
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_clone(&ptr, curl, cpath, copts)
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newRepositoryFromC(ptr), nil
+}
+
+//export remoteCreateCallback
+func remoteCreateCallback(cremote unsafe.Pointer, crepo unsafe.Pointer, cname, curl *C.char, payload unsafe.Pointer) C.int {
+ name := C.GoString(cname)
+ url := C.GoString(curl)
+ repo := newRepositoryFromC((*C.git_repository)(crepo))
+ // We don't own this repository, so make sure we don't try to free it
+ runtime.SetFinalizer(repo, nil)
+
+ if opts, ok := pointerHandles.Get(payload).(CloneOptions); ok {
+ remote, err := opts.RemoteCreateCallback(repo, name, url)
+ // clear finalizer as the calling C function will
+ // free the remote itself
+ runtime.SetFinalizer(remote, nil)
+
+ if err == ErrOk && remote != nil {
+ cptr := (**C.git_remote)(cremote)
+ *cptr = remote.ptr
+ } else if err == ErrOk && remote == nil {
+ panic("no remote created by callback")
+ }
+
+ return C.int(err)
+ } else {
+ panic("invalid remote create callback")
+ }
+}
+
+func populateCloneOptions(ptr *C.git_clone_options, opts *CloneOptions) {
+ C.git_clone_init_options(ptr, C.GIT_CLONE_OPTIONS_VERSION)
+
+ if opts == nil {
+ return
+ }
+ populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
+ populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
+ ptr.bare = cbool(opts.Bare)
+
+ if opts.RemoteCreateCallback != nil {
+ // Go v1.1 does not allow to assign a C function pointer
+ C._go_git_populate_remote_cb(ptr)
+ ptr.remote_cb_payload = pointerHandles.Track(*opts)
+ }
+}
+
+func freeCloneOptions(ptr *C.git_clone_options) {
+ if ptr == nil {
+ return
+ }
+
+ freeCheckoutOpts(&ptr.checkout_opts)
+
+ if ptr.remote_cb_payload != nil {
+ pointerHandles.Untrack(ptr.remote_cb_payload)
+ }
+
+ C.free(unsafe.Pointer(ptr.checkout_branch))
+ C.free(unsafe.Pointer(ptr))
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/commit.go b/vendor/gopkg.in/libgit2/git2go.v25/commit.go
new file mode 100644
index 0000000000000000000000000000000000000000..07b7c375510d9dfac858d108dd7d8256c66791ef
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/commit.go
@@ -0,0 +1,114 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_treewalk(git_tree *tree, git_treewalk_mode mode, void *ptr);
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+// Commit
+type Commit struct {
+ Object
+ cast_ptr *C.git_commit
+}
+
+func (c Commit) Message() string {
+ return C.GoString(C.git_commit_message(c.cast_ptr))
+}
+
+func (c Commit) RawMessage() string {
+ return C.GoString(C.git_commit_message_raw(c.cast_ptr))
+}
+
+func (c Commit) Summary() string {
+ return C.GoString(C.git_commit_summary(c.cast_ptr))
+}
+
+func (c Commit) Tree() (*Tree, error) {
+ var ptr *C.git_tree
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C.git_commit_tree(&ptr, c.cast_ptr)
+ if err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return allocTree(ptr, c.repo), nil
+}
+
+func (c Commit) TreeId() *Oid {
+ return newOidFromC(C.git_commit_tree_id(c.cast_ptr))
+}
+
+func (c Commit) Author() *Signature {
+ cast_ptr := C.git_commit_author(c.cast_ptr)
+ return newSignatureFromC(cast_ptr)
+}
+
+func (c Commit) Committer() *Signature {
+ cast_ptr := C.git_commit_committer(c.cast_ptr)
+ return newSignatureFromC(cast_ptr)
+}
+
+func (c *Commit) Parent(n uint) *Commit {
+ var cobj *C.git_commit
+ ret := C.git_commit_parent(&cobj, c.cast_ptr, C.uint(n))
+ if ret != 0 {
+ return nil
+ }
+
+ return allocCommit(cobj, c.repo)
+}
+
+func (c *Commit) ParentId(n uint) *Oid {
+ return newOidFromC(C.git_commit_parent_id(c.cast_ptr, C.uint(n)))
+}
+
+func (c *Commit) ParentCount() uint {
+ return uint(C.git_commit_parentcount(c.cast_ptr))
+}
+
+func (c *Commit) Amend(refname string, author, committer *Signature, message string, tree *Tree) (*Oid, error) {
+ var cref *C.char
+ if refname == "" {
+ cref = nil
+ } else {
+ cref = C.CString(refname)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ cmsg := C.CString(message)
+ defer C.free(unsafe.Pointer(cmsg))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ authorSig, err := author.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(authorSig)
+
+ committerSig, err := committer.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(committerSig)
+
+ oid := new(Oid)
+
+ cerr := C.git_commit_amend(oid.toC(), c.cast_ptr, cref, authorSig, committerSig, nil, cmsg, tree.cast_ptr)
+ if cerr < 0 {
+ return nil, MakeGitError(cerr)
+ }
+
+ return oid, nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/config.go b/vendor/gopkg.in/libgit2/git2go.v25/config.go
new file mode 100644
index 0000000000000000000000000000000000000000..7408fbca609aa6ca125c8b66d47fe383c010da07
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/config.go
@@ -0,0 +1,435 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type ConfigLevel int
+
+const (
+ // System-wide on Windows, for compatibility with portable git
+ ConfigLevelProgramdata ConfigLevel = C.GIT_CONFIG_LEVEL_PROGRAMDATA
+
+ // System-wide configuration file; /etc/gitconfig on Linux systems
+ ConfigLevelSystem ConfigLevel = C.GIT_CONFIG_LEVEL_SYSTEM
+
+ // XDG compatible configuration file; typically ~/.config/git/config
+ ConfigLevelXDG ConfigLevel = C.GIT_CONFIG_LEVEL_XDG
+
+ // User-specific configuration file (also called Global configuration
+ // file); typically ~/.gitconfig
+ ConfigLevelGlobal ConfigLevel = C.GIT_CONFIG_LEVEL_GLOBAL
+
+ // Repository specific configuration file; $WORK_DIR/.git/config on
+ // non-bare repos
+ ConfigLevelLocal ConfigLevel = C.GIT_CONFIG_LEVEL_LOCAL
+
+ // Application specific configuration file; freely defined by applications
+ ConfigLevelApp ConfigLevel = C.GIT_CONFIG_LEVEL_APP
+
+ // Represents the highest level available config file (i.e. the most
+ // specific config file available that actually is loaded)
+ ConfigLevelHighest ConfigLevel = C.GIT_CONFIG_HIGHEST_LEVEL
+)
+
+type ConfigEntry struct {
+ Name string
+ Value string
+ Level ConfigLevel
+}
+
+func newConfigEntryFromC(centry *C.git_config_entry) *ConfigEntry {
+ return &ConfigEntry{
+ Name: C.GoString(centry.name),
+ Value: C.GoString(centry.value),
+ Level: ConfigLevel(centry.level),
+ }
+}
+
+type Config struct {
+ ptr *C.git_config
+}
+
+// NewConfig creates a new empty configuration object
+func NewConfig() (*Config, error) {
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_new(&config.ptr); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+// AddFile adds a file-backed backend to the config object at the specified level.
+func (c *Config) AddFile(path string, level ConfigLevel, force bool) error {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_add_file_ondisk(c.ptr, cpath, C.git_config_level_t(level), cbool(force))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) LookupInt32(name string) (int32, error) {
+ var out C.int32_t
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_get_int32(&out, c.ptr, cname)
+ if ret < 0 {
+ return 0, MakeGitError(ret)
+ }
+
+ return int32(out), nil
+}
+
+func (c *Config) LookupInt64(name string) (int64, error) {
+ var out C.int64_t
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_get_int64(&out, c.ptr, cname)
+ if ret < 0 {
+ return 0, MakeGitError(ret)
+ }
+
+ return int64(out), nil
+}
+
+func (c *Config) LookupString(name string) (string, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ valBuf := C.git_buf{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_get_string_buf(&valBuf, c.ptr, cname); ret < 0 {
+ return "", MakeGitError(ret)
+ }
+ defer C.git_buf_free(&valBuf)
+
+ return C.GoString(valBuf.ptr), nil
+}
+
+func (c *Config) LookupBool(name string) (bool, error) {
+ var out C.int
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_get_bool(&out, c.ptr, cname)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return out != 0, nil
+}
+
+func (c *Config) NewMultivarIterator(name, regexp string) (*ConfigIterator, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ var cregexp *C.char
+ if regexp == "" {
+ cregexp = nil
+ } else {
+ cregexp = C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+ }
+
+ iter := new(ConfigIterator)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_multivar_iterator_new(&iter.ptr, c.ptr, cname, cregexp)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(iter, (*ConfigIterator).Free)
+ return iter, nil
+}
+
+// NewIterator creates an iterator over each entry in the
+// configuration
+func (c *Config) NewIterator() (*ConfigIterator, error) {
+ iter := new(ConfigIterator)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_iterator_new(&iter.ptr, c.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return iter, nil
+}
+
+// NewIteratorGlob creates an iterator over each entry in the
+// configuration whose name matches the given regular expression
+func (c *Config) NewIteratorGlob(regexp string) (*ConfigIterator, error) {
+ iter := new(ConfigIterator)
+ cregexp := C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_iterator_glob_new(&iter.ptr, c.ptr, cregexp)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return iter, nil
+}
+
+func (c *Config) SetString(name, value string) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ cvalue := C.CString(value)
+ defer C.free(unsafe.Pointer(cvalue))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_string(c.ptr, cname, cvalue)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) Free() {
+ runtime.SetFinalizer(c, nil)
+ C.git_config_free(c.ptr)
+}
+
+func (c *Config) SetInt32(name string, value int32) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_int32(c.ptr, cname, C.int32_t(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetInt64(name string, value int64) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_int64(c.ptr, cname, C.int64_t(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetBool(name string, value bool) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_bool(c.ptr, cname, cbool(value))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) SetMultivar(name, regexp, value string) (err error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ cregexp := C.CString(regexp)
+ defer C.free(unsafe.Pointer(cregexp))
+
+ cvalue := C.CString(value)
+ defer C.free(unsafe.Pointer(cvalue))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_set_multivar(c.ptr, cname, cregexp, cvalue)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (c *Config) Delete(name string) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_delete_entry(c.ptr, cname)
+
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// OpenLevel creates a single-level focused config object from a multi-level one
+func (c *Config) OpenLevel(parent *Config, level ConfigLevel) (*Config, error) {
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_open_level(&config.ptr, parent.ptr, C.git_config_level_t(level))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+// OpenOndisk creates a new config instance containing a single on-disk file
+func OpenOndisk(parent *Config, path string) (*Config, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_config_open_ondisk(&config.ptr, cpath); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return config, nil
+}
+
+type ConfigIterator struct {
+ ptr *C.git_config_iterator
+}
+
+// Next returns the next entry for this iterator
+func (iter *ConfigIterator) Next() (*ConfigEntry, error) {
+ var centry *C.git_config_entry
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_next(¢ry, iter.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newConfigEntryFromC(centry), nil
+}
+
+func (iter *ConfigIterator) Free() {
+ runtime.SetFinalizer(iter, nil)
+ C.free(unsafe.Pointer(iter.ptr))
+}
+
+func ConfigFindGlobal() (string, error) {
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_find_global(&buf)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
+
+func ConfigFindSystem() (string, error) {
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_find_system(&buf)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
+
+func ConfigFindXDG() (string, error) {
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_find_xdg(&buf)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
+
+// ConfigFindProgramdata locate the path to the configuration file in ProgramData.
+//
+// Look for the file in %PROGRAMDATA%\Git\config used by portable git.
+func ConfigFindProgramdata() (string, error) {
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_config_find_programdata(&buf)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/credentials.go b/vendor/gopkg.in/libgit2/git2go.v25/credentials.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e42b6e118a1a2df85afbf11fa4ff04ec45383d5
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/credentials.go
@@ -0,0 +1,91 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import "unsafe"
+
+type CredType uint
+
+const (
+ CredTypeUserpassPlaintext CredType = C.GIT_CREDTYPE_USERPASS_PLAINTEXT
+ CredTypeSshKey CredType = C.GIT_CREDTYPE_SSH_KEY
+ CredTypeSshCustom CredType = C.GIT_CREDTYPE_SSH_CUSTOM
+ CredTypeDefault CredType = C.GIT_CREDTYPE_DEFAULT
+)
+
+type Cred struct {
+ ptr *C.git_cred
+}
+
+func (o *Cred) HasUsername() bool {
+ if C.git_cred_has_username(o.ptr) == 1 {
+ return true
+ }
+ return false
+}
+
+func (o *Cred) Type() CredType {
+ return (CredType)(o.ptr.credtype)
+}
+
+func credFromC(ptr *C.git_cred) *Cred {
+ return &Cred{ptr}
+}
+
+func NewCredUserpassPlaintext(username string, password string) (int, Cred) {
+ cred := Cred{}
+ cusername := C.CString(username)
+ defer C.free(unsafe.Pointer(cusername))
+ cpassword := C.CString(password)
+ defer C.free(unsafe.Pointer(cpassword))
+ ret := C.git_cred_userpass_plaintext_new(&cred.ptr, cusername, cpassword)
+ return int(ret), cred
+}
+
+// NewCredSshKey creates new ssh credentials reading the public and private keys
+// from the file system.
+func NewCredSshKey(username string, publicKeyPath string, privateKeyPath string, passphrase string) (int, Cred) {
+ cred := Cred{}
+ cusername := C.CString(username)
+ defer C.free(unsafe.Pointer(cusername))
+ cpublickey := C.CString(publicKeyPath)
+ defer C.free(unsafe.Pointer(cpublickey))
+ cprivatekey := C.CString(privateKeyPath)
+ defer C.free(unsafe.Pointer(cprivatekey))
+ cpassphrase := C.CString(passphrase)
+ defer C.free(unsafe.Pointer(cpassphrase))
+ ret := C.git_cred_ssh_key_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
+ return int(ret), cred
+}
+
+// NewCredSshKeyFromMemory creates new ssh credentials using the publicKey and privateKey
+// arguments as the values for the public and private keys.
+func NewCredSshKeyFromMemory(username string, publicKey string, privateKey string, passphrase string) (int, Cred) {
+ cred := Cred{}
+ cusername := C.CString(username)
+ defer C.free(unsafe.Pointer(cusername))
+ cpublickey := C.CString(publicKey)
+ defer C.free(unsafe.Pointer(cpublickey))
+ cprivatekey := C.CString(privateKey)
+ defer C.free(unsafe.Pointer(cprivatekey))
+ cpassphrase := C.CString(passphrase)
+ defer C.free(unsafe.Pointer(cpassphrase))
+ ret := C.git_cred_ssh_key_memory_new(&cred.ptr, cusername, cpublickey, cprivatekey, cpassphrase)
+ return int(ret), cred
+}
+
+func NewCredSshKeyFromAgent(username string) (int, Cred) {
+ cred := Cred{}
+ cusername := C.CString(username)
+ defer C.free(unsafe.Pointer(cusername))
+ ret := C.git_cred_ssh_key_from_agent(&cred.ptr, cusername)
+ return int(ret), cred
+}
+
+func NewCredDefault() (int, Cred) {
+ cred := Cred{}
+ ret := C.git_cred_default_new(&cred.ptr)
+ return int(ret), cred
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/describe.go b/vendor/gopkg.in/libgit2/git2go.v25/describe.go
new file mode 100644
index 0000000000000000000000000000000000000000..d75dbcbc01a3870114119dad7aa527b7be27536d
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/describe.go
@@ -0,0 +1,222 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+// DescribeOptions represents the describe operation configuration.
+//
+// You can use DefaultDescribeOptions() to get default options.
+type DescribeOptions struct {
+ // How many tags as candidates to consider to describe the input commit-ish.
+ // Increasing it above 10 will take slightly longer but may produce a more
+ // accurate result. 0 will cause only exact matches to be output.
+ MaxCandidatesTags uint // default: 10
+
+ // By default describe only shows annotated tags. Change this in order
+ // to show all refs from refs/tags or refs/.
+ Strategy DescribeOptionsStrategy // default: DescribeDefault
+
+ // Only consider tags matching the given glob(7) pattern, excluding
+ // the "refs/tags/" prefix. Can be used to avoid leaking private
+ // tags from the repo.
+ Pattern string
+
+ // When calculating the distance from the matching tag or
+ // reference, only walk down the first-parent ancestry.
+ OnlyFollowFirstParent bool
+
+ // If no matching tag or reference is found, the describe
+ // operation would normally fail. If this option is set, it
+ // will instead fall back to showing the full id of the commit.
+ ShowCommitOidAsFallback bool
+}
+
+// DefaultDescribeOptions returns default options for the describe operation.
+func DefaultDescribeOptions() (DescribeOptions, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ opts := C.git_describe_options{}
+ ecode := C.git_describe_init_options(&opts, C.GIT_DESCRIBE_OPTIONS_VERSION)
+ if ecode < 0 {
+ return DescribeOptions{}, MakeGitError(ecode)
+ }
+
+ return DescribeOptions{
+ MaxCandidatesTags: uint(opts.max_candidates_tags),
+ Strategy: DescribeOptionsStrategy(opts.describe_strategy),
+ }, nil
+}
+
+// DescribeFormatOptions can be used for formatting the describe string.
+//
+// You can use DefaultDescribeFormatOptions() to get default options.
+type DescribeFormatOptions struct {
+ // Size of the abbreviated commit id to use. This value is the
+ // lower bound for the length of the abbreviated string.
+ AbbreviatedSize uint // default: 7
+
+ // Set to use the long format even when a shorter name could be used.
+ AlwaysUseLongFormat bool
+
+ // If the workdir is dirty and this is set, this string will be
+ // appended to the description string.
+ DirtySuffix string
+}
+
+// DefaultDescribeFormatOptions returns default options for formatting
+// the output.
+func DefaultDescribeFormatOptions() (DescribeFormatOptions, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ opts := C.git_describe_format_options{}
+ ecode := C.git_describe_init_format_options(&opts, C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION)
+ if ecode < 0 {
+ return DescribeFormatOptions{}, MakeGitError(ecode)
+ }
+
+ return DescribeFormatOptions{
+ AbbreviatedSize: uint(opts.abbreviated_size),
+ AlwaysUseLongFormat: opts.always_use_long_format == 1,
+ }, nil
+}
+
+// DescribeOptionsStrategy behaves like the --tags and --all options
+// to git-describe, namely they say to look for any reference in
+// either refs/tags/ or refs/ respectively.
+//
+// By default it only shows annotated tags.
+type DescribeOptionsStrategy uint
+
+// Describe strategy options.
+const (
+ DescribeDefault DescribeOptionsStrategy = C.GIT_DESCRIBE_DEFAULT
+ DescribeTags DescribeOptionsStrategy = C.GIT_DESCRIBE_TAGS
+ DescribeAll DescribeOptionsStrategy = C.GIT_DESCRIBE_ALL
+)
+
+// Describe performs the describe operation on the commit.
+func (c *Commit) Describe(opts *DescribeOptions) (*DescribeResult, error) {
+ var resultPtr *C.git_describe_result
+
+ var cDescribeOpts *C.git_describe_options
+ if opts != nil {
+ var cpattern *C.char
+ if len(opts.Pattern) > 0 {
+ cpattern = C.CString(opts.Pattern)
+ defer C.free(unsafe.Pointer(cpattern))
+ }
+
+ cDescribeOpts = &C.git_describe_options{
+ version: C.GIT_DESCRIBE_OPTIONS_VERSION,
+ max_candidates_tags: C.uint(opts.MaxCandidatesTags),
+ describe_strategy: C.uint(opts.Strategy),
+ pattern: cpattern,
+ only_follow_first_parent: cbool(opts.OnlyFollowFirstParent),
+ show_commit_oid_as_fallback: cbool(opts.ShowCommitOidAsFallback),
+ }
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_describe_commit(&resultPtr, c.ptr, cDescribeOpts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newDescribeResultFromC(resultPtr), nil
+}
+
+// DescribeWorkdir describes the working tree. It means describe HEAD
+// and appends <mark> (-dirty by default) if the working tree is dirty.
+func (repo *Repository) DescribeWorkdir(opts *DescribeOptions) (*DescribeResult, error) {
+ var resultPtr *C.git_describe_result
+
+ var cDescribeOpts *C.git_describe_options
+ if opts != nil {
+ var cpattern *C.char
+ if len(opts.Pattern) > 0 {
+ cpattern = C.CString(opts.Pattern)
+ defer C.free(unsafe.Pointer(cpattern))
+ }
+
+ cDescribeOpts = &C.git_describe_options{
+ version: C.GIT_DESCRIBE_OPTIONS_VERSION,
+ max_candidates_tags: C.uint(opts.MaxCandidatesTags),
+ describe_strategy: C.uint(opts.Strategy),
+ pattern: cpattern,
+ only_follow_first_parent: cbool(opts.OnlyFollowFirstParent),
+ show_commit_oid_as_fallback: cbool(opts.ShowCommitOidAsFallback),
+ }
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_describe_workdir(&resultPtr, repo.ptr, cDescribeOpts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newDescribeResultFromC(resultPtr), nil
+}
+
+// DescribeResult represents the output from the 'git_describe_commit'
+// and 'git_describe_workdir' functions in libgit2.
+//
+// Use Format() to get a string out of it.
+type DescribeResult struct {
+ ptr *C.git_describe_result
+}
+
+func newDescribeResultFromC(ptr *C.git_describe_result) *DescribeResult {
+ result := &DescribeResult{
+ ptr: ptr,
+ }
+ runtime.SetFinalizer(result, (*DescribeResult).Free)
+ return result
+}
+
+// Format prints the DescribeResult as a string.
+func (result *DescribeResult) Format(opts *DescribeFormatOptions) (string, error) {
+ resultBuf := C.git_buf{}
+
+ var cFormatOpts *C.git_describe_format_options
+ if opts != nil {
+ cDirtySuffix := C.CString(opts.DirtySuffix)
+ defer C.free(unsafe.Pointer(cDirtySuffix))
+
+ cFormatOpts = &C.git_describe_format_options{
+ version: C.GIT_DESCRIBE_FORMAT_OPTIONS_VERSION,
+ abbreviated_size: C.uint(opts.AbbreviatedSize),
+ always_use_long_format: cbool(opts.AlwaysUseLongFormat),
+ dirty_suffix: cDirtySuffix,
+ }
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_describe_format(&resultBuf, result.ptr, cFormatOpts)
+ if ecode < 0 {
+ return "", MakeGitError(ecode)
+ }
+ defer C.git_buf_free(&resultBuf)
+
+ return C.GoString(resultBuf.ptr), nil
+}
+
+// Free cleans up the C reference.
+func (result *DescribeResult) Free() {
+ runtime.SetFinalizer(result, nil)
+ C.git_describe_result_free(result.ptr)
+ result.ptr = nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/diff.go b/vendor/gopkg.in/libgit2/git2go.v25/diff.go
new file mode 100644
index 0000000000000000000000000000000000000000..e8d5007de473d230b60cef6667ebc6e80082486d
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/diff.go
@@ -0,0 +1,781 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_diff_foreach(git_diff *diff, int eachFile, int eachHunk, int eachLine, void *payload);
+extern void _go_git_setup_diff_notify_callbacks(git_diff_options* opts);
+extern int _go_git_diff_blobs(git_blob *old, const char *old_path, git_blob *new, const char *new_path, git_diff_options *opts, int eachFile, int eachHunk, int eachLine, void *payload);
+*/
+import "C"
+import (
+ "errors"
+ "runtime"
+ "unsafe"
+)
+
+type DiffFlag int
+
+const (
+ DiffFlagBinary DiffFlag = C.GIT_DIFF_FLAG_BINARY
+ DiffFlagNotBinary DiffFlag = C.GIT_DIFF_FLAG_NOT_BINARY
+ DiffFlagValidOid DiffFlag = C.GIT_DIFF_FLAG_VALID_ID
+ DiffFlagExists DiffFlag = C.GIT_DIFF_FLAG_EXISTS
+)
+
+type Delta int
+
+const (
+ DeltaUnmodified Delta = C.GIT_DELTA_UNMODIFIED
+ DeltaAdded Delta = C.GIT_DELTA_ADDED
+ DeltaDeleted Delta = C.GIT_DELTA_DELETED
+ DeltaModified Delta = C.GIT_DELTA_MODIFIED
+ DeltaRenamed Delta = C.GIT_DELTA_RENAMED
+ DeltaCopied Delta = C.GIT_DELTA_COPIED
+ DeltaIgnored Delta = C.GIT_DELTA_IGNORED
+ DeltaUntracked Delta = C.GIT_DELTA_UNTRACKED
+ DeltaTypeChange Delta = C.GIT_DELTA_TYPECHANGE
+ DeltaUnreadable Delta = C.GIT_DELTA_UNREADABLE
+ DeltaConflicted Delta = C.GIT_DELTA_CONFLICTED
+)
+
+type DiffLineType int
+
+const (
+ DiffLineContext DiffLineType = C.GIT_DIFF_LINE_CONTEXT
+ DiffLineAddition DiffLineType = C.GIT_DIFF_LINE_ADDITION
+ DiffLineDeletion DiffLineType = C.GIT_DIFF_LINE_DELETION
+ DiffLineContextEOFNL DiffLineType = C.GIT_DIFF_LINE_CONTEXT_EOFNL
+ DiffLineAddEOFNL DiffLineType = C.GIT_DIFF_LINE_ADD_EOFNL
+ DiffLineDelEOFNL DiffLineType = C.GIT_DIFF_LINE_DEL_EOFNL
+
+ DiffLineFileHdr DiffLineType = C.GIT_DIFF_LINE_FILE_HDR
+ DiffLineHunkHdr DiffLineType = C.GIT_DIFF_LINE_HUNK_HDR
+ DiffLineBinary DiffLineType = C.GIT_DIFF_LINE_BINARY
+)
+
+type DiffFile struct {
+ Path string
+ Oid *Oid
+ Size int
+ Flags DiffFlag
+ Mode uint16
+}
+
+func diffFileFromC(file *C.git_diff_file) DiffFile {
+ return DiffFile{
+ Path: C.GoString(file.path),
+ Oid: newOidFromC(&file.id),
+ Size: int(file.size),
+ Flags: DiffFlag(file.flags),
+ Mode: uint16(file.mode),
+ }
+}
+
+type DiffDelta struct {
+ Status Delta
+ Flags DiffFlag
+ Similarity uint16
+ OldFile DiffFile
+ NewFile DiffFile
+}
+
+func diffDeltaFromC(delta *C.git_diff_delta) DiffDelta {
+ return DiffDelta{
+ Status: Delta(delta.status),
+ Flags: DiffFlag(delta.flags),
+ Similarity: uint16(delta.similarity),
+ OldFile: diffFileFromC(&delta.old_file),
+ NewFile: diffFileFromC(&delta.new_file),
+ }
+}
+
+type DiffHunk struct {
+ OldStart int
+ OldLines int
+ NewStart int
+ NewLines int
+ Header string
+}
+
+func diffHunkFromC(hunk *C.git_diff_hunk) DiffHunk {
+ return DiffHunk{
+ OldStart: int(hunk.old_start),
+ OldLines: int(hunk.old_lines),
+ NewStart: int(hunk.new_start),
+ NewLines: int(hunk.new_lines),
+ Header: C.GoStringN(&hunk.header[0], C.int(hunk.header_len)),
+ }
+}
+
+type DiffLine struct {
+ Origin DiffLineType
+ OldLineno int
+ NewLineno int
+ NumLines int
+ Content string
+}
+
+func diffLineFromC(line *C.git_diff_line) DiffLine {
+ return DiffLine{
+ Origin: DiffLineType(line.origin),
+ OldLineno: int(line.old_lineno),
+ NewLineno: int(line.new_lineno),
+ NumLines: int(line.num_lines),
+ Content: C.GoStringN(line.content, C.int(line.content_len)),
+ }
+}
+
+type Diff struct {
+ ptr *C.git_diff
+}
+
+func (diff *Diff) NumDeltas() (int, error) {
+ if diff.ptr == nil {
+ return -1, ErrInvalid
+ }
+ return int(C.git_diff_num_deltas(diff.ptr)), nil
+}
+
+func (diff *Diff) GetDelta(index int) (DiffDelta, error) {
+ if diff.ptr == nil {
+ return DiffDelta{}, ErrInvalid
+ }
+ ptr := C.git_diff_get_delta(diff.ptr, C.size_t(index))
+ return diffDeltaFromC(ptr), nil
+}
+
+func newDiffFromC(ptr *C.git_diff) *Diff {
+ if ptr == nil {
+ return nil
+ }
+
+ diff := &Diff{
+ ptr: ptr,
+ }
+
+ runtime.SetFinalizer(diff, (*Diff).Free)
+ return diff
+}
+
+func (diff *Diff) Free() error {
+ if diff.ptr == nil {
+ return ErrInvalid
+ }
+ runtime.SetFinalizer(diff, nil)
+ C.git_diff_free(diff.ptr)
+ diff.ptr = nil
+ return nil
+}
+
+func (diff *Diff) FindSimilar(opts *DiffFindOptions) error {
+
+ var copts *C.git_diff_find_options
+ if opts != nil {
+ copts = &C.git_diff_find_options{
+ version: C.GIT_DIFF_FIND_OPTIONS_VERSION,
+ flags: C.uint32_t(opts.Flags),
+ rename_threshold: C.uint16_t(opts.RenameThreshold),
+ copy_threshold: C.uint16_t(opts.CopyThreshold),
+ rename_from_rewrite_threshold: C.uint16_t(opts.RenameFromRewriteThreshold),
+ break_rewrite_threshold: C.uint16_t(opts.BreakRewriteThreshold),
+ rename_limit: C.size_t(opts.RenameLimit),
+ }
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_find_similar(diff.ptr, copts)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+
+ return nil
+}
+
+type DiffStats struct {
+ ptr *C.git_diff_stats
+}
+
+func (stats *DiffStats) Free() error {
+ if stats.ptr == nil {
+ return ErrInvalid
+ }
+ runtime.SetFinalizer(stats, nil)
+ C.git_diff_stats_free(stats.ptr)
+ stats.ptr = nil
+ return nil
+}
+
+func (stats *DiffStats) Insertions() int {
+ return int(C.git_diff_stats_insertions(stats.ptr))
+}
+
+func (stats *DiffStats) Deletions() int {
+ return int(C.git_diff_stats_deletions(stats.ptr))
+}
+
+func (stats *DiffStats) FilesChanged() int {
+ return int(C.git_diff_stats_files_changed(stats.ptr))
+}
+
+type DiffStatsFormat int
+
+const (
+ DiffStatsNone DiffStatsFormat = C.GIT_DIFF_STATS_NONE
+ DiffStatsFull DiffStatsFormat = C.GIT_DIFF_STATS_FULL
+ DiffStatsShort DiffStatsFormat = C.GIT_DIFF_STATS_SHORT
+ DiffStatsNumber DiffStatsFormat = C.GIT_DIFF_STATS_NUMBER
+ DiffStatsIncludeSummary DiffStatsFormat = C.GIT_DIFF_STATS_INCLUDE_SUMMARY
+)
+
+func (stats *DiffStats) String(format DiffStatsFormat,
+ width uint) (string, error) {
+ buf := C.git_buf{}
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_diff_stats_to_buf(&buf,
+ stats.ptr, C.git_diff_stats_format_t(format), C.size_t(width))
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
+
+func (diff *Diff) Stats() (*DiffStats, error) {
+ stats := new(DiffStats)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ecode := C.git_diff_get_stats(&stats.ptr, diff.ptr); ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ runtime.SetFinalizer(stats, (*DiffStats).Free)
+
+ return stats, nil
+}
+
+type diffForEachData struct {
+ FileCallback DiffForEachFileCallback
+ HunkCallback DiffForEachHunkCallback
+ LineCallback DiffForEachLineCallback
+ Error error
+}
+
+type DiffForEachFileCallback func(DiffDelta, float64) (DiffForEachHunkCallback, error)
+
+type DiffDetail int
+
+const (
+ DiffDetailFiles DiffDetail = iota
+ DiffDetailHunks
+ DiffDetailLines
+)
+
+func (diff *Diff) ForEach(cbFile DiffForEachFileCallback, detail DiffDetail) error {
+ if diff.ptr == nil {
+ return ErrInvalid
+ }
+
+ intHunks := C.int(0)
+ if detail >= DiffDetailHunks {
+ intHunks = C.int(1)
+ }
+
+ intLines := C.int(0)
+ if detail >= DiffDetailLines {
+ intLines = C.int(1)
+ }
+
+ data := &diffForEachData{
+ FileCallback: cbFile,
+ }
+
+ handle := pointerHandles.Track(data)
+ defer pointerHandles.Untrack(handle)
+
+ ecode := C._go_git_diff_foreach(diff.ptr, 1, intHunks, intLines, handle)
+ if ecode < 0 {
+ return data.Error
+ }
+ return nil
+}
+
+//export diffForEachFileCb
+func diffForEachFileCb(delta *C.git_diff_delta, progress C.float, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*diffForEachData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ data.HunkCallback = nil
+ if data.FileCallback != nil {
+ cb, err := data.FileCallback(diffDeltaFromC(delta), float64(progress))
+ if err != nil {
+ data.Error = err
+ return -1
+ }
+ data.HunkCallback = cb
+ }
+
+ return 0
+}
+
+type DiffForEachHunkCallback func(DiffHunk) (DiffForEachLineCallback, error)
+
+//export diffForEachHunkCb
+func diffForEachHunkCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*diffForEachData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ data.LineCallback = nil
+ if data.HunkCallback != nil {
+ cb, err := data.HunkCallback(diffHunkFromC(hunk))
+ if err != nil {
+ data.Error = err
+ return -1
+ }
+ data.LineCallback = cb
+ }
+
+ return 0
+}
+
+type DiffForEachLineCallback func(DiffLine) error
+
+//export diffForEachLineCb
+func diffForEachLineCb(delta *C.git_diff_delta, hunk *C.git_diff_hunk, line *C.git_diff_line, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*diffForEachData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ err := data.LineCallback(diffLineFromC(line))
+ if err != nil {
+ data.Error = err
+ return -1
+ }
+
+ return 0
+}
+
+func (diff *Diff) Patch(deltaIndex int) (*Patch, error) {
+ if diff.ptr == nil {
+ return nil, ErrInvalid
+ }
+ var patchPtr *C.git_patch
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_patch_from_diff(&patchPtr, diff.ptr, C.size_t(deltaIndex))
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newPatchFromC(patchPtr), nil
+}
+
+type DiffOptionsFlag int
+
+const (
+ DiffNormal DiffOptionsFlag = C.GIT_DIFF_NORMAL
+ DiffReverse DiffOptionsFlag = C.GIT_DIFF_REVERSE
+ DiffIncludeIgnored DiffOptionsFlag = C.GIT_DIFF_INCLUDE_IGNORED
+ DiffRecurseIgnoredDirs DiffOptionsFlag = C.GIT_DIFF_RECURSE_IGNORED_DIRS
+ DiffIncludeUntracked DiffOptionsFlag = C.GIT_DIFF_INCLUDE_UNTRACKED
+ DiffRecurseUntracked DiffOptionsFlag = C.GIT_DIFF_RECURSE_UNTRACKED_DIRS
+ DiffIncludeUnmodified DiffOptionsFlag = C.GIT_DIFF_INCLUDE_UNMODIFIED
+ DiffIncludeTypeChange DiffOptionsFlag = C.GIT_DIFF_INCLUDE_TYPECHANGE
+ DiffIncludeTypeChangeTrees DiffOptionsFlag = C.GIT_DIFF_INCLUDE_TYPECHANGE_TREES
+ DiffIgnoreFilemode DiffOptionsFlag = C.GIT_DIFF_IGNORE_FILEMODE
+ DiffIgnoreSubmodules DiffOptionsFlag = C.GIT_DIFF_IGNORE_SUBMODULES
+ DiffIgnoreCase DiffOptionsFlag = C.GIT_DIFF_IGNORE_CASE
+ DiffIncludeCaseChange DiffOptionsFlag = C.GIT_DIFF_INCLUDE_CASECHANGE
+
+ DiffDisablePathspecMatch DiffOptionsFlag = C.GIT_DIFF_DISABLE_PATHSPEC_MATCH
+ DiffSkipBinaryCheck DiffOptionsFlag = C.GIT_DIFF_SKIP_BINARY_CHECK
+ DiffEnableFastUntrackedDirs DiffOptionsFlag = C.GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS
+
+ DiffForceText DiffOptionsFlag = C.GIT_DIFF_FORCE_TEXT
+ DiffForceBinary DiffOptionsFlag = C.GIT_DIFF_FORCE_BINARY
+
+ DiffIgnoreWhitespace DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE
+ DiffIgnoreWhitespaceChange DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE_CHANGE
+ DiffIgnoreWitespaceEol DiffOptionsFlag = C.GIT_DIFF_IGNORE_WHITESPACE_EOL
+
+ DiffShowUntrackedContent DiffOptionsFlag = C.GIT_DIFF_SHOW_UNTRACKED_CONTENT
+ DiffShowUnmodified DiffOptionsFlag = C.GIT_DIFF_SHOW_UNMODIFIED
+ DiffPatience DiffOptionsFlag = C.GIT_DIFF_PATIENCE
+ DiffMinimal DiffOptionsFlag = C.GIT_DIFF_MINIMAL
+)
+
+type DiffNotifyCallback func(diffSoFar *Diff, deltaToAdd DiffDelta, matchedPathspec string) error
+
+type DiffOptions struct {
+ Flags DiffOptionsFlag
+ IgnoreSubmodules SubmoduleIgnore
+ Pathspec []string
+ NotifyCallback DiffNotifyCallback
+
+ ContextLines uint32
+ InterhunkLines uint32
+ IdAbbrev uint16
+
+ MaxSize int
+
+ OldPrefix string
+ NewPrefix string
+}
+
+func DefaultDiffOptions() (DiffOptions, error) {
+ opts := C.git_diff_options{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_init_options(&opts, C.GIT_DIFF_OPTIONS_VERSION)
+ if ecode < 0 {
+ return DiffOptions{}, MakeGitError(ecode)
+ }
+
+ return DiffOptions{
+ Flags: DiffOptionsFlag(opts.flags),
+ IgnoreSubmodules: SubmoduleIgnore(opts.ignore_submodules),
+ Pathspec: makeStringsFromCStrings(opts.pathspec.strings, int(opts.pathspec.count)),
+ ContextLines: uint32(opts.context_lines),
+ InterhunkLines: uint32(opts.interhunk_lines),
+ IdAbbrev: uint16(opts.id_abbrev),
+ MaxSize: int(opts.max_size),
+ OldPrefix: "a",
+ NewPrefix: "b",
+ }, nil
+}
+
+type DiffFindOptionsFlag int
+
+const (
+ DiffFindByConfig DiffFindOptionsFlag = C.GIT_DIFF_FIND_BY_CONFIG
+ DiffFindRenames DiffFindOptionsFlag = C.GIT_DIFF_FIND_RENAMES
+ DiffFindRenamesFromRewrites DiffFindOptionsFlag = C.GIT_DIFF_FIND_RENAMES_FROM_REWRITES
+ DiffFindCopies DiffFindOptionsFlag = C.GIT_DIFF_FIND_COPIES
+ DiffFindCopiesFromUnmodified DiffFindOptionsFlag = C.GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED
+ DiffFindRewrites DiffFindOptionsFlag = C.GIT_DIFF_FIND_REWRITES
+ DiffFindBreakRewrites DiffFindOptionsFlag = C.GIT_DIFF_BREAK_REWRITES
+ DiffFindAndBreakRewrites DiffFindOptionsFlag = C.GIT_DIFF_FIND_AND_BREAK_REWRITES
+ DiffFindForUntracked DiffFindOptionsFlag = C.GIT_DIFF_FIND_FOR_UNTRACKED
+ DiffFindAll DiffFindOptionsFlag = C.GIT_DIFF_FIND_ALL
+ DiffFindIgnoreLeadingWhitespace DiffFindOptionsFlag = C.GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE
+ DiffFindIgnoreWhitespace DiffFindOptionsFlag = C.GIT_DIFF_FIND_IGNORE_WHITESPACE
+ DiffFindDontIgnoreWhitespace DiffFindOptionsFlag = C.GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE
+ DiffFindExactMatchOnly DiffFindOptionsFlag = C.GIT_DIFF_FIND_EXACT_MATCH_ONLY
+ DiffFindBreakRewritesForRenamesOnly DiffFindOptionsFlag = C.GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY
+ DiffFindRemoveUnmodified DiffFindOptionsFlag = C.GIT_DIFF_FIND_REMOVE_UNMODIFIED
+)
+
+//TODO implement git_diff_similarity_metric
+type DiffFindOptions struct {
+ Flags DiffFindOptionsFlag
+ RenameThreshold uint16
+ CopyThreshold uint16
+ RenameFromRewriteThreshold uint16
+ BreakRewriteThreshold uint16
+ RenameLimit uint
+}
+
+func DefaultDiffFindOptions() (DiffFindOptions, error) {
+ opts := C.git_diff_find_options{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_find_init_options(&opts, C.GIT_DIFF_FIND_OPTIONS_VERSION)
+ if ecode < 0 {
+ return DiffFindOptions{}, MakeGitError(ecode)
+ }
+
+ return DiffFindOptions{
+ Flags: DiffFindOptionsFlag(opts.flags),
+ RenameThreshold: uint16(opts.rename_threshold),
+ CopyThreshold: uint16(opts.copy_threshold),
+ RenameFromRewriteThreshold: uint16(opts.rename_from_rewrite_threshold),
+ BreakRewriteThreshold: uint16(opts.break_rewrite_threshold),
+ RenameLimit: uint(opts.rename_limit),
+ }, nil
+}
+
+var (
+ ErrDeltaSkip = errors.New("Skip delta")
+)
+
+type diffNotifyData struct {
+ Callback DiffNotifyCallback
+ Diff *Diff
+ Error error
+}
+
+//export diffNotifyCb
+func diffNotifyCb(_diff_so_far unsafe.Pointer, delta_to_add *C.git_diff_delta, matched_pathspec *C.char, handle unsafe.Pointer) int {
+ diff_so_far := (*C.git_diff)(_diff_so_far)
+
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*diffNotifyData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ if data != nil {
+ if data.Diff == nil {
+ data.Diff = newDiffFromC(diff_so_far)
+ }
+
+ err := data.Callback(data.Diff, diffDeltaFromC(delta_to_add), C.GoString(matched_pathspec))
+
+ if err == ErrDeltaSkip {
+ return 1
+ } else if err != nil {
+ data.Error = err
+ return -1
+ } else {
+ return 0
+ }
+ }
+ return 0
+}
+
+func diffOptionsToC(opts *DiffOptions) (copts *C.git_diff_options, notifyData *diffNotifyData) {
+ cpathspec := C.git_strarray{}
+ if opts != nil {
+ notifyData = &diffNotifyData{
+ Callback: opts.NotifyCallback,
+ }
+
+ if opts.Pathspec != nil {
+ cpathspec.count = C.size_t(len(opts.Pathspec))
+ cpathspec.strings = makeCStringsFromStrings(opts.Pathspec)
+ }
+
+ copts = &C.git_diff_options{
+ version: C.GIT_DIFF_OPTIONS_VERSION,
+ flags: C.uint32_t(opts.Flags),
+ ignore_submodules: C.git_submodule_ignore_t(opts.IgnoreSubmodules),
+ pathspec: cpathspec,
+ context_lines: C.uint32_t(opts.ContextLines),
+ interhunk_lines: C.uint32_t(opts.InterhunkLines),
+ id_abbrev: C.uint16_t(opts.IdAbbrev),
+ max_size: C.git_off_t(opts.MaxSize),
+ old_prefix: C.CString(opts.OldPrefix),
+ new_prefix: C.CString(opts.NewPrefix),
+ }
+
+ if opts.NotifyCallback != nil {
+ C._go_git_setup_diff_notify_callbacks(copts)
+ copts.payload = pointerHandles.Track(notifyData)
+ }
+ }
+ return
+}
+
+func freeDiffOptions(copts *C.git_diff_options) {
+ if copts != nil {
+ cpathspec := copts.pathspec
+ freeStrarray(&cpathspec)
+ C.free(unsafe.Pointer(copts.old_prefix))
+ C.free(unsafe.Pointer(copts.new_prefix))
+ if copts.payload != nil {
+ pointerHandles.Untrack(copts.payload)
+ }
+ }
+}
+
+func (v *Repository) DiffTreeToTree(oldTree, newTree *Tree, opts *DiffOptions) (*Diff, error) {
+ var diffPtr *C.git_diff
+ var oldPtr, newPtr *C.git_tree
+
+ if oldTree != nil {
+ oldPtr = oldTree.cast_ptr
+ }
+
+ if newTree != nil {
+ newPtr = newTree.cast_ptr
+ }
+
+ copts, notifyData := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_tree_to_tree(&diffPtr, v.ptr, oldPtr, newPtr, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ if notifyData != nil && notifyData.Diff != nil {
+ return notifyData.Diff, nil
+ }
+ return newDiffFromC(diffPtr), nil
+}
+
+func (v *Repository) DiffTreeToWorkdir(oldTree *Tree, opts *DiffOptions) (*Diff, error) {
+ var diffPtr *C.git_diff
+ var oldPtr *C.git_tree
+
+ if oldTree != nil {
+ oldPtr = oldTree.cast_ptr
+ }
+
+ copts, notifyData := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_tree_to_workdir(&diffPtr, v.ptr, oldPtr, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ if notifyData != nil && notifyData.Diff != nil {
+ return notifyData.Diff, nil
+ }
+ return newDiffFromC(diffPtr), nil
+}
+
+func (v *Repository) DiffTreeToIndex(oldTree *Tree, index *Index, opts *DiffOptions) (*Diff, error) {
+ var diffPtr *C.git_diff
+ var oldPtr *C.git_tree
+ var indexPtr *C.git_index
+
+ if oldTree != nil {
+ oldPtr = oldTree.cast_ptr
+ }
+
+ if index != nil {
+ indexPtr = index.ptr
+ }
+
+ copts, notifyData := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_tree_to_index(&diffPtr, v.ptr, oldPtr, indexPtr, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ if notifyData != nil && notifyData.Diff != nil {
+ return notifyData.Diff, nil
+ }
+ return newDiffFromC(diffPtr), nil
+}
+
+func (v *Repository) DiffTreeToWorkdirWithIndex(oldTree *Tree, opts *DiffOptions) (*Diff, error) {
+ var diffPtr *C.git_diff
+ var oldPtr *C.git_tree
+
+ if oldTree != nil {
+ oldPtr = oldTree.cast_ptr
+ }
+
+ copts, notifyData := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_tree_to_workdir_with_index(&diffPtr, v.ptr, oldPtr, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ if notifyData != nil && notifyData.Diff != nil {
+ return notifyData.Diff, nil
+ }
+ return newDiffFromC(diffPtr), nil
+}
+
+func (v *Repository) DiffIndexToWorkdir(index *Index, opts *DiffOptions) (*Diff, error) {
+ var diffPtr *C.git_diff
+ var indexPtr *C.git_index
+
+ if index != nil {
+ indexPtr = index.ptr
+ }
+
+ copts, notifyData := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_diff_index_to_workdir(&diffPtr, v.ptr, indexPtr, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ if notifyData != nil && notifyData.Diff != nil {
+ return notifyData.Diff, nil
+ }
+ return newDiffFromC(diffPtr), nil
+}
+
+// DiffBlobs performs a diff between two arbitrary blobs. You can pass
+// whatever file names you'd like for them to appear as in the diff.
+func DiffBlobs(oldBlob *Blob, oldAsPath string, newBlob *Blob, newAsPath string, opts *DiffOptions, fileCallback DiffForEachFileCallback, detail DiffDetail) error {
+ data := &diffForEachData{
+ FileCallback: fileCallback,
+ }
+
+ intHunks := C.int(0)
+ if detail >= DiffDetailHunks {
+ intHunks = C.int(1)
+ }
+
+ intLines := C.int(0)
+ if detail >= DiffDetailLines {
+ intLines = C.int(1)
+ }
+
+ handle := pointerHandles.Track(data)
+ defer pointerHandles.Untrack(handle)
+
+ var oldBlobPtr, newBlobPtr *C.git_blob
+ if oldBlob != nil {
+ oldBlobPtr = oldBlob.cast_ptr
+ }
+ if newBlob != nil {
+ newBlobPtr = newBlob.cast_ptr
+ }
+
+ oldBlobPath := C.CString(oldAsPath)
+ defer C.free(unsafe.Pointer(oldBlobPath))
+ newBlobPath := C.CString(newAsPath)
+ defer C.free(unsafe.Pointer(newBlobPath))
+
+ copts, _ := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C._go_git_diff_blobs(oldBlobPtr, oldBlobPath, newBlobPtr, newBlobPath, copts, 1, intHunks, intLines, handle)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/features.go b/vendor/gopkg.in/libgit2/git2go.v25/features.go
new file mode 100644
index 0000000000000000000000000000000000000000..f6474a061878a3bb51b2927416b3b38357cf9824
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/features.go
@@ -0,0 +1,30 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+
+type Feature int
+
+const (
+ // libgit2 was built with threading support
+ FeatureThreads Feature = C.GIT_FEATURE_THREADS
+
+ // libgit2 was built with HTTPS support built-in
+ FeatureHttps Feature = C.GIT_FEATURE_HTTPS
+
+ // libgit2 was build with SSH support built-in
+ FeatureSsh Feature = C.GIT_FEATURE_SSH
+
+ // libgit2 was built with nanosecond support for files
+ FeatureNSec Feature = C.GIT_FEATURE_NSEC
+)
+
+// Features returns a bit-flag of Feature values indicating which features the
+// loaded libgit2 library has.
+func Features() Feature {
+ features := C.git_libgit2_features()
+
+ return Feature(features)
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/git.go b/vendor/gopkg.in/libgit2/git2go.v25/git.go
new file mode 100644
index 0000000000000000000000000000000000000000..31d863a93949ea43d9d9f49adb2ca07ab08cd4e7
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/git.go
@@ -0,0 +1,326 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/sys/openssl.h>
+
+#if LIBGIT2_VER_MAJOR != 0 || LIBGIT2_VER_MINOR != 25
+# error "Invalid libgit2 version; this git2go supports libgit2 v0.25"
+#endif
+
+*/
+import "C"
+import (
+ "bytes"
+ "encoding/hex"
+ "errors"
+ "runtime"
+ "strings"
+ "unsafe"
+)
+
+type ErrorClass int
+
+const (
+ ErrClassNone ErrorClass = C.GITERR_NONE
+ ErrClassNoMemory ErrorClass = C.GITERR_NOMEMORY
+ ErrClassOs ErrorClass = C.GITERR_OS
+ ErrClassInvalid ErrorClass = C.GITERR_INVALID
+ ErrClassReference ErrorClass = C.GITERR_REFERENCE
+ ErrClassZlib ErrorClass = C.GITERR_ZLIB
+ ErrClassRepository ErrorClass = C.GITERR_REPOSITORY
+ ErrClassConfig ErrorClass = C.GITERR_CONFIG
+ ErrClassRegex ErrorClass = C.GITERR_REGEX
+ ErrClassOdb ErrorClass = C.GITERR_ODB
+ ErrClassIndex ErrorClass = C.GITERR_INDEX
+ ErrClassObject ErrorClass = C.GITERR_OBJECT
+ ErrClassNet ErrorClass = C.GITERR_NET
+ ErrClassTag ErrorClass = C.GITERR_TAG
+ ErrClassTree ErrorClass = C.GITERR_TREE
+ ErrClassIndexer ErrorClass = C.GITERR_INDEXER
+ ErrClassSSL ErrorClass = C.GITERR_SSL
+ ErrClassSubmodule ErrorClass = C.GITERR_SUBMODULE
+ ErrClassThread ErrorClass = C.GITERR_THREAD
+ ErrClassStash ErrorClass = C.GITERR_STASH
+ ErrClassCheckout ErrorClass = C.GITERR_CHECKOUT
+ ErrClassFetchHead ErrorClass = C.GITERR_FETCHHEAD
+ ErrClassMerge ErrorClass = C.GITERR_MERGE
+ ErrClassSsh ErrorClass = C.GITERR_SSH
+ ErrClassFilter ErrorClass = C.GITERR_FILTER
+ ErrClassRevert ErrorClass = C.GITERR_REVERT
+ ErrClassCallback ErrorClass = C.GITERR_CALLBACK
+)
+
+type ErrorCode int
+
+const (
+
+ // No error
+ ErrOk ErrorCode = C.GIT_OK
+
+ // Generic error
+ ErrGeneric ErrorCode = C.GIT_ERROR
+ // Requested object could not be found
+ ErrNotFound ErrorCode = C.GIT_ENOTFOUND
+ // Object exists preventing operation
+ ErrExists ErrorCode = C.GIT_EEXISTS
+ // More than one object matches
+ ErrAmbigious ErrorCode = C.GIT_EAMBIGUOUS
+ // Output buffer too short to hold data
+ ErrBuffs ErrorCode = C.GIT_EBUFS
+
+ // GIT_EUSER is a special error that is never generated by libgit2
+ // code. You can return it from a callback (e.g to stop an iteration)
+ // to know that it was generated by the callback and not by libgit2.
+ ErrUser ErrorCode = C.GIT_EUSER
+
+ // Operation not allowed on bare repository
+ ErrBareRepo ErrorCode = C.GIT_EBAREREPO
+ // HEAD refers to branch with no commits
+ ErrUnbornBranch ErrorCode = C.GIT_EUNBORNBRANCH
+ // Merge in progress prevented operation
+ ErrUnmerged ErrorCode = C.GIT_EUNMERGED
+ // Reference was not fast-forwardable
+ ErrNonFastForward ErrorCode = C.GIT_ENONFASTFORWARD
+ // Name/ref spec was not in a valid format
+ ErrInvalidSpec ErrorCode = C.GIT_EINVALIDSPEC
+ // Checkout conflicts prevented operation
+ ErrConflict ErrorCode = C.GIT_ECONFLICT
+ // Lock file prevented operation
+ ErrLocked ErrorCode = C.GIT_ELOCKED
+ // Reference value does not match expected
+ ErrModified ErrorCode = C.GIT_EMODIFIED
+ // Authentication failed
+ ErrAuth ErrorCode = C.GIT_EAUTH
+ // Server certificate is invalid
+ ErrCertificate ErrorCode = C.GIT_ECERTIFICATE
+ // Patch/merge has already been applied
+ ErrApplied ErrorCode = C.GIT_EAPPLIED
+ // The requested peel operation is not possible
+ ErrPeel ErrorCode = C.GIT_EPEEL
+ // Unexpected EOF
+ ErrEOF ErrorCode = C.GIT_EEOF
+ // Uncommitted changes in index prevented operation
+ ErrUncommitted ErrorCode = C.GIT_EUNCOMMITTED
+ // The operation is not valid for a directory
+ ErrDirectory ErrorCode = C.GIT_EDIRECTORY
+ // A merge conflict exists and cannot continue
+ ErrMergeConflict ErrorCode = C.GIT_EMERGECONFLICT
+
+ // Internal only
+ ErrPassthrough ErrorCode = C.GIT_PASSTHROUGH
+ // Signals end of iteration with iterator
+ ErrIterOver ErrorCode = C.GIT_ITEROVER
+)
+
+var (
+ ErrInvalid = errors.New("Invalid state for operation")
+)
+
+var pointerHandles *HandleList
+
+func init() {
+ pointerHandles = NewHandleList()
+
+ C.git_libgit2_init()
+
+ // Due to the multithreaded nature of Go and its interaction with
+ // calling C functions, we cannot work with a library that was not built
+ // with multi-threading support. The most likely outcome is a segfault
+ // or panic at an incomprehensible time, so let's make it easy by
+ // panicking right here.
+ if Features()&FeatureThreads == 0 {
+ panic("libgit2 was not built with threading support")
+ }
+
+ // This is not something we should be doing, as we may be
+ // stomping all over someone else's setup. The user should do
+ // this themselves or use some binding/wrapper which does it
+ // in such a way that they can be sure they're the only ones
+ // setting it up.
+ C.git_openssl_set_locking()
+}
+
+// Oid represents the id for a Git object.
+type Oid [20]byte
+
+func newOidFromC(coid *C.git_oid) *Oid {
+ if coid == nil {
+ return nil
+ }
+
+ oid := new(Oid)
+ copy(oid[0:20], C.GoBytes(unsafe.Pointer(coid), 20))
+ return oid
+}
+
+func NewOidFromBytes(b []byte) *Oid {
+ oid := new(Oid)
+ copy(oid[0:20], b[0:20])
+ return oid
+}
+
+func (oid *Oid) toC() *C.git_oid {
+ return (*C.git_oid)(unsafe.Pointer(oid))
+}
+
+func NewOid(s string) (*Oid, error) {
+ if len(s) > C.GIT_OID_HEXSZ {
+ return nil, errors.New("string is too long for oid")
+ }
+
+ o := new(Oid)
+
+ slice, error := hex.DecodeString(s)
+ if error != nil {
+ return nil, error
+ }
+
+ if len(slice) != 20 {
+ return nil, &GitError{"Invalid Oid", ErrClassNone, ErrGeneric}
+ }
+
+ copy(o[:], slice[:20])
+ return o, nil
+}
+
+func (oid *Oid) String() string {
+ return hex.EncodeToString(oid[:])
+}
+
+func (oid *Oid) Cmp(oid2 *Oid) int {
+ return bytes.Compare(oid[:], oid2[:])
+}
+
+func (oid *Oid) Copy() *Oid {
+ ret := new(Oid)
+ copy(ret[:], oid[:])
+ return ret
+}
+
+func (oid *Oid) Equal(oid2 *Oid) bool {
+ return bytes.Equal(oid[:], oid2[:])
+}
+
+func (oid *Oid) IsZero() bool {
+ for _, a := range oid {
+ if a != 0 {
+ return false
+ }
+ }
+ return true
+}
+
+func (oid *Oid) NCmp(oid2 *Oid, n uint) int {
+ return bytes.Compare(oid[:n], oid2[:n])
+}
+
+func ShortenOids(ids []*Oid, minlen int) (int, error) {
+ shorten := C.git_oid_shorten_new(C.size_t(minlen))
+ if shorten == nil {
+ panic("Out of memory")
+ }
+ defer C.git_oid_shorten_free(shorten)
+
+ var ret C.int
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ for _, id := range ids {
+ buf := make([]byte, 41)
+ C.git_oid_fmt((*C.char)(unsafe.Pointer(&buf[0])), id.toC())
+ buf[40] = 0
+ ret = C.git_oid_shorten_add(shorten, (*C.char)(unsafe.Pointer(&buf[0])))
+ if ret < 0 {
+ return int(ret), MakeGitError(ret)
+ }
+ }
+ return int(ret), nil
+}
+
+type GitError struct {
+ Message string
+ Class ErrorClass
+ Code ErrorCode
+}
+
+func (e GitError) Error() string {
+ return e.Message
+}
+
+func IsErrorClass(err error, c ErrorClass) bool {
+
+ if err == nil {
+ return false
+ }
+ if gitError, ok := err.(*GitError); ok {
+ return gitError.Class == c
+ }
+ return false
+}
+
+func IsErrorCode(err error, c ErrorCode) bool {
+ if err == nil {
+ return false
+ }
+ if gitError, ok := err.(*GitError); ok {
+ return gitError.Code == c
+ }
+ return false
+}
+
+func MakeGitError(errorCode C.int) error {
+
+ var errMessage string
+ var errClass ErrorClass
+ if errorCode != C.GIT_ITEROVER {
+ err := C.giterr_last()
+ if err != nil {
+ errMessage = C.GoString(err.message)
+ errClass = ErrorClass(err.klass)
+ } else {
+ errClass = ErrClassInvalid
+ }
+ }
+ return &GitError{errMessage, errClass, ErrorCode(errorCode)}
+}
+
+func MakeGitError2(err int) error {
+ return MakeGitError(C.int(err))
+}
+
+func cbool(b bool) C.int {
+ if b {
+ return C.int(1)
+ }
+ return C.int(0)
+}
+
+func ucbool(b bool) C.uint {
+ if b {
+ return C.uint(1)
+ }
+ return C.uint(0)
+}
+
+func Discover(start string, across_fs bool, ceiling_dirs []string) (string, error) {
+ ceildirs := C.CString(strings.Join(ceiling_dirs, string(C.GIT_PATH_LIST_SEPARATOR)))
+ defer C.free(unsafe.Pointer(ceildirs))
+
+ cstart := C.CString(start)
+ defer C.free(unsafe.Pointer(cstart))
+
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_discover(&buf, cstart, cbool(across_fs), ceildirs)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/git_dynamic.go b/vendor/gopkg.in/libgit2/git2go.v25/git_dynamic.go
new file mode 100644
index 0000000000000000000000000000000000000000..75d9cbc7e9790b554121b2e3eef94e10c76c2a9e
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/git_dynamic.go
@@ -0,0 +1,9 @@
+// +build !static
+
+package git
+
+/*
+#cgo pkg-config: libgit2
+#include <git2.h>
+*/
+import "C"
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/git_static.go b/vendor/gopkg.in/libgit2/git2go.v25/git_static.go
new file mode 100644
index 0000000000000000000000000000000000000000..062dd95ac78f6a00eba1d0fe1418ec9ac65bb9d6
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/git_static.go
@@ -0,0 +1,11 @@
+// +build static
+
+package git
+
+/*
+#cgo CFLAGS: -I${SRCDIR}/vendor/libgit2/include
+#cgo LDFLAGS: -L${SRCDIR}/vendor/libgit2/build/ -lgit2
+#cgo windows LDFLAGS: -lwinhttp
+#cgo !windows pkg-config: --static ${SRCDIR}/vendor/libgit2/build/libgit2.pc
+*/
+import "C"
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/graph.go b/vendor/gopkg.in/libgit2/git2go.v25/graph.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5d773244c7835ff222f5b942feebe8ad571fd12
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/graph.go
@@ -0,0 +1,36 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+)
+
+func (repo *Repository) DescendantOf(commit, ancestor *Oid) (bool, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_graph_descendant_of(repo.ptr, commit.toC(), ancestor.toC())
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return (ret > 0), nil
+}
+
+func (repo *Repository) AheadBehind(local, upstream *Oid) (ahead, behind int, err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var aheadT C.size_t
+ var behindT C.size_t
+
+ ret := C.git_graph_ahead_behind(&aheadT, &behindT, repo.ptr, local.toC(), upstream.toC())
+ if ret < 0 {
+ return 0, 0, MakeGitError(ret)
+ }
+
+ return int(aheadT), int(behindT), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/handles.go b/vendor/gopkg.in/libgit2/git2go.v25/handles.go
new file mode 100644
index 0000000000000000000000000000000000000000..d27d3c35383f5d249ab0fe32b8bc351f1c53cfdc
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/handles.go
@@ -0,0 +1,57 @@
+package git
+
+/*
+#include <stdlib.h>
+*/
+import "C"
+import (
+ "fmt"
+ "sync"
+ "unsafe"
+)
+
+type HandleList struct {
+ sync.RWMutex
+ // stores the Go pointers
+ handles map[unsafe.Pointer]interface{}
+}
+
+func NewHandleList() *HandleList {
+ return &HandleList{
+ handles: make(map[unsafe.Pointer]interface{}),
+ }
+}
+
+// Track adds the given pointer to the list of pointers to track and
+// returns a pointer value which can be passed to C as an opaque
+// pointer.
+func (v *HandleList) Track(pointer interface{}) unsafe.Pointer {
+ handle := C.malloc(1)
+
+ v.Lock()
+ v.handles[handle] = pointer
+ v.Unlock()
+
+ return handle
+}
+
+// Untrack stops tracking the pointer given by the handle
+func (v *HandleList) Untrack(handle unsafe.Pointer) {
+ v.Lock()
+ delete(v.handles, handle)
+ C.free(handle)
+ v.Unlock()
+}
+
+// Get retrieves the pointer from the given handle
+func (v *HandleList) Get(handle unsafe.Pointer) interface{} {
+ v.RLock()
+ defer v.RUnlock()
+
+ ptr, ok := v.handles[handle]
+ if !ok {
+ panic(fmt.Sprintf("invalid pointer handle: %p", handle))
+ }
+
+ return ptr
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/ignore.go b/vendor/gopkg.in/libgit2/git2go.v25/ignore.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b123483efd8809326eddb724636661f59e66f34
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/ignore.go
@@ -0,0 +1,51 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+func (v *Repository) AddIgnoreRule(rules string) error {
+ crules := C.CString(rules)
+ defer C.free(unsafe.Pointer(crules))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_ignore_add_rule(v.ptr, crules)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *Repository) ClearInternalIgnoreRules() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_ignore_clear_internal_rules(v.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *Repository) IsPathIgnored(path string) (bool, error) {
+ var ignored C.int
+
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_ignore_path_is_ignored(&ignored, v.ptr, cpath)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+ return ignored == 1, nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/index.go b/vendor/gopkg.in/libgit2/git2go.v25/index.go
new file mode 100644
index 0000000000000000000000000000000000000000..2afdcdf7f64ec750a2e652a63c22f55334d12497
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/index.go
@@ -0,0 +1,549 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_index_add_all(git_index*, const git_strarray*, unsigned int, void*);
+extern int _go_git_index_update_all(git_index*, const git_strarray*, void*);
+extern int _go_git_index_remove_all(git_index*, const git_strarray*, void*);
+
+*/
+import "C"
+import (
+ "fmt"
+ "runtime"
+ "unsafe"
+)
+
+type IndexMatchedPathCallback func(string, string) int
+
+type IndexAddOpts uint
+
+const (
+ IndexAddDefault IndexAddOpts = C.GIT_INDEX_ADD_DEFAULT
+ IndexAddForce IndexAddOpts = C.GIT_INDEX_ADD_FORCE
+ IndexAddDisablePathspecMatch IndexAddOpts = C.GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH
+ IndexAddCheckPathspec IndexAddOpts = C.GIT_INDEX_ADD_CHECK_PATHSPEC
+)
+
+type IndexStageOpts int
+
+const (
+ // IndexStageAny matches any index stage.
+ //
+ // Some index APIs take a stage to match; pass this value to match
+ // any entry matching the path regardless of stage.
+ IndexStageAny IndexStageOpts = C.GIT_INDEX_STAGE_ANY
+ // IndexStageNormal is a normal staged file in the index.
+ IndexStageNormal IndexStageOpts = C.GIT_INDEX_STAGE_NORMAL
+ // IndexStageAncestor is the ancestor side of a conflict.
+ IndexStageAncestor IndexStageOpts = C.GIT_INDEX_STAGE_ANCESTOR
+ // IndexStageOurs is the "ours" side of a conflict.
+ IndexStageOurs IndexStageOpts = C.GIT_INDEX_STAGE_OURS
+ // IndexStageTheirs is the "theirs" side of a conflict.
+ IndexStageTheirs IndexStageOpts = C.GIT_INDEX_STAGE_THEIRS
+)
+
+type Index struct {
+ ptr *C.git_index
+}
+
+type IndexTime struct {
+ seconds int32
+ nanoseconds uint32
+}
+
+type IndexEntry struct {
+ Ctime IndexTime
+ Mtime IndexTime
+ Mode Filemode
+ Uid uint32
+ Gid uint32
+ Size uint32
+ Id *Oid
+ Path string
+}
+
+func newIndexEntryFromC(entry *C.git_index_entry) *IndexEntry {
+ if entry == nil {
+ return nil
+ }
+ return &IndexEntry{
+ IndexTime{int32(entry.ctime.seconds), uint32(entry.ctime.nanoseconds)},
+ IndexTime{int32(entry.mtime.seconds), uint32(entry.mtime.nanoseconds)},
+ Filemode(entry.mode),
+ uint32(entry.uid),
+ uint32(entry.gid),
+ uint32(entry.file_size),
+ newOidFromC(&entry.id),
+ C.GoString(entry.path),
+ }
+}
+
+func populateCIndexEntry(source *IndexEntry, dest *C.git_index_entry) {
+ dest.ctime.seconds = C.int32_t(source.Ctime.seconds)
+ dest.ctime.nanoseconds = C.uint32_t(source.Ctime.nanoseconds)
+ dest.mtime.seconds = C.int32_t(source.Mtime.seconds)
+ dest.mtime.nanoseconds = C.uint32_t(source.Mtime.nanoseconds)
+ dest.mode = C.uint32_t(source.Mode)
+ dest.uid = C.uint32_t(source.Uid)
+ dest.gid = C.uint32_t(source.Gid)
+ dest.file_size = C.uint32_t(source.Size)
+ dest.id = *source.Id.toC()
+ dest.path = C.CString(source.Path)
+}
+
+func freeCIndexEntry(entry *C.git_index_entry) {
+ C.free(unsafe.Pointer(entry.path))
+}
+
+func newIndexFromC(ptr *C.git_index) *Index {
+ idx := &Index{ptr}
+ runtime.SetFinalizer(idx, (*Index).Free)
+ return idx
+}
+
+// NewIndex allocates a new index. It won't be associated with any
+// file on the filesystem or repository
+func NewIndex() (*Index, error) {
+ var ptr *C.git_index
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_index_new(&ptr); err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return newIndexFromC(ptr), nil
+}
+
+// OpenIndex creates a new index at the given path. If the file does
+// not exist it will be created when Write() is called.
+func OpenIndex(path string) (*Index, error) {
+ var ptr *C.git_index
+
+ var cpath = C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_index_open(&ptr, cpath); err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return newIndexFromC(ptr), nil
+}
+
+// Path returns the index' path on disk or an empty string if it
+// exists only in memory.
+func (v *Index) Path() string {
+ return C.GoString(C.git_index_path(v.ptr))
+}
+
+// Add adds or replaces the given entry to the index, making a copy of
+// the data
+func (v *Index) Add(entry *IndexEntry) error {
+ var centry C.git_index_entry
+
+ populateCIndexEntry(entry, ¢ry)
+ defer freeCIndexEntry(¢ry)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_index_add(v.ptr, ¢ry); err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
+
+func (v *Index) AddByPath(path string) error {
+ cstr := C.CString(path)
+ defer C.free(unsafe.Pointer(cstr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_add_bypath(v.ptr, cstr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Index) AddAll(pathspecs []string, flags IndexAddOpts, callback IndexMatchedPathCallback) error {
+ cpathspecs := C.git_strarray{}
+ cpathspecs.count = C.size_t(len(pathspecs))
+ cpathspecs.strings = makeCStringsFromStrings(pathspecs)
+ defer freeStrarray(&cpathspecs)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var handle unsafe.Pointer
+ if callback != nil {
+ handle = pointerHandles.Track(callback)
+ defer pointerHandles.Untrack(handle)
+ }
+
+ ret := C._go_git_index_add_all(
+ v.ptr,
+ &cpathspecs,
+ C.uint(flags),
+ handle,
+ )
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *Index) UpdateAll(pathspecs []string, callback IndexMatchedPathCallback) error {
+ cpathspecs := C.git_strarray{}
+ cpathspecs.count = C.size_t(len(pathspecs))
+ cpathspecs.strings = makeCStringsFromStrings(pathspecs)
+ defer freeStrarray(&cpathspecs)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var handle unsafe.Pointer
+ if callback != nil {
+ handle = pointerHandles.Track(callback)
+ defer pointerHandles.Untrack(handle)
+ }
+
+ ret := C._go_git_index_update_all(
+ v.ptr,
+ &cpathspecs,
+ handle,
+ )
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *Index) RemoveAll(pathspecs []string, callback IndexMatchedPathCallback) error {
+ cpathspecs := C.git_strarray{}
+ cpathspecs.count = C.size_t(len(pathspecs))
+ cpathspecs.strings = makeCStringsFromStrings(pathspecs)
+ defer freeStrarray(&cpathspecs)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var handle unsafe.Pointer
+ if callback != nil {
+ handle = pointerHandles.Track(callback)
+ defer pointerHandles.Untrack(handle)
+ }
+
+ ret := C._go_git_index_remove_all(
+ v.ptr,
+ &cpathspecs,
+ handle,
+ )
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+//export indexMatchedPathCallback
+func indexMatchedPathCallback(cPath, cMatchedPathspec *C.char, payload unsafe.Pointer) int {
+ if callback, ok := pointerHandles.Get(payload).(IndexMatchedPathCallback); ok {
+ return callback(C.GoString(cPath), C.GoString(cMatchedPathspec))
+ } else {
+ panic("invalid matched path callback")
+ }
+}
+
+func (v *Index) RemoveByPath(path string) error {
+ cstr := C.CString(path)
+ defer C.free(unsafe.Pointer(cstr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_remove_bypath(v.ptr, cstr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// RemoveDirectory removes all entries from the index under a given directory.
+func (v *Index) RemoveDirectory(dir string, stage int) error {
+ cstr := C.CString(dir)
+ defer C.free(unsafe.Pointer(cstr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_remove_directory(v.ptr, cstr, C.int(stage))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Index) WriteTreeTo(repo *Repository) (*Oid, error) {
+ oid := new(Oid)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_write_tree_to(oid.toC(), v.ptr, repo.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return oid, nil
+}
+
+// ReadTree replaces the contents of the index with those of the given
+// tree
+func (v *Index) ReadTree(tree *Tree) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_read_tree(v.ptr, tree.cast_ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Index) WriteTree() (*Oid, error) {
+ oid := new(Oid)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_write_tree(oid.toC(), v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return oid, nil
+}
+
+func (v *Index) Write() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_index_write(v.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Index) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_index_free(v.ptr)
+}
+
+func (v *Index) EntryCount() uint {
+ return uint(C.git_index_entrycount(v.ptr))
+}
+
+func (v *Index) EntryByIndex(index uint) (*IndexEntry, error) {
+ centry := C.git_index_get_byindex(v.ptr, C.size_t(index))
+ if centry == nil {
+ return nil, fmt.Errorf("Index out of Bounds")
+ }
+ return newIndexEntryFromC(centry), nil
+}
+
+func (v *Index) EntryByPath(path string, stage int) (*IndexEntry, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ centry := C.git_index_get_bypath(v.ptr, cpath, C.int(stage))
+ if centry == nil {
+ return nil, MakeGitError(C.GIT_ENOTFOUND)
+ }
+ return newIndexEntryFromC(centry), nil
+}
+
+func (v *Index) Find(path string) (uint, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var pos C.size_t
+ ret := C.git_index_find(&pos, v.ptr, cpath)
+ if ret < 0 {
+ return uint(0), MakeGitError(ret)
+ }
+ return uint(pos), nil
+}
+
+func (v *Index) FindPrefix(prefix string) (uint, error) {
+ cprefix := C.CString(prefix)
+ defer C.free(unsafe.Pointer(cprefix))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var pos C.size_t
+ ret := C.git_index_find_prefix(&pos, v.ptr, cprefix)
+ if ret < 0 {
+ return uint(0), MakeGitError(ret)
+ }
+ return uint(pos), nil
+}
+
+func (v *Index) HasConflicts() bool {
+ return C.git_index_has_conflicts(v.ptr) != 0
+}
+
+// FIXME: this might return an error
+func (v *Index) CleanupConflicts() {
+ C.git_index_conflict_cleanup(v.ptr)
+}
+
+func (v *Index) AddConflict(ancestor *IndexEntry, our *IndexEntry, their *IndexEntry) error {
+
+ var cancestor *C.git_index_entry
+ var cour *C.git_index_entry
+ var ctheir *C.git_index_entry
+
+ if ancestor != nil {
+ cancestor = &C.git_index_entry{}
+ populateCIndexEntry(ancestor, cancestor)
+ defer freeCIndexEntry(cancestor)
+ }
+
+ if our != nil {
+ cour = &C.git_index_entry{}
+ populateCIndexEntry(our, cour)
+ defer freeCIndexEntry(cour)
+ }
+
+ if their != nil {
+ ctheir = &C.git_index_entry{}
+ populateCIndexEntry(their, ctheir)
+ defer freeCIndexEntry(ctheir)
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_index_conflict_add(v.ptr, cancestor, cour, ctheir)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+type IndexConflict struct {
+ Ancestor *IndexEntry
+ Our *IndexEntry
+ Their *IndexEntry
+}
+
+func (v *Index) GetConflict(path string) (IndexConflict, error) {
+
+ var cancestor *C.git_index_entry
+ var cour *C.git_index_entry
+ var ctheir *C.git_index_entry
+
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_index_conflict_get(&cancestor, &cour, &ctheir, v.ptr, cpath)
+ if ecode < 0 {
+ return IndexConflict{}, MakeGitError(ecode)
+ }
+ return IndexConflict{
+ Ancestor: newIndexEntryFromC(cancestor),
+ Our: newIndexEntryFromC(cour),
+ Their: newIndexEntryFromC(ctheir),
+ }, nil
+}
+
+func (v *Index) RemoveConflict(path string) error {
+
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_index_conflict_remove(v.ptr, cpath)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+type IndexConflictIterator struct {
+ ptr *C.git_index_conflict_iterator
+ index *Index
+}
+
+func newIndexConflictIteratorFromC(index *Index, ptr *C.git_index_conflict_iterator) *IndexConflictIterator {
+ i := &IndexConflictIterator{ptr: ptr, index: index}
+ runtime.SetFinalizer(i, (*IndexConflictIterator).Free)
+ return i
+}
+
+func (v *IndexConflictIterator) Index() *Index {
+ return v.index
+}
+
+func (v *IndexConflictIterator) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_index_conflict_iterator_free(v.ptr)
+}
+
+func (v *Index) ConflictIterator() (*IndexConflictIterator, error) {
+ var i *C.git_index_conflict_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_index_conflict_iterator_new(&i, v.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ return newIndexConflictIteratorFromC(v, i), nil
+}
+
+func (v *IndexConflictIterator) Next() (IndexConflict, error) {
+ var cancestor *C.git_index_entry
+ var cour *C.git_index_entry
+ var ctheir *C.git_index_entry
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_index_conflict_next(&cancestor, &cour, &ctheir, v.ptr)
+ if ecode < 0 {
+ return IndexConflict{}, MakeGitError(ecode)
+ }
+ return IndexConflict{
+ Ancestor: newIndexEntryFromC(cancestor),
+ Our: newIndexEntryFromC(cour),
+ Their: newIndexEntryFromC(ctheir),
+ }, nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/merge.go b/vendor/gopkg.in/libgit2/git2go.v25/merge.go
new file mode 100644
index 0000000000000000000000000000000000000000..b3fd818bc4385024a2ecd1cc7c8d5aefe1760647
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/merge.go
@@ -0,0 +1,424 @@
+package git
+
+/*
+#include <git2.h>
+
+extern git_annotated_commit** _go_git_make_merge_head_array(size_t len);
+extern void _go_git_annotated_commit_array_set(git_annotated_commit** array, git_annotated_commit* ptr, size_t n);
+extern git_annotated_commit* _go_git_annotated_commit_array_get(git_annotated_commit** array, size_t n);
+extern int _go_git_merge_file(git_merge_file_result*, char*, size_t, char*, unsigned int, char*, size_t, char*, unsigned int, char*, size_t, char*, unsigned int, git_merge_file_options*);
+
+*/
+import "C"
+import (
+ "reflect"
+ "runtime"
+ "unsafe"
+)
+
+type AnnotatedCommit struct {
+ ptr *C.git_annotated_commit
+}
+
+func newAnnotatedCommitFromC(c *C.git_annotated_commit) *AnnotatedCommit {
+ mh := &AnnotatedCommit{ptr: c}
+ runtime.SetFinalizer(mh, (*AnnotatedCommit).Free)
+ return mh
+}
+
+func (mh *AnnotatedCommit) Free() {
+ runtime.SetFinalizer(mh, nil)
+ C.git_annotated_commit_free(mh.ptr)
+}
+
+func (r *Repository) AnnotatedCommitFromFetchHead(branchName string, remoteURL string, oid *Oid) (*AnnotatedCommit, error) {
+ mh := &AnnotatedCommit{}
+
+ cbranchName := C.CString(branchName)
+ defer C.free(unsafe.Pointer(cbranchName))
+
+ cremoteURL := C.CString(remoteURL)
+ defer C.free(unsafe.Pointer(cremoteURL))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_annotated_commit_from_fetchhead(&mh.ptr, r.ptr, cbranchName, cremoteURL, oid.toC())
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(mh, (*AnnotatedCommit).Free)
+ return mh, nil
+}
+
+func (r *Repository) LookupAnnotatedCommit(oid *Oid) (*AnnotatedCommit, error) {
+ mh := &AnnotatedCommit{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_annotated_commit_lookup(&mh.ptr, r.ptr, oid.toC())
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(mh, (*AnnotatedCommit).Free)
+ return mh, nil
+}
+
+func (r *Repository) AnnotatedCommitFromRef(ref *Reference) (*AnnotatedCommit, error) {
+ mh := &AnnotatedCommit{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_annotated_commit_from_ref(&mh.ptr, r.ptr, ref.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(mh, (*AnnotatedCommit).Free)
+ return mh, nil
+}
+
+type MergeTreeFlag int
+
+const (
+ // Detect renames that occur between the common ancestor and the "ours"
+ // side or the common ancestor and the "theirs" side. This will enable
+ // the ability to merge between a modified and renamed file.
+ MergeTreeFindRenames MergeTreeFlag = C.GIT_MERGE_FIND_RENAMES
+ // If a conflict occurs, exit immediately instead of attempting to
+ // continue resolving conflicts. The merge operation will fail with
+ // GIT_EMERGECONFLICT and no index will be returned.
+ MergeTreeFailOnConflict MergeTreeFlag = C.GIT_MERGE_FAIL_ON_CONFLICT
+)
+
+type MergeOptions struct {
+ Version uint
+ TreeFlags MergeTreeFlag
+
+ RenameThreshold uint
+ TargetLimit uint
+ FileFavor MergeFileFavor
+
+ //TODO: Diff similarity metric
+}
+
+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),
+ FileFavor: MergeFileFavor(opts.file_favor),
+ }
+}
+
+func DefaultMergeOptions() (MergeOptions, error) {
+ opts := C.git_merge_options{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_merge_init_options(&opts, C.GIT_MERGE_OPTIONS_VERSION)
+ if ecode < 0 {
+ return MergeOptions{}, MakeGitError(ecode)
+ }
+ return mergeOptionsFromC(&opts), nil
+}
+
+func (mo *MergeOptions) toC() *C.git_merge_options {
+ if mo == nil {
+ return nil
+ }
+ return &C.git_merge_options{
+ version: C.uint(mo.Version),
+ flags: C.git_merge_flag_t(mo.TreeFlags),
+ rename_threshold: C.uint(mo.RenameThreshold),
+ target_limit: C.uint(mo.TargetLimit),
+ file_favor: C.git_merge_file_favor_t(mo.FileFavor),
+ }
+}
+
+type MergeFileFavor int
+
+const (
+ MergeFileFavorNormal MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_NORMAL
+ MergeFileFavorOurs MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_OURS
+ MergeFileFavorTheirs MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_THEIRS
+ MergeFileFavorUnion MergeFileFavor = C.GIT_MERGE_FILE_FAVOR_UNION
+)
+
+func (r *Repository) Merge(theirHeads []*AnnotatedCommit, mergeOptions *MergeOptions, checkoutOptions *CheckoutOpts) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cMergeOpts := mergeOptions.toC()
+ cCheckoutOpts := checkoutOptions.toC()
+ defer freeCheckoutOpts(cCheckoutOpts)
+
+ gmerge_head_array := make([]*C.git_annotated_commit, len(theirHeads))
+ for i := 0; i < len(theirHeads); i++ {
+ gmerge_head_array[i] = theirHeads[i].ptr
+ }
+ ptr := unsafe.Pointer(&gmerge_head_array[0])
+ err := C.git_merge(r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)), cMergeOpts, cCheckoutOpts)
+ if err < 0 {
+ return MakeGitError(err)
+ }
+ return nil
+}
+
+type MergeAnalysis int
+
+const (
+ MergeAnalysisNone MergeAnalysis = C.GIT_MERGE_ANALYSIS_NONE
+ MergeAnalysisNormal MergeAnalysis = C.GIT_MERGE_ANALYSIS_NORMAL
+ MergeAnalysisUpToDate MergeAnalysis = C.GIT_MERGE_ANALYSIS_UP_TO_DATE
+ MergeAnalysisFastForward MergeAnalysis = C.GIT_MERGE_ANALYSIS_FASTFORWARD
+ MergeAnalysisUnborn MergeAnalysis = C.GIT_MERGE_ANALYSIS_UNBORN
+)
+
+type MergePreference int
+
+const (
+ MergePreferenceNone MergePreference = C.GIT_MERGE_PREFERENCE_NONE
+ MergePreferenceNoFastForward MergePreference = C.GIT_MERGE_PREFERENCE_NO_FASTFORWARD
+ MergePreferenceFastForwardOnly MergePreference = C.GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY
+)
+
+// MergeAnalysis returns the possible actions which could be taken by
+// a 'git-merge' command. There may be multiple answers, so the first
+// return value is a bitmask of MergeAnalysis values.
+func (r *Repository) MergeAnalysis(theirHeads []*AnnotatedCommit) (MergeAnalysis, MergePreference, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ gmerge_head_array := make([]*C.git_annotated_commit, len(theirHeads))
+ for i := 0; i < len(theirHeads); i++ {
+ gmerge_head_array[i] = theirHeads[i].ptr
+ }
+ ptr := unsafe.Pointer(&gmerge_head_array[0])
+ var analysis C.git_merge_analysis_t
+ var preference C.git_merge_preference_t
+ err := C.git_merge_analysis(&analysis, &preference, r.ptr, (**C.git_annotated_commit)(ptr), C.size_t(len(theirHeads)))
+ if err < 0 {
+ return MergeAnalysisNone, MergePreferenceNone, MakeGitError(err)
+ }
+ return MergeAnalysis(analysis), MergePreference(preference), nil
+
+}
+
+func (r *Repository) MergeCommits(ours *Commit, theirs *Commit, options *MergeOptions) (*Index, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ copts := options.toC()
+
+ idx := &Index{}
+
+ ret := C.git_merge_commits(&idx.ptr, r.ptr, ours.cast_ptr, theirs.cast_ptr, copts)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(idx, (*Index).Free)
+ return idx, nil
+}
+
+func (r *Repository) MergeTrees(ancestor *Tree, ours *Tree, theirs *Tree, options *MergeOptions) (*Index, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ copts := options.toC()
+
+ idx := &Index{}
+ var ancestor_ptr *C.git_tree
+ if ancestor != nil {
+ ancestor_ptr = ancestor.cast_ptr
+ }
+ ret := C.git_merge_trees(&idx.ptr, r.ptr, ancestor_ptr, ours.cast_ptr, theirs.cast_ptr, copts)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(idx, (*Index).Free)
+ return idx, nil
+}
+
+func (r *Repository) MergeBase(one *Oid, two *Oid) (*Oid, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var oid C.git_oid
+ ret := C.git_merge_base(&oid, r.ptr, one.toC(), two.toC())
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newOidFromC(&oid), nil
+}
+
+// MergeBases retrieves the list of merge bases between two commits.
+//
+// If none are found, an empty slice is returned and the error is set
+// approprately
+func (r *Repository) MergeBases(one, two *Oid) ([]*Oid, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var coids C.git_oidarray
+ ret := C.git_merge_bases(&coids, r.ptr, one.toC(), two.toC())
+ if ret < 0 {
+ return make([]*Oid, 0), MakeGitError(ret)
+ }
+
+ oids := make([]*Oid, coids.count)
+ hdr := reflect.SliceHeader{
+ Data: uintptr(unsafe.Pointer(coids.ids)),
+ Len: int(coids.count),
+ Cap: int(coids.count),
+ }
+
+ goSlice := *(*[]C.git_oid)(unsafe.Pointer(&hdr))
+
+ for i, cid := range goSlice {
+ oids[i] = newOidFromC(&cid)
+ }
+
+ return oids, nil
+}
+
+//TODO: int git_merge_base_many(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[]);
+//TODO: GIT_EXTERN(int) git_merge_base_octopus(git_oid *out,git_repository *repo,size_t length,const git_oid input_array[]);
+
+type MergeFileResult struct {
+ Automergeable bool
+ Path string
+ Mode uint
+ Contents []byte
+ ptr *C.git_merge_file_result
+}
+
+func newMergeFileResultFromC(c *C.git_merge_file_result) *MergeFileResult {
+ var path string
+ if c.path != nil {
+ path = C.GoString(c.path)
+ }
+
+ originalBytes := C.GoBytes(unsafe.Pointer(c.ptr), C.int(c.len))
+ gobytes := make([]byte, len(originalBytes))
+ copy(gobytes, originalBytes)
+ r := &MergeFileResult{
+ Automergeable: c.automergeable != 0,
+ Path: path,
+ Mode: uint(c.mode),
+ Contents: gobytes,
+ ptr: c,
+ }
+
+ runtime.SetFinalizer(r, (*MergeFileResult).Free)
+ return r
+}
+
+func (r *MergeFileResult) Free() {
+ runtime.SetFinalizer(r, nil)
+ C.git_merge_file_result_free(r.ptr)
+}
+
+type MergeFileInput struct {
+ Path string
+ Mode uint
+ Contents []byte
+}
+
+type MergeFileFlags int
+
+const (
+ MergeFileDefault MergeFileFlags = C.GIT_MERGE_FILE_DEFAULT
+
+ MergeFileStyleMerge MergeFileFlags = C.GIT_MERGE_FILE_STYLE_MERGE
+ MergeFileStyleDiff MergeFileFlags = C.GIT_MERGE_FILE_STYLE_DIFF3
+ MergeFileStyleSimplifyAlnum MergeFileFlags = C.GIT_MERGE_FILE_SIMPLIFY_ALNUM
+)
+
+type MergeFileOptions struct {
+ AncestorLabel string
+ OurLabel string
+ TheirLabel string
+ Favor MergeFileFavor
+ Flags MergeFileFlags
+}
+
+func mergeFileOptionsFromC(c C.git_merge_file_options) MergeFileOptions {
+ return MergeFileOptions{
+ AncestorLabel: C.GoString(c.ancestor_label),
+ OurLabel: C.GoString(c.our_label),
+ TheirLabel: C.GoString(c.their_label),
+ Favor: MergeFileFavor(c.favor),
+ Flags: MergeFileFlags(c.flags),
+ }
+}
+
+func populateCMergeFileOptions(c *C.git_merge_file_options, options MergeFileOptions) {
+ c.ancestor_label = C.CString(options.AncestorLabel)
+ c.our_label = C.CString(options.OurLabel)
+ c.their_label = C.CString(options.TheirLabel)
+ c.favor = C.git_merge_file_favor_t(options.Favor)
+ c.flags = C.git_merge_file_flag_t(options.Flags)
+}
+
+func freeCMergeFileOptions(c *C.git_merge_file_options) {
+ C.free(unsafe.Pointer(c.ancestor_label))
+ C.free(unsafe.Pointer(c.our_label))
+ C.free(unsafe.Pointer(c.their_label))
+}
+
+func MergeFile(ancestor MergeFileInput, ours MergeFileInput, theirs MergeFileInput, options *MergeFileOptions) (*MergeFileResult, error) {
+
+ ancestorPath := C.CString(ancestor.Path)
+ defer C.free(unsafe.Pointer(ancestorPath))
+ var ancestorContents *byte
+ if len(ancestor.Contents) > 0 {
+ ancestorContents = &ancestor.Contents[0]
+ }
+
+ oursPath := C.CString(ours.Path)
+ defer C.free(unsafe.Pointer(oursPath))
+ var oursContents *byte
+ if len(ours.Contents) > 0 {
+ oursContents = &ours.Contents[0]
+ }
+
+ theirsPath := C.CString(theirs.Path)
+ defer C.free(unsafe.Pointer(theirsPath))
+ var theirsContents *byte
+ if len(theirs.Contents) > 0 {
+ theirsContents = &theirs.Contents[0]
+ }
+
+ var copts *C.git_merge_file_options
+ if options != nil {
+ copts = &C.git_merge_file_options{}
+ ecode := C.git_merge_file_init_options(copts, C.GIT_MERGE_FILE_OPTIONS_VERSION)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ populateCMergeFileOptions(copts, *options)
+ defer freeCMergeFileOptions(copts)
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var result C.git_merge_file_result
+ ecode := C._go_git_merge_file(&result,
+ (*C.char)(unsafe.Pointer(ancestorContents)), C.size_t(len(ancestor.Contents)), ancestorPath, C.uint(ancestor.Mode),
+ (*C.char)(unsafe.Pointer(oursContents)), C.size_t(len(ours.Contents)), oursPath, C.uint(ours.Mode),
+ (*C.char)(unsafe.Pointer(theirsContents)), C.size_t(len(theirs.Contents)), theirsPath, C.uint(theirs.Mode),
+ copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newMergeFileResultFromC(&result), nil
+
+}
+
+// TODO: GIT_EXTERN(int) git_merge_file_from_index(git_merge_file_result *out,git_repository *repo,const git_index_entry *ancestor, const git_index_entry *ours, const git_index_entry *theirs, const git_merge_file_options *opts);
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/note.go b/vendor/gopkg.in/libgit2/git2go.v25/note.go
new file mode 100644
index 0000000000000000000000000000000000000000..a1b15d8773fa2088e1f44991c54163b95f6fd412
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/note.go
@@ -0,0 +1,220 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+// This object represents the possible operations which can be
+// performed on the collection of notes for a repository.
+type NoteCollection struct {
+ repo *Repository
+}
+
+// Create adds a note for an object
+func (c *NoteCollection) Create(
+ ref string, author, committer *Signature, id *Oid,
+ note string, force bool) (*Oid, error) {
+
+ oid := new(Oid)
+
+ var cref *C.char
+ if ref == "" {
+ cref = nil
+ } else {
+ cref = C.CString(ref)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ authorSig, err := author.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(authorSig)
+
+ committerSig, err := committer.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(committerSig)
+
+ cnote := C.CString(note)
+ defer C.free(unsafe.Pointer(cnote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_note_create(
+ oid.toC(), c.repo.ptr, cref, authorSig,
+ committerSig, id.toC(), cnote, cbool(force))
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return oid, nil
+}
+
+// Read reads the note for an object
+func (c *NoteCollection) Read(ref string, id *Oid) (*Note, error) {
+ var cref *C.char
+ if ref == "" {
+ cref = nil
+ } else {
+ cref = C.CString(ref)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ note := new(Note)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_note_read(¬e.ptr, c.repo.ptr, cref, id.toC()); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(note, (*Note).Free)
+ return note, nil
+}
+
+// Remove removes the note for an object
+func (c *NoteCollection) Remove(ref string, author, committer *Signature, id *Oid) error {
+ var cref *C.char
+ if ref == "" {
+ cref = nil
+ } else {
+ cref = C.CString(ref)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ authorSig, err := author.toC()
+ if err != nil {
+ return err
+ }
+ defer C.git_signature_free(authorSig)
+
+ committerSig, err := committer.toC()
+ if err != nil {
+ return err
+ }
+ defer C.git_signature_free(committerSig)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_note_remove(c.repo.ptr, cref, authorSig, committerSig, id.toC())
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+// DefaultRef returns the default notes reference for a repository
+func (c *NoteCollection) DefaultRef() (string, error) {
+ buf := C.git_buf{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_note_default_ref(&buf, c.repo.ptr); ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ ret := C.GoString(buf.ptr)
+ C.git_buf_free(&buf)
+
+ return ret, nil
+}
+
+// Note
+type Note struct {
+ ptr *C.git_note
+}
+
+// Free frees a git_note object
+func (n *Note) Free() error {
+ if n.ptr == nil {
+ return ErrInvalid
+ }
+ runtime.SetFinalizer(n, nil)
+ C.git_note_free(n.ptr)
+ n.ptr = nil
+ return nil
+}
+
+// Author returns the signature of the note author
+func (n *Note) Author() *Signature {
+ ptr := C.git_note_author(n.ptr)
+ return newSignatureFromC(ptr)
+}
+
+// Id returns the note object's id
+func (n *Note) Id() *Oid {
+ ptr := C.git_note_id(n.ptr)
+ return newOidFromC(ptr)
+}
+
+// Committer returns the signature of the note committer
+func (n *Note) Committer() *Signature {
+ ptr := C.git_note_committer(n.ptr)
+ return newSignatureFromC(ptr)
+}
+
+// Message returns the note message
+func (n *Note) Message() string {
+ return C.GoString(C.git_note_message(n.ptr))
+}
+
+// NoteIterator
+type NoteIterator struct {
+ ptr *C.git_note_iterator
+}
+
+// NewNoteIterator creates a new iterator for notes
+func (repo *Repository) NewNoteIterator(ref string) (*NoteIterator, error) {
+ var cref *C.char
+ if ref == "" {
+ cref = nil
+ } else {
+ cref = C.CString(ref)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ var ptr *C.git_note_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_note_iterator_new(&ptr, repo.ptr, cref); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ iter := &NoteIterator{ptr: ptr}
+ runtime.SetFinalizer(iter, (*NoteIterator).Free)
+ return iter, nil
+}
+
+// Free frees the note interator
+func (v *NoteIterator) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_note_iterator_free(v.ptr)
+}
+
+// Next returns the current item (note id & annotated id) and advances the
+// iterator internally to the next item
+func (it *NoteIterator) Next() (noteId, annotatedId *Oid, err error) {
+ noteId, annotatedId = new(Oid), new(Oid)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_note_next(noteId.toC(), annotatedId.toC(), it.ptr); ret < 0 {
+ err = MakeGitError(ret)
+ }
+ return
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/object.go b/vendor/gopkg.in/libgit2/git2go.v25/object.go
new file mode 100644
index 0000000000000000000000000000000000000000..1981980a8262ee3744d8e8c1298b0583901fe795
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/object.go
@@ -0,0 +1,207 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "errors"
+ "fmt"
+ "runtime"
+)
+
+type ObjectType int
+
+const (
+ ObjectAny ObjectType = C.GIT_OBJ_ANY
+ ObjectBad ObjectType = C.GIT_OBJ_BAD
+ ObjectCommit ObjectType = C.GIT_OBJ_COMMIT
+ ObjectTree ObjectType = C.GIT_OBJ_TREE
+ ObjectBlob ObjectType = C.GIT_OBJ_BLOB
+ ObjectTag ObjectType = C.GIT_OBJ_TAG
+)
+
+type Object struct {
+ ptr *C.git_object
+ repo *Repository
+}
+
+func (t ObjectType) String() string {
+ switch t {
+ case ObjectAny:
+ return "Any"
+ case ObjectBad:
+ return "Bad"
+ case ObjectCommit:
+ return "Commit"
+ case ObjectTree:
+ return "Tree"
+ case ObjectBlob:
+ return "Blob"
+ case ObjectTag:
+ return "Tag"
+ }
+ // Never reached
+ return ""
+}
+
+func (o *Object) Id() *Oid {
+ return newOidFromC(C.git_object_id(o.ptr))
+}
+
+func (o *Object) Type() ObjectType {
+ return ObjectType(C.git_object_type(o.ptr))
+}
+
+// Owner returns a weak reference to the repository which owns this
+// object. This won't keep the underlying repository alive.
+func (o *Object) Owner() *Repository {
+ return &Repository{
+ ptr: C.git_object_owner(o.ptr),
+ }
+}
+
+func dupObject(obj *Object, kind ObjectType) (*C.git_object, error) {
+ if obj.Type() != kind {
+ return nil, errors.New(fmt.Sprintf("object is not a %v", kind))
+ }
+
+ var cobj *C.git_object
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_object_dup(&cobj, obj.ptr); err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return cobj, nil
+}
+
+func allocTree(ptr *C.git_tree, repo *Repository) *Tree {
+ tree := &Tree{
+ Object: Object{
+ ptr: (*C.git_object)(ptr),
+ repo: repo,
+ },
+ cast_ptr: ptr,
+ }
+ runtime.SetFinalizer(tree, (*Tree).Free)
+
+ return tree
+}
+
+func (o *Object) AsTree() (*Tree, error) {
+ cobj, err := dupObject(o, ObjectTree)
+ if err != nil {
+ return nil, err
+ }
+
+ return allocTree((*C.git_tree)(cobj), o.repo), nil
+}
+
+func allocCommit(ptr *C.git_commit, repo *Repository) *Commit {
+ commit := &Commit{
+ Object: Object{
+ ptr: (*C.git_object)(ptr),
+ repo: repo,
+ },
+ cast_ptr: ptr,
+ }
+ runtime.SetFinalizer(commit, (*Commit).Free)
+
+ return commit
+}
+
+func (o *Object) AsCommit() (*Commit, error) {
+ cobj, err := dupObject(o, ObjectCommit)
+ if err != nil {
+ return nil, err
+ }
+
+ return allocCommit((*C.git_commit)(cobj), o.repo), nil
+}
+
+func allocBlob(ptr *C.git_blob, repo *Repository) *Blob {
+ blob := &Blob{
+ Object: Object{
+ ptr: (*C.git_object)(ptr),
+ repo: repo,
+ },
+ cast_ptr: ptr,
+ }
+ runtime.SetFinalizer(blob, (*Blob).Free)
+
+ return blob
+}
+
+func (o *Object) AsBlob() (*Blob, error) {
+ cobj, err := dupObject(o, ObjectBlob)
+ if err != nil {
+ return nil, err
+ }
+
+ return allocBlob((*C.git_blob)(cobj), o.repo), nil
+}
+
+func allocTag(ptr *C.git_tag, repo *Repository) *Tag {
+ tag := &Tag{
+ Object: Object{
+ ptr: (*C.git_object)(ptr),
+ repo: repo,
+ },
+ cast_ptr: ptr,
+ }
+ runtime.SetFinalizer(tag, (*Tag).Free)
+
+ return tag
+}
+
+func (o *Object) AsTag() (*Tag, error) {
+ cobj, err := dupObject(o, ObjectTag)
+ if err != nil {
+ return nil, err
+ }
+
+ return allocTag((*C.git_tag)(cobj), o.repo), nil
+}
+
+func (o *Object) Free() {
+ runtime.SetFinalizer(o, nil)
+ C.git_object_free(o.ptr)
+}
+
+// Peel recursively peels an object until an object of the specified type is met.
+//
+// If the query cannot be satisfied due to the object model, ErrInvalidSpec
+// will be returned (e.g. trying to peel a blob to a tree).
+//
+// If you pass ObjectAny as the target type, then the object will be peeled
+// until the type changes. A tag will be peeled until the referenced object
+// is no longer a tag, and a commit will be peeled to a tree. Any other object
+// type will return ErrInvalidSpec.
+//
+// If peeling a tag we discover an object which cannot be peeled to the target
+// type due to the object model, an error will be returned.
+func (o *Object) Peel(t ObjectType) (*Object, error) {
+ var cobj *C.git_object
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_object_peel(&cobj, o.ptr, C.git_otype(t)); err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return allocObject(cobj, o.repo), nil
+}
+
+func allocObject(cobj *C.git_object, repo *Repository) *Object {
+ obj := &Object{
+ ptr: cobj,
+ repo: repo,
+ }
+ runtime.SetFinalizer(obj, (*Object).Free)
+
+ return obj
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/odb.go b/vendor/gopkg.in/libgit2/git2go.v25/odb.go
new file mode 100644
index 0000000000000000000000000000000000000000..a728cd32be0da4d6c1c457d44a5270b03fea5a5f
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/odb.go
@@ -0,0 +1,320 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_odb_foreach(git_odb *db, void *payload);
+extern void _go_git_odb_backend_free(git_odb_backend *backend);
+*/
+import "C"
+import (
+ "reflect"
+ "runtime"
+ "unsafe"
+)
+
+type Odb struct {
+ ptr *C.git_odb
+}
+
+type OdbBackend struct {
+ ptr *C.git_odb_backend
+}
+
+func NewOdb() (odb *Odb, err error) {
+ odb = new(Odb)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_new(&odb.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(odb, (*Odb).Free)
+ return odb, nil
+}
+
+func NewOdbBackendFromC(ptr unsafe.Pointer) (backend *OdbBackend) {
+ backend = &OdbBackend{(*C.git_odb_backend)(ptr)}
+ return backend
+}
+
+func (v *Odb) AddBackend(backend *OdbBackend, priority int) (err error) {
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_add_backend(v.ptr, backend.ptr, C.int(priority))
+ if ret < 0 {
+ backend.Free()
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *Odb) ReadHeader(oid *Oid) (uint64, ObjectType, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var sz C.size_t
+ var cotype C.git_otype
+
+ ret := C.git_odb_read_header(&sz, &cotype, v.ptr, oid.toC())
+ if ret < 0 {
+ return 0, C.GIT_OBJ_BAD, MakeGitError(ret)
+ }
+
+ return uint64(sz), ObjectType(cotype), nil
+}
+
+func (v *Odb) Exists(oid *Oid) bool {
+ ret := C.git_odb_exists(v.ptr, oid.toC())
+ return ret != 0
+}
+
+func (v *Odb) Write(data []byte, otype ObjectType) (oid *Oid, err error) {
+ oid = new(Oid)
+ var cptr unsafe.Pointer
+ if len(data) > 0 {
+ cptr = unsafe.Pointer(&data[0])
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_write(oid.toC(), v.ptr, cptr, C.size_t(len(data)), C.git_otype(otype))
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return oid, nil
+}
+
+func (v *Odb) Read(oid *Oid) (obj *OdbObject, err error) {
+ obj = new(OdbObject)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_read(&obj.ptr, v.ptr, oid.toC())
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(obj, (*OdbObject).Free)
+ return obj, nil
+}
+
+type OdbForEachCallback func(id *Oid) error
+
+type foreachData struct {
+ callback OdbForEachCallback
+ err error
+}
+
+//export odbForEachCb
+func odbForEachCb(id *C.git_oid, handle unsafe.Pointer) int {
+ data, ok := pointerHandles.Get(handle).(*foreachData)
+
+ if !ok {
+ panic("could not retrieve handle")
+ }
+
+ err := data.callback(newOidFromC(id))
+ if err != nil {
+ data.err = err
+ return C.GIT_EUSER
+ }
+
+ return 0
+}
+
+func (v *Odb) ForEach(callback OdbForEachCallback) error {
+ data := foreachData{
+ callback: callback,
+ err: nil,
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ handle := pointerHandles.Track(&data)
+ defer pointerHandles.Untrack(handle)
+
+ ret := C._go_git_odb_foreach(v.ptr, handle)
+ if ret == C.GIT_EUSER {
+ return data.err
+ } else if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// Hash determines the object-ID (sha1) of a data buffer.
+func (v *Odb) Hash(data []byte, otype ObjectType) (oid *Oid, err error) {
+ oid = new(Oid)
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+ ptr := unsafe.Pointer(header.Data)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_hash(oid.toC(), ptr, C.size_t(header.Len), C.git_otype(otype))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return oid, nil
+}
+
+// NewReadStream opens a read stream from the ODB. Reading from it will give you the
+// contents of the object.
+func (v *Odb) NewReadStream(id *Oid) (*OdbReadStream, error) {
+ stream := new(OdbReadStream)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_open_rstream(&stream.ptr, v.ptr, id.toC())
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(stream, (*OdbReadStream).Free)
+ return stream, nil
+}
+
+// NewWriteStream opens a write stream to the ODB, which allows you to
+// create a new object in the database. The size and type must be
+// known in advance
+func (v *Odb) NewWriteStream(size int64, otype ObjectType) (*OdbWriteStream, error) {
+ stream := new(OdbWriteStream)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_open_wstream(&stream.ptr, v.ptr, C.git_off_t(size), C.git_otype(otype))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(stream, (*OdbWriteStream).Free)
+ return stream, nil
+}
+
+func (v *OdbBackend) Free() {
+ C._go_git_odb_backend_free(v.ptr)
+}
+
+type OdbObject struct {
+ ptr *C.git_odb_object
+}
+
+func (v *OdbObject) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_odb_object_free(v.ptr)
+}
+
+func (object *OdbObject) Id() (oid *Oid) {
+ return newOidFromC(C.git_odb_object_id(object.ptr))
+}
+
+func (object *OdbObject) Len() (len uint64) {
+ return uint64(C.git_odb_object_size(object.ptr))
+}
+
+func (object *OdbObject) Type() ObjectType {
+ return ObjectType(C.git_odb_object_type(object.ptr))
+}
+
+func (object *OdbObject) Data() (data []byte) {
+ var c_blob unsafe.Pointer = C.git_odb_object_data(object.ptr)
+ var blob []byte
+
+ len := int(C.git_odb_object_size(object.ptr))
+
+ sliceHeader := (*reflect.SliceHeader)((unsafe.Pointer(&blob)))
+ sliceHeader.Cap = len
+ sliceHeader.Len = len
+ sliceHeader.Data = uintptr(c_blob)
+
+ return blob
+}
+
+type OdbReadStream struct {
+ ptr *C.git_odb_stream
+}
+
+// Read reads from the stream
+func (stream *OdbReadStream) Read(data []byte) (int, error) {
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+ ptr := (*C.char)(unsafe.Pointer(header.Data))
+ size := C.size_t(header.Cap)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_stream_read(stream.ptr, ptr, size)
+ if ret < 0 {
+ return 0, MakeGitError(ret)
+ }
+
+ header.Len = int(ret)
+
+ return len(data), nil
+}
+
+// Close is a dummy function in order to implement the Closer and
+// ReadCloser interfaces
+func (stream *OdbReadStream) Close() error {
+ return nil
+}
+
+func (stream *OdbReadStream) Free() {
+ runtime.SetFinalizer(stream, nil)
+ C.git_odb_stream_free(stream.ptr)
+}
+
+type OdbWriteStream struct {
+ ptr *C.git_odb_stream
+ Id Oid
+}
+
+// Write writes to the stream
+func (stream *OdbWriteStream) Write(data []byte) (int, error) {
+ header := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+ ptr := (*C.char)(unsafe.Pointer(header.Data))
+ size := C.size_t(header.Len)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_stream_write(stream.ptr, ptr, size)
+ if ret < 0 {
+ return 0, MakeGitError(ret)
+ }
+
+ return len(data), nil
+}
+
+// Close signals that all the data has been written and stores the
+// resulting object id in the stream's Id field.
+func (stream *OdbWriteStream) Close() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_odb_stream_finalize_write(stream.Id.toC(), stream.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (stream *OdbWriteStream) Free() {
+ runtime.SetFinalizer(stream, nil)
+ C.git_odb_stream_free(stream.ptr)
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/packbuilder.go b/vendor/gopkg.in/libgit2/git2go.v25/packbuilder.go
new file mode 100644
index 0000000000000000000000000000000000000000..4dc352c0a9a052cfee717a844ef78d8cef4814ea
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/packbuilder.go
@@ -0,0 +1,153 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/pack.h>
+#include <stdlib.h>
+
+extern int _go_git_packbuilder_foreach(git_packbuilder *pb, void *payload);
+*/
+import "C"
+import (
+ "io"
+ "os"
+ "runtime"
+ "unsafe"
+)
+
+type Packbuilder struct {
+ ptr *C.git_packbuilder
+}
+
+func (repo *Repository) NewPackbuilder() (*Packbuilder, error) {
+ builder := &Packbuilder{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_packbuilder_new(&builder.ptr, repo.ptr)
+ if ret != 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(builder, (*Packbuilder).Free)
+ return builder, nil
+}
+
+func (pb *Packbuilder) Free() {
+ runtime.SetFinalizer(pb, nil)
+ C.git_packbuilder_free(pb.ptr)
+}
+
+func (pb *Packbuilder) Insert(id *Oid, name string) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_packbuilder_insert(pb.ptr, id.toC(), cname)
+ if ret != 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (pb *Packbuilder) InsertCommit(id *Oid) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_packbuilder_insert_commit(pb.ptr, id.toC())
+ if ret != 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (pb *Packbuilder) InsertTree(id *Oid) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_packbuilder_insert_tree(pb.ptr, id.toC())
+ if ret != 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (pb *Packbuilder) ObjectCount() uint32 {
+ return uint32(C.git_packbuilder_object_count(pb.ptr))
+}
+
+func (pb *Packbuilder) WriteToFile(name string, mode os.FileMode) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_packbuilder_write(pb.ptr, cname, C.uint(mode.Perm()), nil, nil)
+ if ret != 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (pb *Packbuilder) Write(w io.Writer) error {
+ return pb.ForEach(func(slice []byte) error {
+ _, err := w.Write(slice)
+ return err
+ })
+}
+
+func (pb *Packbuilder) Written() uint32 {
+ return uint32(C.git_packbuilder_written(pb.ptr))
+}
+
+type PackbuilderForeachCallback func([]byte) error
+type packbuilderCbData struct {
+ callback PackbuilderForeachCallback
+ err error
+}
+
+//export packbuilderForEachCb
+func packbuilderForEachCb(buf unsafe.Pointer, size C.size_t, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*packbuilderCbData)
+ if !ok {
+ panic("could not get packbuilder CB data")
+ }
+
+ slice := C.GoBytes(buf, C.int(size))
+
+ err := data.callback(slice)
+ if err != nil {
+ data.err = err
+ return C.GIT_EUSER
+ }
+
+ return 0
+}
+
+// ForEach repeatedly calls the callback with new packfile data until
+// there is no more data or the callback returns an error
+func (pb *Packbuilder) ForEach(callback PackbuilderForeachCallback) error {
+ data := packbuilderCbData{
+ callback: callback,
+ err: nil,
+ }
+ handle := pointerHandles.Track(&data)
+ defer pointerHandles.Untrack(handle)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C._go_git_packbuilder_foreach(pb.ptr, handle)
+ if err == C.GIT_EUSER {
+ return data.err
+ }
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/patch.go b/vendor/gopkg.in/libgit2/git2go.v25/patch.go
new file mode 100644
index 0000000000000000000000000000000000000000..45e14ac62c9f499f3f56258d02a761df251ce822
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/patch.go
@@ -0,0 +1,87 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type Patch struct {
+ ptr *C.git_patch
+}
+
+func newPatchFromC(ptr *C.git_patch) *Patch {
+ if ptr == nil {
+ return nil
+ }
+
+ patch := &Patch{
+ ptr: ptr,
+ }
+
+ runtime.SetFinalizer(patch, (*Patch).Free)
+ return patch
+}
+
+func (patch *Patch) Free() error {
+ if patch.ptr == nil {
+ return ErrInvalid
+ }
+ runtime.SetFinalizer(patch, nil)
+ C.git_patch_free(patch.ptr)
+ patch.ptr = nil
+ return nil
+}
+
+func (patch *Patch) String() (string, error) {
+ if patch.ptr == nil {
+ return "", ErrInvalid
+ }
+ var buf C.git_buf
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_patch_to_buf(&buf, patch.ptr)
+ if ecode < 0 {
+ return "", MakeGitError(ecode)
+ }
+ return C.GoString(buf.ptr), nil
+}
+
+func toPointer(data []byte) (ptr unsafe.Pointer) {
+ if len(data) > 0 {
+ ptr = unsafe.Pointer(&data[0])
+ } else {
+ ptr = unsafe.Pointer(nil)
+ }
+ return
+}
+
+func (v *Repository) PatchFromBuffers(oldPath, newPath string, oldBuf, newBuf []byte, opts *DiffOptions) (*Patch, error) {
+ var patchPtr *C.git_patch
+
+ oldPtr := toPointer(oldBuf)
+ newPtr := (*C.char)(toPointer(newBuf))
+
+ cOldPath := C.CString(oldPath)
+ defer C.free(unsafe.Pointer(cOldPath))
+
+ cNewPath := C.CString(newPath)
+ defer C.free(unsafe.Pointer(cNewPath))
+
+ copts, _ := diffOptionsToC(opts)
+ defer freeDiffOptions(copts)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_patch_from_buffers(&patchPtr, oldPtr, C.size_t(len(oldBuf)), cOldPath, newPtr, C.size_t(len(newBuf)), cNewPath, copts)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ return newPatchFromC(patchPtr), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/refdb.go b/vendor/gopkg.in/libgit2/git2go.v25/refdb.go
new file mode 100644
index 0000000000000000000000000000000000000000..4e3ebf9d6f375e599011e33d2ca93949165fc55a
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/refdb.go
@@ -0,0 +1,57 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/sys/refdb_backend.h>
+
+extern void _go_git_refdb_backend_free(git_refdb_backend *backend);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type Refdb struct {
+ ptr *C.git_refdb
+}
+
+type RefdbBackend struct {
+ ptr *C.git_refdb_backend
+}
+
+func (v *Repository) NewRefdb() (refdb *Refdb, err error) {
+ refdb = new(Refdb)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_refdb_new(&refdb.ptr, v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(refdb, (*Refdb).Free)
+ return refdb, nil
+}
+
+func NewRefdbBackendFromC(ptr unsafe.Pointer) (backend *RefdbBackend) {
+ backend = &RefdbBackend{(*C.git_refdb_backend)(ptr)}
+ return backend
+}
+
+func (v *Refdb) SetBackend(backend *RefdbBackend) (err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_refdb_set_backend(v.ptr, backend.ptr)
+ if ret < 0 {
+ backend.Free()
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (v *RefdbBackend) Free() {
+ C._go_git_refdb_backend_free(v.ptr)
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/reference.go b/vendor/gopkg.in/libgit2/git2go.v25/reference.go
new file mode 100644
index 0000000000000000000000000000000000000000..463f2fc607cd73196efed5258fa1c1c8101be5b0
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/reference.go
@@ -0,0 +1,451 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type ReferenceType int
+
+const (
+ ReferenceSymbolic ReferenceType = C.GIT_REF_SYMBOLIC
+ ReferenceOid ReferenceType = C.GIT_REF_OID
+)
+
+type Reference struct {
+ ptr *C.git_reference
+ repo *Repository
+}
+
+type ReferenceCollection struct {
+ repo *Repository
+}
+
+func (c *ReferenceCollection) Lookup(name string) (*Reference, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_reference_lookup(&ptr, c.repo.ptr, cname)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newReferenceFromC(ptr, c.repo), nil
+}
+
+func (c *ReferenceCollection) Create(name string, id *Oid, force bool, msg string) (*Reference, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ var cmsg *C.char
+ if msg == "" {
+ cmsg = nil
+ } else {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_reference_create(&ptr, c.repo.ptr, cname, id.toC(), cbool(force), cmsg)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newReferenceFromC(ptr, c.repo), nil
+}
+
+func (c *ReferenceCollection) CreateSymbolic(name, target string, force bool, msg string) (*Reference, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ ctarget := C.CString(target)
+ defer C.free(unsafe.Pointer(ctarget))
+
+ var cmsg *C.char
+ if msg == "" {
+ cmsg = nil
+ } else {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_reference_symbolic_create(&ptr, c.repo.ptr, cname, ctarget, cbool(force), cmsg)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newReferenceFromC(ptr, c.repo), nil
+}
+
+// EnsureLog ensures that there is a reflog for the given reference
+// name and creates an empty one if necessary.
+func (c *ReferenceCollection) EnsureLog(name string) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_ensure_log(c.repo.ptr, cname)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// HasLog returns whether there is a reflog for the given reference
+// name
+func (c *ReferenceCollection) HasLog(name string) (bool, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_has_log(c.repo.ptr, cname)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return ret == 1, nil
+}
+
+// Dwim looks up a reference by DWIMing its short name
+func (c *ReferenceCollection) Dwim(name string) (*Reference, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_reference
+ ret := C.git_reference_dwim(&ptr, c.repo.ptr, cname)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, c.repo), nil
+}
+
+func newReferenceFromC(ptr *C.git_reference, repo *Repository) *Reference {
+ ref := &Reference{ptr: ptr, repo: repo}
+ runtime.SetFinalizer(ref, (*Reference).Free)
+ return ref
+}
+
+func (v *Reference) SetSymbolicTarget(target string, msg string) (*Reference, error) {
+ var ptr *C.git_reference
+
+ ctarget := C.CString(target)
+ defer C.free(unsafe.Pointer(ctarget))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var cmsg *C.char
+ if msg == "" {
+ cmsg = nil
+ } else {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ ret := C.git_reference_symbolic_set_target(&ptr, v.ptr, ctarget, cmsg)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, v.repo), nil
+}
+
+func (v *Reference) SetTarget(target *Oid, msg string) (*Reference, error) {
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var cmsg *C.char
+ if msg == "" {
+ cmsg = nil
+ } else {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ ret := C.git_reference_set_target(&ptr, v.ptr, target.toC(), cmsg)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, v.repo), nil
+}
+
+func (v *Reference) Resolve() (*Reference, error) {
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_resolve(&ptr, v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, v.repo), nil
+}
+
+func (v *Reference) Rename(name string, force bool, msg string) (*Reference, error) {
+ var ptr *C.git_reference
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ var cmsg *C.char
+ if msg == "" {
+ cmsg = nil
+ } else {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_rename(&ptr, v.ptr, cname, cbool(force), cmsg)
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, v.repo), nil
+}
+
+func (v *Reference) Target() *Oid {
+ return newOidFromC(C.git_reference_target(v.ptr))
+}
+
+func (v *Reference) SymbolicTarget() string {
+ cstr := C.git_reference_symbolic_target(v.ptr)
+ if cstr == nil {
+ return ""
+ }
+
+ return C.GoString(cstr)
+}
+
+func (v *Reference) Delete() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_delete(v.ptr)
+
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Reference) Peel(t ObjectType) (*Object, error) {
+ var cobj *C.git_object
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if err := C.git_reference_peel(&cobj, v.ptr, C.git_otype(t)); err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return allocObject(cobj, v.repo), nil
+}
+
+// Owner returns a weak reference to the repository which owns this
+// reference.
+func (v *Reference) Owner() *Repository {
+ return &Repository{
+ ptr: C.git_reference_owner(v.ptr),
+ }
+}
+
+// Cmp compares both references, retursn 0 on equality, otherwise a
+// stable sorting.
+func (v *Reference) Cmp(ref2 *Reference) int {
+ return int(C.git_reference_cmp(v.ptr, ref2.ptr))
+}
+
+// Shorthand returns a "human-readable" short reference name
+func (v *Reference) Shorthand() string {
+ return C.GoString(C.git_reference_shorthand(v.ptr))
+}
+
+func (v *Reference) Name() string {
+ return C.GoString(C.git_reference_name(v.ptr))
+}
+
+func (v *Reference) Type() ReferenceType {
+ return ReferenceType(C.git_reference_type(v.ptr))
+}
+
+func (v *Reference) IsBranch() bool {
+ return C.git_reference_is_branch(v.ptr) == 1
+}
+
+func (v *Reference) IsRemote() bool {
+ return C.git_reference_is_remote(v.ptr) == 1
+}
+
+func (v *Reference) IsTag() bool {
+ return C.git_reference_is_tag(v.ptr) == 1
+}
+
+// IsNote checks if the reference is a note.
+func (v *Reference) IsNote() bool {
+ return C.git_reference_is_note(v.ptr) == 1
+}
+
+func (v *Reference) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_reference_free(v.ptr)
+}
+
+type ReferenceIterator struct {
+ ptr *C.git_reference_iterator
+ repo *Repository
+}
+
+type ReferenceNameIterator struct {
+ *ReferenceIterator
+}
+
+// NewReferenceIterator creates a new iterator over reference names
+func (repo *Repository) NewReferenceIterator() (*ReferenceIterator, error) {
+ var ptr *C.git_reference_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_iterator_new(&ptr, repo.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ iter := &ReferenceIterator{ptr: ptr, repo: repo}
+ runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
+ return iter, nil
+}
+
+// NewReferenceIterator creates a new branch iterator over reference names
+func (repo *Repository) NewReferenceNameIterator() (*ReferenceNameIterator, error) {
+ var ptr *C.git_reference_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_iterator_new(&ptr, repo.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ iter := &ReferenceIterator{ptr: ptr, repo: repo}
+ runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
+ return iter.Names(), nil
+}
+
+// NewReferenceIteratorGlob creates an iterator over reference names
+// that match the speicified glob. The glob is of the usual fnmatch
+// type.
+func (repo *Repository) NewReferenceIteratorGlob(glob string) (*ReferenceIterator, error) {
+ cstr := C.CString(glob)
+ defer C.free(unsafe.Pointer(cstr))
+ var ptr *C.git_reference_iterator
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_iterator_glob_new(&ptr, repo.ptr, cstr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ iter := &ReferenceIterator{ptr: ptr}
+ runtime.SetFinalizer(iter, (*ReferenceIterator).Free)
+ return iter, nil
+}
+
+func (i *ReferenceIterator) Names() *ReferenceNameIterator {
+ return &ReferenceNameIterator{i}
+}
+
+// NextName retrieves the next reference name. If the iteration is over,
+// the returned error is git.ErrIterOver
+func (v *ReferenceNameIterator) Next() (string, error) {
+ var ptr *C.char
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_next_name(&ptr, v.ptr)
+ if ret < 0 {
+ return "", MakeGitError(ret)
+ }
+
+ return C.GoString(ptr), nil
+}
+
+// Next retrieves the next reference. If the iterationis over, the
+// returned error is git.ErrIterOver
+func (v *ReferenceIterator) Next() (*Reference, error) {
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_reference_next(&ptr, v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newReferenceFromC(ptr, v.repo), nil
+}
+
+// Free the reference iterator
+func (v *ReferenceIterator) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_reference_iterator_free(v.ptr)
+}
+
+// ReferenceIsValidName ensures the reference name is well-formed.
+//
+// Valid reference names must follow one of two patterns:
+//
+// 1. Top-level names must contain only capital letters and underscores,
+// and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+//
+// 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 {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ if C.git_reference_is_valid_name(cname) == 1 {
+ return true
+ }
+ return false
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/remote.go b/vendor/gopkg.in/libgit2/git2go.v25/remote.go
new file mode 100644
index 0000000000000000000000000000000000000000..d3f437de27b1981582e6ee767b7c1fdb3773db33
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/remote.go
@@ -0,0 +1,845 @@
+package git
+
+/*
+#include <git2.h>
+#include <string.h>
+
+extern void _go_git_setup_callbacks(git_remote_callbacks *callbacks);
+
+*/
+import "C"
+import (
+ "crypto/x509"
+ "reflect"
+ "runtime"
+ "strings"
+ "unsafe"
+)
+
+type TransferProgress struct {
+ TotalObjects uint
+ IndexedObjects uint
+ ReceivedObjects uint
+ LocalObjects uint
+ TotalDeltas uint
+ ReceivedBytes uint
+}
+
+func newTransferProgressFromC(c *C.git_transfer_progress) TransferProgress {
+ return TransferProgress{
+ TotalObjects: uint(c.total_objects),
+ IndexedObjects: uint(c.indexed_objects),
+ ReceivedObjects: uint(c.received_objects),
+ LocalObjects: uint(c.local_objects),
+ TotalDeltas: uint(c.total_deltas),
+ ReceivedBytes: uint(c.received_bytes)}
+}
+
+type RemoteCompletion uint
+type ConnectDirection uint
+
+const (
+ RemoteCompletionDownload RemoteCompletion = C.GIT_REMOTE_COMPLETION_DOWNLOAD
+ RemoteCompletionIndexing RemoteCompletion = C.GIT_REMOTE_COMPLETION_INDEXING
+ RemoteCompletionError RemoteCompletion = C.GIT_REMOTE_COMPLETION_ERROR
+
+ ConnectDirectionFetch ConnectDirection = C.GIT_DIRECTION_FETCH
+ ConnectDirectionPush ConnectDirection = C.GIT_DIRECTION_PUSH
+)
+
+type TransportMessageCallback func(str string) ErrorCode
+type CompletionCallback func(RemoteCompletion) ErrorCode
+type CredentialsCallback func(url string, username_from_url string, allowed_types CredType) (ErrorCode, *Cred)
+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 RemoteCallbacks struct {
+ SidebandProgressCallback TransportMessageCallback
+ CompletionCallback
+ CredentialsCallback
+ TransferProgressCallback
+ UpdateTipsCallback
+ CertificateCheckCallback
+ PackProgressCallback PackbuilderProgressCallback
+ PushTransferProgressCallback
+ PushUpdateReferenceCallback
+}
+
+type FetchPrune uint
+
+const (
+ // Use the setting from the configuration
+ FetchPruneUnspecified FetchPrune = C.GIT_FETCH_PRUNE_UNSPECIFIED
+ // Force pruning on
+ FetchPruneOn FetchPrune = C.GIT_FETCH_PRUNE
+ // Force pruning off
+ FetchNoPrune FetchPrune = C.GIT_FETCH_NO_PRUNE
+)
+
+type DownloadTags uint
+
+const (
+
+ // Use the setting from the configuration.
+ DownloadTagsUnspecified DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED
+ // Ask the server for tags pointing to objects we're already
+ // downloading.
+ DownloadTagsAuto DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_AUTO
+
+ // Don't ask for any tags beyond the refspecs.
+ DownloadTagsNone DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_NONE
+
+ // Ask for the all the tags.
+ DownloadTagsAll DownloadTags = C.GIT_REMOTE_DOWNLOAD_TAGS_ALL
+)
+
+type FetchOptions struct {
+ // Callbacks to use for this fetch operation
+ RemoteCallbacks RemoteCallbacks
+ // Whether to perform a prune after the fetch
+ Prune FetchPrune
+ // Whether to write the results to FETCH_HEAD. Defaults to
+ // on. Leave this default in order to behave like git.
+ UpdateFetchhead bool
+
+ // Determines how to behave regarding tags on the remote, such
+ // as auto-downloading tags for objects we're downloading or
+ // downloading all of them.
+ //
+ // The default is to auto-follow tags.
+ DownloadTags DownloadTags
+
+ // Headers are extra headers for the fetch operation.
+ Headers []string
+}
+
+type ProxyType uint
+
+const (
+ // Do not attempt to connect through a proxy
+ //
+ // If built against lbicurl, it itself may attempt to connect
+ // to a proxy if the environment variables specify it.
+ ProxyTypeNone ProxyType = C.GIT_PROXY_NONE
+
+ // Try to auto-detect the proxy from the git configuration.
+ ProxyTypeAuto ProxyType = C.GIT_PROXY_AUTO
+
+ // Connect via the URL given in the options
+ ProxyTypeSpecified ProxyType = C.GIT_PROXY_SPECIFIED
+)
+
+type ProxyOptions struct {
+ // The type of proxy to use (or none)
+ Type ProxyType
+
+ // The proxy's URL
+ Url string
+}
+
+type Remote struct {
+ ptr *C.git_remote
+ callbacks RemoteCallbacks
+}
+
+type CertificateKind uint
+
+const (
+ CertificateX509 CertificateKind = C.GIT_CERT_X509
+ CertificateHostkey CertificateKind = C.GIT_CERT_HOSTKEY_LIBSSH2
+)
+
+// 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
+type Certificate struct {
+ Kind CertificateKind
+ X509 *x509.Certificate
+ Hostkey HostkeyCertificate
+}
+
+type HostkeyKind uint
+
+const (
+ HostkeyMD5 HostkeyKind = C.GIT_CERT_SSH_MD5
+ HostkeySHA1 HostkeyKind = C.GIT_CERT_SSH_SHA1
+)
+
+// Server host key information. If Kind is HostkeyMD5 the MD5 field
+// will be filled. If Kind is HostkeySHA1, then HashSHA1 will be
+// filled.
+type HostkeyCertificate struct {
+ Kind HostkeyKind
+ HashMD5 [16]byte
+ HashSHA1 [20]byte
+}
+
+type PushOptions struct {
+ // Callbacks to use for this push operation
+ RemoteCallbacks RemoteCallbacks
+
+ PbParallelism uint
+
+ // Headers are extra headers for the push operation.
+ Headers []string
+}
+
+type RemoteHead struct {
+ Id *Oid
+ Name string
+}
+
+func newRemoteHeadFromC(ptr *C.git_remote_head) RemoteHead {
+ return RemoteHead{
+ Id: newOidFromC(&ptr.oid),
+ Name: C.GoString(ptr.name),
+ }
+}
+
+func untrackCalbacksPayload(callbacks *C.git_remote_callbacks) {
+ if callbacks != nil && callbacks.payload != nil {
+ pointerHandles.Untrack(callbacks.payload)
+ }
+}
+
+func populateRemoteCallbacks(ptr *C.git_remote_callbacks, callbacks *RemoteCallbacks) {
+ C.git_remote_init_callbacks(ptr, C.GIT_REMOTE_CALLBACKS_VERSION)
+ if callbacks == nil {
+ return
+ }
+ C._go_git_setup_callbacks(ptr)
+ ptr.payload = pointerHandles.Track(callbacks)
+}
+
+//export sidebandProgressCallback
+func sidebandProgressCallback(_str *C.char, _len C.int, data unsafe.Pointer) int {
+ callbacks := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.SidebandProgressCallback == nil {
+ return 0
+ }
+ str := C.GoStringN(_str, _len)
+ return int(callbacks.SidebandProgressCallback(str))
+}
+
+//export completionCallback
+func completionCallback(completion_type C.git_remote_completion_type, data unsafe.Pointer) int {
+ callbacks := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.CompletionCallback == nil {
+ return 0
+ }
+ return int(callbacks.CompletionCallback(RemoteCompletion(completion_type)))
+}
+
+//export credentialsCallback
+func credentialsCallback(_cred **C.git_cred, _url *C.char, _username_from_url *C.char, allowed_types uint, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.CredentialsCallback == nil {
+ return C.GIT_PASSTHROUGH
+ }
+ url := C.GoString(_url)
+ username_from_url := C.GoString(_username_from_url)
+ ret, cred := callbacks.CredentialsCallback(url, username_from_url, (CredType)(allowed_types))
+ if cred != nil {
+ *_cred = cred.ptr
+ }
+ return int(ret)
+}
+
+//export transferProgressCallback
+func transferProgressCallback(stats *C.git_transfer_progress, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.TransferProgressCallback == nil {
+ return 0
+ }
+ return int(callbacks.TransferProgressCallback(newTransferProgressFromC(stats)))
+}
+
+//export updateTipsCallback
+func updateTipsCallback(_refname *C.char, _a *C.git_oid, _b *C.git_oid, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.UpdateTipsCallback == nil {
+ return 0
+ }
+ refname := C.GoString(_refname)
+ a := newOidFromC(_a)
+ b := newOidFromC(_b)
+ return int(callbacks.UpdateTipsCallback(refname, a, b))
+}
+
+//export certificateCheckCallback
+func certificateCheckCallback(_cert *C.git_cert, _valid C.int, _host *C.char, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+ // if there's no callback set, we need to make sure we fail if the library didn't consider this cert valid
+ if callbacks.CertificateCheckCallback == nil {
+ if _valid == 1 {
+ return 0
+ } else {
+ return C.GIT_ECERTIFICATE
+ }
+ }
+ host := C.GoString(_host)
+ valid := _valid != 0
+
+ var cert Certificate
+ if _cert.cert_type == C.GIT_CERT_X509 {
+ cert.Kind = CertificateX509
+ ccert := (*C.git_cert_x509)(unsafe.Pointer(_cert))
+ x509_certs, err := x509.ParseCertificates(C.GoBytes(ccert.data, C.int(ccert.len)))
+ if err != nil {
+ return C.GIT_EUSER
+ }
+
+ // we assume there's only one, which should hold true for any web server we want to talk to
+ cert.X509 = x509_certs[0]
+ } else if _cert.cert_type == C.GIT_CERT_HOSTKEY_LIBSSH2 {
+ cert.Kind = CertificateHostkey
+ ccert := (*C.git_cert_hostkey)(unsafe.Pointer(_cert))
+ cert.Hostkey.Kind = HostkeyKind(ccert._type)
+ 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)))
+ } else {
+ cstr := C.CString("Unsupported certificate type")
+ C.giterr_set_str(C.GITERR_NET, cstr)
+ C.free(unsafe.Pointer(cstr))
+ return -1 // we don't support anything else atm
+ }
+
+ return int(callbacks.CertificateCheckCallback(&cert, valid, host))
+}
+
+//export packProgressCallback
+func packProgressCallback(stage C.int, current, total C.uint, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+
+ if callbacks.PackProgressCallback == nil {
+ return 0
+ }
+
+ return int(callbacks.PackProgressCallback(int32(stage), uint32(current), uint32(total)))
+}
+
+//export pushTransferProgressCallback
+func pushTransferProgressCallback(current, total C.uint, bytes C.size_t, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+ if callbacks.PushTransferProgressCallback == nil {
+ return 0
+ }
+
+ return int(callbacks.PushTransferProgressCallback(uint32(current), uint32(total), uint(bytes)))
+}
+
+//export pushUpdateReferenceCallback
+func pushUpdateReferenceCallback(refname, status *C.char, data unsafe.Pointer) int {
+ callbacks, _ := pointerHandles.Get(data).(*RemoteCallbacks)
+
+ if callbacks.PushUpdateReferenceCallback == nil {
+ return 0
+ }
+
+ return int(callbacks.PushUpdateReferenceCallback(C.GoString(refname), C.GoString(status)))
+}
+
+func populateProxyOptions(ptr *C.git_proxy_options, opts *ProxyOptions) {
+ C.git_proxy_init_options(ptr, C.GIT_PROXY_OPTIONS_VERSION)
+ if opts == nil {
+ return
+ }
+
+ ptr._type = C.git_proxy_t(opts.Type)
+ ptr.url = C.CString(opts.Url)
+}
+
+func freeProxyOptions(ptr *C.git_proxy_options) {
+ C.free(unsafe.Pointer(ptr.url))
+}
+
+func RemoteIsValidName(name string) bool {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ if C.git_remote_is_valid_name(cname) == 1 {
+ return true
+ }
+ return false
+}
+
+func (r *Remote) Free() {
+ runtime.SetFinalizer(r, nil)
+ C.git_remote_free(r.ptr)
+}
+
+type RemoteCollection struct {
+ repo *Repository
+}
+
+func (c *RemoteCollection) List() ([]string, error) {
+ var r C.git_strarray
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_remote_list(&r, c.repo.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ defer C.git_strarray_free(&r)
+
+ remotes := makeStringsFromCStrings(r.strings, int(r.count))
+ return remotes, nil
+}
+
+func (c *RemoteCollection) Create(name string, url string) (*Remote, error) {
+ remote := &Remote{}
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_create(&remote.ptr, c.repo.ptr, cname, curl)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(remote, (*Remote).Free)
+ return remote, nil
+}
+
+func (c *RemoteCollection) Delete(name string) error {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_delete(c.repo.ptr, cname)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (c *RemoteCollection) CreateWithFetchspec(name string, url string, fetch string) (*Remote, error) {
+ remote := &Remote{}
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+ cfetch := C.CString(fetch)
+ defer C.free(unsafe.Pointer(cfetch))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_create_with_fetchspec(&remote.ptr, c.repo.ptr, cname, curl, cfetch)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(remote, (*Remote).Free)
+ return remote, nil
+}
+
+func (c *RemoteCollection) CreateAnonymous(url string) (*Remote, error) {
+ remote := &Remote{}
+
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_create_anonymous(&remote.ptr, c.repo.ptr, curl)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(remote, (*Remote).Free)
+ return remote, nil
+}
+
+func (c *RemoteCollection) Lookup(name string) (*Remote, error) {
+ remote := &Remote{}
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_lookup(&remote.ptr, c.repo.ptr, cname)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(remote, (*Remote).Free)
+ return remote, nil
+}
+
+func (o *Remote) Name() string {
+ return C.GoString(C.git_remote_name(o.ptr))
+}
+
+func (o *Remote) Url() string {
+ return C.GoString(C.git_remote_url(o.ptr))
+}
+
+func (o *Remote) PushUrl() string {
+ return C.GoString(C.git_remote_pushurl(o.ptr))
+}
+
+func (c *RemoteCollection) Rename(remote, newname string) ([]string, error) {
+ cproblems := C.git_strarray{}
+ defer freeStrarray(&cproblems)
+ cnewname := C.CString(newname)
+ defer C.free(unsafe.Pointer(cnewname))
+ cremote := C.CString(remote)
+ defer C.free(unsafe.Pointer(cremote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_rename(&cproblems, c.repo.ptr, cremote, cnewname)
+ if ret < 0 {
+ return []string{}, MakeGitError(ret)
+ }
+
+ problems := makeStringsFromCStrings(cproblems.strings, int(cproblems.count))
+ return problems, nil
+}
+
+func (c *RemoteCollection) SetUrl(remote, url string) error {
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+ cremote := C.CString(remote)
+ defer C.free(unsafe.Pointer(cremote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_url(c.repo.ptr, cremote, curl)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (c *RemoteCollection) SetPushUrl(remote, url string) error {
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+ cremote := C.CString(remote)
+ defer C.free(unsafe.Pointer(cremote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_set_pushurl(c.repo.ptr, cremote, curl)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (c *RemoteCollection) AddFetch(remote, refspec string) error {
+ crefspec := C.CString(refspec)
+ defer C.free(unsafe.Pointer(crefspec))
+ cremote := C.CString(remote)
+ defer C.free(unsafe.Pointer(cremote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_add_fetch(c.repo.ptr, cremote, crefspec)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func sptr(p uintptr) *C.char {
+ return *(**C.char)(unsafe.Pointer(p))
+}
+
+func makeStringsFromCStrings(x **C.char, l int) []string {
+ s := make([]string, l)
+ i := 0
+ for p := uintptr(unsafe.Pointer(x)); i < l; p += unsafe.Sizeof(uintptr(0)) {
+ s[i] = C.GoString(sptr(p))
+ i++
+ }
+ return s
+}
+
+func makeCStringsFromStrings(s []string) **C.char {
+ l := len(s)
+ x := (**C.char)(C.malloc(C.size_t(unsafe.Sizeof(unsafe.Pointer(nil)) * uintptr(l))))
+ i := 0
+ for p := uintptr(unsafe.Pointer(x)); i < l; p += unsafe.Sizeof(uintptr(0)) {
+ *(**C.char)(unsafe.Pointer(p)) = C.CString(s[i])
+ i++
+ }
+ return x
+}
+
+func freeStrarray(arr *C.git_strarray) {
+ count := int(arr.count)
+ size := unsafe.Sizeof(unsafe.Pointer(nil))
+
+ i := 0
+ for p := uintptr(unsafe.Pointer(arr.strings)); i < count; p += size {
+ C.free(unsafe.Pointer(sptr(p)))
+ i++
+ }
+
+ C.free(unsafe.Pointer(arr.strings))
+}
+
+func (o *Remote) FetchRefspecs() ([]string, error) {
+ crefspecs := C.git_strarray{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_get_fetch_refspecs(&crefspecs, o.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ defer C.git_strarray_free(&crefspecs)
+
+ refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))
+ return refspecs, nil
+}
+
+func (c *RemoteCollection) AddPush(remote, refspec string) error {
+ crefspec := C.CString(refspec)
+ defer C.free(unsafe.Pointer(crefspec))
+ cremote := C.CString(remote)
+ defer C.free(unsafe.Pointer(cremote))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_add_push(c.repo.ptr, cremote, crefspec)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (o *Remote) PushRefspecs() ([]string, error) {
+ crefspecs := C.git_strarray{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_get_push_refspecs(&crefspecs, o.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ defer C.git_strarray_free(&crefspecs)
+ refspecs := makeStringsFromCStrings(crefspecs.strings, int(crefspecs.count))
+ return refspecs, nil
+}
+
+func (o *Remote) RefspecCount() uint {
+ return uint(C.git_remote_refspec_count(o.ptr))
+}
+
+func populateFetchOptions(options *C.git_fetch_options, opts *FetchOptions) {
+ C.git_fetch_init_options(options, C.GIT_FETCH_OPTIONS_VERSION)
+ if opts == nil {
+ return
+ }
+ populateRemoteCallbacks(&options.callbacks, &opts.RemoteCallbacks)
+ options.prune = C.git_fetch_prune_t(opts.Prune)
+ options.update_fetchhead = cbool(opts.UpdateFetchhead)
+ options.download_tags = C.git_remote_autotag_option_t(opts.DownloadTags)
+
+ options.custom_headers = C.git_strarray{}
+ options.custom_headers.count = C.size_t(len(opts.Headers))
+ options.custom_headers.strings = makeCStringsFromStrings(opts.Headers)
+}
+
+func populatePushOptions(options *C.git_push_options, opts *PushOptions) {
+ C.git_push_init_options(options, C.GIT_PUSH_OPTIONS_VERSION)
+ if opts == nil {
+ return
+ }
+
+ options.pb_parallelism = C.uint(opts.PbParallelism)
+
+ options.custom_headers = C.git_strarray{}
+ options.custom_headers.count = C.size_t(len(opts.Headers))
+ options.custom_headers.strings = makeCStringsFromStrings(opts.Headers)
+
+ populateRemoteCallbacks(&options.callbacks, &opts.RemoteCallbacks)
+}
+
+// Fetch performs a fetch operation. refspecs specifies which refspecs
+// to use for this fetch, use an empty list to use the refspecs from
+// the configuration; msg specifies what to use for the reflog
+// entries. Leave "" to use defaults.
+func (o *Remote) Fetch(refspecs []string, opts *FetchOptions, msg string) error {
+ var cmsg *C.char = nil
+ if msg != "" {
+ cmsg = C.CString(msg)
+ defer C.free(unsafe.Pointer(cmsg))
+ }
+
+ crefspecs := C.git_strarray{}
+ crefspecs.count = C.size_t(len(refspecs))
+ crefspecs.strings = makeCStringsFromStrings(refspecs)
+ defer freeStrarray(&crefspecs)
+
+ coptions := (*C.git_fetch_options)(C.calloc(1, C.size_t(unsafe.Sizeof(C.git_fetch_options{}))))
+ defer C.free(unsafe.Pointer(coptions))
+
+ populateFetchOptions(coptions, opts)
+ defer untrackCalbacksPayload(&coptions.callbacks)
+ defer freeStrarray(&coptions.custom_headers)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_fetch(o.ptr, &crefspecs, coptions, cmsg)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (o *Remote) ConnectFetch(callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error {
+ return o.Connect(ConnectDirectionFetch, callbacks, proxyOpts, headers)
+}
+
+func (o *Remote) ConnectPush(callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error {
+ return o.Connect(ConnectDirectionPush, callbacks, proxyOpts, headers)
+}
+
+// Connect opens a connection to a remote.
+//
+// The transport is selected based on the URL. The direction argument
+// is due to a limitation of the git protocol (over TCP or SSH) which
+// starts up a specific binary which can only do the one or the other.
+//
+// 'headers' are extra HTTP headers to use in this connection.
+func (o *Remote) Connect(direction ConnectDirection, callbacks *RemoteCallbacks, proxyOpts *ProxyOptions, headers []string) error {
+ var ccallbacks C.git_remote_callbacks
+ populateRemoteCallbacks(&ccallbacks, callbacks)
+
+ var cproxy C.git_proxy_options
+ populateProxyOptions(&cproxy, proxyOpts)
+ defer freeProxyOptions(&cproxy)
+
+ cheaders := C.git_strarray{}
+ cheaders.count = C.size_t(len(headers))
+ cheaders.strings = makeCStringsFromStrings(headers)
+ defer freeStrarray(&cheaders)
+
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_remote_connect(o.ptr, C.git_direction(direction), &ccallbacks, &cproxy, &cheaders); ret != 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (o *Remote) Disconnect() {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ C.git_remote_disconnect(o.ptr)
+}
+
+func (o *Remote) Ls(filterRefs ...string) ([]RemoteHead, error) {
+
+ var refs **C.git_remote_head
+ var length C.size_t
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_remote_ls(&refs, &length, o.ptr); ret != 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ size := int(length)
+
+ if size == 0 {
+ return make([]RemoteHead, 0), nil
+ }
+
+ hdr := reflect.SliceHeader{
+ Data: uintptr(unsafe.Pointer(refs)),
+ Len: size,
+ Cap: size,
+ }
+
+ goSlice := *(*[]*C.git_remote_head)(unsafe.Pointer(&hdr))
+
+ var heads []RemoteHead
+
+ for _, s := range goSlice {
+ head := newRemoteHeadFromC(s)
+
+ if len(filterRefs) > 0 {
+ for _, r := range filterRefs {
+ if strings.Contains(head.Name, r) {
+ heads = append(heads, head)
+ break
+ }
+ }
+ } else {
+ heads = append(heads, head)
+ }
+ }
+
+ return heads, nil
+}
+
+func (o *Remote) Push(refspecs []string, opts *PushOptions) error {
+ crefspecs := C.git_strarray{}
+ crefspecs.count = C.size_t(len(refspecs))
+ crefspecs.strings = makeCStringsFromStrings(refspecs)
+ defer freeStrarray(&crefspecs)
+
+ coptions := (*C.git_push_options)(C.calloc(1, C.size_t(unsafe.Sizeof(C.git_push_options{}))))
+ defer C.free(unsafe.Pointer(coptions))
+
+ populatePushOptions(coptions, opts)
+ defer untrackCalbacksPayload(&coptions.callbacks)
+ defer freeStrarray(&coptions.custom_headers)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_push(o.ptr, &crefspecs, coptions)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (o *Remote) PruneRefs() bool {
+ return C.git_remote_prune_refs(o.ptr) > 0
+}
+
+func (o *Remote) Prune(callbacks *RemoteCallbacks) error {
+ var ccallbacks C.git_remote_callbacks
+ populateRemoteCallbacks(&ccallbacks, callbacks)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_remote_prune(o.ptr, &ccallbacks)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/repository.go b/vendor/gopkg.in/libgit2/git2go.v25/repository.go
new file mode 100644
index 0000000000000000000000000000000000000000..0612b5f66994b0bb94172bf3a484ddeb0096c723
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/repository.go
@@ -0,0 +1,508 @@
+package git
+
+/*
+#include <git2.h>
+#include <git2/sys/repository.h>
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+// Repository
+type Repository struct {
+ ptr *C.git_repository
+ // Remotes represents the collection of remotes and can be
+ // used to add, remove and configure remotes for this
+ // repository.
+ Remotes RemoteCollection
+ // Submodules represents the collection of submodules and can
+ // be used to add, remove and configure submodules in this
+ // repostiory.
+ Submodules SubmoduleCollection
+ // References represents the collection of references and can
+ // be used to create, remove or update refernces for this repository.
+ References ReferenceCollection
+ // Notes represents the collection of notes and can be used to
+ // read, write and delete notes from this repository.
+ Notes NoteCollection
+ // Tags represents the collection of tags and can be used to create,
+ // list, iterate and remove tags in this repository.
+ Tags TagsCollection
+ // Stashes represents the collection of stashes and can be used to
+ // save, apply and iterate over stash states in this repository.
+ Stashes StashCollection
+}
+
+func newRepositoryFromC(ptr *C.git_repository) *Repository {
+ repo := &Repository{ptr: ptr}
+
+ repo.Remotes.repo = repo
+ repo.Submodules.repo = repo
+ repo.References.repo = repo
+ repo.Notes.repo = repo
+ repo.Tags.repo = repo
+ repo.Stashes.repo = repo
+
+ runtime.SetFinalizer(repo, (*Repository).Free)
+
+ return repo
+}
+
+func OpenRepository(path string) (*Repository, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_repository_open(&ptr, cpath)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newRepositoryFromC(ptr), nil
+}
+
+type RepositoryOpenFlag int
+
+const (
+ RepositoryOpenNoSearch RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_NO_SEARCH
+ RepositoryOpenCrossFs RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_CROSS_FS
+ RepositoryOpenBare RepositoryOpenFlag = C.GIT_REPOSITORY_OPEN_BARE
+)
+
+func OpenRepositoryExtended(path string, flags RepositoryOpenFlag, ceiling string) (*Repository, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ var cceiling *C.char = nil
+ if len(ceiling) > 0 {
+ cceiling = C.CString(ceiling)
+ defer C.free(unsafe.Pointer(cceiling))
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_repository_open_ext(&ptr, cpath, C.uint(flags), cceiling)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newRepositoryFromC(ptr), nil
+}
+
+func InitRepository(path string, isbare bool) (*Repository, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_repository_init(&ptr, cpath, ucbool(isbare))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newRepositoryFromC(ptr), nil
+}
+
+func NewRepositoryWrapOdb(odb *Odb) (repo *Repository, err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_repository_wrap_odb(&ptr, odb.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newRepositoryFromC(ptr), nil
+}
+
+func (v *Repository) SetRefdb(refdb *Refdb) {
+ C.git_repository_set_refdb(v.ptr, refdb.ptr)
+}
+
+func (v *Repository) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_repository_free(v.ptr)
+}
+
+func (v *Repository) Config() (*Config, error) {
+ config := new(Config)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_config(&config.ptr, v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(config, (*Config).Free)
+ return config, nil
+}
+
+func (v *Repository) Index() (*Index, error) {
+ var ptr *C.git_index
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_index(&ptr, v.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newIndexFromC(ptr), nil
+}
+
+func (v *Repository) lookupType(id *Oid, t ObjectType) (*Object, error) {
+ var ptr *C.git_object
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_object_lookup(&ptr, v.ptr, id.toC(), C.git_otype(t))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return allocObject(ptr, v), nil
+}
+
+func (v *Repository) Lookup(id *Oid) (*Object, error) {
+ return v.lookupType(id, ObjectAny)
+}
+
+func (v *Repository) LookupTree(id *Oid) (*Tree, error) {
+ obj, err := v.lookupType(id, ObjectTree)
+ if err != nil {
+ return nil, err
+ }
+
+ return obj.AsTree()
+}
+
+func (v *Repository) LookupCommit(id *Oid) (*Commit, error) {
+ obj, err := v.lookupType(id, ObjectCommit)
+ if err != nil {
+ return nil, err
+ }
+
+ return obj.AsCommit()
+}
+
+func (v *Repository) LookupBlob(id *Oid) (*Blob, error) {
+ obj, err := v.lookupType(id, ObjectBlob)
+ if err != nil {
+ return nil, err
+ }
+
+ return obj.AsBlob()
+}
+
+func (v *Repository) LookupTag(id *Oid) (*Tag, error) {
+ obj, err := v.lookupType(id, ObjectTag)
+ if err != nil {
+ return nil, err
+ }
+
+ return obj.AsTag()
+}
+
+func (v *Repository) Head() (*Reference, error) {
+ var ptr *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_repository_head(&ptr, v.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newReferenceFromC(ptr, v), nil
+}
+
+func (v *Repository) SetHead(refname string) error {
+ cname := C.CString(refname)
+ defer C.free(unsafe.Pointer(cname))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_repository_set_head(v.ptr, cname)
+ if ecode != 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *Repository) SetHeadDetached(id *Oid) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_repository_set_head_detached(v.ptr, id.toC())
+ if ecode != 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *Repository) IsHeadDetached() (bool, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_head_detached(v.ptr)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return ret != 0, nil
+}
+
+func (v *Repository) IsHeadUnborn() (bool, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_head_unborn(v.ptr)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+ return ret != 0, nil
+}
+
+func (v *Repository) IsEmpty() (bool, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_is_empty(v.ptr)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+
+ return ret != 0, nil
+}
+
+func (v *Repository) IsShallow() (bool, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_repository_is_shallow(v.ptr)
+ if ret < 0 {
+ return false, MakeGitError(ret)
+ }
+ return ret != 0, nil
+}
+
+func (v *Repository) Walk() (*RevWalk, error) {
+
+ var walkPtr *C.git_revwalk
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revwalk_new(&walkPtr, v.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return revWalkFromC(v, walkPtr), nil
+}
+
+func (v *Repository) CreateCommit(
+ refname string, author, committer *Signature,
+ message string, tree *Tree, parents ...*Commit) (*Oid, error) {
+
+ oid := new(Oid)
+
+ var cref *C.char
+ if refname == "" {
+ cref = nil
+ } else {
+ cref = C.CString(refname)
+ defer C.free(unsafe.Pointer(cref))
+ }
+
+ cmsg := C.CString(message)
+ defer C.free(unsafe.Pointer(cmsg))
+
+ var cparents []*C.git_commit = nil
+ var parentsarg **C.git_commit = nil
+
+ nparents := len(parents)
+ if nparents > 0 {
+ cparents = make([]*C.git_commit, nparents)
+ for i, v := range parents {
+ cparents[i] = v.cast_ptr
+ }
+ parentsarg = &cparents[0]
+ }
+
+ authorSig, err := author.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(authorSig)
+
+ committerSig, err := committer.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(committerSig)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_commit_create(
+ oid.toC(), v.ptr, cref,
+ authorSig, committerSig,
+ nil, cmsg, tree.cast_ptr, C.size_t(nparents), parentsarg)
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return oid, nil
+}
+
+func (v *Odb) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_odb_free(v.ptr)
+}
+
+func (v *Refdb) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_refdb_free(v.ptr)
+}
+
+func (v *Repository) Odb() (odb *Odb, err error) {
+ odb = new(Odb)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_repository_odb(&odb.ptr, v.ptr); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ runtime.SetFinalizer(odb, (*Odb).Free)
+ return odb, nil
+}
+
+func (repo *Repository) Path() string {
+ return C.GoString(C.git_repository_path(repo.ptr))
+}
+
+func (repo *Repository) IsBare() bool {
+ return C.git_repository_is_bare(repo.ptr) != 0
+}
+
+func (repo *Repository) Workdir() string {
+ return C.GoString(C.git_repository_workdir(repo.ptr))
+}
+
+func (repo *Repository) SetWorkdir(workdir string, updateGitlink bool) error {
+ cstr := C.CString(workdir)
+ defer C.free(unsafe.Pointer(cstr))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_repository_set_workdir(repo.ptr, cstr, cbool(updateGitlink)); ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (v *Repository) TreeBuilder() (*TreeBuilder, error) {
+ bld := new(TreeBuilder)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_treebuilder_new(&bld.ptr, v.ptr, nil); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(bld, (*TreeBuilder).Free)
+
+ bld.repo = v
+ return bld, nil
+}
+
+func (v *Repository) TreeBuilderFromTree(tree *Tree) (*TreeBuilder, error) {
+ bld := new(TreeBuilder)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_treebuilder_new(&bld.ptr, v.ptr, tree.cast_ptr); ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ runtime.SetFinalizer(bld, (*TreeBuilder).Free)
+
+ bld.repo = v
+ return bld, nil
+}
+
+type RepositoryState int
+
+const (
+ RepositoryStateNone RepositoryState = C.GIT_REPOSITORY_STATE_NONE
+ RepositoryStateMerge RepositoryState = C.GIT_REPOSITORY_STATE_MERGE
+ RepositoryStateRevert RepositoryState = C.GIT_REPOSITORY_STATE_REVERT
+ RepositoryStateCherrypick RepositoryState = C.GIT_REPOSITORY_STATE_CHERRYPICK
+ RepositoryStateBisect RepositoryState = C.GIT_REPOSITORY_STATE_BISECT
+ RepositoryStateRebase RepositoryState = C.GIT_REPOSITORY_STATE_REBASE
+ RepositoryStateRebaseInteractive RepositoryState = C.GIT_REPOSITORY_STATE_REBASE_INTERACTIVE
+ RepositoryStateRebaseMerge RepositoryState = C.GIT_REPOSITORY_STATE_REBASE_MERGE
+ RepositoryStateApplyMailbox RepositoryState = C.GIT_REPOSITORY_STATE_APPLY_MAILBOX
+ RepositoryStateApplyMailboxOrRebase RepositoryState = C.GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE
+)
+
+func (r *Repository) State() RepositoryState {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ return RepositoryState(C.git_repository_state(r.ptr))
+}
+
+func (r *Repository) StateCleanup() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cErr := C.git_repository_state_cleanup(r.ptr)
+ if cErr < 0 {
+ return MakeGitError(cErr)
+ }
+ return nil
+}
+func (r *Repository) AddGitIgnoreRules(rules string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ crules := C.CString(rules)
+ defer C.free(unsafe.Pointer(crules))
+ if ret := C.git_ignore_add_rule(r.ptr, crules); ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (r *Repository) ClearGitIgnoreRules() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ if ret := C.git_ignore_clear_internal_rules(r.ptr); ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/reset.go b/vendor/gopkg.in/libgit2/git2go.v25/reset.go
new file mode 100644
index 0000000000000000000000000000000000000000..031f5bd129a32847aecce5d5499172224025e6e8
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/reset.go
@@ -0,0 +1,42 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import "runtime"
+
+type ResetType int
+
+const (
+ ResetSoft ResetType = C.GIT_RESET_SOFT
+ ResetMixed ResetType = C.GIT_RESET_MIXED
+ ResetHard ResetType = C.GIT_RESET_HARD
+)
+
+func (r *Repository) ResetToCommit(commit *Commit, resetType ResetType, opts *CheckoutOpts) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ ret := C.git_reset(r.ptr, commit.ptr, C.git_reset_t(resetType), opts.toC())
+
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (r *Repository) ResetDefaultToCommit(commit *Commit, pathspecs []string) error {
+ cpathspecs := C.git_strarray{}
+ cpathspecs.count = C.size_t(len(pathspecs))
+ cpathspecs.strings = makeCStringsFromStrings(pathspecs)
+ defer freeStrarray(&cpathspecs)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ ret := C.git_reset_default(r.ptr, commit.ptr, &cpathspecs)
+
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/revparse.go b/vendor/gopkg.in/libgit2/git2go.v25/revparse.go
new file mode 100644
index 0000000000000000000000000000000000000000..950932b8f9adb3e4293e4253eb67155a5d63a1a9
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/revparse.go
@@ -0,0 +1,113 @@
+package git
+
+/*
+#include <git2.h>
+
+extern void _go_git_revspec_free(git_revspec *revspec);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+type RevparseFlag int
+
+const (
+ RevparseSingle RevparseFlag = C.GIT_REVPARSE_SINGLE
+ RevparseRange RevparseFlag = C.GIT_REVPARSE_RANGE
+ RevparseMergeBase RevparseFlag = C.GIT_REVPARSE_MERGE_BASE
+)
+
+type Revspec struct {
+ to *Object
+ from *Object
+ flags RevparseFlag
+}
+
+func (rs *Revspec) To() *Object {
+ return rs.to
+}
+
+func (rs *Revspec) From() *Object {
+ return rs.from
+}
+
+func (rs *Revspec) Flags() RevparseFlag {
+ return rs.flags
+}
+
+func newRevspecFromC(ptr *C.git_revspec, repo *Repository) *Revspec {
+ var to *Object
+ var from *Object
+
+ if ptr.to != nil {
+ to = allocObject(ptr.to, repo)
+ }
+
+ if ptr.from != nil {
+ from = allocObject(ptr.from, repo)
+ }
+
+ return &Revspec{
+ to: to,
+ from: from,
+ flags: RevparseFlag(ptr.flags),
+ }
+}
+
+func (r *Repository) Revparse(spec string) (*Revspec, error) {
+ cspec := C.CString(spec)
+ defer C.free(unsafe.Pointer(cspec))
+
+ var crevspec C.git_revspec
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revparse(&crevspec, r.ptr, cspec)
+ if ecode != 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return newRevspecFromC(&crevspec, r), nil
+}
+
+func (v *Repository) RevparseSingle(spec string) (*Object, error) {
+ cspec := C.CString(spec)
+ defer C.free(unsafe.Pointer(cspec))
+
+ var ptr *C.git_object
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revparse_single(&ptr, v.ptr, cspec)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+
+ return allocObject(ptr, v), nil
+}
+
+func (r *Repository) RevparseExt(spec string) (*Object, *Reference, error) {
+ cspec := C.CString(spec)
+ defer C.free(unsafe.Pointer(cspec))
+
+ var obj *C.git_object
+ var ref *C.git_reference
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revparse_ext(&obj, &ref, r.ptr, cspec)
+ if ecode != 0 {
+ return nil, nil, MakeGitError(ecode)
+ }
+
+ if ref == nil {
+ return allocObject(obj, r), nil, nil
+ }
+
+ return allocObject(obj, r), newReferenceFromC(ref, r), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/settings.go b/vendor/gopkg.in/libgit2/git2go.v25/settings.go
new file mode 100644
index 0000000000000000000000000000000000000000..c7f1850efa0f2b3243c9bc6b730bde9674925d6f
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/settings.go
@@ -0,0 +1,102 @@
+package git
+
+/*
+#include <git2.h>
+
+int _go_git_opts_get_search_path(int level, git_buf *buf)
+{
+ return git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, level, buf);
+}
+
+int _go_git_opts_set_search_path(int level, const char *path)
+{
+ return git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, path);
+}
+
+int _go_git_opts_set_size_t(int opt, size_t val)
+{
+ return git_libgit2_opts(opt, val);
+}
+
+int _go_git_opts_get_size_t(int opt, size_t *val)
+{
+ return git_libgit2_opts(opt, val);
+}
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+func SearchPath(level ConfigLevel) (string, error) {
+ var buf C.git_buf
+ defer C.git_buf_free(&buf)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C._go_git_opts_get_search_path(C.int(level), &buf)
+ if err < 0 {
+ return "", MakeGitError(err)
+ }
+
+ return C.GoString(buf.ptr), nil
+}
+
+func SetSearchPath(level ConfigLevel, path string) error {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C._go_git_opts_set_search_path(C.int(level), cpath)
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
+
+func MwindowSize() (int, error) {
+ return getSizet(C.GIT_OPT_GET_MWINDOW_SIZE)
+}
+
+func SetMwindowSize(size int) error {
+ return setSizet(C.GIT_OPT_SET_MWINDOW_SIZE, size)
+}
+
+func MwindowMappedLimit() (int, error) {
+ return getSizet(C.GIT_OPT_GET_MWINDOW_MAPPED_LIMIT)
+}
+
+func SetMwindowMappedLimit(size int) error {
+ return setSizet(C.GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, size)
+}
+
+func getSizet(opt C.int) (int, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var val C.size_t
+ err := C._go_git_opts_get_size_t(opt, &val)
+ if err < 0 {
+ return 0, MakeGitError(err)
+ }
+
+ return int(val), nil
+}
+
+func setSizet(opt C.int, val int) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cval := C.size_t(val)
+ err := C._go_git_opts_set_size_t(opt, cval)
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/signature.go b/vendor/gopkg.in/libgit2/git2go.v25/signature.go
new file mode 100644
index 0000000000000000000000000000000000000000..05183871e45d314d95e2500fd912f18b6fcf29c2
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/signature.go
@@ -0,0 +1,73 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+import (
+ "runtime"
+ "time"
+ "unsafe"
+)
+
+type Signature struct {
+ Name string
+ Email string
+ When time.Time
+}
+
+func newSignatureFromC(sig *C.git_signature) *Signature {
+ // git stores minutes, go wants seconds
+ loc := time.FixedZone("", int(sig.when.offset)*60)
+ return &Signature{
+ C.GoString(sig.name),
+ C.GoString(sig.email),
+ time.Unix(int64(sig.when.time), 0).In(loc),
+ }
+}
+
+// the offset in mintes, which is what git wants
+func (v *Signature) Offset() int {
+ _, offset := v.When.Zone()
+ return offset / 60
+}
+
+func (sig *Signature) toC() (*C.git_signature, error) {
+ if sig == nil {
+ return nil, nil
+ }
+
+ var out *C.git_signature
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ name := C.CString(sig.Name)
+ defer C.free(unsafe.Pointer(name))
+
+ email := C.CString(sig.Email)
+ defer C.free(unsafe.Pointer(email))
+
+ ret := C.git_signature_new(&out, name, email, C.git_time_t(sig.When.Unix()), C.int(sig.Offset()))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return out, nil
+}
+
+func (repo *Repository) DefaultSignature() (*Signature, error) {
+ var out *C.git_signature
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cErr := C.git_signature_default(&out, repo.ptr)
+ if cErr < 0 {
+ return nil, MakeGitError(cErr)
+ }
+
+ defer C.git_signature_free(out)
+
+ return newSignatureFromC(out), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/stash.go b/vendor/gopkg.in/libgit2/git2go.v25/stash.go
new file mode 100644
index 0000000000000000000000000000000000000000..809732ed6a19871f0f9b383b2cbf9b5ac1d12f7e
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/stash.go
@@ -0,0 +1,338 @@
+package git
+
+/*
+#include <git2.h>
+
+extern void _go_git_setup_stash_apply_progress_callbacks(git_stash_apply_options *opts);
+extern int _go_git_stash_foreach(git_repository *repo, void *payload);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+// StashFlag are flags that affect the stash save operation.
+type StashFlag int
+
+const (
+ // StashDefault represents no option, default.
+ StashDefault StashFlag = C.GIT_STASH_DEFAULT
+
+ // StashKeepIndex leaves all changes already added to the
+ // index intact in the working directory.
+ StashKeepIndex StashFlag = C.GIT_STASH_KEEP_INDEX
+
+ // StashIncludeUntracked means all untracked files are also
+ // stashed and then cleaned up from the working directory.
+ StashIncludeUntracked StashFlag = C.GIT_STASH_INCLUDE_UNTRACKED
+
+ // StashIncludeIgnored means all ignored files are also
+ // stashed and then cleaned up from the working directory.
+ StashIncludeIgnored StashFlag = C.GIT_STASH_INCLUDE_IGNORED
+)
+
+// StashCollection represents the possible operations that can be
+// performed on the collection of stashes for a repository.
+type StashCollection struct {
+ repo *Repository
+}
+
+// Save saves the local modifications to a new stash.
+//
+// Stasher is the identity of the person performing the stashing.
+// Message is the optional description along with the stashed state.
+// Flags control the stashing process and are given as bitwise OR.
+func (c *StashCollection) Save(
+ stasher *Signature, message string, flags StashFlag) (*Oid, error) {
+
+ oid := new(Oid)
+
+ stasherC, err := stasher.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(stasherC)
+
+ messageC := C.CString(message)
+ defer C.free(unsafe.Pointer(messageC))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_stash_save(
+ oid.toC(), c.repo.ptr,
+ stasherC, messageC, C.uint32_t(flags))
+
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return oid, nil
+}
+
+// StashApplyFlag are flags that affect the stash apply operation.
+type StashApplyFlag int
+
+const (
+ // StashApplyDefault is the default.
+ StashApplyDefault StashApplyFlag = C.GIT_STASH_APPLY_DEFAULT
+
+ // StashApplyReinstateIndex will try to reinstate not only the
+ // working tree's changes, but also the index's changes.
+ StashApplyReinstateIndex StashApplyFlag = C.GIT_STASH_APPLY_REINSTATE_INDEX
+)
+
+// StashApplyProgress are flags describing the progress of the apply operation.
+type StashApplyProgress int
+
+const (
+ // StashApplyProgressNone means loading the stashed data from the object store.
+ StashApplyProgressNone StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_NONE
+
+ // StashApplyProgressLoadingStash means the stored index is being analyzed.
+ StashApplyProgressLoadingStash StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_LOADING_STASH
+
+ // StashApplyProgressAnalyzeIndex means the stored index is being analyzed.
+ StashApplyProgressAnalyzeIndex StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_INDEX
+
+ // StashApplyProgressAnalyzeModified means the modified files are being analyzed.
+ StashApplyProgressAnalyzeModified StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_MODIFIED
+
+ // StashApplyProgressAnalyzeUntracked means the untracked and ignored files are being analyzed.
+ StashApplyProgressAnalyzeUntracked StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_ANALYZE_UNTRACKED
+
+ // StashApplyProgressCheckoutUntracked means the untracked files are being written to disk.
+ StashApplyProgressCheckoutUntracked StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_CHECKOUT_UNTRACKED
+
+ // StashApplyProgressCheckoutModified means the modified files are being written to disk.
+ StashApplyProgressCheckoutModified StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_CHECKOUT_MODIFIED
+
+ // StashApplyProgressDone means the stash was applied successfully.
+ StashApplyProgressDone StashApplyProgress = C.GIT_STASH_APPLY_PROGRESS_DONE
+)
+
+// StashApplyProgressCallback is the apply operation notification callback.
+type StashApplyProgressCallback func(progress StashApplyProgress) error
+
+type stashApplyProgressData struct {
+ Callback StashApplyProgressCallback
+ Error error
+}
+
+//export stashApplyProgressCb
+func stashApplyProgressCb(progress C.git_stash_apply_progress_t, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*stashApplyProgressData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ if data != nil {
+ err := data.Callback(StashApplyProgress(progress))
+ if err != nil {
+ data.Error = err
+ return C.GIT_EUSER
+ }
+ }
+ return 0
+}
+
+// StashApplyOptions represents options to control the apply operation.
+type StashApplyOptions struct {
+ Flags StashApplyFlag
+ CheckoutOptions CheckoutOpts // options to use when writing files to the working directory
+ ProgressCallback StashApplyProgressCallback // optional callback to notify the consumer of application progress
+}
+
+// DefaultStashApplyOptions initializes the structure with default values.
+func DefaultStashApplyOptions() (StashApplyOptions, error) {
+ optsC := C.git_stash_apply_options{}
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_stash_apply_init_options(&optsC, C.GIT_STASH_APPLY_OPTIONS_VERSION)
+ if ecode < 0 {
+ return StashApplyOptions{}, MakeGitError(ecode)
+ }
+ return StashApplyOptions{
+ Flags: StashApplyFlag(optsC.flags),
+ CheckoutOptions: checkoutOptionsFromC(&optsC.checkout_options),
+ }, nil
+}
+
+func (opts *StashApplyOptions) toC() (
+ optsC *C.git_stash_apply_options, progressData *stashApplyProgressData) {
+
+ if opts != nil {
+ progressData = &stashApplyProgressData{
+ Callback: opts.ProgressCallback,
+ }
+
+ optsC = &C.git_stash_apply_options{
+ version: C.GIT_STASH_APPLY_OPTIONS_VERSION,
+ flags: C.git_stash_apply_flags(opts.Flags),
+ }
+ populateCheckoutOpts(&optsC.checkout_options, &opts.CheckoutOptions)
+ if opts.ProgressCallback != nil {
+ C._go_git_setup_stash_apply_progress_callbacks(optsC)
+ optsC.progress_payload = pointerHandles.Track(progressData)
+ }
+ }
+ return
+}
+
+// should be called after every call to toC() as deferred.
+func untrackStashApplyOptionsCallback(optsC *C.git_stash_apply_options) {
+ if optsC != nil && optsC.progress_payload != nil {
+ pointerHandles.Untrack(optsC.progress_payload)
+ }
+}
+
+func freeStashApplyOptions(optsC *C.git_stash_apply_options) {
+ if optsC != nil {
+ freeCheckoutOpts(&optsC.checkout_options)
+ }
+}
+
+// Apply applies a single stashed state from the stash list.
+//
+// If local changes in the working directory conflict with changes in the
+// stash then ErrConflict will be returned. In this case, the index
+// will always remain unmodified and all files in the working directory will
+// remain unmodified. However, if you are restoring untracked files or
+// ignored files and there is a conflict when applying the modified files,
+// then those files will remain in the working directory.
+//
+// If passing the StashApplyReinstateIndex flag and there would be conflicts
+// when reinstating the index, the function will return ErrConflict
+// and both the working directory and index will be left unmodified.
+//
+// Note that a minimum checkout strategy of 'CheckoutSafe' is implied.
+//
+// 'index' is the position within the stash list. 0 points to the most
+// recent stashed state.
+//
+// Returns error code ErrNotFound if there's no stashed state for the given
+// index, error code ErrConflict if local changes in the working directory
+// conflict with changes in the stash, the user returned error from the
+// StashApplyProgressCallback, if any, or other error code.
+//
+// Error codes can be interogated with IsErrorCode(err, ErrNotFound).
+func (c *StashCollection) Apply(index int, opts StashApplyOptions) error {
+ optsC, progressData := opts.toC()
+ defer untrackStashApplyOptionsCallback(optsC)
+ defer freeStashApplyOptions(optsC)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_stash_apply(c.repo.ptr, C.size_t(index), optsC)
+ if ret == C.GIT_EUSER {
+ return progressData.Error
+ }
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+// StashCallback is called per entry when interating over all
+// the stashed states.
+//
+// 'index' is the position of the current stash in the stash list,
+// 'message' is the message used when creating the stash and 'id'
+// is the commit id of the stash.
+type StashCallback func(index int, message string, id *Oid) error
+
+type stashCallbackData struct {
+ Callback StashCallback
+ Error error
+}
+
+//export stashForeachCb
+func stashForeachCb(index C.size_t, message *C.char, id *C.git_oid, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*stashCallbackData)
+ if !ok {
+ panic("could not retrieve data for handle")
+ }
+
+ err := data.Callback(int(index), C.GoString(message), newOidFromC(id))
+ if err != nil {
+ data.Error = err
+ return C.GIT_EUSER
+ }
+ return 0
+}
+
+// Foreach loops over all the stashed states and calls the callback
+// for each one.
+//
+// If callback returns an error, this will stop looping.
+func (c *StashCollection) Foreach(callback StashCallback) error {
+ data := stashCallbackData{
+ Callback: callback,
+ }
+
+ handle := pointerHandles.Track(&data)
+ defer pointerHandles.Untrack(handle)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C._go_git_stash_foreach(c.repo.ptr, handle)
+ if ret == C.GIT_EUSER {
+ return data.Error
+ }
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+// Drop removes a single stashed state from the stash list.
+//
+// 'index' is the position within the stash list. 0 points
+// to the most recent stashed state.
+//
+// Returns error code ErrNotFound if there's no stashed
+// state for the given index.
+func (c *StashCollection) Drop(index int) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_stash_drop(c.repo.ptr, C.size_t(index))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+// Pop applies a single stashed state from the stash list
+// and removes it from the list if successful.
+//
+// 'index' is the position within the stash list. 0 points
+// to the most recent stashed state.
+//
+// 'opts' controls how stashes are applied.
+//
+// Returns error code ErrNotFound if there's no stashed
+// state for the given index.
+func (c *StashCollection) Pop(index int, opts StashApplyOptions) error {
+ optsC, progressData := opts.toC()
+ defer untrackStashApplyOptionsCallback(optsC)
+ defer freeStashApplyOptions(optsC)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_stash_pop(c.repo.ptr, C.size_t(index), optsC)
+ if ret == C.GIT_EUSER {
+ return progressData.Error
+ }
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/status.go b/vendor/gopkg.in/libgit2/git2go.v25/status.go
new file mode 100644
index 0000000000000000000000000000000000000000..e68e6e97ad39228330153b6f7f723375d6a525cd
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/status.go
@@ -0,0 +1,180 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+type Status int
+
+const (
+ StatusCurrent Status = C.GIT_STATUS_CURRENT
+ StatusIndexNew Status = C.GIT_STATUS_INDEX_NEW
+ StatusIndexModified Status = C.GIT_STATUS_INDEX_MODIFIED
+ StatusIndexDeleted Status = C.GIT_STATUS_INDEX_DELETED
+ StatusIndexRenamed Status = C.GIT_STATUS_INDEX_RENAMED
+ StatusIndexTypeChange Status = C.GIT_STATUS_INDEX_TYPECHANGE
+ StatusWtNew Status = C.GIT_STATUS_WT_NEW
+ StatusWtModified Status = C.GIT_STATUS_WT_MODIFIED
+ StatusWtDeleted Status = C.GIT_STATUS_WT_DELETED
+ StatusWtTypeChange Status = C.GIT_STATUS_WT_TYPECHANGE
+ StatusWtRenamed Status = C.GIT_STATUS_WT_RENAMED
+ StatusIgnored Status = C.GIT_STATUS_IGNORED
+ StatusConflicted Status = C.GIT_STATUS_CONFLICTED
+)
+
+type StatusEntry struct {
+ Status Status
+ HeadToIndex DiffDelta
+ IndexToWorkdir DiffDelta
+}
+
+func statusEntryFromC(statusEntry *C.git_status_entry) StatusEntry {
+ var headToIndex DiffDelta = DiffDelta{}
+ var indexToWorkdir DiffDelta = DiffDelta{}
+
+ // Based on the libgit2 status example, head_to_index can be null in some cases
+ if statusEntry.head_to_index != nil {
+ headToIndex = diffDeltaFromC(statusEntry.head_to_index)
+ }
+ if statusEntry.index_to_workdir != nil {
+ indexToWorkdir = diffDeltaFromC(statusEntry.index_to_workdir)
+ }
+
+ return StatusEntry{
+ Status: Status(statusEntry.status),
+ HeadToIndex: headToIndex,
+ IndexToWorkdir: indexToWorkdir,
+ }
+}
+
+type StatusList struct {
+ ptr *C.git_status_list
+}
+
+func newStatusListFromC(ptr *C.git_status_list) *StatusList {
+ if ptr == nil {
+ return nil
+ }
+
+ statusList := &StatusList{
+ ptr: ptr,
+ }
+
+ runtime.SetFinalizer(statusList, (*StatusList).Free)
+ return statusList
+}
+
+func (statusList *StatusList) Free() {
+ if statusList.ptr == nil {
+ return
+ }
+ runtime.SetFinalizer(statusList, nil)
+ C.git_status_list_free(statusList.ptr)
+ statusList.ptr = nil
+}
+
+func (statusList *StatusList) ByIndex(index int) (StatusEntry, error) {
+ if statusList.ptr == nil {
+ return StatusEntry{}, ErrInvalid
+ }
+ ptr := C.git_status_byindex(statusList.ptr, C.size_t(index))
+ return statusEntryFromC(ptr), nil
+}
+
+func (statusList *StatusList) EntryCount() (int, error) {
+ if statusList.ptr == nil {
+ return -1, ErrInvalid
+ }
+ return int(C.git_status_list_entrycount(statusList.ptr)), nil
+}
+
+type StatusOpt int
+
+const (
+ StatusOptIncludeUntracked StatusOpt = C.GIT_STATUS_OPT_INCLUDE_UNTRACKED
+ StatusOptIncludeIgnored StatusOpt = C.GIT_STATUS_OPT_INCLUDE_IGNORED
+ StatusOptIncludeUnmodified StatusOpt = C.GIT_STATUS_OPT_INCLUDE_UNMODIFIED
+ StatusOptExcludeSubmodules StatusOpt = C.GIT_STATUS_OPT_EXCLUDE_SUBMODULES
+ StatusOptRecurseUntrackedDirs StatusOpt = C.GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS
+ StatusOptDisablePathspecMatch StatusOpt = C.GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH
+ StatusOptRecurseIgnoredDirs StatusOpt = C.GIT_STATUS_OPT_RECURSE_IGNORED_DIRS
+ StatusOptRenamesHeadToIndex StatusOpt = C.GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX
+ StatusOptRenamesIndexToWorkdir StatusOpt = C.GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR
+ StatusOptSortCaseSensitively StatusOpt = C.GIT_STATUS_OPT_SORT_CASE_SENSITIVELY
+ StatusOptSortCaseInsensitively StatusOpt = C.GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY
+ StatusOptRenamesFromRewrites StatusOpt = C.GIT_STATUS_OPT_RENAMES_FROM_REWRITES
+ StatusOptNoRefresh StatusOpt = C.GIT_STATUS_OPT_NO_REFRESH
+ StatusOptUpdateIndex StatusOpt = C.GIT_STATUS_OPT_UPDATE_INDEX
+)
+
+type StatusShow int
+
+const (
+ StatusShowIndexAndWorkdir StatusShow = C.GIT_STATUS_SHOW_INDEX_AND_WORKDIR
+ StatusShowIndexOnly StatusShow = C.GIT_STATUS_SHOW_INDEX_ONLY
+ StatusShowWorkdirOnly StatusShow = C.GIT_STATUS_SHOW_WORKDIR_ONLY
+)
+
+type StatusOptions struct {
+ Show StatusShow
+ Flags StatusOpt
+ Pathspec []string
+}
+
+func (v *Repository) StatusList(opts *StatusOptions) (*StatusList, error) {
+ var ptr *C.git_status_list
+ var copts *C.git_status_options
+
+ if opts != nil {
+ cpathspec := C.git_strarray{}
+ if opts.Pathspec != nil {
+ cpathspec.count = C.size_t(len(opts.Pathspec))
+ cpathspec.strings = makeCStringsFromStrings(opts.Pathspec)
+ defer freeStrarray(&cpathspec)
+ }
+
+ copts = &C.git_status_options{
+ version: C.GIT_STATUS_OPTIONS_VERSION,
+ show: C.git_status_show_t(opts.Show),
+ flags: C.uint(opts.Flags),
+ pathspec: cpathspec,
+ }
+ } else {
+ copts = &C.git_status_options{}
+ ret := C.git_status_init_options(copts, C.GIT_STATUS_OPTIONS_VERSION)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_status_list_new(&ptr, v.ptr, copts)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newStatusListFromC(ptr), nil
+}
+
+func (v *Repository) StatusFile(path string) (Status, error) {
+ var statusFlags C.uint
+ cPath := C.CString(path)
+ defer C.free(unsafe.Pointer(cPath))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_status_file(&statusFlags, v.ptr, cPath)
+ if ret < 0 {
+ return 0, MakeGitError(ret)
+ }
+ return Status(statusFlags), nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/submodule.go b/vendor/gopkg.in/libgit2/git2go.v25/submodule.go
new file mode 100644
index 0000000000000000000000000000000000000000..4a32ce49867ef15ed733a2b155346a0b6487e4e0
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/submodule.go
@@ -0,0 +1,342 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_visit_submodule(git_repository *repo, void *fct);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+// SubmoduleUpdateOptions
+type SubmoduleUpdateOptions struct {
+ *CheckoutOpts
+ *FetchOptions
+ CloneCheckoutStrategy CheckoutStrategy
+}
+
+// Submodule
+type Submodule struct {
+ ptr *C.git_submodule
+}
+
+type SubmoduleUpdate int
+
+const (
+ SubmoduleUpdateCheckout SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_CHECKOUT
+ SubmoduleUpdateRebase SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_REBASE
+ SubmoduleUpdateMerge SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_MERGE
+ SubmoduleUpdateNone SubmoduleUpdate = C.GIT_SUBMODULE_UPDATE_NONE
+)
+
+type SubmoduleIgnore int
+
+const (
+ SubmoduleIgnoreNone SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_NONE
+ SubmoduleIgnoreUntracked SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_UNTRACKED
+ SubmoduleIgnoreDirty SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_DIRTY
+ SubmoduleIgnoreAll SubmoduleIgnore = C.GIT_SUBMODULE_IGNORE_ALL
+)
+
+type SubmoduleStatus int
+
+const (
+ SubmoduleStatusInHead SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_HEAD
+ SubmoduleStatusInIndex SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_INDEX
+ SubmoduleStatusInConfig SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_CONFIG
+ SubmoduleStatusInWd SubmoduleStatus = C.GIT_SUBMODULE_STATUS_IN_WD
+ SubmoduleStatusIndexAdded SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_ADDED
+ SubmoduleStatusIndexDeleted SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_DELETED
+ SubmoduleStatusIndexModified SubmoduleStatus = C.GIT_SUBMODULE_STATUS_INDEX_MODIFIED
+ SubmoduleStatusWdUninitialized SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_UNINITIALIZED
+ SubmoduleStatusWdAdded SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_ADDED
+ SubmoduleStatusWdDeleted SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_DELETED
+ SubmoduleStatusWdModified SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_MODIFIED
+ SubmoduleStatusWdIndexModified SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED
+ SubmoduleStatusWdWdModified SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_WD_MODIFIED
+ SubmoduleStatusWdUntracked SubmoduleStatus = C.GIT_SUBMODULE_STATUS_WD_UNTRACKED
+)
+
+type SubmoduleRecurse int
+
+const (
+ SubmoduleRecurseNo SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_NO
+ SubmoduleRecurseYes SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_YES
+ SubmoduleRecurseOndemand SubmoduleRecurse = C.GIT_SUBMODULE_RECURSE_ONDEMAND
+)
+
+type SubmoduleCollection struct {
+ repo *Repository
+}
+
+func SubmoduleStatusIsUnmodified(status int) bool {
+ o := SubmoduleStatus(status) & ^(SubmoduleStatusInHead | SubmoduleStatusInIndex |
+ SubmoduleStatusInConfig | SubmoduleStatusInWd)
+ return o == 0
+}
+
+func (c *SubmoduleCollection) Lookup(name string) (*Submodule, error) {
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ sub := new(Submodule)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_lookup(&sub.ptr, c.repo.ptr, cname)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return sub, nil
+}
+
+type SubmoduleCbk func(sub *Submodule, name string) int
+
+//export SubmoduleVisitor
+func SubmoduleVisitor(csub unsafe.Pointer, name *C.char, handle unsafe.Pointer) C.int {
+ sub := &Submodule{(*C.git_submodule)(csub)}
+
+ if callback, ok := pointerHandles.Get(handle).(SubmoduleCbk); ok {
+ return (C.int)(callback(sub, C.GoString(name)))
+ } else {
+ panic("invalid submodule visitor callback")
+ }
+}
+
+func (c *SubmoduleCollection) Foreach(cbk SubmoduleCbk) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ handle := pointerHandles.Track(cbk)
+ defer pointerHandles.Untrack(handle)
+
+ ret := C._go_git_visit_submodule(c.repo.ptr, handle)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (c *SubmoduleCollection) Add(url, path string, use_git_link bool) (*Submodule, error) {
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+
+ sub := new(Submodule)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_add_setup(&sub.ptr, c.repo.ptr, curl, cpath, cbool(use_git_link))
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return sub, nil
+}
+
+func (sub *Submodule) FinalizeAdd() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_add_finalize(sub.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (sub *Submodule) AddToIndex(write_index bool) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_add_to_index(sub.ptr, cbool(write_index))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (sub *Submodule) Name() string {
+ n := C.git_submodule_name(sub.ptr)
+ return C.GoString(n)
+}
+
+func (sub *Submodule) Path() string {
+ n := C.git_submodule_path(sub.ptr)
+ return C.GoString(n)
+}
+
+func (sub *Submodule) Url() string {
+ n := C.git_submodule_url(sub.ptr)
+ return C.GoString(n)
+}
+
+func (c *SubmoduleCollection) SetUrl(submodule, url string) error {
+ csubmodule := C.CString(submodule)
+ defer C.free(unsafe.Pointer(csubmodule))
+ curl := C.CString(url)
+ defer C.free(unsafe.Pointer(curl))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_set_url(c.repo.ptr, csubmodule, curl)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (sub *Submodule) IndexId() *Oid {
+ idx := C.git_submodule_index_id(sub.ptr)
+ if idx == nil {
+ return nil
+ }
+ return newOidFromC(idx)
+}
+
+func (sub *Submodule) HeadId() *Oid {
+ idx := C.git_submodule_head_id(sub.ptr)
+ if idx == nil {
+ return nil
+ }
+ return newOidFromC(idx)
+}
+
+func (sub *Submodule) WdId() *Oid {
+ idx := C.git_submodule_wd_id(sub.ptr)
+ if idx == nil {
+ return nil
+ }
+ return newOidFromC(idx)
+}
+
+func (sub *Submodule) Ignore() SubmoduleIgnore {
+ o := C.git_submodule_ignore(sub.ptr)
+ return SubmoduleIgnore(o)
+}
+
+func (c *SubmoduleCollection) SetIgnore(submodule string, ignore SubmoduleIgnore) error {
+ csubmodule := C.CString(submodule)
+ defer C.free(unsafe.Pointer(csubmodule))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_set_ignore(c.repo.ptr, csubmodule, C.git_submodule_ignore_t(ignore))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (sub *Submodule) UpdateStrategy() SubmoduleUpdate {
+ o := C.git_submodule_update_strategy(sub.ptr)
+ return SubmoduleUpdate(o)
+}
+
+func (c *SubmoduleCollection) SetUpdate(submodule string, update SubmoduleUpdate) error {
+ csubmodule := C.CString(submodule)
+ defer C.free(unsafe.Pointer(csubmodule))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_set_update(c.repo.ptr, csubmodule, C.git_submodule_update_t(update))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func (sub *Submodule) FetchRecurseSubmodules() SubmoduleRecurse {
+ return SubmoduleRecurse(C.git_submodule_fetch_recurse_submodules(sub.ptr))
+}
+
+func (c *SubmoduleCollection) SetFetchRecurseSubmodules(submodule string, recurse SubmoduleRecurse) error {
+ csubmodule := C.CString(submodule)
+ defer C.free(unsafe.Pointer(csubmodule))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_set_fetch_recurse_submodules(c.repo.ptr, csubmodule, C.git_submodule_recurse_t(recurse))
+ if ret < 0 {
+ return MakeGitError(C.int(ret))
+ }
+ return nil
+}
+
+func (sub *Submodule) Init(overwrite bool) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_init(sub.ptr, cbool(overwrite))
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (sub *Submodule) Sync() error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_sync(sub.ptr)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+ return nil
+}
+
+func (sub *Submodule) Open() (*Repository, error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ var ptr *C.git_repository
+ ret := C.git_submodule_open(&ptr, sub.ptr)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+ return newRepositoryFromC(ptr), nil
+}
+
+func (sub *Submodule) Update(init bool, opts *SubmoduleUpdateOptions) error {
+ var copts C.git_submodule_update_options
+ err := populateSubmoduleUpdateOptions(&copts, opts)
+ if err != nil {
+ return err
+ }
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_submodule_update(sub.ptr, cbool(init), &copts)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+func populateSubmoduleUpdateOptions(ptr *C.git_submodule_update_options, opts *SubmoduleUpdateOptions) error {
+ C.git_submodule_update_init_options(ptr, C.GIT_SUBMODULE_UPDATE_OPTIONS_VERSION)
+
+ if opts == nil {
+ return nil
+ }
+
+ populateCheckoutOpts(&ptr.checkout_opts, opts.CheckoutOpts)
+ populateFetchOptions(&ptr.fetch_opts, opts.FetchOptions)
+ ptr.clone_checkout_strategy = C.uint(opts.CloneCheckoutStrategy)
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/tag.go b/vendor/gopkg.in/libgit2/git2go.v25/tag.go
new file mode 100644
index 0000000000000000000000000000000000000000..81d7258c63536b9f79a139c32476f2091f80904a
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/tag.go
@@ -0,0 +1,226 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_tag_foreach(git_repository *repo, void *payload);
+*/
+import "C"
+import (
+ "runtime"
+ "unsafe"
+)
+
+// Tag
+type Tag struct {
+ Object
+ cast_ptr *C.git_tag
+}
+
+func (t Tag) Message() string {
+ return C.GoString(C.git_tag_message(t.cast_ptr))
+}
+
+func (t Tag) Name() string {
+ return C.GoString(C.git_tag_name(t.cast_ptr))
+}
+
+func (t Tag) Tagger() *Signature {
+ cast_ptr := C.git_tag_tagger(t.cast_ptr)
+ return newSignatureFromC(cast_ptr)
+}
+
+func (t Tag) Target() *Object {
+ var ptr *C.git_object
+ ret := C.git_tag_target(&ptr, t.cast_ptr)
+
+ if ret != 0 {
+ return nil
+ }
+
+ return allocObject(ptr, t.repo)
+}
+
+func (t Tag) TargetId() *Oid {
+ return newOidFromC(C.git_tag_target_id(t.cast_ptr))
+}
+
+func (t Tag) TargetType() ObjectType {
+ return ObjectType(C.git_tag_target_type(t.cast_ptr))
+}
+
+type TagsCollection struct {
+ repo *Repository
+}
+
+func (c *TagsCollection) Create(
+ name string, commit *Commit, tagger *Signature, message string) (*Oid, error) {
+
+ oid := new(Oid)
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ cmessage := C.CString(message)
+ defer C.free(unsafe.Pointer(cmessage))
+
+ taggerSig, err := tagger.toC()
+ if err != nil {
+ return nil, err
+ }
+ defer C.git_signature_free(taggerSig)
+
+ ctarget := commit.ptr
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_tag_create(oid.toC(), c.repo.ptr, cname, ctarget, taggerSig, cmessage, 0)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return oid, nil
+}
+
+func (c *TagsCollection) Remove(name string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ ret := C.git_tag_delete(c.repo.ptr, cname)
+ if ret < 0 {
+ return MakeGitError(ret)
+ }
+
+ return nil
+}
+
+// CreateLightweight creates a new lightweight tag pointing to a commit
+// and returns the id of the target object.
+//
+// The name of the tag is validated for consistency (see git_tag_create() for the rules
+// https://libgit2.github.com/libgit2/#HEAD/group/tag/git_tag_create) and should
+// not conflict with an already existing tag name.
+//
+// If force is true and a reference already exists with the given name, it'll be replaced.
+//
+// The created tag is a simple reference and can be queried using
+// repo.References.Lookup("refs/tags/<name>"). The name of the tag (eg "v1.0.0")
+// is queried with ref.Shorthand().
+func (c *TagsCollection) CreateLightweight(name string, commit *Commit, force bool) (*Oid, error) {
+
+ oid := new(Oid)
+
+ cname := C.CString(name)
+ defer C.free(unsafe.Pointer(cname))
+
+ ctarget := commit.ptr
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C.git_tag_create_lightweight(oid.toC(), c.repo.ptr, cname, ctarget, cbool(force))
+ if err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return oid, nil
+}
+
+// List returns the names of all the tags in the repository,
+// eg: ["v1.0.1", "v2.0.0"].
+func (c *TagsCollection) List() ([]string, error) {
+ var strC C.git_strarray
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_tag_list(&strC, c.repo.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ defer C.git_strarray_free(&strC)
+
+ tags := makeStringsFromCStrings(strC.strings, int(strC.count))
+ return tags, nil
+}
+
+// ListWithMatch returns the names of all the tags in the repository
+// that match a given pattern.
+//
+// The pattern is a standard fnmatch(3) pattern http://man7.org/linux/man-pages/man3/fnmatch.3.html
+func (c *TagsCollection) ListWithMatch(pattern string) ([]string, error) {
+ var strC C.git_strarray
+
+ patternC := C.CString(pattern)
+ defer C.free(unsafe.Pointer(patternC))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_tag_list_match(&strC, patternC, c.repo.ptr)
+ if ecode < 0 {
+ return nil, MakeGitError(ecode)
+ }
+ defer C.git_strarray_free(&strC)
+
+ tags := makeStringsFromCStrings(strC.strings, int(strC.count))
+ return tags, nil
+}
+
+// TagForeachCallback is called for each tag in the repository.
+//
+// The name is the full ref name eg: "refs/tags/v1.0.0".
+//
+// Note that the callback is called for lightweight tags as well,
+// so repo.LookupTag() will return an error for these tags. Use
+// repo.References.Lookup() instead.
+type TagForeachCallback func(name string, id *Oid) error
+type tagForeachData struct {
+ callback TagForeachCallback
+ err error
+}
+
+//export gitTagForeachCb
+func gitTagForeachCb(name *C.char, id *C.git_oid, handle unsafe.Pointer) int {
+ payload := pointerHandles.Get(handle)
+ data, ok := payload.(*tagForeachData)
+ if !ok {
+ panic("could not retrieve tag foreach CB handle")
+ }
+
+ err := data.callback(C.GoString(name), newOidFromC(id))
+ if err != nil {
+ data.err = err
+ return C.GIT_EUSER
+ }
+
+ return 0
+}
+
+// Foreach calls the callback for each tag in the repository.
+func (c *TagsCollection) Foreach(callback TagForeachCallback) error {
+ data := tagForeachData{
+ callback: callback,
+ err: nil,
+ }
+
+ handle := pointerHandles.Track(&data)
+ defer pointerHandles.Untrack(handle)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C._go_git_tag_foreach(c.repo.ptr, handle)
+ if err == C.GIT_EUSER {
+ return data.err
+ }
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/tree.go b/vendor/gopkg.in/libgit2/git2go.v25/tree.go
new file mode 100644
index 0000000000000000000000000000000000000000..eba9f3d12dcce8bdba0b19df6347b7b4a2651f24
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/tree.go
@@ -0,0 +1,195 @@
+package git
+
+/*
+#include <git2.h>
+
+extern int _go_git_treewalk(git_tree *tree, git_treewalk_mode mode, void *ptr);
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+type Filemode int
+
+const (
+ FilemodeTree Filemode = C.GIT_FILEMODE_TREE
+ FilemodeBlob Filemode = C.GIT_FILEMODE_BLOB
+ FilemodeBlobExecutable Filemode = C.GIT_FILEMODE_BLOB_EXECUTABLE
+ FilemodeLink Filemode = C.GIT_FILEMODE_LINK
+ FilemodeCommit Filemode = C.GIT_FILEMODE_COMMIT
+)
+
+type Tree struct {
+ Object
+ cast_ptr *C.git_tree
+}
+
+type TreeEntry struct {
+ Name string
+ Id *Oid
+ Type ObjectType
+ Filemode Filemode
+}
+
+func newTreeEntry(entry *C.git_tree_entry) *TreeEntry {
+ return &TreeEntry{
+ C.GoString(C.git_tree_entry_name(entry)),
+ newOidFromC(C.git_tree_entry_id(entry)),
+ ObjectType(C.git_tree_entry_type(entry)),
+ Filemode(C.git_tree_entry_filemode(entry)),
+ }
+}
+
+func (t Tree) EntryByName(filename string) *TreeEntry {
+ cname := C.CString(filename)
+ defer C.free(unsafe.Pointer(cname))
+
+ entry := C.git_tree_entry_byname(t.cast_ptr, cname)
+ if entry == nil {
+ return nil
+ }
+
+ return newTreeEntry(entry)
+}
+
+// EntryById performs a lookup for a tree entry with the given SHA value.
+//
+// It returns a *TreeEntry that is owned by the Tree. You don't have to
+// free it, but you must not use it after the Tree is freed.
+//
+// Warning: this must examine every entry in the tree, so it is not fast.
+func (t Tree) EntryById(id *Oid) *TreeEntry {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ entry := C.git_tree_entry_byid(t.cast_ptr, id.toC())
+ if entry == nil {
+ return nil
+ }
+
+ return newTreeEntry(entry)
+}
+
+// EntryByPath looks up an entry by its full path, recursing into
+// deeper trees if necessary (i.e. if there are slashes in the path)
+func (t Tree) EntryByPath(path string) (*TreeEntry, error) {
+ cpath := C.CString(path)
+ defer C.free(unsafe.Pointer(cpath))
+ var entry *C.git_tree_entry
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_tree_entry_bypath(&entry, t.cast_ptr, cpath)
+ if ret < 0 {
+ return nil, MakeGitError(ret)
+ }
+
+ return newTreeEntry(entry), nil
+}
+
+func (t Tree) EntryByIndex(index uint64) *TreeEntry {
+ entry := C.git_tree_entry_byindex(t.cast_ptr, C.size_t(index))
+ if entry == nil {
+ return nil
+ }
+
+ return newTreeEntry(entry)
+}
+
+func (t Tree) EntryCount() uint64 {
+ num := C.git_tree_entrycount(t.cast_ptr)
+ return uint64(num)
+}
+
+type TreeWalkCallback func(string, *TreeEntry) int
+
+//export CallbackGitTreeWalk
+func CallbackGitTreeWalk(_root *C.char, _entry unsafe.Pointer, ptr unsafe.Pointer) C.int {
+ root := C.GoString(_root)
+ entry := (*C.git_tree_entry)(_entry)
+
+ if callback, ok := pointerHandles.Get(ptr).(TreeWalkCallback); ok {
+ return C.int(callback(root, newTreeEntry(entry)))
+ } else {
+ panic("invalid treewalk callback")
+ }
+}
+
+func (t Tree) Walk(callback TreeWalkCallback) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ptr := pointerHandles.Track(callback)
+ defer pointerHandles.Untrack(ptr)
+
+ err := C._go_git_treewalk(
+ t.cast_ptr,
+ C.GIT_TREEWALK_PRE,
+ ptr,
+ )
+
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
+
+type TreeBuilder struct {
+ ptr *C.git_treebuilder
+ repo *Repository
+}
+
+func (v *TreeBuilder) Free() {
+ runtime.SetFinalizer(v, nil)
+ C.git_treebuilder_free(v.ptr)
+}
+
+func (v *TreeBuilder) Insert(filename string, id *Oid, filemode Filemode) error {
+ cfilename := C.CString(filename)
+ defer C.free(unsafe.Pointer(cfilename))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C.git_treebuilder_insert(nil, v.ptr, cfilename, id.toC(), C.git_filemode_t(filemode))
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
+
+func (v *TreeBuilder) Remove(filename string) error {
+ cfilename := C.CString(filename)
+ defer C.free(unsafe.Pointer(cfilename))
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C.git_treebuilder_remove(v.ptr, cfilename)
+ if err < 0 {
+ return MakeGitError(err)
+ }
+
+ return nil
+}
+
+func (v *TreeBuilder) Write() (*Oid, error) {
+ oid := new(Oid)
+
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ err := C.git_treebuilder_write(oid.toC(), v.ptr)
+
+ if err < 0 {
+ return nil, MakeGitError(err)
+ }
+
+ return oid, nil
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/walk.go b/vendor/gopkg.in/libgit2/git2go.v25/walk.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab1de6137a3d914dbdc8531944dda72c3e714d61
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/walk.go
@@ -0,0 +1,205 @@
+package git
+
+/*
+#include <git2.h>
+*/
+import "C"
+
+import (
+ "runtime"
+ "unsafe"
+)
+
+// RevWalk
+
+type SortType uint
+
+const (
+ SortNone SortType = C.GIT_SORT_NONE
+ SortTopological SortType = C.GIT_SORT_TOPOLOGICAL
+ SortTime SortType = C.GIT_SORT_TIME
+ SortReverse SortType = C.GIT_SORT_REVERSE
+)
+
+type RevWalk struct {
+ ptr *C.git_revwalk
+ repo *Repository
+}
+
+func revWalkFromC(repo *Repository, c *C.git_revwalk) *RevWalk {
+ v := &RevWalk{ptr: c, repo: repo}
+ runtime.SetFinalizer(v, (*RevWalk).Free)
+ return v
+}
+
+func (v *RevWalk) Reset() {
+ C.git_revwalk_reset(v.ptr)
+}
+
+func (v *RevWalk) Push(id *Oid) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revwalk_push(v.ptr, id.toC())
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) PushGlob(glob string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cstr := C.CString(glob)
+ defer C.free(unsafe.Pointer(cstr))
+
+ ecode := C.git_revwalk_push_glob(v.ptr, cstr)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) PushRange(r string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cstr := C.CString(r)
+ defer C.free(unsafe.Pointer(cstr))
+
+ ecode := C.git_revwalk_push_range(v.ptr, cstr)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) PushRef(r string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cstr := C.CString(r)
+ defer C.free(unsafe.Pointer(cstr))
+
+ ecode := C.git_revwalk_push_ref(v.ptr, cstr)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) PushHead() (err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revwalk_push_head(v.ptr)
+ if ecode < 0 {
+ err = MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) Hide(id *Oid) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revwalk_hide(v.ptr, id.toC())
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) HideGlob(glob string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cstr := C.CString(glob)
+ defer C.free(unsafe.Pointer(cstr))
+
+ ecode := C.git_revwalk_hide_glob(v.ptr, cstr)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) HideRef(r string) error {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ cstr := C.CString(r)
+ defer C.free(unsafe.Pointer(cstr))
+
+ ecode := C.git_revwalk_hide_ref(v.ptr, cstr)
+ if ecode < 0 {
+ return MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) HideHead() (err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ecode := C.git_revwalk_hide_head(v.ptr)
+ if ecode < 0 {
+ err = MakeGitError(ecode)
+ }
+ return nil
+}
+
+func (v *RevWalk) Next(id *Oid) (err error) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+
+ ret := C.git_revwalk_next(id.toC(), v.ptr)
+ switch {
+ case ret < 0:
+ err = MakeGitError(ret)
+ }
+
+ return
+}
+
+type RevWalkIterator func(commit *Commit) bool
+
+func (v *RevWalk) Iterate(fun RevWalkIterator) (err error) {
+ oid := new(Oid)
+ for {
+ err = v.Next(oid)
+ if IsErrorCode(err, ErrIterOver) {
+ return nil
+ }
+ if err != nil {
+ return err
+ }
+
+ commit, err := v.repo.LookupCommit(oid)
+ if err != nil {
+ return err
+ }
+
+ cont := fun(commit)
+ if !cont {
+ break
+ }
+ }
+
+ return nil
+}
+
+func (v *RevWalk) SimplifyFirstParent() {
+ C.git_revwalk_simplify_first_parent(v.ptr)
+}
+
+func (v *RevWalk) Sorting(sm SortType) {
+ C.git_revwalk_sorting(v.ptr, C.uint(sm))
+}
+
+func (v *RevWalk) Free() {
+
+ runtime.SetFinalizer(v, nil)
+ C.git_revwalk_free(v.ptr)
+}
diff --git a/vendor/gopkg.in/libgit2/git2go.v25/wrapper.c b/vendor/gopkg.in/libgit2/git2go.v25/wrapper.c
new file mode 100644
index 0000000000000000000000000000000000000000..11c2f32426f3818cead3e868c7b81d2b7b50edc3
--- /dev/null
+++ b/vendor/gopkg.in/libgit2/git2go.v25/wrapper.c
@@ -0,0 +1,183 @@
+#include "_cgo_export.h"
+#include <git2.h>
+#include <git2/sys/odb_backend.h>
+#include <git2/sys/refdb_backend.h>
+
+typedef int (*gogit_submodule_cbk)(git_submodule *sm, const char *name, void *payload);
+
+void _go_git_populate_remote_cb(git_clone_options *opts)
+{
+ opts->remote_cb = (git_remote_create_cb)remoteCreateCallback;
+}
+
+void _go_git_populate_checkout_cb(git_checkout_options *opts)
+{
+ opts->notify_cb = (git_checkout_notify_cb)checkoutNotifyCallback;
+ opts->progress_cb = (git_checkout_progress_cb)checkoutProgressCallback;
+}
+
+int _go_git_visit_submodule(git_repository *repo, void *fct)
+{
+ return git_submodule_foreach(repo, (gogit_submodule_cbk)&SubmoduleVisitor, fct);
+}
+
+int _go_git_treewalk(git_tree *tree, git_treewalk_mode mode, void *ptr)
+{
+ return git_tree_walk(tree, mode, (git_treewalk_cb)&CallbackGitTreeWalk, ptr);
+}
+
+int _go_git_packbuilder_foreach(git_packbuilder *pb, void *payload)
+{
+ return git_packbuilder_foreach(pb, (git_packbuilder_foreach_cb)&packbuilderForEachCb, payload);
+}
+
+int _go_git_odb_foreach(git_odb *db, void *payload)
+{
+ return git_odb_foreach(db, (git_odb_foreach_cb)&odbForEachCb, payload);
+}
+
+void _go_git_odb_backend_free(git_odb_backend *backend)
+{
+ if (backend->free)
+ backend->free(backend);
+
+ return;
+}
+
+void _go_git_refdb_backend_free(git_refdb_backend *backend)
+{
+ if (backend->free)
+ backend->free(backend);
+
+ return;
+}
+
+int _go_git_diff_foreach(git_diff *diff, int eachFile, int eachHunk, int eachLine, void *payload)
+{
+ git_diff_file_cb fcb = NULL;
+ git_diff_hunk_cb hcb = NULL;
+ git_diff_line_cb lcb = NULL;
+
+ if (eachFile) {
+ fcb = (git_diff_file_cb)&diffForEachFileCb;
+ }
+
+ if (eachHunk) {
+ hcb = (git_diff_hunk_cb)&diffForEachHunkCb;
+ }
+
+ if (eachLine) {
+ lcb = (git_diff_line_cb)&diffForEachLineCb;
+ }
+
+ return git_diff_foreach(diff, fcb, NULL, hcb, lcb, payload);
+}
+
+int _go_git_diff_blobs(git_blob *old, const char *old_path, git_blob *new, const char *new_path, git_diff_options *opts, int eachFile, int eachHunk, int eachLine, void *payload)
+{
+ git_diff_file_cb fcb = NULL;
+ git_diff_hunk_cb hcb = NULL;
+ git_diff_line_cb lcb = NULL;
+
+ if (eachFile) {
+ fcb = (git_diff_file_cb)&diffForEachFileCb;
+ }
+
+ if (eachHunk) {
+ hcb = (git_diff_hunk_cb)&diffForEachHunkCb;
+ }
+
+ if (eachLine) {
+ lcb = (git_diff_line_cb)&diffForEachLineCb;
+ }
+
+ return git_diff_blobs(old, old_path, new, new_path, opts, fcb, NULL, hcb, lcb, payload);
+}
+
+void _go_git_setup_diff_notify_callbacks(git_diff_options *opts) {
+ opts->notify_cb = (git_diff_notify_cb)diffNotifyCb;
+}
+
+void _go_git_setup_callbacks(git_remote_callbacks *callbacks) {
+ typedef int (*completion_cb)(git_remote_completion_type type, void *data);
+ typedef int (*update_tips_cb)(const char *refname, const git_oid *a, const git_oid *b, void *data);
+ typedef int (*push_update_reference_cb)(const char *refname, const char *status, void *data);
+
+ callbacks->sideband_progress = (git_transport_message_cb)sidebandProgressCallback;
+ callbacks->completion = (completion_cb)completionCallback;
+ callbacks->credentials = (git_cred_acquire_cb)credentialsCallback;
+ callbacks->transfer_progress = (git_transfer_progress_cb)transferProgressCallback;
+ callbacks->update_tips = (update_tips_cb)updateTipsCallback;
+ callbacks->certificate_check = (git_transport_certificate_check_cb) certificateCheckCallback;
+ callbacks->pack_progress = (git_packbuilder_progress) packProgressCallback;
+ callbacks->push_transfer_progress = (git_push_transfer_progress) pushTransferProgressCallback;
+ callbacks->push_update_reference = (push_update_reference_cb) pushUpdateReferenceCallback;
+}
+
+int _go_git_index_add_all(git_index *index, const git_strarray *pathspec, unsigned int flags, void *callback) {
+ git_index_matched_path_cb cb = callback ? (git_index_matched_path_cb) &indexMatchedPathCallback : NULL;
+ return git_index_add_all(index, pathspec, flags, cb, callback);
+}
+
+int _go_git_index_update_all(git_index *index, const git_strarray *pathspec, void *callback) {
+ git_index_matched_path_cb cb = callback ? (git_index_matched_path_cb) &indexMatchedPathCallback : NULL;
+ return git_index_update_all(index, pathspec, cb, callback);
+}
+
+int _go_git_index_remove_all(git_index *index, const git_strarray *pathspec, void *callback) {
+ git_index_matched_path_cb cb = callback ? (git_index_matched_path_cb) &indexMatchedPathCallback : NULL;
+ return git_index_remove_all(index, pathspec, cb, callback);
+}
+
+int _go_git_tag_foreach(git_repository *repo, void *payload)
+{
+ return git_tag_foreach(repo, (git_tag_foreach_cb)&gitTagForeachCb, payload);
+}
+
+int _go_git_merge_file(git_merge_file_result* out, char* ancestorContents, size_t ancestorLen, char* ancestorPath, unsigned int ancestorMode, char* oursContents, size_t oursLen, char* oursPath, unsigned int oursMode, char* theirsContents, size_t theirsLen, char* theirsPath, unsigned int theirsMode, git_merge_file_options* copts) {
+ git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT;
+ git_merge_file_input ours = GIT_MERGE_FILE_INPUT_INIT;
+ git_merge_file_input theirs = GIT_MERGE_FILE_INPUT_INIT;
+
+ ancestor.ptr = ancestorContents;
+ ancestor.size = ancestorLen;
+ ancestor.path = ancestorPath;
+ ancestor.mode = ancestorMode;
+
+ ours.ptr = oursContents;
+ ours.size = oursLen;
+ ours.path = oursPath;
+ ours.mode = oursMode;
+
+ theirs.ptr = theirsContents;
+ theirs.size = theirsLen;
+ theirs.path = theirsPath;
+ theirs.mode = theirsMode;
+
+ return git_merge_file(out, &ancestor, &ours, &theirs, copts);
+}
+
+void _go_git_setup_stash_apply_progress_callbacks(git_stash_apply_options *opts) {
+ opts->progress_cb = (git_stash_apply_progress_cb)stashApplyProgressCb;
+}
+
+int _go_git_stash_foreach(git_repository *repo, void *payload) {
+ return git_stash_foreach(repo, (git_stash_cb)&stashForeachCb, payload);
+}
+
+int _go_git_writestream_write(git_writestream *stream, const char *buffer, size_t len)
+{
+ return stream->write(stream, buffer, len);
+}
+
+int _go_git_writestream_close(git_writestream *stream)
+{
+ return stream->close(stream);
+}
+
+void _go_git_writestream_free(git_writestream *stream)
+{
+ stream->free(stream);
+}
+
+/* EOF */
diff --git a/vendor/gopkg.in/src-d/go-billy.v2/Makefile b/vendor/gopkg.in/src-d/go-billy.v2/Makefile
deleted file mode 100644
index 19e743378c268a7a51957c103a8c9b5f9d753ccb..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-billy.v2/Makefile
+++ /dev/null
@@ -1,25 +0,0 @@
-# General
-WORKDIR = $(PWD)
-
-# Go parameters
-GOCMD = go
-GOTEST = $(GOCMD) test -v
-
-# Coverage
-COVERAGE_REPORT = coverage.txt
-COVERAGE_PROFILE = profile.out
-COVERAGE_MODE = atomic
-
-test-coverage:
- cd $(WORKDIR); \
- echo "" > $(COVERAGE_REPORT); \
- for dir in `find . -name "*.go" | grep -o '.*/' | sort | uniq`; do \
- $(GOTEST) $$dir -coverprofile=$(COVERAGE_PROFILE) -covermode=$(COVERAGE_MODE); \
- if [ $$? != 0 ]; then \
- exit 2; \
- fi; \
- if [ -f $(COVERAGE_PROFILE) ]; then \
- cat $(COVERAGE_PROFILE) >> $(COVERAGE_REPORT); \
- rm $(COVERAGE_PROFILE); \
- fi; \
- done; \
diff --git a/vendor/gopkg.in/src-d/go-billy.v2/README.md b/vendor/gopkg.in/src-d/go-billy.v2/README.md
deleted file mode 100644
index 14bdf34b8b427447da856eb37bbc38552ab3546c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-billy.v2/README.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# go-billy [](https://godoc.org/gopkg.in/src-d/go-billy.v2) [](https://travis-ci.org/src-d/go-billy) [](https://codebeat.co/projects/github-com-src-d-go-billy)
-
-An interface to abstract several storages.
-
-This library was extracted from
-[src-d/go-git](https://github.com/src-d/go-git).
-
-## Installation
-
-```go
-go get -u gopkg.in/src-d/go-billy.v2/...
-```
-
-## Why billy?
-
-The library billy deals with storage systems and Billy is the name of a well-known, IKEA
-bookcase. That's it.
-
-## Usage
-
-Billy exposes filesystems using the
-[`Filesystem` interface](https://godoc.org/github.com/src-d/go-billy#Filesystem).
-Each filesystem implementation gives you a `New` method, whose arguments depend on
-the implementation itself, that returns a new `Filesystem`.
-
-The following example caches in memory all readable files in a directory from any
-billy's filesystem implementation.
-
-```go
-func LoadToMemory(fs billy.Filesystem, path string) (*memory.Memory, error) {
- memory := memory.New()
-
- files, err := fs.ReadDir("/")
- if err != nil {
- return nil, err
- }
-
- for _, file := range files {
- if !file.IsDir() {
- orig, err := fs.Open(file.Name())
- if err != nil {
- continue
- }
-
- dest, err := memory.Create(file.Name())
- if err != nil {
- continue
- }
-
- if _, err = io.Copy(dest, orig); err != nil {
- return nil, err
- }
- }
- }
-
- return memory, nil
-}
-```
-
-## License
-
-MIT, see [LICENSE](LICENSE)
diff --git a/vendor/gopkg.in/src-d/go-billy.v2/fs.go b/vendor/gopkg.in/src-d/go-billy.v2/fs.go
deleted file mode 100644
index 77cf25f3445d38b9e28fdba4f7f506b67f17df33..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-billy.v2/fs.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package billy
-
-import (
- "errors"
- "io"
- "os"
-)
-
-var (
- ErrClosed = errors.New("file: Writing on closed file.")
- ErrReadOnly = errors.New("this is a read-only filesystem")
- ErrNotSupported = errors.New("feature not supported")
-)
-
-// Filesystem abstract the operations in a storage-agnostic interface.
-// It allows you to:
-// * Create files.
-// * Open existing files.
-// * Get info about files.
-// * List files in a directory.
-// * Get a temporal file.
-// * Rename files.
-// * Remove files.
-// * Create directories.
-// * Join parts of path.
-// * Obtain a filesystem starting on a subdirectory in the current filesystem.
-// * Get the base path for the filesystem.
-// Each method implementation varies from implementation to implementation. Refer to
-// the specific documentation for more info.
-type Filesystem interface {
- Create(filename string) (File, error)
- Open(filename string) (File, error)
- OpenFile(filename string, flag int, perm os.FileMode) (File, error)
- Stat(filename string) (FileInfo, error)
- ReadDir(path string) ([]FileInfo, error)
- TempFile(dir, prefix string) (File, error)
- Rename(from, to string) error
- Remove(filename string) error
- MkdirAll(filename string, perm os.FileMode) error
- Join(elem ...string) string
- Dir(path string) Filesystem
- Base() string
-}
-
-// File implements io.Closer, io.Reader, io.Seeker, and io.Writer>
-// Provides method to obtain the file name and the state of the file (open or closed).
-type File interface {
- Filename() string
- IsClosed() bool
- io.Writer
- io.Reader
- io.Seeker
- io.Closer
-}
-
-type FileInfo os.FileInfo
-
-type BaseFile struct {
- BaseFilename string
- Closed bool
-}
-
-func (f *BaseFile) Filename() string {
- return f.BaseFilename
-}
-
-func (f *BaseFile) IsClosed() bool {
- return f.Closed
-}
-
-type removerAll interface {
- RemoveAll(string) error
-}
-
-// RemoveAll removes path and any children it contains.
-// It removes everything it can but returns the first error
-// it encounters. If the path does not exist, RemoveAll
-// returns nil (no error).
-func RemoveAll(fs Filesystem, path string) error {
- r, ok := fs.(removerAll)
- if ok {
- return r.RemoveAll(path)
- }
-
- return removeAll(fs, path)
-}
-
-func removeAll(fs Filesystem, path string) error {
- // This implementation is adapted from os.RemoveAll.
-
- // Simple case: if Remove works, we're done.
- err := fs.Remove(path)
- if err == nil || os.IsNotExist(err) {
- return nil
- }
-
- // Otherwise, is this a directory we need to recurse into?
- dir, serr := fs.Stat(path)
- if serr != nil {
- if os.IsNotExist(serr) {
- return nil
- }
-
- return serr
- }
-
- if !dir.IsDir() {
- // Not a directory; return the error from Remove.
- return err
- }
-
- // Directory.
- fis, err := fs.ReadDir(path)
- if err != nil {
- if os.IsNotExist(err) {
- // Race. It was deleted between the Lstat and Open.
- // Return nil per RemoveAll's docs.
- return nil
- }
-
- return err
- }
-
- // Remove contents & return first error.
- err = nil
- for _, fi := range fis {
- cpath := fs.Join(path, fi.Name())
- err1 := removeAll(fs, cpath)
- if err == nil {
- err = err1
- }
- }
-
- // Remove directory.
- err1 := fs.Remove(path)
- if err1 == nil || os.IsNotExist(err1) {
- return nil
- }
-
- if err == nil {
- err = err1
- }
-
- return err
-
-}
diff --git a/vendor/gopkg.in/src-d/go-billy.v2/osfs/os.go b/vendor/gopkg.in/src-d/go-billy.v2/osfs/os.go
deleted file mode 100644
index 0475450c15357cd224e1534283a8d311fea83007..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-billy.v2/osfs/os.go
+++ /dev/null
@@ -1,205 +0,0 @@
-// Package os provides a billy filesystem for the OS.
-package osfs // import "gopkg.in/src-d/go-billy.v2/osfs"
-
-import (
- "io/ioutil"
- "os"
- "path"
- "path/filepath"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-const (
- defaultDirectoryMode = 0755
- defaultCreateMode = 0666
-)
-
-// OS is a filesystem based on the os filesystem
-type OS struct {
- base string
-}
-
-// New returns a new OS filesystem
-func New(baseDir string) *OS {
- return &OS{
- base: baseDir,
- }
-}
-
-// Create creates a file and opens it with standard permissions
-// and modes O_RDWR, O_CREATE and O_TRUNC.
-func (fs *OS) Create(filename string) (billy.File, error) {
- return fs.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, defaultCreateMode)
-}
-
-// OpenFile is equivalent to standard os.OpenFile.
-// If flag os.O_CREATE is set, all parent directories will be created.
-func (fs *OS) OpenFile(filename string, flag int, perm os.FileMode) (billy.File, error) {
- fullpath := path.Join(fs.base, filename)
-
- if flag&os.O_CREATE != 0 {
- if err := fs.createDir(fullpath); err != nil {
- return nil, err
- }
- }
-
- f, err := os.OpenFile(fullpath, flag, perm)
- if err != nil {
- return nil, err
- }
-
- filename, err = filepath.Rel(fs.base, fullpath)
- if err != nil {
- return nil, err
- }
-
- return newOSFile(filename, f), nil
-}
-
-func (fs *OS) createDir(fullpath string) error {
- dir := filepath.Dir(fullpath)
- if dir != "." {
- if err := os.MkdirAll(dir, defaultDirectoryMode); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// ReadDir returns the filesystem info for all the archives under the specified
-// path.
-func (ofs *OS) ReadDir(path string) ([]billy.FileInfo, error) {
- fullpath := ofs.Join(ofs.base, path)
-
- l, err := ioutil.ReadDir(fullpath)
- if err != nil {
- return nil, err
- }
-
- var s = make([]billy.FileInfo, len(l))
- for i, f := range l {
- s[i] = f
- }
-
- return s, nil
-}
-
-// Rename moves a file in disk from _from_ to _to_.
-func (fs *OS) Rename(from, to string) error {
- from = fs.Join(fs.base, from)
- to = fs.Join(fs.base, to)
-
- if err := fs.createDir(to); err != nil {
- return err
- }
-
- return os.Rename(from, to)
-}
-
-// MkdirAll creates a directory.
-func (fs *OS) MkdirAll(path string, perm os.FileMode) error {
- fullpath := fs.Join(fs.base, path)
- return os.MkdirAll(fullpath, defaultDirectoryMode)
-}
-
-// Open opens a file in read-only mode.
-func (fs *OS) Open(filename string) (billy.File, error) {
- return fs.OpenFile(filename, os.O_RDONLY, 0)
-}
-
-// Stat returns the FileInfo structure describing file.
-func (fs *OS) Stat(filename string) (billy.FileInfo, error) {
- fullpath := fs.Join(fs.base, filename)
- return os.Stat(fullpath)
-}
-
-// Remove deletes a file in disk.
-func (fs *OS) Remove(filename string) error {
- fullpath := fs.Join(fs.base, filename)
- return os.Remove(fullpath)
-}
-
-// TempFile creates a new temporal file.
-func (fs *OS) TempFile(dir, prefix string) (billy.File, error) {
- fullpath := fs.Join(fs.base, dir)
- if err := fs.createDir(fullpath + string(os.PathSeparator)); err != nil {
- return nil, err
- }
-
- f, err := ioutil.TempFile(fullpath, prefix)
- if err != nil {
- return nil, err
- }
-
- s, err := f.Stat()
- if err != nil {
- return nil, err
- }
-
- filename, err := filepath.Rel(fs.base, fs.Join(fullpath, s.Name()))
- if err != nil {
- return nil, err
- }
-
- return newOSFile(filename, f), nil
-}
-
-// Join joins the specified elements using the filesystem separator.
-func (fs *OS) Join(elem ...string) string {
- return filepath.Join(elem...)
-}
-
-// Dir returns a new Filesystem from the same type of fs using as baseDir the
-// given path
-func (fs *OS) Dir(path string) billy.Filesystem {
- return New(fs.Join(fs.base, path))
-}
-
-// Base returns the base path of the filesytem
-func (fs *OS) Base() string {
- return fs.base
-}
-
-// RemoveAll removes a file or directory recursively. Removes everything it can,
-// but returns the first error.
-func (fs *OS) RemoveAll(path string) error {
- fullpath := fs.Join(fs.base, path)
- return os.RemoveAll(fullpath)
-}
-
-// osFile represents a file in the os filesystem
-type osFile struct {
- billy.BaseFile
- file *os.File
-}
-
-func newOSFile(filename string, file *os.File) billy.File {
- return &osFile{
- BaseFile: billy.BaseFile{BaseFilename: filename},
- file: file,
- }
-}
-
-func (f *osFile) Read(p []byte) (int, error) {
- return f.file.Read(p)
-}
-
-func (f *osFile) Seek(offset int64, whence int) (int64, error) {
- return f.file.Seek(offset, whence)
-}
-
-func (f *osFile) Write(p []byte) (int, error) {
- return f.file.Write(p)
-}
-
-func (f *osFile) Close() error {
- f.BaseFile.Closed = true
-
- return f.file.Close()
-}
-
-func (f *osFile) ReadAt(p []byte, off int64) (int, error) {
- return f.file.ReadAt(p, off)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/LICENSE b/vendor/gopkg.in/src-d/go-git.v4/LICENSE
deleted file mode 100644
index 6a4a6aa1f8304d34440c6944ad7a523548177197..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/LICENSE
+++ /dev/null
@@ -1,19 +0,0 @@
-Copyright (c) 2015 Sourced Technologies S.L.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is furnished
-to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/vendor/gopkg.in/src-d/go-git.v4/Makefile b/vendor/gopkg.in/src-d/go-git.v4/Makefile
deleted file mode 100644
index d576778f4d295e5b010366ebba8748089d3451ba..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/Makefile
+++ /dev/null
@@ -1,52 +0,0 @@
-# General
-WORKDIR = $(PWD)
-
-# Go parameters
-GOCMD = go
-GOTEST = $(GOCMD) test -v
-
-# Git config
-GIT_VERSION ?=
-GIT_DIST_PATH ?= $(PWD)/.git-dist
-GIT_REPOSITORY = http://github.com/git/git.git
-
-# Coverage
-COVERAGE_REPORT = coverage.txt
-COVERAGE_PROFILE = profile.out
-COVERAGE_MODE = atomic
-
-ifneq ($(origin CI), undefined)
- WORKDIR := $(GOPATH)/src/gopkg.in/src-d/go-git.v4
-endif
-
-build-git:
- @if [ -f $(GIT_DIST_PATH)/git ]; then \
- echo "nothing to do, using cache $(GIT_DIST_PATH)"; \
- else \
- git clone $(GIT_REPOSITORY) -b $(GIT_VERSION) --depth 1 --single-branch $(GIT_DIST_PATH); \
- cd $(GIT_DIST_PATH); \
- make configure; \
- ./configure; \
- make all; \
- fi
-
-test:
- @cd $(WORKDIR); \
- $(GOTEST) ./...
-
-test-coverage:
- @cd $(WORKDIR); \
- echo "" > $(COVERAGE_REPORT); \
- for dir in `find . -name "*.go" | grep -o '.*/' | sort | uniq`; do \
- $(GOTEST) $$dir -coverprofile=$(COVERAGE_PROFILE) -covermode=$(COVERAGE_MODE); \
- if [ $$? != 0 ]; then \
- exit 2; \
- fi; \
- if [ -f $(COVERAGE_PROFILE) ]; then \
- cat $(COVERAGE_PROFILE) >> $(COVERAGE_REPORT); \
- rm $(COVERAGE_PROFILE); \
- fi; \
- done; \
-
-clean:
- rm -rf $(GIT_DIST_PATH)
\ No newline at end of file
diff --git a/vendor/gopkg.in/src-d/go-git.v4/README.md b/vendor/gopkg.in/src-d/go-git.v4/README.md
deleted file mode 100644
index cd6450f365f60124ab2077e28ad1917fa7c3ab53..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/README.md
+++ /dev/null
@@ -1,122 +0,0 @@
-# go-git [](https://godoc.org/github.com/src-d/go-git) [](https://travis-ci.org/src-d/go-git) [](https://codecov.io/github/src-d/go-git) [](https://codebeat.co/projects/github-com-src-d-go-git)
-
-A highly extensible git implementation in **pure Go**.
-
-*go-git* aims to reach the completeness of [libgit2](https://libgit2.github.com/) or [jgit](http://www.eclipse.org/jgit/), nowadays covers the **majority** of the plumbing **read operations** and **some** of the main **write operations**, but lacks the main porcelain operations such as merges.
-
-It is **highly extensible**, we have been following the open/close principle in its design to facilitate extensions, mainly focusing the efforts on the persistence of the objects.
-
-### ... is this production ready?
-
-The master branch represents the `v4` of the library, it is currently under active development and is planned to be released in early 2017.
-
-If you are looking for a production ready version, please take a look to the [`v3`](https://github.com/src-d/go-git/tree/v3) which is being used in production at [source{d}](http://sourced.tech) since August 2015 to analyze all GitHub public repositories (i.e. 16M repositories).
-
-We recommend the use of `v4` to develop new projects since it includes much new functionality and provides a more *idiomatic git* API
-
-Installation
-------------
-
-The recommended way to install *go-git* is:
-
-```
-go get -u gopkg.in/src-d/go-git.v4/...
-```
-
-
-Examples
---------
-
-> Please note that the functions `CheckIfError` and `Info` used in the examples are from the [examples package](https://github.com/src-d/go-git/blob/master/_examples/common.go#L17) just to be used in the examples.
-
-
-### Basic example
-
-A basic example that mimics the standard `git clone` command
-
-```go
-// Clone the given repository to the given directory
-Info("git clone https://github.com/src-d/go-git")
-
-_, err := git.PlainClone("/tmp/foo", false, &git.CloneOptions{
- URL: "https://github.com/src-d/go-git",
- Progress: os.Stdout,
-})
-
-CheckIfError(err)
-```
-
-Outputs:
-```
-Counting objects: 4924, done.
-Compressing objects: 100% (1333/1333), done.
-Total 4924 (delta 530), reused 6 (delta 6), pack-reused 3533
-```
-
-### In-memory example
-
-Cloning a repository into memory and printing the history of HEAD, just like `git log` does
-
-
-```go
-// Clones the given repository in memory, creating the remote, the local
-// branches and fetching the objects, exactly as:
-Info("git clone https://github.com/src-d/go-siva")
-
-r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
- URL: "https://github.com/src-d/go-siva",
-})
-
-CheckIfError(err)
-
-// Gets the HEAD history from HEAD, just like does:
-Info("git log")
-
-// ... retrieves the branch pointed by HEAD
-ref, err := r.Head()
-CheckIfError(err)
-
-// ... retrieves the commit object
-commit, err := r.Commit(ref.Hash())
-CheckIfError(err)
-
-// ... retrieves the commit history
-history, err := commit.History()
-CheckIfError(err)
-
-// ... just iterates over the commits, printing it
-for _, c := range history {
- fmt.Println(c)
-}
-```
-
-Outputs:
-```
-commit ded8054fd0c3994453e9c8aacaf48d118d42991e
-Author: Santiago M. Mola <santi@mola.io>
-Date: Sat Nov 12 21:18:41 2016 +0100
-
- index: ReadFrom/WriteTo returns IndexReadError/IndexWriteError. (#9)
-
-commit df707095626f384ce2dc1a83b30f9a21d69b9dfc
-Author: Santiago M. Mola <santi@mola.io>
-Date: Fri Nov 11 13:23:22 2016 +0100
-
- readwriter: fix bug when writing index. (#10)
-
- When using ReadWriter on an existing siva file, absolute offset for
- index entries was not being calculated correctly.
-...
-```
-
-You can find this [example](_examples/log/main.go) and many other at the [examples](_examples) folder
-
-Contribute
-----------
-
-If you are interested on contributing to go-git, open an [issue](https://github.com/src-d/go-git/issues) explaining which missing functionality you want to work in, and we will guide you through the implementation.
-
-License
--------
-
-MIT, see [LICENSE](LICENSE)
diff --git a/vendor/gopkg.in/src-d/go-git.v4/blame.go b/vendor/gopkg.in/src-d/go-git.v4/blame.go
deleted file mode 100644
index 2f0843d29abe09408ac4e5c14f31e415fba91471..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/blame.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package git
-
-import (
- "bytes"
- "errors"
- "fmt"
- "strconv"
- "strings"
- "unicode/utf8"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
- "gopkg.in/src-d/go-git.v4/utils/diff"
-)
-
-// BlameResult represents the result of a Blame operation.
-type BlameResult struct {
- // Path is the path of the File that we're blaming.
- Path string
- // Rev (Revision) is the hash of the specified Commit used to generate this result.
- Rev plumbing.Hash
- // Lines contains every line with its authorship.
- Lines []*Line
-}
-
-// Blame returns a BlameResult with the information about the last author of
-// each line from file `path` at commit `c`.
-func Blame(c *object.Commit, path string) (*BlameResult, error) {
- // The file to blame is identified by the input arguments:
- // commit and path. commit is a Commit object obtained from a Repository. Path
- // represents a path to a specific file contained into the repository.
- //
- // Blaming a file is a two step process:
- //
- // 1. Create a linear history of the commits affecting a file. We use
- // revlist.New for that.
- //
- // 2. Then build a graph with a node for every line in every file in
- // the history of the file.
- //
- // Each node is assigned a commit: Start by the nodes in the first
- // commit. Assign that commit as the creator of all its lines.
- //
- // Then jump to the nodes in the next commit, and calculate the diff
- // between the two files. Newly created lines get
- // assigned the new commit as its origin. Modified lines also get
- // this new commit. Untouched lines retain the old commit.
- //
- // All this work is done in the assignOrigin function which holds all
- // the internal relevant data in a "blame" struct, that is not
- // exported.
- //
- // TODO: ways to improve the efficiency of this function:
- // 1. Improve revlist
- // 2. Improve how to traverse the history (example a backward traversal will
- // be much more efficient)
- //
- // TODO: ways to improve the function in general:
- // 1. Add memoization between revlist and assign.
- // 2. It is using much more memory than needed, see the TODOs below.
-
- b := new(blame)
- b.fRev = c
- b.path = path
-
- // get all the file revisions
- if err := b.fillRevs(); err != nil {
- return nil, err
- }
-
- // calculate the line tracking graph and fill in
- // file contents in data.
- if err := b.fillGraphAndData(); err != nil {
- return nil, err
- }
-
- file, err := b.fRev.File(b.path)
- if err != nil {
- return nil, err
- }
- finalLines, err := file.Lines()
- if err != nil {
- return nil, err
- }
-
- // Each node (line) holds the commit where it was introduced or
- // last modified. To achieve that we use the FORWARD algorithm
- // described in Zimmermann, et al. "Mining Version Archives for
- // Co-changed Lines", in proceedings of the Mining Software
- // Repositories workshop, Shanghai, May 22-23, 2006.
- lines, err := newLines(finalLines, b.sliceGraph(len(b.graph)-1))
- if err != nil {
- return nil, err
- }
-
- return &BlameResult{
- Path: path,
- Rev: c.Hash,
- Lines: lines,
- }, nil
-}
-
-// Line values represent the contents and author of a line in BlamedResult values.
-type Line struct {
- // Author is the email address of the last author that modified the line.
- Author string
- // Text is the original text of the line.
- Text string
-}
-
-func newLine(author, text string) *Line {
- return &Line{
- Author: author,
- Text: text,
- }
-}
-
-func newLines(contents []string, commits []*object.Commit) ([]*Line, error) {
- if len(contents) != len(commits) {
- return nil, errors.New("contents and commits have different length")
- }
- result := make([]*Line, 0, len(contents))
- for i := range contents {
- l := newLine(commits[i].Author.Email, contents[i])
- result = append(result, l)
- }
- return result, nil
-}
-
-// this struct is internally used by the blame function to hold its
-// inputs, outputs and state.
-type blame struct {
- // the path of the file to blame
- path string
- // the commit of the final revision of the file to blame
- fRev *object.Commit
- // the chain of revisions affecting the the file to blame
- revs []*object.Commit
- // the contents of the file across all its revisions
- data []string
- // the graph of the lines in the file across all the revisions
- graph [][]*object.Commit
-}
-
-// calculte the history of a file "path", starting from commit "from", sorted by commit date.
-func (b *blame) fillRevs() error {
- var err error
-
- b.revs, err = References(b.fRev, b.path)
- if err != nil {
- return err
- }
- return nil
-}
-
-// build graph of a file from its revision history
-func (b *blame) fillGraphAndData() error {
- //TODO: not all commits are needed, only the current rev and the prev
- b.graph = make([][]*object.Commit, len(b.revs))
- b.data = make([]string, len(b.revs)) // file contents in all the revisions
- // for every revision of the file, starting with the first
- // one...
- for i, rev := range b.revs {
- // get the contents of the file
- file, err := rev.File(b.path)
- if err != nil {
- return nil
- }
- b.data[i], err = file.Contents()
- if err != nil {
- return err
- }
- nLines := countLines(b.data[i])
- // create a node for each line
- b.graph[i] = make([]*object.Commit, nLines)
- // assign a commit to each node
- // if this is the first revision, then the node is assigned to
- // this first commit.
- if i == 0 {
- for j := 0; j < nLines; j++ {
- b.graph[i][j] = (*object.Commit)(b.revs[i])
- }
- } else {
- // if this is not the first commit, then assign to the old
- // commit or to the new one, depending on what the diff
- // says.
- b.assignOrigin(i, i-1)
- }
- }
- return nil
-}
-
-// sliceGraph returns a slice of commits (one per line) for a particular
-// revision of a file (0=first revision).
-func (b *blame) sliceGraph(i int) []*object.Commit {
- fVs := b.graph[i]
- result := make([]*object.Commit, 0, len(fVs))
- for _, v := range fVs {
- c := object.Commit(*v)
- result = append(result, &c)
- }
- return result
-}
-
-// Assigns origin to vertexes in current (c) rev from data in its previous (p)
-// revision
-func (b *blame) assignOrigin(c, p int) {
- // assign origin based on diff info
- hunks := diff.Do(b.data[p], b.data[c])
- sl := -1 // source line
- dl := -1 // destination line
- for h := range hunks {
- hLines := countLines(hunks[h].Text)
- for hl := 0; hl < hLines; hl++ {
- switch {
- case hunks[h].Type == 0:
- sl++
- dl++
- b.graph[c][dl] = b.graph[p][sl]
- case hunks[h].Type == 1:
- dl++
- b.graph[c][dl] = (*object.Commit)(b.revs[c])
- case hunks[h].Type == -1:
- sl++
- default:
- panic("unreachable")
- }
- }
- }
-}
-
-// GoString prints the results of a Blame using git-blame's style.
-func (b *blame) GoString() string {
- var buf bytes.Buffer
-
- file, err := b.fRev.File(b.path)
- if err != nil {
- panic("PrettyPrint: internal error in repo.Data")
- }
- contents, err := file.Contents()
- if err != nil {
- panic("PrettyPrint: internal error in repo.Data")
- }
-
- lines := strings.Split(contents, "\n")
- // max line number length
- mlnl := len(fmt.Sprintf("%s", strconv.Itoa(len(lines))))
- // max author length
- mal := b.maxAuthorLength()
- format := fmt.Sprintf("%%s (%%-%ds %%%dd) %%s\n",
- mal, mlnl)
-
- fVs := b.graph[len(b.graph)-1]
- for ln, v := range fVs {
- fmt.Fprintf(&buf, format, v.Hash.String()[:8],
- prettyPrintAuthor(fVs[ln]), ln+1, lines[ln])
- }
- return buf.String()
-}
-
-// utility function to pretty print the author.
-func prettyPrintAuthor(c *object.Commit) string {
- return fmt.Sprintf("%s %s", c.Author.Name, c.Author.When.Format("2006-01-02"))
-}
-
-// utility function to calculate the number of runes needed
-// to print the longest author name in the blame of a file.
-func (b *blame) maxAuthorLength() int {
- memo := make(map[plumbing.Hash]struct{}, len(b.graph)-1)
- fVs := b.graph[len(b.graph)-1]
- m := 0
- for ln := range fVs {
- if _, ok := memo[fVs[ln].Hash]; ok {
- continue
- }
- memo[fVs[ln].Hash] = struct{}{}
- m = max(m, utf8.RuneCountInString(prettyPrintAuthor(fVs[ln])))
- }
- return m
-}
-
-func max(a, b int) int {
- if a > b {
- return a
- }
- return b
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/common.go b/vendor/gopkg.in/src-d/go-git.v4/common.go
deleted file mode 100644
index f837a2654c174180a4455c0f705e02168576594d..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/common.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package git
-
-import "strings"
-
-const defaultDotGitPath = ".git"
-
-// countLines returns the number of lines in a string à la git, this is
-// The newline character is assumed to be '\n'. The empty string
-// contains 0 lines. If the last line of the string doesn't end with a
-// newline, it will still be considered a line.
-func countLines(s string) int {
- if s == "" {
- return 0
- }
-
- nEOL := strings.Count(s, "\n")
- if strings.HasSuffix(s, "\n") {
- return nEOL
- }
-
- return nEOL + 1
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/config/config.go b/vendor/gopkg.in/src-d/go-git.v4/config/config.go
deleted file mode 100644
index e8c99a96932c5b3232792970b07debe2b2e3ff9b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/config/config.go
+++ /dev/null
@@ -1,255 +0,0 @@
-// Package config contains the abstraction of multiple config files
-package config
-
-import (
- "bytes"
- "errors"
- "fmt"
-
- format "gopkg.in/src-d/go-git.v4/plumbing/format/config"
-)
-
-const (
- // DefaultFetchRefSpec is the default refspec used for fetch.
- DefaultFetchRefSpec = "+refs/heads/*:refs/remotes/%s/*"
- // DefaultPushRefSpec is the default refspec used for push.
- DefaultPushRefSpec = "refs/heads/*:refs/heads/*"
-)
-
-// ConfigStorer generic storage of Config object
-type ConfigStorer interface {
- Config() (*Config, error)
- SetConfig(*Config) error
-}
-
-var (
- ErrInvalid = errors.New("config invalid remote")
- ErrRemoteConfigNotFound = errors.New("remote config not found")
- ErrRemoteConfigEmptyURL = errors.New("remote config: empty URL")
- ErrRemoteConfigEmptyName = errors.New("remote config: empty name")
-)
-
-// Config contains the repository configuration
-// ftp://www.kernel.org/pub/software/scm/git/docs/git-config.html#FILES
-type Config struct {
- Core struct {
- // IsBare if true this repository is assumed to be bare and has no
- // working directory associated with it.
- IsBare bool
- // Worktree is the path to the root of the working tree.
- Worktree string
- }
- // Remotes list of repository remotes, the key of the map is the name
- // of the remote, should equal to RemoteConfig.Name.
- Remotes map[string]*RemoteConfig
- // Submodules list of repository submodules, the key of the map is the name
- // of the submodule, should equal to Submodule.Name.
- Submodules map[string]*Submodule
-
- // contains the raw information of a config file, the main goal is preserve
- // the parsed information from the original format, to avoid missing
- // unsupported features.
- raw *format.Config
-}
-
-// NewConfig returns a new empty Config.
-func NewConfig() *Config {
- return &Config{
- Remotes: make(map[string]*RemoteConfig, 0),
- Submodules: make(map[string]*Submodule, 0),
- raw: format.New(),
- }
-}
-
-// Validate validates the fields and sets the default values.
-func (c *Config) Validate() error {
- for name, r := range c.Remotes {
- if r.Name != name {
- return ErrInvalid
- }
-
- if err := r.Validate(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-const (
- remoteSection = "remote"
- submoduleSection = "submodule"
- coreSection = "core"
- fetchKey = "fetch"
- urlKey = "url"
- bareKey = "bare"
- worktreeKey = "worktree"
-)
-
-// Unmarshal parses a git-config file and stores it.
-func (c *Config) Unmarshal(b []byte) error {
- r := bytes.NewBuffer(b)
- d := format.NewDecoder(r)
-
- c.raw = format.New()
- if err := d.Decode(c.raw); err != nil {
- return err
- }
-
- c.unmarshalCore()
- c.unmarshalSubmodules()
- return c.unmarshalRemotes()
-}
-
-func (c *Config) unmarshalCore() {
- s := c.raw.Section(coreSection)
- if s.Options.Get(bareKey) == "true" {
- c.Core.IsBare = true
- }
-
- c.Core.Worktree = s.Options.Get(worktreeKey)
-}
-
-func (c *Config) unmarshalRemotes() error {
- s := c.raw.Section(remoteSection)
- for _, sub := range s.Subsections {
- r := &RemoteConfig{}
- if err := r.unmarshal(sub); err != nil {
- return err
- }
-
- c.Remotes[r.Name] = r
- }
-
- return nil
-}
-
-func (c *Config) unmarshalSubmodules() {
- s := c.raw.Section(submoduleSection)
- for _, sub := range s.Subsections {
- m := &Submodule{}
- m.unmarshal(sub)
-
- c.Submodules[m.Name] = m
- }
-}
-
-// Marshal returns Config encoded as a git-config file.
-func (c *Config) Marshal() ([]byte, error) {
- c.marshalCore()
- c.marshalRemotes()
- c.marshalSubmodules()
-
- buf := bytes.NewBuffer(nil)
- if err := format.NewEncoder(buf).Encode(c.raw); err != nil {
- return nil, err
- }
-
- return buf.Bytes(), nil
-}
-
-func (c *Config) marshalCore() {
- s := c.raw.Section(coreSection)
- s.SetOption(bareKey, fmt.Sprintf("%t", c.Core.IsBare))
-
- if c.Core.Worktree != "" {
- s.SetOption(worktreeKey, c.Core.Worktree)
- }
-}
-
-func (c *Config) marshalRemotes() {
- s := c.raw.Section(remoteSection)
- s.Subsections = make(format.Subsections, len(c.Remotes))
-
- var i int
- for _, r := range c.Remotes {
- s.Subsections[i] = r.marshal()
- i++
- }
-}
-
-func (c *Config) marshalSubmodules() {
- s := c.raw.Section(submoduleSection)
- s.Subsections = make(format.Subsections, len(c.Submodules))
-
- var i int
- for _, r := range c.Submodules {
- section := r.marshal()
- // the submodule section at config is a subset of the .gitmodule file
- // we should remove the non-valid options for the config file.
- section.RemoveOption(pathKey)
- s.Subsections[i] = section
- i++
- }
-}
-
-// RemoteConfig contains the configuration for a given remote repository.
-type RemoteConfig struct {
- // Name of the remote
- Name string
- // URL the URL of a remote repository
- URL string
- // Fetch the default set of "refspec" for fetch operation
- Fetch []RefSpec
-
- // raw representation of the subsection, filled by marshal or unmarshal are
- // called
- raw *format.Subsection
-}
-
-// Validate validates the fields and sets the default values.
-func (c *RemoteConfig) Validate() error {
- if c.Name == "" {
- return ErrRemoteConfigEmptyName
- }
-
- if c.URL == "" {
- return ErrRemoteConfigEmptyURL
- }
-
- for _, r := range c.Fetch {
- if err := r.Validate(); err != nil {
- return err
- }
- }
-
- if len(c.Fetch) == 0 {
- c.Fetch = []RefSpec{RefSpec(fmt.Sprintf(DefaultFetchRefSpec, c.Name))}
- }
-
- return nil
-}
-
-func (c *RemoteConfig) unmarshal(s *format.Subsection) error {
- c.raw = s
-
- fetch := []RefSpec{}
- for _, f := range c.raw.Options.GetAll(fetchKey) {
- rs := RefSpec(f)
- if err := rs.Validate(); err != nil {
- return err
- }
-
- fetch = append(fetch, rs)
- }
-
- c.Name = c.raw.Name
- c.URL = c.raw.Option(urlKey)
- c.Fetch = fetch
-
- return nil
-}
-
-func (c *RemoteConfig) marshal() *format.Subsection {
- if c.raw == nil {
- c.raw = &format.Subsection{}
- }
-
- c.raw.Name = c.Name
- c.raw.SetOption(urlKey, c.URL)
- for _, rs := range c.Fetch {
- c.raw.SetOption(fetchKey, rs.String())
- }
-
- return c.raw
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/config/modules.go b/vendor/gopkg.in/src-d/go-git.v4/config/modules.go
deleted file mode 100644
index 24ef304a0237b30bfd02de1d24510b64ff5a6955..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/config/modules.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package config
-
-import (
- "bytes"
- "errors"
-
- format "gopkg.in/src-d/go-git.v4/plumbing/format/config"
-)
-
-var (
- ErrModuleEmptyURL = errors.New("module config: empty URL")
- ErrModuleEmptyPath = errors.New("module config: empty path")
-)
-
-// Modules defines the submodules properties, represents a .gitmodules file
-// https://www.kernel.org/pub/software/scm/git/docs/gitmodules.html
-type Modules struct {
- // Submodules is a map of submodules being the key the name of the submodule.
- Submodules map[string]*Submodule
-
- raw *format.Config
-}
-
-// NewModules returns a new empty Modules
-func NewModules() *Modules {
- return &Modules{
- Submodules: make(map[string]*Submodule, 0),
- raw: format.New(),
- }
-}
-
-const (
- pathKey = "path"
- branchKey = "branch"
-)
-
-// Unmarshal parses a git-config file and stores it.
-func (m *Modules) Unmarshal(b []byte) error {
- r := bytes.NewBuffer(b)
- d := format.NewDecoder(r)
-
- m.raw = format.New()
- if err := d.Decode(m.raw); err != nil {
- return err
- }
-
- s := m.raw.Section(submoduleSection)
- for _, sub := range s.Subsections {
- mod := &Submodule{}
- mod.unmarshal(sub)
-
- m.Submodules[mod.Path] = mod
- }
-
- return nil
-}
-
-// Marshal returns Modules encoded as a git-config file.
-func (m *Modules) Marshal() ([]byte, error) {
- s := m.raw.Section(submoduleSection)
- s.Subsections = make(format.Subsections, len(m.Submodules))
-
- var i int
- for _, r := range m.Submodules {
- s.Subsections[i] = r.marshal()
- i++
- }
-
- buf := bytes.NewBuffer(nil)
- if err := format.NewEncoder(buf).Encode(m.raw); err != nil {
- return nil, err
- }
-
- return buf.Bytes(), nil
-}
-
-// Submodule defines a submodule.
-type Submodule struct {
- // Name module name
- Name string
- // Path defines the path, relative to the top-level directory of the Git
- // working tree.
- Path string
- // URL defines a URL from which the submodule repository can be cloned.
- URL string
- // Branch is a remote branch name for tracking updates in the upstream
- // submodule. Optional value.
- Branch string
-
- // raw representation of the subsection, filled by marshal or unmarshal are
- // called.
- raw *format.Subsection
-}
-
-// Validate validates the fields and sets the default values.
-func (m *Submodule) Validate() error {
- if m.Path == "" {
- return ErrModuleEmptyPath
- }
-
- if m.URL == "" {
- return ErrModuleEmptyURL
- }
-
- return nil
-}
-
-func (m *Submodule) unmarshal(s *format.Subsection) {
- m.raw = s
-
- m.Name = m.raw.Name
- m.Path = m.raw.Option(pathKey)
- m.URL = m.raw.Option(urlKey)
- m.Branch = m.raw.Option(branchKey)
-}
-
-func (m *Submodule) marshal() *format.Subsection {
- if m.raw == nil {
- m.raw = &format.Subsection{}
- }
-
- m.raw.Name = m.Name
- if m.raw.Name == "" {
- m.raw.Name = m.Path
- }
-
- m.raw.SetOption(pathKey, m.Path)
- m.raw.SetOption(urlKey, m.URL)
-
- if m.Branch != "" {
- m.raw.SetOption(branchKey, m.Branch)
- }
-
- return m.raw
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/config/refspec.go b/vendor/gopkg.in/src-d/go-git.v4/config/refspec.go
deleted file mode 100644
index 7e4106ad64f475a2adb309ea90780c03dc8c59eb..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/config/refspec.go
+++ /dev/null
@@ -1,145 +0,0 @@
-package config
-
-import (
- "errors"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-const (
- refSpecWildcard = "*"
- refSpecForce = "+"
- refSpecSeparator = ":"
-)
-
-var (
- ErrRefSpecMalformedSeparator = errors.New("malformed refspec, separators are wrong")
- ErrRefSpecMalformedWildcard = errors.New("malformed refspec, missmatched number of wildcards")
-)
-
-// RefSpec is a mapping from local branches to remote references
-// The format of the refspec is an optional +, followed by <src>:<dst>, where
-// <src> is the pattern for references on the remote side and <dst> is where
-// those references will be written locally. The + tells Git to update the
-// reference even if it isn’t a fast-forward.
-// eg.: "+refs/heads/*:refs/remotes/origin/*"
-//
-// https://git-scm.com/book/es/v2/Git-Internals-The-Refspec
-type RefSpec string
-
-// Validate validates the RefSpec
-func (s RefSpec) Validate() error {
- spec := string(s)
- if strings.Count(spec, refSpecSeparator) != 1 {
- return ErrRefSpecMalformedSeparator
- }
-
- sep := strings.Index(spec, refSpecSeparator)
- if sep == len(spec)-1 {
- return ErrRefSpecMalformedSeparator
- }
-
- ws := strings.Count(spec[0:sep], refSpecWildcard)
- wd := strings.Count(spec[sep+1:], refSpecWildcard)
- if ws == wd && ws < 2 && wd < 2 {
- return nil
- }
-
- return ErrRefSpecMalformedWildcard
-}
-
-// IsForceUpdate returns if update is allowed in non fast-forward merges.
-func (s RefSpec) IsForceUpdate() bool {
- if s[0] == refSpecForce[0] {
- return true
- }
-
- return false
-}
-
-// IsDelete returns true if the refspec indicates a delete (empty src).
-func (s RefSpec) IsDelete() bool {
- if s[0] == refSpecSeparator[0] {
- return true
- }
-
- return false
-}
-
-// Src return the src side.
-func (s RefSpec) Src() string {
- spec := string(s)
- start := strings.Index(spec, refSpecForce) + 1
- end := strings.Index(spec, refSpecSeparator)
-
- return spec[start:end]
-}
-
-// Match match the given plumbing.ReferenceName against the source.
-func (s RefSpec) Match(n plumbing.ReferenceName) bool {
- if !s.IsWildcard() {
- return s.matchExact(n)
- }
-
- return s.matchGlob(n)
-}
-
-// IsWildcard returns true if the RefSpec contains a wildcard.
-func (s RefSpec) IsWildcard() bool {
- return strings.Index(string(s), refSpecWildcard) != -1
-}
-
-func (s RefSpec) matchExact(n plumbing.ReferenceName) bool {
- return s.Src() == n.String()
-}
-
-func (s RefSpec) matchGlob(n plumbing.ReferenceName) bool {
- src := s.Src()
- name := n.String()
- wildcard := strings.Index(src, refSpecWildcard)
-
- var prefix, suffix string
- prefix = src[0:wildcard]
- if len(src) < wildcard {
- suffix = src[wildcard+1 : len(suffix)]
- }
-
- return len(name) > len(prefix)+len(suffix) &&
- strings.HasPrefix(name, prefix) &&
- strings.HasSuffix(name, suffix)
-}
-
-// Dst returns the destination for the given remote reference.
-func (s RefSpec) Dst(n plumbing.ReferenceName) plumbing.ReferenceName {
- spec := string(s)
- start := strings.Index(spec, refSpecSeparator) + 1
- dst := spec[start:]
- src := s.Src()
-
- if !s.IsWildcard() {
- return plumbing.ReferenceName(dst)
- }
-
- name := n.String()
- ws := strings.Index(src, refSpecWildcard)
- wd := strings.Index(dst, refSpecWildcard)
- match := name[ws : len(name)-(len(src)-(ws+1))]
-
- return plumbing.ReferenceName(dst[0:wd] + match + dst[wd+1:])
-}
-
-func (s RefSpec) String() string {
- return string(s)
-}
-
-// MatchAny returns true if any of the RefSpec match with the given ReferenceName.
-func MatchAny(l []RefSpec, n plumbing.ReferenceName) bool {
- for _, r := range l {
- if r.Match(n) {
- return true
- }
- }
-
- return false
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/doc.go b/vendor/gopkg.in/src-d/go-git.v4/doc.go
deleted file mode 100644
index 60f2261e415ad54a97c0278b4a1616c736e27ecf..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/doc.go
+++ /dev/null
@@ -1,10 +0,0 @@
-// A highly extensible git implementation in pure Go.
-//
-// go-git aims to reach the completeness of libgit2 or jgit, nowadays covers the
-// majority of the plumbing read operations and some of the main write
-// operations, but lacks the main porcelain operations such as merges.
-//
-// It is highly extensible, we have been following the open/close principle in
-// its design to facilitate extensions, mainly focusing the efforts on the
-// persistence of the objects.
-package git // import "gopkg.in/src-d/go-git.v4"
diff --git a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/parser.go b/vendor/gopkg.in/src-d/go-git.v4/internal/revision/parser.go
deleted file mode 100644
index b45a6d8d0291bbe38a4a8ef564bf4612258a0878..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/parser.go
+++ /dev/null
@@ -1,622 +0,0 @@
-// Package revision extracts git revision from string
-// More informations about revision : https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html
-package revision
-
-import (
- "bytes"
- "fmt"
- "io"
- "regexp"
- "strconv"
- "time"
-)
-
-// ErrInvalidRevision is emitted if string doesn't match valid revision
-type ErrInvalidRevision struct {
- s string
-}
-
-func (e *ErrInvalidRevision) Error() string {
- return "Revision invalid : " + e.s
-}
-
-// Revisioner represents a revision component.
-// A revision is made of multiple revision components
-// obtained after parsing a revision string,
-// for instance revision "master~" will be converted in
-// two revision components Ref and TildePath
-type Revisioner interface {
-}
-
-// Ref represents a reference name : HEAD, master
-type Ref string
-
-// TildePath represents ~, ~{n}
-type TildePath struct {
- Depth int
-}
-
-// CaretPath represents ^, ^{n}
-type CaretPath struct {
- Depth int
-}
-
-// CaretReg represents ^{/foo bar}
-type CaretReg struct {
- Regexp *regexp.Regexp
- Negate bool
-}
-
-// CaretType represents ^{commit}
-type CaretType struct {
- ObjectType string
-}
-
-// AtReflog represents @{n}
-type AtReflog struct {
- Depth int
-}
-
-// AtCheckout represents @{-n}
-type AtCheckout struct {
- Depth int
-}
-
-// AtUpstream represents @{upstream}, @{u}
-type AtUpstream struct {
- BranchName string
-}
-
-// AtPush represents @{push}
-type AtPush struct {
- BranchName string
-}
-
-// AtDate represents @{"2006-01-02T15:04:05Z"}
-type AtDate struct {
- Date time.Time
-}
-
-// ColonReg represents :/foo bar
-type ColonReg struct {
- Regexp *regexp.Regexp
- Negate bool
-}
-
-// ColonPath represents :./<path> :<path>
-type ColonPath struct {
- Path string
-}
-
-// ColonStagePath represents :<n>:/<path>
-type ColonStagePath struct {
- Path string
- Stage int
-}
-
-// Parser represents a parser
-// use to tokenize and transform to revisioner chunks
-// a given string
-type Parser struct {
- s *scanner
- currentParsedChar struct {
- tok token
- lit string
- }
- unreadLastChar bool
-}
-
-// NewParserFromString returns a new instance of parser from a string.
-func NewParserFromString(s string) *Parser {
- return NewParser(bytes.NewBufferString(s))
-}
-
-// NewParser returns a new instance of parser.
-func NewParser(r io.Reader) *Parser {
- return &Parser{s: newScanner(r)}
-}
-
-// scan returns the next token from the underlying scanner
-// or the last scanned token if an unscan was requested
-func (p *Parser) scan() (token, string, error) {
- if p.unreadLastChar {
- p.unreadLastChar = false
- return p.currentParsedChar.tok, p.currentParsedChar.lit, nil
- }
-
- tok, lit, err := p.s.scan()
-
- p.currentParsedChar.tok, p.currentParsedChar.lit = tok, lit
-
- return tok, lit, err
-}
-
-// unscan pushes the previously read token back onto the buffer.
-func (p *Parser) unscan() { p.unreadLastChar = true }
-
-// Parse explode a revision string into revisioner chunks
-func (p *Parser) Parse() ([]Revisioner, error) {
- var rev Revisioner
- var revs []Revisioner
- var tok token
- var err error
-
- for {
- tok, _, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch tok {
- case at:
- rev, err = p.parseAt()
- case tilde:
- rev, err = p.parseTilde()
- case caret:
- rev, err = p.parseCaret()
- case colon:
- rev, err = p.parseColon()
- case eof:
- err = p.validateFullRevision(&revs)
-
- if err != nil {
- return []Revisioner{}, err
- }
-
- return revs, nil
- default:
- p.unscan()
- rev, err = p.parseRef()
- }
-
- if err != nil {
- return []Revisioner{}, err
- }
-
- revs = append(revs, rev)
- }
-}
-
-// validateFullRevision ensures all revisioner chunks make a valid revision
-func (p *Parser) validateFullRevision(chunks *[]Revisioner) error {
- var hasReference bool
-
- for i, chunk := range *chunks {
- switch chunk.(type) {
- case Ref:
- if i == 0 {
- hasReference = true
- } else {
- return &ErrInvalidRevision{`reference must be defined once at the beginning`}
- }
- case AtDate:
- if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
- return nil
- }
-
- return &ErrInvalidRevision{`"@" statement is not valid, could be : <refname>@{<ISO-8601 date>}, @{<ISO-8601 date>}`}
- case AtReflog:
- if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
- return nil
- }
-
- return &ErrInvalidRevision{`"@" statement is not valid, could be : <refname>@{<n>}, @{<n>}`}
- case AtCheckout:
- if len(*chunks) == 1 {
- return nil
- }
-
- return &ErrInvalidRevision{`"@" statement is not valid, could be : @{-<n>}`}
- case AtUpstream:
- if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
- return nil
- }
-
- return &ErrInvalidRevision{`"@" statement is not valid, could be : <refname>@{upstream}, @{upstream}, <refname>@{u}, @{u}`}
- case AtPush:
- if len(*chunks) == 1 || hasReference && len(*chunks) == 2 {
- return nil
- }
-
- return &ErrInvalidRevision{`"@" statement is not valid, could be : <refname>@{push}, @{push}`}
- case TildePath, CaretPath, CaretReg:
- if !hasReference {
- return &ErrInvalidRevision{`"~" or "^" statement must have a reference defined at the beginning`}
- }
- case ColonReg:
- if len(*chunks) == 1 {
- return nil
- }
-
- return &ErrInvalidRevision{`":" statement is not valid, could be : :/<regexp>`}
- case ColonPath:
- if i == len(*chunks)-1 && hasReference || len(*chunks) == 1 {
- return nil
- }
-
- return &ErrInvalidRevision{`":" statement is not valid, could be : <revision>:<path>`}
- case ColonStagePath:
- if len(*chunks) == 1 {
- return nil
- }
-
- return &ErrInvalidRevision{`":" statement is not valid, could be : :<n>:<path>`}
- }
- }
-
- return nil
-}
-
-// parseAt extract @ statements
-func (p *Parser) parseAt() (Revisioner, error) {
- var tok, nextTok token
- var lit, nextLit string
- var err error
-
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- if tok != obrace {
- p.unscan()
-
- return Ref("HEAD"), nil
- }
-
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- nextTok, nextLit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == word && (lit == "u" || lit == "upstream") && nextTok == cbrace:
- return AtUpstream{}, nil
- case tok == word && lit == "push" && nextTok == cbrace:
- return AtPush{}, nil
- case tok == number && nextTok == cbrace:
- n, _ := strconv.Atoi(lit)
-
- return AtReflog{n}, nil
- case tok == minus && nextTok == number:
- n, _ := strconv.Atoi(nextLit)
-
- t, _, err := p.scan()
-
- if err != nil {
- return nil, err
- }
-
- if t != cbrace {
- return nil, &ErrInvalidRevision{fmt.Sprintf(`missing "}" in @{-n} structure`)}
- }
-
- return AtCheckout{n}, nil
- default:
- p.unscan()
-
- date := lit
-
- for {
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == cbrace:
- t, err := time.Parse("2006-01-02T15:04:05Z", date)
-
- if err != nil {
- return nil, &ErrInvalidRevision{fmt.Sprintf(`wrong date "%s" must fit ISO-8601 format : 2006-01-02T15:04:05Z`, date)}
- }
-
- return AtDate{t}, nil
- default:
- date += lit
- }
- }
- }
-}
-
-// parseTilde extract ~ statements
-func (p *Parser) parseTilde() (Revisioner, error) {
- var tok token
- var lit string
- var err error
-
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == number:
- n, _ := strconv.Atoi(lit)
-
- return TildePath{n}, nil
- default:
- p.unscan()
- return TildePath{1}, nil
- }
-}
-
-// parseCaret extract ^ statements
-func (p *Parser) parseCaret() (Revisioner, error) {
- var tok token
- var lit string
- var err error
-
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == obrace:
- r, err := p.parseCaretBraces()
-
- if err != nil {
- return nil, err
- }
-
- return r, nil
- case tok == number:
- n, _ := strconv.Atoi(lit)
-
- if n > 2 {
- return nil, &ErrInvalidRevision{fmt.Sprintf(`"%s" found must be 0, 1 or 2 after "^"`, lit)}
- }
-
- return CaretPath{n}, nil
- default:
- p.unscan()
- return CaretPath{1}, nil
- }
-}
-
-// parseCaretBraces extract ^{<data>} statements
-func (p *Parser) parseCaretBraces() (Revisioner, error) {
- var tok, nextTok token
- var lit, _ string
- start := true
- var re string
- var negate bool
- var err error
-
- for {
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- nextTok, _, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == word && nextTok == cbrace && (lit == "commit" || lit == "tree" || lit == "blob" || lit == "tag" || lit == "object"):
- return CaretType{lit}, nil
- case re == "" && tok == cbrace:
- return CaretType{"tag"}, nil
- case re == "" && tok == emark && nextTok == emark:
- re += lit
- case re == "" && tok == emark && nextTok == minus:
- negate = true
- case re == "" && tok == emark:
- return nil, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component sequences starting with "/!" others than those defined are reserved`)}
- case re == "" && tok == slash:
- p.unscan()
- case tok != slash && start:
- return nil, &ErrInvalidRevision{fmt.Sprintf(`"%s" is not a valid revision suffix brace component`, lit)}
- case tok != cbrace:
- p.unscan()
- re += lit
- case tok == cbrace:
- p.unscan()
-
- reg, err := regexp.Compile(re)
-
- if err != nil {
- return CaretReg{}, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component, %s`, err.Error())}
- }
-
- return CaretReg{reg, negate}, nil
- }
-
- start = false
- }
-}
-
-// parseColon extract : statements
-func (p *Parser) parseColon() (Revisioner, error) {
- var tok token
- var err error
-
- tok, _, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch tok {
- case slash:
- return p.parseColonSlash()
- default:
- p.unscan()
- return p.parseColonDefault()
- }
-}
-
-// parseColonSlash extract :/<data> statements
-func (p *Parser) parseColonSlash() (Revisioner, error) {
- var tok, nextTok token
- var lit string
- var re string
- var negate bool
- var err error
-
- for {
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- nextTok, _, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == emark && nextTok == emark:
- re += lit
- case re == "" && tok == emark && nextTok == minus:
- negate = true
- case re == "" && tok == emark:
- return nil, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component sequences starting with "/!" others than those defined are reserved`)}
- case tok == eof:
- p.unscan()
- reg, err := regexp.Compile(re)
-
- if err != nil {
- return ColonReg{}, &ErrInvalidRevision{fmt.Sprintf(`revision suffix brace component, %s`, err.Error())}
- }
-
- return ColonReg{reg, negate}, nil
- default:
- p.unscan()
- re += lit
- }
- }
-}
-
-// parseColonDefault extract :<data> statements
-func (p *Parser) parseColonDefault() (Revisioner, error) {
- var tok token
- var lit string
- var path string
- var stage int
- var err error
- var n = -1
-
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- nextTok, _, err := p.scan()
-
- if err != nil {
- return nil, err
- }
-
- if tok == number && nextTok == colon {
- n, _ = strconv.Atoi(lit)
- }
-
- switch n {
- case 0, 1, 2, 3:
- stage = n
- default:
- path += lit
- p.unscan()
- }
-
- for {
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch {
- case tok == eof && n == -1:
- return ColonPath{path}, nil
- case tok == eof:
- return ColonStagePath{path, stage}, nil
- default:
- path += lit
- }
- }
-}
-
-// parseRef extract reference name
-func (p *Parser) parseRef() (Revisioner, error) {
- var tok, prevTok token
- var lit, buf string
- var endOfRef bool
- var err error
-
- for {
- tok, lit, err = p.scan()
-
- if err != nil {
- return nil, err
- }
-
- switch tok {
- case eof, at, colon, tilde, caret:
- endOfRef = true
- }
-
- err := p.checkRefFormat(tok, lit, prevTok, buf, endOfRef)
-
- if err != nil {
- return "", err
- }
-
- if endOfRef {
- p.unscan()
- return Ref(buf), nil
- }
-
- buf += lit
- prevTok = tok
- }
-}
-
-// checkRefFormat ensure reference name follow rules defined here :
-// https://git-scm.com/docs/git-check-ref-format
-func (p *Parser) checkRefFormat(token token, literal string, previousToken token, buffer string, endOfRef bool) error {
- switch token {
- case aslash, space, control, qmark, asterisk, obracket:
- return &ErrInvalidRevision{fmt.Sprintf(`must not contains "%s"`, literal)}
- }
-
- switch {
- case (token == dot || token == slash) && buffer == "":
- return &ErrInvalidRevision{fmt.Sprintf(`must not start with "%s"`, literal)}
- case previousToken == slash && endOfRef:
- return &ErrInvalidRevision{`must not end with "/"`}
- case previousToken == dot && endOfRef:
- return &ErrInvalidRevision{`must not end with "."`}
- case token == dot && previousToken == slash:
- return &ErrInvalidRevision{`must not contains "/."`}
- case previousToken == dot && token == dot:
- return &ErrInvalidRevision{`must not contains ".."`}
- case previousToken == slash && token == slash:
- return &ErrInvalidRevision{`must not contains consecutively "/"`}
- case (token == slash || endOfRef) && len(buffer) > 4 && buffer[len(buffer)-5:] == ".lock":
- return &ErrInvalidRevision{"cannot end with .lock"}
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/scanner.go b/vendor/gopkg.in/src-d/go-git.v4/internal/revision/scanner.go
deleted file mode 100644
index fb5f333f7f8a9144cbcbfa6e8342ed5dc412626b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/scanner.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package revision
-
-import (
- "bufio"
- "io"
- "unicode"
-)
-
-// runeCategoryValidator takes a rune as input and
-// validates it belongs to a rune category
-type runeCategoryValidator func(r rune) bool
-
-// tokenizeExpression aggegates a series of runes matching check predicate into a single
-// string and provides given tokenType as token type
-func tokenizeExpression(ch rune, tokenType token, check runeCategoryValidator, r *bufio.Reader) (token, string, error) {
- var data []rune
- data = append(data, ch)
-
- for {
- c, _, err := r.ReadRune()
-
- if c == zeroRune {
- break
- }
-
- if err != nil {
- return tokenError, "", err
- }
-
- if check(c) {
- data = append(data, c)
- } else {
- err := r.UnreadRune()
-
- if err != nil {
- return tokenError, "", err
- }
-
- return tokenType, string(data), nil
- }
- }
-
- return tokenType, string(data), nil
-}
-
-var zeroRune = rune(0)
-
-// scanner represents a lexical scanner.
-type scanner struct {
- r *bufio.Reader
-}
-
-// newScanner returns a new instance of scanner.
-func newScanner(r io.Reader) *scanner {
- return &scanner{r: bufio.NewReader(r)}
-}
-
-// Scan extracts tokens and their strings counterpart
-// from the reader
-func (s *scanner) scan() (token, string, error) {
- ch, _, err := s.r.ReadRune()
-
- if err != nil && err != io.EOF {
- return tokenError, "", err
- }
-
- switch ch {
- case zeroRune:
- return eof, "", nil
- case ':':
- return colon, string(ch), nil
- case '~':
- return tilde, string(ch), nil
- case '^':
- return caret, string(ch), nil
- case '.':
- return dot, string(ch), nil
- case '/':
- return slash, string(ch), nil
- case '{':
- return obrace, string(ch), nil
- case '}':
- return cbrace, string(ch), nil
- case '-':
- return minus, string(ch), nil
- case '@':
- return at, string(ch), nil
- case '\\':
- return aslash, string(ch), nil
- case '?':
- return qmark, string(ch), nil
- case '*':
- return asterisk, string(ch), nil
- case '[':
- return obracket, string(ch), nil
- case '!':
- return emark, string(ch), nil
- }
-
- if unicode.IsSpace(ch) {
- return space, string(ch), nil
- }
-
- if unicode.IsControl(ch) {
- return control, string(ch), nil
- }
-
- if unicode.IsLetter(ch) {
- return tokenizeExpression(ch, word, unicode.IsLetter, s.r)
- }
-
- if unicode.IsNumber(ch) {
- return tokenizeExpression(ch, number, unicode.IsNumber, s.r)
- }
-
- return tokenError, string(ch), nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/token.go b/vendor/gopkg.in/src-d/go-git.v4/internal/revision/token.go
deleted file mode 100644
index abc4048869376c5c0ca3ae7629ca2a1004b1c732..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/internal/revision/token.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package revision
-
-// token represents a entity extracted from string parsing
-type token int
-
-const (
- eof token = iota
-
- aslash
- asterisk
- at
- caret
- cbrace
- colon
- control
- dot
- emark
- minus
- number
- obrace
- obracket
- qmark
- slash
- space
- tilde
- tokenError
- word
-)
diff --git a/vendor/gopkg.in/src-d/go-git.v4/options.go b/vendor/gopkg.in/src-d/go-git.v4/options.go
deleted file mode 100644
index 1047d7eed557fa11ebbbe83f46f08b13ad3d6f0a..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/options.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package git
-
-import (
- "errors"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
-)
-
-// SubmoduleRescursivity defines how depth will affect any submodule recursive
-// operation.
-type SubmoduleRescursivity uint
-
-const (
- // DefaultRemoteName name of the default Remote, just like git command.
- DefaultRemoteName = "origin"
-
- // NoRecurseSubmodules disables the recursion for a submodule operation.
- NoRecurseSubmodules SubmoduleRescursivity = 0
- // DefaultSubmoduleRecursionDepth allow recursion in a submodule operation.
- DefaultSubmoduleRecursionDepth SubmoduleRescursivity = 10
-)
-
-var (
- ErrMissingURL = errors.New("URL field is required")
-)
-
-// CloneOptions describes how a clone should be performed.
-type CloneOptions struct {
- // The (possibly remote) repository URL to clone from.
- URL string
- // Auth credentials, if required, to use with the remote repository.
- Auth transport.AuthMethod
- // Name of the remote to be added, by default `origin`.
- RemoteName string
- // Remote branch to clone.
- ReferenceName plumbing.ReferenceName
- // Fetch only ReferenceName if true.
- SingleBranch bool
- // Limit fetching to the specified number of commits.
- Depth int
- // RecurseSubmodules after the clone is created, initialize all submodules
- // within, using their default settings. This option is ignored if the
- // cloned repository does not have a worktree.
- RecurseSubmodules SubmoduleRescursivity
- // Progress is where the human readable information sent by the server is
- // stored, if nil nothing is stored and the capability (if supported)
- // no-progress, is sent to the server to avoid send this information.
- Progress sideband.Progress
-}
-
-// Validate validates the fields and sets the default values.
-func (o *CloneOptions) Validate() error {
- if o.URL == "" {
- return ErrMissingURL
- }
-
- if o.RemoteName == "" {
- o.RemoteName = DefaultRemoteName
- }
-
- if o.ReferenceName == "" {
- o.ReferenceName = plumbing.HEAD
- }
-
- return nil
-}
-
-// PullOptions describes how a pull should be performed.
-type PullOptions struct {
- // Name of the remote to be pulled. If empty, uses the default.
- RemoteName string
- // Remote branch to clone. If empty, uses HEAD.
- ReferenceName plumbing.ReferenceName
- // Fetch only ReferenceName if true.
- SingleBranch bool
- // Limit fetching to the specified number of commits.
- Depth int
- // Auth credentials, if required, to use with the remote repository.
- Auth transport.AuthMethod
- // RecurseSubmodules controls if new commits of all populated submodules
- // should be fetched too.
- RecurseSubmodules SubmoduleRescursivity
- // Progress is where the human readable information sent by the server is
- // stored, if nil nothing is stored and the capability (if supported)
- // no-progress, is sent to the server to avoid send this information.
- Progress sideband.Progress
-}
-
-// Validate validates the fields and sets the default values.
-func (o *PullOptions) Validate() error {
- if o.RemoteName == "" {
- o.RemoteName = DefaultRemoteName
- }
-
- if o.ReferenceName == "" {
- o.ReferenceName = plumbing.HEAD
- }
-
- return nil
-}
-
-// FetchOptions describes how a fetch should be performed
-type FetchOptions struct {
- // Name of the remote to fetch from. Defaults to origin.
- RemoteName string
- RefSpecs []config.RefSpec
- // Depth limit fetching to the specified number of commits from the tip of
- // each remote branch history.
- Depth int
- // Auth credentials, if required, to use with the remote repository.
- Auth transport.AuthMethod
- // Progress is where the human readable information sent by the server is
- // stored, if nil nothing is stored and the capability (if supported)
- // no-progress, is sent to the server to avoid send this information.
- Progress sideband.Progress
-}
-
-// Validate validates the fields and sets the default values.
-func (o *FetchOptions) Validate() error {
- if o.RemoteName == "" {
- o.RemoteName = DefaultRemoteName
- }
-
- for _, r := range o.RefSpecs {
- if err := r.Validate(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// PushOptions describes how a push should be performed.
-type PushOptions struct {
- // RemoteName is the name of the remote to be pushed to.
- RemoteName string
- // RefSpecs specify what destination ref to update with what source
- // object. A refspec with empty src can be used to delete a reference.
- RefSpecs []config.RefSpec
- // Auth credentials, if required, to use with the remote repository.
- Auth transport.AuthMethod
-}
-
-// Validate validates the fields and sets the default values.
-func (o *PushOptions) Validate() error {
- if o.RemoteName == "" {
- o.RemoteName = DefaultRemoteName
- }
-
- if len(o.RefSpecs) == 0 {
- o.RefSpecs = []config.RefSpec{
- config.RefSpec(config.DefaultPushRefSpec),
- }
- }
-
- for _, r := range o.RefSpecs {
- if err := r.Validate(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// SubmoduleUpdateOptions describes how a submodule update should be performed.
-type SubmoduleUpdateOptions struct {
- // Init, if true initializes the submodules recorded in the index.
- Init bool
- // NoFetch tell to the update command to not fetch new objects from the
- // remote site.
- NoFetch bool
- // RecurseSubmodules the update is performed not only in the submodules of
- // the current repository but also in any nested submodules inside those
- // submodules (and so on). Until the SubmoduleRescursivity is reached.
- RecurseSubmodules SubmoduleRescursivity
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/common.go
deleted file mode 100644
index 7b90c55f5b8658d0224e592c7a6c9d1c5090b1c3..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/common.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package cache
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-const (
- Byte FileSize = 1 << (iota * 10)
- KiByte
- MiByte
- GiByte
-)
-
-type FileSize int64
-
-type Object interface {
- Add(o plumbing.EncodedObject)
- Get(k plumbing.Hash) plumbing.EncodedObject
- Clear()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/object.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/object.go
deleted file mode 100644
index 44238ce11e4d297347f20e57f8e6aad9287305dc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/object.go
+++ /dev/null
@@ -1,68 +0,0 @@
-package cache
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-const (
- initialQueueSize = 20
- MaxSize = 10 * MiByte
-)
-
-type ObjectFIFO struct {
- objects map[plumbing.Hash]plumbing.EncodedObject
- order *queue
-
- maxSize FileSize
- actualSize FileSize
-}
-
-// NewObjectFIFO returns an Object cache that keeps the newest objects that fit
-// into the specific memory size
-func NewObjectFIFO(size FileSize) *ObjectFIFO {
- return &ObjectFIFO{
- objects: make(map[plumbing.Hash]plumbing.EncodedObject),
- order: newQueue(initialQueueSize),
- maxSize: size,
- }
-}
-
-// Add adds a new object to the cache. If the object size is greater than the
-// cache size, the object is not added.
-func (c *ObjectFIFO) Add(o plumbing.EncodedObject) {
- // if the size of the object is bigger or equal than the cache size,
- // skip it
- if FileSize(o.Size()) >= c.maxSize {
- return
- }
-
- // if the object is into the cache, do not add it again
- if _, ok := c.objects[o.Hash()]; ok {
- return
- }
-
- // delete the oldest object if cache is full
- if c.actualSize >= c.maxSize {
- h := c.order.Pop()
- o := c.objects[h]
- if o != nil {
- c.actualSize -= FileSize(o.Size())
- delete(c.objects, h)
- }
- }
-
- c.objects[o.Hash()] = o
- c.order.Push(o.Hash())
- c.actualSize += FileSize(o.Size())
-}
-
-// Get returns an object by his hash. If the object is not found in the cache, it
-// returns nil
-func (c *ObjectFIFO) Get(k plumbing.Hash) plumbing.EncodedObject {
- return c.objects[k]
-}
-
-// Clear the content of this object cache
-func (c *ObjectFIFO) Clear() {
- c.objects = make(map[plumbing.Hash]plumbing.EncodedObject)
- c.order = newQueue(initialQueueSize)
- c.actualSize = 0
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/queue.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/queue.go
deleted file mode 100644
index 85413e0b7a9433cc3c3aebc676ba82ed9e872a67..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/cache/queue.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package cache
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-// queue is a basic FIFO queue based on a circular list that resize as needed.
-type queue struct {
- elements []plumbing.Hash
- size int
- head int
- tail int
- count int
-}
-
-// newQueue returns a queue with the specified initial size
-func newQueue(size int) *queue {
- return &queue{
- elements: make([]plumbing.Hash, size),
- size: size,
- }
-}
-
-// Push adds a node to the queue.
-func (q *queue) Push(h plumbing.Hash) {
- if q.head == q.tail && q.count > 0 {
- elements := make([]plumbing.Hash, len(q.elements)+q.size)
- copy(elements, q.elements[q.head:])
- copy(elements[len(q.elements)-q.head:], q.elements[:q.head])
- q.head = 0
- q.tail = len(q.elements)
- q.elements = elements
- }
- q.elements[q.tail] = h
- q.tail = (q.tail + 1) % len(q.elements)
- q.count++
-}
-
-// Pop removes and returns a Hash from the queue in first to last order.
-func (q *queue) Pop() plumbing.Hash {
- if q.count == 0 {
- return plumbing.ZeroHash
- }
- node := q.elements[q.head]
- q.head = (q.head + 1) % len(q.elements)
- q.count--
- return node
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/error.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/error.go
deleted file mode 100644
index a3ebed3f6c26f5b89d0b246aac71cae0a42d7ee0..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/error.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package plumbing
-
-import "fmt"
-
-type PermanentError struct {
- Err error
-}
-
-func NewPermanentError(err error) *PermanentError {
- if err == nil {
- return nil
- }
-
- return &PermanentError{Err: err}
-}
-
-func (e *PermanentError) Error() string {
- return fmt.Sprintf("permanent client error: %s", e.Err.Error())
-}
-
-type UnexpectedError struct {
- Err error
-}
-
-func NewUnexpectedError(err error) *UnexpectedError {
- if err == nil {
- return nil
- }
-
- return &UnexpectedError{Err: err}
-}
-
-func (e *UnexpectedError) Error() string {
- return fmt.Sprintf("unexpected client error: %s", e.Err.Error())
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/filemode/filemode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/filemode/filemode.go
deleted file mode 100644
index 0994bc4d755c001f6f063eacd69f677f7781d9f3..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/filemode/filemode.go
+++ /dev/null
@@ -1,188 +0,0 @@
-package filemode
-
-import (
- "encoding/binary"
- "fmt"
- "os"
- "strconv"
-)
-
-// A FileMode represents the kind of tree entries used by git. It
-// resembles regular file systems modes, although FileModes are
-// considerably simpler (there are not so many), and there are some,
-// like Submodule that has no file system equivalent.
-type FileMode uint32
-
-const (
- // Empty is used as the FileMode of tree elements when comparing
- // trees in the following situations:
- //
- // - the mode of tree elements before their creation. - the mode of
- // tree elements after their deletion. - the mode of unmerged
- // elements when checking the index.
- //
- // Empty has no file system equivalent. As Empty is the zero value
- // of FileMode, it is also returned by New and
- // NewFromOsNewFromOSFileMode along with an error, when they fail.
- Empty FileMode = 0
- // Dir represent a Directory.
- Dir FileMode = 0040000
- // Regular represent non-executable files. Please note this is not
- // the same as golang regular files, which include executable files.
- Regular FileMode = 0100644
- // Deprecated represent non-executable files with the group writable
- // bit set. This mode was supported by the first versions of git,
- // but it has been deprecatred nowadays. This library uses them
- // internally, so you can read old packfiles, but will treat them as
- // Regulars when interfacing with the outside world. This is the
- // standard git behaviuor.
- Deprecated FileMode = 0100664
- // Executable represents executable files.
- Executable FileMode = 0100755
- // Symlink represents symbolic links to files.
- Symlink FileMode = 0120000
- // Submodule represents git submodules. This mode has no file system
- // equivalent.
- Submodule FileMode = 0160000
-)
-
-// New takes the octal string representation of a FileMode and returns
-// the FileMode and a nil error. If the string can not be parsed to a
-// 32 bit unsigned octal number, it returns Empty and the parsing error.
-//
-// Example: "40000" means Dir, "100644" means Regular.
-//
-// Please note this function does not check if the returned FileMode
-// is valid in git or if it is malformed. For instance, "1" will
-// return the malformed FileMode(1) and a nil error.
-func New(s string) (FileMode, error) {
- n, err := strconv.ParseUint(s, 8, 32)
- if err != nil {
- return Empty, err
- }
-
- return FileMode(n), nil
-}
-
-// NewFromOSFileMode returns the FileMode used by git to represent
-// the provided file system modes and a nil error on success. If the
-// file system mode cannot be mapped to any valid git mode (as with
-// sockets or named pipes), it will return Empty and an error.
-//
-// Note that some git modes cannot be generated from os.FileModes, like
-// Deprecated and Submodule; while Empty will be returned, along with an
-// error, only when the method fails.
-func NewFromOSFileMode(m os.FileMode) (FileMode, error) {
- if m.IsRegular() {
- if isSetTemporary(m) {
- return Empty, fmt.Errorf("no equivalent git mode for %s", m)
- }
- if isSetCharDevice(m) {
- return Empty, fmt.Errorf("no equivalent git mode for %s", m)
- }
- if isSetUserExecutable(m) {
- return Executable, nil
- }
- return Regular, nil
- }
-
- if m.IsDir() {
- return Dir, nil
- }
-
- if isSetSymLink(m) {
- return Symlink, nil
- }
-
- return Empty, fmt.Errorf("no equivalent git mode for %s", m)
-}
-
-func isSetCharDevice(m os.FileMode) bool {
- return m&os.ModeCharDevice != 0
-}
-
-func isSetTemporary(m os.FileMode) bool {
- return m&os.ModeTemporary != 0
-}
-
-func isSetUserExecutable(m os.FileMode) bool {
- return m&0100 != 0
-}
-
-func isSetSymLink(m os.FileMode) bool {
- return m&os.ModeSymlink != 0
-}
-
-// Bytes return a slice of 4 bytes with the mode in little endian
-// encoding.
-func (m FileMode) Bytes() []byte {
- ret := make([]byte, 4)
- binary.LittleEndian.PutUint32(ret, uint32(m))
- return ret[:]
-}
-
-// IsMalformed returns if the FileMode should not appear in a git packfile,
-// this is: Empty and any other mode not mentioned as a constant in this
-// package.
-func (m FileMode) IsMalformed() bool {
- return m != Dir &&
- m != Regular &&
- m != Deprecated &&
- m != Executable &&
- m != Symlink &&
- m != Submodule
-}
-
-// String returns the FileMode as a string in the standatd git format,
-// this is, an octal number padded with ceros to 7 digits. Malformed
-// modes are printed in that same format, for easier debugging.
-//
-// Example: Regular is "0100644", Empty is "0000000".
-func (m FileMode) String() string {
- return fmt.Sprintf("%07o", uint32(m))
-}
-
-// IsRegular returns if the FileMode represents that of a regular file,
-// this is, either Regular or Deprecated. Please note that Executable
-// are not regular even though in the UNIX tradition, they usually are:
-// See the IsFile method.
-func (m FileMode) IsRegular() bool {
- return m == Regular ||
- m == Deprecated
-}
-
-// IsFile returns if the FileMode represents that of a file, this is,
-// Regular, Deprecated, Excutable or Link.
-func (m FileMode) IsFile() bool {
- return m == Regular ||
- m == Deprecated ||
- m == Executable ||
- m == Symlink
-}
-
-// ToOSFileMode returns the os.FileMode to be used when creating file
-// system elements with the given git mode and a nil error on success.
-//
-// When the provided mode cannot be mapped to a valid file system mode
-// (e.g. Submodule) it returns os.FileMode(0) and an error.
-//
-// The returned file mode does not take into account the umask.
-func (m FileMode) ToOSFileMode() (os.FileMode, error) {
- switch m {
- case Dir:
- return os.ModePerm | os.ModeDir, nil
- case Submodule:
- return os.ModePerm | os.ModeDir, nil
- case Regular:
- return os.FileMode(0644), nil
- // Deprecated is no longer allowed: treated as a Regular instead
- case Deprecated:
- return os.FileMode(0644), nil
- case Executable:
- return os.FileMode(0755), nil
- case Symlink:
- return os.ModePerm | os.ModeSymlink, nil
- }
-
- return os.FileMode(0), fmt.Errorf("malformed mode (%s)", m)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/common.go
deleted file mode 100644
index 8f98ad1741e1cc45db8d793d3b809ba4553924ae..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/common.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package config
-
-// New creates a new config instance.
-func New() *Config {
- return &Config{}
-}
-
-// Config contains all the sections, comments and includes from a config file.
-type Config struct {
- Comment *Comment
- Sections Sections
- Includes Includes
-}
-
-// Includes is a list of Includes in a config file.
-type Includes []*Include
-
-// Include is a reference to an included config file.
-type Include struct {
- Path string
- Config *Config
-}
-
-// Comment string without the prefix '#' or ';'.
-type Comment string
-
-const (
- // NoSubsection token is passed to Config.Section and Config.SetSection to
- // represent the absence of a section.
- NoSubsection = ""
-)
-
-// Section returns a existing section with the given name or creates a new one.
-func (c *Config) Section(name string) *Section {
- for i := len(c.Sections) - 1; i >= 0; i-- {
- s := c.Sections[i]
- if s.IsName(name) {
- return s
- }
- }
-
- s := &Section{Name: name}
- c.Sections = append(c.Sections, s)
- return s
-}
-
-// AddOption adds an option to a given section and subsection. Use the
-// NoSubsection constant for the subsection argument if no subsection is wanted.
-func (c *Config) AddOption(section string, subsection string, key string, value string) *Config {
- if subsection == "" {
- c.Section(section).AddOption(key, value)
- } else {
- c.Section(section).Subsection(subsection).AddOption(key, value)
- }
-
- return c
-}
-
-// SetOption sets an option to a given section and subsection. Use the
-// NoSubsection constant for the subsection argument if no subsection is wanted.
-func (c *Config) SetOption(section string, subsection string, key string, value string) *Config {
- if subsection == "" {
- c.Section(section).SetOption(key, value)
- } else {
- c.Section(section).Subsection(subsection).SetOption(key, value)
- }
-
- return c
-}
-
-// RemoveSection removes a section from a config file.
-func (c *Config) RemoveSection(name string) *Config {
- result := Sections{}
- for _, s := range c.Sections {
- if !s.IsName(name) {
- result = append(result, s)
- }
- }
-
- c.Sections = result
- return c
-}
-
-// RemoveSubsection remove s a subsection from a config file.
-func (c *Config) RemoveSubsection(section string, subsection string) *Config {
- for _, s := range c.Sections {
- if s.IsName(section) {
- result := Subsections{}
- for _, ss := range s.Subsections {
- if !ss.IsName(subsection) {
- result = append(result, ss)
- }
- }
- s.Subsections = result
- }
- }
-
- return c
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/decoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/decoder.go
deleted file mode 100644
index 0f02ce19307bc36e9f3891af016250272a623898..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/decoder.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package config
-
-import (
- "io"
-
- "github.com/src-d/gcfg"
-)
-
-// A Decoder reads and decodes config files from an input stream.
-type Decoder struct {
- io.Reader
-}
-
-// NewDecoder returns a new decoder that reads from r.
-func NewDecoder(r io.Reader) *Decoder {
- return &Decoder{r}
-}
-
-// Decode reads the whole config from its input and stores it in the
-// value pointed to by config.
-func (d *Decoder) Decode(config *Config) error {
- cb := func(s string, ss string, k string, v string, bv bool) error {
- if ss == "" && k == "" {
- config.Section(s)
- return nil
- }
-
- if ss != "" && k == "" {
- config.Section(s).Subsection(ss)
- return nil
- }
-
- config.AddOption(s, ss, k, v)
- return nil
- }
- return gcfg.ReadWithCallback(d, cb)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/doc.go
deleted file mode 100644
index 3986c8365816949c06bc43a0b1233fc684ac7fd9..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/doc.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Package config implements encoding and decoding of git config files.
-//
-// Configuration File
-// ------------------
-//
-// The Git configuration file contains a number of variables that affect
-// the Git commands' behavior. The `.git/config` file in each repository
-// is used to store the configuration for that repository, and
-// `$HOME/.gitconfig` is used to store a per-user configuration as
-// fallback values for the `.git/config` file. The file `/etc/gitconfig`
-// can be used to store a system-wide default configuration.
-//
-// The configuration variables are used by both the Git plumbing
-// and the porcelains. The variables are divided into sections, wherein
-// the fully qualified variable name of the variable itself is the last
-// dot-separated segment and the section name is everything before the last
-// dot. The variable names are case-insensitive, allow only alphanumeric
-// characters and `-`, and must start with an alphabetic character. Some
-// variables may appear multiple times; we say then that the variable is
-// multivalued.
-//
-// Syntax
-// ~~~~~~
-//
-// The syntax is fairly flexible and permissive; whitespaces are mostly
-// ignored. The '#' and ';' characters begin comments to the end of line,
-// blank lines are ignored.
-//
-// The file consists of sections and variables. A section begins with
-// the name of the section in square brackets and continues until the next
-// section begins. Section names are case-insensitive. Only alphanumeric
-// characters, `-` and `.` are allowed in section names. Each variable
-// must belong to some section, which means that there must be a section
-// header before the first setting of a variable.
-//
-// Sections can be further divided into subsections. To begin a subsection
-// put its name in double quotes, separated by space from the section name,
-// in the section header, like in the example below:
-//
-// --------
-// [section "subsection"]
-//
-// --------
-//
-// Subsection names are case sensitive and can contain any characters except
-// newline (doublequote `"` and backslash can be included by escaping them
-// as `\"` and `\\`, respectively). Section headers cannot span multiple
-// lines. Variables may belong directly to a section or to a given subsection.
-// You can have `[section]` if you have `[section "subsection"]`, but you
-// don't need to.
-//
-// There is also a deprecated `[section.subsection]` syntax. With this
-// syntax, the subsection name is converted to lower-case and is also
-// compared case sensitively. These subsection names follow the same
-// restrictions as section names.
-//
-// All the other lines (and the remainder of the line after the section
-// header) are recognized as setting variables, in the form
-// 'name = value' (or just 'name', which is a short-hand to say that
-// the variable is the boolean "true").
-// The variable names are case-insensitive, allow only alphanumeric characters
-// and `-`, and must start with an alphabetic character.
-//
-// A line that defines a value can be continued to the next line by
-// ending it with a `\`; the backquote and the end-of-line are
-// stripped. Leading whitespaces after 'name =', the remainder of the
-// line after the first comment character '#' or ';', and trailing
-// whitespaces of the line are discarded unless they are enclosed in
-// double quotes. Internal whitespaces within the value are retained
-// verbatim.
-//
-// Inside double quotes, double quote `"` and backslash `\` characters
-// must be escaped: use `\"` for `"` and `\\` for `\`.
-//
-// The following escape sequences (beside `\"` and `\\`) are recognized:
-// `\n` for newline character (NL), `\t` for horizontal tabulation (HT, TAB)
-// and `\b` for backspace (BS). Other char escape sequences (including octal
-// escape sequences) are invalid.
-//
-// Includes
-// ~~~~~~~~
-//
-// You can include one config file from another by setting the special
-// `include.path` variable to the name of the file to be included. The
-// variable takes a pathname as its value, and is subject to tilde
-// expansion.
-//
-// The included file is expanded immediately, as if its contents had been
-// found at the location of the include directive. If the value of the
-// `include.path` variable is a relative path, the path is considered to be
-// relative to the configuration file in which the include directive was
-// found. See below for examples.
-//
-//
-// Example
-// ~~~~~~~
-//
-// # Core variables
-// [core]
-// ; Don't trust file modes
-// filemode = false
-//
-// # Our diff algorithm
-// [diff]
-// external = /usr/local/bin/diff-wrapper
-// renames = true
-//
-// [branch "devel"]
-// remote = origin
-// merge = refs/heads/devel
-//
-// # Proxy settings
-// [core]
-// gitProxy="ssh" for "kernel.org"
-// gitProxy=default-proxy ; for the rest
-//
-// [include]
-// path = /path/to/foo.inc ; include by absolute path
-// path = foo ; expand "foo" relative to the current file
-// path = ~/foo ; expand "foo" in your `$HOME` directory
-//
-package config
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/encoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/encoder.go
deleted file mode 100644
index 88bdf650564e05fd80e9cc19cb091f76a070bd1a..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/encoder.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package config
-
-import (
- "fmt"
- "io"
-)
-
-// An Encoder writes config files to an output stream.
-type Encoder struct {
- w io.Writer
-}
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{w}
-}
-
-// Encode writes the config in git config format to the stream of the encoder.
-func (e *Encoder) Encode(cfg *Config) error {
- for _, s := range cfg.Sections {
- if err := e.encodeSection(s); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeSection(s *Section) error {
- if len(s.Options) > 0 {
- if err := e.printf("[%s]\n", s.Name); err != nil {
- return err
- }
-
- if err := e.encodeOptions(s.Options); err != nil {
- return err
- }
- }
-
- for _, ss := range s.Subsections {
- if err := e.encodeSubsection(s.Name, ss); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeSubsection(sectionName string, s *Subsection) error {
- //TODO: escape
- if err := e.printf("[%s \"%s\"]\n", sectionName, s.Name); err != nil {
- return err
- }
-
- if err := e.encodeOptions(s.Options); err != nil {
- return err
- }
-
- return nil
-}
-
-func (e *Encoder) encodeOptions(opts Options) error {
- for _, o := range opts {
- if err := e.printf("\t%s = %s\n", o.Key, o.Value); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) printf(msg string, args ...interface{}) error {
- _, err := fmt.Fprintf(e.w, msg, args...)
- return err
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/option.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/option.go
deleted file mode 100644
index 3c391c6eb9765c0a00b35b1f29ec567086f36688..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/option.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package config
-
-import (
- "strings"
-)
-
-// Option defines a key/value entity in a config file.
-type Option struct {
- // Key preserving original caseness.
- // Use IsKey instead to compare key regardless of caseness.
- Key string
- // Original value as string, could be not normalized.
- Value string
-}
-
-type Options []*Option
-
-// IsKey returns true if the given key matches
-// this option's key in a case-insensitive comparison.
-func (o *Option) IsKey(key string) bool {
- return strings.ToLower(o.Key) == strings.ToLower(key)
-}
-
-// Get gets the value for the given key if set,
-// otherwise it returns the empty string.
-//
-// Note that there is no difference
-//
-// This matches git behaviour since git v1.8.1-rc1,
-// if there are multiple definitions of a key, the
-// last one wins.
-//
-// See: http://article.gmane.org/gmane.linux.kernel/1407184
-//
-// In order to get all possible values for the same key,
-// use GetAll.
-func (opts Options) Get(key string) string {
- for i := len(opts) - 1; i >= 0; i-- {
- o := opts[i]
- if o.IsKey(key) {
- return o.Value
- }
- }
- return ""
-}
-
-// GetAll returns all possible values for the same key.
-func (opts Options) GetAll(key string) []string {
- result := []string{}
- for _, o := range opts {
- if o.IsKey(key) {
- result = append(result, o.Value)
- }
- }
- return result
-}
-
-func (opts Options) withoutOption(key string) Options {
- result := Options{}
- for _, o := range opts {
- if !o.IsKey(key) {
- result = append(result, o)
- }
- }
- return result
-}
-
-func (opts Options) withAddedOption(key string, value string) Options {
- return append(opts, &Option{key, value})
-}
-
-func (opts Options) withSettedOption(key string, value string) Options {
- for i := len(opts) - 1; i >= 0; i-- {
- o := opts[i]
- if o.IsKey(key) {
- result := make(Options, len(opts))
- copy(result, opts)
- result[i] = &Option{key, value}
- return result
- }
- }
-
- return opts.withAddedOption(key, value)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/section.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/section.go
deleted file mode 100644
index 547da1eb538f4cf1526401689bcf8ae67e076fcc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/config/section.go
+++ /dev/null
@@ -1,125 +0,0 @@
-package config
-
-import "strings"
-
-// Section is the representation of a section inside git configuration files.
-// Each Section contains Options that are used by both the Git plumbing
-// and the porcelains.
-// Sections can be further divided into subsections. To begin a subsection
-// put its name in double quotes, separated by space from the section name,
-// in the section header, like in the example below:
-//
-// [section "subsection"]
-//
-// All the other lines (and the remainder of the line after the section header)
-// are recognized as option variables, in the form "name = value" (or just name,
-// which is a short-hand to say that the variable is the boolean "true").
-// The variable names are case-insensitive, allow only alphanumeric characters
-// and -, and must start with an alphabetic character:
-//
-// [section "subsection1"]
-// option1 = value1
-// option2
-// [section "subsection2"]
-// option3 = value2
-//
-type Section struct {
- Name string
- Options Options
- Subsections Subsections
-}
-
-type Subsection struct {
- Name string
- Options Options
-}
-
-type Sections []*Section
-
-type Subsections []*Subsection
-
-// IsName checks if the name provided is equals to the Section name, case insensitive.
-func (s *Section) IsName(name string) bool {
- return strings.ToLower(s.Name) == strings.ToLower(name)
-}
-
-// Option return the value for the specified key. Empty string is returned if
-// key does not exists.
-func (s *Section) Option(key string) string {
- return s.Options.Get(key)
-}
-
-// AddOption adds a new Option to the Section. The updated Section is returned.
-func (s *Section) AddOption(key string, value string) *Section {
- s.Options = s.Options.withAddedOption(key, value)
- return s
-}
-
-// SetOption adds a new Option to the Section. If the option already exists, is replaced.
-// The updated Section is returned.
-func (s *Section) SetOption(key string, value string) *Section {
- s.Options = s.Options.withSettedOption(key, value)
- return s
-}
-
-// Remove an option with the specified key. The updated Section is returned.
-func (s *Section) RemoveOption(key string) *Section {
- s.Options = s.Options.withoutOption(key)
- return s
-}
-
-// Subsection returns a Subsection from the specified Section. If the
-// Subsection does not exists, new one is created and added to Section.
-func (s *Section) Subsection(name string) *Subsection {
- for i := len(s.Subsections) - 1; i >= 0; i-- {
- ss := s.Subsections[i]
- if ss.IsName(name) {
- return ss
- }
- }
-
- ss := &Subsection{Name: name}
- s.Subsections = append(s.Subsections, ss)
- return ss
-}
-
-// HasSubsection checks if the Section has a Subsection with the specified name.
-func (s *Section) HasSubsection(name string) bool {
- for _, ss := range s.Subsections {
- if ss.IsName(name) {
- return true
- }
- }
-
- return false
-}
-
-// IsName checks if the name of the subsection is exactly the specified name.
-func (s *Subsection) IsName(name string) bool {
- return s.Name == name
-}
-
-// Option returns an option with the specified key. If the option does not exists,
-// empty spring will be returned.
-func (s *Subsection) Option(key string) string {
- return s.Options.Get(key)
-}
-
-// AddOption adds a new Option to the Subsection. The updated Subsection is returned.
-func (s *Subsection) AddOption(key string, value string) *Subsection {
- s.Options = s.Options.withAddedOption(key, value)
- return s
-}
-
-// SetOption adds a new Option to the Subsection. If the option already exists, is replaced.
-// The updated Subsection is returned.
-func (s *Subsection) SetOption(key string, value string) *Subsection {
- s.Options = s.Options.withSettedOption(key, value)
- return s
-}
-
-// RemoveOption removes the option with the specified key. The updated Subsection is returned.
-func (s *Subsection) RemoveOption(key string) *Subsection {
- s.Options = s.Options.withoutOption(key)
- return s
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/decoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/decoder.go
deleted file mode 100644
index 66184757f71d09030673fc3a7a54346be181881b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/decoder.go
+++ /dev/null
@@ -1,147 +0,0 @@
-package idxfile
-
-import (
- "bytes"
- "errors"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-var (
- // ErrUnsupportedVersion is returned by Decode when the idx file version
- // is not supported.
- ErrUnsupportedVersion = errors.New("Unsuported version")
- // ErrMalformedIdxFile is returned by Decode when the idx file is corrupted.
- ErrMalformedIdxFile = errors.New("Malformed IDX file")
-)
-
-// Decoder reads and decodes idx files from an input stream.
-type Decoder struct {
- io.Reader
-}
-
-// NewDecoder builds a new idx stream decoder, that reads from r.
-func NewDecoder(r io.Reader) *Decoder {
- return &Decoder{r}
-}
-
-// Decode reads from the stream and decode the content into the Idxfile struct.
-func (d *Decoder) Decode(idx *Idxfile) error {
- if err := validateHeader(d); err != nil {
- return err
- }
-
- flow := []func(*Idxfile, io.Reader) error{
- readVersion,
- readFanout,
- readObjectNames,
- readCRC32,
- readOffsets,
- readChecksums,
- }
-
- for _, f := range flow {
- if err := f(idx, d); err != nil {
- return err
- }
- }
-
- if !idx.isValid() {
- return ErrMalformedIdxFile
- }
-
- return nil
-}
-
-func validateHeader(r io.Reader) error {
- var h = make([]byte, 4)
- if _, err := io.ReadFull(r, h); err != nil {
- return err
- }
-
- if !bytes.Equal(h, idxHeader) {
- return ErrMalformedIdxFile
- }
-
- return nil
-}
-
-func readVersion(idx *Idxfile, r io.Reader) error {
- v, err := binary.ReadUint32(r)
- if err != nil {
- return err
- }
-
- if v > VersionSupported {
- return ErrUnsupportedVersion
- }
-
- idx.Version = v
- return nil
-}
-
-func readFanout(idx *Idxfile, r io.Reader) error {
- var err error
- for i := 0; i < 255; i++ {
- idx.Fanout[i], err = binary.ReadUint32(r)
- if err != nil {
- return err
- }
- }
-
- idx.ObjectCount, err = binary.ReadUint32(r)
- return err
-}
-
-func readObjectNames(idx *Idxfile, r io.Reader) error {
- c := int(idx.ObjectCount)
- for i := 0; i < c; i++ {
- var ref plumbing.Hash
- if _, err := io.ReadFull(r, ref[:]); err != nil {
- return err
- }
-
- idx.Entries = append(idx.Entries, Entry{Hash: ref})
- }
-
- return nil
-}
-
-func readCRC32(idx *Idxfile, r io.Reader) error {
- c := int(idx.ObjectCount)
- for i := 0; i < c; i++ {
- if err := binary.Read(r, &idx.Entries[i].CRC32); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func readOffsets(idx *Idxfile, r io.Reader) error {
- c := int(idx.ObjectCount)
- for i := 0; i < c; i++ {
- o, err := binary.ReadUint32(r)
- if err != nil {
- return err
- }
-
- idx.Entries[i].Offset = uint64(o)
- }
-
- return nil
-}
-
-func readChecksums(idx *Idxfile, r io.Reader) error {
- if _, err := io.ReadFull(r, idx.PackfileChecksum[:]); err != nil {
- return err
- }
-
- if _, err := io.ReadFull(r, idx.IdxChecksum[:]); err != nil {
- return err
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/doc.go
deleted file mode 100644
index 1e628ab4a5e600fd9a790ac10052bedf8f21f865..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/doc.go
+++ /dev/null
@@ -1,128 +0,0 @@
-// Package idxfile implements encoding and decoding of packfile idx files.
-//
-// == Original (version 1) pack-*.idx files have the following format:
-//
-// - The header consists of 256 4-byte network byte order
-// integers. N-th entry of this table records the number of
-// objects in the corresponding pack, the first byte of whose
-// object name is less than or equal to N. This is called the
-// 'first-level fan-out' table.
-//
-// - The header is followed by sorted 24-byte entries, one entry
-// per object in the pack. Each entry is:
-//
-// 4-byte network byte order integer, recording where the
-// object is stored in the packfile as the offset from the
-// beginning.
-//
-// 20-byte object name.
-//
-// - The file is concluded with a trailer:
-//
-// A copy of the 20-byte SHA1 checksum at the end of
-// corresponding packfile.
-//
-// 20-byte SHA1-checksum of all of the above.
-//
-// Pack Idx file:
-//
-// -- +--------------------------------+
-// fanout | fanout[0] = 2 (for example) |-.
-// table +--------------------------------+ |
-// | fanout[1] | |
-// +--------------------------------+ |
-// | fanout[2] | |
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
-// | fanout[255] = total objects |---.
-// -- +--------------------------------+ | |
-// main | offset | | |
-// index | object name 00XXXXXXXXXXXXXXXX | | |
-// tab +--------------------------------+ | |
-// | offset | | |
-// | object name 00XXXXXXXXXXXXXXXX | | |
-// +--------------------------------+<+ |
-// .-| offset | |
-// | | object name 01XXXXXXXXXXXXXXXX | |
-// | +--------------------------------+ |
-// | | offset | |
-// | | object name 01XXXXXXXXXXXXXXXX | |
-// | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
-// | | offset | |
-// | | object name FFXXXXXXXXXXXXXXXX | |
-// --| +--------------------------------+<--+
-// trailer | | packfile checksum |
-// | +--------------------------------+
-// | | idxfile checksum |
-// | +--------------------------------+
-// .---------.
-// |
-// Pack file entry: <+
-//
-// packed object header:
-// 1-byte size extension bit (MSB)
-// type (next 3 bit)
-// size0 (lower 4-bit)
-// n-byte sizeN (as long as MSB is set, each 7-bit)
-// size0..sizeN form 4+7+7+..+7 bit integer, size0
-// is the least significant part, and sizeN is the
-// most significant part.
-// packed object data:
-// If it is not DELTA, then deflated bytes (the size above
-// is the size before compression).
-// If it is REF_DELTA, then
-// 20-byte base object name SHA1 (the size above is the
-// size of the delta data that follows).
-// delta data, deflated.
-// If it is OFS_DELTA, then
-// n-byte offset (see below) interpreted as a negative
-// offset from the type-byte of the header of the
-// ofs-delta entry (the size above is the size of
-// the delta data that follows).
-// delta data, deflated.
-//
-// offset encoding:
-// n bytes with MSB set in all but the last one.
-// The offset is then the number constructed by
-// concatenating the lower 7 bit of each byte, and
-// for n >= 2 adding 2^7 + 2^14 + ... + 2^(7*(n-1))
-// to the result.
-//
-// == Version 2 pack-*.idx files support packs larger than 4 GiB, and
-// have some other reorganizations. They have the format:
-//
-// - A 4-byte magic number '\377tOc' which is an unreasonable
-// fanout[0] value.
-//
-// - A 4-byte version number (= 2)
-//
-// - A 256-entry fan-out table just like v1.
-//
-// - A table of sorted 20-byte SHA1 object names. These are
-// packed together without offset values to reduce the cache
-// footprint of the binary search for a specific object name.
-//
-// - A table of 4-byte CRC32 values of the packed object data.
-// This is new in v2 so compressed data can be copied directly
-// from pack to pack during repacking without undetected
-// data corruption.
-//
-// - A table of 4-byte offset values (in network byte order).
-// These are usually 31-bit pack file offsets, but large
-// offsets are encoded as an index into the next table with
-// the msbit set.
-//
-// - A table of 8-byte offset entries (empty for pack files less
-// than 2 GiB). Pack files are organized with heavily used
-// objects toward the front, so most object references should
-// not need to refer to this table.
-//
-// - The same trailer as a v1 pack file:
-//
-// A copy of the 20-byte SHA1 checksum at the end of
-// corresponding packfile.
-//
-// 20-byte SHA1-checksum of all of the above.
-//
-// Source:
-// https://www.kernel.org/pub/software/scm/git/docs/v1.7.5/technical/pack-format.txt
-package idxfile
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/encoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/encoder.go
deleted file mode 100644
index 71e1b3fdbfa3326a975873e5744962c31a0dc57f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/encoder.go
+++ /dev/null
@@ -1,132 +0,0 @@
-package idxfile
-
-import (
- "crypto/sha1"
- "hash"
- "io"
- "sort"
-
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-// Encoder writes Idxfile structs to an output stream.
-type Encoder struct {
- io.Writer
- hash hash.Hash
-}
-
-// NewEncoder returns a new stream encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- h := sha1.New()
- mw := io.MultiWriter(w, h)
- return &Encoder{mw, h}
-}
-
-// Encode encodes an Idxfile to the encoder writer.
-func (e *Encoder) Encode(idx *Idxfile) (int, error) {
- idx.Entries.Sort()
-
- flow := []func(*Idxfile) (int, error){
- e.encodeHeader,
- e.encodeFanout,
- e.encodeHashes,
- e.encodeCRC32,
- e.encodeOffsets,
- e.encodeChecksums,
- }
-
- sz := 0
- for _, f := range flow {
- i, err := f(idx)
- sz += i
-
- if err != nil {
- return sz, err
- }
- }
-
- return sz, nil
-}
-
-func (e *Encoder) encodeHeader(idx *Idxfile) (int, error) {
- c, err := e.Write(idxHeader)
- if err != nil {
- return c, err
- }
-
- return c + 4, binary.WriteUint32(e, idx.Version)
-}
-
-func (e *Encoder) encodeFanout(idx *Idxfile) (int, error) {
- fanout := idx.calculateFanout()
- for _, c := range fanout {
- if err := binary.WriteUint32(e, c); err != nil {
- return 0, err
- }
- }
-
- return 1024, nil
-}
-
-func (e *Encoder) encodeHashes(idx *Idxfile) (int, error) {
- sz := 0
- for _, ent := range idx.Entries {
- i, err := e.Write(ent.Hash[:])
- sz += i
-
- if err != nil {
- return sz, err
- }
- }
-
- return sz, nil
-}
-
-func (e *Encoder) encodeCRC32(idx *Idxfile) (int, error) {
- sz := 0
- for _, ent := range idx.Entries {
- err := binary.Write(e, ent.CRC32)
- sz += 4
-
- if err != nil {
- return sz, err
- }
- }
-
- return sz, nil
-}
-
-func (e *Encoder) encodeOffsets(idx *Idxfile) (int, error) {
- sz := 0
- for _, ent := range idx.Entries {
- if err := binary.WriteUint32(e, uint32(ent.Offset)); err != nil {
- return sz, err
- }
-
- sz += 4
-
- }
-
- return sz, nil
-}
-
-func (e *Encoder) encodeChecksums(idx *Idxfile) (int, error) {
- if _, err := e.Write(idx.PackfileChecksum[:]); err != nil {
- return 0, err
- }
-
- copy(idx.IdxChecksum[:], e.hash.Sum(nil)[:20])
- if _, err := e.Write(idx.IdxChecksum[:]); err != nil {
- return 0, err
- }
-
- return 40, nil
-}
-
-// EntryList implements sort.Interface allowing sorting in increasing order.
-type EntryList []Entry
-
-func (p EntryList) Len() int { return len(p) }
-func (p EntryList) Less(i, j int) bool { return p[i].Hash.String() < p[j].Hash.String() }
-func (p EntryList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-func (p EntryList) Sort() { sort.Sort(p) }
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/idxfile.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/idxfile.go
deleted file mode 100644
index 5a718f3f8f5ff014e12e77d4c8ed3b555b888554..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/idxfile/idxfile.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package idxfile
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-const (
- // VersionSupported is the only idx version supported.
- VersionSupported = 2
-)
-
-var (
- idxHeader = []byte{255, 't', 'O', 'c'}
-)
-
-// Idxfile is the in memory representation of an idx file.
-type Idxfile struct {
- Version uint32
- Fanout [255]uint32
- ObjectCount uint32
- Entries EntryList
- PackfileChecksum [20]byte
- IdxChecksum [20]byte
-}
-
-// Entry is the in memory representation of an object entry in the idx file.
-type Entry struct {
- Hash plumbing.Hash
- CRC32 uint32
- Offset uint64
-}
-
-// Add adds a new Entry with the given values to the Idxfile.
-func (idx *Idxfile) Add(h plumbing.Hash, offset uint64, crc32 uint32) {
- idx.Entries = append(idx.Entries, Entry{
- Hash: h,
- Offset: offset,
- CRC32: crc32,
- })
-}
-
-func (idx *Idxfile) isValid() bool {
- fanout := idx.calculateFanout()
- for k, c := range idx.Fanout {
- if fanout[k] != c {
- return false
- }
- }
-
- return true
-}
-
-func (idx *Idxfile) calculateFanout() [256]uint32 {
- fanout := [256]uint32{}
- for _, e := range idx.Entries {
- fanout[e.Hash[0]]++
- }
-
- for i := 1; i < 256; i++ {
- fanout[i] += fanout[i-1]
- }
-
- return fanout
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/decoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/decoder.go
deleted file mode 100644
index 4bc5af125ead80150828080f0b653569b4a6a222..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/decoder.go
+++ /dev/null
@@ -1,454 +0,0 @@
-package index
-
-import (
- "bytes"
- "crypto/sha1"
- "errors"
- "hash"
- "io"
- "io/ioutil"
- "strconv"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-var (
- // DecodeVersionSupported is the range of supported index versions
- DecodeVersionSupported = struct{ Min, Max uint32 }{Min: 2, Max: 4}
-
- // ErrMalformedSignature is returned by Decode when the index header file is
- // malformed
- ErrMalformedSignature = errors.New("malformed index signature file")
- // ErrInvalidChecksum is returned by Decode if the SHA1 hash missmatch with
- // the read content
- ErrInvalidChecksum = errors.New("invalid checksum")
-
- errUnknownExtension = errors.New("unknown extension")
-)
-
-const (
- entryHeaderLength = 62
- entryExtended = 0x4000
- entryValid = 0x8000
- nameMask = 0xfff
- intentToAddMask = 1 << 13
- skipWorkTreeMask = 1 << 14
-)
-
-// A Decoder reads and decodes index files from an input stream.
-type Decoder struct {
- r io.Reader
- hash hash.Hash
- lastEntry *Entry
-}
-
-// NewDecoder returns a new decoder that reads from r.
-func NewDecoder(r io.Reader) *Decoder {
- h := sha1.New()
- return &Decoder{
- r: io.TeeReader(r, h),
- hash: h,
- }
-}
-
-// Decode reads the whole index object from its input and stores it in the
-// value pointed to by idx.
-func (d *Decoder) Decode(idx *Index) error {
- var err error
- idx.Version, err = validateHeader(d.r)
- if err != nil {
- return err
- }
-
- entryCount, err := binary.ReadUint32(d.r)
- if err != nil {
- return err
- }
-
- if err := d.readEntries(idx, int(entryCount)); err != nil {
- return err
- }
-
- return d.readExtensions(idx)
-}
-
-func (d *Decoder) readEntries(idx *Index, count int) error {
- for i := 0; i < count; i++ {
- e, err := d.readEntry(idx)
- if err != nil {
- return err
- }
-
- d.lastEntry = e
- idx.Entries = append(idx.Entries, *e)
- }
-
- return nil
-}
-
-func (d *Decoder) readEntry(idx *Index) (*Entry, error) {
- e := &Entry{}
-
- var msec, mnsec, sec, nsec uint32
- var flags uint16
-
- flow := []interface{}{
- &sec, &nsec,
- &msec, &mnsec,
- &e.Dev,
- &e.Inode,
- &e.Mode,
- &e.UID,
- &e.GID,
- &e.Size,
- &e.Hash,
- &flags,
- }
-
- if err := binary.Read(d.r, flow...); err != nil {
- return nil, err
- }
-
- read := entryHeaderLength
-
- if sec != 0 || nsec != 0 {
- e.CreatedAt = time.Unix(int64(sec), int64(nsec))
- }
-
- if msec != 0 || mnsec != 0 {
- e.ModifiedAt = time.Unix(int64(msec), int64(mnsec))
- }
-
- e.Stage = Stage(flags>>12) & 0x3
-
- if flags&entryExtended != 0 {
- extended, err := binary.ReadUint16(d.r)
- if err != nil {
- return nil, err
- }
-
- read += 2
- e.IntentToAdd = extended&intentToAddMask != 0
- e.SkipWorktree = extended&skipWorkTreeMask != 0
- }
-
- if err := d.readEntryName(idx, e, flags); err != nil {
- return nil, err
- }
-
- return e, d.padEntry(idx, e, read)
-}
-
-func (d *Decoder) readEntryName(idx *Index, e *Entry, flags uint16) error {
- var name string
- var err error
-
- switch idx.Version {
- case 2, 3:
- len := flags & nameMask
- name, err = d.doReadEntryName(len)
- case 4:
- name, err = d.doReadEntryNameV4()
- default:
- return ErrUnsupportedVersion
- }
-
- if err != nil {
- return err
- }
-
- e.Name = name
- return nil
-}
-
-func (d *Decoder) doReadEntryNameV4() (string, error) {
- l, err := binary.ReadVariableWidthInt(d.r)
- if err != nil {
- return "", err
- }
-
- var base string
- if d.lastEntry != nil {
- base = d.lastEntry.Name[:len(d.lastEntry.Name)-int(l)]
- }
-
- name, err := binary.ReadUntil(d.r, '\x00')
- if err != nil {
- return "", err
- }
-
- return base + string(name), nil
-}
-
-func (d *Decoder) doReadEntryName(len uint16) (string, error) {
- name := make([]byte, len)
- if err := binary.Read(d.r, &name); err != nil {
- return "", err
- }
-
- return string(name), nil
-}
-
-// Index entries are padded out to the next 8 byte alignment
-// for historical reasons related to how C Git read the files.
-func (d *Decoder) padEntry(idx *Index, e *Entry, read int) error {
- if idx.Version == 4 {
- return nil
- }
-
- entrySize := read + len(e.Name)
- padLen := 8 - entrySize%8
- if _, err := io.CopyN(ioutil.Discard, d.r, int64(padLen)); err != nil {
- return err
- }
-
- return nil
-}
-
-func (d *Decoder) readExtensions(idx *Index) error {
- // TODO: support 'Split index' and 'Untracked cache' extensions, take in
- // count that they are not supported by jgit or libgit
-
- var expected []byte
- var err error
-
- var header [4]byte
- for {
- expected = d.hash.Sum(nil)
-
- var n int
- if n, err = io.ReadFull(d.r, header[:]); err != nil {
- if n == 0 {
- err = io.EOF
- }
-
- break
- }
-
- err = d.readExtension(idx, header[:])
- if err != nil {
- break
- }
- }
-
- if err != errUnknownExtension {
- return err
- }
-
- return d.readChecksum(expected, header)
-}
-
-func (d *Decoder) readExtension(idx *Index, header []byte) error {
- switch {
- case bytes.Equal(header, treeExtSignature):
- r, err := d.getExtensionReader()
- if err != nil {
- return err
- }
-
- idx.Cache = &Tree{}
- d := &treeExtensionDecoder{r}
- if err := d.Decode(idx.Cache); err != nil {
- return err
- }
- case bytes.Equal(header, resolveUndoExtSignature):
- r, err := d.getExtensionReader()
- if err != nil {
- return err
- }
-
- idx.ResolveUndo = &ResolveUndo{}
- d := &resolveUndoDecoder{r}
- if err := d.Decode(idx.ResolveUndo); err != nil {
- return err
- }
- default:
- return errUnknownExtension
- }
-
- return nil
-}
-
-func (d *Decoder) getExtensionReader() (io.Reader, error) {
- len, err := binary.ReadUint32(d.r)
- if err != nil {
- return nil, err
- }
-
- return &io.LimitedReader{R: d.r, N: int64(len)}, nil
-}
-
-func (d *Decoder) readChecksum(expected []byte, alreadyRead [4]byte) error {
- var h plumbing.Hash
- copy(h[:4], alreadyRead[:])
-
- if err := binary.Read(d.r, h[4:]); err != nil {
- return err
- }
-
- if bytes.Compare(h[:], expected) != 0 {
- return ErrInvalidChecksum
- }
-
- return nil
-}
-
-func validateHeader(r io.Reader) (version uint32, err error) {
- var s = make([]byte, 4)
- if _, err := io.ReadFull(r, s); err != nil {
- return 0, err
- }
-
- if !bytes.Equal(s, indexSignature) {
- return 0, ErrMalformedSignature
- }
-
- version, err = binary.ReadUint32(r)
- if err != nil {
- return 0, err
- }
-
- if version < DecodeVersionSupported.Min || version > DecodeVersionSupported.Max {
- return 0, ErrUnsupportedVersion
- }
-
- return
-}
-
-type treeExtensionDecoder struct {
- r io.Reader
-}
-
-func (d *treeExtensionDecoder) Decode(t *Tree) error {
- for {
- e, err := d.readEntry()
- if err != nil {
- if err == io.EOF {
- return nil
- }
-
- return err
- }
-
- if e == nil {
- continue
- }
-
- t.Entries = append(t.Entries, *e)
- }
-}
-
-func (d *treeExtensionDecoder) readEntry() (*TreeEntry, error) {
- e := &TreeEntry{}
-
- path, err := binary.ReadUntil(d.r, '\x00')
- if err != nil {
- return nil, err
- }
-
- e.Path = string(path)
-
- count, err := binary.ReadUntil(d.r, ' ')
- if err != nil {
- return nil, err
- }
-
- i, err := strconv.Atoi(string(count))
- if err != nil {
- return nil, err
- }
-
- // An entry can be in an invalidated state and is represented by having a
- // negative number in the entry_count field.
- if i == -1 {
- return nil, nil
- }
-
- e.Entries = i
- trees, err := binary.ReadUntil(d.r, '\n')
- if err != nil {
- return nil, err
- }
-
- i, err = strconv.Atoi(string(trees))
- if err != nil {
- return nil, err
- }
-
- e.Trees = i
-
- if err := binary.Read(d.r, &e.Hash); err != nil {
- return nil, err
- }
-
- return e, nil
-}
-
-type resolveUndoDecoder struct {
- r io.Reader
-}
-
-func (d *resolveUndoDecoder) Decode(ru *ResolveUndo) error {
- for {
- e, err := d.readEntry()
- if err != nil {
- if err == io.EOF {
- return nil
- }
-
- return err
- }
-
- ru.Entries = append(ru.Entries, *e)
- }
-}
-
-func (d *resolveUndoDecoder) readEntry() (*ResolveUndoEntry, error) {
- e := &ResolveUndoEntry{
- Stages: make(map[Stage]plumbing.Hash, 0),
- }
-
- path, err := binary.ReadUntil(d.r, '\x00')
- if err != nil {
- return nil, err
- }
-
- e.Path = string(path)
-
- for i := 0; i < 3; i++ {
- if err := d.readStage(e, Stage(i+1)); err != nil {
- return nil, err
- }
- }
-
- for s := range e.Stages {
- var hash plumbing.Hash
- if err := binary.Read(d.r, hash[:]); err != nil {
- return nil, err
- }
-
- e.Stages[s] = hash
- }
-
- return e, nil
-}
-
-func (d *resolveUndoDecoder) readStage(e *ResolveUndoEntry, s Stage) error {
- ascii, err := binary.ReadUntil(d.r, '\x00')
- if err != nil {
- return err
- }
-
- stage, err := strconv.ParseInt(string(ascii), 8, 64)
- if err != nil {
- return err
- }
-
- if stage != 0 {
- e.Stages[s] = plumbing.ZeroHash
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/doc.go
deleted file mode 100644
index d1e7b335bbe50a09be2aeb5a1edd5e7beba30177..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/doc.go
+++ /dev/null
@@ -1,301 +0,0 @@
-// Package index implements encoding and decoding of index format files.
-//
-// Git index format
-// ================
-//
-// == The Git index file has the following format
-//
-// All binary numbers are in network byte order. Version 2 is described
-// here unless stated otherwise.
-//
-// - A 12-byte header consisting of
-//
-// 4-byte signature:
-// The signature is { 'D', 'I', 'R', 'C' } (stands for "dircache")
-//
-// 4-byte version number:
-// The current supported versions are 2, 3 and 4.
-//
-// 32-bit number of index entries.
-//
-// - A number of sorted index entries (see below).
-//
-// - Extensions
-//
-// Extensions are identified by signature. Optional extensions can
-// be ignored if Git does not understand them.
-//
-// Git currently supports cached tree and resolve undo extensions.
-//
-// 4-byte extension signature. If the first byte is 'A'..'Z' the
-// extension is optional and can be ignored.
-//
-// 32-bit size of the extension
-//
-// Extension data
-//
-// - 160-bit SHA-1 over the content of the index file before this
-// checksum.
-//
-// == Index entry
-//
-// Index entries are sorted in ascending order on the name field,
-// interpreted as a string of unsigned bytes (i.e. memcmp() order, no
-// localization, no special casing of directory separator '/'). Entries
-// with the same name are sorted by their stage field.
-//
-// 32-bit ctime seconds, the last time a file's metadata changed
-// this is stat(2) data
-//
-// 32-bit ctime nanosecond fractions
-// this is stat(2) data
-//
-// 32-bit mtime seconds, the last time a file's data changed
-// this is stat(2) data
-//
-// 32-bit mtime nanosecond fractions
-// this is stat(2) data
-//
-// 32-bit dev
-// this is stat(2) data
-//
-// 32-bit ino
-// this is stat(2) data
-//
-// 32-bit mode, split into (high to low bits)
-//
-// 4-bit object type
-// valid values in binary are 1000 (regular file), 1010 (symbolic link)
-// and 1110 (gitlink)
-//
-// 3-bit unused
-//
-// 9-bit unix permission. Only 0755 and 0644 are valid for regular files.
-// Symbolic links and gitlinks have value 0 in this field.
-//
-// 32-bit uid
-// this is stat(2) data
-//
-// 32-bit gid
-// this is stat(2) data
-//
-// 32-bit file size
-// This is the on-disk size from stat(2), truncated to 32-bit.
-//
-// 160-bit SHA-1 for the represented object
-//
-// A 16-bit 'flags' field split into (high to low bits)
-//
-// 1-bit assume-valid flag
-//
-// 1-bit extended flag (must be zero in version 2)
-//
-// 2-bit stage (during merge)
-//
-// 12-bit name length if the length is less than 0xFFF; otherwise 0xFFF
-// is stored in this field.
-//
-// (Version 3 or later) A 16-bit field, only applicable if the
-// "extended flag" above is 1, split into (high to low bits).
-//
-// 1-bit reserved for future
-//
-// 1-bit skip-worktree flag (used by sparse checkout)
-//
-// 1-bit intent-to-add flag (used by "git add -N")
-//
-// 13-bit unused, must be zero
-//
-// Entry path name (variable length) relative to top level directory
-// (without leading slash). '/' is used as path separator. The special
-// path components ".", ".." and ".git" (without quotes) are disallowed.
-// Trailing slash is also disallowed.
-//
-// The exact encoding is undefined, but the '.' and '/' characters
-// are encoded in 7-bit ASCII and the encoding cannot contain a NUL
-// byte (iow, this is a UNIX pathname).
-//
-// (Version 4) In version 4, the entry path name is prefix-compressed
-// relative to the path name for the previous entry (the very first
-// entry is encoded as if the path name for the previous entry is an
-// empty string). At the beginning of an entry, an integer N in the
-// variable width encoding (the same encoding as the offset is encoded
-// for OFS_DELTA pack entries; see pack-format.txt) is stored, followed
-// by a NUL-terminated string S. Removing N bytes from the end of the
-// path name for the previous entry, and replacing it with the string S
-// yields the path name for this entry.
-//
-// 1-8 nul bytes as necessary to pad the entry to a multiple of eight bytes
-// while keeping the name NUL-terminated.
-//
-// (Version 4) In version 4, the padding after the pathname does not
-// exist.
-//
-// Interpretation of index entries in split index mode is completely
-// different. See below for details.
-//
-// == Extensions
-//
-// === Cached tree
-//
-// Cached tree extension contains pre-computed hashes for trees that can
-// be derived from the index. It helps speed up tree object generation
-// from index for a new commit.
-//
-// When a path is updated in index, the path must be invalidated and
-// removed from tree cache.
-//
-// The signature for this extension is { 'T', 'R', 'E', 'E' }.
-//
-// A series of entries fill the entire extension; each of which
-// consists of:
-//
-// - NUL-terminated path component (relative to its parent directory);
-//
-// - ASCII decimal number of entries in the index that is covered by the
-// tree this entry represents (entry_count);
-//
-// - A space (ASCII 32);
-//
-// - ASCII decimal number that represents the number of subtrees this
-// tree has;
-//
-// - A newline (ASCII 10); and
-//
-// - 160-bit object name for the object that would result from writing
-// this span of index as a tree.
-//
-// An entry can be in an invalidated state and is represented by having
-// a negative number in the entry_count field. In this case, there is no
-// object name and the next entry starts immediately after the newline.
-// When writing an invalid entry, -1 should always be used as entry_count.
-//
-// The entries are written out in the top-down, depth-first order. The
-// first entry represents the root level of the repository, followed by the
-// first subtree--let's call this A--of the root level (with its name
-// relative to the root level), followed by the first subtree of A (with
-// its name relative to A), ...
-//
-// === Resolve undo
-//
-// A conflict is represented in the index as a set of higher stage entries.
-// When a conflict is resolved (e.g. with "git add path"), these higher
-// stage entries will be removed and a stage-0 entry with proper resolution
-// is added.
-//
-// When these higher stage entries are removed, they are saved in the
-// resolve undo extension, so that conflicts can be recreated (e.g. with
-// "git checkout -m"), in case users want to redo a conflict resolution
-// from scratch.
-//
-// The signature for this extension is { 'R', 'E', 'U', 'C' }.
-//
-// A series of entries fill the entire extension; each of which
-// consists of:
-//
-// - NUL-terminated pathname the entry describes (relative to the root of
-// the repository, i.e. full pathname);
-//
-// - Three NUL-terminated ASCII octal numbers, entry mode of entries in
-// stage 1 to 3 (a missing stage is represented by "0" in this field);
-// and
-//
-// - At most three 160-bit object names of the entry in stages from 1 to 3
-// (nothing is written for a missing stage).
-//
-// === Split index
-//
-// In split index mode, the majority of index entries could be stored
-// in a separate file. This extension records the changes to be made on
-// top of that to produce the final index.
-//
-// The signature for this extension is { 'l', 'i', 'n', 'k' }.
-//
-// The extension consists of:
-//
-// - 160-bit SHA-1 of the shared index file. The shared index file path
-// is $GIT_DIR/sharedindex.<SHA-1>. If all 160 bits are zero, the
-// index does not require a shared index file.
-//
-// - An ewah-encoded delete bitmap, each bit represents an entry in the
-// shared index. If a bit is set, its corresponding entry in the
-// shared index will be removed from the final index. Note, because
-// a delete operation changes index entry positions, but we do need
-// original positions in replace phase, it's best to just mark
-// entries for removal, then do a mass deletion after replacement.
-//
-// - An ewah-encoded replace bitmap, each bit represents an entry in
-// the shared index. If a bit is set, its corresponding entry in the
-// shared index will be replaced with an entry in this index
-// file. All replaced entries are stored in sorted order in this
-// index. The first "1" bit in the replace bitmap corresponds to the
-// first index entry, the second "1" bit to the second entry and so
-// on. Replaced entries may have empty path names to save space.
-//
-// The remaining index entries after replaced ones will be added to the
-// final index. These added entries are also sorted by entry name then
-// stage.
-//
-// == Untracked cache
-//
-// Untracked cache saves the untracked file list and necessary data to
-// verify the cache. The signature for this extension is { 'U', 'N',
-// 'T', 'R' }.
-//
-// The extension starts with
-//
-// - A sequence of NUL-terminated strings, preceded by the size of the
-// sequence in variable width encoding. Each string describes the
-// environment where the cache can be used.
-//
-// - Stat data of $GIT_DIR/info/exclude. See "Index entry" section from
-// ctime field until "file size".
-//
-// - Stat data of plumbing.excludesfile
-//
-// - 32-bit dir_flags (see struct dir_struct)
-//
-// - 160-bit SHA-1 of $GIT_DIR/info/exclude. Null SHA-1 means the file
-// does not exist.
-//
-// - 160-bit SHA-1 of plumbing.excludesfile. Null SHA-1 means the file does
-// not exist.
-//
-// - NUL-terminated string of per-dir exclude file name. This usually
-// is ".gitignore".
-//
-// - The number of following directory blocks, variable width
-// encoding. If this number is zero, the extension ends here with a
-// following NUL.
-//
-// - A number of directory blocks in depth-first-search order, each
-// consists of
-//
-// - The number of untracked entries, variable width encoding.
-//
-// - The number of sub-directory blocks, variable width encoding.
-//
-// - The directory name terminated by NUL.
-//
-// - A number of untracked file/dir names terminated by NUL.
-//
-// The remaining data of each directory block is grouped by type:
-//
-// - An ewah bitmap, the n-th bit marks whether the n-th directory has
-// valid untracked cache entries.
-//
-// - An ewah bitmap, the n-th bit records "check-only" bit of
-// read_directory_recursive() for the n-th directory.
-//
-// - An ewah bitmap, the n-th bit indicates whether SHA-1 and stat data
-// is valid for the n-th directory and exists in the next data.
-//
-// - An array of stat data. The n-th data corresponds with the n-th
-// "one" bit in the previous ewah bitmap.
-//
-// - An array of SHA-1. The n-th SHA-1 corresponds with the n-th "one" bit
-// in the previous ewah bitmap.
-//
-// - One NUL.
-// Source https://www.kernel.org/pub/software/scm/git/docs/technical/index-format.txt
-package index
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/encoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/encoder.go
deleted file mode 100644
index d568f15c5d3bc6c6da9ea2ba8159d7494aa006b0..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/encoder.go
+++ /dev/null
@@ -1,150 +0,0 @@
-package index
-
-import (
- "bytes"
- "crypto/sha1"
- "errors"
- "hash"
- "io"
- "sort"
- "time"
-
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-var (
- // EncodeVersionSupported is the range of supported index versions
- EncodeVersionSupported uint32 = 2
-
- // ErrInvalidTimestamp is returned by Encode if a Index with a Entry with
- // negative timestamp values
- ErrInvalidTimestamp = errors.New("negative timestamps are not allowed")
-)
-
-// An Encoder writes an Index to an output stream.
-type Encoder struct {
- w io.Writer
- hash hash.Hash
-}
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- h := sha1.New()
- mw := io.MultiWriter(w, h)
- return &Encoder{mw, h}
-}
-
-// Encode writes the Index to the stream of the encoder.
-func (e *Encoder) Encode(idx *Index) error {
- // TODO: support versions v3 and v4
- // TODO: support extensions
- if idx.Version != EncodeVersionSupported {
- return ErrUnsupportedVersion
- }
-
- if err := e.encodeHeader(idx); err != nil {
- return err
- }
-
- if err := e.encodeEntries(idx); err != nil {
- return err
- }
-
- return e.encodeFooter()
-}
-
-func (e *Encoder) encodeHeader(idx *Index) error {
- return binary.Write(e.w,
- indexSignature,
- idx.Version,
- uint32(len(idx.Entries)),
- )
-}
-
-func (e *Encoder) encodeEntries(idx *Index) error {
- sort.Sort(byName(idx.Entries))
-
- for _, entry := range idx.Entries {
- if err := e.encodeEntry(&entry); err != nil {
- return err
- }
-
- wrote := entryHeaderLength + len(entry.Name)
- if err := e.padEntry(wrote); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeEntry(entry *Entry) error {
- if entry.IntentToAdd || entry.SkipWorktree {
- return ErrUnsupportedVersion
- }
-
- sec, nsec, err := e.timeToUint32(&entry.CreatedAt)
- if err != nil {
- return err
- }
-
- msec, mnsec, err := e.timeToUint32(&entry.ModifiedAt)
- if err != nil {
- return err
- }
-
- flags := uint16(entry.Stage&0x3) << 12
- if l := len(entry.Name); l < nameMask {
- flags |= uint16(l)
- } else {
- flags |= nameMask
- }
-
- flow := []interface{}{
- sec, nsec,
- msec, mnsec,
- entry.Dev,
- entry.Inode,
- entry.Mode,
- entry.UID,
- entry.GID,
- entry.Size,
- entry.Hash[:],
- flags,
- }
-
- if err := binary.Write(e.w, flow...); err != nil {
- return err
- }
-
- return binary.Write(e.w, []byte(entry.Name))
-}
-
-func (e *Encoder) timeToUint32(t *time.Time) (uint32, uint32, error) {
- if t.IsZero() {
- return 0, 0, nil
- }
-
- if t.Unix() < 0 || t.UnixNano() < 0 {
- return 0, 0, ErrInvalidTimestamp
- }
-
- return uint32(t.Unix()), uint32(t.Nanosecond()), nil
-}
-
-func (e *Encoder) padEntry(wrote int) error {
- padLen := 8 - wrote%8
-
- _, err := e.w.Write(bytes.Repeat([]byte{'\x00'}, padLen))
- return err
-}
-
-func (e *Encoder) encodeFooter() error {
- return binary.Write(e.w, e.hash.Sum(nil))
-}
-
-type byName []Entry
-
-func (l byName) Len() int { return len(l) }
-func (l byName) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
-func (l byName) Less(i, j int) bool { return l[i].Name < l[j].Name }
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/index.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/index.go
deleted file mode 100644
index ee50efde6fc42db110be210f4fdb4721326341bc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/index/index.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package index
-
-import (
- "errors"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
-)
-
-var (
- // ErrUnsupportedVersion is returned by Decode when the idxindex file
- // version is not supported.
- ErrUnsupportedVersion = errors.New("Unsuported version")
-
- indexSignature = []byte{'D', 'I', 'R', 'C'}
- treeExtSignature = []byte{'T', 'R', 'E', 'E'}
- resolveUndoExtSignature = []byte{'R', 'E', 'U', 'C'}
-)
-
-// Stage during merge
-type Stage int
-
-const (
- // Merged is the default stage, fully merged
- Merged Stage = 1
- // AncestorMode is the base revision
- AncestorMode Stage = 1
- // OurMode is the first tree revision, ours
- OurMode Stage = 2
- // TheirMode is the second tree revision, theirs
- TheirMode Stage = 3
-)
-
-// Index contains the information about which objects are currently checked out
-// in the worktree, having information about the working files. Changes in
-// worktree are detected using this Index. The Index is also used during merges
-type Index struct {
- // Version is index version
- Version uint32
- // Entries collection of entries represented by this Index. The order of
- // this collection is not guaranteed
- Entries []Entry
- // Cache represents the 'Cached tree' extension
- Cache *Tree
- // ResolveUndo represents the 'Resolve undo' extension
- ResolveUndo *ResolveUndo
-}
-
-// Entry represents a single file (or stage of a file) in the cache. An entry
-// represents exactly one stage of a file. If a file path is unmerged then
-// multiple Entry instances may appear for the same path name.
-type Entry struct {
- // Hash is the SHA1 of the represented file
- Hash plumbing.Hash
- // Name is the Entry path name relative to top level directory
- Name string
- // CreatedAt time when the tracked path was created
- CreatedAt time.Time
- // ModifiedAt time when the tracked path was changed
- ModifiedAt time.Time
- // Dev and Inode of the tracked path
- Dev, Inode uint32
- // Mode of the path
- Mode filemode.FileMode
- // UID and GID, userid and group id of the owner
- UID, GID uint32
- // Size is the length in bytes for regular files
- Size uint32
- // Stage on a merge is defines what stage is representing this entry
- // https://git-scm.com/book/en/v2/Git-Tools-Advanced-Merging
- Stage Stage
- // SkipWorktree used in sparse checkouts
- // https://git-scm.com/docs/git-read-tree#_sparse_checkout
- SkipWorktree bool
- // IntentToAdd record only the fact that the path will be added later
- // https://git-scm.com/docs/git-add ("git add -N")
- IntentToAdd bool
-}
-
-// Tree contains pre-computed hashes for trees that can be derived from the
-// index. It helps speed up tree object generation from index for a new commit.
-type Tree struct {
- Entries []TreeEntry
-}
-
-// TreeEntry entry of a cached Tree
-type TreeEntry struct {
- // Path component (relative to its parent directory)
- Path string
- // Entries is the number of entries in the index that is covered by the tree
- // this entry represents.
- Entries int
- // Trees is the number that represents the number of subtrees this tree has
- Trees int
- // Hash object name for the object that would result from writing this span
- // of index as a tree.
- Hash plumbing.Hash
-}
-
-// ResolveUndo is used when a conflict is resolved (e.g. with "git add path"),
-// these higher stage entries are removed and a stage-0 entry with proper
-// resolution is added. When these higher stage entries are removed, they are
-// saved in the resolve undo extension.
-type ResolveUndo struct {
- Entries []ResolveUndoEntry
-}
-
-// ResolveUndoEntry contains the information about a conflict when is resolved
-type ResolveUndoEntry struct {
- Path string
- Stages map[Stage]plumbing.Hash
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/doc.go
deleted file mode 100644
index a7145160ae0e43e93add96a5deb810c40ae8597f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package objfile implements encoding and decoding of object files.
-package objfile
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/reader.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/reader.go
deleted file mode 100644
index e7e119cb1f9e10712945d9a7352d20fd7aabab53..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/reader.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package objfile
-
-import (
- "compress/zlib"
- "errors"
- "io"
- "strconv"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
-)
-
-var (
- ErrClosed = errors.New("objfile: already closed")
- ErrHeader = errors.New("objfile: invalid header")
- ErrNegativeSize = errors.New("objfile: negative object size")
-)
-
-// Reader reads and decodes compressed objfile data from a provided io.Reader.
-// Reader implements io.ReadCloser. Close should be called when finished with
-// the Reader. Close will not close the underlying io.Reader.
-type Reader struct {
- multi io.Reader
- zlib io.ReadCloser
- hasher plumbing.Hasher
-}
-
-// NewReader returns a new Reader reading from r.
-func NewReader(r io.Reader) (*Reader, error) {
- zlib, err := zlib.NewReader(r)
- if err != nil {
- return nil, packfile.ErrZLib.AddDetails(err.Error())
- }
-
- return &Reader{
- zlib: zlib,
- }, nil
-}
-
-// Header reads the type and the size of object, and prepares the reader for read
-func (r *Reader) Header() (t plumbing.ObjectType, size int64, err error) {
- var raw []byte
- raw, err = r.readUntil(' ')
- if err != nil {
- return
- }
-
- t, err = plumbing.ParseObjectType(string(raw))
- if err != nil {
- return
- }
-
- raw, err = r.readUntil(0)
- if err != nil {
- return
- }
-
- size, err = strconv.ParseInt(string(raw), 10, 64)
- if err != nil {
- err = ErrHeader
- return
- }
-
- defer r.prepareForRead(t, size)
- return
-}
-
-// readSlice reads one byte at a time from r until it encounters delim or an
-// error.
-func (r *Reader) readUntil(delim byte) ([]byte, error) {
- var buf [1]byte
- value := make([]byte, 0, 16)
- for {
- if n, err := r.zlib.Read(buf[:]); err != nil && (err != io.EOF || n == 0) {
- if err == io.EOF {
- return nil, ErrHeader
- }
- return nil, err
- }
-
- if buf[0] == delim {
- return value, nil
- }
-
- value = append(value, buf[0])
- }
-}
-
-func (r *Reader) prepareForRead(t plumbing.ObjectType, size int64) {
- r.hasher = plumbing.NewHasher(t, size)
- r.multi = io.TeeReader(r.zlib, r.hasher)
-}
-
-// Read reads len(p) bytes into p from the object data stream. It returns
-// the number of bytes read (0 <= n <= len(p)) and any error encountered. Even
-// if Read returns n < len(p), it may use all of p as scratch space during the
-// call.
-//
-// If Read encounters the end of the data stream it will return err == io.EOF,
-// either in the current call if n > 0 or in a subsequent call.
-func (r *Reader) Read(p []byte) (n int, err error) {
- return r.multi.Read(p)
-}
-
-// Hash returns the hash of the object data stream that has been read so far.
-func (r *Reader) Hash() plumbing.Hash {
- return r.hasher.Sum()
-}
-
-// Close releases any resources consumed by the Reader. Calling Close does not
-// close the wrapped io.Reader originally passed to NewReader.
-func (r *Reader) Close() error {
- if err := r.zlib.Close(); err != nil {
- return err
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/writer.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/writer.go
deleted file mode 100644
index 5555243401d9e0be3682e9149d79bc2fbc344930..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/objfile/writer.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package objfile
-
-import (
- "compress/zlib"
- "errors"
- "io"
- "strconv"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-var (
- ErrOverflow = errors.New("objfile: declared data length exceeded (overflow)")
-)
-
-// Writer writes and encodes data in compressed objfile format to a provided
-// io.Writer. Close should be called when finished with the Writer. Close will
-// not close the underlying io.Writer.
-type Writer struct {
- raw io.Writer
- zlib io.WriteCloser
- hasher plumbing.Hasher
- multi io.Writer
-
- closed bool
- pending int64 // number of unwritten bytes
-}
-
-// NewWriter returns a new Writer writing to w.
-//
-// The returned Writer implements io.WriteCloser. Close should be called when
-// finished with the Writer. Close will not close the underlying io.Writer.
-func NewWriter(w io.Writer) *Writer {
- return &Writer{
- raw: w,
- zlib: zlib.NewWriter(w),
- }
-}
-
-// WriteHeader writes the type and the size and prepares to accept the object's
-// contents. If an invalid t is provided, plumbing.ErrInvalidType is returned. If a
-// negative size is provided, ErrNegativeSize is returned.
-func (w *Writer) WriteHeader(t plumbing.ObjectType, size int64) error {
- if !t.Valid() {
- return plumbing.ErrInvalidType
- }
- if size < 0 {
- return ErrNegativeSize
- }
-
- b := t.Bytes()
- b = append(b, ' ')
- b = append(b, []byte(strconv.FormatInt(size, 10))...)
- b = append(b, 0)
-
- defer w.prepareForWrite(t, size)
- _, err := w.zlib.Write(b)
-
- return err
-}
-
-func (w *Writer) prepareForWrite(t plumbing.ObjectType, size int64) {
- w.pending = size
-
- w.hasher = plumbing.NewHasher(t, size)
- w.multi = io.MultiWriter(w.zlib, w.hasher)
-}
-
-// Write writes the object's contents. Write returns the error ErrOverflow if
-// more than size bytes are written after WriteHeader.
-func (w *Writer) Write(p []byte) (n int, err error) {
- if w.closed {
- return 0, ErrClosed
- }
-
- overwrite := false
- if int64(len(p)) > w.pending {
- p = p[0:w.pending]
- overwrite = true
- }
-
- n, err = w.multi.Write(p)
- w.pending -= int64(n)
- if err == nil && overwrite {
- err = ErrOverflow
- return
- }
-
- return
-}
-
-// Hash returns the hash of the object data stream that has been written so far.
-// It can be called before or after Close.
-func (w *Writer) Hash() plumbing.Hash {
- return w.hasher.Sum() // Not yet closed, return hash of data written so far
-}
-
-// Close releases any resources consumed by the Writer.
-//
-// Calling Close does not close the wrapped io.Writer originally passed to
-// NewWriter.
-func (w *Writer) Close() error {
- if err := w.zlib.Close(); err != nil {
- return err
- }
-
- w.closed = true
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/common.go
deleted file mode 100644
index 6402cd071ceaea10a29293503ce9db32e908315c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/common.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package packfile
-
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-var signature = []byte{'P', 'A', 'C', 'K'}
-
-const (
- // VersionSupported is the packfile version supported by this package
- VersionSupported uint32 = 2
-
- firstLengthBits = uint8(4) // the first byte into object header has 4 bits to store the length
- lengthBits = uint8(7) // subsequent bytes has 7 bits to store the length
- maskFirstLength = 15 // 0000 1111
- maskContinue = 0x80 // 1000 0000
- maskLength = uint8(127) // 0111 1111
- maskType = uint8(112) // 0111 0000
-)
-
-// UpdateObjectStorage updates the given storer.EncodedObjectStorer with the contents of the
-// packfile.
-func UpdateObjectStorage(s storer.EncodedObjectStorer, packfile io.Reader) error {
- if sw, ok := s.(storer.PackfileWriter); ok {
- w, err := sw.PackfileWriter()
- if err != nil {
- return err
- }
-
- defer w.Close()
- _, err = io.Copy(w, packfile)
- return err
- }
-
- stream := NewScanner(packfile)
- d, err := NewDecoder(stream, s)
- if err != nil {
- return err
- }
-
- _, err = d.Decode()
- return err
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/decoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/decoder.go
deleted file mode 100644
index f3328efb7689d4b45e06caf452cbb586f2c83499..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/decoder.go
+++ /dev/null
@@ -1,459 +0,0 @@
-package packfile
-
-import (
- "bytes"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/cache"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-// Format specifies if the packfile uses ref-deltas or ofs-deltas.
-type Format int
-
-// Possible values of the Format type.
-const (
- UnknownFormat Format = iota
- OFSDeltaFormat
- REFDeltaFormat
-)
-
-var (
- // ErrMaxObjectsLimitReached is returned by Decode when the number
- // of objects in the packfile is higher than
- // Decoder.MaxObjectsLimit.
- ErrMaxObjectsLimitReached = NewError("max. objects limit reached")
- // ErrInvalidObject is returned by Decode when an invalid object is
- // found in the packfile.
- ErrInvalidObject = NewError("invalid git object")
- // ErrPackEntryNotFound is returned by Decode when a reference in
- // the packfile references and unknown object.
- ErrPackEntryNotFound = NewError("can't find a pack entry")
- // ErrZLib is returned by Decode when there was an error unzipping
- // the packfile contents.
- ErrZLib = NewError("zlib reading error")
- // ErrCannotRecall is returned by RecallByOffset or RecallByHash if the object
- // to recall cannot be returned.
- ErrCannotRecall = NewError("cannot recall object")
- // ErrResolveDeltasNotSupported is returned if a NewDecoder is used with a
- // non-seekable scanner and without a plumbing.ObjectStorage
- ErrResolveDeltasNotSupported = NewError("resolve delta is not supported")
- // ErrNonSeekable is returned if a ReadObjectAt method is called without a
- // seekable scanner
- ErrNonSeekable = NewError("non-seekable scanner")
- // ErrRollback error making Rollback over a transaction after an error
- ErrRollback = NewError("rollback error, during set error")
- // ErrAlreadyDecoded is returned if NewDecoder is called for a second time
- ErrAlreadyDecoded = NewError("packfile was already decoded")
-)
-
-// Decoder reads and decodes packfiles from an input Scanner, if an ObjectStorer
-// was provided the decoded objects are store there. If not the decode object
-// is destroyed. The Offsets and CRCs are calculated whether an
-// ObjectStorer was provided or not.
-type Decoder struct {
- s *Scanner
- o storer.EncodedObjectStorer
- tx storer.Transaction
-
- isDecoded bool
- offsetToHash map[int64]plumbing.Hash
- hashToOffset map[plumbing.Hash]int64
- crcs map[plumbing.Hash]uint32
-
- offsetToType map[int64]plumbing.ObjectType
- decoderType plumbing.ObjectType
-
- cache cache.Object
-}
-
-// NewDecoder returns a new Decoder that decodes a Packfile using the given
-// Scanner and stores the objects in the provided EncodedObjectStorer. ObjectStorer can be nil, in this
-// If the passed EncodedObjectStorer is nil, objects are not stored, but
-// offsets on the Packfile and CRCs are calculated.
-//
-// If EncodedObjectStorer is nil and the Scanner is not Seekable, ErrNonSeekable is
-// returned.
-//
-// If the ObjectStorer implements storer.Transactioner, a transaction is created
-// during the Decode execution. If anything fails, Rollback is called
-func NewDecoder(s *Scanner, o storer.EncodedObjectStorer) (*Decoder, error) {
- return NewDecoderForType(s, o, plumbing.AnyObject)
-}
-
-// NewDecoderForType returns a new Decoder but in this case for a specific object type.
-// When an object is read using this Decoder instance and it is not of the same type of
-// the specified one, nil will be returned. This is intended to avoid the content
-// deserialization of all the objects
-func NewDecoderForType(s *Scanner, o storer.EncodedObjectStorer,
- t plumbing.ObjectType) (*Decoder, error) {
-
- if t == plumbing.OFSDeltaObject ||
- t == plumbing.REFDeltaObject ||
- t == plumbing.InvalidObject {
- return nil, plumbing.ErrInvalidType
- }
-
- if !canResolveDeltas(s, o) {
- return nil, ErrResolveDeltasNotSupported
- }
-
- return &Decoder{
- s: s,
- o: o,
-
- offsetToHash: make(map[int64]plumbing.Hash, 0),
- hashToOffset: make(map[plumbing.Hash]int64, 0),
- crcs: make(map[plumbing.Hash]uint32, 0),
-
- offsetToType: make(map[int64]plumbing.ObjectType, 0),
- decoderType: t,
-
- cache: cache.NewObjectFIFO(cache.MaxSize),
- }, nil
-}
-
-func canResolveDeltas(s *Scanner, o storer.EncodedObjectStorer) bool {
- return s.IsSeekable || o != nil
-}
-
-// Decode reads a packfile and stores it in the value pointed to by s. The
-// offsets and the CRCs are calculated by this method
-func (d *Decoder) Decode() (checksum plumbing.Hash, err error) {
- defer func() { d.isDecoded = true }()
-
- if d.isDecoded {
- return plumbing.ZeroHash, ErrAlreadyDecoded
- }
-
- if err := d.doDecode(); err != nil {
- return plumbing.ZeroHash, err
- }
-
- return d.s.Checksum()
-}
-
-func (d *Decoder) doDecode() error {
- _, count, err := d.s.Header()
- if err != nil {
- return err
- }
-
- _, isTxStorer := d.o.(storer.Transactioner)
- switch {
- case d.o == nil:
- return d.decodeObjects(int(count))
- case isTxStorer:
- return d.decodeObjectsWithObjectStorerTx(int(count))
- default:
- return d.decodeObjectsWithObjectStorer(int(count))
- }
-}
-
-func (d *Decoder) decodeObjects(count int) error {
- for i := 0; i < count; i++ {
- if _, err := d.DecodeObject(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) decodeObjectsWithObjectStorer(count int) error {
- for i := 0; i < count; i++ {
- obj, err := d.DecodeObject()
- if err != nil {
- return err
- }
-
- if _, err := d.o.SetEncodedObject(obj); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) decodeObjectsWithObjectStorerTx(count int) error {
- d.tx = d.o.(storer.Transactioner).Begin()
-
- for i := 0; i < count; i++ {
- obj, err := d.DecodeObject()
- if err != nil {
- return err
- }
-
- if _, err := d.tx.SetEncodedObject(obj); err != nil {
- if rerr := d.tx.Rollback(); rerr != nil {
- return ErrRollback.AddDetails(
- "error: %s, during tx.Set error: %s", rerr, err,
- )
- }
-
- return err
- }
-
- }
-
- return d.tx.Commit()
-}
-
-// DecodeObject reads the next object from the scanner and returns it. This
-// method can be used in replacement of the Decode method, to work in a
-// interactive way. If you created a new decoder instance using NewDecoderForType
-// constructor, if the object decoded is not equals to the specified one, nil will
-// be returned
-func (d *Decoder) DecodeObject() (plumbing.EncodedObject, error) {
- h, err := d.s.NextObjectHeader()
- if err != nil {
- return nil, err
- }
-
- if d.decoderType == plumbing.AnyObject {
- return d.decodeByHeader(h)
- }
-
- return d.decodeIfSpecificType(h)
-}
-
-func (d *Decoder) decodeIfSpecificType(h *ObjectHeader) (plumbing.EncodedObject, error) {
- var realType plumbing.ObjectType
- var err error
- switch h.Type {
- case plumbing.OFSDeltaObject:
- realType, err = d.ofsDeltaType(h.OffsetReference)
- case plumbing.REFDeltaObject:
- realType, err = d.refDeltaType(h.Reference)
- default:
- realType = h.Type
- }
-
- if err != nil {
- return nil, err
- }
-
- d.offsetToType[h.Offset] = realType
-
- if d.decoderType == realType {
- return d.decodeByHeader(h)
- }
-
- return nil, nil
-}
-
-func (d *Decoder) ofsDeltaType(offset int64) (plumbing.ObjectType, error) {
- t, ok := d.offsetToType[offset]
- if !ok {
- return plumbing.InvalidObject, plumbing.ErrObjectNotFound
- }
-
- return t, nil
-}
-
-func (d *Decoder) refDeltaType(ref plumbing.Hash) (plumbing.ObjectType, error) {
- if o, ok := d.hashToOffset[ref]; ok {
- return d.ofsDeltaType(o)
- }
-
- obj, err := d.o.EncodedObject(plumbing.AnyObject, ref)
- if err != nil {
- return plumbing.InvalidObject, err
- }
-
- return obj.Type(), nil
-}
-
-func (d *Decoder) decodeByHeader(h *ObjectHeader) (plumbing.EncodedObject, error) {
- obj := d.newObject()
- obj.SetSize(h.Length)
- obj.SetType(h.Type)
- var crc uint32
- var err error
- switch h.Type {
- case plumbing.CommitObject, plumbing.TreeObject, plumbing.BlobObject, plumbing.TagObject:
- crc, err = d.fillRegularObjectContent(obj)
- case plumbing.REFDeltaObject:
- crc, err = d.fillREFDeltaObjectContent(obj, h.Reference)
- case plumbing.OFSDeltaObject:
- crc, err = d.fillOFSDeltaObjectContent(obj, h.OffsetReference)
- default:
- err = ErrInvalidObject.AddDetails("type %q", h.Type)
- }
-
- if err != nil {
- return obj, err
- }
-
- hash := obj.Hash()
- d.setOffset(hash, h.Offset)
- d.setCRC(hash, crc)
-
- return obj, nil
-}
-
-func (d *Decoder) newObject() plumbing.EncodedObject {
- if d.o == nil {
- return &plumbing.MemoryObject{}
- }
-
- return d.o.NewEncodedObject()
-}
-
-// DecodeObjectAt reads an object at the given location. Every EncodedObject
-// returned is added into a internal index. This is intended to be able to regenerate
-// objects from deltas (offset deltas or reference deltas) without an package index
-// (.idx file). If Decode wasn't called previously objects offset should provided
-// using the SetOffsets method.
-func (d *Decoder) DecodeObjectAt(offset int64) (plumbing.EncodedObject, error) {
- if !d.s.IsSeekable {
- return nil, ErrNonSeekable
- }
-
- beforeJump, err := d.s.Seek(offset)
- if err != nil {
- return nil, err
- }
-
- defer func() {
- _, seekErr := d.s.Seek(beforeJump)
- if err == nil {
- err = seekErr
- }
- }()
-
- return d.DecodeObject()
-}
-
-func (d *Decoder) fillRegularObjectContent(obj plumbing.EncodedObject) (uint32, error) {
- w, err := obj.Writer()
- if err != nil {
- return 0, err
- }
-
- _, crc, err := d.s.NextObject(w)
- return crc, err
-}
-
-func (d *Decoder) fillREFDeltaObjectContent(obj plumbing.EncodedObject, ref plumbing.Hash) (uint32, error) {
- buf := bytes.NewBuffer(nil)
- _, crc, err := d.s.NextObject(buf)
- if err != nil {
- return 0, err
- }
-
- base := d.cache.Get(ref)
-
- if base == nil {
- base, err = d.recallByHash(ref)
- if err != nil {
- return 0, err
- }
- }
-
- obj.SetType(base.Type())
- err = ApplyDelta(obj, base, buf.Bytes())
- d.cache.Add(obj)
-
- return crc, err
-}
-
-func (d *Decoder) fillOFSDeltaObjectContent(obj plumbing.EncodedObject, offset int64) (uint32, error) {
- buf := bytes.NewBuffer(nil)
- _, crc, err := d.s.NextObject(buf)
- if err != nil {
- return 0, err
- }
-
- h := d.offsetToHash[offset]
- var base plumbing.EncodedObject
- if h != plumbing.ZeroHash {
- base = d.cache.Get(h)
- }
-
- if base == nil {
- base, err = d.recallByOffset(offset)
- if err != nil {
- return 0, err
- }
- }
-
- obj.SetType(base.Type())
- err = ApplyDelta(obj, base, buf.Bytes())
- d.cache.Add(obj)
-
- return crc, err
-}
-
-func (d *Decoder) setOffset(h plumbing.Hash, offset int64) {
- d.offsetToHash[offset] = h
- d.hashToOffset[h] = offset
-}
-
-func (d *Decoder) setCRC(h plumbing.Hash, crc uint32) {
- d.crcs[h] = crc
-}
-
-func (d *Decoder) recallByOffset(o int64) (plumbing.EncodedObject, error) {
- if d.s.IsSeekable {
- return d.DecodeObjectAt(o)
- }
-
- if h, ok := d.offsetToHash[o]; ok {
- return d.recallByHashNonSeekable(h)
- }
-
- return nil, plumbing.ErrObjectNotFound
-}
-
-func (d *Decoder) recallByHash(h plumbing.Hash) (plumbing.EncodedObject, error) {
- if d.s.IsSeekable {
- if o, ok := d.hashToOffset[h]; ok {
- return d.DecodeObjectAt(o)
- }
- }
-
- return d.recallByHashNonSeekable(h)
-}
-
-// recallByHashNonSeekable if we are in a transaction the objects are read from
-// the transaction, if not are directly read from the ObjectStorer
-func (d *Decoder) recallByHashNonSeekable(h plumbing.Hash) (obj plumbing.EncodedObject, err error) {
- if d.tx != nil {
- obj, err = d.tx.EncodedObject(plumbing.AnyObject, h)
- } else {
- obj, err = d.o.EncodedObject(plumbing.AnyObject, h)
- }
-
- if err != plumbing.ErrObjectNotFound {
- return obj, err
- }
-
- return nil, plumbing.ErrObjectNotFound
-}
-
-// SetOffsets sets the offsets, required when using the method DecodeObjectAt,
-// without decoding the full packfile
-func (d *Decoder) SetOffsets(offsets map[plumbing.Hash]int64) {
- d.hashToOffset = offsets
-}
-
-// Offsets returns the objects read offset, Decode method should be called
-// before to calculate the Offsets
-func (d *Decoder) Offsets() map[plumbing.Hash]int64 {
- return d.hashToOffset
-}
-
-// CRCs returns the CRC-32 for each read object. Decode method should be called
-// before to calculate the CRCs
-func (d *Decoder) CRCs() map[plumbing.Hash]uint32 {
- return d.crcs
-}
-
-// Close closes the Scanner. usually this mean that the whole reader is read and
-// discarded
-func (d *Decoder) Close() error {
- d.cache.Clear()
-
- return d.s.Close()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/delta_selector.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/delta_selector.go
deleted file mode 100644
index a73a2091856e1250cf94dfbb87661f94e665e3fe..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/delta_selector.go
+++ /dev/null
@@ -1,169 +0,0 @@
-package packfile
-
-import (
- "sort"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-const (
- // deltas based on deltas, how many steps we can do.
- // 50 is the default value used in JGit
- maxDepth = int64(50)
-)
-
-// applyDelta is the set of object types that we should apply deltas
-var applyDelta = map[plumbing.ObjectType]bool{
- plumbing.BlobObject: true,
- plumbing.TreeObject: true,
-}
-
-type deltaSelector struct {
- storer storer.EncodedObjectStorer
-}
-
-func newDeltaSelector(s storer.EncodedObjectStorer) *deltaSelector {
- return &deltaSelector{s}
-}
-
-// ObjectsToPack creates a list of ObjectToPack from the hashes provided,
-// creating deltas if it's suitable, using an specific internal logic
-func (dw *deltaSelector) ObjectsToPack(hashes []plumbing.Hash) ([]*ObjectToPack, error) {
- otp, err := dw.objectsToPack(hashes)
- if err != nil {
- return nil, err
- }
-
- dw.sort(otp)
-
- if err := dw.walk(otp); err != nil {
- return nil, err
- }
-
- return otp, nil
-}
-
-func (dw *deltaSelector) objectsToPack(hashes []plumbing.Hash) ([]*ObjectToPack, error) {
- var objectsToPack []*ObjectToPack
- for _, h := range hashes {
- o, err := dw.storer.EncodedObject(plumbing.AnyObject, h)
- if err != nil {
- return nil, err
- }
-
- objectsToPack = append(objectsToPack, newObjectToPack(o))
- }
-
- return objectsToPack, nil
-}
-
-func (dw *deltaSelector) sort(objectsToPack []*ObjectToPack) {
- sort.Sort(byTypeAndSize(objectsToPack))
-}
-
-func (dw *deltaSelector) walk(objectsToPack []*ObjectToPack) error {
- for i := 0; i < len(objectsToPack); i++ {
- target := objectsToPack[i]
-
- // We only want to create deltas from specific types
- if !applyDelta[target.Original.Type()] {
- continue
- }
-
- for j := i - 1; j >= 0; j-- {
- base := objectsToPack[j]
- // Objects must use only the same type as their delta base.
- if base.Original.Type() != target.Original.Type() {
- break
- }
-
- if err := dw.tryToDeltify(base, target); err != nil {
- return err
- }
- }
- }
-
- return nil
-}
-
-func (dw *deltaSelector) tryToDeltify(base, target *ObjectToPack) error {
- // If the sizes are radically different, this is a bad pairing.
- if target.Original.Size() < base.Original.Size()>>4 {
- return nil
- }
-
- msz := dw.deltaSizeLimit(
- target.Object.Size(),
- base.Depth,
- target.Depth,
- target.IsDelta(),
- )
-
- // Nearly impossible to fit useful delta.
- if msz <= 8 {
- return nil
- }
-
- // If we have to insert a lot to make this work, find another.
- if base.Original.Size()-target.Object.Size() > msz {
- return nil
- }
-
- // Now we can generate the delta using originals
- delta, err := GetDelta(base.Original, target.Original)
- if err != nil {
- return err
- }
-
- // if delta better than target
- if delta.Size() < msz {
- target.SetDelta(base, delta)
- }
-
- return nil
-}
-
-func (dw *deltaSelector) deltaSizeLimit(targetSize int64, baseDepth int,
- targetDepth int, targetDelta bool) int64 {
- if !targetDelta {
- // Any delta should be no more than 50% of the original size
- // (for text files deflate of whole form should shrink 50%).
- n := targetSize >> 1
-
- // Evenly distribute delta size limits over allowed depth.
- // If src is non-delta (depth = 0), delta <= 50% of original.
- // If src is almost at limit (9/10), delta <= 10% of original.
- return n * (maxDepth - int64(baseDepth)) / maxDepth
- }
-
- // With a delta base chosen any new delta must be "better".
- // Retain the distribution described above.
- d := int64(targetDepth)
- n := targetSize
-
- // If src is whole (depth=0) and base is near limit (depth=9/10)
- // any delta using src can be 10x larger and still be better.
- //
- // If src is near limit (depth=9/10) and base is whole (depth=0)
- // a new delta dependent on src must be 1/10th the size.
- return n * (maxDepth - int64(baseDepth)) / (maxDepth - d)
-}
-
-type byTypeAndSize []*ObjectToPack
-
-func (a byTypeAndSize) Len() int { return len(a) }
-
-func (a byTypeAndSize) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-
-func (a byTypeAndSize) Less(i, j int) bool {
- if a[i].Object.Type() < a[j].Object.Type() {
- return false
- }
-
- if a[i].Object.Type() > a[j].Object.Type() {
- return true
- }
-
- return a[i].Object.Size() > a[j].Object.Size()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff.go
deleted file mode 100644
index ff34329c1d88524458dd9236f0280b042675c844..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff.go
+++ /dev/null
@@ -1,397 +0,0 @@
-package packfile
-
-/*
-
-Copyright (c) 2013, Patrick Mezard
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.
- The names of its contributors may not be used to endorse or promote
-products derived from this software without specific prior written
-permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-// Code based on https://github.com/pmezard/go-difflib
-// Removed unnecessary code for this use case and changed string inputs to byte
-
-type match struct {
- A int
- B int
- Size int
-}
-
-type opCode struct {
- Tag byte
- I1 int
- I2 int
- J1 int
- J2 int
-}
-
-// SequenceMatcher compares sequence of bytes. The basic
-// algorithm predates, and is a little fancier than, an algorithm
-// published in the late 1980's by Ratcliff and Obershelp under the
-// hyperbolic name "gestalt pattern matching". The basic idea is to find
-// the longest contiguous matching subsequence that contains no "junk"
-// elements (R-O doesn't address junk). The same idea is then applied
-// recursively to the pieces of the sequences to the left and to the right
-// of the matching subsequence. This does not yield minimal edit
-// sequences, but does tend to yield matches that "look right" to people.
-//
-// SequenceMatcher tries to compute a "human-friendly diff" between two
-// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the
-// longest *contiguous* & junk-free matching subsequence. That's what
-// catches peoples' eyes. The Windows(tm) windiff has another interesting
-// notion, pairing up elements that appear uniquely in each sequence.
-// That, and the method here, appear to yield more intuitive difference
-// reports than does diff. This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
-// ordinary text files, or maybe "<P>" lines in HTML files). That may be
-// because this is the only method of the 3 that has a *concept* of
-// "junk" <wink>.
-//
-// Timing: Basic R-O is cubic time worst case and quadratic time expected
-// case. SequenceMatcher is quadratic time for the worst case and has
-// expected-case behavior dependent in a complicated way on how many
-// elements the sequences have in common; best case time is linear.
-type sequenceMatcher struct {
- a []byte
- b []byte
- b2j map[byte][]int
- IsJunk func(byte) bool
- autoJunk bool
- bJunk map[byte]struct{}
- matchingBlocks []match
- fullBCount map[byte]int
- bPopular map[byte]struct{}
- opCodes []opCode
-}
-
-func newMatcher(a, b []byte) *sequenceMatcher {
- m := sequenceMatcher{autoJunk: true}
- m.SetSeqs(a, b)
- return &m
-}
-
-// Set two sequences to be compared.
-func (m *sequenceMatcher) SetSeqs(a, b []byte) {
- m.SetSeq1(a)
- m.SetSeq2(b)
-}
-
-// Set the first sequence to be compared. The second sequence to be compared is
-// not changed.
-//
-// SequenceMatcher computes and caches detailed information about the second
-// sequence, so if you want to compare one sequence S against many sequences,
-// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other
-// sequences.
-//
-// See also SetSeqs() and SetSeq2().
-func (m *sequenceMatcher) SetSeq1(a []byte) {
- if &a == &m.a {
- return
- }
- m.a = a
- m.matchingBlocks = nil
- m.opCodes = nil
-}
-
-// Set the second sequence to be compared. The first sequence to be compared is
-// not changed.
-func (m *sequenceMatcher) SetSeq2(b []byte) {
- if &b == &m.b {
- return
- }
- m.b = b
- m.matchingBlocks = nil
- m.opCodes = nil
- m.fullBCount = nil
- m.chainB()
-}
-
-func (m *sequenceMatcher) chainB() {
- // Populate line -> index mapping
- b2j := map[byte][]int{}
- for i, s := range m.b {
- indices := b2j[s]
- indices = append(indices, i)
- b2j[s] = indices
- }
-
- // Purge junk elements
- m.bJunk = map[byte]struct{}{}
- if m.IsJunk != nil {
- junk := m.bJunk
- for s := range b2j {
- if m.IsJunk(s) {
- junk[s] = struct{}{}
- }
- }
- for s := range junk {
- delete(b2j, s)
- }
- }
-
- // Purge remaining popular elements
- popular := map[byte]struct{}{}
- n := len(m.b)
- if m.autoJunk && n >= 200 {
- ntest := n/100 + 1
- for s, indices := range b2j {
- if len(indices) > ntest {
- popular[s] = struct{}{}
- }
- }
- for s := range popular {
- delete(b2j, s)
- }
- }
- m.bPopular = popular
- m.b2j = b2j
-}
-
-func (m *sequenceMatcher) isBJunk(s byte) bool {
- _, ok := m.bJunk[s]
- return ok
-}
-
-// Find longest matching block in a[alo:ahi] and b[blo:bhi].
-//
-// If IsJunk is not defined:
-//
-// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-// alo <= i <= i+k <= ahi
-// blo <= j <= j+k <= bhi
-// and for all (i',j',k') meeting those conditions,
-// k >= k'
-// i <= i'
-// and if i == i', j <= j'
-//
-// In other words, of all maximal matching blocks, return one that
-// starts earliest in a, and of all those maximal matching blocks that
-// start earliest in a, return the one that starts earliest in b.
-//
-// If IsJunk is defined, first the longest matching block is
-// determined as above, but with the additional restriction that no
-// junk element appears in the block. Then that block is extended as
-// far as possible by matching (only) junk elements on both sides. So
-// the resulting block never matches on junk except as identical junk
-// happens to be adjacent to an "interesting" match.
-//
-// If no blocks match, return (alo, blo, 0).
-func (m *sequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) match {
- // CAUTION: stripping common prefix or suffix would be incorrect.
- // E.g.,
- // ab
- // acab
- // Longest matching block is "ab", but if common prefix is
- // stripped, it's "a" (tied with "b"). UNIX(tm) diff does so
- // strip, so ends up claiming that ab is changed to acab by
- // inserting "ca" in the middle. That's minimal but unintuitive:
- // "it's obvious" that someone inserted "ac" at the front.
- // Windiff ends up at the same place as diff, but by pairing up
- // the unique 'b's and then matching the first two 'a's.
- besti, bestj, bestsize := alo, blo, 0
-
- // find longest junk-free match
- // during an iteration of the loop, j2len[j] = length of longest
- // junk-free match ending with a[i-1] and b[j]
- j2len := map[int]int{}
- for i := alo; i != ahi; i++ {
- // look at all instances of a[i] in b; note that because
- // b2j has no junk keys, the loop is skipped if a[i] is junk
- newj2len := map[int]int{}
- for _, j := range m.b2j[m.a[i]] {
- // a[i] matches b[j]
- if j < blo {
- continue
- }
- if j >= bhi {
- break
- }
- k := j2len[j-1] + 1
- newj2len[j] = k
- if k > bestsize {
- besti, bestj, bestsize = i-k+1, j-k+1, k
- }
- }
- j2len = newj2len
- }
-
- // Extend the best by non-junk elements on each end. In particular,
- // "popular" non-junk elements aren't in b2j, which greatly speeds
- // the inner loop above, but also means "the best" match so far
- // doesn't contain any junk *or* popular non-junk elements.
- for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- !m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- // Now that we have a wholly interesting match (albeit possibly
- // empty!), we may as well suck up the matching junk on each
- // side of it too. Can't think of a good reason not to, and it
- // saves post-processing the (possibly considerable) expense of
- // figuring out what to do with it. In the case of an empty
- // interesting match, this is clearly the right thing to do,
- // because no other kind of match is possible in the regions.
- for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) &&
- m.a[besti-1] == m.b[bestj-1] {
- besti, bestj, bestsize = besti-1, bestj-1, bestsize+1
- }
- for besti+bestsize < ahi && bestj+bestsize < bhi &&
- m.isBJunk(m.b[bestj+bestsize]) &&
- m.a[besti+bestsize] == m.b[bestj+bestsize] {
- bestsize += 1
- }
-
- return match{A: besti, B: bestj, Size: bestsize}
-}
-
-// Return list of triples describing matching subsequences.
-//
-// Each triple is of the form (i, j, n), and means that
-// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in
-// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are
-// adjacent triples in the list, and the second is not the last triple in the
-// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe
-// adjacent equal blocks.
-//
-// The last triple is a dummy, (len(a), len(b), 0), and is the only
-// triple with n==0.
-func (m *sequenceMatcher) GetMatchingBlocks() []match {
- if m.matchingBlocks != nil {
- return m.matchingBlocks
- }
-
- var matchBlocks func(alo, ahi, blo, bhi int, matched []match) []match
- matchBlocks = func(alo, ahi, blo, bhi int, matched []match) []match {
- match := m.findLongestMatch(alo, ahi, blo, bhi)
- i, j, k := match.A, match.B, match.Size
- if match.Size > 0 {
- if alo < i && blo < j {
- matched = matchBlocks(alo, i, blo, j, matched)
- }
- matched = append(matched, match)
- if i+k < ahi && j+k < bhi {
- matched = matchBlocks(i+k, ahi, j+k, bhi, matched)
- }
- }
- return matched
- }
- matched := matchBlocks(0, len(m.a), 0, len(m.b), nil)
-
- // It's possible that we have adjacent equal blocks in the
- // matching_blocks list now.
- nonAdjacent := []match{}
- i1, j1, k1 := 0, 0, 0
- for _, b := range matched {
- // Is this block adjacent to i1, j1, k1?
- i2, j2, k2 := b.A, b.B, b.Size
- if i1+k1 == i2 && j1+k1 == j2 {
- // Yes, so collapse them -- this just increases the length of
- // the first block by the length of the second, and the first
- // block so lengthened remains the block to compare against.
- k1 += k2
- } else {
- // Not adjacent. Remember the first block (k1==0 means it's
- // the dummy we started with), and make the second block the
- // new block to compare against.
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, match{i1, j1, k1})
- }
- i1, j1, k1 = i2, j2, k2
- }
- }
- if k1 > 0 {
- nonAdjacent = append(nonAdjacent, match{i1, j1, k1})
- }
-
- nonAdjacent = append(nonAdjacent, match{len(m.a), len(m.b), 0})
- m.matchingBlocks = nonAdjacent
- return m.matchingBlocks
-}
-
-const (
- tagReplace = 'r'
- tagDelete = 'd'
- tagInsert = 'i'
- tagEqual = 'e'
-)
-
-// Return list of 5-tuples describing how to turn a into b.
-//
-// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple
-// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
-// tuple preceding it, and likewise for j1 == the previous j2.
-//
-// The tags are characters, with these meanings:
-//
-// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2]
-//
-// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case.
-//
-// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case.
-//
-// 'e' (equal): a[i1:i2] == b[j1:j2]
-func (m *sequenceMatcher) GetOpCodes() []opCode {
- if m.opCodes != nil {
- return m.opCodes
- }
- i, j := 0, 0
- matching := m.GetMatchingBlocks()
- opCodes := make([]opCode, 0, len(matching))
- for _, m := range matching {
- // invariant: we've pumped out correct diffs to change
- // a[:i] into b[:j], and the next matching block is
- // a[ai:ai+size] == b[bj:bj+size]. So we need to pump
- // out a diff to change a[i:ai] into b[j:bj], pump out
- // the matching block, and move (i,j) beyond the match
- ai, bj, size := m.A, m.B, m.Size
- tag := byte(0)
- if i < ai && j < bj {
- tag = tagReplace
- } else if i < ai {
- tag = tagDelete
- } else if j < bj {
- tag = tagInsert
- }
- if tag > 0 {
- opCodes = append(opCodes, opCode{tag, i, ai, j, bj})
- }
- i, j = ai+size, bj+size
- // the list of matching blocks is terminated by a
- // sentinel with size 0
- if size > 0 {
- opCodes = append(opCodes, opCode{tagEqual, ai, i, bj, j})
- }
- }
- m.opCodes = opCodes
- return m.opCodes
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff_delta.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff_delta.go
deleted file mode 100644
index 40d450f938d26b43d56e7d6c5e79000ae83c1fdb..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/diff_delta.go
+++ /dev/null
@@ -1,142 +0,0 @@
-package packfile
-
-import (
- "io/ioutil"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-// See https://github.com/jelmer/dulwich/blob/master/dulwich/pack.py and
-// https://github.com/tarruda/node-git-core/blob/master/src/js/delta.js
-// for more info
-
-const (
- maxCopyLen = 0xffff
-)
-
-// GetDelta returns an EncodedObject of type OFSDeltaObject. Base and Target object,
-// will be loaded into memory to be able to create the delta object.
-// To generate target again, you will need the obtained object and "base" one.
-// Error will be returned if base or target object cannot be read.
-func GetDelta(base, target plumbing.EncodedObject) (plumbing.EncodedObject, error) {
- br, err := base.Reader()
- if err != nil {
- return nil, err
- }
- tr, err := target.Reader()
- if err != nil {
- return nil, err
- }
-
- bb, err := ioutil.ReadAll(br)
- if err != nil {
- return nil, err
- }
-
- tb, err := ioutil.ReadAll(tr)
- if err != nil {
- return nil, err
- }
-
- db := DiffDelta(bb, tb)
- delta := &plumbing.MemoryObject{}
- _, err = delta.Write(db)
- if err != nil {
- return nil, err
- }
-
- delta.SetSize(int64(len(db)))
- delta.SetType(plumbing.OFSDeltaObject)
-
- return delta, nil
-}
-
-// DiffDelta returns the delta that transforms baseBuf into targetBuf.
-func DiffDelta(baseBuf []byte, targetBuf []byte) []byte {
- var outBuff []byte
-
- outBuff = append(outBuff, deltaEncodeSize(len(baseBuf))...)
- outBuff = append(outBuff, deltaEncodeSize(len(targetBuf))...)
-
- sm := newMatcher(baseBuf, targetBuf)
- for _, op := range sm.GetOpCodes() {
- switch {
- case op.Tag == tagEqual:
- copyStart := op.I1
- copyLen := op.I2 - op.I1
- for {
- if copyLen <= 0 {
- break
- }
- var toCopy int
- if copyLen < maxCopyLen {
- toCopy = copyLen
- } else {
- toCopy = maxCopyLen
- }
-
- outBuff = append(outBuff, encodeCopyOperation(copyStart, toCopy)...)
- copyStart += toCopy
- copyLen -= toCopy
- }
- case op.Tag == tagReplace || op.Tag == tagInsert:
- s := op.J2 - op.J1
- o := op.J1
- for {
- if s <= 127 {
- break
- }
- outBuff = append(outBuff, byte(127))
- outBuff = append(outBuff, targetBuf[o:o+127]...)
- s -= 127
- o += 127
- }
- outBuff = append(outBuff, byte(s))
- outBuff = append(outBuff, targetBuf[o:o+s]...)
- }
- }
-
- return outBuff
-}
-
-func deltaEncodeSize(size int) []byte {
- var ret []byte
- c := size & 0x7f
- size >>= 7
- for {
- if size == 0 {
- break
- }
-
- ret = append(ret, byte(c|0x80))
- c = size & 0x7f
- size >>= 7
- }
- ret = append(ret, byte(c))
-
- return ret
-}
-
-func encodeCopyOperation(offset, length int) []byte {
- code := 0x80
- var opcodes []byte
-
- var i uint
- for i = 0; i < 4; i++ {
- f := 0xff << (i * 8)
- if offset&f != 0 {
- opcodes = append(opcodes, byte(offset&f>>(i*8)))
- code |= 0x01 << i
- }
- }
-
- for i = 0; i < 3; i++ {
- f := 0xff << (i * 8)
- if length&f != 0 {
- opcodes = append(opcodes, byte(length&f>>(i*8)))
- code |= 0x10 << i
- }
- }
-
- return append([]byte{byte(code)}, opcodes...)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/doc.go
deleted file mode 100644
index 2882a7f378268ec96039ef98e78fea9463d4d26b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/doc.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// Package packfile implements encoding and decoding of packfile format.
-//
-// == pack-*.pack files have the following format:
-//
-// - A header appears at the beginning and consists of the following:
-//
-// 4-byte signature:
-// The signature is: {'P', 'A', 'C', 'K'}
-//
-// 4-byte version number (network byte order):
-// GIT currently accepts version number 2 or 3 but
-// generates version 2 only.
-//
-// 4-byte number of objects contained in the pack (network byte order)
-//
-// Observation: we cannot have more than 4G versions ;-) and
-// more than 4G objects in a pack.
-//
-// - The header is followed by number of object entries, each of
-// which looks like this:
-//
-// (undeltified representation)
-// n-byte type and length (3-bit type, (n-1)*7+4-bit length)
-// compressed data
-//
-// (deltified representation)
-// n-byte type and length (3-bit type, (n-1)*7+4-bit length)
-// 20-byte base object name
-// compressed delta data
-//
-// Observation: length of each object is encoded in a variable
-// length format and is not constrained to 32-bit or anything.
-//
-// - The trailer records 20-byte SHA1 checksum of all of the above.
-//
-//
-// Source:
-// https://www.kernel.org/pub/software/scm/git/docs/v1.7.5/technical/pack-protocol.txt
-package packfile
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/encoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/encoder.go
deleted file mode 100644
index ae8375247912dad219fe52485e7254e47c9325e5..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/encoder.go
+++ /dev/null
@@ -1,183 +0,0 @@
-package packfile
-
-import (
- "compress/zlib"
- "crypto/sha1"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-// Encoder gets the data from the storage and write it into the writer in PACK
-// format
-type Encoder struct {
- selector *deltaSelector
- w *offsetWriter
- zw *zlib.Writer
- hasher plumbing.Hasher
- offsets map[plumbing.Hash]int64
- useRefDeltas bool
-}
-
-// NewEncoder creates a new packfile encoder using a specific Writer and
-// EncodedObjectStorer. By default deltas used to generate the packfile will be
-// OFSDeltaObject. To use Reference deltas, set useRefDeltas to true.
-func NewEncoder(w io.Writer, s storer.EncodedObjectStorer, useRefDeltas bool) *Encoder {
- h := plumbing.Hasher{
- Hash: sha1.New(),
- }
- mw := io.MultiWriter(w, h)
- ow := newOffsetWriter(mw)
- zw := zlib.NewWriter(mw)
- return &Encoder{
- selector: newDeltaSelector(s),
- w: ow,
- zw: zw,
- hasher: h,
- offsets: make(map[plumbing.Hash]int64),
- useRefDeltas: useRefDeltas,
- }
-}
-
-// Encode creates a packfile containing all the objects referenced in hashes
-// and writes it to the writer in the Encoder.
-func (e *Encoder) Encode(hashes []plumbing.Hash) (plumbing.Hash, error) {
- objects, err := e.selector.ObjectsToPack(hashes)
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- return e.encode(objects)
-}
-
-func (e *Encoder) encode(objects []*ObjectToPack) (plumbing.Hash, error) {
- if err := e.head(len(objects)); err != nil {
- return plumbing.ZeroHash, err
- }
-
- for _, o := range objects {
- if err := e.entry(o); err != nil {
- return plumbing.ZeroHash, err
- }
- }
-
- return e.footer()
-}
-
-func (e *Encoder) head(numEntries int) error {
- return binary.Write(
- e.w,
- signature,
- int32(VersionSupported),
- int32(numEntries),
- )
-}
-
-func (e *Encoder) entry(o *ObjectToPack) error {
- offset := e.w.Offset()
-
- if o.IsDelta() {
- if err := e.writeDeltaHeader(o, offset); err != nil {
- return err
- }
- } else {
- if err := e.entryHead(o.Object.Type(), o.Object.Size()); err != nil {
- return err
- }
- }
-
- // Save the position using the original hash, maybe a delta will need it
- e.offsets[o.Original.Hash()] = offset
-
- e.zw.Reset(e.w)
- or, err := o.Object.Reader()
- if err != nil {
- return err
- }
- _, err = io.Copy(e.zw, or)
- if err != nil {
- return err
- }
-
- return e.zw.Close()
-}
-
-func (e *Encoder) writeDeltaHeader(o *ObjectToPack, offset int64) error {
- // Write offset deltas by default
- t := plumbing.OFSDeltaObject
- if e.useRefDeltas {
- t = plumbing.REFDeltaObject
- }
-
- if err := e.entryHead(t, o.Object.Size()); err != nil {
- return err
- }
-
- if e.useRefDeltas {
- return e.writeRefDeltaHeader(o.Base.Original.Hash())
- } else {
- return e.writeOfsDeltaHeader(offset, o.Base.Original.Hash())
- }
-}
-
-func (e *Encoder) writeRefDeltaHeader(base plumbing.Hash) error {
- return binary.Write(e.w, base)
-}
-
-func (e *Encoder) writeOfsDeltaHeader(deltaOffset int64, base plumbing.Hash) error {
- // because it is an offset delta, we need the base
- // object position
- offset, ok := e.offsets[base]
- if !ok {
- return fmt.Errorf("delta base not found. Hash: %v", base)
- }
-
- return binary.WriteVariableWidthInt(e.w, deltaOffset-offset)
-}
-
-func (e *Encoder) entryHead(typeNum plumbing.ObjectType, size int64) error {
- t := int64(typeNum)
- header := []byte{}
- c := (t << firstLengthBits) | (size & maskFirstLength)
- size >>= firstLengthBits
- for {
- if size == 0 {
- break
- }
- header = append(header, byte(c|maskContinue))
- c = size & int64(maskLength)
- size >>= lengthBits
- }
-
- header = append(header, byte(c))
- _, err := e.w.Write(header)
-
- return err
-}
-
-func (e *Encoder) footer() (plumbing.Hash, error) {
- h := e.hasher.Sum()
- return h, binary.Write(e.w, h)
-}
-
-type offsetWriter struct {
- w io.Writer
- offset int64
-}
-
-func newOffsetWriter(w io.Writer) *offsetWriter {
- return &offsetWriter{w: w}
-}
-
-func (ow *offsetWriter) Write(p []byte) (n int, err error) {
- n, err = ow.w.Write(p)
- ow.offset += int64(n)
- return n, err
-}
-
-func (ow *offsetWriter) Offset() int64 {
- return ow.offset
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/error.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/error.go
deleted file mode 100644
index c0b9163313109ee34b2aa0503de3cb337d8bc900..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/error.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package packfile
-
-import "fmt"
-
-// Error specifies errors returned during packfile parsing.
-type Error struct {
- reason, details string
-}
-
-// NewError returns a new error.
-func NewError(reason string) *Error {
- return &Error{reason: reason}
-}
-
-// Error returns a text representation of the error.
-func (e *Error) Error() string {
- if e.details == "" {
- return e.reason
- }
-
- return fmt.Sprintf("%s: %s", e.reason, e.details)
-}
-
-// AddDetails adds details to an error, with additional text.
-func (e *Error) AddDetails(format string, args ...interface{}) *Error {
- return &Error{
- reason: e.reason,
- details: fmt.Sprintf(format, args...),
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/object_pack.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/object_pack.go
deleted file mode 100644
index a3e99c031b0dbcebefdf604e7e885360d9bcbf28..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/object_pack.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package packfile
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-// ObjectToPack is a representation of an object that is going to be into a
-// pack file.
-type ObjectToPack struct {
- // The main object to pack, it could be any object, including deltas
- Object plumbing.EncodedObject
- // Base is the object that a delta is based on (it could be also another delta).
- // If the main object is not a delta, Base will be null
- Base *ObjectToPack
- // Original is the object that we can generate applying the delta to
- // Base, or the same object as EncodedObject in the case of a non-delta
- // object.
- Original plumbing.EncodedObject
- // Depth is the amount of deltas needed to resolve to obtain Original
- // (delta based on delta based on ...)
- Depth int
-}
-
-// newObjectToPack creates a correct ObjectToPack based on a non-delta object
-func newObjectToPack(o plumbing.EncodedObject) *ObjectToPack {
- return &ObjectToPack{
- Object: o,
- Original: o,
- }
-}
-
-// newDeltaObjectToPack creates a correct ObjectToPack for a delta object, based on
-// his base (could be another delta), the delta target (in this case called original),
-// and the delta Object itself
-func newDeltaObjectToPack(base *ObjectToPack, original, delta plumbing.EncodedObject) *ObjectToPack {
- return &ObjectToPack{
- Object: delta,
- Base: base,
- Original: original,
- Depth: base.Depth + 1,
- }
-}
-
-func (o *ObjectToPack) IsDelta() bool {
- if o.Base != nil {
- return true
- }
-
- return false
-}
-
-func (o *ObjectToPack) SetDelta(base *ObjectToPack, delta plumbing.EncodedObject) {
- o.Object = delta
- o.Base = base
- o.Depth = base.Depth + 1
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/patch_delta.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/patch_delta.go
deleted file mode 100644
index 840f84098f6ccc77a9d8eff09fb5c84acb58de16..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/patch_delta.go
+++ /dev/null
@@ -1,181 +0,0 @@
-package packfile
-
-import (
- "io/ioutil"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-// See https://github.com/git/git/blob/49fa3dc76179e04b0833542fa52d0f287a4955ac/delta.h
-// https://github.com/git/git/blob/c2c5f6b1e479f2c38e0e01345350620944e3527f/patch-delta.c,
-// and https://github.com/tarruda/node-git-core/blob/master/src/js/delta.js
-// for details about the delta format.
-
-const deltaSizeMin = 4
-
-// ApplyDelta writes to target the result of applying the modification deltas in delta to base.
-func ApplyDelta(target, base plumbing.EncodedObject, delta []byte) error {
- r, err := base.Reader()
- if err != nil {
- return err
- }
-
- w, err := target.Writer()
- if err != nil {
- return err
- }
-
- src, err := ioutil.ReadAll(r)
- if err != nil {
- return err
- }
-
- dst := PatchDelta(src, delta)
- target.SetSize(int64(len(dst)))
-
- if _, err := w.Write(dst); err != nil {
- return err
- }
-
- return nil
-}
-
-// PatchDelta returns the result of applying the modification deltas in delta to src.
-func PatchDelta(src, delta []byte) []byte {
- if len(delta) < deltaSizeMin {
- return nil
- }
-
- srcSz, delta := decodeLEB128(delta)
- if srcSz != uint(len(src)) {
- return nil
- }
-
- targetSz, delta := decodeLEB128(delta)
- remainingTargetSz := targetSz
-
- var dest []byte
- var cmd byte
- for {
- cmd = delta[0]
- delta = delta[1:]
- if isCopyFromSrc(cmd) {
- var offset, sz uint
- offset, delta = decodeOffset(cmd, delta)
- sz, delta = decodeSize(cmd, delta)
- if invalidSize(sz, targetSz) ||
- invalidOffsetSize(offset, sz, srcSz) {
- break
- }
- dest = append(dest, src[offset:offset+sz]...)
- remainingTargetSz -= sz
- } else if isCopyFromDelta(cmd) {
- sz := uint(cmd) // cmd is the size itself
- if invalidSize(sz, targetSz) {
- break
- }
- dest = append(dest, delta[0:sz]...)
- remainingTargetSz -= sz
- delta = delta[sz:]
- } else {
- return nil
- }
-
- if remainingTargetSz <= 0 {
- break
- }
- }
-
- return dest
-}
-
-// Decodes a number encoded as an unsigned LEB128 at the start of some
-// binary data and returns the decoded number and the rest of the
-// stream.
-//
-// This must be called twice on the delta data buffer, first to get the
-// expected source buffer size, and again to get the target buffer size.
-func decodeLEB128(input []byte) (uint, []byte) {
- var num, sz uint
- var b byte
- for {
- b = input[sz]
- num |= (uint(b) & payload) << (sz * 7) // concats 7 bits chunks
- sz++
-
- if uint(b)&continuation == 0 || sz == uint(len(input)) {
- break
- }
- }
-
- return num, input[sz:]
-}
-
-const (
- payload = 0x7f // 0111 1111
- continuation = 0x80 // 1000 0000
-)
-
-func isCopyFromSrc(cmd byte) bool {
- return (cmd & 0x80) != 0
-}
-
-func isCopyFromDelta(cmd byte) bool {
- return (cmd&0x80) == 0 && cmd != 0
-}
-
-func decodeOffset(cmd byte, delta []byte) (uint, []byte) {
- var offset uint
- if (cmd & 0x01) != 0 {
- offset = uint(delta[0])
- delta = delta[1:]
- }
- if (cmd & 0x02) != 0 {
- offset |= uint(delta[0]) << 8
- delta = delta[1:]
- }
- if (cmd & 0x04) != 0 {
- offset |= uint(delta[0]) << 16
- delta = delta[1:]
- }
- if (cmd & 0x08) != 0 {
- offset |= uint(delta[0]) << 24
- delta = delta[1:]
- }
-
- return offset, delta
-}
-
-func decodeSize(cmd byte, delta []byte) (uint, []byte) {
- var sz uint
- if (cmd & 0x10) != 0 {
- sz = uint(delta[0])
- delta = delta[1:]
- }
- if (cmd & 0x20) != 0 {
- sz |= uint(delta[0]) << 8
- delta = delta[1:]
- }
- if (cmd & 0x40) != 0 {
- sz |= uint(delta[0]) << 16
- delta = delta[1:]
- }
- if sz == 0 {
- sz = 0x10000
- }
-
- return sz, delta
-}
-
-func invalidSize(sz, targetSz uint) bool {
- return sz > targetSz
-}
-
-func invalidOffsetSize(offset, sz, srcSz uint) bool {
- return sumOverflows(offset, sz) ||
- offset+sz > srcSz
-}
-
-func sumOverflows(a, b uint) bool {
- return a+b < a
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/scanner.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/scanner.go
deleted file mode 100644
index d8cece6776b01a877cf364380303fdd841bd4050..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/packfile/scanner.go
+++ /dev/null
@@ -1,419 +0,0 @@
-package packfile
-
-import (
- "bufio"
- "bytes"
- "compress/zlib"
- "fmt"
- "hash"
- "hash/crc32"
- "io"
- "io/ioutil"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/utils/binary"
-)
-
-var (
- // ErrEmptyPackfile is returned by ReadHeader when no data is found in the packfile
- ErrEmptyPackfile = NewError("empty packfile")
- // ErrBadSignature is returned by ReadHeader when the signature in the packfile is incorrect.
- ErrBadSignature = NewError("malformed pack file signature")
- // ErrUnsupportedVersion is returned by ReadHeader when the packfile version is
- // different than VersionSupported.
- ErrUnsupportedVersion = NewError("unsupported packfile version")
- // ErrSeekNotSupported returned if seek is not support
- ErrSeekNotSupported = NewError("not seek support")
-)
-
-// ObjectHeader contains the information related to the object, this information
-// is collected from the previous bytes to the content of the object.
-type ObjectHeader struct {
- Type plumbing.ObjectType
- Offset int64
- Length int64
- Reference plumbing.Hash
- OffsetReference int64
-}
-
-type Scanner struct {
- r reader
- zr readerResetter
- crc hash.Hash32
-
- // pendingObject is used to detect if an object has been read, or still
- // is waiting to be read
- pendingObject *ObjectHeader
- version, objects uint32
-
- // lsSeekable says if this scanner can do Seek or not, to have a Scanner
- // seekable a r implementing io.Seeker is required
- IsSeekable bool
-}
-
-// NewScanner returns a new Scanner based on a reader, if the given reader
-// implements io.ReadSeeker the Scanner will be also Seekable
-func NewScanner(r io.Reader) *Scanner {
- seeker, ok := r.(io.ReadSeeker)
- if !ok {
- seeker = &trackableReader{Reader: r}
- }
-
- crc := crc32.NewIEEE()
- return &Scanner{
- r: &teeReader{
- newByteReadSeeker(seeker),
- crc,
- },
- crc: crc,
- IsSeekable: ok,
- }
-}
-
-// Header reads the whole packfile header (signature, version and object count).
-// It returns the version and the object count and performs checks on the
-// validity of the signature and the version fields.
-func (s *Scanner) Header() (version, objects uint32, err error) {
- if s.version != 0 {
- return s.version, s.objects, nil
- }
-
- sig, err := s.readSignature()
- if err != nil {
- if err == io.EOF {
- err = ErrEmptyPackfile
- }
-
- return
- }
-
- if !s.isValidSignature(sig) {
- err = ErrBadSignature
- return
- }
-
- version, err = s.readVersion()
- s.version = version
- if err != nil {
- return
- }
-
- if !s.isSupportedVersion(version) {
- err = ErrUnsupportedVersion.AddDetails("%d", version)
- return
- }
-
- objects, err = s.readCount()
- s.objects = objects
- return
-}
-
-// readSignature reads an returns the signature field in the packfile.
-func (s *Scanner) readSignature() ([]byte, error) {
- var sig = make([]byte, 4)
- if _, err := io.ReadFull(s.r, sig); err != nil {
- return []byte{}, err
- }
-
- return sig, nil
-}
-
-// isValidSignature returns if sig is a valid packfile signature.
-func (s *Scanner) isValidSignature(sig []byte) bool {
- return bytes.Equal(sig, signature)
-}
-
-// readVersion reads and returns the version field of a packfile.
-func (s *Scanner) readVersion() (uint32, error) {
- return binary.ReadUint32(s.r)
-}
-
-// isSupportedVersion returns whether version v is supported by the parser.
-// The current supported version is VersionSupported, defined above.
-func (s *Scanner) isSupportedVersion(v uint32) bool {
- return v == VersionSupported
-}
-
-// readCount reads and returns the count of objects field of a packfile.
-func (s *Scanner) readCount() (uint32, error) {
- return binary.ReadUint32(s.r)
-}
-
-// NextObjectHeader returns the ObjectHeader for the next object in the reader
-func (s *Scanner) NextObjectHeader() (*ObjectHeader, error) {
- if err := s.doPending(); err != nil {
- return nil, err
- }
-
- s.crc.Reset()
-
- h := &ObjectHeader{}
- s.pendingObject = h
-
- var err error
- h.Offset, err = s.r.Seek(0, io.SeekCurrent)
- if err != nil {
- return nil, err
- }
-
- h.Type, h.Length, err = s.readObjectTypeAndLength()
- if err != nil {
- return nil, err
- }
-
- switch h.Type {
- case plumbing.OFSDeltaObject:
- no, err := binary.ReadVariableWidthInt(s.r)
- if err != nil {
- return nil, err
- }
-
- h.OffsetReference = h.Offset - no
- case plumbing.REFDeltaObject:
- var err error
- h.Reference, err = binary.ReadHash(s.r)
- if err != nil {
- return nil, err
- }
- }
-
- return h, nil
-}
-
-func (s *Scanner) doPending() error {
- if s.version == 0 {
- var err error
- s.version, s.objects, err = s.Header()
- if err != nil {
- return err
- }
- }
-
- return s.discardObjectIfNeeded()
-}
-
-func (s *Scanner) discardObjectIfNeeded() error {
- if s.pendingObject == nil {
- return nil
- }
-
- h := s.pendingObject
- n, _, err := s.NextObject(ioutil.Discard)
- if err != nil {
- return err
- }
-
- if n != h.Length {
- return fmt.Errorf(
- "error discarding object, discarded %d, expected %d",
- n, h.Length,
- )
- }
-
- return nil
-}
-
-// ReadObjectTypeAndLength reads and returns the object type and the
-// length field from an object entry in a packfile.
-func (s *Scanner) readObjectTypeAndLength() (plumbing.ObjectType, int64, error) {
- t, c, err := s.readType()
- if err != nil {
- return t, 0, err
- }
-
- l, err := s.readLength(c)
-
- return t, l, err
-}
-
-func (s *Scanner) readType() (plumbing.ObjectType, byte, error) {
- var c byte
- var err error
- if c, err = s.r.ReadByte(); err != nil {
- return plumbing.ObjectType(0), 0, err
- }
-
- typ := parseType(c)
-
- return typ, c, nil
-}
-
-func parseType(b byte) plumbing.ObjectType {
- return plumbing.ObjectType((b & maskType) >> firstLengthBits)
-}
-
-// the length is codified in the last 4 bits of the first byte and in
-// the last 7 bits of subsequent bytes. Last byte has a 0 MSB.
-func (s *Scanner) readLength(first byte) (int64, error) {
- length := int64(first & maskFirstLength)
-
- c := first
- shift := firstLengthBits
- var err error
- for c&maskContinue > 0 {
- if c, err = s.r.ReadByte(); err != nil {
- return 0, err
- }
-
- length += int64(c&maskLength) << shift
- shift += lengthBits
- }
-
- return length, nil
-}
-
-// NextObject writes the content of the next object into the reader, returns
-// the number of bytes written, the CRC32 of the content and an error, if any
-func (s *Scanner) NextObject(w io.Writer) (written int64, crc32 uint32, err error) {
- defer s.crc.Reset()
-
- s.pendingObject = nil
- written, err = s.copyObject(w)
- crc32 = s.crc.Sum32()
- return
-}
-
-// ReadRegularObject reads and write a non-deltified object
-// from it zlib stream in an object entry in the packfile.
-func (s *Scanner) copyObject(w io.Writer) (int64, error) {
- var err error
- if s.zr == nil {
- zr, err := zlib.NewReader(s.r)
- if err != nil {
- return 0, fmt.Errorf("zlib initialization error: %s", err)
- }
-
- s.zr = zr.(readerResetter)
- } else {
- if err := s.zr.Reset(s.r, nil); err != nil {
- return 0, fmt.Errorf("zlib reset error: %s", err)
- }
- }
-
- defer func() {
- closeErr := s.zr.Close()
- if err == nil {
- err = closeErr
- }
- }()
-
- return io.Copy(w, s.zr)
-}
-
-// Seek sets a new offset from start, returns the old position before the change
-func (s *Scanner) Seek(offset int64) (previous int64, err error) {
- // if seeking we assume that you are not interested on the header
- if s.version == 0 {
- s.version = VersionSupported
- }
-
- previous, err = s.r.Seek(0, io.SeekCurrent)
- if err != nil {
- return -1, err
- }
-
- _, err = s.r.Seek(offset, io.SeekStart)
- return previous, err
-}
-
-// Checksum returns the checksum of the packfile
-func (s *Scanner) Checksum() (plumbing.Hash, error) {
- err := s.discardObjectIfNeeded()
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- return binary.ReadHash(s.r)
-}
-
-// Close reads the reader until io.EOF
-func (s *Scanner) Close() error {
- _, err := io.Copy(ioutil.Discard, s.r)
- return err
-}
-
-type trackableReader struct {
- count int64
- io.Reader
-}
-
-// Read reads up to len(p) bytes into p.
-func (r *trackableReader) Read(p []byte) (n int, err error) {
- n, err = r.Reader.Read(p)
- r.count += int64(n)
-
- return
-}
-
-// Seek only supports io.SeekCurrent, any other operation fails
-func (r *trackableReader) Seek(offset int64, whence int) (int64, error) {
- if whence != io.SeekCurrent {
- return -1, ErrSeekNotSupported
- }
-
- return r.count, nil
-}
-
-func newByteReadSeeker(r io.ReadSeeker) *bufferedSeeker {
- return &bufferedSeeker{
- r: r,
- Reader: *bufio.NewReader(r),
- }
-}
-
-type bufferedSeeker struct {
- r io.ReadSeeker
- bufio.Reader
-}
-
-func (r *bufferedSeeker) Seek(offset int64, whence int) (int64, error) {
- if whence == io.SeekCurrent {
- current, err := r.r.Seek(offset, whence)
- if err != nil {
- return current, err
- }
-
- return current - int64(r.Buffered()), nil
- }
-
- defer r.Reader.Reset(r.r)
- return r.r.Seek(offset, whence)
-}
-
-type readerResetter interface {
- io.ReadCloser
- zlib.Resetter
-}
-
-type reader interface {
- io.Reader
- io.ByteReader
- io.Seeker
-}
-
-type teeReader struct {
- reader
- w hash.Hash32
-}
-
-func (r *teeReader) Read(p []byte) (n int, err error) {
- n, err = r.reader.Read(p)
- if n > 0 {
- if n, err := r.w.Write(p[:n]); err != nil {
- return n, err
- }
- }
- return
-}
-
-func (r *teeReader) ReadByte() (b byte, err error) {
- b, err = r.reader.ReadByte()
- if err == nil {
- _, err := r.w.Write([]byte{b})
- if err != nil {
- return 0, err
- }
- }
-
- return
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/encoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/encoder.go
deleted file mode 100644
index 797b813c6b4ce6c838812a1bc9c8a0246eb64c35..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/encoder.go
+++ /dev/null
@@ -1,125 +0,0 @@
-// Package pktline implements reading payloads form pkt-lines and encoding
-// pkt-lines from payloads.
-package pktline
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
-)
-
-// An Encoder writes pkt-lines to an output stream.
-type Encoder struct {
- w io.Writer
-}
-
-const (
- // MaxPayloadSize is the maximum payload size of a pkt-line in bytes.
- MaxPayloadSize = 65516
-)
-
-var (
- // FlushPkt are the contents of a flush-pkt pkt-line.
- FlushPkt = []byte{'0', '0', '0', '0'}
- // Flush is the payload to use with the Encode method to encode a flush-pkt.
- Flush = []byte{}
- // FlushString is the payload to use with the EncodeString method to encode a flush-pkt.
- FlushString = ""
- // ErrPayloadTooLong is returned by the Encode methods when any of the
- // provided payloads is bigger than MaxPayloadSize.
- ErrPayloadTooLong = errors.New("payload is too long")
-)
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{
- w: w,
- }
-}
-
-// Flush encodes a flush-pkt to the output stream.
-func (e *Encoder) Flush() error {
- _, err := e.w.Write(FlushPkt)
- return err
-}
-
-// Encode encodes a pkt-line with the payload specified and write it to
-// the output stream. If several payloads are specified, each of them
-// will get streamed in their own pkt-lines.
-func (e *Encoder) Encode(payloads ...[]byte) error {
- for _, p := range payloads {
- if err := e.encodeLine(p); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeLine(p []byte) error {
- if len(p) > MaxPayloadSize {
- return ErrPayloadTooLong
- }
-
- if bytes.Equal(p, Flush) {
- if err := e.Flush(); err != nil {
- return err
- }
- return nil
- }
-
- n := len(p) + 4
- if _, err := e.w.Write(asciiHex16(n)); err != nil {
- return err
- }
- if _, err := e.w.Write(p); err != nil {
- return err
- }
-
- return nil
-}
-
-// Returns the hexadecimal ascii representation of the 16 less
-// significant bits of n. The length of the returned slice will always
-// be 4. Example: if n is 1234 (0x4d2), the return value will be
-// []byte{'0', '4', 'd', '2'}.
-func asciiHex16(n int) []byte {
- var ret [4]byte
- ret[0] = byteToASCIIHex(byte(n & 0xf000 >> 12))
- ret[1] = byteToASCIIHex(byte(n & 0x0f00 >> 8))
- ret[2] = byteToASCIIHex(byte(n & 0x00f0 >> 4))
- ret[3] = byteToASCIIHex(byte(n & 0x000f))
-
- return ret[:]
-}
-
-// turns a byte into its hexadecimal ascii representation. Example:
-// from 11 (0xb) to 'b'.
-func byteToASCIIHex(n byte) byte {
- if n < 10 {
- return '0' + n
- }
-
- return 'a' - 10 + n
-}
-
-// EncodeString works similarly as Encode but payloads are specified as strings.
-func (e *Encoder) EncodeString(payloads ...string) error {
- for _, p := range payloads {
- if err := e.Encode([]byte(p)); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// Encodef encodes a single pkt-line with the payload formatted as
-// the format specifier. The rest of the arguments will be used in
-// the format string.
-func (e *Encoder) Encodef(format string, a ...interface{}) error {
- return e.EncodeString(
- fmt.Sprintf(format, a...),
- )
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/scanner.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/scanner.go
deleted file mode 100644
index 4af254f002042b546fed15ccd08cb3c40adc5bfb..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/format/pktline/scanner.go
+++ /dev/null
@@ -1,134 +0,0 @@
-package pktline
-
-import (
- "errors"
- "io"
-)
-
-const (
- lenSize = 4
-)
-
-// ErrInvalidPktLen is returned by Err() when an invalid pkt-len is found.
-var ErrInvalidPktLen = errors.New("invalid pkt-len found")
-
-// Scanner provides a convenient interface for reading the payloads of a
-// series of pkt-lines. It takes an io.Reader providing the source,
-// which then can be tokenized through repeated calls to the Scan
-// method.
-//
-// After each Scan call, the Bytes method will return the payload of the
-// corresponding pkt-line on a shared buffer, which will be 65516 bytes
-// or smaller. Flush pkt-lines are represented by empty byte slices.
-//
-// Scanning stops at EOF or the first I/O error.
-type Scanner struct {
- r io.Reader // The reader provided by the client
- err error // Sticky error
- payload []byte // Last pkt-payload
- len [lenSize]byte // Last pkt-len
-}
-
-// NewScanner returns a new Scanner to read from r.
-func NewScanner(r io.Reader) *Scanner {
- return &Scanner{
- r: r,
- }
-}
-
-// Err returns the first error encountered by the Scanner.
-func (s *Scanner) Err() error {
- return s.err
-}
-
-// Scan advances the Scanner to the next pkt-line, whose payload will
-// then be available through the Bytes method. Scanning stops at EOF
-// or the first I/O error. After Scan returns false, the Err method
-// will return any error that occurred during scanning, except that if
-// it was io.EOF, Err will return nil.
-func (s *Scanner) Scan() bool {
- var l int
- l, s.err = s.readPayloadLen()
- if s.err == io.EOF {
- s.err = nil
- return false
- }
- if s.err != nil {
- return false
- }
-
- if cap(s.payload) < l {
- s.payload = make([]byte, 0, l)
- }
-
- if _, s.err = io.ReadFull(s.r, s.payload[:l]); s.err != nil {
- return false
- }
- s.payload = s.payload[:l]
-
- return true
-}
-
-// Bytes returns the most recent payload generated by a call to Scan.
-// The underlying array may point to data that will be overwritten by a
-// subsequent call to Scan. It does no allocation.
-func (s *Scanner) Bytes() []byte {
- return s.payload
-}
-
-// Method readPayloadLen returns the payload length by reading the
-// pkt-len and subtracting the pkt-len size.
-func (s *Scanner) readPayloadLen() (int, error) {
- if _, err := io.ReadFull(s.r, s.len[:]); err != nil {
- if err == io.ErrUnexpectedEOF {
- return 0, ErrInvalidPktLen
- }
-
- return 0, err
- }
-
- n, err := hexDecode(s.len)
- if err != nil {
- return 0, err
- }
-
- switch {
- case n == 0:
- return 0, nil
- case n <= lenSize:
- return 0, ErrInvalidPktLen
- case n > MaxPayloadSize+lenSize:
- return 0, ErrInvalidPktLen
- default:
- return n - lenSize, nil
- }
-}
-
-// Turns the hexadecimal representation of a number in a byte slice into
-// a number. This function substitute strconv.ParseUint(string(buf), 16,
-// 16) and/or hex.Decode, to avoid generating new strings, thus helping the
-// GC.
-func hexDecode(buf [lenSize]byte) (int, error) {
- var ret int
- for i := 0; i < lenSize; i++ {
- n, err := asciiHexToByte(buf[i])
- if err != nil {
- return 0, ErrInvalidPktLen
- }
- ret = 16*ret + int(n)
- }
- return ret, nil
-}
-
-// turns the hexadecimal ascii representation of a byte into its
-// numerical value. Example: from 'b' to 11 (0xb).
-func asciiHexToByte(b byte) (byte, error) {
- switch {
- case b >= '0' && b <= '9':
- return b - '0', nil
- case b >= 'a' && b <= 'f':
- return b - 'a' + 10, nil
- default:
- return 0, ErrInvalidPktLen
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/hash.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/hash.go
deleted file mode 100644
index 8e60877894abba0e00c40ba5d68f0fdc78a88d8f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/hash.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package plumbing
-
-import (
- "bytes"
- "crypto/sha1"
- "encoding/hex"
- "hash"
- "sort"
- "strconv"
-)
-
-// Hash SHA1 hased content
-type Hash [20]byte
-
-// ZeroHash is Hash with value zero
-var ZeroHash Hash
-
-// ComputeHash compute the hash for a given ObjectType and content
-func ComputeHash(t ObjectType, content []byte) Hash {
- h := NewHasher(t, int64(len(content)))
- h.Write(content)
- return h.Sum()
-}
-
-// NewHash return a new Hash from a hexadecimal hash representation
-func NewHash(s string) Hash {
- b, _ := hex.DecodeString(s)
-
- var h Hash
- copy(h[:], b)
-
- return h
-}
-
-func (h Hash) IsZero() bool {
- var empty Hash
- return h == empty
-}
-
-func (h Hash) String() string {
- return hex.EncodeToString(h[:])
-}
-
-type Hasher struct {
- hash.Hash
-}
-
-func NewHasher(t ObjectType, size int64) Hasher {
- h := Hasher{sha1.New()}
- h.Write(t.Bytes())
- h.Write([]byte(" "))
- h.Write([]byte(strconv.FormatInt(size, 10)))
- h.Write([]byte{0})
- return h
-}
-
-func (h Hasher) Sum() (hash Hash) {
- copy(hash[:], h.Hash.Sum(nil))
- return
-}
-
-// HashesSort sorts a slice of Hashes in increasing order.
-func HashesSort(a []Hash) {
- sort.Sort(HashSlice(a))
-}
-
-// HashSlice attaches the methods of sort.Interface to []Hash, sorting in
-// increasing order.
-type HashSlice []Hash
-
-func (p HashSlice) Len() int { return len(p) }
-func (p HashSlice) Less(i, j int) bool { return bytes.Compare(p[i][:], p[j][:]) < 0 }
-func (p HashSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/memory.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/memory.go
deleted file mode 100644
index c65ce1f643663a0ddbb50188594dfa0144d774c1..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/memory.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package plumbing
-
-import (
- "bytes"
- "io"
- "io/ioutil"
-)
-
-// MemoryObject on memory Object implementation
-type MemoryObject struct {
- t ObjectType
- h Hash
- cont []byte
- sz int64
-}
-
-// Hash return the object Hash, the hash is calculated on-the-fly the first
-// time is called, the subsequent calls the same Hash is returned even if the
-// type or the content has changed. The Hash is only generated if the size of
-// the content is exactly the Object.Size
-func (o *MemoryObject) Hash() Hash {
- if o.h == ZeroHash && int64(len(o.cont)) == o.sz {
- o.h = ComputeHash(o.t, o.cont)
- }
-
- return o.h
-}
-
-// Type return the ObjectType
-func (o *MemoryObject) Type() ObjectType { return o.t }
-
-// SetType sets the ObjectType
-func (o *MemoryObject) SetType(t ObjectType) { o.t = t }
-
-// Size return the size of the object
-func (o *MemoryObject) Size() int64 { return o.sz }
-
-// SetSize set the object size, a content of the given size should be written
-// afterwards
-func (o *MemoryObject) SetSize(s int64) { o.sz = s }
-
-// Reader returns a ObjectReader used to read the object's content.
-func (o *MemoryObject) Reader() (io.ReadCloser, error) {
- return ioutil.NopCloser(bytes.NewBuffer(o.cont)), nil
-}
-
-// Writer returns a ObjectWriter used to write the object's content.
-func (o *MemoryObject) Writer() (io.WriteCloser, error) {
- return o, nil
-}
-
-func (o *MemoryObject) Write(p []byte) (n int, err error) {
- o.cont = append(o.cont, p...)
- return len(p), nil
-}
-
-// Close releases any resources consumed by the object when it is acting as a
-// ObjectWriter.
-func (o *MemoryObject) Close() error { return nil }
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object.go
deleted file mode 100644
index 3304da278cd8e71e9dbc51acc386b584c11dc030..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// package plumbing implement the core interfaces and structs used by go-git
-package plumbing
-
-import (
- "errors"
- "io"
-)
-
-var (
- ErrObjectNotFound = errors.New("object not found")
- // ErrInvalidType is returned when an invalid object type is provided.
- ErrInvalidType = errors.New("invalid object type")
-)
-
-// Object is a generic representation of any git object
-type EncodedObject interface {
- Hash() Hash
- Type() ObjectType
- SetType(ObjectType)
- Size() int64
- SetSize(int64)
- Reader() (io.ReadCloser, error)
- Writer() (io.WriteCloser, error)
-}
-
-// ObjectType internal object type
-// Integer values from 0 to 7 map to those exposed by git.
-// AnyObject is used to represent any from 0 to 7.
-type ObjectType int8
-
-const (
- InvalidObject ObjectType = 0
- CommitObject ObjectType = 1
- TreeObject ObjectType = 2
- BlobObject ObjectType = 3
- TagObject ObjectType = 4
- // 5 reserved for future expansion
- OFSDeltaObject ObjectType = 6
- REFDeltaObject ObjectType = 7
-
- AnyObject ObjectType = -127
-)
-
-func (t ObjectType) String() string {
- switch t {
- case CommitObject:
- return "commit"
- case TreeObject:
- return "tree"
- case BlobObject:
- return "blob"
- case TagObject:
- return "tag"
- case OFSDeltaObject:
- return "ofs-delta"
- case REFDeltaObject:
- return "ref-delta"
- case AnyObject:
- return "any"
- default:
- return "unknown"
- }
-}
-
-func (t ObjectType) Bytes() []byte {
- return []byte(t.String())
-}
-
-// Valid returns true if t is a valid ObjectType.
-func (t ObjectType) Valid() bool {
- return t >= CommitObject && t <= REFDeltaObject
-}
-
-// ParseObjectType parses a string representation of ObjectType. It returns an
-// error on parse failure.
-func ParseObjectType(value string) (typ ObjectType, err error) {
- switch value {
- case "commit":
- typ = CommitObject
- case "tree":
- typ = TreeObject
- case "blob":
- typ = BlobObject
- case "tag":
- typ = TagObject
- case "ofs-delta":
- typ = OFSDeltaObject
- case "ref-delta":
- typ = REFDeltaObject
- default:
- err = ErrInvalidType
- }
- return
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/blob.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/blob.go
deleted file mode 100644
index 2771416787817201e268423b9b4499efcaa7aacc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/blob.go
+++ /dev/null
@@ -1,139 +0,0 @@
-package object
-
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// Blob is used to store arbitrary data - it is generally a file.
-type Blob struct {
- // Hash of the blob.
- Hash plumbing.Hash
- // Size of the (uncompressed) blob.
- Size int64
-
- obj plumbing.EncodedObject
-}
-
-// GetBlob gets a blob from an object storer and decodes it.
-func GetBlob(s storer.EncodedObjectStorer, h plumbing.Hash) (*Blob, error) {
- o, err := s.EncodedObject(plumbing.BlobObject, h)
- if err != nil {
- return nil, err
- }
-
- return DecodeBlob(o)
-}
-
-// DecodeObject decodes an encoded object into a *Blob.
-func DecodeBlob(o plumbing.EncodedObject) (*Blob, error) {
- b := &Blob{}
- if err := b.Decode(o); err != nil {
- return nil, err
- }
-
- return b, nil
-}
-
-// ID returns the object ID of the blob. The returned value will always match
-// the current value of Blob.Hash.
-//
-// ID is present to fulfill the Object interface.
-func (b *Blob) ID() plumbing.Hash {
- return b.Hash
-}
-
-// Type returns the type of object. It always returns plumbing.BlobObject.
-//
-// Type is present to fulfill the Object interface.
-func (b *Blob) Type() plumbing.ObjectType {
- return plumbing.BlobObject
-}
-
-// Decode transforms a plumbing.EncodedObject into a Blob struct.
-func (b *Blob) Decode(o plumbing.EncodedObject) error {
- if o.Type() != plumbing.BlobObject {
- return ErrUnsupportedObject
- }
-
- b.Hash = o.Hash()
- b.Size = o.Size()
- b.obj = o
-
- return nil
-}
-
-// Encode transforms a Blob into a plumbing.EncodedObject.
-func (b *Blob) Encode(o plumbing.EncodedObject) error {
- w, err := o.Writer()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(w, &err)
- r, err := b.Reader()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(r, &err)
- _, err = io.Copy(w, r)
- o.SetType(plumbing.BlobObject)
- return err
-}
-
-// Reader returns a reader allow the access to the content of the blob
-func (b *Blob) Reader() (io.ReadCloser, error) {
- return b.obj.Reader()
-}
-
-// BlobIter provides an iterator for a set of blobs.
-type BlobIter struct {
- storer.EncodedObjectIter
- s storer.EncodedObjectStorer
-}
-
-// NewBlobIter takes a storer.EncodedObjectStorer and a
-// storer.EncodedObjectIter and returns a *BlobIter that iterates over all
-// blobs contained in the storer.EncodedObjectIter.
-//
-// Any non-blob object returned by the storer.EncodedObjectIter is skipped.
-func NewBlobIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *BlobIter {
- return &BlobIter{iter, s}
-}
-
-// Next moves the iterator to the next blob and returns a pointer to it. If
-// there are no more blobs, it returns io.EOF.
-func (iter *BlobIter) Next() (*Blob, error) {
- for {
- obj, err := iter.EncodedObjectIter.Next()
- if err != nil {
- return nil, err
- }
-
- if obj.Type() != plumbing.BlobObject {
- continue
- }
-
- return DecodeBlob(obj)
- }
-}
-
-// ForEach call the cb function for each blob contained on this iter until
-// an error happens or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *BlobIter) ForEach(cb func(*Blob) error) error {
- return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
- if obj.Type() != plumbing.BlobObject {
- return nil
- }
-
- b, err := DecodeBlob(obj)
- if err != nil {
- return err
- }
-
- return cb(b)
- })
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change.go
deleted file mode 100644
index d29836de2a70439db9aa9f2d77f2b4ed8efb8ac8..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package object
-
-import (
- "bytes"
- "fmt"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie"
-)
-
-// Change values represent a detected change between two git trees. For
-// modifications, From is the original status of the node and To is its
-// final status. For insertions, From is the zero value and for
-// deletions To is the zero value.
-type Change struct {
- From ChangeEntry
- To ChangeEntry
-}
-
-var empty = ChangeEntry{}
-
-// Action returns the kind of action represented by the change, an
-// insertion, a deletion or a modification.
-func (c *Change) Action() (merkletrie.Action, error) {
- if c.From == empty && c.To == empty {
- return merkletrie.Action(0),
- fmt.Errorf("malformed change: empty from and to")
- }
- if c.From == empty {
- return merkletrie.Insert, nil
- }
- if c.To == empty {
- return merkletrie.Delete, nil
- }
-
- return merkletrie.Modify, nil
-}
-
-// Files return the files before and after a change.
-// For insertions from will be nil. For deletions to will be nil.
-func (c *Change) Files() (from, to *File, err error) {
- action, err := c.Action()
- if err != nil {
- return
- }
-
- if action == merkletrie.Insert || action == merkletrie.Modify {
- to, err = c.To.Tree.TreeEntryFile(&c.To.TreeEntry)
- if err != nil {
- return
- }
- }
-
- if action == merkletrie.Delete || action == merkletrie.Modify {
- from, err = c.From.Tree.TreeEntryFile(&c.From.TreeEntry)
- if err != nil {
- return
- }
- }
-
- return
-}
-
-func (c *Change) String() string {
- action, err := c.Action()
- if err != nil {
- return fmt.Sprintf("malformed change")
- }
-
- return fmt.Sprintf("<Action: %s, Path: %s>", action, c.name())
-}
-
-func (c *Change) name() string {
- if c.From != empty {
- return c.From.Name
- }
-
- return c.To.Name
-}
-
-// ChangeEntry values represent a node that has suffered a change.
-type ChangeEntry struct {
- // Full path of the node using "/" as separator.
- Name string
- // Parent tree of the node that has changed.
- Tree *Tree
- // The entry of the node.
- TreeEntry TreeEntry
-}
-
-// Changes represents a collection of changes between two git trees.
-// Implements sort.Interface lexicographically over the path of the
-// changed files.
-type Changes []*Change
-
-func (c Changes) Len() int {
- return len(c)
-}
-
-func (c Changes) Swap(i, j int) {
- c[i], c[j] = c[j], c[i]
-}
-
-func (c Changes) Less(i, j int) bool {
- return strings.Compare(c[i].name(), c[j].name()) < 0
-}
-
-func (c Changes) String() string {
- var buffer bytes.Buffer
- buffer.WriteString("[")
- comma := ""
- for _, v := range c {
- buffer.WriteString(comma)
- buffer.WriteString(v.String())
- comma = ", "
- }
- buffer.WriteString("]")
-
- return buffer.String()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change_adaptor.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change_adaptor.go
deleted file mode 100644
index cf8de6cd0c9cd058287200ce2857cd42228f5c6d..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/change_adaptor.go
+++ /dev/null
@@ -1,60 +0,0 @@
-package object
-
-import (
- "fmt"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie"
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// The folowing functions transform changes types form the merkletrie
-// package to changes types from this package.
-
-func newChange(c merkletrie.Change) (*Change, error) {
- ret := &Change{}
-
- var err error
- if ret.From, err = newChangeEntry(c.From); err != nil {
- return nil, fmt.Errorf("From field: ", err)
- }
-
- if ret.To, err = newChangeEntry(c.To); err != nil {
- return nil, fmt.Errorf("To field: ", err)
- }
-
- return ret, nil
-}
-
-func newChangeEntry(p noder.Path) (ChangeEntry, error) {
- if p == nil {
- return empty, nil
- }
-
- asTreeNoder, ok := p.Last().(*treeNoder)
- if !ok {
- return ChangeEntry{}, fmt.Errorf("cannot transform non-TreeNoders")
- }
-
- return ChangeEntry{
- Name: p.String(),
- Tree: asTreeNoder.parent,
- TreeEntry: TreeEntry{
- Name: asTreeNoder.name,
- Mode: asTreeNoder.mode,
- Hash: asTreeNoder.hash,
- },
- }, nil
-}
-
-func newChanges(src merkletrie.Changes) (Changes, error) {
- ret := make(Changes, len(src))
- var err error
- for i, e := range src {
- ret[i], err = newChange(e)
- if err != nil {
- return nil, fmt.Errorf("change #%d: %s", err)
- }
- }
-
- return ret, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit.go
deleted file mode 100644
index 7507bc740c5f668a929f6d0a556a1d86e21f1b3f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit.go
+++ /dev/null
@@ -1,300 +0,0 @@
-package object
-
-import (
- "bufio"
- "bytes"
- "fmt"
- "io"
- "sort"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// Hash represents the hash of an object
-type Hash plumbing.Hash
-
-// Commit points to a single tree, marking it as what the project looked like
-// at a certain point in time. It contains meta-information about that point
-// in time, such as a timestamp, the author of the changes since the last
-// commit, a pointer to the previous commit(s), etc.
-// http://schacon.github.io/gitbook/1_the_git_object_model.html
-type Commit struct {
- // Hash of the commit object.
- Hash plumbing.Hash
- // Author is the original author of the commit.
- Author Signature
- // Committer is the one performing the commit, might be different from
- // Author.
- Committer Signature
- // Message is the commit message, contains arbitrary text.
- Message string
-
- tree plumbing.Hash
- parents []plumbing.Hash
- s storer.EncodedObjectStorer
-}
-
-// GetCommit gets a commit from an object storer and decodes it.
-func GetCommit(s storer.EncodedObjectStorer, h plumbing.Hash) (*Commit, error) {
- o, err := s.EncodedObject(plumbing.CommitObject, h)
- if err != nil {
- return nil, err
- }
-
- return DecodeCommit(s, o)
-}
-
-// DecodeCommit decodes an encoded object into a *Commit and associates it to
-// the given object storer.
-func DecodeCommit(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Commit, error) {
- c := &Commit{s: s}
- if err := c.Decode(o); err != nil {
- return nil, err
- }
-
- return c, nil
-}
-
-// Tree returns the Tree from the commit.
-func (c *Commit) Tree() (*Tree, error) {
- return GetTree(c.s, c.tree)
-}
-
-// Parents return a CommitIter to the parent Commits.
-func (c *Commit) Parents() *CommitIter {
- return NewCommitIter(c.s,
- storer.NewEncodedObjectLookupIter(c.s, plumbing.CommitObject, c.parents),
- )
-}
-
-// NumParents returns the number of parents in a commit.
-func (c *Commit) NumParents() int {
- return len(c.parents)
-}
-
-// File returns the file with the specified "path" in the commit and a
-// nil error if the file exists. If the file does not exist, it returns
-// a nil file and the ErrFileNotFound error.
-func (c *Commit) File(path string) (*File, error) {
- tree, err := c.Tree()
- if err != nil {
- return nil, err
- }
-
- return tree.File(path)
-}
-
-// Files returns a FileIter allowing to iterate over the Tree
-func (c *Commit) Files() (*FileIter, error) {
- tree, err := c.Tree()
- if err != nil {
- return nil, err
- }
-
- return tree.Files(), nil
-}
-
-// ID returns the object ID of the commit. The returned value will always match
-// the current value of Commit.Hash.
-//
-// ID is present to fulfill the Object interface.
-func (c *Commit) ID() plumbing.Hash {
- return c.Hash
-}
-
-// Type returns the type of object. It always returns plumbing.CommitObject.
-//
-// Type is present to fulfill the Object interface.
-func (c *Commit) Type() plumbing.ObjectType {
- return plumbing.CommitObject
-}
-
-// Decode transforms a plumbing.EncodedObject into a Commit struct.
-func (c *Commit) Decode(o plumbing.EncodedObject) (err error) {
- if o.Type() != plumbing.CommitObject {
- return ErrUnsupportedObject
- }
-
- c.Hash = o.Hash()
-
- reader, err := o.Reader()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(reader, &err)
-
- r := bufio.NewReader(reader)
-
- var message bool
- for {
- line, err := r.ReadBytes('\n')
- if err != nil && err != io.EOF {
- return err
- }
-
- if !message {
- line = bytes.TrimSpace(line)
- if len(line) == 0 {
- message = true
- continue
- }
-
- split := bytes.SplitN(line, []byte{' '}, 2)
- switch string(split[0]) {
- case "tree":
- c.tree = plumbing.NewHash(string(split[1]))
- case "parent":
- c.parents = append(c.parents, plumbing.NewHash(string(split[1])))
- case "author":
- c.Author.Decode(split[1])
- case "committer":
- c.Committer.Decode(split[1])
- }
- } else {
- c.Message += string(line)
- }
-
- if err == io.EOF {
- return nil
- }
- }
-}
-
-// History returns a slice with the previous commits in the history of this
-// commit, sorted in reverse chronological order.
-func (c *Commit) History() ([]*Commit, error) {
- var commits []*Commit
- err := WalkCommitHistory(c, func(commit *Commit) error {
- commits = append(commits, commit)
- return nil
- })
-
- ReverseSortCommits(commits)
- return commits, err
-}
-
-// Encode transforms a Commit into a plumbing.EncodedObject.
-func (b *Commit) Encode(o plumbing.EncodedObject) error {
- o.SetType(plumbing.CommitObject)
- w, err := o.Writer()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(w, &err)
- if _, err = fmt.Fprintf(w, "tree %s\n", b.tree.String()); err != nil {
- return err
- }
- for _, parent := range b.parents {
- if _, err = fmt.Fprintf(w, "parent %s\n", parent.String()); err != nil {
- return err
- }
- }
- if _, err = fmt.Fprint(w, "author "); err != nil {
- return err
- }
- if err = b.Author.Encode(w); err != nil {
- return err
- }
- if _, err = fmt.Fprint(w, "\ncommitter "); err != nil {
- return err
- }
- if err = b.Committer.Encode(w); err != nil {
- return err
- }
- if _, err = fmt.Fprintf(w, "\n\n%s", b.Message); err != nil {
- return err
- }
- return err
-}
-
-func (c *Commit) String() string {
- return fmt.Sprintf(
- "%s %s\nAuthor: %s\nDate: %s\n\n%s\n",
- plumbing.CommitObject, c.Hash, c.Author.String(),
- c.Author.When.Format(DateFormat), indent(c.Message),
- )
-}
-
-func indent(t string) string {
- var output []string
- for _, line := range strings.Split(t, "\n") {
- if len(line) != 0 {
- line = " " + line
- }
-
- output = append(output, line)
- }
-
- return strings.Join(output, "\n")
-}
-
-// CommitIter provides an iterator for a set of commits.
-type CommitIter struct {
- storer.EncodedObjectIter
- s storer.EncodedObjectStorer
-}
-
-// NewCommitIter takes a storer.EncodedObjectStorer and a
-// storer.EncodedObjectIter and returns a *CommitIter that iterates over all
-// commits contained in the storer.EncodedObjectIter.
-//
-// Any non-commit object returned by the storer.EncodedObjectIter is skipped.
-func NewCommitIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *CommitIter {
- return &CommitIter{iter, s}
-}
-
-// Next moves the iterator to the next commit and returns a pointer to it. If
-// there are no more commits, it returns io.EOF.
-func (iter *CommitIter) Next() (*Commit, error) {
- obj, err := iter.EncodedObjectIter.Next()
- if err != nil {
- return nil, err
- }
-
- return DecodeCommit(iter.s, obj)
-}
-
-// ForEach call the cb function for each commit contained on this iter until
-// an error appends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *CommitIter) ForEach(cb func(*Commit) error) error {
- return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
- c, err := DecodeCommit(iter.s, obj)
- if err != nil {
- return err
- }
-
- return cb(c)
- })
-}
-
-type commitSorterer struct {
- l []*Commit
-}
-
-func (s commitSorterer) Len() int {
- return len(s.l)
-}
-
-func (s commitSorterer) Less(i, j int) bool {
- return s.l[i].Committer.When.Before(s.l[j].Committer.When)
-}
-
-func (s commitSorterer) Swap(i, j int) {
- s.l[i], s.l[j] = s.l[j], s.l[i]
-}
-
-// SortCommits sorts a commit list by commit date, from older to newer.
-func SortCommits(l []*Commit) {
- s := &commitSorterer{l}
- sort.Sort(s)
-}
-
-// ReverseSortCommits sorts a commit list by commit date, from newer to older.
-func ReverseSortCommits(l []*Commit) {
- s := &commitSorterer{l}
- sort.Sort(sort.Reverse(s))
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit_walker.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit_walker.go
deleted file mode 100644
index 681ea5ec8dc004d518993e8429b158b72ba171cf..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/commit_walker.go
+++ /dev/null
@@ -1,96 +0,0 @@
-package object
-
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-type commitWalker struct {
- seen map[plumbing.Hash]bool
- stack []*CommitIter
- start *Commit
- cb func(*Commit) error
-}
-
-// WalkCommitHistory walks the commit history, starting at the given commit and
-// visiting its parents in pre-order. The given callback will be called for each
-// visited commit. Each commit will be visited only once. If the callback returns
-// an error, walking will stop and will return the error. Other errors might be
-// returned if the history cannot be traversed (e.g. missing objects).
-func WalkCommitHistory(c *Commit, cb func(*Commit) error) error {
- w := &commitWalker{
- seen: make(map[plumbing.Hash]bool),
- stack: make([]*CommitIter, 0),
- start: c,
- cb: cb,
- }
-
- return w.walk()
-}
-
-func (w *commitWalker) walk() error {
- var commit *Commit
-
- if w.start != nil {
- commit = w.start
- w.start = nil
- } else {
- current := len(w.stack) - 1
- if current < 0 {
- return nil
- }
-
- var err error
- commit, err = w.stack[current].Next()
- if err == io.EOF {
- w.stack = w.stack[:current]
- return w.walk()
- }
-
- if err != nil {
- return err
- }
- }
-
- // check and update seen
- if w.seen[commit.Hash] {
- return w.walk()
- }
-
- w.seen[commit.Hash] = true
- if commit.NumParents() > 0 {
- w.stack = append(w.stack, commit.Parents())
- }
-
- if err := w.cb(commit); err != nil {
- return err
- }
-
- return w.walk()
-}
-
-// WalkCommitHistoryPost walks the commit history like WalkCommitHistory
-// but in post-order. This means that after walking a merge commit, the
-// merged commit will be walked before the base it was merged on. This
-// can be useful if you wish to see the history in chronological order.
-func WalkCommitHistoryPost(c *Commit, cb func(*Commit) error) error {
- stack := []*Commit{c}
- seen := make(map[plumbing.Hash]bool)
- for len(stack) > 0 {
- c := stack[len(stack)-1]
- stack = stack[:len(stack)-1]
- if seen[c.Hash] {
- continue
- }
- seen[c.Hash] = true
- if err := cb(c); err != nil {
- return err
- }
- c.Parents().ForEach(func(pcm *Commit) error {
- stack = append(stack, pcm)
- return nil
- })
- }
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/difftree.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/difftree.go
deleted file mode 100644
index 87a7153e2049a9c6b42fdce301a986650d0644c2..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/difftree.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package object
-
-import (
- "bytes"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie"
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// DiffTree compares the content and mode of the blobs found via two
-// tree objects.
-func DiffTree(a, b *Tree) (Changes, error) {
- from := newTreeNoder(a)
- to := newTreeNoder(b)
-
- hashEqual := func(a, b noder.Hasher) bool {
- return bytes.Equal(a.Hash(), b.Hash())
- }
-
- merkletrieChanges, err := merkletrie.DiffTree(from, to, hashEqual)
- if err != nil {
- return nil, err
- }
-
- return newChanges(merkletrieChanges)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/file.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/file.go
deleted file mode 100644
index 6932c31ababda13032d1b62ceb96268454653555..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/file.go
+++ /dev/null
@@ -1,125 +0,0 @@
-package object
-
-import (
- "bytes"
- "io"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// File represents git file objects.
-type File struct {
- // Name is the path of the file. It might be relative to a tree,
- // depending of the function that generates it.
- Name string
- // Mode is the file mode.
- Mode filemode.FileMode
- // Blob with the contents of the file.
- Blob
-}
-
-// NewFile returns a File based on the given blob object
-func NewFile(name string, m filemode.FileMode, b *Blob) *File {
- return &File{Name: name, Mode: m, Blob: *b}
-}
-
-// Contents returns the contents of a file as a string.
-func (f *File) Contents() (content string, err error) {
- reader, err := f.Reader()
- if err != nil {
- return "", err
- }
- defer ioutil.CheckClose(reader, &err)
-
- buf := new(bytes.Buffer)
- if _, err := buf.ReadFrom(reader); err != nil {
- return "", err
- }
-
- return buf.String(), nil
-}
-
-// Lines returns a slice of lines from the contents of a file, stripping
-// all end of line characters. If the last line is empty (does not end
-// in an end of line), it is also stripped.
-func (f *File) Lines() ([]string, error) {
- content, err := f.Contents()
- if err != nil {
- return nil, err
- }
-
- splits := strings.Split(content, "\n")
- // remove the last line if it is empty
- if splits[len(splits)-1] == "" {
- return splits[:len(splits)-1], nil
- }
-
- return splits, nil
-}
-
-// FileIter provides an iterator for the files in a tree.
-type FileIter struct {
- s storer.EncodedObjectStorer
- w TreeWalker
-}
-
-// NewFileIter takes a storer.EncodedObjectStorer and a Tree and returns a
-// *FileIter that iterates over all files contained in the tree, recursively.
-func NewFileIter(s storer.EncodedObjectStorer, t *Tree) *FileIter {
- return &FileIter{s: s, w: *NewTreeWalker(t, true)}
-}
-
-// Next moves the iterator to the next file and returns a pointer to it. If
-// there are no more files, it returns io.EOF.
-func (iter *FileIter) Next() (*File, error) {
- for {
- name, entry, err := iter.w.Next()
- if err != nil {
- return nil, err
- }
-
- if entry.Mode == filemode.Dir || entry.Mode == filemode.Submodule {
- continue
- }
-
- blob, err := GetBlob(iter.s, entry.Hash)
- if err != nil {
- return nil, err
- }
-
- return NewFile(name, entry.Mode, blob), nil
- }
-}
-
-// ForEach call the cb function for each file contained in this iter until
-// an error happens or the end of the iter is reached. If plumbing.ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *FileIter) ForEach(cb func(*File) error) error {
- defer iter.Close()
-
- for {
- f, err := iter.Next()
- if err != nil {
- if err == io.EOF {
- return nil
- }
-
- return err
- }
-
- if err := cb(f); err != nil {
- if err == storer.ErrStop {
- return nil
- }
-
- return err
- }
- }
-}
-
-func (iter *FileIter) Close() {
- iter.w.Close()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/object.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/object.go
deleted file mode 100644
index 701145d05679d51c558a90788b506395582b63b2..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/object.go
+++ /dev/null
@@ -1,228 +0,0 @@
-// Package object contains implementations of all Git objects and utility
-// functions to work with them.
-package object
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
- "strconv"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-// ErrUnsupportedObject trigger when a non-supported object is being decoded.
-var ErrUnsupportedObject = errors.New("unsupported object type")
-
-// Object is a generic representation of any git object. It is implemented by
-// Commit, Tree, Blob, and Tag, and includes the functions that are common to
-// them.
-//
-// Object is returned when an object can be of any type. It is frequently used
-// with a type cast to acquire the specific type of object:
-//
-// func process(obj Object) {
-// switch o := obj.(type) {
-// case *Commit:
-// // o is a Commit
-// case *Tree:
-// // o is a Tree
-// case *Blob:
-// // o is a Blob
-// case *Tag:
-// // o is a Tag
-// }
-// }
-//
-// This interface is intentionally different from plumbing.EncodedObject, which
-// is a lower level interface used by storage implementations to read and write
-// objects in its encoded form.
-type Object interface {
- ID() plumbing.Hash
- Type() plumbing.ObjectType
- Decode(plumbing.EncodedObject) error
- Encode(plumbing.EncodedObject) error
-}
-
-// GetObject gets an object from an object storer and decodes it.
-func GetObject(s storer.EncodedObjectStorer, h plumbing.Hash) (Object, error) {
- o, err := s.EncodedObject(plumbing.AnyObject, h)
- if err != nil {
- return nil, err
- }
-
- return DecodeObject(s, o)
-}
-
-// DecodeObject decodes an encoded object into an Object and associates it to
-// the given object storer.
-func DecodeObject(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (Object, error) {
- switch o.Type() {
- case plumbing.CommitObject:
- return DecodeCommit(s, o)
- case plumbing.TreeObject:
- return DecodeTree(s, o)
- case plumbing.BlobObject:
- return DecodeBlob(o)
- case plumbing.TagObject:
- return DecodeTag(s, o)
- default:
- return nil, plumbing.ErrInvalidType
- }
-}
-
-// DateFormat is the format being used in the original git implementation
-const DateFormat = "Mon Jan 02 15:04:05 2006 -0700"
-
-// Signature is used to identify who and when created a commit or tag.
-type Signature struct {
- // Name represents a person name. It is an arbitrary string.
- Name string
- // Email is an email, but it cannot be assumed to be well-formed.
- Email string
- // When is the timestamp of the signature.
- When time.Time
-}
-
-// Decode decodes a byte slice into a signature
-func (s *Signature) Decode(b []byte) {
- open := bytes.LastIndexByte(b, '<')
- close := bytes.LastIndexByte(b, '>')
- if open == -1 || close == -1 {
- return
- }
-
- if close < open {
- return
- }
-
- s.Name = string(bytes.Trim(b[:open], " "))
- s.Email = string(b[open+1 : close])
-
- hasTime := close+2 < len(b)
- if hasTime {
- s.decodeTimeAndTimeZone(b[close+2:])
- }
-}
-
-// Encode encodes a Signature into a writer.
-func (s *Signature) Encode(w io.Writer) error {
- if _, err := fmt.Fprintf(w, "%s <%s> ", s.Name, s.Email); err != nil {
- return err
- }
- if err := s.encodeTimeAndTimeZone(w); err != nil {
- return err
- }
- return nil
-}
-
-var timeZoneLength = 5
-
-func (s *Signature) decodeTimeAndTimeZone(b []byte) {
- space := bytes.IndexByte(b, ' ')
- if space == -1 {
- space = len(b)
- }
-
- ts, err := strconv.ParseInt(string(b[:space]), 10, 64)
- if err != nil {
- return
- }
-
- s.When = time.Unix(ts, 0).In(time.UTC)
- var tzStart = space + 1
- if tzStart >= len(b) || tzStart+timeZoneLength > len(b) {
- return
- }
-
- tl, err := time.Parse("-0700", string(b[tzStart:tzStart+timeZoneLength]))
- if err != nil {
- return
- }
-
- s.When = s.When.In(tl.Location())
-}
-
-func (s *Signature) encodeTimeAndTimeZone(w io.Writer) error {
- _, err := fmt.Fprintf(w, "%d %s", s.When.Unix(), s.When.Format("-0700"))
- return err
-}
-
-func (s *Signature) String() string {
- return fmt.Sprintf("%s <%s>", s.Name, s.Email)
-}
-
-// ObjectIter provides an iterator for a set of objects.
-type ObjectIter struct {
- storer.EncodedObjectIter
- s storer.EncodedObjectStorer
-}
-
-// NewObjectIter takes a storer.EncodedObjectStorer and a
-// storer.EncodedObjectIter and returns an *ObjectIter that iterates over all
-// objects contained in the storer.EncodedObjectIter.
-func NewObjectIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *ObjectIter {
- return &ObjectIter{iter, s}
-}
-
-// Next moves the iterator to the next object and returns a pointer to it. If
-// there are no more objects, it returns io.EOF.
-func (iter *ObjectIter) Next() (Object, error) {
- for {
- obj, err := iter.EncodedObjectIter.Next()
- if err != nil {
- return nil, err
- }
-
- o, err := iter.toObject(obj)
- if err == plumbing.ErrInvalidType {
- continue
- }
-
- if err != nil {
- return nil, err
- }
-
- return o, nil
- }
-}
-
-// ForEach call the cb function for each object contained on this iter until
-// an error happens or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *ObjectIter) ForEach(cb func(Object) error) error {
- return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
- o, err := iter.toObject(obj)
- if err == plumbing.ErrInvalidType {
- return nil
- }
-
- if err != nil {
- return err
- }
-
- return cb(o)
- })
-}
-
-func (iter *ObjectIter) toObject(obj plumbing.EncodedObject) (Object, error) {
- switch obj.Type() {
- case plumbing.BlobObject:
- blob := &Blob{}
- return blob, blob.Decode(obj)
- case plumbing.TreeObject:
- tree := &Tree{s: iter.s}
- return tree, tree.Decode(obj)
- case plumbing.CommitObject:
- commit := &Commit{}
- return commit, commit.Decode(obj)
- case plumbing.TagObject:
- tag := &Tag{}
- return tag, tag.Decode(obj)
- default:
- return nil, plumbing.ErrInvalidType
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tag.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tag.go
deleted file mode 100644
index 7b091d076dfc023d8d1530bda480dae67d541928..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tag.go
+++ /dev/null
@@ -1,275 +0,0 @@
-package object
-
-import (
- "bufio"
- "bytes"
- "fmt"
- "io"
- stdioutil "io/ioutil"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// Tag represents an annotated tag object. It points to a single git object of
-// any type, but tags typically are applied to commit or blob objects. It
-// provides a reference that associates the target with a tag name. It also
-// contains meta-information about the tag, including the tagger, tag date and
-// message.
-//
-// Note that this is not used for lightweight tags.
-//
-// https://git-scm.com/book/en/v2/Git-Internals-Git-References#Tags
-type Tag struct {
- // Hash of the tag.
- Hash plumbing.Hash
- // Name of the tag.
- Name string
- // Tagger is the one who created the tag.
- Tagger Signature
- // Message is an arbitrary text message.
- Message string
- // TargetType is the object type of the target.
- TargetType plumbing.ObjectType
- // Target is the hash of the target object.
- Target plumbing.Hash
-
- s storer.EncodedObjectStorer
-}
-
-// GetTag gets a tag from an object storer and decodes it.
-func GetTag(s storer.EncodedObjectStorer, h plumbing.Hash) (*Tag, error) {
- o, err := s.EncodedObject(plumbing.TagObject, h)
- if err != nil {
- return nil, err
- }
-
- return DecodeTag(s, o)
-}
-
-// DecodeTag decodes an encoded object into a *Commit and associates it to the
-// given object storer.
-func DecodeTag(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Tag, error) {
- t := &Tag{s: s}
- if err := t.Decode(o); err != nil {
- return nil, err
- }
-
- return t, nil
-}
-
-// ID returns the object ID of the tag, not the object that the tag references.
-// The returned value will always match the current value of Tag.Hash.
-//
-// ID is present to fulfill the Object interface.
-func (t *Tag) ID() plumbing.Hash {
- return t.Hash
-}
-
-// Type returns the type of object. It always returns plumbing.TagObject.
-//
-// Type is present to fulfill the Object interface.
-func (t *Tag) Type() plumbing.ObjectType {
- return plumbing.TagObject
-}
-
-// Decode transforms a plumbing.EncodedObject into a Tag struct.
-func (t *Tag) Decode(o plumbing.EncodedObject) (err error) {
- if o.Type() != plumbing.TagObject {
- return ErrUnsupportedObject
- }
-
- t.Hash = o.Hash()
-
- reader, err := o.Reader()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(reader, &err)
-
- r := bufio.NewReader(reader)
- for {
- line, err := r.ReadBytes('\n')
- if err != nil && err != io.EOF {
- return err
- }
-
- line = bytes.TrimSpace(line)
- if len(line) == 0 {
- break // Start of message
- }
-
- split := bytes.SplitN(line, []byte{' '}, 2)
- switch string(split[0]) {
- case "object":
- t.Target = plumbing.NewHash(string(split[1]))
- case "type":
- t.TargetType, err = plumbing.ParseObjectType(string(split[1]))
- if err != nil {
- return err
- }
- case "tag":
- t.Name = string(split[1])
- case "tagger":
- t.Tagger.Decode(split[1])
- }
-
- if err == io.EOF {
- return nil
- }
- }
-
- data, err := stdioutil.ReadAll(r)
- if err != nil {
- return err
- }
- t.Message = string(data)
-
- return nil
-}
-
-// Encode transforms a Tag into a plumbing.EncodedObject.
-func (t *Tag) Encode(o plumbing.EncodedObject) error {
- o.SetType(plumbing.TagObject)
- w, err := o.Writer()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(w, &err)
-
- if _, err = fmt.Fprintf(w,
- "object %s\ntype %s\ntag %s\ntagger ",
- t.Target.String(), t.TargetType.Bytes(), t.Name); err != nil {
- return err
- }
-
- if err = t.Tagger.Encode(w); err != nil {
- return err
- }
-
- if _, err = fmt.Fprint(w, "\n\n"); err != nil {
- return err
- }
-
- if _, err = fmt.Fprint(w, t.Message); err != nil {
- return err
- }
-
- return err
-}
-
-// Commit returns the commit pointed to by the tag. If the tag points to a
-// different type of object ErrUnsupportedObject will be returned.
-func (t *Tag) Commit() (*Commit, error) {
- if t.TargetType != plumbing.CommitObject {
- return nil, ErrUnsupportedObject
- }
-
- o, err := t.s.EncodedObject(plumbing.CommitObject, t.Target)
- if err != nil {
- return nil, err
- }
-
- return DecodeCommit(t.s, o)
-}
-
-// Tree returns the tree pointed to by the tag. If the tag points to a commit
-// object the tree of that commit will be returned. If the tag does not point
-// to a commit or tree object ErrUnsupportedObject will be returned.
-func (t *Tag) Tree() (*Tree, error) {
- switch t.TargetType {
- case plumbing.CommitObject:
- c, err := t.Commit()
- if err != nil {
- return nil, err
- }
-
- return c.Tree()
- case plumbing.TreeObject:
- return GetTree(t.s, t.Target)
- default:
- return nil, ErrUnsupportedObject
- }
-}
-
-// Blob returns the blob pointed to by the tag. If the tag points to a
-// different type of object ErrUnsupportedObject will be returned.
-func (t *Tag) Blob() (*Blob, error) {
- if t.TargetType != plumbing.BlobObject {
- return nil, ErrUnsupportedObject
- }
-
- return GetBlob(t.s, t.Target)
-}
-
-// Object returns the object pointed to by the tag.
-func (t *Tag) Object() (Object, error) {
- o, err := t.s.EncodedObject(t.TargetType, t.Target)
- if err != nil {
- return nil, err
- }
-
- return DecodeObject(t.s, o)
-}
-
-// String returns the meta information contained in the tag as a formatted
-// string.
-func (t *Tag) String() string {
- obj, _ := t.Object()
-
- return fmt.Sprintf(
- "%s %s\nTagger: %s\nDate: %s\n\n%s\n%s",
- plumbing.TagObject, t.Name, t.Tagger.String(), t.Tagger.When.Format(DateFormat),
- t.Message, objectAsString(obj),
- )
-}
-
-// TagIter provides an iterator for a set of tags.
-type TagIter struct {
- storer.EncodedObjectIter
- s storer.EncodedObjectStorer
-}
-
-// NewTagIter takes a storer.EncodedObjectStorer and a
-// storer.EncodedObjectIter and returns a *TagIter that iterates over all
-// tags contained in the storer.EncodedObjectIter.
-//
-// Any non-tag object returned by the storer.EncodedObjectIter is skipped.
-func NewTagIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *TagIter {
- return &TagIter{iter, s}
-}
-
-// Next moves the iterator to the next tag and returns a pointer to it. If
-// there are no more tags, it returns io.EOF.
-func (iter *TagIter) Next() (*Tag, error) {
- obj, err := iter.EncodedObjectIter.Next()
- if err != nil {
- return nil, err
- }
-
- return DecodeTag(iter.s, obj)
-}
-
-// ForEach call the cb function for each tag contained on this iter until
-// an error happends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *TagIter) ForEach(cb func(*Tag) error) error {
- return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
- t, err := DecodeTag(iter.s, obj)
- if err != nil {
- return err
- }
-
- return cb(t)
- })
-}
-
-func objectAsString(obj Object) string {
- switch o := obj.(type) {
- case *Commit:
- return o.String()
- default:
- return ""
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tree.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tree.go
deleted file mode 100644
index e70b5cd32ead7118be99dc83d32ababc4de14116..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/tree.go
+++ /dev/null
@@ -1,449 +0,0 @@
-package object
-
-import (
- "bufio"
- "errors"
- "fmt"
- "io"
- "path"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-const (
- maxTreeDepth = 1024
- startingStackSize = 8
-)
-
-// New errors defined by this package.
-var (
- ErrMaxTreeDepth = errors.New("maximum tree depth exceeded")
- ErrFileNotFound = errors.New("file not found")
- ErrDirectoryNotFound = errors.New("directory not found")
-)
-
-// Tree is basically like a directory - it references a bunch of other trees
-// and/or blobs (i.e. files and sub-directories)
-type Tree struct {
- Entries []TreeEntry
- Hash plumbing.Hash
-
- s storer.EncodedObjectStorer
- m map[string]*TreeEntry
-}
-
-// GetTree gets a tree from an object storer and decodes it.
-func GetTree(s storer.EncodedObjectStorer, h plumbing.Hash) (*Tree, error) {
- o, err := s.EncodedObject(plumbing.TreeObject, h)
- if err != nil {
- return nil, err
- }
-
- return DecodeTree(s, o)
-}
-
-// DecodeTree decodes an encoded object into a *Tree and associates it to the
-// given object storer.
-func DecodeTree(s storer.EncodedObjectStorer, o plumbing.EncodedObject) (*Tree, error) {
- t := &Tree{s: s}
- if err := t.Decode(o); err != nil {
- return nil, err
- }
-
- return t, nil
-}
-
-// TreeEntry represents a file
-type TreeEntry struct {
- Name string
- Mode filemode.FileMode
- Hash plumbing.Hash
-}
-
-// File returns the hash of the file identified by the `path` argument.
-// The path is interpreted as relative to the tree receiver.
-func (t *Tree) File(path string) (*File, error) {
- e, err := t.findEntry(path)
- if err != nil {
- return nil, ErrFileNotFound
- }
-
- blob, err := GetBlob(t.s, e.Hash)
- if err != nil {
- if err == plumbing.ErrObjectNotFound {
- return nil, ErrFileNotFound
- }
- return nil, err
- }
-
- return NewFile(path, e.Mode, blob), nil
-}
-
-// Tree returns the tree identified by the `path` argument.
-// The path is interpreted as relative to the tree receiver.
-func (t *Tree) Tree(path string) (*Tree, error) {
- e, err := t.findEntry(path)
- if err != nil {
- return nil, ErrDirectoryNotFound
- }
-
- tree, err := GetTree(t.s, e.Hash)
- if err == plumbing.ErrObjectNotFound {
- return nil, ErrDirectoryNotFound
- }
-
- return tree, err
-}
-
-// TreeEntryFile returns the *File for a given *TreeEntry.
-func (t *Tree) TreeEntryFile(e *TreeEntry) (*File, error) {
- blob, err := GetBlob(t.s, e.Hash)
- if err != nil {
- return nil, err
- }
-
- return NewFile(e.Name, e.Mode, blob), nil
-}
-
-func (t *Tree) findEntry(path string) (*TreeEntry, error) {
- pathParts := strings.Split(path, "/")
-
- var tree *Tree
- var err error
- for tree = t; len(pathParts) > 1; pathParts = pathParts[1:] {
- if tree, err = tree.dir(pathParts[0]); err != nil {
- return nil, err
- }
- }
-
- return tree.entry(pathParts[0])
-}
-
-func (t *Tree) dir(baseName string) (*Tree, error) {
- entry, err := t.entry(baseName)
- if err != nil {
- return nil, ErrDirectoryNotFound
- }
-
- obj, err := t.s.EncodedObject(plumbing.TreeObject, entry.Hash)
- if err != nil {
- return nil, err
- }
-
- tree := &Tree{s: t.s}
- tree.Decode(obj)
-
- return tree, nil
-}
-
-var errEntryNotFound = errors.New("entry not found")
-
-func (t *Tree) entry(baseName string) (*TreeEntry, error) {
- if t.m == nil {
- t.buildMap()
- }
- entry, ok := t.m[baseName]
- if !ok {
- return nil, errEntryNotFound
- }
-
- return entry, nil
-}
-
-// Files returns a FileIter allowing to iterate over the Tree
-func (t *Tree) Files() *FileIter {
- return NewFileIter(t.s, t)
-}
-
-// ID returns the object ID of the tree. The returned value will always match
-// the current value of Tree.Hash.
-//
-// ID is present to fulfill the Object interface.
-func (t *Tree) ID() plumbing.Hash {
- return t.Hash
-}
-
-// Type returns the type of object. It always returns plumbing.TreeObject.
-func (t *Tree) Type() plumbing.ObjectType {
- return plumbing.TreeObject
-}
-
-// Decode transform an plumbing.EncodedObject into a Tree struct
-func (t *Tree) Decode(o plumbing.EncodedObject) (err error) {
- if o.Type() != plumbing.TreeObject {
- return ErrUnsupportedObject
- }
-
- t.Hash = o.Hash()
- if o.Size() == 0 {
- return nil
- }
-
- t.Entries = nil
- t.m = nil
-
- reader, err := o.Reader()
- if err != nil {
- return err
- }
- defer ioutil.CheckClose(reader, &err)
-
- r := bufio.NewReader(reader)
- for {
- str, err := r.ReadString(' ')
- if err != nil {
- if err == io.EOF {
- break
- }
-
- return err
- }
- str = str[:len(str)-1] // strip last byte (' ')
-
- mode, err := filemode.New(str)
- if err != nil {
- return err
- }
-
- name, err := r.ReadString(0)
- if err != nil && err != io.EOF {
- return err
- }
-
- var hash plumbing.Hash
- if _, err = io.ReadFull(r, hash[:]); err != nil {
- return err
- }
-
- baseName := name[:len(name)-1]
- t.Entries = append(t.Entries, TreeEntry{
- Hash: hash,
- Mode: mode,
- Name: baseName,
- })
- }
-
- return nil
-}
-
-// Encode transforms a Tree into a plumbing.EncodedObject.
-func (t *Tree) Encode(o plumbing.EncodedObject) error {
- o.SetType(plumbing.TreeObject)
- w, err := o.Writer()
- if err != nil {
- return err
- }
-
- var size int
- defer ioutil.CheckClose(w, &err)
- for _, entry := range t.Entries {
- n, err := fmt.Fprintf(w, "%o %s", entry.Mode, entry.Name)
- if err != nil {
- return err
- }
-
- size += n
- n, err = w.Write([]byte{0x00})
- if err != nil {
- return err
- }
-
- size += n
- n, err = w.Write([]byte(entry.Hash[:]))
- if err != nil {
- return err
- }
- size += n
- }
-
- o.SetSize(int64(size))
- return err
-}
-
-func (t *Tree) buildMap() {
- t.m = make(map[string]*TreeEntry)
- for i := 0; i < len(t.Entries); i++ {
- t.m[t.Entries[i].Name] = &t.Entries[i]
- }
-}
-
-// Diff returns a list of changes between this tree and the provided one
-func (from *Tree) Diff(to *Tree) (Changes, error) {
- return DiffTree(from, to)
-}
-
-// treeEntryIter facilitates iterating through the TreeEntry objects in a Tree.
-type treeEntryIter struct {
- t *Tree
- pos int
-}
-
-func (iter *treeEntryIter) Next() (TreeEntry, error) {
- if iter.pos >= len(iter.t.Entries) {
- return TreeEntry{}, io.EOF
- }
- iter.pos++
- return iter.t.Entries[iter.pos-1], nil
-}
-
-// TreeWalker provides a means of walking through all of the entries in a Tree.
-type TreeWalker struct {
- stack []treeEntryIter
- base string
- recursive bool
-
- s storer.EncodedObjectStorer
- t *Tree
-}
-
-// NewTreeWalker returns a new TreeWalker for the given tree.
-//
-// It is the caller's responsibility to call Close() when finished with the
-// tree walker.
-func NewTreeWalker(t *Tree, recursive bool) *TreeWalker {
- stack := make([]treeEntryIter, 0, startingStackSize)
- stack = append(stack, treeEntryIter{t, 0})
-
- return &TreeWalker{
- stack: stack,
- recursive: recursive,
-
- s: t.s,
- t: t,
- }
-}
-
-// Next returns the next object from the tree. Objects are returned in order
-// and subtrees are included. After the last object has been returned further
-// calls to Next() will return io.EOF.
-//
-// In the current implementation any objects which cannot be found in the
-// underlying repository will be skipped automatically. It is possible that this
-// may change in future versions.
-func (w *TreeWalker) Next() (name string, entry TreeEntry, err error) {
- var obj Object
- for {
- current := len(w.stack) - 1
- if current < 0 {
- // Nothing left on the stack so we're finished
- err = io.EOF
- return
- }
-
- if current > maxTreeDepth {
- // We're probably following bad data or some self-referencing tree
- err = ErrMaxTreeDepth
- return
- }
-
- entry, err = w.stack[current].Next()
- if err == io.EOF {
- // Finished with the current tree, move back up to the parent
- w.stack = w.stack[:current]
- w.base, _ = path.Split(w.base)
- w.base = path.Clean(w.base) // Remove trailing slash
- continue
- }
-
- if err != nil {
- return
- }
-
- if entry.Mode == filemode.Dir {
- obj, err = GetTree(w.s, entry.Hash)
- }
-
- name = path.Join(w.base, entry.Name)
-
- if err != nil {
- err = io.EOF
- return
- }
-
- break
- }
-
- if !w.recursive {
- return
- }
-
- if t, ok := obj.(*Tree); ok {
- w.stack = append(w.stack, treeEntryIter{t, 0})
- w.base = path.Join(w.base, entry.Name)
- }
-
- return
-}
-
-// Tree returns the tree that the tree walker most recently operated on.
-func (w *TreeWalker) Tree() *Tree {
- current := len(w.stack) - 1
- if w.stack[current].pos == 0 {
- current--
- }
-
- if current < 0 {
- return nil
- }
-
- return w.stack[current].t
-}
-
-// Close releases any resources used by the TreeWalker.
-func (w *TreeWalker) Close() {
- w.stack = nil
-}
-
-// TreeIter provides an iterator for a set of trees.
-type TreeIter struct {
- storer.EncodedObjectIter
- s storer.EncodedObjectStorer
-}
-
-// NewTreeIter takes a storer.EncodedObjectStorer and a
-// storer.EncodedObjectIter and returns a *TreeIter that iterates over all
-// tree contained in the storer.EncodedObjectIter.
-//
-// Any non-tree object returned by the storer.EncodedObjectIter is skipped.
-func NewTreeIter(s storer.EncodedObjectStorer, iter storer.EncodedObjectIter) *TreeIter {
- return &TreeIter{iter, s}
-}
-
-// Next moves the iterator to the next tree and returns a pointer to it. If
-// there are no more trees, it returns io.EOF.
-func (iter *TreeIter) Next() (*Tree, error) {
- for {
- obj, err := iter.EncodedObjectIter.Next()
- if err != nil {
- return nil, err
- }
-
- if obj.Type() != plumbing.TreeObject {
- continue
- }
-
- return DecodeTree(iter.s, obj)
- }
-}
-
-// ForEach call the cb function for each tree contained on this iter until
-// an error happens or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *TreeIter) ForEach(cb func(*Tree) error) error {
- return iter.EncodedObjectIter.ForEach(func(obj plumbing.EncodedObject) error {
- if obj.Type() != plumbing.TreeObject {
- return nil
- }
-
- t, err := DecodeTree(iter.s, obj)
- if err != nil {
- return err
- }
-
- return cb(t)
- })
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/treenoder.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/treenoder.go
deleted file mode 100644
index 4da82989d900125d904d91e15f7502b872bf1203..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/object/treenoder.go
+++ /dev/null
@@ -1,142 +0,0 @@
-package object
-
-// A treenoder is a helper type that wraps git trees into merkletrie
-// noders.
-//
-// As a merkletrie noder doesn't understand the concept of modes (e.g.
-// file permissions), the treenoder includes the mode of the git tree in
-// the hash, so changes in the modes will be detected as modifications
-// to the file contents by the merkletrie difftree algorithm. This is
-// consistent with how the "git diff-tree" command works.
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-type treeNoder struct {
- parent *Tree // the root node is its own parent
- name string // empty string for the root node
- mode filemode.FileMode
- hash plumbing.Hash
- children []noder.Noder // memoized
-}
-
-func newTreeNoder(t *Tree) *treeNoder {
- if t == nil {
- return &treeNoder{}
- }
-
- return &treeNoder{
- parent: t,
- name: "",
- mode: filemode.Dir,
- hash: t.Hash,
- }
-}
-
-func (t *treeNoder) isRoot() bool {
- return t.name == ""
-}
-
-func (t *treeNoder) String() string {
- return "treeNoder <" + t.name + ">"
-}
-
-// The hash of a treeNoder is the result of concatenating the hash of
-// its contents and its mode; that way the difftree algorithm will
-// detect changes in the contents of files and also in their mode.
-//
-// Files with Regular and Deprecated file modes are considered the same
-// for the purpose of difftree, so Regular will be used as the mode for
-// Deprecated files here.
-func (t *treeNoder) Hash() []byte {
- if t.mode == filemode.Deprecated {
- return append(t.hash[:], filemode.Regular.Bytes()...)
- }
- return append(t.hash[:], t.mode.Bytes()...)
-}
-
-func (t *treeNoder) Name() string {
- return t.name
-}
-
-func (t *treeNoder) IsDir() bool {
- return t.mode == filemode.Dir
-}
-
-// Children will return the children of a treenoder as treenoders,
-// building them from the children of the wrapped git tree.
-func (t *treeNoder) Children() ([]noder.Noder, error) {
- if t.mode != filemode.Dir {
- return noder.NoChildren, nil
- }
-
- // children are memoized for efficiency
- if t.children != nil {
- return t.children, nil
- }
-
- // the parent of the returned children will be ourself as a tree if
- // we are a not the root treenoder. The root is special as it
- // is is own parent.
- parent := t.parent
- if !t.isRoot() {
- var err error
- if parent, err = t.parent.Tree(t.name); err != nil {
- return nil, err
- }
- }
-
- return transformChildren(parent)
-}
-
-// Returns the children of a tree as treenoders.
-// Efficiency is key here.
-func transformChildren(t *Tree) ([]noder.Noder, error) {
- var err error
- var e TreeEntry
-
- // there will be more tree entries than children in the tree,
- // due to submodules and empty directories, but I think it is still
- // worth it to pre-allocate the whole array now, even if sometimes
- // is bigger than needed.
- ret := make([]noder.Noder, 0, len(t.Entries))
-
- walker := NewTreeWalker(t, false) // don't recurse
- // don't defer walker.Close() for efficiency reasons.
- for {
- _, e, err = walker.Next()
- if err == io.EOF {
- break
- }
- if err != nil {
- walker.Close()
- return nil, err
- }
-
- ret = append(ret, &treeNoder{
- parent: t,
- name: e.Name,
- mode: e.Mode,
- hash: e.Hash,
- })
- }
- walker.Close()
-
- return ret, nil
-}
-
-// len(t.tree.Entries) != the number of elements walked by treewalker
-// for some reason because of empty directories, submodules, etc, so we
-// have to walk here.
-func (t *treeNoder) NumChildren() (int, error) {
- children, err := t.Children()
- if err != nil {
- return 0, err
- }
-
- return len(children), nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs.go
deleted file mode 100644
index 7d644bcb0de88f5155c76a0d921aa9d95e79539c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package packp
-
-import (
- "fmt"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/storage/memory"
-)
-
-// AdvRefs values represent the information transmitted on an
-// advertised-refs message. Values from this type are not zero-value
-// safe, use the New function instead.
-type AdvRefs struct {
- // Prefix stores prefix payloads.
- //
- // When using this message over (smart) HTTP, you have to add a pktline
- // before the whole thing with the following payload:
- //
- // '# service=$servicename" LF
- //
- // Moreover, some (all) git HTTP smart servers will send a flush-pkt
- // just after the first pkt-line.
- //
- // To accommodate both situations, the Prefix field allow you to store
- // any data you want to send before the actual pktlines. It will also
- // be filled up with whatever is found on the line.
- Prefix [][]byte
- // Head stores the resolved HEAD reference if present.
- // This can be present with git-upload-pack, not with git-receive-pack.
- Head *plumbing.Hash
- // Capabilities are the capabilities.
- Capabilities *capability.List
- // References are the hash references.
- References map[string]plumbing.Hash
- // Peeled are the peeled hash references.
- Peeled map[string]plumbing.Hash
- // Shallows are the shallow object ids.
- Shallows []plumbing.Hash
-}
-
-// NewAdvRefs returns a pointer to a new AdvRefs value, ready to be used.
-func NewAdvRefs() *AdvRefs {
- return &AdvRefs{
- Prefix: [][]byte{},
- Capabilities: capability.NewList(),
- References: make(map[string]plumbing.Hash),
- Peeled: make(map[string]plumbing.Hash),
- Shallows: []plumbing.Hash{},
- }
-}
-
-func (a *AdvRefs) AddReference(r *plumbing.Reference) error {
- switch r.Type() {
- case plumbing.SymbolicReference:
- v := fmt.Sprintf("%s:%s", r.Name().String(), r.Target().String())
- a.Capabilities.Add(capability.SymRef, v)
- case plumbing.HashReference:
- a.References[r.Name().String()] = r.Hash()
- default:
- return plumbing.ErrInvalidType
- }
-
- return nil
-}
-
-func (a *AdvRefs) AllReferences() (memory.ReferenceStorage, error) {
- s := memory.ReferenceStorage{}
- if err := addRefs(s, a); err != nil {
- return s, plumbing.NewUnexpectedError(err)
- }
-
- return s, nil
-}
-
-func addRefs(s storer.ReferenceStorer, ar *AdvRefs) error {
- for name, hash := range ar.References {
- ref := plumbing.NewReferenceFromStrings(name, hash.String())
- if err := s.SetReference(ref); err != nil {
- return err
- }
- }
-
- return addSymbolicRefs(s, ar)
-}
-
-func addSymbolicRefs(s storer.ReferenceStorer, ar *AdvRefs) error {
- if !hasSymrefs(ar) {
- return nil
- }
-
- for _, symref := range ar.Capabilities.Get(capability.SymRef) {
- chunks := strings.Split(symref, ":")
- if len(chunks) != 2 {
- err := fmt.Errorf("bad number of `:` in symref value (%q)", symref)
- return plumbing.NewUnexpectedError(err)
- }
- name := plumbing.ReferenceName(chunks[0])
- target := plumbing.ReferenceName(chunks[1])
- ref := plumbing.NewSymbolicReference(name, target)
- if err := s.SetReference(ref); err != nil {
- return nil
- }
- }
-
- return nil
-}
-
-func hasSymrefs(ar *AdvRefs) bool {
- return ar.Capabilities.Supports(capability.SymRef)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_decode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_decode.go
deleted file mode 100644
index e0a449ef64a5b54fd811de9aa1109202237bbc79..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_decode.go
+++ /dev/null
@@ -1,288 +0,0 @@
-package packp
-
-import (
- "bytes"
- "encoding/hex"
- "errors"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-// Decode reads the next advertised-refs message form its input and
-// stores it in the AdvRefs.
-func (a *AdvRefs) Decode(r io.Reader) error {
- d := newAdvRefsDecoder(r)
- return d.Decode(a)
-}
-
-type advRefsDecoder struct {
- s *pktline.Scanner // a pkt-line scanner from the input stream
- line []byte // current pkt-line contents, use parser.nextLine() to make it advance
- nLine int // current pkt-line number for debugging, begins at 1
- hash plumbing.Hash // last hash read
- err error // sticky error, use the parser.error() method to fill this out
- data *AdvRefs // parsed data is stored here
-}
-
-var (
- // ErrEmptyAdvRefs is returned by Decode if it gets an empty advertised
- // references message.
- ErrEmptyAdvRefs = errors.New("empty advertised-ref message")
- // ErrEmptyInput is returned by Decode if the input is empty.
- ErrEmptyInput = errors.New("empty input")
-)
-
-func newAdvRefsDecoder(r io.Reader) *advRefsDecoder {
- return &advRefsDecoder{
- s: pktline.NewScanner(r),
- }
-}
-
-func (d *advRefsDecoder) Decode(v *AdvRefs) error {
- d.data = v
-
- for state := decodePrefix; state != nil; {
- state = state(d)
- }
-
- return d.err
-}
-
-type decoderStateFn func(*advRefsDecoder) decoderStateFn
-
-// fills out the parser stiky error
-func (d *advRefsDecoder) error(format string, a ...interface{}) {
- msg := fmt.Sprintf(
- "pkt-line %d: %s", d.nLine,
- fmt.Sprintf(format, a...),
- )
-
- d.err = NewErrUnexpectedData(msg, d.line)
-}
-
-// Reads a new pkt-line from the scanner, makes its payload available as
-// p.line and increments p.nLine. A successful invocation returns true,
-// otherwise, false is returned and the sticky error is filled out
-// accordingly. Trims eols at the end of the payloads.
-func (d *advRefsDecoder) nextLine() bool {
- d.nLine++
-
- if !d.s.Scan() {
- if d.err = d.s.Err(); d.err != nil {
- return false
- }
-
- if d.nLine == 1 {
- d.err = ErrEmptyInput
- return false
- }
-
- d.error("EOF")
- return false
- }
-
- d.line = d.s.Bytes()
- d.line = bytes.TrimSuffix(d.line, eol)
-
- return true
-}
-
-// The HTTP smart prefix is often followed by a flush-pkt.
-func decodePrefix(d *advRefsDecoder) decoderStateFn {
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- if !isPrefix(d.line) {
- return decodeFirstHash
- }
-
- tmp := make([]byte, len(d.line))
- copy(tmp, d.line)
- d.data.Prefix = append(d.data.Prefix, tmp)
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- if !isFlush(d.line) {
- return decodeFirstHash
- }
-
- d.data.Prefix = append(d.data.Prefix, pktline.Flush)
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- return decodeFirstHash
-}
-
-func isPrefix(payload []byte) bool {
- return len(payload) > 0 && payload[0] == '#'
-}
-
-// If the first hash is zero, then a no-refs is coming. Otherwise, a
-// list-of-refs is coming, and the hash will be followed by the first
-// advertised ref.
-func decodeFirstHash(p *advRefsDecoder) decoderStateFn {
- // If the repository is empty, we receive a flush here (HTTP).
- if isFlush(p.line) {
- p.err = ErrEmptyAdvRefs
- return nil
- }
-
- if len(p.line) < hashSize {
- p.error("cannot read hash, pkt-line too short")
- return nil
- }
-
- if _, err := hex.Decode(p.hash[:], p.line[:hashSize]); err != nil {
- p.error("invalid hash text: %s", err)
- return nil
- }
-
- p.line = p.line[hashSize:]
-
- if p.hash.IsZero() {
- return decodeSkipNoRefs
- }
-
- return decodeFirstRef
-}
-
-// Skips SP "capabilities^{}" NUL
-func decodeSkipNoRefs(p *advRefsDecoder) decoderStateFn {
- if len(p.line) < len(noHeadMark) {
- p.error("too short zero-id ref")
- return nil
- }
-
- if !bytes.HasPrefix(p.line, noHeadMark) {
- p.error("malformed zero-id ref")
- return nil
- }
-
- p.line = p.line[len(noHeadMark):]
-
- return decodeCaps
-}
-
-// decode the refname, expectes SP refname NULL
-func decodeFirstRef(l *advRefsDecoder) decoderStateFn {
- if len(l.line) < 3 {
- l.error("line too short after hash")
- return nil
- }
-
- if !bytes.HasPrefix(l.line, sp) {
- l.error("no space after hash")
- return nil
- }
- l.line = l.line[1:]
-
- chunks := bytes.SplitN(l.line, null, 2)
- if len(chunks) < 2 {
- l.error("NULL not found")
- return nil
- }
- ref := chunks[0]
- l.line = chunks[1]
-
- if bytes.Equal(ref, []byte(head)) {
- l.data.Head = &l.hash
- } else {
- l.data.References[string(ref)] = l.hash
- }
-
- return decodeCaps
-}
-
-func decodeCaps(p *advRefsDecoder) decoderStateFn {
- if err := p.data.Capabilities.Decode(p.line); err != nil {
- p.error("invalid capabilities: %s", err)
- return nil
- }
-
- return decodeOtherRefs
-}
-
-// The refs are either tips (obj-id SP refname) or a peeled (obj-id SP refname^{}).
-// If there are no refs, then there might be a shallow or flush-ptk.
-func decodeOtherRefs(p *advRefsDecoder) decoderStateFn {
- if ok := p.nextLine(); !ok {
- return nil
- }
-
- if bytes.HasPrefix(p.line, shallow) {
- return decodeShallow
- }
-
- if len(p.line) == 0 {
- return nil
- }
-
- saveTo := p.data.References
- if bytes.HasSuffix(p.line, peeled) {
- p.line = bytes.TrimSuffix(p.line, peeled)
- saveTo = p.data.Peeled
- }
-
- ref, hash, err := readRef(p.line)
- if err != nil {
- p.error("%s", err)
- return nil
- }
- saveTo[ref] = hash
-
- return decodeOtherRefs
-}
-
-// Reads a ref-name
-func readRef(data []byte) (string, plumbing.Hash, error) {
- chunks := bytes.Split(data, sp)
- switch {
- case len(chunks) == 1:
- return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: no space was found")
- case len(chunks) > 2:
- return "", plumbing.ZeroHash, fmt.Errorf("malformed ref data: more than one space found")
- default:
- return string(chunks[1]), plumbing.NewHash(string(chunks[0])), nil
- }
-}
-
-// Keeps reading shallows until a flush-pkt is found
-func decodeShallow(p *advRefsDecoder) decoderStateFn {
- if !bytes.HasPrefix(p.line, shallow) {
- p.error("malformed shallow prefix, found %q... instead", p.line[:len(shallow)])
- return nil
- }
- p.line = bytes.TrimPrefix(p.line, shallow)
-
- if len(p.line) != hashSize {
- p.error(fmt.Sprintf(
- "malformed shallow hash: wrong length, expected 40 bytes, read %d bytes",
- len(p.line)))
- return nil
- }
-
- text := p.line[:hashSize]
- var h plumbing.Hash
- if _, err := hex.Decode(h[:], text); err != nil {
- p.error("invalid hash text: %s", err)
- return nil
- }
-
- p.data.Shallows = append(p.data.Shallows, h)
-
- if ok := p.nextLine(); !ok {
- return nil
- }
-
- if len(p.line) == 0 {
- return nil // succesfull parse of the advertised-refs message
- }
-
- return decodeShallow
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_encode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_encode.go
deleted file mode 100644
index e981120e5425ff4824e53080d5052671cc8bca2f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/advrefs_encode.go
+++ /dev/null
@@ -1,156 +0,0 @@
-package packp
-
-import (
- "bytes"
- "io"
- "sort"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-// Encode writes the AdvRefs encoding to a writer.
-//
-// All the payloads will end with a newline character. Capabilities,
-// references and shallows are written in alphabetical order, except for
-// peeled references that always follow their corresponding references.
-func (a *AdvRefs) Encode(w io.Writer) error {
- e := newAdvRefsEncoder(w)
- return e.Encode(a)
-}
-
-type advRefsEncoder struct {
- data *AdvRefs // data to encode
- pe *pktline.Encoder // where to write the encoded data
- err error // sticky error
-}
-
-func newAdvRefsEncoder(w io.Writer) *advRefsEncoder {
- return &advRefsEncoder{
- pe: pktline.NewEncoder(w),
- }
-}
-
-func (e *advRefsEncoder) Encode(v *AdvRefs) error {
- e.data = v
-
- for state := encodePrefix; state != nil; {
- state = state(e)
- }
-
- return e.err
-}
-
-type encoderStateFn func(*advRefsEncoder) encoderStateFn
-
-func encodePrefix(e *advRefsEncoder) encoderStateFn {
- for _, p := range e.data.Prefix {
- if bytes.Equal(p, pktline.Flush) {
- if e.err = e.pe.Flush(); e.err != nil {
- return nil
- }
- continue
- }
- if e.err = e.pe.Encodef("%s\n", string(p)); e.err != nil {
- return nil
- }
- }
-
- return encodeFirstLine
-}
-
-// Adds the first pkt-line payload: head hash, head ref and capabilities.
-// Also handle the special case when no HEAD ref is found.
-func encodeFirstLine(e *advRefsEncoder) encoderStateFn {
- head := formatHead(e.data.Head)
- separator := formatSeparator(e.data.Head)
- capabilities := formatCaps(e.data.Capabilities)
-
- if e.err = e.pe.Encodef("%s %s\x00%s\n", head, separator, capabilities); e.err != nil {
- return nil
- }
-
- return encodeRefs
-}
-
-func formatHead(h *plumbing.Hash) string {
- if h == nil {
- return plumbing.ZeroHash.String()
- }
-
- return h.String()
-}
-
-func formatSeparator(h *plumbing.Hash) string {
- if h == nil {
- return noHead
- }
-
- return head
-}
-
-func formatCaps(c *capability.List) string {
- if c == nil {
- return ""
- }
-
- return c.String()
-}
-
-// Adds the (sorted) refs: hash SP refname EOL
-// and their peeled refs if any.
-func encodeRefs(e *advRefsEncoder) encoderStateFn {
- refs := sortRefs(e.data.References)
- for _, r := range refs {
- hash, _ := e.data.References[r]
- if e.err = e.pe.Encodef("%s %s\n", hash.String(), r); e.err != nil {
- return nil
- }
-
- if hash, ok := e.data.Peeled[r]; ok {
- if e.err = e.pe.Encodef("%s %s^{}\n", hash.String(), r); e.err != nil {
- return nil
- }
- }
- }
-
- return encodeShallow
-}
-
-func sortRefs(m map[string]plumbing.Hash) []string {
- ret := make([]string, 0, len(m))
- for k := range m {
- ret = append(ret, k)
- }
- sort.Strings(ret)
-
- return ret
-}
-
-// Adds the (sorted) shallows: "shallow" SP hash EOL
-func encodeShallow(e *advRefsEncoder) encoderStateFn {
- sorted := sortShallows(e.data.Shallows)
- for _, hash := range sorted {
- if e.err = e.pe.Encodef("shallow %s\n", hash); e.err != nil {
- return nil
- }
- }
-
- return encodeFlush
-}
-
-func sortShallows(c []plumbing.Hash) []string {
- ret := []string{}
- for _, h := range c {
- ret = append(ret, h.String())
- }
- sort.Strings(ret)
-
- return ret
-}
-
-func encodeFlush(e *advRefsEncoder) encoderStateFn {
- e.err = e.pe.Flush()
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/capability.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/capability.go
deleted file mode 100644
index 96d93f697c3907fbc5ae711f5d49bb426d95ff2d..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/capability.go
+++ /dev/null
@@ -1,252 +0,0 @@
-// Package capability defines the server and client capabilities.
-package capability
-
-// Capability describes a server or client capability.
-type Capability string
-
-func (n Capability) String() string {
- return string(n)
-}
-
-const (
- // MultiACK capability allows the server to return "ACK obj-id continue" as
- // soon as it finds a commit that it can use as a common base, between the
- // client's wants and the client's have set.
- //
- // By sending this early, the server can potentially head off the client
- // from walking any further down that particular branch of the client's
- // repository history. The client may still need to walk down other
- // branches, sending have lines for those, until the server has a
- // complete cut across the DAG, or the client has said "done".
- //
- // Without multi_ack, a client sends have lines in --date-order until
- // the server has found a common base. That means the client will send
- // have lines that are already known by the server to be common, because
- // they overlap in time with another branch that the server hasn't found
- // a common base on yet.
- //
- // For example suppose the client has commits in caps that the server
- // doesn't and the server has commits in lower case that the client
- // doesn't, as in the following diagram:
- //
- // +---- u ---------------------- x
- // / +----- y
- // / /
- // a -- b -- c -- d -- E -- F
- // \
- // +--- Q -- R -- S
- //
- // If the client wants x,y and starts out by saying have F,S, the server
- // doesn't know what F,S is. Eventually the client says "have d" and
- // the server sends "ACK d continue" to let the client know to stop
- // walking down that line (so don't send c-b-a), but it's not done yet,
- // it needs a base for x. The client keeps going with S-R-Q, until a
- // gets reached, at which point the server has a clear base and it all
- // ends.
- //
- // Without multi_ack the client would have sent that c-b-a chain anyway,
- // interleaved with S-R-Q.
- MultiACK Capability = "multi_ack"
- // MultiACKDetailed is an extension of multi_ack that permits client to
- // better understand the server's in-memory state.
- MultiACKDetailed Capability = "multi_ack_detailed"
- // NoDone should only be used with the smart HTTP protocol. If
- // multi_ack_detailed and no-done are both present, then the sender is
- // free to immediately send a pack following its first "ACK obj-id ready"
- // message.
- //
- // Without no-done in the smart HTTP protocol, the server session would
- // end and the client has to make another trip to send "done" before
- // the server can send the pack. no-done removes the last round and
- // thus slightly reduces latency.
- NoDone Capability = "no-done"
- // ThinPack is one with deltas which reference base objects not
- // contained within the pack (but are known to exist at the receiving
- // end). This can reduce the network traffic significantly, but it
- // requires the receiving end to know how to "thicken" these packs by
- // adding the missing bases to the pack.
- //
- // The upload-pack server advertises 'thin-pack' when it can generate
- // and send a thin pack. A client requests the 'thin-pack' capability
- // when it understands how to "thicken" it, notifying the server that
- // it can receive such a pack. A client MUST NOT request the
- // 'thin-pack' capability if it cannot turn a thin pack into a
- // self-contained pack.
- //
- // Receive-pack, on the other hand, is assumed by default to be able to
- // handle thin packs, but can ask the client not to use the feature by
- // advertising the 'no-thin' capability. A client MUST NOT send a thin
- // pack if the server advertises the 'no-thin' capability.
- //
- // The reasons for this asymmetry are historical. The receive-pack
- // program did not exist until after the invention of thin packs, so
- // historically the reference implementation of receive-pack always
- // understood thin packs. Adding 'no-thin' later allowed receive-pack
- // to disable the feature in a backwards-compatible manner.
- ThinPack Capability = "thin-pack"
- // Sideband means that server can send, and client understand multiplexed
- // progress reports and error info interleaved with the packfile itself.
- //
- // These two options are mutually exclusive. A modern client always
- // favors Sideband64k.
- //
- // Either mode indicates that the packfile data will be streamed broken
- // up into packets of up to either 1000 bytes in the case of 'side_band',
- // or 65520 bytes in the case of 'side_band_64k'. Each packet is made up
- // of a leading 4-byte pkt-line length of how much data is in the packet,
- // followed by a 1-byte stream code, followed by the actual data.
- //
- // The stream code can be one of:
- //
- // 1 - pack data
- // 2 - progress messages
- // 3 - fatal error message just before stream aborts
- //
- // The "side-band-64k" capability came about as a way for newer clients
- // that can handle much larger packets to request packets that are
- // actually crammed nearly full, while maintaining backward compatibility
- // for the older clients.
- //
- // Further, with side-band and its up to 1000-byte messages, it's actually
- // 999 bytes of payload and 1 byte for the stream code. With side-band-64k,
- // same deal, you have up to 65519 bytes of data and 1 byte for the stream
- // code.
- //
- // The client MUST send only maximum of one of "side-band" and "side-
- // band-64k". Server MUST diagnose it as an error if client requests
- // both.
- Sideband Capability = "side-band"
- Sideband64k Capability = "side-band-64k"
- // OFSDelta server can send, and client understand PACKv2 with delta
- // referring to its base by position in pack rather than by an obj-id. That
- // is, they can send/read OBJ_OFS_DELTA (aka type 6) in a packfile.
- OFSDelta Capability = "ofs-delta"
- // Agent the server may optionally send this capability to notify the client
- // that the server is running version `X`. The client may optionally return
- // its own agent string by responding with an `agent=Y` capability (but it
- // MUST NOT do so if the server did not mention the agent capability). The
- // `X` and `Y` strings may contain any printable ASCII characters except
- // space (i.e., the byte range 32 < x < 127), and are typically of the form
- // "package/version" (e.g., "git/1.8.3.1"). The agent strings are purely
- // informative for statistics and debugging purposes, and MUST NOT be used
- // to programmatically assume the presence or absence of particular features.
- Agent Capability = "agent"
- // Shallow capability adds "deepen", "shallow" and "unshallow" commands to
- // the fetch-pack/upload-pack protocol so clients can request shallow
- // clones.
- Shallow Capability = "shallow"
- // DeepenSince adds "deepen-since" command to fetch-pack/upload-pack
- // protocol so the client can request shallow clones that are cut at a
- // specific time, instead of depth. Internally it's equivalent of doing
- // "rev-list --max-age=<timestamp>" on the server side. "deepen-since"
- // cannot be used with "deepen".
- DeepenSince Capability = "deepen-since"
- // DeepenNot adds "deepen-not" command to fetch-pack/upload-pack
- // protocol so the client can request shallow clones that are cut at a
- // specific revision, instead of depth. Internally it's equivalent of
- // doing "rev-list --not <rev>" on the server side. "deepen-not"
- // cannot be used with "deepen", but can be used with "deepen-since".
- DeepenNot Capability = "deepen-not"
- // DeepenRelative if this capability is requested by the client, the
- // semantics of "deepen" command is changed. The "depth" argument is the
- // depth from the current shallow boundary, instead of the depth from
- // remote refs.
- DeepenRelative Capability = "deepen-relative"
- // NoProgress the client was started with "git clone -q" or something, and
- // doesn't want that side band 2. Basically the client just says "I do not
- // wish to receive stream 2 on sideband, so do not send it to me, and if
- // you did, I will drop it on the floor anyway". However, the sideband
- // channel 3 is still used for error responses.
- NoProgress Capability = "no-progress"
- // IncludeTag capability is about sending annotated tags if we are
- // sending objects they point to. If we pack an object to the client, and
- // a tag object points exactly at that object, we pack the tag object too.
- // In general this allows a client to get all new annotated tags when it
- // fetches a branch, in a single network connection.
- //
- // Clients MAY always send include-tag, hardcoding it into a request when
- // the server advertises this capability. The decision for a client to
- // request include-tag only has to do with the client's desires for tag
- // data, whether or not a server had advertised objects in the
- // refs/tags/* namespace.
- //
- // Servers MUST pack the tags if their referrant is packed and the client
- // has requested include-tags.
- //
- // Clients MUST be prepared for the case where a server has ignored
- // include-tag and has not actually sent tags in the pack. In such
- // cases the client SHOULD issue a subsequent fetch to acquire the tags
- // that include-tag would have otherwise given the client.
- //
- // The server SHOULD send include-tag, if it supports it, regardless
- // of whether or not there are tags available.
- IncludeTag Capability = "include-tag"
- // ReportStatus the receive-pack process can receive a 'report-status'
- // capability, which tells it that the client wants a report of what
- // happened after a packfile upload and reference update. If the pushing
- // client requests this capability, after unpacking and updating references
- // the server will respond with whether the packfile unpacked successfully
- // and if each reference was updated successfully. If any of those were not
- // successful, it will send back an error message. See pack-protocol.txt
- // for example messages.
- ReportStatus Capability = "report-status"
- // DeleteRefs If the server sends back this capability, it means that
- // it is capable of accepting a zero-id value as the target
- // value of a reference update. It is not sent back by the client, it
- // simply informs the client that it can be sent zero-id values
- // to delete references
- DeleteRefs Capability = "delete-refs"
- // Quiet If the receive-pack server advertises this capability, it is
- // capable of silencing human-readable progress output which otherwise may
- // be shown when processing the received pack. A send-pack client should
- // respond with the 'quiet' capability to suppress server-side progress
- // reporting if the local progress reporting is also being suppressed
- // (e.g., via `push -q`, or if stderr does not go to a tty).
- Quiet Capability = "quiet"
- // Atomic If the server sends this capability it is capable of accepting
- // atomic pushes. If the pushing client requests this capability, the server
- // will update the refs in one atomic transaction. Either all refs are
- // updated or none.
- Atomic Capability = "atomic"
- // PushOptions If the server sends this capability it is able to accept
- // push options after the update commands have been sent, but before the
- // packfile is streamed. If the pushing client requests this capability,
- // the server will pass the options to the pre- and post- receive hooks
- // that process this push request.
- PushOptions Capability = "push-options"
- // AllowTipSHA1InWant if the upload-pack server advertises this capability,
- // fetch-pack may send "want" lines with SHA-1s that exist at the server but
- // are not advertised by upload-pack.
- AllowTipSHA1InWant Capability = "allow-tip-sha1-in-want"
- // AllowReachableSHA1InWant if the upload-pack server advertises this
- // capability, fetch-pack may send "want" lines with SHA-1s that exist at
- // the server but are not advertised by upload-pack.
- AllowReachableSHA1InWant Capability = "allow-reachable-sha1-in-want"
- // PushCert the receive-pack server that advertises this capability is
- // willing to accept a signed push certificate, and asks the <nonce> to be
- // included in the push certificate. A send-pack client MUST NOT
- // send a push-cert packet unless the receive-pack server advertises
- // this capability.
- PushCert Capability = "push-cert"
- // SymRef symbolic reference support for better negotiation.
- SymRef Capability = "symref"
-)
-
-const DefaultAgent = "go-git/4.x"
-
-var valid = map[Capability]bool{
- MultiACK: true, MultiACKDetailed: true, NoDone: true, ThinPack: true,
- Sideband: true, Sideband64k: true, OFSDelta: true, Agent: true,
- Shallow: true, DeepenSince: true, DeepenNot: true, DeepenRelative: true,
- NoProgress: true, IncludeTag: true, ReportStatus: true, DeleteRefs: true,
- Quiet: true, Atomic: true, PushOptions: true, AllowTipSHA1InWant: true,
- AllowReachableSHA1InWant: true, PushCert: true, SymRef: true,
-}
-
-var requiresArgument = map[Capability]bool{
- Agent: true, PushCert: true, SymRef: true,
-}
-
-var multipleArgument = map[Capability]bool{
- SymRef: true,
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/list.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/list.go
deleted file mode 100644
index 69fdb5134b8c487b33fa8c7ef890997d9dc2ecd9..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability/list.go
+++ /dev/null
@@ -1,197 +0,0 @@
-package capability
-
-import (
- "bytes"
- "errors"
- "fmt"
- "strings"
-)
-
-var (
- // ErrUnknownCapability is returned if a unknown capability is given
- ErrUnknownCapability = errors.New("unknown capability")
- // ErrArgumentsRequired is returned if no arguments are giving with a
- // capability that requires arguments
- ErrArgumentsRequired = errors.New("arguments required")
- // ErrArguments is returned if arguments are given with a capabilities that
- // not supports arguments
- ErrArguments = errors.New("arguments not allowed")
- // ErrEmtpyArgument is returned when an empty value is given
- ErrEmtpyArgument = errors.New("empty argument")
- // ErrMultipleArguments multiple argument given to a capabilities that not
- // support it
- ErrMultipleArguments = errors.New("multiple arguments not allowed")
-)
-
-// List represents a list of capabilities
-type List struct {
- m map[Capability]*entry
- sort []string
-}
-
-type entry struct {
- Name Capability
- Values []string
-}
-
-// NewList returns a new List of capabilities
-func NewList() *List {
- return &List{
- m: make(map[Capability]*entry),
- }
-}
-
-// IsEmpty returns true if the List is empty
-func (l *List) IsEmpty() bool {
- return len(l.sort) == 0
-}
-
-// Decode decodes list of capabilities from raw into the list
-func (l *List) Decode(raw []byte) error {
- // git 1.x receive pack used to send a leading space on its
- // git-receive-pack capabilities announcement. We just trim space to be
- // tolerant to space changes in different versions.
- raw = bytes.TrimSpace(raw)
-
- if len(raw) == 0 {
- return nil
- }
-
- for _, data := range bytes.Split(raw, []byte{' '}) {
- pair := bytes.SplitN(data, []byte{'='}, 2)
-
- c := Capability(pair[0])
- if len(pair) == 1 {
- if err := l.Add(c); err != nil {
- return err
- }
-
- continue
- }
-
- if err := l.Add(c, string(pair[1])); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// Get returns the values for a capability
-func (l *List) Get(capability Capability) []string {
- if _, ok := l.m[capability]; !ok {
- return nil
- }
-
- return l.m[capability].Values
-}
-
-// Set sets a capability removing the previous values
-func (l *List) Set(capability Capability, values ...string) error {
- if _, ok := l.m[capability]; ok {
- delete(l.m, capability)
- }
-
- return l.Add(capability, values...)
-}
-
-// Add adds a capability, values are optional
-func (l *List) Add(c Capability, values ...string) error {
- if err := l.validate(c, values); err != nil {
- return err
- }
-
- if !l.Supports(c) {
- l.m[c] = &entry{Name: c}
- l.sort = append(l.sort, c.String())
- }
-
- if len(values) == 0 {
- return nil
- }
-
- if !multipleArgument[c] && len(l.m[c].Values) > 0 {
- return ErrMultipleArguments
- }
-
- l.m[c].Values = append(l.m[c].Values, values...)
- return nil
-}
-
-func (l *List) validate(c Capability, values []string) error {
- if _, ok := valid[c]; !ok {
- return ErrUnknownCapability
- }
-
- if requiresArgument[c] && len(values) == 0 {
- return ErrArgumentsRequired
- }
-
- if !requiresArgument[c] && len(values) != 0 {
- return ErrArguments
- }
-
- if !multipleArgument[c] && len(values) > 1 {
- return ErrMultipleArguments
- }
-
- for _, v := range values {
- if v == "" {
- return ErrEmtpyArgument
- }
- }
-
- return nil
-}
-
-// Supports returns true if capability is present
-func (l *List) Supports(capability Capability) bool {
- _, ok := l.m[capability]
- return ok
-}
-
-// Delete deletes a capability from the List
-func (l *List) Delete(capability Capability) {
- if !l.Supports(capability) {
- return
- }
-
- delete(l.m, capability)
- for i, c := range l.sort {
- if c != string(capability) {
- continue
- }
-
- l.sort = append(l.sort[:i], l.sort[i+1:]...)
- return
- }
-}
-
-// All returns a slice with all defined capabilities.
-func (l *List) All() []Capability {
- var cs []Capability
- for _, key := range l.sort {
- cs = append(cs, Capability(key))
- }
-
- return cs
-}
-
-// String generates the capabilities strings, the capabilities are sorted in
-// insertion order
-func (l *List) String() string {
- var o []string
- for _, key := range l.sort {
- cap := l.m[Capability(key)]
- if len(cap.Values) == 0 {
- o = append(o, key)
- continue
- }
-
- for _, value := range cap.Values {
- o = append(o, fmt.Sprintf("%s=%s", key, value))
- }
- }
-
- return strings.Join(o, " ")
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/common.go
deleted file mode 100644
index ab07ac8f74fd7fe63aaef2ee895f8c79c02acb36..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/common.go
+++ /dev/null
@@ -1,70 +0,0 @@
-package packp
-
-import (
- "fmt"
-)
-
-type stateFn func() stateFn
-
-const (
- // common
- hashSize = 40
-
- // advrefs
- head = "HEAD"
- noHead = "capabilities^{}"
-)
-
-var (
- // common
- sp = []byte(" ")
- eol = []byte("\n")
- eq = []byte{'='}
-
- // advertised-refs
- null = []byte("\x00")
- peeled = []byte("^{}")
- noHeadMark = []byte(" capabilities^{}\x00")
-
- // upload-request
- want = []byte("want ")
- shallow = []byte("shallow ")
- deepen = []byte("deepen")
- deepenCommits = []byte("deepen ")
- deepenSince = []byte("deepen-since ")
- deepenReference = []byte("deepen-not ")
-
- // shallow-update
- unshallow = []byte("unshallow ")
-
- // server-response
- ack = []byte("ACK")
- nak = []byte("NAK")
-
- // updreq
- shallowNoSp = []byte("shallow")
-)
-
-func isFlush(payload []byte) bool {
- return len(payload) == 0
-}
-
-// ErrUnexpectedData represents an unexpected data decoding a message
-type ErrUnexpectedData struct {
- Msg string
- Data []byte
-}
-
-// NewErrUnexpectedData returns a new ErrUnexpectedData containing the data and
-// the message given
-func NewErrUnexpectedData(msg string, data []byte) error {
- return &ErrUnexpectedData{Msg: msg, Data: data}
-}
-
-func (err *ErrUnexpectedData) Error() string {
- if len(err.Data) == 0 {
- return err.Msg
- }
-
- return fmt.Sprintf("%s (%s)", err.Msg, err.Data)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/doc.go
deleted file mode 100644
index 4950d1d6625b91ba50bbc2ba3c3d324080b601f2..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/doc.go
+++ /dev/null
@@ -1,724 +0,0 @@
-package packp
-
-/*
-
-A nice way to trace the real data transmitted and received by git, use:
-
-GIT_TRACE_PACKET=true git ls-remote http://github.com/src-d/go-git
-GIT_TRACE_PACKET=true git clone http://github.com/src-d/go-git
-
-Here follows a copy of the current protocol specification at the time of
-this writing.
-
-(Please notice that most http git servers will add a flush-pkt after the
-first pkt-line when using HTTP smart.)
-
-
-Documentation Common to Pack and Http Protocols
-===============================================
-
-ABNF Notation
--------------
-
-ABNF notation as described by RFC 5234 is used within the protocol documents,
-except the following replacement core rules are used:
-----
- HEXDIG = DIGIT / "a" / "b" / "c" / "d" / "e" / "f"
-----
-
-We also define the following common rules:
-----
- NUL = %x00
- zero-id = 40*"0"
- obj-id = 40*(HEXDIGIT)
-
- refname = "HEAD"
- refname /= "refs/" <see discussion below>
-----
-
-A refname is a hierarchical octet string beginning with "refs/" and
-not violating the 'git-check-ref-format' command's validation rules.
-More specifically, they:
-
-. They can include slash `/` for hierarchical (directory)
- grouping, but no slash-separated component can begin with a
- dot `.`.
-
-. They must contain at least one `/`. This enforces the presence of a
- category like `heads/`, `tags/` etc. but the actual names are not
- restricted.
-
-. They cannot have two consecutive dots `..` anywhere.
-
-. They cannot have ASCII control characters (i.e. bytes whose
- values are lower than \040, or \177 `DEL`), space, tilde `~`,
- caret `^`, colon `:`, question-mark `?`, asterisk `*`,
- or open bracket `[` anywhere.
-
-. They cannot end with a slash `/` or a dot `.`.
-
-. They cannot end with the sequence `.lock`.
-
-. They cannot contain a sequence `@{`.
-
-. They cannot contain a `\\`.
-
-
-pkt-line Format
----------------
-
-Much (but not all) of the payload is described around pkt-lines.
-
-A pkt-line is a variable length binary string. The first four bytes
-of the line, the pkt-len, indicates the total length of the line,
-in hexadecimal. The pkt-len includes the 4 bytes used to contain
-the length's hexadecimal representation.
-
-A pkt-line MAY contain binary data, so implementors MUST ensure
-pkt-line parsing/formatting routines are 8-bit clean.
-
-A non-binary line SHOULD BE terminated by an LF, which if present
-MUST be included in the total length. Receivers MUST treat pkt-lines
-with non-binary data the same whether or not they contain the trailing
-LF (stripping the LF if present, and not complaining when it is
-missing).
-
-The maximum length of a pkt-line's data component is 65516 bytes.
-Implementations MUST NOT send pkt-line whose length exceeds 65520
-(65516 bytes of payload + 4 bytes of length data).
-
-Implementations SHOULD NOT send an empty pkt-line ("0004").
-
-A pkt-line with a length field of 0 ("0000"), called a flush-pkt,
-is a special case and MUST be handled differently than an empty
-pkt-line ("0004").
-
-----
- pkt-line = data-pkt / flush-pkt
-
- data-pkt = pkt-len pkt-payload
- pkt-len = 4*(HEXDIG)
- pkt-payload = (pkt-len - 4)*(OCTET)
-
- flush-pkt = "0000"
-----
-
-Examples (as C-style strings):
-
-----
- pkt-line actual value
- ---------------------------------
- "0006a\n" "a\n"
- "0005a" "a"
- "000bfoobar\n" "foobar\n"
- "0004" ""
-----
-
-Packfile transfer protocols
-===========================
-
-Git supports transferring data in packfiles over the ssh://, git://, http:// and
-file:// transports. There exist two sets of protocols, one for pushing
-data from a client to a server and another for fetching data from a
-server to a client. The three transports (ssh, git, file) use the same
-protocol to transfer data. http is documented in http-protocol.txt.
-
-The processes invoked in the canonical Git implementation are 'upload-pack'
-on the server side and 'fetch-pack' on the client side for fetching data;
-then 'receive-pack' on the server and 'send-pack' on the client for pushing
-data. The protocol functions to have a server tell a client what is
-currently on the server, then for the two to negotiate the smallest amount
-of data to send in order to fully update one or the other.
-
-pkt-line Format
----------------
-
-The descriptions below build on the pkt-line format described in
-protocol-common.txt. When the grammar indicate `PKT-LINE(...)`, unless
-otherwise noted the usual pkt-line LF rules apply: the sender SHOULD
-include a LF, but the receiver MUST NOT complain if it is not present.
-
-Transports
-----------
-There are three transports over which the packfile protocol is
-initiated. The Git transport is a simple, unauthenticated server that
-takes the command (almost always 'upload-pack', though Git
-servers can be configured to be globally writable, in which 'receive-
-pack' initiation is also allowed) with which the client wishes to
-communicate and executes it and connects it to the requesting
-process.
-
-In the SSH transport, the client just runs the 'upload-pack'
-or 'receive-pack' process on the server over the SSH protocol and then
-communicates with that invoked process over the SSH connection.
-
-The file:// transport runs the 'upload-pack' or 'receive-pack'
-process locally and communicates with it over a pipe.
-
-Git Transport
--------------
-
-The Git transport starts off by sending the command and repository
-on the wire using the pkt-line format, followed by a NUL byte and a
-hostname parameter, terminated by a NUL byte.
-
- 0032git-upload-pack /project.git\0host=myserver.com\0
-
---
- git-proto-request = request-command SP pathname NUL [ host-parameter NUL ]
- request-command = "git-upload-pack" / "git-receive-pack" /
- "git-upload-archive" ; case sensitive
- pathname = *( %x01-ff ) ; exclude NUL
- host-parameter = "host=" hostname [ ":" port ]
---
-
-Only host-parameter is allowed in the git-proto-request. Clients
-MUST NOT attempt to send additional parameters. It is used for the
-git-daemon name based virtual hosting. See --interpolated-path
-option to git daemon, with the %H/%CH format characters.
-
-Basically what the Git client is doing to connect to an 'upload-pack'
-process on the server side over the Git protocol is this:
-
- $ echo -e -n \
- "0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
- nc -v example.com 9418
-
-If the server refuses the request for some reasons, it could abort
-gracefully with an error message.
-
-----
- error-line = PKT-LINE("ERR" SP explanation-text)
-----
-
-
-SSH Transport
--------------
-
-Initiating the upload-pack or receive-pack processes over SSH is
-executing the binary on the server via SSH remote execution.
-It is basically equivalent to running this:
-
- $ ssh git.example.com "git-upload-pack '/project.git'"
-
-For a server to support Git pushing and pulling for a given user over
-SSH, that user needs to be able to execute one or both of those
-commands via the SSH shell that they are provided on login. On some
-systems, that shell access is limited to only being able to run those
-two commands, or even just one of them.
-
-In an ssh:// format URI, it's absolute in the URI, so the '/' after
-the host name (or port number) is sent as an argument, which is then
-read by the remote git-upload-pack exactly as is, so it's effectively
-an absolute path in the remote filesystem.
-
- git clone ssh://user@example.com/project.git
- |
- v
- ssh user@example.com "git-upload-pack '/project.git'"
-
-In a "user@host:path" format URI, its relative to the user's home
-directory, because the Git client will run:
-
- git clone user@example.com:project.git
- |
- v
- ssh user@example.com "git-upload-pack 'project.git'"
-
-The exception is if a '~' is used, in which case
-we execute it without the leading '/'.
-
- ssh://user@example.com/~alice/project.git,
- |
- v
- ssh user@example.com "git-upload-pack '~alice/project.git'"
-
-A few things to remember here:
-
-- The "command name" is spelled with dash (e.g. git-upload-pack), but
- this can be overridden by the client;
-
-- The repository path is always quoted with single quotes.
-
-Fetching Data From a Server
----------------------------
-
-When one Git repository wants to get data that a second repository
-has, the first can 'fetch' from the second. This operation determines
-what data the server has that the client does not then streams that
-data down to the client in packfile format.
-
-
-Reference Discovery
--------------------
-
-When the client initially connects the server will immediately respond
-with a listing of each reference it has (all branches and tags) along
-with the object name that each reference currently points to.
-
- $ echo -e -n "0039git-upload-pack /schacon/gitbook.git\0host=example.com\0" |
- nc -v example.com 9418
- 00887217a7c7e582c46cec22a130adf4b9d7d950fba0 HEAD\0multi_ack thin-pack
- side-band side-band-64k ofs-delta shallow no-progress include-tag
- 00441d3fcd5ced445d1abc402225c0b8a1299641f497 refs/heads/integration
- 003f7217a7c7e582c46cec22a130adf4b9d7d950fba0 refs/heads/master
- 003cb88d2441cac0977faf98efc80305012112238d9d refs/tags/v0.9
- 003c525128480b96c89e6418b1e40909bf6c5b2d580f refs/tags/v1.0
- 003fe92df48743b7bc7d26bcaabfddde0a1e20cae47c refs/tags/v1.0^{}
- 0000
-
-The returned response is a pkt-line stream describing each ref and
-its current value. The stream MUST be sorted by name according to
-the C locale ordering.
-
-If HEAD is a valid ref, HEAD MUST appear as the first advertised
-ref. If HEAD is not a valid ref, HEAD MUST NOT appear in the
-advertisement list at all, but other refs may still appear.
-
-The stream MUST include capability declarations behind a NUL on the
-first ref. The peeled value of a ref (that is "ref^{}") MUST be
-immediately after the ref itself, if presented. A conforming server
-MUST peel the ref if it's an annotated tag.
-
-----
- advertised-refs = (no-refs / list-of-refs)
- *shallow
- flush-pkt
-
- no-refs = PKT-LINE(zero-id SP "capabilities^{}"
- NUL capability-list)
-
- list-of-refs = first-ref *other-ref
- first-ref = PKT-LINE(obj-id SP refname
- NUL capability-list)
-
- other-ref = PKT-LINE(other-tip / other-peeled)
- other-tip = obj-id SP refname
- other-peeled = obj-id SP refname "^{}"
-
- shallow = PKT-LINE("shallow" SP obj-id)
-
- capability-list = capability *(SP capability)
- capability = 1*(LC_ALPHA / DIGIT / "-" / "_")
- LC_ALPHA = %x61-7A
-----
-
-Server and client MUST use lowercase for obj-id, both MUST treat obj-id
-as case-insensitive.
-
-See protocol-capabilities.txt for a list of allowed server capabilities
-and descriptions.
-
-Packfile Negotiation
---------------------
-After reference and capabilities discovery, the client can decide to
-terminate the connection by sending a flush-pkt, telling the server it can
-now gracefully terminate, and disconnect, when it does not need any pack
-data. This can happen with the ls-remote command, and also can happen when
-the client already is up-to-date.
-
-Otherwise, it enters the negotiation phase, where the client and
-server determine what the minimal packfile necessary for transport is,
-by telling the server what objects it wants, its shallow objects
-(if any), and the maximum commit depth it wants (if any). The client
-will also send a list of the capabilities it wants to be in effect,
-out of what the server said it could do with the first 'want' line.
-
-----
- upload-request = want-list
- *shallow-line
- *1depth-request
- flush-pkt
-
- want-list = first-want
- *additional-want
-
- shallow-line = PKT-LINE("shallow" SP obj-id)
-
- depth-request = PKT-LINE("deepen" SP depth) /
- PKT-LINE("deepen-since" SP timestamp) /
- PKT-LINE("deepen-not" SP ref)
-
- first-want = PKT-LINE("want" SP obj-id SP capability-list)
- additional-want = PKT-LINE("want" SP obj-id)
-
- depth = 1*DIGIT
-----
-
-Clients MUST send all the obj-ids it wants from the reference
-discovery phase as 'want' lines. Clients MUST send at least one
-'want' command in the request body. Clients MUST NOT mention an
-obj-id in a 'want' command which did not appear in the response
-obtained through ref discovery.
-
-The client MUST write all obj-ids which it only has shallow copies
-of (meaning that it does not have the parents of a commit) as
-'shallow' lines so that the server is aware of the limitations of
-the client's history.
-
-The client now sends the maximum commit history depth it wants for
-this transaction, which is the number of commits it wants from the
-tip of the history, if any, as a 'deepen' line. A depth of 0 is the
-same as not making a depth request. The client does not want to receive
-any commits beyond this depth, nor does it want objects needed only to
-complete those commits. Commits whose parents are not received as a
-result are defined as shallow and marked as such in the server. This
-information is sent back to the client in the next step.
-
-Once all the 'want's and 'shallow's (and optional 'deepen') are
-transferred, clients MUST send a flush-pkt, to tell the server side
-that it is done sending the list.
-
-Otherwise, if the client sent a positive depth request, the server
-will determine which commits will and will not be shallow and
-send this information to the client. If the client did not request
-a positive depth, this step is skipped.
-
-----
- shallow-update = *shallow-line
- *unshallow-line
- flush-pkt
-
- shallow-line = PKT-LINE("shallow" SP obj-id)
-
- unshallow-line = PKT-LINE("unshallow" SP obj-id)
-----
-
-If the client has requested a positive depth, the server will compute
-the set of commits which are no deeper than the desired depth. The set
-of commits start at the client's wants.
-
-The server writes 'shallow' lines for each
-commit whose parents will not be sent as a result. The server writes
-an 'unshallow' line for each commit which the client has indicated is
-shallow, but is no longer shallow at the currently requested depth
-(that is, its parents will now be sent). The server MUST NOT mark
-as unshallow anything which the client has not indicated was shallow.
-
-Now the client will send a list of the obj-ids it has using 'have'
-lines, so the server can make a packfile that only contains the objects
-that the client needs. In multi_ack mode, the canonical implementation
-will send up to 32 of these at a time, then will send a flush-pkt. The
-canonical implementation will skip ahead and send the next 32 immediately,
-so that there is always a block of 32 "in-flight on the wire" at a time.
-
-----
- upload-haves = have-list
- compute-end
-
- have-list = *have-line
- have-line = PKT-LINE("have" SP obj-id)
- compute-end = flush-pkt / PKT-LINE("done")
-----
-
-If the server reads 'have' lines, it then will respond by ACKing any
-of the obj-ids the client said it had that the server also has. The
-server will ACK obj-ids differently depending on which ack mode is
-chosen by the client.
-
-In multi_ack mode:
-
- * the server will respond with 'ACK obj-id continue' for any common
- commits.
-
- * once the server has found an acceptable common base commit and is
- ready to make a packfile, it will blindly ACK all 'have' obj-ids
- back to the client.
-
- * the server will then send a 'NAK' and then wait for another response
- from the client - either a 'done' or another list of 'have' lines.
-
-In multi_ack_detailed mode:
-
- * the server will differentiate the ACKs where it is signaling
- that it is ready to send data with 'ACK obj-id ready' lines, and
- signals the identified common commits with 'ACK obj-id common' lines.
-
-Without either multi_ack or multi_ack_detailed:
-
- * upload-pack sends "ACK obj-id" on the first common object it finds.
- After that it says nothing until the client gives it a "done".
-
- * upload-pack sends "NAK" on a flush-pkt if no common object
- has been found yet. If one has been found, and thus an ACK
- was already sent, it's silent on the flush-pkt.
-
-After the client has gotten enough ACK responses that it can determine
-that the server has enough information to send an efficient packfile
-(in the canonical implementation, this is determined when it has received
-enough ACKs that it can color everything left in the --date-order queue
-as common with the server, or the --date-order queue is empty), or the
-client determines that it wants to give up (in the canonical implementation,
-this is determined when the client sends 256 'have' lines without getting
-any of them ACKed by the server - meaning there is nothing in common and
-the server should just send all of its objects), then the client will send
-a 'done' command. The 'done' command signals to the server that the client
-is ready to receive its packfile data.
-
-However, the 256 limit *only* turns on in the canonical client
-implementation if we have received at least one "ACK %s continue"
-during a prior round. This helps to ensure that at least one common
-ancestor is found before we give up entirely.
-
-Once the 'done' line is read from the client, the server will either
-send a final 'ACK obj-id' or it will send a 'NAK'. 'obj-id' is the object
-name of the last commit determined to be common. The server only sends
-ACK after 'done' if there is at least one common base and multi_ack or
-multi_ack_detailed is enabled. The server always sends NAK after 'done'
-if there is no common base found.
-
-Then the server will start sending its packfile data.
-
-----
- server-response = *ack_multi ack / nak
- ack_multi = PKT-LINE("ACK" SP obj-id ack_status)
- ack_status = "continue" / "common" / "ready"
- ack = PKT-LINE("ACK" SP obj-id)
- nak = PKT-LINE("NAK")
-----
-
-A simple clone may look like this (with no 'have' lines):
-
-----
- C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
- side-band-64k ofs-delta\n
- C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
- C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
- C: 0032want 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
- C: 0032want 74730d410fcb6603ace96f1dc55ea6196122532d\n
- C: 0000
- C: 0009done\n
-
- S: 0008NAK\n
- S: [PACKFILE]
-----
-
-An incremental update (fetch) response might look like this:
-
-----
- C: 0054want 74730d410fcb6603ace96f1dc55ea6196122532d multi_ack \
- side-band-64k ofs-delta\n
- C: 0032want 7d1665144a3a975c05f1f43902ddaf084e784dbe\n
- C: 0032want 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a\n
- C: 0000
- C: 0032have 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01\n
- C: [30 more have lines]
- C: 0032have 74730d410fcb6603ace96f1dc55ea6196122532d\n
- C: 0000
-
- S: 003aACK 7e47fe2bd8d01d481f44d7af0531bd93d3b21c01 continue\n
- S: 003aACK 74730d410fcb6603ace96f1dc55ea6196122532d continue\n
- S: 0008NAK\n
-
- C: 0009done\n
-
- S: 0031ACK 74730d410fcb6603ace96f1dc55ea6196122532d\n
- S: [PACKFILE]
-----
-
-
-Packfile Data
--------------
-
-Now that the client and server have finished negotiation about what
-the minimal amount of data that needs to be sent to the client is, the server
-will construct and send the required data in packfile format.
-
-See pack-format.txt for what the packfile itself actually looks like.
-
-If 'side-band' or 'side-band-64k' capabilities have been specified by
-the client, the server will send the packfile data multiplexed.
-
-Each packet starting with the packet-line length of the amount of data
-that follows, followed by a single byte specifying the sideband the
-following data is coming in on.
-
-In 'side-band' mode, it will send up to 999 data bytes plus 1 control
-code, for a total of up to 1000 bytes in a pkt-line. In 'side-band-64k'
-mode it will send up to 65519 data bytes plus 1 control code, for a
-total of up to 65520 bytes in a pkt-line.
-
-The sideband byte will be a '1', '2' or a '3'. Sideband '1' will contain
-packfile data, sideband '2' will be used for progress information that the
-client will generally print to stderr and sideband '3' is used for error
-information.
-
-If no 'side-band' capability was specified, the server will stream the
-entire packfile without multiplexing.
-
-
-Pushing Data To a Server
-------------------------
-
-Pushing data to a server will invoke the 'receive-pack' process on the
-server, which will allow the client to tell it which references it should
-update and then send all the data the server will need for those new
-references to be complete. Once all the data is received and validated,
-the server will then update its references to what the client specified.
-
-Authentication
---------------
-
-The protocol itself contains no authentication mechanisms. That is to be
-handled by the transport, such as SSH, before the 'receive-pack' process is
-invoked. If 'receive-pack' is configured over the Git transport, those
-repositories will be writable by anyone who can access that port (9418) as
-that transport is unauthenticated.
-
-Reference Discovery
--------------------
-
-The reference discovery phase is done nearly the same way as it is in the
-fetching protocol. Each reference obj-id and name on the server is sent
-in packet-line format to the client, followed by a flush-pkt. The only
-real difference is that the capability listing is different - the only
-possible values are 'report-status', 'delete-refs', 'ofs-delta' and
-'push-options'.
-
-Reference Update Request and Packfile Transfer
-----------------------------------------------
-
-Once the client knows what references the server is at, it can send a
-list of reference update requests. For each reference on the server
-that it wants to update, it sends a line listing the obj-id currently on
-the server, the obj-id the client would like to update it to and the name
-of the reference.
-
-This list is followed by a flush-pkt. Then the push options are transmitted
-one per packet followed by another flush-pkt. After that the packfile that
-should contain all the objects that the server will need to complete the new
-references will be sent.
-
-----
- update-request = *shallow ( command-list | push-cert ) [packfile]
-
- shallow = PKT-LINE("shallow" SP obj-id)
-
- command-list = PKT-LINE(command NUL capability-list)
- *PKT-LINE(command)
- flush-pkt
-
- command = create / delete / update
- create = zero-id SP new-id SP name
- delete = old-id SP zero-id SP name
- update = old-id SP new-id SP name
-
- old-id = obj-id
- new-id = obj-id
-
- push-cert = PKT-LINE("push-cert" NUL capability-list LF)
- PKT-LINE("certificate version 0.1" LF)
- PKT-LINE("pusher" SP ident LF)
- PKT-LINE("pushee" SP url LF)
- PKT-LINE("nonce" SP nonce LF)
- PKT-LINE(LF)
- *PKT-LINE(command LF)
- *PKT-LINE(gpg-signature-lines LF)
- PKT-LINE("push-cert-end" LF)
-
- packfile = "PACK" 28*(OCTET)
-----
-
-If the receiving end does not support delete-refs, the sending end MUST
-NOT ask for delete command.
-
-If the receiving end does not support push-cert, the sending end
-MUST NOT send a push-cert command. When a push-cert command is
-sent, command-list MUST NOT be sent; the commands recorded in the
-push certificate is used instead.
-
-The packfile MUST NOT be sent if the only command used is 'delete'.
-
-A packfile MUST be sent if either create or update command is used,
-even if the server already has all the necessary objects. In this
-case the client MUST send an empty packfile. The only time this
-is likely to happen is if the client is creating
-a new branch or a tag that points to an existing obj-id.
-
-The server will receive the packfile, unpack it, then validate each
-reference that is being updated that it hasn't changed while the request
-was being processed (the obj-id is still the same as the old-id), and
-it will run any update hooks to make sure that the update is acceptable.
-If all of that is fine, the server will then update the references.
-
-Push Certificate
-----------------
-
-A push certificate begins with a set of header lines. After the
-header and an empty line, the protocol commands follow, one per
-line. Note that the trailing LF in push-cert PKT-LINEs is _not_
-optional; it must be present.
-
-Currently, the following header fields are defined:
-
-`pusher` ident::
- Identify the GPG key in "Human Readable Name <email@address>"
- format.
-
-`pushee` url::
- The repository URL (anonymized, if the URL contains
- authentication material) the user who ran `git push`
- intended to push into.
-
-`nonce` nonce::
- The 'nonce' string the receiving repository asked the
- pushing user to include in the certificate, to prevent
- replay attacks.
-
-The GPG signature lines are a detached signature for the contents
-recorded in the push certificate before the signature block begins.
-The detached signature is used to certify that the commands were
-given by the pusher, who must be the signer.
-
-Report Status
--------------
-
-After receiving the pack data from the sender, the receiver sends a
-report if 'report-status' capability is in effect.
-It is a short listing of what happened in that update. It will first
-list the status of the packfile unpacking as either 'unpack ok' or
-'unpack [error]'. Then it will list the status for each of the references
-that it tried to update. Each line is either 'ok [refname]' if the
-update was successful, or 'ng [refname] [error]' if the update was not.
-
-----
- report-status = unpack-status
- 1*(command-status)
- flush-pkt
-
- unpack-status = PKT-LINE("unpack" SP unpack-result)
- unpack-result = "ok" / error-msg
-
- command-status = command-ok / command-fail
- command-ok = PKT-LINE("ok" SP refname)
- command-fail = PKT-LINE("ng" SP refname SP error-msg)
-
- error-msg = 1*(OCTECT) ; where not "ok"
-----
-
-Updates can be unsuccessful for a number of reasons. The reference can have
-changed since the reference discovery phase was originally sent, meaning
-someone pushed in the meantime. The reference being pushed could be a
-non-fast-forward reference and the update hooks or configuration could be
-set to not allow that, etc. Also, some references can be updated while others
-can be rejected.
-
-An example client/server communication might look like this:
-
-----
- S: 007c74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/local\0report-status delete-refs ofs-delta\n
- S: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe refs/heads/debug\n
- S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/master\n
- S: 003f74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/team\n
- S: 0000
-
- C: 003e7d1665144a3a975c05f1f43902ddaf084e784dbe 74730d410fcb6603ace96f1dc55ea6196122532d refs/heads/debug\n
- C: 003e74730d410fcb6603ace96f1dc55ea6196122532d 5a3f6be755bbb7deae50065988cbfa1ffa9ab68a refs/heads/master\n
- C: 0000
- C: [PACKDATA]
-
- S: 000eunpack ok\n
- S: 0018ok refs/heads/debug\n
- S: 002ang refs/heads/master non-fast-forward\n
-----
-*/
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/report_status.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/report_status.go
deleted file mode 100644
index 29c1a4cd8630ac25cae5c80721a64dc41bc2339e..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/report_status.go
+++ /dev/null
@@ -1,165 +0,0 @@
-package packp
-
-import (
- "bytes"
- "fmt"
- "io"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-const (
- ok = "ok"
-)
-
-// ReportStatus is a report status message, as used in the git-receive-pack
-// process whenever the 'report-status' capability is negotiated.
-type ReportStatus struct {
- UnpackStatus string
- CommandStatuses []*CommandStatus
-}
-
-// NewReportStatus creates a new ReportStatus message.
-func NewReportStatus() *ReportStatus {
- return &ReportStatus{}
-}
-
-// Error returns the first error if any.
-func (s *ReportStatus) Error() error {
- if s.UnpackStatus != ok {
- return fmt.Errorf("unpack error: %s", s.UnpackStatus)
- }
-
- for _, s := range s.CommandStatuses {
- if err := s.Error(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// Encode writes the report status to a writer.
-func (s *ReportStatus) Encode(w io.Writer) error {
- e := pktline.NewEncoder(w)
- if err := e.Encodef("unpack %s\n", s.UnpackStatus); err != nil {
- return err
- }
-
- for _, cs := range s.CommandStatuses {
- if err := cs.encode(w); err != nil {
- return err
- }
- }
-
- return e.Flush()
-}
-
-// Decode reads from the given reader and decodes a report-status message. It
-// does not read more input than what is needed to fill the report status.
-func (s *ReportStatus) Decode(r io.Reader) error {
- scan := pktline.NewScanner(r)
- if err := s.scanFirstLine(scan); err != nil {
- return err
- }
-
- if err := s.decodeReportStatus(scan.Bytes()); err != nil {
- return err
- }
-
- flushed := false
- for scan.Scan() {
- b := scan.Bytes()
- if isFlush(b) {
- flushed = true
- break
- }
-
- if err := s.decodeCommandStatus(b); err != nil {
- return err
- }
- }
-
- if !flushed {
- return fmt.Errorf("missing flush")
- }
-
- return scan.Err()
-}
-
-func (s *ReportStatus) scanFirstLine(scan *pktline.Scanner) error {
- if scan.Scan() {
- return nil
- }
-
- if scan.Err() != nil {
- return scan.Err()
- }
-
- return io.ErrUnexpectedEOF
-}
-
-func (s *ReportStatus) decodeReportStatus(b []byte) error {
- if isFlush(b) {
- return fmt.Errorf("premature flush")
- }
-
- b = bytes.TrimSuffix(b, eol)
-
- line := string(b)
- fields := strings.SplitN(line, " ", 2)
- if len(fields) != 2 || fields[0] != "unpack" {
- return fmt.Errorf("malformed unpack status: %s", line)
- }
-
- s.UnpackStatus = fields[1]
- return nil
-}
-
-func (s *ReportStatus) decodeCommandStatus(b []byte) error {
- b = bytes.TrimSuffix(b, eol)
-
- line := string(b)
- fields := strings.SplitN(line, " ", 3)
- status := ok
- if len(fields) == 3 && fields[0] == "ng" {
- status = fields[2]
- } else if len(fields) != 2 || fields[0] != "ok" {
- return fmt.Errorf("malformed command status: %s", line)
- }
-
- cs := &CommandStatus{
- ReferenceName: plumbing.ReferenceName(fields[1]),
- Status: status,
- }
- s.CommandStatuses = append(s.CommandStatuses, cs)
- return nil
-}
-
-// CommandStatus is the status of a reference in a report status.
-// See ReportStatus struct.
-type CommandStatus struct {
- ReferenceName plumbing.ReferenceName
- Status string
-}
-
-// Error returns the error, if any.
-func (s *CommandStatus) Error() error {
- if s.Status == ok {
- return nil
- }
-
- return fmt.Errorf("command error on %s: %s",
- s.ReferenceName.String(), s.Status)
-}
-
-func (s *CommandStatus) encode(w io.Writer) error {
- e := pktline.NewEncoder(w)
- if s.Error() == nil {
- return e.Encodef("ok %s\n", s.ReferenceName.String())
- }
-
- return e.Encodef("ng %s %s\n", s.ReferenceName.String(), s.Status)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/shallowupd.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/shallowupd.go
deleted file mode 100644
index 40f58e88311e211b119acbc0e561cb7e405e67b2..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/shallowupd.go
+++ /dev/null
@@ -1,92 +0,0 @@
-package packp
-
-import (
- "bytes"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-const (
- shallowLineLen = 48
- unshallowLineLen = 50
-)
-
-type ShallowUpdate struct {
- Shallows []plumbing.Hash
- Unshallows []plumbing.Hash
-}
-
-func (r *ShallowUpdate) Decode(reader io.Reader) error {
- s := pktline.NewScanner(reader)
-
- for s.Scan() {
- line := s.Bytes()
- line = bytes.TrimSpace(line)
-
- var err error
- switch {
- case bytes.HasPrefix(line, shallow):
- err = r.decodeShallowLine(line)
- case bytes.HasPrefix(line, unshallow):
- err = r.decodeUnshallowLine(line)
- case bytes.Compare(line, pktline.Flush) == 0:
- return nil
- }
-
- if err != nil {
- return err
- }
- }
-
- return s.Err()
-}
-
-func (r *ShallowUpdate) decodeShallowLine(line []byte) error {
- hash, err := r.decodeLine(line, shallow, shallowLineLen)
- if err != nil {
- return err
- }
-
- r.Shallows = append(r.Shallows, hash)
- return nil
-}
-
-func (r *ShallowUpdate) decodeUnshallowLine(line []byte) error {
- hash, err := r.decodeLine(line, unshallow, unshallowLineLen)
- if err != nil {
- return err
- }
-
- r.Unshallows = append(r.Unshallows, hash)
- return nil
-}
-
-func (r *ShallowUpdate) decodeLine(line, prefix []byte, expLen int) (plumbing.Hash, error) {
- if len(line) != expLen {
- return plumbing.ZeroHash, fmt.Errorf("malformed %s%q", prefix, line)
- }
-
- raw := string(line[expLen-40 : expLen])
- return plumbing.NewHash(raw), nil
-}
-
-func (r *ShallowUpdate) Encode(w io.Writer) error {
- e := pktline.NewEncoder(w)
-
- for _, h := range r.Shallows {
- if err := e.Encodef("%s%s\n", shallow, h.String()); err != nil {
- return err
- }
- }
-
- for _, h := range r.Unshallows {
- if err := e.Encodef("%s%s\n", unshallow, h.String()); err != nil {
- return err
- }
- }
-
- return e.Flush()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/common.go
deleted file mode 100644
index de5001281fd50bd3f933d57793b4e0b3bdc7d46f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/common.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package sideband
-
-// Type sideband type "side-band" or "side-band-64k"
-type Type int8
-
-const (
- // Sideband legacy sideband type up to 1000-byte messages
- Sideband Type = iota
- // Sideband64k sideband type up to 65519-byte messages
- Sideband64k Type = iota
-
- // MaxPackedSize for Sideband type
- MaxPackedSize = 1000
- // MaxPackedSize64k for Sideband64k type
- MaxPackedSize64k = 65520
-)
-
-// Channel sideband channel
-type Channel byte
-
-// WithPayload encode the payload as a message
-func (ch Channel) WithPayload(payload []byte) []byte {
- return append([]byte{byte(ch)}, payload...)
-}
-
-const (
- // PackData packfile content
- PackData Channel = 1
- // ProgressMessage progress messages
- ProgressMessage Channel = 2
- // ErrorMessage fatal error message just before stream aborts
- ErrorMessage Channel = 3
-)
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/demux.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/demux.go
deleted file mode 100644
index 352336dc68b9367b255624b4d05f97ba3bd68bef..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/demux.go
+++ /dev/null
@@ -1,148 +0,0 @@
-package sideband
-
-import (
- "errors"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-// ErrMaxPackedExceeded returned by Read, if the maximum packed size is exceeded
-var ErrMaxPackedExceeded = errors.New("max. packed size exceeded")
-
-// Progress where the progress information is stored
-type Progress interface {
- io.Writer
-}
-
-// Demuxer demultiplexes the progress reports and error info interleaved with the
-// packfile itself.
-//
-// A sideband has three different channels the main one, called PackData, contains
-// the packfile data; the ErrorMessage channel, that contains server errors; and
-// the last one, ProgressMessage channel, containing information about the ongoing
-// task happening in the server (optional, can be suppressed sending NoProgress
-// or Quiet capabilities to the server)
-//
-// In order to demultiplex the data stream, method `Read` should be called to
-// retrieve the PackData channel, the incoming data from the ProgressMessage is
-// written at `Progress` (if any), if any message is retrieved from the
-// ErrorMessage channel an error is returned and we can assume that the
-// connection has been closed.
-type Demuxer struct {
- t Type
- r io.Reader
- s *pktline.Scanner
-
- max int
- pending []byte
-
- // Progress is where the progress messages are stored
- Progress Progress
-}
-
-// NewDemuxer returns a new Demuxer for the given t and read from r
-func NewDemuxer(t Type, r io.Reader) *Demuxer {
- max := MaxPackedSize64k
- if t == Sideband {
- max = MaxPackedSize
- }
-
- return &Demuxer{
- t: t,
- r: r,
- max: max,
- s: pktline.NewScanner(r),
- }
-}
-
-// Read reads up to len(p) bytes from the PackData channel into p, an error can
-// be return if an error happens when reading or if a message is sent in the
-// ErrorMessage channel.
-//
-// When a ProgressMessage is read, is not copy to b, instead of this is written
-// to the Progress
-func (d *Demuxer) Read(b []byte) (n int, err error) {
- var read, req int
-
- req = len(b)
- for read < req {
- n, err := d.doRead(b[read:req])
- read += n
-
- if err != nil {
- return read, err
- }
- }
-
- return read, nil
-}
-
-func (d *Demuxer) doRead(b []byte) (int, error) {
- read, err := d.nextPackData()
- size := len(read)
- wanted := len(b)
-
- if size > wanted {
- d.pending = read[wanted:]
- }
-
- if wanted > size {
- wanted = size
- }
-
- size = copy(b, read[:wanted])
- return size, err
-}
-
-func (d *Demuxer) nextPackData() ([]byte, error) {
- content := d.getPending()
- if len(content) != 0 {
- return content, nil
- }
-
- if !d.s.Scan() {
- if err := d.s.Err(); err != nil {
- return nil, err
- }
-
- return nil, io.EOF
- }
-
- content = d.s.Bytes()
-
- size := len(content)
- if size == 0 {
- return nil, nil
- } else if size > d.max {
- return nil, ErrMaxPackedExceeded
- }
-
- switch Channel(content[0]) {
- case PackData:
- return content[1:], nil
- case ProgressMessage:
- if d.Progress != nil {
- _, err := d.Progress.Write(content[1:])
- return nil, err
- }
- case ErrorMessage:
- return nil, fmt.Errorf("unexpected error: %s", content[1:])
- default:
- return nil, fmt.Errorf("unknown channel %s", content)
- }
-
- return nil, nil
-}
-
-func (d *Demuxer) getPending() (b []byte) {
- if len(d.pending) == 0 {
- return nil
- }
-
- content := d.pending
- d.pending = nil
-
- return content
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/doc.go
deleted file mode 100644
index c5d2429529164ef35f6f318586f93aa33a996ad8..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/doc.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Package sideband implements a sideband mutiplex/demultiplexer
-package sideband
-
-// If 'side-band' or 'side-band-64k' capabilities have been specified by
-// the client, the server will send the packfile data multiplexed.
-//
-// Either mode indicates that the packfile data will be streamed broken
-// up into packets of up to either 1000 bytes in the case of 'side_band',
-// or 65520 bytes in the case of 'side_band_64k'. Each packet is made up
-// of a leading 4-byte pkt-line length of how much data is in the packet,
-// followed by a 1-byte stream code, followed by the actual data.
-//
-// The stream code can be one of:
-//
-// 1 - pack data
-// 2 - progress messages
-// 3 - fatal error message just before stream aborts
-//
-// The "side-band-64k" capability came about as a way for newer clients
-// that can handle much larger packets to request packets that are
-// actually crammed nearly full, while maintaining backward compatibility
-// for the older clients.
-//
-// Further, with side-band and its up to 1000-byte messages, it's actually
-// 999 bytes of payload and 1 byte for the stream code. With side-band-64k,
-// same deal, you have up to 65519 bytes of data and 1 byte for the stream
-// code.
-//
-// The client MUST send only maximum of one of "side-band" and "side-
-// band-64k". Server MUST diagnose it as an error if client requests
-// both.
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/muxer.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/muxer.go
deleted file mode 100644
index 45fecc2cbd2d0e3dd77fb46fcc8f0c6431ea01de..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband/muxer.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package sideband
-
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-// Muxer multiplex the packfile along with the progress messages and the error
-// information. The multiplex is perform using pktline format.
-type Muxer struct {
- max int
- e *pktline.Encoder
-}
-
-const chLen = 1
-
-// NewMuxer returns a new Muxer for the given t that writes on w.
-//
-// If t is equal to `Sideband` the max pack size is set to MaxPackedSize, in any
-// other value is given, max pack is set to MaxPackedSize64k, that is the
-// maximum length of a line in pktline format.
-func NewMuxer(t Type, w io.Writer) *Muxer {
- max := MaxPackedSize64k
- if t == Sideband {
- max = MaxPackedSize
- }
-
- return &Muxer{
- max: max - chLen,
- e: pktline.NewEncoder(w),
- }
-}
-
-// Write writes p in the PackData channel
-func (m *Muxer) Write(p []byte) (int, error) {
- return m.WriteChannel(PackData, p)
-}
-
-// WriteChannel writes p in the given channel. This method can be used with any
-// channel, but is recommend use it only for the ProgressMessage and
-// ErrorMessage channels and use Write for the PackData channel
-func (m *Muxer) WriteChannel(t Channel, p []byte) (int, error) {
- wrote := 0
- size := len(p)
- for wrote < size {
- n, err := m.doWrite(t, p[wrote:])
- wrote += n
-
- if err != nil {
- return wrote, err
- }
- }
-
- return wrote, nil
-}
-
-func (m *Muxer) doWrite(ch Channel, p []byte) (int, error) {
- sz := len(p)
- if sz > m.max {
- sz = m.max
- }
-
- return sz, m.e.Encode(ch.WithPayload(p[:sz]))
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/srvresp.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/srvresp.go
deleted file mode 100644
index 0c89e47da93ed5f7b68c36cb9f662c5fe2f3465c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/srvresp.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package packp
-
-import (
- "bytes"
- "errors"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-const ackLineLen = 44
-
-// ServerResponse object acknowledgement from upload-pack service
-type ServerResponse struct {
- ACKs []plumbing.Hash
-}
-
-// Decode decodes the response into the struct, isMultiACK should be true, if
-// the request was done with multi_ack or multi_ack_detailed capabilities
-func (r *ServerResponse) Decode(reader io.Reader, isMultiACK bool) error {
- // TODO: implement support for multi_ack or multi_ack_detailed responses
- if isMultiACK {
- return errors.New("multi_ack and multi_ack_detailed are not supported")
- }
-
- s := pktline.NewScanner(reader)
-
- for s.Scan() {
- line := s.Bytes()
-
- if err := r.decodeLine(line); err != nil {
- return err
- }
-
- if !isMultiACK {
- break
- }
- }
-
- return s.Err()
-}
-
-func (r *ServerResponse) decodeLine(line []byte) error {
- if len(line) == 0 {
- return fmt.Errorf("unexpected flush")
- }
-
- if bytes.Compare(line[0:3], ack) == 0 {
- return r.decodeACKLine(line)
- }
-
- if bytes.Compare(line[0:3], nak) == 0 {
- return nil
- }
-
- return fmt.Errorf("unexpected content %q", string(line))
-}
-
-func (r *ServerResponse) decodeACKLine(line []byte) error {
- if len(line) < ackLineLen {
- return fmt.Errorf("malformed ACK %q", line)
- }
-
- sp := bytes.Index(line, []byte(" "))
- h := plumbing.NewHash(string(line[sp+1 : sp+41]))
- r.ACKs = append(r.ACKs, h)
- return nil
-}
-
-// Encode encodes the ServerResponse into a writer.
-func (r *ServerResponse) Encode(w io.Writer) error {
- if len(r.ACKs) > 1 {
- return errors.New("multi_ack and multi_ack_detailed are not supported")
- }
-
- e := pktline.NewEncoder(w)
- if len(r.ACKs) == 0 {
- return e.Encodef("%s\n", nak)
- }
-
- return e.Encodef("%s %s\n", ack, r.ACKs[0].String())
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq.go
deleted file mode 100644
index 7832007b195fd063c3415e0d21b43e18161b35d6..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq.go
+++ /dev/null
@@ -1,168 +0,0 @@
-package packp
-
-import (
- "fmt"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-// UploadRequest values represent the information transmitted on a
-// upload-request message. Values from this type are not zero-value
-// safe, use the New function instead.
-// This is a low level type, use UploadPackRequest instead.
-type UploadRequest struct {
- Capabilities *capability.List
- Wants []plumbing.Hash
- Shallows []plumbing.Hash
- Depth Depth
-}
-
-// Depth values stores the desired depth of the requested packfile: see
-// DepthCommit, DepthSince and DepthReference.
-type Depth interface {
- isDepth()
- IsZero() bool
-}
-
-// DepthCommits values stores the maximum number of requested commits in
-// the packfile. Zero means infinite. A negative value will have
-// undefined consecuences.
-type DepthCommits int
-
-func (d DepthCommits) isDepth() {}
-
-func (d DepthCommits) IsZero() bool {
- return d == 0
-}
-
-// DepthSince values requests only commits newer than the specified time.
-type DepthSince time.Time
-
-func (d DepthSince) isDepth() {}
-
-func (d DepthSince) IsZero() bool {
- return time.Time(d).IsZero()
-}
-
-// DepthReference requests only commits not to found in the specified reference.
-type DepthReference string
-
-func (d DepthReference) isDepth() {}
-
-func (d DepthReference) IsZero() bool {
- return string(d) == ""
-}
-
-// NewUploadRequest returns a pointer to a new UploadRequest value, ready to be
-// used. It has no capabilities, wants or shallows and an infinite depth. Please
-// note that to encode an upload-request it has to have at least one wanted hash.
-func NewUploadRequest() *UploadRequest {
- return &UploadRequest{
- Capabilities: capability.NewList(),
- Wants: []plumbing.Hash{},
- Shallows: []plumbing.Hash{},
- Depth: DepthCommits(0),
- }
-}
-
-// NewUploadRequestFromCapabilities returns a pointer to a new UploadRequest
-// value, the request capabilities are filled with the most optiomal ones, based
-// on the adv value (advertaised capabilities), the UploadRequest generated it
-// has no wants or shallows and an infinite depth.
-func NewUploadRequestFromCapabilities(adv *capability.List) *UploadRequest {
- r := NewUploadRequest()
-
- if adv.Supports(capability.MultiACKDetailed) {
- r.Capabilities.Set(capability.MultiACKDetailed)
- } else if adv.Supports(capability.MultiACK) {
- r.Capabilities.Set(capability.MultiACK)
- }
-
- if adv.Supports(capability.Sideband64k) {
- r.Capabilities.Set(capability.Sideband64k)
- } else if adv.Supports(capability.Sideband) {
- r.Capabilities.Set(capability.Sideband)
- }
-
- if adv.Supports(capability.ThinPack) {
- r.Capabilities.Set(capability.ThinPack)
- }
-
- if adv.Supports(capability.OFSDelta) {
- r.Capabilities.Set(capability.OFSDelta)
- }
-
- if adv.Supports(capability.Agent) {
- r.Capabilities.Set(capability.Agent, capability.DefaultAgent)
- }
-
- return r
-}
-
-// Validate validates the content of UploadRequest, following the next rules:
-// - Wants MUST have at least one reference
-// - capability.Shallow MUST be present if Shallows is not empty
-// - is a non-zero DepthCommits is given capability.Shallow MUST be present
-// - is a DepthSince is given capability.Shallow MUST be present
-// - is a DepthReference is given capability.DeepenNot MUST be present
-// - MUST contain only maximum of one of capability.Sideband and capability.Sideband64k
-// - MUST contain only maximum of one of capability.MultiACK and capability.MultiACKDetailed
-func (r *UploadRequest) Validate() error {
- if len(r.Wants) == 0 {
- return fmt.Errorf("want can't be empty")
- }
-
- if err := r.validateRequiredCapabilities(); err != nil {
- return err
- }
-
- if err := r.validateConflictCapabilities(); err != nil {
- return err
- }
-
- return nil
-}
-
-func (r *UploadRequest) validateRequiredCapabilities() error {
- msg := "missing capability %s"
-
- if len(r.Shallows) != 0 && !r.Capabilities.Supports(capability.Shallow) {
- return fmt.Errorf(msg, capability.Shallow)
- }
-
- switch r.Depth.(type) {
- case DepthCommits:
- if r.Depth != DepthCommits(0) {
- if !r.Capabilities.Supports(capability.Shallow) {
- return fmt.Errorf(msg, capability.Shallow)
- }
- }
- case DepthSince:
- if !r.Capabilities.Supports(capability.DeepenSince) {
- return fmt.Errorf(msg, capability.DeepenSince)
- }
- case DepthReference:
- if !r.Capabilities.Supports(capability.DeepenNot) {
- return fmt.Errorf(msg, capability.DeepenNot)
- }
- }
-
- return nil
-}
-
-func (r *UploadRequest) validateConflictCapabilities() error {
- msg := "capabilities %s and %s are mutually exclusive"
- if r.Capabilities.Supports(capability.Sideband) &&
- r.Capabilities.Supports(capability.Sideband64k) {
- return fmt.Errorf(msg, capability.Sideband, capability.Sideband64k)
- }
-
- if r.Capabilities.Supports(capability.MultiACK) &&
- r.Capabilities.Supports(capability.MultiACKDetailed) {
- return fmt.Errorf(msg, capability.MultiACK, capability.MultiACKDetailed)
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_decode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_decode.go
deleted file mode 100644
index bcd642db2a5b52c20421fb6fd5db698384eecf33..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_decode.go
+++ /dev/null
@@ -1,257 +0,0 @@
-package packp
-
-import (
- "bytes"
- "encoding/hex"
- "fmt"
- "io"
- "strconv"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-// Decode reads the next upload-request form its input and
-// stores it in the UploadRequest.
-func (u *UploadRequest) Decode(r io.Reader) error {
- d := newUlReqDecoder(r)
- return d.Decode(u)
-}
-
-type ulReqDecoder struct {
- s *pktline.Scanner // a pkt-line scanner from the input stream
- line []byte // current pkt-line contents, use parser.nextLine() to make it advance
- nLine int // current pkt-line number for debugging, begins at 1
- err error // sticky error, use the parser.error() method to fill this out
- data *UploadRequest // parsed data is stored here
-}
-
-func newUlReqDecoder(r io.Reader) *ulReqDecoder {
- return &ulReqDecoder{
- s: pktline.NewScanner(r),
- }
-}
-
-func (d *ulReqDecoder) Decode(v *UploadRequest) error {
- d.data = v
-
- for state := d.decodeFirstWant; state != nil; {
- state = state()
- }
-
- return d.err
-}
-
-// fills out the parser stiky error
-func (d *ulReqDecoder) error(format string, a ...interface{}) {
- msg := fmt.Sprintf(
- "pkt-line %d: %s", d.nLine,
- fmt.Sprintf(format, a...),
- )
-
- d.err = NewErrUnexpectedData(msg, d.line)
-}
-
-// Reads a new pkt-line from the scanner, makes its payload available as
-// p.line and increments p.nLine. A successful invocation returns true,
-// otherwise, false is returned and the sticky error is filled out
-// accordingly. Trims eols at the end of the payloads.
-func (d *ulReqDecoder) nextLine() bool {
- d.nLine++
-
- if !d.s.Scan() {
- if d.err = d.s.Err(); d.err != nil {
- return false
- }
-
- d.error("EOF")
- return false
- }
-
- d.line = d.s.Bytes()
- d.line = bytes.TrimSuffix(d.line, eol)
-
- return true
-}
-
-// Expected format: want <hash>[ capabilities]
-func (d *ulReqDecoder) decodeFirstWant() stateFn {
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- if !bytes.HasPrefix(d.line, want) {
- d.error("missing 'want ' prefix")
- return nil
- }
- d.line = bytes.TrimPrefix(d.line, want)
-
- hash, ok := d.readHash()
- if !ok {
- return nil
- }
- d.data.Wants = append(d.data.Wants, hash)
-
- return d.decodeCaps
-}
-
-func (d *ulReqDecoder) readHash() (plumbing.Hash, bool) {
- if len(d.line) < hashSize {
- d.err = fmt.Errorf("malformed hash: %v", d.line)
- return plumbing.ZeroHash, false
- }
-
- var hash plumbing.Hash
- if _, err := hex.Decode(hash[:], d.line[:hashSize]); err != nil {
- d.error("invalid hash text: %s", err)
- return plumbing.ZeroHash, false
- }
- d.line = d.line[hashSize:]
-
- return hash, true
-}
-
-// Expected format: sp cap1 sp cap2 sp cap3...
-func (d *ulReqDecoder) decodeCaps() stateFn {
- d.line = bytes.TrimPrefix(d.line, sp)
- if err := d.data.Capabilities.Decode(d.line); err != nil {
- d.error("invalid capabilities: %s", err)
- }
-
- return d.decodeOtherWants
-}
-
-// Expected format: want <hash>
-func (d *ulReqDecoder) decodeOtherWants() stateFn {
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- if bytes.HasPrefix(d.line, shallow) {
- return d.decodeShallow
- }
-
- if bytes.HasPrefix(d.line, deepen) {
- return d.decodeDeepen
- }
-
- if len(d.line) == 0 {
- return nil
- }
-
- if !bytes.HasPrefix(d.line, want) {
- d.error("unexpected payload while expecting a want: %q", d.line)
- return nil
- }
- d.line = bytes.TrimPrefix(d.line, want)
-
- hash, ok := d.readHash()
- if !ok {
- return nil
- }
- d.data.Wants = append(d.data.Wants, hash)
-
- return d.decodeOtherWants
-}
-
-// Expected format: shallow <hash>
-func (d *ulReqDecoder) decodeShallow() stateFn {
- if bytes.HasPrefix(d.line, deepen) {
- return d.decodeDeepen
- }
-
- if len(d.line) == 0 {
- return nil
- }
-
- if !bytes.HasPrefix(d.line, shallow) {
- d.error("unexpected payload while expecting a shallow: %q", d.line)
- return nil
- }
- d.line = bytes.TrimPrefix(d.line, shallow)
-
- hash, ok := d.readHash()
- if !ok {
- return nil
- }
- d.data.Shallows = append(d.data.Shallows, hash)
-
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- return d.decodeShallow
-}
-
-// Expected format: deepen <n> / deepen-since <ul> / deepen-not <ref>
-func (d *ulReqDecoder) decodeDeepen() stateFn {
- if bytes.HasPrefix(d.line, deepenCommits) {
- return d.decodeDeepenCommits
- }
-
- if bytes.HasPrefix(d.line, deepenSince) {
- return d.decodeDeepenSince
- }
-
- if bytes.HasPrefix(d.line, deepenReference) {
- return d.decodeDeepenReference
- }
-
- if len(d.line) == 0 {
- return nil
- }
-
- d.error("unexpected deepen specification: %q", d.line)
- return nil
-}
-
-func (d *ulReqDecoder) decodeDeepenCommits() stateFn {
- d.line = bytes.TrimPrefix(d.line, deepenCommits)
-
- var n int
- if n, d.err = strconv.Atoi(string(d.line)); d.err != nil {
- return nil
- }
- if n < 0 {
- d.err = fmt.Errorf("negative depth")
- return nil
- }
- d.data.Depth = DepthCommits(n)
-
- return d.decodeFlush
-}
-
-func (d *ulReqDecoder) decodeDeepenSince() stateFn {
- d.line = bytes.TrimPrefix(d.line, deepenSince)
-
- var secs int64
- secs, d.err = strconv.ParseInt(string(d.line), 10, 64)
- if d.err != nil {
- return nil
- }
- t := time.Unix(secs, 0).UTC()
- d.data.Depth = DepthSince(t)
-
- return d.decodeFlush
-}
-
-func (d *ulReqDecoder) decodeDeepenReference() stateFn {
- d.line = bytes.TrimPrefix(d.line, deepenReference)
-
- d.data.Depth = DepthReference(string(d.line))
-
- return d.decodeFlush
-}
-
-func (d *ulReqDecoder) decodeFlush() stateFn {
- if ok := d.nextLine(); !ok {
- return nil
- }
-
- if len(d.line) != 0 {
- d.err = fmt.Errorf("unexpected payload while expecting a flush-pkt: %q", d.line)
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_encode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_encode.go
deleted file mode 100644
index 4a26e74d573b490e3f0c61f4cd3e70c23cc60b5e..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/ulreq_encode.go
+++ /dev/null
@@ -1,145 +0,0 @@
-package packp
-
-import (
- "bytes"
- "fmt"
- "io"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-// Encode writes the UlReq encoding of u to the stream.
-//
-// All the payloads will end with a newline character. Wants and
-// shallows are sorted alphabetically. A depth of 0 means no depth
-// request is sent.
-func (u *UploadRequest) Encode(w io.Writer) error {
- e := newUlReqEncoder(w)
- return e.Encode(u)
-}
-
-type ulReqEncoder struct {
- pe *pktline.Encoder // where to write the encoded data
- data *UploadRequest // the data to encode
- err error // sticky error
-}
-
-func newUlReqEncoder(w io.Writer) *ulReqEncoder {
- return &ulReqEncoder{
- pe: pktline.NewEncoder(w),
- }
-}
-
-func (e *ulReqEncoder) Encode(v *UploadRequest) error {
- e.data = v
-
- if len(v.Wants) == 0 {
- return fmt.Errorf("empty wants provided")
- }
-
- plumbing.HashesSort(e.data.Wants)
- for state := e.encodeFirstWant; state != nil; {
- state = state()
- }
-
- return e.err
-}
-
-func (e *ulReqEncoder) encodeFirstWant() stateFn {
- var err error
- if e.data.Capabilities.IsEmpty() {
- err = e.pe.Encodef("want %s\n", e.data.Wants[0])
- } else {
- err = e.pe.Encodef(
- "want %s %s\n",
- e.data.Wants[0],
- e.data.Capabilities.String(),
- )
- }
-
- if err != nil {
- e.err = fmt.Errorf("encoding first want line: %s", err)
- return nil
- }
-
- return e.encodeAditionalWants
-}
-
-func (e *ulReqEncoder) encodeAditionalWants() stateFn {
- last := e.data.Wants[0]
- for _, w := range e.data.Wants[1:] {
- if bytes.Compare(last[:], w[:]) == 0 {
- continue
- }
-
- if err := e.pe.Encodef("want %s\n", w); err != nil {
- e.err = fmt.Errorf("encoding want %q: %s", w, err)
- return nil
- }
-
- last = w
- }
-
- return e.encodeShallows
-}
-
-func (e *ulReqEncoder) encodeShallows() stateFn {
- plumbing.HashesSort(e.data.Shallows)
-
- var last plumbing.Hash
- for _, s := range e.data.Shallows {
- if bytes.Compare(last[:], s[:]) == 0 {
- continue
- }
-
- if err := e.pe.Encodef("shallow %s\n", s); err != nil {
- e.err = fmt.Errorf("encoding shallow %q: %s", s, err)
- return nil
- }
-
- last = s
- }
-
- return e.encodeDepth
-}
-
-func (e *ulReqEncoder) encodeDepth() stateFn {
- switch depth := e.data.Depth.(type) {
- case DepthCommits:
- if depth != 0 {
- commits := int(depth)
- if err := e.pe.Encodef("deepen %d\n", commits); err != nil {
- e.err = fmt.Errorf("encoding depth %d: %s", depth, err)
- return nil
- }
- }
- case DepthSince:
- when := time.Time(depth).UTC()
- if err := e.pe.Encodef("deepen-since %d\n", when.Unix()); err != nil {
- e.err = fmt.Errorf("encoding depth %s: %s", when, err)
- return nil
- }
- case DepthReference:
- reference := string(depth)
- if err := e.pe.Encodef("deepen-not %s\n", reference); err != nil {
- e.err = fmt.Errorf("encoding depth %s: %s", reference, err)
- return nil
- }
- default:
- e.err = fmt.Errorf("unsupported depth type")
- return nil
- }
-
- return e.encodeFlush
-}
-
-func (e *ulReqEncoder) encodeFlush() stateFn {
- if err := e.pe.Flush(); err != nil {
- e.err = fmt.Errorf("encoding flush-pkt: %s", err)
- return nil
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq.go
deleted file mode 100644
index 0624930289468cc78ebf7fb3e6bbe37783c85f2d..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq.go
+++ /dev/null
@@ -1,117 +0,0 @@
-package packp
-
-import (
- "errors"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-var (
- ErrEmptyCommands = errors.New("commands cannot be empty")
- ErrMalformedCommand = errors.New("malformed command")
-)
-
-// ReferenceUpdateRequest values represent reference upload requests.
-// Values from this type are not zero-value safe, use the New function instead.
-type ReferenceUpdateRequest struct {
- Capabilities *capability.List
- Commands []*Command
- Shallow *plumbing.Hash
- // Packfile contains an optional packfile reader.
- Packfile io.ReadCloser
-}
-
-// New returns a pointer to a new ReferenceUpdateRequest value.
-func NewReferenceUpdateRequest() *ReferenceUpdateRequest {
- return &ReferenceUpdateRequest{
- // TODO: Add support for push-cert
- Capabilities: capability.NewList(),
- Commands: nil,
- }
-}
-
-// NewReferenceUpdateRequestFromCapabilities returns a pointer to a new
-// ReferenceUpdateRequest value, the request capabilities are filled with the
-// most optimal ones, based on the adv value (advertised capabilities), the
-// ReferenceUpdateRequest contains no commands
-//
-// It does set the following capabilities:
-// - agent
-// - report-status
-// - ofs-delta
-// - ref-delta
-// It leaves up to the user to add the following capabilities later:
-// - atomic
-// - ofs-delta
-// - side-band
-// - side-band-64k
-// - quiet
-// - push-cert
-func NewReferenceUpdateRequestFromCapabilities(adv *capability.List) *ReferenceUpdateRequest {
- r := NewReferenceUpdateRequest()
-
- if adv.Supports(capability.Agent) {
- r.Capabilities.Set(capability.Agent, capability.DefaultAgent)
- }
-
- if adv.Supports(capability.ReportStatus) {
- r.Capabilities.Set(capability.ReportStatus)
- }
-
- return r
-}
-
-func (r *ReferenceUpdateRequest) validate() error {
- if len(r.Commands) == 0 {
- return ErrEmptyCommands
- }
-
- for _, c := range r.Commands {
- if err := c.validate(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-type Action string
-
-const (
- Create Action = "create"
- Update = "update"
- Delete = "delete"
- Invalid = "invalid"
-)
-
-type Command struct {
- Name plumbing.ReferenceName
- Old plumbing.Hash
- New plumbing.Hash
-}
-
-func (c *Command) Action() Action {
- if c.Old == plumbing.ZeroHash && c.New == plumbing.ZeroHash {
- return Invalid
- }
-
- if c.Old == plumbing.ZeroHash {
- return Create
- }
-
- if c.New == plumbing.ZeroHash {
- return Delete
- }
-
- return Update
-}
-
-func (c *Command) validate() error {
- if c.Action() == Invalid {
- return ErrMalformedCommand
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_decode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_decode.go
deleted file mode 100644
index c15d49cfb752bbc5e37271b2abb23dc6c4571d1c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_decode.go
+++ /dev/null
@@ -1,250 +0,0 @@
-package packp
-
-import (
- "bytes"
- "encoding/hex"
- "errors"
- "fmt"
- "io"
- "io/ioutil"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
-)
-
-var (
- shallowLineLength = len(shallow) + hashSize
- minCommandLength = hashSize*2 + 2 + 1
- minCommandAndCapsLenth = minCommandLength + 1
-)
-
-var (
- ErrEmpty = errors.New("empty update-request message")
- errNoCommands = errors.New("unexpected EOF before any command")
- errMissingCapabilitiesDelimiter = errors.New("capabilities delimiter not found")
-)
-
-func errMalformedRequest(reason string) error {
- return fmt.Errorf("malformed request: %s", reason)
-}
-
-func errInvalidHashSize(got int) error {
- return fmt.Errorf("invalid hash size: expected %d, got %d",
- hashSize, got)
-}
-
-func errInvalidHash(err error) error {
- return fmt.Errorf("invalid hash: %s", err.Error())
-}
-
-func errInvalidShallowLineLength(got int) error {
- return errMalformedRequest(fmt.Sprintf(
- "invalid shallow line length: expected %d, got %d",
- shallowLineLength, got))
-}
-
-func errInvalidCommandCapabilitiesLineLength(got int) error {
- return errMalformedRequest(fmt.Sprintf(
- "invalid command and capabilities line length: expected at least %d, got %d",
- minCommandAndCapsLenth, got))
-}
-
-func errInvalidCommandLineLength(got int) error {
- return errMalformedRequest(fmt.Sprintf(
- "invalid command line length: expected at least %d, got %d",
- minCommandLength, got))
-}
-
-func errInvalidShallowObjId(err error) error {
- return errMalformedRequest(
- fmt.Sprintf("invalid shallow object id: %s", err.Error()))
-}
-
-func errInvalidOldObjId(err error) error {
- return errMalformedRequest(
- fmt.Sprintf("invalid old object id: %s", err.Error()))
-}
-
-func errInvalidNewObjId(err error) error {
- return errMalformedRequest(
- fmt.Sprintf("invalid new object id: %s", err.Error()))
-}
-
-func errMalformedCommand(err error) error {
- return errMalformedRequest(fmt.Sprintf(
- "malformed command: %s", err.Error()))
-}
-
-// Decode reads the next update-request message form the reader and wr
-func (req *ReferenceUpdateRequest) Decode(r io.Reader) error {
- var rc io.ReadCloser
- var ok bool
- rc, ok = r.(io.ReadCloser)
- if !ok {
- rc = ioutil.NopCloser(r)
- }
-
- d := &updReqDecoder{r: rc, s: pktline.NewScanner(r)}
- return d.Decode(req)
-}
-
-type updReqDecoder struct {
- r io.ReadCloser
- s *pktline.Scanner
- req *ReferenceUpdateRequest
-}
-
-func (d *updReqDecoder) Decode(req *ReferenceUpdateRequest) error {
- d.req = req
- funcs := []func() error{
- d.scanLine,
- d.decodeShallow,
- d.decodeCommandAndCapabilities,
- d.decodeCommands,
- d.setPackfile,
- req.validate,
- }
-
- for _, f := range funcs {
- if err := f(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *updReqDecoder) scanLine() error {
- if ok := d.s.Scan(); !ok {
- return d.scanErrorOr(ErrEmpty)
- }
-
- return nil
-}
-
-func (d *updReqDecoder) decodeShallow() error {
- b := d.s.Bytes()
-
- if !bytes.HasPrefix(b, shallowNoSp) {
- return nil
- }
-
- if len(b) != shallowLineLength {
- return errInvalidShallowLineLength(len(b))
- }
-
- h, err := parseHash(string(b[len(shallow):]))
- if err != nil {
- return errInvalidShallowObjId(err)
- }
-
- if ok := d.s.Scan(); !ok {
- return d.scanErrorOr(errNoCommands)
- }
-
- d.req.Shallow = &h
-
- return nil
-}
-
-func (d *updReqDecoder) decodeCommands() error {
- for {
- b := d.s.Bytes()
- if bytes.Equal(b, pktline.Flush) {
- return nil
- }
-
- c, err := parseCommand(b)
- if err != nil {
- return err
- }
-
- d.req.Commands = append(d.req.Commands, c)
-
- if ok := d.s.Scan(); !ok {
- return d.s.Err()
- }
- }
-}
-
-func (d *updReqDecoder) decodeCommandAndCapabilities() error {
- b := d.s.Bytes()
- i := bytes.IndexByte(b, 0)
- if i == -1 {
- return errMissingCapabilitiesDelimiter
- }
-
- if len(b) < minCommandAndCapsLenth {
- return errInvalidCommandCapabilitiesLineLength(len(b))
- }
-
- cmd, err := parseCommand(b[:i])
- if err != nil {
- return err
- }
-
- d.req.Commands = append(d.req.Commands, cmd)
-
- if err := d.req.Capabilities.Decode(b[i+1:]); err != nil {
- return err
- }
-
- if err := d.scanLine(); err != nil {
- return err
- }
-
- return nil
-}
-
-func (d *updReqDecoder) setPackfile() error {
- d.req.Packfile = d.r
-
- return nil
-}
-
-func parseCommand(b []byte) (*Command, error) {
- if len(b) < minCommandLength {
- return nil, errInvalidCommandLineLength(len(b))
- }
-
- var (
- os, ns string
- n plumbing.ReferenceName
- )
- if _, err := fmt.Sscanf(string(b), "%s %s %s", &os, &ns, &n); err != nil {
- return nil, errMalformedCommand(err)
- }
-
- oh, err := parseHash(os)
- if err != nil {
- return nil, errInvalidOldObjId(err)
- }
-
- nh, err := parseHash(ns)
- if err != nil {
- return nil, errInvalidNewObjId(err)
- }
-
- return &Command{Old: oh, New: nh, Name: plumbing.ReferenceName(n)}, nil
-}
-
-func parseHash(s string) (plumbing.Hash, error) {
- if len(s) != hashSize {
- return plumbing.ZeroHash, errInvalidHashSize(len(s))
- }
-
- if _, err := hex.DecodeString(s); err != nil {
- return plumbing.ZeroHash, errInvalidHash(err)
- }
-
- h := plumbing.NewHash(s)
- return h, nil
-}
-
-func (d *updReqDecoder) scanErrorOr(origErr error) error {
- if err := d.s.Err(); err != nil {
- return err
- }
-
- return origErr
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_encode.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_encode.go
deleted file mode 100644
index 44c05739d8db776eef79811c3d2f0e9914d00514..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/updreq_encode.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package packp
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-var (
- zeroHashString = plumbing.ZeroHash.String()
-)
-
-// Encode writes the ReferenceUpdateRequest encoding to the stream.
-func (r *ReferenceUpdateRequest) Encode(w io.Writer) error {
- if err := r.validate(); err != nil {
- return err
- }
-
- e := pktline.NewEncoder(w)
-
- if err := r.encodeShallow(e, r.Shallow); err != nil {
- return err
- }
-
- if err := r.encodeCommands(e, r.Commands, r.Capabilities); err != nil {
- return err
- }
-
- if r.Packfile != nil {
- if _, err := io.Copy(w, r.Packfile); err != nil {
- return err
- }
-
- return r.Packfile.Close()
- }
-
- return nil
-}
-
-func (r *ReferenceUpdateRequest) encodeShallow(e *pktline.Encoder,
- h *plumbing.Hash) error {
-
- if h == nil {
- return nil
- }
-
- objId := []byte(h.String())
- return e.Encodef("%s%s", shallow, objId)
-}
-
-func (r *ReferenceUpdateRequest) encodeCommands(e *pktline.Encoder,
- cmds []*Command, cap *capability.List) error {
-
- if err := e.Encodef("%s\x00%s",
- formatCommand(cmds[0]), cap.String()); err != nil {
- return err
- }
-
- for _, cmd := range cmds[1:] {
- if err := e.Encodef(formatCommand(cmd)); err != nil {
- return err
- }
- }
-
- return e.Flush()
-}
-
-func formatCommand(cmd *Command) string {
- o := cmd.Old.String()
- n := cmd.New.String()
- return fmt.Sprintf("%s %s %s", o, n, cmd.Name)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackreq.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackreq.go
deleted file mode 100644
index 4bb22d0a066d2c5b31c78d2700e01ad3937e5b41..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackreq.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package packp
-
-import (
- "bytes"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-// UploadPackRequest represents a upload-pack request.
-// Zero-value is not safe, use NewUploadPackRequest instead.
-type UploadPackRequest struct {
- UploadRequest
- UploadHaves
-}
-
-// NewUploadPackRequest creates a new UploadPackRequest and returns a pointer.
-func NewUploadPackRequest() *UploadPackRequest {
- ur := NewUploadRequest()
- return &UploadPackRequest{
- UploadHaves: UploadHaves{},
- UploadRequest: *ur,
- }
-}
-
-// NewUploadPackRequestFromCapabilities creates a new UploadPackRequest and
-// returns a pointer. The request capabilities are filled with the most optiomal
-// ones, based on the adv value (advertaised capabilities), the UploadPackRequest
-// it has no wants, haves or shallows and an infinite depth
-func NewUploadPackRequestFromCapabilities(adv *capability.List) *UploadPackRequest {
- ur := NewUploadRequestFromCapabilities(adv)
- return &UploadPackRequest{
- UploadHaves: UploadHaves{},
- UploadRequest: *ur,
- }
-}
-
-// IsEmpty a request if empty if Haves are contained in the Wants, or if Wants
-// length is zero
-func (r *UploadPackRequest) IsEmpty() bool {
- return isSubset(r.Wants, r.Haves)
-}
-
-func isSubset(needle []plumbing.Hash, haystack []plumbing.Hash) bool {
- for _, h := range needle {
- found := false
- for _, oh := range haystack {
- if h == oh {
- found = true
- break
- }
- }
-
- if !found {
- return false
- }
- }
-
- return true
-}
-
-// UploadHaves is a message to signal the references that a client has in a
-// upload-pack. Do not use this directly. Use UploadPackRequest request instead.
-type UploadHaves struct {
- Haves []plumbing.Hash
-}
-
-// Encode encodes the UploadHaves into the Writer. If flush is true, a flush
-// command will be encoded at the end of the writer content.
-func (u *UploadHaves) Encode(w io.Writer, flush bool) error {
- e := pktline.NewEncoder(w)
-
- plumbing.HashesSort(u.Haves)
-
- var last plumbing.Hash
- for _, have := range u.Haves {
- if bytes.Compare(last[:], have[:]) == 0 {
- continue
- }
-
- if err := e.Encodef("have %s\n", have); err != nil {
- return fmt.Errorf("sending haves for %q: %s", have, err)
- }
-
- last = have
- }
-
- if flush && len(u.Haves) != 0 {
- if err := e.Flush(); err != nil {
- return fmt.Errorf("sending flush-pkt after haves: %s", err)
- }
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackresp.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackresp.go
deleted file mode 100644
index ac456f3dc34f421157fce154dae1304491f4910f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/uppackresp.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package packp
-
-import (
- "errors"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// ErrUploadPackResponseNotDecoded is returned if Read is called without
-// decoding first
-var ErrUploadPackResponseNotDecoded = errors.New("upload-pack-response should be decoded")
-
-// UploadPackResponse contains all the information responded by the upload-pack
-// service, the response implements io.ReadCloser that allows to read the
-// packfile directly from it.
-type UploadPackResponse struct {
- ShallowUpdate
- ServerResponse
-
- r io.ReadCloser
- isShallow bool
- isMultiACK bool
- isOk bool
-}
-
-// NewUploadPackResponse create a new UploadPackResponse instance, the request
-// being responded by the response is required.
-func NewUploadPackResponse(req *UploadPackRequest) *UploadPackResponse {
- isShallow := !req.Depth.IsZero()
- isMultiACK := req.Capabilities.Supports(capability.MultiACK) ||
- req.Capabilities.Supports(capability.MultiACKDetailed)
-
- return &UploadPackResponse{
- isShallow: isShallow,
- isMultiACK: isMultiACK,
- }
-}
-
-// NewUploadPackResponseWithPackfile creates a new UploadPackResponse instance,
-// and sets its packfile reader.
-func NewUploadPackResponseWithPackfile(req *UploadPackRequest,
- pf io.ReadCloser) *UploadPackResponse {
-
- r := NewUploadPackResponse(req)
- r.r = pf
- return r
-}
-
-// Decode decodes all the responses sent by upload-pack service into the struct
-// and prepares it to read the packfile using the Read method
-func (r *UploadPackResponse) Decode(reader io.ReadCloser) error {
- if r.isShallow {
- if err := r.ShallowUpdate.Decode(reader); err != nil {
- return err
- }
- }
-
- if err := r.ServerResponse.Decode(reader, r.isMultiACK); err != nil {
- return err
- }
-
- // now the reader is ready to read the packfile content
- r.r = reader
-
- return nil
-}
-
-// Encode encodes an UploadPackResponse.
-func (r *UploadPackResponse) Encode(w io.Writer) (err error) {
- if r.isShallow {
- if err := r.ShallowUpdate.Encode(w); err != nil {
- return err
- }
- }
-
- if err := r.ServerResponse.Encode(w); err != nil {
- return err
- }
-
- defer ioutil.CheckClose(r.r, &err)
- _, err = io.Copy(w, r.r)
- return err
-}
-
-// Read reads the packfile data, if the request was done with any Sideband
-// capability the content read should be demultiplexed. If the methods wasn't
-// called before the ErrUploadPackResponseNotDecoded will be return
-func (r *UploadPackResponse) Read(p []byte) (int, error) {
- if r.r == nil {
- return 0, ErrUploadPackResponseNotDecoded
- }
-
- return r.r.Read(p)
-}
-
-// Close the underlying reader, if any
-func (r *UploadPackResponse) Close() error {
- if r.r == nil {
- return nil
- }
-
- return r.r.Close()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/reference.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/reference.go
deleted file mode 100644
index 8fa103efb0243542ebec4d07f69f55e00f141059..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/reference.go
+++ /dev/null
@@ -1,179 +0,0 @@
-package plumbing
-
-import (
- "errors"
- "fmt"
- "strings"
-)
-
-const (
- refPrefix = "refs/"
- refHeadPrefix = refPrefix + "heads/"
- refTagPrefix = refPrefix + "tags/"
- refRemotePrefix = refPrefix + "remotes/"
- refNotePrefix = refPrefix + "notes/"
- symrefPrefix = "ref: "
-)
-
-var (
- refPrefixes = []string{
- refHeadPrefix,
- refTagPrefix,
- refRemotePrefix,
- refNotePrefix,
- refPrefix,
- }
-)
-
-var (
- ErrReferenceNotFound = errors.New("reference not found")
-)
-
-// ReferenceType reference type's
-type ReferenceType int8
-
-const (
- InvalidReference ReferenceType = 0
- HashReference ReferenceType = 1
- SymbolicReference ReferenceType = 2
-)
-
-func (r ReferenceType) String() string {
- switch r {
- case InvalidReference:
- return "invalid-reference"
- case HashReference:
- return "hash-reference"
- case SymbolicReference:
- return "symbolic-reference"
- }
-
- return ""
-}
-
-// ReferenceName reference name's
-type ReferenceName string
-
-func (r ReferenceName) String() string {
- return string(r)
-}
-
-// Short returns the short name of a ReferenceName
-func (r ReferenceName) Short() string {
- return r.removeRefPrefix()
-}
-
-// Instead of hardcoding a number of components, we should remove the prefixes
-// refHeadPrefix, refTagPrefix, refRemotePrefix, refNotePrefix and refPrefix
-func (r ReferenceName) removeRefPrefix() string {
- s := string(r)
- for _, prefix := range refPrefixes {
- s = strings.TrimPrefix(s, prefix)
- }
- return s
-}
-
-const (
- HEAD ReferenceName = "HEAD"
- Master ReferenceName = "refs/heads/master"
-)
-
-// Reference is a representation of git reference
-type Reference struct {
- t ReferenceType
- n ReferenceName
- h Hash
- target ReferenceName
-}
-
-// NewReferenceFromStrings creates a reference from name and target as string,
-// the resulting reference can be a SymbolicReference or a HashReference base
-// on the target provided
-func NewReferenceFromStrings(name, target string) *Reference {
- n := ReferenceName(name)
-
- if strings.HasPrefix(target, symrefPrefix) {
- target := ReferenceName(target[len(symrefPrefix):])
- return NewSymbolicReference(n, target)
- }
-
- return NewHashReference(n, NewHash(target))
-}
-
-// NewSymbolicReference creates a new SymbolicReference reference
-func NewSymbolicReference(n, target ReferenceName) *Reference {
- return &Reference{
- t: SymbolicReference,
- n: n,
- target: target,
- }
-}
-
-// NewHashReference creates a new HashReference reference
-func NewHashReference(n ReferenceName, h Hash) *Reference {
- return &Reference{
- t: HashReference,
- n: n,
- h: h,
- }
-}
-
-// Type return the type of a reference
-func (r *Reference) Type() ReferenceType {
- return r.t
-}
-
-// Name return the name of a reference
-func (r *Reference) Name() ReferenceName {
- return r.n
-}
-
-// Hash return the hash of a hash reference
-func (r *Reference) Hash() Hash {
- return r.h
-}
-
-// Target return the target of a symbolic reference
-func (r *Reference) Target() ReferenceName {
- return r.target
-}
-
-// IsBranch check if a reference is a branch
-func (r *Reference) IsBranch() bool {
- return strings.HasPrefix(string(r.n), refHeadPrefix)
-}
-
-// IsNote check if a reference is a note
-func (r *Reference) IsNote() bool {
- return strings.HasPrefix(string(r.n), refNotePrefix)
-}
-
-// IsRemote check if a reference is a remote
-func (r *Reference) IsRemote() bool {
- return strings.HasPrefix(string(r.n), refRemotePrefix)
-}
-
-// IsTag check if a reference is a tag
-func (r *Reference) IsTag() bool {
- return strings.HasPrefix(string(r.n), refTagPrefix)
-}
-
-// Strings dump a reference as a [2]string
-func (r *Reference) Strings() [2]string {
- var o [2]string
- o[0] = r.Name().String()
-
- switch r.Type() {
- case HashReference:
- o[1] = r.Hash().String()
- case SymbolicReference:
- o[1] = symrefPrefix + r.Target().String()
- }
-
- return o
-}
-
-func (r *Reference) String() string {
- s := r.Strings()
- return fmt.Sprintf("%s %s", s[1], s[0])
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/revision.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/revision.go
deleted file mode 100644
index 5f053b200c0b25787aa6ff330b6134977e2d0db6..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/revision.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package plumbing
-
-// Revision represents a git revision
-// to get more details about git revisions
-// please check git manual page :
-// https://www.kernel.org/pub/software/scm/git/docs/gitrevisions.html
-type Revision string
-
-func (r Revision) String() string {
- return string(r)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/revlist/revlist.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/revlist/revlist.go
deleted file mode 100644
index eb9afaf59ffc2ec9ba19fd7ea7e80405a1cc1146..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/revlist/revlist.go
+++ /dev/null
@@ -1,149 +0,0 @@
-// Package revlist provides support to access the ancestors of commits, in a
-// similar way as the git-rev-list command.
-package revlist
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-// Objects applies a complementary set. It gets all the hashes from all
-// the reachable objects from the given objects. Ignore param are object hashes
-// that we want to ignore on the result. All that objects must be accessible
-// from the object storer.
-func Objects(
- s storer.EncodedObjectStorer,
- objects []plumbing.Hash,
- ignore []plumbing.Hash) ([]plumbing.Hash, error) {
-
- seen := hashListToSet(ignore)
- result := make(map[plumbing.Hash]bool)
-
- walkerFunc := func(h plumbing.Hash) {
- if !seen[h] {
- result[h] = true
- seen[h] = true
- }
- }
-
- for _, h := range objects {
- if err := processObject(s, h, seen, walkerFunc); err != nil {
- return nil, err
- }
- }
-
- return hashSetToList(result), nil
-}
-
-// processObject obtains the object using the hash an process it depending of its type
-func processObject(
- s storer.EncodedObjectStorer,
- h plumbing.Hash,
- seen map[plumbing.Hash]bool,
- walkerFunc func(h plumbing.Hash),
-) error {
- o, err := s.EncodedObject(plumbing.AnyObject, h)
- if err != nil {
- return err
- }
-
- do, err := object.DecodeObject(s, o)
- if err != nil {
- return err
- }
-
- switch do := do.(type) {
- case *object.Commit:
- return reachableObjects(do, seen, walkerFunc)
- case *object.Tree:
- return iterateCommitTrees(seen, do, walkerFunc)
- case *object.Tag:
- walkerFunc(do.Hash)
- return processObject(s, do.Target, seen, walkerFunc)
- case *object.Blob:
- walkerFunc(do.Hash)
- default:
- return fmt.Errorf("object type not valid: %s. "+
- "Object reference: %s", o.Type(), o.Hash())
- }
-
- return nil
-}
-
-// reachableObjects returns, using the callback function, all the reachable
-// objects from the specified commit. To avoid to iterate over seen commits,
-// if a commit hash is into the 'seen' set, we will not iterate all his trees
-// and blobs objects.
-func reachableObjects(
- commit *object.Commit,
- seen map[plumbing.Hash]bool,
- cb func(h plumbing.Hash)) error {
- return object.WalkCommitHistory(commit, func(commit *object.Commit) error {
- if seen[commit.Hash] {
- return nil
- }
-
- cb(commit.Hash)
-
- tree, err := commit.Tree()
- if err != nil {
- return err
- }
-
- return iterateCommitTrees(seen, tree, cb)
- })
-}
-
-// iterateCommitTrees iterate all reachable trees from the given commit
-func iterateCommitTrees(
- seen map[plumbing.Hash]bool,
- tree *object.Tree,
- cb func(h plumbing.Hash)) error {
- if seen[tree.Hash] {
- return nil
- }
-
- cb(tree.Hash)
-
- treeWalker := object.NewTreeWalker(tree, true)
-
- for {
- _, e, err := treeWalker.Next()
- if err == io.EOF {
- break
- }
- if err != nil {
- return err
- }
-
- if seen[e.Hash] {
- continue
- }
-
- cb(e.Hash)
- }
-
- return nil
-}
-
-func hashSetToList(hashes map[plumbing.Hash]bool) []plumbing.Hash {
- var result []plumbing.Hash
- for key := range hashes {
- result = append(result, key)
- }
-
- return result
-}
-
-func hashListToSet(hashes []plumbing.Hash) map[plumbing.Hash]bool {
- result := make(map[plumbing.Hash]bool)
- for _, h := range hashes {
- result[h] = true
- }
-
- return result
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/doc.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/doc.go
deleted file mode 100644
index 4d4f179c61839f9e3504f901d366f00fb8e1ad61..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package storer defines the interfaces to store objects, references, etc.
-package storer
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/index.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/index.go
deleted file mode 100644
index e087296ec9dbd34210e76868b7caf79f682489d7..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/index.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package storer
-
-import "gopkg.in/src-d/go-git.v4/plumbing/format/index"
-
-// IndexStorer generic storage of index.Index
-type IndexStorer interface {
- SetIndex(*index.Index) error
- Index() (*index.Index, error)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/object.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/object.go
deleted file mode 100644
index a733ee6f05f07492d5bbc94cc01d6fb34b8fa6cc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/object.go
+++ /dev/null
@@ -1,248 +0,0 @@
-package storer
-
-import (
- "errors"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-var (
- //ErrStop is used to stop a ForEach function in an Iter
- ErrStop = errors.New("stop iter")
-)
-
-// EncodedObjectStorer generic storage of objects
-type EncodedObjectStorer interface {
- // NewEncodedObject returns a new plumbing.EncodedObject, the real type
- // of the object can be a custom implementation or the default one,
- // plumbing.MemoryObject.
- NewEncodedObject() plumbing.EncodedObject
- // SetEncodedObject saves an object into the storage, the object should
- // be create with the NewEncodedObject, method, and file if the type is
- // not supported.
- SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
- // EncodedObject gets an object by hash with the given
- // plumbing.ObjectType. Implementors should return
- // (nil, plumbing.ErrObjectNotFound) if an object doesn't exist with
- // both the given hash and object type.
- //
- // Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
- // TreeObject and AnyObject. If plumbing.AnyObject is given, the object must
- // be looked up regardless of its type.
- EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
- // IterObjects returns a custom EncodedObjectStorer over all the object
- // on the storage.
- //
- // Valid plumbing.ObjectType values are CommitObject, BlobObject, TagObject,
- IterEncodedObjects(plumbing.ObjectType) (EncodedObjectIter, error)
-}
-
-// Transactioner is a optional method for ObjectStorer, it enable transaction
-// base write and read operations in the storage
-type Transactioner interface {
- // Begin starts a transaction.
- Begin() Transaction
-}
-
-// PackfileWriter is a optional method for ObjectStorer, it enable direct write
-// of packfile to the storage
-type PackfileWriter interface {
- // PackfileWriter returns a writer for writing a packfile to the storage
- //
- // If the Storer not implements PackfileWriter the objects should be written
- // using the Set method.
- PackfileWriter() (io.WriteCloser, error)
-}
-
-// EncodedObjectIter is a generic closable interface for iterating over objects.
-type EncodedObjectIter interface {
- Next() (plumbing.EncodedObject, error)
- ForEach(func(plumbing.EncodedObject) error) error
- Close()
-}
-
-// Transaction is an in-progress storage transaction. A transaction must end
-// with a call to Commit or Rollback.
-type Transaction interface {
- SetEncodedObject(plumbing.EncodedObject) (plumbing.Hash, error)
- EncodedObject(plumbing.ObjectType, plumbing.Hash) (plumbing.EncodedObject, error)
- Commit() error
- Rollback() error
-}
-
-// EncodedObjectLookupIter implements EncodedObjectIter. It iterates over a
-// series of object hashes and yields their associated objects by retrieving
-// each one from object storage. The retrievals are lazy and only occur when the
-// iterator moves forward with a call to Next().
-//
-// The EncodedObjectLookupIter must be closed with a call to Close() when it is
-// no longer needed.
-type EncodedObjectLookupIter struct {
- storage EncodedObjectStorer
- series []plumbing.Hash
- t plumbing.ObjectType
- pos int
-}
-
-// NewEncodedObjectLookupIter returns an object iterator given an object storage
-// and a slice of object hashes.
-func NewEncodedObjectLookupIter(
- storage EncodedObjectStorer, t plumbing.ObjectType, series []plumbing.Hash) *EncodedObjectLookupIter {
- return &EncodedObjectLookupIter{
- storage: storage,
- series: series,
- t: t,
- }
-}
-
-// Next returns the next object from the iterator. If the iterator has reached
-// the end it will return io.EOF as an error. If the object can't be found in
-// the object storage, it will return plumbing.ErrObjectNotFound as an error.
-// If the object is retreieved successfully error will be nil.
-func (iter *EncodedObjectLookupIter) Next() (plumbing.EncodedObject, error) {
- if iter.pos >= len(iter.series) {
- return nil, io.EOF
- }
-
- hash := iter.series[iter.pos]
- obj, err := iter.storage.EncodedObject(iter.t, hash)
- if err == nil {
- iter.pos++
- }
-
- return obj, err
-}
-
-// ForEach call the cb function for each object contained on this iter until
-// an error happends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *EncodedObjectLookupIter) ForEach(cb func(plumbing.EncodedObject) error) error {
- return ForEachIterator(iter, cb)
-}
-
-// Close releases any resources used by the iterator.
-func (iter *EncodedObjectLookupIter) Close() {
- iter.pos = len(iter.series)
-}
-
-// EncodedObjectSliceIter implements EncodedObjectIter. It iterates over a
-// series of objects stored in a slice and yields each one in turn when Next()
-// is called.
-//
-// The EncodedObjectSliceIter must be closed with a call to Close() when it is
-// no longer needed.
-type EncodedObjectSliceIter struct {
- series []plumbing.EncodedObject
- pos int
-}
-
-// NewEncodedObjectSliceIter returns an object iterator for the given slice of
-// objects.
-func NewEncodedObjectSliceIter(series []plumbing.EncodedObject) *EncodedObjectSliceIter {
- return &EncodedObjectSliceIter{
- series: series,
- }
-}
-
-// Next returns the next object from the iterator. If the iterator has reached
-// the end it will return io.EOF as an error. If the object is retreieved
-// successfully error will be nil.
-func (iter *EncodedObjectSliceIter) Next() (plumbing.EncodedObject, error) {
- if len(iter.series) == 0 {
- return nil, io.EOF
- }
-
- obj := iter.series[0]
- iter.series = iter.series[1:]
-
- return obj, nil
-}
-
-// ForEach call the cb function for each object contained on this iter until
-// an error happends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *EncodedObjectSliceIter) ForEach(cb func(plumbing.EncodedObject) error) error {
- return ForEachIterator(iter, cb)
-}
-
-// Close releases any resources used by the iterator.
-func (iter *EncodedObjectSliceIter) Close() {
- iter.series = []plumbing.EncodedObject{}
-}
-
-// MultiEncodedObjectIter implements EncodedObjectIter. It iterates over several
-// EncodedObjectIter,
-//
-// The MultiObjectIter must be closed with a call to Close() when it is no
-// longer needed.
-type MultiEncodedObjectIter struct {
- iters []EncodedObjectIter
- pos int
-}
-
-// NewMultiEncodedObjectIter returns an object iterator for the given slice of
-// objects.
-func NewMultiEncodedObjectIter(iters []EncodedObjectIter) EncodedObjectIter {
- return &MultiEncodedObjectIter{iters: iters}
-}
-
-// Next returns the next object from the iterator, if one iterator reach io.EOF
-// is removed and the next one is used.
-func (iter *MultiEncodedObjectIter) Next() (plumbing.EncodedObject, error) {
- if len(iter.iters) == 0 {
- return nil, io.EOF
- }
-
- obj, err := iter.iters[0].Next()
- if err == io.EOF {
- iter.iters[0].Close()
- iter.iters = iter.iters[1:]
- return iter.Next()
- }
-
- return obj, err
-}
-
-// ForEach call the cb function for each object contained on this iter until
-// an error happends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *MultiEncodedObjectIter) ForEach(cb func(plumbing.EncodedObject) error) error {
- return ForEachIterator(iter, cb)
-}
-
-// Close releases any resources used by the iterator.
-func (iter *MultiEncodedObjectIter) Close() {
- for _, i := range iter.iters {
- i.Close()
- }
-}
-
-type bareIterator interface {
- Next() (plumbing.EncodedObject, error)
- Close()
-}
-
-// ForEachIterator is a helper function to build iterators without need to
-// rewrite the same ForEach function each time.
-func ForEachIterator(iter bareIterator, cb func(plumbing.EncodedObject) error) error {
- defer iter.Close()
- for {
- obj, err := iter.Next()
- if err != nil {
- if err == io.EOF {
- return nil
- }
-
- return err
- }
-
- if err := cb(obj); err != nil {
- if err == ErrStop {
- return nil
- }
-
- return err
- }
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/reference.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/reference.go
deleted file mode 100644
index 988c78466787d6a5d5bfca38a1cde74ececf2404..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/reference.go
+++ /dev/null
@@ -1,171 +0,0 @@
-package storer
-
-import (
- "errors"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-const MaxResolveRecursion = 1024
-
-// ErrMaxResolveRecursion is returned by ResolveReference is MaxResolveRecursion
-// is exceeded
-var ErrMaxResolveRecursion = errors.New("max. recursion level reached")
-
-// ReferenceStorer is a generic storage of references.
-type ReferenceStorer interface {
- SetReference(*plumbing.Reference) error
- Reference(plumbing.ReferenceName) (*plumbing.Reference, error)
- IterReferences() (ReferenceIter, error)
- RemoveReference(plumbing.ReferenceName) error
-}
-
-// ReferenceIter is a generic closable interface for iterating over references.
-type ReferenceIter interface {
- Next() (*plumbing.Reference, error)
- ForEach(func(*plumbing.Reference) error) error
- Close()
-}
-
-type referenceFilteredIter struct {
- ff func(r *plumbing.Reference) bool
- iter ReferenceIter
-}
-
-// NewReferenceFilteredIter returns a reference iterator for the given reference
-// Iterator. This iterator will iterate only references that accomplish the
-// provided function.
-func NewReferenceFilteredIter(
- ff func(r *plumbing.Reference) bool, iter ReferenceIter) ReferenceIter {
- return &referenceFilteredIter{ff, iter}
-}
-
-// Next returns the next reference from the iterator. If the iterator has reached
-// the end it will return io.EOF as an error.
-func (iter *referenceFilteredIter) Next() (*plumbing.Reference, error) {
- for {
- r, err := iter.iter.Next()
- if err != nil {
- return nil, err
- }
-
- if iter.ff(r) {
- return r, nil
- }
-
- continue
- }
-}
-
-// ForEach call the cb function for each reference contained on this iter until
-// an error happens or the end of the iter is reached. If ErrStop is sent
-// the iteration is stopped but no error is returned. The iterator is closed.
-func (iter *referenceFilteredIter) ForEach(cb func(*plumbing.Reference) error) error {
- defer iter.Close()
- for {
- r, err := iter.Next()
- if err == io.EOF {
- break
- }
- if err != nil {
- return err
- }
-
- if err := cb(r); err != nil {
- if err == ErrStop {
- break
- }
-
- return err
- }
- }
-
- return nil
-}
-
-// Close releases any resources used by the iterator.
-func (iter *referenceFilteredIter) Close() {
- iter.iter.Close()
-}
-
-// ReferenceSliceIter implements ReferenceIter. It iterates over a series of
-// references stored in a slice and yields each one in turn when Next() is
-// called.
-//
-// The ReferenceSliceIter must be closed with a call to Close() when it is no
-// longer needed.
-type ReferenceSliceIter struct {
- series []*plumbing.Reference
- pos int
-}
-
-// NewReferenceSliceIter returns a reference iterator for the given slice of
-// objects.
-func NewReferenceSliceIter(series []*plumbing.Reference) ReferenceIter {
- return &ReferenceSliceIter{
- series: series,
- }
-}
-
-// Next returns the next reference from the iterator. If the iterator has
-// reached the end it will return io.EOF as an error.
-func (iter *ReferenceSliceIter) Next() (*plumbing.Reference, error) {
- if iter.pos >= len(iter.series) {
- return nil, io.EOF
- }
-
- obj := iter.series[iter.pos]
- iter.pos++
- return obj, nil
-}
-
-// ForEach call the cb function for each reference contained on this iter until
-// an error happends or the end of the iter is reached. If ErrStop is sent
-// the iteration is stop but no error is returned. The iterator is closed.
-func (iter *ReferenceSliceIter) ForEach(cb func(*plumbing.Reference) error) error {
- defer iter.Close()
- for _, r := range iter.series {
- if err := cb(r); err != nil {
- if err == ErrStop {
- return nil
- }
-
- return err
- }
- }
-
- return nil
-}
-
-// Close releases any resources used by the iterator.
-func (iter *ReferenceSliceIter) Close() {
- iter.pos = len(iter.series)
-}
-
-// ResolveReference resolves a SymbolicReference to a HashReference.
-func ResolveReference(s ReferenceStorer, n plumbing.ReferenceName) (*plumbing.Reference, error) {
- r, err := s.Reference(n)
- if err != nil || r == nil {
- return r, err
- }
- return resolveReference(s, r, 0)
-}
-
-func resolveReference(s ReferenceStorer, r *plumbing.Reference, recursion int) (*plumbing.Reference, error) {
- if r.Type() != plumbing.SymbolicReference {
- return r, nil
- }
-
- if recursion > MaxResolveRecursion {
- return nil, ErrMaxResolveRecursion
- }
-
- t, err := s.Reference(r.Target())
- if err != nil {
- return nil, err
- }
-
- recursion++
- return resolveReference(s, t, recursion)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/shallow.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/shallow.go
deleted file mode 100644
index 39aaaa540d8af6cf31c68b9757dda99ba5c9485a..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/shallow.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package storer
-
-import "gopkg.in/src-d/go-git.v4/plumbing"
-
-// ShallowStorer is a storage of references to shallow commits by hash,
-// meaning that these commits have missing parents because of a shallow fetch.
-type ShallowStorer interface {
- SetShallow([]plumbing.Hash) error
- Shallow() ([]plumbing.Hash, error)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/storer.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/storer.go
deleted file mode 100644
index 0b96c0ee1c9f29c64afd5a8552cda88a14b6183e..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/storer/storer.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package storer
-
-// Storer is a basic storer for encoded objects and references.
-type Storer interface {
- EncodedObjectStorer
- ReferenceStorer
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/client/client.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/client/client.go
deleted file mode 100644
index a398a743f6b0ab544a307652e543ee64970e43c9..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/client/client.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Package client contains helper function to deal with the different client
-// protocols.
-package client
-
-import (
- "fmt"
-
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/file"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/git"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/http"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/ssh"
-)
-
-// Protocols are the protocols supported by default.
-var Protocols = map[string]transport.Transport{
- "http": http.DefaultClient,
- "https": http.DefaultClient,
- "ssh": ssh.DefaultClient,
- "git": git.DefaultClient,
- "file": file.DefaultClient,
-}
-
-// InstallProtocol adds or modifies an existing protocol.
-func InstallProtocol(scheme string, c transport.Transport) {
- if c == nil {
- delete(Protocols, scheme)
- return
- }
-
- Protocols[scheme] = c
-}
-
-// NewClient returns the appropriate client among of the set of known protocols:
-// http://, https://, ssh:// and file://.
-// See `InstallProtocol` to add or modify protocols.
-func NewClient(endpoint transport.Endpoint) (transport.Transport, error) {
- f, ok := Protocols[endpoint.Scheme]
- if !ok {
- return nil, fmt.Errorf("unsupported scheme %q", endpoint.Scheme)
- }
-
- if f == nil {
- return nil, fmt.Errorf("malformed client for scheme %q, client is defined as nil", endpoint.Scheme)
- }
-
- return f, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/common.go
deleted file mode 100644
index 3fcdef24d55e027a980678e6c2e24c4f56c02556..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/common.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// Package transport includes the implementation for different transport
-// protocols.
-//
-// `Client` can be used to fetch and send packfiles to a git server.
-// The `client` package provides higher level functions to instantiate the
-// appropriate `Client` based on the repository URL.
-//
-// go-git supports HTTP and SSH (see `Protocols`), but you can also install
-// your own protocols (see the `client` package).
-//
-// Each protocol has its own implementation of `Client`, but you should
-// generally not use them directly, use `client.NewClient` instead.
-package transport
-
-import (
- "errors"
- "fmt"
- "io"
- "net/url"
- "regexp"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
-)
-
-var (
- ErrRepositoryNotFound = errors.New("repository not found")
- ErrEmptyRemoteRepository = errors.New("remote repository is empty")
- ErrAuthorizationRequired = errors.New("authorization required")
- ErrEmptyUploadPackRequest = errors.New("empty git-upload-pack given")
- ErrInvalidAuthMethod = errors.New("invalid auth method")
- ErrAlreadyConnected = errors.New("session already established")
-)
-
-const (
- UploadPackServiceName = "git-upload-pack"
- ReceivePackServiceName = "git-receive-pack"
-)
-
-// Transport can initiate git-upload-pack and git-receive-pack processes.
-// It is implemented both by the client and the server, making this a RPC.
-type Transport interface {
- // NewUploadPackSession starts a git-upload-pack session for an endpoint.
- NewUploadPackSession(Endpoint, AuthMethod) (UploadPackSession, error)
- // NewReceivePackSession starts a git-receive-pack session for an endpoint.
- NewReceivePackSession(Endpoint, AuthMethod) (ReceivePackSession, error)
-}
-
-type Session interface {
- // AdvertisedReferences retrieves the advertised references for a
- // repository.
- // If the repository does not exist, returns ErrRepositoryNotFound.
- // If the repository exists, but is empty, returns ErrEmptyRemoteRepository.
- AdvertisedReferences() (*packp.AdvRefs, error)
- io.Closer
-}
-
-type AuthMethod interface {
- fmt.Stringer
- Name() string
-}
-
-// UploadPackSession represents a git-upload-pack session.
-// A git-upload-pack session has two steps: reference discovery
-// (AdvertisedReferences) and uploading pack (UploadPack).
-type UploadPackSession interface {
- Session
- // UploadPack takes a git-upload-pack request and returns a response,
- // including a packfile. Don't be confused by terminology, the client
- // side of a git-upload-pack is called git-fetch-pack, although here
- // the same interface is used to make it RPC-like.
- UploadPack(*packp.UploadPackRequest) (*packp.UploadPackResponse, error)
-}
-
-// ReceivePackSession represents a git-receive-pack session.
-// A git-receive-pack session has two steps: reference discovery
-// (AdvertisedReferences) and receiving pack (ReceivePack).
-// In that order.
-type ReceivePackSession interface {
- Session
- // ReceivePack sends an update references request and a packfile
- // reader and returns a ReportStatus and error. Don't be confused by
- // terminology, the client side of a git-receive-pack is called
- // git-send-pack, although here the same interface is used to make it
- // RPC-like.
- ReceivePack(*packp.ReferenceUpdateRequest) (*packp.ReportStatus, error)
-}
-
-type Endpoint url.URL
-
-var (
- isSchemeRegExp = regexp.MustCompile("^[^:]+://")
- scpLikeUrlRegExp = regexp.MustCompile("^(?P<user>[^@]+@)?(?P<host>[^:]+):/?(?P<path>.+)$")
-)
-
-func NewEndpoint(endpoint string) (Endpoint, error) {
- endpoint = transformSCPLikeIfNeeded(endpoint)
-
- u, err := url.Parse(endpoint)
- if err != nil {
- return Endpoint{}, plumbing.NewPermanentError(err)
- }
-
- if !u.IsAbs() {
- return Endpoint{}, plumbing.NewPermanentError(fmt.Errorf(
- "invalid endpoint: %s", endpoint,
- ))
- }
-
- return Endpoint(*u), nil
-}
-
-func (e *Endpoint) String() string {
- u := url.URL(*e)
- return u.String()
-}
-
-func transformSCPLikeIfNeeded(endpoint string) string {
- if !isSchemeRegExp.MatchString(endpoint) && scpLikeUrlRegExp.MatchString(endpoint) {
- m := scpLikeUrlRegExp.FindStringSubmatch(endpoint)
- return fmt.Sprintf("ssh://%s%s/%s", m[1], m[2], m[3])
- }
-
- return endpoint
-}
-
-// UnsupportedCapabilities are the capabilities not supported by any client
-// implementation
-var UnsupportedCapabilities = []capability.Capability{
- capability.MultiACK,
- capability.MultiACKDetailed,
- capability.ThinPack,
-}
-
-// FilterUnsupportedCapabilities it filter out all the UnsupportedCapabilities
-// from a capability.List, the intended usage is on the client implementation
-// to filter the capabilities from an AdvRefs message.
-func FilterUnsupportedCapabilities(list *capability.List) {
- for _, c := range UnsupportedCapabilities {
- list.Delete(c)
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/client.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/client.go
deleted file mode 100644
index 58e60dbc3c82a84c03cca26e75c950abd3b13c9b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/client.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Package file implements the file transport protocol.
-package file
-
-import (
- "io"
- "os/exec"
-
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common"
-)
-
-// DefaultClient is the default local client.
-var DefaultClient = NewClient(
- transport.UploadPackServiceName,
- transport.ReceivePackServiceName,
-)
-
-type runner struct {
- UploadPackBin string
- ReceivePackBin string
-}
-
-// NewClient returns a new local client using the given git-upload-pack and
-// git-receive-pack binaries.
-func NewClient(uploadPackBin, receivePackBin string) transport.Transport {
- return common.NewClient(&runner{
- UploadPackBin: uploadPackBin,
- ReceivePackBin: receivePackBin,
- })
-}
-
-func (r *runner) Command(cmd string, ep transport.Endpoint, auth transport.AuthMethod) (common.Command, error) {
- switch cmd {
- case transport.UploadPackServiceName:
- cmd = r.UploadPackBin
- case transport.ReceivePackServiceName:
- cmd = r.ReceivePackBin
- }
-
- if _, err := exec.LookPath(cmd); err != nil {
- return nil, err
- }
-
- return &command{cmd: exec.Command(cmd, ep.Path)}, nil
-}
-
-type command struct {
- cmd *exec.Cmd
- closed bool
-}
-
-func (c *command) Start() error {
- return c.cmd.Start()
-}
-
-func (c *command) StderrPipe() (io.Reader, error) {
- return c.cmd.StderrPipe()
-}
-
-func (c *command) StdinPipe() (io.WriteCloser, error) {
- return c.cmd.StdinPipe()
-}
-
-func (c *command) StdoutPipe() (io.Reader, error) {
- return c.cmd.StdoutPipe()
-}
-
-// Close waits for the command to exit.
-func (c *command) Close() error {
- if c.closed {
- return nil
- }
-
- return c.cmd.Process.Kill()
-}
-
-func (c *command) Wait() error {
- defer func() { c.closed = true }()
- return c.cmd.Wait()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/server.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/server.go
deleted file mode 100644
index 74085c276a6a4e1e65b5fa4bac64ffaa890c8a4c..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/file/server.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package file
-
-import (
- "fmt"
- "os"
-
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/server"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// ServeUploadPack serves a git-upload-pack request using standard output, input
-// and error. This is meant to be used when implementing a git-upload-pack
-// command.
-func ServeUploadPack(path string) error {
- ep, err := transport.NewEndpoint(fmt.Sprintf("file://%s", path))
- if err != nil {
- return err
- }
-
- // TODO: define and implement a server-side AuthMethod
- s, err := server.DefaultServer.NewUploadPackSession(ep, nil)
- if err != nil {
- return fmt.Errorf("error creating session: %s", err)
- }
-
- return common.ServeUploadPack(srvCmd, s)
-}
-
-// ServeReceivePack serves a git-receive-pack request using standard output,
-// input and error. This is meant to be used when implementing a
-// git-receive-pack command.
-func ServeReceivePack(path string) error {
- ep, err := transport.NewEndpoint(fmt.Sprintf("file://%s", path))
- if err != nil {
- return err
- }
-
- // TODO: define and implement a server-side AuthMethod
- s, err := server.DefaultServer.NewReceivePackSession(ep, nil)
- if err != nil {
- return fmt.Errorf("error creating session: %s", err)
- }
-
- return common.ServeReceivePack(srvCmd, s)
-}
-
-var srvCmd = common.ServerCommand{
- Stdin: os.Stdin,
- Stdout: ioutil.WriteNopCloser(os.Stdout),
- Stderr: os.Stderr,
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/git/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/git/common.go
deleted file mode 100644
index 24134c1b295a930a3ee0ec2dcaf06bd5436dcb88..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/git/common.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Package git implements the git transport protocol.
-package git
-
-import (
- "fmt"
- "io"
- "net"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// DefaultClient is the default git client.
-var DefaultClient = common.NewClient(&runner{})
-
-type runner struct{}
-
-// Command returns a new Command for the given cmd in the given Endpoint
-func (r *runner) Command(cmd string, ep transport.Endpoint, auth transport.AuthMethod) (common.Command, error) {
- // auth not allowed since git protocol doesn't support authentication
- if auth != nil {
- return nil, transport.ErrInvalidAuthMethod
- }
- c := &command{command: cmd, endpoint: ep}
- if err := c.connect(); err != nil {
- return nil, err
- }
- return c, nil
-}
-
-type command struct {
- conn net.Conn
- connected bool
- command string
- endpoint transport.Endpoint
-}
-
-// Start executes the command sending the required message to the TCP connection
-func (c *command) Start() error {
- cmd := endpointToCommand(c.command, c.endpoint)
-
- e := pktline.NewEncoder(c.conn)
- return e.Encode([]byte(cmd))
-}
-
-func (c *command) connect() error {
- if c.connected {
- return transport.ErrAlreadyConnected
- }
-
- var err error
- c.conn, err = net.Dial("tcp", c.getHostWithPort())
- if err != nil {
- return err
- }
-
- c.connected = true
- return nil
-}
-
-func (c *command) getHostWithPort() string {
- host := c.endpoint.Host
- if strings.Index(c.endpoint.Host, ":") == -1 {
- host += ":9418"
- }
-
- return host
-}
-
-// StderrPipe git protocol doesn't have any dedicated error channel
-func (c *command) StderrPipe() (io.Reader, error) {
- return nil, nil
-}
-
-// StdinPipe return the underlying connection as WriteCloser, wrapped to prevent
-// call to the Close function from the connection, a command execution in git
-// protocol can't be closed or killed
-func (c *command) StdinPipe() (io.WriteCloser, error) {
- return ioutil.WriteNopCloser(c.conn), nil
-}
-
-// StdoutPipe return the underlying connection as Reader
-func (c *command) StdoutPipe() (io.Reader, error) {
- return c.conn, nil
-}
-
-func endpointToCommand(cmd string, ep transport.Endpoint) string {
- return fmt.Sprintf("%s %s%chost=%s%c", cmd, ep.Path, 0, ep.Host, 0)
-}
-
-// Wait no-op function, required by the interface
-func (c *command) Wait() error {
- return nil
-}
-
-// Close closes the TCP connection and connection.
-func (c *command) Close() error {
- if !c.connected {
- return nil
- }
-
- c.connected = false
- return c.conn.Close()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/common.go
deleted file mode 100644
index baad12ec6707552476a5d3ea5548a05c4cd8e08e..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/common.go
+++ /dev/null
@@ -1,152 +0,0 @@
-// Package http implements the HTTP transport protocol.
-package http
-
-import (
- "fmt"
- "net/http"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
-)
-
-type client struct {
- c *http.Client
-}
-
-// DefaultClient is the default HTTP client, which uses `http.DefaultClient`.
-var DefaultClient = NewClient(nil)
-
-// NewClient creates a new client with a custom net/http client.
-// See `InstallProtocol` to install and override default http client.
-// Unless a properly initialized client is given, it will fall back into
-// `http.DefaultClient`.
-//
-// Note that for HTTP client cannot distinguist between private repositories and
-// unexistent repositories on GitHub. So it returns `ErrAuthorizationRequired`
-// for both.
-func NewClient(c *http.Client) transport.Transport {
- if c == nil {
- return &client{http.DefaultClient}
- }
-
- return &client{
- c: c,
- }
-}
-
-func (c *client) NewUploadPackSession(ep transport.Endpoint, auth transport.AuthMethod) (
- transport.UploadPackSession, error) {
-
- return newUploadPackSession(c.c, ep, auth)
-}
-
-func (c *client) NewReceivePackSession(ep transport.Endpoint, auth transport.AuthMethod) (
- transport.ReceivePackSession, error) {
-
- return newReceivePackSession(c.c, ep, auth)
-}
-
-type session struct {
- auth AuthMethod
- client *http.Client
- endpoint transport.Endpoint
- advRefs *packp.AdvRefs
-}
-
-func (*session) Close() error {
- return nil
-}
-
-func (s *session) applyAuthToRequest(req *http.Request) {
- if s.auth == nil {
- return
- }
-
- s.auth.setAuth(req)
-}
-
-// AuthMethod is concrete implementation of common.AuthMethod for HTTP services
-type AuthMethod interface {
- transport.AuthMethod
- setAuth(r *http.Request)
-}
-
-func basicAuthFromEndpoint(ep transport.Endpoint) *BasicAuth {
- info := ep.User
- if info == nil {
- return nil
- }
-
- p, ok := info.Password()
- if !ok {
- return nil
- }
-
- u := info.Username()
- return NewBasicAuth(u, p)
-}
-
-// BasicAuth represent a HTTP basic auth
-type BasicAuth struct {
- username, password string
-}
-
-// NewBasicAuth returns a basicAuth base on the given user and password
-func NewBasicAuth(username, password string) *BasicAuth {
- return &BasicAuth{username, password}
-}
-
-func (a *BasicAuth) setAuth(r *http.Request) {
- if a == nil {
- return
- }
-
- r.SetBasicAuth(a.username, a.password)
-}
-
-// Name is name of the auth
-func (a *BasicAuth) Name() string {
- return "http-basic-auth"
-}
-
-func (a *BasicAuth) String() string {
- masked := "*******"
- if a.password == "" {
- masked = "<empty>"
- }
-
- return fmt.Sprintf("%s - %s:%s", a.Name(), a.username, masked)
-}
-
-// Err is a dedicated error to return errors based on status code
-type Err struct {
- Response *http.Response
-}
-
-// NewErr returns a new Err based on a http response
-func NewErr(r *http.Response) error {
- if r.StatusCode >= http.StatusOK && r.StatusCode < http.StatusMultipleChoices {
- return nil
- }
-
- switch r.StatusCode {
- case http.StatusUnauthorized:
- return transport.ErrAuthorizationRequired
- case http.StatusNotFound:
- return transport.ErrRepositoryNotFound
- }
-
- return plumbing.NewUnexpectedError(&Err{r})
-}
-
-// StatusCode returns the status code of the response
-func (e *Err) StatusCode() int {
- return e.Response.StatusCode
-}
-
-func (e *Err) Error() string {
- return fmt.Sprintf("unexpected requesting %q status code: %d",
- e.Response.Request.URL, e.Response.StatusCode,
- )
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/receive_pack.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/receive_pack.go
deleted file mode 100644
index 7a3704927400d959008bdfddf9efc4a0c9d56247..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/receive_pack.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package http
-
-import (
- "errors"
- "net/http"
-
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
-)
-
-var errReceivePackNotSupported = errors.New("receive-pack not supported yet")
-
-type rpSession struct {
- *session
-}
-
-func newReceivePackSession(c *http.Client, ep transport.Endpoint, auth transport.AuthMethod) (transport.ReceivePackSession, error) {
- return &rpSession{&session{}}, nil
-}
-
-func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) {
-
- return nil, errReceivePackNotSupported
-}
-
-func (s *rpSession) ReceivePack(*packp.ReferenceUpdateRequest) (
- *packp.ReportStatus, error) {
-
- return nil, errReceivePackNotSupported
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/upload_pack.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/upload_pack.go
deleted file mode 100644
index fd1787c95783126d6367ec172cb4c622af3bab71..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/http/upload_pack.go
+++ /dev/null
@@ -1,183 +0,0 @@
-package http
-
-import (
- "bytes"
- "fmt"
- "io"
- "net/http"
- "strconv"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-type upSession struct {
- *session
-}
-
-func newUploadPackSession(c *http.Client, ep transport.Endpoint, auth transport.AuthMethod) (transport.UploadPackSession, error) {
- s := &session{
- auth: basicAuthFromEndpoint(ep),
- client: c,
- endpoint: ep,
- }
- if auth != nil {
- a, ok := auth.(AuthMethod)
- if !ok {
- return nil, transport.ErrInvalidAuthMethod
- }
-
- s.auth = a
- }
-
- return &upSession{session: s}, nil
-}
-
-func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) {
- if s.advRefs != nil {
- return s.advRefs, nil
- }
-
- url := fmt.Sprintf(
- "%s/info/refs?service=%s",
- s.endpoint.String(), transport.UploadPackServiceName,
- )
-
- req, err := http.NewRequest(http.MethodGet, url, nil)
- if err != nil {
- return nil, err
- }
-
- s.applyAuthToRequest(req)
- s.applyHeadersToRequest(req, nil)
- res, err := s.client.Do(req)
- if err != nil {
- return nil, err
- }
-
- defer res.Body.Close()
-
- if res.StatusCode == http.StatusUnauthorized {
- return nil, transport.ErrAuthorizationRequired
- }
-
- ar := packp.NewAdvRefs()
- if err := ar.Decode(res.Body); err != nil {
- if err == packp.ErrEmptyAdvRefs {
- err = transport.ErrEmptyRemoteRepository
- }
-
- return nil, err
- }
-
- transport.FilterUnsupportedCapabilities(ar.Capabilities)
- s.advRefs = ar
- return ar, nil
-}
-
-func (s *upSession) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) {
- if req.IsEmpty() {
- return nil, transport.ErrEmptyUploadPackRequest
- }
-
- if err := req.Validate(); err != nil {
- return nil, err
- }
-
- url := fmt.Sprintf(
- "%s/%s",
- s.endpoint.String(), transport.UploadPackServiceName,
- )
-
- content, err := uploadPackRequestToReader(req)
- if err != nil {
- return nil, err
- }
-
- res, err := s.doRequest(http.MethodPost, url, content)
- if err != nil {
- return nil, err
- }
-
- r, err := ioutil.NonEmptyReader(res.Body)
- if err != nil {
- if err == ioutil.ErrEmptyReader || err == io.ErrUnexpectedEOF {
- return nil, transport.ErrEmptyUploadPackRequest
- }
-
- return nil, err
- }
-
- rc := ioutil.NewReadCloser(r, res.Body)
- return common.DecodeUploadPackResponse(rc, req)
-}
-
-// Close does nothing.
-func (s *upSession) Close() error {
- return nil
-}
-
-func (s *upSession) doRequest(method, url string, content *bytes.Buffer) (*http.Response, error) {
- var body io.Reader
- if content != nil {
- body = content
- }
-
- req, err := http.NewRequest(method, url, body)
- if err != nil {
- return nil, plumbing.NewPermanentError(err)
- }
-
- s.applyHeadersToRequest(req, content)
- s.applyAuthToRequest(req)
-
- res, err := s.client.Do(req)
- if err != nil {
- return nil, plumbing.NewUnexpectedError(err)
- }
-
- if err := NewErr(res); err != nil {
- _ = res.Body.Close()
- return nil, err
- }
-
- return res, nil
-}
-
-// it requires a bytes.Buffer, because we need to know the length
-func (s *upSession) applyHeadersToRequest(req *http.Request, content *bytes.Buffer) {
- req.Header.Add("User-Agent", "git/1.0")
- req.Header.Add("Host", s.endpoint.Host)
-
- if content == nil {
- req.Header.Add("Accept", "*/*")
- return
- }
-
- req.Header.Add("Accept", "application/x-git-upload-pack-result")
- req.Header.Add("Content-Type", "application/x-git-upload-pack-request")
- req.Header.Add("Content-Length", strconv.Itoa(content.Len()))
-}
-
-func uploadPackRequestToReader(req *packp.UploadPackRequest) (*bytes.Buffer, error) {
- buf := bytes.NewBuffer(nil)
- e := pktline.NewEncoder(buf)
-
- if err := req.UploadRequest.Encode(buf); err != nil {
- return nil, fmt.Errorf("sending upload-req message: %s", err)
- }
-
- if err := req.UploadHaves.Encode(buf, false); err != nil {
- return nil, fmt.Errorf("sending haves message: %s", err)
- }
-
- if err := e.EncodeString("done\n"); err != nil {
- return nil, err
- }
-
- return buf, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/common.go
deleted file mode 100644
index f67ae29c5ba96450e931ea0a47c92af4461bc89b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/common.go
+++ /dev/null
@@ -1,414 +0,0 @@
-// Package common implements the git pack protocol with a pluggable transport.
-// This is a low-level package to implement new transports. Use a concrete
-// implementation instead (e.g. http, file, ssh).
-//
-// A simple example of usage can be found in the file package.
-package common
-
-import (
- "bufio"
- "errors"
- "fmt"
- "io"
- "strings"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-const (
- readErrorSecondsTimeout = 10
- errLinesBuffer = 1000
-)
-
-var (
- ErrTimeoutExceeded = errors.New("timeout exceeded")
-)
-
-// Commander creates Command instances. This is the main entry point for
-// transport implementations.
-type Commander interface {
- // Command creates a new Command for the given git command and
- // endpoint. cmd can be git-upload-pack or git-receive-pack. An
- // error should be returned if the endpoint is not supported or the
- // command cannot be created (e.g. binary does not exist, connection
- // cannot be established).
- Command(cmd string, ep transport.Endpoint, auth transport.AuthMethod) (Command, error)
-}
-
-// Command is used for a single command execution.
-// This interface is modeled after exec.Cmd and ssh.Session in the standard
-// library.
-type Command interface {
- // StderrPipe returns a pipe that will be connected to the command's
- // standard error when the command starts. It should not be called after
- // Start.
- StderrPipe() (io.Reader, error)
- // StdinPipe returns a pipe that will be connected to the command's
- // standard input when the command starts. It should not be called after
- // Start. The pipe should be closed when no more input is expected.
- StdinPipe() (io.WriteCloser, error)
- // StdoutPipe returns a pipe that will be connected to the command's
- // standard output when the command starts. It should not be called after
- // Start.
- StdoutPipe() (io.Reader, error)
- // Start starts the specified command. It does not wait for it to
- // complete.
- Start() error
- // Wait waits for the command to exit. It must have been started by
- // Start. The returned error is nil if the command runs, has no
- // problems copying stdin, stdout, and stderr, and exits with a zero
- // exit status.
- Wait() error
- // Close closes the command and releases any resources used by it. It
- // can be called to forcibly finish the command without calling to Wait
- // or to release resources after calling Wait.
- Close() error
-}
-
-type client struct {
- cmdr Commander
-}
-
-// NewClient creates a new client using the given Commander.
-func NewClient(runner Commander) transport.Transport {
- return &client{runner}
-}
-
-// NewUploadPackSession creates a new UploadPackSession.
-func (c *client) NewUploadPackSession(ep transport.Endpoint, auth transport.AuthMethod) (
- transport.UploadPackSession, error) {
-
- return c.newSession(transport.UploadPackServiceName, ep, auth)
-}
-
-// NewReceivePackSession creates a new ReceivePackSession.
-func (c *client) NewReceivePackSession(ep transport.Endpoint, auth transport.AuthMethod) (
- transport.ReceivePackSession, error) {
-
- return c.newSession(transport.ReceivePackServiceName, ep, auth)
-}
-
-type session struct {
- Stdin io.WriteCloser
- Stdout io.Reader
- Command Command
-
- isReceivePack bool
- advRefs *packp.AdvRefs
- packRun bool
- finished bool
- errLines chan string
-}
-
-func (c *client) newSession(s string, ep transport.Endpoint, auth transport.AuthMethod) (*session, error) {
- cmd, err := c.cmdr.Command(s, ep, auth)
- if err != nil {
- return nil, err
- }
-
- stdin, err := cmd.StdinPipe()
- if err != nil {
- return nil, err
- }
-
- stdout, err := cmd.StdoutPipe()
- if err != nil {
- return nil, err
- }
-
- stderr, err := cmd.StderrPipe()
- if err != nil {
- return nil, err
- }
-
- if err := cmd.Start(); err != nil {
- return nil, err
- }
-
- return &session{
- Stdin: stdin,
- Stdout: stdout,
- Command: cmd,
- errLines: c.listenErrors(stderr),
- isReceivePack: s == transport.ReceivePackServiceName,
- }, nil
-}
-
-func (c *client) listenErrors(r io.Reader) chan string {
- if r == nil {
- return nil
- }
-
- errLines := make(chan string, errLinesBuffer)
- go func() {
- s := bufio.NewScanner(r)
- for s.Scan() {
- line := string(s.Bytes())
- errLines <- line
- }
- }()
-
- return errLines
-}
-
-// AdvertisedReferences retrieves the advertised references from the server.
-func (s *session) AdvertisedReferences() (*packp.AdvRefs, error) {
- if s.advRefs != nil {
- return s.advRefs, nil
- }
-
- ar := packp.NewAdvRefs()
- if err := ar.Decode(s.Stdout); err != nil {
- if err := s.handleAdvRefDecodeError(err); err != nil {
- return nil, err
- }
- }
-
- transport.FilterUnsupportedCapabilities(ar.Capabilities)
- s.advRefs = ar
- return ar, nil
-}
-
-func (s *session) handleAdvRefDecodeError(err error) error {
- // If repository is not found, we get empty stdout and server writes an
- // error to stderr.
- if err == packp.ErrEmptyInput {
- if err := s.checkNotFoundError(); err != nil {
- return err
- }
-
- return io.ErrUnexpectedEOF
- }
-
- // For empty (but existing) repositories, we get empty advertised-references
- // message. But valid. That is, it includes at least a flush.
- if err == packp.ErrEmptyAdvRefs {
- // Empty repositories are valid for git-receive-pack.
- if s.isReceivePack {
- return nil
- }
-
- if err := s.finish(); err != nil {
- return err
- }
-
- return transport.ErrEmptyRemoteRepository
- }
-
- // Some server sends the errors as normal content (git protocol), so when
- // we try to decode it fails, we need to check the content of it, to detect
- // not found errors
- if uerr, ok := err.(*packp.ErrUnexpectedData); ok {
- if isRepoNotFoundError(string(uerr.Data)) {
- return transport.ErrRepositoryNotFound
- }
- }
-
- return err
-}
-
-// UploadPack performs a request to the server to fetch a packfile. A reader is
-// returned with the packfile content. The reader must be closed after reading.
-func (s *session) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) {
- if req.IsEmpty() {
- return nil, transport.ErrEmptyUploadPackRequest
- }
-
- if err := req.Validate(); err != nil {
- return nil, err
- }
-
- if _, err := s.AdvertisedReferences(); err != nil {
- return nil, err
- }
-
- s.packRun = true
-
- if err := uploadPack(s.Stdin, s.Stdout, req); err != nil {
- return nil, err
- }
-
- r, err := ioutil.NonEmptyReader(s.Stdout)
- if err == ioutil.ErrEmptyReader {
- if c, ok := s.Stdout.(io.Closer); ok {
- _ = c.Close()
- }
-
- return nil, transport.ErrEmptyUploadPackRequest
- }
-
- if err != nil {
- return nil, err
- }
-
- wc := &waitCloser{s.Command}
- rc := ioutil.NewReadCloser(r, wc)
-
- return DecodeUploadPackResponse(rc, req)
-}
-
-func (s *session) ReceivePack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) {
- if _, err := s.AdvertisedReferences(); err != nil {
- return nil, err
- }
-
- s.packRun = true
-
- if err := req.Encode(s.Stdin); err != nil {
- return nil, err
- }
-
- if !req.Capabilities.Supports(capability.ReportStatus) {
- // If we have neither report-status or sideband, we can only
- // check return value error.
- return nil, s.Command.Wait()
- }
-
- report := packp.NewReportStatus()
- if err := report.Decode(s.Stdout); err != nil {
- return nil, err
- }
-
- if err := report.Error(); err != nil {
- return report, err
- }
-
- return report, s.Command.Wait()
-}
-
-func (s *session) finish() error {
- if s.finished {
- return nil
- }
-
- s.finished = true
-
- // If we did not run a upload/receive-pack, we close the connection
- // gracefully by sending a flush packet to the server. If the server
- // operates correctly, it will exit with status 0.
- if !s.packRun {
- _, err := s.Stdin.Write(pktline.FlushPkt)
- return err
- }
-
- return nil
-}
-
-func (s *session) Close() error {
- if err := s.finish(); err != nil {
- _ = s.Command.Close()
- return nil
- }
-
- return s.Command.Close()
-}
-
-func (s *session) checkNotFoundError() error {
- t := time.NewTicker(time.Second * readErrorSecondsTimeout)
- defer t.Stop()
-
- select {
- case <-t.C:
- return ErrTimeoutExceeded
- case line, ok := <-s.errLines:
- if !ok {
- return nil
- }
-
- if isRepoNotFoundError(line) {
- return transport.ErrRepositoryNotFound
- }
-
- return fmt.Errorf("unknown error: %s", line)
- }
-}
-
-var (
- githubRepoNotFoundErr = "ERROR: Repository not found."
- bitbucketRepoNotFoundErr = "conq: repository does not exist."
- localRepoNotFoundErr = "does not appear to be a git repository"
- gitProtocolNotFoundErr = "ERR \n Repository not found."
-)
-
-func isRepoNotFoundError(s string) bool {
- if strings.HasPrefix(s, githubRepoNotFoundErr) {
- return true
- }
-
- if strings.HasPrefix(s, bitbucketRepoNotFoundErr) {
- return true
- }
-
- if strings.HasSuffix(s, localRepoNotFoundErr) {
- return true
- }
-
- if strings.HasPrefix(s, gitProtocolNotFoundErr) {
- return true
- }
-
- return false
-}
-
-var (
- nak = []byte("NAK")
- eol = []byte("\n")
-)
-
-// uploadPack implements the git-upload-pack protocol.
-func uploadPack(w io.WriteCloser, r io.Reader, req *packp.UploadPackRequest) error {
- // TODO support multi_ack mode
- // TODO support multi_ack_detailed mode
- // TODO support acks for common objects
- // TODO build a proper state machine for all these processing options
-
- if err := req.UploadRequest.Encode(w); err != nil {
- return fmt.Errorf("sending upload-req message: %s", err)
- }
-
- if err := req.UploadHaves.Encode(w, true); err != nil {
- return fmt.Errorf("sending haves message: %s", err)
- }
-
- if err := sendDone(w); err != nil {
- return fmt.Errorf("sending done message: %s", err)
- }
-
- if err := w.Close(); err != nil {
- return fmt.Errorf("closing input: %s", err)
- }
-
- return nil
-}
-
-func sendDone(w io.Writer) error {
- e := pktline.NewEncoder(w)
-
- return e.Encodef("done\n")
-}
-
-// DecodeUploadPackResponse decodes r into a new packp.UploadPackResponse
-func DecodeUploadPackResponse(r io.ReadCloser, req *packp.UploadPackRequest) (
- *packp.UploadPackResponse, error,
-) {
- res := packp.NewUploadPackResponse(req)
- if err := res.Decode(r); err != nil {
- return nil, fmt.Errorf("error decoding upload-pack response: %s", err)
- }
-
- return res, nil
-}
-
-type waitCloser struct {
- Command Command
-}
-
-// Close waits until the command exits and returns error, if any.
-func (c *waitCloser) Close() error {
- return c.Command.Wait()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/server.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/server.go
deleted file mode 100644
index dd6cfbea308a35b2a0df2aa07c699d63d2e30129..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common/server.go
+++ /dev/null
@@ -1,72 +0,0 @@
-package common
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-// ServerCommand is used for a single server command execution.
-type ServerCommand struct {
- Stderr io.Writer
- Stdout io.WriteCloser
- Stdin io.Reader
-}
-
-func ServeUploadPack(cmd ServerCommand, s transport.UploadPackSession) (err error) {
- ioutil.CheckClose(cmd.Stdout, &err)
-
- ar, err := s.AdvertisedReferences()
- if err != nil {
- return err
- }
-
- if err := ar.Encode(cmd.Stdout); err != nil {
- return err
- }
-
- req := packp.NewUploadPackRequest()
- if err := req.Decode(cmd.Stdin); err != nil {
- return err
- }
-
- var resp *packp.UploadPackResponse
- resp, err = s.UploadPack(req)
- if err != nil {
- return err
- }
-
- return resp.Encode(cmd.Stdout)
-}
-
-func ServeReceivePack(cmd ServerCommand, s transport.ReceivePackSession) error {
- ar, err := s.AdvertisedReferences()
- if err != nil {
- return fmt.Errorf("internal error in advertised references: %s", err)
- }
-
- if err := ar.Encode(cmd.Stdout); err != nil {
- return fmt.Errorf("error in advertised references encoding: %s", err)
- }
-
- req := packp.NewReferenceUpdateRequest()
- if err := req.Decode(cmd.Stdin); err != nil {
- return fmt.Errorf("error decoding: %s", err)
- }
-
- rs, err := s.ReceivePack(req)
- if rs != nil {
- if err := rs.Encode(cmd.Stdout); err != nil {
- return fmt.Errorf("error in encoding report status %s", err)
- }
- }
-
- if err != nil {
- return fmt.Errorf("error in receive pack: %s", err)
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/loader.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/loader.go
deleted file mode 100644
index cfe9f041b13d7bffa07e9b9c684981e1e22482ce..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/loader.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package server
-
-import (
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/storage/filesystem"
-
- "gopkg.in/src-d/go-billy.v2"
- "gopkg.in/src-d/go-billy.v2/osfs"
-)
-
-// DefaultLoader is a filesystem loader ignoring host and resolving paths to /.
-var DefaultLoader = NewFilesystemLoader(osfs.New("/"))
-
-// Loader loads repository's storer.Storer based on an optional host and a path.
-type Loader interface {
- // Load loads a storer.Storer given a transport.Endpoint.
- // Returns transport.ErrRepositoryNotFound if the repository does not
- // exist.
- Load(ep transport.Endpoint) (storer.Storer, error)
-}
-
-type fsLoader struct {
- base billy.Filesystem
-}
-
-// NewFilesystemLoader creates a Loader that ignores host and resolves paths
-// with a given base filesystem.
-func NewFilesystemLoader(base billy.Filesystem) Loader {
- return &fsLoader{base}
-}
-
-// Load looks up the endpoint's path in the base file system and returns a
-// storer for it. Returns transport.ErrRepositoryNotFound if a repository does
-// not exist in the given path.
-func (l *fsLoader) Load(ep transport.Endpoint) (storer.Storer, error) {
- fs := l.base.Dir(ep.Path)
- if _, err := fs.Stat("config"); err != nil {
- return nil, transport.ErrRepositoryNotFound
- }
-
- return filesystem.NewStorage(fs)
-}
-
-// MapLoader is a Loader that uses a lookup map of storer.Storer by
-// transport.Endpoint.
-type MapLoader map[transport.Endpoint]storer.Storer
-
-// Load returns a storer.Storer for given a transport.Endpoint by looking it up
-// in the map. Returns transport.ErrRepositoryNotFound if the endpoint does not
-// exist.
-func (l MapLoader) Load(ep transport.Endpoint) (storer.Storer, error) {
- s, ok := l[ep]
- if !ok {
- return nil, transport.ErrRepositoryNotFound
- }
-
- return s, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/server.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/server.go
deleted file mode 100644
index 89fce5f6584de5237764a7735a4fe40683c609ae..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/server/server.go
+++ /dev/null
@@ -1,433 +0,0 @@
-// Package server implements the git server protocol. For most use cases, the
-// transport-specific implementations should be used.
-package server
-
-import (
- "errors"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
- "gopkg.in/src-d/go-git.v4/plumbing/revlist"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
-)
-
-var DefaultServer = NewServer(DefaultLoader)
-
-type server struct {
- loader Loader
- handler *handler
-}
-
-// NewServer returns a transport.Transport implementing a git server,
-// independent of transport. Each transport must wrap this.
-func NewServer(loader Loader) transport.Transport {
- return &server{loader, &handler{}}
-}
-
-func (s *server) NewUploadPackSession(ep transport.Endpoint, auth transport.AuthMethod) (transport.UploadPackSession, error) {
- sto, err := s.loader.Load(ep)
- if err != nil {
- return nil, err
- }
-
- return s.handler.NewUploadPackSession(sto)
-}
-
-func (s *server) NewReceivePackSession(ep transport.Endpoint, auth transport.AuthMethod) (transport.ReceivePackSession, error) {
- sto, err := s.loader.Load(ep)
- if err != nil {
- return nil, err
- }
-
- return s.handler.NewReceivePackSession(sto)
-}
-
-type handler struct{}
-
-func (h *handler) NewUploadPackSession(s storer.Storer) (transport.UploadPackSession, error) {
- return &upSession{
- session: session{storer: s},
- }, nil
-}
-
-func (h *handler) NewReceivePackSession(s storer.Storer) (transport.ReceivePackSession, error) {
- return &rpSession{
- session: session{storer: s},
- cmdStatus: map[plumbing.ReferenceName]error{},
- }, nil
-}
-
-type session struct {
- storer storer.Storer
- caps *capability.List
-}
-
-func (s *session) Close() error {
- return nil
-}
-
-func (s *session) SetAuth(transport.AuthMethod) error {
- //TODO: deprecate
- return nil
-}
-
-func (s *session) checkSupportedCapabilities(cl *capability.List) error {
- for _, c := range cl.All() {
- if !s.caps.Supports(c) {
- return fmt.Errorf("unsupported capability: %s", c)
- }
- }
-
- return nil
-}
-
-type upSession struct {
- session
-}
-
-func (s *upSession) AdvertisedReferences() (*packp.AdvRefs, error) {
- ar := packp.NewAdvRefs()
-
- if err := s.setSupportedCapabilities(ar.Capabilities); err != nil {
- return nil, err
- }
-
- s.caps = ar.Capabilities
-
- if err := setReferences(s.storer, ar); err != nil {
- return nil, err
- }
-
- if err := setHEAD(s.storer, ar); err != nil {
- return nil, err
- }
-
- return ar, nil
-}
-
-func (s *upSession) UploadPack(req *packp.UploadPackRequest) (*packp.UploadPackResponse, error) {
- if req.IsEmpty() {
- return nil, transport.ErrEmptyUploadPackRequest
- }
-
- if err := req.Validate(); err != nil {
- return nil, err
- }
-
- if s.caps == nil {
- s.caps = capability.NewList()
- if err := s.setSupportedCapabilities(s.caps); err != nil {
- return nil, err
- }
- }
-
- if err := s.checkSupportedCapabilities(req.Capabilities); err != nil {
- return nil, err
- }
-
- s.caps = req.Capabilities
-
- if len(req.Shallows) > 0 {
- return nil, fmt.Errorf("shallow not supported")
- }
-
- objs, err := s.objectsToUpload(req)
- if err != nil {
- return nil, err
- }
-
- pr, pw := io.Pipe()
- e := packfile.NewEncoder(pw, s.storer, false)
- go func() {
- _, err := e.Encode(objs)
- pw.CloseWithError(err)
- }()
-
- return packp.NewUploadPackResponseWithPackfile(req, pr), nil
-}
-
-func (s *upSession) objectsToUpload(req *packp.UploadPackRequest) ([]plumbing.Hash, error) {
- haves, err := revlist.Objects(s.storer, req.Haves, nil)
- if err != nil {
- return nil, err
- }
-
- return revlist.Objects(s.storer, req.Wants, haves)
-}
-
-func (*upSession) setSupportedCapabilities(c *capability.List) error {
- if err := c.Set(capability.Agent, capability.DefaultAgent); err != nil {
- return err
- }
-
- if err := c.Set(capability.OFSDelta); err != nil {
- return err
- }
-
- return nil
-}
-
-type rpSession struct {
- session
- cmdStatus map[plumbing.ReferenceName]error
- firstErr error
- unpackErr error
-}
-
-func (s *rpSession) AdvertisedReferences() (*packp.AdvRefs, error) {
- ar := packp.NewAdvRefs()
-
- if err := s.setSupportedCapabilities(ar.Capabilities); err != nil {
- return nil, err
- }
-
- s.caps = ar.Capabilities
-
- if err := setReferences(s.storer, ar); err != nil {
- return nil, err
- }
-
- if err := setHEAD(s.storer, ar); err != nil {
- return nil, err
- }
-
- return ar, nil
-}
-
-var (
- ErrUpdateReference = errors.New("failed to update ref")
-)
-
-func (s *rpSession) ReceivePack(req *packp.ReferenceUpdateRequest) (*packp.ReportStatus, error) {
- if s.caps == nil {
- s.caps = capability.NewList()
- if err := s.setSupportedCapabilities(s.caps); err != nil {
- return nil, err
- }
- }
-
- if err := s.checkSupportedCapabilities(req.Capabilities); err != nil {
- return nil, err
- }
-
- s.caps = req.Capabilities
-
- //TODO: Implement 'atomic' update of references.
-
- if err := s.writePackfile(req.Packfile); err != nil {
- s.unpackErr = err
- s.firstErr = err
- return s.reportStatus(), err
- }
-
- updatedRefs := s.updatedReferences(req)
-
- if s.caps.Supports(capability.Atomic) && s.firstErr != nil {
- //TODO: add support for 'atomic' once we have reference
- // transactions, currently we do not announce it.
- rs := s.reportStatus()
- for _, cs := range rs.CommandStatuses {
- if cs.Error() == nil {
- cs.Status = ""
- }
- }
- }
-
- for name, ref := range updatedRefs {
- //TODO: add support for 'delete-refs' once we can delete
- // references, currently we do not announce it.
- err := s.storer.SetReference(ref)
- s.setStatus(name, err)
- }
-
- return s.reportStatus(), s.firstErr
-}
-
-func (s *rpSession) updatedReferences(req *packp.ReferenceUpdateRequest) map[plumbing.ReferenceName]*plumbing.Reference {
- refs := map[plumbing.ReferenceName]*plumbing.Reference{}
- for _, cmd := range req.Commands {
- exists, err := referenceExists(s.storer, cmd.Name)
- if err != nil {
- s.setStatus(cmd.Name, err)
- continue
- }
-
- switch cmd.Action() {
- case packp.Create:
- if exists {
- s.setStatus(cmd.Name, ErrUpdateReference)
- continue
- }
-
- ref := plumbing.NewHashReference(cmd.Name, cmd.New)
- refs[ref.Name()] = ref
- case packp.Delete:
- if !exists {
- s.setStatus(cmd.Name, ErrUpdateReference)
- continue
- }
-
- if !s.caps.Supports(capability.DeleteRefs) {
- s.setStatus(cmd.Name, fmt.Errorf("delete not supported"))
- continue
- }
-
- refs[cmd.Name] = nil
- case packp.Update:
- if !exists {
- s.setStatus(cmd.Name, ErrUpdateReference)
- continue
- }
-
- if err != nil {
- s.setStatus(cmd.Name, err)
- continue
- }
-
- ref := plumbing.NewHashReference(cmd.Name, cmd.New)
- refs[ref.Name()] = ref
- }
- }
-
- return refs
-}
-
-func (s *rpSession) failAtomicUpdate() (*packp.ReportStatus, error) {
- rs := s.reportStatus()
- for _, cs := range rs.CommandStatuses {
- if cs.Error() == nil {
- cs.Status = "atomic updated"
- }
- }
-
- return rs, s.firstErr
-}
-
-func (s *rpSession) writePackfile(r io.ReadCloser) error {
- if r == nil {
- return nil
- }
-
- if err := packfile.UpdateObjectStorage(s.storer, r); err != nil {
- _ = r.Close()
- return err
- }
-
- return r.Close()
-}
-
-func (s *rpSession) setStatus(ref plumbing.ReferenceName, err error) {
- s.cmdStatus[ref] = err
- if s.firstErr == nil && err != nil {
- s.firstErr = err
- }
-}
-
-func (s *rpSession) reportStatus() *packp.ReportStatus {
- if !s.caps.Supports(capability.ReportStatus) {
- return nil
- }
-
- rs := packp.NewReportStatus()
- rs.UnpackStatus = "ok"
-
- if s.unpackErr != nil {
- rs.UnpackStatus = s.unpackErr.Error()
- }
-
- if s.cmdStatus == nil {
- return rs
- }
-
- for ref, err := range s.cmdStatus {
- msg := "ok"
- if err != nil {
- msg = err.Error()
- }
- status := &packp.CommandStatus{
- ReferenceName: ref,
- Status: msg,
- }
- rs.CommandStatuses = append(rs.CommandStatuses, status)
- }
-
- return rs
-}
-
-func (*rpSession) setSupportedCapabilities(c *capability.List) error {
- if err := c.Set(capability.Agent, capability.DefaultAgent); err != nil {
- return err
- }
-
- if err := c.Set(capability.OFSDelta); err != nil {
- return err
- }
-
- return c.Set(capability.ReportStatus)
-}
-
-func setHEAD(s storer.Storer, ar *packp.AdvRefs) error {
- ref, err := s.Reference(plumbing.HEAD)
- if err == plumbing.ErrReferenceNotFound {
- return nil
- }
-
- if err != nil {
- return err
- }
-
- if ref.Type() == plumbing.SymbolicReference {
- if err := ar.AddReference(ref); err != nil {
- return nil
- }
-
- ref, err = storer.ResolveReference(s, ref.Target())
- if err == plumbing.ErrReferenceNotFound {
- return nil
- }
-
- if err != nil {
- return err
- }
- }
-
- if ref.Type() != plumbing.HashReference {
- return plumbing.ErrInvalidType
- }
-
- h := ref.Hash()
- ar.Head = &h
-
- return nil
-}
-
-func setReferences(s storer.Storer, ar *packp.AdvRefs) error {
- //TODO: add peeled references.
- iter, err := s.IterReferences()
- if err != nil {
- return err
- }
-
- return iter.ForEach(func(ref *plumbing.Reference) error {
- if ref.Type() != plumbing.HashReference {
- return nil
- }
-
- ar.References[ref.Name().String()] = ref.Hash()
- return nil
- })
-}
-
-func referenceExists(s storer.ReferenceStorer, n plumbing.ReferenceName) (bool, error) {
- _, err := s.Reference(n)
- if err == plumbing.ErrReferenceNotFound {
- return false, nil
- }
-
- return err == nil, err
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/auth_method.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/auth_method.go
deleted file mode 100644
index f53e510e5b41a3a466fb6886512b73bf106f90ba..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/auth_method.go
+++ /dev/null
@@ -1,165 +0,0 @@
-package ssh
-
-import (
- "errors"
- "fmt"
- "net"
- "os"
-
- "golang.org/x/crypto/ssh"
- "golang.org/x/crypto/ssh/agent"
-)
-
-var ErrEmptySSHAgentAddr = errors.New("SSH_AUTH_SOCK env variable is required")
-
-// AuthMethod is the interface all auth methods for the ssh client
-// must implement. The clientConfig method returns the ssh client
-// configuration needed to establish an ssh connection.
-type AuthMethod interface {
- clientConfig() *ssh.ClientConfig
-}
-
-// The names of the AuthMethod implementations. To be returned by the
-// Name() method. Most git servers only allow PublicKeysName and
-// PublicKeysCallbackName.
-const (
- KeyboardInteractiveName = "ssh-keyboard-interactive"
- PasswordName = "ssh-password"
- PasswordCallbackName = "ssh-password-callback"
- PublicKeysName = "ssh-public-keys"
- PublicKeysCallbackName = "ssh-public-key-callback"
-)
-
-// KeyboardInteractive implements AuthMethod by using a
-// prompt/response sequence controlled by the server.
-type KeyboardInteractive struct {
- User string
- Challenge ssh.KeyboardInteractiveChallenge
-}
-
-func (a *KeyboardInteractive) Name() string {
- return KeyboardInteractiveName
-}
-
-func (a *KeyboardInteractive) String() string {
- return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
-}
-
-func (a *KeyboardInteractive) clientConfig() *ssh.ClientConfig {
- return &ssh.ClientConfig{
- User: a.User,
- Auth: []ssh.AuthMethod{ssh.KeyboardInteractiveChallenge(a.Challenge)},
- }
-}
-
-// Password implements AuthMethod by using the given password.
-type Password struct {
- User string
- Pass string
-}
-
-func (a *Password) Name() string {
- return PasswordName
-}
-
-func (a *Password) String() string {
- return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
-}
-
-func (a *Password) clientConfig() *ssh.ClientConfig {
- return &ssh.ClientConfig{
- User: a.User,
- Auth: []ssh.AuthMethod{ssh.Password(a.Pass)},
- }
-}
-
-// PasswordCallback implements AuthMethod by using a callback
-// to fetch the password.
-type PasswordCallback struct {
- User string
- Callback func() (pass string, err error)
-}
-
-func (a *PasswordCallback) Name() string {
- return PasswordCallbackName
-}
-
-func (a *PasswordCallback) String() string {
- return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
-}
-
-func (a *PasswordCallback) clientConfig() *ssh.ClientConfig {
- return &ssh.ClientConfig{
- User: a.User,
- Auth: []ssh.AuthMethod{ssh.PasswordCallback(a.Callback)},
- }
-}
-
-// PublicKeys implements AuthMethod by using the given
-// key pairs.
-type PublicKeys struct {
- User string
- Signer ssh.Signer
-}
-
-func (a *PublicKeys) Name() string {
- return PublicKeysName
-}
-
-func (a *PublicKeys) String() string {
- return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
-}
-
-func (a *PublicKeys) clientConfig() *ssh.ClientConfig {
- return &ssh.ClientConfig{
- User: a.User,
- Auth: []ssh.AuthMethod{ssh.PublicKeys(a.Signer)},
- }
-}
-
-// PublicKeysCallback implements AuthMethod by asking a
-// ssh.agent.Agent to act as a signer.
-type PublicKeysCallback struct {
- User string
- Callback func() (signers []ssh.Signer, err error)
-}
-
-func (a *PublicKeysCallback) Name() string {
- return PublicKeysCallbackName
-}
-
-func (a *PublicKeysCallback) String() string {
- return fmt.Sprintf("user: %s, name: %s", a.User, a.Name())
-}
-
-func (a *PublicKeysCallback) clientConfig() *ssh.ClientConfig {
- return &ssh.ClientConfig{
- User: a.User,
- Auth: []ssh.AuthMethod{ssh.PublicKeysCallback(a.Callback)},
- }
-}
-
-const DefaultSSHUsername = "git"
-
-// NewSSHAgentAuth opens a pipe with the SSH agent and uses the pipe
-// as the implementer of the public key callback function.
-func NewSSHAgentAuth(user string) (*PublicKeysCallback, error) {
- if user == "" {
- user = DefaultSSHUsername
- }
-
- sshAgentAddr := os.Getenv("SSH_AUTH_SOCK")
- if sshAgentAddr == "" {
- return nil, ErrEmptySSHAgentAddr
- }
-
- pipe, err := net.Dial("unix", sshAgentAddr)
- if err != nil {
- return nil, fmt.Errorf("error connecting to SSH agent: %q", err)
- }
-
- return &PublicKeysCallback{
- User: user,
- Callback: agent.NewClient(pipe).Signers,
- }, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/common.go b/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/common.go
deleted file mode 100644
index 5ed64d464fbfc5e4d7417cd4ec25e5cae67b20ea..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/plumbing/transport/ssh/common.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Package ssh implements the SSH transport protocol.
-package ssh
-
-import (
- "fmt"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common"
-
- "golang.org/x/crypto/ssh"
-)
-
-// DefaultClient is the default SSH client.
-var DefaultClient = common.NewClient(&runner{})
-
-type runner struct{}
-
-func (r *runner) Command(cmd string, ep transport.Endpoint, auth transport.AuthMethod) (common.Command, error) {
- c := &command{command: cmd, endpoint: ep}
- if auth != nil {
- c.setAuth(auth)
- }
-
- if err := c.connect(); err != nil {
- return nil, err
- }
- return c, nil
-}
-
-type command struct {
- *ssh.Session
- connected bool
- command string
- endpoint transport.Endpoint
- client *ssh.Client
- auth AuthMethod
-}
-
-func (c *command) setAuth(auth transport.AuthMethod) error {
- a, ok := auth.(AuthMethod)
- if !ok {
- return transport.ErrInvalidAuthMethod
- }
-
- c.auth = a
- return nil
-}
-
-func (c *command) Start() error {
- return c.Session.Start(endpointToCommand(c.command, c.endpoint))
-}
-
-// Close closes the SSH session and connection.
-func (c *command) Close() error {
- if !c.connected {
- return nil
- }
-
- c.connected = false
-
- //XXX: If did read the full packfile, then the session might be already
- // closed.
- _ = c.Session.Close()
-
- return c.client.Close()
-}
-
-// connect connects to the SSH server, unless a AuthMethod was set with
-// SetAuth method, by default uses an auth method based on PublicKeysCallback,
-// it connects to a SSH agent, using the address stored in the SSH_AUTH_SOCK
-// environment var.
-func (c *command) connect() error {
- if c.connected {
- return transport.ErrAlreadyConnected
- }
-
- if c.auth == nil {
- if err := c.setAuthFromEndpoint(); err != nil {
- return err
- }
- }
-
- var err error
- c.client, err = ssh.Dial("tcp", c.getHostWithPort(), c.auth.clientConfig())
- if err != nil {
- return err
- }
-
- c.Session, err = c.client.NewSession()
- if err != nil {
- _ = c.client.Close()
- return err
- }
-
- c.connected = true
- return nil
-}
-
-func (c *command) getHostWithPort() string {
- host := c.endpoint.Host
- if strings.Index(c.endpoint.Host, ":") == -1 {
- host += ":22"
- }
-
- return host
-}
-
-func (c *command) setAuthFromEndpoint() error {
- var u string
- if info := c.endpoint.User; info != nil {
- u = info.Username()
- }
-
- var err error
- c.auth, err = NewSSHAgentAuth(u)
- return err
-}
-
-func endpointToCommand(cmd string, ep transport.Endpoint) string {
- return fmt.Sprintf("%s '%s'", cmd, ep.Path)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/references.go b/vendor/gopkg.in/src-d/go-git.v4/references.go
deleted file mode 100644
index 957d7410d4c87f8631ec339d3819282a586500ee..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/references.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package git
-
-import (
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
- "gopkg.in/src-d/go-git.v4/utils/diff"
-
- "github.com/sergi/go-diff/diffmatchpatch"
-)
-
-// References returns a slice of Commits for the file at "path", starting from
-// the commit provided that contains the file from the provided path. The last
-// commit into the returned slice is the commit where the file was created.
-// If the provided commit does not contains the specified path, a nil slice is
-// returned. The commits are sorted in commit order, newer to older.
-//
-// Caveats:
-//
-// - Moves and copies are not currently supported.
-//
-// - Cherry-picks are not detected unless there are no commits between them and
-// therefore can appear repeated in the list. (see git path-id for hints on how
-// to fix this).
-func References(c *object.Commit, path string) ([]*object.Commit, error) {
- var result []*object.Commit
- seen := make(map[plumbing.Hash]struct{}, 0)
- if err := walkGraph(&result, &seen, c, path); err != nil {
- return nil, err
- }
-
- object.SortCommits(result)
-
- // for merges of identical cherry-picks
- return removeComp(path, result, equivalent)
-}
-
-// Recursive traversal of the commit graph, generating a linear history of the
-// path.
-func walkGraph(result *[]*object.Commit, seen *map[plumbing.Hash]struct{}, current *object.Commit, path string) error {
- // check and update seen
- if _, ok := (*seen)[current.Hash]; ok {
- return nil
- }
- (*seen)[current.Hash] = struct{}{}
-
- // if the path is not in the current commit, stop searching.
- if _, err := current.File(path); err != nil {
- return nil
- }
-
- // optimization: don't traverse branches that does not
- // contain the path.
- parents := parentsContainingPath(path, current)
-
- switch len(parents) {
- // if the path is not found in any of its parents, the path was
- // created by this commit; we must add it to the revisions list and
- // stop searching. This includes the case when current is the
- // initial commit.
- case 0:
- *result = append(*result, current)
- return nil
- case 1: // only one parent contains the path
- // if the file contents has change, add the current commit
- different, err := differentContents(path, current, parents)
- if err != nil {
- return err
- }
- if len(different) == 1 {
- *result = append(*result, current)
- }
- // in any case, walk the parent
- return walkGraph(result, seen, parents[0], path)
- default: // more than one parent contains the path
- // TODO: detect merges that had a conflict, because they must be
- // included in the result here.
- for _, p := range parents {
- err := walkGraph(result, seen, p, path)
- if err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-func parentsContainingPath(path string, c *object.Commit) []*object.Commit {
- // TODO: benchmark this method making git.object.Commit.parent public instead of using
- // an iterator
- var result []*object.Commit
- iter := c.Parents()
- for {
- parent, err := iter.Next()
- if err != nil {
- if err == io.EOF {
- return result
- }
- panic("unreachable")
- }
- if _, err := parent.File(path); err == nil {
- result = append(result, parent)
- }
- }
-}
-
-// Returns an slice of the commits in "cs" that has the file "path", but with different
-// contents than what can be found in "c".
-func differentContents(path string, c *object.Commit, cs []*object.Commit) ([]*object.Commit, error) {
- result := make([]*object.Commit, 0, len(cs))
- h, found := blobHash(path, c)
- if !found {
- return nil, object.ErrFileNotFound
- }
- for _, cx := range cs {
- if hx, found := blobHash(path, cx); found && h != hx {
- result = append(result, cx)
- }
- }
- return result, nil
-}
-
-// blobHash returns the hash of a path in a commit
-func blobHash(path string, commit *object.Commit) (hash plumbing.Hash, found bool) {
- file, err := commit.File(path)
- if err != nil {
- var empty plumbing.Hash
- return empty, found
- }
- return file.Hash, true
-}
-
-type contentsComparatorFn func(path string, a, b *object.Commit) (bool, error)
-
-// Returns a new slice of commits, with duplicates removed. Expects a
-// sorted commit list. Duplication is defined according to "comp". It
-// will always keep the first commit of a series of duplicated commits.
-func removeComp(path string, cs []*object.Commit, comp contentsComparatorFn) ([]*object.Commit, error) {
- result := make([]*object.Commit, 0, len(cs))
- if len(cs) == 0 {
- return result, nil
- }
- result = append(result, cs[0])
- for i := 1; i < len(cs); i++ {
- equals, err := comp(path, cs[i], cs[i-1])
- if err != nil {
- return nil, err
- }
- if !equals {
- result = append(result, cs[i])
- }
- }
- return result, nil
-}
-
-// Equivalent commits are commits whose patch is the same.
-func equivalent(path string, a, b *object.Commit) (bool, error) {
- numParentsA := a.NumParents()
- numParentsB := b.NumParents()
-
- // the first commit is not equivalent to anyone
- // and "I think" merges can not be equivalent to anything
- if numParentsA != 1 || numParentsB != 1 {
- return false, nil
- }
-
- diffsA, err := patch(a, path)
- if err != nil {
- return false, err
- }
- diffsB, err := patch(b, path)
- if err != nil {
- return false, err
- }
-
- return sameDiffs(diffsA, diffsB), nil
-}
-
-func patch(c *object.Commit, path string) ([]diffmatchpatch.Diff, error) {
- // get contents of the file in the commit
- file, err := c.File(path)
- if err != nil {
- return nil, err
- }
- content, err := file.Contents()
- if err != nil {
- return nil, err
- }
-
- // get contents of the file in the first parent of the commit
- var contentParent string
- iter := c.Parents()
- parent, err := iter.Next()
- if err != nil {
- return nil, err
- }
- file, err = parent.File(path)
- if err != nil {
- contentParent = ""
- } else {
- contentParent, err = file.Contents()
- if err != nil {
- return nil, err
- }
- }
-
- // compare the contents of parent and child
- return diff.Do(content, contentParent), nil
-}
-
-func sameDiffs(a, b []diffmatchpatch.Diff) bool {
- if len(a) != len(b) {
- return false
- }
- for i := range a {
- if !sameDiff(a[i], b[i]) {
- return false
- }
- }
- return true
-}
-
-func sameDiff(a, b diffmatchpatch.Diff) bool {
- if a.Type != b.Type {
- return false
- }
- switch a.Type {
- case 0:
- return countLines(a.Text) == countLines(b.Text)
- case 1, -1:
- return a.Text == b.Text
- default:
- panic("unreachable")
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/remote.go b/vendor/gopkg.in/src-d/go-git.v4/remote.go
deleted file mode 100644
index ca6b33eeabf7bb2e9ca718a2d7e3da98f3b95867..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/remote.go
+++ /dev/null
@@ -1,547 +0,0 @@
-package git
-
-import (
- "errors"
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability"
- "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband"
- "gopkg.in/src-d/go-git.v4/plumbing/revlist"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/plumbing/transport"
- "gopkg.in/src-d/go-git.v4/plumbing/transport/client"
- "gopkg.in/src-d/go-git.v4/storage"
- "gopkg.in/src-d/go-git.v4/storage/memory"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-)
-
-var NoErrAlreadyUpToDate = errors.New("already up-to-date")
-
-// Remote represents a connection to a remote repository.
-type Remote struct {
- c *config.RemoteConfig
- s storage.Storer
-}
-
-func newRemote(s storage.Storer, c *config.RemoteConfig) *Remote {
- return &Remote{s: s, c: c}
-}
-
-// Config returns the RemoteConfig object used to instantiate this Remote.
-func (r *Remote) Config() *config.RemoteConfig {
- return r.c
-}
-
-func (r *Remote) String() string {
- fetch := r.c.URL
- push := r.c.URL
-
- return fmt.Sprintf("%s\t%s (fetch)\n%[1]s\t%s (push)", r.c.Name, fetch, push)
-}
-
-// Fetch fetches references from the remote to the local repository.
-// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
-// no changes to be fetched, or an error.
-func (r *Remote) Fetch(o *FetchOptions) error {
- _, err := r.fetch(o)
- return err
-}
-
-// Push performs a push to the remote. Returns NoErrAlreadyUpToDate if the
-// remote was already up-to-date.
-func (r *Remote) Push(o *PushOptions) (err error) {
- // TODO: Support deletes.
- // TODO: Support pushing tags.
- // TODO: Check if force update is given, otherwise reject non-fast forward.
- // TODO: Sideband suppor
-
- if o.RemoteName == "" {
- o.RemoteName = r.c.Name
- }
-
- if err := o.Validate(); err != nil {
- return err
- }
-
- if o.RemoteName != r.c.Name {
- return fmt.Errorf("remote names don't match: %s != %s", o.RemoteName, r.c.Name)
- }
-
- s, err := newSendPackSession(r.c.URL, o.Auth)
- if err != nil {
- return err
- }
-
- ar, err := s.AdvertisedReferences()
- if err != nil {
- return err
- }
-
- remoteRefs, err := ar.AllReferences()
- if err != nil {
- return err
- }
-
- req := packp.NewReferenceUpdateRequestFromCapabilities(ar.Capabilities)
- if err := r.addReferencesToUpdate(o.RefSpecs, remoteRefs, req); err != nil {
- return err
- }
-
- if len(req.Commands) == 0 {
- return NoErrAlreadyUpToDate
- }
-
- objects, err := objectsToPush(req.Commands)
- if err != nil {
- return err
- }
-
- haves, err := referencesToHashes(remoteRefs)
- if err != nil {
- return err
- }
-
- hashesToPush, err := revlist.Objects(r.s, objects, haves)
- if err != nil {
- return err
- }
-
- rs, err := pushHashes(s, r.s, req, hashesToPush)
- if err != nil {
- return err
- }
-
- return rs.Error()
-}
-
-func (r *Remote) fetch(o *FetchOptions) (refs storer.ReferenceStorer, err error) {
- if o.RemoteName == "" {
- o.RemoteName = r.c.Name
- }
-
- if err := o.Validate(); err != nil {
- return nil, err
- }
-
- if len(o.RefSpecs) == 0 {
- o.RefSpecs = r.c.Fetch
- }
-
- s, err := newUploadPackSession(r.c.URL, o.Auth)
- if err != nil {
- return nil, err
- }
-
- defer ioutil.CheckClose(s, &err)
-
- ar, err := s.AdvertisedReferences()
- if err != nil {
- return nil, err
- }
-
- req, err := r.newUploadPackRequest(o, ar)
- if err != nil {
- return nil, err
- }
-
- remoteRefs, err := ar.AllReferences()
- if err != nil {
- return nil, err
- }
-
- req.Wants, err = getWants(o.RefSpecs, r.s, remoteRefs)
- if len(req.Wants) == 0 {
- return remoteRefs, NoErrAlreadyUpToDate
- }
-
- req.Haves, err = getHaves(r.s)
- if err != nil {
- return nil, err
- }
-
- if err := r.fetchPack(o, s, req); err != nil {
- return nil, err
- }
-
- if err := r.updateLocalReferenceStorage(o.RefSpecs, remoteRefs); err != nil {
- return nil, err
- }
-
- return remoteRefs, err
-}
-
-func newUploadPackSession(url string, auth transport.AuthMethod) (transport.UploadPackSession, error) {
- c, ep, err := newClient(url)
- if err != nil {
- return nil, err
- }
-
- return c.NewUploadPackSession(ep, auth)
-}
-
-func newSendPackSession(url string, auth transport.AuthMethod) (transport.ReceivePackSession, error) {
- c, ep, err := newClient(url)
- if err != nil {
- return nil, err
- }
-
- return c.NewReceivePackSession(ep, auth)
-}
-
-func newClient(url string) (transport.Transport, transport.Endpoint, error) {
- ep, err := transport.NewEndpoint(url)
- if err != nil {
- return nil, transport.Endpoint{}, err
- }
-
- c, err := client.NewClient(ep)
- if err != nil {
- return nil, transport.Endpoint{}, err
- }
-
- return c, ep, err
-}
-
-func (r *Remote) fetchPack(o *FetchOptions, s transport.UploadPackSession,
- req *packp.UploadPackRequest) (err error) {
-
- reader, err := s.UploadPack(req)
- if err != nil {
- return err
- }
-
- defer ioutil.CheckClose(reader, &err)
-
- if err := r.updateShallow(o, reader); err != nil {
- return err
- }
-
- if err = packfile.UpdateObjectStorage(r.s,
- buildSidebandIfSupported(req.Capabilities, reader, o.Progress),
- ); err != nil {
- return err
- }
-
- return err
-}
-
-func (r *Remote) addReferencesToUpdate(refspecs []config.RefSpec,
- remoteRefs storer.ReferenceStorer,
- req *packp.ReferenceUpdateRequest) error {
-
- for _, rs := range refspecs {
- iter, err := r.s.IterReferences()
- if err != nil {
- return err
- }
-
- err = iter.ForEach(func(ref *plumbing.Reference) error {
- return r.addReferenceIfRefSpecMatches(
- rs, remoteRefs, ref, req,
- )
- })
- if err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (r *Remote) addReferenceIfRefSpecMatches(rs config.RefSpec,
- remoteRefs storer.ReferenceStorer, localRef *plumbing.Reference,
- req *packp.ReferenceUpdateRequest) error {
-
- if localRef.Type() != plumbing.HashReference {
- return nil
- }
-
- if !rs.Match(localRef.Name()) {
- return nil
- }
-
- dstName := rs.Dst(localRef.Name())
- oldHash := plumbing.ZeroHash
- newHash := localRef.Hash()
-
- iter, err := remoteRefs.IterReferences()
- if err != nil {
- return err
- }
-
- err = iter.ForEach(func(remoteRef *plumbing.Reference) error {
- if remoteRef.Type() != plumbing.HashReference {
- return nil
- }
-
- if dstName != remoteRef.Name() {
- return nil
- }
-
- oldHash = remoteRef.Hash()
- return nil
- })
-
- if oldHash == newHash {
- return nil
- }
-
- req.Commands = append(req.Commands, &packp.Command{
- Name: dstName,
- Old: oldHash,
- New: newHash,
- })
- return nil
-}
-
-func getHaves(localRefs storer.ReferenceStorer) ([]plumbing.Hash, error) {
- iter, err := localRefs.IterReferences()
- if err != nil {
- return nil, err
- }
-
- var haves []plumbing.Hash
- err = iter.ForEach(func(ref *plumbing.Reference) error {
- if ref.Type() != plumbing.HashReference {
- return nil
- }
-
- haves = append(haves, ref.Hash())
- return nil
- })
- if err != nil {
- return nil, err
- }
-
- return haves, nil
-}
-
-func getWants(
- spec []config.RefSpec, localStorer storage.Storer, remoteRefs storer.ReferenceStorer,
-) ([]plumbing.Hash, error) {
- wantTags := true
- for _, s := range spec {
- if !s.IsWildcard() {
- wantTags = false
- break
- }
- }
-
- iter, err := remoteRefs.IterReferences()
- if err != nil {
- return nil, err
- }
-
- wants := map[plumbing.Hash]bool{}
- err = iter.ForEach(func(ref *plumbing.Reference) error {
- if !config.MatchAny(spec, ref.Name()) {
- if !ref.IsTag() || !wantTags {
- return nil
- }
- }
-
- if ref.Type() == plumbing.SymbolicReference {
- ref, err = storer.ResolveReference(remoteRefs, ref.Name())
- if err != nil {
- return err
- }
- }
-
- if ref.Type() != plumbing.HashReference {
- return nil
- }
-
- hash := ref.Hash()
-
- exists, err := objectExists(localStorer, hash)
- if err != nil {
- return err
- }
-
- if !exists {
- wants[hash] = true
- }
-
- return nil
- })
- if err != nil {
- return nil, err
- }
-
- var result []plumbing.Hash
- for h := range wants {
- result = append(result, h)
- }
-
- return result, nil
-}
-
-func objectExists(s storer.EncodedObjectStorer, h plumbing.Hash) (bool, error) {
- _, err := s.EncodedObject(plumbing.AnyObject, h)
- if err == plumbing.ErrObjectNotFound {
- return false, nil
- }
-
- return true, err
-}
-
-func (r *Remote) newUploadPackRequest(o *FetchOptions,
- ar *packp.AdvRefs) (*packp.UploadPackRequest, error) {
-
- req := packp.NewUploadPackRequestFromCapabilities(ar.Capabilities)
-
- if o.Depth != 0 {
- req.Depth = packp.DepthCommits(o.Depth)
- if err := req.Capabilities.Set(capability.Shallow); err != nil {
- return nil, err
- }
- }
-
- if o.Progress == nil && ar.Capabilities.Supports(capability.NoProgress) {
- if err := req.Capabilities.Set(capability.NoProgress); err != nil {
- return nil, err
- }
- }
-
- return req, nil
-}
-
-func buildSidebandIfSupported(l *capability.List, reader io.Reader, p sideband.Progress) io.Reader {
- var t sideband.Type
-
- switch {
- case l.Supports(capability.Sideband):
- t = sideband.Sideband
- case l.Supports(capability.Sideband64k):
- t = sideband.Sideband64k
- default:
- return reader
- }
-
- d := sideband.NewDemuxer(t, reader)
- d.Progress = p
-
- return d
-}
-
-func (r *Remote) updateLocalReferenceStorage(specs []config.RefSpec, refs memory.ReferenceStorage) error {
- for _, spec := range specs {
- for _, ref := range refs {
- if !spec.Match(ref.Name()) {
- continue
- }
-
- if ref.Type() != plumbing.HashReference {
- continue
- }
-
- name := spec.Dst(ref.Name())
- n := plumbing.NewHashReference(name, ref.Hash())
- if err := r.s.SetReference(n); err != nil {
- return err
- }
- }
- }
-
- return r.buildFetchedTags(refs)
-}
-
-func (r *Remote) buildFetchedTags(refs storer.ReferenceStorer) error {
- iter, err := refs.IterReferences()
- if err != nil {
- return err
- }
-
- return iter.ForEach(func(ref *plumbing.Reference) error {
- if !ref.IsTag() {
- return nil
- }
-
- _, err := r.s.EncodedObject(plumbing.AnyObject, ref.Hash())
- if err == plumbing.ErrObjectNotFound {
- return nil
- }
-
- if err != nil {
- return err
- }
-
- return r.s.SetReference(ref)
- })
-}
-
-func objectsToPush(commands []*packp.Command) ([]plumbing.Hash, error) {
- var objects []plumbing.Hash
- for _, cmd := range commands {
- if cmd.New == plumbing.ZeroHash {
- continue
- }
-
- objects = append(objects, cmd.New)
- }
-
- return objects, nil
-}
-
-func referencesToHashes(refs storer.ReferenceStorer) ([]plumbing.Hash, error) {
- iter, err := refs.IterReferences()
- if err != nil {
- return nil, err
- }
-
- var hs []plumbing.Hash
- err = iter.ForEach(func(ref *plumbing.Reference) error {
- if ref.Type() != plumbing.HashReference {
- return nil
- }
-
- hs = append(hs, ref.Hash())
- return nil
- })
- if err != nil {
- return nil, err
- }
-
- return hs, nil
-}
-
-func pushHashes(sess transport.ReceivePackSession, sto storer.EncodedObjectStorer,
- req *packp.ReferenceUpdateRequest, hs []plumbing.Hash) (*packp.ReportStatus, error) {
-
- rd, wr := io.Pipe()
- req.Packfile = rd
- done := make(chan error)
- go func() {
- e := packfile.NewEncoder(wr, sto, false)
- if _, err := e.Encode(hs); err != nil {
- done <- wr.CloseWithError(err)
- return
- }
-
- done <- wr.Close()
- }()
-
- rs, err := sess.ReceivePack(req)
- if err != nil {
- return nil, err
- }
-
- if err := <-done; err != nil {
- return nil, err
- }
-
- return rs, nil
-}
-
-func (r *Remote) updateShallow(o *FetchOptions, resp *packp.UploadPackResponse) error {
- if o.Depth == 0 {
- return nil
- }
-
- return r.s.SetShallow(resp.Shallows)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/repository.go b/vendor/gopkg.in/src-d/go-git.v4/repository.go
deleted file mode 100644
index 9e325e4d44e0b4e0d6594e23f12ddb01449da6f9..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/repository.go
+++ /dev/null
@@ -1,898 +0,0 @@
-package git
-
-import (
- "errors"
- "fmt"
- "os"
- "path/filepath"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/internal/revision"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/storage"
- "gopkg.in/src-d/go-git.v4/storage/filesystem"
-
- "gopkg.in/src-d/go-billy.v2"
- "gopkg.in/src-d/go-billy.v2/osfs"
-)
-
-var (
- ErrObjectNotFound = errors.New("object not found")
- ErrInvalidReference = errors.New("invalid reference, should be a tag or a branch")
- ErrRepositoryNotExists = errors.New("repository not exists")
- ErrRepositoryAlreadyExists = errors.New("repository already exists")
- ErrRemoteNotFound = errors.New("remote not found")
- ErrRemoteExists = errors.New("remote already exists")
- ErrWorktreeNotProvided = errors.New("worktree should be provided")
- ErrIsBareRepository = errors.New("worktree not available in a bare repository")
-)
-
-// Repository represents a git repository
-type Repository struct {
- Storer storage.Storer
-
- r map[string]*Remote
- wt billy.Filesystem
-}
-
-// Init creates an empty git repository, based on the given Storer and worktree.
-// The worktree Filesystem is optional, if nil a bare repository is created. If
-// the given storer is not empty ErrRepositoryAlreadyExists is returned
-func Init(s storage.Storer, worktree billy.Filesystem) (*Repository, error) {
- r := newRepository(s, worktree)
- _, err := r.Reference(plumbing.HEAD, false)
- switch err {
- case plumbing.ErrReferenceNotFound:
- case nil:
- return nil, ErrRepositoryAlreadyExists
- default:
- return nil, err
- }
-
- h := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.Master)
- if err := s.SetReference(h); err != nil {
- return nil, err
- }
-
- if worktree == nil {
- r.setIsBare(true)
- return r, nil
- }
-
- return r, setWorktreeAndStoragePaths(r, worktree)
-}
-
-func setWorktreeAndStoragePaths(r *Repository, worktree billy.Filesystem) error {
- type fsBased interface {
- Filesystem() billy.Filesystem
- }
-
- // .git file is only created if the storage is file based and the file
- // system is osfs.OS
- fs, isFSBased := r.Storer.(fsBased)
- if !isFSBased {
- return nil
- }
-
- _, isOS := fs.Filesystem().(*osfs.OS)
- if !isOS {
- return nil
- }
-
- if err := createDotGitFile(worktree, fs.Filesystem()); err != nil {
- return err
- }
-
- return setConfigWorktree(r, worktree, fs.Filesystem())
-}
-
-func createDotGitFile(worktree, storage billy.Filesystem) error {
- path, err := filepath.Rel(worktree.Base(), storage.Base())
- if err != nil {
- path = storage.Base()
- }
-
- if path == ".git" {
- // not needed, since the folder is the default place
- return nil
- }
-
- f, err := worktree.Create(".git")
- if err != nil {
- return err
- }
-
- defer f.Close()
- _, err = fmt.Fprintf(f, "gitdir: %s\n", path)
- return err
-}
-
-func setConfigWorktree(r *Repository, worktree, storage billy.Filesystem) error {
- path, err := filepath.Rel(storage.Base(), worktree.Base())
- if err != nil {
- path = worktree.Base()
- }
-
- if path == ".." {
- // not needed, since the folder is the default place
- return nil
- }
-
- cfg, err := r.Storer.Config()
- if err != nil {
- return err
- }
-
- cfg.Core.Worktree = path
- return r.Storer.SetConfig(cfg)
-}
-
-// Open opens a git repository using the given Storer and worktree filesystem,
-// if the given storer is complete empty ErrRepositoryNotExists is returned.
-// The worktree can be nil when the repository being opened is bare, if the
-// repository is a normal one (not bare) and worktree is nil the err
-// ErrWorktreeNotProvided is returned
-func Open(s storage.Storer, worktree billy.Filesystem) (*Repository, error) {
- _, err := s.Reference(plumbing.HEAD)
- if err == plumbing.ErrReferenceNotFound {
- return nil, ErrRepositoryNotExists
- }
-
- if err != nil {
- return nil, err
- }
-
- cfg, err := s.Config()
- if err != nil {
- return nil, err
- }
-
- if !cfg.Core.IsBare && worktree == nil {
- return nil, ErrWorktreeNotProvided
- }
-
- return newRepository(s, worktree), nil
-}
-
-// Clone a repository into the given Storer and worktree Filesystem with the
-// given options, if worktree is nil a bare repository is created. If the given
-// storer is not empty ErrRepositoryAlreadyExists is returned
-func Clone(s storage.Storer, worktree billy.Filesystem, o *CloneOptions) (*Repository, error) {
- r, err := Init(s, worktree)
- if err != nil {
- return nil, err
- }
-
- return r, r.clone(o)
-}
-
-// PlainInit create an empty git repository at the given path. isBare defines
-// if the repository will have worktree (non-bare) or not (bare), if the path
-// is not empty ErrRepositoryAlreadyExists is returned
-func PlainInit(path string, isBare bool) (*Repository, error) {
- var wt, dot billy.Filesystem
-
- if isBare {
- dot = osfs.New(path)
- } else {
- wt = osfs.New(path)
- dot = wt.Dir(".git")
- }
-
- s, err := filesystem.NewStorage(dot)
- if err != nil {
- return nil, err
- }
-
- return Init(s, wt)
-}
-
-// PlainOpen opens a git repository from the given path. It detects if the
-// repository is bare or a normal one. If the path doesn't contain a valid
-// repository ErrRepositoryNotExists is returned
-func PlainOpen(path string) (*Repository, error) {
- var wt, dot billy.Filesystem
-
- fs := osfs.New(path)
- if _, err := fs.Stat(".git"); err != nil {
- if !os.IsNotExist(err) {
- return nil, err
- }
-
- dot = fs
- } else {
- wt = fs
- dot = fs.Dir(".git")
- }
-
- s, err := filesystem.NewStorage(dot)
- if err != nil {
- return nil, err
- }
-
- return Open(s, wt)
-}
-
-// PlainClone a repository into the path with the given options, isBare defines
-// if the new repository will be bare or normal. If the path is not empty
-// ErrRepositoryAlreadyExists is returned
-func PlainClone(path string, isBare bool, o *CloneOptions) (*Repository, error) {
- r, err := PlainInit(path, isBare)
- if err != nil {
- return nil, err
- }
-
- return r, r.clone(o)
-}
-
-func newRepository(s storage.Storer, worktree billy.Filesystem) *Repository {
- return &Repository{
- Storer: s,
- wt: worktree,
- r: make(map[string]*Remote, 0),
- }
-}
-
-// Config return the repository config
-func (r *Repository) Config() (*config.Config, error) {
- return r.Storer.Config()
-}
-
-// Remote return a remote if exists
-func (r *Repository) Remote(name string) (*Remote, error) {
- cfg, err := r.Storer.Config()
- if err != nil {
- return nil, err
- }
-
- c, ok := cfg.Remotes[name]
- if !ok {
- return nil, ErrRemoteNotFound
- }
-
- return newRemote(r.Storer, c), nil
-}
-
-// Remotes returns a list with all the remotes
-func (r *Repository) Remotes() ([]*Remote, error) {
- cfg, err := r.Storer.Config()
- if err != nil {
- return nil, err
- }
-
- remotes := make([]*Remote, len(cfg.Remotes))
-
- var i int
- for _, c := range cfg.Remotes {
- remotes[i] = newRemote(r.Storer, c)
- i++
- }
-
- return remotes, nil
-}
-
-// CreateRemote creates a new remote
-func (r *Repository) CreateRemote(c *config.RemoteConfig) (*Remote, error) {
- if err := c.Validate(); err != nil {
- return nil, err
- }
-
- remote := newRemote(r.Storer, c)
-
- cfg, err := r.Storer.Config()
- if err != nil {
- return nil, err
- }
-
- if _, ok := cfg.Remotes[c.Name]; ok {
- return nil, ErrRemoteExists
- }
-
- cfg.Remotes[c.Name] = c
- return remote, r.Storer.SetConfig(cfg)
-}
-
-// DeleteRemote delete a remote from the repository and delete the config
-func (r *Repository) DeleteRemote(name string) error {
- cfg, err := r.Storer.Config()
- if err != nil {
- return err
- }
-
- if _, ok := cfg.Remotes[name]; !ok {
- return ErrRemoteNotFound
- }
-
- delete(cfg.Remotes, name)
- return r.Storer.SetConfig(cfg)
-}
-
-// Clone clones a remote repository
-func (r *Repository) clone(o *CloneOptions) error {
- if err := o.Validate(); err != nil {
- return err
- }
-
- c := &config.RemoteConfig{
- Name: o.RemoteName,
- URL: o.URL,
- }
-
- remote, err := r.CreateRemote(c)
- if err != nil {
- return err
- }
-
- remoteRefs, err := remote.fetch(&FetchOptions{
- RefSpecs: r.cloneRefSpec(o, c),
- Depth: o.Depth,
- Auth: o.Auth,
- Progress: o.Progress,
- })
- if err != nil {
- return err
- }
-
- head, err := storer.ResolveReference(remoteRefs, o.ReferenceName)
- if err != nil {
- return err
- }
-
- if _, err := r.updateReferences(c.Fetch, o.ReferenceName, head); err != nil {
- return err
- }
-
- if err := r.updateWorktree(); err != nil {
- return err
- }
-
- if o.RecurseSubmodules != NoRecurseSubmodules && r.wt != nil {
- if err := r.updateSubmodules(o.RecurseSubmodules); err != nil {
- return err
- }
- }
-
- return r.updateRemoteConfig(remote, o, c, head)
-}
-
-func (r *Repository) updateSubmodules(recursion SubmoduleRescursivity) error {
- w, err := r.Worktree()
- if err != nil {
- return err
- }
-
- s, err := w.Submodules()
- if err != nil {
- return err
- }
-
- return s.Update(&SubmoduleUpdateOptions{
- Init: true,
- RecurseSubmodules: recursion,
- })
-}
-
-func (r *Repository) cloneRefSpec(o *CloneOptions,
- c *config.RemoteConfig) []config.RefSpec {
-
- if !o.SingleBranch {
- return c.Fetch
- }
-
- var rs string
-
- if o.ReferenceName == plumbing.HEAD {
- rs = fmt.Sprintf(refspecSingleBranchHEAD, c.Name)
- } else {
- rs = fmt.Sprintf(refspecSingleBranch,
- o.ReferenceName.Short(), c.Name)
- }
-
- return []config.RefSpec{config.RefSpec(rs)}
-}
-
-func (r *Repository) setIsBare(isBare bool) error {
- cfg, err := r.Storer.Config()
- if err != nil {
- return err
- }
-
- cfg.Core.IsBare = isBare
- return r.Storer.SetConfig(cfg)
-}
-
-const (
- refspecSingleBranch = "+refs/heads/%s:refs/remotes/%s/%[1]s"
- refspecSingleBranchHEAD = "+HEAD:refs/remotes/%s/HEAD"
-)
-
-func (r *Repository) updateRemoteConfig(remote *Remote, o *CloneOptions,
- c *config.RemoteConfig, head *plumbing.Reference) error {
-
- if !o.SingleBranch {
- return nil
- }
-
- c.Fetch = []config.RefSpec{config.RefSpec(fmt.Sprintf(
- refspecSingleBranch, head.Name().Short(), c.Name,
- ))}
-
- cfg, err := r.Storer.Config()
- if err != nil {
- return err
- }
-
- cfg.Remotes[c.Name] = c
- return r.Storer.SetConfig(cfg)
-}
-
-func (r *Repository) updateReferences(spec []config.RefSpec,
- headName plumbing.ReferenceName, resolvedHead *plumbing.Reference) (updated bool, err error) {
-
- if !resolvedHead.IsBranch() {
- // Detached HEAD mode
- head := plumbing.NewHashReference(plumbing.HEAD, resolvedHead.Hash())
- return updateReferenceStorerIfNeeded(r.Storer, head)
- }
-
- refs := []*plumbing.Reference{
- // Create local reference for the resolved head
- resolvedHead,
- // Create local symbolic HEAD
- plumbing.NewSymbolicReference(plumbing.HEAD, resolvedHead.Name()),
- }
-
- refs = append(refs, r.calculateRemoteHeadReference(spec, resolvedHead)...)
-
- for _, ref := range refs {
- u, err := updateReferenceStorerIfNeeded(r.Storer, ref)
- if err != nil {
- return updated, err
- }
-
- if u {
- updated = true
- }
- }
-
- return
-}
-
-func (r *Repository) calculateRemoteHeadReference(spec []config.RefSpec,
- resolvedHead *plumbing.Reference) []*plumbing.Reference {
-
- var refs []*plumbing.Reference
-
- // Create resolved HEAD reference with remote prefix if it does not
- // exist. This is needed when using single branch and HEAD.
- for _, rs := range spec {
- name := resolvedHead.Name()
- if !rs.Match(name) {
- continue
- }
-
- name = rs.Dst(name)
- _, err := r.Storer.Reference(name)
- if err == plumbing.ErrReferenceNotFound {
- refs = append(refs, plumbing.NewHashReference(name, resolvedHead.Hash()))
- }
- }
-
- return refs
-}
-
-func updateReferenceStorerIfNeeded(
- s storer.ReferenceStorer, r *plumbing.Reference) (updated bool, err error) {
-
- p, err := s.Reference(r.Name())
- if err != nil && err != plumbing.ErrReferenceNotFound {
- return false, err
- }
-
- // we use the string method to compare references, is the easiest way
- if err == plumbing.ErrReferenceNotFound || r.String() != p.String() {
- if err := s.SetReference(r); err != nil {
- return false, err
- }
-
- return true, nil
- }
-
- return false, nil
-}
-
-// Pull incorporates changes from a remote repository into the current branch.
-// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
-// no changes to be fetched, or an error.
-func (r *Repository) Pull(o *PullOptions) error {
- if err := o.Validate(); err != nil {
- return err
- }
-
- remote, err := r.Remote(o.RemoteName)
- if err != nil {
- return err
- }
-
- remoteRefs, err := remote.fetch(&FetchOptions{
- Depth: o.Depth,
- Auth: o.Auth,
- Progress: o.Progress,
- })
-
- updated := true
- if err == NoErrAlreadyUpToDate {
- updated = false
- } else if err != nil {
- return err
- }
-
- head, err := storer.ResolveReference(remoteRefs, o.ReferenceName)
- if err != nil {
- return err
- }
-
- refsUpdated, err := r.updateReferences(remote.c.Fetch, o.ReferenceName, head)
- if err != nil {
- return err
- }
-
- if refsUpdated {
- updated = refsUpdated
- }
-
- if !updated {
- return NoErrAlreadyUpToDate
- }
-
- if err := r.updateWorktree(); err != nil {
- return err
- }
-
- if o.RecurseSubmodules != NoRecurseSubmodules && r.wt != nil {
- if err := r.updateSubmodules(o.RecurseSubmodules); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (r *Repository) updateWorktree() error {
- if r.wt == nil {
- return nil
- }
-
- w, err := r.Worktree()
- if err != nil {
- return err
- }
-
- h, err := r.Head()
- if err != nil {
- return err
- }
-
- return w.Checkout(h.Hash())
-}
-
-// Fetch fetches changes from a remote repository.
-// Returns nil if the operation is successful, NoErrAlreadyUpToDate if there are
-// no changes to be fetched, or an error.
-func (r *Repository) Fetch(o *FetchOptions) error {
- if err := o.Validate(); err != nil {
- return err
- }
-
- remote, err := r.Remote(o.RemoteName)
- if err != nil {
- return err
- }
-
- return remote.Fetch(o)
-}
-
-// Push pushes changes to a remote.
-func (r *Repository) Push(o *PushOptions) error {
- if err := o.Validate(); err != nil {
- return err
- }
-
- remote, err := r.Remote(o.RemoteName)
- if err != nil {
- return err
- }
-
- return remote.Push(o)
-}
-
-// Tags returns all the References from Tags. This method returns all the tag
-// types, lightweight, and annotated ones.
-func (r *Repository) Tags() (storer.ReferenceIter, error) {
- refIter, err := r.Storer.IterReferences()
- if err != nil {
- return nil, err
- }
-
- return storer.NewReferenceFilteredIter(
- func(r *plumbing.Reference) bool {
- return r.IsTag()
- }, refIter), nil
-}
-
-// Branches returns all the References that are Branches.
-func (r *Repository) Branches() (storer.ReferenceIter, error) {
- refIter, err := r.Storer.IterReferences()
- if err != nil {
- return nil, err
- }
-
- return storer.NewReferenceFilteredIter(
- func(r *plumbing.Reference) bool {
- return r.IsBranch()
- }, refIter), nil
-}
-
-// Notes returns all the References that are Branches.
-func (r *Repository) Notes() (storer.ReferenceIter, error) {
- refIter, err := r.Storer.IterReferences()
- if err != nil {
- return nil, err
- }
-
- return storer.NewReferenceFilteredIter(
- func(r *plumbing.Reference) bool {
- return r.IsNote()
- }, refIter), nil
-}
-
-// TreeObject return a Tree with the given hash. If not found
-// plumbing.ErrObjectNotFound is returned
-func (r *Repository) TreeObject(h plumbing.Hash) (*object.Tree, error) {
- return object.GetTree(r.Storer, h)
-}
-
-// TreeObjects returns an unsorted TreeIter with all the trees in the repository
-func (r *Repository) TreeObjects() (*object.TreeIter, error) {
- iter, err := r.Storer.IterEncodedObjects(plumbing.TreeObject)
- if err != nil {
- return nil, err
- }
-
- return object.NewTreeIter(r.Storer, iter), nil
-}
-
-// CommitObject return a Commit with the given hash. If not found
-// plumbing.ErrObjectNotFound is returned.
-func (r *Repository) CommitObject(h plumbing.Hash) (*object.Commit, error) {
- return object.GetCommit(r.Storer, h)
-}
-
-// CommitObjects returns an unsorted CommitIter with all the commits in the repository.
-func (r *Repository) CommitObjects() (*object.CommitIter, error) {
- iter, err := r.Storer.IterEncodedObjects(plumbing.CommitObject)
- if err != nil {
- return nil, err
- }
-
- return object.NewCommitIter(r.Storer, iter), nil
-}
-
-// BlobObject returns a Blob with the given hash. If not found
-// plumbing.ErrObjectNotFound is returned.
-func (r *Repository) BlobObject(h plumbing.Hash) (*object.Blob, error) {
- return object.GetBlob(r.Storer, h)
-}
-
-// BlobObjects returns an unsorted BlobIter with all the blobs in the repository.
-func (r *Repository) BlobObjects() (*object.BlobIter, error) {
- iter, err := r.Storer.IterEncodedObjects(plumbing.BlobObject)
- if err != nil {
- return nil, err
- }
-
- return object.NewBlobIter(r.Storer, iter), nil
-}
-
-// TagObject returns a Tag with the given hash. If not found
-// plumbing.ErrObjectNotFound is returned. This method only returns
-// annotated Tags, no lightweight Tags.
-func (r *Repository) TagObject(h plumbing.Hash) (*object.Tag, error) {
- return object.GetTag(r.Storer, h)
-}
-
-// TagObjects returns a unsorted TagIter that can step through all of the annotated
-// tags in the repository.
-func (r *Repository) TagObjects() (*object.TagIter, error) {
- iter, err := r.Storer.IterEncodedObjects(plumbing.TagObject)
- if err != nil {
- return nil, err
- }
-
- return object.NewTagIter(r.Storer, iter), nil
-}
-
-// Object returns an Object with the given hash. If not found
-// plumbing.ErrObjectNotFound is returned.
-func (r *Repository) Object(t plumbing.ObjectType, h plumbing.Hash) (object.Object, error) {
- obj, err := r.Storer.EncodedObject(t, h)
- if err != nil {
- if err == plumbing.ErrObjectNotFound {
- return nil, ErrObjectNotFound
- }
-
- return nil, err
- }
-
- return object.DecodeObject(r.Storer, obj)
-}
-
-// Objects returns an unsorted ObjectIter with all the objects in the repository.
-func (r *Repository) Objects() (*object.ObjectIter, error) {
- iter, err := r.Storer.IterEncodedObjects(plumbing.AnyObject)
- if err != nil {
- return nil, err
- }
-
- return object.NewObjectIter(r.Storer, iter), nil
-}
-
-// Head returns the reference where HEAD is pointing to.
-func (r *Repository) Head() (*plumbing.Reference, error) {
- return storer.ResolveReference(r.Storer, plumbing.HEAD)
-}
-
-// Reference returns the reference for a given reference name. If resolved is
-// true, any symbolic reference will be resolved.
-func (r *Repository) Reference(name plumbing.ReferenceName, resolved bool) (
- *plumbing.Reference, error) {
-
- if resolved {
- return storer.ResolveReference(r.Storer, name)
- }
-
- return r.Storer.Reference(name)
-}
-
-// References returns an unsorted ReferenceIter for all references.
-func (r *Repository) References() (storer.ReferenceIter, error) {
- return r.Storer.IterReferences()
-}
-
-// Worktree returns a worktree based on the given fs, if nil the default
-// worktree will be used.
-func (r *Repository) Worktree() (*Worktree, error) {
- if r.wt == nil {
- return nil, ErrIsBareRepository
- }
-
- return &Worktree{r: r, fs: r.wt}, nil
-}
-
-// ResolveRevision resolves revision to corresponding hash.
-func (r *Repository) ResolveRevision(rev plumbing.Revision) (*plumbing.Hash, error) {
- p := revision.NewParserFromString(string(rev))
-
- items, err := p.Parse()
-
- if err != nil {
- return nil, err
- }
-
- var commit *object.Commit
-
- for _, item := range items {
- switch item.(type) {
- case revision.Ref:
- ref, err := storer.ResolveReference(r.Storer, plumbing.ReferenceName(item.(revision.Ref)))
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- h := ref.Hash()
-
- commit, err = r.CommitObject(h)
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
- case revision.CaretPath:
- depth := item.(revision.CaretPath).Depth
-
- if depth == 0 {
- break
- }
-
- iter := commit.Parents()
-
- c, err := iter.Next()
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- if depth == 1 {
- commit = c
-
- break
- }
-
- c, err = iter.Next()
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- commit = c
- case revision.TildePath:
- for i := 0; i < item.(revision.TildePath).Depth; i++ {
- c, err := commit.Parents().Next()
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- commit = c
- }
- case revision.CaretReg:
- history, err := commit.History()
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- re := item.(revision.CaretReg).Regexp
- negate := item.(revision.CaretReg).Negate
-
- var c *object.Commit
-
- for i := 0; i < len(history); i++ {
- if !negate && re.MatchString(history[i].Message) {
- c = history[i]
-
- break
- }
-
- if negate && !re.MatchString(history[i].Message) {
- c = history[i]
-
- break
- }
- }
-
- if c == nil {
- return &plumbing.ZeroHash, fmt.Errorf(`No commit message match regexp : "%s"`, re.String())
- }
-
- commit = c
- case revision.AtDate:
- history, err := commit.History()
-
- if err != nil {
- return &plumbing.ZeroHash, err
- }
-
- date := item.(revision.AtDate).Date
- var c *object.Commit
-
- for i := 0; i < len(history); i++ {
- if date.Equal(history[i].Committer.When.UTC()) || history[i].Committer.When.UTC().Before(date) {
- c = history[i]
-
- break
- }
- }
-
- if c == nil {
- return &plumbing.ZeroHash, fmt.Errorf(`No commit exists prior to date "%s"`, date.String())
- }
-
- commit = c
- }
- }
-
- return &commit.Hash, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/config.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/config.go
deleted file mode 100644
index cad698a4a41595240012292fb535f15c767cd938..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/config.go
+++ /dev/null
@@ -1,60 +0,0 @@
-package filesystem
-
-import (
- "io/ioutil"
- "os"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-)
-
-type ConfigStorage struct {
- dir *dotgit.DotGit
-}
-
-func (c *ConfigStorage) Config() (*config.Config, error) {
- cfg := config.NewConfig()
-
- f, err := c.dir.Config()
- if err != nil {
- if os.IsNotExist(err) {
- return cfg, nil
- }
-
- return nil, err
- }
-
- defer f.Close()
-
- b, err := ioutil.ReadAll(f)
- if err != nil {
- return nil, err
- }
-
- if err := cfg.Unmarshal(b); err != nil {
- return nil, err
- }
-
- return cfg, nil
-}
-
-func (c *ConfigStorage) SetConfig(cfg *config.Config) error {
- if err := cfg.Validate(); err != nil {
- return err
- }
-
- f, err := c.dir.ConfigWriter()
- if err != nil {
- return err
- }
-
- defer f.Close()
-
- b, err := cfg.Marshal()
- if err != nil {
- return err
- }
-
- _, err = f.Write(b)
- return err
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/index.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/index.go
deleted file mode 100644
index 456ef0b89814acc8d498b66e543285b177598e94..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/index.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package filesystem
-
-import (
- "os"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/index"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-)
-
-type IndexStorage struct {
- dir *dotgit.DotGit
-}
-
-func (s *IndexStorage) SetIndex(idx *index.Index) error {
- f, err := s.dir.IndexWriter()
- if err != nil {
- return err
- }
-
- defer f.Close()
-
- e := index.NewEncoder(f)
- return e.Encode(idx)
-}
-
-func (s *IndexStorage) Index() (*index.Index, error) {
- idx := &index.Index{
- Version: 2,
- }
-
- f, err := s.dir.Index()
- if err != nil {
- if os.IsNotExist(err) {
- return idx, nil
- }
-
- return nil, err
- }
-
- defer f.Close()
-
- d := index.NewDecoder(f)
- return idx, d.Decode(idx)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/dotgit.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/dotgit.go
deleted file mode 100644
index fdfcea73552e1a49d81f767dff84819db34b921f..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/dotgit.go
+++ /dev/null
@@ -1,483 +0,0 @@
-// https://github.com/git/git/blob/master/Documentation/gitrepository-layout.txt
-package dotgit
-
-import (
- "bufio"
- "errors"
- "fmt"
- stdioutil "io/ioutil"
- "os"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/utils/ioutil"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-const (
- suffix = ".git"
- packedRefsPath = "packed-refs"
- configPath = "config"
- indexPath = "index"
- shallowPath = "shallow"
- modulePath = "module"
- objectsPath = "objects"
- packPath = "pack"
- refsPath = "refs"
-
- tmpPackedRefsPrefix = "._packed-refs"
-
- packExt = ".pack"
- idxExt = ".idx"
-)
-
-var (
- // ErrNotFound is returned by New when the path is not found.
- ErrNotFound = errors.New("path not found")
- // ErrIdxNotFound is returned by Idxfile when the idx file is not found
- ErrIdxNotFound = errors.New("idx file not found")
- // ErrPackfileNotFound is returned by Packfile when the packfile is not found
- ErrPackfileNotFound = errors.New("packfile not found")
- // ErrConfigNotFound is returned by Config when the config is not found
- ErrConfigNotFound = errors.New("config file not found")
- // ErrPackedRefsDuplicatedRef is returned when a duplicated reference is
- // found in the packed-ref file. This is usually the case for corrupted git
- // repositories.
- ErrPackedRefsDuplicatedRef = errors.New("duplicated ref found in packed-ref file")
- // ErrPackedRefsBadFormat is returned when the packed-ref file corrupt.
- ErrPackedRefsBadFormat = errors.New("malformed packed-ref")
- // ErrSymRefTargetNotFound is returned when a symbolic reference is
- // targeting a non-existing object. This usually means the repository
- // is corrupt.
- ErrSymRefTargetNotFound = errors.New("symbolic reference target not found")
-)
-
-// The DotGit type represents a local git repository on disk. This
-// type is not zero-value-safe, use the New function to initialize it.
-type DotGit struct {
- fs billy.Filesystem
-}
-
-// New returns a DotGit value ready to be used. The path argument must
-// be the absolute path of a git repository directory (e.g.
-// "/foo/bar/.git").
-func New(fs billy.Filesystem) *DotGit {
- return &DotGit{fs: fs}
-}
-
-// ConfigWriter returns a file pointer for write to the config file
-func (d *DotGit) ConfigWriter() (billy.File, error) {
- return d.fs.Create(configPath)
-}
-
-// Config returns a file pointer for read to the config file
-func (d *DotGit) Config() (billy.File, error) {
- return d.fs.Open(configPath)
-}
-
-// IndexWriter returns a file pointer for write to the index file
-func (d *DotGit) IndexWriter() (billy.File, error) {
- return d.fs.Create(indexPath)
-}
-
-// Index returns a file pointer for read to the index file
-func (d *DotGit) Index() (billy.File, error) {
- return d.fs.Open(indexPath)
-}
-
-// ShallowWriter returns a file pointer for write to the shallow file
-func (d *DotGit) ShallowWriter() (billy.File, error) {
- return d.fs.Create(shallowPath)
-}
-
-// Shallow returns a file pointer for read to the shallow file
-func (d *DotGit) Shallow() (billy.File, error) {
- f, err := d.fs.Open(shallowPath)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, nil
- }
-
- return nil, err
- }
-
- return f, nil
-}
-
-// NewObjectPack return a writer for a new packfile, it saves the packfile to
-// disk and also generates and save the index for the given packfile.
-func (d *DotGit) NewObjectPack() (*PackWriter, error) {
- return newPackWrite(d.fs)
-}
-
-// ObjectPacks returns the list of availables packfiles
-func (d *DotGit) ObjectPacks() ([]plumbing.Hash, error) {
- packDir := d.fs.Join(objectsPath, packPath)
- files, err := d.fs.ReadDir(packDir)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, nil
- }
-
- return nil, err
- }
-
- var packs []plumbing.Hash
- for _, f := range files {
- if !strings.HasSuffix(f.Name(), packExt) {
- continue
- }
-
- n := f.Name()
- h := plumbing.NewHash(n[5 : len(n)-5]) //pack-(hash).pack
- packs = append(packs, h)
-
- }
-
- return packs, nil
-}
-
-// ObjectPack returns a fs.File of the given packfile
-func (d *DotGit) ObjectPack(hash plumbing.Hash) (billy.File, error) {
- file := d.fs.Join(objectsPath, packPath, fmt.Sprintf("pack-%s.pack", hash.String()))
-
- pack, err := d.fs.Open(file)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, ErrPackfileNotFound
- }
-
- return nil, err
- }
-
- return pack, nil
-}
-
-// ObjectPackIdx returns a fs.File of the index file for a given packfile
-func (d *DotGit) ObjectPackIdx(hash plumbing.Hash) (billy.File, error) {
- file := d.fs.Join(objectsPath, packPath, fmt.Sprintf("pack-%s.idx", hash.String()))
- idx, err := d.fs.Open(file)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, ErrPackfileNotFound
- }
-
- return nil, err
- }
-
- return idx, nil
-}
-
-// NewObject return a writer for a new object file.
-func (d *DotGit) NewObject() (*ObjectWriter, error) {
- return newObjectWriter(d.fs)
-}
-
-// Objects returns a slice with the hashes of objects found under the
-// .git/objects/ directory.
-func (d *DotGit) Objects() ([]plumbing.Hash, error) {
- files, err := d.fs.ReadDir(objectsPath)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, nil
- }
-
- return nil, err
- }
-
- var objects []plumbing.Hash
- for _, f := range files {
- if f.IsDir() && len(f.Name()) == 2 && isHex(f.Name()) {
- base := f.Name()
- d, err := d.fs.ReadDir(d.fs.Join(objectsPath, base))
- if err != nil {
- return nil, err
- }
-
- for _, o := range d {
- objects = append(objects, plumbing.NewHash(base+o.Name()))
- }
- }
- }
-
- return objects, nil
-}
-
-// Object return a fs.File poiting the object file, if exists
-func (d *DotGit) Object(h plumbing.Hash) (billy.File, error) {
- hash := h.String()
- file := d.fs.Join(objectsPath, hash[0:2], hash[2:40])
-
- return d.fs.Open(file)
-}
-
-func (d *DotGit) SetRef(r *plumbing.Reference) error {
- var content string
- switch r.Type() {
- case plumbing.SymbolicReference:
- content = fmt.Sprintf("ref: %s\n", r.Target())
- case plumbing.HashReference:
- content = fmt.Sprintln(r.Hash().String())
- }
-
- f, err := d.fs.Create(r.Name().String())
- if err != nil {
- return err
- }
-
- if _, err := f.Write([]byte(content)); err != nil {
- return err
- }
- return f.Close()
-}
-
-// Refs scans the git directory collecting references, which it returns.
-// Symbolic references are resolved and included in the output.
-func (d *DotGit) Refs() ([]*plumbing.Reference, error) {
- var refs []*plumbing.Reference
- if err := d.addRefsFromPackedRefs(&refs); err != nil {
- return nil, err
- }
-
- if err := d.addRefsFromRefDir(&refs); err != nil {
- return nil, err
- }
-
- if err := d.addRefFromHEAD(&refs); err != nil {
- return nil, err
- }
-
- return refs, nil
-}
-
-// Ref returns the reference for a given reference name.
-func (d *DotGit) Ref(name plumbing.ReferenceName) (*plumbing.Reference, error) {
- ref, err := d.readReferenceFile(".", name.String())
- if err == nil {
- return ref, nil
- }
-
- refs, err := d.Refs()
- if err != nil {
- return nil, err
- }
-
- for _, ref := range refs {
- if ref.Name() == name {
- return ref, nil
- }
- }
-
- return nil, plumbing.ErrReferenceNotFound
-}
-
-// RemoveRef removes a reference by name.
-func (d *DotGit) RemoveRef(name plumbing.ReferenceName) error {
- path := d.fs.Join(".", name.String())
- _, err := d.fs.Stat(path)
- if err == nil {
- return d.fs.Remove(path)
- }
-
- if err != nil && !os.IsNotExist(err) {
- return err
- }
-
- return d.rewritePackedRefsWithoutRef(name)
-}
-
-func (d *DotGit) addRefsFromPackedRefs(refs *[]*plumbing.Reference) (err error) {
- f, err := d.fs.Open(packedRefsPath)
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
- return err
- }
- defer ioutil.CheckClose(f, &err)
-
- s := bufio.NewScanner(f)
- for s.Scan() {
- ref, err := d.processLine(s.Text())
- if err != nil {
- return err
- }
-
- if ref != nil {
- *refs = append(*refs, ref)
- }
- }
-
- return s.Err()
-}
-
-func (d *DotGit) rewritePackedRefsWithoutRef(name plumbing.ReferenceName) (err error) {
- f, err := d.fs.Open(packedRefsPath)
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
-
- return err
- }
- defer ioutil.CheckClose(f, &err)
-
- // Creating the temp file in the same directory as the target file
- // improves our chances for rename operation to be atomic.
- tmp, err := d.fs.TempFile("", tmpPackedRefsPrefix)
- if err != nil {
- return err
- }
-
- tmpPath := tmp.Filename()
- defer ioutil.CheckClose(tmp, &err)
- defer d.fs.Remove(tmpPath)
-
- s := bufio.NewScanner(f)
- found := false
- for s.Scan() {
- line := s.Text()
- ref, err := d.processLine(line)
- if err != nil {
- return err
- }
-
- if ref != nil && ref.Name() == name {
- found = true
- continue
- }
-
- if _, err := fmt.Fprintln(tmp, line); err != nil {
- return err
- }
- }
-
- if err := s.Err(); err != nil {
- return err
- }
-
- if !found {
- return nil
- }
-
- return d.fs.Rename(tmpPath, packedRefsPath)
-}
-
-// process lines from a packed-refs file
-func (d *DotGit) processLine(line string) (*plumbing.Reference, error) {
- if len(line) == 0 {
- return nil, nil
- }
-
- switch line[0] {
- case '#': // comment - ignore
- return nil, nil
- case '^': // annotated tag commit of the previous line - ignore
- return nil, nil
- default:
- ws := strings.Split(line, " ") // hash then ref
- if len(ws) != 2 {
- return nil, ErrPackedRefsBadFormat
- }
-
- return plumbing.NewReferenceFromStrings(ws[1], ws[0]), nil
- }
-}
-
-func (d *DotGit) addRefsFromRefDir(refs *[]*plumbing.Reference) error {
- return d.walkReferencesTree(refs, refsPath)
-}
-
-func (d *DotGit) walkReferencesTree(refs *[]*plumbing.Reference, relPath string) error {
- files, err := d.fs.ReadDir(relPath)
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
-
- return err
- }
-
- for _, f := range files {
- newRelPath := d.fs.Join(relPath, f.Name())
- if f.IsDir() {
- if err = d.walkReferencesTree(refs, newRelPath); err != nil {
- return err
- }
-
- continue
- }
-
- ref, err := d.readReferenceFile(".", newRelPath)
- if err != nil {
- return err
- }
-
- if ref != nil {
- *refs = append(*refs, ref)
- }
- }
-
- return nil
-}
-
-func (d *DotGit) addRefFromHEAD(refs *[]*plumbing.Reference) error {
- ref, err := d.readReferenceFile(".", "HEAD")
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
-
- return err
- }
-
- *refs = append(*refs, ref)
- return nil
-}
-
-func (d *DotGit) readReferenceFile(refsPath, refFile string) (ref *plumbing.Reference, err error) {
- path := d.fs.Join(refsPath, refFile)
-
- f, err := d.fs.Open(path)
- if err != nil {
- return nil, err
- }
- defer ioutil.CheckClose(f, &err)
-
- b, err := stdioutil.ReadAll(f)
- if err != nil {
- return nil, err
- }
-
- line := strings.TrimSpace(string(b))
- return plumbing.NewReferenceFromStrings(refFile, line), nil
-}
-
-// Module return a billy.Filesystem poiting to the module folder
-func (d *DotGit) Module(name string) billy.Filesystem {
- return d.fs.Dir(d.fs.Join(modulePath, name))
-}
-
-func isHex(s string) bool {
- for _, b := range []byte(s) {
- if isNum(b) {
- continue
- }
- if isHexAlpha(b) {
- continue
- }
-
- return false
- }
-
- return true
-}
-
-func isNum(b byte) bool {
- return b >= '0' && b <= '9'
-}
-
-func isHexAlpha(b byte) bool {
- return b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F'
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/writers.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/writers.go
deleted file mode 100644
index 0d2747f314a4f37f4506f7a0e422262606c693d4..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit/writers.go
+++ /dev/null
@@ -1,286 +0,0 @@
-package dotgit
-
-import (
- "fmt"
- "io"
- "sync/atomic"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/idxfile"
- "gopkg.in/src-d/go-git.v4/plumbing/format/objfile"
- "gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-// PackWriter is a io.Writer that generates the packfile index simultaneously,
-// a packfile.Decoder is used with a file reader to read the file being written
-// this operation is synchronized with the write operations.
-// The packfile is written in a temp file, when Close is called this file
-// is renamed/moved (depends on the Filesystem implementation) to the final
-// location, if the PackWriter is not used, nothing is written
-type PackWriter struct {
- Notify func(h plumbing.Hash, i idxfile.Idxfile)
-
- fs billy.Filesystem
- fr, fw billy.File
- synced *syncedReader
- checksum plumbing.Hash
- index idxfile.Idxfile
- result chan error
-}
-
-func newPackWrite(fs billy.Filesystem) (*PackWriter, error) {
- fw, err := fs.TempFile(fs.Join(objectsPath, packPath), "tmp_pack_")
- if err != nil {
- return nil, err
- }
-
- fr, err := fs.Open(fw.Filename())
- if err != nil {
- return nil, err
- }
-
- writer := &PackWriter{
- fs: fs,
- fw: fw,
- fr: fr,
- synced: newSyncedReader(fw, fr),
- result: make(chan error),
- }
-
- go writer.buildIndex()
- return writer, nil
-}
-
-func (w *PackWriter) buildIndex() {
- s := packfile.NewScanner(w.synced)
- d, err := packfile.NewDecoder(s, nil)
- if err != nil {
- w.result <- err
- return
- }
-
- checksum, err := d.Decode()
- if err != nil {
- w.result <- err
- return
- }
-
- w.checksum = checksum
- w.index.PackfileChecksum = checksum
- w.index.Version = idxfile.VersionSupported
-
- offsets := d.Offsets()
- for h, crc := range d.CRCs() {
- w.index.Add(h, uint64(offsets[h]), crc)
- }
-
- w.result <- err
-}
-
-// waitBuildIndex waits until buildIndex function finishes, this can terminate
-// with a packfile.ErrEmptyPackfile, this means that nothing was written so we
-// ignore the error
-func (w *PackWriter) waitBuildIndex() error {
- err := <-w.result
- if err == packfile.ErrEmptyPackfile {
- return nil
- }
-
- return err
-}
-
-func (w *PackWriter) Write(p []byte) (int, error) {
- return w.synced.Write(p)
-}
-
-// Close closes all the file descriptors and save the final packfile, if nothing
-// was written, the tempfiles are deleted without writing a packfile.
-func (w *PackWriter) Close() error {
- defer func() {
- if w.Notify != nil {
- w.Notify(w.checksum, w.index)
- }
-
- close(w.result)
- }()
-
- if err := w.synced.Close(); err != nil {
- return err
- }
-
- if err := w.waitBuildIndex(); err != nil {
- return err
- }
-
- if err := w.fr.Close(); err != nil {
- return err
- }
-
- if err := w.fw.Close(); err != nil {
- return err
- }
-
- if len(w.index.Entries) == 0 {
- return w.clean()
- }
-
- return w.save()
-}
-
-func (w *PackWriter) clean() error {
- return w.fs.Remove(w.fw.Filename())
-}
-
-func (w *PackWriter) save() error {
- base := w.fs.Join(objectsPath, packPath, fmt.Sprintf("pack-%s", w.checksum))
- idx, err := w.fs.Create(fmt.Sprintf("%s.idx", base))
- if err != nil {
- return err
- }
-
- if err := w.encodeIdx(idx); err != nil {
- return err
- }
-
- if err := idx.Close(); err != nil {
- return err
- }
-
- return w.fs.Rename(w.fw.Filename(), fmt.Sprintf("%s.pack", base))
-}
-
-func (w *PackWriter) encodeIdx(writer io.Writer) error {
- e := idxfile.NewEncoder(writer)
- _, err := e.Encode(&w.index)
- return err
-}
-
-type syncedReader struct {
- w io.Writer
- r io.ReadSeeker
-
- blocked, done uint32
- written, read uint64
- news chan bool
-}
-
-func newSyncedReader(w io.Writer, r io.ReadSeeker) *syncedReader {
- return &syncedReader{
- w: w,
- r: r,
- news: make(chan bool),
- }
-}
-
-func (s *syncedReader) Write(p []byte) (n int, err error) {
- defer func() {
- written := atomic.AddUint64(&s.written, uint64(n))
- read := atomic.LoadUint64(&s.read)
- if written > read {
- s.wake()
- }
- }()
-
- n, err = s.w.Write(p)
- return
-}
-
-func (s *syncedReader) Read(p []byte) (n int, err error) {
- defer func() { atomic.AddUint64(&s.read, uint64(n)) }()
-
- s.sleep()
- n, err = s.r.Read(p)
- if err == io.EOF && !s.isDone() {
- if n == 0 {
- return s.Read(p)
- }
-
- return n, nil
- }
-
- return
-}
-
-func (s *syncedReader) isDone() bool {
- return atomic.LoadUint32(&s.done) == 1
-}
-
-func (s *syncedReader) isBlocked() bool {
- return atomic.LoadUint32(&s.blocked) == 1
-}
-
-func (s *syncedReader) wake() {
- if s.isBlocked() {
- // fmt.Println("wake")
- atomic.StoreUint32(&s.blocked, 0)
- s.news <- true
- }
-}
-
-func (s *syncedReader) sleep() {
- read := atomic.LoadUint64(&s.read)
- written := atomic.LoadUint64(&s.written)
- if read >= written {
- atomic.StoreUint32(&s.blocked, 1)
- // fmt.Println("sleep", read, written)
- <-s.news
- }
-
-}
-
-func (s *syncedReader) Seek(offset int64, whence int) (int64, error) {
- if whence == io.SeekCurrent {
- return s.r.Seek(offset, whence)
- }
-
- p, err := s.r.Seek(offset, whence)
- s.read = uint64(p)
-
- return p, err
-}
-
-func (s *syncedReader) Close() error {
- atomic.StoreUint32(&s.done, 1)
- close(s.news)
- return nil
-}
-
-type ObjectWriter struct {
- objfile.Writer
- fs billy.Filesystem
- f billy.File
-}
-
-func newObjectWriter(fs billy.Filesystem) (*ObjectWriter, error) {
- f, err := fs.TempFile(fs.Join(objectsPath, packPath), "tmp_obj_")
- if err != nil {
- return nil, err
- }
-
- return &ObjectWriter{
- Writer: (*objfile.NewWriter(f)),
- fs: fs,
- f: f,
- }, nil
-}
-
-func (w *ObjectWriter) Close() error {
- if err := w.Writer.Close(); err != nil {
- return err
- }
-
- if err := w.f.Close(); err != nil {
- return err
- }
-
- return w.save()
-}
-
-func (w *ObjectWriter) save() error {
- hash := w.Hash().String()
- file := w.fs.Join(objectsPath, hash[0:2], hash[2:40])
-
- return w.fs.Rename(w.f.Filename(), file)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/module.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/module.go
deleted file mode 100644
index 2e469d375caa9f84a86e6c20b291996b9650aad9..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/module.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package filesystem
-
-import (
- "gopkg.in/src-d/go-git.v4/storage"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-)
-
-type ModuleStorage struct {
- dir *dotgit.DotGit
-}
-
-func (s *ModuleStorage) Module(name string) (storage.Storer, error) {
- return NewStorage(s.dir.Module(name))
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/object.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/object.go
deleted file mode 100644
index 1518256a7bd0ae9b67a8b07be29fb01ec4345b75..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/object.go
+++ /dev/null
@@ -1,378 +0,0 @@
-package filesystem
-
-import (
- "io"
- "os"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/idxfile"
- "gopkg.in/src-d/go-git.v4/plumbing/format/objfile"
- "gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
- "gopkg.in/src-d/go-git.v4/storage/memory"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-type ObjectStorage struct {
- dir *dotgit.DotGit
- index map[plumbing.Hash]idx
-}
-
-func newObjectStorage(dir *dotgit.DotGit) (ObjectStorage, error) {
- s := ObjectStorage{
- dir: dir,
- index: make(map[plumbing.Hash]idx, 0),
- }
-
- return s, s.loadIdxFiles()
-}
-
-func (s *ObjectStorage) loadIdxFiles() error {
- packs, err := s.dir.ObjectPacks()
- if err != nil {
- return err
- }
-
- for _, h := range packs {
- if err := s.loadIdxFile(h); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (s *ObjectStorage) loadIdxFile(h plumbing.Hash) error {
- idxfile, err := s.dir.ObjectPackIdx(h)
- if err != nil {
- return err
- }
-
- s.index[h] = make(idx)
- return s.index[h].Decode(idxfile)
-}
-
-func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
- return &plumbing.MemoryObject{}
-}
-
-func (s *ObjectStorage) PackfileWriter() (io.WriteCloser, error) {
- w, err := s.dir.NewObjectPack()
- if err != nil {
- return nil, err
- }
-
- w.Notify = func(h plumbing.Hash, idxfile idxfile.Idxfile) {
- s.index[h] = make(idx)
- for _, e := range idxfile.Entries {
- s.index[h][e.Hash] = int64(e.Offset)
- }
- }
-
- return w, nil
-}
-
-// SetEncodedObject adds a new object to the storage.
-func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (plumbing.Hash, error) {
- if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
- return plumbing.ZeroHash, plumbing.ErrInvalidType
- }
-
- ow, err := s.dir.NewObject()
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- defer ow.Close()
-
- or, err := o.Reader()
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- defer or.Close()
-
- if err := ow.WriteHeader(o.Type(), o.Size()); err != nil {
- return plumbing.ZeroHash, err
- }
-
- if _, err := io.Copy(ow, or); err != nil {
- return plumbing.ZeroHash, err
- }
-
- return o.Hash(), nil
-}
-
-// EncodedObject returns the object with the given hash, by searching for it in
-// the packfile and the git object directories.
-func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
- obj, err := s.getFromUnpacked(h)
- if err == plumbing.ErrObjectNotFound {
- obj, err = s.getFromPackfile(h)
- }
-
- if err != nil {
- return nil, err
- }
-
- if plumbing.AnyObject != t && obj.Type() != t {
- return nil, plumbing.ErrObjectNotFound
- }
-
- return obj, nil
-}
-
-func (s *ObjectStorage) getFromUnpacked(h plumbing.Hash) (obj plumbing.EncodedObject, err error) {
- f, err := s.dir.Object(h)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, plumbing.ErrObjectNotFound
- }
-
- return nil, err
- }
-
- defer f.Close()
-
- obj = s.NewEncodedObject()
- r, err := objfile.NewReader(f)
- if err != nil {
- return nil, err
- }
-
- defer r.Close()
-
- t, size, err := r.Header()
- if err != nil {
- return nil, err
- }
-
- obj.SetType(t)
- obj.SetSize(size)
- w, err := obj.Writer()
- if err != nil {
- return nil, err
- }
-
- _, err = io.Copy(w, r)
- return obj, err
-}
-
-// Get returns the object with the given hash, by searching for it in
-// the packfile.
-func (s *ObjectStorage) getFromPackfile(h plumbing.Hash) (plumbing.EncodedObject, error) {
- pack, offset := s.findObjectInPackfile(h)
- if offset == -1 {
- return nil, plumbing.ErrObjectNotFound
- }
-
- f, err := s.dir.ObjectPack(pack)
- if err != nil {
- return nil, err
- }
-
- defer f.Close()
-
- p := packfile.NewScanner(f)
- d, err := packfile.NewDecoder(p, memory.NewStorage())
- if err != nil {
- return nil, err
- }
-
- d.SetOffsets(s.index[pack])
- return d.DecodeObjectAt(offset)
-}
-
-func (s *ObjectStorage) findObjectInPackfile(h plumbing.Hash) (plumbing.Hash, int64) {
- for packfile, index := range s.index {
- if offset, ok := index[h]; ok {
- return packfile, offset
- }
- }
-
- return plumbing.ZeroHash, -1
-}
-
-// IterEncodedObjects returns an iterator for all the objects in the packfile
-// with the given type.
-func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
- objects, err := s.dir.Objects()
- if err != nil {
- return nil, err
- }
-
- seen := make(map[plumbing.Hash]bool, 0)
- var iters []storer.EncodedObjectIter
- if len(objects) != 0 {
- iters = append(iters, &objectsIter{s: s, t: t, h: objects})
- seen = hashListAsMap(objects)
- }
-
- packi, err := s.buildPackfileIters(t, seen)
- if err != nil {
- return nil, err
- }
-
- iters = append(iters, packi...)
- return storer.NewMultiEncodedObjectIter(iters), nil
-}
-
-func (s *ObjectStorage) buildPackfileIters(
- t plumbing.ObjectType, seen map[plumbing.Hash]bool) ([]storer.EncodedObjectIter, error) {
- packs, err := s.dir.ObjectPacks()
- if err != nil {
- return nil, err
- }
-
- var iters []storer.EncodedObjectIter
- for _, h := range packs {
- pack, err := s.dir.ObjectPack(h)
- if err != nil {
- return nil, err
- }
-
- iter, err := newPackfileIter(pack, t, seen, s.index[h])
- if err != nil {
- return nil, err
- }
-
- iters = append(iters, iter)
- }
-
- return iters, nil
-}
-
-type idx map[plumbing.Hash]int64
-
-func (i idx) Decode(r io.Reader) error {
- idx := &idxfile.Idxfile{}
-
- d := idxfile.NewDecoder(r)
- if err := d.Decode(idx); err != nil {
- return err
- }
-
- for _, e := range idx.Entries {
- i[e.Hash] = int64(e.Offset)
- }
-
- return nil
-}
-
-type packfileIter struct {
- f billy.File
- d *packfile.Decoder
- t plumbing.ObjectType
-
- seen map[plumbing.Hash]bool
- position uint32
- total uint32
-}
-
-func NewPackfileIter(f billy.File, t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
- return newPackfileIter(f, t, make(map[plumbing.Hash]bool), nil)
-}
-
-func newPackfileIter(f billy.File, t plumbing.ObjectType, seen map[plumbing.Hash]bool,
- index idx) (storer.EncodedObjectIter, error) {
- s := packfile.NewScanner(f)
- _, total, err := s.Header()
- if err != nil {
- return nil, err
- }
-
- d, err := packfile.NewDecoderForType(s, memory.NewStorage(), t)
- if err != nil {
- return nil, err
- }
-
- d.SetOffsets(index)
-
- return &packfileIter{
- f: f,
- d: d,
- t: t,
-
- total: total,
- seen: seen,
- }, nil
-}
-
-func (iter *packfileIter) Next() (plumbing.EncodedObject, error) {
- for {
- if iter.position >= iter.total {
- return nil, io.EOF
- }
-
- obj, err := iter.d.DecodeObject()
- if err != nil {
- return nil, err
- }
-
- iter.position++
- if obj == nil {
- continue
- }
-
- if iter.seen[obj.Hash()] {
- return iter.Next()
- }
-
- return obj, nil
- }
-}
-
-// ForEach is never called since is used inside of a MultiObjectIterator
-func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error {
- return nil
-}
-
-func (iter *packfileIter) Close() {
- iter.f.Close()
- iter.d.Close()
-}
-
-type objectsIter struct {
- s *ObjectStorage
- t plumbing.ObjectType
- h []plumbing.Hash
-}
-
-func (iter *objectsIter) Next() (plumbing.EncodedObject, error) {
- if len(iter.h) == 0 {
- return nil, io.EOF
- }
-
- obj, err := iter.s.getFromUnpacked(iter.h[0])
- iter.h = iter.h[1:]
-
- if err != nil {
- return nil, err
- }
-
- if iter.t != plumbing.AnyObject && iter.t != obj.Type() {
- return iter.Next()
- }
-
- return obj, err
-}
-
-// ForEach is never called since is used inside of a MultiObjectIterator
-func (iter *objectsIter) ForEach(cb func(plumbing.EncodedObject) error) error {
- return nil
-}
-
-func (iter *objectsIter) Close() {
- iter.h = []plumbing.Hash{}
-}
-
-func hashListAsMap(l []plumbing.Hash) map[plumbing.Hash]bool {
- m := make(map[plumbing.Hash]bool, len(l))
- for _, h := range l {
- m[h] = true
- }
-
- return m
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/reference.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/reference.go
deleted file mode 100644
index 49627d3540014df2f780f7ae62f3a7f6acda7348..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/reference.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package filesystem
-
-import (
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-)
-
-type ReferenceStorage struct {
- dir *dotgit.DotGit
-}
-
-func (r *ReferenceStorage) SetReference(ref *plumbing.Reference) error {
- return r.dir.SetRef(ref)
-}
-
-func (r *ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
- return r.dir.Ref(n)
-}
-
-func (r *ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
- refs, err := r.dir.Refs()
- if err != nil {
- return nil, err
- }
-
- return storer.NewReferenceSliceIter(refs), nil
-}
-
-func (r *ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
- return r.dir.RemoveRef(n)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/shallow.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/shallow.go
deleted file mode 100644
index ec8d20e89e72d8cd0b0cd0681f715032d6bb2bdf..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/shallow.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package filesystem
-
-import (
- "bufio"
- "fmt"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-)
-
-// ShallowStorage where the shallow commits are stored, an internal to
-// manipulate the shallow file
-type ShallowStorage struct {
- dir *dotgit.DotGit
-}
-
-// SetShallow save the shallows in the shallow file in the .git folder as one
-// commit per line represented by 40-byte hexadecimal object terminated by a
-// newline.
-func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
- f, err := s.dir.ShallowWriter()
- if err != nil {
- return err
- }
-
- defer f.Close()
- for _, h := range commits {
- if _, err := fmt.Fprintf(f, "%s\n", h); err != err {
- return err
- }
- }
-
- return nil
-}
-
-// Shallow return the shallow commits reading from shallo file from .git
-func (s *ShallowStorage) Shallow() ([]plumbing.Hash, error) {
- f, err := s.dir.Shallow()
- if err != nil {
- return nil, err
- }
-
- var hash []plumbing.Hash
-
- scn := bufio.NewScanner(f)
- for scn.Scan() {
- hash = append(hash, plumbing.NewHash(scn.Text()))
- }
-
- return hash, scn.Err()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/storage.go b/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/storage.go
deleted file mode 100644
index 6d58006b21be26f169782ffc2b8f7964da5581f2..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/filesystem/storage.go
+++ /dev/null
@@ -1,47 +0,0 @@
-// Package filesystem is a storage backend base on filesystems
-package filesystem
-
-import (
- "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-// Storage is an implementation of git.Storer that stores data on disk in the
-// standard git format (this is, the .git directory). Zero values of this type
-// are not safe to use, see the NewStorage function below.
-type Storage struct {
- fs billy.Filesystem
-
- ObjectStorage
- ReferenceStorage
- IndexStorage
- ShallowStorage
- ConfigStorage
- ModuleStorage
-}
-
-// NewStorage returns a new Storage backed by a given `fs.Filesystem`
-func NewStorage(fs billy.Filesystem) (*Storage, error) {
- dir := dotgit.New(fs)
- o, err := newObjectStorage(dir)
- if err != nil {
- return nil, err
- }
-
- return &Storage{
- fs: fs,
-
- ObjectStorage: o,
- ReferenceStorage: ReferenceStorage{dir: dir},
- IndexStorage: IndexStorage{dir: dir},
- ShallowStorage: ShallowStorage{dir: dir},
- ConfigStorage: ConfigStorage{dir: dir},
- ModuleStorage: ModuleStorage{dir: dir},
- }, nil
-}
-
-// Filesystem returns the underlying filesystem
-func (s *Storage) Filesystem() billy.Filesystem {
- return s.fs
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/memory/storage.go b/vendor/gopkg.in/src-d/go-git.v4/storage/memory/storage.go
deleted file mode 100644
index 2380fedbe07cd98484052c7fb1e1a18490f33180..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/memory/storage.go
+++ /dev/null
@@ -1,250 +0,0 @@
-// Package memory is a storage backend base on memory
-package memory
-
-import (
- "fmt"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/format/index"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
- "gopkg.in/src-d/go-git.v4/storage"
-)
-
-var ErrUnsupportedObjectType = fmt.Errorf("unsupported object type")
-
-// Storage is an implementation of git.Storer that stores data on memory, being
-// ephemeral. The use of this storage should be done in controlled envoriments,
-// since the representation in memory of some repository can fill the machine
-// memory. in the other hand this storage has the best performance.
-type Storage struct {
- ConfigStorage
- ObjectStorage
- ShallowStorage
- IndexStorage
- ReferenceStorage
- ModuleStorage
-}
-
-// NewStorage returns a new Storage base on memory
-func NewStorage() *Storage {
- return &Storage{
- ReferenceStorage: make(ReferenceStorage, 0),
- ConfigStorage: ConfigStorage{},
- ShallowStorage: ShallowStorage{},
- ObjectStorage: ObjectStorage{
- Objects: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- Commits: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- Trees: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- Blobs: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- Tags: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- },
- ModuleStorage: make(ModuleStorage, 0),
- }
-}
-
-type ConfigStorage struct {
- config *config.Config
-}
-
-func (c *ConfigStorage) SetConfig(cfg *config.Config) error {
- if err := cfg.Validate(); err != nil {
- return err
- }
-
- c.config = cfg
- return nil
-}
-
-func (c *ConfigStorage) Config() (*config.Config, error) {
- if c.config == nil {
- c.config = config.NewConfig()
- }
-
- return c.config, nil
-}
-
-type IndexStorage struct {
- index *index.Index
-}
-
-func (c *IndexStorage) SetIndex(idx *index.Index) error {
- c.index = idx
- return nil
-}
-
-func (c *IndexStorage) Index() (*index.Index, error) {
- if c.index == nil {
- c.index = &index.Index{Version: 2}
- }
-
- return c.index, nil
-}
-
-type ObjectStorage struct {
- Objects map[plumbing.Hash]plumbing.EncodedObject
- Commits map[plumbing.Hash]plumbing.EncodedObject
- Trees map[plumbing.Hash]plumbing.EncodedObject
- Blobs map[plumbing.Hash]plumbing.EncodedObject
- Tags map[plumbing.Hash]plumbing.EncodedObject
-}
-
-func (o *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
- return &plumbing.MemoryObject{}
-}
-
-func (o *ObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
- h := obj.Hash()
- o.Objects[h] = obj
-
- switch obj.Type() {
- case plumbing.CommitObject:
- o.Commits[h] = o.Objects[h]
- case plumbing.TreeObject:
- o.Trees[h] = o.Objects[h]
- case plumbing.BlobObject:
- o.Blobs[h] = o.Objects[h]
- case plumbing.TagObject:
- o.Tags[h] = o.Objects[h]
- default:
- return h, ErrUnsupportedObjectType
- }
-
- return h, nil
-}
-
-func (o *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
- obj, ok := o.Objects[h]
- if !ok || (plumbing.AnyObject != t && obj.Type() != t) {
- return nil, plumbing.ErrObjectNotFound
- }
-
- return obj, nil
-}
-
-func (o *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
- var series []plumbing.EncodedObject
- switch t {
- case plumbing.AnyObject:
- series = flattenObjectMap(o.Objects)
- case plumbing.CommitObject:
- series = flattenObjectMap(o.Commits)
- case plumbing.TreeObject:
- series = flattenObjectMap(o.Trees)
- case plumbing.BlobObject:
- series = flattenObjectMap(o.Blobs)
- case plumbing.TagObject:
- series = flattenObjectMap(o.Tags)
- }
-
- return storer.NewEncodedObjectSliceIter(series), nil
-}
-
-func flattenObjectMap(m map[plumbing.Hash]plumbing.EncodedObject) []plumbing.EncodedObject {
- objects := make([]plumbing.EncodedObject, 0, len(m))
- for _, obj := range m {
- objects = append(objects, obj)
- }
- return objects
-}
-
-func (o *ObjectStorage) Begin() storer.Transaction {
- return &TxObjectStorage{
- Storage: o,
- Objects: make(map[plumbing.Hash]plumbing.EncodedObject, 0),
- }
-}
-
-type TxObjectStorage struct {
- Storage *ObjectStorage
- Objects map[plumbing.Hash]plumbing.EncodedObject
-}
-
-func (tx *TxObjectStorage) SetEncodedObject(obj plumbing.EncodedObject) (plumbing.Hash, error) {
- h := obj.Hash()
- tx.Objects[h] = obj
-
- return h, nil
-}
-
-func (tx *TxObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
- obj, ok := tx.Objects[h]
- if !ok || (plumbing.AnyObject != t && obj.Type() != t) {
- return nil, plumbing.ErrObjectNotFound
- }
-
- return obj, nil
-}
-
-func (tx *TxObjectStorage) Commit() error {
- for h, obj := range tx.Objects {
- delete(tx.Objects, h)
- if _, err := tx.Storage.SetEncodedObject(obj); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (tx *TxObjectStorage) Rollback() error {
- tx.Objects = make(map[plumbing.Hash]plumbing.EncodedObject, 0)
- return nil
-}
-
-type ReferenceStorage map[plumbing.ReferenceName]*plumbing.Reference
-
-func (r ReferenceStorage) SetReference(ref *plumbing.Reference) error {
- if ref != nil {
- r[ref.Name()] = ref
- }
-
- return nil
-}
-
-func (r ReferenceStorage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
- ref, ok := r[n]
- if !ok {
- return nil, plumbing.ErrReferenceNotFound
- }
-
- return ref, nil
-}
-
-func (r ReferenceStorage) IterReferences() (storer.ReferenceIter, error) {
- var refs []*plumbing.Reference
- for _, ref := range r {
- refs = append(refs, ref)
- }
-
- return storer.NewReferenceSliceIter(refs), nil
-}
-
-func (r ReferenceStorage) RemoveReference(n plumbing.ReferenceName) error {
- delete(r, n)
- return nil
-}
-
-type ShallowStorage []plumbing.Hash
-
-func (s *ShallowStorage) SetShallow(commits []plumbing.Hash) error {
- *s = commits
- return nil
-}
-
-func (s ShallowStorage) Shallow() ([]plumbing.Hash, error) {
- return s, nil
-}
-
-type ModuleStorage map[string]*Storage
-
-func (s ModuleStorage) Module(name string) (storage.Storer, error) {
- if m, ok := s[name]; ok {
- return m, nil
- }
-
- m := NewStorage()
- s[name] = m
-
- return m, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/storage/storer.go b/vendor/gopkg.in/src-d/go-git.v4/storage/storer.go
deleted file mode 100644
index 50bfd55c81084da599da33676c03764f9d516337..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/storage/storer.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package storage
-
-import (
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing/storer"
-)
-
-// Storer is a generic storage of objects, references and any information
-// related to a particular repository. The package gopkg.in/src-d/go-git.v4/storage
-// contains two implementation a filesystem base implementation (such as `.git`)
-// and a memory implementations being ephemeral
-type Storer interface {
- storer.EncodedObjectStorer
- storer.ReferenceStorer
- storer.ShallowStorer
- storer.IndexStorer
- config.ConfigStorer
- ModuleStorer
-}
-
-// ModuleStorer allows interact with the modules' Storers
-type ModuleStorer interface {
- // Module returns a Storer reprensting a submodule, if not exists returns a
- // new empty Storer is returned
- Module(name string) (Storer, error)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/submodule.go b/vendor/gopkg.in/src-d/go-git.v4/submodule.go
deleted file mode 100644
index 69c5d75c852ae6d74f6b7e56f5d69d3f4a8f45cf..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/submodule.go
+++ /dev/null
@@ -1,174 +0,0 @@
-package git
-
-import (
- "errors"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-var (
- ErrSubmoduleAlreadyInitialized = errors.New("submodule already initialized")
- ErrSubmoduleNotInitialized = errors.New("submodule not initialized")
-)
-
-// Submodule a submodule allows you to keep another Git repository in a
-// subdirectory of your repository.
-type Submodule struct {
- initialized bool
-
- c *config.Submodule
- w *Worktree
-}
-
-// Config returns the submodule config
-func (s *Submodule) Config() *config.Submodule {
- return s.c
-}
-
-// Init initialize the submodule reading the recoreded Entry in the index for
-// the given submodule
-func (s *Submodule) Init() error {
- cfg, err := s.w.r.Storer.Config()
- if err != nil {
- return err
- }
-
- _, ok := cfg.Submodules[s.c.Name]
- if ok {
- return ErrSubmoduleAlreadyInitialized
- }
-
- s.initialized = true
-
- cfg.Submodules[s.c.Name] = s.c
- return s.w.r.Storer.SetConfig(cfg)
-}
-
-// Repository returns the Repository represented by this submodule
-func (s *Submodule) Repository() (*Repository, error) {
- storer, err := s.w.r.Storer.Module(s.c.Name)
- if err != nil {
- return nil, err
- }
-
- _, err = storer.Reference(plumbing.HEAD)
- if err != nil && err != plumbing.ErrReferenceNotFound {
- return nil, err
- }
-
- worktree := s.w.fs.Dir(s.c.Path)
- if err == nil {
- return Open(storer, worktree)
- }
-
- r, err := Init(storer, worktree)
- if err != nil {
- return nil, err
- }
-
- _, err = r.CreateRemote(&config.RemoteConfig{
- Name: DefaultRemoteName,
- URL: s.c.URL,
- })
-
- return r, err
-}
-
-// Update the registered submodule to match what the superproject expects, the
-// submodule should be initilized first calling the Init method or setting in
-// the options SubmoduleUpdateOptions.Init equals true
-func (s *Submodule) Update(o *SubmoduleUpdateOptions) error {
- if !s.initialized && !o.Init {
- return ErrSubmoduleNotInitialized
- }
-
- if !s.initialized && o.Init {
- if err := s.Init(); err != nil {
- return err
- }
- }
-
- e, err := s.w.readIndexEntry(s.c.Path)
- if err != nil {
- return err
- }
-
- r, err := s.Repository()
- if err != nil {
- return err
- }
-
- if err := s.fetchAndCheckout(r, o, e.Hash); err != nil {
- return err
- }
-
- return s.doRecrusiveUpdate(r, o)
-}
-
-func (s *Submodule) doRecrusiveUpdate(r *Repository, o *SubmoduleUpdateOptions) error {
- if o.RecurseSubmodules == NoRecurseSubmodules {
- return nil
- }
-
- w, err := r.Worktree()
- if err != nil {
- return err
- }
-
- l, err := w.Submodules()
- if err != nil {
- return err
- }
-
- new := &SubmoduleUpdateOptions{}
- *new = *o
- new.RecurseSubmodules--
- return l.Update(new)
-}
-
-func (s *Submodule) fetchAndCheckout(r *Repository, o *SubmoduleUpdateOptions, hash plumbing.Hash) error {
- if !o.NoFetch {
- err := r.Fetch(&FetchOptions{})
- if err != nil && err != NoErrAlreadyUpToDate {
- return err
- }
- }
-
- w, err := r.Worktree()
- if err != nil {
- return err
- }
-
- if err := w.Checkout(hash); err != nil {
- return err
- }
-
- head := plumbing.NewHashReference(plumbing.HEAD, hash)
- return r.Storer.SetReference(head)
-}
-
-// Submodules list of several submodules from the same repository
-type Submodules []*Submodule
-
-// Init initializes the submodules in this list
-func (s Submodules) Init() error {
- for _, sub := range s {
- if err := sub.Init(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// Update updates all the submodules in this list
-func (s Submodules) Update(o *SubmoduleUpdateOptions) error {
- for _, sub := range s {
- if err := sub.Update(o); err != nil {
- return err
- }
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/binary/read.go b/vendor/gopkg.in/src-d/go-git.v4/utils/binary/read.go
deleted file mode 100644
index 0bcf11a6d3934ac15e2a4aae6c1bfc187cce6519..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/binary/read.go
+++ /dev/null
@@ -1,124 +0,0 @@
-// Package binary implements sintax-sugar functions on top of the standard
-// library binary package
-package binary
-
-import (
- "encoding/binary"
- "io"
-
- "gopkg.in/src-d/go-git.v4/plumbing"
-)
-
-// Read reads structured binary data from r into data. Bytes are read and
-// decoded in BigEndian order
-// https://golang.org/pkg/encoding/binary/#Read
-func Read(r io.Reader, data ...interface{}) error {
- for _, v := range data {
- if err := binary.Read(r, binary.BigEndian, v); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-// ReadUntil reads from r untin delim is found
-func ReadUntil(r io.Reader, delim byte) ([]byte, error) {
- var buf [1]byte
- value := make([]byte, 0, 16)
- for {
- if _, err := io.ReadFull(r, buf[:]); err != nil {
- if err == io.EOF {
- return nil, err
- }
-
- return nil, err
- }
-
- if buf[0] == delim {
- return value, nil
- }
-
- value = append(value, buf[0])
- }
-}
-
-// ReadVariableWidthInt reads and returns an int in Git VLQ special format:
-//
-// Ordinary VLQ has some redundancies, example: the number 358 can be
-// encoded as the 2-octet VLQ 0x8166 or the 3-octet VLQ 0x808166 or the
-// 4-octet VLQ 0x80808166 and so forth.
-//
-// To avoid these redundancies, the VLQ format used in Git removes this
-// prepending redundancy and extends the representable range of shorter
-// VLQs by adding an offset to VLQs of 2 or more octets in such a way
-// that the lowest possible value for such an (N+1)-octet VLQ becomes
-// exactly one more than the maximum possible value for an N-octet VLQ.
-// In particular, since a 1-octet VLQ can store a maximum value of 127,
-// the minimum 2-octet VLQ (0x8000) is assigned the value 128 instead of
-// 0. Conversely, the maximum value of such a 2-octet VLQ (0xff7f) is
-// 16511 instead of just 16383. Similarly, the minimum 3-octet VLQ
-// (0x808000) has a value of 16512 instead of zero, which means
-// that the maximum 3-octet VLQ (0xffff7f) is 2113663 instead of
-// just 2097151. And so forth.
-//
-// This is how the offset is saved in C:
-//
-// dheader[pos] = ofs & 127;
-// while (ofs >>= 7)
-// dheader[--pos] = 128 | (--ofs & 127);
-//
-func ReadVariableWidthInt(r io.Reader) (int64, error) {
- var c byte
- if err := Read(r, &c); err != nil {
- return 0, err
- }
-
- var v = int64(c & maskLength)
- for c&maskContinue > 0 {
- v++
- if err := Read(r, &c); err != nil {
- return 0, err
- }
-
- v = (v << lengthBits) + int64(c&maskLength)
- }
-
- return v, nil
-}
-
-const (
- maskContinue = uint8(128) // 1000 000
- maskLength = uint8(127) // 0111 1111
- lengthBits = uint8(7) // subsequent bytes has 7 bits to store the length
-)
-
-// ReadUint32 reads 4 bytes and returns them as a Big ndian uint32
-func ReadUint32(r io.Reader) (uint32, error) {
- var v uint32
- if err := binary.Read(r, binary.BigEndian, &v); err != nil {
- return 0, err
- }
-
- return v, nil
-}
-
-// ReadUint16 reads 2 bytes and returns them as a BigEndian uint16
-func ReadUint16(r io.Reader) (uint16, error) {
- var v uint16
- if err := binary.Read(r, binary.BigEndian, &v); err != nil {
- return 0, err
- }
-
- return v, nil
-}
-
-// ReadHash reads a plumbing.Hash from r
-func ReadHash(r io.Reader) (plumbing.Hash, error) {
- var h plumbing.Hash
- if err := binary.Read(r, binary.BigEndian, h[:]); err != nil {
- return plumbing.ZeroHash, err
- }
-
- return h, nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/binary/write.go b/vendor/gopkg.in/src-d/go-git.v4/utils/binary/write.go
deleted file mode 100644
index 2ec358134642e9018375ecb24ebbcbb66029a5be..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/binary/write.go
+++ /dev/null
@@ -1,44 +0,0 @@
-package binary
-
-import (
- "encoding/binary"
- "io"
-)
-
-// Write writes the binary representation of data into w, using BigEndian order
-// https://golang.org/pkg/encoding/binary/#Write
-func Write(w io.Writer, data ...interface{}) error {
- for _, v := range data {
- if err := binary.Write(w, binary.BigEndian, v); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func WriteVariableWidthInt(w io.Writer, n int64) error {
- buf := []byte{byte(n & 0x7f)}
- n >>= 7
- for n != 0 {
- n--
- buf = append([]byte{0x80 | (byte(n & 0x7f))}, buf...)
- n >>= 7
- }
-
- _, err := w.Write(buf)
-
- return err
-}
-
-// WriteUint32 writes the binary representation of a uint32 into w, in BigEndian
-// order
-func WriteUint32(w io.Writer, value uint32) error {
- return binary.Write(w, binary.BigEndian, value)
-}
-
-// WriteUint16 writes the binary representation of a uint16 into w, in BigEndian
-// order
-func WriteUint16(w io.Writer, value uint16) error {
- return binary.Write(w, binary.BigEndian, value)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/diff/diff.go b/vendor/gopkg.in/src-d/go-git.v4/utils/diff/diff.go
deleted file mode 100644
index b840ad6d75565b881a036d50e2bf814fe22e1701..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/diff/diff.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Package diff implements line oriented diffs, similar to the ancient
-// Unix diff command.
-//
-// The current implementation is just a wrapper around Sergi's
-// go-diff/diffmatchpatch library, which is a go port of Neil
-// Fraser's google-diff-match-patch code
-package diff
-
-import (
- "bytes"
-
- "github.com/sergi/go-diff/diffmatchpatch"
-)
-
-// Do computes the (line oriented) modifications needed to turn the src
-// string into the dst string.
-func Do(src, dst string) (diffs []diffmatchpatch.Diff) {
- dmp := diffmatchpatch.New()
- wSrc, wDst, warray := dmp.DiffLinesToChars(src, dst)
- diffs = dmp.DiffMain(wSrc, wDst, false)
- diffs = dmp.DiffCharsToLines(diffs, warray)
- return diffs
-}
-
-// Dst computes and returns the destination text.
-func Dst(diffs []diffmatchpatch.Diff) string {
- var text bytes.Buffer
- for _, d := range diffs {
- if d.Type != diffmatchpatch.DiffDelete {
- text.WriteString(d.Text)
- }
- }
- return text.String()
-}
-
-// Src computes and returns the source text
-func Src(diffs []diffmatchpatch.Diff) string {
- var text bytes.Buffer
- for _, d := range diffs {
- if d.Type != diffmatchpatch.DiffInsert {
- text.WriteString(d.Text)
- }
- }
- return text.String()
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/ioutil/common.go b/vendor/gopkg.in/src-d/go-git.v4/utils/ioutil/common.go
deleted file mode 100644
index 73cc9c3e76bbcb57a3deabdeccd1b822621e4341..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/ioutil/common.go
+++ /dev/null
@@ -1,74 +0,0 @@
-// Package ioutil implements some I/O utility functions.
-package ioutil
-
-import (
- "bufio"
- "errors"
- "io"
-)
-
-type readPeeker interface {
- io.Reader
- Peek(int) ([]byte, error)
-}
-
-var (
- ErrEmptyReader = errors.New("reader is empty")
-)
-
-// NonEmptyReader takes a reader and returns it if it is not empty, or
-// `ErrEmptyReader` if it is empty. If there is an error when reading the first
-// byte of the given reader, it will be propagated.
-func NonEmptyReader(r io.Reader) (io.Reader, error) {
- pr, ok := r.(readPeeker)
- if !ok {
- pr = bufio.NewReader(r)
- }
-
- _, err := pr.Peek(1)
- if err == io.EOF {
- return nil, ErrEmptyReader
- }
-
- if err != nil {
- return nil, err
- }
-
- return pr, nil
-}
-
-type readCloser struct {
- io.Reader
- closer io.Closer
-}
-
-func (r *readCloser) Close() error {
- return r.closer.Close()
-}
-
-// NewReadCloser creates an `io.ReadCloser` with the given `io.Reader` and
-// `io.Closer`.
-func NewReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
- return &readCloser{Reader: r, closer: c}
-}
-
-type writeNopCloser struct {
- io.Writer
-}
-
-func (writeNopCloser) Close() error { return nil }
-
-// WriteNopCloser returns a WriteCloser with a no-op Close method wrapping
-// the provided Writer w.
-func WriteNopCloser(w io.Writer) io.WriteCloser {
- return writeNopCloser{w}
-}
-
-// CheckClose calls Close on the given io.Closer. If the given *error points to
-// nil, it will be assigned the error returned by Close. Otherwise, any error
-// returned by Close will be ignored. CheckClose is usually called with defer.
-func CheckClose(c io.Closer, err *error) {
- if cerr := c.Close(); cerr != nil && *err == nil {
- *err = cerr
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/change.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/change.go
deleted file mode 100644
index 0b50ca71d3facf2702473eeafb7239b10347c292..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/change.go
+++ /dev/null
@@ -1,149 +0,0 @@
-package merkletrie
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// Action values represent the kind of things a Change can represent:
-// insertion, deletions or modifications of files.
-type Action int
-
-// The set of possible actions in a change.
-const (
- _ Action = iota
- Insert
- Delete
- Modify
-)
-
-// String returns the action as a human readable text.
-func (a Action) String() string {
- switch a {
- case Insert:
- return "Insert"
- case Delete:
- return "Delete"
- case Modify:
- return "Modify"
- default:
- panic(fmt.Sprintf("unsupported action: %d", a))
- }
-}
-
-// A Change value represent how a noder has change between to merkletries.
-type Change struct {
- // The noder before the change or nil if it was inserted.
- From noder.Path
- // The noder after the change or nil if it was deleted.
- To noder.Path
-}
-
-// Action is convenience method that returns what Action c represents.
-func (c *Change) Action() (Action, error) {
- if c.From == nil && c.To == nil {
- return Action(0), fmt.Errorf("malformed change: nil from and to")
- }
- if c.From == nil {
- return Insert, nil
- }
- if c.To == nil {
- return Delete, nil
- }
-
- return Modify, nil
-}
-
-// NewInsert returns a new Change representing the insertion of n.
-func NewInsert(n noder.Path) Change { return Change{To: n} }
-
-// NewDelete returns a new Change representing the deletion of n.
-func NewDelete(n noder.Path) Change { return Change{From: n} }
-
-// NewModify returns a new Change representing that a has been modified and
-// it is now b.
-func NewModify(a, b noder.Path) Change {
- return Change{
- From: a,
- To: b,
- }
-}
-
-// String returns a single change in human readable form, using the
-// format: '<' + action + space + path + '>'. The contents of the file
-// before or after the change are not included in this format.
-//
-// Example: inserting a file at the path a/b/c.txt will return "<Insert
-// a/b/c.txt>".
-func (c Change) String() string {
- action, err := c.Action()
- if err != nil {
- panic(err)
- }
-
- var path string
- if action == Delete {
- path = c.From.String()
- } else {
- path = c.To.String()
- }
-
- return fmt.Sprintf("<%s %s>", action, path)
-}
-
-// Changes is a list of changes between to merkletries.
-type Changes []Change
-
-// NewChanges returns an empty list of changes.
-func NewChanges() Changes {
- return Changes{}
-}
-
-// Add adds the change c to the list of changes.
-func (l *Changes) Add(c Change) {
- *l = append(*l, c)
-}
-
-// AddRecursiveInsert adds the required changes to insert all the
-// file-like noders found in root, recursively.
-func (l *Changes) AddRecursiveInsert(root noder.Path) error {
- return l.addRecursive(root, NewInsert)
-}
-
-// AddRecursiveDelete adds the required changes to delete all the
-// file-like noders found in root, recursively.
-func (l *Changes) AddRecursiveDelete(root noder.Path) error {
- return l.addRecursive(root, NewDelete)
-}
-
-type noderToChangeFn func(noder.Path) Change // NewInsert or NewDelete
-
-func (l *Changes) addRecursive(root noder.Path, ctor noderToChangeFn) error {
- if !root.IsDir() {
- l.Add(ctor(root))
- return nil
- }
-
- i, err := NewIterFromPath(root)
- if err != nil {
- return err
- }
-
- var current noder.Path
- for {
- if current, err = i.Step(); err != nil {
- if err == io.EOF {
- break
- }
- return err
- }
- if current.IsDir() {
- continue
- }
- l.Add(ctor(current))
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/difftree.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/difftree.go
deleted file mode 100644
index 074886554be1bd0cc956789f6a3a510bd2e00f71..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/difftree.go
+++ /dev/null
@@ -1,403 +0,0 @@
-package merkletrie
-
-// The focus of this difftree implementation is to save time by
-// skipping whole directories if their hash is the same in both
-// trees.
-//
-// The diff algorithm implemented here is based on the doubleiter
-// type defined in this same package; we will iterate over both
-// trees at the same time, while comparing the current noders in
-// each iterator. Depending on how they differ we will output the
-// corresponding chages and move the iterators further over both
-// trees.
-//
-// The table bellow show all the possible comparison results, along
-// with what changes should we produce and how to advance the
-// iterators.
-//
-// The table is implemented by the switches in this function,
-// diffTwoNodes, diffTwoNodesSameName and diffTwoDirs.
-//
-// Many Bothans died to bring us this information, make sure you
-// understand the table before modifying this code.
-
-// # Cases
-//
-// When comparing noders in both trees you will found yourself in
-// one of 169 possible cases, but if we ignore moves, we can
-// simplify a lot the search space into the following table:
-//
-// - "-": nothing, no file or directory
-// - a<>: an empty file named "a".
-// - a<1>: a file named "a", with "1" as its contents.
-// - a<2>: a file named "a", with "2" as its contents.
-// - a(): an empty dir named "a".
-// - a(...): a dir named "a", with some files and/or dirs inside (possibly
-// empty).
-// - a(;;;): a dir named "a", with some other files and/or dirs inside
-// (possibly empty), which different from the ones in "a(...)".
-//
-// \ to - a<> a<1> a<2> a() a(...) a(;;;)
-// from \
-// - 00 01 02 03 04 05 06
-// a<> 10 11 12 13 14 15 16
-// a<1> 20 21 22 23 24 25 26
-// a<2> 30 31 32 33 34 35 36
-// a() 40 41 42 43 44 45 46
-// a(...) 50 51 52 53 54 55 56
-// a(;;;) 60 61 62 63 64 65 66
-//
-// Every (from, to) combination in the table is a special case, but
-// some of them can be merged into some more general cases, for
-// instance 11 and 22 can be merged into the general case: both
-// noders are equal.
-//
-// Here is a full list of all the cases that are similar and how to
-// merge them together into more general cases. Each general case
-// is labeled wiht an uppercase letter for further reference, and it
-// is followed by the pseudocode of the checks you have to perfrom
-// on both noders to see if you are in such a case, the actions to
-// perform (i.e. what changes to output) and how to advance the
-// iterators of each tree to continue the comparison process.
-//
-// ## A. Impossible: 00
-//
-// ## B. Same thing on both sides: 11, 22, 33, 44, 55, 66
-// - check: `SameName() && SameHash()`
-// - action: do nothing.
-// - advance: `FromNext(); ToNext()`
-//
-// ### C. To was created: 01, 02, 03, 04, 05, 06
-// - check: `DifferentName() && ToBeforeFrom()`
-// - action: inserRecursively(to)
-// - advance: `ToNext()`
-//
-// ### D. From was deleted: 10, 20, 30, 40, 50, 60
-// - check: `DifferentName() && FromBeforeTo()`
-// - action: `DeleteRecursively(from)`
-// - advance: `FromNext()`
-//
-// ### E. Empty file to file with contents: 12, 13
-// - check: `SameName() && DifferentHash() && FromIsFile() &&
-// ToIsFile() && FromIsEmpty()`
-// - action: `modifyFile(from, to)`
-// - advance: `FromNext()` or `FromStep()`
-//
-// ### E'. file with contents to empty file: 21, 31
-// - check: `SameName() && DifferentHash() && FromIsFile() &&
-// ToIsFile() && ToIsEmpty()`
-// - action: `modifyFile(from, to)`
-// - advance: `FromNext()` or `FromStep()`
-//
-// ### F. empty file to empty dir with the same name: 14
-// - check: `SameName() && FromIsFile() && FromIsEmpty() &&
-// ToIsDir() && ToIsEmpty()`
-// - action: `DeleteFile(from); InsertEmptyDir(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### F'. empty dir to empty file of the same name: 41
-// - check: `SameName() && FromIsDir() && FromIsEmpty &&
-// ToIsFile() && ToIsEmpty()`
-// - action: `DeleteEmptyDir(from); InsertFile(to)`
-// - advance: `FromNext(); ToNext()` or step for any of them.
-//
-// ### G. empty file to non-empty dir of the same name: 15, 16
-// - check: `SameName() && FromIsFile() && ToIsDir() &&
-// FromIsEmpty() && ToIsNotEmpty()`
-// - action: `DeleteFile(from); InsertDirRecursively(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### G'. non-empty dir to empty file of the same name: 51, 61
-// - check: `SameName() && FromIsDir() && FromIsNotEmpty() &&
-// ToIsFile() && FromIsEmpty()`
-// - action: `DeleteDirRecursively(from); InsertFile(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### H. modify file contents: 23, 32
-// - check: `SameName() && FromIsFile() && ToIsFile() &&
-// FromIsNotEmpty() && ToIsNotEmpty()`
-// - action: `ModifyFile(from, to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### I. file with contents to empty dir: 24, 34
-// - check: `SameName() && DifferentHash() && FromIsFile() &&
-// FromIsNotEmpty() && ToIsDir() && ToIsEmpty()`
-// - action: `DeleteFile(from); InsertEmptyDir(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### I'. empty dir to file with contents: 42, 43
-// - check: `SameName() && DifferentHash() && FromIsDir() &&
-// FromIsEmpty() && ToIsFile() && ToIsEmpty()`
-// - action: `DeleteDir(from); InsertFile(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### J. file with contents to dir with contetns: 25, 26, 35, 36
-// - check: `SameName() && DifferentHash() && FromIsFile() &&
-// FromIsNotEmpty() && ToIsDir() && ToIsNotEmpty()`
-// - action: `DeleteFile(from); InsertDirRecursively(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### J'. dir with contetns to file with contents: 52, 62, 53, 63
-// - check: `SameName() && DifferentHash() && FromIsDir() &&
-// FromIsNotEmpty() && ToIsFile() && ToIsNotEmpty()`
-// - action: `DeleteDirRecursively(from); InsertFile(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### K. empty dir to dir with contents: 45, 46
-// - check: `SameName() && DifferentHash() && FromIsDir() &&
-// FromIsEmpty() && ToIsDir() && ToIsNotEmpty()`
-// - action: `InsertChildrenRecursively(to)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### K'. dir with contents to empty dir: 54, 64
-// - check: `SameName() && DifferentHash() && FromIsDir() &&
-// FromIsEmpty() && ToIsDir() && ToIsNotEmpty()`
-// - action: `DeleteChildrenRecursively(from)`
-// - advance: `FromNext(); ToNext()`
-//
-// ### L. dir with contents to dir with different contents: 56, 65
-// - check: `SameName() && DifferentHash() && FromIsDir() &&
-// FromIsNotEmpty() && ToIsDir() && ToIsNotEmpty()`
-// - action: nothing
-// - advance: `FromStep(); ToStep()`
-//
-//
-
-// All these cases can be further simplified by a truth table
-// reduction process, in which we gather similar checks together to
-// make the final code easier to read and understand.
-//
-// The first 6 columns are the outputs of the checks to perform on
-// both noders. I have labeled them 1 to 6, this is what they mean:
-//
-// 1: SameName()
-// 2: SameHash()
-// 3: FromIsDir()
-// 4: ToIsDir()
-// 5: FromIsEmpty()
-// 6: ToIsEmpty()
-//
-// The from and to columns are a fsnoder example of the elements
-// that you will find on each tree under the specified comparison
-// results (columns 1 to 6).
-//
-// The type column identifies the case we are into, from the list above.
-//
-// The type' column identifies the new set of reduced cases, using
-// lowercase letters, and they are explained after the table.
-//
-// The last column is the set of actions and advances for each case.
-//
-// "---" means impossible except in case of hash collision.
-//
-// advance meaning:
-// - NN: from.Next(); to.Next()
-// - SS: from.Step(); to.Step()
-//
-// 1 2 3 4 5 6 | from | to |type|type'|action ; advance
-// ------------+--------+--------+----+------------------------------------
-// 0 0 0 0 0 0 | | | | | if !SameName() {
-// . | | | | | if FromBeforeTo() {
-// . | | | D | d | delete(from); from.Next()
-// . | | | | | } else {
-// . | | | C | c | insert(to); to.Next()
-// . | | | | | }
-// 0 1 1 1 1 1 | | | | | }
-// 1 0 0 0 0 0 | a<1> | a<2> | H | e | modify(from, to); NN
-// 1 0 0 0 0 1 | a<1> | a<> | E' | e | modify(from, to); NN
-// 1 0 0 0 1 0 | a<> | a<1> | E | e | modify(from, to); NN
-// 1 0 0 0 1 1 | ---- | ---- | | e |
-// 1 0 0 1 0 0 | a<1> | a(...) | J | f | delete(from); insert(to); NN
-// 1 0 0 1 0 1 | a<1> | a() | I | f | delete(from); insert(to); NN
-// 1 0 0 1 1 0 | a<> | a(...) | G | f | delete(from); insert(to); NN
-// 1 0 0 1 1 1 | a<> | a() | F | f | delete(from); insert(to); NN
-// 1 0 1 0 0 0 | a(...) | a<1> | J' | f | delete(from); insert(to); NN
-// 1 0 1 0 0 1 | a(...) | a<> | G' | f | delete(from); insert(to); NN
-// 1 0 1 0 1 0 | a() | a<1> | I' | f | delete(from); insert(to); NN
-// 1 0 1 0 1 1 | a() | a<> | F' | f | delete(from); insert(to); NN
-// 1 0 1 1 0 0 | a(...) | a(;;;) | L | g | nothing; SS
-// 1 0 1 1 0 1 | a(...) | a() | K' | h | deleteChidren(from); NN
-// 1 0 1 1 1 0 | a() | a(...) | K | i | insertChildren(to); NN
-// 1 0 1 1 1 1 | ---- | ---- | | |
-// 1 1 0 0 0 0 | a<1> | a<1> | B | b | nothing; NN
-// 1 1 0 0 0 1 | ---- | ---- | | b |
-// 1 1 0 0 1 0 | ---- | ---- | | b |
-// 1 1 0 0 1 1 | a<> | a<> | B | b | nothing; NN
-// 1 1 0 1 0 0 | ---- | ---- | | b |
-// 1 1 0 1 0 1 | ---- | ---- | | b |
-// 1 1 0 1 1 0 | ---- | ---- | | b |
-// 1 1 0 1 1 1 | ---- | ---- | | b |
-// 1 1 1 0 0 0 | ---- | ---- | | b |
-// 1 1 1 0 0 1 | ---- | ---- | | b |
-// 1 1 1 0 1 0 | ---- | ---- | | b |
-// 1 1 1 0 1 1 | ---- | ---- | | b |
-// 1 1 1 1 0 0 | a(...) | a(...) | B | b | nothing; NN
-// 1 1 1 1 0 1 | ---- | ---- | | b |
-// 1 1 1 1 1 0 | ---- | ---- | | b |
-// 1 1 1 1 1 1 | a() | a() | B | b | nothing; NN
-//
-// c and d:
-// if !SameName()
-// d if FromBeforeTo()
-// c else
-// b: SameName) && sameHash()
-// e: SameName() && !sameHash() && BothAreFiles()
-// f: SameName() && !sameHash() && FileAndDir()
-// g: SameName() && !sameHash() && BothAreDirs() && NoneIsEmpty
-// i: SameName() && !sameHash() && BothAreDirs() && FromIsEmpty
-// h: else of i
-
-import (
- "fmt"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// DiffTree calculates the list of changes between two merkletries. It
-// uses the provided hashEqual callback to compare noders.
-func DiffTree(fromTree, toTree noder.Noder,
- hashEqual noder.Equal) (Changes, error) {
- ret := NewChanges()
-
- ii, err := newDoubleIter(fromTree, toTree, hashEqual)
- if err != nil {
- return nil, err
- }
-
- for {
- from := ii.from.current
- to := ii.to.current
-
- switch r := ii.remaining(); r {
- case noMoreNoders:
- return ret, nil
- case onlyFromRemains:
- if err = ret.AddRecursiveDelete(from); err != nil {
- return nil, err
- }
- if err = ii.nextFrom(); err != nil {
- return nil, err
- }
- case onlyToRemains:
- if err = ret.AddRecursiveInsert(to); err != nil {
- return nil, err
- }
- if err = ii.nextTo(); err != nil {
- return nil, err
- }
- case bothHaveNodes:
- if err = diffNodes(&ret, ii); err != nil {
- return nil, err
- }
- default:
- panic(fmt.Sprintf("unknown remaining value: %d", r))
- }
- }
-}
-
-func diffNodes(changes *Changes, ii *doubleIter) error {
- from := ii.from.current
- to := ii.to.current
- var err error
-
- // compare their full paths as strings
- switch from.Compare(to) {
- case -1:
- if err = changes.AddRecursiveDelete(from); err != nil {
- return err
- }
- if err = ii.nextFrom(); err != nil {
- return err
- }
- case 1:
- if err = changes.AddRecursiveInsert(to); err != nil {
- return err
- }
- if err = ii.nextTo(); err != nil {
- return err
- }
- default:
- if err := diffNodesSameName(changes, ii); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func diffNodesSameName(changes *Changes, ii *doubleIter) error {
- from := ii.from.current
- to := ii.to.current
-
- status, err := ii.compare()
- if err != nil {
- return err
- }
-
- switch {
- case status.sameHash:
- // do nothing
- if err = ii.nextBoth(); err != nil {
- return err
- }
- case status.bothAreFiles:
- changes.Add(NewModify(from, to))
- if err = ii.nextBoth(); err != nil {
- return err
- }
- case status.fileAndDir:
- if err = changes.AddRecursiveDelete(from); err != nil {
- return err
- }
- if err = changes.AddRecursiveInsert(to); err != nil {
- return err
- }
- if err = ii.nextBoth(); err != nil {
- return err
- }
- case status.bothAreDirs:
- if err = diffDirs(changes, ii); err != nil {
- return err
- }
- default:
- return fmt.Errorf("bad status from double iterator")
- }
-
- return nil
-}
-
-func diffDirs(changes *Changes, ii *doubleIter) error {
- from := ii.from.current
- to := ii.to.current
-
- status, err := ii.compare()
- if err != nil {
- return err
- }
-
- switch {
- case status.fromIsEmptyDir:
- if err = changes.AddRecursiveInsert(to); err != nil {
- return err
- }
- if err = ii.nextBoth(); err != nil {
- return err
- }
- case status.toIsEmptyDir:
- if err = changes.AddRecursiveDelete(from); err != nil {
- return err
- }
- if err = ii.nextBoth(); err != nil {
- return err
- }
- case !status.fromIsEmptyDir && !status.toIsEmptyDir:
- // do nothing
- if err = ii.stepBoth(); err != nil {
- return err
- }
- default:
- return fmt.Errorf("both dirs are empty but has different hash")
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doc.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doc.go
deleted file mode 100644
index 5204024ad4f996a850c84fcce1095398814a4433..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doc.go
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-Package merkletrie provides support for n-ary trees that are at the same
-time Merkle trees and Radix trees (tries).
-
-Git trees are Radix n-ary trees in virtue of the names of their
-tree entries. At the same time, git trees are Merkle trees thanks to
-their hashes.
-
-This package defines Merkle tries as nodes that should have:
-
-- a hash: the Merkle part of the Merkle trie
-
-- a key: the Radix part of the Merkle trie
-
-The Merkle hash condition is not enforced by this package though. This
-means that the hash of a node doesn't have to take into account the hashes of
-their children, which is good for testing purposes.
-
-Nodes in the Merkle trie are abstracted by the Noder interface. The
-intended use is that git trees implements this interface, either
-directly or using a simple wrapper.
-
-This package provides an iterator for merkletries that can skip whole
-directory-like noders and an efficient merkletrie comparison algorithm.
-
-When comparing git trees, the simple approach of alphabetically sorting
-their elements and comparing the resulting lists is too slow as it
-depends linearly on the number of files in the trees: When a directory
-has lots of files but none of them has been modified, this approach is
-very expensive. We can do better by prunning whole directories that
-have not change, just by looking at their hashes. This package provides
-the tools to do exactly that.
-*/
-package merkletrie
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doubleiter.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doubleiter.go
deleted file mode 100644
index e56dee701f2ae4c7d7a55315c4ea8a05d8620f6a..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/doubleiter.go
+++ /dev/null
@@ -1,187 +0,0 @@
-package merkletrie
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// A doubleIter is a convenience type to keep track of the current
-// noders in two merkletries that are going to be iterated in parallel.
-// It has methods for:
-//
-// - iterating over the merkletries, both at the same time or
-// individually: nextFrom, nextTo, nextBoth, stepBoth
-//
-// - checking if there are noders left in one or both of them with the
-// remaining method and its associated returned type.
-//
-// - comparing the current noders of both merkletries in several ways,
-// with the compare method and its associated returned type.
-type doubleIter struct {
- from struct {
- iter *Iter
- current noder.Path // nil if no more nodes
- }
- to struct {
- iter *Iter
- current noder.Path // nil if no more nodes
- }
- hashEqual noder.Equal
-}
-
-// NewdoubleIter returns a new doubleIter for the merkletries "from" and
-// "to". The hashEqual callback function will be used by the doubleIter
-// to compare the hash of the noders in the merkletries. The doubleIter
-// will be initialized to the first elements in each merkletrie if any.
-func newDoubleIter(from, to noder.Noder, hashEqual noder.Equal) (
- *doubleIter, error) {
- var ii doubleIter
- var err error
-
- if ii.from.iter, err = NewIter(from); err != nil {
- return nil, fmt.Errorf("from: %s", err)
- }
- if ii.from.current, err = ii.from.iter.Next(); turnEOFIntoNil(err) != nil {
- return nil, fmt.Errorf("from: %s", err)
- }
-
- if ii.to.iter, err = NewIter(to); err != nil {
- return nil, fmt.Errorf("to: %s", err)
- }
- if ii.to.current, err = ii.to.iter.Next(); turnEOFIntoNil(err) != nil {
- return nil, fmt.Errorf("to: %s", err)
- }
-
- ii.hashEqual = hashEqual
-
- return &ii, nil
-}
-
-func turnEOFIntoNil(e error) error {
- if e != nil && e != io.EOF {
- return e
- }
- return nil
-}
-
-// NextBoth makes d advance to the next noder in both merkletries. If
-// any of them is a directory, it skips its contents.
-func (d *doubleIter) nextBoth() error {
- if err := d.nextFrom(); err != nil {
- return err
- }
- if err := d.nextTo(); err != nil {
- return err
- }
-
- return nil
-}
-
-// NextFrom makes d advance to the next noder in the "from" merkletrie,
-// skipping its contents if it is a directory.
-func (d *doubleIter) nextFrom() (err error) {
- d.from.current, err = d.from.iter.Next()
- return turnEOFIntoNil(err)
-}
-
-// NextTo makes d advance to the next noder in the "to" merkletrie,
-// skipping its contents if it is a directory.
-func (d *doubleIter) nextTo() (err error) {
- d.to.current, err = d.to.iter.Next()
- return turnEOFIntoNil(err)
-}
-
-// StepBoth makes d advance to the next noder in both merkletries,
-// getting deeper into directories if that is the case.
-func (d *doubleIter) stepBoth() (err error) {
- if d.from.current, err = d.from.iter.Step(); turnEOFIntoNil(err) != nil {
- return err
- }
- if d.to.current, err = d.to.iter.Step(); turnEOFIntoNil(err) != nil {
- return err
- }
- return nil
-}
-
-// Remaining returns if there are no more noders in the tree, if both
-// have noders or if one of them doesn't.
-func (d *doubleIter) remaining() remaining {
- if d.from.current == nil && d.to.current == nil {
- return noMoreNoders
- }
-
- if d.from.current == nil && d.to.current != nil {
- return onlyToRemains
- }
-
- if d.from.current != nil && d.to.current == nil {
- return onlyFromRemains
- }
-
- return bothHaveNodes
-}
-
-// Remaining values tells you whether both trees still have noders, or
-// only one of them or none of them.
-type remaining int
-
-const (
- noMoreNoders remaining = iota
- onlyToRemains
- onlyFromRemains
- bothHaveNodes
-)
-
-// Compare returns the comparison between the current elements in the
-// merkletries.
-func (d *doubleIter) compare() (s comparison, err error) {
- s.sameHash = d.hashEqual(d.from.current, d.to.current)
-
- fromIsDir := d.from.current.IsDir()
- toIsDir := d.to.current.IsDir()
-
- s.bothAreDirs = fromIsDir && toIsDir
- s.bothAreFiles = !fromIsDir && !toIsDir
- s.fileAndDir = !s.bothAreDirs && !s.bothAreFiles
-
- fromNumChildren, err := d.from.current.NumChildren()
- if err != nil {
- return comparison{}, fmt.Errorf("from: %s", err)
- }
-
- toNumChildren, err := d.to.current.NumChildren()
- if err != nil {
- return comparison{}, fmt.Errorf("to: %s", err)
- }
-
- s.fromIsEmptyDir = fromIsDir && fromNumChildren == 0
- s.toIsEmptyDir = toIsDir && toNumChildren == 0
-
- return
-}
-
-// Answers to a lot of questions you can ask about how to noders are
-// equal or different.
-type comparison struct {
- // the following are only valid if both nodes have the same name
- // (i.e. nameComparison == 0)
-
- // Do both nodes have the same hash?
- sameHash bool
- // Are both nodes files?
- bothAreFiles bool
-
- // the following are only valid if any of the noders are dirs,
- // this is, if !bothAreFiles
-
- // Is one a file and the other a dir?
- fileAndDir bool
- // Are both nodes dirs?
- bothAreDirs bool
- // Is the from node an empty dir?
- fromIsEmptyDir bool
- // Is the to Node an empty dir?
- toIsEmptyDir bool
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame/frame.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame/frame.go
deleted file mode 100644
index a0b042ee61d8ca843549d130717ca67ee2eec28b..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame/frame.go
+++ /dev/null
@@ -1,91 +0,0 @@
-package frame
-
-import (
- "bytes"
- "fmt"
- "sort"
- "strings"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// A Frame is a collection of siblings in a trie, sorted alphabetically
-// by name.
-type Frame struct {
- // siblings, sorted in reverse alphabetical order by name
- stack []noder.Noder
-}
-
-type byName []noder.Noder
-
-func (a byName) Len() int { return len(a) }
-func (a byName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a byName) Less(i, j int) bool {
- return strings.Compare(a[i].Name(), a[j].Name()) < 0
-}
-
-// New returns a frame with the children of the provided node.
-func New(n noder.Noder) (*Frame, error) {
- children, err := n.Children()
- if err != nil {
- return nil, err
- }
-
- sort.Sort(sort.Reverse(byName(children)))
- return &Frame{
- stack: children,
- }, nil
-}
-
-// String returns the quoted names of the noders in the frame sorted in
-// alphabeticall order by name, surrounded by square brackets and
-// separated by comas.
-//
-// Examples:
-// []
-// ["a", "b"]
-func (f *Frame) String() string {
- var buf bytes.Buffer
- _ = buf.WriteByte('[')
-
- sep := ""
- for i := f.Len() - 1; i >= 0; i-- {
- _, _ = buf.WriteString(sep)
- sep = ", "
- _, _ = buf.WriteString(fmt.Sprintf("%q", f.stack[i].Name()))
- }
-
- _ = buf.WriteByte(']')
-
- return buf.String()
-}
-
-// First returns, but dont extract, the noder with the alphabetically
-// smaller name in the frame and true if the frame was not empy.
-// Otherwise it returns nil and false.
-func (f *Frame) First() (noder.Noder, bool) {
- if f.Len() == 0 {
- return nil, false
- }
-
- top := f.Len() - 1
-
- return f.stack[top], true
-}
-
-// Drop extracts the noder with the alphabetically smaller name in the
-// frame or does nothing if the frame was empty.
-func (f *Frame) Drop() {
- if f.Len() == 0 {
- return
- }
-
- top := f.Len() - 1
- f.stack[top] = nil
- f.stack = f.stack[:top]
-}
-
-// Len returns the number of noders in the frame.
-func (f *Frame) Len() int {
- return len(f.stack)
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/iter.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/iter.go
deleted file mode 100644
index c84f6fcc8a70525251cec18433ae27ae149ba3fe..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/iter.go
+++ /dev/null
@@ -1,212 +0,0 @@
-package merkletrie
-
-import (
- "fmt"
- "io"
-
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame"
- "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder"
-)
-
-// Iter is an iterator for merkletries (only the trie part of the
-// merkletrie is relevant here, it does not use the Hasher interface).
-//
-// The iteration is performed in depth-first pre-order. Entries at each
-// depth are traversed in (case-sensitive) alphabetical order.
-//
-// This is the kind of traversal you will expect when listing ordinary
-// files and directories recursively, for example:
-//
-// Trie Traversal order
-// ---- ---------------
-// .
-// / | \ c
-// / | \ d/
-// d c z ===> d/a
-// / \ d/b
-// b a z
-//
-//
-// This iterator is somewhat especial as you can chose to skip whole
-// "directories" when iterating:
-//
-// - The Step method will iterate normally.
-//
-// - the Next method will not descend deeper into the tree.
-//
-// For example, if the iterator is at `d/`, the Step method will return
-// `d/a` while the Next would have returned `z` instead (skipping `d/`
-// and its descendants). The name of the these two methods are based on
-// the well known "next" and "step" operations, quite common in
-// debuggers, like gdb.
-//
-// The paths returned by the iterator will be relative, if the iterator
-// was created from a single node, or absolute, if the iterator was
-// created from the path to the node (the path will be prefixed to all
-// returned paths).
-type Iter struct {
- // Tells if the iteration has started.
- hasStarted bool
- // The top of this stack has the current node and its siblings. The
- // rest of the stack keeps the ancestors of the current node and
- // their corresponding siblings. The current element is always the
- // top element of the top frame.
- //
- // When "step"ping into a node, its children are pushed as a new
- // frame.
- //
- // When "next"ing pass a node, the current element is dropped by
- // popping the top frame.
- frameStack []*frame.Frame
- // The base path used to turn the relative paths used internally by
- // the iterator into absolute paths used by external applications.
- // For relative iterator this will be nil.
- base noder.Path
-}
-
-// NewIter returns a new relative iterator using the provider noder as
-// its unnamed root. When iterating, all returned paths will be
-// relative to node.
-func NewIter(n noder.Noder) (*Iter, error) {
- return newIter(n, nil)
-}
-
-// NewIterFromPath returns a new absolute iterator from the noder at the
-// end of the path p. When iterating, all returned paths will be
-// absolute, using the root of the path p as their root.
-func NewIterFromPath(p noder.Path) (*Iter, error) {
- return newIter(p, p) // Path implements Noder
-}
-
-func newIter(root noder.Noder, base noder.Path) (*Iter, error) {
- ret := &Iter{
- base: base,
- }
-
- frame, err := frame.New(root)
- if err != nil {
- return nil, err
- }
- ret.push(frame)
-
- return ret, nil
-}
-
-func (iter *Iter) top() (*frame.Frame, bool) {
- if len(iter.frameStack) == 0 {
- return nil, false
- }
- top := len(iter.frameStack) - 1
-
- return iter.frameStack[top], true
-}
-
-func (iter *Iter) push(f *frame.Frame) {
- iter.frameStack = append(iter.frameStack, f)
-}
-
-const (
- doDescend = true
- dontDescend = false
-)
-
-// Next returns the path of the next node without descending deeper into
-// the trie and nil. If there are no more entries in the trie it
-// returns nil and io.EOF. In case of error, it will return nil and the
-// error.
-func (iter *Iter) Next() (noder.Path, error) {
- return iter.advance(dontDescend)
-}
-
-// Step returns the path to the next node in the trie, descending deeper
-// into it if needed, and nil. If there are no more nodes in the trie,
-// it returns nil and io.EOF. In case of error, it will return nil and
-// the error.
-func (iter *Iter) Step() (noder.Path, error) {
- return iter.advance(doDescend)
-}
-
-// Advances the iterator in the desired direction: descend or
-// dontDescend.
-//
-// Returns the new current element and a nil error on success. If there
-// are no more elements in the trie below the base, it returns nil, and
-// io.EOF. Returns nil and an error in case of errors.
-func (iter *Iter) advance(wantDescend bool) (noder.Path, error) {
- current, err := iter.current()
- if err != nil {
- return nil, err
- }
-
- // The first time we just return the current node.
- if !iter.hasStarted {
- iter.hasStarted = true
- return current, nil
- }
-
- // Advances means getting a next current node, either its first child or
- // its next sibling, depending if we must descend or not.
- numChildren, err := current.NumChildren()
- if err != nil {
- return nil, err
- }
-
- mustDescend := numChildren != 0 && wantDescend
- if mustDescend {
- // descend: add a new frame with the current's children.
- frame, err := frame.New(current)
- if err != nil {
- return nil, err
- }
- iter.push(frame)
- } else {
- // don't descend: just drop the current node
- iter.drop()
- }
-
- return iter.current()
-}
-
-// Returns the path to the current node, adding the base if there was
-// one, and a nil error. If there were no noders left, it returns nil
-// and io.EOF. If an error occurred, it returns nil and the error.
-func (iter *Iter) current() (noder.Path, error) {
- if topFrame, ok := iter.top(); !ok {
- return nil, io.EOF
- } else if _, ok := topFrame.First(); !ok {
- return nil, io.EOF
- }
-
- ret := make(noder.Path, 0, len(iter.base)+len(iter.frameStack))
-
- // concat the base...
- ret = append(ret, iter.base...)
- // ... and the current node and all its ancestors
- for i, f := range iter.frameStack {
- t, ok := f.First()
- if !ok {
- panic(fmt.Sprintf("frame %d is empty", i))
- }
- ret = append(ret, t)
- }
-
- return ret, nil
-}
-
-// removes the current node if any, and all the frames that become empty as a
-// consecuence of this action.
-func (iter *Iter) drop() {
- frame, ok := iter.top()
- if !ok {
- return
- }
-
- frame.Drop()
- // if the frame is empty, remove it and its parent, recursively
- if frame.Len() == 0 {
- top := len(iter.frameStack) - 1
- iter.frameStack[top] = nil
- iter.frameStack = iter.frameStack[:top]
- iter.drop()
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/noder.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/noder.go
deleted file mode 100644
index d6b3de4adafa3ec873166cf8dd1186a53375bb03..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/noder.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Package noder provide an interface for defining nodes in a
-// merkletrie, their hashes and their paths (a noders and its
-// ancestors).
-//
-// The hasher interface is easy to implement naively by elements that
-// already have a hash, like git blobs and trees. More sophisticated
-// implementations can implement the Equal function in exotic ways
-// though: for instance, comparing the modification time of directories
-// in a filesystem.
-package noder
-
-import "fmt"
-
-// Hasher interface is implemented by types that can tell you
-// their hash.
-type Hasher interface {
- Hash() []byte
-}
-
-// Equal functions take two hashers and return if they are equal.
-//
-// These functions are expected to be faster than reflect.Equal or
-// reflect.DeepEqual because they can compare just the hash of the
-// objects, instead of their contents, so they are expected to be O(1).
-type Equal func(a, b Hasher) bool
-
-// The Noder interface is implemented by the elements of a Merkle Trie.
-//
-// There are two types of elements in a Merkle Trie:
-//
-// - file-like nodes: they cannot have children.
-//
-// - directory-like nodes: they can have 0 or more children and their
-// hash is calculated by combining their children hashes.
-type Noder interface {
- Hasher
- fmt.Stringer // for testing purposes
- // Name returns the name of an element (relative, not its full
- // path).
- Name() string
- // IsDir returns true if the element is a directory-like node or
- // false if it is a file-like node.
- IsDir() bool
- // Children returns the children of the element. Note that empty
- // directory-like noders and file-like noders will both return
- // NoChildren.
- Children() ([]Noder, error)
- // NumChildren returns the number of children this element has.
- //
- // This method is an optimization: the number of children is easily
- // calculated as the length of the value returned by the Children
- // method (above); yet, some implementations will be able to
- // implement NumChildren in O(1) while Children is usually more
- // complex.
- NumChildren() (int, error)
-}
-
-// NoChildren represents the children of a noder without children.
-var NoChildren = []Noder{}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/path.go b/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/path.go
deleted file mode 100644
index 85742dbe5f4d758b8c16ccd29ceb430401544616..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/utils/merkletrie/noder/path.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package noder
-
-import (
- "bytes"
- "strings"
-)
-
-// Path values represent a noder and its ancestors. The root goes first
-// and the actual final noder the path is refering to will be the last.
-//
-// A path implements the Noder interface, redirecting all the interface
-// calls to its final noder.
-//
-// Paths build from an empty Noder slice are not valid paths and should
-// not be used.
-type Path []Noder
-
-// String returns the full path of the final noder as a string, using
-// "/" as the separator.
-func (p Path) String() string {
- var buf bytes.Buffer
- sep := ""
- for _, e := range p {
- _, _ = buf.WriteString(sep)
- sep = "/"
- _, _ = buf.WriteString(e.Name())
- }
-
- return buf.String()
-}
-
-// Last returns the final noder in the path.
-func (p Path) Last() Noder {
- return p[len(p)-1]
-}
-
-// Hash returns the hash of the final noder of the path.
-func (p Path) Hash() []byte {
- return p.Last().Hash()
-}
-
-// Name returns the name of the final noder of the path.
-func (p Path) Name() string {
- return p.Last().Name()
-}
-
-// IsDir returns if the final noder of the path is a directory-like
-// noder.
-func (p Path) IsDir() bool {
- return p.Last().IsDir()
-}
-
-// Children returns the children of the final noder in the path.
-func (p Path) Children() ([]Noder, error) {
- return p.Last().Children()
-}
-
-// NumChildren returns the number of children the final noder of the
-// path has.
-func (p Path) NumChildren() (int, error) {
- return p.Last().NumChildren()
-}
-
-// Compare returns -1, 0 or 1 if the path p is smaller, equal or bigger
-// than other, in "directory order"; for example:
-//
-// "a" < "b"
-// "a/b/c/d/z" < "b"
-// "a/b/a" > "a/b"
-func (p Path) Compare(other Path) int {
- i := 0
- for {
- switch {
- case len(other) == len(p) && i == len(p):
- return 0
- case i == len(other):
- return 1
- case i == len(p):
- return -1
- default:
- cmp := strings.Compare(p[i].Name(), other[i].Name())
- if cmp != 0 {
- return cmp
- }
- }
- i++
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/worktree.go b/vendor/gopkg.in/src-d/go-git.v4/worktree.go
deleted file mode 100644
index 40ebe585dd4f9e92a53f642f9ade1d4e689f6d96..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/worktree.go
+++ /dev/null
@@ -1,438 +0,0 @@
-package git
-
-import (
- "errors"
- "fmt"
- "io"
- "io/ioutil"
- "os"
-
- "gopkg.in/src-d/go-git.v4/config"
- "gopkg.in/src-d/go-git.v4/plumbing"
- "gopkg.in/src-d/go-git.v4/plumbing/filemode"
- "gopkg.in/src-d/go-git.v4/plumbing/format/index"
- "gopkg.in/src-d/go-git.v4/plumbing/object"
-
- "gopkg.in/src-d/go-billy.v2"
-)
-
-var ErrWorktreeNotClean = errors.New("worktree is not clean")
-var ErrSubmoduleNotFound = errors.New("submodule not found")
-
-type Worktree struct {
- r *Repository
- fs billy.Filesystem
-}
-
-func (w *Worktree) Checkout(commit plumbing.Hash) error {
- s, err := w.Status()
- if err != nil {
- return err
- }
-
- if !s.IsClean() {
- return ErrWorktreeNotClean
- }
-
- c, err := w.r.CommitObject(commit)
- if err != nil {
- return err
- }
-
- t, err := c.Tree()
- if err != nil {
- return err
- }
-
- idx := &index.Index{Version: 2}
- walker := object.NewTreeWalker(t, true)
-
- for {
- name, entry, err := walker.Next()
- if err == io.EOF {
- break
- }
-
- if err != nil {
- return err
- }
-
- if err := w.checkoutEntry(name, &entry, idx); err != nil {
- return err
- }
- }
-
- return w.r.Storer.SetIndex(idx)
-}
-
-func (w *Worktree) checkoutEntry(name string, e *object.TreeEntry, idx *index.Index) error {
- if e.Mode == filemode.Submodule {
- return w.addIndexFromTreeEntry(name, e, idx)
- }
-
- if e.Mode == filemode.Dir {
- return nil
- }
-
- return w.checkoutFile(name, e, idx)
-}
-
-func (w *Worktree) checkoutFile(name string, e *object.TreeEntry, idx *index.Index) error {
- blob, err := object.GetBlob(w.r.Storer, e.Hash)
- if err != nil {
- return err
- }
-
- from, err := blob.Reader()
- if err != nil {
- return err
- }
- defer from.Close()
-
- mode, err := e.Mode.ToOSFileMode()
- if err != nil {
- return err
- }
-
- to, err := w.fs.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode.Perm())
- if err != nil {
- return err
- }
- defer to.Close()
-
- if _, err := io.Copy(to, from); err != nil {
- return err
- }
-
- return w.addIndexFromFile(name, e, idx)
-}
-
-var fillSystemInfo func(e *index.Entry, sys interface{})
-
-func (w *Worktree) addIndexFromTreeEntry(name string, f *object.TreeEntry, idx *index.Index) error {
- idx.Entries = append(idx.Entries, index.Entry{
- Hash: f.Hash,
- Name: name,
- Mode: filemode.Submodule,
- })
-
- return nil
-}
-
-func (w *Worktree) addIndexFromFile(name string, f *object.TreeEntry, idx *index.Index) error {
- fi, err := w.fs.Stat(name)
- if err != nil {
- return err
- }
-
- mode, err := filemode.NewFromOSFileMode(fi.Mode())
- if err != nil {
- return err
- }
-
- e := index.Entry{
- Hash: f.Hash,
- Name: name,
- Mode: mode,
- ModifiedAt: fi.ModTime(),
- Size: uint32(fi.Size()),
- }
-
- // if the FileInfo.Sys() comes from os the ctime, dev, inode, uid and gid
- // can be retrieved, otherwise this doesn't apply
- if fillSystemInfo != nil {
- fillSystemInfo(&e, fi.Sys())
- }
-
- idx.Entries = append(idx.Entries, e)
- return nil
-}
-
-func (w *Worktree) Status() (Status, error) {
- idx, err := w.r.Storer.Index()
- if err != nil {
- return nil, err
- }
-
- files, err := readDirAll(w.fs)
- if err != nil {
- return nil, err
- }
-
- s := make(Status, 0)
- for _, e := range idx.Entries {
- fi, ok := files[e.Name]
- delete(files, e.Name)
-
- if !ok {
- s.File(e.Name).Worktree = Deleted
- continue
- }
-
- status, err := w.compareFileWithEntry(fi, &e)
- if err != nil {
- return nil, err
- }
-
- s.File(e.Name).Worktree = status
- }
-
- for f := range files {
- s.File(f).Worktree = Untracked
- }
-
- return s, nil
-}
-
-func (w *Worktree) compareFileWithEntry(fi billy.FileInfo, e *index.Entry) (StatusCode, error) {
- if fi.Size() != int64(e.Size) {
- return Modified, nil
- }
-
- mode, err := filemode.NewFromOSFileMode(fi.Mode())
- if err != nil {
- return Modified, err
- }
-
- if mode != e.Mode {
- return Modified, nil
- }
-
- h, err := calcSHA1(w.fs, e.Name)
- if h != e.Hash || err != nil {
- return Modified, err
-
- }
-
- return Unmodified, nil
-}
-
-const gitmodulesFile = ".gitmodules"
-
-// Submodule returns the submodule with the given name
-func (w *Worktree) Submodule(name string) (*Submodule, error) {
- l, err := w.Submodules()
- if err != nil {
- return nil, err
- }
-
- for _, m := range l {
- if m.Config().Name == name {
- return m, nil
- }
- }
-
- return nil, ErrSubmoduleNotFound
-}
-
-// Submodules returns all the available submodules
-func (w *Worktree) Submodules() (Submodules, error) {
- l := make(Submodules, 0)
- m, err := w.readGitmodulesFile()
- if err != nil || m == nil {
- return l, err
- }
-
- c, err := w.r.Config()
- for _, s := range m.Submodules {
- l = append(l, w.newSubmodule(s, c.Submodules[s.Name]))
- }
-
- return l, nil
-}
-
-func (w *Worktree) newSubmodule(fromModules, fromConfig *config.Submodule) *Submodule {
- m := &Submodule{w: w}
- m.initialized = fromConfig != nil
-
- if !m.initialized {
- m.c = fromModules
- return m
- }
-
- m.c = fromConfig
- m.c.Path = fromModules.Path
- return m
-}
-
-func (w *Worktree) readGitmodulesFile() (*config.Modules, error) {
- f, err := w.fs.Open(gitmodulesFile)
- if err != nil {
- if os.IsNotExist(err) {
- return nil, nil
- }
-
- return nil, err
- }
-
- input, err := ioutil.ReadAll(f)
- if err != nil {
- return nil, err
- }
-
- m := config.NewModules()
- return m, m.Unmarshal(input)
-}
-
-func (w *Worktree) readIndexEntry(path string) (index.Entry, error) {
- var e index.Entry
-
- idx, err := w.r.Storer.Index()
- if err != nil {
- return e, err
- }
-
- for _, e := range idx.Entries {
- if e.Name == path {
- return e, nil
- }
- }
-
- return e, fmt.Errorf("unable to find %q entry in the index", path)
-}
-
-// Status current status of a Worktree
-type Status map[string]*FileStatus
-
-func (s Status) File(filename string) *FileStatus {
- if _, ok := (s)[filename]; !ok {
- s[filename] = &FileStatus{}
- }
-
- return s[filename]
-
-}
-
-func (s Status) IsClean() bool {
- for _, status := range s {
- if status.Worktree != Unmodified || status.Staging != Unmodified {
- return false
- }
- }
-
- return true
-}
-
-func (s Status) String() string {
- var names []string
- for name := range s {
- names = append(names, name)
- }
-
- var output string
- for _, name := range names {
- status := s[name]
- if status.Staging == 0 && status.Worktree == 0 {
- continue
- }
-
- if status.Staging == Renamed {
- name = fmt.Sprintf("%s -> %s", name, status.Extra)
- }
-
- output += fmt.Sprintf("%s%s %s\n", status.Staging, status.Worktree, name)
- }
-
- return output
-}
-
-// FileStatus status of a file in the Worktree
-type FileStatus struct {
- Staging StatusCode
- Worktree StatusCode
- Extra string
-}
-
-// StatusCode status code of a file in the Worktree
-type StatusCode int8
-
-const (
- Unmodified StatusCode = iota
- Untracked
- Modified
- Added
- Deleted
- Renamed
- Copied
- UpdatedButUnmerged
-)
-
-func (c StatusCode) String() string {
- switch c {
- case Unmodified:
- return " "
- case Modified:
- return "M"
- case Added:
- return "A"
- case Deleted:
- return "D"
- case Renamed:
- return "R"
- case Copied:
- return "C"
- case UpdatedButUnmerged:
- return "U"
- case Untracked:
- return "?"
- default:
- return "-"
- }
-}
-
-func calcSHA1(fs billy.Filesystem, filename string) (plumbing.Hash, error) {
- file, err := fs.Open(filename)
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- stat, err := fs.Stat(filename)
- if err != nil {
- return plumbing.ZeroHash, err
- }
-
- h := plumbing.NewHasher(plumbing.BlobObject, stat.Size())
- if _, err := io.Copy(h, file); err != nil {
- return plumbing.ZeroHash, err
- }
-
- return h.Sum(), nil
-}
-
-func readDirAll(filesystem billy.Filesystem) (map[string]billy.FileInfo, error) {
- all := make(map[string]billy.FileInfo, 0)
- return all, doReadDirAll(filesystem, "", all)
-}
-
-func doReadDirAll(fs billy.Filesystem, path string, files map[string]billy.FileInfo) error {
- if path == defaultDotGitPath {
- return nil
- }
-
- l, err := fs.ReadDir(path)
- if err != nil {
- if os.IsNotExist(err) {
- return nil
- }
-
- return err
- }
-
- for _, info := range l {
- file := fs.Join(path, info.Name())
- if file == defaultDotGitPath {
- continue
- }
-
- if !info.IsDir() {
- files[file] = info
- continue
- }
-
- if err := doReadDirAll(fs, file, files); err != nil {
- return err
- }
- }
-
- return nil
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/worktree_darwin.go b/vendor/gopkg.in/src-d/go-git.v4/worktree_darwin.go
deleted file mode 100644
index 8eaffde8af65da8866c020aecee2a2a824d22e2e..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/worktree_darwin.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// +build darwin freebsd netbsd openbsd
-
-package git
-
-import (
- "syscall"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/index"
-)
-
-func init() {
- fillSystemInfo = func(e *index.Entry, sys interface{}) {
- if os, ok := sys.(*syscall.Stat_t); ok {
- e.CreatedAt = time.Unix(int64(os.Atimespec.Sec), int64(os.Atimespec.Nsec))
- e.Dev = uint32(os.Dev)
- e.Inode = uint32(os.Ino)
- e.GID = os.Gid
- e.UID = os.Uid
- }
- }
-}
diff --git a/vendor/gopkg.in/src-d/go-git.v4/worktree_linux.go b/vendor/gopkg.in/src-d/go-git.v4/worktree_linux.go
deleted file mode 100644
index a33cd2fb9625ca819ee5a788903ed02512090dab..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/src-d/go-git.v4/worktree_linux.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// +build linux
-
-package git
-
-import (
- "syscall"
- "time"
-
- "gopkg.in/src-d/go-git.v4/plumbing/format/index"
-)
-
-func init() {
- fillSystemInfo = func(e *index.Entry, sys interface{}) {
- if os, ok := sys.(*syscall.Stat_t); ok {
- e.CreatedAt = time.Unix(int64(os.Ctim.Sec), int64(os.Ctim.Nsec))
- e.Dev = uint32(os.Dev)
- e.Inode = uint32(os.Ino)
- e.GID = os.Gid
- e.UID = os.Uid
- }
- }
-}
diff --git a/vendor/gopkg.in/warnings.v0/LICENSE b/vendor/gopkg.in/warnings.v0/LICENSE
deleted file mode 100644
index d65f7e9d8cd6f1fda500b512fa6fcd14c2d8cefc..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/warnings.v0/LICENSE
+++ /dev/null
@@ -1,24 +0,0 @@
-Copyright (c) 2016 Péter Surányi.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/gopkg.in/warnings.v0/README b/vendor/gopkg.in/warnings.v0/README
deleted file mode 100644
index 77f46dd2c691bd2359dde22218620368feac01c5..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/warnings.v0/README
+++ /dev/null
@@ -1,74 +0,0 @@
-Package warnings implements error handling with non-fatal errors (warnings).
-
-import path: "gopkg.in/warnings.v0"
-package docs: https://godoc.org/gopkg.in/warnings.v0
-issues: https://github.com/go-warnings/warnings/issues
-pull requests: https://github.com/go-warnings/warnings/pulls
-
-A recurring pattern in Go programming is the following:
-
- func myfunc(params) error {
- if err := doSomething(...); err != nil {
- return err
- }
- if err := doSomethingElse(...); err != nil {
- return err
- }
- if ok := doAnotherThing(...); !ok {
- return errors.New("my error")
- }
- ...
- return nil
- }
-
-This pattern allows interrupting the flow on any received error. But what if
-there are errors that should be noted but still not fatal, for which the flow
-should not be interrupted? Implementing such logic at each if statement would
-make the code complex and the flow much harder to follow.
-
-Package warnings provides the Collector type and a clean and simple pattern
-for achieving such logic. The Collector takes care of deciding when to break
-the flow and when to continue, collecting any non-fatal errors (warnings)
-along the way. The only requirement is that fatal and non-fatal errors can be
-distinguished programmatically; that is a function such as
-
- IsFatal(error) bool
-
-must be implemented. The following is an example of what the above snippet
-could look like using the warnings package:
-
- import "gopkg.in/warnings.v0"
-
- func isFatal(err error) bool {
- _, ok := err.(WarningType)
- return !ok
- }
-
- func myfunc(params) error {
- c := warnings.NewCollector(isFatal)
- c.FatalWithWarnings = true
- if err := c.Collect(doSomething()); err != nil {
- return err
- }
- if err := c.Collect(doSomethingElse(...)); err != nil {
- return err
- }
- if ok := doAnotherThing(...); !ok {
- if err := c.Collect(errors.New("my error")); err != nil {
- return err
- }
- }
- ...
- return c.Done()
- }
-
-Rules for using warnings
-
- - ensure that warnings are programmatically distinguishable from fatal
- errors (i.e. implement an isFatal function and any necessary error types)
- - ensure that there is a single Collector instance for a call of each
- exported function
- - ensure that all errors (fatal or warning) are fed through Collect
- - ensure that every time an error is returned, it is one returned by a
- Collector (from Collect or Done)
- - ensure that Collect is never called after Done
diff --git a/vendor/gopkg.in/warnings.v0/warnings.go b/vendor/gopkg.in/warnings.v0/warnings.go
deleted file mode 100644
index 5b57f4353c9dfde946be893c3b870259c5192087..0000000000000000000000000000000000000000
--- a/vendor/gopkg.in/warnings.v0/warnings.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Package warnings implements error handling with non-fatal errors (warnings).
-//
-// A recurring pattern in Go programming is the following:
-//
-// func myfunc(params) error {
-// if err := doSomething(...); err != nil {
-// return err
-// }
-// if err := doSomethingElse(...); err != nil {
-// return err
-// }
-// if ok := doAnotherThing(...); !ok {
-// return errors.New("my error")
-// }
-// ...
-// return nil
-// }
-//
-// This pattern allows interrupting the flow on any received error. But what if
-// there are errors that should be noted but still not fatal, for which the flow
-// should not be interrupted? Implementing such logic at each if statement would
-// make the code complex and the flow much harder to follow.
-//
-// Package warnings provides the Collector type and a clean and simple pattern
-// for achieving such logic. The Collector takes care of deciding when to break
-// the flow and when to continue, collecting any non-fatal errors (warnings)
-// along the way. The only requirement is that fatal and non-fatal errors can be
-// distinguished programmatically; that is a function such as
-//
-// IsFatal(error) bool
-//
-// must be implemented. The following is an example of what the above snippet
-// could look like using the warnings package:
-//
-// import "gopkg.in/warnings.v0"
-//
-// func isFatal(err error) bool {
-// _, ok := err.(WarningType)
-// return !ok
-// }
-//
-// func myfunc(params) error {
-// c := warnings.NewCollector(isFatal)
-// c.FatalWithWarnings = true
-// if err := c.Collect(doSomething()); err != nil {
-// return err
-// }
-// if err := c.Collect(doSomethingElse(...)); err != nil {
-// return err
-// }
-// if ok := doAnotherThing(...); !ok {
-// if err := c.Collect(errors.New("my error")); err != nil {
-// return err
-// }
-// }
-// ...
-// return c.Done()
-// }
-//
-// Rules for using warnings
-//
-// - ensure that warnings are programmatically distinguishable from fatal
-// errors (i.e. implement an isFatal function and any necessary error types)
-// - ensure that there is a single Collector instance for a call of each
-// exported function
-// - ensure that all errors (fatal or warning) are fed through Collect
-// - ensure that every time an error is returned, it is one returned by a
-// Collector (from Collect or Done)
-// - ensure that Collect is never called after Done
-//
-// TODO
-//
-// - optionally limit the number of warnings (e.g. stop after 20 warnings) (?)
-// - consider interaction with contexts
-// - go vet-style invocations verifier
-// - semi-automatic code converter
-//
-package warnings // import "gopkg.in/warnings.v0"
-
-import (
- "bytes"
- "fmt"
-)
-
-// List holds a collection of warnings and optionally one fatal error.
-type List struct {
- Warnings []error
- Fatal error
-}
-
-// Error implements the error interface.
-func (l List) Error() string {
- b := bytes.NewBuffer(nil)
- if l.Fatal != nil {
- fmt.Fprintln(b, "fatal:")
- fmt.Fprintln(b, l.Fatal)
- }
- switch len(l.Warnings) {
- case 0:
- // nop
- case 1:
- fmt.Fprintln(b, "warning:")
- default:
- fmt.Fprintln(b, "warnings:")
- }
- for _, err := range l.Warnings {
- fmt.Fprintln(b, err)
- }
- return b.String()
-}
-
-// A Collector collects errors up to the first fatal error.
-type Collector struct {
- // IsFatal distinguishes between warnings and fatal errors.
- IsFatal func(error) bool
- // FatalWithWarnings set to true means that a fatal error is returned as
- // a List together with all warnings so far. The default behavior is to
- // only return the fatal error and discard any warnings that have been
- // collected.
- FatalWithWarnings bool
-
- l List
- done bool
-}
-
-// NewCollector returns a new Collector; it uses isFatal to distinguish between
-// warnings and fatal errors.
-func NewCollector(isFatal func(error) bool) *Collector {
- return &Collector{IsFatal: isFatal}
-}
-
-// Collect collects a single error (warning or fatal). It returns nil if
-// collection can continue (only warnings so far), or otherwise the errors
-// collected. Collect mustn't be called after the first fatal error or after
-// Done has been called.
-func (c *Collector) Collect(err error) error {
- if c.done {
- panic("warnings.Collector already done")
- }
- if err == nil {
- return nil
- }
- if c.IsFatal(err) {
- c.done = true
- c.l.Fatal = err
- } else {
- c.l.Warnings = append(c.l.Warnings, err)
- }
- if c.l.Fatal != nil {
- return c.erorr()
- }
- return nil
-}
-
-// Done ends collection and returns the collected error(s).
-func (c *Collector) Done() error {
- c.done = true
- return c.erorr()
-}
-
-func (c *Collector) erorr() error {
- if !c.FatalWithWarnings && c.l.Fatal != nil {
- return c.l.Fatal
- }
- if c.l.Fatal == nil && len(c.l.Warnings) == 0 {
- return nil
- }
- // Note that a single warning is also returned as a List. This is to make it
- // easier to determine fatal-ness of the returned error.
- return c.l
-}
-
-// FatalOnly returns the fatal error, if any, **in an error returned by a
-// Collector**. It returns nil if and only if err is nil or err is a List
-// with err.Fatal == nil.
-func FatalOnly(err error) error {
- l, ok := err.(List)
- if !ok {
- return err
- }
- return l.Fatal
-}
-
-// WarningsOnly returns the warnings **in an error returned by a Collector**.
-func WarningsOnly(err error) []error {
- l, ok := err.(List)
- if !ok {
- return nil
- }
- return l.Warnings
-}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 3938979b084c3ce2a40fa48e49eab0501135a3b4..3dadb5b2fe8a64ff1e8c110386c6e7e96e7143de 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -82,76 +82,6 @@
"revision": "03c771153cfff2627e0e7c8326f6b3c6891b6acf",
"revisionTime": "2017-03-29T16:09:13Z"
},
- {
- "checksumSHA1": "iWCtyR1TkJ22Bi/ygzfKDvOQdQY=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/github.com/sergi/go-diff/diffmatchpatch",
- "path": "github.com/sergi/go-diff/diffmatchpatch",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "8QeSG127zQqbA+YfkO1WkKx/iUI=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/github.com/src-d/gcfg",
- "path": "github.com/src-d/gcfg",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "yf5NBT8BofPfGYCXoLnj7BIA1wo=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/github.com/src-d/gcfg/scanner",
- "path": "github.com/src-d/gcfg/scanner",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "C5Z8YVyNTuvupM9AUr9KbPlps4Q=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/github.com/src-d/gcfg/token",
- "path": "github.com/src-d/gcfg/token",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "mDkN3UpR7auuFbwUuIwExz4DZgY=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/github.com/src-d/gcfg/types",
- "path": "github.com/src-d/gcfg/types",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "C1KKOxFoW7/W/NFNpiXK+boguNo=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/golang.org/x/crypto/curve25519",
- "path": "golang.org/x/crypto/curve25519",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "wGb//LjBPNxYHqk+dcLo7BjPXK8=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/golang.org/x/crypto/ed25519",
- "path": "golang.org/x/crypto/ed25519",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "LXFcVx8I587SnWmKycSDEq9yvK8=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/golang.org/x/crypto/ed25519/internal/edwards25519",
- "path": "golang.org/x/crypto/ed25519/internal/edwards25519",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "fsrFs762jlaILyqqQImS1GfvIvw=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/golang.org/x/crypto/ssh",
- "path": "golang.org/x/crypto/ssh",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "SJ3Ma3Ozavxpbh1usZWBCnzMKIc=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/golang.org/x/crypto/ssh/agent",
- "path": "golang.org/x/crypto/ssh/agent",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
{
"checksumSHA1": "Y+HGqEkYM15ir+J93MEaHdyFy0c=",
"path": "golang.org/x/net/context",
@@ -164,6 +94,12 @@
"revision": "a6577fac2d73be281a500b310739095313165611",
"revisionTime": "2017-03-08T20:54:49Z"
},
+ {
+ "checksumSHA1": "Ws1ZR+8A8E4lgwbgFO29nChcRiw=",
+ "path": "gopkg.in/libgit2/git2go.v25",
+ "revision": "334260d743d713a55ff3c097ec6707f2bb39e9d5",
+ "revisionTime": "2017-01-20T13:46:32Z"
+ },
{
"checksumSHA1": "++OrH7Epi89IOXHT7Cwhq5y9ZBo=",
"path": "gopkg.in/olivere/elastic.v5",
@@ -175,243 +111,6 @@
"path": "gopkg.in/olivere/elastic.v5/uritemplates",
"revision": "8c148e9a5e627a3c155c6980fb965fe7813d78b8",
"revisionTime": "2017-03-16T11:04:01Z"
- },
- {
- "checksumSHA1": "TrrpN8Ra20NKSET2JN1jHTJPVKI=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/gopkg.in/src-d/go-billy.v2",
- "path": "gopkg.in/src-d/go-billy.v2",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "ulk0E0hadjYY051SDWIFUU7CmJU=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/gopkg.in/src-d/go-billy.v2/osfs",
- "path": "gopkg.in/src-d/go-billy.v2/osfs",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "pBrkx5lQtbYkQKDP4XuZ8YKuhWY=",
- "path": "gopkg.in/src-d/go-git.v4",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "s8gwNiC3stn7E+7r+o/YbJCzTg0=",
- "path": "gopkg.in/src-d/go-git.v4/config",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "A3WduoxOIVoBnsDAEZtI798CZtU=",
- "path": "gopkg.in/src-d/go-git.v4/internal/revision",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "gnDMY5QTenyeb4Z/wsbKdCVk8AU=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "ccn330T2+i5MJIMFNWSld0JED2I=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/cache",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "pHPMiAzXG/TJqTLEKj2SHjxX4zs=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/filemode",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "SfXSsfv1ji5LFY8GdLLleOfWPd4=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/config",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "YoinR3unctE6LY/W74CqWnVCwp4=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/idxfile",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "I81+nhcMO6z6DWvV+oMSZR9ZRho=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/index",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "RYeQffgqVS4Kbbk2YVcaPadXCiI=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/objfile",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "d8vqfvAF30/uHLKL+9zM6S/XYjA=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/packfile",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "rA6jJ2fxdcALXL7EaP8Ja37xXjw=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/format/pktline",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "0PaLECZE+WS9F7XZqzV+wJIqbtQ=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/object",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "XBymyCj04MIi6oPrw+NXiMX95qI=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "FNapUewRlNHGOyob9Rzl44HvQB8=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/capability",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "wVfbzV5BNhjW/HFFJuTCjkPSJ5M=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/protocol/packp/sideband",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "lcZUgalumxWfUjijwHde2Ox1Xcg=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/revlist",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "ysDmbzNW3RSfgjlUCGN48GXx6Ok=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/storer",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "3O9OpI4U1fhkFdcNPjQ0vjYObUs=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "UF+MxBfonAjr2zn35ZZhFfL/dz4=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/client",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "eWYSaNrdtP6H85O1Qa62+J++oO8=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/file",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "F0xBNcEflhHlwUctYJVj6AhZ+kk=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/git",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "LXB3DF29p4tYagVyJYmTSKwElQg=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/http",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "pLQiuOmKInVwJIOml37Bt9e3YYA=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/internal/common",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "PKt08BrFTrleyYIqCtXM33Vbz6A=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/server",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "FoyQq1pQUXCHpfNLfSbAEklCPkA=",
- "path": "gopkg.in/src-d/go-git.v4/plumbing/transport/ssh",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "3n+s0+8HMD0++79ZUYOE2lyCQWY=",
- "path": "gopkg.in/src-d/go-git.v4/storage",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "dCejhXWbG1RWI/wMENAtAQ9BIlI=",
- "path": "gopkg.in/src-d/go-git.v4/storage/filesystem",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "GEOoF+Zk7c02wI9mnoctaKqkF34=",
- "path": "gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "OfzMDAIu253dJ9591gd3w/APq0I=",
- "path": "gopkg.in/src-d/go-git.v4/storage/memory",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "8WNcGWxmpmcQTxa+LT7lghx3UNY=",
- "path": "gopkg.in/src-d/go-git.v4/utils/binary",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "vniUxB6bbDYazl21cOfmhdZZiY8=",
- "path": "gopkg.in/src-d/go-git.v4/utils/diff",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "nP0yUyAxESlNgNSZm7lM/VSGpqM=",
- "path": "gopkg.in/src-d/go-git.v4/utils/ioutil",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "+5CJIylVMH9B9Y34yeU81gAHxFQ=",
- "path": "gopkg.in/src-d/go-git.v4/utils/merkletrie",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "7eEw/xsSrFLfSppRf/JIt9u7lbU=",
- "path": "gopkg.in/src-d/go-git.v4/utils/merkletrie/internal/frame",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "f3kxzpAxqnc5ETJNuQmbaaLRpQU=",
- "path": "gopkg.in/src-d/go-git.v4/utils/merkletrie/noder",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
- },
- {
- "checksumSHA1": "ALQFMX3kmJkyB/8VEzVnGZG1H4A=",
- "origin": "gopkg.in/src-d/go-git.v4/vendor/gopkg.in/warnings.v0",
- "path": "gopkg.in/warnings.v0",
- "revision": "36c78b9d1b1eea682703fb1cbb0f4f3144354389",
- "revisionTime": "2017-03-28T03:53:33Z"
}
],
"rootPath": "gitlab.com/gitlab-org/es-git-go"