mirror of https://github.com/jetkvm/kvm.git
589 lines
16 KiB
Go
589 lines
16 KiB
Go
package kvm
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
gadget "github.com/openstadia/go-usb-gadget"
|
|
)
|
|
|
|
const configFSPath = "/sys/kernel/config"
|
|
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 (u *UsbDevicesConfig) isGadgetConfigItemEnabled(itemKey string) bool {
|
|
switch itemKey {
|
|
case "absolute_mouse":
|
|
return u.AbsoluteMouse
|
|
case "relative_mouse":
|
|
return u.RelativeMouse
|
|
case "keyboard":
|
|
return u.Keyboard
|
|
case "mass_storage_base":
|
|
return u.MassStorage
|
|
case "mass_storage_usb0":
|
|
return u.MassStorage
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
type gadgetConfigItem struct {
|
|
device string
|
|
path []string
|
|
attrs gadgetAttributes
|
|
configAttrs gadgetAttributes
|
|
configPath string
|
|
reportDesc []byte
|
|
}
|
|
|
|
type gadgetAttributes map[string]string
|
|
|
|
var gadgetConfig = map[string]gadgetConfigItem{
|
|
"base": {
|
|
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": {
|
|
path: []string{"strings", "0x409"},
|
|
attrs: gadgetAttributes{
|
|
"serialnumber": GetDeviceID(),
|
|
"manufacturer": "JetKVM",
|
|
"product": "JetKVM USB Emulation Device",
|
|
},
|
|
configAttrs: gadgetAttributes{
|
|
"configuration": "Config 1: HID",
|
|
},
|
|
},
|
|
// keyboard HID
|
|
"keyboard": {
|
|
device: "hid.usb0",
|
|
path: []string{"functions", "hid.usb0"},
|
|
configPath: path.Join(configC1Path, "hid.usb0"),
|
|
attrs: gadgetAttributes{
|
|
"protocol": "1",
|
|
"subclass": "1",
|
|
"report_length": "8",
|
|
},
|
|
reportDesc: KeyboardReportDesc,
|
|
},
|
|
// mouse HID
|
|
"absolute_mouse": {
|
|
device: "hid.usb1",
|
|
path: []string{"functions", "hid.usb1"},
|
|
configPath: path.Join(configC1Path, "hid.usb1"),
|
|
attrs: gadgetAttributes{
|
|
"protocol": "2",
|
|
"subclass": "1",
|
|
"report_length": "6",
|
|
},
|
|
reportDesc: CombinedAbsoluteMouseReportDesc,
|
|
},
|
|
// relative mouse HID
|
|
"relative_mouse": {
|
|
device: "hid.usb2",
|
|
path: []string{"functions", "hid.usb2"},
|
|
configPath: path.Join(configC1Path, "hid.usb2"),
|
|
attrs: gadgetAttributes{
|
|
"protocol": "2",
|
|
"subclass": "1",
|
|
"report_length": "4",
|
|
},
|
|
reportDesc: CombinedRelativeMouseReportDesc,
|
|
},
|
|
// mass storage
|
|
"mass_storage_base": {
|
|
device: "mass_storage.usb0",
|
|
path: []string{"functions", "mass_storage.usb0"},
|
|
configPath: path.Join(configC1Path, "mass_storage.usb0"),
|
|
attrs: gadgetAttributes{
|
|
"stall": "1",
|
|
},
|
|
},
|
|
"mass_storage_usb0": {
|
|
path: []string{"functions", "mass_storage.usb0", "lun.0"},
|
|
attrs: gadgetAttributes{
|
|
"cdrom": "1",
|
|
"ro": "1",
|
|
"removable": "1",
|
|
"file": "\n",
|
|
"inquiry_string": "JetKVM Virtual Media",
|
|
},
|
|
},
|
|
}
|
|
|
|
func mountConfigFS() error {
|
|
_, err := os.Stat(gadgetPath)
|
|
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 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) {
|
|
logger.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 {
|
|
logger.Tracef("skipping writing to %s as it already has the correct content", filePath)
|
|
return nil
|
|
}
|
|
|
|
logger.Tracef("writing to %s as it has different content %v %v", filePath, oldContent, content)
|
|
}
|
|
}
|
|
return os.WriteFile(filePath, content, permMode)
|
|
}
|
|
|
|
func disableGadgetItemConfig(item gadgetConfigItem) error {
|
|
// remove symlink if exists
|
|
if item.configPath != "" {
|
|
if _, err := os.Lstat(item.configPath); os.IsNotExist(err) {
|
|
logger.Tracef("symlink %s does not exist", item.configPath)
|
|
} else {
|
|
err := os.Remove(item.configPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to remove symlink %s: %w", item.configPath, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func writeGadgetItemConfig(item gadgetConfigItem) error {
|
|
// create directory for the item
|
|
gadgetItemPathArr := append([]string{kvmGadgetPath}, item.path...)
|
|
gadgetItemPath := filepath.Join(gadgetItemPathArr...)
|
|
err := os.MkdirAll(gadgetItemPath, 0755)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create path %s: %w", gadgetItemPath, err)
|
|
}
|
|
|
|
if len(item.configAttrs) > 0 {
|
|
configItemPathArr := append([]string{configC1Path}, item.path...)
|
|
configItemPath := filepath.Join(configItemPathArr...)
|
|
err = os.MkdirAll(configItemPath, 0755)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create path %s: %w", config, err)
|
|
}
|
|
|
|
err = writeGadgetAttrs(configItemPath, item.configAttrs)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to write config attributes for %s: %w", configItemPath, err)
|
|
}
|
|
}
|
|
|
|
if len(item.attrs) > 0 {
|
|
// write attributes for the item
|
|
err = 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 = writeIfDifferent(path.Join(gadgetItemPath, "report_desc"), item.reportDesc, 0644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// create symlink if configPath is set
|
|
if item.configPath != "" {
|
|
logger.Tracef("Creating symlink from %s to %s", item.configPath, gadgetItemPath)
|
|
|
|
// check if the symlink already exists, if yes, check if it points to the correct path
|
|
if _, err := os.Lstat(item.configPath); err == nil {
|
|
linkPath, err := os.Readlink(item.configPath)
|
|
if err != nil || linkPath != gadgetItemPath {
|
|
err = os.Remove(item.configPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to remove existing symlink %s: %w", item.configPath, err)
|
|
}
|
|
}
|
|
} else if !os.IsNotExist(err) {
|
|
return fmt.Errorf("failed to check if symlink exists: %w", err)
|
|
}
|
|
|
|
err = os.Symlink(gadgetItemPath, item.configPath)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create symlink from %s to %s: %w", item.configPath, gadgetItemPath, 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
|
|
}
|
|
|
|
logger.Tracef("writing gadget config")
|
|
for key, item := range gadgetConfig {
|
|
// check if the item is enabled in the config
|
|
if !config.UsbDevices.isGadgetConfigItemEnabled(key) {
|
|
logger.Tracef("disabling gadget config: %s", key)
|
|
err = disableGadgetItemConfig(item)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
logger.Tracef("writing gadget config: %s", key)
|
|
err = writeGadgetItemConfig(item)
|
|
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()
|
|
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()
|
|
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 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 abs(x float64) float64 {
|
|
if x < 0 {
|
|
return -x
|
|
}
|
|
return x
|
|
}
|
|
|
|
var usbState = "unknown"
|
|
|
|
func rpcGetUSBState() (state string) {
|
|
stateBytes, err := os.ReadFile("/sys/class/udc/ffb00000.usb/state")
|
|
if err != nil {
|
|
return "unknown"
|
|
}
|
|
return strings.TrimSpace(string(stateBytes))
|
|
}
|
|
|
|
func triggerUSBStateUpdate() {
|
|
go func() {
|
|
if currentSession == nil {
|
|
log.Println("No active RPC session, skipping update state update")
|
|
return
|
|
}
|
|
writeJSONRPCEvent("usbState", usbState, currentSession)
|
|
}()
|
|
}
|
|
|
|
var udc string
|
|
|
|
func init() {
|
|
ensureConfigLoaded()
|
|
|
|
go func() {
|
|
for {
|
|
newState := rpcGetUSBState()
|
|
if newState != usbState {
|
|
log.Printf("USB state changed from %s to %s", usbState, newState)
|
|
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
|
|
}
|