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

socks udp tunnel

Browse Source
This commit is contained in:
rui.zheng 2015-10-27 15:28:50 +08:00
parent 467ea676d3
commit c4a1b96ba2
7 changed files with 384 additions and 452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
README.md
View File

@ -67,7 +67,7 @@ gost -L=admin:123456@localhost:8080
* 多端口监听
```bash
gost -L=http://localhost:8080 -L=socks://localhost:8081 -L=ss://aes-256-cfb:123456@:8082
gost -L=:8080 -L=ss://aes-256-cfb:123456@:8081
```
##### 设置转发代理
@ -88,28 +88,29 @@ gost -L=:8080 -F=http://admin:123456@192.168.1.1:8081
```bash
gost -L=:8080 -F=http://192.168.1.1:8081 -F=socks://192.168.1.2:8082 -F=a.b.c.d:NNNN
```
gost按照-F设置顺序通过转发链将请求最终转发给a.b.c.d:NNNN处理，每一个转发代理可以是任意一种类型的代理(http/socks5)。
gost按照-F设置顺序通过转发链将请求最终转发给a.b.c.d:NNNN处理，每一个转发代理可以是任意http/socks5类型代理。
#### SOCKS5 UDP数据处理
##### 不设置转发代理
<img src="https://ginuerzh.github.io/images/udp01.png" height=110 />
<img src="https://ginuerzh.github.io/images/udp01.png" height=100 />
gost作为标准socks5代理处理UDP数据
##### 设置转发代理
<img src="https://ginuerzh.github.io/images/udp02.png" height=110 />
<img src="https://ginuerzh.github.io/images/udp02.png" height=100 />
##### 设置多个转发代理(转发链)
<img src="https://ginuerzh.github.io/images/udp03.png" height=200 />
当设置转发代理时，gost会使用UDP over TCP方式转发UDP数据。
当设置转发代理时，gost会使用UDP-Over-TCP方式转发UDP数据。proxy1 - proxyN可以为任意http/socks5类型代理。
##### 限制条件
如果要转发socks5的BIND和UDP请求，转发链的末端(最后一个-F参数)必须是gost socks5类型代理，且转发链中的http代理必须支持CONNECT方法。

35
http.go
View File

@ -34,29 +34,21 @@ func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
"Proxy-Agent: gost/" + Version + "\r\n\r\n"
if _, err := conn.Write([]byte(resp)); err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
}
if glog.V(LDEBUG) {
glog.Infoln(resp)
}
if glog.V(LWARNING) {
glog.Warningln("http: proxy authentication required")
glog.V(LWARNING).Infoln(err)
}
glog.V(LDEBUG).Infoln(resp)
glog.V(LWARNING).Infoln("http: proxy authentication required")
return
}
c, err := Connect(req.Host)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
glog.V(LWARNING).Infoln(err)
b := []byte("HTTP/1.1 503 Service unavailable\r\n" +
"Proxy-Agent: gost/" + Version + "\r\n\r\n")
if glog.V(LDEBUG) {
glog.Infoln(string(b))
}
glog.V(LDEBUG).Infoln(string(b))
conn.Write(b)
return
}
@ -65,13 +57,10 @@ func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
if req.Method == "CONNECT" {
b := []byte("HTTP/1.1 200 Connection established\r\n" +
"Proxy-Agent: gost/" + Version + "\r\n\r\n")
if glog.V(LDEBUG) {
glog.Infoln(string(b))
}
glog.V(LDEBUG).Infoln(string(b))
if _, err := conn.Write(b); err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
glog.V(LWARNING).Infoln(err)
return
}
} else {
@ -81,9 +70,7 @@ func handleHttpRequest(req *http.Request, conn net.Conn, arg Args) {
err = req.Write(c)
}
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
glog.V(LWARNING).Infoln(err)
return
}
}

613
socks.go
View File

