bughz/glider
1
0
Fork 0
mirror of https://github.com/nadoo/glider.git synced 2025-02-23 17:35:40 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

ss: support udp forward chain

Browse Source
This commit is contained in:
nadoo 2018-01-18 18:12:17 +08:00
parent 9ac6db498e
commit 65e6caaa39
4 changed files with 30 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
direct.go
View File

@ -30,15 +30,15 @@ func (d *direct) Dial(network, addr string) (net.Conn, error) {
}
// DialUDP connects to the given address via the proxy.
func (d *direct) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
pc, err = net.ListenPacket(network, "")
func (d *direct) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
pc, err := net.ListenPacket(network, "")
if err != nil {
logf("ListenPacket error: %s", err)
return nil, nil, err
}
uAddr, err := net.ResolveUDPAddr("udp", addr)
return pc, uAddr, nil
return pc, uAddr, err
}
func (d *direct) NextDialer(dstAddr string) Dialer { return d }

5
forwarder.go
View File

@ -25,6 +25,11 @@ func (p *Forwarder) Dial(network, addr string) (net.Conn, error) {
return p.cDialer.Dial(network, addr)
}
// DialUDP to remote addr via cDialer
func (p *Forwarder) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
return p.cDialer.DialUDP(network, addr)
}
// NextDialer returns the next cDialer
func (p *Forwarder) NextDialer(dstAddr string) Dialer {
return p.cDialer

63
ss.go
View File

@ -5,7 +5,6 @@ import (
"log"
"net"
"strings"
"sync"
"time"
"github.com/shadowsocks/go-shadowsocks2/core"
@ -139,7 +138,6 @@ func (s *SS) ServeTCP(c net.Conn) {
}
// ListenAndServeUDP serves udp ss requests.
// TODO: Forwarder chain not supported now.
func (s *SS) ListenAndServeUDP() {
c, err := net.ListenPacket("udp", s.addr)
if err != nil {
@ -151,8 +149,6 @@ func (s *SS) ListenAndServeUDP() {
logf("proxy-ss-udp listening UDP on %s", s.addr)
c = s.PacketConn(c)
var nm sync.Map
buf := make([]byte, udpBufSize)
for {
@ -168,41 +164,34 @@ func (s *SS) ListenAndServeUDP() {
continue
}
tgtUDPAddr, err := net.ResolveUDPAddr("udp", tgtAddr.String())
if err != nil {
logf("proxy-ss-udp failed to resolve target UDP address: %v", err)
continue
}
logf("proxy-ss-udp %s <-> %s", raddr, tgtAddr)
payload := buf[len(tgtAddr):n]
var pc net.PacketConn
v, ok := nm.Load(raddr.String())
if !ok && v == nil {
pc, err = net.ListenPacket("udp", "")
if err != nil {
logf("proxy-ss-udp remote listen error: %v", err)
continue
}
nm.Store(raddr.String(), pc)
go func() {
timedCopy(c, raddr, pc, 5*time.Minute, true)
pc.Close()
nm.Delete(raddr.String())
}()
} else {
pc = v.(net.PacketConn)
rc, nexHop, err := s.sDialer.DialUDP("udp", tgtAddr.String())
if err != nil {
logf("proxy-ss-udp remote listen error: %v", err)
continue
}
_, err = pc.WriteTo(payload, tgtUDPAddr) // accept only UDPAddr despite the signature
_, err = rc.WriteTo(payload, nexHop) // accept only UDPAddr despite the signature
if err != nil {
logf("proxy-ss-udp remote write error: %v", err)
continue
}
rcBuf := make([]byte, udpBufSize)
rc.SetReadDeadline(time.Now().Add(time.Minute))
copy(rcBuf, tgtAddr)
n, _, err = rc.ReadFrom(rcBuf[len(tgtAddr):])
if err != nil {
logf("proxy-ss-udp rc.Read error: %v", err)
return
}
rc.Close()
c.WriteTo(rcBuf[:len(tgtAddr)+n], raddr)
}
}
@ -244,20 +233,15 @@ func (s *SS) Dial(network, addr string) (net.Conn, error) {
}
// DialUDP connects to the given address via the proxy.
func (s *SS) DialUDP(network, addr string) (pc net.PacketConn, writeTo net.Addr, err error) {
// TODO: check forward chain
pc, nextHop, err := s.cDialer.DialUDP(network, addr)
func (s *SS) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
pc, nextHop, err := s.cDialer.DialUDP(network, s.addr)
if err != nil {
logf("proxy-ss dialudp to %s error: %s", addr, err)
logf("proxy-ss dialudp to %s error: %s", s.addr, err)
return nil, nil, err
}
nextHopAddr := ParseAddr(nextHop.String())
writeTo, err = net.ResolveUDPAddr("udp", s.Addr())
pkc := NewPktConn(s.PacketConn(pc), writeTo, nextHopAddr, true)
return pkc, writeTo, err
pkc := NewPktConn(s.PacketConn(pc), nextHop, ParseAddr(addr), true)
return pkc, nextHop, err
}
// PktConn wraps a net.PacketConn and support Write method like net.Conn
@ -271,7 +255,6 @@ type PktConn struct {
// NewPktConn returns a PktConn
func NewPktConn(c net.PacketConn, addr net.Addr, target Addr, tgtHeader bool) *PktConn {
pc := &PktConn{
PacketConn: c,
addr: addr,
@ -312,8 +295,6 @@ func (pc *PktConn) Write(b []byte) (int, error) {
copy(buf, pc.target)
copy(buf[len(pc.target):], b)
// logf("Write: \n%s", hex.Dump(buf))
return pc.PacketConn.WriteTo(buf, pc.addr)
}

10
udptun.go
View File

@ -1,7 +1,6 @@
package main
import (
"encoding/hex"
"net"
"time"
)
@ -45,9 +44,6 @@ func (s *UDPTun) ListenAndServe() {
continue
}
logf("ClientAddr: %s", clientAddr)
logf("ReadFrom:\n%s", hex.Dump(buf[:n]))
go func() {
rc, wt, err := s.sDialer.DialUDP("udp", s.raddr)
if err != nil {
@ -55,15 +51,12 @@ func (s *UDPTun) ListenAndServe() {
return
}
logf("WriteTo")
n, err = rc.WriteTo(buf[:n], wt)
if err != nil {
logf("proxy-udptun rc.Write error: %v", err)
return
}
logf("ReadFrom")
rcBuf := make([]byte, udpBufSize)
rc.SetReadDeadline(time.Now().Add(time.Minute))
@ -74,9 +67,6 @@ func (s *UDPTun) ListenAndServe() {
}
rc.Close()
// logf("rc resp: \n%s", hex.Dump(buf[:n]))
logf("c.WriteTo")
c.WriteTo(rcBuf[:n], clientAddr)
logf("proxy-udptun %s <-> %s", clientAddr, s.raddr)
}()