Update App version to 0.0.2

vpn.go

@@ -1,8 +1,12 @@
 package kvm
 
 import (
+	"bufio"
 	"encoding/json"
 	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"syscall"
 	"time"
 )
@@ -30,8 +34,6 @@ func rpcLoginTailScale(xEdge bool) (TailScaleSettings, error) {
 		IP:       "",
 	}
 
-	//fmt.Printf("[rpcLoginTailScale] xEdge: %v\n", xEdge)
-
 	_, err := CallVpnCtrlAction("login_tailscale", map[string]interface{}{"xEdge": xEdge})
 	if err != nil {
 		return settings, err
@@ -63,13 +65,19 @@ func rpcLoginTailScale(xEdge bool) (TailScaleSettings, error) {
 		case "logined":
 			config.TailScaleAutoStart = true
 			config.TailScaleXEdge = settings.XEdge
-			SaveConfig()
-			return settings, nil
+			err := SaveConfig()
+			if err != nil {
+				vpnLogger.Error().Err(err).Msg("failed to save config")
+			}
+			return settings, err
 		case "connected":
 			config.TailScaleAutoStart = true
 			config.TailScaleXEdge = settings.XEdge
-			SaveConfig()
-			return settings, nil
+			err = SaveConfig()
+			if err != nil {
+				vpnLogger.Error().Err(err).Msg("failed to save config")
+			}
+			return settings, err
 		case "connecting":
 			if i >= 10 {
 				settings.State = "disconnected"
@@ -77,7 +85,10 @@ func rpcLoginTailScale(xEdge bool) (TailScaleSettings, error) {
 				settings.State = "connecting"
 			}
 		case "cancel":
-			go rpcLogoutTailScale()
+			err := rpcLogoutTailScale()
+			if err != nil {
+				vpnLogger.Error().Err(err).Msg("failed to logout tailscale")
+			}
 			settings.State = "disconnected"
 			return settings, nil
 		default:
@@ -135,7 +146,6 @@ type ZeroTierSettings struct {
 
 func rpcLoginZeroTier(networkID string) (ZeroTierSettings, error) {
 	LoadConfig()
-	//fmt.Printf("[rpcLoginZeroTier] networkID: %s\n", networkID)
 	settings := ZeroTierSettings{
 		State:     "connecting",
 		NetworkID: networkID,
@@ -161,13 +171,14 @@ func rpcLoginZeroTier(networkID string) (ZeroTierSettings, error) {
 		}
 	}
 
-	if settings.State == "closed" {
+	switch settings.State {
+	case "closed":
 		config.ZeroTierAutoStart = false
 		config.ZeroTierNetworkID = ""
 		if err := SaveConfig(); err != nil {
 			vpnLogger.Error().Err(err).Msg("failed to save config")
 		}
-	} else if settings.State == "connected" || settings.State == "logined" {
+	case "connected", "logined":
 		config.ZeroTierAutoStart = true
 		config.ZeroTierNetworkID = settings.NetworkID
 		if err := SaveConfig(); err != nil {
@@ -243,27 +254,146 @@ func HandleVpnDisplayUpdateMessage(event CtrlResponse) {
 		return
 	}
 
-	if vpnUpdateDisplayState.TailScaleState == "connected" {
+	switch vpnUpdateDisplayState.TailScaleState {
+	case "connected":
 		updateLabelIfChanged("Network_TailScale_Label", "Connected")
-	} else if vpnUpdateDisplayState.TailScaleState == "logined" {
+	case "logined":
 		updateLabelIfChanged("Network_TailScale_Label", "Logined")
-	} else {
+	default:
 		updateLabelIfChanged("Network_TailScale_Label", "Disconnected")
 	}
 
-	if vpnUpdateDisplayState.ZeroTierState == "connected" {
+	switch vpnUpdateDisplayState.ZeroTierState {
+	case "connected":
 		updateLabelIfChanged("Network_ZeroTier_Label", "Connected")
-	} else if vpnUpdateDisplayState.ZeroTierState == "logined" {
+	case "logined":
 		updateLabelIfChanged("Network_ZeroTier_Label", "Logined")
-	} else {
+	default:
 		updateLabelIfChanged("Network_ZeroTier_Label", "Disconnected")
 	}
+}
 
+type FrpcStatus struct {
+	Running bool `json:"running"`
+}
+
+var (
+	frpcTomlPath = "/userdata/frpc/frpc.toml"
+	frpcLogPath  = "/tmp/frpc.log"
+)
+
+func frpcRunning() bool {
+	cmd := exec.Command("pgrep", "-x", "frpc")
+	return cmd.Run() == nil
+}
+
+func rpcGetFrpcLog() (string, error) {
+	f, err := os.Open(frpcLogPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", fmt.Errorf("frpc log file not exist")
+		}
+		return "", err
+	}
+	defer f.Close()
+
+	const want = 30
+	lines := make([]string, 0, want+10)
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		lines = append(lines, sc.Text())
+		if len(lines) > want {
+			lines = lines[1:]
+		}
+	}
+	if err := sc.Err(); err != nil {
+		return "", err
+	}
+
+	var buf []byte
+	for _, l := range lines {
+		buf = append(buf, l...)
+		buf = append(buf, '\n')
+	}
+	return string(buf), nil
+}
+
+func rpcGetFrpcToml() (string, error) {
+	return config.FrpcToml, nil
+}
+
+func rpcStartFrpc(frpcToml string) error {
+	if frpcRunning() {
+		_ = exec.Command("pkill", "-x", "frpc").Run()
+	}
+
+	if frpcToml != "" {
+		_ = os.MkdirAll(filepath.Dir(frpcTomlPath), 0700)
+		if err := os.WriteFile(frpcTomlPath, []byte(frpcToml), 0600); err != nil {
+			return err
+		}
+		cmd := exec.Command("frpc", "-c", frpcTomlPath)
+		cmd.Stdout = nil
+		cmd.Stderr = nil
+		logFile, err := os.OpenFile(frpcLogPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+		if err != nil {
+			return err
+		}
+		defer logFile.Close()
+		cmd.Stdout = logFile
+		cmd.Stderr = logFile
+
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+
+		if err := cmd.Start(); err != nil {
+			return fmt.Errorf("start frpc failed: %w", err)
+		} else {
+			config.FrpcAutoStart = true
+			config.FrpcToml = frpcToml
+			if err := SaveConfig(); err != nil {
+				return fmt.Errorf("failed to save config: %w", err)
+			}
+		}
+	} else {
+		return fmt.Errorf("frpcToml is empty")
+	}
+
+	return nil
+}
+
+func rpcStopFrpc() error {
+	if frpcRunning() {
+		err := exec.Command("pkill", "-x", "frpc").Run()
+		if err != nil {
+			return fmt.Errorf("failed to stop frpc: %w", err)
+		}
+	}
+
+	config.FrpcAutoStart = false
+	err := SaveConfig()
+	if err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+	return nil
+}
+
+func rpcGetFrpcStatus() (FrpcStatus, error) {
+	return FrpcStatus{Running: frpcRunning()}, nil
 }
 
 func initVPN() {
 	waitVpnCtrlClientConnected()
 	go func() {
+		for {
+			if !networkState.IsOnline() {
+				vpnLogger.Warn().Msg("waiting for network to be online, will retry in 3 seconds")
+				time.Sleep(3 * time.Second)
+				continue
+			} else {
+				break
+			}
+		}
+
 		if config.TailScaleAutoStart {
 			if _, err := rpcLoginTailScale(config.TailScaleXEdge); err != nil {
 				vpnLogger.Error().Err(err).Msg("Failed to auto start TailScale")
@@ -275,6 +405,12 @@ func initVPN() {
 				vpnLogger.Error().Err(err).Msg("Failed to auto start ZeroTier")
 			}
 		}
+
+		if config.FrpcAutoStart && config.FrpcToml != "" {
+			if err := rpcStartFrpc(config.FrpcToml); err != nil {
+				vpnLogger.Error().Err(err).Msg("Failed to auto start frpc")
+			}
+		}
 	}()
 
 	go func() {