clash/hub/route/server.go

248 lines
5.2 KiB
Go
Raw Normal View History

2018-11-21 05:47:46 +00:00
package route
2018-06-18 03:31:49 +00:00
import (
"bytes"
2018-06-18 03:31:49 +00:00
"encoding/json"
"net"
2018-06-18 03:31:49 +00:00
"net/http"
2018-10-06 05:15:02 +00:00
"strings"
2018-06-18 03:31:49 +00:00
"time"
2019-09-13 09:44:30 +00:00
C "github.com/Dreamacro/clash/constant"
_ "github.com/Dreamacro/clash/constant/mime"
2018-11-21 05:47:46 +00:00
"github.com/Dreamacro/clash/log"
"github.com/Dreamacro/clash/tunnel/statistic"
2018-06-18 03:31:49 +00:00
2021-04-03 06:59:03 +00:00
"github.com/go-chi/chi/v5"
2018-07-19 01:31:53 +00:00
"github.com/go-chi/cors"
2018-06-18 03:31:49 +00:00
"github.com/go-chi/render"
"github.com/gorilla/websocket"
2018-06-18 03:31:49 +00:00
)
2018-11-21 05:47:46 +00:00
var (
serverSecret = ""
serverAddr = ""
2018-12-19 17:29:13 +00:00
uiPath = ""
2019-09-30 06:13:29 +00:00
upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool {
return true
},
}
2018-11-21 05:47:46 +00:00
)
2018-10-06 05:15:02 +00:00
2018-06-18 03:31:49 +00:00
type Traffic struct {
Up int64 `json:"up"`
Down int64 `json:"down"`
}
2018-12-19 17:29:13 +00:00
func SetUIPath(path string) {
uiPath = C.Path.Resolve(path)
2018-12-19 17:29:13 +00:00
}
2018-11-21 05:47:46 +00:00
func Start(addr string, secret string) {
if serverAddr != "" {
return
}
2018-11-21 05:47:46 +00:00
serverAddr = addr
serverSecret = secret
2018-06-18 03:31:49 +00:00
r := chi.NewRouter()
2022-04-23 18:07:57 +00:00
corsM := cors.New(cors.Options{
2018-07-19 01:31:53 +00:00
AllowedOrigins: []string{"*"},
2018-12-29 06:11:54 +00:00
AllowedMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE"},
2018-10-06 05:15:02 +00:00
AllowedHeaders: []string{"Content-Type", "Authorization"},
2018-07-19 01:31:53 +00:00
MaxAge: 300,
})
2022-04-23 18:07:57 +00:00
r.Use(corsM.Handler)
r.Group(func(r chi.Router) {
r.Use(authentication)
2020-02-21 10:00:19 +00:00
r.Get("/", hello)
r.Get("/logs", getLogs)
r.Get("/traffic", traffic)
2019-09-13 09:44:30 +00:00
r.Get("/version", version)
r.Mount("/configs", configRouter())
r.Mount("/proxies", proxyRouter())
r.Mount("/rules", ruleRouter())
r.Mount("/connections", connectionRouter())
r.Mount("/providers/proxies", proxyProviderRouter())
2021-12-02 14:56:17 +00:00
r.Mount("/providers/rules", ruleProviderRouter())
2022-01-05 11:28:54 +00:00
r.Mount("/script", scriptRouter())
2022-03-22 17:05:43 +00:00
r.Mount("/cache", cacheRouter())
})
2018-06-18 03:31:49 +00:00
2018-12-19 17:29:13 +00:00
if uiPath != "" {
r.Group(func(r chi.Router) {
fs := http.StripPrefix("/ui", http.FileServer(http.Dir(uiPath)))
2019-09-08 14:33:52 +00:00
r.Get("/ui", http.RedirectHandler("/ui/", http.StatusTemporaryRedirect).ServeHTTP)
r.Get("/ui/*", func(w http.ResponseWriter, r *http.Request) {
fs.ServeHTTP(w, r)
})
2018-12-19 17:29:13 +00:00
})
}
l, err := net.Listen("tcp", addr)
2018-06-18 03:31:49 +00:00
if err != nil {
log.Errorln("External controller listen error: %s", err)
return
}
serverAddr = l.Addr().String()
log.Infoln("RESTful API listening at: %s", serverAddr)
if err = http.Serve(l, r); err != nil {
log.Errorln("External controller serve error: %s", err)
2018-06-18 03:31:49 +00:00
}
}
2018-10-06 05:15:02 +00:00
func authentication(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
2018-11-21 05:47:46 +00:00
if serverSecret == "" {
2018-10-06 05:15:02 +00:00
next.ServeHTTP(w, r)
return
}
2019-09-30 06:13:29 +00:00
// Browser websocket not support custom header
if websocket.IsWebSocketUpgrade(r) && r.URL.Query().Get("token") != "" {
token := r.URL.Query().Get("token")
if token != serverSecret {
render.Status(r, http.StatusUnauthorized)
render.JSON(w, r, ErrUnauthorized)
return
}
next.ServeHTTP(w, r)
return
}
header := r.Header.Get("Authorization")
2022-03-16 04:10:13 +00:00
bearer, token, found := strings.Cut(header, " ")
2019-09-30 06:13:29 +00:00
2022-03-16 04:10:13 +00:00
hasInvalidHeader := bearer != "Bearer"
hasInvalidSecret := !found || token != serverSecret
2020-04-24 15:49:35 +00:00
if hasInvalidHeader || hasInvalidSecret {
2018-12-10 03:33:37 +00:00
render.Status(r, http.StatusUnauthorized)
render.JSON(w, r, ErrUnauthorized)
2018-10-06 05:15:02 +00:00
return
}
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
}
2018-12-29 06:11:54 +00:00
func hello(w http.ResponseWriter, r *http.Request) {
render.JSON(w, r, render.M{"hello": "clash.meta"})
2018-12-29 06:11:54 +00:00
}
2018-06-18 03:31:49 +00:00
func traffic(w http.ResponseWriter, r *http.Request) {
var wsConn *websocket.Conn
if websocket.IsWebSocketUpgrade(r) {
var err error
wsConn, err = upgrader.Upgrade(w, r, nil)
if err != nil {
return
}
}
if wsConn == nil {
w.Header().Set("Content-Type", "application/json")
render.Status(r, http.StatusOK)
}
2018-06-18 03:31:49 +00:00
tick := time.NewTicker(time.Second)
2020-07-12 16:25:54 +00:00
defer tick.Stop()
t := statistic.DefaultManager
buf := &bytes.Buffer{}
var err error
2018-06-18 03:31:49 +00:00
for range tick.C {
buf.Reset()
2018-06-18 03:31:49 +00:00
up, down := t.Now()
if err := json.NewEncoder(buf).Encode(Traffic{
2018-06-18 03:31:49 +00:00
Up: up,
Down: down,
}); err != nil {
break
}
if wsConn == nil {
_, err = w.Write(buf.Bytes())
w.(http.Flusher).Flush()
} else {
err = wsConn.WriteMessage(websocket.TextMessage, buf.Bytes())
}
if err != nil {
break
}
2018-06-18 03:31:49 +00:00
}
}
2018-06-22 05:15:20 +00:00
type Log struct {
Type string `json:"type"`
Payload string `json:"payload"`
}
2018-06-18 03:31:49 +00:00
func getLogs(w http.ResponseWriter, r *http.Request) {
2018-08-12 11:35:13 +00:00
levelText := r.URL.Query().Get("level")
if levelText == "" {
levelText = "info"
2018-06-22 05:15:20 +00:00
}
2018-11-21 05:47:46 +00:00
level, ok := log.LogLevelMapping[levelText]
2018-06-22 05:15:20 +00:00
if !ok {
2018-12-10 03:33:37 +00:00
render.Status(r, http.StatusBadRequest)
render.JSON(w, r, ErrBadRequest)
2018-06-22 05:15:20 +00:00
return
}
var wsConn *websocket.Conn
if websocket.IsWebSocketUpgrade(r) {
var err error
wsConn, err = upgrader.Upgrade(w, r, nil)
if err != nil {
return
}
}
if wsConn == nil {
w.Header().Set("Content-Type", "application/json")
render.Status(r, http.StatusOK)
}
2018-11-21 05:47:46 +00:00
sub := log.Subscribe()
defer log.UnSubscribe(sub)
buf := &bytes.Buffer{}
var err error
2018-06-18 03:31:49 +00:00
for elm := range sub {
buf.Reset()
2022-04-23 18:07:57 +00:00
logM := elm
if logM.LogLevel < level {
2018-06-22 05:15:20 +00:00
continue
}
if err := json.NewEncoder(buf).Encode(Log{
2022-04-23 18:07:57 +00:00
Type: logM.Type(),
Payload: logM.Payload,
2018-06-18 03:31:49 +00:00
}); err != nil {
break
}
if wsConn == nil {
_, err = w.Write(buf.Bytes())
w.(http.Flusher).Flush()
} else {
err = wsConn.WriteMessage(websocket.TextMessage, buf.Bytes())
}
if err != nil {
break
}
2018-06-18 03:31:49 +00:00
}
}
2019-09-13 09:44:30 +00:00
func version(w http.ResponseWriter, r *http.Request) {
2021-12-03 13:54:45 +00:00
render.JSON(w, r, render.M{"meta": C.Meta, "version": C.Version})
2019-09-13 09:44:30 +00:00
}