root/gost_software
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update udp local port forwarding policy

Browse Source
This commit is contained in:
rui.zheng 2016-09-14 22:11:29 +08:00
parent d492b8b53e
commit e12336fc3f
2 changed files with 139 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
conn.go
View File

@ -35,7 +35,7 @@ var (
// udp buffer pool // udp buffer pool
udpPool = sync.Pool{ udpPool = sync.Pool{
New: func() interface{} { New: func() interface{} {
return make([]byte, 64*1024+262) return make([]byte, 32*1024)
}, },
} }
) )
@ -108,35 +108,6 @@ func listenAndServeTcpForward(arg Args) error {
} }
} }
func prepareUdpConnectTunnel(addr net.Addr) (net.Conn, error) {
conn, _, err := forwardChain(forwardArgs...)
if err != nil {
return nil, err
}
conn.SetWriteDeadline(time.Now().Add(time.Second * 90))
if err = gosocks5.NewRequest(CmdUdpConnect, ToSocksAddr(addr)).Write(conn); err != nil {
conn.Close()
return nil, err
}
conn.SetWriteDeadline(time.Time{})
conn.SetReadDeadline(time.Now().Add(90 * time.Second))
reply, err := gosocks5.ReadReply(conn)
if err != nil {
conn.Close()
return nil, err
}
conn.SetReadDeadline(time.Time{})
if reply.Rep != gosocks5.Succeeded {
conn.Close()
return nil, errors.New("udp connect failure")
}
return conn, nil
}
func listenAndServeUdpForward(arg Args) error { func listenAndServeUdpForward(arg Args) error {
laddr, err := net.ResolveUDPAddr("udp", arg.Addr) laddr, err := net.ResolveUDPAddr("udp", arg.Addr)
if err != nil { if err != nil {
@ -148,28 +119,20 @@ func listenAndServeUdpForward(arg Args) error {
return err return err
} }
for { conn, err := net.ListenUDP("udp", laddr)
var conn *net.UDPConn
for {
conn, err = net.ListenUDP("udp", laddr)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err) glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
time.Sleep((1) * time.Second) return err
continue
} }
break
}
if len(forwardArgs) == 0 {
defer conn.Close() defer conn.Close()
if len(forwardArgs) == 0 {
for { for {
b := udpPool.Get().([]byte) b := udpPool.Get().([]byte)
n, addr, err := conn.ReadFromUDP(b) n, addr, err := conn.ReadFromUDP(b)
if err != nil { if err != nil {
glog.V(LWARNING).Infoln(err) glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
continue continue
} }
go func() { go func() {
@ -179,24 +142,42 @@ func listenAndServeUdpForward(arg Args) error {
} }
} }
var tun net.Conn rChan, wChan := make(chan *gosocks5.UDPDatagram, 32), make(chan *gosocks5.UDPDatagram, 32)
retry := 0
go func() {
for { for {
tun, err = prepareUdpConnectTunnel(raddr) b := make([]byte, 32*1024)
n, addr, err := conn.ReadFromUDP(b)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err) glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
time.Sleep((1 << uint(retry)) * time.Second) return
if retry < 5 {
retry++
} }
continue
select {
case rChan <- gosocks5.NewUDPDatagram(gosocks5.NewUDPHeader(uint16(n), 0, ToSocksAddr(addr)), b[:n]):
default:
// glog.V(LWARNING).Infof("[udp-connect] %s -> %s : rbuf is full", laddr, raddr)
} }
break
} }
glog.V(LWARNING).Infof("[udp-connect] %s <-> %s", laddr, raddr) }()
tunnelUDP(conn, tun, false)
glog.V(LWARNING).Infof("[udp-connect] %s >-< %s", laddr, raddr) go func() {
conn.Close() for {
dgram := <-wChan
addr, err := net.ResolveUDPAddr("udp", dgram.Header.Addr.String())
if err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s <- %s : %s", laddr, raddr, err)
continue // drop silently
}
if _, err = conn.WriteToUDP(dgram.Data, addr); err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s <- %s : %s", laddr, raddr, err)
return
}
}
}()
for {
handleUdpForwardTunnel(laddr, raddr, rChan, wChan)
} }
} }

152
forward.go
View File

