Chore: update README.md

Makefile

@@ -1,6 +1,6 @@
 NAME=clash
 BINDIR=bin
-VERSION=$(shell git describe --tags --long --dirty || echo "unkown version")
+VERSION=$(shell git describe --tags || echo "unkown version")
 BUILDTIME=$(shell date -u)
 GOBUILD=CGO_ENABLED=0 go build -ldflags '-X "github.com/Dreamacro/clash/constant.Version=$(VERSION)" \
 		-X "github.com/Dreamacro/clash/constant.BuildTime=$(BUILDTIME)" \
@@ -81,7 +81,7 @@ zip_releases=$(addsuffix .zip, $(WINDOWS_ARCH_LIST))
 
 $(gz_releases): %.gz : %
 	chmod +x $(BINDIR)/$(NAME)-$(basename $@)
-	tar -czf $(BINDIR)/$(NAME)-$(basename $@)-$(VERSION).tar.gz -C $(BINDIR) $(NAME)-$(basename $@)
+	gzip -f -S -$(VERSION).gz $(BINDIR)/$(NAME)-$(basename $@)
 
 $(zip_releases): %.zip : %
 	zip -m -j $(BINDIR)/$(NAME)-$(basename $@)-$(VERSION).zip $(BINDIR)/$(NAME)-$(basename $@).exe

README.md

@@ -105,11 +105,16 @@ external-controller: 127.0.0.1:9090
 # Secret for RESTful API (Optional)
 # secret: ""
 
+# experimental feature
+experimental:
+  ignore-resolve-fail: true # ignore dns reslove fail, default value is true
+
 # dns:
   # enable: true # set true to enable dns (default is false)
   # ipv6: false # default is false
   # listen: 0.0.0.0:53
-  # enhanced-mode: redir-host
+  # enhanced-mode: redir-host # or fake-ip
+  # # fake-ip-range: 198.18.0.1/16 # if you don't know what it is, don't change it
   # nameserver:
   #   - 114.114.114.114
   #   - tls://dns.rubyfish.cn:853 # dns over tls
@@ -122,7 +127,7 @@ Proxy:
 # The types of cipher are consistent with go-shadowsocks2
 # support AEAD_AES_128_GCM AEAD_AES_192_GCM AEAD_AES_256_GCM AEAD_CHACHA20_POLY1305 AES-128-CTR AES-192-CTR AES-256-CTR AES-128-CFB AES-192-CFB AES-256-CFB CHACHA20-IETF XCHACHA20
 # In addition to what go-shadowsocks2 supports, it also supports chacha20 rc4-md5 xchacha20-ietf-poly1305
