Style: code style

listener/auth/auth.go

@@ -0,0 +1,17 @@
+package auth
+
+import (
+	"github.com/Dreamacro/clash/component/auth"
+)
+
+var (
+	authenticator auth.Authenticator
+)
+
+func Authenticator() auth.Authenticator {
+	return authenticator
+}
+
+func SetAuthenticator(au auth.Authenticator) {
+	authenticator = au
+}

listener/http/server.go

@@ -0,0 +1,111 @@
+package http
+
+import (
+	"bufio"
+	"encoding/base64"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	"github.com/Dreamacro/clash/common/cache"
+	"github.com/Dreamacro/clash/component/auth"
+	C "github.com/Dreamacro/clash/constant"
+	authStore "github.com/Dreamacro/clash/listener/auth"
+	"github.com/Dreamacro/clash/log"
+)
+
+type Listener struct {
+	net.Listener
+	address string
+	closed  bool
+	cache   *cache.Cache
+}
+
+func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+	hl := &Listener{l, addr, false, cache.New(30 * time.Second)}
+	go func() {
+		for {
+			c, err := hl.Accept()
+			if err != nil {
+				if hl.closed {
+					break
+				}
+				continue
+			}
+			go HandleConn(c, in, hl.cache)
+		}
+	}()
+
+	return hl, nil
+}
+
+func (l *Listener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *Listener) Address() string {
+	return l.address
+}
+
+func canActivate(loginStr string, authenticator auth.Authenticator, cache *cache.Cache) (ret bool) {
+	if result := cache.Get(loginStr); result != nil {
+		ret = result.(bool)
+		return
+	}
+	loginData, err := base64.StdEncoding.DecodeString(loginStr)
+	login := strings.Split(string(loginData), ":")
+	ret = err == nil && len(login) == 2 && authenticator.Verify(login[0], login[1])
+
+	cache.Put(loginStr, ret, time.Minute)
+	return
+}
+
+func HandleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
+	br := bufio.NewReader(conn)
+
+keepAlive:
+	request, err := http.ReadRequest(br)
+	if err != nil || request.URL.Host == "" {
+		conn.Close()
+		return
+	}
+
+	keepAlive := strings.TrimSpace(strings.ToLower(request.Header.Get("Proxy-Connection"))) == "keep-alive"
+	authenticator := authStore.Authenticator()
+	if authenticator != nil {
+		if authStrings := strings.Split(request.Header.Get("Proxy-Authorization"), " "); len(authStrings) != 2 {
+			conn.Write([]byte("HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic\r\n\r\n"))
+			if keepAlive {
+				goto keepAlive
+			}
+			return
+		} else if !canActivate(authStrings[1], authenticator, cache) {
+			conn.Write([]byte("HTTP/1.1 403 Forbidden\r\n\r\n"))
+			log.Infoln("Auth failed from %s", conn.RemoteAddr().String())
+			if keepAlive {
+				goto keepAlive
+			}
+			conn.Close()
+			return
+		}
+	}
+
+	if request.Method == http.MethodConnect {
+		_, err := conn.Write([]byte("HTTP/1.1 200 Connection established\r\n\r\n"))
+		if err != nil {
+			conn.Close()
+			return
+		}
+		in <- inbound.NewHTTPS(request, conn)
+		return
+	}
+
+	in <- inbound.NewHTTP(request, conn)
+}

listener/listener.go

