feature: add agit flow support

ref: https://git-repo.info/en/2020/03/agit-flow-and-git-repo/

example:

```Bash
git checkout -b test
echo "test" >> README.md
git commit -m "test"
git push origin HEAD:refs/for/master -o topic=test
```

Signed-off-by: a1012112796 <[email protected]>

Author: a1012112796

cmd/hook.go

@@ -38,6 +38,7 @@ var (
 			subcmdHookPreReceive,
 			subcmdHookUpdate,
 			subcmdHookPostReceive,
+			subcmdHookProcReceive,
 		},
 	}
 
@@ -74,6 +75,18 @@ var (
 			},
 		},
 	}
+	// Note: new hook since git 2.29
+	subcmdHookProcReceive = cli.Command{
+		Name:        "proc-receive",
+		Usage:       "Delegate proc-receive Git hook",
+		Description: "This command should only be called by Git",
+		Action:      runHookProcReceive,
+		Flags: []cli.Flag{
+			cli.BoolFlag{
+				Name: "debug",
+			},
+		},
+	}
 )
 
 type delayWriter struct {
@@ -460,3 +473,261 @@ func pushOptions() map[string]string {
 	}
 	return opts
 }
+
+func runHookProcReceive(c *cli.Context) error {
+	setup("hooks/proc-receive.log", c.Bool("debug"))
+
+	if len(os.Getenv("SSH_ORIGINAL_COMMAND")) == 0 {
+		if setting.OnlyAllowPushIfGiteaEnvironmentSet {
+			fail(`Rejecting changes as Gitea environment not set.
+If you are pushing over SSH you must push with a key managed by
+Gitea or set your environment appropriately.`, "")
+		} else {
+			return nil
+		}
+	}
+
+	lf, err := os.OpenFile("test.log", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0777)
+	if err != nil {
+		fail("Internal Server Error", "open log file failed: %v", err)
+	}
+	defer lf.Close()
+
+	if git.CheckGitVersionAtLeast("2.29") != nil {
+		fail("Internal Server Error", "git not support proc-receive.")
+	}
+
+	reader := bufio.NewReader(os.Stdin)
+	repoUser := os.Getenv(models.EnvRepoUsername)
+	repoName := os.Getenv(models.EnvRepoName)
+	pusherID, _ := strconv.ParseInt(os.Getenv(models.EnvPusherID), 10, 64)
+	pusherName := os.Getenv(models.EnvPusherName)
+
+	// 1. Version and features negotiation.
+	// S: PKT-LINE(version=1\0push-options atomic...)
+	// S: flush-pkt
+	// H: PKT-LINE(version=1\0push-options...)
+	// H: flush-pkt
+
+	rs, err := readPktLine(reader)
+	if err != nil {
+		fail("Internal Server Error", "Pkt-Line format is wrong :%v", err)
+	}
+	if rs.Type != pktLineTypeData {
+		fail("Internal Server Error", "Pkt-Line format is wrong. get %v", rs)
+	}
+
+	const VersionHead string = "version=1"
+
+	if !strings.HasPrefix(rs.Data, VersionHead) {
+		fail("Internal Server Error", "Pkt-Line format is wrong. get %v", rs)
+	}
+
+	hasPushOptions := false
+	response := []byte(VersionHead)
+	if strings.Contains(rs.Data, "push-options") {
+		response = append(response, byte(0))
+		response = append(response, []byte("push-options")...)
+		hasPushOptions = true
+	}
+	response = append(response, []byte("\n")...)
+
+	rs, err = readPktLine(reader)
+	if err != nil {
+		fail("Internal Server Error", "Pkt-Line format is wrong :%v", err)
+	}
+	if rs.Type != pktLineTypeFlush {
+		fail("Internal Server Error", "Pkt-Line format is wrong. get %v", rs)
+	}
+
+	err = writePktLine(os.Stdout, pktLineTypeData, response)
+	if err != nil {
+		fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+	}
+
+	err = writePktLine(os.Stdout, pktLineTypeFlush, nil)
+	if err != nil {
+		fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+	}
+
+	// 2. receive commands from server.
+	// S: PKT-LINE(<old-oid> <new-oid> <ref>)
+	// S: ... ...
+	// S: flush-pkt
+	// # receive push-options
+	// S: PKT-LINE(push-option)
+	// S: ... ...
+	// S: flush-pkt
+	hookOptions := private.HookOptions{
+		UserName: pusherName,
+		UserID:   pusherID,
+	}
+	hookOptions.OldCommitIDs = make([]string, 0, hookBatchSize)
+	hookOptions.NewCommitIDs = make([]string, 0, hookBatchSize)
+	hookOptions.RefFullNames = make([]string, 0, hookBatchSize)
+
+	for {
+		rs, err = readPktLine(reader)
+		if err != nil {
+			fail("Internal Server Error", "Pkt-Line format is wrong :%v", err)
+		}
+		if rs.Type == pktLineTypeFlush {
+			break
+		}
+		t := strings.SplitN(rs.Data, " ", 3)
+		if len(t) != 3 {
+			continue
+		}
+		hookOptions.OldCommitIDs = append(hookOptions.OldCommitIDs, t[0])
+		hookOptions.NewCommitIDs = append(hookOptions.NewCommitIDs, t[1])
+		hookOptions.RefFullNames = append(hookOptions.RefFullNames, t[2])
+	}
+
+	hookOptions.GitPushOptions = make(map[string]string)
+
+	if hasPushOptions {
+		for {
+			rs, err = readPktLine(reader)
+			if err != nil {
+				fail("Internal Server Error", "Pkt-Line format is wrong :%v", err)
+			}
+			if rs.Type == pktLineTypeFlush {
+				break
+			}
+
+			kv := strings.SplitN(rs.Data, "=", 2)
+			if len(kv) == 2 {
+				hookOptions.GitPushOptions[kv[0]] = kv[1]
+			}
+		}
+	}
+
+	// run hook
+	resp, err := private.HookProcReceive(repoUser, repoName, hookOptions)
+	if err != nil {
+		fail("Internal Server Error", "run proc-receive hook failed :%v", err)
+	}
+
+	// 3 response result to service.
+	// # OK, but has an alternate reference.  The alternate reference name
+	// # and other status can be given in option directives.
+	// H: PKT-LINE(ok <ref>)
+	// H: PKT-LINE(option refname <refname>)
+	// H: PKT-LINE(option old-oid <old-oid>)
+	// H: PKT-LINE(option new-oid <new-oid>)
+	// H: PKT-LINE(option forced-update)
+	// H: ... ...
+	// H: flush-pkt
+	for _, rs := range resp.Results {
+		err = writePktLine(os.Stdout, pktLineTypeData, []byte("ok "+rs.OrignRef))
+		if err != nil {
+			fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+		}
+		err = writePktLine(os.Stdout, pktLineTypeData, []byte("option refname "+rs.Ref))
+		if err != nil {
+			fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+		}
+		err = writePktLine(os.Stdout, pktLineTypeData, []byte("option old-oid "+rs.OldOID))
+		if err != nil {
+			fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+		}
+		err = writePktLine(os.Stdout, pktLineTypeData, []byte("option new-oid "+rs.NewOID))
+		if err != nil {
+			fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+		}
+	}
+	err = writePktLine(os.Stdout, pktLineTypeFlush, nil)
+	if err != nil {
+		fail("Internal Server Error", "Pkt-Line response failed: %v", err)
+	}
+	return nil
+}
+
+// git PKT-Line api
+// pktLineType message type of pkt-line
+type pktLineType int64
+
+const (
+	// UnKnow type
+	pktLineTypeUnknow pktLineType = 0
+	// flush-pkt "0000"
+	pktLineTypeFlush pktLineType = iota
+	// data line
+	pktLineTypeData
+)
+
+// gitPktLine pkt-line api
+type gitPktLine struct {
+	Type   pktLineType
+	Length int64
+	Data   string
+}
+
+func readPktLine(in *bufio.Reader) (r *gitPktLine, err error) {
+	// read prefix
+	lengthBytes := make([]byte, 4)
+	for i := 0; i < 4; i++ {
+		lengthBytes[i], err = in.ReadByte()
+		if err != nil {
+			return nil, err
+		}
+	}
+	r = new(gitPktLine)
+	r.Length, err = strconv.ParseInt(string(lengthBytes), 16, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	if r.Length == 0 {
+		r.Type = pktLineTypeFlush
+		return r, nil
+	}
+
+	if r.Length <= 4 || r.Length > 65520 {
+		r.Type = pktLineTypeUnknow
+		return r, nil
+	}
+
+	tmp := make([]byte, r.Length-4)
+	for i := range tmp {
+		tmp[i], err = in.ReadByte()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	r.Type = pktLineTypeData
+	r.Data = string(tmp)
+
+	return r, nil
+}
+
+func writePktLine(out io.Writer, typ pktLineType, data []byte) error {
+	if typ == pktLineTypeFlush {
+		l, err := out.Write([]byte("0000"))
+		if err != nil {
+			return err
+		}
+		if l != 4 {
+			return fmt.Errorf("real write length is different with request, want %v, real %v", 4, l)
+		}
+	}
+
+	if typ != pktLineTypeData {
+		return nil
+	}
+
+	l := len(data) + 4
+	tmp := []byte(fmt.Sprintf("%04x", l))
+	tmp = append(tmp, data...)
+
+	lr, err := out.Write(tmp)
+	if err != nil {
+		return err
+	}
+	if l != lr {
+		return fmt.Errorf("real write length is different with request, want %v, real %v", l, lr)
+	}
+
+	return nil
+}

cmd/hook_test.go

@@ -0,0 +1,41 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package cmd
+
+import (
+	"bufio"
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPktLine(t *testing.T) {
+	// test read
+	s := strings.NewReader("0000")
+	r := bufio.NewReader(s)
+	result, err := readPktLine(r)
+	assert.NoError(t, err)
+	assert.Equal(t, pktLineTypeFlush, result.Type)
+
+	s = strings.NewReader("0006a\n")
+	r = bufio.NewReader(s)
+	result, err = readPktLine(r)
+	assert.NoError(t, err)
+	assert.Equal(t, pktLineTypeData, result.Type)
+	assert.Equal(t, "a\n", result.Data)
+
+	// test write
+	w := bytes.NewBuffer([]byte{})
+	err = writePktLine(w, pktLineTypeFlush, nil)
+	assert.NoError(t, err)
+	assert.Equal(t, []byte("0000"), w.Bytes())
+
+	w.Reset()
+	err = writePktLine(w, pktLineTypeData, []byte("a\nb"))
+	assert.NoError(t, err)
+	assert.Equal(t, []byte("0007a\nb"), w.Bytes())
+}

cmd/serv.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"code.gitea.io/gitea/models"
+	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/lfs"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/pprof"
@@ -135,6 +136,13 @@ func runServ(c *cli.Context) error {
 	}
 
 	if len(words) < 2 {
+		if git.CheckGitVersionAtLeast("2.29") == nil {
+			// for AGit Flow
+			if cmd == "ssh_info" {
+				fmt.Print(`{"type":"gitea","version":1}`)
+				return nil
+			}
+		}
 		fail("Too few arguments", "Too few arguments in cmd: %s", cmd)
 	}
 
@@ -203,6 +211,11 @@ func runServ(c *cli.Context) error {
 		}
 	}
 
+	// Because of special ref "refs/for" .. , need delay write permission check
+	if git.CheckGitVersionAtLeast("2.29") == nil {
+		requestedMode = models.AccessModeRead
+	}
+
 	results, err := private.ServCommand(keyID, username, reponame, requestedMode, verb, lfsVerb)
 	if err != nil {
 		if private.IsErrServCommand(err) {

models/migrations/migrations.go

@@ -284,6 +284,8 @@ var migrations = []Migration{
 	NewMigration("Add user redirect", addUserRedirect),
 	// v168 -> v169
 	NewMigration("Recreate user table to fix default values", recreateUserTableToFixDefaultValues),
+	// v169 -> v170
+	NewMigration("Add agit style pull request support", addAgitStylePullRequest),
 }
 
 // GetCurrentDBVersion returns the current db version

models/migrations/v169.go

@@ -0,0 +1,25 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package migrations
+
+import (
+	"fmt"
+
+	"xorm.io/xorm"
+)
+
+func addAgitStylePullRequest(x *xorm.Engine) error {
+	type PullRequestStyle int
+
+	type PullRequest struct {
+		TopicBranch string
+		Style       PullRequestStyle
+	}
+
+	if err := x.Sync2(new(PullRequest)); err != nil {
+		return fmt.Errorf("Sync2: %v", err)
+	}
+	return nil
+}