mirror of
https://codeberg.org/Codeberg/pages-server.git
synced 2024-11-23 06:18:59 +00:00
355 lines
12 KiB
Go
355 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"github.com/OrlovEvgeny/go-mcache"
|
|
"github.com/valyala/fasthttp"
|
|
"github.com/valyala/fastjson"
|
|
"mime"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// handler handles a single HTTP request to the web server.
|
|
func handler(ctx *fasthttp.RequestCtx) {
|
|
ctx.Response.Header.Set("Server", "Codeberg Pages")
|
|
|
|
// Force new default from specification (since November 2020) - see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#strict-origin-when-cross-origin
|
|
ctx.Response.Header.Set("Referrer-Policy", "strict-origin-when-cross-origin")
|
|
|
|
// Enable caching, but require revalidation to reduce confusion
|
|
ctx.Response.Header.Set("Cache-Control", "must-revalidate")
|
|
|
|
// Block all methods not required for static pages
|
|
if !ctx.IsGet() && !ctx.IsHead() && !ctx.IsOptions() {
|
|
ctx.Response.Header.Set("Allow", "GET, HEAD, OPTIONS")
|
|
ctx.Error("Method not allowed", fasthttp.StatusMethodNotAllowed)
|
|
return
|
|
}
|
|
|
|
// Block blacklisted paths (like ACME challenges)
|
|
for _, blacklistedPath := range BlacklistedPaths {
|
|
if bytes.HasPrefix(ctx.Path(), blacklistedPath) {
|
|
returnErrorPage(ctx, fasthttp.StatusForbidden)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Allow CORS for specified domains
|
|
if ctx.IsOptions() {
|
|
allowCors := false
|
|
for _, allowedCorsDomain := range AllowedCorsDomains {
|
|
if bytes.Equal(ctx.Request.Host(), allowedCorsDomain) {
|
|
allowCors = true
|
|
break
|
|
}
|
|
}
|
|
if allowCors {
|
|
ctx.Response.Header.Set("Access-Control-Allow-Origin", "*")
|
|
ctx.Response.Header.Set("Access-Control-Allow-Methods", "GET, HEAD")
|
|
}
|
|
ctx.Response.Header.Set("Allow", "GET, HEAD, OPTIONS")
|
|
ctx.Response.Header.SetStatusCode(fasthttp.StatusNoContent)
|
|
return
|
|
}
|
|
|
|
// Prepare request information to Gitea
|
|
var targetOwner, targetRepo, targetBranch, targetPath string
|
|
var targetOptions = &upstreamOptions{
|
|
ForbiddenMimeTypes: map[string]struct{}{},
|
|
TryIndexPages: true,
|
|
}
|
|
|
|
// tryBranch checks if a branch exists and populates the target variables. If canonicalLink is non-empty, it will
|
|
// also disallow search indexing and add a Link header to the canonical URL.
|
|
var tryBranch = func(repo string, branch string, path []string, canonicalLink string) bool {
|
|
if repo == "" {
|
|
return false
|
|
}
|
|
|
|
// Check if the branch exists, otherwise treat it as a file path
|
|
branchTimestampResult := getBranchTimestamp(targetOwner, repo, branch)
|
|
if branchTimestampResult == nil {
|
|
// branch doesn't exist
|
|
return false
|
|
}
|
|
|
|
// Branch exists, use it
|
|
targetRepo = repo
|
|
targetPath = strings.Trim(strings.Join(path, "/"), "/")
|
|
targetBranch = branchTimestampResult.branch
|
|
targetOptions.BranchTimestamp = branchTimestampResult.timestamp
|
|
|
|
if canonicalLink != "" {
|
|
// Hide from search machines & add canonical link
|
|
ctx.Response.Header.Set("X-Robots-Tag", "noarchive, noindex")
|
|
ctx.Response.Header.Set("Link",
|
|
strings.NewReplacer("%b", targetBranch, "%p", targetPath).Replace(canonicalLink)+
|
|
"; rel=\"canonical\"",
|
|
)
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// tryUpstream forwards the target request to the Gitea API, and shows an error page on failure.
|
|
var tryUpstream = func() {
|
|
// Try to request the file from the Gitea API
|
|
if !upstream(ctx, targetOwner, targetRepo, targetBranch, targetPath, targetOptions) {
|
|
returnErrorPage(ctx, ctx.Response.StatusCode())
|
|
}
|
|
}
|
|
|
|
if RawDomain != nil && bytes.Equal(ctx.Request.Host(), RawDomain) {
|
|
// Serve raw content from RawDomain
|
|
|
|
targetOptions.TryIndexPages = false
|
|
targetOptions.ForbiddenMimeTypes["text/html"] = struct{}{}
|
|
targetOptions.DefaultMimeType = "text/plain; charset=utf-8"
|
|
|
|
pathElements := strings.Split(string(bytes.Trim(ctx.Request.URI().Path(), "/")), "/")
|
|
if len(pathElements) < 2 {
|
|
// https://{RawDomain}/{owner}/{repo}[/@{branch}]/{path} is required
|
|
ctx.Redirect(RawInfoPage, fasthttp.StatusTemporaryRedirect)
|
|
return
|
|
}
|
|
targetOwner = pathElements[0]
|
|
targetRepo = pathElements[1]
|
|
|
|
// raw.codeberg.page/example/myrepo/@main/index.html
|
|
if len(pathElements) > 2 && strings.HasPrefix(pathElements[2], "@") {
|
|
if tryBranch(targetRepo, pathElements[2][1:], pathElements[3:],
|
|
string(GiteaRoot)+"/"+targetOwner+"/"+targetRepo+"/src/branch/%b/%p",
|
|
) {
|
|
tryUpstream()
|
|
return
|
|
}
|
|
returnErrorPage(ctx, fasthttp.StatusFailedDependency)
|
|
return
|
|
} else {
|
|
tryBranch(targetRepo, "", pathElements[2:],
|
|
string(GiteaRoot)+"/"+targetOwner+"/"+targetRepo+"/src/branch/%b/%p",
|
|
)
|
|
tryUpstream()
|
|
return
|
|
}
|
|
|
|
} else if bytes.HasSuffix(ctx.Request.Host(), MainDomainSuffix) {
|
|
// Serve pages from subdomains of MainDomainSuffix
|
|
|
|
pathElements := strings.Split(string(bytes.Trim(ctx.Request.URI().Path(), "/")), "/")
|
|
targetOwner = string(bytes.TrimSuffix(ctx.Request.Host(), MainDomainSuffix))
|
|
targetRepo = pathElements[0]
|
|
targetPath = strings.Trim(strings.Join(pathElements[1:], "/"), "/")
|
|
|
|
// Check if the first directory is a repo with the second directory as a branch
|
|
// example.codeberg.page/myrepo/@main/index.html
|
|
if len(pathElements) > 1 && strings.HasPrefix(pathElements[1], "@") {
|
|
if targetRepo == "pages" {
|
|
// example.codeberg.org/pages/@... redirects to example.codeberg.org/@...
|
|
ctx.Redirect("/" + strings.Join(pathElements[1:], "/"), fasthttp.StatusMovedPermanently)
|
|
return
|
|
}
|
|
|
|
if tryBranch(pathElements[0], pathElements[1][1:], pathElements[2:],
|
|
"/"+pathElements[0]+"/%p",
|
|
) {
|
|
tryUpstream()
|
|
} else {
|
|
returnErrorPage(ctx, fasthttp.StatusFailedDependency)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Check if the first directory is a branch for the "pages" repo
|
|
// example.codeberg.page/@main/index.html
|
|
if strings.HasPrefix(pathElements[0], "@") {
|
|
if tryBranch("pages", pathElements[0][1:], pathElements[1:], "/%p") {
|
|
tryUpstream()
|
|
} else {
|
|
returnErrorPage(ctx, fasthttp.StatusFailedDependency)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Check if the first directory is a repo with a "pages" branch
|
|
// example.codeberg.page/myrepo/index.html
|
|
// example.codeberg.page/pages/... is not allowed here.
|
|
if pathElements[0] != "pages" && tryBranch(pathElements[0], "pages", pathElements[1:], "") {
|
|
tryUpstream()
|
|
return
|
|
}
|
|
|
|
// Try to use the "pages" repo on its default branch
|
|
// example.codeberg.page/index.html
|
|
if tryBranch("pages", "", pathElements, "") {
|
|
tryUpstream()
|
|
return
|
|
}
|
|
|
|
// Couldn't find a valid repo/branch
|
|
returnErrorPage(ctx, fasthttp.StatusFailedDependency)
|
|
return
|
|
} else {
|
|
// Serve pages from external domains
|
|
|
|
targetOwner, targetRepo, targetBranch, targetPath = getTargetFromDNS(ctx)
|
|
if targetOwner == "" {
|
|
ctx.Redirect(BrokenDNSPage, fasthttp.StatusTemporaryRedirect)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// returnErrorPage sets the response status code and writes NotFoundPage to the response body, with "%status" replaced
|
|
// with the provided status code.
|
|
func returnErrorPage(ctx *fasthttp.RequestCtx, code int) {
|
|
ctx.Response.SetStatusCode(code)
|
|
ctx.Response.Header.SetContentType("text/html; charset=utf-8")
|
|
ctx.Response.SetBody(bytes.ReplaceAll(NotFoundPage, []byte("%status"), []byte(strconv.Itoa(code)+" "+fasthttp.StatusMessage(code))))
|
|
}
|
|
|
|
type branchTimestamp struct {
|
|
branch string
|
|
timestamp time.Time
|
|
}
|
|
var branchTimestampCache = mcache.New()
|
|
|
|
// getBranchTimestamp finds the default branch (if branch is "") and returns the last modification time of the branch
|
|
// (or an empty time.Time if the branch doesn't exist)
|
|
func getBranchTimestamp(owner, repo, branch string) *branchTimestamp {
|
|
if result, ok := branchTimestampCache.Get(owner + "/" + repo + "/" + branch); ok {
|
|
return result.(*branchTimestamp)
|
|
}
|
|
result := &branchTimestamp{}
|
|
result.branch = branch
|
|
if branch == "" {
|
|
var body = make([]byte, 0)
|
|
status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo, 10*time.Second)
|
|
if err != nil || status != 200 {
|
|
return nil
|
|
}
|
|
branch = fastjson.GetString(body, "default_branch")
|
|
result.branch = branch
|
|
}
|
|
|
|
var body = make([]byte, 0)
|
|
status, body, err := fasthttp.GetTimeout(body, string(GiteaRoot)+"/api/v1/repos/"+owner+"/"+repo+"/branches/"+branch, 10*time.Second)
|
|
if err != nil || status != 200 {
|
|
return nil
|
|
}
|
|
|
|
result.timestamp, _ = time.Parse(time.RFC3339, fastjson.GetString(body, "commit", "timestamp"))
|
|
_ = branchTimestampCache.Set(owner + "/" + repo + "/" + branch, result, 15 * time.Second)
|
|
return result
|
|
}
|
|
|
|
var upstreamClient = fasthttp.Client{
|
|
ReadTimeout: 10 * time.Second,
|
|
MaxConnDuration: 60 * time.Second,
|
|
MaxConnWaitTimeout: 1000 * time.Millisecond,
|
|
MaxConnsPerHost: 1024 * 16, // TODO: adjust bottlenecks for best performance with Gitea!
|
|
}
|
|
|
|
// upstream requests a file from the Gitea API at GiteaRoot and writes it to the request context.
|
|
func upstream(ctx *fasthttp.RequestCtx, targetOwner string, targetRepo string, targetBranch string, targetPath string, options *upstreamOptions) (success bool) {
|
|
if options.ForbiddenMimeTypes == nil {
|
|
options.ForbiddenMimeTypes = map[string]struct{}{}
|
|
}
|
|
|
|
// Check if the branch exists and when it was modified
|
|
if options.BranchTimestamp == (time.Time{}) {
|
|
branch := getBranchTimestamp(targetOwner, targetRepo, targetBranch)
|
|
|
|
if branch == nil {
|
|
returnErrorPage(ctx, fasthttp.StatusFailedDependency)
|
|
return true
|
|
}
|
|
targetBranch = branch.branch
|
|
options.BranchTimestamp = branch.timestamp
|
|
}
|
|
|
|
if targetOwner == "" || targetRepo == "" || targetBranch == "" {
|
|
returnErrorPage(ctx, fasthttp.StatusBadRequest)
|
|
return true
|
|
}
|
|
|
|
// Check if the browser has a cached version
|
|
if ifModifiedSince, err := time.Parse(time.RFC1123, string(ctx.Request.Header.Peek("If-Modified-Since"))); err == nil {
|
|
if !ifModifiedSince.Before(options.BranchTimestamp) {
|
|
ctx.Response.SetStatusCode(fasthttp.StatusNotModified)
|
|
return true
|
|
}
|
|
}
|
|
|
|
// Make a GET request to the upstream URL
|
|
req := fasthttp.AcquireRequest()
|
|
req.SetRequestURI(string(GiteaRoot) + "/api/v1/repos/" + targetOwner + "/" + targetRepo + "/raw/" + targetBranch + "/" + targetPath)
|
|
res := fasthttp.AcquireResponse()
|
|
err := upstreamClient.Do(req, res)
|
|
|
|
// Handle errors
|
|
if res.StatusCode() == fasthttp.StatusNotFound {
|
|
if options.TryIndexPages {
|
|
// copy the options struct & try if an index page exists
|
|
optionsForIndexPages := *options
|
|
optionsForIndexPages.TryIndexPages = false
|
|
optionsForIndexPages.AppendTrailingSlash = true
|
|
for _, indexPage := range IndexPages {
|
|
if upstream(ctx, targetOwner, targetRepo, targetBranch, strings.TrimSuffix(targetPath, "/")+"/"+indexPage, &optionsForIndexPages) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
ctx.Response.SetStatusCode(fasthttp.StatusNotFound)
|
|
return false
|
|
}
|
|
if err != nil || res.StatusCode() != fasthttp.StatusOK {
|
|
fmt.Printf("Couldn't fetch contents from \"%s\": %s (status code %d)\n", req.RequestURI(), err, res.StatusCode())
|
|
returnErrorPage(ctx, fasthttp.StatusInternalServerError)
|
|
return true
|
|
}
|
|
|
|
// Append trailing slash if missing (for index files)
|
|
if options.AppendTrailingSlash && !bytes.HasSuffix(ctx.Request.URI().Path(), []byte{'/'}) {
|
|
ctx.Redirect(string(ctx.Request.URI().Path())+"/", fasthttp.StatusTemporaryRedirect)
|
|
return true
|
|
}
|
|
|
|
// Set the MIME type
|
|
mimeType := mime.TypeByExtension(path.Ext(targetPath))
|
|
mimeTypeSplit := strings.SplitN(mimeType, ";", 2)
|
|
if _, ok := options.ForbiddenMimeTypes[mimeTypeSplit[0]]; ok || mimeType == "" {
|
|
if options.DefaultMimeType != "" {
|
|
mimeType = options.DefaultMimeType
|
|
} else {
|
|
mimeType = "application/octet-stream"
|
|
}
|
|
}
|
|
ctx.Response.Header.SetContentType(mimeType)
|
|
|
|
// Write the response to the original request
|
|
ctx.Response.SetStatusCode(fasthttp.StatusOK)
|
|
ctx.Response.Header.SetLastModified(options.BranchTimestamp)
|
|
err = res.BodyWriteTo(ctx.Response.BodyWriter())
|
|
if err != nil {
|
|
fmt.Printf("Couldn't write body for \"%s\": %s\n", req.RequestURI(), err)
|
|
returnErrorPage(ctx, fasthttp.StatusInternalServerError)
|
|
return true
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// upstreamOptions provides various options for the upstream request.
|
|
type upstreamOptions struct {
|
|
DefaultMimeType string
|
|
ForbiddenMimeTypes map[string]struct{}
|
|
TryIndexPages bool
|
|
AppendTrailingSlash bool
|
|
BranchTimestamp time.Time
|
|
}
|