fix

Author: wxiaoguang

custom/conf/app.example.ini

@@ -63,14 +63,18 @@ RUN_USER = ; git
 ;PROTOCOL = http
 ;;
 ;; Set the domain for the server.
-;; Most users should set it to the real website domain of their Gitea instance.
 ;DOMAIN = localhost
 ;;
-;; The AppURL used by Gitea to generate absolute links, defaults to "{PROTOCOL}://{DOMAIN}:{HTTP_PORT}/".
+;; The AppURL is used to generate public URL links, defaults to "{PROTOCOL}://{DOMAIN}:{HTTP_PORT}/".
 ;; Most users should set it to the real website URL of their Gitea instance when there is a reverse proxy.
-;; When it is empty, Gitea will use HTTP "Host" header to generate ROOT_URL, and fall back to the default one if no "Host" header.
 ;ROOT_URL =
 ;;
+;; Controls how to generate the public URL. Most users should leave it empty to use the "auto" behavior.
+;; * auto: generate the public URL automatically by X-Forwarded-Proto and Host headers in the request
+;; * use-host: if "auto" fails (no X-Forwarded-Proto header), still use the value of Host header in the request, scheme will be "https" if PROTOCOL=https
+;; * fixed: ignore the HTTP headers in the request, only use the configured ROOT_URL value for public URL
+;PUBLIC_URL_GENERATION = auto
+;;
 ;; For development purpose only. It makes Gitea handle sub-path ("/sub-path/owner/repo/...") directly when debugging without a reverse proxy.
 ;; DO NOT USE IT IN PRODUCTION!!!
 ;USE_SUB_URL_PATH = false

modules/httplib/url.go

@@ -53,30 +53,34 @@ func getRequestScheme(req *http.Request) string {
 	return ""
 }
 
