2016-06-24 09:43:58 +02:00
|
|
|
// Copyright 2016 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 (
|
|
|
|
"bufio"
|
2016-07-24 09:00:18 +02:00
|
|
|
"bytes"
|
|
|
|
"fmt"
|
|
|
|
"io"
|
2016-06-24 09:43:58 +02:00
|
|
|
"net"
|
|
|
|
"net/http"
|
2016-07-24 09:00:18 +02:00
|
|
|
"net/url"
|
2016-06-24 09:43:58 +02:00
|
|
|
"strings"
|
|
|
|
"time"
|
|
|
|
|
2016-08-11 10:10:44 +02:00
|
|
|
"github.com/fatedier/frp/src/utils/conn"
|
|
|
|
"github.com/fatedier/frp/src/utils/pool"
|
2016-06-24 09:43:58 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
type HttpMuxer struct {
|
|
|
|
*VhostMuxer
|
|
|
|
}
|
|
|
|
|
|
|
|
func GetHttpHostname(c *conn.Conn) (_ net.Conn, routerName string, err error) {
|
|
|
|
sc, rd := newShareConn(c.TcpConn)
|
|
|
|
|
|
|
|
request, err := http.ReadRequest(bufio.NewReader(rd))
|
|
|
|
if err != nil {
|
|
|
|
return sc, "", err
|
|
|
|
}
|
|
|
|
tmpArr := strings.Split(request.Host, ":")
|
|
|
|
routerName = tmpArr[0]
|
|
|
|
request.Body.Close()
|
|
|
|
return sc, routerName, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewHttpMuxer(listener *conn.Listener, timeout time.Duration) (*HttpMuxer, error) {
|
2016-07-25 18:18:19 +02:00
|
|
|
mux, err := NewVhostMuxer(listener, GetHttpHostname, HttpHostNameRewrite, timeout)
|
2016-06-24 09:43:58 +02:00
|
|
|
return &HttpMuxer{mux}, err
|
|
|
|
}
|
2016-07-24 09:00:18 +02:00
|
|
|
|
2016-07-25 18:18:19 +02:00
|
|
|
func HttpHostNameRewrite(c *conn.Conn, rewriteHost string) (_ net.Conn, err error) {
|
2016-07-24 09:00:18 +02:00
|
|
|
sc, rd := newShareConn(c.TcpConn)
|
|
|
|
var buff []byte
|
2016-07-25 18:18:19 +02:00
|
|
|
if buff, err = hostNameRewrite(rd, rewriteHost); err != nil {
|
2016-07-24 09:00:18 +02:00
|
|
|
return sc, err
|
|
|
|
}
|
|
|
|
err = sc.WriteBuff(buff)
|
|
|
|
return sc, err
|
|
|
|
}
|
|
|
|
|
2016-07-25 18:18:19 +02:00
|
|
|
func hostNameRewrite(request io.Reader, rewriteHost string) (_ []byte, err error) {
|
2016-07-30 21:26:41 +02:00
|
|
|
buf := pool.GetBuf(1024)
|
|
|
|
defer pool.PutBuf(buf)
|
|
|
|
|
|
|
|
request.Read(buf)
|
|
|
|
retBuffer, err := parseRequest(buf, rewriteHost)
|
2016-07-24 09:00:18 +02:00
|
|
|
return retBuffer, err
|
|
|
|
}
|
|
|
|
|
2016-07-25 18:18:19 +02:00
|
|
|
func parseRequest(org []byte, rewriteHost string) (ret []byte, err error) {
|
2016-07-24 09:00:18 +02:00
|
|
|
tp := bytes.NewBuffer(org)
|
|
|
|
// First line: GET /index.html HTTP/1.0
|
|
|
|
var b []byte
|
|
|
|
if b, err = tp.ReadBytes('\n'); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
req := new(http.Request)
|
2016-07-25 18:18:19 +02:00
|
|
|
// we invoked ReadRequest in GetHttpHostname before, so we ignore error
|
2016-07-24 09:00:18 +02:00
|
|
|
req.Method, req.RequestURI, req.Proto, _ = parseRequestLine(string(b))
|
|
|
|
rawurl := req.RequestURI
|
2016-07-25 18:18:19 +02:00
|
|
|
// CONNECT www.google.com:443 HTTP/1.1
|
2016-07-24 09:00:18 +02:00
|
|
|
justAuthority := req.Method == "CONNECT" && !strings.HasPrefix(rawurl, "/")
|
|
|
|
if justAuthority {
|
|
|
|
rawurl = "http://" + rawurl
|
|
|
|
}
|
|
|
|
req.URL, _ = url.ParseRequestURI(rawurl)
|
|
|
|
if justAuthority {
|
|
|
|
// Strip the bogus "http://" back off.
|
|
|
|
req.URL.Scheme = ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// RFC2616: first case
|
|
|
|
// GET /index.html HTTP/1.1
|
|
|
|
// Host: www.google.com
|
|
|
|
if req.URL.Host == "" {
|
2016-07-25 18:18:19 +02:00
|
|
|
changedBuf, err := changeHostName(tp, rewriteHost)
|
2016-07-24 09:00:18 +02:00
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
buf.Write(b)
|
|
|
|
buf.Write(changedBuf)
|
|
|
|
return buf.Bytes(), err
|
|
|
|
}
|
|
|
|
|
|
|
|
// RFC2616: second case
|
|
|
|
// GET http://www.google.com/index.html HTTP/1.1
|
|
|
|
// Host: doesntmatter
|
|
|
|
// In this case, any Host line is ignored.
|
2016-07-25 18:18:19 +02:00
|
|
|
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])
|
|
|
|
}
|
2016-07-24 09:00:18 +02:00
|
|
|
firstLine := req.Method + " " + req.URL.String() + " " + req.Proto
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
buf.WriteString(firstLine)
|
|
|
|
tp.WriteTo(buf)
|
|
|
|
return buf.Bytes(), err
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// parseRequestLine parses "GET /foo HTTP/1.1" into its three parts.
|
|
|
|
func parseRequestLine(line string) (method, requestURI, proto string, ok bool) {
|
|
|
|
s1 := strings.Index(line, " ")
|
|
|
|
s2 := strings.Index(line[s1+1:], " ")
|
|
|
|
if s1 < 0 || s2 < 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
s2 += s1 + 1
|
|
|
|
return line[:s1], line[s1+1 : s2], line[s2+1:], true
|
|
|
|
}
|
|
|
|
|
2016-07-25 18:18:19 +02:00
|
|
|
func changeHostName(buff *bytes.Buffer, rewriteHost string) (_ []byte, err error) {
|
2016-07-24 09:00:18 +02:00
|
|
|
retBuf := new(bytes.Buffer)
|
|
|
|
|
|
|
|
peek := buff.Bytes()
|
|
|
|
for len(peek) > 0 {
|
|
|
|
i := bytes.IndexByte(peek, '\n')
|
|
|
|
if i < 3 {
|
|
|
|
// Not present (-1) or found within the next few bytes,
|
|
|
|
// implying we're at the end ("\r\n\r\n" or "\n\n")
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
kv := peek[:i]
|
|
|
|
j := bytes.IndexByte(kv, ':')
|
|
|
|
if j < 0 {
|
|
|
|
return nil, fmt.Errorf("malformed MIME header line: " + string(kv))
|
|
|
|
}
|
|
|
|
if strings.Contains(strings.ToLower(string(kv[:j])), "host") {
|
2016-07-25 18:18:19 +02:00
|
|
|
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:])
|
|
|
|
}
|
2016-07-24 09:00:18 +02:00
|
|
|
retBuf.WriteString(hostHeader)
|
|
|
|
peek = peek[i+1:]
|
|
|
|
break
|
|
|
|
} else {
|
|
|
|
retBuf.Write(peek[:i])
|
|
|
|
retBuf.WriteByte('\n')
|
|
|
|
}
|
|
|
|
|
|
|
|
peek = peek[i+1:]
|
|
|
|
}
|
|
|
|
retBuf.Write(peek)
|
|
|
|
return retBuf.Bytes(), err
|
|
|
|
}
|