>6]+i[128|63&n]:n<55296||57344<=n?t+=i[224|n>>12]+i[128|n>>6&63]+i[128|63&n]:(o+=1,n=65536+((1023&n)<<10|1023&r.charCodeAt(o)),t+=i[240|n>>18]+i[128|n>>12&63]+i[128|n>>6&63]+i[128|63&n])}return t},isBuffer:function(e){return null!=e&&!!(e.constructor&&e.constructor.isBuffer&&e.constructor.isBuffer(e))},isRegExp:function(e){return"[object RegExp]"===Object.prototype.toString.call(e)},merge:function o(t,n,i){if(!n)return t;if("object"!=typeof n){if(Array.isArray(t))t.push(n);else{if("object"!=typeof t)return[t,n];(i.plainObjects||i.allowPrototypes||!a.call(Object.prototype,n))&&(t[n]=!0)}return t}if("object"!=typeof t)return[t].concat(n);var e=t;return Array.isArray(t)&&!Array.isArray(n)&&(e=l(t,i)),Array.isArray(t)&&Array.isArray(n)?(n.forEach(function(e,r){a.call(t,r)?t[r]&&"object"==typeof t[r]?t[r]=o(t[r],e,i):t.push(e):t[r]=e}),t):Object.keys(n).reduce(function(e,r){var t=n[r];return a.call(e,r)?e[r]=o(e[r],t,i):e[r]=t,e},e)}}},{}]},{},[2])(2)});
--------------------------------------------------------------------------------
/web/assets/vue@2.6.12/vue.common.js:
--------------------------------------------------------------------------------
1 | if (process.env.NODE_ENV === 'production') {
2 | module.exports = require('./vue.common.prod.js')
3 | } else {
4 | module.exports = require('./vue.common.dev.js')
5 | }
6 |
--------------------------------------------------------------------------------
/web/assets/vue@2.6.12/vue.runtime.common.js:
--------------------------------------------------------------------------------
1 | if (process.env.NODE_ENV === 'production') {
2 | module.exports = require('./vue.runtime.common.prod.js')
3 | } else {
4 | module.exports = require('./vue.runtime.common.dev.js')
5 | }
6 |
--------------------------------------------------------------------------------
/web/controller/api.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "github.com/gin-gonic/gin"
5 | )
6 | type APIController struct {
7 | BaseController
8 |
9 | inboundController *InboundController
10 | settingController *SettingController
11 | }
12 |
13 | func NewAPIController(g *gin.RouterGroup) *APIController {
14 | a := &APIController{}
15 | a.initRouter(g)
16 | return a
17 | }
18 |
19 | func (a *APIController) initRouter(g *gin.RouterGroup) {
20 | g = g.Group("/xui/API/inbounds")
21 | g.Use(a.checkLogin)
22 |
23 | g.GET("/", a.inbounds)
24 | g.GET("/get/:id", a.inbound)
25 | g.POST("/add", a.addInbound)
26 | g.POST("/del/:id", a.delInbound)
27 | g.POST("/update/:id", a.updateInbound)
28 |
29 |
30 | a.inboundController = NewInboundController(g)
31 | }
32 |
33 |
34 | func (a *APIController) inbounds(c *gin.Context) {
35 | a.inboundController.getInbounds(c)
36 | }
37 | func (a *APIController) inbound(c *gin.Context) {
38 | a.inboundController.getInbound(c)
39 | }
40 | func (a *APIController) addInbound(c *gin.Context) {
41 | a.inboundController.addInbound(c)
42 | }
43 | func (a *APIController) delInbound(c *gin.Context) {
44 | a.inboundController.delInbound(c)
45 | }
46 | func (a *APIController) updateInbound(c *gin.Context) {
47 | a.inboundController.updateInbound(c)
48 | }
49 |
--------------------------------------------------------------------------------
/web/controller/base.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "github.com/gin-gonic/gin"
5 | "net/http"
6 | "x-ui/web/session"
7 | )
8 |
9 | type BaseController struct {
10 | }
11 |
12 | func (a *BaseController) checkLogin(c *gin.Context) {
13 | if !session.IsLogin(c) {
14 | if isAjax(c) {
15 | pureJsonMsg(c, false, I18n(c , "pages.login.loginAgain"))
16 | } else {
17 | c.Redirect(http.StatusTemporaryRedirect, c.GetString("base_path"))
18 | }
19 | c.Abort()
20 | } else {
21 | c.Next()
22 | }
23 | }
24 |
25 |
26 | func I18n(c *gin.Context , name string) string{
27 | anyfunc, _ := c.Get("I18n")
28 | i18n, _ := anyfunc.(func(key string, params ...string) (string, error))
29 |
30 | message, _ := i18n(name)
31 |
32 | return message;
33 | }
34 |
--------------------------------------------------------------------------------
/web/controller/inbound.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "fmt"
5 | "github.com/gin-gonic/gin"
6 | "strconv"
7 | "x-ui/database/model"
8 | "x-ui/logger"
9 | "x-ui/web/global"
10 | "x-ui/web/service"
11 | "x-ui/web/session"
12 | )
13 |
14 | type InboundController struct {
15 | inboundService service.InboundService
16 | xrayService service.XrayService
17 | }
18 |
19 | func NewInboundController(g *gin.RouterGroup) *InboundController {
20 | a := &InboundController{}
21 | a.initRouter(g)
22 | a.startTask()
23 | return a
24 | }
25 |
26 | func (a *InboundController) initRouter(g *gin.RouterGroup) {
27 | g = g.Group("/inbound")
28 |
29 | g.POST("/list", a.getInbounds)
30 | g.POST("/add", a.addInbound)
31 | g.POST("/del/:id", a.delInbound)
32 | g.POST("/update/:id", a.updateInbound)
33 |
34 | g.POST("/clientIps/:email", a.getClientIps)
35 | g.POST("/clearClientIps/:email", a.clearClientIps)
36 | g.POST("/resetClientTraffic/:email", a.resetClientTraffic)
37 |
38 |
39 | }
40 |
41 | func (a *InboundController) startTask() {
42 | webServer := global.GetWebServer()
43 | c := webServer.GetCron()
44 | c.AddFunc("@every 10s", func() {
45 | if a.xrayService.IsNeedRestartAndSetFalse() {
46 | err := a.xrayService.RestartXray(false)
47 | if err != nil {
48 | logger.Error("restart xray failed:", err)
49 | }
50 | }
51 | })
52 | }
53 |
54 | func (a *InboundController) getInbounds(c *gin.Context) {
55 | user := session.GetLoginUser(c)
56 | inbounds, err := a.inboundService.GetInbounds(user.Id)
57 | if err != nil {
58 | jsonMsg(c, I18n(c , "pages.inbounds.toasts.obtain"), err)
59 | return
60 | }
61 | jsonObj(c, inbounds, nil)
62 | }
63 | func (a *InboundController) getInbound(c *gin.Context) {
64 | id, err := strconv.Atoi(c.Param("id"))
65 | if err != nil {
66 | jsonMsg(c, I18n(c , "get"), err)
67 | return
68 | }
69 | inbound, err := a.inboundService.GetInbound(id)
70 | if err != nil {
71 | jsonMsg(c, I18n(c , "pages.inbounds.toasts.obtain"), err)
72 | return
73 | }
74 | jsonObj(c, inbound, nil)
75 | }
76 |
77 | func (a *InboundController) addInbound(c *gin.Context) {
78 | inbound := &model.Inbound{}
79 | err := c.ShouldBind(inbound)
80 | if err != nil {
81 | jsonMsg(c, I18n(c , "pages.inbounds.addTo"), err)
82 | return
83 | }
84 | user := session.GetLoginUser(c)
85 | inbound.UserId = user.Id
86 | inbound.Enable = true
87 | inbound.Tag = fmt.Sprintf("inbound-%v", inbound.Port)
88 | inbound, err = a.inboundService.AddInbound(inbound)
89 | jsonMsgObj(c, I18n(c , "pages.inbounds.addTo"), inbound, err)
90 | if err == nil {
91 | a.xrayService.SetToNeedRestart()
92 | }
93 | }
94 |
95 | func (a *InboundController) delInbound(c *gin.Context) {
96 | id, err := strconv.Atoi(c.Param("id"))
97 | if err != nil {
98 | jsonMsg(c, I18n(c , "delete"), err)
99 | return
100 | }
101 | err = a.inboundService.DelInbound(id)
102 | jsonMsgObj(c, I18n(c , "delete"), id, err)
103 | if err == nil {
104 | a.xrayService.SetToNeedRestart()
105 | }
106 | }
107 |
108 | func (a *InboundController) updateInbound(c *gin.Context) {
109 | id, err := strconv.Atoi(c.Param("id"))
110 | if err != nil {
111 | jsonMsg(c, I18n(c , "pages.inbounds.revise"), err)
112 | return
113 | }
114 | inbound := &model.Inbound{
115 | Id: id,
116 | }
117 | err = c.ShouldBind(inbound)
118 | if err != nil {
119 | jsonMsg(c, I18n(c , "pages.inbounds.revise"), err)
120 | return
121 | }
122 | inbound, err = a.inboundService.UpdateInbound(inbound)
123 | jsonMsgObj(c, I18n(c , "pages.inbounds.revise"), inbound, err)
124 | if err == nil {
125 | a.xrayService.SetToNeedRestart()
126 | }
127 | }
128 | func (a *InboundController) getClientIps(c *gin.Context) {
129 | email := c.Param("email")
130 |
131 | ips , err := a.inboundService.GetInboundClientIps(email)
132 | if err != nil {
133 | jsonObj(c, "No IP Record", nil)
134 | return
135 | }
136 | jsonObj(c, ips, nil)
137 | }
138 | func (a *InboundController) clearClientIps(c *gin.Context) {
139 | email := c.Param("email")
140 |
141 | err := a.inboundService.ClearClientIps(email)
142 | if err != nil {
143 | jsonMsg(c, "修改", err)
144 | return
145 | }
146 | jsonMsg(c, "Log Cleared", nil)
147 | }
148 | func (a *InboundController) resetClientTraffic(c *gin.Context) {
149 | email := c.Param("email")
150 |
151 | err := a.inboundService.ResetClientTraffic(email)
152 | if err != nil {
153 | jsonMsg(c, "something worng!", err)
154 | return
155 | }
156 | jsonMsg(c, "traffic reseted", nil)
157 | }
158 |
--------------------------------------------------------------------------------
/web/controller/index.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "net/http"
5 | "time"
6 | "x-ui/logger"
7 | "x-ui/web/job"
8 | "x-ui/web/service"
9 | "x-ui/web/session"
10 |
11 | "github.com/gin-gonic/gin"
12 | )
13 |
14 | type LoginForm struct {
15 | Username string `json:"username" form:"username"`
16 | Password string `json:"password" form:"password"`
17 | }
18 |
19 | type IndexController struct {
20 | BaseController
21 |
22 | userService service.UserService
23 | }
24 |
25 | func NewIndexController(g *gin.RouterGroup) *IndexController {
26 | a := &IndexController{}
27 | a.initRouter(g)
28 | return a
29 | }
30 |
31 | func (a *IndexController) initRouter(g *gin.RouterGroup) {
32 | g.GET("/", a.index)
33 | g.POST("/login", a.login)
34 | g.GET("/logout", a.logout)
35 | }
36 |
37 | func (a *IndexController) index(c *gin.Context) {
38 | if session.IsLogin(c) {
39 | c.Redirect(http.StatusTemporaryRedirect, "xui/")
40 | return
41 | }
42 | html(c, "login.html", "pages.login.title", nil)
43 | }
44 |
45 | func (a *IndexController) login(c *gin.Context) {
46 | var form LoginForm
47 | err := c.ShouldBind(&form)
48 | if err != nil {
49 | pureJsonMsg(c, false, I18n(c , "pages.login.toasts.invalidFormData"))
50 | return
51 | }
52 | if form.Username == "" {
53 | pureJsonMsg(c, false, I18n(c, "pages.login.toasts.emptyUsername"))
54 | return
55 | }
56 | if form.Password == "" {
57 | pureJsonMsg(c, false, I18n(c , "pages.login.toasts.emptyPassword"))
58 | return
59 | }
60 | user := a.userService.CheckUser(form.Username, form.Password)
61 | timeStr := time.Now().Format("2006-01-02 15:04:05")
62 | if user == nil {
63 | job.NewStatsNotifyJob().UserLoginNotify(form.Username, getRemoteIp(c), timeStr, 0)
64 | logger.Infof("wrong username or password: \"%s\" \"%s\"", form.Username, form.Password)
65 | pureJsonMsg(c, false, I18n(c , "pages.login.toasts.wrongUsernameOrPassword"))
66 | return
67 | } else {
68 | logger.Infof("%s login success,Ip Address:%s\n", form.Username, getRemoteIp(c))
69 | job.NewStatsNotifyJob().UserLoginNotify(form.Username, getRemoteIp(c), timeStr, 1)
70 | }
71 |
72 | err = session.SetLoginUser(c, user)
73 | logger.Info("user", user.Id, "login success")
74 | jsonMsg(c, I18n(c , "pages.login.toasts.successLogin"), err)
75 | }
76 |
77 | func (a *IndexController) logout(c *gin.Context) {
78 | user := session.GetLoginUser(c)
79 | if user != nil {
80 | logger.Info("user", user.Id, "logout")
81 | }
82 | session.ClearSession(c)
83 | c.Redirect(http.StatusTemporaryRedirect, c.GetString("base_path"))
84 | }
85 |
--------------------------------------------------------------------------------
/web/controller/server.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "github.com/gin-gonic/gin"
5 | "time"
6 | "x-ui/web/global"
7 | "x-ui/web/service"
8 | )
9 |
10 | type ServerController struct {
11 | BaseController
12 |
13 | serverService service.ServerService
14 |
15 | lastStatus *service.Status
16 | lastGetStatusTime time.Time
17 |
18 | lastVersions []string
19 | lastGetVersionsTime time.Time
20 | }
21 |
22 | func NewServerController(g *gin.RouterGroup) *ServerController {
23 | a := &ServerController{
24 | lastGetStatusTime: time.Now(),
25 | }
26 | a.initRouter(g)
27 | a.startTask()
28 | return a
29 | }
30 |
31 | func (a *ServerController) initRouter(g *gin.RouterGroup) {
32 | g = g.Group("/server")
33 |
34 | g.Use(a.checkLogin)
35 | g.POST("/status", a.status)
36 | g.POST("/getXrayVersion", a.getXrayVersion)
37 | g.POST("/installXray/:version", a.installXray)
38 | }
39 |
40 | func (a *ServerController) refreshStatus() {
41 | a.lastStatus = a.serverService.GetStatus(a.lastStatus)
42 | }
43 |
44 | func (a *ServerController) startTask() {
45 | webServer := global.GetWebServer()
46 | c := webServer.GetCron()
47 | c.AddFunc("@every 2s", func() {
48 | now := time.Now()
49 | if now.Sub(a.lastGetStatusTime) > time.Minute*3 {
50 | return
51 | }
52 | a.refreshStatus()
53 | })
54 | }
55 |
56 | func (a *ServerController) status(c *gin.Context) {
57 | a.lastGetStatusTime = time.Now()
58 |
59 | jsonObj(c, a.lastStatus, nil)
60 | }
61 |
62 | func (a *ServerController) getXrayVersion(c *gin.Context) {
63 | now := time.Now()
64 | if now.Sub(a.lastGetVersionsTime) <= time.Minute {
65 | jsonObj(c, a.lastVersions, nil)
66 | return
67 | }
68 |
69 | versions, err := a.serverService.GetXrayVersions()
70 | if err != nil {
71 | jsonMsg(c, I18n(c , "getVersion"), err)
72 | return
73 | }
74 |
75 | a.lastVersions = versions
76 | a.lastGetVersionsTime = time.Now()
77 |
78 | jsonObj(c, versions, nil)
79 | }
80 |
81 | func (a *ServerController) installXray(c *gin.Context) {
82 | version := c.Param("version")
83 | err := a.serverService.UpdateXray(version)
84 | jsonMsg(c, I18n(c , "install") + " xray", err)
85 | }
86 |
--------------------------------------------------------------------------------
/web/controller/setting.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "errors"
5 | "github.com/gin-gonic/gin"
6 | "time"
7 | "x-ui/web/entity"
8 | "x-ui/web/service"
9 | "x-ui/web/session"
10 | )
11 |
12 | type updateUserForm struct {
13 | OldUsername string `json:"oldUsername" form:"oldUsername"`
14 | OldPassword string `json:"oldPassword" form:"oldPassword"`
15 | NewUsername string `json:"newUsername" form:"newUsername"`
16 | NewPassword string `json:"newPassword" form:"newPassword"`
17 | }
18 |
19 | type SettingController struct {
20 | settingService service.SettingService
21 | userService service.UserService
22 | panelService service.PanelService
23 | }
24 |
25 | func NewSettingController(g *gin.RouterGroup) *SettingController {
26 | a := &SettingController{}
27 | a.initRouter(g)
28 | return a
29 | }
30 |
31 | func (a *SettingController) initRouter(g *gin.RouterGroup) {
32 | g = g.Group("/setting")
33 |
34 | g.POST("/all", a.getAllSetting)
35 | g.POST("/update", a.updateSetting)
36 | g.POST("/updateUser", a.updateUser)
37 | g.POST("/restartPanel", a.restartPanel)
38 | }
39 |
40 | func (a *SettingController) getAllSetting(c *gin.Context) {
41 | allSetting, err := a.settingService.GetAllSetting()
42 | if err != nil {
43 | jsonMsg(c, I18n(c , "pages.setting.toasts.getSetting"), err)
44 | return
45 | }
46 | jsonObj(c, allSetting, nil)
47 | }
48 |
49 | func (a *SettingController) updateSetting(c *gin.Context) {
50 | allSetting := &entity.AllSetting{}
51 | err := c.ShouldBind(allSetting)
52 | if err != nil {
53 | jsonMsg(c, I18n(c , "pages.setting.toasts.modifySetting"), err)
54 | return
55 | }
56 | err = a.settingService.UpdateAllSetting(allSetting)
57 | jsonMsg(c, I18n(c , "pages.setting.toasts.modifySetting"), err)
58 | }
59 |
60 | func (a *SettingController) updateUser(c *gin.Context) {
61 | form := &updateUserForm{}
62 | err := c.ShouldBind(form)
63 | if err != nil {
64 | jsonMsg(c, I18n(c , "pages.setting.toasts.modifySetting"), err)
65 | return
66 | }
67 | user := session.GetLoginUser(c)
68 | if user.Username != form.OldUsername || user.Password != form.OldPassword {
69 | jsonMsg(c, I18n(c , "pages.setting.toasts.modifyUser"), errors.New(I18n(c , "pages.setting.toasts.originalUserPassIncorrect")))
70 | return
71 | }
72 | if form.NewUsername == "" || form.NewPassword == "" {
73 | jsonMsg(c,I18n(c , "pages.setting.toasts.modifyUser"), errors.New(I18n(c , "pages.setting.toasts.userPassMustBeNotEmpty")))
74 | return
75 | }
76 | err = a.userService.UpdateUser(user.Id, form.NewUsername, form.NewPassword)
77 | if err == nil {
78 | user.Username = form.NewUsername
79 | user.Password = form.NewPassword
80 | session.SetLoginUser(c, user)
81 | }
82 | jsonMsg(c, I18n(c , "pages.setting.toasts.modifyUser"), err)
83 | }
84 |
85 | func (a *SettingController) restartPanel(c *gin.Context) {
86 | err := a.panelService.RestartPanel(time.Second * 3)
87 | jsonMsg(c, I18n(c , "pages.setting.restartPanel"), err)
88 | }
89 |
--------------------------------------------------------------------------------
/web/controller/util.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "github.com/gin-gonic/gin"
5 | "net"
6 | "net/http"
7 | "strings"
8 | "x-ui/config"
9 | "x-ui/logger"
10 | "x-ui/web/entity"
11 | )
12 |
13 | func getUriId(c *gin.Context) int64 {
14 | s := struct {
15 | Id int64 `uri:"id"`
16 | }{}
17 |
18 | _ = c.BindUri(&s)
19 | return s.Id
20 | }
21 |
22 | func getRemoteIp(c *gin.Context) string {
23 | value := c.GetHeader("X-Forwarded-For")
24 | if value != "" {
25 | ips := strings.Split(value, ",")
26 | return ips[0]
27 | } else {
28 | addr := c.Request.RemoteAddr
29 | ip, _, _ := net.SplitHostPort(addr)
30 | return ip
31 | }
32 | }
33 |
34 | func jsonMsg(c *gin.Context, msg string, err error) {
35 | jsonMsgObj(c, msg, nil, err)
36 | }
37 |
38 | func jsonObj(c *gin.Context, obj interface{}, err error) {
39 | jsonMsgObj(c, "", obj, err)
40 | }
41 |
42 | func jsonMsgObj(c *gin.Context, msg string, obj interface{}, err error) {
43 | m := entity.Msg{
44 | Obj: obj,
45 | }
46 | if err == nil {
47 | m.Success = true
48 | if msg != "" {
49 | m.Msg = msg + I18n(c , "success")
50 | }
51 | } else {
52 | m.Success = false
53 | m.Msg = msg + I18n(c , "fail") + ": " + err.Error()
54 | logger.Warning(msg + I18n(c , "fail") + ": ", err)
55 | }
56 | c.JSON(http.StatusOK, m)
57 | }
58 |
59 | func pureJsonMsg(c *gin.Context, success bool, msg string) {
60 | if success {
61 | c.JSON(http.StatusOK, entity.Msg{
62 | Success: true,
63 | Msg: msg,
64 | })
65 | } else {
66 | c.JSON(http.StatusOK, entity.Msg{
67 | Success: false,
68 | Msg: msg,
69 | })
70 | }
71 | }
72 |
73 | func html(c *gin.Context, name string, title string, data gin.H) {
74 | if data == nil {
75 | data = gin.H{}
76 | }
77 | data["title"] = title
78 | data["request_uri"] = c.Request.RequestURI
79 | data["base_path"] = c.GetString("base_path")
80 | c.HTML(http.StatusOK, name, getContext(data))
81 | }
82 |
83 | func getContext(h gin.H) gin.H {
84 | a := gin.H{
85 | "cur_ver": config.GetVersion(),
86 | }
87 | if h != nil {
88 | for key, value := range h {
89 | a[key] = value
90 | }
91 | }
92 | return a
93 | }
94 |
95 | func isAjax(c *gin.Context) bool {
96 | return c.GetHeader("X-Requested-With") == "XMLHttpRequest"
97 | }
98 |
--------------------------------------------------------------------------------
/web/controller/xui.go:
--------------------------------------------------------------------------------
1 | package controller
2 |
3 | import (
4 | "github.com/gin-gonic/gin"
5 | )
6 |
7 | type XUIController struct {
8 | BaseController
9 |
10 | inboundController *InboundController
11 | settingController *SettingController
12 | }
13 |
14 | func NewXUIController(g *gin.RouterGroup) *XUIController {
15 | a := &XUIController{}
16 | a.initRouter(g)
17 | return a
18 | }
19 |
20 | func (a *XUIController) initRouter(g *gin.RouterGroup) {
21 | g = g.Group("/xui")
22 | g.Use(a.checkLogin)
23 |
24 | g.GET("/", a.index)
25 | g.GET("/inbounds", a.inbounds)
26 | g.GET("/setting", a.setting)
27 |
28 | a.inboundController = NewInboundController(g)
29 | a.settingController = NewSettingController(g)
30 | }
31 |
32 | func (a *XUIController) index(c *gin.Context) {
33 | html(c, "index.html", "pages.index.title", nil)
34 | }
35 |
36 | func (a *XUIController) inbounds(c *gin.Context) {
37 | html(c, "inbounds.html", "pages.inbounds.title", nil)
38 | }
39 |
40 | func (a *XUIController) setting(c *gin.Context) {
41 | html(c, "setting.html", "pages.setting.title", nil)
42 | }
43 |
--------------------------------------------------------------------------------
/web/entity/entity.go:
--------------------------------------------------------------------------------
1 | package entity
2 |
3 | import (
4 | "crypto/tls"
5 | "encoding/json"
6 | "net"
7 | "strings"
8 | "time"
9 | _ "time/tzdata"
10 | "x-ui/util/common"
11 | "x-ui/xray"
12 | )
13 |
14 | type Msg struct {
15 | Success bool `json:"success"`
16 | Msg string `json:"msg"`
17 | Obj interface{} `json:"obj"`
18 | }
19 |
20 | type Pager struct {
21 | Current int `json:"current"`
22 | PageSize int `json:"page_size"`
23 | Total int `json:"total"`
24 | OrderBy string `json:"order_by"`
25 | Desc bool `json:"desc"`
26 | Key string `json:"key"`
27 | List interface{} `json:"list"`
28 | }
29 |
30 | type AllSetting struct {
31 | WebListen string `json:"webListen" form:"webListen"`
32 | WebPort int `json:"webPort" form:"webPort"`
33 | WebCertFile string `json:"webCertFile" form:"webCertFile"`
34 | WebKeyFile string `json:"webKeyFile" form:"webKeyFile"`
35 | WebBasePath string `json:"webBasePath" form:"webBasePath"`
36 | TgBotEnable bool `json:"tgBotEnable" form:"tgBotEnable"`
37 | TgBotToken string `json:"tgBotToken" form:"tgBotToken"`
38 | TgBotChatId int `json:"tgBotChatId" form:"tgBotChatId"`
39 | TgRunTime string `json:"tgRunTime" form:"tgRunTime"`
40 | XrayTemplateConfig string `json:"xrayTemplateConfig" form:"xrayTemplateConfig"`
41 |
42 | TimeLocation string `json:"timeLocation" form:"timeLocation"`
43 | }
44 |
45 | func (s *AllSetting) CheckValid() error {
46 | if s.WebListen != "" {
47 | ip := net.ParseIP(s.WebListen)
48 | if ip == nil {
49 | return common.NewError("web listen is not valid ip:", s.WebListen)
50 | }
51 | }
52 |
53 | if s.WebPort <= 0 || s.WebPort > 65535 {
54 | return common.NewError("web port is not a valid port:", s.WebPort)
55 | }
56 |
57 | if s.WebCertFile != "" || s.WebKeyFile != "" {
58 | _, err := tls.LoadX509KeyPair(s.WebCertFile, s.WebKeyFile)
59 | if err != nil {
60 | return common.NewErrorf("cert file <%v> or key file <%v> invalid: %v", s.WebCertFile, s.WebKeyFile, err)
61 | }
62 | }
63 |
64 | if !strings.HasPrefix(s.WebBasePath, "/") {
65 | s.WebBasePath = "/" + s.WebBasePath
66 | }
67 | if !strings.HasSuffix(s.WebBasePath, "/") {
68 | s.WebBasePath += "/"
69 | }
70 |
71 | xrayConfig := &xray.Config{}
72 | err := json.Unmarshal([]byte(s.XrayTemplateConfig), xrayConfig)
73 | if err != nil {
74 | return common.NewError("xray template config invalid:", err)
75 | }
76 |
77 | _, err = time.LoadLocation(s.TimeLocation)
78 | if err != nil {
79 | return common.NewError("time location not exist:", s.TimeLocation)
80 | }
81 |
82 | return nil
83 | }
84 |
--------------------------------------------------------------------------------
/web/global/global.go:
--------------------------------------------------------------------------------
1 | package global
2 |
3 | import (
4 | "context"
5 | "github.com/robfig/cron/v3"
6 | _ "unsafe"
7 | )
8 |
9 | var webServer WebServer
10 |
11 | type WebServer interface {
12 | GetCron() *cron.Cron
13 | GetCtx() context.Context
14 | }
15 |
16 | func SetWebServer(s WebServer) {
17 | webServer = s
18 | }
19 |
20 | func GetWebServer() WebServer {
21 | return webServer
22 | }
23 |
--------------------------------------------------------------------------------
/web/html/common/head.html:
--------------------------------------------------------------------------------
1 | {{define "head"}}
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
15 | {{ i18n .title}}
16 |
17 | {{end}}
--------------------------------------------------------------------------------
/web/html/common/js.html:
--------------------------------------------------------------------------------
1 | {{define "js"}}
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
22 | {{end}}
--------------------------------------------------------------------------------
/web/html/common/prompt_modal.html:
--------------------------------------------------------------------------------
1 | {{define "promptModal"}}
2 |
5 |
10 |
11 |
12 |
67 | {{end}}
--------------------------------------------------------------------------------
/web/html/common/qrcode_modal.html:
--------------------------------------------------------------------------------
1 | {{define "qrcodeModal"}}
2 |
5 | click on QR Code to Copy
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
120 | {{end}}
--------------------------------------------------------------------------------
/web/html/common/text_modal.html:
--------------------------------------------------------------------------------
1 | {{define "textModal"}}
2 |
5 |
7 | {{ i18n "download" }} [[ txtModal.fileName ]]
8 |
9 |
11 |
12 |
13 |
58 | {{end}}
--------------------------------------------------------------------------------
/web/html/login.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | {{template "head" .}}
4 |
36 |
37 |
38 |
39 |
40 |
41 |
42 | {{ i18n "pages.login.title" }}
43 |
44 |
45 |
46 |
47 |
48 |
49 |
51 |
52 |
53 |
54 |
55 |
57 |
58 |
59 |
60 |
61 | {{ i18n "login" }}
62 |
63 |
64 |
65 |
66 | Language :
67 |
68 |
69 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 | {{template "js" .}}
93 |
122 |
123 |
--------------------------------------------------------------------------------
/web/html/xui/common_sider.html:
--------------------------------------------------------------------------------
1 | {{define "menuItems"}}
2 |
3 |
4 | {{ i18n "menu.dashboard"}}
5 |
6 |
7 |
8 | {{ i18n "menu.inbounds"}}
9 |
10 |
11 |
12 | {{ i18n "menu.setting"}}
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 | {{ i18n "menu.link"}}
22 |
23 |
24 |
25 | Github
26 |
27 |
28 |
29 |
30 | {{ i18n "menu.logout"}}
31 |
32 | {{end}}
33 |
34 |
35 | {{define "commonSider"}}
36 |
37 |
39 | {{template "menuItems" .}}
40 |
41 |
42 |
45 |
48 |
50 | {{template "menuItems" .}}
51 |
52 |
53 |
69 | {{end}}
70 |
--------------------------------------------------------------------------------
/web/html/xui/component/inbound_info.html:
--------------------------------------------------------------------------------
1 | {{define "inboundInfoStream"}}
2 | {{ i18n "transmission" }}: [[ inbound.network ]]
3 |
4 |
5 | host: [[ inbound.host ]]
6 | {{ i18n "host" }}: {{ i18n "none" }}
7 |
8 | path: [[ inbound.path ]]
9 | {{ i18n "path" }}: {{ i18n "none" }}
10 |
11 |
12 |
13 | quic {{ i18n "encryption" }}: [[ inbound.quicSecurity ]]
14 | quic {{ i18n "password" }}: [[ inbound.quicKey ]]
15 | quic {{ i18n "camouflage" }}: [[ inbound.quicType ]]
16 |
17 |
18 |
19 | kcp {{ i18n "encryption" }}: [[ inbound.kcpType ]]
20 | kcp {{ i18n "password" }}: [[ inbound.kcpSeed ]]
21 |
22 |
23 |
24 | grpc serviceName: [[ inbound.serviceName ]]
25 |
26 |
27 |
28 | tls: {{ i18n "turnOn" }}
29 | xtls: {{ i18n "turnOn" }}
30 |
31 |
32 | tls: {{ i18n "closure" }}
33 |
34 |
35 | tls {{ i18n "domainName" }}: [[ inbound.serverName ? inbound.serverName : '' ]]
36 |
37 |
38 | xtls {{ i18n "domainName" }}: [[ inbound.serverName ? inbound.serverName : '' ]]
39 |
40 | {{end}}
41 |
42 |
43 | {{define "component/inboundInfoComponent"}}
44 |
45 |
{{ i18n "protocol"}}: [[ dbInbound.protocol ]]
46 |
{{ i18n "pages.inbounds.address"}}: [[ dbInbound.address ]]
47 |
{{ i18n "pages.inbounds.port"}}: [[ dbInbound.port ]]
48 |
49 |
50 | uuid: [[ vmess.id ]]
51 | alterId: [[ vmess.alterId ]]
52 |
53 |
54 |
55 |
56 | uuid: [[ vless.id ]]
57 | flow: [[ vless.flow ]]
58 |
59 |
60 |
61 |
62 | {{ i18n "password"}}: [[ inbound.password ]]
63 |
64 |
65 |
66 | {{ i18n "encryption"}}: [[ inbound.method ]]
67 | {{ i18n "password"}}: [[ inbound.password ]]
68 |
69 |
70 |
71 | {{ i18n "username"}}: [[ inbound.username ]]
72 | {{ i18n "password"}}: [[ inbound.password ]]
73 |
74 |
75 |
76 | {{ i18n "username"}}: [[ inbound.username ]]
77 | {{ i18n "password"}}: [[ inbound.password ]]
78 |
79 |
80 |
81 | {{template "inboundInfoStream"}}
82 |
83 |