`)
if lang != "" {
_ = lang // no syntax highlighting, just consume
}
i++
for i < n {
cl := bytes.TrimSpace(lines[i])
// closing fence: >= same backtick count, nothing else
ticks := 0
for ticks < len(cl) && cl[ticks] == '`' {
ticks++
}
if ticks >= fenceLen && allChar(cl, '`') {
break
}
b.WriteString(esc(lines[i]))
b.WriteByte('\n')
i++
}
b.WriteString(`| " + mdInline(bytes.TrimSpace(cell), linkName) + " | ") } b.WriteString("
|---|
| " + mdInline(bytes.TrimSpace(cell), linkName) + " | ") } b.WriteString("
") closeTags = append(closeTags, "\n") } text := "" if len(line) > 2 { text = line[2:] } b.WriteString(mdInline(text, linkName) + "\n") i++ continue } // unordered list if (bytes.HasPrefix(line, "- ") || bytes.HasPrefix(line, "* ") || bytes.HasPrefix(line, "+ ")) && len(line) > 2 { if !inState("\n") { flush() b.WriteString("
") closeTags = append(closeTags, "
\n") } else { b.WriteByte('\n') } b.WriteString(mdInline(line, linkName)) i++ } flush() return b.String() } // mdInline processes inline markdown: code, bold, italic, links, images. func mdInline(s, linkName string) string { s = esc(s) // HTML-escape first; markdown punctuation (*,[,],`,!) is not affected var b bytes.Buffer i := 0 for i < len(s) { // backtick code span if s[i] == '`' { end := bytes.IndexByte(s[i+1:], '`') if end >= 0 { b.WriteString("" + s[i+1:i+1+end] + "")
i += end + 2
continue
}
}
// linked image [](link-url) — render as text link to link-url
if s[i] == '[' && i+1 < len(s) && s[i+1] == '!' && i+2 < len(s) && s[i+2] == '[' {
if innerText, _, innerAdv := parseLink(s[i+2:]); innerAdv > 0 {
pos := i + 2 + innerAdv
if pos+1 < len(s) && s[pos] == ']' && s[pos+1] == '(' {
end := bytes.IndexByte(s[pos+2:], ')')
if end >= 0 {
url := s[pos+2 : pos+2+end]
b.WriteString(`` + innerText + ``)
i = pos + 2 + end + 1
continue
}
}
}
}
// image  — inline if relative, link if external
if s[i] == '!' && i+1 < len(s) && s[i+1] == '[' {
if text, url, advance := parseLink(s[i+1:]); advance > 0 {
if bytes.HasPrefix(url, "http://") || bytes.HasPrefix(url, "https://") || bytes.HasPrefix(url, "//") {
b.WriteString(`` + text + ``)
} else {
raw := "/" + linkName + "/raw/" + bytes.TrimPrefix(url, "./")
b.WriteString(`` + esc(desc) + `
`) } // clone urls b.WriteString(`git clone https://` + esc(host) + `/` + esc(repo) + `
`) b.WriteString(`git clone ssh://git@` + esc(host) + `:2222/~/` + esc(repo) + `
`) // readme for _, readme := range []string{"README.md", "README", "README.txt", "readme.md"} { data, err := gitCmd(repoDir, "show", ref+":"+readme) if err == nil && len(data) > 0 { b.WriteString(`` + esc(string(data)) + ``) } b.WriteString(`
empty repository — push to get started
`) } else if len(entries) > 0 { b.WriteString(`` + esc(err.Error()) + `
`) return } writeEntriesList(b, linkName, entries, treePath) } func writeEntriesList(b *bytes.Buffer, linkName string, entries []entry, treePath string) { b.WriteString(``)
for i, line := range lines {
ln := fmt.Sprintf("%4d ", i+1)
b.WriteString(`` + ln + `` + esc(line) + "\n")
}
b.WriteString(``)
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write(page(linkName+" / "+blobPath, b.String()))
}
func serveRaw(w http.ResponseWriter, linkName, repoDir, filePath string) {
if filePath == "" {
http.NotFound(w, nil)
return
}
ref := defaultRef(repoDir)
data, err := gitCmd(repoDir, "show", ref+":"+filePath)
if err != nil {
http.NotFound(w, nil)
return
}
w.Header().Set("Content-Type", mimeType(filePath))
w.Header().Set("Cache-Control", "max-age=300")
w.Write(data)
}
func serveGit(w http.ResponseWriter, r *http.Request) {
env := []string{
"PATH=/usr/bin:/bin",
"GIT_PROJECT_ROOT=" + repoRoot,
"GIT_HTTP_EXPORT_ALL=1",
"REQUEST_METHOD=" + r.Method,
"QUERY_STRING=" + r.URL.RawQuery,
"PATH_INFO=" + r.URL.Path,
"SERVER_PROTOCOL=HTTP/1.1",
}
if ct := r.Header.Get("Content-Type"); ct != "" {
env = append(env, "CONTENT_TYPE="+ct)
}
if cl := r.Header.Get("Content-Length"); cl != "" {
env = append(env, "CONTENT_LENGTH="+cl)
}
if proto := r.Header.Get("Git-Protocol"); proto != "" {
env = append(env, "GIT_PROTOCOL="+proto)
}
ra := r.RemoteAddr
if i := bytes.LastIndexByte(ra, ':'); i >= 0 {
ra = ra[:i]
}
env = append(env, "REMOTE_ADDR="+ra)
var stdin []byte
if r.Method == "POST" && r.Body != nil {
var body bytes.Buffer
tmp := []byte{:8192}
for {
n, err := r.Body.Read(tmp)
if n > 0 {
body.Write(tmp[:n])
}
if err != nil {
break
}
}
if body.Len() > 0 {
stdin = body.Bytes()
}
}
out, err := runIO(env, stdin, gitBackend)
if err != nil && len(out) == 0 {
http.Error(w, "git backend error", 500)
return
}
// parse CGI response: headers \n\n body
sep := bytes.Index(out, []byte("\r\n\r\n"))
skip := 4
if sep < 0 {
sep = bytes.Index(out, []byte("\n\n"))
skip = 2
}
if sep < 0 {
http.Error(w, "bad cgi response", 500)
return
}
code := 200
for _, line := range bytes.Split(string(out[:sep]), "\n") {
line = bytes.TrimRight(line, "\r")
idx := bytes.IndexByte(line, ':')
if idx < 0 {
continue
}
key := bytes.TrimSpace(line[:idx])
val := bytes.TrimSpace(line[idx+1:])
if bytes.EqualFold(key, "Status") {
if len(val) >= 3 {
code = 0
for j := 0; j < 3; j++ {
if val[j] >= '0' && val[j] <= '9' {
code = code*10 + int(val[j]-'0')
}
}
}
} else {
w.Header().Set(key, val)
}
}
w.WriteHeader(code)
w.Write(out[sep+skip:])
}
// ── main ────────────────────────────────────────────────────────
func main() {
for i := 1; i < len(os.Args); i++ {
switch os.Args[i] {
case "-repos":
i++
if i < len(os.Args) {
repoRoot = os.Args[i]
}
case "-listen":
i++
if i < len(os.Args) {
addr = os.Args[i]
}
case "-git":
i++
if i < len(os.Args) {
gitBin = os.Args[i]
}
case "-host":
i++
if i < len(os.Args) {
host = os.Args[i]
}
case "-git-backend":
i++
if i < len(os.Args) {
gitBackend = os.Args[i]
}
}
}
// auto-detect git-http-backend path
if _, err := os.Stat(gitBackend); err != nil {
for _, p := range []string{"/usr/lib/git-core/git-http-backend", "/usr/libexec/git-core/git-http-backend"} {
if _, err := os.Stat(p); err == nil {
gitBackend = p
break
}
}
}
fmt.Printf("gitweb %s repos=%s\n", addr, repoRoot)
// Parse addr ourselves to bypass moxie SplitHostPort codegen bug.
tcpAddr := &net.TCPAddr{Port: 3000}
if i := bytes.LastIndexByte(addr, ':'); i >= 0 {
h := addr[:i]
p := addr[i+1:]
if h != "" {
tcpAddr.IP = net.ParseIP(h)
}
port := 0
for _, c := range p {
port = port*10 + int(c-'0')
}
tcpAddr.Port = port
}
ln, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
http.HandleFunc("/", handler)
if err := http.Serve(ln, nil); err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
}