vmess: add experimental vemss support

main.go

@@ -20,6 +20,7 @@ import (
 	_ "github.com/nadoo/glider/proxy/tcptun"
 	_ "github.com/nadoo/glider/proxy/udptun"
 	_ "github.com/nadoo/glider/proxy/uottun"
+	_ "github.com/nadoo/glider/proxy/vmess"
 )
 
 // VERSION .

proxy/dnstun/dnstun.go

@@ -38,7 +38,6 @@ func NewDNSTun(s string, dialer proxy.Dialer) (*DNSTun, error) {
 
 	addr := u.Host
 	d := strings.Split(addr, "=")
-
 	addr, raddr := d[0], d[1]
 
 	p := &DNSTun{

proxy/vmess/vmess.go

@@ -0,0 +1,177 @@
+package vmess
+
+import (
+	"context"
+	"errors"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/nadoo/glider/common/log"
+	"github.com/nadoo/glider/proxy"
+
+	"v2ray.com/core"
+	"v2ray.com/core/app/dispatcher"
+	"v2ray.com/core/app/proxyman"
+	v2net "v2ray.com/core/common/net"
+	"v2ray.com/core/common/protocol"
+	"v2ray.com/core/common/serial"
+	"v2ray.com/core/proxy/vmess"
+	"v2ray.com/core/proxy/vmess/outbound"
+	"v2ray.com/core/transport/internet"
+	"v2ray.com/core/transport/internet/tls"
+
+	_ "v2ray.com/core/app/proxyman/outbound"
+	_ "v2ray.com/core/transport/internet/tcp"
+)
+
+// VMess .
+type VMess struct {
+	dialer proxy.Dialer
+	addr   string
+
+	uuid     string
+	alertID  uint32
+	network  string
+	security string
+
+	config   *core.Config
+	instance *core.Instance
+}
+
+func init() {
+	proxy.RegisterDialer("vmess", NewVMessDialer)
+}
+
+// NewVMess returns a vmess proxy.
+func NewVMess(s string, dialer proxy.Dialer) (*VMess, error) {
+	u, err := url.Parse(s)
+	if err != nil {
+		log.F("parse url err: %s", err)
+		return nil, err
+	}
+
+	addr := u.Host
+	host := u.Hostname()
+	port, err := strconv.ParseUint(u.Port(), 10, 32)
+	if err != nil {
+		log.F("parse port err: %s", err)
+		return nil, err
+	}
+
+	var uuid, aid string
+	if u.User != nil {
+		uuid = u.User.Username()
+		aid, _ = u.User.Password()
+	}
+
+	alertID, err := strconv.ParseUint(aid, 10, 32)
+	if err != nil {
+		log.F("parse alertID err: %s", err)
+		return nil, err
+	}
+
+	config := &core.Config{
+		App: []*serial.TypedMessage{
+			serial.ToTypedMessage(&dispatcher.Config{}),
+			serial.ToTypedMessage(&proxyman.OutboundConfig{}),
+		},
+		Outbound: []*core.OutboundHandlerConfig{{
+			ProxySettings: serial.ToTypedMessage(&outbound.Config{
+				Receiver: []*protocol.ServerEndpoint{
+					{
+						Address: v2net.NewIPOrDomain(v2net.ParseAddress(host)),
+						Port:    uint32(port),
+						User: []*protocol.User{
+							{
+								Account: serial.ToTypedMessage(&vmess.Account{
+									Id:      uuid,
+									AlterId: uint32(alertID),
+									SecuritySettings: &protocol.SecurityConfig{
+										Type: protocol.SecurityType_NONE,
+									},
+								}),
+							},
+						},
+					},
+				},
+			}),
+			SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{
+				StreamSettings: &internet.StreamConfig{
+					Protocol:     internet.TransportProtocol_TCP,
+					SecurityType: serial.GetMessageType(&tls.Config{}),
+					SecuritySettings: []*serial.TypedMessage{
+						serial.ToTypedMessage(&tls.Config{
+							AllowInsecure: true,
+						}),
+					},
+				},
+			})},
+		},
+	}
+
+	v, err := core.New(config)
+	if err != nil {
+		log.Fatal("Failed to create V: ", err.Error())
+	}
+
+	p := &VMess{
+		dialer: dialer,
+		addr:   addr,
+
+		uuid:     uuid,
+		alertID:  uint32(alertID),
+		network:  "tcp",
+		security: "tls",
+
+		config:   config,
+		instance: v,
+	}
+
+	return p, nil
+}
+
+// NewVMessDialer returns a vmess proxy dialer.
+func NewVMessDialer(s string, dialer proxy.Dialer) (proxy.Dialer, error) {
+	return NewVMess(s, dialer)
+}
+
+// Addr returns forwarder's address
+func (s *VMess) Addr() string { return s.addr }
+
+// NextDialer returns the next dialer
+func (s *VMess) NextDialer(dstAddr string) proxy.Dialer { return s.dialer.NextDialer(dstAddr) }
+
+// Dial connects to the address addr on the network net via the proxy.
+func (s *VMess) Dial(network, addr string) (net.Conn, error) {
+
+	// c, err := s.dialer.Dial("tcp", s.addr)
+
+	d := strings.Split(addr, ":")
+	host, portStr := d[0], d[1]
+	port, err := strconv.ParseUint(portStr, 10, 32)
+	if err != nil {
+		log.F("parse portStr err: %s", err)
+		return nil, err
+	}
+
+	// TODO: does not support upstream dialer now
+	c, err := core.Dial(context.Background(), s.instance, v2net.TCPDestination(v2net.ParseAddress(host), v2net.Port(port)))
+	if err != nil {
+		log.F("proxy-vmess dial to %s error: %s", s.addr, err)
+		return nil, err
+	}
+
+	if c, ok := c.(*net.TCPConn); ok {
+		c.SetKeepAlive(true)
+	}
+
+	return c, err
+
+}
+
+// DialUDP connects to the given address via the proxy.
+func (s *VMess) DialUDP(network, addr string) (net.PacketConn, net.Addr, error) {
+	return nil, nil, errors.New("vmess client does not support udp now")
+}