mirror of
https://github.com/oauth2-proxy/oauth2-proxy.git
synced 2025-05-19 22:23:30 +02:00
cb53401c3a
A regular (non-regex) file: upstream needs to strip the prefix so that it is equivalent to "mounting" the specified directory under the configured path in the URL space, but with regex rewriting the target path is determined by the rewriteTarget. Fixes oauth2-proxy/oauth2-proxy#2242
83 lines
2.6 KiB
Go
83 lines
2.6 KiB
Go
package upstream
|
|
|
|
import (
|
|
"net/http"
|
|
"net/url"
|
|
"runtime"
|
|
"strings"
|
|
|
|
"github.com/oauth2-proxy/oauth2-proxy/v7/pkg/apis/options"
|
|
|
|
"github.com/oauth2-proxy/oauth2-proxy/v7/pkg/apis/middleware"
|
|
)
|
|
|
|
const fileScheme = "file"
|
|
|
|
// newFileServer creates a new fileServer that can serve requests
|
|
// to a file system location.
|
|
func newFileServer(upstream options.Upstream, fileSystemPath string) http.Handler {
|
|
handler := newFileServerForPath(fileSystemPath)
|
|
|
|
if upstream.RewriteTarget == "" {
|
|
// if the upstream does not have a rewrite target, strip off the Path prefix
|
|
// (so e.g. a request for /static/some-file.html looks for some-file.html
|
|
// relative to the fileSystemPath rather than static/some-file.html).
|
|
handler = http.StripPrefix(upstream.Path, handler)
|
|
} else {
|
|
// if the upstream *does* have a rewrite target then that means the target
|
|
// path relative to the fileSystemPath will be the one in the (rewritten)
|
|
// RequestURI.
|
|
handler = requestURIToURL(handler)
|
|
}
|
|
return &fileServer{
|
|
upstream: upstream.ID,
|
|
handler: handler,
|
|
}
|
|
}
|
|
|
|
// newFileServerForPath creates a http.Handler to serve files from the filesystem
|
|
func newFileServerForPath(filesystemPath string) http.Handler {
|
|
// Windows fileSSystemPath will be be prefixed with `/`, eg`/C:/...,
|
|
// if they were parsed by url.Parse`
|
|
if runtime.GOOS == "windows" {
|
|
filesystemPath = strings.TrimPrefix(filesystemPath, "/")
|
|
}
|
|
|
|
return http.FileServer(http.Dir(filesystemPath))
|
|
}
|
|
|
|
// requestURIToURL returns a Handler that replaces the URL in its request with
|
|
// the result of parsing req.RequestURI. This is necessary for file handlers
|
|
// that have a rewrite target, since http.FileServer uses req.URL.Path when
|
|
// looking for the target file, but the rewrite handler only updates the
|
|
// RequestURI, leaving the original path in the URL.
|
|
func requestURIToURL(handler http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
|
|
reqURL, err := url.ParseRequestURI(req.RequestURI)
|
|
if err != nil {
|
|
http.Error(rw, "500 Internal Server Error", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
req.URL = reqURL
|
|
handler.ServeHTTP(rw, req)
|
|
})
|
|
}
|
|
|
|
// fileServer represents a single filesystem upstream proxy
|
|
type fileServer struct {
|
|
upstream string
|
|
handler http.Handler
|
|
}
|
|
|
|
// ServeHTTP proxies requests to the upstream provider while signing the
|
|
// request headers
|
|
func (u *fileServer) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
|
|
scope := middleware.GetRequestScope(req)
|
|
// If scope is nil, this will panic.
|
|
// A scope should always be injected before this handler is called.
|
|
scope.Upstream = u.upstream
|
|
|
|
u.handler.ServeHTTP(rw, req)
|
|
}
|