Merged
fix: pak gzip-requests van smart HTTP uit
timfa
wants to merge
1 commit
from
cursor/gzip-smart-http-674d
into
master
Overview Commits 1 Pipelines 1 Changes 3
Git stuurt bij een smart-HTTP-POST groter dan 1024 bytes Content-Encoding: gzip. git http-backend pakt die body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is. Zonder die variabele kwam er een lege 200 terug, waardoor git fetch bleef hangen.
ServeSmartHTTP geeft gzip en x-gzip nu door. CONTENT_LENGTH blijft de gecomprimeerde lengte.
De test post een gzip-body naar git-upload-pack en cloont daarna met de standaard http.postBuffer, zodat git zelf gzip stuurt.
Activity
- timfa Pipeline #74 is Passed 23 October 2026
- timfa opened this merge request 23 October 2026
- timfa merged this merge request 23 October 2026
Commits
- fix: pak gzip-requests van smart HTTP uit
18fda33e69timfa
Pipelines
- #74 Passed
Changes
@@ -32,6 +32,15 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
32
32
if r.ContentLength >= 0 {
33
33
cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))
34
34
}
35
// Git comprimeert een smart-HTTP-POST met gzip zodra die groter is dan
36
// 1024 bytes en zet dan Content-Encoding: gzip. http-backend pakt de
37
// body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is.
38
// Zonder die variabele leest hij de gzip-bytes als pkt-lines en komt er
39
// een lege 200 terug. CONTENT_LENGTH blijft de gecomprimeerde lengte:
40
// daar leest inflate_request precies zoveel bytes van.
41
if enc := gzipContentEncoding(r.Header.Get("Content-Encoding")); enc != "" {
42
cmd.Env = append(cmd.Env, "HTTP_CONTENT_ENCODING="+enc)
43
}
35
44
cmd.Env = append(cmd.Env, extraEnv...)
36
45
cmd.Stdin = r.Body
37
46
stdout, err := cmd.StdoutPipe()
@@ -75,6 +84,24 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,
75
84
return nil
76
85
}
77
86
87
// gzipContentEncoding is de waarde voor HTTP_CONTENT_ENCODING.
88
// git http-backend herkent alleen "gzip" en "x-gzip", hoofdlettergevoelig.
89
func gzipContentEncoding(v string) string {
90
v = strings.TrimSpace(v)
91
if v == "" {
92
return ""
93
}
94
if i := strings.IndexByte(v, ','); i >= 0 {
95
v = strings.TrimSpace(v[:i])
96
}
97
switch strings.ToLower(v) {
98
case "gzip", "x-gzip":
99
return strings.ToLower(v)
100
default:
101
return ""
102
}
103
}
104
78
105
// ProjectRoot is de map waarin owner/naam.git staat.
79
106
func ProjectRoot(storage string) string {
80
107
return storage + "/repos"
@@ -32,6 +32,15 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,32
if r.ContentLength >= 0 {32
if r.ContentLength >= 0 {33
cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))33
cmd.Env = append(cmd.Env, "CONTENT_LENGTH="+strconv.FormatInt(r.ContentLength, 10))34
}34
}35
// Git comprimeert een smart-HTTP-POST met gzip zodra die groter is dan36
// 1024 bytes en zet dan Content-Encoding: gzip. http-backend pakt de37
// body alleen uit als de CGI-variabele HTTP_CONTENT_ENCODING gezet is.38
// Zonder die variabele leest hij de gzip-bytes als pkt-lines en komt er39
// een lege 200 terug. CONTENT_LENGTH blijft de gecomprimeerde lengte:40
// daar leest inflate_request precies zoveel bytes van.41
if enc := gzipContentEncoding(r.Header.Get("Content-Encoding")); enc != "" {42
cmd.Env = append(cmd.Env, "HTTP_CONTENT_ENCODING="+enc)43
}35
cmd.Env = append(cmd.Env, extraEnv...)44
cmd.Env = append(cmd.Env, extraEnv...)36
cmd.Stdin = r.Body45
cmd.Stdin = r.Body37
stdout, err := cmd.StdoutPipe()46
stdout, err := cmd.StdoutPipe()@@ -75,6 +84,24 @@ func ServeSmartHTTP(w http.ResponseWriter, r *http.Request, gitBin, projectRoot,75
return nil84
return nil76
}85
}77
86
87
// gzipContentEncoding is de waarde voor HTTP_CONTENT_ENCODING.88
// git http-backend herkent alleen "gzip" en "x-gzip", hoofdlettergevoelig.89
func gzipContentEncoding(v string) string {90
v = strings.TrimSpace(v)91
if v == "" {92
return ""93
}94
if i := strings.IndexByte(v, ','); i >= 0 {95
v = strings.TrimSpace(v[:i])96
}97
switch strings.ToLower(v) {98
case "gzip", "x-gzip":99
return strings.ToLower(v)100
default:101
return ""102
}103
}104
78
// ProjectRoot is de map waarin owner/naam.git staat.105
// ProjectRoot is de map waarin owner/naam.git staat.79
func ProjectRoot(storage string) string {106
func ProjectRoot(storage string) string {80
return storage + "/repos"107
return storage + "/repos"@@ -0,0 +1,21 @@
1
package gitrepo
2
3
import "testing"
4
5
func TestGzipContentEncoding(t *testing.T) {
6
cases := []struct{ in, want string }{
7
{"", ""},
8
{"identity", ""},
9
{"deflate", ""},
10
{"gzip", "gzip"},
11
{"GZIP", "gzip"},
12
{"x-gzip", "x-gzip"},
13
{"gzip, deflate", "gzip"},
14
{" gzip ", "gzip"},
15
}
16
for _, tc := range cases {
17
if got := gzipContentEncoding(tc.in); got != tc.want {
18
t.Errorf("%q: %q, verwacht %q", tc.in, got, tc.want)
19
}
20
}
21
}
@@ -0,0 +1,21 @@1
package gitrepo2
3
import "testing"4
5
func TestGzipContentEncoding(t *testing.T) {6
cases := []struct{ in, want string }{7
{"", ""},8
{"identity", ""},9
{"deflate", ""},10
{"gzip", "gzip"},11
{"GZIP", "gzip"},12
{"x-gzip", "x-gzip"},13
{"gzip, deflate", "gzip"},14
{" gzip ", "gzip"},15
}16
for _, tc := range cases {17
if got := gzipContentEncoding(tc.in); got != tc.want {18
t.Errorf("%q: %q, verwacht %q", tc.in, got, tc.want)19
}20
}21
}@@ -0,0 +1,181 @@
1
package server
2
3
import (
4
"bytes"
5
"compress/gzip"
6
"crypto/rand"
7
"encoding/base64"
8
"fmt"
9
"io"
10
"net/http"
11
"net/http/cookiejar"
12
"net/http/httptest"
13
"net/url"
14
"os"
15
"os/exec"
16
"path/filepath"
17
"strings"
18
"testing"
19
20
"gitlab.com/Timfa/bluegit/internal/auth"
21
"gitlab.com/Timfa/bluegit/internal/config"
22
"gitlab.com/Timfa/bluegit/internal/gitrepo"
23
"gitlab.com/Timfa/bluegit/internal/store"
24
)
25
26
func TestGzipSmartHTTP(t *testing.T) {
27
if why := gitHTTPGap(); why != "" {
28
t.Skip(why)
29
}
30
storage := t.TempDir()
31
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
32
if err != nil {
33
t.Fatal(err)
34
}
35
t.Cleanup(func() { _ = st.Close() })
36
cfg := config.Config{
37
BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
38
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},
39
Git: config.Git{Binary: "git", DefaultBranch: "master"},
40
}
41
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}
42
ts := httptest.NewServer(srv.Handler())
43
t.Cleanup(ts.Close)
44
45
jar, _ := cookiejar.New(nil)
46
client := &http.Client{Jar: jar}
47
res, err := client.Get(ts.URL + "/login")
48
if err != nil {
49
t.Fatal(err)
50
}
51
page := read(t, res)
52
res, err = client.PostForm(ts.URL+"/new/repo", url.Values{
53
"csrf": {csrfOf(t, page)}, "name": {"pakket"}, "visibility": {"public"},
54
})
55
if err != nil {
56
t.Fatal(err)
57
}
58
page = read(t, res)
59
res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{
60
"csrf": {csrfOf(t, page)}, "name": {"laptop"},
61
})
62
if err != nil {
63
t.Fatal(err)
64
}
65
token := between(read(t, res), `<p class="code">`, "</p>")
66
if !strings.HasPrefix(token, "bg_") {
67
t.Fatal("geen token")
68
}
69
70
bare := gitrepo.Dir(storage, "tim", "pakket")
71
work := t.TempDir()
72
gitPrep(t, work)
73
writeFile(t, filepath.Join(work, "leesmij.txt"), "hallo\n")
74
git(t, work, "add", "leesmij.txt")
75
git(t, work, "commit", "-m", "leesmij")
76
git(t, work, "remote", "add", "origin", bare)
77
git(t, work, "push", "origin", "master")
78
sha := revHEAD(t, work)
79
80
raw := uploadPackRequest(sha)
81
var compressed bytes.Buffer
82
zw := gzip.NewWriter(&compressed)
83
if _, err := zw.Write(raw); err != nil {
84
t.Fatal(err)
85
}
86
if err := zw.Close(); err != nil {
87
t.Fatal(err)
88
}
89
req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/pakket.git/git-upload-pack", bytes.NewReader(compressed.Bytes()))
90
if err != nil {
91
t.Fatal(err)
92
}
93
req.Header.Set("Content-Type", "application/x-git-upload-pack-request")
94
req.Header.Set("Accept", "application/x-git-upload-pack-result")
95
req.Header.Set("Content-Encoding", "gzip")
96
res, err = http.DefaultClient.Do(req)
97
if err != nil {
98
t.Fatal(err)
99
}
100
body, err := io.ReadAll(res.Body)
101
res.Body.Close()
102
if err != nil {
103
t.Fatal(err)
104
}
105
if res.StatusCode != http.StatusOK || len(body) == 0 || (!bytes.Contains(body, []byte("NAK")) && !bytes.Contains(body, []byte("PACK"))) {
106
t.Fatalf("gzip-POST: status %d, %d bytes, begin %q", res.StatusCode, len(body), body[:min(80, len(body))])
107
}
108
109
blob := make([]byte, 4096)
110
if _, err := rand.Read(blob); err != nil {
111
t.Fatal(err)
112
}
113
if err := os.WriteFile(filepath.Join(work, "groot.bin"), blob, 0o644); err != nil {
114
t.Fatal(err)
115
}
116
git(t, work, "add", "groot.bin")
117
git(t, work, "commit", "-m", "groot bestand")
118
remote := ts.URL + "/tim/pakket.git"
119
git(t, work, "remote", "set-url", "origin", remote)
120
auth := "Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte("git:"+token))
121
// git push over protocol v1 zet zelf geen Content-Encoding. De aanroep
122
// laat http.postBuffer op de standaard staan: een grote body mag niet
123
// blijven hangen.
124
gitTrace(t, work, auth, "push", "origin", "master")
125
126
for i := 0; i < 40; i++ {
127
git(t, work, "branch", fmt.Sprintf("tak-%02d", i))
128
}
129
gitTrace(t, work, auth, "push", "origin", "--all")
130
131
// Clone vraagt elke branch. Dat verzoek is groter dan 1024 bytes, dus
132
// git stuurt Content-Encoding: gzip. Zonder uitpakken is de clone leeg.
133
clone := t.TempDir()
134
fetchTrace := gitTrace(t, clone, auth, "clone", remote, "kopie")
135
if !strings.Contains(fetchTrace, "Content-Encoding: gzip") {
136
t.Fatalf("git fetch/clone stuurde geen gzip:\n%s", redactTrace(fetchTrace))
137
}
138
if _, err := os.Stat(filepath.Join(clone, "kopie", "groot.bin")); err != nil {
139
t.Fatal(err)
140
}
141
}
142
143
func uploadPackRequest(sha string) []byte {
144
want := fmt.Sprintf("want %s multi_ack_detailed no-done side-band-64k ofs-delta\n", sha)
145
done := "done\n"
146
pkt := func(s string) []byte {
147
return []byte(fmt.Sprintf("%04x%s", len(s)+4, s))
148
}
149
var raw []byte
150
raw = append(raw, pkt(want)...)
151
raw = append(raw, []byte("0000")...)
152
raw = append(raw, pkt(done)...)
153
return raw
154
}
155
156
func gitTrace(t *testing.T, dir, auth string, args ...string) string {
157
t.Helper()
158
if why := gitHTTPGap(); why != "" {
159
t.Skip(why)
160
}
161
cmd := exec.Command("git", append([]string{"-c", "http.extraHeader=" + auth}, args...)...)
162
cmd.Dir = dir
163
cmd.Env = append(os.Environ(), "GIT_CURL_VERBOSE=1", "GIT_TERMINAL_PROMPT=0")
164
out, err := cmd.CombinedOutput()
165
if err != nil {
166
t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, redactTrace(string(out)))
167
}
168
return string(out)
169
}
170
171
func redactTrace(s string) string {
172
var b strings.Builder
173
for _, line := range strings.Split(s, "\n") {
174
if strings.Contains(line, "Authorization:") || strings.Contains(line, "bg_") {
175
continue
176
}
177
b.WriteString(line)
178
b.WriteByte('\n')
179
}
180
return b.String()
181
}
@@ -0,0 +1,181 @@1
package server2
3
import (4
"bytes"5
"compress/gzip"6
"crypto/rand"7
"encoding/base64"8
"fmt"9
"io"10
"net/http"11
"net/http/cookiejar"12
"net/http/httptest"13
"net/url"14
"os"15
"os/exec"16
"path/filepath"17
"strings"18
"testing"19
20
"gitlab.com/Timfa/bluegit/internal/auth"21
"gitlab.com/Timfa/bluegit/internal/config"22
"gitlab.com/Timfa/bluegit/internal/gitrepo"23
"gitlab.com/Timfa/bluegit/internal/store"24
)25
26
func TestGzipSmartHTTP(t *testing.T) {27
if why := gitHTTPGap(); why != "" {28
t.Skip(why)29
}30
storage := t.TempDir()31
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())32
if err != nil {33
t.Fatal(err)34
}35
t.Cleanup(func() { _ = st.Close() })36
cfg := config.Config{37
BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,38
Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test"},39
Git: config.Git{Binary: "git", DefaultBranch: "master"},40
}41
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", HookBin: "/bin/true"}42
ts := httptest.NewServer(srv.Handler())43
t.Cleanup(ts.Close)44
45
jar, _ := cookiejar.New(nil)46
client := &http.Client{Jar: jar}47
res, err := client.Get(ts.URL + "/login")48
if err != nil {49
t.Fatal(err)50
}51
page := read(t, res)52
res, err = client.PostForm(ts.URL+"/new/repo", url.Values{53
"csrf": {csrfOf(t, page)}, "name": {"pakket"}, "visibility": {"public"},54
})55
if err != nil {56
t.Fatal(err)57
}58
page = read(t, res)59
res, err = client.PostForm(ts.URL+"/settings/tokens", url.Values{60
"csrf": {csrfOf(t, page)}, "name": {"laptop"},61
})62
if err != nil {63
t.Fatal(err)64
}65
token := between(read(t, res), `<p class="code">`, "</p>")66
if !strings.HasPrefix(token, "bg_") {67
t.Fatal("geen token")68
}69
70
bare := gitrepo.Dir(storage, "tim", "pakket")71
work := t.TempDir()72
gitPrep(t, work)73
writeFile(t, filepath.Join(work, "leesmij.txt"), "hallo\n")74
git(t, work, "add", "leesmij.txt")75
git(t, work, "commit", "-m", "leesmij")76
git(t, work, "remote", "add", "origin", bare)77
git(t, work, "push", "origin", "master")78
sha := revHEAD(t, work)79
80
raw := uploadPackRequest(sha)81
var compressed bytes.Buffer82
zw := gzip.NewWriter(&compressed)83
if _, err := zw.Write(raw); err != nil {84
t.Fatal(err)85
}86
if err := zw.Close(); err != nil {87
t.Fatal(err)88
}89
req, err := http.NewRequest(http.MethodPost, ts.URL+"/tim/pakket.git/git-upload-pack", bytes.NewReader(compressed.Bytes()))90
if err != nil {91
t.Fatal(err)92
}93
req.Header.Set("Content-Type", "application/x-git-upload-pack-request")94
req.Header.Set("Accept", "application/x-git-upload-pack-result")95
req.Header.Set("Content-Encoding", "gzip")96
res, err = http.DefaultClient.Do(req)97
if err != nil {98
t.Fatal(err)99
}100
body, err := io.ReadAll(res.Body)101
res.Body.Close()102
if err != nil {103
t.Fatal(err)104
}105
if res.StatusCode != http.StatusOK || len(body) == 0 || (!bytes.Contains(body, []byte("NAK")) && !bytes.Contains(body, []byte("PACK"))) {106
t.Fatalf("gzip-POST: status %d, %d bytes, begin %q", res.StatusCode, len(body), body[:min(80, len(body))])107
}108
109
blob := make([]byte, 4096)110
if _, err := rand.Read(blob); err != nil {111
t.Fatal(err)112
}113
if err := os.WriteFile(filepath.Join(work, "groot.bin"), blob, 0o644); err != nil {114
t.Fatal(err)115
}116
git(t, work, "add", "groot.bin")117
git(t, work, "commit", "-m", "groot bestand")118
remote := ts.URL + "/tim/pakket.git"119
git(t, work, "remote", "set-url", "origin", remote)120
auth := "Authorization: Basic " + base64.StdEncoding.EncodeToString([]byte("git:"+token))121
// git push over protocol v1 zet zelf geen Content-Encoding. De aanroep122
// laat http.postBuffer op de standaard staan: een grote body mag niet123
// blijven hangen.124
gitTrace(t, work, auth, "push", "origin", "master")125
126
for i := 0; i < 40; i++ {127
git(t, work, "branch", fmt.Sprintf("tak-%02d", i))128
}129
gitTrace(t, work, auth, "push", "origin", "--all")130
131
// Clone vraagt elke branch. Dat verzoek is groter dan 1024 bytes, dus132
// git stuurt Content-Encoding: gzip. Zonder uitpakken is de clone leeg.133
clone := t.TempDir()134
fetchTrace := gitTrace(t, clone, auth, "clone", remote, "kopie")135
if !strings.Contains(fetchTrace, "Content-Encoding: gzip") {136
t.Fatalf("git fetch/clone stuurde geen gzip:\n%s", redactTrace(fetchTrace))137
}138
if _, err := os.Stat(filepath.Join(clone, "kopie", "groot.bin")); err != nil {139
t.Fatal(err)140
}141
}142
143
func uploadPackRequest(sha string) []byte {144
want := fmt.Sprintf("want %s multi_ack_detailed no-done side-band-64k ofs-delta\n", sha)145
done := "done\n"146
pkt := func(s string) []byte {147
return []byte(fmt.Sprintf("%04x%s", len(s)+4, s))148
}149
var raw []byte150
raw = append(raw, pkt(want)...)151
raw = append(raw, []byte("0000")...)152
raw = append(raw, pkt(done)...)153
return raw154
}155
156
func gitTrace(t *testing.T, dir, auth string, args ...string) string {157
t.Helper()158
if why := gitHTTPGap(); why != "" {159
t.Skip(why)160
}161
cmd := exec.Command("git", append([]string{"-c", "http.extraHeader=" + auth}, args...)...)162
cmd.Dir = dir163
cmd.Env = append(os.Environ(), "GIT_CURL_VERBOSE=1", "GIT_TERMINAL_PROMPT=0")164
out, err := cmd.CombinedOutput()165
if err != nil {166
t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, redactTrace(string(out)))167
}168
return string(out)169
}170
171
func redactTrace(s string) string {172
var b strings.Builder173
for _, line := range strings.Split(s, "\n") {174
if strings.Contains(line, "Authorization:") || strings.Contains(line, "bg_") {175
continue176
}177
b.WriteString(line)178
b.WriteByte('\n')179
}180
return b.String()181
}