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

add bind forward

pull/44/head
rui.zheng 11 years ago
parent
706e22e7a7
commit
d7dfb3edaa
3 changed files with 196 additions and 112 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. 71
      conn.go
  2. 2
      http.go
  3. 235
      socks.go

71
conn.go
View File

@ -111,7 +111,7 @@ func handleConn(conn net.Conn, arg Args) {
}
return
}
handleSocks5Request(req, conn, arg)
handleSocks5Request(req, conn)
return
}
@ -162,7 +162,7 @@ func handleConn(conn net.Conn, arg Args) {
}
return
}
handleSocks5Request(req, conn, arg)
handleSocks5Request(req, conn)
return
}
@ -198,41 +198,43 @@ func (r *reqReader) Read(p []byte) (n int, err error) {
return
}
func connect(addr string) (conn net.Conn, err error) {
func Connect(addr string) (conn net.Conn, err error) {
if !strings.Contains(addr, ":") {
addr += ":80"
}
if len(forwardArgs) == 0 {
return net.Dial("tcp", addr)
}
return forwardChain(addr, forwardArgs[0], forwardArgs[1:]...)
}
func forwardChain(addr string, level1 Args, chain ...Args) (conn net.Conn, err error) {
if glog.V(LINFO) {
glog.Infof("forward: %s/%s %s", level1.Protocol, level1.Transport, level1.Addr)
}
if conn, err = net.Dial("tcp", level1.Addr); err != nil {
return
}
c, err := forward(conn, level1)
var end Args
conn, end, err = forwardChain(forwardArgs...)
if err != nil {
if conn != nil {
conn.Close()
}
return nil, err
}
if err := establish(conn, addr, end); err != nil {
conn.Close()
return nil, err
}
conn = c
return conn, nil
}
if len(chain) == 0 {
if err := establish(conn, addr, level1); err != nil {
conn.Close()
return nil, err
}
func forwardChain(chain ...Args) (conn net.Conn, end Args, err error) {
end = chain[0]
if conn, err = net.Dial("tcp", end.Addr); err != nil {
return
}
c, err := forward(conn, end)
if err != nil {
return
}
conn = c
cur := level1
chain = chain[1:]
for _, arg := range chain {
if err = establish(conn, arg.Addr, cur); err != nil {
if err = establish(conn, arg.Addr, end); err != nil {
goto exit
}
@ -241,26 +243,18 @@ func forwardChain(addr string, level1 Args, chain ...Args) (conn net.Conn, err e
goto exit
}
conn = c
cur = arg
end = arg
}
exit:
if err != nil {
conn.Close()
return nil, err
}
if err := establish(conn, addr, cur); err != nil {
conn.Close()
return nil, err
}
return
}
func forward(conn net.Conn, arg Args) (net.Conn, error) {
var err error
if glog.V(LINFO) {
glog.Infof("forward: %s/%s %s", arg.Protocol, arg.Transport, arg.Addr)
}
switch arg.Transport {
case "ws": // websocket connection
conn, err = wsClient(conn, arg.Addr)
@ -312,10 +306,19 @@ func establish(conn net.Conn, addr string, arg Args) error {
Host: host,
Port: uint16(p),
})
rep, err := requestSocks5(conn, req)
if err := req.Write(conn); err != nil {
return err
}
if glog.V(LDEBUG) {
glog.Infoln(req)
}
rep, err := gosocks5.ReadReply(conn)
if err != nil {
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
if rep.Rep != gosocks5.Succeeded {
return errors.New("Service unavailable")
}

2
http.go
View File

@ -47,7 +47,7 @@ func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
return
}
c, err := connect(req.Host)
c, err := Connect(req.Host)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)

235
socks.go
View File

@ -2,6 +2,7 @@ package main
import (
"crypto/tls"
"errors"
"github.com/ginuerzh/gosocks5"
"github.com/golang/glog"
"net"
@ -175,24 +176,7 @@ func (selector *serverSelector) OnSelected(method uint8, conn net.Conn) (net.Con
return conn, nil
}
func requestSocks5(conn net.Conn, req *gosocks5.Request) (*gosocks5.Reply, error) {
if err := req.Write(conn); err != nil {
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(req.String())
}
rep, err := gosocks5.ReadReply(conn)
if err != nil {
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(rep.String())
}
return rep, nil
}
func handleSocks5Request(req *gosocks5.Request, conn net.Conn, arg Args) {
func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
if glog.V(LDEBUG) {
glog.Infoln(req)
}
@ -202,7 +186,7 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn, arg Args) {
if glog.V(LINFO) {
glog.Infoln("socks5 connect:", req.Addr.String())
}
tconn, err := connect(req.Addr.String())
tconn, err := Connect(req.Addr.String())
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 connect:", err)
@ -234,15 +218,21 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn, arg Args) {
Transport(conn, tconn)
case gosocks5.CmdBind:
l, err := net.ListenTCP("tcp", nil)
if len(forwardArgs) > 0 {
forwardBind(req, conn)
} else {
serveBind(conn)
}
case gosocks5.CmdUdp:
uconn, err := net.ListenUDP("udp", nil)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind listen:", err)
glog.Warningln("socks5 udp listen:", err)
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind listen:", err)
glog.Warningln("socks5 udp listen:", err)
}
} else {
if glog.V(LDEBUG) {
@ -251,102 +241,193 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn, arg Args) {
}
return
}
defer uconn.Close()
addr := ToSocksAddr(l.Addr())
addr := ToSocksAddr(uconn.LocalAddr())
addr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String())
if glog.V(LINFO) {
glog.Infoln("socks5 bind:", addr)
glog.Infoln("socks5 udp:", addr)
}
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
glog.Warningln("socks5 udp:", err)
}
l.Close()
return
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
srvTunnelUDP(conn, uconn)
}
}
tconn, err := l.AcceptTCP()
l.Close() // only accept one peer
if err != nil {
func serveBind(conn net.Conn) error {
l, err := net.ListenTCP("tcp", nil)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind listen:", err)
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind accept:", err)
glog.Warningln("socks5 bind listen:", err)
}
rep = gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind accept:", err)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
return
}
defer tconn.Close()
return err
}
addr = ToSocksAddr(tconn.RemoteAddr())
if glog.V(LINFO) {
glog.Infoln("socks5 bind accept:", addr.String())
addr := ToSocksAddr(l.Addr())
// Issue: may not reachable when host has two interfaces
addr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String())
if glog.V(LINFO) {
glog.Infoln("socks5 bind:", addr)
}
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
}
l.Close()
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
tconn, err := l.AcceptTCP()
l.Close() // only accept one peer
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind accept:", err)
}
rep = gosocks5.NewReply(gosocks5.Succeeded, addr)
rep = gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind accept:", err)
}
return
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
return err
}
defer tconn.Close()
addr = ToSocksAddr(tconn.RemoteAddr())
if glog.V(LINFO) {
glog.Infoln("socks5 bind accept:", addr.String())
}
rep = gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind accept:", err)
}
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
return Transport(conn, tconn)
}
if err := Transport(conn, tconn); err != nil {
//log.Println(err)
func forwardBind(req *gosocks5.Request, conn net.Conn) error {
fc, _, err := forwardChain(forwardArgs...)
if err != nil {
if fc != nil {
fc.Close()
}
case gosocks5.CmdUdp:
uconn, err := net.ListenUDP("udp", nil)
if err != nil {
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp listen:", err)
glog.Warningln("socks5 bind:", err)
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp listen:", err)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
return
}
defer uconn.Close()
return err
}
defer fc.Close()
addr := ToSocksAddr(uconn.LocalAddr())
addr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String())
if glog.V(LINFO) {
glog.Infoln("socks5 udp:", addr)
if err := req.Write(fc); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
}
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
if glog.V(LDEBUG) {
glog.Infoln(req)
}
// first reply
if err := peekBindReply(conn, fc); err != nil {
return err
}
// second reply
if err := peekBindReply(conn, fc); err != nil {
return err
}
return Transport(conn, fc)
}
func peekBindReply(conn, fc net.Conn) error {
rep, err := gosocks5.ReadReply(fc)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
}
rep = gosocks5.NewReply(gosocks5.Failure, nil)
}
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
}
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
if rep.Rep != gosocks5.Succeeded {
return errors.New("Bind failure")
}
return nil
}
/*
func forwardUDP() error {
fc, _, err := forwardChain(forwardArgs...)
if err != nil {
if fc != nil {
fc.Close()
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp:", err)
glog.Warningln("socks5 bind:", err)
}
return
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
srvTunnelUDP(conn, uconn)
return err
}
}
defer fc.Close()
}
*/
func srvTunnelUDP(conn net.Conn, uconn *net.UDPConn) {
go func() {
b := make([]byte, 16*1024)

Write Preview
Loading…
Cancel
Save