@@ -0,0 +1,332 @@
+package proxy
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"sync"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/listener/http"
+	"github.com/Dreamacro/clash/listener/mixed"
+	"github.com/Dreamacro/clash/listener/redir"
+	"github.com/Dreamacro/clash/listener/socks"
+	"github.com/Dreamacro/clash/listener/tproxy"
+	"github.com/Dreamacro/clash/log"
+)
+
+var (
+	allowLan    = false
+	bindAddress = "*"
+
+	socksListener     *socks.Listener
+	socksUDPListener  *socks.UDPListener
+	httpListener      *http.Listener
+	redirListener     *redir.Listener
+	redirUDPListener  *tproxy.UDPListener
+	tproxyListener    *tproxy.Listener
+	tproxyUDPListener *tproxy.UDPListener
+	mixedListener     *mixed.Listener
+	mixedUDPLister    *socks.UDPListener
+
+	// lock for recreate function
+	socksMux  sync.Mutex
+	httpMux   sync.Mutex
+	redirMux  sync.Mutex
+	tproxyMux sync.Mutex
+	mixedMux  sync.Mutex
+)
+
+type Ports struct {
+	Port       int `json:"port"`
+	SocksPort  int `json:"socks-port"`
+	RedirPort  int `json:"redir-port"`
+	TProxyPort int `json:"tproxy-port"`
+	MixedPort  int `json:"mixed-port"`
+}
+
+func AllowLan() bool {
+	return allowLan
+}
+
+func BindAddress() string {
+	return bindAddress
+}
+
+func SetAllowLan(al bool) {
+	allowLan = al
+}
+
+func SetBindAddress(host string) {
+	bindAddress = host
+}
+
+func ReCreateHTTP(port int, tcpIn chan<- C.ConnContext) error {
+	httpMux.Lock()
+	defer httpMux.Unlock()
+
+	addr := genAddr(bindAddress, port, allowLan)
+
+	if httpListener != nil {
+		if httpListener.Address() == addr {
+			return nil
+		}
+		httpListener.Close()
+		httpListener = nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	httpListener, err = http.New(addr, tcpIn)
+	if err != nil {
+		return err
+	}
+
+	log.Infoln("HTTP proxy listening at: %s", httpListener.Address())
+	return nil
+}
+
+func ReCreateSocks(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) error {
+	socksMux.Lock()
+	defer socksMux.Unlock()
+
+	addr := genAddr(bindAddress, port, allowLan)
+
+	shouldTCPIgnore := false
+	shouldUDPIgnore := false
+
+	if socksListener != nil {
+		if socksListener.Address() != addr {
+			socksListener.Close()
+			socksListener = nil
+		} else {
+			shouldTCPIgnore = true
+		}
+	}
+
+	if socksUDPListener != nil {
+		if socksUDPListener.Address() != addr {
+			socksUDPListener.Close()
+			socksUDPListener = nil
+		} else {
+			shouldUDPIgnore = true
+		}
+	}
+
+	if shouldTCPIgnore && shouldUDPIgnore {
+		return nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	tcpListener, err := socks.New(addr, tcpIn)
+	if err != nil {
+		return err
+	}
+
+	udpListener, err := socks.NewUDP(addr, udpIn)
+	if err != nil {
+		tcpListener.Close()
+		return err
+	}
+
+	socksListener = tcpListener
+	socksUDPListener = udpListener
+
+	log.Infoln("SOCKS5 proxy listening at: %s", socksListener.Address())
+	return nil
+}
+
+func ReCreateRedir(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) error {
+	redirMux.Lock()
+	defer redirMux.Unlock()
+
+	addr := genAddr(bindAddress, port, allowLan)
+
+	if redirListener != nil {
+		if redirListener.Address() == addr {
+			return nil
+		}
+		redirListener.Close()
+		redirListener = nil
+	}
+
+	if redirUDPListener != nil {
+		if redirUDPListener.Address() == addr {
+			return nil
+		}
+		redirUDPListener.Close()
+		redirUDPListener = nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	redirListener, err = redir.New(addr, tcpIn)
+	if err != nil {
+		return err
+	}
+
+	redirUDPListener, err = tproxy.NewUDP(addr, udpIn)
+	if err != nil {
+		log.Warnln("Failed to start Redir UDP Listener: %s", err)
+	}
+
+	log.Infoln("Redirect proxy listening at: %s", redirListener.Address())
+	return nil
+}
+
+func ReCreateTProxy(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) error {
+	tproxyMux.Lock()
+	defer tproxyMux.Unlock()
+
+	addr := genAddr(bindAddress, port, allowLan)
+
+	if tproxyListener != nil {
+		if tproxyListener.Address() == addr {
+			return nil
+		}
+		tproxyListener.Close()
+		tproxyListener = nil
+	}
+
+	if tproxyUDPListener != nil {
+		if tproxyUDPListener.Address() == addr {
+			return nil
+		}
+		tproxyUDPListener.Close()
+		tproxyUDPListener = nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	tproxyListener, err = tproxy.New(addr, tcpIn)
+	if err != nil {
+		return err
+	}
+
+	tproxyUDPListener, err = tproxy.NewUDP(addr, udpIn)
+	if err != nil {
+		log.Warnln("Failed to start TProxy UDP Listener: %s", err)
+	}
+
+	log.Infoln("TProxy server listening at: %s", tproxyListener.Address())
+	return nil
+}
+
+func ReCreateMixed(port int, tcpIn chan<- C.ConnContext, udpIn chan<- *inbound.PacketAdapter) error {
+	mixedMux.Lock()
+	defer mixedMux.Unlock()
+
+	addr := genAddr(bindAddress, port, allowLan)
+
+	shouldTCPIgnore := false
+	shouldUDPIgnore := false
+
+	if mixedListener != nil {
+		if mixedListener.Address() != addr {
+			mixedListener.Close()
+			mixedListener = nil
+		} else {
+			shouldTCPIgnore = true
+		}
+	}
+	if mixedUDPLister != nil {
+		if mixedUDPLister.Address() != addr {
+			mixedUDPLister.Close()
+			mixedUDPLister = nil
+		} else {
+			shouldUDPIgnore = true
+		}
+	}
+
+	if shouldTCPIgnore && shouldUDPIgnore {
+		return nil
+	}
+
+	if portIsZero(addr) {
+		return nil
+	}
+
+	var err error
+	mixedListener, err = mixed.New(addr, tcpIn)
+	if err != nil {
+		return err
+	}
+
+	mixedUDPLister, err = socks.NewUDP(addr, udpIn)
+	if err != nil {
+		mixedListener.Close()
+		return err
+	}
+
+	log.Infoln("Mixed(http+socks5) proxy listening at: %s", mixedListener.Address())
+	return nil
+}
+
+// GetPorts return the ports of proxy servers
+func GetPorts() *Ports {
+	ports := &Ports{}
+
+	if httpListener != nil {
+		_, portStr, _ := net.SplitHostPort(httpListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.Port = port
+	}
+
+	if socksListener != nil {
+		_, portStr, _ := net.SplitHostPort(socksListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.SocksPort = port
+	}
+
+	if redirListener != nil {
+		_, portStr, _ := net.SplitHostPort(redirListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.RedirPort = port
+	}
+
+	if tproxyListener != nil {
+		_, portStr, _ := net.SplitHostPort(tproxyListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.TProxyPort = port
+	}
+
+	if mixedListener != nil {
+		_, portStr, _ := net.SplitHostPort(mixedListener.Address())
+		port, _ := strconv.Atoi(portStr)
+		ports.MixedPort = port
+	}
+
+	return ports
+}
+
+func portIsZero(addr string) bool {
+	_, port, err := net.SplitHostPort(addr)
+	if port == "0" || port == "" || err != nil {
+		return true
+	}
+	return false
+}
+
+func genAddr(host string, port int, allowLan bool) string {
+	if allowLan {
+		if host == "*" {
+			return fmt.Sprintf(":%d", port)
+		}
+		return fmt.Sprintf("%s:%d", host, port)
+	}
+
+	return fmt.Sprintf("127.0.0.1:%d", port)
+}

listener/mixed/conn.go

@@ -0,0 +1,41 @@
+package mixed
+
+import (
+	"bufio"
+	"net"
+)
+
+type BufferedConn struct {
+	r *bufio.Reader
+	net.Conn
+}
+
+func NewBufferedConn(c net.Conn) *BufferedConn {
+	return &BufferedConn{bufio.NewReader(c), c}
+}
+
+// Reader returns the internal bufio.Reader.
+func (c *BufferedConn) Reader() *bufio.Reader {
+	return c.r
+}
+
+// Peek returns the next n bytes without advancing the reader.
+func (c *BufferedConn) Peek(n int) ([]byte, error) {
+	return c.r.Peek(n)
+}
+
+func (c *BufferedConn) Read(p []byte) (int, error) {
+	return c.r.Read(p)
+}
+
+func (c *BufferedConn) ReadByte() (byte, error) {
+	return c.r.ReadByte()
+}
+
+func (c *BufferedConn) UnreadByte() error {
+	return c.r.UnreadByte()
+}
+
+func (c *BufferedConn) Buffered() int {
+	return c.r.Buffered()
+}

listener/mixed/mixed.go

@@ -0,0 +1,66 @@
+package mixed
+
+import (
+	"net"
+	"time"
+
+	"github.com/Dreamacro/clash/common/cache"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/listener/http"
+	"github.com/Dreamacro/clash/listener/socks"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type Listener struct {
+	net.Listener
+	address string
+	closed  bool
+	cache   *cache.Cache
+}
+
+func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	ml := &Listener{l, addr, false, cache.New(30 * time.Second)}
+	go func() {
+		for {
+			c, err := ml.Accept()
+			if err != nil {
+				if ml.closed {
+					break
+				}
+				continue
+			}
+			go handleConn(c, in, ml.cache)
+		}
+	}()
+
+	return ml, nil
+}
+
+func (l *Listener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *Listener) Address() string {
+	return l.address
+}
+
+func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.Cache) {
+	bufConn := NewBufferedConn(conn)
+	head, err := bufConn.Peek(1)
+	if err != nil {
+		return
+	}
+
+	if head[0] == socks5.Version {
+		socks.HandleSocks(bufConn, in)
+		return
+	}
+
+	http.HandleConn(bufConn, in, cache)
+}

listener/redir/tcp.go

@@ -0,0 +1,56 @@
+package redir
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Listener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+	rl := &Listener{l, addr, false}
+
+	go func() {
+		for {
+			c, err := l.Accept()
+			if err != nil {
+				if rl.closed {
+					break
+				}
+				continue
+			}
+			go handleRedir(c, in)
+		}
+	}()
+
+	return rl, nil
+}
+
+func (l *Listener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *Listener) Address() string {
+	return l.address
+}
+
+func handleRedir(conn net.Conn, in chan<- C.ConnContext) {
+	target, err := parserPacket(conn)
+	if err != nil {
+		conn.Close()
+		return
+	}
+	conn.(*net.TCPConn).SetKeepAlive(true)
+	in <- inbound.NewSocket(target, conn, C.REDIR)
+}

listener/redir/tcp_darwin.go

@@ -0,0 +1,58 @@
+package redir
+
+import (
+	"net"
+	"syscall"
+	"unsafe"
+
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+func parserPacket(c net.Conn) (socks5.Addr, error) {
+	const (
+		PfInout     = 0
+		PfIn        = 1
+		PfOut       = 2
+		IOCOut      = 0x40000000
+		IOCIn       = 0x80000000
+		IOCInOut    = IOCIn | IOCOut
+		IOCPARMMask = 0x1FFF
+		LEN         = 4*16 + 4*4 + 4*1
+		// #define	_IOC(inout,group,num,len) (inout | ((len & IOCPARMMask) << 16) | ((group) << 8) | (num))
+		// #define	_IOWR(g,n,t)	_IOC(IOCInOut,	(g), (n), sizeof(t))
+		// #define DIOCNATLOOK		_IOWR('D', 23, struct pfioc_natlook)
+		DIOCNATLOOK = IOCInOut | ((LEN & IOCPARMMask) << 16) | ('D' << 8) | 23
+	)
+
+	fd, err := syscall.Open("/dev/pf", 0, syscall.O_RDONLY)
+	if err != nil {
+		return nil, err
+	}
+	defer syscall.Close(fd)
+
+	nl := struct { // struct pfioc_natlook
+		saddr, daddr, rsaddr, rdaddr       [16]byte
+		sxport, dxport, rsxport, rdxport   [4]byte
+		af, proto, protoVariant, direction uint8
+	}{
+		af:        syscall.AF_INET,
+		proto:     syscall.IPPROTO_TCP,
+		direction: PfOut,
+	}
+	saddr := c.RemoteAddr().(*net.TCPAddr)
+	daddr := c.LocalAddr().(*net.TCPAddr)
+	copy(nl.saddr[:], saddr.IP)
+	copy(nl.daddr[:], daddr.IP)
+	nl.sxport[0], nl.sxport[1] = byte(saddr.Port>>8), byte(saddr.Port)
+	nl.dxport[0], nl.dxport[1] = byte(daddr.Port>>8), byte(daddr.Port)
+
+	if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(fd), DIOCNATLOOK, uintptr(unsafe.Pointer(&nl))); errno != 0 {
+		return nil, errno
+	}
+
+	addr := make([]byte, 1+net.IPv4len+2)
+	addr[0] = socks5.AtypIPv4
+	copy(addr[1:1+net.IPv4len], nl.rdaddr[:4])
+	copy(addr[1+net.IPv4len:], nl.rdxport[:2])
+	return addr, nil
+}

listener/redir/tcp_freebsd.go

@@ -0,0 +1,52 @@
+package redir
+
+import (
+	"errors"
+	"net"
+	"syscall"
+	"unsafe"
+
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+const (
+	SO_ORIGINAL_DST      = 80 // from linux/include/uapi/linux/netfilter_ipv4.h
+	IP6T_SO_ORIGINAL_DST = 80 // from linux/include/uapi/linux/netfilter_ipv6/ip6_tables.h
+)
+
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
+	c, ok := conn.(*net.TCPConn)
+	if !ok {
+		return nil, errors.New("only work with TCP connection")
+	}
+
+	rc, err := c.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+
+	var addr socks5.Addr
+
+	rc.Control(func(fd uintptr) {
+		addr, err = getorigdst(fd)
+	})
+
+	return addr, err
+}
+
+// Call getorigdst() from linux/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+func getorigdst(fd uintptr) (socks5.Addr, error) {
+	raw := syscall.RawSockaddrInet4{}
+	siz := unsafe.Sizeof(raw)
+	_, _, err := syscall.Syscall6(syscall.SYS_GETSOCKOPT, fd, syscall.IPPROTO_IP, SO_ORIGINAL_DST, uintptr(unsafe.Pointer(&raw)), uintptr(unsafe.Pointer(&siz)), 0)
+	if err != 0 {
+		return nil, err
+	}
+
+	addr := make([]byte, 1+net.IPv4len+2)
+	addr[0] = socks5.AtypIPv4
+	copy(addr[1:1+net.IPv4len], raw.Addr[:])
+	port := (*[2]byte)(unsafe.Pointer(&raw.Port)) // big-endian
+	addr[1+net.IPv4len], addr[1+net.IPv4len+1] = port[0], port[1]
+	return addr, nil
+}

listener/redir/tcp_linux.go

@@ -0,0 +1,51 @@
+package redir
+
+import (
+	"errors"
+	"net"
+	"syscall"
+	"unsafe"
+
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+const (
+	SO_ORIGINAL_DST      = 80 // from linux/include/uapi/linux/netfilter_ipv4.h
+	IP6T_SO_ORIGINAL_DST = 80 // from linux/include/uapi/linux/netfilter_ipv6/ip6_tables.h
+)
+
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
+	c, ok := conn.(*net.TCPConn)
+	if !ok {
+		return nil, errors.New("only work with TCP connection")
+	}
+
+	rc, err := c.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+
+	var addr socks5.Addr
+
+	rc.Control(func(fd uintptr) {
+		addr, err = getorigdst(fd)
+	})
+
+	return addr, err
+}
+
+// Call getorigdst() from linux/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
+func getorigdst(fd uintptr) (socks5.Addr, error) {
+	raw := syscall.RawSockaddrInet4{}
+	siz := unsafe.Sizeof(raw)
+	if err := socketcall(GETSOCKOPT, fd, syscall.IPPROTO_IP, SO_ORIGINAL_DST, uintptr(unsafe.Pointer(&raw)), uintptr(unsafe.Pointer(&siz)), 0); err != nil {
+		return nil, err
+	}
+
+	addr := make([]byte, 1+net.IPv4len+2)
+	addr[0] = socks5.AtypIPv4
+	copy(addr[1:1+net.IPv4len], raw.Addr[:])
+	port := (*[2]byte)(unsafe.Pointer(&raw.Port)) // big-endian
+	addr[1+net.IPv4len], addr[1+net.IPv4len+1] = port[0], port[1]
+	return addr, nil
+}

listener/redir/tcp_linux_386.go

@@ -0,0 +1,17 @@
+package redir
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+const GETSOCKOPT = 15 // https://golang.org/src/syscall/syscall_linux_386.go#L183
+
+func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) error {
+	var a [6]uintptr
+	a[0], a[1], a[2], a[3], a[4], a[5] = a0, a1, a2, a3, a4, a5
+	if _, _, errno := syscall.Syscall6(syscall.SYS_SOCKETCALL, call, uintptr(unsafe.Pointer(&a)), 0, 0, 0, 0); errno != 0 {
+		return errno
+	}
+	return nil
+}

listener/redir/tcp_linux_other.go

@@ -0,0 +1,14 @@
+// +build linux,!386
+
+package redir
+
+import "syscall"
+
+const GETSOCKOPT = syscall.SYS_GETSOCKOPT
+
+func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) error {
+	if _, _, errno := syscall.Syscall6(call, a0, a1, a2, a3, a4, a5); errno != 0 {
+		return errno
+	}
+	return nil
+}

listener/redir/tcp_other.go

@@ -0,0 +1,14 @@
+// +build !darwin,!linux,!freebsd
+
+package redir
+
+import (
+	"errors"
+	"net"
+
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
+	return nil, errors.New("system not support yet")
+}

listener/socks/tcp.go

@@ -0,0 +1,67 @@
+package socks
+
+import (
+	"io"
+	"io/ioutil"
+	"net"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	C "github.com/Dreamacro/clash/constant"
+	authStore "github.com/Dreamacro/clash/listener/auth"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type Listener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	sl := &Listener{l, addr, false}
+	go func() {
+		for {
+			c, err := l.Accept()
+			if err != nil {
+				if sl.closed {
+					break
+				}
+				continue
+			}
+			go HandleSocks(c, in)
+		}
+	}()
+
+	return sl, nil
+}
+
+func (l *Listener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *Listener) Address() string {
+	return l.address
+}
+
+func HandleSocks(conn net.Conn, in chan<- C.ConnContext) {
+	target, command, err := socks5.ServerHandshake(conn, authStore.Authenticator())
+	if err != nil {
+		conn.Close()
+		return
+	}
+	if c, ok := conn.(*net.TCPConn); ok {
+		c.SetKeepAlive(true)
+	}
+	if command == socks5.CmdUDPAssociate {
+		defer conn.Close()
+		io.Copy(ioutil.Discard, conn)
+		return
+	}
+	in <- inbound.NewSocket(target, conn, C.SOCKS)
+}

listener/socks/udp.go

@@ -0,0 +1,75 @@
+package socks
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	"github.com/Dreamacro/clash/common/pool"
+	"github.com/Dreamacro/clash/common/sockopt"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/log"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type UDPListener struct {
+	net.PacketConn
+	address string
+	closed  bool
+}
+
+func NewUDP(addr string, in chan<- *inbound.PacketAdapter) (*UDPListener, error) {
+	l, err := net.ListenPacket("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := sockopt.UDPReuseaddr(l.(*net.UDPConn)); err != nil {
+		log.Warnln("Failed to Reuse UDP Address: %s", err)
+	}
+
+	sl := &UDPListener{l, addr, false}
+	go func() {
+		for {
+			buf := pool.Get(pool.RelayBufferSize)
+			n, remoteAddr, err := l.ReadFrom(buf)
+			if err != nil {
+				pool.Put(buf)
+				if sl.closed {
+					break
+				}
+				continue
+			}
+			handleSocksUDP(l, in, buf[:n], remoteAddr)
+		}
+	}()
+
+	return sl, nil
+}
+
+func (l *UDPListener) Close() error {
+	l.closed = true
+	return l.PacketConn.Close()
+}
+
+func (l *UDPListener) Address() string {
+	return l.address
+}
+
+func handleSocksUDP(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, addr net.Addr) {
+	target, payload, err := socks5.DecodeUDPPacket(buf)
+	if err != nil {
+		// Unresolved UDP packet, return buffer to the pool
+		pool.Put(buf)
+		return
+	}
+	packet := &packet{
+		pc:      pc,
+		rAddr:   addr,
+		payload: payload,
+		bufRef:  buf,
+	}
+	select {
+	case in <- inbound.NewPacket(target, packet, C.TPROXY):
+	default:
+	}
+}

listener/socks/utils.go

@@ -0,0 +1,37 @@
+package socks
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/common/pool"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type packet struct {
+	pc      net.PacketConn
+	rAddr   net.Addr
+	payload []byte
+	bufRef  []byte
+}
+
+func (c *packet) Data() []byte {
+	return c.payload
+}
+
+// WriteBack write UDP packet with source(ip, port) = `addr`
+func (c *packet) WriteBack(b []byte, addr net.Addr) (n int, err error) {
+	packet, err := socks5.EncodeUDPPacket(socks5.ParseAddrToSocksAddr(addr), b)
+	if err != nil {
+		return
+	}
+	return c.pc.WriteTo(packet, c.rAddr)
+}
+
+// LocalAddr returns the source IP/Port of UDP Packet
+func (c *packet) LocalAddr() net.Addr {
+	return c.rAddr
+}
+
+func (c *packet) Drop() {
+	pool.Put(c.bufRef)
+}

listener/tproxy/packet.go

@@ -0,0 +1,37 @@
+package tproxy
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/common/pool"
+)
+
+type packet struct {
+	lAddr *net.UDPAddr
+	buf   []byte
+}
+
+func (c *packet) Data() []byte {
+	return c.buf
+}
+
+// WriteBack opens a new socket binding `addr` to write UDP packet back
+func (c *packet) WriteBack(b []byte, addr net.Addr) (n int, err error) {
+	tc, err := dialUDP("udp", addr.(*net.UDPAddr), c.lAddr)
+	if err != nil {
+		n = 0
+		return
+	}
+	n, err = tc.Write(b)
+	tc.Close()
+	return
+}
+
+// LocalAddr returns the source IP/Port of UDP Packet
+func (c *packet) LocalAddr() net.Addr {
+	return c.lAddr
+}
+
+func (c *packet) Drop() {
+	pool.Put(c.buf)
+}

