From 9b17278aece47aca17d32a37f67b7078708e78be Mon Sep 17 00:00:00 2001
From: Runxi Yu <me@runxiyu.org>
Date: Sat, 05 Apr 2025 17:21:14 +0800
Subject: [PATCH] Refactor git2d comms to ./git2c

---
 git2c/cmd1.go             |  60 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 git2c/cmd2.go             |  89 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 git2c/git2c.go            |  39 +++++++++++++++++++++++++++++++++++++++
 git2c/git_types.go        |  22 ++++++++++++++++++++++
 http_handle_repo_index.go |  71 ++++++-----------------------------------------------
 http_handle_repo_raw.go   | 119 ++++++++---------------------------------------------
 http_handle_repo_tree.go  | 117 ++++++++---------------------------------------------
 resources.go              |   4 +---

diff --git a/git2c/cmd1.go b/git2c/cmd1.go
new file mode 100644
index 0000000000000000000000000000000000000000..ba59b5ae977fa0c626fa2d191056f664862d5982
--- /dev/null
+++ b/git2c/cmd1.go
@@ -0,0 +1,60 @@
+package git2c
+
+import (
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+)
+
+func (c *Client) Cmd1(repoPath string) ([]Commit, *FilenameContents, error) {
+	if err := c.writer.WriteData([]byte(repoPath)); err != nil {
+		return nil, nil, fmt.Errorf("sending repo path failed: %w", err)
+	}
+	if err := c.writer.WriteUint(1); err != nil {
+		return nil, nil, fmt.Errorf("sending command failed: %w", err)
+	}
+
+	status, err := c.reader.ReadUint()
+	if err != nil {
+		return nil, nil, fmt.Errorf("reading status failed: %w", err)
+	}
+	if status != 0 {
+		return nil, nil, fmt.Errorf("git2d error: %d", status)
+	}
+
+	// README
+	readmeRaw, err := c.reader.ReadData()
+	if err != nil {
+		readmeRaw = nil
+	}
+
+	readmeFilename := "README.md" // TODO
+	readme := &FilenameContents{Filename: readmeFilename, Content: readmeRaw}
+
+	// Commits
+	var commits []Commit
+	for {
+		id, err := c.reader.ReadData()
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break
+			}
+			return nil, nil, fmt.Errorf("reading commit ID failed: %w", err)
+		}
+		title, _ := c.reader.ReadData()
+		authorName, _ := c.reader.ReadData()
+		authorEmail, _ := c.reader.ReadData()
+		authorDate, _ := c.reader.ReadData()
+
+		commits = append(commits, Commit{
+			Hash:    hex.EncodeToString(id),
+			Author:  string(authorName),
+			Email:   string(authorEmail),
+			Date:    string(authorDate),
+			Message: string(title),
+		})
+	}
+
+	return commits, readme, nil
+}
diff --git a/git2c/cmd2.go b/git2c/cmd2.go
new file mode 100644
index 0000000000000000000000000000000000000000..067137256f519c8a469d26ff98e598ddd543cffa
--- /dev/null
+++ b/git2c/cmd2.go
@@ -0,0 +1,89 @@
+package git2c
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+func (c *Client) Cmd2(repoPath, pathSpec string) ([]TreeEntry, string, error) {
+	if err := c.writer.WriteData([]byte(repoPath)); err != nil {
+		return nil, "", fmt.Errorf("sending repo path failed: %w", err)
+	}
+	if err := c.writer.WriteUint(2); err != nil {
+		return nil, "", fmt.Errorf("sending command failed: %w", err)
+	}
+	if err := c.writer.WriteData([]byte(pathSpec)); err != nil {
+		return nil, "", fmt.Errorf("sending path failed: %w", err)
+	}
+
+	status, err := c.reader.ReadUint()
+	if err != nil {
+		return nil, "", fmt.Errorf("reading status failed: %w", err)
+	}
+
+	switch status {
+	case 0:
+		kind, err := c.reader.ReadUint()
+		if err != nil {
+			return nil, "", fmt.Errorf("reading object kind failed: %w", err)
+		}
+
+		switch kind {
+		case 1:
+			// Tree
+			count, err := c.reader.ReadUint()
+			if err != nil {
+				return nil, "", fmt.Errorf("reading entry count failed: %w", err)
+			}
+
+			var files []TreeEntry
+			for i := 0; i < int(count); i++ {
+				typeCode, err := c.reader.ReadUint()
+				if err != nil {
+					return nil, "", fmt.Errorf("error reading entry type: %w", err)
+				}
+				mode, err := c.reader.ReadUint()
+				if err != nil {
+					return nil, "", fmt.Errorf("error reading entry mode: %w", err)
+				}
+				size, err := c.reader.ReadUint()
+				if err != nil {
+					return nil, "", fmt.Errorf("error reading entry size: %w", err)
+				}
+				name, err := c.reader.ReadData()
+				if err != nil {
+					return nil, "", fmt.Errorf("error reading entry name: %w", err)
+				}
+
+				files = append(files, TreeEntry{
+					Name:      string(name),
+					Mode:      fmt.Sprintf("%06o", mode),
+					Size:      size,
+					IsFile:    typeCode == 2,
+					IsSubtree: typeCode == 1,
+				})
+			}
+
+			return files, "", nil
+
+		case 2:
+			// Blob
+			content, err := c.reader.ReadData()
+			if err != nil && !errors.Is(err, io.EOF) {
+				return nil, "", fmt.Errorf("error reading file content: %w", err)
+			}
+
+			return nil, string(content), nil
+
+		default:
+			return nil, "", fmt.Errorf("unknown kind: %d", kind)
+		}
+
+	case 3:
+		return nil, "", fmt.Errorf("path not found: %s", pathSpec)
+
+	default:
+		return nil, "", fmt.Errorf("unknown status code: %d", status)
+	}
+}
diff --git a/git2c/git2c.go b/git2c/git2c.go
new file mode 100644
index 0000000000000000000000000000000000000000..c4c3ab48d66f590c1781c283a218bfe3cda81a39
--- /dev/null
+++ b/git2c/git2c.go
@@ -0,0 +1,39 @@
+package git2c
+
+import (
+	"fmt"
+	"net"
+
+	"git.sr.ht/~sircmpwn/go-bare"
+)
+
+type Client struct {
+	SocketPath string
+	conn       net.Conn
+	writer     *bare.Writer
+	reader     *bare.Reader
+}
+
+func NewClient(socketPath string) (*Client, error) {
+	conn, err := net.Dial("unix", socketPath)
+	if err != nil {
+		return nil, fmt.Errorf("git2d connection failed: %w", err)
+	}
+
+	writer := bare.NewWriter(conn)
+	reader := bare.NewReader(conn)
+
+	return &Client{
+		SocketPath: socketPath,
+		conn:       conn,
+		writer:     writer,
+		reader:     reader,
+	}, nil
+}
+
+func (c *Client) Close() error {
+	if c.conn != nil {
+		return c.conn.Close()
+	}
+	return nil
+}
diff --git a/git2c/git_types.go b/git2c/git_types.go
new file mode 100644
index 0000000000000000000000000000000000000000..da90db6df96bc55df21d98d81951ca1279998f5c
--- /dev/null
+++ b/git2c/git_types.go
@@ -0,0 +1,22 @@
+package git2c
+
+type Commit struct {
+	Hash    string
+	Author  string
+	Email   string
+	Date    string
+	Message string
+}
+
+type FilenameContents struct {
+	Filename string
+	Content  []byte
+}
+
+type TreeEntry struct {
+	Name      string
+	Mode      string
+	Size      uint64
+	IsFile    bool
+	IsSubtree bool
+}
diff --git a/http_handle_repo_index.go b/http_handle_repo_index.go
index 8f0a62b6586abf9ab584cf57374017f00a529d86..182b5dffcb9eb80ba2cb2a77b114f57f7d5fbdb7 100644
--- a/http_handle_repo_index.go
+++ b/http_handle_repo_index.go
@@ -4,15 +4,10 @@
 package main
 
 import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"net"
 	"net/http"
 	"strings"
 
