mirror of
https://github.com/yhl452493373/frps-panel.git
synced 2026-04-04 06:16:59 +08:00
the first commit, finish almost all function what i need
This commit is contained in:
杨黄林
598
pkg/server/controller/controller.go
Normal file
598
pkg/server/controller/controller.go
Normal file
@@ -0,0 +1,598 @@
|
||||
package controller
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
plugin "github.com/fatedier/frp/pkg/plugin/server"
|
||||
ginI18n "github.com/gin-contrib/i18n"
|
||||
"github.com/gin-gonic/gin"
|
||||
"log"
|
||||
"net/http"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
const (
|
||||
Success = 0
|
||||
ParamError = 1
|
||||
UserExist = 2
|
||||
SaveError = 3
|
||||
)
|
||||
|
||||
var TrimAllSpaceReg = regexp.MustCompile("[\\n\\t\\r\\s]")
|
||||
var TrimBreakLineReg = regexp.MustCompile("[\\n\\t\\r]")
|
||||
|
||||
type Response struct {
|
||||
Msg string `json:"msg"`
|
||||
}
|
||||
|
||||
type HTTPError struct {
|
||||
Code int
|
||||
Err error
|
||||
}
|
||||
|
||||
type CommonInfo struct {
|
||||
PluginAddr string
|
||||
PluginPort int
|
||||
User string
|
||||
Pwd string
|
||||
}
|
||||
|
||||
type TokenInfo struct {
|
||||
User string `json:"user" form:"user"`
|
||||
Token string `json:"token" form:"token"`
|
||||
Comment string `json:"comment" form:"comment"`
|
||||
Ports string `json:"ports" from:"ports"`
|
||||
Domains string `json:"domains" from:"domains"`
|
||||
Subdomains string `json:"subdomains" from:"subdomains"`
|
||||
Status bool `json:"status" form:"status"`
|
||||
}
|
||||
|
||||
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"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
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()
|
||||
}
|
||||
|
||||
type HandlerFunc func(ctx *gin.Context) (interface{}, error)
|
||||
|
||||
func (c *HandleController) MakeHandlerFunc() gin.HandlerFunc {
|
||||
return func(context *gin.Context) {
|
||||
var response plugin.Response
|
||||
var err error
|
||||
|
||||
request := plugin.Request{}
|
||||
if err := context.BindJSON(&request); err != nil {
|
||||
_ = context.Error(&HTTPError{
|
||||
Code: http.StatusBadRequest,
|
||||
Err: err,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
jsonStr, err := json.Marshal(request.Content)
|
||||
if err != nil {
|
||||
_ = context.Error(&HTTPError{
|
||||
Code: http.StatusBadRequest,
|
||||
Err: err,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if request.Op == "Login" {
|
||||
content := plugin.LoginContent{}
|
||||
err = json.Unmarshal(jsonStr, &content)
|
||||
response = c.HandleLogin(&content)
|
||||
} else if request.Op == "NewProxy" {
|
||||
content := plugin.NewProxyContent{}
|
||||
err = json.Unmarshal(jsonStr, &content)
|
||||
response = c.HandleNewProxy(&content)
|
||||
} else if request.Op == "Ping" {
|
||||
content := plugin.PingContent{}
|
||||
err = json.Unmarshal(jsonStr, &content)
|
||||
response = c.HandlePing(&content)
|
||||
} else if request.Op == "NewWorkConn" {
|
||||
content := plugin.NewWorkConnContent{}
|
||||
err = json.Unmarshal(jsonStr, &content)
|
||||
response = c.HandleNewWorkConn(&content)
|
||||
} else if request.Op == "NewUserConn" {
|
||||
content := plugin.NewUserConnContent{}
|
||||
err = json.Unmarshal(jsonStr, &content)
|
||||
response = c.HandleNewUserConn(&content)
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
log.Printf("handle %s error: %v", context.Request.URL.Path, err)
|
||||
var e *HTTPError
|
||||
switch {
|
||||
case errors.As(err, &e):
|
||||
context.JSON(e.Code, &Response{Msg: e.Err.Error()})
|
||||
default:
|
||||
context.JSON(http.StatusInternalServerError, &Response{Msg: err.Error()})
|
||||
}
|
||||
return
|
||||
} else {
|
||||
resStr, _ := json.Marshal(response)
|
||||
log.Printf("handle:%v , result: %v", request.Op, string(resStr))
|
||||
}
|
||||
|
||||
context.JSON(http.StatusOK, response)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeManagerFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
context.HTML(http.StatusOK, "index.html", gin.H{
|
||||
"UserManage": ginI18n.MustGetMessage(context, "User Manage"),
|
||||
"User": ginI18n.MustGetMessage(context, "User"),
|
||||
"Token": ginI18n.MustGetMessage(context, "Token"),
|
||||
"Notes": ginI18n.MustGetMessage(context, "Notes"),
|
||||
"Search": ginI18n.MustGetMessage(context, "Search"),
|
||||
"Reset": ginI18n.MustGetMessage(context, "Reset"),
|
||||
"NewUser": ginI18n.MustGetMessage(context, "New user"),
|
||||
"RemoveUser": ginI18n.MustGetMessage(context, "Remove user"),
|
||||
"DisableUser": ginI18n.MustGetMessage(context, "Disable user"),
|
||||
"EnableUser": ginI18n.MustGetMessage(context, "Enable user"),
|
||||
"Remove": ginI18n.MustGetMessage(context, "Remove"),
|
||||
"Enable": ginI18n.MustGetMessage(context, "Enable"),
|
||||
"Disable": ginI18n.MustGetMessage(context, "Disable"),
|
||||
"PleaseInputUserAccount": ginI18n.MustGetMessage(context, "Please input user account"),
|
||||
"PleaseInputUserToken": ginI18n.MustGetMessage(context, "Please input user token"),
|
||||
"PleaseInputUserNotes": ginI18n.MustGetMessage(context, "Please input user notes"),
|
||||
"AllowedPorts": ginI18n.MustGetMessage(context, "Allowed ports"),
|
||||
"PleaseInputAllowedPorts": ginI18n.MustGetMessage(context, "Please input allowed ports"),
|
||||
"AllowedDomains": ginI18n.MustGetMessage(context, "Allowed domains"),
|
||||
"PleaseInputAllowedDomains": ginI18n.MustGetMessage(context, "Please input allowed domains"),
|
||||
"AllowedSubdomains": ginI18n.MustGetMessage(context, "Allowed subdomains"),
|
||||
"PleaseInputAllowedSubdomains": ginI18n.MustGetMessage(context, "Please input allowed subdomains"),
|
||||
"NotLimit": ginI18n.MustGetMessage(context, "Not limit"),
|
||||
"None": ginI18n.MustGetMessage(context, "None"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeLangFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
context.JSON(http.StatusOK, gin.H{
|
||||
"User": ginI18n.MustGetMessage(context, "User"),
|
||||
"Token": ginI18n.MustGetMessage(context, "Token"),
|
||||
"Notes": ginI18n.MustGetMessage(context, "Notes"),
|
||||
"Status": ginI18n.MustGetMessage(context, "Status"),
|
||||
"Operation": ginI18n.MustGetMessage(context, "Operation"),
|
||||
"Enable": ginI18n.MustGetMessage(context, "Enable"),
|
||||
"Disable": ginI18n.MustGetMessage(context, "Disable"),
|
||||
"NewUser": ginI18n.MustGetMessage(context, "New user"),
|
||||
"Confirm": ginI18n.MustGetMessage(context, "Confirm"),
|
||||
"Cancel": ginI18n.MustGetMessage(context, "Cancel"),
|
||||
"RemoveUser": ginI18n.MustGetMessage(context, "Remove user"),
|
||||
"DisableUser": ginI18n.MustGetMessage(context, "Disable user"),
|
||||
"ConfirmRemoveUser": ginI18n.MustGetMessage(context, "Confirm to remove user"),
|
||||
"ConfirmDisableUser": ginI18n.MustGetMessage(context, "Confirm to disable user"),
|
||||
"TakeTimeMakeEffective": ginI18n.MustGetMessage(context, "will take sometime to make effective"),
|
||||
"ConfirmEnableUser": ginI18n.MustGetMessage(context, "Confirm to enable user"),
|
||||
"OperateSuccess": ginI18n.MustGetMessage(context, "Operate success"),
|
||||
"OperateError": ginI18n.MustGetMessage(context, "Operate error"),
|
||||
"OperateFailed": ginI18n.MustGetMessage(context, "Operate failed"),
|
||||
"UserExist": ginI18n.MustGetMessage(context, "User exist"),
|
||||
"TokenEmpty": ginI18n.MustGetMessage(context, "Token cannot be empty"),
|
||||
"ShouldCheckUser": ginI18n.MustGetMessage(context, "Please check at least one user"),
|
||||
"OperationConfirm": ginI18n.MustGetMessage(context, "Operation confirm"),
|
||||
"EmptyData": ginI18n.MustGetMessage(context, "Empty data"),
|
||||
"AllowedPorts": ginI18n.MustGetMessage(context, "Allowed ports"),
|
||||
"AllowedDomains": ginI18n.MustGetMessage(context, "Allowed domains"),
|
||||
"AllowedSubdomains": ginI18n.MustGetMessage(context, "Allowed subdomains"),
|
||||
"PortsInvalid": ginI18n.MustGetMessage(context, "Ports is invalid"),
|
||||
"DomainsInvalid": ginI18n.MustGetMessage(context, "Domains is invalid"),
|
||||
"SubdomainsInvalid": ginI18n.MustGetMessage(context, "Subdomains is invalid"),
|
||||
"CommentInvalid": ginI18n.MustGetMessage(context, "Comment is invalid"),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeQueryTokensFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
|
||||
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
|
||||
})
|
||||
|
||||
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 filter(main TokenInfo, sub TokenInfo) bool {
|
||||
replaceSpaceUser := TrimAllSpaceReg.ReplaceAllString(sub.User, "")
|
||||
if len(replaceSpaceUser) != 0 {
|
||||
if !strings.Contains(main.User, replaceSpaceUser) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
replaceSpaceToken := TrimAllSpaceReg.ReplaceAllString(sub.Token, "")
|
||||
if len(replaceSpaceToken) != 0 {
|
||||
if !strings.Contains(main.Token, replaceSpaceToken) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
replaceSpaceComment := TrimAllSpaceReg.ReplaceAllString(sub.Comment, "")
|
||||
if len(replaceSpaceComment) != 0 {
|
||||
if !strings.Contains(main.Comment, replaceSpaceComment) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeAddTokenFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
info := TokenInfo{
|
||||
Status: true,
|
||||
}
|
||||
response := OperationResponse{
|
||||
Success: true,
|
||||
Code: Success,
|
||||
Message: "user add success",
|
||||
}
|
||||
err := context.BindJSON(&info)
|
||||
if err != nil {
|
||||
log.Printf("user add failed, param error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = ParamError
|
||||
response.Message = "user add failed, param error "
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
if _, exist := c.Tokens[info.User]; exist {
|
||||
log.Printf("user add failed, user [%v] exist", info.User)
|
||||
response.Success = false
|
||||
response.Code = UserExist
|
||||
response.Message = fmt.Sprintf("user add failed, user [%s] exist ", info.User)
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
c.Tokens[info.User] = info
|
||||
|
||||
usersSection, _ := c.IniFile.GetSection("users")
|
||||
key, err := usersSection.NewKey(info.User, info.Token)
|
||||
key.Comment = info.Comment
|
||||
|
||||
replaceSpacePorts := TrimAllSpaceReg.ReplaceAllString(info.Ports, "")
|
||||
if len(replaceSpacePorts) != 0 {
|
||||
portsSection, _ := c.IniFile.GetSection("ports")
|
||||
key, err = portsSection.NewKey(info.User, replaceSpacePorts)
|
||||
key.Comment = fmt.Sprintf("user %s allowed ports", info.User)
|
||||
}
|
||||
|
||||
replaceSpaceDomains := TrimAllSpaceReg.ReplaceAllString(info.Domains, "")
|
||||
if len(replaceSpaceDomains) != 0 {
|
||||
domainsSection, _ := c.IniFile.GetSection("domains")
|
||||
key, err = domainsSection.NewKey(info.User, replaceSpaceDomains)
|
||||
key.Comment = fmt.Sprintf("user %s allowed domains", info.User)
|
||||
}
|
||||
|
||||
replaceSpaceSubdomains := TrimAllSpaceReg.ReplaceAllString(info.Subdomains, "")
|
||||
if len(replaceSpaceSubdomains) != 0 {
|
||||
subdomainsSection, _ := c.IniFile.GetSection("subdomains")
|
||||
key, err = subdomainsSection.NewKey(info.User, replaceSpaceSubdomains)
|
||||
key.Comment = fmt.Sprintf("user %s allowed subdomains", info.User)
|
||||
}
|
||||
|
||||
err = c.IniFile.SaveTo(c.ConfigFile)
|
||||
if err != nil {
|
||||
log.Printf("add failed, error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = SaveError
|
||||
response.Message = "user add failed"
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
context.JSON(0, &response)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeUpdateTokensFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
response := OperationResponse{
|
||||
Success: true,
|
||||
Code: Success,
|
||||
Message: "user update success",
|
||||
}
|
||||
update := TokenUpdate{}
|
||||
err := context.BindJSON(&update)
|
||||
if err != nil {
|
||||
log.Printf("update failed, param error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = ParamError
|
||||
response.Message = "user update failed, param error "
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
after := update.After
|
||||
before := update.Before
|
||||
|
||||
usersSection, _ := c.IniFile.GetSection("users")
|
||||
key, err := usersSection.GetKey(before.User)
|
||||
comment := TrimBreakLineReg.ReplaceAllString(after.Comment, "")
|
||||
after.Comment = comment
|
||||
key.Comment = comment
|
||||
key.SetValue(after.Token)
|
||||
|
||||
if before.Ports != after.Ports {
|
||||
portsSection, _ := c.IniFile.GetSection("ports")
|
||||
replaceSpacePorts := TrimAllSpaceReg.ReplaceAllString(after.Ports, "")
|
||||
after.Ports = replaceSpacePorts
|
||||
ports := strings.Split(replaceSpacePorts, ",")
|
||||
if len(replaceSpacePorts) != 0 {
|
||||
key, err = portsSection.NewKey(after.User, replaceSpacePorts)
|
||||
key.Comment = fmt.Sprintf("user %s allowed ports", after.User)
|
||||
c.Ports[after.User] = ports
|
||||
} else {
|
||||
portsSection.DeleteKey(after.User)
|
||||
delete(c.Ports, after.User)
|
||||
}
|
||||
}
|
||||
|
||||
if before.Domains != after.Domains {
|
||||
domainsSection, _ := c.IniFile.GetSection("domains")
|
||||
replaceSpaceDomains := TrimAllSpaceReg.ReplaceAllString(after.Domains, "")
|
||||
after.Domains = replaceSpaceDomains
|
||||
domains := strings.Split(replaceSpaceDomains, ",")
|
||||
if len(replaceSpaceDomains) != 0 {
|
||||
key, err = domainsSection.NewKey(after.User, replaceSpaceDomains)
|
||||
key.Comment = fmt.Sprintf("user %s allowed domains", after.User)
|
||||
c.Domains[after.User] = domains
|
||||
} else {
|
||||
domainsSection.DeleteKey(after.User)
|
||||
delete(c.Domains, after.User)
|
||||
}
|
||||
}
|
||||
|
||||
if before.Subdomains != after.Subdomains {
|
||||
subdomainsSection, _ := c.IniFile.GetSection("subdomains")
|
||||
replaceSpaceSubdomains := TrimAllSpaceReg.ReplaceAllString(after.Subdomains, "")
|
||||
after.Subdomains = replaceSpaceSubdomains
|
||||
subdomains := strings.Split(replaceSpaceSubdomains, ",")
|
||||
if len(replaceSpaceSubdomains) != 0 {
|
||||
key, err = subdomainsSection.NewKey(after.User, replaceSpaceSubdomains)
|
||||
key.Comment = fmt.Sprintf("user %s allowed subdomains", after.User)
|
||||
c.Subdomains[after.User] = subdomains
|
||||
} else {
|
||||
subdomainsSection.DeleteKey(after.User)
|
||||
delete(c.Subdomains, after.User)
|
||||
}
|
||||
}
|
||||
|
||||
c.Tokens[after.User] = after
|
||||
|
||||
err = c.IniFile.SaveTo(c.ConfigFile)
|
||||
if err != nil {
|
||||
log.Printf("user update failed, error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = SaveError
|
||||
response.Message = "user update failed"
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
context.JSON(http.StatusOK, &response)
|
||||
}
|
||||
}
|
||||
|
||||
func (c *HandleController) MakeRemoveTokensFunc() func(context *gin.Context) {
|
||||
return func(context *gin.Context) {
|
||||
response := OperationResponse{
|
||||
Success: true,
|
||||
Code: Success,
|
||||
Message: "user remove success",
|
||||
}
|
||||
remove := TokenRemove{}
|
||||
err := context.BindJSON(&remove)
|
||||
if err != nil {
|
||||
log.Printf("user remove failed, param error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = ParamError
|
||||
response.Message = "user remove failed, param error "
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
usersSection, _ := c.IniFile.GetSection("users")
|
||||
for _, user := range remove.Users {
|
||||
delete(c.Tokens, user.User)
|
||||
usersSection.DeleteKey(user.User)
|
||||
}
|
||||
|
||||
portsSection, _ := c.IniFile.GetSection("ports")
|
||||
for _, user := range remove.Users {
|
||||
delete(c.Ports, user.User)
|
||||
portsSection.DeleteKey(user.User)
|
||||
}
|
||||
|
||||
domainsSection, _ := c.IniFile.GetSection("domains")
|
||||
for _, user := range remove.Users {
|
||||
delete(c.Domains, user.User)
|
||||
domainsSection.DeleteKey(user.User)
|
||||
}
|
||||
|
||||
subdomainsSection, _ := c.IniFile.GetSection("subdomains")
|
||||
for _, user := range remove.Users {
|
||||
delete(c.Subdomains, user.User)
|
||||
subdomainsSection.DeleteKey(user.User)
|
||||
}
|
||||
|
||||
err = c.IniFile.SaveTo(c.ConfigFile)
|
||||
if err != nil {
|
||||
log.Printf("user remove failed, error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = SaveError
|
||||
response.Message = "user remove failed"
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
context.JSON(http.StatusOK, &response)
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
log.Printf("disable failed, param error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = ParamError
|
||||
response.Message = "disable failed, param error "
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
section, _ := c.IniFile.GetSection("disabled")
|
||||
for _, user := range disable.Users {
|
||||
section.DeleteKey(user.User)
|
||||
token := c.Tokens[user.User]
|
||||
token.Status = false
|
||||
c.Tokens[user.User] = token
|
||||
key, err := section.NewKey(user.User, "disable")
|
||||
if err != nil {
|
||||
log.Printf("disable failed, error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = SaveError
|
||||
response.Message = "disable failed"
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
key.Comment = fmt.Sprintf("disable user '%s'", user.User)
|
||||
}
|
||||
|
||||
err = c.IniFile.SaveTo(c.ConfigFile)
|
||||
if err != nil {
|
||||
log.Printf("disable failed, error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = SaveError
|
||||
response.Message = "disable failed"
|
||||
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 {
|
||||
log.Printf("enable failed, param error : %v", err)
|
||||
response.Success = false
|
||||
response.Code = ParamError
|
||||
response.Message = "enable failed, param error "
|
||||
context.JSON(http.StatusOK, &response)
|
||||
return
|
||||
}
|
||||
|
||||
section, _ := c.IniFile.GetSection("disabled")
|
||||
for _, user := range enable.Users {
|
||||
section.DeleteKey(user.User)
|
||||
token := c.Tokens[user.User]
|
||||
token.Status = true
|
||||
c.Tokens[user.User] = token
|
||||
}
|
||||
|
||||
err = c.IniFile.SaveTo(c.ConfigFile)
|
||||
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)
|
||||
}
|
||||
}
|
||||
234
pkg/server/controller/op.go
Normal file
234
pkg/server/controller/op.go
Normal file
@@ -0,0 +1,234 @@
|
||||
package controller
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
plugin "github.com/fatedier/frp/pkg/plugin/server"
|
||||
"github.com/gin-gonic/gin"
|
||||
"gopkg.in/ini.v1"
|
||||
"log"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type HandleController struct {
|
||||
CommonInfo CommonInfo
|
||||
Tokens map[string]TokenInfo
|
||||
Ports map[string][]string
|
||||
Domains map[string][]string
|
||||
Subdomains map[string][]string
|
||||
ConfigFile string
|
||||
IniFile *ini.File
|
||||
}
|
||||
|
||||
func NewHandleController(config *HandleController) *HandleController {
|
||||
return config
|
||||
}
|
||||
|
||||
func (c *HandleController) Register(engine *gin.Engine) {
|
||||
engine.Delims("${", "}")
|
||||
engine.LoadHTMLGlob("./assets/templates/*")
|
||||
engine.POST("/handler", c.MakeHandlerFunc())
|
||||
|
||||
var group *gin.RouterGroup
|
||||
if len(c.CommonInfo.User) != 0 {
|
||||
group = engine.Group("/", gin.BasicAuthForRealm(gin.Accounts{
|
||||
c.CommonInfo.User: c.CommonInfo.Pwd,
|
||||
}, "Restricted"))
|
||||
} else {
|
||||
group = engine.Group("/")
|
||||
}
|
||||
group.Static("/static", "./assets/static")
|
||||
group.GET("/", c.MakeManagerFunc())
|
||||
group.GET("/lang", c.MakeLangFunc())
|
||||
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())
|
||||
}
|
||||
|
||||
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.Status {
|
||||
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 StringIndexOf(proxyType, supportProxyTypes) == -1 {
|
||||
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 _, exist := c.Ports[user]; exist {
|
||||
for _, port := range c.Ports[user] {
|
||||
if strings.Contains(port, "-") {
|
||||
allowedRanges := strings.Split(port, "-")
|
||||
if len(allowedRanges) != 2 {
|
||||
portErr = fmt.Errorf("user [%v] port range [%v] format error", user, port)
|
||||
break
|
||||
}
|
||||
start, err := strconv.Atoi(strings.TrimSpace(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(strings.TrimSpace(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(port)
|
||||
if err != nil {
|
||||
portErr = fmt.Errorf("user [%v] allowed port [%v] is not a number", user, 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 _, exist := c.Domains[user]; exist {
|
||||
for _, userDomain := range userDomains {
|
||||
if StringIndexOf(userDomain, c.Domains[user]) == -1 {
|
||||
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 _, exist := c.Subdomains[user]; exist {
|
||||
for _, subdomain := range c.Subdomains[user] {
|
||||
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
|
||||
}
|
||||
|
||||
func StringIndexOf(element string, data []string) int {
|
||||
for k, v := range data {
|
||||
if element == v {
|
||||
return k
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
Reference in New Issue
Block a user