@ -6,7 +6,6 @@ import (
"github.com/ginuerzh/gosocks5" "github.com/ginuerzh/gosocks5"
"github.com/golang/glog" "github.com/golang/glog"
"net" "net"
"strings"
"time" "time"
) )
@ -56,109 +55,98 @@ func handleUdpForwardLocal(conn *net.UDPConn, laddr, raddr *net.UDPAddr, data []
return return
} }
func handleUdpForward(conn *net.UDPConn, raddr *net.UDPAddr, data []byte, arg Args) { func prepareUdpConnectTunnel(addr net.Addr) (net.Conn, error) {
if !strings.Contains(arg.Remote, ":") { conn, _, err := forwardChain(forwardArgs...)
arg.Remote += ":53" // default is dns service
}
faddr, err := net.ResolveUDPAddr("udp", arg.Remote)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", raddr, arg.Remote, err) return nil, err
return
} }
glog.V(LINFO).Infof("[udp-forward] %s - %s", raddr, faddr) conn.SetWriteDeadline(time.Now().Add(time.Second * 90))
if err = gosocks5.NewRequest(CmdUdpConnect, ToSocksAddr(addr)).Write(conn); err != nil {
conn.Close()
return nil, err
}
conn.SetWriteDeadline(time.Time{})
if len(forwardArgs) == 0 { conn.SetReadDeadline(time.Now().Add(90 * time.Second))
lconn, err := net.ListenUDP("udp", nil) reply, err := gosocks5.ReadReply(conn)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", raddr, arg.Remote, err) conn.Close()
return return nil, err
} }
defer lconn.Close() conn.SetReadDeadline(time.Time{})
if _, err := lconn.WriteToUDP(data, faddr); err != nil { if reply.Rep != gosocks5.Succeeded {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", raddr, arg.Remote, err) conn.Close()
return return nil, errors.New("failure")
} }
glog.V(LDEBUG).Infof("[udp-forward] %s >>> %s length %d", raddr, arg.Remote, len(data))
b := udpPool.Get().([]byte) return conn, nil
defer udpPool.Put(b) }
lconn.SetReadDeadline(time.Now().Add(time.Second * 60))
n, addr, err := lconn.ReadFromUDP(b) func handleUdpForwardTunnel(laddr, raddr *net.UDPAddr, rChan, wChan chan *gosocks5.UDPDatagram) {
var tun net.Conn
var err error
retry := 0
for {
tun, err = prepareUdpConnectTunnel(raddr)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", raddr, arg.Remote, err) glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
return time.Sleep((1 << uint(retry)) * time.Second)
if retry < 5 {
retry++
} }
glog.V(LDEBUG).Infof("[udp-forward] %s <<< %s length %d", raddr, addr, n) continue
if _, err := conn.WriteToUDP(b[:n], raddr); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", raddr, arg.Remote, err)
} }
glog.V(LINFO).Infof("[udp-forward] %s >-< %s", raddr, arg.Remote) break
return
} }
tun, _, err := forwardChain(forwardArgs...) glog.V(LINFO).Infof("[udp-connect] %s <-> %s", laddr, raddr)
rExit := make(chan interface{})
rErr, wErr := make(chan error, 1), make(chan error, 1)
go func() {
for {
select {
case dgram := <-rChan:
if err := dgram.Write(tun); err != nil {
glog.V(LWARNING).Infof("[udp-connect] %s -> %s : %s", laddr, raddr, err)
rErr <- err
return
}
glog.V(LDEBUG).Infof("[udp-tun] %s >>> %s length: %d", laddr, raddr, len(dgram.Data))
case <-rExit:
// glog.V(LDEBUG).Infof("[udp-connect] %s -> %s : exited", laddr, raddr)
return
}
}
}()
go func() {
for {
dgram, err := gosocks5.ReadUDPDatagram(tun)
if err != nil { if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", raddr, arg.Remote, err) glog.V(LWARNING).Infof("[udp-connect] %s <- %s : %s", laddr, raddr, err)
close(rExit)
wErr <- err
return return
} }
defer tun.Close()
glog.V(LINFO).Infof("[udp-forward] %s -> %s ASSOCIATE", raddr, arg.Remote) select {
case wChan <- dgram:
req := gosocks5.NewRequest(CmdUdpTun, nil) glog.V(LDEBUG).Infof("[udp-tun] %s <<< %s length: %d", laddr, raddr, len(dgram.Data))
tun.SetWriteDeadline(time.Now().Add(time.Second * 90)) default:
if err = req.Write(tun); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s ASSOCIATE : %s", raddr, arg.Remote, err)
return
} }
tun.SetWriteDeadline(time.Time{})
glog.V(LDEBUG).Infof("[udp-forward] %s -> %s\n%s", raddr, arg.Remote, req)
tun.SetReadDeadline(time.Now().Add(90 * time.Second))
rep, err := gosocks5.ReadReply(tun)
if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s ASSOCIATE : %s", raddr, arg.Remote, err)
return
} }
tun.SetReadDeadline(time.Time{}) }()
glog.V(LDEBUG).Infof("[udp-forward] %s <- %s\n%s", raddr, arg.Remote, rep) select {
if rep.Rep != gosocks5.Succeeded { case <-rErr:
glog.V(LWARNING).Infof("[udp-forward] %s <- %s ASSOCIATE failured", raddr, arg.Remote) //log.Println("w exit", err)
return case <-wErr:
//log.Println("r exit", err)
} }
glog.V(LINFO).Infof("[udp-forward] %s <-> %s ASSOCIATE ON %s", raddr, arg.Remote, rep.Addr) glog.V(LINFO).Infof("[udp-connect] %s >-< %s", laddr, raddr)
dgram := gosocks5.NewUDPDatagram(
gosocks5.NewUDPHeader(uint16(len(data)), 0, ToSocksAddr(faddr)), data)
tun.SetWriteDeadline(time.Now().Add(time.Second * 90))
if err = dgram.Write(tun); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s -> %s : %s", raddr, arg.Remote, err)
return
}
tun.SetWriteDeadline(time.Time{})
glog.V(LDEBUG).Infof("[udp-forward] %s >>> %s length %d", raddr, arg.Remote, len(data))
tun.SetReadDeadline(time.Now().Add(time.Second * 90))
dgram, err = gosocks5.ReadUDPDatagram(tun)
if err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", raddr, arg.Remote, err)
return
}
tun.SetReadDeadline(time.Time{})
glog.V(LDEBUG).Infof("[udp-forward] %s <<< %s length %d", raddr, dgram.Header.Addr, len(dgram.Data))
if _, err = conn.WriteToUDP(dgram.Data, raddr); err != nil {
glog.V(LWARNING).Infof("[udp-forward] %s <- %s : %s", raddr, arg.Remote, err)
}
// NOTE: for now we only get one response from peer
glog.V(LINFO).Infof("[udp-forward] %s >-< %s", raddr, arg.Remote)
} }
func connectRTcpForward(conn net.Conn, arg Args) error { func connectRTcpForward(conn net.Conn, arg Args) error {