-	"git.sr.ht/~sircmpwn/go-bare"
+	"go.lindenii.runxiyu.org/forge/git2c"
 )
 
 type commitDisplay struct {
@@ -35,72 +30,22 @@ 	if strings.Contains(repoName, "\n") || sliceContainsNewlines(groupPath) {
 		notes = append(notes, "Path contains newlines; HTTP Git access impossible")
 	}
 
-	conn, err := net.Dial("unix", config.Git.Socket)
+	client, err := git2c.NewClient(config.Git.Socket)
 	if err != nil {
-		errorPage500(w, params, "git2d connection failed: "+err.Error())
-		return
-	}
-	defer conn.Close()
-
-	writer := bare.NewWriter(conn)
-	reader := bare.NewReader(conn)
-
-	if err := writer.WriteData(stringToBytes(repoPath)); err != nil {
-		errorPage500(w, params, "sending repo path failed: "+err.Error())
+		errorPage500(w, params, err.Error())
 		return
 	}
+	defer client.Close()
 
-	if err := writer.WriteUint(1); err != nil {
-		errorPage500(w, params, "sending command failed: "+err.Error())
-		return
-	}
-
-	status, err := reader.ReadUint()
+	commits, readme, err := client.Cmd1(repoPath)
 	if err != nil {
-		errorPage500(w, params, "reading status failed: "+err.Error())
-		return
-	}
-	if status != 0 {
-		errorPage500(w, params, fmt.Sprintf("git2d error: %d", status))
+		errorPage500(w, params, err.Error())
 		return
 	}
 
-	// README
-	readmeRaw, err := reader.ReadData()
-	if err != nil {
-		readmeRaw = nil
-	}
-	readmeFilename, readmeRendered := renderReadme(readmeRaw, "README.md")
-
-	// Commits
-	var commits []commitDisplay
-	for {
-		id, err := reader.ReadData()
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-			errorPage500(w, params, "error reading commit ID: "+err.Error())
-			return
-		}
-
-		title, _ := reader.ReadData()
-		authorName, _ := reader.ReadData()
-		authorEmail, _ := reader.ReadData()
-		authorDate, _ := reader.ReadData()
-
-		commits = append(commits, commitDisplay{
-			Hash:    hex.EncodeToString(id),
-			Author:  bytesToString(authorName),
-			Email:   bytesToString(authorEmail),
-			Date:    bytesToString(authorDate),
-			Message: bytesToString(title),
-		})
-	}
-
 	params["commits"] = commits
