add host_header_rewrite in frpc.ini to rewrite your requests with a modified Host header

src/frp/utils/conn/conn.go

@@ -117,8 +117,13 @@ func ConnectServer(host string, port int64) (c *Conn, err error) {
 	return c, nil
 }
 
+// if the tcpConn is different with c.TcpConn
+// you should call c.Close() first
 func (c *Conn) SetTcpConn(tcpConn net.Conn) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
 	c.TcpConn = tcpConn
+	c.closeFlag = false
 	c.Reader = bufio.NewReader(c.TcpConn)
 }
 

src/frp/utils/vhost/http.go

@@ -26,7 +26,6 @@ import (
 	"time"
 
 	"frp/utils/conn"
-	"frp/utils/log"
 )
 
 type HttpMuxer struct {
@@ -47,31 +46,28 @@ func GetHttpHostname(c *conn.Conn) (_ net.Conn, routerName string, err error) {
 }
 
 func NewHttpMuxer(listener *conn.Listener, timeout time.Duration) (*HttpMuxer, error) {
-	mux, err := NewVhostMuxer(listener, GetHttpHostname, timeout)
+	mux, err := NewVhostMuxer(listener, GetHttpHostname, HttpHostNameRewrite, timeout)
 	return &HttpMuxer{mux}, err
 }
 
-func HostNameRewrite(c *conn.Conn, clientHost string) (_ net.Conn, err error) {
-	log.Info("HostNameRewrite, clientHost: %s", clientHost)
+func HttpHostNameRewrite(c *conn.Conn, rewriteHost string) (_ net.Conn, err error) {
 	sc, rd := newShareConn(c.TcpConn)
 	var buff []byte
-	if buff, err = hostNameRewrite(rd, clientHost); err != nil {
+	if buff, err = hostNameRewrite(rd, rewriteHost); err != nil {
 		return sc, err
 	}
 	err = sc.WriteBuff(buff)
 	return sc, err
 }
 
-func hostNameRewrite(request io.Reader, clientHost string) (_ []byte, err error) {
+func hostNameRewrite(request io.Reader, rewriteHost string) (_ []byte, err error) {
 	buffer := make([]byte, 1024)
 	request.Read(buffer)
-	log.Debug("before hostNameRewrite:\n %s", string(buffer))
-	retBuffer, err := parseRequest(buffer, clientHost)
-	log.Debug("after hostNameRewrite:\n %s", string(retBuffer))
+	retBuffer, err := parseRequest(buffer, rewriteHost)
 	return retBuffer, err
 }
 
-func parseRequest(org []byte, clientHost string) (ret []byte, err error) {
+func parseRequest(org []byte, rewriteHost string) (ret []byte, err error) {
 	tp := bytes.NewBuffer(org)
 	// First line: GET /index.html HTTP/1.0
 	var b []byte
@@ -79,10 +75,10 @@ func parseRequest(org []byte, clientHost string) (ret []byte, err error) {
 		return nil, err
 	}
 	req := new(http.Request)
-	//we invoked ReadRequest in GetHttpHostname before, so we ignore error
+	// we invoked ReadRequest in GetHttpHostname before, so we ignore error
 	req.Method, req.RequestURI, req.Proto, _ = parseRequestLine(string(b))
 	rawurl := req.RequestURI
-	//CONNECT www.google.com:443 HTTP/1.1
+	// CONNECT www.google.com:443 HTTP/1.1
 	justAuthority := req.Method == "CONNECT" && !strings.HasPrefix(rawurl, "/")
 	if justAuthority {
 		rawurl = "http://" + rawurl
@@ -97,7 +93,7 @@ func parseRequest(org []byte, clientHost string) (ret []byte, err error) {
 	//  GET /index.html HTTP/1.1
 	//  Host: www.google.com
 	if req.URL.Host == "" {
-		changedBuf, err := changeHostName(tp, clientHost)
+		changedBuf, err := changeHostName(tp, rewriteHost)
 		buf := new(bytes.Buffer)
 		buf.Write(b)
 		buf.Write(changedBuf)
@@ -108,7 +104,12 @@ func parseRequest(org []byte, clientHost string) (ret []byte, err error) {
 	// GET http://www.google.com/index.html HTTP/1.1
 	// Host: doesntmatter
 	// In this case, any Host line is ignored.
-	req.URL.Host = clientHost
+	hostPort := strings.Split(req.URL.Host, ":")
+	if len(hostPort) == 1 {
+		req.URL.Host = rewriteHost
+	} else if len(hostPort) == 2 {
+		req.URL.Host = fmt.Sprintf("%s:%s", rewriteHost, hostPort[1])
+	}
 	firstLine := req.Method + " " + req.URL.String() + " " + req.Proto
 	buf := new(bytes.Buffer)
 	buf.WriteString(firstLine)
@@ -128,7 +129,7 @@ func parseRequestLine(line string) (method, requestURI, proto string, ok bool) {
 	return line[:s1], line[s1+1 : s2], line[s2+1:], true
 }
 
-func changeHostName(buff *bytes.Buffer, clientHost string) (_ []byte, err error) {
+func changeHostName(buff *bytes.Buffer, rewriteHost string) (_ []byte, err error) {
 	retBuf := new(bytes.Buffer)
 
 	peek := buff.Bytes()
@@ -145,7 +146,13 @@ func changeHostName(buff *bytes.Buffer, clientHost string) (_ []byte, err error)
 			return nil, fmt.Errorf("malformed MIME header line: " + string(kv))
 		}
 		if strings.Contains(strings.ToLower(string(kv[:j])), "host") {
-			hostHeader := fmt.Sprintf("Host: %s\n", clientHost)
+			var hostHeader string
+			portPos := bytes.IndexByte(kv[j+1:], ':')
+			if portPos == -1 {
+				hostHeader = fmt.Sprintf("Host: %s\n", rewriteHost)
+			} else {
+				hostHeader = fmt.Sprintf("Host: %s:%s\n", rewriteHost, kv[portPos+1:])
+			}
 			retBuf.WriteString(hostHeader)
 			peek = peek[i+1:]
 			break

src/frp/utils/vhost/https.go

@@ -47,7 +47,7 @@ type HttpsMuxer struct {
 }
 
 func NewHttpsMuxer(listener *conn.Listener, timeout time.Duration) (*HttpsMuxer, error) {
-	mux, err := NewVhostMuxer(listener, GetHttpsHostname, timeout)
+	mux, err := NewVhostMuxer(listener, GetHttpsHostname, nil, timeout)
 	return &HttpsMuxer{mux}, err
 }
 

src/frp/utils/vhost/vhost.go

@@ -27,41 +27,42 @@ import (
 )
 
 type muxFunc func(*conn.Conn) (net.Conn, string, error)
+type hostRewriteFunc func(*conn.Conn, string) (net.Conn, error)
 
 type VhostMuxer struct {
 	listener    *conn.Listener
 	timeout     time.Duration
 	vhostFunc   muxFunc
+	rewriteFunc hostRewriteFunc
 	registryMap map[string]*Listener
 	mutex       sync.RWMutex
 }
 
-func NewVhostMuxer(listener *conn.Listener, vhostFunc muxFunc, timeout time.Duration) (mux *VhostMuxer, err error) {
+func NewVhostMuxer(listener *conn.Listener, vhostFunc muxFunc, rewriteFunc hostRewriteFunc, timeout time.Duration) (mux *VhostMuxer, err error) {
 	mux = &VhostMuxer{
 		listener:    listener,
 		timeout:     timeout,
 		vhostFunc:   vhostFunc,
+		rewriteFunc: rewriteFunc,
 		registryMap: make(map[string]*Listener),
 	}
 	go mux.run()
 	return mux, nil
 }
 
-func (v *VhostMuxer) Listen(name, proxytype, clientIp string, clientPort, serverPort int64) (l *Listener, err error) {
+// listen for a new domain name, if rewriteHost is not empty  and rewriteFunc is not nil, then rewrite the host header to rewriteHost
+func (v *VhostMuxer) Listen(name string, rewriteHost string) (l *Listener, err error) {
 	v.mutex.Lock()
 	defer v.mutex.Unlock()
 	if _, exist := v.registryMap[name]; exist {
-		return nil, fmt.Errorf("name %s is already bound", name)
+		return nil, fmt.Errorf("domain name %s is already bound", name)
 	}
 
 	l = &Listener{
-		name:       name,
-		mux:        v,
-		accept:     make(chan *conn.Conn),
-		proxyType:  proxytype,
-		clientIp:   clientIp,
-		clientPort: clientPort,
-		serverPort: serverPort,
+		name:        name,
+		rewriteHost: rewriteHost,
+		mux:         v,
+		accept:      make(chan *conn.Conn),
 	}
 	v.registryMap[name] = l
 	return l, nil
@@ -115,13 +116,10 @@ func (v *VhostMuxer) handle(c *conn.Conn) {
 }
 
 type Listener struct {
-	name       string
-	mux        *VhostMuxer // for closing VhostMuxer
-	accept     chan *conn.Conn
-	proxyType  string //suppor http host rewrite
-	clientIp   string
-	clientPort int64
-	serverPort int64
+	name        string
+	rewriteHost string
+	mux         *VhostMuxer // for closing VhostMuxer
+	accept      chan *conn.Conn
 }
 
 func (l *Listener) Accept() (*conn.Conn, error) {
@@ -129,19 +127,16 @@ func (l *Listener) Accept() (*conn.Conn, error) {
 	if !ok {
 		return nil, fmt.Errorf("Listener closed")
 	}
-	if net.ParseIP(l.clientIp) == nil && l.proxyType == "http" {
-		if (l.name != l.clientIp) || (l.serverPort != l.clientPort) {
-			clientHost := l.clientIp
-			if l.clientPort != 80 {
-				strPort := fmt.Sprintf(":%d", l.clientPort)
-				clientHost += strPort
-			}
-			retConn, err := HostNameRewrite(conn, clientHost)
-			if err != nil {
-				return nil, fmt.Errorf("http host rewrite failed")
-			}
-			conn.SetTcpConn(retConn)
+
+	// if rewriteFunc is exist and rewriteHost is set
+	// rewrite http requests with a modified host header
+	if l.mux.rewriteFunc != nil && l.rewriteHost != "" {
+		fmt.Printf("host rewrite: %s\n", l.rewriteHost)
+		sConn, err := l.mux.rewriteFunc(conn, l.rewriteHost)
+		if err != nil {
+			return nil, fmt.Errorf("http host header rewrite failed")
 		}
+		conn.SetTcpConn(sConn)
 	}
 	return conn, nil
 }
@@ -162,6 +157,7 @@ type sharedConn struct {
 	buff *bytes.Buffer
 }
 
+// the bytes you read in io.Reader, will be reserved in sharedConn
 func newShareConn(conn net.Conn) (*sharedConn, io.Reader) {
 	sc := &sharedConn{
 		Conn: conn,