remove unused sturct;

add new user popup

pkg/server/controller/controller.go

@@ -10,7 +10,6 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"sort"
 	"strconv"
 	"strings"
 )
@@ -76,62 +75,25 @@ func (c *HandleController) MakeLangFunc() func(context *gin.Context) {
 	}
 }
 
-func (c *HandleController) MakeQueryTokensFunc() func(context *gin.Context) {
+func (c *HandleController) MakeAddProxyFunc() func(context *gin.Context) {
 	return func(context *gin.Context) {
+		proxyType, exist := context.GetQuery("type")
+		if !exist {
 
-		search := TokenSearch{}
-		search.Limit = 0
-
-		err := context.BindQuery(&search)
-		if err != nil {
-			return
 		}
 
-		var tokenList []TokenInfo
-		for _, tokenInfo := range c.Tokens {
-			tokenList = append(tokenList, tokenInfo)
-		}
-		sort.Slice(tokenList, func(i, j int) bool {
-			return strings.Compare(tokenList[i].User, tokenList[j].User) < 0
-		})
+		proxy, exist := proxyConfTypeMap[proxyType]
+		if !exist {
 
-		var filtered []TokenInfo
-		for _, tokenInfo := range tokenList {
-			if filter(tokenInfo, search.TokenInfo) {
-				filtered = append(filtered, tokenInfo)
-			}
-		}
-		if filtered == nil {
-			filtered = []TokenInfo{}
 		}
 
-		count := len(filtered)
-		if search.Limit > 0 {
-			start := max((search.Page-1)*search.Limit, 0)
-			end := min(search.Page*search.Limit, len(filtered))
-			filtered = filtered[start:end]
-		}
-
-		context.JSON(http.StatusOK, &TokenResponse{
-			Code:  0,
-			Msg:   "query Tokens success",
-			Count: count,
-			Data:  filtered,
-		})
-	}
-}
-
-func (c *HandleController) MakeAddTokenFunc() func(context *gin.Context) {
-	return func(context *gin.Context) {
-		info := TokenInfo{
-			Enable: true,
-		}
 		response := OperationResponse{
 			Success: true,
 			Code:    Success,
 			Message: "user add success",
 		}
-		err := context.BindJSON(&info)
+
+		err := context.BindJSON(&proxy)
 		if err != nil {
 			response.Success = false
 			response.Code = ParamError
@@ -141,21 +103,7 @@ func (c *HandleController) MakeAddTokenFunc() func(context *gin.Context) {
 			return
 		}
 
-		result := c.verifyToken(info, TOKEN_ADD)
-
-		if !result.Success {
-			context.JSON(http.StatusOK, &result)
-			return
-		}
-
-		info.Comment = cleanString(info.Comment)
-		info.Ports = cleanPorts(info.Ports)
-		info.Domains = cleanStrings(info.Domains)
-		info.Subdomains = cleanStrings(info.Subdomains)
-
-		c.Tokens[info.User] = info
-
-		err = c.saveToken()
+		err = c.reloadFrpc()
 		if err != nil {
 			response.Success = false
 			response.Code = SaveError
@@ -169,15 +117,25 @@ func (c *HandleController) MakeAddTokenFunc() func(context *gin.Context) {
 	}
 }
 
-func (c *HandleController) MakeUpdateTokensFunc() func(context *gin.Context) {
+func (c *HandleController) MakeUpdateProxyFunc() func(context *gin.Context) {
 	return func(context *gin.Context) {
+		proxyType, exist := context.GetQuery("type")
+		if !exist {
+
+		}
+
+		proxy, exist := proxyConfTypeMap[proxyType]
+		if !exist {
+
+		}
+
 		response := OperationResponse{
 			Success: true,
 			Code:    Success,
 			Message: "user update success",
 		}
-		update := TokenUpdate{}
-		err := context.BindJSON(&update)
+
+		err := context.BindJSON(&proxy)
 		if err != nil {
 			response.Success = false
 			response.Code = ParamError
@@ -187,33 +145,7 @@ func (c *HandleController) MakeUpdateTokensFunc() func(context *gin.Context) {
 			return
 		}
 
-		before := update.Before
-		after := update.After
-
-		if before.User != after.User {
-			response.Success = false
-			response.Code = ParamError
-			response.Message = fmt.Sprintf("update failed, user should be same : before -> %v, after -> %v", before.User, after.User)
-			log.Printf(response.Message)
-			context.JSON(http.StatusOK, &response)
-			return
-		}
-
-		result := c.verifyToken(after, TOKEN_UPDATE)
-
-		if !result.Success {
-			context.JSON(http.StatusOK, &result)
-			return
-		}
-
-		after.Comment = cleanString(after.Comment)
-		after.Ports = cleanPorts(after.Ports)
-		after.Domains = cleanStrings(after.Domains)
-		after.Subdomains = cleanStrings(after.Subdomains)
-
-		c.Tokens[after.User] = after
-
-		err = c.saveToken()
+		err = c.reloadFrpc()
 		if err != nil {
 			response.Success = false
 			response.Code = SaveError
@@ -227,15 +159,25 @@ func (c *HandleController) MakeUpdateTokensFunc() func(context *gin.Context) {
 	}
 }
 
-func (c *HandleController) MakeRemoveTokensFunc() func(context *gin.Context) {
+func (c *HandleController) MakeRemoveProxyFunc() func(context *gin.Context) {
 	return func(context *gin.Context) {
+		proxyType, exist := context.GetQuery("type")
+		if !exist {
+
+		}
+
+		proxy, exist := proxyConfTypeMap[proxyType]
+		if !exist {
+
+		}
+
 		response := OperationResponse{
 			Success: true,
 			Code:    Success,
-			Message: "user remove success",
+			Message: "proxy remove success",
 		}
-		remove := TokenRemove{}
-		err := context.BindJSON(&remove)
+
+		err := context.BindJSON(&proxy)
 		if err != nil {
 			response.Success = false
 			response.Code = ParamError
@@ -245,20 +187,7 @@ func (c *HandleController) MakeRemoveTokensFunc() func(context *gin.Context) {
 			return
 		}
 
-		for _, user := range remove.Users {
-			result := c.verifyToken(user, TOKEN_REMOVE)
-
-			if !result.Success {
-				context.JSON(http.StatusOK, &result)
-				return
-			}
-		}
-
-		for _, user := range remove.Users {
-			delete(c.Tokens, user.User)
-		}
-
-		err = c.saveToken()
+		err = c.reloadFrpc()
 		if err != nil {
 			response.Success = false
 			response.Code = SaveError
@@ -272,102 +201,6 @@ func (c *HandleController) MakeRemoveTokensFunc() func(context *gin.Context) {
 	}
 }
 
-func (c *HandleController) MakeDisableTokensFunc() func(context *gin.Context) {
-	return func(context *gin.Context) {
-		response := OperationResponse{
-			Success: true,
-			Code:    Success,
-			Message: "remove success",
-		}
-		disable := TokenDisable{}
-		err := context.BindJSON(&disable)
-		if err != nil {
-			response.Success = false
-			response.Code = ParamError
-			response.Message = fmt.Sprintf("disable failed, param error : %v", err)
-			log.Printf(response.Message)
-			context.JSON(http.StatusOK, &response)
-			return
-		}
-
-		for _, user := range disable.Users {
-			result := c.verifyToken(user, TOKEN_DISABLE)
-
-			if !result.Success {
-				context.JSON(http.StatusOK, &result)
-				return
-			}
-		}
-
-		for _, user := range disable.Users {
-			token := c.Tokens[user.User]
-			token.Enable = false
-			c.Tokens[user.User] = token
-		}
-
-		err = c.saveToken()
-
-		if err != nil {
-			response.Success = false
-			response.Code = SaveError
-			response.Message = fmt.Sprintf("disable failed, error : %v", err)
-			log.Printf(response.Message)
-			context.JSON(http.StatusOK, &response)
-			return
-		}
-
-		context.JSON(http.StatusOK, &response)
-	}
-}
-
-func (c *HandleController) MakeEnableTokensFunc() func(context *gin.Context) {
-	return func(context *gin.Context) {
-		response := OperationResponse{
-			Success: true,
-			Code:    Success,
-			Message: "remove success",
-		}
-		enable := TokenEnable{}
-		err := context.BindJSON(&enable)
-		if err != nil {
-			response.Success = false
-			response.Code = ParamError
-			response.Message = fmt.Sprintf("enable failed, param error : %v", err)
-			log.Printf(response.Message)
-			context.JSON(http.StatusOK, &response)
-			return
-		}
-
-		for _, user := range enable.Users {
-			result := c.verifyToken(user, TOKEN_ENABLE)
-
-			if !result.Success {
-				context.JSON(http.StatusOK, &result)
-				return
-			}
-		}
-
-		for _, user := range enable.Users {
-			token := c.Tokens[user.User]
-			token.Enable = true
-			c.Tokens[user.User] = token
-		}
-
-		err = c.saveToken()
-
-		if err != nil {
-			log.Printf("enable failed, error : %v", err)
-			response.Success = false
-			response.Code = SaveError
-			response.Message = "enable failed"
-			context.JSON(http.StatusOK, &response)
-			return
-		}
-
-		context.JSON(http.StatusOK, &response)
-	}
-}
-
 func (c *HandleController) MakeProxyFunc() func(context *gin.Context) {
 	return func(context *gin.Context) {
 		var client *http.Client

pkg/server/controller/handler.go

@@ -1,193 +0,0 @@
-package controller
-
-import (
-	"fmt"
-	plugin "github.com/fatedier/frp/pkg/plugin/server"
-	"log"
-	"strconv"
-	"strings"
-)
-
-func (c *HandleController) HandleLogin(content *plugin.LoginContent) plugin.Response {
-	token := content.Metas["token"]
-	user := content.User
-	return c.JudgeToken(user, token)
-}
-
-func (c *HandleController) HandleNewProxy(content *plugin.NewProxyContent) plugin.Response {
-	token := content.User.Metas["token"]
-	user := content.User.User
-	judgeToken := c.JudgeToken(user, token)
-	if judgeToken.Reject {
-		return judgeToken
-	}
-	return c.JudgePort(content)
-}
-
-func (c *HandleController) HandlePing(content *plugin.PingContent) plugin.Response {
-	token := content.User.Metas["token"]
-	user := content.User.User
-	return c.JudgeToken(user, token)
-}
-
-func (c *HandleController) HandleNewWorkConn(content *plugin.NewWorkConnContent) plugin.Response {
-	token := content.User.Metas["token"]
-	user := content.User.User
-	return c.JudgeToken(user, token)
-}
-
-func (c *HandleController) HandleNewUserConn(content *plugin.NewUserConnContent) plugin.Response {
-	token := content.User.Metas["token"]
-	user := content.User.User
-	return c.JudgeToken(user, token)
-}
-
-func (c *HandleController) JudgeToken(user string, token string) plugin.Response {
-	var res plugin.Response
-	if len(c.Tokens) == 0 {
-		res.Unchange = true
-	} else if user == "" || token == "" {
-		res.Reject = true
-		res.RejectReason = "user or meta token can not be empty"
-	} else if info, exist := c.Tokens[user]; exist {
-		if !info.Enable {
-			res.Reject = true
-			res.RejectReason = fmt.Sprintf("user [%s] is disabled", user)
-		} else {
-			if info.Token != token {
-				res.Reject = true
-				res.RejectReason = fmt.Sprintf("invalid meta token for user [%s]", user)
-			} else {
-				res.Unchange = true
-			}
-		}
-	} else {
-		res.Reject = true
-		res.RejectReason = fmt.Sprintf("user [%s] not exist", user)
-	}
-
-	return res
-}
-
-func (c *HandleController) JudgePort(content *plugin.NewProxyContent) plugin.Response {
-	var res plugin.Response
-	var portErr error
-	var reject = false
-	supportProxyTypes := []string{
-		"tcp", "tcpmux", "udp", "http", "https",
-	}
-	proxyType := content.ProxyType
-	if stringContains(proxyType, supportProxyTypes) {
-		log.Printf("proxy type [%v] not support, plugin do nothing", proxyType)
-		res.Unchange = true
-		return res
-	}
-
-	user := content.User.User
-	userPort := content.RemotePort
-	userDomains := content.CustomDomains
-	userSubdomain := content.SubDomain
-
-	portAllowed := true
-	if proxyType == "tcp" || proxyType == "udp" {
-		portAllowed = false
-		if token, exist := c.Tokens[user]; exist {
-			for _, port := range token.Ports {
-				if str, ok := port.(string); ok {
-					if strings.Contains(str, "-") {
-						allowedRanges := strings.Split(str, "-")
-						if len(allowedRanges) != 2 {
-							portErr = fmt.Errorf("user [%v] port range [%v] format error", user, port)
-							break
-						}
-						start, err := strconv.Atoi(trimString(allowedRanges[0]))
-						if err != nil {
-							portErr = fmt.Errorf("user [%v] port rang [%v] start port [%v] is not a number", user, port, allowedRanges[0])
-							break
-						}
-						end, err := strconv.Atoi(trimString(allowedRanges[1]))
-						if err != nil {
-							portErr = fmt.Errorf("user [%v] port rang [%v] end port [%v] is not a number", user, port, allowedRanges[0])
-							break
-						}
-						if max(userPort, start) == userPort && min(userPort, end) == userPort {
-							portAllowed = true
-							break
-						}
-					} else {
-						allowed, err := strconv.Atoi(str)
-						if err != nil {
-							portErr = fmt.Errorf("user [%v] allowed port [%v] is not a number", user, port)
-						}
-						if allowed == userPort {
-							portAllowed = true
-							break
-						}
-					}
-				} else {
-					allowed := port
-					if allowed == userPort {
-						portAllowed = true
-						break
-					}
-				}
-
-			}
-		} else {
-			portAllowed = true
-		}
-	}
-	if !portAllowed {
-		if portErr == nil {
-			portErr = fmt.Errorf("user [%v] port [%v] is not allowed", user, userPort)
-		}
-		reject = true
-	}
-
-	domainAllowed := true
-	if proxyType == "http" || proxyType == "https" || proxyType == "tcpmux" {
-		if portAllowed {
-			if token, exist := c.Tokens[user]; exist {
-				for _, userDomain := range userDomains {
-					if stringContains(userDomain, token.Domains) {
-						domainAllowed = false
-						break
-					}
-				}
-			}
-			if !domainAllowed {
-				portErr = fmt.Errorf("user [%v] domain [%v] is not allowed", user, strings.Join(userDomains, ","))
-				reject = true
-			}
-		}
-	}
-
-	subdomainAllowed := true
-	if proxyType == "http" || proxyType == "https" {
-		subdomainAllowed = false
-		if portAllowed && domainAllowed {
-			if token, exist := c.Tokens[user]; exist {
-				for _, subdomain := range token.Subdomains {
-					if subdomain == userSubdomain {
-						subdomainAllowed = true
-						break
-					}
-				}
-			} else {
-				subdomainAllowed = true
-			}
-			if !subdomainAllowed {
-				portErr = fmt.Errorf("user [%v] subdomain [%v] is not allowed", user, userSubdomain)
-				reject = true
-			}
-		}
-	}
-
-	if reject {
-		res.Reject = true
-		res.RejectReason = portErr.Error()
-	} else {
-		res.Unchange = true
-	}
-	return res
-}

pkg/server/controller/register.go

@@ -8,7 +8,6 @@ import (
 
 type HandleController struct {
 	CommonInfo CommonInfo
-	Tokens     map[string]TokenInfo
 	Version    string
 	ConfigFile string
 	TokensFile string
@@ -40,11 +39,8 @@ func (c *HandleController) Register(rootDir string, engine *gin.Engine) {
 		group = engine.Group("/")
 	}
 	group.GET("/", c.MakeIndexFunc())
-	group.GET("/tokens", c.MakeQueryTokensFunc())
-	group.POST("/add", c.MakeAddTokenFunc())
-	group.POST("/update", c.MakeUpdateTokensFunc())
-	group.POST("/remove", c.MakeRemoveTokensFunc())
-	group.POST("/disable", c.MakeDisableTokensFunc())
-	group.POST("/enable", c.MakeEnableTokensFunc())
+	group.POST("/add", c.MakeAddProxyFunc())
+	group.POST("/update", c.MakeUpdateProxyFunc())
+	group.POST("/remove", c.MakeRemoveProxyFunc())
 	group.GET("/proxy/*serverApi", c.MakeProxyFunc())
 }

pkg/server/controller/utils.go

@@ -1,189 +1,13 @@
 package controller
 
 import (
-	"fmt"
-	"github.com/BurntSushi/toml"
-	"log"
-	"os"
 	"strings"
 )
 
-func filter(main TokenInfo, sub TokenInfo) bool {
-	replaceSpaceUser := trimAllSpace.ReplaceAllString(sub.User, "")
-	if len(replaceSpaceUser) != 0 {
-		if !strings.Contains(main.User, replaceSpaceUser) {
-			return false
-		}
-	}
-
-	replaceSpaceToken := trimAllSpace.ReplaceAllString(sub.Token, "")
-	if len(replaceSpaceToken) != 0 {
-		if !strings.Contains(main.Token, replaceSpaceToken) {
-			return false
-		}
-	}
-
-	replaceSpaceComment := trimAllSpace.ReplaceAllString(sub.Comment, "")
-	if len(replaceSpaceComment) != 0 {
-		if !strings.Contains(main.Comment, replaceSpaceComment) {
-			return false
-		}
-	}
-	return true
-}
-
 func trimString(str string) string {
 	return strings.TrimSpace(str)
 }
 
-func (c *HandleController) verifyToken(token TokenInfo, operate int) OperationResponse {
-	response := OperationResponse{
-		Success: true,
-		Code:    Success,
-		Message: "operate success",
-	}
-
-	var (
-		validateExist      = false
-		validateNotExist   = false
-		validateUser       = false
-		validateToken      = false
-		validateComment    = false
-		validatePorts      = false
-		validateDomains    = false
-		validateSubdomains = false
-	)
-
-	if operate == TOKEN_ADD {
-		validateExist = true
-		validateUser = true
-		validateToken = true
-		validateComment = true
-		validatePorts = true
-		validateDomains = true
-		validateSubdomains = true
-	} else if operate == TOKEN_UPDATE {
-		validateNotExist = true
-		validateUser = true
-		validateToken = true
-		validateComment = true
-		validatePorts = true
-		validateDomains = true
-		validateSubdomains = true
-	} else if operate == TOKEN_ENABLE || operate == TOKEN_DISABLE || operate == TOKEN_REMOVE {
-		validateNotExist = true
-	}
-
-	if validateUser && !userFormat.MatchString(token.User) {
-		response.Success = false
-		response.Code = UserFormatError
-		response.Message = fmt.Sprintf("operate failed, user [%s] format error", token.User)
-		log.Printf(response.Message)
-		return response
-	}
-
-	if validateExist {
-		if _, exist := c.Tokens[token.User]; exist {
-			response.Success = false
-			response.Code = UserExist
-			response.Message = fmt.Sprintf("operate failed, user [%s] exist ", token.User)
-			log.Printf(response.Message)
-			return response
-		}
-	}
-
-	if validateNotExist {
-		if _, exist := c.Tokens[token.User]; !exist {
-			response.Success = false
-			response.Code = UserNotExist
-			response.Message = fmt.Sprintf("operate failed, user [%s] not exist ", token.User)
-			log.Printf(response.Message)
-			return response
-		}
-	}
-
-	if validateToken && !tokenFormat.MatchString(token.Token) {
-		response.Success = false
-		response.Code = TokenFormatError
-		response.Message = fmt.Sprintf("operate failed, token [%s] format error", token.Token)
-		log.Printf(response.Message)
-		return response
-	}
-
-	trimmedComment := trimString(token.Comment)
-	if validateComment && trimmedComment != "" && commentFormat.MatchString(trimmedComment) {
-		response.Success = false
-		response.Code = CommentFormatError
-		response.Message = fmt.Sprintf("operate failed, comment [%s] format error", token.Comment)
-		log.Printf(response.Message)
-		return response
-	}
-
-	if validatePorts {
-		for _, port := range token.Ports {
-			if str, ok := port.(string); ok {
-				trimmedPort := trimString(str)
-				if trimmedPort != "" && !portsFormatSingle.MatchString(trimmedPort) && !portsFormatRange.MatchString(trimmedPort) {
-					response.Success = false
-					response.Code = PortsFormatError
-					response.Message = fmt.Sprintf("operate failed, ports [%v] format error", token.Ports)
-					log.Printf(response.Message)
-					return response
-				}
-			}
-		}
-	}
-
-	if validateDomains {
-		for _, domain := range token.Domains {
-			trimmedDomain := trimString(domain)
-			if trimmedDomain != "" && !domainFormat.MatchString(trimmedDomain) {
-				response.Success = false
-				response.Code = DomainsFormatError
-				response.Message = fmt.Sprintf("operate failed, domains [%v] format error", token.Domains)
-				log.Printf(response.Message)
-				return response
-			}
-		}
-	}
-
-	if validateSubdomains {
-		for _, subdomain := range token.Subdomains {
-			trimmedSubdomain := trimString(subdomain)
-			if trimmedSubdomain != "" && !subdomainFormat.MatchString(trimmedSubdomain) {
-				response.Success = false
-				response.Code = SubdomainsFormatError
-				response.Message = fmt.Sprintf("operate failed, subdomains [%v] format error", token.Subdomains)
-				log.Printf(response.Message)
-				return response
-			}
-		}
-	}
-
-	return response
-}
-
-func cleanPorts(ports []any) []any {
-	cleanedPorts := make([]any, len(ports))
-	for i, port := range ports {
-		if str, ok := port.(string); ok {
-			cleanedPorts[i] = cleanString(str)
-		} else {
-			//float64, for JSON numbers
-			cleanedPorts[i] = int(port.(float64))
-		}
-	}
-	return cleanedPorts
-}
-
-func cleanStrings(originalStrings []string) []string {
-	cleanedStrings := make([]string, len(originalStrings))
-	for i, str := range originalStrings {
-		cleanedStrings[i] = cleanString(str)
-	}
-	return cleanedStrings
-}
-
 func cleanString(originalString string) string {
 	return trimString(originalString)
 }
@@ -197,26 +21,6 @@ func stringContains(element string, data []string) bool {
 	return false
 }
 
-func tokensList(tokens map[string]TokenInfo) Tokens {
-	return Tokens{
-		tokens,
-	}
-}
-
-func (c *HandleController) saveToken() error {
-	tokenFile, err := os.Create(c.TokensFile)
-	if err != nil {
-		log.Printf("error to crate file %v: %v", c.TokensFile, err)
-	}
-
-	encoder := toml.NewEncoder(tokenFile)
-	encoder.Indent = "    "
-	if err = encoder.Encode(tokensList(c.Tokens)); err != nil {
-		log.Printf("error to encode tokens: %v", err)
-	}
-	if err = tokenFile.Close(); err != nil {
-		log.Printf("error to close file %v: %v", c.TokensFile, err)
-	}
-
-	return err
+func (c *HandleController) reloadFrpc() error {
+	return nil
 }

pkg/server/controller/variables.go

@@ -1,30 +1,22 @@
 package controller
 
 import (
-	"regexp"
+	"github.com/fatedier/frp/pkg/config"
+	"github.com/fatedier/frp/pkg/consts"
+	"reflect"
 )
 
 const (
 	Success int = iota
 	ParamError
-	UserExist
-	UserNotExist
 	SaveError
-	UserFormatError
-	TokenFormatError
-	CommentFormatError
-	PortsFormatError
-	DomainsFormatError
-	SubdomainsFormatError
 	FrpServerError
 )
 
 const (
-	TOKEN_ADD int = iota
-	TOKEN_UPDATE
-	TOKEN_REMOVE
-	TOKEN_ENABLE
-	TOKEN_DISABLE
+	ProxyAdd int = iota
+	ProxyUpdate
+	ProxyRemove
 )
 
 const (
@@ -37,18 +29,19 @@ const (
 )
 
 var (
-	userFormat        = regexp.MustCompile("^\\w+$")
-	tokenFormat       = regexp.MustCompile("^[\\w!@#$%^&*()]+$")
-	commentFormat     = regexp.MustCompile("[\\n\\t\\r]")
-	portsFormatSingle = regexp.MustCompile("^\\s*\\d{1,5}\\s*$")
-	portsFormatRange  = regexp.MustCompile("^\\s*\\d{1,5}\\s*-\\s*\\d{1,5}\\s*$")
-	domainFormat      = regexp.MustCompile("^([a-zA-Z0-9]+(-[a-zA-Z0-9]+)*\\.)+[a-zA-Z]{2,}$")
-	subdomainFormat   = regexp.MustCompile("^[a-zA-z0-9-]{1,20}$")
-	trimAllSpace      = regexp.MustCompile("[\\n\\t\\r\\s]")
+	proxyConfTypeMap map[string]reflect.Type
 )
 
-type Response struct {
-	Msg string `json:"msg"`
+func init() {
+	proxyConfTypeMap = make(map[string]reflect.Type)
+	proxyConfTypeMap[consts.TCPProxy] = reflect.TypeOf(config.TCPProxyConf{})
+	proxyConfTypeMap[consts.TCPMuxProxy] = reflect.TypeOf(config.TCPMuxProxyConf{})
+	proxyConfTypeMap[consts.UDPProxy] = reflect.TypeOf(config.UDPProxyConf{})
+	proxyConfTypeMap[consts.HTTPProxy] = reflect.TypeOf(config.HTTPProxyConf{})
+	proxyConfTypeMap[consts.HTTPSProxy] = reflect.TypeOf(config.HTTPSProxyConf{})
+	proxyConfTypeMap[consts.STCPProxy] = reflect.TypeOf(config.STCPProxyConf{})
+	proxyConfTypeMap[consts.XTCPProxy] = reflect.TypeOf(config.XTCPProxyConf{})
+	proxyConfTypeMap[consts.SUDPProxy] = reflect.TypeOf(config.SUDPProxyConf{})
 }
 
 type HTTPError struct {
@@ -76,27 +69,6 @@ type CommonInfo struct {
 	DashboardTls  bool
 }
 
-type Tokens struct {
-	Tokens map[string]TokenInfo `toml:"tokens"`
-}
-
-type TokenInfo struct {
-	User       string   `toml:"user" json:"user" form:"user"`
-	Token      string   `toml:"token" json:"token" form:"token"`
-	Comment    string   `toml:"comment" json:"comment" form:"comment"`
-	Ports      []any    `toml:"ports" json:"ports" from:"ports"`
-	Domains    []string `toml:"domains" json:"domains" from:"domains"`
-	Subdomains []string `toml:"subdomains" json:"subdomains" from:"subdomains"`
-	Enable     bool     `toml:"enable" json:"enable" form:"enable"`
-}
-
-type TokenResponse struct {
-	Code  int         `json:"code"`
-	Msg   string      `json:"msg"`
-	Count int         `json:"count"`
-	Data  []TokenInfo `json:"data"`
-}
-
 type OperationResponse struct {
 	Success bool   `json:"success"`
 	Code    int    `json:"code"`
@@ -108,29 +80,6 @@ type ProxyResponse struct {
 	Data any `json:"data"`
 }
 
-type TokenSearch struct {
-	TokenInfo
-	Page  int `form:"page"`
-	Limit int `form:"limit"`
-}
-
-type TokenUpdate struct {
-	Before TokenInfo `json:"before"`
-	After  TokenInfo `json:"after"`
-}
-
-type TokenRemove struct {
-	Users []TokenInfo `json:"users"`
-}
-
-type TokenDisable struct {
-	TokenRemove
-}
-
-type TokenEnable struct {
-	TokenDisable
-}
-
 func (e *HTTPError) Error() string {
 	return e.Err.Error()
 }