-	params["readme_filename"] = readmeFilename
-	params["readme"] = readmeRendered
+	params["readme_filename"] = readme.Filename
+	_, params["readme"] = renderReadme(readme.Content, readme.Filename)
 	params["notes"] = notes
 
 	renderTemplate(w, "repo_index", params)
diff --git a/http_handle_repo_raw.go b/http_handle_repo_raw.go
index d12fa392d81abac1417dc30ad12b1b1a44ed3844..54ca931ba0721d173fe951db74595551c578bf10 100644
--- a/http_handle_repo_raw.go
+++ b/http_handle_repo_raw.go
@@ -4,15 +4,12 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"html/template"
-	"io"
-	"net"
 	"net/http"
 	"strings"
 
-	"git.sr.ht/~sircmpwn/go-bare"
+	"go.lindenii.runxiyu.org/forge/git2c"
 )
 
 // httpHandleRepoRaw serves raw files, or directory listings that point to raw
@@ -26,113 +23,31 @@ 	params["path_spec"] = pathSpec
 
 	_, repoPath, _, _, _, _, _ := getRepoInfo(request.Context(), groupPath, repoName, "")
 
-	conn, err := net.Dial("unix", config.Git.Socket)
+	client, err := git2c.NewClient(config.Git.Socket)
 	if err != nil {
-		errorPage500(writer, params, "git2d connection failed: "+err.Error())
-		return
-	}
-	defer conn.Close()
-
-	brWriter := bare.NewWriter(conn)
-	brReader := bare.NewReader(conn)
-
-	if err := brWriter.WriteData(stringToBytes(repoPath)); err != nil {
-		errorPage500(writer, params, "sending repo path failed: "+err.Error())
-		return
-	}
-	if err := brWriter.WriteUint(2); err != nil {
-		errorPage500(writer, params, "sending command failed: "+err.Error())
+		errorPage500(writer, params, err.Error())
 		return
 	}
-	if err := brWriter.WriteData(stringToBytes(pathSpec)); err != nil {
-		errorPage500(writer, params, "sending path failed: "+err.Error())
-		return
-	}
+	defer client.Close()
 