-// GuessCurrentAppURL tries to guess the current full app URL (with sub-path) by http headers. It always has a '/' suffix, exactly the same as setting.AppURL
+// GuessCurrentAppURL tries to guess the current full public URL (with sub-path) by http headers. It always has a '/' suffix, exactly the same as setting.AppURL
+// TODO: should rename it to GuessCurrentPublicURL in the future
 func GuessCurrentAppURL(ctx context.Context) string {
 	return GuessCurrentHostURL(ctx) + setting.AppSubURL + "/"
 }
 
 // GuessCurrentHostURL tries to guess the current full host URL (no sub-path) by http headers, there is no trailing slash.
 func GuessCurrentHostURL(ctx context.Context) string {
-	req, ok := ctx.Value(RequestContextKey).(*http.Request)
-	if !ok {
+	if setting.PublicURLGeneration == setting.PublicURLFixed {
 		return strings.TrimSuffix(setting.AppURL, setting.AppSubURL+"/")
 	}
-	// If no scheme provided by reverse proxy, then do not guess the AppURL, use the configured one.
+	// Try the best guess to get the current host URL (will be used for public URL) by http headers.
 	// At the moment, if site admin doesn't configure the proxy headers correctly, then Gitea would guess wrong.
 	// There are some cases:
 	// 1. The reverse proxy is configured correctly, it passes "X-Forwarded-Proto/Host" headers. Perfect, Gitea can handle it correctly.
 	// 2. The reverse proxy is not configured correctly, doesn't pass "X-Forwarded-Proto/Host" headers, eg: only one "proxy_pass http://gitea:3000" in Nginx.
 	// 3. There is no reverse proxy.
 	// Without more information, Gitea is impossible to distinguish between case 2 and case 3, then case 2 would result in
-	// wrong guess like guessed AppURL becomes "http://gitea:3000/" behind a "https" reverse proxy, which is not accessible by end users.
-	// So we introduced "UseHostHeader" option, it could be enabled by setting "ROOT_URL" to empty
+	// wrong guess like guessed public URL becomes "http://gitea:3000/" behind a "https" reverse proxy, which is not accessible by end users.
+	// So we introduced "PUBLIC_URL_GENERATION" option, to control the guessing behavior to satisfy different use cases.
+	req, ok := ctx.Value(RequestContextKey).(*http.Request)
+	if !ok {
+		return strings.TrimSuffix(setting.AppURL, setting.AppSubURL+"/")
+	}
 	reqScheme := getRequestScheme(req)
 	if reqScheme == "" {
 		// if no reverse proxy header, try to use "Host" header for absolute URL
-		if setting.UseHostHeader && req.Host != "" {
+		if setting.PublicURLGeneration == setting.PublicURLUseHost && req.Host != "" {
 			return util.Iif(req.TLS == nil, "http://", "https://") + req.Host
 		}
 		// fall back to default AppURL
@@ -93,8 +97,8 @@ func GuessCurrentHostDomain(ctx context.Context) string {
 	return util.IfZero(domain, host)
 }
 
-// MakeAbsoluteURL tries to make a link to an absolute URL:
-// * If link is empty, it returns the current app URL.
+// MakeAbsoluteURL tries to make a link to an absolute public URL:
+// * If link is empty, it returns the current public URL.
 // * If link is absolute, it returns the link.
 // * Otherwise, it returns the current host URL + link, the link itself should have correct sub-path (AppSubURL) if needed.
 func MakeAbsoluteURL(ctx context.Context, link string) string {

modules/httplib/url_test.go

@@ -43,20 +43,37 @@ func TestIsRelativeURL(t *testing.T) {
 func TestGuessCurrentHostURL(t *testing.T) {
 	defer test.MockVariableValue(&setting.AppURL, "http://cfg-host/sub/")()
 	defer test.MockVariableValue(&setting.AppSubURL, "/sub")()
-	defer test.MockVariableValue(&setting.UseHostHeader, false)()
+	headersWithProto := http.Header{"X-Forwarded-Proto": {"https"}}
 
-	ctx := t.Context()
-	assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(ctx))
+	t.Run("AutoAndNever", func(t *testing.T) {
+		defer test.MockVariableValue(&setting.PublicURLGeneration, setting.PublicURLAuto)()
+
+		assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(t.Context()))
+
+		ctx := context.WithValue(t.Context(), RequestContextKey, &http.Request{Host: "req-host:3000"})
+		assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(ctx))
 
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{Host: "localhost:3000"})
-	assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(ctx))
+		ctx = context.WithValue(t.Context(), RequestContextKey, &http.Request{Host: "req-host:3000", Header: headersWithProto})
+		assert.Equal(t, "https://req-host:3000", GuessCurrentHostURL(ctx))
+
+		setting.PublicURLGeneration = setting.PublicURLFixed
+		assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(ctx))
+	})
 
-	defer test.MockVariableValue(&setting.UseHostHeader, true)()
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{Host: "http-host:3000"})
-	assert.Equal(t, "http://http-host:3000", GuessCurrentHostURL(ctx))
+	t.Run("UseHost", func(t *testing.T) {
+		defer test.MockVariableValue(&setting.PublicURLGeneration, setting.PublicURLUseHost)()
 
-	ctx = context.WithValue(ctx, RequestContextKey, &http.Request{Host: "http-host", TLS: &tls.ConnectionState{}})
-	assert.Equal(t, "https://http-host", GuessCurrentHostURL(ctx))
+		assert.Equal(t, "http://cfg-host", GuessCurrentHostURL(t.Context()))
+
+		ctx := context.WithValue(t.Context(), RequestContextKey, &http.Request{Host: "req-host:3000"})
+		assert.Equal(t, "http://req-host:3000", GuessCurrentHostURL(ctx))
+
+		ctx = context.WithValue(t.Context(), RequestContextKey, &http.Request{Host: "req-host", TLS: &tls.ConnectionState{}})
+		assert.Equal(t, "https://req-host", GuessCurrentHostURL(ctx))
+
+		ctx = context.WithValue(t.Context(), RequestContextKey, &http.Request{Host: "req-host:3000", Header: headersWithProto})
+		assert.Equal(t, "https://req-host:3000", GuessCurrentHostURL(ctx))
+	})
 }
 
 func TestMakeAbsoluteURL(t *testing.T) {

modules/setting/server.go

@@ -41,12 +41,21 @@ const (
 	LandingPageLogin         LandingPage = "/user/login"
 )
 
+const (
+	PublicURLAuto    = "auto"
+	PublicURLUseHost = "use-host"
+	PublicURLFixed   = "fixed"
+)
+
 // Server settings
 var (
 	// AppURL is the Application ROOT_URL. It always has a '/' suffix
 	// It maps to ini:"ROOT_URL"
 	AppURL string
 
+	// PublicURLGeneration controls how to use the HTTP request headers to generate public URL
+	PublicURLGeneration string
+
 	// AppSubURL represents the sub-url mounting point for gitea, parsed from "ROOT_URL"
 	// It is either "" or starts with '/' and ends without '/', such as '/{sub-path}'.
 	// This value is empty if site does not have sub-url.
@@ -56,9 +65,6 @@ var (
 	// to make it easier to debug sub-path related problems without a reverse proxy.
 	UseSubURLPath bool
 
-	// UseHostHeader makes Gitea prefer to use the "Host" request header for construction of absolute URLs.
-	UseHostHeader bool
-
 	// AppDataPath is the default path for storing data.
 	// It maps to ini:"APP_DATA_PATH" in [server] and defaults to AppWorkPath + "/data"
 	AppDataPath string
@@ -283,10 +289,10 @@ func loadServerFrom(rootCfg ConfigProvider) {
 	PerWritePerKbTimeout = sec.Key("PER_WRITE_PER_KB_TIMEOUT").MustDuration(PerWritePerKbTimeout)
 
 	defaultAppURL := string(Protocol) + "://" + Domain + ":" + HTTPPort
-	AppURL = sec.Key("ROOT_URL").String()
-	if AppURL == "" {
-		UseHostHeader = true
-		AppURL = defaultAppURL
+	AppURL = sec.Key("ROOT_URL").MustString(defaultAppURL)
+	PublicURLGeneration = sec.Key("PUBLIC_URL_GENERATION").MustString(PublicURLAuto)
+	if PublicURLGeneration != PublicURLAuto && PublicURLGeneration != PublicURLUseHost && PublicURLGeneration != PublicURLFixed {
+		log.Fatal("Invalid PUBLIC_URL_GENERATION value: %s", PublicURLGeneration)
 	}
 
 	// Check validity of AppURL

routers/web/admin/admin_test.go

@@ -76,7 +76,6 @@ func TestShadowPassword(t *testing.T) {
 func TestSelfCheckPost(t *testing.T) {
 	defer test.MockVariableValue(&setting.AppURL, "http://config/sub/")()
 	defer test.MockVariableValue(&setting.AppSubURL, "/sub")()
-	defer test.MockVariableValue(&setting.UseHostHeader, false)()
 
 	ctx, resp := contexttest.MockContext(t, "GET http://host/sub/admin/self_check?location_origin=http://frontend")
 	SelfCheckPost(ctx)