listener/tproxy/setsockopt_linux.go

@@ -0,0 +1,40 @@
+// +build linux
+
+package tproxy
+
+import (
+	"net"
+	"syscall"
+)
+
+func setsockopt(rc syscall.RawConn, addr string) error {
+	isIPv6 := true
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return err
+	}
+	ip := net.ParseIP(host)
+	if ip != nil && ip.To4() != nil {
+		isIPv6 = false
+	}
+
+	rc.Control(func(fd uintptr) {
+		err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
+
+		if err == nil {
+			err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_TRANSPARENT, 1)
+		}
+		if err == nil && isIPv6 {
+			err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_TRANSPARENT, 1)
+		}
+
+		if err == nil {
+			err = syscall.SetsockoptInt(int(fd), syscall.SOL_IP, syscall.IP_RECVORIGDSTADDR, 1)
+		}
+		if err == nil && isIPv6 {
+			err = syscall.SetsockoptInt(int(fd), syscall.SOL_IPV6, IPV6_RECVORIGDSTADDR, 1)
+		}
+	})
+
+	return err
+}

listener/tproxy/setsockopt_other.go

@@ -0,0 +1,12 @@
+// +build !linux
+
+package tproxy
+
+import (
+	"errors"
+	"syscall"
+)
+
+func setsockopt(rc syscall.RawConn, addr string) error {
+	return errors.New("not supported on current platform")
+}

