move some code

node/controller.go

@@ -64,11 +64,12 @@ func (c *Controller) Start() error {
 		}
 	}
 	// Add new tag
-	err = c.addNewNode(c.nodeInfo)
+	err = c.server.AddNode(c.Tag, c.nodeInfo, c.ControllerConfig)
 	if err != nil {
 		return fmt.Errorf("add new tag failed: %s", err)
 	}
-	err = c.addNewUser(c.userList, c.nodeInfo)
+	added, err := c.server.AddUsers(&core.AddUsersParams{})
+	log.Printf("[%s: %d] Added %d new users", c.nodeInfo.NodeType, c.nodeInfo.NodeId, added)
 	if err != nil {
 		return err
 	}

node/inbound.go

@@ -1,315 +0,0 @@
-package node
-
-import (
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/hex"
-	"fmt"
-	"github.com/Yuzuki616/V2bX/api/panel"
-	"github.com/Yuzuki616/V2bX/common/file"
-	"github.com/Yuzuki616/V2bX/conf"
-	"github.com/Yuzuki616/V2bX/node/lego"
-	"github.com/goccy/go-json"
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/core"
-	coreConf "github.com/xtls/xray-core/infra/conf"
-)
-
-// BuildInbound build Inbound config for different protocol
-func BuildInbound(config *conf.ControllerConfig, nodeInfo *panel.NodeInfo, tag string) (*core.InboundHandlerConfig, error) {
-	inbound := &coreConf.InboundDetourConfig{}
-	// Set network protocol
-	t := coreConf.TransportProtocol(nodeInfo.Network)
-	inbound.StreamSetting = &coreConf.StreamConfig{Network: &t}
-	var err error
-	switch nodeInfo.NodeType {
-	case "v2ray":
-		err = buildV2ray(config, nodeInfo, inbound)
-	case "trojan":
-		err = buildTrojan(config, nodeInfo, inbound)
-	case "shadowsocks":
-		err = buildShadowsocks(config, nodeInfo, inbound)
-	default:
-		return nil, fmt.Errorf("unsupported node type: %s, Only support: V2ray, Trojan, Shadowsocks", nodeInfo.NodeType)
-	}
-	if err != nil {
-		return nil, err
-	}
-	// Set server port
-	inbound.PortList = &coreConf.PortList{
-		Range: []coreConf.PortRange{{From: uint32(nodeInfo.ServerPort), To: uint32(nodeInfo.ServerPort)}},
-	}
-	// Set Listen IP address
-	ipAddress := net.ParseAddress(config.ListenIP)
-	inbound.ListenOn = &coreConf.Address{Address: ipAddress}
-	// Set SniffingConfig
-	sniffingConfig := &coreConf.SniffingConfig{
-		Enabled:      true,
-		DestOverride: &coreConf.StringList{"http", "tls"},
-	}
-	if config.DisableSniffing {
-		sniffingConfig.Enabled = false
-	}
-	inbound.SniffingConfig = sniffingConfig
-	if *inbound.StreamSetting.Network == "tcp" {
-		if inbound.StreamSetting.TCPSettings != nil {
-			inbound.StreamSetting.TCPSettings.AcceptProxyProtocol = config.EnableProxyProtocol
-		} else {
-			tcpSetting := &coreConf.TCPConfig{
-				AcceptProxyProtocol: config.EnableProxyProtocol,
-			} //Enable proxy protocol
-			inbound.StreamSetting.TCPSettings = tcpSetting
-		}
-	} else if *inbound.StreamSetting.Network == "ws" {
-		inbound.StreamSetting.WSSettings = &coreConf.WebSocketConfig{
-			AcceptProxyProtocol: config.EnableProxyProtocol} //Enable proxy protocol
-	}
-	// Set TLS and XTLS settings
-	if nodeInfo.Tls != 0 {
-		if config.CertConfig.CertMode != "none" {
-			// Normal tls
-			inbound.StreamSetting.Security = "tls"
-			certFile, keyFile, err := getCertFile(config.CertConfig)
-			if err != nil {
-				return nil, err
-			}
-			inbound.StreamSetting.TLSSettings = &coreConf.TLSConfig{
-				Certs: []*coreConf.TLSCertConfig{
-					{
-						CertFile:     certFile,
-						KeyFile:      keyFile,
-						OcspStapling: 3600,
-					},
-				},
-				RejectUnknownSNI: config.CertConfig.RejectUnknownSni,
-			}
-		} else if config.EnableReality {
-			// Reality
-			inbound.StreamSetting.Security = "reality"
-			d, err := json.Marshal(config.RealityConfig.Dest)
-			if err != nil {
-				return nil, fmt.Errorf("marshal reality dest error: %s", err)
-			}
-			inbound.StreamSetting.REALITYSettings = &coreConf.REALITYConfig{
-				Dest:         d,
-				Xver:         config.RealityConfig.Xver,
-				ServerNames:  config.RealityConfig.ServerNames,
-				PrivateKey:   config.RealityConfig.PrivateKey,
-				MinClientVer: config.RealityConfig.MinClientVer,
-				MaxClientVer: config.RealityConfig.MaxClientVer,
-				MaxTimeDiff:  config.RealityConfig.MaxTimeDiff,
-				ShortIds:     config.RealityConfig.ShortIds,
-			}
-		}
-	}
-	// Support ProxyProtocol for any transport protocol
-	if *inbound.StreamSetting.Network != "tcp" &&
-		*inbound.StreamSetting.Network != "ws" &&
-		config.EnableProxyProtocol {
-		sockoptConfig := &coreConf.SocketConfig{
-			AcceptProxyProtocol: config.EnableProxyProtocol,
-		} //Enable proxy protocol
-		inbound.StreamSetting.SocketSettings = sockoptConfig
-	}
-	inbound.Tag = tag
-	return inbound.Build()
-}
-
-func buildV2ray(config *conf.ControllerConfig, nodeInfo *panel.NodeInfo, inbound *coreConf.InboundDetourConfig) error {
-	if config.EnableVless {
-		//Set vless
-		inbound.Protocol = "vless"
-		if config.EnableFallback {
-			// Set fallback
-			fallbackConfigs, err := buildVlessFallbacks(config.FallBackConfigs)
-			if err != nil {
-				return err
-			}
-			s, err := json.Marshal(&coreConf.VLessInboundConfig{
-				Decryption: "none",
-				Fallbacks:  fallbackConfigs,
-			})
-			if err != nil {
-				return fmt.Errorf("marshal vless fallback config error: %s", err)
-			}
-			inbound.Settings = (*json.RawMessage)(&s)
-		} else {
-			var err error
-			s, err := json.Marshal(&coreConf.VLessInboundConfig{
-				Decryption: "none",
-			})
-			if err != nil {
-				return fmt.Errorf("marshal vless config error: %s", err)
-			}
-			inbound.Settings = (*json.RawMessage)(&s)
-		}
-	} else {
-		// Set vmess
-		inbound.Protocol = "vmess"
-		var err error
-		s, err := json.Marshal(&coreConf.VMessInboundConfig{})
-		if err != nil {
-			return fmt.Errorf("marshal vmess settings error: %s", err)
-		}
-		inbound.Settings = (*json.RawMessage)(&s)
-	}
-	if len(nodeInfo.NetworkSettings) == 0 {
-		return nil
-	}
-	switch nodeInfo.Network {
-	case "tcp":
-		err := json.Unmarshal(nodeInfo.NetworkSettings, &inbound.StreamSetting.TCPSettings)
-		if err != nil {
-			return fmt.Errorf("unmarshal tcp settings error: %s", err)
-		}
-	case "ws":
-		err := json.Unmarshal(nodeInfo.NetworkSettings, &inbound.StreamSetting.WSSettings)
-		if err != nil {
-			return fmt.Errorf("unmarshal ws settings error: %s", err)
-		}
-	case "grpc":
-		err := json.Unmarshal(nodeInfo.NetworkSettings, &inbound.StreamSetting.GRPCConfig)
-		if err != nil {
-			return fmt.Errorf("unmarshal grpc settings error: %s", err)
-		}
-	}
-	return nil
-}
-
-func buildTrojan(config *conf.ControllerConfig, nodeInfo *panel.NodeInfo, inbound *coreConf.InboundDetourConfig) error {
-	inbound.Protocol = "trojan"
-	if config.EnableFallback {
-		// Set fallback
-		fallbackConfigs, err := buildTrojanFallbacks(config.FallBackConfigs)
-		if err != nil {
-			return err
-		}
-		s, err := json.Marshal(&coreConf.TrojanServerConfig{
-			Fallbacks: fallbackConfigs,
-		})
-		inbound.Settings = (*json.RawMessage)(&s)
-		if err != nil {
-			return fmt.Errorf("marshal trojan fallback config error: %s", err)
-		}
-	} else {
-		s := []byte("{}")
-		inbound.Settings = (*json.RawMessage)(&s)
-	}
-	t := coreConf.TransportProtocol(nodeInfo.Network)
-	inbound.StreamSetting = &coreConf.StreamConfig{Network: &t}
-	return nil
-}
-
-func buildShadowsocks(config *conf.ControllerConfig, nodeInfo *panel.NodeInfo, inbound *coreConf.InboundDetourConfig) error {
-	inbound.Protocol = "shadowsocks"
-	settings := &coreConf.ShadowsocksServerConfig{
-		Cipher: nodeInfo.Cipher,
-	}
-	p := make([]byte, 32)
-	_, err := rand.Read(p)
-	if err != nil {
-		return fmt.Errorf("generate random password error: %s", err)
-	}
-	randomPasswd := hex.EncodeToString(p)
-	cipher := nodeInfo.Cipher
-	if nodeInfo.ServerKey != "" {
-		settings.Password = nodeInfo.ServerKey
-		randomPasswd = base64.StdEncoding.EncodeToString([]byte(randomPasswd))
-		cipher = ""
-	}
-	defaultSSuser := &coreConf.ShadowsocksUserConfig{
-		Cipher:   cipher,
-		Password: randomPasswd,
-	}
-	settings.Users = append(settings.Users, defaultSSuser)
-	settings.NetworkList = &coreConf.NetworkList{"tcp", "udp"}
-	settings.IVCheck = true
-	if config.DisableIVCheck {
-		settings.IVCheck = false
-	}
-	t := coreConf.TransportProtocol("tcp")
-	inbound.StreamSetting = &coreConf.StreamConfig{Network: &t}
-	s, err := json.Marshal(settings)
-	inbound.Settings = (*json.RawMessage)(&s)
-	if err != nil {
-		return fmt.Errorf("marshal shadowsocks settings error: %s", err)
-	}
-	return nil
-}
-
-func getCertFile(certConfig *conf.CertConfig) (certFile string, keyFile string, err error) {
-	if certConfig.CertFile == "" || certConfig.KeyFile == "" {
-		return "", "", fmt.Errorf("cert file path or key file path not exist")
-	}
-	switch certConfig.CertMode {
-	case "file":
-		return certConfig.CertFile, certConfig.KeyFile, nil
-	case "dns", "http":
-		if file.IsExist(certConfig.CertFile) && file.IsExist(certConfig.KeyFile) {
-			return certConfig.CertFile, certConfig.KeyFile, nil
-		}
-		l, err := lego.New(certConfig)
-		if err != nil {
-			return "", "", fmt.Errorf("create lego object error: %s", err)
-		}
-		err = l.CreateCert()
-		if err != nil {
-			return "", "", fmt.Errorf("create cert error: %s", err)
-		}
-		return certConfig.CertFile, certConfig.KeyFile, nil
-	}
-	return "", "", fmt.Errorf("unsupported certmode: %s", certConfig.CertMode)
-}
-
-func buildVlessFallbacks(fallbackConfigs []conf.FallBackConfig) ([]*coreConf.VLessInboundFallback, error) {
-	if fallbackConfigs == nil {
-		return nil, fmt.Errorf("you must provide FallBackConfigs")
-	}
-	vlessFallBacks := make([]*coreConf.VLessInboundFallback, len(fallbackConfigs))
-	for i, c := range fallbackConfigs {
-		if c.Dest == "" {
-			return nil, fmt.Errorf("dest is required for fallback fialed")
-		}
-		var dest json.RawMessage
-		dest, err := json.Marshal(c.Dest)
-		if err != nil {
-			return nil, fmt.Errorf("marshal dest %s config fialed: %s", dest, err)
-		}
-		vlessFallBacks[i] = &coreConf.VLessInboundFallback{
-			Name: c.SNI,
-			Alpn: c.Alpn,
-			Path: c.Path,
-			Dest: dest,
-			Xver: c.ProxyProtocolVer,
-		}
-	}
-	return vlessFallBacks, nil
-}
-
-func buildTrojanFallbacks(fallbackConfigs []conf.FallBackConfig) ([]*coreConf.TrojanInboundFallback, error) {
-	if fallbackConfigs == nil {
-		return nil, fmt.Errorf("you must provide FallBackConfigs")
-	}
-
-	trojanFallBacks := make([]*coreConf.TrojanInboundFallback, len(fallbackConfigs))
-	for i, c := range fallbackConfigs {
-
-		if c.Dest == "" {
-			return nil, fmt.Errorf("dest is required for fallback fialed")
-		}
-
-		var dest json.RawMessage
-		dest, err := json.Marshal(c.Dest)
-		if err != nil {
-			return nil, fmt.Errorf("marshal dest %s config fialed: %s", dest, err)
-		}
-		trojanFallBacks[i] = &coreConf.TrojanInboundFallback{
-			Name: c.SNI,
-			Alpn: c.Alpn,
-			Path: c.Path,
-			Dest: dest,
-			Xver: c.ProxyProtocolVer,
-		}
-	}
-	return trojanFallBacks, nil
-}

