diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 59053daf..8ba5444a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -15,7 +15,7 @@ jobs:
if: github.event_name != 'pull_request_review' || github.event.review.state == 'approved'
steps:
- name: Checkout
- uses: actions/checkout@v4
+ uses: actions/checkout@v5
- name: Set up Node.js
uses: actions/setup-node@v4
with:
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index 6c6dff37..4c08b85b 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -22,7 +22,7 @@ jobs:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+ uses: actions/checkout@ff7abcd0c3c05ccf6adc123a8cd1fd4fb30fb493 # v4.2.2
- name: Install Go
uses: actions/setup-go@fa96338abe5531f6e34c5cc0bbe28c1a533d5505 # v4.2.1
with:
diff --git a/.github/workflows/ui-lint.yml b/.github/workflows/ui-lint.yml
index ad002fc9..32374d33 100644
--- a/.github/workflows/ui-lint.yml
+++ b/.github/workflows/ui-lint.yml
@@ -17,7 +17,7 @@ jobs:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
- uses: actions/checkout@v4
+ uses: actions/checkout@v5
- name: Set up Node.js
uses: actions/setup-node@v4
with:
diff --git a/block_device.go b/block_device.go
index 22740985..2099da8f 100644
--- a/block_device.go
+++ b/block_device.go
@@ -22,25 +22,12 @@ func (r remoteImageBackend) ReadAt(p []byte, off int64) (n int, err error) {
return 0, errors.New("image not mounted")
}
source := currentVirtualMediaState.Source
- mountedImageSize := currentVirtualMediaState.Size
virtualMediaStateMutex.RUnlock()
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ _, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
- readLen := int64(len(p))
- if off+readLen > mountedImageSize {
- readLen = mountedImageSize - off
- }
- var data []byte
switch source {
- case WebRTC:
- data, err = webRTCDiskReader.Read(ctx, off, readLen)
- if err != nil {
- return 0, err
- }
- n = copy(p, data)
- return n, nil
case HTTP:
return httpRangeReader.ReadAt(p, off)
default:
diff --git a/config.go b/config.go
index ba06dacd..a5239ab5 100644
--- a/config.go
+++ b/config.go
@@ -114,7 +114,7 @@ var defaultConfig = &Config{
ActiveExtension: "",
KeyboardMacros: []KeyboardMacro{},
DisplayRotation: "270",
- KeyboardLayout: "en_US",
+ KeyboardLayout: "en-US",
DisplayMaxBrightness: 64,
DisplayDimAfterSec: 120, // 2 minutes
DisplayOffAfterSec: 1800, // 30 minutes
diff --git a/display.go b/display.go
index a2504b60..f34a6486 100644
--- a/display.go
+++ b/display.go
@@ -30,7 +30,7 @@ const (
// do not call this function directly, use switchToScreenIfDifferent instead
// this function is not thread safe
func switchToScreen(screen string) {
- _, err := CallCtrlAction("lv_scr_load", map[string]interface{}{"obj": screen})
+ _, err := CallCtrlAction("lv_scr_load", map[string]any{"obj": screen})
if err != nil {
displayLogger.Warn().Err(err).Str("screen", screen).Msg("failed to switch to screen")
return
@@ -39,15 +39,15 @@ func switchToScreen(screen string) {
}
func lvObjSetState(objName string, state string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_obj_set_state", map[string]interface{}{"obj": objName, "state": state})
+ return CallCtrlAction("lv_obj_set_state", map[string]any{"obj": objName, "state": state})
}
func lvObjAddFlag(objName string, flag string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_obj_add_flag", map[string]interface{}{"obj": objName, "flag": flag})
+ return CallCtrlAction("lv_obj_add_flag", map[string]any{"obj": objName, "flag": flag})
}
func lvObjClearFlag(objName string, flag string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_obj_clear_flag", map[string]interface{}{"obj": objName, "flag": flag})
+ return CallCtrlAction("lv_obj_clear_flag", map[string]any{"obj": objName, "flag": flag})
}
func lvObjHide(objName string) (*CtrlResponse, error) {
@@ -59,27 +59,27 @@ func lvObjShow(objName string) (*CtrlResponse, error) {
}
func lvObjSetOpacity(objName string, opacity int) (*CtrlResponse, error) { // nolint:unused
- return CallCtrlAction("lv_obj_set_style_opa_layered", map[string]interface{}{"obj": objName, "opa": opacity})
+ return CallCtrlAction("lv_obj_set_style_opa_layered", map[string]any{"obj": objName, "opa": opacity})
}
func lvObjFadeIn(objName string, duration uint32) (*CtrlResponse, error) {
- return CallCtrlAction("lv_obj_fade_in", map[string]interface{}{"obj": objName, "time": duration})
+ return CallCtrlAction("lv_obj_fade_in", map[string]any{"obj": objName, "time": duration})
}
func lvObjFadeOut(objName string, duration uint32) (*CtrlResponse, error) {
- return CallCtrlAction("lv_obj_fade_out", map[string]interface{}{"obj": objName, "time": duration})
+ return CallCtrlAction("lv_obj_fade_out", map[string]any{"obj": objName, "time": duration})
}
func lvLabelSetText(objName string, text string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_label_set_text", map[string]interface{}{"obj": objName, "text": text})
+ return CallCtrlAction("lv_label_set_text", map[string]any{"obj": objName, "text": text})
}
func lvImgSetSrc(objName string, src string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_img_set_src", map[string]interface{}{"obj": objName, "src": src})
+ return CallCtrlAction("lv_img_set_src", map[string]any{"obj": objName, "src": src})
}
func lvDispSetRotation(rotation string) (*CtrlResponse, error) {
- return CallCtrlAction("lv_disp_set_rotation", map[string]interface{}{"rotation": rotation})
+ return CallCtrlAction("lv_disp_set_rotation", map[string]any{"rotation": rotation})
}
func updateLabelIfChanged(objName string, newText string) {
diff --git a/fuse.go b/fuse.go
deleted file mode 100644
index 19f144f0..00000000
--- a/fuse.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package kvm
-
-import (
- "context"
- "os"
- "sync"
- "syscall"
-
- "github.com/hanwen/go-fuse/v2/fs"
- "github.com/hanwen/go-fuse/v2/fuse"
-)
-
-type WebRTCStreamFile struct {
- fs.Inode
- mu sync.Mutex
- Attr fuse.Attr
- size uint64
-}
-
-var _ = (fs.NodeOpener)((*WebRTCStreamFile)(nil))
-var _ = (fs.NodeOpener)((*WebRTCStreamFile)(nil))
-var _ = (fs.NodeOpener)((*WebRTCStreamFile)(nil))
-var _ = (fs.NodeOpener)((*WebRTCStreamFile)(nil))
-var _ = (fs.NodeOpener)((*WebRTCStreamFile)(nil))
-
-func (f *WebRTCStreamFile) Open(ctx context.Context, flags uint32) (fh fs.FileHandle, fuseFlags uint32, errno syscall.Errno) {
- return nil, fuse.FOPEN_KEEP_CACHE, fs.OK
-}
-
-func (f *WebRTCStreamFile) Write(ctx context.Context, fh fs.FileHandle, data []byte, off int64) (uint32, syscall.Errno) {
- return 0, syscall.EROFS
-}
-
-var _ = (fs.NodeGetattrer)((*WebRTCStreamFile)(nil))
-
-func (f *WebRTCStreamFile) Getattr(ctx context.Context, fh fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
- f.mu.Lock()
- defer f.mu.Unlock()
- out.Attr = f.Attr
- out.Size = f.size
- return fs.OK
-}
-
-func (f *WebRTCStreamFile) Setattr(ctx context.Context, fh fs.FileHandle, in *fuse.SetAttrIn, out *fuse.AttrOut) syscall.Errno {
- f.mu.Lock()
- defer f.mu.Unlock()
- out.Attr = f.Attr
- return fs.OK
-}
-
-func (f *WebRTCStreamFile) Flush(ctx context.Context, fh fs.FileHandle) syscall.Errno {
- return fs.OK
-}
-
-type DiskReadRequest struct {
- Start uint64 `json:"start"`
- End uint64 `json:"end"`
-}
-
-var diskReadChan = make(chan []byte, 1)
-
-func (f *WebRTCStreamFile) Read(ctx context.Context, fh fs.FileHandle, dest []byte, off int64) (fuse.ReadResult, syscall.Errno) {
- buf, err := webRTCDiskReader.Read(ctx, off, int64(len(dest)))
- if err != nil {
- return nil, syscall.EIO
- }
- return fuse.ReadResultData(buf), fs.OK
-}
-
-func (f *WebRTCStreamFile) SetSize(size uint64) {
- f.mu.Lock()
- defer f.mu.Unlock()
- f.size = size
-}
-
-type FuseRoot struct {
- fs.Inode
-}
-
-var webRTCStreamFile = &WebRTCStreamFile{}
-
-func (r *FuseRoot) OnAdd(ctx context.Context) {
- ch := r.NewPersistentInode(ctx, webRTCStreamFile, fs.StableAttr{Ino: 2})
- r.AddChild("disk", ch, false)
-}
-
-func (r *FuseRoot) Getattr(ctx context.Context, fh fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
- out.Mode = 0755
- return 0
-}
-
-var _ = (fs.NodeGetattrer)((*FuseRoot)(nil))
-var _ = (fs.NodeOnAdder)((*FuseRoot)(nil))
-
-const fuseMountPoint = "/mnt/webrtc"
-
-var fuseServer *fuse.Server
-
-func RunFuseServer() {
- opts := &fs.Options{}
- opts.DirectMountStrict = true
- _ = os.Mkdir(fuseMountPoint, 0755)
- var err error
- fuseServer, err = fs.Mount(fuseMountPoint, &FuseRoot{}, opts)
- if err != nil {
- logger.Warn().Err(err).Msg("failed to mount fuse")
- }
- fuseServer.Wait()
-}
-
-type WebRTCImage struct {
- Size uint64 `json:"size"`
- Filename string `json:"filename"`
-}
diff --git a/go.mod b/go.mod
index 3e41071e..72e57cd2 100644
--- a/go.mod
+++ b/go.mod
@@ -6,32 +6,31 @@ require (
github.com/Masterminds/semver/v3 v3.4.0
github.com/beevik/ntp v1.4.3
github.com/coder/websocket v1.8.13
- github.com/coreos/go-oidc/v3 v3.14.1
+ github.com/coreos/go-oidc/v3 v3.15.0
github.com/creack/pty v1.1.24
github.com/fsnotify/fsnotify v1.9.0
github.com/gin-contrib/logger v1.2.6
github.com/gin-gonic/gin v1.10.1
- github.com/go-co-op/gocron/v2 v2.16.3
+ github.com/go-co-op/gocron/v2 v2.16.5
github.com/google/uuid v1.6.0
github.com/guregu/null/v6 v6.0.0
- github.com/gwatts/rootcerts v0.0.0-20250601184604-370a9a75f341
- github.com/hanwen/go-fuse/v2 v2.8.0
+ github.com/gwatts/rootcerts v0.0.0-20250901182336-dc5ae18bd79f
github.com/pion/logging v0.2.4
github.com/pion/mdns/v2 v2.0.7
- github.com/pion/webrtc/v4 v4.1.3
+ github.com/pion/webrtc/v4 v4.1.4
github.com/pojntfx/go-nbd v0.3.2
- github.com/prometheus/client_golang v1.22.0
- github.com/prometheus/common v0.65.0
- github.com/prometheus/procfs v0.16.1
+ github.com/prometheus/client_golang v1.23.0
+ github.com/prometheus/common v0.66.0
+ github.com/prometheus/procfs v0.17.0
github.com/psanford/httpreadat v0.1.0
github.com/rs/zerolog v1.34.0
github.com/sourcegraph/tf-dag v0.2.2-0.20250131204052-3e8ff1477b4f
- github.com/stretchr/testify v1.10.0
+ github.com/stretchr/testify v1.11.1
github.com/vishvananda/netlink v1.3.1
go.bug.st/serial v1.6.4
- golang.org/x/crypto v0.40.0
- golang.org/x/net v0.41.0
- golang.org/x/sys v0.34.0
+ golang.org/x/crypto v0.41.0
+ golang.org/x/net v0.43.0
+ golang.org/x/sys v0.35.0
)
replace github.com/pojntfx/go-nbd v0.3.2 => github.com/chemhack/go-nbd v0.0.0-20241006125820-59e45f5b1e7b
@@ -51,6 +50,7 @@ require (
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.26.0 // indirect
github.com/goccy/go-json v0.10.5 // indirect
+ github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc // indirect
github.com/jonboulle/clockwork v0.5.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.2.10 // indirect
@@ -63,18 +63,18 @@ require (
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/pilebones/go-udev v0.9.1 // indirect
github.com/pion/datachannel v1.5.10 // indirect
- github.com/pion/dtls/v3 v3.0.6 // indirect
+ github.com/pion/dtls/v3 v3.0.7 // indirect
github.com/pion/ice/v4 v4.0.10 // indirect
github.com/pion/interceptor v0.1.40 // indirect
github.com/pion/randutil v0.1.0 // indirect
github.com/pion/rtcp v1.2.15 // indirect
- github.com/pion/rtp v1.8.20 // indirect
+ github.com/pion/rtp v1.8.22 // indirect
github.com/pion/sctp v1.8.39 // indirect
- github.com/pion/sdp/v3 v3.0.14 // indirect
- github.com/pion/srtp/v3 v3.0.6 // indirect
+ github.com/pion/sdp/v3 v3.0.16 // indirect
+ github.com/pion/srtp/v3 v3.0.7 // indirect
github.com/pion/stun/v3 v3.0.0 // indirect
github.com/pion/transport/v3 v3.0.7 // indirect
- github.com/pion/turn/v4 v4.0.2 // indirect
+ github.com/pion/turn/v4 v4.1.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/prometheus/client_model v0.6.2 // indirect
github.com/robfig/cron/v3 v3.0.1 // indirect
@@ -85,7 +85,8 @@ require (
github.com/wlynxg/anet v0.0.5 // indirect
golang.org/x/arch v0.18.0 // indirect
golang.org/x/oauth2 v0.30.0 // indirect
- golang.org/x/text v0.27.0 // indirect
- google.golang.org/protobuf v1.36.6 // indirect
+ golang.org/x/text v0.28.0 // indirect
+ google.golang.org/protobuf v1.36.8 // indirect
+ gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
diff --git a/go.sum b/go.sum
index 6b75ad17..36087a28 100644
--- a/go.sum
+++ b/go.sum
@@ -18,8 +18,8 @@ github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJ
github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
github.com/coder/websocket v1.8.13 h1:f3QZdXy7uGVz+4uCJy2nTZyM0yTBj8yANEHhqlXZ9FE=
github.com/coder/websocket v1.8.13/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
-github.com/coreos/go-oidc/v3 v3.14.1 h1:9ePWwfdwC4QKRlCXsJGou56adA/owXczOzwKdOumLqk=
-github.com/coreos/go-oidc/v3 v3.14.1/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmrfah6hnSYEU=
+github.com/coreos/go-oidc/v3 v3.15.0 h1:R6Oz8Z4bqWR7VFQ+sPSvZPQv4x8M+sJkDO5ojgwlyAg=
+github.com/coreos/go-oidc/v3 v3.15.0/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmrfah6hnSYEU=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/creack/goselect v0.1.3 h1:MaGNMclRo7P2Jl21hBpR1Cn33ITSbKP6E49RtfblLKc=
github.com/creack/goselect v0.1.3/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
@@ -38,8 +38,8 @@ github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.10.1 h1:T0ujvqyCSqRopADpgPgiTT63DUQVSfojyME59Ei63pQ=
github.com/gin-gonic/gin v1.10.1/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
-github.com/go-co-op/gocron/v2 v2.16.3 h1:kYqukZqBa8RC2+AFAHnunmKcs9GRTjwBo8WRF3I6cbI=
-github.com/go-co-op/gocron/v2 v2.16.3/go.mod h1:aTf7/+5Jo2E+cyAqq625UQ6DzpkV96b22VHIUAt6l3c=
+github.com/go-co-op/gocron/v2 v2.16.5 h1:j228Jxk7bb9CF8LKR3gS+bK3rcjRUINjlVI+ZMp26Ss=
+github.com/go-co-op/gocron/v2 v2.16.5/go.mod h1:zAfC/GFQ668qHxOVl/D68Jh5Ce7sDqX6TJnSQyRkRBc=
github.com/go-jose/go-jose/v4 v4.1.0 h1:cYSYxd3pw5zd2FSXk2vGdn9igQU2PS8MuxrCOCl0FdY=
github.com/go-jose/go-jose/v4 v4.1.0/go.mod h1:GG/vqmYm3Von2nYiB2vGTXzdoNKE5tix5tuc6iAd+sw=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
@@ -58,12 +58,12 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc h1:GN2Lv3MGO7AS6PrRoT6yV5+wkrOpcszoIsO4+4ds248=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc/go.mod h1:+JKpmjMGhpgPL+rXZ5nsZieVzvarn86asRlBg4uNGnk=
github.com/guregu/null/v6 v6.0.0 h1:N14VRS+4di81i1PXRiprbQJ9EM9gqBa0+KVMeS/QSjQ=
github.com/guregu/null/v6 v6.0.0/go.mod h1:hrMIhIfrOZeLPZhROSn149tpw2gHkidAqxoXNyeX3iQ=
-github.com/gwatts/rootcerts v0.0.0-20250601184604-370a9a75f341 h1:zPrkLSKi7kKJoNJH4uUmsQ86+0/QqpwEns0NyNLwKv0=
-github.com/gwatts/rootcerts v0.0.0-20250601184604-370a9a75f341/go.mod h1:5Kt9XkWvkGi2OHOq0QsGxebHmhCcqJ8KCbNg/a6+n+g=
-github.com/hanwen/go-fuse/v2 v2.8.0 h1:wV8rG7rmCz8XHSOwBZhG5YcVqcYjkzivjmbaMafPlAs=
-github.com/hanwen/go-fuse/v2 v2.8.0/go.mod h1:yE6D2PqWwm3CbYRxFXV9xUd8Md5d6NG0WBs5spCswmI=
+github.com/gwatts/rootcerts v0.0.0-20250901182336-dc5ae18bd79f h1:08t2PbrkDgW2+mwCQ3jhKUBrCM9Bc9SeH5j2Dst3B+0=
+github.com/gwatts/rootcerts v0.0.0-20250901182336-dc5ae18bd79f/go.mod h1:5Kt9XkWvkGi2OHOq0QsGxebHmhCcqJ8KCbNg/a6+n+g=
github.com/jonboulle/clockwork v0.5.0 h1:Hyh9A8u51kptdkR+cqRpT1EebBwTn1oK9YfGYbdFz6I=
github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7XN3SzBPjZF60=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -92,8 +92,6 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/moby/sys/mountinfo v0.7.2 h1:1shs6aH5s4o5H2zQLn796ADW1wMrIwHsyJ2v9KouLrg=
-github.com/moby/sys/mountinfo v0.7.2/go.mod h1:1YOa8w8Ih7uW0wALDUgT1dTTSBrZ+HiBLGws92L2RU4=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -107,8 +105,8 @@ github.com/pilebones/go-udev v0.9.1 h1:uN72M1C1fgzhsVmBGEM8w9RD1JY4iVsPZpr+Z6rb3
github.com/pilebones/go-udev v0.9.1/go.mod h1:Bgcl07crebF3JSeS4+nuaRvhWFdCeFoBhXXeAp93XNo=
github.com/pion/datachannel v1.5.10 h1:ly0Q26K1i6ZkGf42W7D4hQYR90pZwzFOjTq5AuCKk4o=
github.com/pion/datachannel v1.5.10/go.mod h1:p/jJfC9arb29W7WrxyKbepTU20CFgyx5oLo8Rs4Py/M=
-github.com/pion/dtls/v3 v3.0.6 h1:7Hkd8WhAJNbRgq9RgdNh1aaWlZlGpYTzdqjy9x9sK2E=
-github.com/pion/dtls/v3 v3.0.6/go.mod h1:iJxNQ3Uhn1NZWOMWlLxEEHAN5yX7GyPvvKw04v9bzYU=
+github.com/pion/dtls/v3 v3.0.7 h1:bItXtTYYhZwkPFk4t1n3Kkf5TDrfj6+4wG+CZR8uI9Q=
+github.com/pion/dtls/v3 v3.0.7/go.mod h1:uDlH5VPrgOQIw59irKYkMudSFprY9IEFCqz/eTz16f8=
github.com/pion/ice/v4 v4.0.10 h1:P59w1iauC/wPk9PdY8Vjl4fOFL5B+USq1+xbDcN6gT4=
github.com/pion/ice/v4 v4.0.10/go.mod h1:y3M18aPhIxLlcO/4dn9X8LzLLSma84cx6emMSu14FGw=
github.com/pion/interceptor v0.1.40 h1:e0BjnPcGpr2CFQgKhrQisBU7V3GXK6wrfYrGYaU6Jq4=
@@ -121,33 +119,33 @@ github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
github.com/pion/rtcp v1.2.15 h1:LZQi2JbdipLOj4eBjK4wlVoQWfrZbh3Q6eHtWtJBZBo=
github.com/pion/rtcp v1.2.15/go.mod h1:jlGuAjHMEXwMUHK78RgX0UmEJFV4zUKOFHR7OP+D3D0=
-github.com/pion/rtp v1.8.20 h1:8zcyqohadZE8FCBeGdyEvHiclPIezcwRQH9zfapFyYI=
-github.com/pion/rtp v1.8.20/go.mod h1:bAu2UFKScgzyFqvUKmbvzSdPr+NGbZtv6UB2hesqXBk=
+github.com/pion/rtp v1.8.22 h1:8NCVDDF+uSJmMUkjLJVnIr/HX7gPesyMV1xFt5xozXc=
+github.com/pion/rtp v1.8.22/go.mod h1:rF5nS1GqbR7H/TCpKwylzeq6yDM+MM6k+On5EgeThEM=
github.com/pion/sctp v1.8.39 h1:PJma40vRHa3UTO3C4MyeJDQ+KIobVYRZQZ0Nt7SjQnE=
github.com/pion/sctp v1.8.39/go.mod h1:cNiLdchXra8fHQwmIoqw0MbLLMs+f7uQ+dGMG2gWebE=
-github.com/pion/sdp/v3 v3.0.14 h1:1h7gBr9FhOWH5GjWWY5lcw/U85MtdcibTyt/o6RxRUI=
-github.com/pion/sdp/v3 v3.0.14/go.mod h1:88GMahN5xnScv1hIMTqLdu/cOcUkj6a9ytbncwMCq2E=
-github.com/pion/srtp/v3 v3.0.6 h1:E2gyj1f5X10sB/qILUGIkL4C2CqK269Xq167PbGCc/4=
-github.com/pion/srtp/v3 v3.0.6/go.mod h1:BxvziG3v/armJHAaJ87euvkhHqWe9I7iiOy50K2QkhY=
+github.com/pion/sdp/v3 v3.0.16 h1:0dKzYO6gTAvuLaAKQkC02eCPjMIi4NuAr/ibAwrGDCo=
+github.com/pion/sdp/v3 v3.0.16/go.mod h1:9tyKzznud3qiweZcD86kS0ff1pGYB3VX+Bcsmkx6IXo=
+github.com/pion/srtp/v3 v3.0.7 h1:QUElw0A/FUg3MP8/KNMZB3i0m8F9XeMnTum86F7S4bs=
+github.com/pion/srtp/v3 v3.0.7/go.mod h1:qvnHeqbhT7kDdB+OGB05KA/P067G3mm7XBfLaLiaNF0=
github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw=
github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU=
github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0=
github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo=
-github.com/pion/turn/v4 v4.0.2 h1:ZqgQ3+MjP32ug30xAbD6Mn+/K4Sxi3SdNOTFf+7mpps=
-github.com/pion/turn/v4 v4.0.2/go.mod h1:pMMKP/ieNAG/fN5cZiN4SDuyKsXtNTr0ccN7IToA1zs=
-github.com/pion/webrtc/v4 v4.1.3 h1:YZ67Boj9X/hk190jJZ8+HFGQ6DqSZ/fYP3sLAZv7c3c=
-github.com/pion/webrtc/v4 v4.1.3/go.mod h1:rsq+zQ82ryfR9vbb0L1umPJ6Ogq7zm8mcn9fcGnxomM=
+github.com/pion/turn/v4 v4.1.1 h1:9UnY2HB99tpDyz3cVVZguSxcqkJ1DsTSZ+8TGruh4fc=
+github.com/pion/turn/v4 v4.1.1/go.mod h1:2123tHk1O++vmjI5VSD0awT50NywDAq5A2NNNU4Jjs8=
+github.com/pion/webrtc/v4 v4.1.4 h1:/gK1ACGHXQmtyVVbJFQDxNoODg4eSRiFLB7t9r9pg8M=
+github.com/pion/webrtc/v4 v4.1.4/go.mod h1:Oab9npu1iZtQRMic3K3toYq5zFPvToe/QBw7dMI2ok4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
-github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
+github.com/prometheus/client_golang v1.23.0 h1:ust4zpdl9r4trLY/gSjlm07PuiBq2ynaXXlptpfy8Uc=
+github.com/prometheus/client_golang v1.23.0/go.mod h1:i/o0R9ByOnHX0McrTMTyhYvKE4haaf2mW08I+jGAjEE=
github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
-github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
-github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
-github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
+github.com/prometheus/common v0.66.0 h1:K/rJPHrG3+AoQs50r2+0t7zMnMzek2Vbv31OFVsMeVY=
+github.com/prometheus/common v0.66.0/go.mod h1:Ux6NtV1B4LatamKE63tJBntoxD++xmtI/lK0VtEplN4=
+github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
+github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
github.com/psanford/httpreadat v0.1.0 h1:VleW1HS2zO7/4c7c7zNl33fO6oYACSagjJIyMIwZLUE=
github.com/psanford/httpreadat v0.1.0/go.mod h1:Zg7P+TlBm3bYbyHTKv/EdtSJZn3qwbPwpfZ/I9GKCRE=
github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
@@ -167,8 +165,8 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
@@ -185,10 +183,10 @@ go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
golang.org/x/arch v0.18.0 h1:WN9poc33zL4AzGxqf8VtpKUnGvMi8O9lhNyBMF/85qc=
golang.org/x/arch v0.18.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
-golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
-golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -196,15 +194,17 @@ golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
-golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/hidrpc.go b/hidrpc.go
new file mode 100644
index 00000000..74fe687f
--- /dev/null
+++ b/hidrpc.go
@@ -0,0 +1,162 @@
+package kvm
+
+import (
+ "fmt"
+ "time"
+
+ "github.com/jetkvm/kvm/internal/hidrpc"
+ "github.com/jetkvm/kvm/internal/usbgadget"
+)
+
+func handleHidRPCMessage(message hidrpc.Message, session *Session) {
+ var rpcErr error
+
+ switch message.Type() {
+ case hidrpc.TypeHandshake:
+ message, err := hidrpc.NewHandshakeMessage().Marshal()
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to marshal handshake message")
+ return
+ }
+ if err := session.HidChannel.Send(message); err != nil {
+ logger.Warn().Err(err).Msg("failed to send handshake message")
+ return
+ }
+ session.hidRPCAvailable = true
+ case hidrpc.TypeKeypressReport, hidrpc.TypeKeyboardReport:
+ keysDownState, err := handleHidRPCKeyboardInput(message)
+ if keysDownState != nil {
+ session.reportHidRPCKeysDownState(*keysDownState)
+ }
+ rpcErr = err
+ case hidrpc.TypePointerReport:
+ pointerReport, err := message.PointerReport()
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to get pointer report")
+ return
+ }
+ rpcErr = rpcAbsMouseReport(pointerReport.X, pointerReport.Y, pointerReport.Button)
+ case hidrpc.TypeMouseReport:
+ mouseReport, err := message.MouseReport()
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to get mouse report")
+ return
+ }
+ rpcErr = rpcRelMouseReport(mouseReport.DX, mouseReport.DY, mouseReport.Button)
+ default:
+ logger.Warn().Uint8("type", uint8(message.Type())).Msg("unknown HID RPC message type")
+ }
+
+ if rpcErr != nil {
+ logger.Warn().Err(rpcErr).Msg("failed to handle HID RPC message")
+ }
+}
+
+func onHidMessage(data []byte, session *Session) {
+ scopedLogger := hidRPCLogger.With().Bytes("data", data).Logger()
+ scopedLogger.Debug().Msg("HID RPC message received")
+
+ if len(data) < 1 {
+ scopedLogger.Warn().Int("length", len(data)).Msg("received empty data in HID RPC message handler")
+ return
+ }
+
+ var message hidrpc.Message
+
+ if err := hidrpc.Unmarshal(data, &message); err != nil {
+ scopedLogger.Warn().Err(err).Msg("failed to unmarshal HID RPC message")
+ return
+ }
+
+ scopedLogger = scopedLogger.With().Str("descr", message.String()).Logger()
+
+ t := time.Now()
+
+ r := make(chan interface{})
+ go func() {
+ handleHidRPCMessage(message, session)
+ r <- nil
+ }()
+ select {
+ case <-time.After(1 * time.Second):
+ scopedLogger.Warn().Msg("HID RPC message timed out")
+ case <-r:
+ scopedLogger.Debug().Dur("duration", time.Since(t)).Msg("HID RPC message handled")
+ }
+}
+
+func handleHidRPCKeyboardInput(message hidrpc.Message) (*usbgadget.KeysDownState, error) {
+ switch message.Type() {
+ case hidrpc.TypeKeypressReport:
+ keypressReport, err := message.KeypressReport()
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to get keypress report")
+ return nil, err
+ }
+ keysDownState, rpcError := rpcKeypressReport(keypressReport.Key, keypressReport.Press)
+ return &keysDownState, rpcError
+ case hidrpc.TypeKeyboardReport:
+ keyboardReport, err := message.KeyboardReport()
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to get keyboard report")
+ return nil, err
+ }
+ keysDownState, rpcError := rpcKeyboardReport(keyboardReport.Modifier, keyboardReport.Keys)
+ return &keysDownState, rpcError
+ }
+
+ return nil, fmt.Errorf("unknown HID RPC message type: %d", message.Type())
+}
+
+func reportHidRPC(params any, session *Session) {
+ if session == nil {
+ logger.Warn().Msg("session is nil, skipping reportHidRPC")
+ return
+ }
+
+ if !session.hidRPCAvailable || session.HidChannel == nil {
+ logger.Warn().Msg("HID RPC is not available, skipping reportHidRPC")
+ return
+ }
+
+ var (
+ message []byte
+ err error
+ )
+ switch params := params.(type) {
+ case usbgadget.KeyboardState:
+ message, err = hidrpc.NewKeyboardLedMessage(params).Marshal()
+ case usbgadget.KeysDownState:
+ message, err = hidrpc.NewKeydownStateMessage(params).Marshal()
+ default:
+ err = fmt.Errorf("unknown HID RPC message type: %T", params)
+ }
+
+ if err != nil {
+ logger.Warn().Err(err).Msg("failed to marshal HID RPC message")
+ return
+ }
+
+ if message == nil {
+ logger.Warn().Msg("failed to marshal HID RPC message")
+ return
+ }
+
+ if err := session.HidChannel.Send(message); err != nil {
+ logger.Warn().Err(err).Msg("failed to send HID RPC message")
+ }
+}
+
+func (s *Session) reportHidRPCKeyboardLedState(state usbgadget.KeyboardState) {
+ if !s.hidRPCAvailable {
+ writeJSONRPCEvent("keyboardLedState", state, s)
+ }
+ reportHidRPC(state, s)
+}
+
+func (s *Session) reportHidRPCKeysDownState(state usbgadget.KeysDownState) {
+ if !s.hidRPCAvailable {
+ writeJSONRPCEvent("keysDownState", state, s)
+ }
+ reportHidRPC(state, s)
+}
diff --git a/internal/confparser/confparser.go b/internal/confparser/confparser.go
index 5ccd1cbe..aaa39686 100644
--- a/internal/confparser/confparser.go
+++ b/internal/confparser/confparser.go
@@ -16,22 +16,22 @@ import (
type FieldConfig struct {
Name string
Required bool
- RequiredIf map[string]interface{}
+ RequiredIf map[string]any
OneOf []string
ValidateTypes []string
- Defaults interface{}
+ Defaults any
IsEmpty bool
- CurrentValue interface{}
+ CurrentValue any
TypeString string
Delegated bool
shouldUpdateValue bool
}
-func SetDefaultsAndValidate(config interface{}) error {
+func SetDefaultsAndValidate(config any) error {
return setDefaultsAndValidate(config, true)
}
-func setDefaultsAndValidate(config interface{}, isRoot bool) error {
+func setDefaultsAndValidate(config any, isRoot bool) error {
// first we need to check if the config is a pointer
if reflect.TypeOf(config).Kind() != reflect.Ptr {
return fmt.Errorf("config is not a pointer")
@@ -55,7 +55,7 @@ func setDefaultsAndValidate(config interface{}, isRoot bool) error {
Name: field.Name,
OneOf: splitString(field.Tag.Get("one_of")),
ValidateTypes: splitString(field.Tag.Get("validate_type")),
- RequiredIf: make(map[string]interface{}),
+ RequiredIf: make(map[string]any),
CurrentValue: fieldValue.Interface(),
IsEmpty: false,
TypeString: fieldType,
@@ -142,8 +142,8 @@ func setDefaultsAndValidate(config interface{}, isRoot bool) error {
// now check if the field has required_if
requiredIf := field.Tag.Get("required_if")
if requiredIf != "" {
- requiredIfParts := strings.Split(requiredIf, ",")
- for _, part := range requiredIfParts {
+ requiredIfParts := strings.SplitSeq(requiredIf, ",")
+ for part := range requiredIfParts {
partVal := strings.SplitN(part, "=", 2)
if len(partVal) != 2 {
return fmt.Errorf("invalid required_if for field `%s`: %s", field.Name, requiredIf)
@@ -168,7 +168,7 @@ func setDefaultsAndValidate(config interface{}, isRoot bool) error {
return nil
}
-func validateFields(config interface{}, fields map[string]FieldConfig) error {
+func validateFields(config any, fields map[string]FieldConfig) error {
// now we can start to validate the fields
for _, fieldConfig := range fields {
if err := fieldConfig.validate(fields); err != nil {
@@ -215,7 +215,7 @@ func (f *FieldConfig) validate(fields map[string]FieldConfig) error {
return nil
}
-func (f *FieldConfig) populate(config interface{}) {
+func (f *FieldConfig) populate(config any) {
// update the field if it's not empty
if !f.shouldUpdateValue {
return
diff --git a/internal/confparser/utils.go b/internal/confparser/utils.go
index a46871e9..36ee28b1 100644
--- a/internal/confparser/utils.go
+++ b/internal/confparser/utils.go
@@ -16,7 +16,7 @@ func splitString(s string) []string {
return strings.Split(s, ",")
}
-func toString(v interface{}) (string, error) {
+func toString(v any) (string, error) {
switch v := v.(type) {
case string:
return v, nil
diff --git a/internal/hidrpc/hidrpc.go b/internal/hidrpc/hidrpc.go
new file mode 100644
index 00000000..e9c8c24d
--- /dev/null
+++ b/internal/hidrpc/hidrpc.go
@@ -0,0 +1,100 @@
+package hidrpc
+
+import (
+ "fmt"
+
+ "github.com/jetkvm/kvm/internal/usbgadget"
+)
+
+// MessageType is the type of the HID RPC message
+type MessageType byte
+
+const (
+ TypeHandshake MessageType = 0x01
+ TypeKeyboardReport MessageType = 0x02
+ TypePointerReport MessageType = 0x03
+ TypeWheelReport MessageType = 0x04
+ TypeKeypressReport MessageType = 0x05
+ TypeMouseReport MessageType = 0x06
+ TypeKeyboardLedState MessageType = 0x32
+ TypeKeydownState MessageType = 0x33
+)
+
+const (
+ Version byte = 0x01 // Version of the HID RPC protocol
+)
+
+// GetQueueIndex returns the index of the queue to which the message should be enqueued.
+func GetQueueIndex(messageType MessageType) int {
+ switch messageType {
+ case TypeHandshake:
+ return 0
+ case TypeKeyboardReport, TypeKeypressReport, TypeKeyboardLedState, TypeKeydownState:
+ return 1
+ case TypePointerReport, TypeMouseReport, TypeWheelReport:
+ return 2
+ default:
+ return 3
+ }
+}
+
+// Unmarshal unmarshals the HID RPC message from the data.
+func Unmarshal(data []byte, message *Message) error {
+ l := len(data)
+ if l < 1 {
+ return fmt.Errorf("invalid data length: %d", l)
+ }
+
+ message.t = MessageType(data[0])
+ message.d = data[1:]
+ return nil
+}
+
+// Marshal marshals the HID RPC message to the data.
+func Marshal(message *Message) ([]byte, error) {
+ if message.t == 0 {
+ return nil, fmt.Errorf("invalid message type: %d", message.t)
+ }
+
+ data := make([]byte, len(message.d)+1)
+ data[0] = byte(message.t)
+ copy(data[1:], message.d)
+
+ return data, nil
+}
+
+// NewHandshakeMessage creates a new handshake message.
+func NewHandshakeMessage() *Message {
+ return &Message{
+ t: TypeHandshake,
+ d: []byte{Version},
+ }
+}
+
+// NewKeyboardReportMessage creates a new keyboard report message.
+func NewKeyboardReportMessage(keys []byte, modifier uint8) *Message {
+ return &Message{
+ t: TypeKeyboardReport,
+ d: append([]byte{modifier}, keys...),
+ }
+}
+
+// NewKeyboardLedMessage creates a new keyboard LED message.
+func NewKeyboardLedMessage(state usbgadget.KeyboardState) *Message {
+ return &Message{
+ t: TypeKeyboardLedState,
+ d: []byte{state.Byte()},
+ }
+}
+
+// NewKeydownStateMessage creates a new keydown state message.
+func NewKeydownStateMessage(state usbgadget.KeysDownState) *Message {
+ data := make([]byte, len(state.Keys)+1)
+ data[0] = state.Modifier
+ copy(data[1:], state.Keys)
+
+ return &Message{
+ t: TypeKeydownState,
+ d: data,
+ }
+}
diff --git a/internal/hidrpc/message.go b/internal/hidrpc/message.go
new file mode 100644
index 00000000..84bbda7c
--- /dev/null
+++ b/internal/hidrpc/message.go
@@ -0,0 +1,133 @@
+package hidrpc
+
+import (
+ "fmt"
+)
+
+// Message ..
+type Message struct {
+ t MessageType
+ d []byte
+}
+
+// Marshal marshals the message to a byte array.
+func (m *Message) Marshal() ([]byte, error) {
+ return Marshal(m)
+}
+
+func (m *Message) Type() MessageType {
+ return m.t
+}
+
+func (m *Message) String() string {
+ switch m.t {
+ case TypeHandshake:
+ return "Handshake"
+ case TypeKeypressReport:
+ if len(m.d) < 2 {
+ return fmt.Sprintf("KeypressReport{Malformed: %v}", m.d)
+ }
+ return fmt.Sprintf("KeypressReport{Key: %d, Press: %v}", m.d[0], m.d[1] == uint8(1))
+ case TypeKeyboardReport:
+ if len(m.d) < 2 {
+ return fmt.Sprintf("KeyboardReport{Malformed: %v}", m.d)
+ }
+ return fmt.Sprintf("KeyboardReport{Modifier: %d, Keys: %v}", m.d[0], m.d[1:])
+ case TypePointerReport:
+ if len(m.d) < 9 {
+ return fmt.Sprintf("PointerReport{Malformed: %v}", m.d)
+ }
+ return fmt.Sprintf("PointerReport{X: %d, Y: %d, Button: %d}", m.d[0:4], m.d[4:8], m.d[8])
+ case TypeMouseReport:
+ if len(m.d) < 3 {
+ return fmt.Sprintf("MouseReport{Malformed: %v}", m.d)
+ }
+ return fmt.Sprintf("MouseReport{DX: %d, DY: %d, Button: %d}", m.d[0], m.d[1], m.d[2])
+ default:
+ return fmt.Sprintf("Unknown{Type: %d, Data: %v}", m.t, m.d)
+ }
+}
+
+// KeypressReport ..
+type KeypressReport struct {
+ Key byte
+ Press bool
+}
+
+// KeypressReport returns the keypress report from the message.
+func (m *Message) KeypressReport() (KeypressReport, error) {
+ if m.t != TypeKeypressReport {
+ return KeypressReport{}, fmt.Errorf("invalid message type: %d", m.t)
+ }
+
+ return KeypressReport{
+ Key: m.d[0],
+ Press: m.d[1] == uint8(1),
+ }, nil
+}
+
+// KeyboardReport ..
+type KeyboardReport struct {
+ Modifier byte
+ Keys []byte
+}
+
+// KeyboardReport returns the keyboard report from the message.
+func (m *Message) KeyboardReport() (KeyboardReport, error) {
+ if m.t != TypeKeyboardReport {
+ return KeyboardReport{}, fmt.Errorf("invalid message type: %d", m.t)
+ }
+
+ return KeyboardReport{
+ Modifier: m.d[0],
+ Keys: m.d[1:],
+ }, nil
+}
+
+// PointerReport ..
+type PointerReport struct {
+ X int
+ Y int
+ Button uint8
+}
+
+func toInt(b []byte) int {
+ return int(b[0])<<24 + int(b[1])<<16 + int(b[2])<<8 + int(b[3])<<0
+}
+
+// PointerReport returns the point report from the message.
+func (m *Message) PointerReport() (PointerReport, error) {
+ if m.t != TypePointerReport {
+ return PointerReport{}, fmt.Errorf("invalid message type: %d", m.t)
+ }
+
+ if len(m.d) != 9 {
+ return PointerReport{}, fmt.Errorf("invalid message length: %d", len(m.d))
+ }
+
+ return PointerReport{
+ X: toInt(m.d[0:4]),
+ Y: toInt(m.d[4:8]),
+ Button: uint8(m.d[8]),
+ }, nil
+}
+
+// MouseReport ..
+type MouseReport struct {
+ DX int8
+ DY int8
+ Button uint8
+}
+
+// MouseReport returns the mouse report from the message.
+func (m *Message) MouseReport() (MouseReport, error) {
+ if m.t != TypeMouseReport {
+ return MouseReport{}, fmt.Errorf("invalid message type: %d", m.t)
+ }
+
+ return MouseReport{
+ DX: int8(m.d[0]),
+ DY: int8(m.d[1]),
+ Button: uint8(m.d[2]),
+ }, nil
+}
diff --git a/internal/logging/logger.go b/internal/logging/logger.go
index 39156ecc..3a8274c5 100644
--- a/internal/logging/logger.go
+++ b/internal/logging/logger.go
@@ -50,7 +50,7 @@ var (
TimeFormat: time.RFC3339,
PartsOrder: []string{"time", "level", "scope", "component", "message"},
FieldsExclude: []string{"scope", "component"},
- FormatPartValueByName: func(value interface{}, name string) string {
+ FormatPartValueByName: func(value any, name string) string {
val := fmt.Sprintf("%s", value)
if name == "component" {
if value == nil {
@@ -121,8 +121,8 @@ func (l *Logger) updateLogLevel() {
continue
}
- scopes := strings.Split(strings.ToLower(env), ",")
- for _, scope := range scopes {
+ scopes := strings.SplitSeq(strings.ToLower(env), ",")
+ for scope := range scopes {
l.scopeLevels[scope] = level
}
}
diff --git a/internal/logging/pion.go b/internal/logging/pion.go
index 453b8bc9..2676caf2 100644
--- a/internal/logging/pion.go
+++ b/internal/logging/pion.go
@@ -13,32 +13,32 @@ type pionLogger struct {
func (c pionLogger) Trace(msg string) {
c.logger.Trace().Msg(msg)
}
-func (c pionLogger) Tracef(format string, args ...interface{}) {
+func (c pionLogger) Tracef(format string, args ...any) {
c.logger.Trace().Msgf(format, args...)
}
func (c pionLogger) Debug(msg string) {
c.logger.Debug().Msg(msg)
}
-func (c pionLogger) Debugf(format string, args ...interface{}) {
+func (c pionLogger) Debugf(format string, args ...any) {
c.logger.Debug().Msgf(format, args...)
}
func (c pionLogger) Info(msg string) {
c.logger.Info().Msg(msg)
}
-func (c pionLogger) Infof(format string, args ...interface{}) {
+func (c pionLogger) Infof(format string, args ...any) {
c.logger.Info().Msgf(format, args...)
}
func (c pionLogger) Warn(msg string) {
c.logger.Warn().Msg(msg)
}
-func (c pionLogger) Warnf(format string, args ...interface{}) {
+func (c pionLogger) Warnf(format string, args ...any) {
c.logger.Warn().Msgf(format, args...)
}
func (c pionLogger) Error(msg string) {
c.logger.Error().Msg(msg)
}
-func (c pionLogger) Errorf(format string, args ...interface{}) {
+func (c pionLogger) Errorf(format string, args ...any) {
c.logger.Error().Msgf(format, args...)
}
diff --git a/internal/logging/utils.go b/internal/logging/utils.go
index e622d964..73ae37a8 100644
--- a/internal/logging/utils.go
+++ b/internal/logging/utils.go
@@ -13,7 +13,7 @@ func GetDefaultLogger() *zerolog.Logger {
return &defaultLogger
}
-func ErrorfL(l *zerolog.Logger, format string, err error, args ...interface{}) error {
+func ErrorfL(l *zerolog.Logger, format string, err error, args ...any) error {
// TODO: move rootLogger to logging package
if l == nil {
l = &defaultLogger
diff --git a/internal/network/hostname.go b/internal/network/hostname.go
index d75255c8..09d39969 100644
--- a/internal/network/hostname.go
+++ b/internal/network/hostname.go
@@ -42,7 +42,7 @@ func updateEtcHosts(hostname string, fqdn string) error {
hostLine := fmt.Sprintf("127.0.1.1\t%s %s", hostname, fqdn)
hostLineExists := false
- for _, line := range strings.Split(string(lines), "\n") {
+ for line := range strings.SplitSeq(string(lines), "\n") {
if strings.HasPrefix(line, "127.0.1.1") {
hostLineExists = true
line = hostLine
diff --git a/internal/network/utils.go b/internal/network/utils.go
index 6d643326..797fd72f 100644
--- a/internal/network/utils.go
+++ b/internal/network/utils.go
@@ -13,7 +13,7 @@ func lifetimeToTime(lifetime int) *time.Time {
return &t
}
-func IsSame(a, b interface{}) bool {
+func IsSame(a, b any) bool {
aJSON, err := json.Marshal(a)
if err != nil {
return false
diff --git a/internal/udhcpc/parser.go b/internal/udhcpc/parser.go
index 66c3ba2a..d75857c9 100644
--- a/internal/udhcpc/parser.go
+++ b/internal/udhcpc/parser.go
@@ -101,7 +101,7 @@ func (l *Lease) SetLeaseExpiry() (time.Time, error) {
func UnmarshalDHCPCLease(lease *Lease, str string) error {
// parse the lease file as a map
data := make(map[string]string)
- for _, line := range strings.Split(str, "\n") {
+ for line := range strings.SplitSeq(str, "\n") {
line = strings.TrimSpace(line)
// skip empty lines and comments
if line == "" || strings.HasPrefix(line, "#") {
@@ -165,7 +165,7 @@ func UnmarshalDHCPCLease(lease *Lease, str string) error {
field.Set(reflect.ValueOf(ip))
case []net.IP:
val := make([]net.IP, 0)
- for _, ipStr := range strings.Fields(value) {
+ for ipStr := range strings.FieldsSeq(value) {
ip := net.ParseIP(ipStr)
if ip == nil {
continue
diff --git a/internal/udhcpc/udhcpc.go b/internal/udhcpc/udhcpc.go
index 128ea66b..7b4d6e4d 100644
--- a/internal/udhcpc/udhcpc.go
+++ b/internal/udhcpc/udhcpc.go
@@ -52,7 +52,7 @@ func NewDHCPClient(options *DHCPClientOptions) *DHCPClient {
}
func (c *DHCPClient) getWatchPaths() []string {
- watchPaths := make(map[string]interface{})
+ watchPaths := make(map[string]any)
watchPaths[filepath.Dir(c.leaseFile)] = nil
if c.pidFile != "" {
diff --git a/internal/usbgadget/consts.go b/internal/usbgadget/consts.go
index 8204d0aa..958aecca 100644
--- a/internal/usbgadget/consts.go
+++ b/internal/usbgadget/consts.go
@@ -1,3 +1,7 @@
package usbgadget
+import "time"
+
const dwc3Path = "/sys/bus/platform/drivers/dwc3"
+
+const hidWriteTimeout = 10 * time.Millisecond
diff --git a/internal/usbgadget/hid_keyboard.go b/internal/usbgadget/hid_keyboard.go
index 14b054bd..8208a541 100644
--- a/internal/usbgadget/hid_keyboard.go
+++ b/internal/usbgadget/hid_keyboard.go
@@ -1,10 +1,10 @@
package usbgadget
import (
+ "bytes"
"context"
"fmt"
"os"
- "reflect"
"time"
)
@@ -61,6 +61,8 @@ var keyboardReportDesc = []byte{
const (
hidReadBufferSize = 8
+ hidKeyBufferSize = 6
+ hidErrorRollOver = 0x01
// https://www.usb.org/sites/default/files/documents/hid1_11.pdf
// https://www.usb.org/sites/default/files/hut1_2.pdf
KeyboardLedMaskNumLock = 1 << 0
@@ -68,7 +70,9 @@ const (
KeyboardLedMaskScrollLock = 1 << 2
KeyboardLedMaskCompose = 1 << 3
KeyboardLedMaskKana = 1 << 4
- ValidKeyboardLedMasks = KeyboardLedMaskNumLock | KeyboardLedMaskCapsLock | KeyboardLedMaskScrollLock | KeyboardLedMaskCompose | KeyboardLedMaskKana
+ // power on/off LED is 5
+ KeyboardLedMaskShift = 1 << 6
+ ValidKeyboardLedMasks = KeyboardLedMaskNumLock | KeyboardLedMaskCapsLock | KeyboardLedMaskScrollLock | KeyboardLedMaskCompose | KeyboardLedMaskKana | KeyboardLedMaskShift
)
// Synchronization between LED states and CAPS LOCK, NUM LOCK, SCROLL LOCK,
@@ -81,6 +85,13 @@ type KeyboardState struct {
ScrollLock bool `json:"scroll_lock"`
Compose bool `json:"compose"`
Kana bool `json:"kana"`
+ Shift bool `json:"shift"` // This is not part of the main USB HID spec
+ raw byte
+}
+
+// Byte returns the raw byte representation of the keyboard state.
+func (k *KeyboardState) Byte() byte {
+ return k.raw
}
func getKeyboardState(b byte) KeyboardState {
@@ -91,27 +102,28 @@ func getKeyboardState(b byte) KeyboardState {
ScrollLock: b&KeyboardLedMaskScrollLock != 0,
Compose: b&KeyboardLedMaskCompose != 0,
Kana: b&KeyboardLedMaskKana != 0,
+ Shift: b&KeyboardLedMaskShift != 0,
+ raw: b,
}
}
-func (u *UsbGadget) updateKeyboardState(b byte) {
+func (u *UsbGadget) updateKeyboardState(state byte) {
u.keyboardStateLock.Lock()
defer u.keyboardStateLock.Unlock()
- if b&^ValidKeyboardLedMasks != 0 {
- u.log.Trace().Uint8("b", b).Msg("contains invalid bits, ignoring")
+ if state&^ValidKeyboardLedMasks != 0 {
+ u.log.Warn().Uint8("state", state).Msg("ignoring invalid bits")
return
}
- newState := getKeyboardState(b)
- if reflect.DeepEqual(u.keyboardState, newState) {
+ if u.keyboardState == state {
return
}
- u.log.Info().Interface("old", u.keyboardState).Interface("new", newState).Msg("keyboardState updated")
- u.keyboardState = newState
+ u.log.Trace().Uint8("old", u.keyboardState).Uint8("new", state).Msg("keyboardState updated")
+ u.keyboardState = state
if u.onKeyboardStateChange != nil {
- (*u.onKeyboardStateChange)(newState)
+ (*u.onKeyboardStateChange)(getKeyboardState(state))
}
}
@@ -123,7 +135,42 @@ func (u *UsbGadget) GetKeyboardState() KeyboardState {
u.keyboardStateLock.Lock()
defer u.keyboardStateLock.Unlock()
- return u.keyboardState
+ return getKeyboardState(u.keyboardState)
+}
+
+func (u *UsbGadget) GetKeysDownState() KeysDownState {
+ u.keyboardStateLock.Lock()
+ defer u.keyboardStateLock.Unlock()
+
+ return u.keysDownState
+}
+
+func (u *UsbGadget) updateKeyDownState(state KeysDownState) {
+ u.log.Trace().Interface("old", u.keysDownState).Interface("new", state).Msg("acquiring keyboardStateLock for updateKeyDownState")
+
+ // this is intentional to unlock keyboard state lock before onKeysDownChange callback
+ {
+ u.keyboardStateLock.Lock()
+ defer u.keyboardStateLock.Unlock()
+
+ if u.keysDownState.Modifier == state.Modifier &&
+ bytes.Equal(u.keysDownState.Keys, state.Keys) {
+ return // No change in key down state
+ }
+
+ u.log.Trace().Interface("old", u.keysDownState).Interface("new", state).Msg("keysDownState updated")
+ u.keysDownState = state
+ }
+
+ if u.onKeysDownChange != nil {
+ u.log.Trace().Interface("state", state).Msg("calling onKeysDownChange")
+ (*u.onKeysDownChange)(state)
+ u.log.Trace().Interface("state", state).Msg("onKeysDownChange called")
+ }
+}
+
+func (u *UsbGadget) SetOnKeysDownChange(f func(state KeysDownState)) {
+ u.onKeysDownChange = &f
}
func (u *UsbGadget) listenKeyboardEvents() {
@@ -142,7 +189,7 @@ func (u *UsbGadget) listenKeyboardEvents() {
l.Info().Msg("context done")
return
default:
- l.Trace().Msg("reading from keyboard")
+ l.Trace().Msg("reading from keyboard for LED state changes")
if u.keyboardHidFile == nil {
u.logWithSuppression("keyboardHidFileNil", 100, &l, nil, "keyboardHidFile is nil")
// show the error every 100 times to avoid spamming the logs
@@ -159,7 +206,7 @@ func (u *UsbGadget) listenKeyboardEvents() {
}
u.resetLogSuppressionCounter("keyboardHidFileRead")
- l.Trace().Int("n", n).Bytes("buf", buf).Msg("got data from keyboard")
+ l.Trace().Int("n", n).Uints8("buf", buf).Msg("got data from keyboard")
if n != 1 {
l.Trace().Int("n", n).Msg("expected 1 byte, got")
continue
@@ -195,12 +242,12 @@ func (u *UsbGadget) OpenKeyboardHidFile() error {
return u.openKeyboardHidFile()
}
-func (u *UsbGadget) keyboardWriteHidFile(data []byte) error {
+func (u *UsbGadget) keyboardWriteHidFile(modifier byte, keys []byte) error {
if err := u.openKeyboardHidFile(); err != nil {
return err
}
- _, err := u.keyboardHidFile.Write(data)
+ _, err := u.writeWithTimeout(u.keyboardHidFile, append([]byte{modifier, 0x00}, keys[:hidKeyBufferSize]...))
if err != nil {
u.logWithSuppression("keyboardWriteHidFile", 100, u.log, err, "failed to write to hidg0")
// Keep file open on write errors to reduce I/O overhead
@@ -210,22 +257,145 @@ func (u *UsbGadget) keyboardWriteHidFile(data []byte) error {
return nil
}
-func (u *UsbGadget) KeyboardReport(modifier uint8, keys []uint8) error {
+func (u *UsbGadget) UpdateKeysDown(modifier byte, keys []byte) KeysDownState {
+ // if we just reported an error roll over, we should clear the keys
+ if keys[0] == hidErrorRollOver {
+ for i := range keys {
+ keys[i] = 0
+ }
+ }
+
+ downState := KeysDownState{
+ Modifier: modifier,
+ Keys: []byte(keys[:]),
+ }
+ u.updateKeyDownState(downState)
+ return downState
+}
+
+func (u *UsbGadget) KeyboardReport(modifier byte, keys []byte) (KeysDownState, error) {
u.keyboardLock.Lock()
defer u.keyboardLock.Unlock()
+ defer u.resetUserInputTime()
- if len(keys) > 6 {
- keys = keys[:6]
+ if len(keys) > hidKeyBufferSize {
+ keys = keys[:hidKeyBufferSize]
}
- if len(keys) < 6 {
- keys = append(keys, make([]uint8, 6-len(keys))...)
+ if len(keys) < hidKeyBufferSize {
+ keys = append(keys, make([]byte, hidKeyBufferSize-len(keys))...)
}
- err := u.keyboardWriteHidFile([]byte{modifier, 0, keys[0], keys[1], keys[2], keys[3], keys[4], keys[5]})
+ err := u.keyboardWriteHidFile(modifier, keys)
if err != nil {
- return err
+ u.log.Warn().Uint8("modifier", modifier).Uints8("keys", keys).Msg("Could not write keyboard report to hidg0")
}
- u.resetUserInputTime()
- return nil
+ return u.UpdateKeysDown(modifier, keys), err
+}
+
+const (
+ // https://www.usb.org/sites/default/files/documents/hut1_2.pdf
+ // Dynamic Flags (DV)
+ LeftControl = 0xE0
+ LeftShift = 0xE1
+ LeftAlt = 0xE2
+ LeftSuper = 0xE3 // Left GUI (e.g. Windows key, Apple Command key)
+ RightControl = 0xE4
+ RightShift = 0xE5
+ RightAlt = 0xE6
+ RightSuper = 0xE7 // Right GUI (e.g. Windows key, Apple Command key)
+)
+
+const (
+ // https://www.usb.org/sites/default/files/documents/hid1_11.pdf Appendix C
+ ModifierMaskLeftControl = 0x01
+ ModifierMaskRightControl = 0x10
+ ModifierMaskLeftShift = 0x02
+ ModifierMaskRightShift = 0x20
+ ModifierMaskLeftAlt = 0x04
+ ModifierMaskRightAlt = 0x40
+ ModifierMaskLeftSuper = 0x08
+ ModifierMaskRightSuper = 0x80
+)
+
+// KeyCodeToMaskMap is a slice of KeyCodeMask for quick lookup
+var KeyCodeToMaskMap = map[byte]byte{
+ LeftControl: ModifierMaskLeftControl,
+ LeftShift: ModifierMaskLeftShift,
+ LeftAlt: ModifierMaskLeftAlt,
+ LeftSuper: ModifierMaskLeftSuper,
+ RightControl: ModifierMaskRightControl,
+ RightShift: ModifierMaskRightShift,
+ RightAlt: ModifierMaskRightAlt,
+ RightSuper: ModifierMaskRightSuper,
+}
+
+func (u *UsbGadget) KeypressReport(key byte, press bool) (KeysDownState, error) {
+ u.keyboardLock.Lock()
+ defer u.keyboardLock.Unlock()
+ defer u.resetUserInputTime()
+
+ // IMPORTANT: This code parallels the logic in the kernel's hid-gadget driver
+ // for handling key presses and releases. It ensures that the USB gadget
+ // behaves similarly to a real USB HID keyboard. This logic is paralleled
+ // in the client/browser-side code in useKeyboard.ts so make sure to keep
+ // them in sync.
+ var state = u.keysDownState
+ modifier := state.Modifier
+ keys := append([]byte(nil), state.Keys...)
+
+ if mask, exists := KeyCodeToMaskMap[key]; exists {
+ // If the key is a modifier key, we update the keyboardModifier state
+ // by setting or clearing the corresponding bit in the modifier byte.
+ // This allows us to track the state of dynamic modifier keys like
+ // Shift, Control, Alt, and Super.
+ if press {
+ modifier |= mask
+ } else {
+ modifier &^= mask
+ }
+ } else {
+ // handle other keys that are not modifier keys by placing or removing them
+ // from the key buffer since the buffer tracks currently pressed keys
+ overrun := true
+ for i := range hidKeyBufferSize {
+ // If we find the key in the buffer the buffer, we either remove it (if press is false)
+ // or do nothing (if down is true) because the buffer tracks currently pressed keys
+ // and if we find a zero byte, we can place the key there (if press is true)
+ if keys[i] == key || keys[i] == 0 {
+ if press {
+ keys[i] = key // overwrites the zero byte or the same key if already pressed
+ } else {
+ // we are releasing the key, remove it from the buffer
+ if keys[i] != 0 {
+ copy(keys[i:], keys[i+1:])
+ keys[hidKeyBufferSize-1] = 0 // Clear the last byte
+ }
+ }
+ overrun = false // We found a slot for the key
+ break
+ }
+ }
+
+ // If we reach here it means we didn't find an empty slot or the key in the buffer
+ if overrun {
+ if press {
+ u.log.Error().Uint8("key", key).Msg("keyboard buffer overflow, key not added")
+ // Fill all key slots with ErrorRollOver (0x01) to indicate overflow
+ for i := range keys {
+ keys[i] = hidErrorRollOver
+ }
+ } else {
+ // If we are releasing a key, and we didn't find it in a slot, who cares?
+ u.log.Warn().Uint8("key", key).Msg("key not found in buffer, nothing to release")
+ }
+ }
+ }
+
+ err := u.keyboardWriteHidFile(modifier, keys)
+ if err != nil {
+ u.log.Warn().Uint8("modifier", modifier).Uints8("keys", keys).Msg("Could not write keypress report to hidg0")
+ }
+
+ return u.UpdateKeysDown(modifier, keys), err
}
diff --git a/internal/usbgadget/hid_mouse_absolute.go b/internal/usbgadget/hid_mouse_absolute.go
index ec1d7300..1dd01256 100644
--- a/internal/usbgadget/hid_mouse_absolute.go
+++ b/internal/usbgadget/hid_mouse_absolute.go
@@ -74,7 +74,7 @@ func (u *UsbGadget) absMouseWriteHidFile(data []byte) error {
}
}
- _, err := u.absMouseHidFile.Write(data)
+ _, err := u.writeWithTimeout(u.absMouseHidFile, data)
if err != nil {
u.logWithSuppression("absMouseWriteHidFile", 100, u.log, err, "failed to write to hidg1")
// Keep file open on write errors to reduce I/O overhead
@@ -84,17 +84,17 @@ func (u *UsbGadget) absMouseWriteHidFile(data []byte) error {
return nil
}
-func (u *UsbGadget) AbsMouseReport(x, y int, buttons uint8) error {
+func (u *UsbGadget) AbsMouseReport(x int, 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
+ 1, // Report ID 1
+ buttons, // Buttons
+ byte(x), // X Low Byte
+ byte(x >> 8), // X High Byte
+ byte(y), // Y Low Byte
+ byte(y >> 8), // Y High Byte
})
if err != nil {
return err
diff --git a/internal/usbgadget/hid_mouse_relative.go b/internal/usbgadget/hid_mouse_relative.go
index 6ece51fe..722784b9 100644
--- a/internal/usbgadget/hid_mouse_relative.go
+++ b/internal/usbgadget/hid_mouse_relative.go
@@ -64,7 +64,7 @@ func (u *UsbGadget) relMouseWriteHidFile(data []byte) error {
}
}
- _, err := u.relMouseHidFile.Write(data)
+ _, err := u.writeWithTimeout(u.relMouseHidFile, data)
if err != nil {
u.logWithSuppression("relMouseWriteHidFile", 100, u.log, err, "failed to write to hidg2")
// Keep file open on write errors to reduce I/O overhead
@@ -74,15 +74,15 @@ func (u *UsbGadget) relMouseWriteHidFile(data []byte) error {
return nil
}
-func (u *UsbGadget) RelMouseReport(mx, my int8, buttons uint8) error {
+func (u *UsbGadget) RelMouseReport(mx int8, 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
+ buttons, // Buttons
+ byte(mx), // X
+ byte(my), // Y
+ 0, // Wheel
})
if err != nil {
return err
diff --git a/internal/usbgadget/usbgadget.go b/internal/usbgadget/usbgadget.go
index ede6f528..5fc7a49b 100644
--- a/internal/usbgadget/usbgadget.go
+++ b/internal/usbgadget/usbgadget.go
@@ -42,6 +42,11 @@ var defaultUsbGadgetDevices = Devices{
MassStorage: true,
}
+type KeysDownState struct {
+ Modifier byte `json:"modifier"`
+ Keys ByteSlice `json:"keys"`
+}
+
// UsbGadget is a struct that represents a USB gadget.
type UsbGadget struct {
name string
@@ -61,7 +66,9 @@ type UsbGadget struct {
relMouseHidFile *os.File
relMouseLock sync.Mutex
- keyboardState KeyboardState
+ keyboardState byte // keyboard latched state (NumLock, CapsLock, ScrollLock, Compose, Kana)
+ keysDownState KeysDownState // keyboard dynamic state (modifier keys and pressed keys)
+
keyboardStateLock sync.Mutex
keyboardStateCtx context.Context
keyboardStateCancel context.CancelFunc
@@ -78,6 +85,7 @@ type UsbGadget struct {
txLock sync.Mutex
onKeyboardStateChange *func(state KeyboardState)
+ onKeysDownChange *func(state KeysDownState)
log *zerolog.Logger
@@ -183,7 +191,8 @@ func newUsbGadget(name string, configMap map[string]gadgetConfigItem, enabledDev
txLock: sync.Mutex{},
keyboardStateCtx: keyboardCtx,
keyboardStateCancel: keyboardCancel,
- keyboardState: KeyboardState{},
+ keyboardState: 0,
+ keysDownState: KeysDownState{Modifier: 0, Keys: []byte{0, 0, 0, 0, 0, 0}}, // must be initialized to hidKeyBufferSize (6) zero bytes
enabledDevices: *enabledDevices,
lastUserInput: time.Now(),
log: logger,
diff --git a/internal/usbgadget/utils.go b/internal/usbgadget/utils.go
index 8654924a..d51f9e40 100644
--- a/internal/usbgadget/utils.go
+++ b/internal/usbgadget/utils.go
@@ -2,14 +2,43 @@ package usbgadget
import (
"bytes"
+ "encoding/json"
+ "errors"
"fmt"
+ "os"
"path/filepath"
"strconv"
"strings"
+ "time"
"github.com/rs/zerolog"
)
+type ByteSlice []byte
+
+func (s ByteSlice) MarshalJSON() ([]byte, error) {
+ vals := make([]int, len(s))
+ for i, v := range s {
+ vals[i] = int(v)
+ }
+ return json.Marshal(vals)
+}
+
+func (s *ByteSlice) UnmarshalJSON(data []byte) error {
+ var vals []int
+ if err := json.Unmarshal(data, &vals); err != nil {
+ return err
+ }
+ *s = make([]byte, len(vals))
+ for i, v := range vals {
+ if v < 0 || v > 255 {
+ return fmt.Errorf("value %d out of byte range", v)
+ }
+ (*s)[i] = byte(v)
+ }
+ return nil
+}
+
func joinPath(basePath string, paths []string) string {
pathArr := append([]string{basePath}, paths...)
return filepath.Join(pathArr...)
@@ -81,7 +110,32 @@ func compareFileContent(oldContent []byte, newContent []byte, looserMatch bool)
return false
}
-func (u *UsbGadget) logWithSuppression(counterName string, every int, logger *zerolog.Logger, err error, msg string, args ...interface{}) {
+func (u *UsbGadget) writeWithTimeout(file *os.File, data []byte) (n int, err error) {
+ if err := file.SetWriteDeadline(time.Now().Add(hidWriteTimeout)); err != nil {
+ return -1, err
+ }
+
+ n, err = file.Write(data)
+ if err == nil {
+ return
+ }
+
+ if errors.Is(err, os.ErrDeadlineExceeded) {
+ u.logWithSuppression(
+ fmt.Sprintf("writeWithTimeout_%s", file.Name()),
+ 1000,
+ u.log,
+ err,
+ "write timed out: %s",
+ file.Name(),
+ )
+ err = nil
+ }
+
+ return
+}
+
+func (u *UsbGadget) logWithSuppression(counterName string, every int, logger *zerolog.Logger, err error, msg string, args ...any) {
u.logSuppressionLock.Lock()
defer u.logSuppressionLock.Unlock()
diff --git a/jsonrpc.go b/jsonrpc.go
index 399f01b1..873ad34d 100644
--- a/jsonrpc.go
+++ b/jsonrpc.go
@@ -13,6 +13,7 @@ import (
"time"
"github.com/pion/webrtc/v4"
+ "github.com/rs/zerolog"
"go.bug.st/serial"
"github.com/jetkvm/kvm/internal/audio"
@@ -22,23 +23,23 @@ import (
// Direct RPC message handling for optimal input responsiveness
type JSONRPCRequest struct {
- JSONRPC string `json:"jsonrpc"`
- Method string `json:"method"`
- Params map[string]interface{} `json:"params,omitempty"`
- ID interface{} `json:"id,omitempty"`
+ JSONRPC string `json:"jsonrpc"`
+ Method string `json:"method"`
+ Params map[string]any `json:"params,omitempty"`
+ ID any `json:"id,omitempty"`
}
type JSONRPCResponse struct {
- JSONRPC string `json:"jsonrpc"`
- Result interface{} `json:"result,omitempty"`
- Error interface{} `json:"error,omitempty"`
- ID interface{} `json:"id"`
+ JSONRPC string `json:"jsonrpc"`
+ Result any `json:"result,omitempty"`
+ Error any `json:"error,omitempty"`
+ ID any `json:"id"`
}
type JSONRPCEvent struct {
- JSONRPC string `json:"jsonrpc"`
- Method string `json:"method"`
- Params interface{} `json:"params,omitempty"`
+ JSONRPC string `json:"jsonrpc"`
+ Method string `json:"method"`
+ Params any `json:"params,omitempty"`
}
type DisplayRotationSettings struct {
@@ -64,7 +65,7 @@ func writeJSONRPCResponse(response JSONRPCResponse, session *Session) {
}
}
-func writeJSONRPCEvent(event string, params interface{}, session *Session) {
+func writeJSONRPCEvent(event string, params any, session *Session) {
request := JSONRPCEvent{
JSONRPC: "2.0",
Method: event,
@@ -85,7 +86,7 @@ func writeJSONRPCEvent(event string, params interface{}, session *Session) {
Str("data", requestString).
Logger()
- scopedLogger.Info().Msg("sending JSONRPC event")
+ scopedLogger.Trace().Msg("sending JSONRPC event")
err = session.RPCChannel.SendText(requestString)
if err != nil {
@@ -105,7 +106,7 @@ func onRPCMessage(message webrtc.DataChannelMessage, session *Session) {
errorResponse := JSONRPCResponse{
JSONRPC: "2.0",
- Error: map[string]interface{}{
+ Error: map[string]any{
"code": -32700,
"message": "Parse error",
},
@@ -159,7 +160,7 @@ func onRPCMessage(message webrtc.DataChannelMessage, session *Session) {
if !ok {
errorResponse := JSONRPCResponse{
JSONRPC: "2.0",
- Error: map[string]interface{}{
+ Error: map[string]any{
"code": -32601,
"message": "Method not found",
},
@@ -169,13 +170,12 @@ func onRPCMessage(message webrtc.DataChannelMessage, session *Session) {
return
}
- scopedLogger.Trace().Msg("Calling RPC handler")
- result, err := callRPCHandler(handler, request.Params)
+ result, err := callRPCHandler(scopedLogger, handler, request.Params)
if err != nil {
scopedLogger.Error().Err(err).Msg("Error calling RPC handler")
errorResponse := JSONRPCResponse{
JSONRPC: "2.0",
- Error: map[string]interface{}{
+ Error: map[string]any{
"code": -32603,
"message": "Internal error",
"data": err.Error(),
@@ -236,7 +236,7 @@ func rpcGetStreamQualityFactor() (float64, error) {
func rpcSetStreamQualityFactor(factor float64) error {
logger.Info().Float64("factor", factor).Msg("Setting stream quality factor")
- var _, err = CallCtrlAction("set_video_quality_factor", map[string]interface{}{"quality_factor": factor})
+ var _, err = CallCtrlAction("set_video_quality_factor", map[string]any{"quality_factor": factor})
if err != nil {
return err
}
@@ -276,7 +276,7 @@ func rpcSetEDID(edid string) error {
} else {
logger.Info().Str("edid", edid).Msg("Setting EDID")
}
- _, err := CallCtrlAction("set_edid", map[string]interface{}{"edid": edid})
+ _, err := CallCtrlAction("set_edid", map[string]any{"edid": edid})
if err != nil {
return err
}
@@ -503,12 +503,12 @@ func rpcSetTLSState(state TLSState) error {
}
type RPCHandler struct {
- Func interface{}
+ Func any
Params []string
}
// call the handler but recover from a panic to ensure our RPC thread doesn't collapse on malformed calls
-func callRPCHandler(handler RPCHandler, params map[string]interface{}) (result interface{}, err error) {
+func callRPCHandler(logger zerolog.Logger, handler RPCHandler, params map[string]any) (result any, err error) {
// Use defer to recover from a panic
defer func() {
if r := recover(); r != nil {
@@ -522,11 +522,11 @@ func callRPCHandler(handler RPCHandler, params map[string]interface{}) (result i
}()
// Call the handler
- result, err = riskyCallRPCHandler(handler, params)
- return result, err
+ result, err = riskyCallRPCHandler(logger, handler, params)
+ return result, err // do not combine these two lines into one, as it breaks the above defer function's setting of err
}
-func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (interface{}, error) {
+func riskyCallRPCHandler(logger zerolog.Logger, handler RPCHandler, params map[string]any) (any, error) {
handlerValue := reflect.ValueOf(handler.Func)
handlerType := handlerValue.Type()
@@ -535,20 +535,24 @@ func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (int
}
numParams := handlerType.NumIn()
- args := make([]reflect.Value, numParams)
- // Get the parameter names from the RPCHandler
- paramNames := handler.Params
+ paramNames := handler.Params // Get the parameter names from the RPCHandler
if len(paramNames) != numParams {
- return nil, errors.New("mismatch between handler parameters and defined parameter names")
+ err := fmt.Errorf("mismatch between handler parameters (%d) and defined parameter names (%d)", numParams, len(paramNames))
+ logger.Error().Strs("paramNames", paramNames).Err(err).Msg("Cannot call RPC handler")
+ return nil, err
}
- for i := 0; i < numParams; i++ {
+ args := make([]reflect.Value, numParams)
+
+ for i := range numParams {
paramType := handlerType.In(i)
paramName := paramNames[i]
paramValue, ok := params[paramName]
if !ok {
- return nil, errors.New("missing parameter: " + paramName)
+ err := fmt.Errorf("missing parameter: %s", paramName)
+ logger.Error().Err(err).Msg("Cannot marshal arguments for RPC handler")
+ return nil, err
}
convertedValue := reflect.ValueOf(paramValue)
@@ -565,7 +569,7 @@ func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (int
if elemValue.Kind() == reflect.Float64 && paramType.Elem().Kind() == reflect.Uint8 {
intValue := int(elemValue.Float())
if intValue < 0 || intValue > 255 {
- return nil, fmt.Errorf("value out of range for uint8: %v", intValue)
+ return nil, fmt.Errorf("value out of range for uint8: %v for parameter %s", intValue, paramName)
}
newSlice.Index(j).SetUint(uint64(intValue))
} else {
@@ -581,12 +585,12 @@ func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (int
} else if paramType.Kind() == reflect.Struct && convertedValue.Kind() == reflect.Map {
jsonData, err := json.Marshal(convertedValue.Interface())
if err != nil {
- return nil, fmt.Errorf("failed to marshal map to JSON: %v", err)
+ return nil, fmt.Errorf("failed to marshal map to JSON: %v for parameter %s", err, paramName)
}
newStruct := reflect.New(paramType).Interface()
if err := json.Unmarshal(jsonData, newStruct); err != nil {
- return nil, fmt.Errorf("failed to unmarshal JSON into struct: %v", err)
+ return nil, fmt.Errorf("failed to unmarshal JSON into struct: %v for parameter %s", err, paramName)
}
args[i] = reflect.ValueOf(newStruct).Elem()
} else {
@@ -597,6 +601,7 @@ func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (int
}
}
+ logger.Trace().Msg("Calling RPC handler")
results := handlerValue.Call(args)
if len(results) == 0 {
@@ -604,23 +609,32 @@ func riskyCallRPCHandler(handler RPCHandler, params map[string]interface{}) (int
}
if len(results) == 1 {
- if results[0].Type().Implements(reflect.TypeOf((*error)(nil)).Elem()) {
- if !results[0].IsNil() {
- return nil, results[0].Interface().(error)
+ if ok, err := asError(results[0]); ok {
+ return nil, err
+ }
+ return results[0].Interface(), nil
+ }
+
+ if len(results) == 2 {
+ if ok, err := asError(results[1]); ok {
+ if err != nil {
+ return nil, err
}
- return nil, nil
}
return results[0].Interface(), nil
}
- if len(results) == 2 && results[1].Type().Implements(reflect.TypeOf((*error)(nil)).Elem()) {
- if !results[1].IsNil() {
- return nil, results[1].Interface().(error)
- }
- return results[0].Interface(), nil
- }
+ return nil, fmt.Errorf("too many return values from handler: %d", len(results))
+}
- return nil, errors.New("unexpected return values from handler")
+func asError(value reflect.Value) (bool, error) {
+ if value.Type().Implements(reflect.TypeOf((*error)(nil)).Elem()) {
+ if value.IsNil() {
+ return true, nil
+ }
+ return true, value.Interface().(error)
+ }
+ return false, nil
}
func rpcSetMassStorageMode(mode string) (string, error) {
@@ -1130,7 +1144,7 @@ func rpcSetKeyboardLayout(layout string) error {
return nil
}
-func getKeyboardMacros() (interface{}, error) {
+func getKeyboardMacros() (any, error) {
macros := make([]KeyboardMacro, len(config.KeyboardMacros))
copy(macros, config.KeyboardMacros)
@@ -1138,10 +1152,10 @@ func getKeyboardMacros() (interface{}, error) {
}
type KeyboardMacrosParams struct {
- Macros []interface{} `json:"macros"`
+ Macros []any `json:"macros"`
}
-func setKeyboardMacros(params KeyboardMacrosParams) (interface{}, error) {
+func setKeyboardMacros(params KeyboardMacrosParams) (any, error) {
if params.Macros == nil {
return nil, fmt.Errorf("missing or invalid macros parameter")
}
@@ -1149,7 +1163,7 @@ func setKeyboardMacros(params KeyboardMacrosParams) (interface{}, error) {
newMacros := make([]KeyboardMacro, 0, len(params.Macros))
for i, item := range params.Macros {
- macroMap, ok := item.(map[string]interface{})
+ macroMap, ok := item.(map[string]any)
if !ok {
return nil, fmt.Errorf("invalid macro at index %d", i)
}
@@ -1167,16 +1181,16 @@ func setKeyboardMacros(params KeyboardMacrosParams) (interface{}, error) {
}
steps := []KeyboardMacroStep{}
- if stepsArray, ok := macroMap["steps"].([]interface{}); ok {
+ if stepsArray, ok := macroMap["steps"].([]any); ok {
for _, stepItem := range stepsArray {
- stepMap, ok := stepItem.(map[string]interface{})
+ stepMap, ok := stepItem.(map[string]any)
if !ok {
continue
}
step := KeyboardMacroStep{}
- if keysArray, ok := stepMap["keys"].([]interface{}); ok {
+ if keysArray, ok := stepMap["keys"].([]any); ok {
for _, k := range keysArray {
if keyStr, ok := k.(string); ok {
step.Keys = append(step.Keys, keyStr)
@@ -1184,7 +1198,7 @@ func setKeyboardMacros(params KeyboardMacrosParams) (interface{}, error) {
}
}
- if modsArray, ok := stepMap["modifiers"].([]interface{}); ok {
+ if modsArray, ok := stepMap["modifiers"].([]any); ok {
for _, m := range modsArray {
if modStr, ok := m.(string); ok {
step.Modifiers = append(step.Modifiers, modStr)
@@ -1254,6 +1268,8 @@ var rpcHandlers = map[string]RPCHandler{
"renewDHCPLease": {Func: rpcRenewDHCPLease},
"keyboardReport": {Func: rpcKeyboardReport, Params: []string{"modifier", "keys"}},
"getKeyboardLedState": {Func: rpcGetKeyboardLedState},
+ "keypressReport": {Func: rpcKeypressReport, Params: []string{"key", "press"}},
+ "getKeyDownState": {Func: rpcGetKeysDownState},
"absMouseReport": {Func: rpcAbsMouseReport, Params: []string{"x", "y", "buttons"}},
"relMouseReport": {Func: rpcRelMouseReport, Params: []string{"dx", "dy", "buttons"}},
"wheelReport": {Func: rpcWheelReport, Params: []string{"wheelY"}},
@@ -1294,7 +1310,6 @@ var rpcHandlers = map[string]RPCHandler{
"getVirtualMediaState": {Func: rpcGetVirtualMediaState},
"getStorageSpace": {Func: rpcGetStorageSpace},
"mountWithHTTP": {Func: rpcMountWithHTTP, Params: []string{"url", "mode"}},
- "mountWithWebRTC": {Func: rpcMountWithWebRTC, Params: []string{"filename", "size", "mode"}},
"mountWithStorage": {Func: rpcMountWithStorage, Params: []string{"filename", "mode"}},
"listStorageFiles": {Func: rpcListStorageFiles},
"deleteStorageFile": {Func: rpcDeleteStorageFile, Params: []string{"filename"}},
diff --git a/log.go b/log.go
index b353a2c4..2047bbfa 100644
--- a/log.go
+++ b/log.go
@@ -5,7 +5,7 @@ import (
"github.com/rs/zerolog"
)
-func ErrorfL(l *zerolog.Logger, format string, err error, args ...interface{}) error {
+func ErrorfL(l *zerolog.Logger, format string, err error, args ...any) error {
return logging.ErrorfL(l, format, err, args...)
}
@@ -19,6 +19,7 @@ var (
nbdLogger = logging.GetSubsystemLogger("nbd")
timesyncLogger = logging.GetSubsystemLogger("timesync")
jsonRpcLogger = logging.GetSubsystemLogger("jsonrpc")
+ hidRPCLogger = logging.GetSubsystemLogger("hidrpc")
watchdogLogger = logging.GetSubsystemLogger("watchdog")
websecureLogger = logging.GetSubsystemLogger("websecure")
otaLogger = logging.GetSubsystemLogger("ota")
diff --git a/native.go b/native.go
index fc8cfcba..622b7fef 100644
--- a/native.go
+++ b/native.go
@@ -3,34 +3,57 @@
package kvm
import (
+ "bytes"
+ "encoding/json"
"fmt"
+ "io"
+ "net"
"os"
"os/exec"
+ "strings"
"sync"
- "syscall"
"time"
- "github.com/rs/zerolog"
+ "github.com/jetkvm/kvm/resource"
)
-type nativeOutput struct {
- logger *zerolog.Logger
+var ctrlSocketConn net.Conn
+
+type CtrlAction struct {
+ Action string `json:"action"`
+ Seq int32 `json:"seq,omitempty"`
+ Params map[string]any `json:"params,omitempty"`
}
-func (n *nativeOutput) Write(p []byte) (int, error) {
- n.logger.Debug().Str("output", string(p)).Msg("native binary output")
- return len(p), nil
+type CtrlResponse struct {
+ Seq int32 `json:"seq,omitempty"`
+ Error string `json:"error,omitempty"`
+ Errno int32 `json:"errno,omitempty"`
+ Result map[string]any `json:"result,omitempty"`
+ Event string `json:"event,omitempty"`
+ Data json.RawMessage `json:"data,omitempty"`
}
+type EventHandler func(event CtrlResponse)
+
+var seq int32 = 1
+
+var ongoingRequests = make(map[int32]chan *CtrlResponse)
+
+var lock = &sync.Mutex{}
+
var (
nativeCmd *exec.Cmd
nativeCmdLock = &sync.Mutex{}
)
-func startNativeBinary(binaryPath string) (*exec.Cmd, error) {
- cmd := exec.Command(binaryPath)
- cmd.SysProcAttr = &syscall.SysProcAttr{
- Pdeathsig: syscall.SIGTERM,
+func CallCtrlAction(action string, params map[string]any) (*CtrlResponse, error) {
+ lock.Lock()
+ defer lock.Unlock()
+ ctrlAction := CtrlAction{
+ Action: action,
+ Seq: seq,
+ Params: params,
}
cmd.Stdout = &nativeOutput{logger: nativeLogger}
cmd.Stderr = &nativeOutput{logger: nativeLogger}
@@ -142,3 +165,87 @@ func ExtractAndRunNativeBin() error {
return nil
}
+
+func shouldOverwrite(destPath string, srcHash []byte) bool {
+ if srcHash == nil {
+ nativeLogger.Debug().Msg("error reading embedded jetkvm_native.sha256, doing overwriting")
+ return true
+ }
+
+ dstHash, err := os.ReadFile(destPath + ".sha256")
+ if err != nil {
+ nativeLogger.Debug().Msg("error reading existing jetkvm_native.sha256, doing overwriting")
+ return true
+ }
+
+ return !bytes.Equal(srcHash, dstHash)
+}
+
+func getNativeSha256() ([]byte, error) {
+ version, err := resource.ResourceFS.ReadFile("jetkvm_native.sha256")
+ if err != nil {
+ return nil, err
+ }
+ return version, nil
+}
+
+func GetNativeVersion() (string, error) {
+ version, err := getNativeSha256()
+ if err != nil {
+ return "", err
+ }
+ return strings.TrimSpace(string(version)), nil
+}
+
+func ensureBinaryUpdated(destPath string) error {
+ srcFile, err := resource.ResourceFS.Open("jetkvm_native")
+ if err != nil {
+ return err
+ }
+ defer srcFile.Close()
+
+ srcHash, err := getNativeSha256()
+ if err != nil {
+ nativeLogger.Debug().Msg("error reading embedded jetkvm_native.sha256, proceeding with update")
+ srcHash = nil
+ }
+
+ _, err = os.Stat(destPath)
+ if shouldOverwrite(destPath, srcHash) || err != nil {
+ nativeLogger.Info().
+ Interface("hash", srcHash).
+ Msg("writing jetkvm_native")
+
+ _ = os.Remove(destPath)
+ destFile, err := os.OpenFile(destPath, os.O_CREATE|os.O_RDWR, 0755)
+ if err != nil {
+ return err
+ }
+ _, err = io.Copy(destFile, srcFile)
+ destFile.Close()
+ if err != nil {
+ return err
+ }
+ if srcHash != nil {
+ err = os.WriteFile(destPath+".sha256", srcHash, 0644)
+ if err != nil {
+ return err
+ }
+ }
+ nativeLogger.Info().Msg("jetkvm_native updated")
+ }
+
+ return nil
+}
+
+// Restore the HDMI EDID value from the config.
+// Called after successful connection to jetkvm_native.
+func restoreHdmiEdid() {
+ if config.EdidString != "" {
+ nativeLogger.Info().Str("edid", config.EdidString).Msg("Restoring HDMI EDID")
+ _, err := CallCtrlAction("set_edid", map[string]any{"edid": config.EdidString})
+ if err != nil {
+ nativeLogger.Warn().Err(err).Msg("Failed to restore HDMI EDID")
+ }
+ }
+}
diff --git a/remote_mount.go b/remote_mount.go
deleted file mode 100644
index befffcbc..00000000
--- a/remote_mount.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package kvm
-
-import (
- "context"
- "encoding/json"
- "errors"
-)
-
-type RemoteImageReader interface {
- Read(ctx context.Context, offset int64, size int64) ([]byte, error)
-}
-
-type WebRTCDiskReader struct {
-}
-
-var webRTCDiskReader WebRTCDiskReader
-
-func (w *WebRTCDiskReader) Read(ctx context.Context, offset int64, size int64) ([]byte, error) {
- virtualMediaStateMutex.RLock()
- if currentVirtualMediaState == nil {
- virtualMediaStateMutex.RUnlock()
- return nil, errors.New("image not mounted")
- }
- if currentVirtualMediaState.Source != WebRTC {
- virtualMediaStateMutex.RUnlock()
- return nil, errors.New("image not mounted from webrtc")
- }
- mountedImageSize := currentVirtualMediaState.Size
- virtualMediaStateMutex.RUnlock()
- end := offset + size
- if end > mountedImageSize {
- end = mountedImageSize
- }
- req := DiskReadRequest{
- Start: uint64(offset),
- End: uint64(end),
- }
- jsonBytes, err := json.Marshal(req)
- if err != nil {
- return nil, err
- }
-
- if currentSession == nil || currentSession.DiskChannel == nil {
- return nil, errors.New("not active session")
- }
-
- logger.Debug().Str("request", string(jsonBytes)).Msg("reading from webrtc")
- err = currentSession.DiskChannel.SendText(string(jsonBytes))
- if err != nil {
- return nil, err
- }
- var buf []byte
- for {
- select {
- case data := <-diskReadChan:
- buf = data[16:]
- case <-ctx.Done():
- return nil, context.Canceled
- }
- if len(buf) >= int(end-offset) {
- break
- }
- }
- return buf, nil
-}
diff --git a/ui/eslint.config.cjs b/ui/eslint.config.cjs
index a6c0c1fb..6e972586 100644
--- a/ui/eslint.config.cjs
+++ b/ui/eslint.config.cjs
@@ -66,6 +66,10 @@ module.exports = defineConfig([{
groups: ["builtin", "external", "internal", "parent", "sibling"],
"newlines-between": "always",
}],
+
+ "@typescript-eslint/no-unused-vars": ["warn", {
+ "argsIgnorePattern": "^_", "varsIgnorePattern": "^_"
+ }],
},
settings: {
diff --git a/ui/index.html b/ui/index.html
index af9bdfb4..0ce91234 100644
--- a/ui/index.html
+++ b/ui/index.html
@@ -1,7 +1,7 @@
-
+
JetKVM
-
+
+
+
+
+
+
+
+