listener/tproxy/tproxy.go

@@ -0,0 +1,68 @@
+package tproxy
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type Listener struct {
+	net.Listener
+	address string
+	closed  bool
+}
+
+func New(addr string, in chan<- C.ConnContext) (*Listener, error) {
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	tl := l.(*net.TCPListener)
+	rc, err := tl.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+
+	err = setsockopt(rc, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	rl := &Listener{
+		Listener: l,
+		address:  addr,
+	}
+
+	go func() {
+		for {
+			c, err := l.Accept()
+			if err != nil {
+				if rl.closed {
+					break
+				}
+				continue
+			}
+			go rl.handleTProxy(c, in)
+		}
+	}()
+
+	return rl, nil
+}
+
+func (l *Listener) Close() {
+	l.closed = true
+	l.Listener.Close()
+}
+
+func (l *Listener) Address() string {
+	return l.address
+}
+
+func (l *Listener) handleTProxy(conn net.Conn, in chan<- C.ConnContext) {
+	target := socks5.ParseAddrToSocksAddr(conn.LocalAddr())
+	conn.(*net.TCPConn).SetKeepAlive(true)
+	in <- inbound.NewSocket(target, conn, C.TPROXY)
+}

listener/tproxy/udp.go

@@ -0,0 +1,81 @@
+package tproxy
+
+import (
+	"net"
+
+	"github.com/Dreamacro/clash/adapter/inbound"
+	"github.com/Dreamacro/clash/common/pool"
+	C "github.com/Dreamacro/clash/constant"
+	"github.com/Dreamacro/clash/transport/socks5"
+)
+
+type UDPListener struct {
+	net.PacketConn
+	address string
+	closed  bool
+}
+
+func NewUDP(addr string, in chan<- *inbound.PacketAdapter) (*UDPListener, error) {
+	l, err := net.ListenPacket("udp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	rl := &UDPListener{l, addr, false}
+
+	c := l.(*net.UDPConn)
+
+	rc, err := c.SyscallConn()
+	if err != nil {
+		return nil, err
+	}
+
+	err = setsockopt(rc, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	go func() {
+		oob := make([]byte, 1024)
+		for {
+			buf := pool.Get(pool.RelayBufferSize)
+			n, oobn, _, lAddr, err := c.ReadMsgUDP(buf, oob)
+			if err != nil {
+				pool.Put(buf)
+				if rl.closed {
+					break
+				}
+				continue
+			}
+
+			rAddr, err := getOrigDst(oob, oobn)
+			if err != nil {
+				continue
+			}
+			handlePacketConn(l, in, buf[:n], lAddr, rAddr)
+		}
+	}()
+
+	return rl, nil
+}
+
+func (l *UDPListener) Close() error {
+	l.closed = true
+	return l.PacketConn.Close()
+}
+
+func (l *UDPListener) Address() string {
+	return l.address
+}
+
+func handlePacketConn(pc net.PacketConn, in chan<- *inbound.PacketAdapter, buf []byte, lAddr *net.UDPAddr, rAddr *net.UDPAddr) {
+	target := socks5.ParseAddrToSocksAddr(rAddr)
+	pkt := &packet{
+		lAddr: lAddr,
+		buf:   buf,
+	}
+	select {
+	case in <- inbound.NewPacket(target, pkt, C.TPROXY):
+	default:
+	}
+}

listener/tproxy/udp_linux.go

@@ -0,0 +1,124 @@
+// +build linux
+
+package tproxy
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"strconv"
+	"syscall"
+)
+
+const (
+	IPV6_TRANSPARENT     = 0x4b
+	IPV6_RECVORIGDSTADDR = 0x4a
+)
+
+// dialUDP acts like net.DialUDP for transparent proxy.
+// It binds to a non-local address(`lAddr`).
+func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
+	rSockAddr, err := udpAddrToSockAddr(rAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	lSockAddr, err := udpAddrToSockAddr(lAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	fd, err := syscall.Socket(udpAddrFamily(network, lAddr, rAddr), syscall.SOCK_DGRAM, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	if err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+
+	if err = syscall.SetsockoptInt(fd, syscall.SOL_IP, syscall.IP_TRANSPARENT, 1); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+
+	if err = syscall.Bind(fd, lSockAddr); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+
+	if err = syscall.Connect(fd, rSockAddr); err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+
+	fdFile := os.NewFile(uintptr(fd), fmt.Sprintf("net-udp-dial-%s", rAddr.String()))
+	defer fdFile.Close()
+
+	c, err := net.FileConn(fdFile)
+	if err != nil {
+		syscall.Close(fd)
+		return nil, err
+	}
+
+	return c.(*net.UDPConn), nil
+}
+
+func udpAddrToSockAddr(addr *net.UDPAddr) (syscall.Sockaddr, error) {
+	switch {
+	case addr.IP.To4() != nil:
+		ip := [4]byte{}
+		copy(ip[:], addr.IP.To4())
+
+		return &syscall.SockaddrInet4{Addr: ip, Port: addr.Port}, nil
+
+	default:
+		ip := [16]byte{}
+		copy(ip[:], addr.IP.To16())
+
+		zoneID, err := strconv.ParseUint(addr.Zone, 10, 32)
+		if err != nil {
+			zoneID = 0
+		}
+
+		return &syscall.SockaddrInet6{Addr: ip, Port: addr.Port, ZoneId: uint32(zoneID)}, nil
+	}
+}
+
+func udpAddrFamily(net string, lAddr, rAddr *net.UDPAddr) int {
+	switch net[len(net)-1] {
+	case '4':
+		return syscall.AF_INET
+	case '6':
+		return syscall.AF_INET6
+	}
+
+	if (lAddr == nil || lAddr.IP.To4() != nil) && (rAddr == nil || lAddr.IP.To4() != nil) {
+		return syscall.AF_INET
+	}
+	return syscall.AF_INET6
+}
+
+func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
+	msgs, err := syscall.ParseSocketControlMessage(oob[:oobn])
+	if err != nil {
+		return nil, err
+	}
+
+	for _, msg := range msgs {
+		if msg.Header.Level == syscall.SOL_IP && msg.Header.Type == syscall.IP_RECVORIGDSTADDR {
+			ip := net.IP(msg.Data[4:8])
+			port := binary.BigEndian.Uint16(msg.Data[2:4])
+			return &net.UDPAddr{IP: ip, Port: int(port)}, nil
+		} else if msg.Header.Level == syscall.SOL_IPV6 && msg.Header.Type == IPV6_RECVORIGDSTADDR {
+			ip := net.IP(msg.Data[8:24])
+			port := binary.BigEndian.Uint16(msg.Data[2:4])
+			return &net.UDPAddr{IP: ip, Port: int(port)}, nil
+		}
+	}
+
+	return nil, errors.New("cannot find origDst")
+}

listener/tproxy/udp_other.go

@@ -0,0 +1,16 @@
+// +build !linux
+
+package tproxy
+
+import (
+	"errors"
+	"net"
+)
+
+func getOrigDst(oob []byte, oobn int) (*net.UDPAddr, error) {
+	return nil, errors.New("UDP redir not supported on current platform")
+}
+
+func dialUDP(network string, lAddr *net.UDPAddr, rAddr *net.UDPAddr) (*net.UDPConn, error) {
+	return nil, errors.New("UDP redir not supported on current platform")
+}