refactor(usb): move usbconfig to a seperated package

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)
+}