-- { name: "ss1", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password" }
+- { name: "ss1", type: ss, server: server, port: 443, cipher: AEAD_CHACHA20_POLY1305, password: "password", udp: true }
 
 # old obfs configuration remove after prerelease
 - name: "ss2"
@@ -202,13 +207,19 @@ Rule:
 - DOMAIN,google.com,auto
 - DOMAIN-SUFFIX,ad.com,REJECT
 - IP-CIDR,127.0.0.0/8,DIRECT
-- SOURCE-IP-CIDR,192.168.1.201/32,DIRECT
+# rename SOURCE-IP-CIDR and would remove after prerelease
+- SRC-IP-CIDR,192.168.1.201/32,DIRECT
 - GEOIP,CN,DIRECT
+- DST-PORT,80,DIRECT
+- SRC-PORT,7777,DIRECT
 # FINAL would remove after prerelease
 # you also can use `FINAL,Proxy` or `FINAL,,Proxy` now
 - MATCH,auto
 ```
 
+## Documentations
+https://clash.gitbook.io/
+
 ## Thanks
 
 [riobard/go-shadowsocks2](https://github.com/riobard/go-shadowsocks2)
@@ -223,5 +234,5 @@ Rule:
 
 - [x] Complementing the necessary rule operators
 - [x] Redir proxy
-- [ ] UDP support
+- [x] UDP support
 - [ ] Connection manager

adapters/inbound/http.go

@@ -10,34 +10,27 @@ import (
 
 // HTTPAdapter is a adapter for HTTP connection
 type HTTPAdapter struct {
+	net.Conn
 	metadata *C.Metadata
-	conn     net.Conn
 	R        *http.Request
 }
 
-// Close HTTP connection
-func (h *HTTPAdapter) Close() {
-	h.conn.Close()
-}
-
 // Metadata return destination metadata
 func (h *HTTPAdapter) Metadata() *C.Metadata {
 	return h.metadata
 }
 
-// Conn return raw net.Conn of HTTP
-func (h *HTTPAdapter) Conn() net.Conn {
-	return h.conn
-}
-
 // NewHTTP is HTTPAdapter generator
 func NewHTTP(request *http.Request, conn net.Conn) *HTTPAdapter {
 	metadata := parseHTTPAddr(request)
-	metadata.SourceIP = parseSourceIP(conn)
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
 	return &HTTPAdapter{
 		metadata: metadata,
 		R:        request,
-		conn:     conn,
+		Conn:     conn,
 	}
 }
 

adapters/inbound/https.go

@@ -8,9 +8,12 @@ import (
 // NewHTTPS is HTTPAdapter generator
 func NewHTTPS(request *http.Request, conn net.Conn) *SocketAdapter {
 	metadata := parseHTTPAddr(request)
-	metadata.SourceIP = parseSourceIP(conn)
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
 	return &SocketAdapter{
 		metadata: metadata,
-		conn:     conn,
+		Conn:     conn,
 	}
 }

adapters/inbound/socket.go

@@ -3,39 +3,33 @@ package adapters
 import (
 	"net"
 
+	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 // SocketAdapter is a adapter for socks and redir connection
 type SocketAdapter struct {
-	conn     net.Conn
+	net.Conn
 	metadata *C.Metadata
 }
 
-// Close socks and redir connection
-func (s *SocketAdapter) Close() {
-	s.conn.Close()
-}
-
 // Metadata return destination metadata
 func (s *SocketAdapter) Metadata() *C.Metadata {
 	return s.metadata
 }
 
-// Conn return raw net.Conn
-func (s *SocketAdapter) Conn() net.Conn {
-	return s.conn
-}
-
 // NewSocket is SocketAdapter generator
-func NewSocket(target socks.Addr, conn net.Conn, source C.SourceType) *SocketAdapter {
+func NewSocket(target socks5.Addr, conn net.Conn, source C.Type, netType C.NetWork) *SocketAdapter {
 	metadata := parseSocksAddr(target)
-	metadata.Source = source
+	metadata.NetWork = netType
-	metadata.SourceIP = parseSourceIP(conn)
+	metadata.Type = source
+	if ip, port, err := parseAddr(conn.RemoteAddr().String()); err == nil {
+		metadata.SrcIP = ip
+		metadata.SrcPort = port
+	}
 
 	return &SocketAdapter{
-		conn:     conn,
+		Conn:     conn,
 		metadata: metadata,
 	}
 }

adapters/inbound/util.go

@@ -5,28 +5,27 @@ import (
 	"net/http"
 	"strconv"
 
+	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
-func parseSocksAddr(target socks.Addr) *C.Metadata {
+func parseSocksAddr(target socks5.Addr) *C.Metadata {
 	metadata := &C.Metadata{
-		NetWork:  C.TCP,
 		AddrType: int(target[0]),
 	}
 
 	switch target[0] {
-	case socks.AtypDomainName:
+	case socks5.AtypDomainName:
 		metadata.Host = string(target[2 : 2+target[1]])
-		metadata.Port = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
+		metadata.DstPort = strconv.Itoa((int(target[2+target[1]]) << 8) | int(target[2+target[1]+1]))
-	case socks.AtypIPv4:
+	case socks5.AtypIPv4:
 		ip := net.IP(target[1 : 1+net.IPv4len])
-		metadata.IP = &ip
+		metadata.DstIP = &ip
-		metadata.Port = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
+		metadata.DstPort = strconv.Itoa((int(target[1+net.IPv4len]) << 8) | int(target[1+net.IPv4len+1]))
-	case socks.AtypIPv6:
+	case socks5.AtypIPv6:
 		ip := net.IP(target[1 : 1+net.IPv6len])
-		metadata.IP = &ip
+		metadata.DstIP = &ip
-		metadata.Port = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
+		metadata.DstPort = strconv.Itoa((int(target[1+net.IPv6len]) << 8) | int(target[1+net.IPv6len+1]))
 	}
 
 	return metadata
@@ -41,11 +40,11 @@ func parseHTTPAddr(request *http.Request) *C.Metadata {
 
 	metadata := &C.Metadata{
 		NetWork:  C.TCP,
-		Source:   C.HTTP,
+		Type:     C.HTTP,
 		AddrType: C.AtypDomainName,
 		Host:     host,
-		IP:       nil,
+		DstIP:    nil,
-		Port:     port,
+		DstPort:  port,
 	}
 
 	ip := net.ParseIP(host)
@@ -56,15 +55,18 @@ func parseHTTPAddr(request *http.Request) *C.Metadata {
 		default:
 			metadata.AddrType = C.AtypIPv4
 		}
-		metadata.IP = &ip
+		metadata.DstIP = &ip
 	}
 
 	return metadata
 }
 
-func parseSourceIP(conn net.Conn) *net.IP {
+func parseAddr(addr string) (*net.IP, string, error) {
-	if addr, ok := conn.RemoteAddr().(*net.TCPAddr); ok {
+	host, port, err := net.SplitHostPort(addr)
-		return &addr.IP
+	if err != nil {
+		return nil, "", err
 	}
-	return nil
+
+	ip := net.ParseIP(host)
+	return &ip, port, nil
 }

adapters/outbound/base.go

@@ -2,6 +2,7 @@ package adapters
 
 import (
 	"encoding/json"
+	"errors"
 	"net"
 	"net/http"
 	"time"
@@ -13,6 +14,7 @@ import (
 type Base struct {
 	name string
 	tp   C.AdapterType
+	udp  bool
 }
 
 func (b *Base) Name() string {
@@ -23,6 +25,14 @@ func (b *Base) Type() C.AdapterType {
 	return b.tp
 }
 
+func (b *Base) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	return nil, nil, errors.New("no support")
+}
+
+func (b *Base) SupportUDP() bool {
+	return b.udp
+}
+
 func (b *Base) Destroy() {}
 
 func (b *Base) MarshalJSON() ([]byte, error) {

adapters/outbound/direct.go

@@ -11,9 +11,9 @@ type Direct struct {
 }
 
 func (d *Direct) Dial(metadata *C.Metadata) (net.Conn, error) {
-	address := net.JoinHostPort(metadata.Host, metadata.Port)
+	address := net.JoinHostPort(metadata.Host, metadata.DstPort)
-	if metadata.IP != nil {
+	if metadata.DstIP != nil {
-		address = net.JoinHostPort(metadata.IP.String(), metadata.Port)
+		address = net.JoinHostPort(metadata.DstIP.String(), metadata.DstPort)
 	}
 
 	c, err := net.DialTimeout("tcp", address, tcpTimeout)
@@ -24,11 +24,25 @@ func (d *Direct) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return c, nil
 }
 
+func (d *Direct) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	pc, err := net.ListenPacket("udp", "")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	addr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
+	if err != nil {
+		return nil, nil, err
+	}
+	return pc, addr, nil
+}
+
 func NewDirect() *Direct {
 	return &Direct{
 		Base: &Base{
 			name: "DIRECT",
 			tp:   C.Direct,
+			udp:  true,
 		},
 	}
 }

adapters/outbound/fallback.go

@@ -35,6 +35,16 @@ func (f *Fallback) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return proxy.Dial(metadata)
 }
 
+func (f *Fallback) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	proxy := f.findAliveProxy()
+	return proxy.DialUDP(metadata)
+}
+
+func (f *Fallback) SupportUDP() bool {
+	proxy := f.findAliveProxy()
+	return proxy.SupportUDP()
+}
+
 func (f *Fallback) MarshalJSON() ([]byte, error) {
 	var all []string
 	for _, proxy := range f.proxies {

adapters/outbound/http.go

@@ -58,7 +58,7 @@ func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 	var buf bytes.Buffer
 	var err error
 
-	addr := net.JoinHostPort(metadata.String(), metadata.Port)
+	addr := net.JoinHostPort(metadata.String(), metadata.DstPort)
 	buf.WriteString("CONNECT " + addr + " HTTP/1.1\r\n")
 	buf.WriteString("Host: " + metadata.String() + "\r\n")
 	buf.WriteString("Proxy-Connection: Keep-Alive\r\n")

adapters/outbound/loadbalance.go

@@ -34,11 +34,11 @@ func getKey(metadata *C.Metadata) string {
 		}
 	}
 
-	if metadata.IP == nil {
+	if metadata.DstIP == nil {
 		return ""
 	}
 
-	return metadata.IP.String()
+	return metadata.DstIP.String()
 }
 
 func jumpHash(key uint64, buckets int32) int32 {
@@ -67,6 +67,24 @@ func (lb *LoadBalance) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return lb.proxies[0].Dial(metadata)
 }
 
+func (lb *LoadBalance) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	key := uint64(murmur3.Sum32([]byte(getKey(metadata))))
+	buckets := int32(len(lb.proxies))
+	for i := 0; i < lb.maxRetry; i, key = i+1, key+1 {
+		idx := jumpHash(key, buckets)
+		proxy := lb.proxies[idx]
+		if proxy.Alive() {
+			return proxy.DialUDP(metadata)
+		}
+	}
+
+	return lb.proxies[0].DialUDP(metadata)
+}
+
+func (lb *LoadBalance) SupportUDP() bool {
+	return true
+}
+
 func (lb *LoadBalance) Destroy() {
 	lb.done <- struct{}{}
 }

adapters/outbound/selector.go

@@ -24,6 +24,14 @@ func (s *Selector) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return s.selected.Dial(metadata)
 }
 
+func (s *Selector) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	return s.selected.DialUDP(metadata)
+}
+
+func (s *Selector) SupportUDP() bool {
+	return s.selected.SupportUDP()
+}
+
 func (s *Selector) MarshalJSON() ([]byte, error) {
 	var all []string
 	for k := range s.proxies {

adapters/outbound/shadowsocks.go

@@ -1,20 +1,20 @@
 package adapters
 
 import (
-	"bytes"
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
 	"net"
 	"strconv"
 
+	"github.com/Dreamacro/clash/common/pool"
 	"github.com/Dreamacro/clash/common/structure"
 	obfs "github.com/Dreamacro/clash/component/simple-obfs"
+	"github.com/Dreamacro/clash/component/socks5"
 	v2rayObfs "github.com/Dreamacro/clash/component/v2ray-plugin"
 	C "github.com/Dreamacro/clash/constant"
 
 	"github.com/Dreamacro/go-shadowsocks2/core"
-	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 type ShadowSocks struct {
@@ -34,6 +34,7 @@ type ShadowSocksOption struct {
 	Port       int                    `proxy:"port"`
 	Password   string                 `proxy:"password"`
 	Cipher     string                 `proxy:"cipher"`
+	UDP        bool                   `proxy:"udp,omitempty"`
 	Plugin     string                 `proxy:"plugin,omitempty"`
 	PluginOpts map[string]interface{} `proxy:"plugin-opts,omitempty"`
 
@@ -80,6 +81,26 @@ func (ss *ShadowSocks) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return c, err
 }
 
+func (ss *ShadowSocks) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	pc, err := net.ListenPacket("udp", "")
+	if err != nil {
+		return nil, nil, err
+	}
+
+	addr, err := net.ResolveUDPAddr("udp", ss.server)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	remoteAddr, err := net.ResolveUDPAddr("udp", net.JoinHostPort(metadata.String(), metadata.DstPort))
+	if err != nil {
+		return nil, nil, err
+	}
+
+	pc = ss.cipher.PacketConn(pc)
+	return &ssUDPConn{PacketConn: pc, rAddr: remoteAddr}, addr, nil
+}
+
 func (ss *ShadowSocks) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]string{
 		"type": ss.Type().String(),
@@ -144,6 +165,7 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 		Base: &Base{
 			name: option.Name,
 			tp:   C.Shadowsocks,
+			udp:  option.UDP,
 		},
 		server: server,
 		cipher: ciph,
@@ -154,22 +176,23 @@ func NewShadowSocks(option ShadowSocksOption) (*ShadowSocks, error) {
 	}, nil
 }
 
-func serializesSocksAddr(metadata *C.Metadata) []byte {
+type ssUDPConn struct {
-	var buf [][]byte
+	net.PacketConn
-	aType := uint8(metadata.AddrType)
+	rAddr net.Addr
-	p, _ := strconv.Atoi(metadata.Port)
+}
-	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
+
-	switch metadata.AddrType {
+func (uc *ssUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
-	case socks.AtypDomainName:
+	buf := pool.BufPool.Get().([]byte)
-		len := uint8(len(metadata.Host))
+	defer pool.BufPool.Put(buf[:cap(buf)])
-		host := []byte(metadata.Host)
+	rAddr := socks5.ParseAddr(uc.rAddr.String())
-		buf = [][]byte{{aType, len}, host, port}
+	copy(buf[len(rAddr):], b)
-	case socks.AtypIPv4:
+	copy(buf, rAddr)
-		host := metadata.IP.To4()
+	return uc.PacketConn.WriteTo(buf[:len(rAddr)+len(b)], addr)
-		buf = [][]byte{{aType}, host, port}
+}
-	case socks.AtypIPv6:
+
-		host := metadata.IP.To16()
+func (uc *ssUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
-		buf = [][]byte{{aType}, host, port}
+	n, a, e := uc.PacketConn.ReadFrom(b)
-	}
+	addr := socks5.SplitAddr(b[:n])
-	return bytes.Join(buf, nil)
+	copy(b, b[len(addr):])
+	return n - len(addr), a, e
 }

adapters/outbound/socks5.go

@@ -1,17 +1,13 @@
 package adapters
 
 import (
-	"bytes"
 	"crypto/tls"
-	"errors"
 	"fmt"
-	"io"
 	"net"
 	"strconv"
 
+	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 type Socks5 struct {
@@ -31,6 +27,7 @@ type Socks5Option struct {
 	UserName       string `proxy:"username,omitempty"`
 	Password       string `proxy:"password,omitempty"`
 	TLS            bool   `proxy:"tls,omitempty"`
+	UDP            bool   `proxy:"udp,omitempty"`
 	SkipCertVerify bool   `proxy:"skip-cert-verify,omitempty"`
 }
 
@@ -47,69 +44,44 @@ func (ss *Socks5) Dial(metadata *C.Metadata) (net.Conn, error) {
 		return nil, fmt.Errorf("%s connect error", ss.addr)
 	}
 	tcpKeepAlive(c)
-	if err := ss.shakeHand(metadata, c); err != nil {
+	var user *socks5.User
+	if ss.user != "" {
+		user = &socks5.User{
+			Username: ss.user,
+			Password: ss.pass,
+		}
+	}
+	if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdConnect, user); err != nil {
 		return nil, err
 	}
 	return c, nil
 }
 
-func (ss *Socks5) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
+func (ss *Socks5) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
-	buf := make([]byte, socks.MaxAddrLen)
+	c, err := net.DialTimeout("tcp", ss.addr, tcpTimeout)
-	var err error
 
-	// VER, NMETHODS, METHODS
+	if err == nil && ss.tls {
-	if len(ss.user) > 0 {
+		cc := tls.Client(c, ss.tlsConfig)
-		_, err = rw.Write([]byte{5, 1, 2})
+		err = cc.Handshake()
-	} else {
+		c = cc
-		_, err = rw.Write([]byte{5, 1, 0})
 	}
+
 	if err != nil {
-		return err
+		return nil, nil, fmt.Errorf("%s connect error", ss.addr)
 	}
-
+	tcpKeepAlive(c)
-	// VER, METHOD
+	var user *socks5.User
-	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
+	if ss.user != "" {
-		return err
+		user = &socks5.User{
-	}
+			Username: ss.user,
-
+			Password: ss.pass,
-	if buf[0] != 5 {
-		return errors.New("SOCKS version error")
-	}
-
-	if buf[1] == 2 {
-		// password protocol version
-		authMsg := &bytes.Buffer{}
-		authMsg.WriteByte(1)
-		authMsg.WriteByte(uint8(len(ss.user)))
-		authMsg.WriteString(ss.user)
-		authMsg.WriteByte(uint8(len(ss.pass)))
-		authMsg.WriteString(ss.pass)
-
-		if _, err := rw.Write(authMsg.Bytes()); err != nil {
-			return err
 		}
-
-		if _, err := io.ReadFull(rw, buf[:2]); err != nil {
-			return err
-		}
-
-		if buf[1] != 0 {
-			return errors.New("rejected username/password")
-		}
-	} else if buf[1] != 0 {
-		return errors.New("SOCKS need auth")
 	}
 
-	// VER, CMD, RSV, ADDR
+	if err := socks5.ClientHandshake(c, serializesSocksAddr(metadata), socks5.CmdUDPAssociate, user); err != nil {
-	if _, err := rw.Write(bytes.Join([][]byte{{5, 1, 0}, serializesSocksAddr(metadata)}, []byte(""))); err != nil {
+		return nil, nil, err
-		return err
 	}
-
+	return &fakeUDPConn{Conn: c}, c.LocalAddr(), nil
-	if _, err := io.ReadFull(rw, buf[:10]); err != nil {
-		return err
-	}
-
-	return nil
 }
 
 func NewSocks5(option Socks5Option) *Socks5 {
@@ -126,6 +98,7 @@ func NewSocks5(option Socks5Option) *Socks5 {
 		Base: &Base{
 			name: option.Name,
 			tp:   C.Socks5,
+			udp:  option.UDP,
 		},
 		addr:           net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		user:           option.UserName,

adapters/outbound/urltest.go

@@ -43,6 +43,14 @@ func (u *URLTest) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return a, err
 }
 
+func (u *URLTest) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	return u.fast.DialUDP(metadata)
+}
+
+func (u *URLTest) SupportUDP() bool {
+	return u.fast.SupportUDP()
+}
+
 func (u *URLTest) MarshalJSON() ([]byte, error) {
 	var all []string
 	for _, proxy := range u.proxies {

adapters/outbound/util.go

@@ -1,13 +1,16 @@
 package adapters
 
 import (
+	"bytes"
 	"crypto/tls"
 	"fmt"
 	"net"
 	"net/url"
+	"strconv"
 	"sync"
 	"time"
 
+	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
 )
 
@@ -41,8 +44,8 @@ func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
 	addr = C.Metadata{
 		AddrType: C.AtypDomainName,
 		Host:     u.Hostname(),
-		IP:       nil,
+		DstIP:    nil,
-		Port:     port,
+		DstPort:  port,
 	}
 	return
 }
@@ -60,3 +63,36 @@ func getClientSessionCache() tls.ClientSessionCache {
 	})
 	return globalClientSessionCache
 }
+
+func serializesSocksAddr(metadata *C.Metadata) []byte {
+	var buf [][]byte
+	aType := uint8(metadata.AddrType)
+	p, _ := strconv.Atoi(metadata.DstPort)
+	port := []byte{uint8(p >> 8), uint8(p & 0xff)}
+	switch metadata.AddrType {
+	case socks5.AtypDomainName:
+		len := uint8(len(metadata.Host))
+		host := []byte(metadata.Host)
+		buf = [][]byte{{aType, len}, host, port}
+	case socks5.AtypIPv4:
+		host := metadata.DstIP.To4()
+		buf = [][]byte{{aType}, host, port}
+	case socks5.AtypIPv6:
+		host := metadata.DstIP.To16()
+		buf = [][]byte{{aType}, host, port}
+	}
+	return bytes.Join(buf, nil)
+}
+
+type fakeUDPConn struct {
+	net.Conn
+}
+
+func (fuc *fakeUDPConn) WriteTo(b []byte, addr net.Addr) (int, error) {
+	return fuc.Conn.Write(b)
+}
+
+func (fuc *fakeUDPConn) ReadFrom(b []byte) (int, net.Addr, error) {
+	n, err := fuc.Conn.Read(b)
+	return n, fuc.RemoteAddr(), err
+}

adapters/outbound/vmess.go

@@ -24,6 +24,7 @@ type VmessOption struct {
 	AlterID        int               `proxy:"alterId"`
 	Cipher         string            `proxy:"cipher"`
 	TLS            bool              `proxy:"tls,omitempty"`
+	UDP            bool              `proxy:"udp,omitempty"`
 	Network        string            `proxy:"network,omitempty"`
 	WSPath         string            `proxy:"ws-path,omitempty"`
 	WSHeaders      map[string]string `proxy:"ws-headers,omitempty"`
@@ -40,6 +41,16 @@ func (v *Vmess) Dial(metadata *C.Metadata) (net.Conn, error) {
 	return c, err
 }
 
+func (v *Vmess) DialUDP(metadata *C.Metadata) (net.PacketConn, net.Addr, error) {
+	c, err := net.DialTimeout("tcp", v.server, tcpTimeout)
+	if err != nil {
+		return nil, nil, fmt.Errorf("%s connect error", v.server)
+	}
+	tcpKeepAlive(c)
+	c, err = v.client.New(c, parseVmessAddr(metadata))
+	return &fakeUDPConn{Conn: c}, c.LocalAddr(), err
+}
+
 func NewVmess(option VmessOption) (*Vmess, error) {
 	security := strings.ToLower(option.Cipher)
 	client, err := vmess.NewClient(vmess.Config{
@@ -63,6 +74,7 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 		Base: &Base{
 			name: option.Name,
 			tp:   C.Vmess,
+			udp:  option.UDP,
 		},
 		server: net.JoinHostPort(option.Server, strconv.Itoa(option.Port)),
 		client: client,
@@ -76,11 +88,11 @@ func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
 	case C.AtypIPv4:
 		addrType = byte(vmess.AtypIPv4)
 		addr = make([]byte, net.IPv4len)
-		copy(addr[:], metadata.IP.To4())
+		copy(addr[:], metadata.DstIP.To4())
 	case C.AtypIPv6:
 		addrType = byte(vmess.AtypIPv6)
 		addr = make([]byte, net.IPv6len)
-		copy(addr[:], metadata.IP.To16())
+		copy(addr[:], metadata.DstIP.To16())
 	case C.AtypDomainName:
 		addrType = byte(vmess.AtypDomainName)
 		addr = make([]byte, len(metadata.Host)+1)
@@ -88,8 +100,9 @@ func parseVmessAddr(metadata *C.Metadata) *vmess.DstAddr {
 		copy(addr[1:], []byte(metadata.Host))
 	}
 
-	port, _ := strconv.Atoi(metadata.Port)
+	port, _ := strconv.Atoi(metadata.DstPort)
 	return &vmess.DstAddr{
+		UDP:      metadata.NetWork == C.UDP,
 		AddrType: addrType,
 		Addr:     addr,
 		Port:     uint(port),

common/pool/pool.go

@@ -0,0 +1,15 @@
+package pool
+
+import (
+	"sync"
+)
+
+const (
+	// io.Copy default buffer size is 32 KiB
+	// but the maximum packet size of vmess/shadowsocks is about 16 KiB
+	// so define a buffer of 20 KiB to reduce the memory of each TCP relay
+	bufferSize = 20 * 1024
+)
+
+// BufPool provide buffer for relay
+var BufPool = sync.Pool{New: func() interface{} { return make([]byte, bufferSize) }}

component/fakeip/pool.go

@@ -0,0 +1,50 @@
+package fakeip
+
+import (
+	"errors"
+	"net"
+)
+
+// Pool is a implementation about fake ip generator without storage
+type Pool struct {
+	max    uint32
+	min    uint32
+	offset uint32
+}
+
+// Get return a new fake ip
+func (p *Pool) Get() net.IP {
+	ip := uintToIP(p.min + p.offset)
+	p.offset = (p.offset + 1) % (p.max - p.min)
+	return ip
+}
+
+func ipToUint(ip net.IP) uint32 {
+	v := uint32(ip[0]) << 24
+	v += uint32(ip[1]) << 16
+	v += uint32(ip[2]) << 8
+	v += uint32(ip[3])
+	return v
+}
+
+func uintToIP(v uint32) net.IP {
+	return net.IPv4(byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+}
+
+// New return Pool instance
+func New(ipnet *net.IPNet) (*Pool, error) {
+	min := ipToUint(ipnet.IP) + 1
+
+	ones, bits := ipnet.Mask.Size()
+	total := 1<<uint(bits-ones) - 2
+
+	if total <= 0 {
+		return nil, errors.New("ipnet don't have valid ip")
+	}
+
+	max := min + uint32(total)
+	return &Pool{
+		min: min,
+		max: max,
+	}, nil
+}

component/fakeip/pool_test.go

@@ -0,0 +1,44 @@
+package fakeip
+
+import (
+	"net"
+	"testing"
+)
+
+func TestPool_Basic(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
+	pool, _ := New(ipnet)
+
+	first := pool.Get()
+	last := pool.Get()
+
+	if !first.Equal(net.IP{192, 168, 0, 1}) {
+		t.Error("should get right first ip, instead of", first.String())
+	}
+
+	if !last.Equal(net.IP{192, 168, 0, 2}) {
+		t.Error("should get right last ip, instead of", first.String())
+	}
+}
+
+func TestPool_Cycle(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/30")
+	pool, _ := New(ipnet)
+
+	first := pool.Get()
+	pool.Get()
+	same := pool.Get()
+
+	if !first.Equal(same) {
+		t.Error("should return same ip", first.String())
+	}
+}
+
+func TestPool_Error(t *testing.T) {
+	_, ipnet, _ := net.ParseCIDR("192.168.0.1/31")
+	_, err := New(ipnet)
+
+	if err == nil {
+		t.Error("should return err")
+	}
+}

component/simple-obfs/http.go

@@ -8,6 +8,8 @@ import (
 	"math/rand"
 	"net"
 	"net/http"
+
+	"github.com/Dreamacro/clash/common/pool"
 )
 
 // HTTPObfs is shadowsocks http simple-obfs implementation
@@ -32,15 +34,15 @@ func (ho *HTTPObfs) Read(b []byte) (int, error) {
 	}
 
 	if ho.firstResponse {
-		buf := bufPool.Get().([]byte)
+		buf := pool.BufPool.Get().([]byte)
 		n, err := ho.Conn.Read(buf)
 		if err != nil {
-			bufPool.Put(buf[:cap(buf)])
+			pool.BufPool.Put(buf[:cap(buf)])
 			return 0, err
 		}
 		idx := bytes.Index(buf[:n], []byte("\r\n\r\n"))
 		if idx == -1 {
-			bufPool.Put(buf[:cap(buf)])
+			pool.BufPool.Put(buf[:cap(buf)])
 			return 0, io.EOF
 		}
 		ho.firstResponse = false
@@ -50,7 +52,7 @@ func (ho *HTTPObfs) Read(b []byte) (int, error) {
 			ho.buf = buf[:idx+4+length]
 			ho.offset = idx + 4 + n
 		} else {
-			bufPool.Put(buf[:cap(buf)])
+			pool.BufPool.Put(buf[:cap(buf)])
 		}
 		return n, nil
 	}

component/simple-obfs/tls.go

@@ -6,8 +6,9 @@ import (
 	"io"
 	"math/rand"
 	"net"
-	"sync"
 	"time"
+
+	"github.com/Dreamacro/clash/common/pool"
 )
 
 func init() {
@@ -18,8 +19,6 @@ const (
 	chunkSize = 1 << 14 // 2 ** 14 == 16 * 1024
 )
 
-var bufPool = sync.Pool{New: func() interface{} { return make([]byte, 2048) }}
-
 // TLSObfs is shadowsocks tls simple-obfs implementation
 type TLSObfs struct {
 	net.Conn
@@ -30,12 +29,12 @@ type TLSObfs struct {
 }
 
 func (to *TLSObfs) read(b []byte, discardN int) (int, error) {
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
 	_, err := io.ReadFull(to.Conn, buf[:discardN])
 	if err != nil {
 		return 0, err
 	}
-	bufPool.Put(buf[:cap(buf)])
+	pool.BufPool.Put(buf[:cap(buf)])
 
 	sizeBuf := make([]byte, 2)
 	_, err = io.ReadFull(to.Conn, sizeBuf)
@@ -103,7 +102,7 @@ func (to *TLSObfs) write(b []byte) (int, error) {
 		return len(b), err
 	}
 
-	size := bufPool.Get().([]byte)
+	size := pool.BufPool.Get().([]byte)
 	binary.BigEndian.PutUint16(size[:2], uint16(len(b)))
 
 	buf := &bytes.Buffer{}
@@ -111,7 +110,7 @@ func (to *TLSObfs) write(b []byte) (int, error) {
 	buf.Write(size[:2])
 	buf.Write(b)
 	_, err := to.Conn.Write(buf.Bytes())
-	bufPool.Put(size[:cap(size)])
+	pool.BufPool.Put(size[:cap(size)])
 	return len(b), err
 }
 

component/socks5/socks5.go

@@ -0,0 +1,247 @@
+package socks5
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"net"
+	"strconv"
+)
+
+// Error represents a SOCKS error
+type Error byte
+
+func (err Error) Error() string {
+	return "SOCKS error: " + strconv.Itoa(int(err))
+}
+
+// Command is request commands as defined in RFC 1928 section 4.
+type Command = uint8
+
+// SOCKS request commands as defined in RFC 1928 section 4.
+const (
+	CmdConnect      Command = 1
+	CmdBind         Command = 2
+	CmdUDPAssociate Command = 3
+)
+
+// SOCKS address types as defined in RFC 1928 section 5.
+const (
+	AtypIPv4       = 1
+	AtypDomainName = 3
+	AtypIPv6       = 4
+)
+
+// MaxAddrLen is the maximum size of SOCKS address in bytes.
+const MaxAddrLen = 1 + 1 + 255 + 2
+
+// Addr represents a SOCKS address as defined in RFC 1928 section 5.
+type Addr = []byte
+
+// SOCKS errors as defined in RFC 1928 section 6.
+const (
+	ErrGeneralFailure       = Error(1)
+	ErrConnectionNotAllowed = Error(2)
+	ErrNetworkUnreachable   = Error(3)
+	ErrHostUnreachable      = Error(4)
+	ErrConnectionRefused    = Error(5)
+	ErrTTLExpired           = Error(6)
+	ErrCommandNotSupported  = Error(7)
+	ErrAddressNotSupported  = Error(8)
+)
+
+type User struct {
+	Username string
+	Password string
+}
+
+// ServerHandshake fast-tracks SOCKS initialization to get target address to connect on server side.
+func ServerHandshake(rw io.ReadWriter) (addr Addr, command Command, err error) {
+	// Read RFC 1928 for request and reply structure and sizes.
+	buf := make([]byte, MaxAddrLen)
+	// read VER, NMETHODS, METHODS
+	if _, err = io.ReadFull(rw, buf[:2]); err != nil {
+		return
+	}
+	nmethods := buf[1]
+	if _, err = io.ReadFull(rw, buf[:nmethods]); err != nil {
+		return
+	}
+	// write VER METHOD
+	if _, err = rw.Write([]byte{5, 0}); err != nil {
+		return
+	}
+	// read VER CMD RSV ATYP DST.ADDR DST.PORT
+	if _, err = io.ReadFull(rw, buf[:3]); err != nil {
+		return
+	}
+
+	if buf[1] != CmdConnect && buf[1] != CmdUDPAssociate {
+		err = ErrCommandNotSupported
+		return
+	}
+
+	command = buf[1]
+	addr, err = readAddr(rw, buf)
+	if err != nil {
+		return
+	}
+	// write VER REP RSV ATYP BND.ADDR BND.PORT
+	_, err = rw.Write([]byte{5, 0, 0, 1, 0, 0, 0, 0, 0, 0})
+	return
+}
+
+// ClientHandshake fast-tracks SOCKS initialization to get target address to connect on client side.
+func ClientHandshake(rw io.ReadWriter, addr Addr, cammand Command, user *User) error {
+	buf := make([]byte, MaxAddrLen)
+	var err error
+
+	// VER, NMETHODS, METHODS
+	if user != nil {
+		_, err = rw.Write([]byte{5, 1, 2})
+	} else {
+		_, err = rw.Write([]byte{5, 1, 0})
+	}
+	if err != nil {
+		return err
+	}
+
+	// VER, METHOD
+	if _, err := io.ReadFull(rw, buf[:2]); err != nil {
+		return err
+	}
+
+	if buf[0] != 5 {
+		return errors.New("SOCKS version error")
+	}
+
+	if buf[1] == 2 {
+		// password protocol version
+		authMsg := &bytes.Buffer{}
+		authMsg.WriteByte(1)
+		authMsg.WriteByte(uint8(len(user.Username)))
+		authMsg.WriteString(user.Username)
+		authMsg.WriteByte(uint8(len(user.Password)))
+		authMsg.WriteString(user.Password)
+
+		if _, err := rw.Write(authMsg.Bytes()); err != nil {
+			return err
+		}
+
+		if _, err := io.ReadFull(rw, buf[:2]); err != nil {
+			return err
+		}
+
+		if buf[1] != 0 {
+			return errors.New("rejected username/password")
+		}
+	} else if buf[1] != 0 {
+		return errors.New("SOCKS need auth")
+	}
+
+	// VER, CMD, RSV, ADDR
+	if _, err := rw.Write(bytes.Join([][]byte{{5, cammand, 0}, addr}, []byte(""))); err != nil {
+		return err
+	}
+
+	if _, err := io.ReadFull(rw, buf[:10]); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func readAddr(r io.Reader, b []byte) (Addr, error) {
+	if len(b) < MaxAddrLen {
+		return nil, io.ErrShortBuffer
+	}
+	_, err := io.ReadFull(r, b[:1]) // read 1st byte for address type
+	if err != nil {
+		return nil, err
+	}
+
+	switch b[0] {
+	case AtypDomainName:
+		_, err = io.ReadFull(r, b[1:2]) // read 2nd byte for domain length
+		if err != nil {
+			return nil, err
+		}
+		domainLength := uint16(b[1])
+		_, err = io.ReadFull(r, b[2:2+domainLength+2])
+		return b[:1+1+domainLength+2], err
+	case AtypIPv4:
+		_, err = io.ReadFull(r, b[1:1+net.IPv4len+2])
+		return b[:1+net.IPv4len+2], err
+	case AtypIPv6:
+		_, err = io.ReadFull(r, b[1:1+net.IPv6len+2])
+		return b[:1+net.IPv6len+2], err
+	}
+
+	return nil, ErrAddressNotSupported
+}
+
+// SplitAddr slices a SOCKS address from beginning of b. Returns nil if failed.
+func SplitAddr(b []byte) Addr {
+	addrLen := 1
+	if len(b) < addrLen {
+		return nil
+	}
+
+	switch b[0] {
+	case AtypDomainName:
+		if len(b) < 2 {
+			return nil
+		}
+		addrLen = 1 + 1 + int(b[1]) + 2
+	case AtypIPv4:
+		addrLen = 1 + net.IPv4len + 2
+	case AtypIPv6:
+		addrLen = 1 + net.IPv6len + 2
+	default:
+		return nil
+
+	}
+
+	if len(b) < addrLen {
+		return nil
+	}
+
+	return b[:addrLen]
+}
+
+// ParseAddr parses the address in string s. Returns nil if failed.
+func ParseAddr(s string) Addr {
+	var addr Addr
+	host, port, err := net.SplitHostPort(s)
+	if err != nil {
+		return nil
+	}
+	if ip := net.ParseIP(host); ip != nil {
+		if ip4 := ip.To4(); ip4 != nil {
+			addr = make([]byte, 1+net.IPv4len+2)
+			addr[0] = AtypIPv4
+			copy(addr[1:], ip4)
+		} else {
+			addr = make([]byte, 1+net.IPv6len+2)
+			addr[0] = AtypIPv6
+			copy(addr[1:], ip)
+		}
+	} else {
+		if len(host) > 255 {
+			return nil
+		}
+		addr = make([]byte, 1+1+len(host)+2)
+		addr[0] = AtypDomainName
+		addr[1] = byte(len(host))
+		copy(addr[2:], host)
+	}
+
+	portnum, err := strconv.ParseUint(port, 10, 16)
+	if err != nil {
+		return nil
+	}
+
+	addr[len(addr)-2], addr[len(addr)-1] = byte(portnum>>8), byte(portnum)
+
+	return addr
+}

component/vmess/aead.go

@@ -5,6 +5,8 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
+
+	"github.com/Dreamacro/clash/common/pool"
 )
 
 type aeadWriter struct {
@@ -20,8 +22,8 @@ func newAEADWriter(w io.Writer, aead cipher.AEAD, iv []byte) *aeadWriter {
 }
 
 func (w *aeadWriter) Write(b []byte) (n int, err error) {
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
-	defer bufPool.Put(buf[:cap(buf)])
+	defer pool.BufPool.Put(buf[:cap(buf)])
 	length := len(b)
 	for {
 		if length == 0 {
@@ -71,7 +73,7 @@ func (r *aeadReader) Read(b []byte) (int, error) {
 		n := copy(b, r.buf[r.offset:])
 		r.offset += n
 		if r.offset == len(r.buf) {
-			bufPool.Put(r.buf[:cap(r.buf)])
+			pool.BufPool.Put(r.buf[:cap(r.buf)])
 			r.buf = nil
 		}
 		return n, nil
@@ -87,10 +89,10 @@ func (r *aeadReader) Read(b []byte) (int, error) {
 		return 0, errors.New("Buffer is larger than standard")
 	}
 
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
 	_, err = io.ReadFull(r.Reader, buf[:size])
 	if err != nil {
-		bufPool.Put(buf[:cap(buf)])
+		pool.BufPool.Put(buf[:cap(buf)])
 		return 0, err
 	}
 
@@ -105,7 +107,7 @@ func (r *aeadReader) Read(b []byte) (int, error) {
 	realLen := size - r.Overhead()
 	n := copy(b, buf[:realLen])
 	if len(b) >= realLen {
-		bufPool.Put(buf[:cap(buf)])
+		pool.BufPool.Put(buf[:cap(buf)])
 		return n, nil
 	}
 

component/vmess/chunk.go

@@ -4,7 +4,8 @@ import (
 	"encoding/binary"
 	"errors"
 	"io"
-	"sync"
+
+	"github.com/Dreamacro/clash/common/pool"
 )
 
 const (
@@ -13,8 +14,6 @@ const (
 	maxSize   = 17 * 1024 // 2 + chunkSize + aead.Overhead()
 )
 
-var bufPool = sync.Pool{New: func() interface{} { return make([]byte, maxSize) }}
-
 type chunkReader struct {
 	io.Reader
 	buf     []byte
@@ -35,7 +34,7 @@ func (cr *chunkReader) Read(b []byte) (int, error) {
 		n := copy(b, cr.buf[cr.offset:])
 		cr.offset += n
 		if cr.offset == len(cr.buf) {
-			bufPool.Put(cr.buf[:cap(cr.buf)])
+			pool.BufPool.Put(cr.buf[:cap(cr.buf)])
 			cr.buf = nil
 		}
 		return n, nil
@@ -60,10 +59,10 @@ func (cr *chunkReader) Read(b []byte) (int, error) {
 		return size, nil
 	}
 
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
 	_, err = io.ReadFull(cr.Reader, buf[:size])
 	if err != nil {
-		bufPool.Put(buf[:cap(buf)])
+		pool.BufPool.Put(buf[:cap(buf)])
 		return 0, err
 	}
 	n := copy(b, cr.buf[:])
@@ -77,8 +76,8 @@ type chunkWriter struct {
 }
 
 func (cw *chunkWriter) Write(b []byte) (n int, err error) {
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
-	defer bufPool.Put(buf[:cap(buf)])
+	defer pool.BufPool.Put(buf[:cap(buf)])
 	length := len(b)
 	for {
 		if length == 0 {

component/vmess/conn.go

@@ -77,7 +77,11 @@ func (vc *Conn) sendRequest() error {
 	// P Sec Reserve Cmd
 	buf.WriteByte(byte(p<<4) | byte(vc.security))
 	buf.WriteByte(0)
-	buf.WriteByte(CommandTCP)
+	if vc.dst.UDP {
+		buf.WriteByte(CommandUDP)
+	} else {
+		buf.WriteByte(CommandTCP)
+	}
 
 	// Port AddrType Addr
 	binary.Write(buf, binary.BigEndian, uint16(vc.dst.Port))

component/vmess/vmess.go

@@ -57,6 +57,7 @@ const (
 
 // DstAddr store destination address
 type DstAddr struct {
+	UDP      bool
 	AddrType byte
 	Addr     []byte
 	Port     uint

config/config.go

@@ -11,6 +11,7 @@ import (
 
 	adapters "github.com/Dreamacro/clash/adapters/outbound"
 	"github.com/Dreamacro/clash/common/structure"
+	"github.com/Dreamacro/clash/component/fakeip"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/dns"
 	"github.com/Dreamacro/clash/log"
@@ -41,14 +42,21 @@ type DNS struct {
 	Fallback     []dns.NameServer `yaml:"fallback"`
 	Listen       string           `yaml:"listen"`
 	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
+	FakeIPRange  *fakeip.Pool
+}
+
+// Experimental config
+type Experimental struct {
+	IgnoreResolveFail bool `yaml:"ignore-resolve-fail"`
 }
 
 // Config is clash config manager
 type Config struct {
-	General *General
+	General      *General
-	DNS     *DNS
+	DNS          *DNS
-	Rules   []C.Rule
+	Experimental *Experimental
-	Proxies map[string]C.Proxy
+	Rules        []C.Rule
+	Proxies      map[string]C.Proxy
 }
 
 type rawDNS struct {
@@ -58,6 +66,7 @@ type rawDNS struct {
 	Fallback     []string         `yaml:"fallback"`
 	Listen       string           `yaml:"listen"`
 	EnhancedMode dns.EnhancedMode `yaml:"enhanced-mode"`
+	FakeIPRange  string           `yaml:"fake-ip-range"`
 }
 
 type rawConfig struct {
@@ -71,10 +80,11 @@ type rawConfig struct {
 	ExternalUI         string       `yaml:"external-ui"`
 	Secret             string       `yaml:"secret"`
 
-	DNS        rawDNS                   `yaml:"dns"`
+	DNS          rawDNS                   `yaml:"dns"`
-	Proxy      []map[string]interface{} `yaml:"Proxy"`
+	Experimental Experimental             `yaml:"experimental"`
-	ProxyGroup []map[string]interface{} `yaml:"Proxy Group"`
+	Proxy        []map[string]interface{} `yaml:"Proxy"`
-	Rule       []string                 `yaml:"Rule"`
+	ProxyGroup   []map[string]interface{} `yaml:"Proxy Group"`
+	Rule         []string                 `yaml:"Rule"`
 }
 
 func readConfig(path string) (*rawConfig, error) {
@@ -98,8 +108,12 @@ func readConfig(path string) (*rawConfig, error) {
 		Rule:       []string{},
 		Proxy:      []map[string]interface{}{},
 		ProxyGroup: []map[string]interface{}{},
+		Experimental: Experimental{
+			IgnoreResolveFail: true,
+		},
 		DNS: rawDNS{
-			Enable: false,
+			Enable:      false,
+			FakeIPRange: "198.18.0.1/16",
 		},
 	}
 	err = yaml.Unmarshal([]byte(data), &rawConfig)
@@ -114,6 +128,7 @@ func Parse(path string) (*Config, error) {
 	if err != nil {
 		return nil, err
 	}
+	config.Experimental = &rawCfg.Experimental
 
 	general, err := parseGeneral(rawCfg)
 	if err != nil {
@@ -357,12 +372,24 @@ func parseRules(cfg *rawConfig) ([]C.Rule, error) {
 			if rule := R.NewIPCIDR(payload, target, false); rule != nil {
 				parsed = rule
 			}
+		// deprecated when bump to 1.0
 		case "SOURCE-IP-CIDR":
+			fallthrough
+		case "SRC-IP-CIDR":
 			if rule := R.NewIPCIDR(payload, target, true); rule != nil {
 				parsed = rule
 			}
+		case "SRC-PORT":
+			if rule := R.NewPort(payload, target, true); rule != nil {
+				parsed = rule
+			}
+		case "DST-PORT":
+			if rule := R.NewPort(payload, target, false); rule != nil {
+				parsed = rule
+			}
 		case "MATCH":
 			fallthrough
+		// deprecated when bump to 1.0
 		case "FINAL":
 			parsed = R.NewMatch(target)
 		}
@@ -455,5 +482,18 @@ func parseDNS(cfg rawDNS) (*DNS, error) {
 		return nil, err
 	}
 
+	if cfg.EnhancedMode == dns.FAKEIP {
+		_, ipnet, err := net.ParseCIDR(cfg.FakeIPRange)
+		if err != nil {
+			return nil, err
+		}
+		pool, err := fakeip.New(ipnet)
+		if err != nil {
+			return nil, err
+		}
+
+		dnsCfg.FakeIPRange = pool
+	}
+
 	return dnsCfg, nil
 }

config/initial.go

@@ -65,7 +65,7 @@ func Init(dir string) error {
 
 	// initial config.yml
 	if _, err := os.Stat(C.Path.Config()); os.IsNotExist(err) {
-		log.Info("Can't find config, create a empty file")
+		log.Info("Can't find config, create an empty file")
 		os.OpenFile(C.Path.Config(), os.O_CREATE|os.O_WRONLY, 0644)
 	}
 

constant/adapters.go

@@ -20,14 +20,16 @@ const (
 )
 
 type ServerAdapter interface {
+	net.Conn
 	Metadata() *Metadata
-	Close()
 }
 
 type ProxyAdapter interface {
 	Name() string
 	Type() AdapterType
 	Dial(metadata *Metadata) (net.Conn, error)
+	DialUDP(metadata *Metadata) (net.PacketConn, net.Addr, error)
+	SupportUDP() bool
 	Destroy()
 	MarshalJSON() ([]byte, error)
 }

constant/metadata.go

@@ -13,7 +13,7 @@ const (
 	TCP NetWork = iota
 	UDP
 
-	HTTP SourceType = iota
+	HTTP Type = iota
 	SOCKS
 	REDIR
 )
@@ -27,26 +27,27 @@ func (n *NetWork) String() string {
 	return "udp"
 }
 
-type SourceType int
+type Type int
 
 // Metadata is used to store connection address
 type Metadata struct {
 	NetWork  NetWork
-	Source   SourceType
+	Type     Type
-	SourceIP *net.IP
+	SrcIP    *net.IP
+	DstIP    *net.IP
+	SrcPort  string
+	DstPort  string
 	AddrType int
 	Host     string
-	IP       *net.IP
-	Port     string
 }
 
 func (m *Metadata) String() string {
 	if m.Host == "" {
-		return m.IP.String()
+		return m.DstIP.String()
 	}
 	return m.Host
 }
 
 func (m *Metadata) Valid() bool {
-	return m.Host != "" || m.IP != nil
+	return m.Host != "" || m.DstIP != nil
 }

constant/rule.go

@@ -7,7 +7,9 @@ const (
 	DomainKeyword
 	GEOIP
 	IPCIDR
-	SourceIPCIDR
+	SrcIPCIDR
+	SrcPort
+	DstPort
 	MATCH
 )
 
@@ -25,8 +27,12 @@ func (rt RuleType) String() string {
 		return "GEOIP"
 	case IPCIDR:
 		return "IPCIDR"
-	case SourceIPCIDR:
+	case SrcIPCIDR:
-		return "SourceIPCIDR"
+		return "SrcIPCIDR"
+	case SrcPort:
+		return "SrcPort"
+	case DstPort:
+		return "DstPort"
 	case MATCH:
 		return "MATCH"
 	default:

dns/client.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/Dreamacro/clash/common/cache"
 	"github.com/Dreamacro/clash/common/picker"
+	"github.com/Dreamacro/clash/component/fakeip"
 	C "github.com/Dreamacro/clash/constant"
 
 	D "github.com/miekg/dns"
@@ -28,6 +29,8 @@ var (
 type Resolver struct {
 	ipv6     bool
 	mapping  bool
+	fakeip   bool
+	pool     *fakeip.Pool
 	fallback []*nameserver
 	main     []*nameserver
 	cache    *cache.Cache
@@ -209,6 +212,10 @@ func (r *Resolver) IsMapping() bool {
 	return r.mapping
 }
 
+func (r *Resolver) IsFakeIP() bool {
+	return r.fakeip
+}
+
 type NameServer struct {
 	Net  string
 	Addr string
@@ -223,6 +230,7 @@ type Config struct {
 	Main, Fallback []NameServer
 	IPv6           bool
 	EnhancedMode   EnhancedMode
+	Pool           *fakeip.Pool
 }
 
 func transform(servers []NameServer) []*nameserver {
@@ -252,6 +260,8 @@ func New(config Config) *Resolver {
 		ipv6:    config.IPv6,
 		cache:   cache.New(time.Second * 60),
 		mapping: config.EnhancedMode == MAPPING,
+		fakeip:  config.EnhancedMode == FAKEIP,
+		pool:    config.Pool,
 	}
 	if config.Fallback != nil {
 		r.fallback = transform(config.Fallback)

dns/server.go

@@ -1,16 +1,21 @@
 package dns
 
 import (
+	"errors"
 	"fmt"
 	"net"
+	"time"
 
 	"github.com/Dreamacro/clash/log"
+	"github.com/miekg/dns"
 	D "github.com/miekg/dns"
 )
 
 var (
 	address string
 	server  = &Server{}
+
+	dnsDefaultTTL uint32 = 600
 )
 
 type Server struct {
@@ -19,6 +24,17 @@ type Server struct {
 }
 
 func (s *Server) ServeDNS(w D.ResponseWriter, r *D.Msg) {
+	if s.r.IsFakeIP() {
+		msg, err := s.handleFakeIP(r)
+		if err != nil {
+			D.HandleFailed(w, r)
+			return
+		}
+		msg.SetReply(r)
+		w.WriteMsg(msg)
+		return
+	}
+
 	msg, err := s.r.Exchange(r)
 
 	if err != nil {
@@ -34,6 +50,40 @@ func (s *Server) ServeDNS(w D.ResponseWriter, r *D.Msg) {
 	w.WriteMsg(msg)
 }
 
+func (s *Server) handleFakeIP(r *D.Msg) (msg *D.Msg, err error) {
+	if len(r.Question) == 0 {
+		err = errors.New("should have one question at least")
+		return
+	}
+
+	q := r.Question[0]
+
+	cache, expireTime := s.r.cache.GetWithExpire("fakeip:" + q.String())
+	if cache != nil {
+		msg = cache.(*D.Msg).Copy()
+		setMsgTTL(msg, uint32(expireTime.Sub(time.Now()).Seconds()))
+		return
+	}
+
+	var ip net.IP
+	defer func() {
+		if msg == nil {
+			return
+		}
+
+		putMsgToCache(s.r.cache, "fakeip:"+q.String(), msg)
+		putMsgToCache(s.r.cache, ip.String(), msg)
+	}()
+
+	rr := &D.A{}
+	rr.Hdr = dns.RR_Header{Name: r.Question[0].Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: dnsDefaultTTL}
+	ip = s.r.pool.Get()
+	rr.A = ip
+	msg = r.Copy()
+	msg.Answer = []D.RR{rr}
+	return
+}
+
 func (s *Server) setReslover(r *Resolver) {
 	s.r = r
 }

dns/util.go

@@ -70,7 +70,7 @@ func (e EnhancedMode) String() string {
 	case NORMAL:
 		return "normal"
 	case FAKEIP:
-		return "fakeip"
+		return "fake-ip"
 	case MAPPING:
 		return "redir-host"
 	default:

go.mod

@@ -1,19 +1,19 @@
 module github.com/Dreamacro/clash
 
 require (
-	github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112
+	github.com/Dreamacro/go-shadowsocks2 v0.1.3
 	github.com/eapache/queue v1.1.0 // indirect
-	github.com/go-chi/chi v4.0.1+incompatible
+	github.com/go-chi/chi v4.0.2+incompatible
 	github.com/go-chi/cors v1.0.0
 	github.com/go-chi/render v1.0.1
 	github.com/gofrs/uuid v3.2.0+incompatible
 	github.com/gorilla/websocket v1.4.0
-	github.com/miekg/dns v1.1.4
+	github.com/miekg/dns v1.1.9
 	github.com/oschwald/geoip2-golang v1.2.1
 	github.com/oschwald/maxminddb-golang v1.3.0 // indirect
-	github.com/sirupsen/logrus v1.3.0
+	github.com/sirupsen/logrus v1.4.1
-	golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613
+	golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734
-	golang.org/x/net v0.0.0-20181108082009-03003ca0c849
+	golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3
 	golang.org/x/sync v0.0.0-20181108010431-42b317875d0f // indirect
 	gopkg.in/eapache/channels.v1 v1.1.0
 	gopkg.in/yaml.v2 v2.2.2

go.sum

@@ -1,13 +1,13 @@
-github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112 h1:1axYxE0ZLJy40+ulq46XQt7MaJDJr4iGer1NQz7jmKw=
+github.com/Dreamacro/go-shadowsocks2 v0.1.3 h1:1ffY/q4e3o+MnztYgIq1iZiX1BWoWQ6D3AIO1kkb8bc=
-github.com/Dreamacro/go-shadowsocks2 v0.1.3-0.20190202135136-da4602d8f112/go.mod h1:giIuN+TuUudTxHc1jjTOyyQYiJ3VXp1pWOHdJbSCAPo=
+github.com/Dreamacro/go-shadowsocks2 v0.1.3/go.mod h1:0x17IhQ+mlY6q/ffKRpzaE7u4aHMxxnitTRSrV5G6TU=
 github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY=
 github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/eapache/queue v1.1.0 h1:YOEu7KNc61ntiQlcEeUIoDTJ2o8mQznoNvUhiigpIqc=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/go-chi/chi v4.0.1+incompatible h1:RSRC5qmFPtO90t7pTL0DBMNpZFsb/sHF3RXVlDgFisA=
+github.com/go-chi/chi v4.0.2+incompatible h1:maB6vn6FqCxrpz4FqWdh4+lwpyZIQS7YEAUcHlgXVRs=
-github.com/go-chi/chi v4.0.1+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
+github.com/go-chi/chi v4.0.2+incompatible/go.mod h1:eB3wogJHnLi3x/kFX2A+IbTBlXxmMeXJVKy9tTv1XzQ=
 github.com/go-chi/cors v1.0.0 h1:e6x8k7uWbUwYs+aXDoiUzeQFT6l0cygBYyNhD7/1Tg0=
 github.com/go-chi/cors v1.0.0/go.mod h1:K2Yje0VW/SJzxiyMYu6iPQYa7hMjQX2i/F491VChg1I=
 github.com/go-chi/render v1.0.1 h1:4/5tis2cKaNdnv9zFLfXzcquC9HbeZgCnxGnKrltBS8=
@@ -18,29 +18,31 @@ github.com/gorilla/websocket v1.4.0 h1:WDFjx/TMzVgy9VdMMQi2K2Emtwi2QcUQsztZ/zLaH
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/miekg/dns v1.1.4 h1:rCMZsU2ScVSYcAsOXgmC6+AKOK+6pmQTOcw03nfwYV0=
+github.com/miekg/dns v1.1.9 h1:OIdC9wT96RzuZMf2PfKRhFgsStHUUBZLM/lo1LqiM9E=
-github.com/miekg/dns v1.1.4/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.9/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/oschwald/geoip2-golang v1.2.1 h1:3iz+jmeJc6fuCyWeKgtXSXu7+zvkxJbHFXkMT5FVebU=
 github.com/oschwald/geoip2-golang v1.2.1/go.mod h1:0LTTzix/Ao1uMvOhAV4iLU0Lz7eCrP94qZWBTDKf0iE=
 github.com/oschwald/maxminddb-golang v1.3.0 h1:oTh8IBSj10S5JNlUDg5WjJ1QdBMdeaZIkPEVfESSWgE=
 github.com/oschwald/maxminddb-golang v1.3.0/go.mod h1:3jhIUymTJ5VREKyIhWm66LJiQt04F0UCDdodShpjWsY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sirupsen/logrus v1.3.0 h1:hI/7Q+DtNZ2kINb6qt/lS+IyXnHQe9e90POfeewL/ME=
+github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=
-github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613 h1:MQ/ZZiDsUapFFiMS+vzwXkCTeEKaum+Do5rINYJDmxc=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734 h1:p/H982KKEjUnLJkM3tt/LemDnOc1GiZL5FCVlORJ5zo=
-golang.org/x/crypto v0.0.0-20190131182504-b8fe1690c613/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/net v0.0.0-20181108082009-03003ca0c849 h1:FSqE2GGG7wzsYUsWiQ8MZrvEd1EOyU3NCF0AW3Wtltg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
-golang.org/x/net v0.0.0-20181108082009-03003ca0c849/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181005133103-4497e2df6f9e h1:EfdBzeKbFSvOjoIqSZcfS8wp0FBLokGBEs9lz1OtSg0=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181005133103-4497e2df6f9e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/eapache/channels.v1 v1.1.0 h1:5bGAyKKvyCTWjSj7mhefG6Lc68VyN4MH1v8/7OoeeB4=

hub/executor/executor.go

@@ -27,6 +27,7 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	updateProxies(cfg.Proxies)
 	updateRules(cfg.Rules)
 	updateDNS(cfg.DNS)
+	updateExperimental(cfg.Experimental)
 }
 
 func GetGeneral() *config.General {
@@ -41,6 +42,10 @@ func GetGeneral() *config.General {
 	}
 }
 
+func updateExperimental(c *config.Experimental) {
+	T.Instance().UpdateExperimental(c.IgnoreResolveFail)
+}
+
 func updateDNS(c *config.DNS) {
 	if c.Enable == false {
 		T.Instance().SetResolver(nil)
@@ -52,6 +57,7 @@ func updateDNS(c *config.DNS) {
 		Fallback:     c.Fallback,
 		IPv6:         c.IPv6,
 		EnhancedMode: c.EnhancedMode,
+		Pool:         c.FakeIPRange,
 	})
 	T.Instance().SetResolver(r)
 	if err := dns.ReCreateServer(c.Listen, r); err != nil {

proxy/redir/tcp.go

@@ -59,5 +59,5 @@ func handleRedir(conn net.Conn) {
 		return
 	}
 	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocket(target, conn, C.REDIR))
+	tun.Add(adapters.NewSocket(target, conn, C.REDIR, C.TCP))
 }

proxy/redir/tcp_darwin.go

@@ -5,10 +5,10 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/Dreamacro/go-shadowsocks2/socks"
+	"github.com/Dreamacro/clash/component/socks5"
 )
 
-func parserPacket(c net.Conn) (socks.Addr, error) {
+func parserPacket(c net.Conn) (socks5.Addr, error) {
 	const (
 		PfInout     = 0
 		PfIn        = 1
@@ -51,7 +51,7 @@ func parserPacket(c net.Conn) (socks.Addr, error) {
 	}
 
 	addr := make([]byte, 1+net.IPv4len+2)
-	addr[0] = socks.AtypIPv4
+	addr[0] = socks5.AtypIPv4
 	copy(addr[1:1+net.IPv4len], nl.rdaddr[:4])
 	copy(addr[1+net.IPv4len:], nl.rdxport[:2])
 	return addr, nil

proxy/redir/tcp_freebsd.go

@@ -6,7 +6,7 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/Dreamacro/go-shadowsocks2/socks"
+	"github.com/Dreamacro/clash/component/socks5"
 )
 
 const (
@@ -14,7 +14,7 @@ const (
 	IP6T_SO_ORIGINAL_DST = 80 // from linux/include/uapi/linux/netfilter_ipv6/ip6_tables.h
 )
 
-func parserPacket(conn net.Conn) (socks.Addr, error) {
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
 	c, ok := conn.(*net.TCPConn)
 	if !ok {
 		return nil, errors.New("only work with TCP connection")
@@ -25,7 +25,7 @@ func parserPacket(conn net.Conn) (socks.Addr, error) {
 		return nil, err
 	}
 
-	var addr socks.Addr
+	var addr socks5.Addr
 
 	rc.Control(func(fd uintptr) {
 		addr, err = getorigdst(fd)
@@ -35,7 +35,7 @@ func parserPacket(conn net.Conn) (socks.Addr, error) {
 }
 
 // Call getorigdst() from linux/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
-func getorigdst(fd uintptr) (socks.Addr, error) {
+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)
@@ -44,7 +44,7 @@ func getorigdst(fd uintptr) (socks.Addr, error) {
 	}
 
 	addr := make([]byte, 1+net.IPv4len+2)
-	addr[0] = socks.AtypIPv4
+	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]

proxy/redir/tcp_linux.go

@@ -6,7 +6,7 @@ import (
 	"syscall"
 	"unsafe"
 
-	"github.com/Dreamacro/go-shadowsocks2/socks"
+	"github.com/Dreamacro/clash/component/socks5"
 )
 
 const (
@@ -14,7 +14,7 @@ const (
 	IP6T_SO_ORIGINAL_DST = 80 // from linux/include/uapi/linux/netfilter_ipv6/ip6_tables.h
 )
 
-func parserPacket(conn net.Conn) (socks.Addr, error) {
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
 	c, ok := conn.(*net.TCPConn)
 	if !ok {
 		return nil, errors.New("only work with TCP connection")
@@ -25,7 +25,7 @@ func parserPacket(conn net.Conn) (socks.Addr, error) {
 		return nil, err
 	}
 
-	var addr socks.Addr
+	var addr socks5.Addr
 
 	rc.Control(func(fd uintptr) {
 		addr, err = getorigdst(fd)
@@ -35,7 +35,7 @@ func parserPacket(conn net.Conn) (socks.Addr, error) {
 }
 
 // Call getorigdst() from linux/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c
-func getorigdst(fd uintptr) (socks.Addr, error) {
+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 {
@@ -43,7 +43,7 @@ func getorigdst(fd uintptr) (socks.Addr, error) {
 	}
 
 	addr := make([]byte, 1+net.IPv4len+2)
-	addr[0] = socks.AtypIPv4
+	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]

proxy/redir/tcp_windows.go

@@ -4,9 +4,9 @@ import (
 	"errors"
 	"net"
 
-	"github.com/Dreamacro/go-shadowsocks2/socks"
+	"github.com/Dreamacro/clash/component/socks5"
 )
 
-func parserPacket(conn net.Conn) (socks.Addr, error) {
+func parserPacket(conn net.Conn) (socks5.Addr, error) {
 	return nil, errors.New("Windows not support yet")
 }

proxy/socks/tcp.go

@@ -3,12 +3,11 @@ package socks
 import (
 	"net"
 
-	"github.com/Dreamacro/clash/adapters/inbound"
+	adapters "github.com/Dreamacro/clash/adapters/inbound"
+	"github.com/Dreamacro/clash/component/socks5"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/tunnel"
-
-	"github.com/Dreamacro/go-shadowsocks2/socks"
 )
 
 var (
@@ -55,11 +54,15 @@ func (l *SockListener) Address() string {
 }
 
 func handleSocks(conn net.Conn) {
-	target, err := socks.Handshake(conn)
+	target, command, err := socks5.ServerHandshake(conn)
 	if err != nil {
 		conn.Close()
 		return
 	}
 	conn.(*net.TCPConn).SetKeepAlive(true)
-	tun.Add(adapters.NewSocket(target, conn, C.SOCKS))
+	if command == socks5.CmdUDPAssociate {
+		tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.UDP))
+		return
+	}
+	tun.Add(adapters.NewSocket(target, conn, C.SOCKS, C.TCP))
 }

proxy/socks/udp.go

@@ -1 +0,0 @@
-package socks

rules/geoip.go

@@ -24,10 +24,10 @@ func (g *GEOIP) RuleType() C.RuleType {
 }
 
 func (g *GEOIP) IsMatch(metadata *C.Metadata) bool {
-	if metadata.IP == nil {
+	if metadata.DstIP == nil {
 		return false
 	}
-	record, _ := mmdb.Country(*metadata.IP)
+	record, _ := mmdb.Country(*metadata.DstIP)
 	return record.Country.IsoCode == g.country
 }
 

rules/ipcidr.go

@@ -14,15 +14,15 @@ type IPCIDR struct {
 
 func (i *IPCIDR) RuleType() C.RuleType {
 	if i.isSourceIP {
-		return C.SourceIPCIDR
+		return C.SrcIPCIDR
 	}
 	return C.IPCIDR
 }
 
 func (i *IPCIDR) IsMatch(metadata *C.Metadata) bool {
-	ip := metadata.IP
+	ip := metadata.DstIP
 	if i.isSourceIP {
-		ip = metadata.SourceIP
+		ip = metadata.SrcIP
 	}
 	return ip != nil && i.ipnet.Contains(*ip)
 }

rules/port.go

@@ -0,0 +1,47 @@
+package rules
+
+import (
+	"strconv"
+
+	C "github.com/Dreamacro/clash/constant"
+)
+
+type Port struct {
+	adapter  string
+	port     string
+	isSource bool
+}
+
+func (p *Port) RuleType() C.RuleType {
+	if p.isSource {
+		return C.SrcPort
+	}
+	return C.DstPort
+}
+
+func (p *Port) IsMatch(metadata *C.Metadata) bool {
+	if p.isSource {
+		return metadata.SrcPort == p.port
+	}
+	return metadata.DstPort == p.port
+}
+
+func (p *Port) Adapter() string {
+	return p.adapter
+}
+
+func (p *Port) Payload() string {
+	return p.port
+}
+
+func NewPort(port string, adapter string, isSource bool) *Port {
+	_, err := strconv.Atoi(port)
+	if err != nil {
+		return nil
+	}
+	return &Port{
+		adapter:  adapter,
+		port:     port,
+		isSource: isSource,
+	}
+}

tunnel/connection.go

@@ -6,21 +6,12 @@ import (
 	"net"
 	"net/http"
 	"strings"
-	"sync"
 	"time"
 
 	adapters "github.com/Dreamacro/clash/adapters/inbound"
+	"github.com/Dreamacro/clash/common/pool"
 )
 
-const (
-	// io.Copy default buffer size is 32 KiB
-	// but the maximum packet size of vmess/shadowsocks is about 16 KiB
-	// so define a buffer of 20 KiB to reduce the memory of each TCP relay
-	bufferSize = 20 * 1024
-)
-
-var bufPool = sync.Pool{New: func() interface{} { return make([]byte, bufferSize) }}
-
 func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
 	conn := newTrafficTrack(outbound, t.traffic)
 	req := request.R
@@ -50,7 +41,7 @@ func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
 		} else {
 			resp.Close = true
 		}
-		err = resp.Write(request.Conn())
+		err = resp.Write(request)
 		if err != nil || resp.Close {
 			break
 		}
@@ -59,7 +50,7 @@ func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
 			break
 		}
 
-		req, err = http.ReadRequest(bufio.NewReader(request.Conn()))
+		req, err = http.ReadRequest(bufio.NewReader(request))
 		if err != nil {
 			break
 		}
@@ -72,9 +63,52 @@ func (t *Tunnel) handleHTTP(request *adapters.HTTPAdapter, outbound net.Conn) {
 	}
 }
 
-func (t *Tunnel) handleSOCKS(request *adapters.SocketAdapter, outbound net.Conn) {
+func (t *Tunnel) handleSocket(request *adapters.SocketAdapter, outbound net.Conn) {
 	conn := newTrafficTrack(outbound, t.traffic)
-	relay(request.Conn(), conn)
+	relay(request, conn)
+}
+
+func (t *Tunnel) handleUDPOverTCP(conn net.Conn, pc net.PacketConn, addr net.Addr) error {
+	ch := make(chan error, 1)
+
+	go func() {
+		buf := pool.BufPool.Get().([]byte)
+		defer pool.BufPool.Put(buf)
+		for {
+			n, err := conn.Read(buf)
+			if err != nil {
+				ch <- err
+				return
+			}
+			pc.SetReadDeadline(time.Now().Add(120 * time.Second))
+			if _, err = pc.WriteTo(buf[:n], addr); err != nil {
+				ch <- err
+				return
+			}
+			t.traffic.Up() <- int64(n)
+			ch <- nil
+		}
+	}()
+
+	buf := pool.BufPool.Get().([]byte)
+	defer pool.BufPool.Put(buf)
+
+	for {
+		pc.SetReadDeadline(time.Now().Add(120 * time.Second))
+		n, _, err := pc.ReadFrom(buf)
+		if err != nil {
+			break
+		}
+
+		if _, err := conn.Write(buf[:n]); err != nil {
+			break
+		}
+
+		t.traffic.Down() <- int64(n)
+	}
+
+	<-ch
+	return nil
 }
 
 // relay copies between left and right bidirectionally.
@@ -82,16 +116,16 @@ func relay(leftConn, rightConn net.Conn) {
 	ch := make(chan error)
 
 	go func() {
-		buf := bufPool.Get().([]byte)
+		buf := pool.BufPool.Get().([]byte)
 		_, err := io.CopyBuffer(leftConn, rightConn, buf)
-		bufPool.Put(buf[:cap(buf)])
+		pool.BufPool.Put(buf[:cap(buf)])
 		leftConn.SetReadDeadline(time.Now())
 		ch <- err
 	}()
 
-	buf := bufPool.Get().([]byte)
+	buf := pool.BufPool.Get().([]byte)
 	io.CopyBuffer(rightConn, leftConn, buf)
-	bufPool.Put(buf[:cap(buf)])
+	pool.BufPool.Put(buf[:cap(buf)])
 	rightConn.SetReadDeadline(time.Now())
 	<-ch
 }

tunnel/tunnel.go

@@ -19,14 +19,17 @@ var (
 	once   sync.Once
 )
 
-// Tunnel handle proxy socket and HTTP/SOCKS socket
+// Tunnel handle relay inbound proxy and outbound proxy
 type Tunnel struct {
-	queue      *channels.InfiniteChannel
+	queue     *channels.InfiniteChannel
-	rules      []C.Rule
+	rules     []C.Rule
-	proxies    map[string]C.Proxy
+	proxies   map[string]C.Proxy
-	configLock *sync.RWMutex
+	configMux *sync.RWMutex
-	traffic    *C.Traffic
+	traffic   *C.Traffic
-	resolver   *dns.Resolver
+	resolver  *dns.Resolver
+
+	// experimental features
+	ignoreResolveFail bool
 
 	// Outbound Rule
 	mode Mode
@@ -49,9 +52,9 @@ func (t *Tunnel) Rules() []C.Rule {
 
 // UpdateRules handle update rules
 func (t *Tunnel) UpdateRules(rules []C.Rule) {
-	t.configLock.Lock()
+	t.configMux.Lock()
 	t.rules = rules
-	t.configLock.Unlock()
+	t.configMux.Unlock()
 }
 
 // Proxies return all proxies
@@ -61,9 +64,16 @@ func (t *Tunnel) Proxies() map[string]C.Proxy {
 
 // UpdateProxies handle update proxies
 func (t *Tunnel) UpdateProxies(proxies map[string]C.Proxy) {
-	t.configLock.Lock()
+	t.configMux.Lock()
 	t.proxies = proxies
-	t.configLock.Unlock()
+	t.configMux.Unlock()
+}
+
+// UpdateExperimental handle update experimental config
+func (t *Tunnel) UpdateExperimental(ignoreResolveFail bool) {
+	t.configMux.Lock()
+	t.ignoreResolveFail = ignoreResolveFail
+	t.configMux.Unlock()
 }
 
 // Mode return current mode
@@ -108,7 +118,7 @@ func (t *Tunnel) resolveIP(host string) (net.IP, error) {
 }
 
 func (t *Tunnel) needLookupIP(metadata *C.Metadata) bool {
-	return t.hasResolver() && t.resolver.IsMapping() && metadata.Host == "" && metadata.IP != nil
+	return t.hasResolver() && (t.resolver.IsMapping() || t.resolver.IsFakeIP()) && metadata.Host == "" && metadata.DstIP != nil
 }
 
 func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
@@ -120,11 +130,15 @@ func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 		return
 	}
 
+	// preprocess enhanced-mode metadata
 	if t.needLookupIP(metadata) {
-		host, exist := t.resolver.IPToHost(*metadata.IP)
+		host, exist := t.resolver.IPToHost(*metadata.DstIP)
 		if exist {
 			metadata.Host = host
 			metadata.AddrType = C.AtypDomainName
+			if t.resolver.IsFakeIP() {
+				metadata.DstIP = nil
+			}
 		}
 	}
 
@@ -143,9 +157,20 @@ func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 		}
 	}
 
+	if metadata.NetWork == C.UDP {
+		pc, addr, err := proxy.DialUDP(metadata)
+		defer pc.Close()
+		if err != nil {
+			log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
+		}
+
+		t.handleUDPOverTCP(localConn, pc, addr)
+		return
+	}
+
 	remoConn, err := proxy.Dial(metadata)
 	if err != nil {
-		log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SourceIP.String(), metadata.String(), err.Error())
+		log.Warnln("Proxy[%s] connect [%s --> %s] error: %s", proxy.Name(), metadata.SrcIP.String(), metadata.String(), err.Error())
 		return
 	}
 	defer remoConn.Close()
@@ -154,46 +179,59 @@ func (t *Tunnel) handleConn(localConn C.ServerAdapter) {
 	case *InboundAdapter.HTTPAdapter:
 		t.handleHTTP(adapter, remoConn)
 	case *InboundAdapter.SocketAdapter:
-		t.handleSOCKS(adapter, remoConn)
+		t.handleSocket(adapter, remoConn)
 	}
 }
 
 func (t *Tunnel) shouldResolveIP(rule C.Rule, metadata *C.Metadata) bool {
-	return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.IP == nil
+	return (rule.RuleType() == C.GEOIP || rule.RuleType() == C.IPCIDR) && metadata.Host != "" && metadata.DstIP == nil
 }
 
 func (t *Tunnel) match(metadata *C.Metadata) (C.Proxy, error) {
-	t.configLock.RLock()
+	t.configMux.RLock()
-	defer t.configLock.RUnlock()
+	defer t.configMux.RUnlock()
 
+	var resolved bool
 	for _, rule := range t.rules {
-		if t.shouldResolveIP(rule, metadata) {
+		if !resolved && t.shouldResolveIP(rule, metadata) {
 			ip, err := t.resolveIP(metadata.Host)
 			if err != nil {
-				return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
+				if !t.ignoreResolveFail {
+					return nil, fmt.Errorf("[DNS] resolve %s error: %s", metadata.Host, err.Error())
+				}
+				log.Debugln("[DNS] resolve %s error: %s", metadata.Host, err.Error())
+			} else {
+				log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
+				metadata.DstIP = &ip
 			}
-			log.Debugln("[DNS] %s --> %s", metadata.Host, ip.String())
+			resolved = true
-			metadata.IP = &ip
 		}
 
 		if rule.IsMatch(metadata) {
-			if a, ok := t.proxies[rule.Adapter()]; ok {
+			adapter, ok := t.proxies[rule.Adapter()]
-				log.Infoln("%s --> %v match %s using %s", metadata.SourceIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
+			if !ok {
-				return a, nil
+				continue
 			}
+
+			if metadata.NetWork == C.UDP && !adapter.SupportUDP() {
+				continue
+			}
+
+			log.Infoln("%s --> %v match %s using %s", metadata.SrcIP.String(), metadata.String(), rule.RuleType().String(), rule.Adapter())
+			return adapter, nil
 		}
 	}
-	log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SourceIP.String(), metadata.String())
+	log.Infoln("%s --> %v doesn't match any rule using DIRECT", metadata.SrcIP.String(), metadata.String())
 	return t.proxies["DIRECT"], nil
 }
 
 func newTunnel() *Tunnel {
 	return &Tunnel{
-		queue:      channels.NewInfiniteChannel(),
+		queue:     channels.NewInfiniteChannel(),
-		proxies:    make(map[string]C.Proxy),
+		proxies:   make(map[string]C.Proxy),
-		configLock: &sync.RWMutex{},
+		configMux: &sync.RWMutex{},
-		traffic:    C.NewTraffic(time.Second),
+		traffic:   C.NewTraffic(time.Second),
-		mode:       Rule,
+		mode:      Rule,
 	}
 }