1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
package engine
import (
"context"
"encoding/json"
"fmt"
"log"
"os"
"path/filepath"
"sync"
box "github.com/sagernet/sing-box"
"github.com/sagernet/sing-box/include"
"github.com/sagernet/sing-box/option"
"vpnem/internal/config"
"vpnem/internal/models"
)
type Engine struct {
mu sync.Mutex
instance *box.Box
cancel context.CancelFunc
running bool
configPath string
dataDir string
localProxyPort int
}
func New(dataDir string) *Engine {
return &Engine{
dataDir: dataDir,
configPath: filepath.Join(dataDir, "config.json"),
}
}
func (e *Engine) Start(server models.Server, mode config.Mode, ruleSets []models.RuleSet, serverIPs []string) error {
return e.StartFull(server, mode, ruleSets, serverIPs, nil, config.LocalProxyPort, nil)
}
func (e *Engine) StartFull(server models.Server, mode config.Mode, ruleSets []models.RuleSet, serverIPs []string, customBypass []string, localProxyPort int, policy *models.RoutingPolicy) error {
e.mu.Lock()
defer e.mu.Unlock()
if e.running {
return fmt.Errorf("already running")
}
cfg := config.BuildConfigFullWithLocalProxy(server, mode, ruleSets, serverIPs, customBypass, localProxyPort, policy)
data, err := json.MarshalIndent(cfg, "", " ")
if err != nil {
return fmt.Errorf("marshal config: %w", err)
}
os.MkdirAll(e.dataDir, 0o755)
_ = os.WriteFile(e.configPath, data, 0o644)
log.Printf("engine: config saved (%d bytes)", len(data))
var opts option.Options
ctx := include.Context(context.Background())
if err := opts.UnmarshalJSONContext(ctx, data); err != nil {
log.Printf("engine: parse FAILED: %v", err)
return fmt.Errorf("parse config: %w", err)
}
boxCtx, cancel := context.WithCancel(ctx)
e.cancel = cancel
instance, err := box.New(box.Options{
Context: boxCtx,
Options: opts,
})
if err != nil {
cancel()
log.Printf("engine: create FAILED: %v", err)
return fmt.Errorf("create sing-box: %w", err)
}
if err := instance.Start(); err != nil {
instance.Close()
cancel()
log.Printf("engine: start FAILED: %v", err)
return fmt.Errorf("start sing-box: %w", err)
}
e.instance = instance
e.running = true
e.localProxyPort = localProxyPort
log.Println("engine: started ok")
return nil
}
func (e *Engine) Stop() error {
e.mu.Lock()
defer e.mu.Unlock()
if !e.running {
return nil
}
if e.instance != nil {
e.instance.Close()
e.instance = nil
}
if e.cancel != nil {
e.cancel()
}
e.running = false
e.localProxyPort = 0
log.Println("engine: stopped")
return nil
}
func (e *Engine) Restart(server models.Server, mode config.Mode, ruleSets []models.RuleSet, serverIPs []string) error {
e.Stop()
return e.Start(server, mode, ruleSets, serverIPs)
}
func (e *Engine) RestartFull(server models.Server, mode config.Mode, ruleSets []models.RuleSet, serverIPs []string, customBypass []string, localProxyPort int, policy *models.RoutingPolicy) error {
e.Stop()
return e.StartFull(server, mode, ruleSets, serverIPs, customBypass, localProxyPort, policy)
}
func (e *Engine) IsRunning() bool {
e.mu.Lock()
defer e.mu.Unlock()
return e.running
}
func (e *Engine) ConfigPath() string {
return e.configPath
}
func (e *Engine) LocalProxyPort() int {
e.mu.Lock()
defer e.mu.Unlock()
return e.localProxyPort
}
|
