mirror of
https://github.com/luckfox-eng29/kvm.git
synced 2026-01-17 19:22:15 +01:00
437 lines
12 KiB
Go
437 lines
12 KiB
Go
package kvm
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
|
|
"kvm/internal/logging"
|
|
"kvm/internal/network"
|
|
"kvm/internal/usbgadget"
|
|
)
|
|
|
|
type WakeOnLanDevice struct {
|
|
Name string `json:"name"`
|
|
MacAddress string `json:"macAddress"`
|
|
}
|
|
|
|
// Constants for keyboard macro limits
|
|
const (
|
|
MaxMacrosPerDevice = 25
|
|
MaxStepsPerMacro = 10
|
|
MaxKeysPerStep = 10
|
|
MinStepDelay = 50
|
|
MaxStepDelay = 2000
|
|
)
|
|
|
|
type KeyboardMacroStep struct {
|
|
Keys []string `json:"keys"`
|
|
Modifiers []string `json:"modifiers"`
|
|
Delay int `json:"delay"`
|
|
}
|
|
|
|
func (s *KeyboardMacroStep) Validate() error {
|
|
if len(s.Keys) > MaxKeysPerStep {
|
|
return fmt.Errorf("too many keys in step (max %d)", MaxKeysPerStep)
|
|
}
|
|
|
|
if s.Delay < MinStepDelay {
|
|
s.Delay = MinStepDelay
|
|
} else if s.Delay > MaxStepDelay {
|
|
s.Delay = MaxStepDelay
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type KeyboardMacro struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Steps []KeyboardMacroStep `json:"steps"`
|
|
SortOrder int `json:"sortOrder,omitempty"`
|
|
}
|
|
|
|
func (m *KeyboardMacro) Validate() error {
|
|
if m.Name == "" {
|
|
return fmt.Errorf("macro name cannot be empty")
|
|
}
|
|
|
|
if len(m.Steps) == 0 {
|
|
return fmt.Errorf("macro must have at least one step")
|
|
}
|
|
|
|
if len(m.Steps) > MaxStepsPerMacro {
|
|
return fmt.Errorf("too many steps in macro (max %d)", MaxStepsPerMacro)
|
|
}
|
|
|
|
for i := range m.Steps {
|
|
if err := m.Steps[i].Validate(); err != nil {
|
|
return fmt.Errorf("invalid step %d: %w", i+1, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type Config struct {
|
|
STUN string `json:"stun"`
|
|
JigglerEnabled bool `json:"jiggler_enabled"`
|
|
AutoUpdateEnabled bool `json:"auto_update_enabled"`
|
|
IncludePreRelease bool `json:"include_pre_release"`
|
|
HashedPassword string `json:"hashed_password"`
|
|
LocalAuthToken string `json:"local_auth_token"`
|
|
LocalAuthMode string `json:"localAuthMode"` //TODO: fix it with migration
|
|
LocalLoopbackOnly bool `json:"local_loopback_only"`
|
|
WakeOnLanDevices []WakeOnLanDevice `json:"wake_on_lan_devices"`
|
|
KeyboardMacros []KeyboardMacro `json:"keyboard_macros"`
|
|
KeyboardLayout string `json:"keyboard_layout"`
|
|
EdidString string `json:"hdmi_edid_string"`
|
|
ForceHpd bool `json:"force_hpd"` // 强制输出EDID
|
|
ActiveExtension string `json:"active_extension"`
|
|
DisplayRotation string `json:"display_rotation"`
|
|
DisplayMaxBrightness int `json:"display_max_brightness"`
|
|
DisplayDimAfterSec int `json:"display_dim_after_sec"`
|
|
DisplayOffAfterSec int `json:"display_off_after_sec"`
|
|
TLSMode string `json:"tls_mode"` // options: "self-signed", "user-defined", ""
|
|
UsbConfig *usbgadget.Config `json:"usb_config"`
|
|
UsbDevices *usbgadget.Devices `json:"usb_devices"`
|
|
NetworkConfig *network.NetworkConfig `json:"network_config"`
|
|
AppliedNetworkConfig *network.NetworkConfig `json:"applied_network_config,omitempty"`
|
|
DefaultLogLevel string `json:"default_log_level"`
|
|
TailScaleAutoStart bool `json:"tailscale_autostart"`
|
|
TailScaleXEdge bool `json:"tailscale_xedge"`
|
|
ZeroTierNetworkID string `json:"zerotier_network_id"`
|
|
ZeroTierAutoStart bool `json:"zerotier_autostart"`
|
|
FrpcAutoStart bool `json:"frpc_autostart"`
|
|
FrpcToml string `json:"frpc_toml"`
|
|
CloudflaredAutoStart bool `json:"cloudflared_autostart"`
|
|
CloudflaredToken string `json:"cloudflared_token"`
|
|
IO0Status bool `json:"io0_status"`
|
|
IO1Status bool `json:"io1_status"`
|
|
AudioMode string `json:"audio_mode"`
|
|
TimeZone string `json:"time_zone"`
|
|
LEDGreenMode string `json:"led_green_mode"`
|
|
LEDYellowMode string `json:"led_yellow_mode"`
|
|
AutoMountSystemInfo bool `json:"auto_mount_system_info_img"`
|
|
EasytierAutoStart bool `json:"easytier_autostart"`
|
|
EasytierConfig EasytierConfig `json:"easytier_config"`
|
|
VntAutoStart bool `json:"vnt_autostart"`
|
|
VntConfig VntConfig `json:"vnt_config"`
|
|
}
|
|
|
|
type VntConfig struct {
|
|
Token string `json:"token"`
|
|
DeviceId string `json:"device_id"`
|
|
Name string `json:"name"`
|
|
ServerAddr string `json:"server_addr"`
|
|
ConfigMode string `json:"config_mode"` // "params" or "file"
|
|
ConfigFile string `json:"config_file"`
|
|
Model string `json:"model"`
|
|
Password string `json:"password"`
|
|
}
|
|
|
|
const configPath = "/userdata/kvm_config.json"
|
|
const sdConfigPath = "/mnt/sdcard/kvm_config.json"
|
|
|
|
var defaultConfig = &Config{
|
|
STUN: "stun:stun.l.google.com:19302",
|
|
AutoUpdateEnabled: false, // Set a default value
|
|
ActiveExtension: "",
|
|
KeyboardMacros: []KeyboardMacro{},
|
|
DisplayRotation: "180",
|
|
TimeZone: "UTC-8",
|
|
KeyboardLayout: "en_US",
|
|
DisplayMaxBrightness: 64,
|
|
DisplayDimAfterSec: 120, // 2 minutes
|
|
DisplayOffAfterSec: 1800, // 30 minutes
|
|
TLSMode: "",
|
|
ForceHpd: false, // 默认不强制输出EDID
|
|
UsbConfig: &usbgadget.Config{
|
|
VendorId: "0x1d6b", //The Linux Foundation
|
|
ProductId: "0x0104", //Multifunction Composite Gadget
|
|
SerialNumber: "",
|
|
Manufacturer: "KVM",
|
|
Product: "USB Emulation Device",
|
|
},
|
|
UsbDevices: &usbgadget.Devices{
|
|
AbsoluteMouse: true,
|
|
RelativeMouse: true,
|
|
Keyboard: true,
|
|
MassStorage: true,
|
|
Audio: false, //At any given time, only one of Audio and Mtp can be set to true
|
|
Mtp: false,
|
|
},
|
|
NetworkConfig: &network.NetworkConfig{},
|
|
AppliedNetworkConfig: nil,
|
|
DefaultLogLevel: "INFO",
|
|
ZeroTierAutoStart: false,
|
|
TailScaleAutoStart: false,
|
|
TailScaleXEdge: false,
|
|
FrpcAutoStart: false,
|
|
CloudflaredAutoStart: false,
|
|
IO0Status: true,
|
|
IO1Status: true,
|
|
AudioMode: "disabled",
|
|
LEDGreenMode: "network-rx",
|
|
LEDYellowMode: "kernel-activity",
|
|
AutoMountSystemInfo: true,
|
|
}
|
|
|
|
var (
|
|
config *Config
|
|
configLock = &sync.Mutex{}
|
|
)
|
|
|
|
func LoadConfig() {
|
|
configLock.Lock()
|
|
defer configLock.Unlock()
|
|
|
|
if config != nil {
|
|
logger.Debug().Msg("config already loaded, skipping")
|
|
return
|
|
}
|
|
|
|
// load the default config
|
|
if defaultConfig.UsbConfig.SerialNumber == "" {
|
|
serialNumber, err := extractSerialNumber()
|
|
if err != nil {
|
|
logger.Warn().Err(err).Msg("failed to extract serial number")
|
|
} else {
|
|
defaultConfig.UsbConfig.SerialNumber = serialNumber
|
|
}
|
|
}
|
|
loadedConfig := *defaultConfig
|
|
config = &loadedConfig
|
|
|
|
file, err := os.Open(configPath)
|
|
if err != nil {
|
|
logger.Debug().Msg("default config file doesn't exist, using default")
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
// load and merge the default config with the user config
|
|
if err := json.NewDecoder(file).Decode(&loadedConfig); err != nil {
|
|
logger.Warn().Err(err).Msg("config file JSON parsing failed")
|
|
os.Remove(configPath)
|
|
if _, err := os.Stat(sdConfigPath); err == nil {
|
|
os.Remove(sdConfigPath)
|
|
}
|
|
return
|
|
}
|
|
|
|
// merge the user config with the default config
|
|
if loadedConfig.UsbConfig == nil {
|
|
loadedConfig.UsbConfig = defaultConfig.UsbConfig
|
|
}
|
|
|
|
if loadedConfig.UsbDevices == nil {
|
|
loadedConfig.UsbDevices = defaultConfig.UsbDevices
|
|
}
|
|
|
|
if loadedConfig.NetworkConfig == nil {
|
|
loadedConfig.NetworkConfig = defaultConfig.NetworkConfig
|
|
}
|
|
|
|
config = &loadedConfig
|
|
|
|
logging.GetRootLogger().UpdateLogLevel(config.DefaultLogLevel)
|
|
|
|
logger.Info().Str("path", configPath).Msg("config loaded")
|
|
}
|
|
|
|
func copyFile(src, dst string) error {
|
|
in, err := os.Open(src)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer in.Close()
|
|
|
|
if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
out, err := os.Create(dst)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
if cerr := out.Close(); cerr != nil && err == nil {
|
|
err = cerr
|
|
}
|
|
}()
|
|
|
|
if _, err := io.Copy(out, in); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := out.Sync(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func SyncConfigSD(isUpdate bool) {
|
|
resp, err := rpcGetSDMountStatus()
|
|
if err != nil {
|
|
logger.Error().Err(err).Msg("failed to get sd mount status")
|
|
return
|
|
}
|
|
|
|
if resp.Status == SDMountOK {
|
|
if _, err := os.Stat(configPath); err != nil {
|
|
if err := SaveConfig(); err != nil {
|
|
logger.Error().Err(err).Msg("failed to create kvm_config.json")
|
|
return
|
|
}
|
|
}
|
|
|
|
if isUpdate {
|
|
if _, err := os.Stat(sdConfigPath); err == nil {
|
|
if err := copyFile(sdConfigPath, configPath); err != nil {
|
|
logger.Error().Err(err).Msg("failed to copy kvm_config.json from sdcard to userdata")
|
|
return
|
|
}
|
|
} else {
|
|
if err := copyFile(configPath, sdConfigPath); err != nil {
|
|
logger.Error().Err(err).Msg("failed to copy kvm_config.json from userdata to sdcard")
|
|
return
|
|
}
|
|
}
|
|
} else {
|
|
if err := copyFile(configPath, sdConfigPath); err != nil {
|
|
logger.Error().Err(err).Msg("failed to copy kvm_config.json from userdata to sdcard")
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func SaveConfig() error {
|
|
configLock.Lock()
|
|
defer configLock.Unlock()
|
|
|
|
logger.Trace().Str("path", configPath).Msg("Saving config")
|
|
|
|
file, err := os.Create(configPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create config file: %w", err)
|
|
}
|
|
defer file.Close()
|
|
|
|
encoder := json.NewEncoder(file)
|
|
encoder.SetIndent("", " ")
|
|
if err := encoder.Encode(config); err != nil {
|
|
return fmt.Errorf("failed to encode config: %w", err)
|
|
}
|
|
|
|
SyncConfigSD(false)
|
|
|
|
return nil
|
|
}
|
|
|
|
func ensureConfigLoaded() {
|
|
if config == nil {
|
|
LoadConfig()
|
|
}
|
|
}
|
|
|
|
var systemInfoWriteLock sync.Mutex
|
|
|
|
func writeSystemInfoImg() error {
|
|
systemInfoWriteLock.Lock()
|
|
defer systemInfoWriteLock.Unlock()
|
|
|
|
imgPath := filepath.Join(imagesFolder, "system_info.img")
|
|
unverifiedimgPath := filepath.Join(imagesFolder, "system_info.img") + ".unverified"
|
|
mountPoint := "/mnt/system_info"
|
|
|
|
run := func(cmd string, args ...string) error {
|
|
c := exec.Command(cmd, args...)
|
|
c.Stdout = os.Stdout
|
|
c.Stderr = os.Stderr
|
|
return c.Run()
|
|
}
|
|
|
|
if _, err := os.Stat(unverifiedimgPath); err == nil {
|
|
err := os.Rename(unverifiedimgPath, imgPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to rename %s to %s: %v", unverifiedimgPath, imgPath, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
isMounted := false
|
|
if f, err := os.Open("/proc/mounts"); err == nil {
|
|
defer f.Close()
|
|
scanner := bufio.NewScanner(f)
|
|
for scanner.Scan() {
|
|
fields := strings.Fields(scanner.Text())
|
|
if len(fields) >= 2 && fields[1] == mountPoint {
|
|
isMounted = true
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if isMounted {
|
|
logger.Info().Msgf("%s is mounted, umounting...\n", mountPoint)
|
|
_ = run("umount", mountPoint)
|
|
}
|
|
|
|
if _, err := os.Stat(mountPoint); err == nil {
|
|
if err := os.Remove(mountPoint); err != nil {
|
|
return fmt.Errorf("failed to remove %s: %v", mountPoint, err)
|
|
}
|
|
}
|
|
|
|
if _, err := os.Stat(imgPath); err == nil {
|
|
if err := copyFile(imgPath, unverifiedimgPath); err != nil {
|
|
logger.Error().Err(err).Msg("failed to copy system_info.img")
|
|
return err
|
|
}
|
|
} else {
|
|
if err := run("dd", "if=/dev/zero", "of="+unverifiedimgPath, "bs=1M", "count=4"); err != nil {
|
|
return fmt.Errorf("dd failed: %v", err)
|
|
}
|
|
|
|
if err := run("mkfs.vfat", unverifiedimgPath); err != nil {
|
|
return fmt.Errorf("mkfs.vfat failed: %v", err)
|
|
}
|
|
}
|
|
|
|
if err := os.MkdirAll(mountPoint, 0755); err != nil {
|
|
return fmt.Errorf("mkdir failed: %v", err)
|
|
}
|
|
|
|
if err := run("mount", "-o", "loop", unverifiedimgPath, mountPoint); err != nil {
|
|
return fmt.Errorf("mount failed: %v", err)
|
|
}
|
|
|
|
if err := run("cp", "/etc/hostname", mountPoint+"/hostname.txt"); err != nil {
|
|
return fmt.Errorf("copy hostname failed: %v", err)
|
|
}
|
|
if err := run("sh", "-c", "ip addr show > "+mountPoint+"/network_info.txt"); err != nil {
|
|
return fmt.Errorf("write network info failed: %v", err)
|
|
}
|
|
|
|
_ = run("umount", mountPoint)
|
|
if err := os.RemoveAll(mountPoint); err != nil {
|
|
return fmt.Errorf("failed to remove %s: %v", mountPoint, err)
|
|
}
|
|
|
|
if err := os.Rename(unverifiedimgPath, imgPath); err != nil {
|
|
return fmt.Errorf("failed to rename %s to %s: %v", unverifiedimgPath, imgPath, err)
|
|
}
|
|
|
|
logger.Info().Msg("system_info.img update successfully")
|
|
return nil
|
|
}
|