186 lines
3.3 KiB
Go
186 lines
3.3 KiB
Go
package xray
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sync"
|
|
"time"
|
|
|
|
"vpnclient/internal/config"
|
|
)
|
|
|
|
// Engine runs official XTLS/Xray-core for VLESS / VMess / Trojan.
|
|
type Engine struct {
|
|
mu sync.Mutex
|
|
cmd *exec.Cmd
|
|
cancel context.CancelFunc
|
|
done chan struct{}
|
|
workdir string
|
|
profile config.Profile
|
|
stderr io.Writer
|
|
running bool
|
|
proto config.Protocol
|
|
}
|
|
|
|
func New(stderr io.Writer) *Engine {
|
|
if stderr == nil {
|
|
stderr = os.Stderr
|
|
}
|
|
return &Engine{stderr: stderr}
|
|
}
|
|
|
|
func (e *Engine) Protocol() config.Protocol {
|
|
if e.proto != "" {
|
|
return e.proto
|
|
}
|
|
return config.ProtocolVLESS
|
|
}
|
|
|
|
func (e *Engine) Start(ctx context.Context, profile config.Profile, binDir string) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
if e.running {
|
|
return fmt.Errorf("xray: already running")
|
|
}
|
|
|
|
link, err := Parse(profile.Proxy)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
e.proto = link.Protocol
|
|
|
|
bin, err := ResolveBinary(binDir)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
workdir, err := os.MkdirTemp("", "vpnclient-xray-*")
|
|
if err != nil {
|
|
return fmt.Errorf("xray: temp dir: %w", err)
|
|
}
|
|
cfgPath := filepath.Join(workdir, "config.json")
|
|
if err := writeRuntimeConfig(cfgPath, profile); err != nil {
|
|
os.RemoveAll(workdir)
|
|
return err
|
|
}
|
|
|
|
runCtx, cancel := context.WithCancel(context.Background())
|
|
cmd := exec.CommandContext(runCtx, bin, "run", "-c", cfgPath)
|
|
cmd.Dir = workdir
|
|
cmd.Stdout = e.stderr
|
|
cmd.Stderr = e.stderr
|
|
applySysProcAttr(cmd)
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
cancel()
|
|
os.RemoveAll(workdir)
|
|
return fmt.Errorf("xray: start %s: %w", bin, err)
|
|
}
|
|
|
|
done := make(chan struct{})
|
|
e.cmd = cmd
|
|
e.cancel = cancel
|
|
e.done = done
|
|
e.workdir = workdir
|
|
e.profile = profile
|
|
e.running = true
|
|
|
|
go func() {
|
|
err := cmd.Wait()
|
|
if err != nil {
|
|
fmt.Fprintf(e.stderr, "xray: process ended: %v\n", err)
|
|
}
|
|
e.mu.Lock()
|
|
e.cleanupLocked()
|
|
e.mu.Unlock()
|
|
close(done)
|
|
}()
|
|
|
|
e.mu.Unlock()
|
|
timer := time.NewTimer(900 * time.Millisecond)
|
|
defer timer.Stop()
|
|
var startErr error
|
|
select {
|
|
case <-done:
|
|
startErr = fmt.Errorf("xray: process exited immediately; check link and install-core (xray)")
|
|
case <-ctx.Done():
|
|
_ = e.Stop()
|
|
startErr = ctx.Err()
|
|
case <-timer.C:
|
|
e.mu.Lock()
|
|
alive := e.running
|
|
e.mu.Unlock()
|
|
if !alive {
|
|
startErr = fmt.Errorf("xray: process exited during startup")
|
|
}
|
|
}
|
|
e.mu.Lock()
|
|
return startErr
|
|
}
|
|
|
|
func (e *Engine) Stop() error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
return e.stopLocked()
|
|
}
|
|
|
|
func (e *Engine) stopLocked() error {
|
|
if !e.running || e.cmd == nil {
|
|
return nil
|
|
}
|
|
done := e.done
|
|
if e.cancel != nil {
|
|
e.cancel()
|
|
}
|
|
proc := e.cmd.Process
|
|
e.mu.Unlock()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(2 * time.Second):
|
|
if proc != nil {
|
|
_ = proc.Kill()
|
|
}
|
|
<-done
|
|
}
|
|
e.mu.Lock()
|
|
return nil
|
|
}
|
|
|
|
func (e *Engine) cleanupLocked() {
|
|
if e.workdir != "" {
|
|
_ = os.RemoveAll(e.workdir)
|
|
e.workdir = ""
|
|
}
|
|
e.cmd = nil
|
|
e.cancel = nil
|
|
e.running = false
|
|
}
|
|
|
|
func (e *Engine) Running() bool {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
return e.running
|
|
}
|
|
|
|
func (e *Engine) LocalHTTPProxy() (string, bool) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
if !e.running {
|
|
return "", false
|
|
}
|
|
return e.profile.HTTPListenHostPort()
|
|
}
|
|
|
|
func (e *Engine) LocalSOCKSProxy() (string, bool) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
if !e.running {
|
|
return "", false
|
|
}
|
|
return e.profile.SOCKSListenHostPort()
|
|
}
|