gitoria

7.9 KB

1. // transport.hl — CLONE, FETCH AND PUSH OVER HTTPS (ticket gitoria#7; docs/git-backend.md). Git's "smart HTTP" protocol,
2. // answered by this app itself with the `git` binary: on a repo address `<slug>.<domain>` the paths
3. // /<slug>.git/info/refs?service=git-upload-pack | git-receive-pack (what a client asks first)
4. // /<slug>.git/git-upload-pack (fetch / clone) /<slug>.git/git-receive-pack (push)
5. // spawn `git upload-pack | receive-pack --stateless-rpc` and hand the request body over and the answer back.
6. // The clone URL is https://<slug>.<domain>/<slug>.git — the folder git makes is named like the repo.
7. // * READ (clone, fetch) needs no login: every repo is public (the concept has no private repos yet).
8. // * WRITE (push) needs a token as the password (tokens.hl) of THE REPO'S OWNER — nobody else may push (decision below).
9. // * The body travels through temp files, byte for byte (a String here holds raw bytes; hl:fs writes and reads them as
10. // they are): hl:proc run() has no stdin, so the child reads `< body` and writes `> answer` in a tiny `sh -c` with
11. // the paths as positional arguments (no user text in the script). A gzip body (git compresses big requests) is
12. // unpacked first. Git protocol v2 is passed through (`Git-Protocol` → GIT_PROTOCOL, digits only).
13. // * No hook: pull requests and releases are read from the commits when their page is built.
14. import { Response } from 'hl:http1'
15. import { run } from 'hl:proc'
16. import { writeFile, readFile, remove, exists, mkDir } from 'hl:fs'
17. import { randomBytes } from 'hl:crypto'
18. import { slugError, repoBySlug } from './repos.hl'
19. import { slugOfHost, userRecord, publicUrl } from './users.hl'
20. import { userOfToken } from './tokens.hl'
21. import { gitRoot, repoDir } from './git.hl'
22. import { notifyPush } from './tickets.hl'
24. static NL = "
25. "
26. static seconds = 300 // one upload-pack / receive-pack call
27. static maxBody = 500000000 // a push or fetch request above this is refused (bytes)
29. static isBase64 = (s) => {
30. if (s.length == 0 || s.length > 600) { return false }
31. let i = 0
32. while (i < s.length) {
33. let c = s.charCodeAt(i)
34. if (!((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c == 43 || c == 47 || c == 61)) { return false }
35. i = i + 1
36. }
37. return true
38. }
40. // the password of a Basic `Authorization` header ('user:password' → 'password'); null without one.
41. // Hybriel has no base64 decoder (hybriel ticket candidate), so `base64 -d` decodes it — the text goes in as an
42. // argument, after a check that it only holds base64 characters.
43. static passwordOf = (header) => {
44. if (header == null || hlTypeName(header) != 'String') { return null }
45. let h = header.trim()
46. if (h.length < 7 || h.slice(0, 6).toLowerCase() != 'basic ') { return null }
47. let b = h.slice(6).trim()
48. if (!isBase64(b)) { return null }
49. let r = run(['sh', '-c', 'printf %s "$1" | base64 -d 2>/dev/null', 'sh', b], { timeout = 10 })
50. if (r == null || r.exit != 0 || r.lines.length == 0) { return null }
51. let text = r.lines[0]
52. let colon = text.indexOf(':')
53. return colon < 0 ? null : text.slice(colon + 1)
54. }
56. static plain = (status, text, extra) => {
57. let headers = { 'Content-Type' = 'text/plain; charset=utf-8' 'Cache-Control' = 'no-store' }
58. if (extra != null) { for (k of extra.keys()) { headers[k] = extra[k] } }
59. return new Response(text + NL, { status = status headers = headers })
60. }
62. // git speaks protocol v2 when the client says so: `Git-Protocol: version=2` (only that shape is passed on)
63. static protocolEnv = (req) => {
64. let v = req.headers['git-protocol']
65. if (v == null || hlTypeName(v) != 'String' || v.length > 40) { return {} }
66. let ok = v.length > 0
67. let i = 0
68. while (i < v.length) {
69. let c = v.charCodeAt(i)
70. if (!((c >= 48 && c <= 57) || (c >= 97 && c <= 122) || c == 61 || c == 58)) { ok = false }
71. i = i + 1
72. }
73. return ok ? { GIT_PROTOCOL = v } : {}
74. }
76. static tmpDir = () => {
77. let d = gitRoot + '/.tmp'
78. if (!exists(d)) { mkDir(d, 448) }
79. return d
80. }
82. // ONE GIT CALL: the request body (or none) in, the answer out. → the answer's bytes as a String, or null (git failed and said nothing)
83. static callGit = (slug, service, advertise, req) => {
84. let dir = tmpDir()
85. let name = dir + '/' + randomBytes(12, 'hex')
86. let inFile = name + '.in'
87. let outFile = name + '.out'
88. let zipped = false
89. let script = 'exec git ' + service.slice(4) + ' --stateless-rpc --advertise-refs "$1" > "$3"'
90. if (!advertise) {
91. let body = req.body == null ? '' : req.body
92. writeFile(inFile, body, 384)
93. let enc = req.headers['content-encoding']
94. zipped = enc != null && hlTypeName(enc) == 'String' && (enc.toLowerCase() == 'gzip' || enc.toLowerCase() == 'x-gzip')
95. script = zipped ? 'gzip -dc < "$2" | git ' + service.slice(4) + ' --stateless-rpc "$1" > "$3"' : 'exec git ' + service.slice(4) + ' --stateless-rpc "$1" < "$2" > "$3"'
96. }
97. let r = run(['sh', '-c', script, 'sh', repoDir(slug), inFile, outFile], { timeout = seconds env = protocolEnv(req) })
98. let out = exists(outFile) ? readFile(outFile) : null
99. if (exists(inFile)) { remove(inFile) }
100. if (exists(outFile)) { remove(outFile) }
101. // git answers nothing to the client's "0000" probe of a big push (exit 0): that is a 200 with an empty body, as git http-backend does
102. if (out == null || (out == '' && (r == null || r.exit != 0))) { return null }
103. return out
104. }
106. // pkt-line: 4 hex digits of the length (itself included), then the text
107. static pktLine = (text) => {
108. let n = text.length + 4
109. let hex = '0123456789abcdef'
110. let out = ''
111. let i = 0
112. while (i < 4) {
113. let d = n % 16
114. out = hex[d] + out
115. n = (n - d) / 16
116. i = i + 1
117. }
118. return out + text
119. }
121. // THE ROUTE (project.hl): `/:repo/info/refs`, `/:repo/git-upload-pack`, `/:repo/git-receive-pack`
122. static gitTransport = (route, req) => {
123. let hostHeader = req.headers['host']
124. let slug = slugOfHost(hostHeader == null ? '' : hostHeader.split(':')[0])
125. let repoName = route.params.repo
126. if (slug == '' || slugError(slug) != null || repoName != slug + '.git' || repoBySlug(slug) == null) { return plain(404, 'no such repository') }
127. let last = req.path.slice(req.path.lastIndexOf('/') + 1)
128. let advertise = last == 'refs'
129. let service = advertise ? (req.query != null ? req.query.service : null) : last
130. if (service != 'git-upload-pack' && service != 'git-receive-pack') { return plain(403, 'only the smart git protocol is served here: use git clone / fetch / push') }
131. if (advertise && req.method != 'GET') { return plain(405, 'GET only') }
132. if (!advertise && req.method != 'POST') { return plain(405, 'POST only') }
133. if (req.body != null && req.body.length > maxBody) { return plain(413, 'that request is too big') }
135. if (service == 'git-receive-pack') {
136. let realm = { 'WWW-Authenticate' = 'Basic realm="gitoria"' }
137. let pw = passwordOf(req.headers['authorization'])
138. if (pw == null) { return plain(401, 'pushing needs a token: log in at ' + publicUrl + ', make one under "Access tokens", and use it as the password', realm) }
139. let userId = userOfToken(pw)
140. if (userId == null) { return plain(401, 'that token is not valid (removed, or mistyped)', realm) }
141. let repo = repoBySlug(slug)
142. if (userRecord(userId) == null || repo.owner != userId) { return plain(403, 'only the owner of this repository can push to it') }
143. }
145. let out = callGit(slug, service, advertise, req)
146. if (out == null) { return plain(500, 'git gave no answer') }
147. let headers = { 'Cache-Control' = 'no-cache, max-age=0, must-revalidate' 'Pragma' = 'no-cache' }
148. if (advertise) {
149. headers['Content-Type'] = 'application/x-' + service + '-advertisement'
150. // protocol v2 answers without the service banner; v0/v1 starts with it (as git http-backend does)
151. let v2 = protocolEnv(req).GIT_PROTOCOL != null && protocolEnv(req).GIT_PROTOCOL.includes('version=2')
152. if (!v2) { out = pktLine('# service=' + service + NL) + '0000' + out }
153. } else {
154. headers['Content-Type'] = 'application/x-' + service + '-result'
155. // a push arrived: tell the connected tickets project about commits naming a ticket (tickets.hl; never fails the push)
156. if (service == 'git-receive-pack') { notifyPush(slug, false) }
157. }
158. return new Response(out, { headers = headers })
159. }