feat: usb dynamic config (#248)

config.go

@@ -3,6 +3,7 @@ package kvm
 import (
 	"encoding/json"
 	"fmt"
+	"kvm/internal/usbgadget"
 	"os"
 	"sync"
 )
@@ -12,14 +13,6 @@ type WakeOnLanDevice struct {
 	MacAddress string `json:"macAddress"`
 }
 
-type UsbConfig struct {
-	VendorId     string `json:"vendor_id"`
-	ProductId    string `json:"product_id"`
-	SerialNumber string `json:"serial_number"`
-	Manufacturer string `json:"manufacturer"`
-	Product      string `json:"product"`
-}
-
 type Config struct {
 	CloudURL             string             `json:"cloud_url"`
 	CloudAppURL          string             `json:"cloud_app_url"`
@@ -37,7 +30,9 @@ type Config struct {
 	DisplayMaxBrightness int                `json:"display_max_brightness"`
 	DisplayDimAfterSec   int                `json:"display_dim_after_sec"`
 	DisplayOffAfterSec   int                `json:"display_off_after_sec"`
-	UsbConfig            *UsbConfig        `json:"usb_config"`
+	TLSMode              string             `json:"tls_mode"`
+	UsbConfig            *usbgadget.Config  `json:"usb_config"`
+	UsbDevices           *usbgadget.Devices `json:"usb_devices"`
 }
 
 const configPath = "/userdata/kvm_config.json"
@@ -50,13 +45,20 @@ var defaultConfig = &Config{
 	DisplayMaxBrightness: 64,
 	DisplayDimAfterSec:   120,  // 2 minutes
 	DisplayOffAfterSec:   1800, // 30 minutes
-	UsbConfig: &UsbConfig{
+	TLSMode:              "",
+	UsbConfig: &usbgadget.Config{
 		VendorId:     "0x1d6b", //The Linux Foundation
 		ProductId:    "0x0104", //Multifunction Composite Gadget
 		SerialNumber: "",
 		Manufacturer: "JetKVM",
 		Product:      "USB Emulation Device",
 	},
+	UsbDevices: &usbgadget.Devices{
+		AbsoluteMouse: true,
+		RelativeMouse: true,
+		Keyboard:      true,
+		MassStorage:   true,
+	},
 }
 
 var (
@@ -95,6 +97,10 @@ func LoadConfig() {
 		loadedConfig.UsbConfig = defaultConfig.UsbConfig
 	}
 
+	if loadedConfig.UsbDevices == nil {
+		loadedConfig.UsbDevices = defaultConfig.UsbDevices
+	}
+
 	config = &loadedConfig
 }
 

internal/usbgadget/config.go

@@ -0,0 +1,327 @@
+package usbgadget
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"sort"
+)
+
+type gadgetConfigItem struct {
+	order       uint
+	device      string
+	path        []string
+	attrs       gadgetAttributes
+	configAttrs gadgetAttributes
+	configPath  []string
+	reportDesc  []byte
+}
+
+type gadgetAttributes map[string]string
+
+type gadgetConfigItemWithKey struct {
+	key  string
+	item gadgetConfigItem
+}
+
+type orderedGadgetConfigItems []gadgetConfigItemWithKey
+
+var defaultGadgetConfig = map[string]gadgetConfigItem{
+	"base": {
+		order: 0,
+		attrs: gadgetAttributes{
+			"bcdUSB":    "0x0200", // USB 2.0
+			"idVendor":  "0x1d6b", // The Linux Foundation
+			"idProduct": "0104",   // Multifunction Composite Gadget
+			"bcdDevice": "0100",
+		},
+		configAttrs: gadgetAttributes{
+			"MaxPower": "250", // in unit of 2mA
+		},
+	},
+	"base_info": {
+		order:      1,
+		path:       []string{"strings", "0x409"},
+		configPath: []string{"strings", "0x409"},
+		attrs: gadgetAttributes{
+			"serialnumber": "",
+			"manufacturer": "JetKVM",
+			"product":      "JetKVM USB Emulation Device",
+		},
+		configAttrs: gadgetAttributes{
+			"configuration": "Config 1: HID",
+		},
+	},
+	// keyboard HID
+	"keyboard": keyboardConfig,
+	// mouse HID
+	"absolute_mouse": absoluteMouseConfig,
+	// relative mouse HID
+	"relative_mouse": relativeMouseConfig,
+	// mass storage
+	"mass_storage_base": massStorageBaseConfig,
+	"mass_storage_lun0": massStorageLun0Config,
+}
+
+func (u *UsbGadget) isGadgetConfigItemEnabled(itemKey string) bool {
+	switch itemKey {
+	case "absolute_mouse":
+		return u.enabledDevices.AbsoluteMouse
+	case "relative_mouse":
+		return u.enabledDevices.RelativeMouse
+	case "keyboard":
+		return u.enabledDevices.Keyboard
+	case "mass_storage_base":
+		return u.enabledDevices.MassStorage
+	case "mass_storage_lun0":
+		return u.enabledDevices.MassStorage
+	default:
+		return true
+	}
+}
+
+func (u *UsbGadget) loadGadgetConfig() {
+	if u.customConfig.isEmpty {
+		u.log.Trace("using default gadget config")
+		return
+	}
+
+	u.configMap["base"].attrs["idVendor"] = u.customConfig.VendorId
+	u.configMap["base"].attrs["idProduct"] = u.customConfig.ProductId
+
+	u.configMap["base_info"].attrs["serialnumber"] = u.customConfig.SerialNumber
+	u.configMap["base_info"].attrs["manufacturer"] = u.customConfig.Manufacturer
+	u.configMap["base_info"].attrs["product"] = u.customConfig.Product
+}
+
+func (u *UsbGadget) SetGadgetConfig(config *Config) {
+	u.configLock.Lock()
+	defer u.configLock.Unlock()
+
+	if config == nil {
+		return // nothing to do
+	}
+
+	u.customConfig = *config
+	u.loadGadgetConfig()
+}
+
+func (u *UsbGadget) SetGadgetDevices(devices *Devices) {
+	u.configLock.Lock()
+	defer u.configLock.Unlock()
+
+	if devices == nil {
+		return // nothing to do
+	}
+
+	u.enabledDevices = *devices
+}
+
+// GetConfigPath returns the path to the config item.
+func (u *UsbGadget) GetConfigPath(itemKey string) (string, error) {
+	item, ok := u.configMap[itemKey]
+	if !ok {
+		return "", fmt.Errorf("config item %s not found", itemKey)
+	}
+	return joinPath(u.kvmGadgetPath, item.configPath), nil
+}
+
+func mountConfigFS() error {
+	_, err := os.Stat(gadgetPath)
+	// TODO: check if it's mounted properly
+	if err == nil {
+		return nil
+	}
+
+	if os.IsNotExist(err) {
+		err = exec.Command("mount", "-t", "configfs", "none", configFSPath).Run()
+		if err != nil {
+			return fmt.Errorf("failed to mount configfs: %w", err)
+		}
+	} else {
+		return fmt.Errorf("unable to access usb gadget path: %w", err)
+	}
+	return nil
+}
+
+func (u *UsbGadget) Init() error {
+	u.configLock.Lock()
+	defer u.configLock.Unlock()
+
+	u.loadGadgetConfig()
+
+	udcs := getUdcs()
+	if len(udcs) < 1 {
+		u.log.Error("no udc found, skipping USB stack init")
+		return nil
+	}
+
+	u.udc = udcs[0]
+	_, err := os.Stat(u.kvmGadgetPath)
+	if err == nil {
+		u.log.Info("usb gadget already exists")
+	}
+
+	if err := mountConfigFS(); err != nil {
+		u.log.Errorf("failed to mount configfs: %v, usb stack might not function properly", err)
+	}
+
+	if err := os.MkdirAll(u.configC1Path, 0755); err != nil {
+		u.log.Errorf("failed to create config path: %v", err)
+	}
+
+	if err := u.writeGadgetConfig(); err != nil {
+		u.log.Errorf("failed to start gadget: %v", err)
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) UpdateGadgetConfig() error {
+	u.configLock.Lock()
+	defer u.configLock.Unlock()
+
+	u.loadGadgetConfig()
+
+	if err := u.writeGadgetConfig(); err != nil {
+		u.log.Errorf("failed to update gadget: %v", err)
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) getOrderedConfigItems() orderedGadgetConfigItems {
+	items := make([]gadgetConfigItemWithKey, 0)
+	for key, item := range u.configMap {
+		items = append(items, gadgetConfigItemWithKey{key, item})
+	}
+
+	sort.Slice(items, func(i, j int) bool {
+		return items[i].item.order < items[j].item.order
+	})
+
+	return items
+}
+
+func (u *UsbGadget) writeGadgetConfig() error {
+	// create kvm gadget path
+	err := os.MkdirAll(u.kvmGadgetPath, 0755)
+	if err != nil {
+		return err
+	}
+
+	u.log.Tracef("writing gadget config")
+	for _, val := range u.getOrderedConfigItems() {
+		key := val.key
+		item := val.item
+
+		// check if the item is enabled in the config
+		if !u.isGadgetConfigItemEnabled(key) {
+			u.log.Tracef("disabling gadget config: %s", key)
+			err = u.disableGadgetItemConfig(item)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+		u.log.Tracef("writing gadget config: %s", key)
+		err = u.writeGadgetItemConfig(item)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err = u.writeUDC(); err != nil {
+		u.log.Errorf("failed to write UDC: %v", err)
+		return err
+	}
+
+	if err = u.rebindUsb(true); err != nil {
+		u.log.Infof("failed to rebind usb: %v", err)
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) disableGadgetItemConfig(item gadgetConfigItem) error {
+	// remove symlink if exists
+	if item.configPath == nil {
+		return nil
+	}
+
+	configPath := joinPath(u.configC1Path, item.configPath)
+
+	if _, err := os.Lstat(configPath); os.IsNotExist(err) {
+		u.log.Tracef("symlink %s does not exist", item.configPath)
+		return nil
+	}
+
+	if err := os.Remove(configPath); err != nil {
+		return fmt.Errorf("failed to remove symlink %s: %w", item.configPath, err)
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) writeGadgetItemConfig(item gadgetConfigItem) error {
+	// create directory for the item
+	gadgetItemPath := joinPath(u.kvmGadgetPath, item.path)
+	err := os.MkdirAll(gadgetItemPath, 0755)
+	if err != nil {
+		return fmt.Errorf("failed to create path %s: %w", gadgetItemPath, err)
+	}
+
+	if len(item.attrs) > 0 {
+		// write attributes for the item
+		err = u.writeGadgetAttrs(gadgetItemPath, item.attrs)
+		if err != nil {
+			return fmt.Errorf("failed to write attributes for %s: %w", gadgetItemPath, err)
+		}
+	}
+
+	// write report descriptor if available
+	if item.reportDesc != nil {
+		err = u.writeIfDifferent(path.Join(gadgetItemPath, "report_desc"), item.reportDesc, 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	// create config directory if configAttrs are set
+	if len(item.configAttrs) > 0 {
+		configItemPath := joinPath(u.configC1Path, item.configPath)
+		err = os.MkdirAll(configItemPath, 0755)
+		if err != nil {
+			return fmt.Errorf("failed to create path %s: %w", configItemPath, err)
+		}
+
+		err = u.writeGadgetAttrs(configItemPath, item.configAttrs)
+		if err != nil {
+			return fmt.Errorf("failed to write config attributes for %s: %w", configItemPath, err)
+		}
+	}
+
+	// create symlink if configPath is set
+	if item.configPath != nil && item.configAttrs == nil {
+		configPath := joinPath(u.configC1Path, item.configPath)
+		u.log.Tracef("Creating symlink from %s to %s", configPath, gadgetItemPath)
+		if err := ensureSymlink(configPath, gadgetItemPath); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) writeGadgetAttrs(basePath string, attrs gadgetAttributes) error {
+	for key, val := range attrs {
+		filePath := filepath.Join(basePath, key)
+		err := u.writeIfDifferent(filePath, []byte(val), 0644)
+		if err != nil {
+			return fmt.Errorf("failed to write to %s: %w", filePath, err)
+		}
+	}
+	return nil
+}

internal/usbgadget/consts.go

@@ -0,0 +1,3 @@
+package usbgadget
+
+const dwc3Path = "/sys/bus/platform/drivers/dwc3"

internal/usbgadget/hid.go

@@ -0,0 +1,11 @@
+package usbgadget
+
+import "time"
+
+func (u *UsbGadget) resetUserInputTime() {
+	u.lastUserInput = time.Now()
+}
+
+func (u *UsbGadget) GetLastUserInputTime() time.Time {
+	return u.lastUserInput
+}

internal/usbgadget/hid_keyboard.go

@@ -0,0 +1,95 @@
+package usbgadget
+
+import (
+	"fmt"
+	"os"
+)
+
+var keyboardConfig = gadgetConfigItem{
+	order:      1000,
+	device:     "hid.usb0",
+	path:       []string{"functions", "hid.usb0"},
+	configPath: []string{"hid.usb0"},
+	attrs: gadgetAttributes{
+		"protocol":      "1",
+		"subclass":      "1",
+		"report_length": "8",
+	},
+	reportDesc: keyboardReportDesc,
+}
+
+// Source: https://www.kernel.org/doc/Documentation/usb/gadget_hid.txt
+var keyboardReportDesc = []byte{
+	0x05, 0x01, /* USAGE_PAGE (Generic Desktop)	          */
+	0x09, 0x06, /* USAGE (Keyboard)                       */
+	0xa1, 0x01, /* COLLECTION (Application)               */
+	0x05, 0x07, /*   USAGE_PAGE (Keyboard)                */
+	0x19, 0xe0, /*   USAGE_MINIMUM (Keyboard LeftControl) */
+	0x29, 0xe7, /*   USAGE_MAXIMUM (Keyboard Right GUI)   */
+	0x15, 0x00, /*   LOGICAL_MINIMUM (0)                  */
+	0x25, 0x01, /*   LOGICAL_MAXIMUM (1)                  */
+	0x75, 0x01, /*   REPORT_SIZE (1)                      */
+	0x95, 0x08, /*   REPORT_COUNT (8)                     */
+	0x81, 0x02, /*   INPUT (Data,Var,Abs)                 */
+	0x95, 0x01, /*   REPORT_COUNT (1)                     */
+	0x75, 0x08, /*   REPORT_SIZE (8)                      */
+	0x81, 0x03, /*   INPUT (Cnst,Var,Abs)                 */
+	0x95, 0x05, /*   REPORT_COUNT (5)                     */
+	0x75, 0x01, /*   REPORT_SIZE (1)                      */
+	0x05, 0x08, /*   USAGE_PAGE (LEDs)                    */
+	0x19, 0x01, /*   USAGE_MINIMUM (Num Lock)             */
+	0x29, 0x05, /*   USAGE_MAXIMUM (Kana)                 */
+	0x91, 0x02, /*   OUTPUT (Data,Var,Abs)                */
+	0x95, 0x01, /*   REPORT_COUNT (1)                     */
+	0x75, 0x03, /*   REPORT_SIZE (3)                      */
+	0x91, 0x03, /*   OUTPUT (Cnst,Var,Abs)                */
+	0x95, 0x06, /*   REPORT_COUNT (6)                     */
+	0x75, 0x08, /*   REPORT_SIZE (8)                      */
+	0x15, 0x00, /*   LOGICAL_MINIMUM (0)                  */
+	0x25, 0x65, /*   LOGICAL_MAXIMUM (101)                */
+	0x05, 0x07, /*   USAGE_PAGE (Keyboard)                */
+	0x19, 0x00, /*   USAGE_MINIMUM (Reserved)             */
+	0x29, 0x65, /*   USAGE_MAXIMUM (Keyboard Application) */
+	0x81, 0x00, /*   INPUT (Data,Ary,Abs)                 */
+	0xc0, /* END_COLLECTION                         */
+}
+
+func (u *UsbGadget) keyboardWriteHidFile(data []byte) error {
+	if u.keyboardHidFile == nil {
+		var err error
+		u.keyboardHidFile, err = os.OpenFile("/dev/hidg0", os.O_RDWR, 0666)
+		if err != nil {
+			return fmt.Errorf("failed to open hidg0: %w", err)
+		}
+	}
+
+	_, err := u.keyboardHidFile.Write(data)
+	if err != nil {
+		u.log.Errorf("failed to write to hidg0: %w", err)
+		u.keyboardHidFile.Close()
+		u.keyboardHidFile = nil
+		return err
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) KeyboardReport(modifier uint8, keys []uint8) error {
+	u.keyboardLock.Lock()
+	defer u.keyboardLock.Unlock()
+
+	if len(keys) > 6 {
+		keys = keys[:6]
+	}
+	if len(keys) < 6 {
+		keys = append(keys, make([]uint8, 6-len(keys))...)
+	}
+
+	err := u.keyboardWriteHidFile([]byte{modifier, 0, keys[0], keys[1], keys[2], keys[3], keys[4], keys[5]})
+	if err != nil {
+		return err
+	}
+
+	u.resetUserInputTime()
+	return nil
+}

internal/usbgadget/hid_mouse_absolute.go

@@ -0,0 +1,128 @@
+package usbgadget
+
+import (
+	"fmt"
+	"os"
+)
+
+var absoluteMouseConfig = gadgetConfigItem{
+	order:      1001,
+	device:     "hid.usb1",
+	path:       []string{"functions", "hid.usb1"},
+	configPath: []string{"hid.usb1"},
+	attrs: gadgetAttributes{
+		"protocol":      "2",
+		"subclass":      "1",
+		"report_length": "6",
+	},
+	reportDesc: absoluteMouseCombinedReportDesc,
+}
+
+var absoluteMouseCombinedReportDesc = []byte{
+	0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+	0x09, 0x02, // Usage (Mouse)
+	0xA1, 0x01, // Collection (Application)
+
+	// Report ID 1: Absolute Mouse Movement
+	0x85, 0x01, //     Report ID (1)
+	0x09, 0x01, //     Usage (Pointer)
+	0xA1, 0x00, //     Collection (Physical)
+	0x05, 0x09, //         Usage Page (Button)
+	0x19, 0x01, //         Usage Minimum (0x01)
+	0x29, 0x03, //         Usage Maximum (0x03)
+	0x15, 0x00, //         Logical Minimum (0)
+	0x25, 0x01, //         Logical Maximum (1)
+	0x75, 0x01, //         Report Size (1)
+	0x95, 0x03, //         Report Count (3)
+	0x81, 0x02, //         Input (Data, Var, Abs)
+	0x95, 0x01, //         Report Count (1)
+	0x75, 0x05, //         Report Size (5)
+	0x81, 0x03, //         Input (Cnst, Var, Abs)
+	0x05, 0x01, //         Usage Page (Generic Desktop Ctrls)
+	0x09, 0x30, //         Usage (X)
+	0x09, 0x31, //         Usage (Y)
+	0x16, 0x00, 0x00, //         Logical Minimum (0)
+	0x26, 0xFF, 0x7F, //         Logical Maximum (32767)
+	0x36, 0x00, 0x00, //         Physical Minimum (0)
+	0x46, 0xFF, 0x7F, //         Physical Maximum (32767)
+	0x75, 0x10, //         Report Size (16)
+	0x95, 0x02, //         Report Count (2)
+	0x81, 0x02, //         Input (Data, Var, Abs)
+	0xC0, //     End Collection
+
+	// Report ID 2: Relative Wheel Movement
+	0x85, 0x02, //     Report ID (2)
+	0x09, 0x38, //     Usage (Wheel)
+	0x15, 0x81, //     Logical Minimum (-127)
+	0x25, 0x7F, //     Logical Maximum (127)
+	0x75, 0x08, //     Report Size (8)
+	0x95, 0x01, //     Report Count (1)
+	0x81, 0x06, //     Input (Data, Var, Rel)
+
+	0xC0, // End Collection
+}
+
+func (u *UsbGadget) absMouseWriteHidFile(data []byte) error {
+	if u.absMouseHidFile == nil {
+		var err error
+		u.absMouseHidFile, err = os.OpenFile("/dev/hidg1", os.O_RDWR, 0666)
+		if err != nil {
+			return fmt.Errorf("failed to open hidg1: %w", err)
+		}
+	}
+
+	_, err := u.absMouseHidFile.Write(data)
+	if err != nil {
+		u.log.Errorf("failed to write to hidg1: %w", err)
+		u.absMouseHidFile.Close()
+		u.absMouseHidFile = nil
+		return err
+	}
+	return nil
+}
+
+func (u *UsbGadget) AbsMouseReport(x, y int, buttons uint8) error {
+	u.absMouseLock.Lock()
+	defer u.absMouseLock.Unlock()
+
+	err := u.absMouseWriteHidFile([]byte{
+		1,             // Report ID 1
+		buttons,       // Buttons
+		uint8(x),      // X Low Byte
+		uint8(x >> 8), // X High Byte
+		uint8(y),      // Y Low Byte
+		uint8(y >> 8), // Y High Byte
+	})
+	if err != nil {
+		return err
+	}
+
+	u.resetUserInputTime()
+	return nil
+}
+
+func (u *UsbGadget) AbsMouseWheelReport(wheelY int8) error {
+	u.absMouseLock.Lock()
+	defer u.absMouseLock.Unlock()
+
+	// Accumulate the wheelY value
+	u.absMouseAccumulatedWheelY += float64(wheelY) / 8.0
+
+	// Only send a report if the accumulated value is significant
+	if abs(u.absMouseAccumulatedWheelY) < 1.0 {
+		return nil
+	}
+
+	scaledWheelY := int8(u.absMouseAccumulatedWheelY)
+
+	err := u.absMouseWriteHidFile([]byte{
+		2,                  // Report ID 2
+		byte(scaledWheelY), // Scaled Wheel Y (signed)
+	})
+
+	// Reset the accumulator, keeping any remainder
+	u.absMouseAccumulatedWheelY -= float64(scaledWheelY)
+
+	u.resetUserInputTime()
+	return err
+}

internal/usbgadget/hid_mouse_relative.go

@@ -0,0 +1,92 @@
+package usbgadget
+
+import (
+	"fmt"
+	"os"
+)
+
+var relativeMouseConfig = gadgetConfigItem{
+	order:      1002,
+	device:     "hid.usb2",
+	path:       []string{"functions", "hid.usb2"},
+	configPath: []string{"hid.usb2"},
+	attrs: gadgetAttributes{
+		"protocol":      "2",
+		"subclass":      "1",
+		"report_length": "4",
+	},
+	reportDesc: relativeMouseCombinedReportDesc,
+}
+
+// from: https://github.com/NicoHood/HID/blob/b16be57caef4295c6cd382a7e4c64db5073647f7/src/SingleReport/BootMouse.cpp#L26
+var relativeMouseCombinedReportDesc = []byte{
+	0x05, 0x01, // USAGE_PAGE (Generic Desktop)	  54
+	0x09, 0x02, // USAGE (Mouse)
+	0xa1, 0x01, // COLLECTION (Application)
+
+	// Pointer and Physical are required by Apple Recovery
+	0x09, 0x01, // USAGE (Pointer)
+	0xa1, 0x00, // COLLECTION (Physical)
+
+	// 8 Buttons
+	0x05, 0x09, // USAGE_PAGE (Button)
+	0x19, 0x01, // USAGE_MINIMUM (Button 1)
+	0x29, 0x08, // USAGE_MAXIMUM (Button 8)
+	0x15, 0x00, // LOGICAL_MINIMUM (0)
+	0x25, 0x01, // LOGICAL_MAXIMUM (1)
+	0x95, 0x08, // REPORT_COUNT (8)
+	0x75, 0x01, // REPORT_SIZE (1)
+	0x81, 0x02, // INPUT (Data,Var,Abs)
+
+	// X, Y, Wheel
+	0x05, 0x01, // USAGE_PAGE (Generic Desktop)
+	0x09, 0x30, // USAGE (X)
+	0x09, 0x31, // USAGE (Y)
+	0x09, 0x38, // USAGE (Wheel)
+	0x15, 0x81, // LOGICAL_MINIMUM (-127)
+	0x25, 0x7f, // LOGICAL_MAXIMUM (127)
+	0x75, 0x08, // REPORT_SIZE (8)
+	0x95, 0x03, // REPORT_COUNT (3)
+	0x81, 0x06, // INPUT (Data,Var,Rel)
+
+	// End
+	0xc0, //       End Collection (Physical)
+	0xc0, //       End Collection
+}
+
+func (u *UsbGadget) relMouseWriteHidFile(data []byte) error {
+	if u.relMouseHidFile == nil {
+		var err error
+		u.relMouseHidFile, err = os.OpenFile("/dev/hidg2", os.O_RDWR, 0666)
+		if err != nil {
+			return fmt.Errorf("failed to open hidg1: %w", err)
+		}
+	}
+
+	_, err := u.relMouseHidFile.Write(data)
+	if err != nil {
+		u.log.Errorf("failed to write to hidg2: %w", err)
+		u.relMouseHidFile.Close()
+		u.relMouseHidFile = nil
+		return err
+	}
+	return nil
+}
+
+func (u *UsbGadget) RelMouseReport(mx, my int8, buttons uint8) error {
+	u.relMouseLock.Lock()
+	defer u.relMouseLock.Unlock()
+
+	err := u.relMouseWriteHidFile([]byte{
+		buttons,   // Buttons
+		uint8(mx), // X
+		uint8(my), // Y
+		0,         // Wheel
+	})
+	if err != nil {
+		return err
+	}
+
+	u.resetUserInputTime()
+	return nil
+}

internal/usbgadget/mass_storage.go

@@ -0,0 +1,23 @@
+package usbgadget
+
+var massStorageBaseConfig = gadgetConfigItem{
+	order:      3000,
+	device:     "mass_storage.usb0",
+	path:       []string{"functions", "mass_storage.usb0"},
+	configPath: []string{"mass_storage.usb0"},
+	attrs: gadgetAttributes{
+		"stall": "1",
+	},
+}
+
+var massStorageLun0Config = gadgetConfigItem{
+	order: 3001,
+	path:  []string{"functions", "mass_storage.usb0", "lun.0"},
+	attrs: gadgetAttributes{
+		"cdrom":          "1",
+		"ro":             "1",
+		"removable":      "1",
+		"file":           "\n",
+		"inquiry_string": "JetKVM Virtual Media",
+	},
+}

internal/usbgadget/udc.go

@@ -0,0 +1,109 @@
+package usbgadget
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+func getUdcs() []string {
+	var udcs []string
+
+	files, err := os.ReadDir("/sys/devices/platform/usbdrd")
+	if err != nil {
+		return nil
+	}
+
+	for _, file := range files {
+		if !file.IsDir() || !strings.HasSuffix(file.Name(), ".usb") {
+			continue
+		}
+		udcs = append(udcs, file.Name())
+	}
+
+	return udcs
+}
+
+func rebindUsb(udc string, ignoreUnbindError bool) error {
+	err := os.WriteFile(path.Join(dwc3Path, "unbind"), []byte(udc), 0644)
+	if err != nil && !ignoreUnbindError {
+		return err
+	}
+	err = os.WriteFile(path.Join(dwc3Path, "bind"), []byte(udc), 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (u *UsbGadget) rebindUsb(ignoreUnbindError bool) error {
+	u.log.Infof("rebinding USB gadget to UDC %s", u.udc)
+	return rebindUsb(u.udc, ignoreUnbindError)
+}
+
+// RebindUsb rebinds the USB gadget to the UDC.
+func (u *UsbGadget) RebindUsb(ignoreUnbindError bool) error {
+	u.configLock.Lock()
+	defer u.configLock.Unlock()
+
+	return u.rebindUsb(ignoreUnbindError)
+}
+
+func (u *UsbGadget) writeUDC() error {
+	path := path.Join(u.kvmGadgetPath, "UDC")
+
+	u.log.Tracef("writing UDC %s to %s", u.udc, path)
+	err := u.writeIfDifferent(path, []byte(u.udc), 0644)
+	if err != nil {
+		return fmt.Errorf("failed to write UDC: %w", err)
+	}
+
+	return nil
+}
+
+// GetUsbState returns the current state of the USB gadget
+func (u *UsbGadget) GetUsbState() (state string) {
+	stateFile := path.Join("/sys/class/udc", u.udc, "state")
+	stateBytes, err := os.ReadFile(stateFile)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "not attached"
+		} else {
+			u.log.Tracef("failed to read usb state: %v", err)
+		}
+		return "unknown"
+	}
+	return strings.TrimSpace(string(stateBytes))
+}
+
+// IsUDCBound checks if the UDC state is bound.
+func (u *UsbGadget) IsUDCBound() (bool, error) {
+	udcFilePath := path.Join(dwc3Path, u.udc)
+	_, err := os.Stat(udcFilePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("error checking USB emulation state: %w", err)
+	}
+	return true, nil
+}
+
+// BindUDC binds the gadget to the UDC.
+func (u *UsbGadget) BindUDC() error {
+	err := os.WriteFile(path.Join(dwc3Path, "bind"), []byte(u.udc), 0644)
+	if err != nil {
+		return fmt.Errorf("error binding UDC: %w", err)
+	}
+	return nil
+}
+
+// UnbindUDC unbinds the gadget from the UDC.
+func (u *UsbGadget) UnbindUDC() error {
+	err := os.WriteFile(path.Join(dwc3Path, "unbind"), []byte(u.udc), 0644)
+	if err != nil {
+		return fmt.Errorf("error unbinding UDC: %w", err)
+	}
+	return nil
+}

internal/usbgadget/usbgadget.go

@@ -0,0 +1,110 @@
+// Package usbgadget provides a high-level interface to manage USB gadgets
+// THIS PACKAGE IS FOR INTERNAL USE ONLY AND ITS API MAY CHANGE WITHOUT NOTICE
+package usbgadget
+
+import (
+	"os"
+	"path"
+	"sync"
+	"time"
+
+	"github.com/pion/logging"
+)
+
+// Devices is a struct that represents the USB devices that can be enabled on a USB gadget.
+type Devices struct {
+	AbsoluteMouse bool `json:"absolute_mouse"`
+	RelativeMouse bool `json:"relative_mouse"`
+	Keyboard      bool `json:"keyboard"`
+	MassStorage   bool `json:"mass_storage"`
+}
+
+// Config is a struct that represents the customizations for a USB gadget.
+// TODO: rename to something else that won't confuse with the USB gadget configuration
+type Config struct {
+	VendorId     string `json:"vendor_id"`
+	ProductId    string `json:"product_id"`
+	SerialNumber string `json:"serial_number"`
+	Manufacturer string `json:"manufacturer"`
+	Product      string `json:"product"`
+
+	isEmpty bool
+}
+
+var defaultUsbGadgetDevices = Devices{
+	AbsoluteMouse: true,
+	RelativeMouse: true,
+	Keyboard:      true,
+	MassStorage:   true,
+}
+
+// UsbGadget is a struct that represents a USB gadget.
+type UsbGadget struct {
+	name          string
+	udc           string
+	kvmGadgetPath string
+	configC1Path  string
+
+	configMap    map[string]gadgetConfigItem
+	customConfig Config
+
+	configLock sync.Mutex
+
+	keyboardHidFile *os.File
+	keyboardLock    sync.Mutex
+	absMouseHidFile *os.File
+	absMouseLock    sync.Mutex
+	relMouseHidFile *os.File
+	relMouseLock    sync.Mutex
+
+	enabledDevices Devices
+
+	absMouseAccumulatedWheelY float64
+
+	lastUserInput time.Time
+
+	log logging.LeveledLogger
+}
+
+const configFSPath = "/sys/kernel/config"
+const gadgetPath = "/sys/kernel/config/usb_gadget"
+
+var defaultLogger = logging.NewDefaultLoggerFactory().NewLogger("usbgadget")
+
+// NewUsbGadget creates a new UsbGadget.
+func NewUsbGadget(name string, enabledDevices *Devices, config *Config, logger *logging.LeveledLogger) *UsbGadget {
+	if logger == nil {
+		logger = &defaultLogger
+	}
+
+	if enabledDevices == nil {
+		enabledDevices = &defaultUsbGadgetDevices
+	}
+
+	if config == nil {
+		config = &Config{isEmpty: true}
+	}
+
+	g := &UsbGadget{
+		name:           name,
+		kvmGadgetPath:  path.Join(gadgetPath, name),
+		configC1Path:   path.Join(gadgetPath, name, "configs/c.1"),
+		configMap:      defaultGadgetConfig,
+		customConfig:   *config,
+		configLock:     sync.Mutex{},
+		keyboardLock:   sync.Mutex{},
+		absMouseLock:   sync.Mutex{},
+		relMouseLock:   sync.Mutex{},
+		enabledDevices: *enabledDevices,
+		lastUserInput:  time.Now(),
+		log:            *logger,
+
+		absMouseAccumulatedWheelY: 0,
+	}
+	if err := g.Init(); err != nil {
+		g.log.Errorf("failed to init USB gadget: %v", err)
+		return nil
+	}
+
+	return g
+}

internal/usbgadget/utils.go

@@ -0,0 +1,63 @@
+package usbgadget
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// Helper function to get absolute value of float64
+func abs(x float64) float64 {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+
+func joinPath(basePath string, paths []string) string {
+	pathArr := append([]string{basePath}, paths...)
+	return filepath.Join(pathArr...)
+}
+
+func ensureSymlink(linkPath string, target string) error {
+	if _, err := os.Lstat(linkPath); err == nil {
+		currentTarget, err := os.Readlink(linkPath)
+		if err != nil || currentTarget != target {
+			err = os.Remove(linkPath)
+			if err != nil {
+				return fmt.Errorf("failed to remove existing symlink %s: %w", linkPath, err)
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("failed to check if symlink exists: %w", err)
+	}
+
+	if err := os.Symlink(target, linkPath); err != nil {
+		return fmt.Errorf("failed to create symlink from %s to %s: %w", linkPath, target, err)
+	}
+
+	return nil
+}
+
+func (u *UsbGadget) writeIfDifferent(filePath string, content []byte, permMode os.FileMode) error {
+	if _, err := os.Stat(filePath); err == nil {
+		oldContent, err := os.ReadFile(filePath)
+		if err == nil {
+			if bytes.Equal(oldContent, content) {
+				u.log.Tracef("skipping writing to %s as it already has the correct content", filePath)
+				return nil
+			}
+
+			if len(oldContent) == len(content)+1 &&
+				bytes.Equal(oldContent[:len(content)], content) &&
+				oldContent[len(content)] == 10 {
+				u.log.Tracef("skipping writing to %s as it already has the correct content", filePath)
+				return nil
+			}
+
+			u.log.Tracef("writing to %s as it has different content old%v new%v", filePath, oldContent, content)
+		}
+	}
+	return os.WriteFile(filePath, content, permMode)
+}

jsonrpc.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"kvm/internal/usbgadget"
 	"log"
 	"os"
 	"os/exec"
@@ -518,45 +519,27 @@ func rpcIsUpdatePending() (bool, error) {
 }
 
 func rpcGetUsbEmulationState() (bool, error) {
-	_, err := os.Stat(filepath.Join("/sys/bus/platform/drivers/dwc3", udc))
+	return gadget.IsUDCBound()
-	if err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, fmt.Errorf("error checking USB emulation state: %w", err)
-	}
-	return true, nil
 }
 
 func rpcSetUsbEmulationState(enabled bool) error {
 	if enabled {
-		return os.WriteFile("/sys/bus/platform/drivers/dwc3/bind", []byte(udc), 0644)
+		return gadget.BindUDC()
 	} else {
-		return os.WriteFile("/sys/bus/platform/drivers/dwc3/unbind", []byte(udc), 0644)
+		return gadget.UnbindUDC()
 	}
 }
 
-func rpcGetUsbConfig() (UsbConfig, error) {
+func rpcGetUsbConfig() (usbgadget.Config, error) {
 	LoadConfig()
 	return *config.UsbConfig, nil
 }
 
-func rpcSetUsbConfig(usbConfig UsbConfig) error {
+func rpcSetUsbConfig(usbConfig usbgadget.Config) error {
 	LoadConfig()
 	config.UsbConfig = &usbConfig
-
+	gadget.SetGadgetConfig(config.UsbConfig)
-	err := UpdateGadgetConfig()
+	return updateUsbRelatedConfig()
-	if err != nil {
-		return fmt.Errorf("failed to write gadget config: %w", err)
-	}
-
-	err = SaveConfig()
-	if err != nil {
-		return fmt.Errorf("failed to save usb config: %w", err)
-	}
-
-	log.Printf("[jsonrpc.go:rpcSetUsbConfig] usb config set to %s", usbConfig)
-	return nil
 }
 
 func rpcGetWakeOnLanDevices() ([]WakeOnLanDevice, error) {
@@ -751,6 +734,43 @@ func rpcSetSerialSettings(settings SerialSettings) error {
 	return nil
 }
 
+func rpcGetUsbDevices() (usbgadget.Devices, error) {
+	return *config.UsbDevices, nil
+}
+
+func updateUsbRelatedConfig() error {
+	if err := gadget.UpdateGadgetConfig(); err != nil {
+		return fmt.Errorf("failed to write gadget config: %w", err)
+	}
+	if err := SaveConfig(); err != nil {
+		return fmt.Errorf("failed to save config: %w", err)
+	}
+	return nil
+}
+
+func rpcSetUsbDevices(usbDevices usbgadget.Devices) error {
+	config.UsbDevices = &usbDevices
+	gadget.SetGadgetDevices(config.UsbDevices)
+	return updateUsbRelatedConfig()
+}
+
+func rpcSetUsbDeviceState(device string, enabled bool) error {
+	switch device {
+	case "absoluteMouse":
+		config.UsbDevices.AbsoluteMouse = enabled
+	case "relativeMouse":
+		config.UsbDevices.RelativeMouse = enabled
+	case "keyboard":
+		config.UsbDevices.Keyboard = enabled
+	case "massStorage":
+		config.UsbDevices.MassStorage = enabled
+	default:
+		return fmt.Errorf("invalid device: %s", device)
+	}
+	gadget.SetGadgetDevices(config.UsbDevices)
+	return updateUsbRelatedConfig()
+}
+
 func rpcSetCloudUrl(apiUrl string, appUrl string) error {
 	config.CloudURL = apiUrl
 	config.CloudAppURL = appUrl
@@ -831,6 +851,9 @@ var rpcHandlers = map[string]RPCHandler{
 	"setATXPowerAction":      {Func: rpcSetATXPowerAction, Params: []string{"action"}},
 	"getSerialSettings":      {Func: rpcGetSerialSettings},
 	"setSerialSettings":      {Func: rpcSetSerialSettings, Params: []string{"settings"}},
+	"getUsbDevices":          {Func: rpcGetUsbDevices},
+	"setUsbDevices":          {Func: rpcSetUsbDevices, Params: []string{"devices"}},
+	"setUsbDeviceState":      {Func: rpcSetUsbDeviceState, Params: []string{"device", "enabled"}},
 	"setCloudUrl":            {Func: rpcSetCloudUrl, Params: []string{"apiUrl", "appUrl"}},
 	"getScrollSensitivity":   {Func: rpcGetScrollSensitivity},
 	"setScrollSensitivity":   {Func: rpcSetScrollSensitivity, Params: []string{"sensitivity"}},

main.go

@@ -44,6 +44,8 @@ func Main() {
 		}
 	}()
 
+	initUsbGadget()
+
 	go func() {
 		time.Sleep(15 * time.Minute)
 		for {

ui/src/components/UsbDeviceSetting.tsx

@@ -0,0 +1,129 @@
+import { useCallback } from "react";
+
+import { useEffect, useState } from "react";
+import { useJsonRpc } from "../hooks/useJsonRpc";
+import notifications from "../notifications";
+import { SettingsItem } from "../routes/devices.$id.settings";
+import Checkbox from "./Checkbox";
+
+export interface USBConfig {
+  vendor_id: string;
+  product_id: string;
+  serial_number: string;
+  manufacturer: string;
+  product: string;
+}
+
+export interface UsbDeviceConfig {
+  keyboard: boolean;
+  absolute_mouse: boolean;
+  relative_mouse: boolean;
+  mass_storage: boolean;
+}
+
+const defaultUsbDeviceConfig: UsbDeviceConfig = {
+  keyboard: true,
+  absolute_mouse: true,
+  relative_mouse: true,
+  mass_storage: true,
+}
+
+export function UsbDeviceSetting() {
+  const [send] = useJsonRpc();
+
+  const [usbDeviceConfig, setUsbDeviceConfig] = useState<UsbDeviceConfig>(defaultUsbDeviceConfig);
+  const syncUsbDeviceConfig = useCallback(() => {
+    send("getUsbDevices", {}, resp => {
+      if ("error" in resp) {
+        console.error("Failed to load USB devices:", resp.error);
+        notifications.error(
+          `Failed to load USB devices: ${resp.error.data || "Unknown error"}`,
+        );
+      } else {
+        console.log("syncUsbDeviceConfig#getUsbDevices result:", resp.result);
+        const usbConfigState = resp.result as UsbDeviceConfig;
+        setUsbDeviceConfig(usbConfigState);
+      }
+    });
+  }, [send]);
+
+  const handleUsbConfigChange = useCallback(
+    (devices: UsbDeviceConfig) => {
+      send("setUsbDevices", { devices }, resp => {
+        if ("error" in resp) {
+          notifications.error(
+            `Failed to set usb devices: ${resp.error.data || "Unknown error"}`,
+          );
+          return;
+        }
+        notifications.success(
+          `USB Devices updated`
+        );
+        syncUsbDeviceConfig();
+      });
+    },
+    [send, syncUsbDeviceConfig],
+  );
+
+  const onUsbConfigItemChange = useCallback((key: keyof UsbDeviceConfig) => (e: React.ChangeEvent<HTMLInputElement>) => {
+    setUsbDeviceConfig((val) => {
+      val[key] = e.target.checked;
+      handleUsbConfigChange(val);
+      return val;
+    });
+  }, [handleUsbConfigChange]);
+
+  useEffect(() => {
+    syncUsbDeviceConfig();
+  }, [syncUsbDeviceConfig]);
+
+  return (
+    <>
+      <div className="h-[1px] w-full bg-slate-800/10 dark:bg-slate-300/20" />
+      <div className="space-y-4">
+        <SettingsItem
+          title="Enable Keyboard"
+          description="Enable Keyboard"
+        >
+          <Checkbox
+            checked={usbDeviceConfig.keyboard}
+            onChange={onUsbConfigItemChange("keyboard")}
+          />
+        </SettingsItem>
+      </div>
+      <div className="space-y-4">
+        <SettingsItem
+          title="Enable Absolute Mouse (Pointer)"
+          description="Enable Absolute Mouse (Pointer)"
+        >
+          <Checkbox
+            checked={usbDeviceConfig.absolute_mouse}
+            onChange={onUsbConfigItemChange("absolute_mouse")}
+          />
+        </SettingsItem>
+      </div>
+      <div className="space-y-4">
+        <SettingsItem
+          title="Enable Relative Mouse"
+          description="Enable Relative Mouse"
+        >
+          <Checkbox
+            checked={usbDeviceConfig.relative_mouse}
+            onChange={onUsbConfigItemChange("relative_mouse")}
+          />
+        </SettingsItem>
+      </div>
+      <div className="space-y-4">
+        <SettingsItem
+          title="Enable USB Mass Storage"
+          description="Sometimes it might need to be disabled to prevent issues with certain devices"
+        >
+          <Checkbox
+            checked={usbDeviceConfig.mass_storage}
+            onChange={onUsbConfigItemChange("mass_storage")}
+          />
+        </SettingsItem>
+      </div>
+    </>
+  );
+}

ui/src/routes/devices.$id.settings.hardware.tsx

@@ -7,6 +7,7 @@ import { useJsonRpc } from "@/hooks/useJsonRpc";
 import notifications from "../notifications";
 import { SelectMenuBasic } from "@components/SelectMenuBasic";
 import { UsbConfigSetting } from "../components/UsbConfigSetting";
+import { UsbDeviceSetting } from "@components/UsbDeviceSetting";
 import { FeatureFlag } from "../components/FeatureFlag";
 
 export default function SettingsHardwareRoute() {
@@ -132,6 +133,10 @@ export default function SettingsHardwareRoute() {
       <FeatureFlag minAppVersion="0.3.8">
         <UsbConfigSetting />
       </FeatureFlag>
+
+      <FeatureFlag minAppVersion="0.3.8">
+        <UsbDeviceSetting />
+      </FeatureFlag>
     </div>
   );
 }

usb.go

@@ -1,378 +1,51 @@
 package kvm
 
 import (
-	"errors"
+	"kvm/internal/usbgadget"
-	"fmt"
 	"log"
-	"os"
-	"os/exec"
-	"path"
-	"path/filepath"
-	"strings"
-	"sync"
 	"time"
-
-	gadget "github.com/openstadia/go-usb-gadget"
 )
 
-const configFSPath = "/sys/kernel/config"
+var gadget *usbgadget.UsbGadget
-const gadgetPath = "/sys/kernel/config/usb_gadget"
-const kvmGadgetPath = "/sys/kernel/config/usb_gadget/jetkvm"
-const configC1Path = "/sys/kernel/config/usb_gadget/jetkvm/configs/c.1"
 
-func mountConfigFS() error {
+// initUsbGadget initializes the USB gadget.
-	_, err := os.Stat(gadgetPath)
+// call it only after the config is loaded.
-	if os.IsNotExist(err) {
+func initUsbGadget() {
-		err = exec.Command("mount", "-t", "configfs", "none", configFSPath).Run()
+	gadget = usbgadget.NewUsbGadget(
-		if err != nil {
+		"jetkvm",
-			return fmt.Errorf("failed to mount configfs: %w", err)
+		config.UsbDevices,
+		config.UsbConfig,
+		&logger,
+	)
+
+	go func() {
+		for {
+			checkUSBState()
+			time.Sleep(500 * time.Millisecond)
 		}
-	} else {
+	}()
-		return fmt.Errorf("unable to access usb gadget path: %w", err)
-	}
-	return nil
 }
 
-func init() {
-	ensureConfigLoaded()
-
-	_ = os.MkdirAll(imagesFolder, 0755)
-	udcs := gadget.GetUdcs()
-	if len(udcs) < 1 {
-		usbLogger.Error("no udc found, skipping USB stack init")
-		return
-	}
-	udc = udcs[0]
-	_, err := os.Stat(kvmGadgetPath)
-	if err == nil {
-		logger.Info("usb gadget already exists, skipping usb gadget initialization")
-		return
-	}
-	err = mountConfigFS()
-	if err != nil {
-		logger.Errorf("failed to mount configfs: %v, usb stack might not function properly", err)
-	}
-	err = writeGadgetConfig()
-	if err != nil {
-		logger.Errorf("failed to start gadget: %v", err)
-	}
-
-	//TODO: read hid reports(capslock, numlock, etc) from keyboardHidFile
-}
-
-func UpdateGadgetConfig() error {
-	LoadConfig()
-	gadgetAttrs := [][]string{
-		{"idVendor", config.UsbConfig.VendorId},
-		{"idProduct", config.UsbConfig.ProductId},
-	}
-	err := writeGadgetAttrs(kvmGadgetPath, gadgetAttrs)
-	if err != nil {
-		return err
-	}
-
-	log.Printf("Successfully updated usb gadget attributes: %v", gadgetAttrs)
-
-	strAttrs := [][]string{
-		{"serialnumber", config.UsbConfig.SerialNumber},
-		{"manufacturer", config.UsbConfig.Manufacturer},
-		{"product", config.UsbConfig.Product},
-	}
-	gadgetStringsPath := filepath.Join(kvmGadgetPath, "strings", "0x409")
-	err = os.MkdirAll(gadgetStringsPath, 0755)
-	if err != nil {
-		return err
-	}
-	err = writeGadgetAttrs(gadgetStringsPath, strAttrs)
-	if err != nil {
-		return err
-	}
-
-	log.Printf("Successfully updated usb string attributes: %s", strAttrs)
-
-	err = rebindUsb()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func writeGadgetAttrs(basePath string, attrs [][]string) error {
-	for _, item := range attrs {
-		filePath := filepath.Join(basePath, item[0])
-		err := os.WriteFile(filePath, []byte(item[1]), 0644)
-		if err != nil {
-			return fmt.Errorf("failed to write to %s: %w", filePath, err)
-		}
-	}
-	return nil
-}
-
-func writeGadgetConfig() error {
-	if _, err := os.Stat(gadgetPath); os.IsNotExist(err) {
-		return fmt.Errorf("USB gadget path does not exist: %s", gadgetPath)
-	}
-
-	err := os.MkdirAll(kvmGadgetPath, 0755)
-	if err != nil {
-		return err
-	}
-
-	err = writeGadgetAttrs(kvmGadgetPath, [][]string{
-		{"bcdUSB", "0x0200"},                      //USB 2.0
-		{"idVendor", config.UsbConfig.VendorId},   //The Linux Foundation
-		{"idProduct", config.UsbConfig.ProductId}, //Multifunction Composite Gadget¬
-		{"bcdDevice", "0100"},
-	})
-	if err != nil {
-		return err
-	}
-
-	gadgetStringsPath := filepath.Join(kvmGadgetPath, "strings", "0x409")
-	err = os.MkdirAll(gadgetStringsPath, 0755)
-	if err != nil {
-		return err
-	}
-
-	err = writeGadgetAttrs(gadgetStringsPath, [][]string{
-		{"serialnumber", GetDeviceID()},
-		{"manufacturer", config.UsbConfig.Manufacturer},
-		{"product", config.UsbConfig.Product},
-	})
-	if err != nil {
-		return err
-	}
-
-	configC1StringsPath := path.Join(configC1Path, "strings", "0x409")
-	err = os.MkdirAll(configC1StringsPath, 0755)
-	if err != nil {
-		return err
-	}
-
-	err = writeGadgetAttrs(configC1Path, [][]string{
-		{"MaxPower", "250"}, //in unit of 2mA
-	})
-	if err != nil {
-		return err
-	}
-
-	err = writeGadgetAttrs(configC1StringsPath, [][]string{
-		{"configuration", "Config 1: HID"},
-	})
-	if err != nil {
-		return err
-	}
-
-	//keyboard HID
-	hid0Path := path.Join(kvmGadgetPath, "functions", "hid.usb0")
-	err = os.MkdirAll(hid0Path, 0755)
-	if err != nil {
-		return err
-	}
-	err = writeGadgetAttrs(hid0Path, [][]string{
-		{"protocol", "1"},
-		{"subclass", "1"},
-		{"report_length", "8"},
-	})
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(path.Join(hid0Path, "report_desc"), KeyboardReportDesc, 0644)
-	if err != nil {
-		return err
-	}
-
-	//mouse HID
-	hid1Path := path.Join(kvmGadgetPath, "functions", "hid.usb1")
-	err = os.MkdirAll(hid1Path, 0755)
-	if err != nil {
-		return err
-	}
-	err = writeGadgetAttrs(hid1Path, [][]string{
-		{"protocol", "2"},
-		{"subclass", "1"},
-		{"report_length", "6"},
-	})
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(path.Join(hid1Path, "report_desc"), CombinedMouseReportDesc, 0644)
-	if err != nil {
-		return err
-	}
-	//mass storage
-	massStoragePath := path.Join(kvmGadgetPath, "functions", "mass_storage.usb0")
-	err = os.MkdirAll(massStoragePath, 0755)
-	if err != nil {
-		return err
-	}
-
-	err = writeGadgetAttrs(massStoragePath, [][]string{
-		{"stall", "1"},
-	})
-	if err != nil {
-		return err
-	}
-	lun0Path := path.Join(massStoragePath, "lun.0")
-	err = os.MkdirAll(lun0Path, 0755)
-	if err != nil {
-		return err
-	}
-	err = writeGadgetAttrs(lun0Path, [][]string{
-		{"cdrom", "1"},
-		{"ro", "1"},
-		{"removable", "1"},
-		{"file", "\n"},
-		{"inquiry_string", "JetKVM Virtual Media"},
-	})
-	if err != nil {
-		return err
-	}
-
-	err = os.Symlink(hid0Path, path.Join(configC1Path, "hid.usb0"))
-	if err != nil {
-		return err
-	}
-
-	err = os.Symlink(hid1Path, path.Join(configC1Path, "hid.usb1"))
-	if err != nil {
-		return err
-	}
-
-	err = os.Symlink(massStoragePath, path.Join(configC1Path, "mass_storage.usb0"))
-	if err != nil {
-		return err
-	}
-
-	err = os.WriteFile(path.Join(kvmGadgetPath, "UDC"), []byte(udc), 0644)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func rebindUsb() error {
-	err := os.WriteFile("/sys/bus/platform/drivers/dwc3/unbind", []byte(udc), 0644)
-	if err != nil {
-		return err
-	}
-	err = os.WriteFile("/sys/bus/platform/drivers/dwc3/bind", []byte(udc), 0644)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-var keyboardHidFile *os.File
-var keyboardLock = sync.Mutex{}
-var mouseHidFile *os.File
-var mouseLock = sync.Mutex{}
-
 func rpcKeyboardReport(modifier uint8, keys []uint8) error {
-	keyboardLock.Lock()
+	return gadget.KeyboardReport(modifier, keys)
-	defer keyboardLock.Unlock()
-	if keyboardHidFile == nil {
-		var err error
-		keyboardHidFile, err = os.OpenFile("/dev/hidg0", os.O_RDWR, 0666)
-		if err != nil {
-			return fmt.Errorf("failed to open hidg0: %w", err)
-		}
-	}
-	if len(keys) > 6 {
-		keys = keys[:6]
-	}
-	if len(keys) < 6 {
-		keys = append(keys, make([]uint8, 6-len(keys))...)
-	}
-	_, err := keyboardHidFile.Write([]byte{modifier, 0, keys[0], keys[1], keys[2], keys[3], keys[4], keys[5]})
-	if err != nil {
-		keyboardHidFile.Close()
-		keyboardHidFile = nil
-		return err
-	}
-	resetUserInputTime()
-	return err
 }
 
 func rpcAbsMouseReport(x, y int, buttons uint8) error {
-	mouseLock.Lock()
+	return gadget.AbsMouseReport(x, y, buttons)
-	defer mouseLock.Unlock()
-	if mouseHidFile == nil {
-		var err error
-		mouseHidFile, err = os.OpenFile("/dev/hidg1", os.O_RDWR, 0666)
-		if err != nil {
-			return fmt.Errorf("failed to open hidg1: %w", err)
-		}
-	}
-	resetUserInputTime()
-	_, err := mouseHidFile.Write([]byte{
-		1,             // Report ID 1
-		buttons,       // Buttons
-		uint8(x),      // X Low Byte
-		uint8(x >> 8), // X High Byte
-		uint8(y),      // Y Low Byte
-		uint8(y >> 8), // Y High Byte
-	})
-	if err != nil {
-		mouseHidFile.Close()
-		mouseHidFile = nil
-		return err
-	}
-	return nil
 }
 
-var accumulatedWheelY float64 = 0
-
 func rpcWheelReport(wheelY int8) error {
-	if mouseHidFile == nil {
+	return gadget.AbsMouseWheelReport(wheelY)
-		return errors.New("hid not initialized")
-	}
-
-	// Accumulate the wheelY value with finer granularity
-	// Reduce divisor from 8.0 to a smaller value (e.g., 2.0 or 4.0)
-	accumulatedWheelY += float64(wheelY) / 4.0
-
-	// Lower the threshold for sending a report (0.25 instead of 1.0)
-	if abs(accumulatedWheelY) >= 0.25 {
-		// Scale the wheel value appropriately for the HID report
-		// The descriptor uses an 8-bit signed value (-127 to 127)
-		scaledWheelY := int8(accumulatedWheelY * 0.5) // Scale down to prevent too much scrolling
-
-		_, err := mouseHidFile.Write([]byte{
-			2,                  // Report ID 2
-			byte(scaledWheelY), // Scaled Wheel Y (signed)
-		})
-
-		// Reset the accumulator, keeping any remainder
-		accumulatedWheelY -= float64(scaledWheelY) / 0.5 // Adjust based on the scaling factor
-
-		resetUserInputTime()
-		return err
-	}
-
-	return nil
 }
 
-// Helper function to get absolute value of float64
+func rpcRelMouseReport(mx, my int8, buttons uint8) error {
-func abs(x float64) float64 {
+	return gadget.RelMouseReport(mx, my, buttons)
-	if x < 0 {
-		return -x
-	}
-	return x
 }
 
 var usbState = "unknown"
 
 func rpcGetUSBState() (state string) {
-	stateBytes, err := os.ReadFile("/sys/class/udc/ffb00000.usb/state")
+	return gadget.GetUsbState()
-	if err != nil {
-		return "unknown"
-	}
-	return strings.TrimSpace(string(stateBytes))
 }
 
 func triggerUSBStateUpdate() {
@@ -385,102 +58,14 @@ func triggerUSBStateUpdate() {
 	}()
 }
 
-var udc string
+func checkUSBState() {
-
+	newState := gadget.GetUsbState()
-func init() {
+	if newState == usbState {
-	ensureConfigLoaded()
+		return
-
+	}
-	go func() {
-		for {
-			newState := rpcGetUSBState()
-			if newState != usbState {
-				log.Printf("USB state changed from %s to %s", usbState, newState)
 	usbState = newState
+
+	logger.Infof("USB state changed from %s to %s", usbState, newState)
 	requestDisplayUpdate()
 	triggerUSBStateUpdate()
-			}
-			time.Sleep(500 * time.Millisecond)
-		}
-	}()
-}
-
-// Source: https://www.kernel.org/doc/Documentation/usb/gadget_hid.txt
-var KeyboardReportDesc = []byte{
-	0x05, 0x01, /* USAGE_PAGE (Generic Desktop)	          */
-	0x09, 0x06, /* USAGE (Keyboard)                       */
-	0xa1, 0x01, /* COLLECTION (Application)               */
-	0x05, 0x07, /*   USAGE_PAGE (Keyboard)                */
-	0x19, 0xe0, /*   USAGE_MINIMUM (Keyboard LeftControl) */
-	0x29, 0xe7, /*   USAGE_MAXIMUM (Keyboard Right GUI)   */
-	0x15, 0x00, /*   LOGICAL_MINIMUM (0)                  */
-	0x25, 0x01, /*   LOGICAL_MAXIMUM (1)                  */
-	0x75, 0x01, /*   REPORT_SIZE (1)                      */
-	0x95, 0x08, /*   REPORT_COUNT (8)                     */
-	0x81, 0x02, /*   INPUT (Data,Var,Abs)                 */
-	0x95, 0x01, /*   REPORT_COUNT (1)                     */
-	0x75, 0x08, /*   REPORT_SIZE (8)                      */
-	0x81, 0x03, /*   INPUT (Cnst,Var,Abs)                 */
-	0x95, 0x05, /*   REPORT_COUNT (5)                     */
-	0x75, 0x01, /*   REPORT_SIZE (1)                      */
-	0x05, 0x08, /*   USAGE_PAGE (LEDs)                    */
-	0x19, 0x01, /*   USAGE_MINIMUM (Num Lock)             */
-	0x29, 0x05, /*   USAGE_MAXIMUM (Kana)                 */
-	0x91, 0x02, /*   OUTPUT (Data,Var,Abs)                */
-	0x95, 0x01, /*   REPORT_COUNT (1)                     */
-	0x75, 0x03, /*   REPORT_SIZE (3)                      */
-	0x91, 0x03, /*   OUTPUT (Cnst,Var,Abs)                */
-	0x95, 0x06, /*   REPORT_COUNT (6)                     */
-	0x75, 0x08, /*   REPORT_SIZE (8)                      */
-	0x15, 0x00, /*   LOGICAL_MINIMUM (0)                  */
-	0x25, 0x65, /*   LOGICAL_MAXIMUM (101)                */
-	0x05, 0x07, /*   USAGE_PAGE (Keyboard)                */
-	0x19, 0x00, /*   USAGE_MINIMUM (Reserved)             */
-	0x29, 0x65, /*   USAGE_MAXIMUM (Keyboard Application) */
-	0x81, 0x00, /*   INPUT (Data,Ary,Abs)                 */
-	0xc0, /* END_COLLECTION                         */
-}
-
-// Combined absolute and relative mouse report descriptor with report ID
-var CombinedMouseReportDesc = []byte{
-	0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
-	0x09, 0x02, // Usage (Mouse)
-	0xA1, 0x01, // Collection (Application)
-
-	// Report ID 1: Absolute Mouse Movement
-	0x85, 0x01, //     Report ID (1)
-	0x09, 0x01, //     Usage (Pointer)
-	0xA1, 0x00, //     Collection (Physical)
-	0x05, 0x09, //         Usage Page (Button)
-	0x19, 0x01, //         Usage Minimum (0x01)
-	0x29, 0x03, //         Usage Maximum (0x03)
-	0x15, 0x00, //         Logical Minimum (0)
-	0x25, 0x01, //         Logical Maximum (1)
-	0x75, 0x01, //         Report Size (1)
-	0x95, 0x03, //         Report Count (3)
-	0x81, 0x02, //         Input (Data, Var, Abs)
-	0x95, 0x01, //         Report Count (1)
-	0x75, 0x05, //         Report Size (5)
-	0x81, 0x03, //         Input (Cnst, Var, Abs)
-	0x05, 0x01, //         Usage Page (Generic Desktop Ctrls)
-	0x09, 0x30, //         Usage (X)
-	0x09, 0x31, //         Usage (Y)
-	0x16, 0x00, 0x00, //         Logical Minimum (0)
-	0x26, 0xFF, 0x7F, //         Logical Maximum (32767)
-	0x36, 0x00, 0x00, //         Physical Minimum (0)
-	0x46, 0xFF, 0x7F, //         Physical Maximum (32767)
-	0x75, 0x10, //         Report Size (16)
-	0x95, 0x02, //         Report Count (2)
-	0x81, 0x02, //         Input (Data, Var, Abs)
-	0xC0, //     End Collection
-
-	// Report ID 2: Relative Wheel Movement
-	0x85, 0x02, //     Report ID (2)
-	0x09, 0x38, //     Usage (Wheel)
-	0x15, 0x81, //     Logical Minimum (-127)
-	0x25, 0x7F, //     Logical Maximum (127)
-	0x75, 0x08, //     Report Size (8)
-	0x95, 0x01, //     Report Count (1)
-	0x81, 0x06, //     Input (Data, Var, Rel)
-
-	0xC0, // End Collection
 }

usb_mass_storage.go

@@ -26,27 +26,33 @@ import (
 
 const massStorageName = "mass_storage.usb0"
 
-var massStorageFunctionPath = path.Join(gadgetPath, "jetkvm", "functions", massStorageName)
-
 func writeFile(path string, data string) error {
 	return os.WriteFile(path, []byte(data), 0644)
 }
 
 func setMassStorageImage(imagePath string) error {
-	err := writeFile(path.Join(massStorageFunctionPath, "lun.0", "file"), imagePath)
+	massStorageFunctionPath, err := gadget.GetConfigPath("mass_storage_lun0")
 	if err != nil {
+		return fmt.Errorf("failed to get mass storage path: %w", err)
+	}
+
+	if err := writeFile(path.Join(massStorageFunctionPath, "file"), imagePath); err != nil {
 		return fmt.Errorf("failed to set image path: %w", err)
 	}
 	return nil
 }
 
 func setMassStorageMode(cdrom bool) error {
+	massStorageFunctionPath, err := gadget.GetConfigPath("mass_storage_lun0")
+	if err != nil {
+		return fmt.Errorf("failed to get mass storage path: %w", err)
+	}
+
 	mode := "0"
 	if cdrom {
 		mode = "1"
 	}
-	err := writeFile(path.Join(massStorageFunctionPath, "lun.0", "cdrom"), mode)
+	if err := writeFile(path.Join(massStorageFunctionPath, "lun.0", "cdrom"), mode); err != nil {
-	if err != nil {
 		return fmt.Errorf("failed to set cdrom mode: %w", err)
 	}
 	return nil
@@ -108,6 +114,11 @@ func rpcMountBuiltInImage(filename string) error {
 }
 
 func getMassStorageMode() (bool, error) {
+	massStorageFunctionPath, err := gadget.GetConfigPath("mass_storage_lun0")
+	if err != nil {
+		return false, fmt.Errorf("failed to get mass storage path: %w", err)
+	}
+
 	data, err := os.ReadFile(path.Join(massStorageFunctionPath, "lun.0", "cdrom"))
 	if err != nil {
 		return false, fmt.Errorf("failed to read cdrom mode: %w", err)