@ -47,27 +47,19 @@ func (selector *clientSelector) OnSelected(method uint8, conn net.Conn) (net.Con
req := gosocks5.NewUserPassRequest(gosocks5.UserPassVer, username, password)
if err := req.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 auth:", err)
}
glog.V(LWARNING).Infoln("socks5 auth:", err)
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(req)
}
glog.V(LDEBUG).Infoln(req)
res, err := gosocks5.ReadUserPassResponse(conn)
resp, err := gosocks5.ReadUserPassResponse(conn)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 auth:", err)
}
glog.V(LWARNING).Infoln("socks5 auth:", err)
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(res)
}
glog.V(LDEBUG).Infoln(resp)
if res.Status != gosocks5.Succeeded {
if resp.Status != gosocks5.Succeeded {
return nil, gosocks5.ErrAuthFailure
}
case gosocks5.MethodNoAcceptable:
@ -87,9 +79,7 @@ func (selector *serverSelector) Methods() []uint8 {
}
func (selector *serverSelector) Select(methods ...uint8) (method uint8) {
if glog.V(LDEBUG) {
glog.Infof("%d %d % d", gosocks5.Ver5, len(methods), methods)
}
glog.V(LDEBUG).Infof("%d %d % d", gosocks5.Ver5, len(methods), methods)
method = gosocks5.MethodNoAuth
for _, m := range methods {
@ -113,9 +103,7 @@ func (selector *serverSelector) Select(methods ...uint8) (method uint8) {
}
func (selector *serverSelector) OnSelected(method uint8, conn net.Conn) (net.Conn, error) {
if glog.V(LDEBUG) {
glog.Infof("%d %d", gosocks5.Ver5, method)
}
glog.V(LDEBUG).Infof("%d %d", gosocks5.Ver5, method)
switch method {
case MethodTLS:
@ -128,14 +116,10 @@ func (selector *serverSelector) OnSelected(method uint8, conn net.Conn) (net.Con
req, err := gosocks5.ReadUserPassRequest(conn)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 auth:", err)
}
glog.V(LWARNING).Infoln("socks5 auth:", err)
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(req.String())
}
glog.V(LDEBUG).Infoln(req.String())
var username, password string
if selector.arg.User != nil {
@ -146,30 +130,21 @@ func (selector *serverSelector) OnSelected(method uint8, conn net.Conn) (net.Con
if (username != "" && req.Username != username) || (password != "" && req.Password != password) {
resp := gosocks5.NewUserPassResponse(gosocks5.UserPassVer, gosocks5.Failure)
if err := resp.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 auth:", err)
}
glog.V(LWARNING).Infoln("socks5 auth:", err)
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(resp)
}
if glog.V(LWARNING) {
glog.Warningln("socks5: proxy authentication required")
}
glog.V(LDEBUG).Infoln(resp)
glog.V(LWARNING).Infoln("socks5: proxy authentication required")
return nil, gosocks5.ErrAuthFailure
}
resp := gosocks5.NewUserPassResponse(gosocks5.UserPassVer, gosocks5.Succeeded)
if err := resp.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 auth:", err)
}
glog.V(LWARNING).Infoln("socks5 auth:", err)
return nil, err
}
if glog.V(LDEBUG) {
glog.Infoln(resp)
}
glog.V(LDEBUG).Infoln(resp)
case gosocks5.MethodNoAcceptable:
return nil, gosocks5.ErrBadMethod
@ -179,29 +154,20 @@ func (selector *serverSelector) OnSelected(method uint8, conn net.Conn) (net.Con
}
func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
if glog.V(LDEBUG) {
glog.Infoln(req)
}
glog.V(LDEBUG).Infoln(req)
switch req.Cmd {
case gosocks5.CmdConnect:
if glog.V(LINFO) {
glog.Infoln("socks5 connect:", req.Addr.String())
}
glog.V(LINFO).Infoln(">>> socks5 connect:", req.Addr.String())
tconn, err := Connect(req.Addr.String())
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 connect:", err)
}
glog.V(LWARNING).Infoln("socks5 connect:", err)
rep := gosocks5.NewReply(gosocks5.HostUnreachable, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 connect:", err)
}
glog.V(LWARNING).Infoln("socks5 connect:", err)
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
glog.V(LDEBUG).Infoln(rep)
}
return
}
@ -209,43 +175,31 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
rep := gosocks5.NewReply(gosocks5.Succeeded, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 connect:", err)
}
glog.V(LWARNING).Infoln("socks5 connect:", err)
return
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
glog.V(LDEBUG).Infoln(rep)
Transport(conn, tconn)
case gosocks5.CmdBind:
if glog.V(LINFO) {
glog.Infoln("socks5 bind:", req.Addr)
}
glog.V(LINFO).Infoln(">>> socks5 bind:", req.Addr)
if len(forwardArgs) > 0 {
forwardBind(req, conn)
} else {
serveBind(conn)
}
case gosocks5.CmdUdp:
if glog.V(LINFO) {
glog.Infoln("socks5 udp associate:", req.Addr)
}
glog.V(LINFO).Infoln(">>> socks5 udp associate:", req.Addr)
uconn, err := net.ListenUDP("udp", nil)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp listen:", err)
}
glog.V(LWARNING).Infoln("socks5 udp listen:", err)
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp listen:", err)
}
glog.V(LWARNING).Infoln("socks5 udp listen:", err)
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
glog.V(LDEBUG).Infoln(rep)
}
return
}
@ -253,47 +207,166 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
addr := ToSocksAddr(uconn.LocalAddr())
addr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String())
if glog.V(LINFO) {
glog.Infoln("socks5 udp listen:", addr)
}
glog.V(LINFO).Infoln("socks5 udp listen:", addr)
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp:", err)
}
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
glog.V(LDEBUG).Infoln(rep)
}
//clientConn, dgram, err := createClientConn(conn, uconn)
_, dgram, err := createClientConn(conn, uconn)
cc, dgram, err := createClientConn(conn, uconn)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp:", err)
}
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
if glog.V(LDEBUG) {
glog.Infof("[udp] length %d, to %s", len(dgram.Data), dgram.Header.Addr)
glog.V(LDEBUG).Infof("[udp] to %s, length %d", dgram.Header.Addr, len(dgram.Data))
raddr, err := net.ResolveUDPAddr("udp", dgram.Header.Addr.String())
if err != nil {
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
sc, err := createServerConn(uconn, raddr)
if err != nil {
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
//serverConn, err := createServerConn(uconn)
_, err = createServerConn(uconn)
if err = sc.WriteUDP(dgram); err != nil {
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
dgram, err = sc.ReadUDP()
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp forward:", err)
}
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
glog.V(LDEBUG).Infof("[udp] from %s, length %d", dgram.Header.Addr, len(dgram.Data))
if err = cc.WriteUDP(dgram); err != nil {
glog.V(LWARNING).Infoln("socks5 udp:", err)
return
}
TransportUDP(cc, sc)
default:
if glog.V(LWARNING) {
glog.Warningln("Unrecognized request: ", req)
}
glog.V(LWARNING).Infoln("Unrecognized request: ", req)
}
}
func serveBind(conn net.Conn) error {
l, err := net.ListenTCP("tcp", nil)
if err != nil {
glog.V(LWARNING).Infoln("socks5 bind listen:", err)
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind listen:", err)
} else {
glog.V(LDEBUG).Infoln(rep)
}
return err
}
addr := ToSocksAddr(l.Addr())
// Issue: may not reachable when host has two interfaces
addr.Host, _, _ = net.SplitHostPort(conn.LocalAddr().String())
glog.V(LINFO).Infoln("socks5 bind:", addr)
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind:", err)
l.Close()
return err
}
glog.V(LDEBUG).Infoln(rep)
tconn, err := l.AcceptTCP()
l.Close() // only accept one peer
if err != nil {
glog.V(LWARNING).Infoln("socks5 bind accept:", err)
rep = gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind accept:", err)
} else {
glog.V(LDEBUG).Infoln(rep)
}
return err
}
defer tconn.Close()
addr = ToSocksAddr(tconn.RemoteAddr())
glog.V(LINFO).Infoln("socks5 bind accept:", addr.String())
rep = gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind accept:", err)
return err
}
glog.V(LDEBUG).Infoln(rep)
return Transport(conn, tconn)
}
func forwardBind(req *gosocks5.Request, conn net.Conn) error {
fconn, _, err := forwardChain(forwardArgs...)
if err != nil {
if fconn != nil {
fconn.Close()
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind forward:", err)
} else {
glog.V(LDEBUG).Infoln(rep)
}
return err
}
defer fconn.Close()
if err := req.Write(fconn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind forward:", err)
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
glog.V(LDEBUG).Infoln(req)
// first reply
if err := peekReply(conn, fconn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind forward:", err)
return err
}
// second reply
if err := peekReply(conn, fconn); err != nil {
glog.V(LWARNING).Infoln("socks5 bind forward:", err)
return err
}
return Transport(conn, fconn)
}
func peekReply(dst io.Writer, src io.Reader) error {
rep, err := gosocks5.ReadReply(src)
if err != nil {
glog.V(LWARNING).Infoln(err)
rep = gosocks5.NewReply(gosocks5.Failure, nil)
}
if err := rep.Write(dst); err != nil {
return err
}
glog.V(LDEBUG).Infoln(rep)
if rep.Rep != gosocks5.Succeeded {
return errors.New("Failure")
}
return nil
}
func createClientConn(conn net.Conn, uconn *net.UDPConn) (c *UDPConn, dgram *gosocks5.UDPDatagram, err error) {
var raddr *net.UDPAddr
dgramChan := make(chan *gosocks5.UDPDatagram, 1)
@ -338,7 +411,7 @@ func createClientConn(conn net.Conn, uconn *net.UDPConn) (c *UDPConn, dgram *gos
return
}
func createServerConn(uconn *net.UDPConn) (c *UDPConn, err error) {
func createServerConn(uconn *net.UDPConn, addr net.Addr) (c *UDPConn, err error) {
if len(forwardArgs) == 0 {
c = Server(uconn)
return
@ -351,291 +424,30 @@ func createServerConn(uconn *net.UDPConn) (c *UDPConn, err error) {
}
return
}
glog.V(LINFO).Infoln("forward udp associate")
req := gosocks5.NewRequest(gosocks5.CmdUdp, nil)
if err = req.Write(fconn); err != nil {
fconn.Close()
return
}
glog.V(LDEBUG).Infoln(req)
rep, err := gosocks5.ReadReply(fconn)
if err != nil {
fconn.Close()
return
}
glog.V(LDEBUG).Infoln(rep)
if rep.Rep != gosocks5.Succeeded {
fconn.Close()
return nil, errors.New("Failure")
}
c = Server(fconn)
return
}
/*
func forwardUDP(req *gosocks5.Request) (conn net.Conn, err error) {
if err != nil {
if conn != nil {
conn.Close()
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp forward:", err)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
return
}
if err = req.Write(fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp forward:", err)
}
return
}
if err = peekReply(conn, fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp forward:", err)
}
return
}
}
*/
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 listen:", err)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
return err
}
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.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)
}
}
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)
}
func forwardBind(req *gosocks5.Request, conn net.Conn) error {
fconn, _, err := forwardChain(forwardArgs...)
if err != nil {
if fconn != nil {
fconn.Close()
}
rep := gosocks5.NewReply(gosocks5.Failure, nil)
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
}
return err
}
defer fconn.Close()
if err := req.Write(fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
}
if glog.V(LDEBUG) {
glog.Infoln(req)
}
// first reply
if err := peekReply(conn, fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
return err
}
// second reply
if err := peekReply(conn, fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
return err
}
return Transport(conn, fconn)
}
func peekReply(dst io.Writer, src io.Reader) error {
rep, err := gosocks5.ReadReply(src)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
rep = gosocks5.NewReply(gosocks5.Failure, nil)
}
if err := rep.Write(dst); err != nil {
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
if rep.Rep != gosocks5.Succeeded {
return errors.New("Failure")
}
return nil
}
/*
func cliTunnelUDP(uconn *net.UDPConn, sconn net.Conn) {
var raddr *net.UDPAddr
go func() {
b := make([]byte, 16*1024)
for {
n, addr, err := uconn.ReadFromUDP(b)
if err != nil {
log.Println(err)
return
}
raddr = addr
r := bytes.NewBuffer(b[:n])
udp, err := gosocks5.ReadUDPDatagram(r)
if err != nil {
return
}
udp.Header.Rsv = uint16(len(udp.Data))
//log.Println("r", raddr.String(), udp.Header)
if err := udp.Write(sconn); err != nil {
log.Println(err)
return
}
}
}()
for {
b := lpool.Take()
defer lpool.put(b)
udp, err := gosocks5.ReadUDPDatagram(sconn)
if err != nil {
log.Println(err)
return
}
//log.Println("w", udp.Header)
udp.Header.Rsv = 0
buf := bytes.NewBuffer(b[0:0])
udp.Write(buf)
if _, err := uconn.WriteTo(buf.Bytes(), raddr); err != nil {
log.Println(err)
return
}
}
}
func srvTunnelUDP(conn net.Conn, uconn *net.UDPConn) {
go func() {
b := make([]byte, 16*1024)
for {
n, addr, err := uconn.ReadFromUDP(b)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
return
}
udp := gosocks5.NewUDPDatagram(
gosocks5.NewUDPHeader(uint16(n), 0, ToSocksAddr(addr)), b[:n])
//log.Println("r", udp.Header)
if err := udp.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
return
}
}
}()
for {
udp, err := gosocks5.ReadUDPDatagram(conn)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
return
}
//log.Println("w", udp.Header)
addr, err := net.ResolveUDPAddr("udp", udp.Header.Addr.String())
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
continue // drop silently
}
if _, err := uconn.WriteToUDP(udp.Data, addr); err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
return
}
}
}
*/
func ToSocksAddr(addr net.Addr) *gosocks5.Addr {
host, port, _ := net.SplitHostPort(addr.String())
p, _ := strconv.Atoi(port)
@ -646,3 +458,40 @@ func ToSocksAddr(addr net.Addr) *gosocks5.Addr {
Port: uint16(p),
}
}
func PipeUDP(src, dst *UDPConn, ch chan<- error) {
var err error
for {
var dgram *gosocks5.UDPDatagram
dgram, err = src.ReadUDP()
if err != nil {
break
}
glog.V(LDEBUG).Infof("[udp] addr %s, length %d", dgram.Header.Addr, len(dgram.Data))
if err = dst.WriteUDP(dgram); err != nil {
break
}
}
ch <- err
close(ch)
}
func TransportUDP(cc, sc *UDPConn) (err error) {
rChan := make(chan error, 1)
wChan := make(chan error, 1)
go PipeUDP(cc, sc, wChan)
go PipeUDP(sc, cc, rChan)
select {
case err = <-wChan:
//log.Println("w exit", err)
case err = <-rChan:
//log.Println("r exit", err)
}
return
}

