mirror of
https://github.com/wyx2685/V2bX.git
synced 2026-02-04 12:40:11 +00:00
change project structure, fix online ip report bug
This commit is contained in:
yuzuki999
78
api/panel/api.go
Normal file
78
api/panel/api.go
Normal file
@@ -0,0 +1,78 @@
|
||||
// Package api contains all the api used by XrayR
|
||||
// To implement an api , one needs to implement the interface below.
|
||||
|
||||
package panel
|
||||
|
||||
import (
|
||||
"github.com/Yuzuki616/V2bX/conf"
|
||||
"github.com/go-resty/resty/v2"
|
||||
"log"
|
||||
"strconv"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Panel is the interface for different panel's api.
|
||||
|
||||
type ClientInfo struct {
|
||||
APIHost string
|
||||
NodeID int
|
||||
Key string
|
||||
NodeType string
|
||||
}
|
||||
|
||||
type Client struct {
|
||||
client *resty.Client
|
||||
APIHost string
|
||||
NodeID int
|
||||
Key string
|
||||
NodeType string
|
||||
//EnableSS2022 bool
|
||||
EnableVless bool
|
||||
EnableXTLS bool
|
||||
SpeedLimit float64
|
||||
DeviceLimit int
|
||||
LocalRuleList []DetectRule
|
||||
RemoteRuleCache *[]Rule
|
||||
access sync.Mutex
|
||||
NodeInfoRspMd5 [16]byte
|
||||
NodeRuleRspMd5 [16]byte
|
||||
}
|
||||
|
||||
func New(apiConfig *conf.ApiConfig) Panel {
|
||||
client := resty.New()
|
||||
client.SetRetryCount(3)
|
||||
if apiConfig.Timeout > 0 {
|
||||
client.SetTimeout(time.Duration(apiConfig.Timeout) * time.Second)
|
||||
} else {
|
||||
client.SetTimeout(5 * time.Second)
|
||||
}
|
||||
client.OnError(func(req *resty.Request, err error) {
|
||||
if v, ok := err.(*resty.ResponseError); ok {
|
||||
// v.Response contains the last response from the server
|
||||
// v.Err contains the original error
|
||||
log.Print(v.Err)
|
||||
}
|
||||
})
|
||||
client.SetBaseURL(apiConfig.APIHost)
|
||||
// Create Key for each requests
|
||||
client.SetQueryParams(map[string]string{
|
||||
"node_id": strconv.Itoa(apiConfig.NodeID),
|
||||
"token": apiConfig.Key,
|
||||
})
|
||||
// Read local rule list
|
||||
localRuleList := readLocalRuleList(apiConfig.RuleListPath)
|
||||
return &Client{
|
||||
client: client,
|
||||
NodeID: apiConfig.NodeID,
|
||||
Key: apiConfig.Key,
|
||||
APIHost: apiConfig.APIHost,
|
||||
NodeType: apiConfig.NodeType,
|
||||
//EnableSS2022: apiConfig.EnableSS2022,
|
||||
EnableVless: apiConfig.EnableVless,
|
||||
EnableXTLS: apiConfig.EnableXTLS,
|
||||
SpeedLimit: apiConfig.SpeedLimit,
|
||||
DeviceLimit: apiConfig.DeviceLimit,
|
||||
LocalRuleList: localRuleList,
|
||||
}
|
||||
}
|
||||
272
api/panel/node.go
Normal file
272
api/panel/node.go
Normal file
@@ -0,0 +1,272 @@
|
||||
package panel
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
md52 "crypto/md5"
|
||||
"fmt"
|
||||
"github.com/go-resty/resty/v2"
|
||||
"github.com/goccy/go-json"
|
||||
"github.com/xtls/xray-core/infra/conf"
|
||||
"log"
|
||||
"os"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
type DetectRule struct {
|
||||
ID int
|
||||
Pattern *regexp.Regexp
|
||||
}
|
||||
type DetectResult struct {
|
||||
UID int
|
||||
RuleID int
|
||||
}
|
||||
|
||||
// readLocalRuleList reads the local rule list file
|
||||
func readLocalRuleList(path string) (LocalRuleList []DetectRule) {
|
||||
LocalRuleList = make([]DetectRule, 0)
|
||||
if path != "" {
|
||||
// open the file
|
||||
file, err := os.Open(path)
|
||||
|
||||
//handle errors while opening
|
||||
if err != nil {
|
||||
log.Printf("Error when opening file: %s", err)
|
||||
return LocalRuleList
|
||||
}
|
||||
|
||||
fileScanner := bufio.NewScanner(file)
|
||||
|
||||
// read line by line
|
||||
for fileScanner.Scan() {
|
||||
LocalRuleList = append(LocalRuleList, DetectRule{
|
||||
ID: -1,
|
||||
Pattern: regexp.MustCompile(fileScanner.Text()),
|
||||
})
|
||||
}
|
||||
// handle first encountered error while reading
|
||||
if err := fileScanner.Err(); err != nil {
|
||||
log.Fatalf("Error while reading file: %s", err)
|
||||
return []DetectRule{}
|
||||
}
|
||||
file.Close()
|
||||
}
|
||||
|
||||
return LocalRuleList
|
||||
}
|
||||
|
||||
type NodeInfo struct {
|
||||
DeviceLimit int
|
||||
SpeedLimit uint64
|
||||
NodeType string
|
||||
NodeId int
|
||||
TLSType string
|
||||
EnableVless bool
|
||||
EnableTls bool
|
||||
//EnableSS2022 bool
|
||||
V2ray *V2rayConfig
|
||||
Trojan *TrojanConfig
|
||||
SS *SSConfig
|
||||
}
|
||||
|
||||
type SSConfig struct {
|
||||
Port int `json:"port"`
|
||||
TransportProtocol string `json:"transportProtocol"`
|
||||
CypherMethod string `json:"cypher"`
|
||||
}
|
||||
type V2rayConfig struct {
|
||||
Inbounds []conf.InboundDetourConfig `json:"inbounds"`
|
||||
Routing *struct {
|
||||
Rules json.RawMessage `json:"rules"`
|
||||
} `json:"routing"`
|
||||
}
|
||||
|
||||
type Rule struct {
|
||||
Type string `json:"type"`
|
||||
InboundTag string `json:"inboundTag,omitempty"`
|
||||
OutboundTag string `json:"outboundTag"`
|
||||
Domain []string `json:"domain,omitempty"`
|
||||
Protocol []string `json:"protocol,omitempty"`
|
||||
}
|
||||
|
||||
type TrojanConfig struct {
|
||||
LocalPort int `json:"local_port"`
|
||||
Password []interface{} `json:"password"`
|
||||
TransportProtocol string
|
||||
Ssl struct {
|
||||
Sni string `json:"sni"`
|
||||
} `json:"ssl"`
|
||||
}
|
||||
|
||||
// GetNodeInfo will pull NodeInfo Config from sspanel
|
||||
func (c *Client) GetNodeInfo() (nodeInfo *NodeInfo, err error) {
|
||||
var path string
|
||||
var res *resty.Response
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
path = "/api/v1/server/Deepbwork/config"
|
||||
case "Trojan":
|
||||
path = "/api/v1/server/TrojanTidalab/config"
|
||||
case "Shadowsocks":
|
||||
if nodeInfo, err = c.ParseSSNodeResponse(); err == nil {
|
||||
return nodeInfo, nil
|
||||
} else {
|
||||
return nil, err
|
||||
}
|
||||
default:
|
||||
return nil, fmt.Errorf("unsupported Node type: %s", c.NodeType)
|
||||
}
|
||||
res, err = c.client.R().
|
||||
SetQueryParam("local_port", "1").
|
||||
ForceContentType("application/json").
|
||||
Get(path)
|
||||
err = c.checkResponse(res, path, err)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
c.access.Lock()
|
||||
defer c.access.Unlock()
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
i := bytes.Index(res.Body(), []byte("outbo"))
|
||||
md := md52.Sum(res.Body()[:i])
|
||||
nodeNotIsChange := true
|
||||
if c.NodeInfoRspMd5 == [16]byte{} {
|
||||
nodeNotIsChange = false
|
||||
c.NodeInfoRspMd5 = md
|
||||
} else {
|
||||
if c.NodeInfoRspMd5 != md {
|
||||
nodeNotIsChange = false
|
||||
c.NodeInfoRspMd5 = md
|
||||
}
|
||||
}
|
||||
md2 := md52.Sum(res.Body()[i:])
|
||||
ruleIsChange := false
|
||||
if c.NodeRuleRspMd5 != md2 {
|
||||
ruleIsChange = true
|
||||
c.NodeRuleRspMd5 = md2
|
||||
}
|
||||
nodeInfo, err = c.ParseV2rayNodeResponse(res.Body(), nodeNotIsChange, ruleIsChange)
|
||||
case "Trojan":
|
||||
md := md52.Sum(res.Body())
|
||||
if c.NodeInfoRspMd5 != [16]byte{} {
|
||||
if c.NodeInfoRspMd5 == md {
|
||||
return nil, nil
|
||||
}
|
||||
}
|
||||
c.NodeInfoRspMd5 = md
|
||||
nodeInfo, err = c.ParseTrojanNodeResponse(res.Body())
|
||||
}
|
||||
return nodeInfo, nil
|
||||
}
|
||||
|
||||
func (c *Client) GetNodeRule() ([]DetectRule, []string, error) {
|
||||
ruleList := c.LocalRuleList
|
||||
if c.NodeType != "V2ray" || c.RemoteRuleCache == nil {
|
||||
return ruleList, nil, nil
|
||||
}
|
||||
// V2board only support the rule for v2ray
|
||||
// fix: reuse config response
|
||||
c.access.Lock()
|
||||
defer c.access.Unlock()
|
||||
if len(*c.RemoteRuleCache) >= 2 {
|
||||
for i, rule := range (*c.RemoteRuleCache)[1].Domain {
|
||||
ruleListItem := DetectRule{
|
||||
ID: i,
|
||||
Pattern: regexp.MustCompile(rule),
|
||||
}
|
||||
ruleList = append(ruleList, ruleListItem)
|
||||
}
|
||||
}
|
||||
var protocolList []string
|
||||
if len(*c.RemoteRuleCache) >= 3 {
|
||||
for _, str := range (*c.RemoteRuleCache)[2].Protocol {
|
||||
protocolList = append(protocolList, str)
|
||||
}
|
||||
}
|
||||
c.RemoteRuleCache = nil
|
||||
return ruleList, protocolList, nil
|
||||
}
|
||||
|
||||
// ParseTrojanNodeResponse parse the response for the given nodeinfor format
|
||||
func (c *Client) ParseTrojanNodeResponse(body []byte) (*NodeInfo, error) {
|
||||
node := &NodeInfo{Trojan: &TrojanConfig{}}
|
||||
var err = json.Unmarshal(body, node.Trojan)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unmarshal nodeinfo error: %s", err)
|
||||
}
|
||||
node.SpeedLimit = uint64(c.SpeedLimit * 1000000 / 8)
|
||||
node.DeviceLimit = c.DeviceLimit
|
||||
node.NodeId = c.NodeID
|
||||
node.NodeType = c.NodeType
|
||||
node.Trojan.TransportProtocol = "tcp"
|
||||
return node, nil
|
||||
}
|
||||
|
||||
// ParseSSNodeResponse parse the response for the given nodeinfor format
|
||||
func (c *Client) ParseSSNodeResponse() (*NodeInfo, error) {
|
||||
var port int
|
||||
var method string
|
||||
userInfo, err := c.GetUserList()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(userInfo) > 0 {
|
||||
port = userInfo[0].Port
|
||||
method = userInfo[0].Cipher
|
||||
} else {
|
||||
return nil, fmt.Errorf("shadowsocks node need a active user")
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
node := &NodeInfo{
|
||||
SpeedLimit: uint64(c.SpeedLimit * 1000000 / 8),
|
||||
DeviceLimit: c.DeviceLimit,
|
||||
//EnableSS2022: c.EnableSS2022,
|
||||
NodeType: c.NodeType,
|
||||
NodeId: c.NodeID,
|
||||
SS: &SSConfig{
|
||||
Port: port,
|
||||
TransportProtocol: "tcp",
|
||||
CypherMethod: method,
|
||||
},
|
||||
}
|
||||
return node, nil
|
||||
}
|
||||
|
||||
// ParseV2rayNodeResponse parse the response for the given nodeinfor format
|
||||
func (c *Client) ParseV2rayNodeResponse(body []byte, notParseNode, parseRule bool) (*NodeInfo, error) {
|
||||
if notParseNode && !parseRule {
|
||||
return nil, nil
|
||||
}
|
||||
node := &NodeInfo{V2ray: &V2rayConfig{}}
|
||||
err := json.Unmarshal(body, node.V2ray)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unmarshal nodeinfo error: %s", err)
|
||||
}
|
||||
if parseRule {
|
||||
c.RemoteRuleCache = &[]Rule{}
|
||||
err := json.Unmarshal(node.V2ray.Routing.Rules, c.RemoteRuleCache)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
}
|
||||
if notParseNode {
|
||||
return nil, nil
|
||||
}
|
||||
}
|
||||
node.V2ray.Routing = nil
|
||||
node.SpeedLimit = uint64(c.SpeedLimit * 1000000 / 8)
|
||||
node.DeviceLimit = c.DeviceLimit
|
||||
node.NodeType = c.NodeType
|
||||
node.NodeId = c.NodeID
|
||||
if c.EnableXTLS {
|
||||
node.TLSType = "xtls"
|
||||
} else {
|
||||
node.TLSType = "tls"
|
||||
}
|
||||
node.EnableVless = c.EnableVless
|
||||
node.EnableTls = node.V2ray.Inbounds[0].StreamSetting.Security == "tls"
|
||||
return node, nil
|
||||
}
|
||||
10
api/panel/panel.go
Normal file
10
api/panel/panel.go
Normal file
@@ -0,0 +1,10 @@
|
||||
package panel
|
||||
|
||||
type Panel interface {
|
||||
GetNodeInfo() (nodeInfo *NodeInfo, err error)
|
||||
GetUserList() (userList []UserInfo, err error)
|
||||
ReportUserTraffic(userTraffic []UserTraffic) (err error)
|
||||
Describe() ClientInfo
|
||||
GetNodeRule() (ruleList []DetectRule, protocolList []string, err error)
|
||||
Debug()
|
||||
}
|
||||
111
api/panel/user.go
Normal file
111
api/panel/user.go
Normal file
@@ -0,0 +1,111 @@
|
||||
package panel
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/goccy/go-json"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
type OnlineUser struct {
|
||||
UID int
|
||||
IP string
|
||||
}
|
||||
|
||||
type V2RayUserInfo struct {
|
||||
Uuid string `json:"uuid"`
|
||||
Email string `json:"email"`
|
||||
AlterId int `json:"alter_id"`
|
||||
}
|
||||
type TrojanUserInfo struct {
|
||||
Password string `json:"password"`
|
||||
}
|
||||
type UserInfo struct {
|
||||
/*DeviceLimit int `json:"device_limit"`
|
||||
SpeedLimit uint64 `json:"speed_limit"`*/
|
||||
UID int `json:"id"`
|
||||
Port int `json:"port"`
|
||||
Cipher string `json:"cipher"`
|
||||
Secret string `json:"secret"`
|
||||
V2rayUser *V2RayUserInfo `json:"v2ray_user"`
|
||||
TrojanUser *TrojanUserInfo `json:"trojan_user"`
|
||||
}
|
||||
|
||||
func (p *UserInfo) GetUserEmail() string {
|
||||
if p.V2rayUser != nil {
|
||||
return p.V2rayUser.Email
|
||||
} else if p.TrojanUser != nil {
|
||||
return p.TrojanUser.Password
|
||||
}
|
||||
return p.Cipher
|
||||
}
|
||||
|
||||
type UserListBody struct {
|
||||
//Msg string `json:"msg"`
|
||||
Data []UserInfo `json:"data"`
|
||||
}
|
||||
|
||||
// GetUserList will pull user form sspanel
|
||||
func (c *Client) GetUserList() (UserList []UserInfo, err error) {
|
||||
var path string
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
path = "/api/v1/server/Deepbwork/user"
|
||||
case "Trojan":
|
||||
path = "/api/v1/server/TrojanTidalab/user"
|
||||
case "Shadowsocks":
|
||||
path = "/api/v1/server/ShadowsocksTidalab/user"
|
||||
default:
|
||||
return nil, fmt.Errorf("unsupported Node type: %s", c.NodeType)
|
||||
}
|
||||
res, err := c.client.R().
|
||||
ForceContentType("application/json").
|
||||
Get(path)
|
||||
err = c.checkResponse(res, path, err)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var userList *UserListBody
|
||||
err = json.Unmarshal(res.Body(), &userList)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("unmarshal userlist error: %s", err)
|
||||
}
|
||||
return userList.Data, nil
|
||||
}
|
||||
|
||||
type UserTraffic struct {
|
||||
UID int `json:"user_id"`
|
||||
Upload int64 `json:"u"`
|
||||
Download int64 `json:"d"`
|
||||
}
|
||||
|
||||
// ReportUserTraffic reports the user traffic
|
||||
func (c *Client) ReportUserTraffic(userTraffic []UserTraffic) error {
|
||||
var path string
|
||||
switch c.NodeType {
|
||||
case "V2ray":
|
||||
path = "/api/v1/server/Deepbwork/submit"
|
||||
case "Trojan":
|
||||
path = "/api/v1/server/TrojanTidalab/submit"
|
||||
case "Shadowsocks":
|
||||
path = "/api/v1/server/ShadowsocksTidalab/submit"
|
||||
}
|
||||
|
||||
data := make([]UserTraffic, len(userTraffic))
|
||||
for i, traffic := range userTraffic {
|
||||
data[i] = UserTraffic{
|
||||
UID: traffic.UID,
|
||||
Upload: traffic.Upload,
|
||||
Download: traffic.Download}
|
||||
}
|
||||
|
||||
res, err := c.client.R().
|
||||
SetQueryParam("node_id", strconv.Itoa(c.NodeID)).
|
||||
SetBody(data).
|
||||
ForceContentType("application/json").
|
||||
Post(path)
|
||||
err = c.checkResponse(res, path, err)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
31
api/panel/utils.go
Normal file
31
api/panel/utils.go
Normal file
@@ -0,0 +1,31 @@
|
||||
package panel
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/go-resty/resty/v2"
|
||||
)
|
||||
|
||||
// Describe return a description of the client
|
||||
func (c *Client) Describe() ClientInfo {
|
||||
return ClientInfo{APIHost: c.APIHost, NodeID: c.NodeID, Key: c.Key, NodeType: c.NodeType}
|
||||
}
|
||||
|
||||
// Debug set the client debug for client
|
||||
func (c *Client) Debug() {
|
||||
c.client.SetDebug(true)
|
||||
}
|
||||
|
||||
func (c *Client) assembleURL(path string) string {
|
||||
return c.APIHost + path
|
||||
}
|
||||
func (c *Client) checkResponse(res *resty.Response, path string, err error) error {
|
||||
if err != nil {
|
||||
return fmt.Errorf("request %s failed: %s", c.assembleURL(path), err)
|
||||
}
|
||||
|
||||
if res.StatusCode() > 400 {
|
||||
body := res.Body()
|
||||
return fmt.Errorf("request %s failed: %s, %s", c.assembleURL(path), string(body), err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user