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

socks5 udp init

pull/44/head
rui.zheng 11 years ago
parent
d7dfb3edaa
commit
7919b469cf
3 changed files with 135 additions and 52 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. 9
      main.go
  2. 165
      socks.go
  3. 13
      version.go

9
main.go
View File

@ -3,6 +3,7 @@ package main
import (
"flag"
"fmt"
"github.com/golang/glog"
"sync"
)
@ -15,6 +16,10 @@ const (
LDEBUG
)
const (
Version = "2.0"
)
var (
listenAddr, forwardAddr strSlice
pv bool // print version
@ -24,7 +29,7 @@ var (
)
func init() {
flag.Var(&listenAddr, "L", "listen address")
flag.Var(&listenAddr, "L", "listen address, can listen on multiple ports")
flag.Var(&forwardAddr, "F", "forward address, can make a forward chain")
flag.BoolVar(&pv, "V", false, "print version")
flag.Parse()
@ -38,7 +43,7 @@ func main() {
return
}
if pv {
printVersion()
fmt.Println("gost", Version)
return
}

165
socks.go
View File

@ -5,6 +5,8 @@ import (
"errors"
"github.com/ginuerzh/gosocks5"
"github.com/golang/glog"
"io"
"io/ioutil"
"net"
"strconv"
)
@ -218,12 +220,18 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
Transport(conn, tconn)
case gosocks5.CmdBind:
if glog.V(LINFO) {
glog.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)
}
uconn, err := net.ListenUDP("udp", nil)
if err != nil {
if glog.V(LWARNING) {
@ -246,7 +254,7 @@ 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:", addr)
glog.Infoln("socks5 udp listen:", addr)
}
rep := gosocks5.NewReply(gosocks5.Succeeded, addr)
if err := rep.Write(conn); err != nil {
@ -259,10 +267,66 @@ func handleSocks5Request(req *gosocks5.Request, conn net.Conn) {
glog.Infoln(rep)
}
}
srvTunnelUDP(conn, uconn)
}
}
func serveUDP(conn *net.UDPConn) {
if len(forwardArgs) > 0 {
fconn, _, err = forwardChain(forwardArgs...)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 udp forward:", err)
}
if fconn != nil {
fconn.Close()
}
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 transportUDP() {
}
func serveBind(conn net.Conn) error {
l, err := net.ListenTCP("tcp", nil)
if err != nil {
@ -339,15 +403,15 @@ func serveBind(conn net.Conn) error {
}
func forwardBind(req *gosocks5.Request, conn net.Conn) error {
fc, _, err := forwardChain(forwardArgs...)
fconn, _, err := forwardChain(forwardArgs...)
if err != nil {
if fc != nil {
fc.Close()
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:", err)
glog.Warningln("socks5 bind forward:", err)
}
} else {
if glog.V(LDEBUG) {
@ -356,11 +420,11 @@ func forwardBind(req *gosocks5.Request, conn net.Conn) error {
}
return err
}
defer fc.Close()
defer fconn.Close()
if err := req.Write(fc); err != nil {
if err := req.Write(fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
glog.Warningln("socks5 bind forward:", err)
}
gosocks5.NewReply(gosocks5.Failure, nil).Write(conn)
return err
@ -370,64 +434,91 @@ func forwardBind(req *gosocks5.Request, conn net.Conn) error {
}
// first reply
if err := peekBindReply(conn, fc); err != nil {
if err := peekReply(conn, fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
return err
}
// second reply
if err := peekBindReply(conn, fc); err != nil {
if err := peekReply(conn, fconn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind forward:", err)
}
return err
}
return Transport(conn, fc)
return Transport(conn, fconn)
}
func peekBindReply(conn, fc net.Conn) error {
rep, err := gosocks5.ReadReply(fc)
func peekReply(dst io.Writer, src io.Reader) error {
rep, err := gosocks5.ReadReply(src)
if err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
glog.Warningln(err)
}
rep = gosocks5.NewReply(gosocks5.Failure, nil)
}
if err := rep.Write(conn); err != nil {
if glog.V(LWARNING) {
glog.Warningln("socks5 bind:", err)
}
if err := rep.Write(dst); err != nil {
return err
}
if glog.V(LDEBUG) {
glog.Infoln(rep)
}
if rep.Rep != gosocks5.Succeeded {
return errors.New("Bind failure")
return errors.New("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 bind:", err)
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
}
} else {
if glog.V(LDEBUG) {
glog.Infoln(rep)
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
}
}
return err
}
defer fc.Close()
}()
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)

13
version.go
View File

@ -1,13 +0,0 @@
package main
import (
"fmt"
)
const (
Version = "2.0"
)
func printVersion() {
fmt.Println("gost", Version)
}
Write Preview
Loading…
Cancel
Save