21
ss.go
View File

@ -16,9 +16,7 @@ func handleShadow(conn net.Conn, arg Args) {
password, _ := arg.User.Password()
cipher, err := shadowsocks.NewCipher(method, password)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("shadowsocks:", err)
}
glog.V(LWARNING).Infoln("shadowsocks:", err)
return
}
conn = shadowsocks.NewConn(conn, cipher)
@ -26,28 +24,21 @@ func handleShadow(conn net.Conn, arg Args) {
addr, extra, err := getShadowRequest(conn)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("shadowsocks:", err)
}
glog.V(LWARNING).Infoln("shadowsocks:", err)
return
}
if glog.V(LINFO) {
glog.Infoln("shadowsocks connect:", addr.String())
}
glog.V(LINFO).Infoln("shadowsocks connect:", addr.String())
sconn, err := Connect(addr.String())
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("shadowsocks:", err)
}
glog.V(LWARNING).Infoln("shadowsocks:", err)
return
}
defer sconn.Close()
if extra != nil {
if _, err := sconn.Write(extra); err != nil {
if glog.V(LWARNING) {
glog.Warningln("shadowsocks:", err)
}
glog.V(LWARNING).Infoln("shadowsocks:", err)
return
}
}

135
udp.go
View File

@ -1,39 +1,148 @@
package main
import (
//"github.com/ginuerzh/gosocks5"
//"github.com/golang/glog"
"bytes"
"github.com/ginuerzh/gosocks5"
"github.com/golang/glog"
"net"
"time"
)
type UDPConn struct {
isClient bool
udpConn *net.UDPConn
udp *net.UDPConn
addr net.Addr
tcpConn net.Conn
tcp net.Conn
}
func Client(conn net.Conn, addr net.Addr) *UDPConn {
client := &UDPConn{isClient: true}
c := &UDPConn{isClient: true}
switch conn := conn.(type) {
case *net.UDPConn:
client.udpConn = conn
client.addr = addr
c.udp = conn
c.addr = addr
default:
client.tcpConn = conn
c.tcp = conn
}
return client
return c
}
func Server(conn net.Conn) *UDPConn {
server := &UDPConn{}
c := &UDPConn{}
switch conn := conn.(type) {
case *net.UDPConn:
server.udpConn = conn
c.udp = conn
default:
server.tcpConn = conn
c.tcp = conn
}
return server
return c
}
func (c *UDPConn) ReadUDP() (*gosocks5.UDPDatagram, error) {
if c.isClient {
return c.readUDPClient()
}
return c.readUDPServer()
}
func (c *UDPConn) readUDPClient() (*gosocks5.UDPDatagram, error) {
if c.udp != nil {
return gosocks5.ReadUDPDatagram(c.udp)
}
return gosocks5.ReadUDPDatagram(c.tcp)
}
func (c *UDPConn) readUDPServer() (*gosocks5.UDPDatagram, error) {
if c.udp != nil {
b := make([]byte, 65535)
n, addr, err := c.udp.ReadFromUDP(b)
if err != nil {
return nil, err
}
dgram := gosocks5.NewUDPDatagram(
gosocks5.NewUDPHeader(0, 0, ToSocksAddr(addr)), b[:n])
return dgram, nil
}
return gosocks5.ReadUDPDatagram(c.tcp)
}
func (c *UDPConn) WriteUDP(dgram *gosocks5.UDPDatagram) error {
if c.isClient {
return c.writeUDPClient(dgram)
}
return c.writeUDPServer(dgram)
}
func (c *UDPConn) writeUDPClient(dgram *gosocks5.UDPDatagram) error {
if c.udp != nil {
dgram.Header.Rsv = 0
buffer := bytes.Buffer{}
dgram.Write(&buffer)
_, err := c.udp.WriteTo(buffer.Bytes(), c.addr)
return err
}
dgram.Header.Rsv = uint16(len(dgram.Data))
return dgram.Write(c.tcp)
}
func (c *UDPConn) writeUDPServer(dgram *gosocks5.UDPDatagram) error {
if c.udp != nil {
addr, err := net.ResolveUDPAddr("udp", dgram.Header.Addr.String())
if err != nil {
glog.V(LWARNING).Infoln(err)
return nil // drop silently
}
_, err = c.udp.WriteTo(dgram.Data, addr)
return err
}
dgram.Header.Rsv = uint16(len(dgram.Data))
return dgram.Write(c.tcp)
}
func (c *UDPConn) Close() error {
if c.udp != nil {
return c.udp.Close()
}
return c.tcp.Close()
}
func (c *UDPConn) LocalAddr() net.Addr {
if c.udp != nil {
return c.udp.LocalAddr()
}
return c.tcp.LocalAddr()
}
func (c *UDPConn) RemoteAddr() net.Addr {
if c.udp != nil {
return c.udp.RemoteAddr()
}
return c.tcp.RemoteAddr()
}
func (c *UDPConn) SetDeadline(t time.Time) error {
if c.udp != nil {
return c.udp.SetDeadline(t)
}
return c.tcp.SetDeadline(t)
}
func (c *UDPConn) SetReadDeadline(t time.Time) error {
if c.udp != nil {
return c.udp.SetReadDeadline(t)
}
return c.tcp.SetReadDeadline(t)
}
func (c *UDPConn) SetWriteDeadline(t time.Time) error {
if c.udp != nil {
return c.udp.SetWriteDeadline(t)
}
return c.tcp.SetWriteDeadline(t)
}

