sing-box/experimental/clashapi/proxies.go

259 lines
6.6 KiB
Go
Raw Normal View History

2022-07-19 14:16:49 +00:00
package clashapi
import (
"context"
2022-07-21 13:03:41 +00:00
"fmt"
2022-07-19 14:16:49 +00:00
"net/http"
2022-07-22 05:51:08 +00:00
"sort"
2022-07-21 13:03:41 +00:00
"strconv"
"time"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/common/badjson"
2022-07-22 05:51:08 +00:00
"github.com/sagernet/sing-box/common/urltest"
2022-07-21 13:03:41 +00:00
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/outbound"
"github.com/sagernet/sing/common"
F "github.com/sagernet/sing/common/format"
2022-07-29 16:29:22 +00:00
N "github.com/sagernet/sing/common/network"
2022-07-19 14:16:49 +00:00
"github.com/go-chi/chi/v5"
"github.com/go-chi/render"
)
2022-07-21 13:03:41 +00:00
func proxyRouter(server *Server, router adapter.Router) http.Handler {
2022-07-19 14:16:49 +00:00
r := chi.NewRouter()
2022-07-21 13:03:41 +00:00
r.Get("/", getProxies(server, router))
2022-07-19 14:16:49 +00:00
r.Route("/{name}", func(r chi.Router) {
2022-07-21 13:03:41 +00:00
r.Use(parseProxyName, findProxyByName(router))
r.Get("/", getProxy(server))
r.Get("/delay", getProxyDelay(server))
2022-07-19 14:16:49 +00:00
r.Put("/", updateProxy)
})
return r
}
func parseProxyName(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
name := getEscapeParam(r, "name")
ctx := context.WithValue(r.Context(), CtxKeyProxyName, name)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
2022-07-21 13:03:41 +00:00
func findProxyByName(router adapter.Router) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
name := r.Context().Value(CtxKeyProxyName).(string)
proxy, exist := router.Outbound(name)
if !exist {
render.Status(r, http.StatusNotFound)
render.JSON(w, r, ErrNotFound)
return
}
ctx := context.WithValue(r.Context(), CtxKeyProxy, proxy)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
}
2022-07-19 14:16:49 +00:00
2022-07-21 13:03:41 +00:00
func proxyInfo(server *Server, detour adapter.Outbound) *badjson.JSONObject {
var info badjson.JSONObject
var clashType string
2022-07-22 05:51:08 +00:00
var isGroup bool
2022-07-21 13:03:41 +00:00
switch detour.Type() {
case C.TypeDirect:
clashType = "Direct"
case C.TypeBlock:
clashType = "Reject"
case C.TypeSocks:
clashType = "Socks"
case C.TypeHTTP:
2022-09-14 15:02:11 +00:00
clashType = "HTTP"
2022-07-21 13:03:41 +00:00
case C.TypeShadowsocks:
clashType = "Shadowsocks"
case C.TypeVMess:
2022-09-14 15:02:11 +00:00
clashType = "VMess"
2022-09-08 10:19:41 +00:00
case C.TypeTrojan:
clashType = "Trojan"
2022-09-14 15:02:11 +00:00
case C.TypeHysteria:
clashType = "Hysteria"
case C.TypeWireGuard:
clashType = "WireGuard"
case C.TypeShadowsocksR:
clashType = "ShadowsocksR"
case C.TypeVLESS:
clashType = "VLESS"
case C.TypeTor:
clashType = "Tor"
case C.TypeSSH:
clashType = "SSH"
2022-07-21 13:03:41 +00:00
case C.TypeSelector:
clashType = "Selector"
2022-07-22 05:51:08 +00:00
isGroup = true
2022-07-21 13:03:41 +00:00
default:
2022-09-14 15:02:11 +00:00
clashType = "Direct"
2022-07-21 13:03:41 +00:00
}
info.Put("type", clashType)
info.Put("name", detour.Tag())
2022-07-29 16:29:22 +00:00
info.Put("udp", common.Contains(detour.Network(), N.NetworkUDP))
2022-07-28 08:36:31 +00:00
delayHistory := server.urlTestHistory.LoadURLTestHistory(adapter.OutboundTag(detour))
2022-07-22 05:51:08 +00:00
if delayHistory != nil {
info.Put("history", []*urltest.History{delayHistory})
2022-07-22 01:29:13 +00:00
} else {
2022-07-22 05:51:08 +00:00
info.Put("history", []*urltest.History{})
2022-07-22 01:29:13 +00:00
}
2022-07-22 05:51:08 +00:00
if isGroup {
selector := detour.(adapter.OutboundGroup)
info.Put("now", selector.Now())
info.Put("all", selector.All())
2022-07-21 13:03:41 +00:00
}
return &info
2022-07-19 14:16:49 +00:00
}
2022-07-21 13:03:41 +00:00
func getProxies(server *Server, router adapter.Router) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
var proxyMap badjson.JSONObject
2022-07-22 01:29:13 +00:00
outbounds := common.Filter(router.Outbounds(), func(detour adapter.Outbound) bool {
return detour.Tag() != ""
})
2022-07-21 13:03:41 +00:00
2022-07-22 01:29:13 +00:00
allProxies := make([]string, 0, len(outbounds))
for _, detour := range outbounds {
switch detour.Type() {
2022-07-28 08:40:06 +00:00
case C.TypeDirect, C.TypeBlock, C.TypeDNS:
2022-07-22 01:29:13 +00:00
continue
}
allProxies = append(allProxies, detour.Tag())
}
2022-07-29 16:29:22 +00:00
defaultTag := router.DefaultOutbound(N.NetworkTCP).Tag()
2022-07-22 01:29:13 +00:00
if defaultTag == "" {
defaultTag = allProxies[0]
}
sort.Slice(allProxies, func(i, j int) bool {
return allProxies[i] == defaultTag
2022-07-21 13:03:41 +00:00
})
2022-07-22 01:29:13 +00:00
// fix clash dashboard
2022-07-21 13:03:41 +00:00
proxyMap.Put("GLOBAL", map[string]any{
2022-07-22 01:29:13 +00:00
"type": "Fallback",
2022-07-21 13:03:41 +00:00
"name": "GLOBAL",
"udp": true,
2022-07-22 05:51:08 +00:00
"history": []*urltest.History{},
2022-07-22 01:29:13 +00:00
"all": allProxies,
"now": defaultTag,
2022-07-21 13:03:41 +00:00
})
for i, detour := range outbounds {
var tag string
if detour.Tag() == "" {
tag = F.ToString(i)
} else {
tag = detour.Tag()
}
proxyMap.Put(tag, proxyInfo(server, detour))
}
var responseMap badjson.JSONObject
responseMap.Put("proxies", &proxyMap)
response, err := responseMap.MarshalJSON()
if err != nil {
render.Status(r, http.StatusInternalServerError)
render.JSON(w, r, newError(err.Error()))
return
}
w.Write(response)
}
2022-07-19 14:16:49 +00:00
}
2022-07-21 13:03:41 +00:00
func getProxy(server *Server) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
proxy := r.Context().Value(CtxKeyProxy).(adapter.Outbound)
response, err := proxyInfo(server, proxy).MarshalJSON()
if err != nil {
render.Status(r, http.StatusInternalServerError)
render.JSON(w, r, newError(err.Error()))
return
}
w.Write(response)
}
2022-07-19 14:16:49 +00:00
}
type UpdateProxyRequest struct {
Name string `json:"name"`
}
func updateProxy(w http.ResponseWriter, r *http.Request) {
2022-07-21 13:03:41 +00:00
req := UpdateProxyRequest{}
if err := render.DecodeJSON(r.Body, &req); err != nil {
render.Status(r, http.StatusBadRequest)
render.JSON(w, r, ErrBadRequest)
return
}
2022-07-19 14:16:49 +00:00
2022-07-21 13:03:41 +00:00
proxy := r.Context().Value(CtxKeyProxy).(adapter.Outbound)
selector, ok := proxy.(*outbound.Selector)
if !ok {
render.Status(r, http.StatusBadRequest)
render.JSON(w, r, newError("Must be a Selector"))
return
}
2022-07-19 14:16:49 +00:00
2022-07-21 13:03:41 +00:00
if !selector.SelectOutbound(req.Name) {
render.Status(r, http.StatusBadRequest)
render.JSON(w, r, newError(fmt.Sprintf("Selector update error: not found")))
return
}
2022-07-19 14:16:49 +00:00
render.NoContent(w, r)
}
2022-07-21 13:03:41 +00:00
func getProxyDelay(server *Server) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
query := r.URL.Query()
2022-07-19 14:16:49 +00:00
url := query.Get("url")
timeout, err := strconv.ParseInt(query.Get("timeout"), 10, 16)
if err != nil {
render.Status(r, http.StatusBadRequest)
render.JSON(w, r, ErrBadRequest)
return
}
2022-07-21 13:03:41 +00:00
proxy := r.Context().Value(CtxKeyProxy).(adapter.Outbound)
2022-07-19 14:16:49 +00:00
ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*time.Duration(timeout))
defer cancel()
2022-07-22 05:51:08 +00:00
delay, err := urltest.URLTest(ctx, url, proxy)
defer func() {
realTag := outbound.RealTag(proxy)
if err != nil {
2022-07-28 08:36:31 +00:00
server.urlTestHistory.DeleteURLTestHistory(realTag)
2022-07-22 05:51:08 +00:00
} else {
2022-07-28 08:36:31 +00:00
server.urlTestHistory.StoreURLTestHistory(realTag, &urltest.History{
2022-07-22 05:51:08 +00:00
Time: time.Now(),
Delay: delay,
})
}
}()
2022-07-19 14:16:49 +00:00
if ctx.Err() != nil {
render.Status(r, http.StatusGatewayTimeout)
render.JSON(w, r, ErrRequestTimeout)
return
}
if err != nil || delay == 0 {
render.Status(r, http.StatusServiceUnavailable)
render.JSON(w, r, newError("An error occurred in the delay test"))
return
}
2022-07-21 13:03:41 +00:00
render.JSON(w, r, render.M{
"delay": delay,
})
}
}