-	status, err := brReader.ReadUint()
+	files, content, err := client.Cmd2(repoPath, pathSpec)
 	if err != nil {
-		errorPage500(writer, params, "reading status failed: "+err.Error())
+		errorPage500(writer, params, err.Error())
 		return
 	}
 
-	switch status {
-	case 0:
-		kind, err := brReader.ReadUint()
-		if err != nil {
-			errorPage500(writer, params, "reading object kind failed: "+err.Error())
+	if files != nil {
+		params["files"] = files
+		params["readme_filename"] = "README.md"
+		params["readme"] = template.HTML("<p>README rendering here is WIP again</p>") // TODO
+		renderTemplate(writer, "repo_raw_dir", params)
+	} else if content != "" {
+		if redirectNoDir(writer, request) {
 			return
 		}
-
-		switch kind {
-		case 1:
-			// Tree
-			if redirectDir(writer, request) {
-				return
-			}
-			count, err := brReader.ReadUint()
-			if err != nil {
-				errorPage500(writer, params, "reading entry count failed: "+err.Error())
-				return
-			}
-
-			files := make([]displayTreeEntry, 0, count)
-			for range count {
-				typeCode, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry type: "+err.Error())
-					return
-				}
-				mode, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry mode: "+err.Error())
-					return
-				}
-				size, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry size: "+err.Error())
-					return
-				}
-				name, err := brReader.ReadData()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry name: "+err.Error())
-					return
-				}
-				files = append(files, displayTreeEntry{
-					Name:      bytesToString(name),
-					Mode:      fmt.Sprintf("%06o", mode),
-					Size:      size,
-					IsFile:    typeCode == 2,
-					IsSubtree: typeCode == 1,
-				})
-			}
-
-			params["files"] = files
-			params["readme_filename"] = "README.md"
-			params["readme"] = template.HTML("<p>README rendering here is WIP again</p>") // TODO
-
-			renderTemplate(writer, "repo_raw_dir", params)
-
-		case 2:
-			// Blob
-			if redirectNoDir(writer, request) {
-				return
-			}
-			content, err := brReader.ReadData()
-			if err != nil && !errors.Is(err, io.EOF) {
-				errorPage500(writer, params, "error reading blob content: "+err.Error())
-				return
-			}
-			writer.Header().Set("Content-Type", "application/octet-stream")
-			fmt.Fprint(writer, bytesToString(content))
-
-		default:
-			errorPage500(writer, params, fmt.Sprintf("unknown object kind: %d", kind))
-		}
-
-	case 3:
-		errorPage500(writer, params, "path not found: "+pathSpec)
-
-	default:
-		errorPage500(writer, params, fmt.Sprintf("unknown status code: %d", status))
+		writer.Header().Set("Content-Type", "application/octet-stream")
+		fmt.Fprint(writer, content)
+	} else {
+		errorPage500(writer, params, "Unknown error fetching repo raw data")
 	}
 }
diff --git a/http_handle_repo_tree.go b/http_handle_repo_tree.go
index 347026dd2c12a024687c885bd56f4bc811a61cd0..d577f4842d2891626f627bdd42bea4d1918e0c8d 100644
--- a/http_handle_repo_tree.go
+++ b/http_handle_repo_tree.go
@@ -4,15 +4,11 @@
 package main
 
 import (
-	"errors"
-	"fmt"
 	"html/template"
-	"io"
-	"net"
 	"net/http"
 	"strings"
 
-	"git.sr.ht/~sircmpwn/go-bare"
+	"go.lindenii.runxiyu.org/forge/git2c"
 )
 
 // httpHandleRepoTree provides a friendly, syntax-highlighted view of
@@ -28,108 +24,29 @@ 	params["path_spec"] = pathSpec
 
 	_, repoPath, _, _, _, _, _ := getRepoInfo(request.Context(), groupPath, repoName, "")
 
