frp/pkg/util/vhost/http.go

320 lines
9.6 KiB
Go
Raw Normal View History

2017-12-13 03:27:43 +08:00
// Copyright 2017 fatedier, fatedier@gmail.com
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package vhost
import (
"bytes"
2017-12-13 03:27:43 +08:00
"context"
"encoding/base64"
2017-12-13 03:27:43 +08:00
"errors"
"fmt"
2017-12-13 03:27:43 +08:00
"log"
"net"
"net/http"
"net/url"
2017-12-13 03:27:43 +08:00
"strings"
"time"
2020-09-23 13:49:14 +08:00
frpLog "github.com/fatedier/frp/pkg/util/log"
"github.com/fatedier/frp/pkg/util/util"
frpIo "github.com/fatedier/golib/io"
2018-05-08 02:13:30 +08:00
"github.com/fatedier/golib/pool"
2017-12-13 03:27:43 +08:00
)
var (
ErrNoRouteFound = errors.New("no route found")
2017-12-13 03:27:43 +08:00
)
2020-05-24 17:48:37 +08:00
type HTTPReverseProxyOptions struct {
2018-08-08 11:18:38 +08:00
ResponseHeaderTimeoutS int64
}
2020-05-24 17:48:37 +08:00
type HTTPReverseProxy struct {
2019-07-31 00:41:58 +08:00
proxy *ReverseProxy
2020-05-24 17:48:37 +08:00
vhostRouter *Routers
2017-12-13 03:27:43 +08:00
2018-08-08 11:18:38 +08:00
responseHeaderTimeout time.Duration
2017-12-13 03:27:43 +08:00
}
2020-05-24 17:48:37 +08:00
func NewHTTPReverseProxy(option HTTPReverseProxyOptions, vhostRouter *Routers) *HTTPReverseProxy {
2018-08-08 11:18:38 +08:00
if option.ResponseHeaderTimeoutS <= 0 {
option.ResponseHeaderTimeoutS = 60
}
2020-05-24 17:48:37 +08:00
rp := &HTTPReverseProxy{
2018-08-08 11:18:38 +08:00
responseHeaderTimeout: time.Duration(option.ResponseHeaderTimeoutS) * time.Second,
2019-07-31 00:41:58 +08:00
vhostRouter: vhostRouter,
2017-12-13 03:27:43 +08:00
}
proxy := &ReverseProxy{
// Modify incoming requests by route policies.
2017-12-13 03:27:43 +08:00
Director: func(req *http.Request) {
req.URL.Scheme = "http"
2020-05-24 17:48:37 +08:00
url := req.Context().Value(RouteInfoURL).(string)
routeByHTTPUser := req.Context().Value(RouteInfoHTTPUser).(string)
oldHost, _ := util.CanonicalHost(req.Context().Value(RouteInfoHost).(string))
rc := rp.GetRouteConfig(oldHost, url, routeByHTTPUser)
if rc != nil {
if rc.RewriteHost != "" {
req.Host = rc.RewriteHost
}
// Set {domain}.{location}.{routeByHTTPUser} as URL host here to let http transport reuse connections.
// TODO(fatedier): use proxy name instead?
req.URL.Host = rc.Domain + "." +
base64.StdEncoding.EncodeToString([]byte(rc.Location)) + "." +
base64.StdEncoding.EncodeToString([]byte(rc.RouteByHTTPUser))
2018-05-20 23:22:07 +08:00
for k, v := range rc.Headers {
req.Header.Set(k, v)
}
} else {
req.URL.Host = req.Host
2018-05-20 23:22:07 +08:00
}
2017-12-13 03:27:43 +08:00
},
// Create a connection to one proxy routed by route policy.
2017-12-13 03:27:43 +08:00
Transport: &http.Transport{
2018-08-08 11:18:38 +08:00
ResponseHeaderTimeout: rp.responseHeaderTimeout,
IdleConnTimeout: 60 * time.Second,
2017-12-13 03:27:43 +08:00
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
2020-05-24 17:48:37 +08:00
url := ctx.Value(RouteInfoURL).(string)
host, _ := util.CanonicalHost(ctx.Value(RouteInfoHost).(string))
routerByHTTPUser := ctx.Value(RouteInfoHTTPUser).(string)
2020-05-24 17:48:37 +08:00
remote := ctx.Value(RouteInfoRemote).(string)
return rp.CreateConnection(host, url, routerByHTTPUser, remote)
},
Proxy: func(req *http.Request) (*url.URL, error) {
// Use proxy mode if there is host in HTTP first request line.
// GET http://example.com/ HTTP/1.1
// Host: example.com
//
// Normal:
// GET / HTTP/1.1
// Host: example.com
urlHost := req.Context().Value(RouteInfoURLHost).(string)
if urlHost != "" {
return req.URL, nil
}
return nil, nil
2017-12-13 03:27:43 +08:00
},
},
BufferPool: newWrapPool(),
ErrorLog: log.New(newWrapLogger(), "", 0),
2019-08-06 16:49:22 +08:00
ErrorHandler: func(rw http.ResponseWriter, req *http.Request, err error) {
2022-04-14 11:24:36 +08:00
frpLog.Warn("do http proxy request [host: %s] error: %v", req.Host, err)
2019-08-06 16:49:22 +08:00
rw.WriteHeader(http.StatusNotFound)
rw.Write(getNotFoundPageContent())
},
2017-12-13 03:27:43 +08:00
}
rp.proxy = proxy
return rp
}
2019-07-31 00:41:58 +08:00
// Register register the route config to reverse proxy
// reverse proxy will use CreateConnFn from routeCfg to create a connection to the remote service
2020-05-24 17:48:37 +08:00
func (rp *HTTPReverseProxy) Register(routeCfg RouteConfig) error {
err := rp.vhostRouter.Add(routeCfg.Domain, routeCfg.Location, routeCfg.RouteByHTTPUser, &routeCfg)
2019-07-31 00:41:58 +08:00
if err != nil {
return err
2017-12-13 03:27:43 +08:00
}
return nil
}
2019-07-31 00:41:58 +08:00
// UnRegister unregister route config by domain and location
func (rp *HTTPReverseProxy) UnRegister(routeCfg RouteConfig) {
rp.vhostRouter.Del(routeCfg.Domain, routeCfg.Location, routeCfg.RouteByHTTPUser)
2017-12-13 03:27:43 +08:00
}
func (rp *HTTPReverseProxy) GetRouteConfig(domain, location, routeByHTTPUser string) *RouteConfig {
vr, ok := rp.getVhost(domain, location, routeByHTTPUser)
if ok {
frpLog.Debug("get new HTTP request host [%s] path [%s] httpuser [%s]", domain, location, routeByHTTPUser)
return vr.payload.(*RouteConfig)
}
return nil
}
func (rp *HTTPReverseProxy) GetRealHost(domain, location, routeByHTTPUser string) (host string) {
vr, ok := rp.getVhost(domain, location, routeByHTTPUser)
2017-12-13 03:27:43 +08:00
if ok {
2020-05-24 17:48:37 +08:00
host = vr.payload.(*RouteConfig).RewriteHost
2017-12-13 03:27:43 +08:00
}
return
}
func (rp *HTTPReverseProxy) GetHeaders(domain, location, routeByHTTPUser string) (headers map[string]string) {
vr, ok := rp.getVhost(domain, location, routeByHTTPUser)
2018-05-20 23:22:07 +08:00
if ok {
2020-05-24 17:48:37 +08:00
headers = vr.payload.(*RouteConfig).Headers
2018-05-20 23:22:07 +08:00
}
return
}
2019-07-31 00:41:58 +08:00
// CreateConnection create a new connection by route config
func (rp *HTTPReverseProxy) CreateConnection(domain, location, routeByHTTPUser string, remoteAddr string) (net.Conn, error) {
vr, ok := rp.getVhost(domain, location, routeByHTTPUser)
2017-12-13 03:27:43 +08:00
if ok {
2020-05-24 17:48:37 +08:00
fn := vr.payload.(*RouteConfig).CreateConnFn
2017-12-13 03:27:43 +08:00
if fn != nil {
2019-04-10 10:51:01 +08:00
return fn(remoteAddr)
2017-12-13 03:27:43 +08:00
}
}
return nil, fmt.Errorf("%v: %s %s %s", ErrNoRouteFound, domain, location, routeByHTTPUser)
2017-12-13 03:27:43 +08:00
}
func (rp *HTTPReverseProxy) CheckAuth(domain, location, routeByHTTPUser, user, passwd string) bool {
vr, ok := rp.getVhost(domain, location, routeByHTTPUser)
2017-12-13 23:44:27 +08:00
if ok {
2020-05-24 17:48:37 +08:00
checkUser := vr.payload.(*RouteConfig).Username
checkPasswd := vr.payload.(*RouteConfig).Password
2017-12-13 23:44:27 +08:00
if (checkUser != "" || checkPasswd != "") && (checkUser != user || checkPasswd != passwd) {
return false
}
}
return true
}
// getVhost trys to get vhost router by route policy.
func (rp *HTTPReverseProxy) getVhost(domain, location, routeByHTTPUser string) (*Router, bool) {
findRouter := func(inDomain, inLocation, inRouteByHTTPUser string) (*Router, bool) {
vr, ok := rp.vhostRouter.Get(inDomain, inLocation, inRouteByHTTPUser)
if ok {
return vr, ok
}
// Try to check if there is one proxy that doesn't specify routerByHTTPUser, it means match all.
vr, ok = rp.vhostRouter.Get(inDomain, inLocation, "")
if ok {
return vr, ok
}
return nil, false
}
// First we check the full hostname
2017-12-13 03:27:43 +08:00
// if not exist, then check the wildcard_domain such as *.example.com
vr, ok := findRouter(domain, location, routeByHTTPUser)
2017-12-13 03:27:43 +08:00
if ok {
return vr, ok
2017-12-13 03:27:43 +08:00
}
// e.g. domain = test.example.com, try to match wildcard domains.
// *.example.com
// *.com
2017-12-13 03:27:43 +08:00
domainSplit := strings.Split(domain, ".")
for {
if len(domainSplit) < 3 {
break
}
domainSplit[0] = "*"
domain = strings.Join(domainSplit, ".")
vr, ok = findRouter(domain, location, routeByHTTPUser)
if ok {
return vr, true
}
domainSplit = domainSplit[1:]
2017-12-13 03:27:43 +08:00
}
// Finally, try to check if there is one proxy that domain is "*" means match all domains.
vr, ok = findRouter("*", location, routeByHTTPUser)
if ok {
return vr, true
}
return nil, false
}
func (rp *HTTPReverseProxy) connectHandler(rw http.ResponseWriter, req *http.Request) {
hj, ok := rw.(http.Hijacker)
if !ok {
rw.WriteHeader(http.StatusInternalServerError)
return
}
client, _, err := hj.Hijack()
if err != nil {
rw.WriteHeader(http.StatusInternalServerError)
return
}
url := req.Context().Value(RouteInfoURL).(string)
routeByHTTPUser := req.Context().Value(RouteInfoHTTPUser).(string)
domain, _ := util.CanonicalHost(req.Context().Value(RouteInfoHost).(string))
remoteAddr := req.Context().Value(RouteInfoRemote).(string)
remote, err := rp.CreateConnection(domain, url, routeByHTTPUser, remoteAddr)
if err != nil {
http.Error(rw, "Failed", http.StatusBadRequest)
client.Close()
return
}
req.Write(remote)
go frpIo.Join(remote, client)
}
func (rp *HTTPReverseProxy) injectRequestInfoToCtx(req *http.Request) *http.Request {
newctx := req.Context()
newctx = context.WithValue(newctx, RouteInfoURL, req.URL.Path)
newctx = context.WithValue(newctx, RouteInfoHost, req.Host)
newctx = context.WithValue(newctx, RouteInfoURLHost, req.URL.Host)
user := ""
// If url host isn't empty, it's a proxy request. Get http user from Proxy-Authorization header.
if req.URL.Host != "" {
proxyAuth := req.Header.Get("Proxy-Authorization")
if proxyAuth != "" {
user, _, _ = parseBasicAuth(proxyAuth)
}
}
if user == "" {
user, _, _ = req.BasicAuth()
}
newctx = context.WithValue(newctx, RouteInfoHTTPUser, user)
newctx = context.WithValue(newctx, RouteInfoRemote, req.RemoteAddr)
return req.Clone(newctx)
2017-12-13 03:27:43 +08:00
}
2020-05-24 17:48:37 +08:00
func (rp *HTTPReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
domain, _ := util.CanonicalHost(req.Host)
2017-12-13 23:44:27 +08:00
location := req.URL.Path
user, passwd, _ := req.BasicAuth()
if !rp.CheckAuth(domain, location, user, user, passwd) {
2017-12-13 23:44:27 +08:00
rw.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
http.Error(rw, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
newreq := rp.injectRequestInfoToCtx(req)
if req.Method == http.MethodConnect {
rp.connectHandler(rw, newreq)
} else {
rp.proxy.ServeHTTP(rw, newreq)
}
2017-12-13 03:27:43 +08:00
}
type wrapPool struct{}
func newWrapPool() *wrapPool { return &wrapPool{} }
func (p *wrapPool) Get() []byte { return pool.GetBuf(32 * 1024) }
func (p *wrapPool) Put(buf []byte) { pool.PutBuf(buf) }
type wrapLogger struct{}
func newWrapLogger() *wrapLogger { return &wrapLogger{} }
func (l *wrapLogger) Write(p []byte) (n int, err error) {
frpLog.Warn("%s", string(bytes.TrimRight(p, "\n")))
2017-12-13 03:27:43 +08:00
return len(p), nil
}