node/inbound_test.go

@@ -1,34 +0,0 @@
-package node_test
-
-import (
-	"github.com/Yuzuki616/V2bX/api/panel"
-	"github.com/Yuzuki616/V2bX/conf"
-	. "github.com/Yuzuki616/V2bX/node"
-	"testing"
-)
-
-func TestBuildV2ray(t *testing.T) {
-	nodeInfo := &panel.NodeInfo{
-		NodeType:        "v2ray",
-		NodeId:          1,
-		ServerPort:      1145,
-		Network:         "ws",
-		NetworkSettings: nil,
-		Host:            "test.test.tk",
-		ServerName:      "test.test.tk",
-	}
-	certConfig := &conf.CertConfig{
-		CertMode:   "none",
-		CertDomain: "test.test.tk",
-		Provider:   "alidns",
-		Email:      "test@gmail.com",
-	}
-	config := &conf.ControllerConfig{
-		ListenIP:   "0.0.0.0",
-		CertConfig: certConfig,
-	}
-	_, err := BuildInbound(config, nodeInfo, "11")
-	if err != nil {
-		t.Error(err)
-	}
-}

node/outbound.go

@@ -1,45 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"github.com/Yuzuki616/V2bX/api/panel"
-	conf2 "github.com/Yuzuki616/V2bX/conf"
-	"github.com/goccy/go-json"
-
-	"github.com/xtls/xray-core/common/net"
-	"github.com/xtls/xray-core/core"
-	"github.com/xtls/xray-core/infra/conf"
-)
-
-// buildOutbound build freedom outbund config for addoutbound
-func buildOutbound(config *conf2.ControllerConfig, nodeInfo *panel.NodeInfo, tag string) (*core.OutboundHandlerConfig, error) {
-	outboundDetourConfig := &conf.OutboundDetourConfig{}
-	outboundDetourConfig.Protocol = "freedom"
-	outboundDetourConfig.Tag = tag
-
-	// Build Send IP address
-	if config.SendIP != "" {
-		ipAddress := net.ParseAddress(config.SendIP)
-		outboundDetourConfig.SendThrough = &conf.Address{Address: ipAddress}
-	}
-
-	// Freedom Protocol setting
-	var domainStrategy = "Asis"
-	if config.EnableDNS {
-		if config.DNSType != "" {
-			domainStrategy = config.DNSType
-		} else {
-			domainStrategy = "UseIP"
-		}
-	}
-	proxySetting := &conf.FreedomConfig{
-		DomainStrategy: domainStrategy,
-	}
-	var setting json.RawMessage
-	setting, err := json.Marshal(proxySetting)
-	if err != nil {
-		return nil, fmt.Errorf("marshal proxy %s config fialed: %s", nodeInfo.NodeType, err)
-	}
-	outboundDetourConfig.Settings = &setting
-	return outboundDetourConfig.Build()
-}