-	conn, err := net.Dial("unix", config.Git.Socket)
+	client, err := git2c.NewClient(config.Git.Socket)
 	if err != nil {
-		errorPage500(writer, params, "git2d connection failed: "+err.Error())
-		return
-	}
-	defer conn.Close()
-
-	brWriter := bare.NewWriter(conn)
-	brReader := bare.NewReader(conn)
-
-	if err := brWriter.WriteData(stringToBytes(repoPath)); err != nil {
-		errorPage500(writer, params, "sending repo path failed: "+err.Error())
+		errorPage500(writer, params, err.Error())
 		return
 	}
-	if err := brWriter.WriteUint(2); err != nil {
-		errorPage500(writer, params, "sending command failed: "+err.Error())
-		return
-	}
-	if err := brWriter.WriteData(stringToBytes(pathSpec)); err != nil {
-		errorPage500(writer, params, "sending path failed: "+err.Error())
-		return
-	}
+	defer client.Close()
 
-	status, err := brReader.ReadUint()
+	files, content, err := client.Cmd2(repoPath, pathSpec)
 	if err != nil {
-		errorPage500(writer, params, "reading status failed: "+err.Error())
+		errorPage500(writer, params, err.Error())
 		return
 	}
 
-	switch status {
-	case 0:
-		kind, err := brReader.ReadUint()
-		if err != nil {
-			errorPage500(writer, params, "reading object kind failed: "+err.Error())
-			return
-		}
-
-		switch kind {
-		case 1:
-			// Tree
-			count, err := brReader.ReadUint()
-			if err != nil {
-				errorPage500(writer, params, "reading entry count failed: "+err.Error())
-				return
-			}
-			files := make([]displayTreeEntry, 0, count)
-			for range count {
-				typeCode, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry type: "+err.Error())
-					return
-				}
-				mode, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry mode: "+err.Error())
-					return
-				}
-				size, err := brReader.ReadUint()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry size: "+err.Error())
-					return
-				}
-				name, err := brReader.ReadData()
-				if err != nil {
-					errorPage500(writer, params, "error reading entry name: "+err.Error())
-					return
-				}
-
-				files = append(files, displayTreeEntry{
-					Name:      bytesToString(name),
-					Mode:      fmt.Sprintf("%06o", mode),
-					Size:      size,
-					IsFile:    typeCode == 2,
-					IsSubtree: typeCode == 1,
-				})
-			}
-			params["files"] = files
-			params["readme_filename"] = "README.md"
-			params["readme"] = template.HTML("<p>README rendering here is WIP again</p>") // TODO
-			renderTemplate(writer, "repo_tree_dir", params)
-
-		case 2:
-			// Blob
-			content, err := brReader.ReadData()
-			if err != nil && !errors.Is(err, io.EOF) {
-				errorPage500(writer, params, "error reading file content: "+err.Error())
-				return
-			}
-			rendered := renderHighlightedFile(pathSpec, bytesToString(content))
-			params["file_contents"] = rendered
-			renderTemplate(writer, "repo_tree_file", params)
-
-		default:
-			errorPage500(writer, params, fmt.Sprintf("unknown kind: %d", kind))
-			return
-		}
-
-	case 3:
-		errorPage500(writer, params, "path not found: "+pathSpec)
-		return
-
-	default:
-		errorPage500(writer, params, fmt.Sprintf("unknown status code: %d", status))
+	if files != nil {
+		params["files"] = files
+		params["readme_filename"] = "README.md"
+		params["readme"] = template.HTML("<p>README rendering here is WIP again</p>") // TODO
+		renderTemplate(writer, "repo_tree_dir", params)
+	} else if content != "" {
+		rendered := renderHighlightedFile(pathSpec, content)
+		params["file_contents"] = rendered
+		renderTemplate(writer, "repo_tree_file", params)
+	} else {
+		errorPage500(writer, params, "Unknown object type, something is seriously wrong")
 	}
 }
diff --git a/resources.go b/resources.go
index 48e8ff44120e3e8e0b3ceb1e778febe615f845b2..0bb033ae2eda1c890c83b80b6abe848ce734df6e 100644
--- a/resources.go
+++ b/resources.go
@@ -69,9 +69,7 @@ 	})
 	return err
 }
 
-var (
-	staticHandler http.Handler
-)
+var staticHandler http.Handler
 
 // This init sets up static handlers. The resulting handlers must be
 // used in the HTTP router, and do nothing unless called from elsewhere.

-- 
2.48.1