mirror
/
gost-mirror
mirror of https://github.com/ginuerzh/gost
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

fix http2

pull/55/head
rui.zheng 10 years ago
parent
057a17be87
commit
a5e06c6666
7 changed files with 74 additions and 63 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 86
      conn.go
  2. 2
      forward.go
  3. 31
      http.go
  4. 3
      main.go
  5. 2
      socks.go
  6. 2
      ss.go
  7. 11
      util.go

86
conn.go
View File

@ -52,13 +52,10 @@ func listenAndServe(arg Args) error {
case "wss": // websocket security connection
return NewWs(arg).listenAndServeTLS()
case "tls": // tls connection
if arg.Protocol == "http2" { // only support http2 over TLS
return listenAndServeHttp2(arg, http.HandlerFunc(handlerHttp2Request))
}
ln, err = tls.Listen("tcp", arg.Addr,
&tls.Config{Certificates: []tls.Certificate{arg.Cert}})
case "http2": // http2 connetction
return listenAndServeHttp2(arg, http.HandlerFunc(handleHttp2Transport))
return listenAndServeHttp2(arg, http.HandlerFunc(handlerHttp2Request))
case "tcp": // Local TCP port forwarding
return listenAndServeTcpForward(arg)
case "udp": // Local UDP port forwarding
@ -378,58 +375,71 @@ func (r *reqReader) Read(p []byte) (n int, err error) {
return
}
func Connect(addr string) (conn net.Conn, err error) {
if len(forwardArgs) > 0 {
last := forwardArgs[len(forwardArgs)-1]
if http2Client != nil && last.Protocol == "http2" {
return connectHttp2(http2Client, addr)
}
func connect(addr string, prot string, chain []Args) (conn net.Conn, err error) {
if !strings.Contains(addr, ":") {
addr += ":80"
}
return connectWithChain(addr, forwardArgs...)
}
func connectHttp2(client *http.Client, host string) (net.Conn, error) {
pr, pw := io.Pipe()
u := url.URL{Scheme: "https", Host: host}
req, err := http.NewRequest(http.MethodConnect, u.String(), ioutil.NopCloser(pr))
if err != nil {
return nil, err
if enabled, h2host := http2Enabled(); enabled {
return connectHttp2(http2Client, h2host, addr, prot)
}
req.ContentLength = -1
if glog.V(LDEBUG) {
dump, _ := httputil.DumpRequest(req, false)
glog.Infoln(string(dump))
if len(chain) == 0 {
return net.DialTimeout("tcp", addr, time.Second*90)
}
resp, err := http2Client.Do(req)
var end Args
conn, end, err = forwardChain(chain...)
if err != nil {
return nil, err
}
if resp.StatusCode != http.StatusOK {
resp.Body.Close()
return nil, errors.New(resp.Status)
if err := establish(conn, addr, end); err != nil {
conn.Close()
return nil, err
}
conn := &Http2ClientConn{r: resp.Body, w: pw}
conn.remoteAddr, _ = net.ResolveTCPAddr("tcp", host)
return conn, nil
}
func connectWithChain(addr string, chain ...Args) (conn net.Conn, err error) {
if !strings.Contains(addr, ":") {
addr += ":80"
func http2Enabled() (enabled bool, host string) {
length := len(forwardArgs)
if http2Client == nil || length == 0 || forwardArgs[length-1].Transport != "http2" {
return
}
if len(chain) == 0 {
return net.DialTimeout("tcp", addr, time.Second*90)
return true, forwardArgs[length-1].Addr
}
func connectHttp2(client *http.Client, host, target string, prot string) (net.Conn, error) {
pr, pw := io.Pipe()
req := http.Request{
Method: http.MethodConnect,
URL: &url.URL{Scheme: "https", Host: host},
Header: make(http.Header),
Proto: "HTTP/2.0",
ProtoMajor: 2,
ProtoMinor: 0,
Body: ioutil.NopCloser(pr),
Host: host,
ContentLength: -1,
}
req.Header.Set("gost-target-addr", target)
if prot != "" {
req.Header.Set("gost-prot", prot)
}
var end Args
conn, end, err = forwardChain(chain...)
if glog.V(LDEBUG) {
dump, _ := httputil.DumpRequest(&req, false)
glog.Infoln(string(dump))
}
resp, err := client.Do(&req)
if err != nil {
return nil, err
}
if err := establish(conn, addr, end); err != nil {
conn.Close()
return nil, err
if resp.StatusCode != http.StatusOK {
resp.Body.Close()
return nil, errors.New(resp.Status)
}
conn := &Http2ClientConn{r: resp.Body, w: pw}
conn.remoteAddr, _ = net.ResolveTCPAddr("tcp", target)
return conn, nil
}

2
forward.go
View File

@ -13,7 +13,7 @@ func handleTcpForward(conn net.Conn, raddr net.Addr) {
defer conn.Close()
glog.V(LINFO).Infof("[tcp] %s - %s", conn.RemoteAddr(), raddr)
c, err := Connect(raddr.String())
c, err := connect(raddr.String(), "")
if err != nil {
glog.V(LWARNING).Infof("[tcp] %s -> %s : %s", conn.RemoteAddr(), raddr, err)
return

31
http.go
View File

@ -19,7 +19,7 @@ var (
)
func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
glog.V(LINFO).Infof("[http] %s - %s", conn.RemoteAddr(), req.Host)
glog.V(LINFO).Infof("[http] %s %s - %s %s", req.Method, conn.RemoteAddr(), req.Host, req.Proto)
if glog.V(LDEBUG) {
dump, _ := httputil.DumpRequest(req, false)
@ -55,7 +55,8 @@ func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
return
}
}
c, err := Connect(req.Host)
c, err := connect(req.Host, "http")
if err != nil {
glog.V(LWARNING).Infof("[http] %s -> %s : %s", conn.RemoteAddr(), req.Host, err)
@ -160,7 +161,6 @@ func (c *Http2ClientConn) SetWriteDeadline(t time.Time) error {
// init http2 client with target http2 proxy server addr, and forward chain chain
func initHttp2Client(host string, chain ...Args) {
glog.V(LINFO).Infoln("init http2 client")
tr := http2.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
@ -178,15 +178,20 @@ func initHttp2Client(host string, chain ...Args) {
}
func handlerHttp2Request(w http.ResponseWriter, req *http.Request) {
glog.V(LINFO).Infof("[http2] %s - %s", req.RemoteAddr, req.Host)
target := req.Header.Get("gost-target-addr")
if target == "" {
target = req.Host
}
glog.V(LINFO).Infof("[http2] %s %s - %s %s", req.Method, req.RemoteAddr, target, req.Proto)
if glog.V(LDEBUG) {
dump, _ := httputil.DumpRequest(req, false)
glog.Infoln(string(dump))
}
c, err := Connect(req.Host)
c, err := connect(target, req.Header.Get("gost-prot"))
if err != nil {
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, req.Host, err)
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, target, err)
w.Header().Set("Proxy-Agent", "gost/"+Version)
w.WriteHeader(http.StatusServiceUnavailable)
if fw, ok := w.(http.Flusher); ok {
@ -196,7 +201,7 @@ func handlerHttp2Request(w http.ResponseWriter, req *http.Request) {
}
defer c.Close()
glog.V(LINFO).Infof("[http2] %s <-> %s", req.RemoteAddr, req.Host)
glog.V(LINFO).Infof("[http2] %s <-> %s", req.RemoteAddr, target)
errc := make(chan error, 2)
if req.Method == http.MethodConnect {
@ -211,7 +216,7 @@ func handlerHttp2Request(w http.ResponseWriter, req *http.Request) {
// we take over the underly connection
conn, _, err := hj.Hijack()
if err != nil {
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, req.Host, err)
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, target, err)
return
}
defer conn.Close()
@ -230,7 +235,7 @@ func handlerHttp2Request(w http.ResponseWriter, req *http.Request) {
} else {
req.Header.Set("Connection", "Keep-Alive")
if err = req.Write(c); err != nil {
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, req.Host, err)
glog.V(LWARNING).Infof("[http2] %s -> %s : %s", req.RemoteAddr, target, err)
return
}
@ -250,15 +255,16 @@ func handlerHttp2Request(w http.ResponseWriter, req *http.Request) {
if fw, ok := w.(http.Flusher); ok {
fw.Flush()
}
if _, err := io.Copy(flushWriter{w}, resp.Body); err != nil {
glog.V(LWARNING).Infof("[http2] %s <- %s : %s", req.RemoteAddr, req.Host, err)
glog.V(LWARNING).Infof("[http2] %s <- %s : %s", req.RemoteAddr, target, err)
}
}
glog.V(LINFO).Infof("[http2] %s >-< %s", req.RemoteAddr, req.Host)
glog.V(LINFO).Infof("[http2] %s >-< %s", req.RemoteAddr, target)
}
//func processSocks5OverHttp2()
func handleHttp2Transport(w http.ResponseWriter, req *http.Request) {
glog.V(LINFO).Infof("[http2] %s - %s", req.RemoteAddr, req.Host)
if glog.V(LDEBUG) {
@ -296,7 +302,6 @@ func (fw flushWriter) Write(p []byte) (n int, err error) {
n, err = fw.w.Write(p)
if err != nil {
glog.V(LWARNING).Infoln("flush writer:", err)
return
}
if f, ok := fw.w.(http.Flusher); ok {
f.Flush()

3
main.go
View File

@ -17,6 +17,7 @@ const (
LWARNING
LINFO
LDEBUG
LVDEBUG // verbose debug
)
const (
@ -37,7 +38,7 @@ func init() {
flag.BoolVar(&pv, "V", false, "print version")
flag.Parse()
if glog.V(LDEBUG) {
if glog.V(LVDEBUG) {
http2.VerboseLogs = true
}
}

2
socks.go
View File

@ -170,7 +170,7 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
case gosocks5.CmdConnect:
glog.V(LINFO).Infof("[socks5-connect] %s - %s", conn.RemoteAddr(), req.Addr)
tconn, err := Connect(req.Addr.String())
tconn, err := connect(req.Addr.String(), "socks5")
if err != nil {
glog.V(LWARNING).Infof("[socks5-connect] %s -> %s : %s", conn.RemoteAddr(), req.Addr, err)
rep := gosocks5.NewReply(gosocks5.HostUnreachable, nil)

2
ss.go
View File

@ -31,7 +31,7 @@ func handleShadow(conn net.Conn, arg Args) {
}
glog.V(LINFO).Infof("[ss] %s -> %s", conn.RemoteAddr(), addr.String())
sconn, err := Connect(addr.String())
sconn, err := connect(addr.String(), "ss")
if err != nil {
glog.V(LWARNING).Infof("[ss] %s -> %s : %s", conn.RemoteAddr(), addr.String(), err)
return

11
util.go
View File

@ -79,7 +79,7 @@ func parseArgs(ss []string) (args []Args) {
arg.Protocol = "http"
arg.Transport = "tls"
case "http2":
arg.Protocol = ""
arg.Protocol = "http2"
case "tcp", "udp": // started from v2.1, tcp and udp are for local port forwarding
arg.Remote = strings.Trim(u.EscapedPath(), "/")
case "rtcp", "rudp": // started from v2.1, rtcp and rudp are for remote port forwarding
@ -89,9 +89,7 @@ func parseArgs(ss []string) (args []Args) {
}
switch arg.Protocol {
case "http", "socks", "socks5", "ss":
case "http2":
arg.Transport = "tls" // standard http2 proxy, only support http2 over tls
case "http", "http2", "socks", "socks5", "ss":
default:
arg.Protocol = ""
}
@ -112,14 +110,11 @@ func processForwardChain(chain ...Args) {
// http2 restrict: only last proxy can enable http2
for i, _ := range c {
if c[i].Protocol == "http2" {
c[i].Protocol = "http"
}
if c[i].Transport == "http2" {
c[i].Transport = ""
}
}
if last.Protocol == "http2" || last.Transport == "http2" {
if last.Transport == "http2" {
initHttp2Client(last.Addr, c...)
}
}

Write Preview
Loading…
Cancel
Save