Merge pull request #936 from aymanbagabas/more-packpv5.10.1

Respect pktline error-line errors

3 files changed, 224 insertions, 0 deletions

diff --git a/plumbing/protocol/packp/common.go b/plumbing/protocol/packp/common.go
index fef50a4..a858323 100644
--- a/plumbing/protocol/packp/common.go
+++ b/plumbing/protocol/packp/common.go
@@ -48,6 +48,11 @@ func isFlush(payload []byte) bool {
 	return len(payload) == 0
 }
 
+var (
+	// ErrNilWriter is returned when a nil writer is passed to the encoder.
+	ErrNilWriter = fmt.Errorf("nil writer")
+)
+
 // ErrUnexpectedData represents an unexpected data decoding a message
 type ErrUnexpectedData struct {
 	Msg  string
diff --git a/plumbing/protocol/packp/gitproto.go b/plumbing/protocol/packp/gitproto.go
new file mode 100644
index 0000000..0b7ff8f
--- /dev/null
+++ b/plumbing/protocol/packp/gitproto.go
@@ -0,0 +1,120 @@
+package packp
+
+import (
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/go-git/go-git/v5/plumbing/format/pktline"
+)
+
+var (
+	// ErrInvalidGitProtoRequest is returned by Decode if the input is not a
+	// valid git protocol request.
+	ErrInvalidGitProtoRequest = fmt.Errorf("invalid git protocol request")
+)
+
+// GitProtoRequest is a command request for the git protocol.
+// It is used to send the command, endpoint, and extra parameters to the
+// remote.
+// See https://git-scm.com/docs/pack-protocol#_git_transport
+type GitProtoRequest struct {
+	RequestCommand string
+	Pathname       string
+
+	// Optional
+	Host string
+
+	// Optional
+	ExtraParams []string
+}
+
+// validate validates the request.
+func (g *GitProtoRequest) validate() error {
+	if g.RequestCommand == "" {
+		return fmt.Errorf("%w: empty request command", ErrInvalidGitProtoRequest)
+	}
+
+	if g.Pathname == "" {
+		return fmt.Errorf("%w: empty pathname", ErrInvalidGitProtoRequest)
+	}
+
+	return nil
+}
+
+// Encode encodes the request into the writer.
+func (g *GitProtoRequest) Encode(w io.Writer) error {
+	if w == nil {
+		return ErrNilWriter
+	}
+
+	if err := g.validate(); err != nil {
+		return err
+	}
+
+	p := pktline.NewEncoder(w)
+	req := fmt.Sprintf("%s %s\x00", g.RequestCommand, g.Pathname)
+	if host := g.Host; host != "" {
+		req += fmt.Sprintf("host=%s\x00", host)
+	}
+
+	if len(g.ExtraParams) > 0 {
+		req += "\x00"
+		for _, param := range g.ExtraParams {
+			req += param + "\x00"
+		}
+	}
+
+	if err := p.Encode([]byte(req)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Decode decodes the request from the reader.
+func (g *GitProtoRequest) Decode(r io.Reader) error {
+	s := pktline.NewScanner(r)
+	if !s.Scan() {
+		err := s.Err()
+		if err == nil {
+			return ErrInvalidGitProtoRequest
+		}
+		return err
+	}
+
+	line := string(s.Bytes())
+	if len(line) == 0 {
+		return io.EOF
+	}
+
+	if line[len(line)-1] != 0 {
+		return fmt.Errorf("%w: missing null terminator", ErrInvalidGitProtoRequest)
+	}
+
+	parts := strings.SplitN(line, " ", 2)
+	if len(parts) != 2 {
+		return fmt.Errorf("%w: short request", ErrInvalidGitProtoRequest)
+	}
+
+	g.RequestCommand = parts[0]
+	params := strings.Split(parts[1], string(null))
+	if len(params) < 1 {
+		return fmt.Errorf("%w: missing pathname", ErrInvalidGitProtoRequest)
+	}
+
+	g.Pathname = params[0]
+	if len(params) > 1 {
+		g.Host = strings.TrimPrefix(params[1], "host=")
+	}
+
+	if len(params) > 2 {
+		for _, param := range params[2:] {
+			if param != "" {
+				g.ExtraParams = append(g.ExtraParams, param)
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/plumbing/protocol/packp/gitproto_test.go b/plumbing/protocol/packp/gitproto_test.go
new file mode 100644
index 0000000..9cf1049
--- /dev/null
+++ b/plumbing/protocol/packp/gitproto_test.go
@@ -0,0 +1,99 @@
+package packp
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestEncodeEmptyGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	var p GitProtoRequest
+	err := p.Encode(&buf)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestEncodeGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	p := GitProtoRequest{
+		RequestCommand: "command",
+		Pathname:       "pathname",
+		Host:           "host",
+		ExtraParams:    []string{"param1", "param2"},
+	}
+	err := p.Encode(&buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := "002ecommand pathname\x00host=host\x00\x00param1\x00param2\x00"
+	if buf.String() != expected {
+		t.Fatalf("expected %q, got %q", expected, buf.String())
+	}
+}
+
+func TestEncodeInvalidGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	p := GitProtoRequest{
+		RequestCommand: "command",
+	}
+	err := p.Encode(&buf)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestDecodeEmptyGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	var p GitProtoRequest
+	err := p.Decode(&buf)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestDecodeGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	buf.WriteString("002ecommand pathname\x00host=host\x00\x00param1\x00param2\x00")
+	var p GitProtoRequest
+	err := p.Decode(&buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := GitProtoRequest{
+		RequestCommand: "command",
+		Pathname:       "pathname",
+		Host:           "host",
+		ExtraParams:    []string{"param1", "param2"},
+	}
+	if p.RequestCommand != expected.RequestCommand {
+		t.Fatalf("expected %q, got %q", expected.RequestCommand, p.RequestCommand)
+	}
+	if p.Pathname != expected.Pathname {
+		t.Fatalf("expected %q, got %q", expected.Pathname, p.Pathname)
+	}
+	if p.Host != expected.Host {
+		t.Fatalf("expected %q, got %q", expected.Host, p.Host)
+	}
+	if len(p.ExtraParams) != len(expected.ExtraParams) {
+		t.Fatalf("expected %d, got %d", len(expected.ExtraParams), len(p.ExtraParams))
+	}
+}
+
+func TestDecodeInvalidGitProtoRequest(t *testing.T) {
+	var buf bytes.Buffer
+	buf.WriteString("0026command \x00host=host\x00\x00param1\x00param2")
+	var p GitProtoRequest
+	err := p.Decode(&buf)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestValidateEmptyGitProtoRequest(t *testing.T) {
+	var p GitProtoRequest
+	err := p.validate()
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}