yhl452493373/frps-panel
1
0
Fork 0
mirror of https://github.com/yhl452493373/frps-panel.git synced 2026-04-04 06:16:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

the first commit, finish almost all function what i need

Browse Source
This commit is contained in:
杨黄林
2023-08-30 15:46:46 +08:00
commit 1e17465466
31 changed files with 5467 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

598
pkg/server/controller/controller.go Normal file
View 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
View 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
}

142
pkg/server/server.go Normal file
View File

@@ -0,0 +1,142 @@
package server
import (
"context"
"encoding/json"
"errors"
"fmt"
"frps-multiuser/pkg/server/controller"
ginI18n "github.com/gin-contrib/i18n"
"github.com/gin-gonic/gin"
"golang.org/x/text/language"
"log"
"net"
"net/http"
"os"
"strconv"
"strings"
"time"
)
type Server struct {
cfg controller.HandleController
s *http.Server
done chan struct{}
}
func New(cfg controller.HandleController) (*Server, error) {
s := &Server{
cfg: cfg,
done: make(chan struct{}),
}
if err := s.init(); err != nil {
return nil, err
}
return s, nil
}
func (s *Server) Run() error {
bindAddress := s.cfg.CommonInfo.PluginAddr + ":" + strconv.Itoa(s.cfg.CommonInfo.PluginPort)
l, err := net.Listen("tcp", bindAddress)
if err != nil {
return err
}
log.Printf("HTTP server listen on %s", l.Addr().String())
go func() {
if err = s.s.Serve(l); !errors.Is(http.ErrServerClosed, err) {
log.Printf("error shutdown HTTP server: %v", err)
}
}()
<-s.done
return nil
}
func (s *Server) Stop() error {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := s.s.Shutdown(ctx); err != nil {
log.Fatalf("shutdown HTTP server error: %v", err)
}
log.Printf("HTTP server exited")
close(s.done)
return nil
}
func (s *Server) init() error {
if err := s.initHTTPServer(); err != nil {
log.Printf("init HTTP server error: %v", err)
return err
}
return nil
}
func LoadSupportLanguage(dir string) ([]language.Tag, error) {
var tags []language.Tag
files, err := os.Open(dir)
if err != nil {
log.Printf("error opening directory: %v", err)
return tags, err
}
fileList, err := files.Readdir(-1)
if err != nil {
log.Printf("error reading directory: %v", err)
return tags, err
}
err = files.Close()
if err != nil {
return nil, err
}
for _, file := range fileList {
name, _ := strings.CutSuffix(file.Name(), ".json")
parsedLang, _ := language.Parse(name)
tags = append(tags, parsedLang)
}
if len(tags) == 0 {
return tags, fmt.Errorf("not found any language file in directory: %v", dir)
}
return tags, nil
}
func GinI18nLocalize() gin.HandlerFunc {
dir := "./assets/lang"
tags, err := LoadSupportLanguage(dir)
if err != nil {
log.Panicf("language file is not found: %v", err)
}
return ginI18n.Localize(
ginI18n.WithBundle(&ginI18n.BundleCfg{
RootPath: dir,
AcceptLanguage: tags,
DefaultLanguage: language.Chinese,
FormatBundleFile: "json",
UnmarshalFunc: json.Unmarshal,
}),
ginI18n.WithGetLngHandle(
func(context *gin.Context, defaultLng string) string {
header := context.GetHeader("Accept-Language")
lang, _, err := language.ParseAcceptLanguage(header)
if err != nil {
return defaultLng
}
return lang[0].String()
},
),
)
}
func (s *Server) initHTTPServer() error {
gin.SetMode(gin.ReleaseMode)
engine := gin.New()
engine.Use(GinI18nLocalize())
s.s = &http.Server{
Handler: engine,
}
controller.NewHandleController(&s.cfg).Register(engine)
return nil
}