1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100
101. 101
102. 102
103. 103
104. 104
105. 105
106. 106
107. 107
108. 108
109. 109
110. 110
111. 111
112. 112
113. 113
114. 114
115. 115
116. 116
117. 117
118. 118
119. 119
120. 120
121. 121

package service

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"net/http"
	"os/exec"
	"strings"
	"syscall"
)

// Mostly from charmbracelet/soft-serve and sosedoff/gitkit.

type ServiceCommand struct {
	Dir    string
	Stdin  io.Reader
	Stdout http.ResponseWriter
}

func (c *ServiceCommand) InfoRefs() error {
	cmd := exec.Command("git", []string{
		"upload-pack",
		"--stateless-rpc",
		"--advertise-refs",
		".",
	}...)

	cmd.Dir = c.Dir
	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	stdoutPipe, _ := cmd.StdoutPipe()
	cmd.Stderr = cmd.Stdout

	if err := cmd.Start(); err != nil {
		log.Printf("git: failed to start git-upload-pack (info/refs): %s", err)
		return err
	}

	if err := packLine(c.Stdout, "# service=git-upload-pack\n"); err != nil {
		log.Printf("git: failed to write pack line: %s", err)
		return err
	}

	if err := packFlush(c.Stdout); err != nil {
		log.Printf("git: failed to flush pack: %s", err)
		return err
	}

	buf := bytes.Buffer{}
	if _, err := io.Copy(&buf, stdoutPipe); err != nil {
		log.Printf("git: failed to copy stdout to tmp buffer: %s", err)
		return err
	}

	if err := cmd.Wait(); err != nil {
		out := strings.Builder{}
		_, _ = io.Copy(&out, &buf)
		log.Printf("git: failed to run git-upload-pack; err: %s; output: %s", err, out.String())
		return err
	}

	if _, err := io.Copy(c.Stdout, &buf); err != nil {
		log.Printf("git: failed to copy stdout: %s", err)
	}

	return nil
}

func (c *ServiceCommand) UploadPack() error {
	cmd := exec.Command("git", []string{
		"-c", "uploadpack.allowFilter=true",
		"upload-pack",
		"--stateless-rpc",
		".",
	}...)
	cmd.Dir = c.Dir
	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

	stdoutPipe, _ := cmd.StdoutPipe()
	cmd.Stderr = cmd.Stdout
	defer stdoutPipe.Close()

	stdinPipe, err := cmd.StdinPipe()
	if err != nil {
		return err
	}
	defer stdinPipe.Close()

	if err := cmd.Start(); err != nil {
		log.Printf("git: failed to start git-upload-pack: %s", err)
		return err
	}

	if _, err := io.Copy(stdinPipe, c.Stdin); err != nil {
		log.Printf("git: failed to copy stdin: %s", err)
		return err
	}
	stdinPipe.Close()

	if _, err := io.Copy(newWriteFlusher(c.Stdout), stdoutPipe); err != nil {
		log.Printf("git: failed to copy stdout: %s", err)
		return err
	}
	if err := cmd.Wait(); err != nil {
		log.Printf("git: failed to wait for git-upload-pack: %s", err)
		return err
	}

	return nil
}

func packLine(w io.Writer, s string) error {
	_, err := fmt.Fprintf(w, "%04x%s", len(s)+4, s)
	return err
}

func packFlush(w io.Writer) error {
	_, err := fmt.Fprint(w, "0000")
	return err
}