17
util.go
View File

@ -62,12 +62,11 @@ nh/BAoGBAMY5z2f1pmMhrvtPDSlEVjgjELbaInxFaxPLR4Pdyzn83gtIIU14+R8X
func init() {
var err error
if cert, err = tls.LoadX509KeyPair("cert.pem", "key.pem"); err != nil {
if glog.V(LFATAL) {
glog.Warningln(err)
}
glog.V(LWARNING).Infoln(err)
cert, err = tls.X509KeyPair([]byte(rawCert), []byte(rawKey))
if err != nil && glog.V(LFATAL) {
glog.Warningln(err)
if err != nil {
glog.V(LFATAL).Infoln(err)
}
}
}
@ -112,9 +111,7 @@ func parseArgs(ss []string) (args []Args) {
}
u, err := url.Parse(s)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln(err)
}
glog.V(LWARNING).Infoln(err)
continue
}
@ -186,9 +183,9 @@ func Copy(dst io.Writer, src io.Reader) (written int64, err error) {
return
}
func Pipe(src io.Reader, dst io.Writer, c chan<- error) {
func Pipe(src io.Reader, dst io.Writer, ch chan<- error) {
_, err := Copy(dst, src)
c <- err
ch <- err
}
func Transport(conn, conn2 net.Conn) (err error) {

4
ws.go
View File

@ -105,9 +105,7 @@ func (s *ws) handle(w http.ResponseWriter, r *http.Request) {
}
conn, err := s.upgrader.Upgrade(w, r, nil)
if err != nil {
if glog.V(LERROR) {
glog.Errorln(err)
}
glog.V(LERROR).Infoln(err)
return
}
handleConn(wsServer(conn), s.arg)