node/task.go

@@ -3,6 +3,8 @@ package node
 import (
 	"fmt"
 	"github.com/Yuzuki616/V2bX/api/panel"
+	"github.com/Yuzuki616/V2bX/common/builder"
+	"github.com/Yuzuki616/V2bX/core"
 	"github.com/Yuzuki616/V2bX/limiter"
 	"github.com/Yuzuki616/V2bX/node/lego"
 	"github.com/xtls/xray-core/common/task"
@@ -61,7 +63,7 @@ func (c *Controller) nodeInfoMonitor() (err error) {
 	if newNodeInfo != nil {
 		// Remove old tag
 		oldTag := c.Tag
-		err := c.removeOldNode(oldTag)
+		err := c.server.DelNode(oldTag)
 		if err != nil {
 			log.Print(err)
 			return nil
@@ -71,7 +73,7 @@ func (c *Controller) nodeInfoMonitor() (err error) {
 		// Add new tag
 		c.nodeInfo = newNodeInfo
 		c.Tag = c.buildNodeTag()
-		err = c.addNewNode(newNodeInfo)
+		err = c.server.AddNode(c.Tag, newNodeInfo, c.ControllerConfig)
 		if err != nil {
 			log.Print(err)
 			return nil
@@ -88,7 +90,10 @@ func (c *Controller) nodeInfoMonitor() (err error) {
 		c.userList = newUserInfo
 		// Add new Limiter
 		l := limiter.AddLimiter(c.Tag, &c.LimitConfig, newUserInfo)
-		err = c.addNewUser(newUserInfo, newNodeInfo)
+		_, err = c.server.AddUsers(&core.AddUsersParams{
+			Tag:    c.Tag,
+			Config: c.ControllerConfig,
+		})
 		if err != nil {
 			log.Print(err)
 			return nil
@@ -132,7 +137,12 @@ func (c *Controller) nodeInfoMonitor() (err error) {
 			}
 		}
 		if len(added) > 0 {
-			err = c.addNewUser(added, c.nodeInfo)
+			_, err := c.server.AddUsers(&core.AddUsersParams{
+				Tag:      c.Tag,
+				Config:   c.ControllerConfig,
+				UserInfo: added,
+				NodeInfo: c.nodeInfo,
+			})
 			if err != nil {
 				log.Print(err)
 			}
@@ -151,38 +161,6 @@ func (c *Controller) nodeInfoMonitor() (err error) {
 	return nil
 }
 
-func (c *Controller) removeOldNode(oldTag string) (err error) {
-	err = c.server.RemoveInbound(oldTag)
-	if err != nil {
-		return err
-	}
-	err = c.server.RemoveOutbound(oldTag)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (c *Controller) addNewNode(newNodeInfo *panel.NodeInfo) (err error) {
-	inboundConfig, err := BuildInbound(c.ControllerConfig, newNodeInfo, c.Tag)
-	if err != nil {
-		return fmt.Errorf("build inbound error: %s", err)
-	}
-	err = c.server.AddInbound(inboundConfig)
-	if err != nil {
-		return fmt.Errorf("add inbound error: %s", err)
-	}
-	outBoundConfig, err := buildOutbound(c.ControllerConfig, newNodeInfo, c.Tag)
-	if err != nil {
-		return fmt.Errorf("build outbound error: %s", err)
-	}
-	err = c.server.AddOutbound(outBoundConfig)
-	if err != nil {
-		return fmt.Errorf("add outbound error: %s", err)
-	}
-	return nil
-}
-
 func compareUserList(old, new []panel.UserInfo) (deleted, added []panel.UserInfo) {
 	tmp := map[string]struct{}{}
 	tmp2 := map[string]struct{}{}
@@ -215,7 +193,7 @@ func (c *Controller) reportUserTraffic() (err error) {
 	// Get User traffic
 	userTraffic := make([]panel.UserTraffic, 0)
 	for i := range c.userList {
-		up, down := c.server.GetUserTraffic(c.buildUserTag(&(c.userList)[i]), true)
+		up, down := c.server.GetUserTraffic(builder.BuildUserTag(c.Tag, &c.userList[i]), true)
 		if up > 0 || down > 0 {
 			if c.LimitConfig.EnableDynamicSpeedLimit {
 				c.userList[i].Traffic += up + down

node/user.go

@@ -1,154 +0,0 @@
-package node
-
-import (
-	"encoding/base64"
-	"fmt"
-	"github.com/Yuzuki616/V2bX/api/panel"
-	"github.com/xtls/xray-core/common/protocol"
-	"github.com/xtls/xray-core/common/serial"
-	"github.com/xtls/xray-core/infra/conf"
-	"github.com/xtls/xray-core/proxy/shadowsocks"
-	"github.com/xtls/xray-core/proxy/shadowsocks_2022"
-	"github.com/xtls/xray-core/proxy/trojan"
-	"github.com/xtls/xray-core/proxy/vless"
-	"log"
-	"strings"
-)
-
-const xtlsFLow = "xtls-rprx-vision"
-
-func (c *Controller) addNewUser(userInfo []panel.UserInfo, nodeInfo *panel.NodeInfo) (err error) {
-	users := make([]*protocol.User, 0, len(userInfo))
-	switch nodeInfo.NodeType {
-	case "v2ray":
-		if c.EnableVless {
-			users = c.buildVlessUsers(userInfo)
-		} else {
-			users = c.buildVmessUsers(userInfo)
-		}
-	case "trojan":
-		users = c.buildTrojanUsers(userInfo)
-	case "shadowsocks":
-		users = c.buildSSUsers(userInfo, getCipherFromString(nodeInfo.Cipher))
-	default:
-		return fmt.Errorf("unsupported node type: %s", nodeInfo.NodeType)
-	}
-	err = c.server.AddUsers(users, c.Tag)
-	if err != nil {
-		return fmt.Errorf("add users error: %s", err)
-	}
-	log.Printf("[%s: %d] Added %d new users", c.nodeInfo.NodeType, c.nodeInfo.NodeId, len(userInfo))
-	return nil
-}
-
-func (c *Controller) buildVmessUsers(userInfo []panel.UserInfo) (users []*protocol.User) {
-	users = make([]*protocol.User, len(userInfo))
-	for i, user := range userInfo {
-		users[i] = c.buildVmessUser(&user, 0)
-	}
-	return users
-}
-
-func (c *Controller) buildVmessUser(userInfo *panel.UserInfo, serverAlterID uint16) (user *protocol.User) {
-	vmessAccount := &conf.VMessAccount{
-		ID:       userInfo.Uuid,
-		AlterIds: serverAlterID,
-		Security: "auto",
-	}
-	return &protocol.User{
-		Level:   0,
-		Email:   c.buildUserTag(userInfo), // Uid: InboundTag|email|uid
-		Account: serial.ToTypedMessage(vmessAccount.Build()),
-	}
-}
-
-func (c *Controller) buildVlessUsers(userInfo []panel.UserInfo) (users []*protocol.User) {
-	users = make([]*protocol.User, len(userInfo))
-	for i := range userInfo {
-		users[i] = c.buildVlessUser(&(userInfo)[i])
-	}
-	return users
-}
-
-func (c *Controller) buildVlessUser(userInfo *panel.UserInfo) (user *protocol.User) {
-	vlessAccount := &vless.Account{
-		Id: userInfo.Uuid,
-	}
-	if c.EnableXtls {
-		vlessAccount.Flow = xtlsFLow
-	}
-	return &protocol.User{
-		Level:   0,
-		Email:   c.buildUserTag(userInfo),
-		Account: serial.ToTypedMessage(vlessAccount),
-	}
-}
-
-func (c *Controller) buildTrojanUsers(userInfo []panel.UserInfo) (users []*protocol.User) {
-	users = make([]*protocol.User, len(userInfo))
-	for i := range userInfo {
-		users[i] = c.buildTrojanUser(&(userInfo)[i])
-	}
-	return users
-}
-
-func (c *Controller) buildTrojanUser(userInfo *panel.UserInfo) (user *protocol.User) {
-	trojanAccount := &trojan.Account{
-		Password: userInfo.Uuid,
-	}
-	return &protocol.User{
-		Level:   0,
-		Email:   c.buildUserTag(userInfo),
-		Account: serial.ToTypedMessage(trojanAccount),
-	}
-}
-
-func getCipherFromString(c string) shadowsocks.CipherType {
-	switch strings.ToLower(c) {
-	case "aes-128-gcm", "aead_aes_128_gcm":
-		return shadowsocks.CipherType_AES_128_GCM
-	case "aes-256-gcm", "aead_aes_256_gcm":
-		return shadowsocks.CipherType_AES_256_GCM
-	case "chacha20-poly1305", "aead_chacha20_poly1305", "chacha20-ietf-poly1305":
-		return shadowsocks.CipherType_CHACHA20_POLY1305
-	case "none", "plain":
-		return shadowsocks.CipherType_NONE
-	default:
-		return shadowsocks.CipherType_UNKNOWN
-	}
-}
-
-func (c *Controller) buildSSUsers(userInfo []panel.UserInfo, cypher shadowsocks.CipherType) (users []*protocol.User) {
-	users = make([]*protocol.User, len(userInfo))
-	for i := range userInfo {
-		users[i] = c.buildSSUser(&(userInfo)[i], cypher)
-	}
-	return users
-}
-
-func (c *Controller) buildSSUser(userInfo *panel.UserInfo, cypher shadowsocks.CipherType) (user *protocol.User) {
-	if c.nodeInfo.ServerKey == "" {
-		ssAccount := &shadowsocks.Account{
-			Password:   userInfo.Uuid,
-			CipherType: cypher,
-		}
-		return &protocol.User{
-			Level:   0,
-			Email:   c.buildUserTag(userInfo),
-			Account: serial.ToTypedMessage(ssAccount),
-		}
-	} else {
-		ssAccount := &shadowsocks_2022.User{
-			Key: base64.StdEncoding.EncodeToString([]byte(userInfo.Uuid[:32])),
-		}
-		return &protocol.User{
-			Level:   0,
-			Email:   c.buildUserTag(userInfo),
-			Account: serial.ToTypedMessage(ssAccount),
-		}
-	}
-}
-
-func (c *Controller) buildUserTag(user *panel.UserInfo) string {
-	return fmt.Sprintf("%s|%s|%d", c.Tag, user.Uuid, user.Id)
-}