hidrpc.go

@@ -8,7 +8,7 @@ import (
 	"github.com/jetkvm/kvm/internal/usbgadget"
 )
 
-func handleHidRPCMessage(message hidrpc.Message, session *Session) {
+func handleHidRpcMessage(message hidrpc.Message, session *Session) {
 	var rpcErr error
 
 	switch message.Type() {
@@ -22,11 +22,11 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
 			logger.Warn().Err(err).Msg("failed to send handshake message")
 			return
 		}
-		session.hidRPCAvailable = true
+		session.hidRpcAvailable = true
 	case hidrpc.TypeKeypressReport, hidrpc.TypeKeyboardReport:
-		keysDownState, err := handleHidRPCKeyboardInput(message)
+		keysDownState, err := handleHidRpcKeyboardInput(message)
 		if keysDownState != nil {
-			session.reportHidRPCKeysDownState(*keysDownState)
+			reportHidRpcKeysDownState(*keysDownState, session)
 		}
 		rpcErr = err
 	case hidrpc.TypePointerReport:
@@ -53,7 +53,7 @@ func handleHidRPCMessage(message hidrpc.Message, session *Session) {
 }
 
 func onHidMessage(data []byte, session *Session) {
-	scopedLogger := hidRPCLogger.With().Bytes("data", data).Logger()
+	scopedLogger := hidRpcLogger.With().Bytes("data", data).Logger()
 	scopedLogger.Debug().Msg("HID RPC message received")
 
 	if len(data) < 1 {
@@ -74,7 +74,7 @@ func onHidMessage(data []byte, session *Session) {
 
 	r := make(chan interface{})
 	go func() {
-		handleHidRPCMessage(message, session)
+		handleHidRpcMessage(message, session)
 		r <- nil
 	}()
 	select {
@@ -85,7 +85,7 @@ func onHidMessage(data []byte, session *Session) {
 	}
 }
 
-func handleHidRPCKeyboardInput(message hidrpc.Message) (*usbgadget.KeysDownState, error) {
+func handleHidRpcKeyboardInput(message hidrpc.Message) (*usbgadget.KeysDownState, error) {
 	switch message.Type() {
 	case hidrpc.TypeKeypressReport:
 		keypressReport, err := message.KeypressReport()
@@ -108,7 +108,7 @@ func handleHidRPCKeyboardInput(message hidrpc.Message) (*usbgadget.KeysDownState
 	return nil, fmt.Errorf("unknown HID RPC message type: %d", message.Type())
 }
 
-func reportHidRPC(params any, session *Session) {
+func reportHidRpc(params any, session *Session) {
 	var (
 		message []byte
 		err     error
@@ -118,8 +118,6 @@ func reportHidRPC(params any, session *Session) {
 		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 {
@@ -137,16 +135,16 @@ func reportHidRPC(params any, session *Session) {
 	}
 }
 
-func (s *Session) reportHidRPCKeyboardLedState(state usbgadget.KeyboardState) {
+func reportHidRpcKeyboardLedState(state usbgadget.KeyboardState, session *Session) {
-	if !s.hidRPCAvailable {
+	if !session.hidRpcAvailable {
-		writeJSONRPCEvent("keyboardLedState", state, s)
+		writeJSONRPCEvent("keyboardLedState", state, currentSession)
 	}
-	reportHidRPC(state, s)
+	reportHidRpc(state, session)
 }
 
-func (s *Session) reportHidRPCKeysDownState(state usbgadget.KeysDownState) {
+func reportHidRpcKeysDownState(state usbgadget.KeysDownState, session *Session) {
-	if !s.hidRPCAvailable {
+	if !session.hidRpcAvailable {
-		writeJSONRPCEvent("keysDownState", state, s)
+		writeJSONRPCEvent("keysDownState", state, currentSession)
 	}
-	reportHidRPC(state, s)
+	reportHidRpc(state, session)
 }

internal/hidrpc/hidrpc.go

@@ -6,8 +6,12 @@ import (
 	"github.com/jetkvm/kvm/internal/usbgadget"
 )
 
+// HID RPC is a variable-length packet format that is used to exchange keyboard and mouse events between the client and the server.
+// The packet format is as follows:
+// 1 byte: Event Type
+
 // MessageType is the type of the HID RPC message
-type MessageType byte
+type MessageType uint8
 
 const (
 	TypeHandshake        MessageType = 0x01
@@ -20,22 +24,9 @@ const (
 	TypeKeydownState     MessageType = 0x33
 )
 
-const (
+// ShouldUseEnqueue returns true if the message type should be enqueued to the HID queue.
-	Version byte = 0x01 // Version of the HID RPC protocol
+func ShouldUseEnqueue(messageType MessageType) bool {
-)
+	return messageType == TypeMouseReport
-
-// 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.
@@ -67,7 +58,7 @@ func Marshal(message *Message) ([]byte, error) {
 func NewHandshakeMessage() *Message {
 	return &Message{
 		t: TypeHandshake,
-		d: []byte{Version},
+		d: []byte{},
 	}
 }
 

internal/hidrpc/message.go

@@ -24,25 +24,13 @@ func (m *Message) String() string {
 	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{DX: %d, DY: %d, Button: %d}", m.d[0:2], m.d[2:4], m.d[4])
-			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)
 	}

internal/usbgadget/hid_keyboard.go

@@ -103,7 +103,6 @@ func getKeyboardState(b byte) KeyboardState {
 		Compose:    b&KeyboardLedMaskCompose != 0,
 		Kana:       b&KeyboardLedMaskKana != 0,
 		Shift:      b&KeyboardLedMaskShift != 0,
-		raw:        b,
 	}
 }
 

jsonrpc.go

@@ -83,7 +83,7 @@ func writeJSONRPCEvent(event string, params any, session *Session) {
 		Str("data", requestString).
 		Logger()
 
-	scopedLogger.Trace().Msg("sending JSONRPC event")
+	scopedLogger.Info().Msg("sending JSONRPC event")
 
 	err = session.RPCChannel.SendText(requestString)
 	if err != nil {

log.go

@@ -19,7 +19,7 @@ var (
 	nbdLogger       = logging.GetSubsystemLogger("nbd")
 	timesyncLogger  = logging.GetSubsystemLogger("timesync")
 	jsonRpcLogger   = logging.GetSubsystemLogger("jsonrpc")
-	hidRPCLogger    = logging.GetSubsystemLogger("hidrpc")
+	hidRpcLogger    = logging.GetSubsystemLogger("hidrpc")
 	watchdogLogger  = logging.GetSubsystemLogger("watchdog")
 	websecureLogger = logging.GetSubsystemLogger("websecure")
 	otaLogger       = logging.GetSubsystemLogger("ota")

ui/src/components/InfoBar.tsx

@@ -15,8 +15,8 @@ import { useHidRpc } from "@/hooks/useHidRpc";
 export default function InfoBar() {
   const { keysDownState } = useHidStore();
   const { mouseX, mouseY, mouseMove } = useMouseStore();
-  const { rpcHidStatus } = useHidRpc();
+  const { rpcHidReady } = useHidRpc();
-
+  
   const videoClientSize = useVideoStore(
     (state: VideoState) => `${Math.round(state.clientWidth)}x${Math.round(state.clientHeight)}`,
   );
@@ -48,7 +48,7 @@ export default function InfoBar() {
     const modifierNames = Object.entries(modifiers).filter(([_, mask]) => (activeModifierMask & mask) !== 0).map(([name, _]) => name);
     const keyNames = Object.entries(keys).filter(([_, value]) => keysDown.includes(value)).map(([name, _]) => name);
 
-    return [...modifierNames, ...keyNames].join(", ");
+    return [...modifierNames,...keyNames].join(", ");
   }, [keysDownState, showPressedKeys]);
 
   return (
@@ -105,7 +105,7 @@ export default function InfoBar() {
             {debugMode && (
               <div className="flex w-[156px] items-center gap-x-1">
                 <span className="text-xs font-semibold">HidRPC State:</span>
-                <span className="text-xs">{rpcHidStatus}</span>
+                <span className="text-xs">{rpcHidReady ? "Ready" : "Not Ready"}</span>
               </div>
             )}
 

ui/src/hooks/hidRpc.ts

@@ -1,303 +0,0 @@
-import { KeyboardLedState, KeysDownState } from "./stores";
-
-export const HID_RPC_MESSAGE_TYPES = {
-    Handshake: 0x01,
-    KeyboardReport: 0x02,
-    PointerReport: 0x03,
-    WheelReport: 0x04,
-    KeypressReport: 0x05,
-    MouseReport: 0x06,
-    KeyboardLedState: 0x32,
-    KeysDownState: 0x33,
-}
-
-export type HidRpcMessageType = typeof HID_RPC_MESSAGE_TYPES[keyof typeof HID_RPC_MESSAGE_TYPES];
-
-export const HID_RPC_VERSION = 0x01;
-
-const withinUint8Range = (value: number) => {
-    return value >= 0 && value <= 255;
-};
-
-const fromInt32toUint8 = (n: number) => {
-    if (n !== n >> 0) {
-        throw new Error(`Number ${n} is not within the int32 range`);
-    }
-
-    return new Uint8Array([
-        (n >> 24) & 0xFF,
-        (n >> 16) & 0xFF,
-        (n >> 8) & 0xFF,
-        (n >> 0) & 0xFF,
-    ]);
-};
-
-const fromInt8ToUint8 = (n: number) => {
-    if (n < -128 || n > 127) {
-        throw new Error(`Number ${n} is not within the int8 range`);
-    }
-
-    return (n >> 0) & 0xFF;
-};
-
-const keyboardLedStateMasks = {
-    num_lock: 1 << 0,
-    caps_lock: 1 << 1,
-    scroll_lock: 1 << 2,
-    compose: 1 << 3,
-    kana: 1 << 4,
-    shift: 1 << 6,
-}
-
-export class RpcMessage {
-    messageType: HidRpcMessageType;
-
-    constructor(messageType: HidRpcMessageType) {
-        this.messageType = messageType;
-    }
-
-    marshal(): Uint8Array {
-        throw new Error("Not implemented");
-    }
-
-    // @ts-expect-error: this is a base class, so we don't need to implement it
-    public static unmarshal(data: Uint8Array): RpcMessage | undefined {
-        throw new Error("Not implemented");
-    }
-}
-
-export class HandshakeMessage extends RpcMessage {
-    version: number;
-
-    constructor(version: number) {
-        super(HID_RPC_MESSAGE_TYPES.Handshake);
-        this.version = version;
-    }
-
-    marshal(): Uint8Array {
-        return new Uint8Array([this.messageType, this.version]);
-    }
-
-    public static unmarshal(data: Uint8Array): HandshakeMessage | undefined {
-        if (data.length < 1) {
-            throw new Error(`Invalid handshake message length: ${data.length}`);
-        }
-
-        return new HandshakeMessage(data[0]);
-    }
-}
-
-export class KeypressReportMessage extends RpcMessage {
-    private _key = 0;
-    private _press = false;
-
-    get key(): number {
-        return this._key;
-    }
-
-    set key(value: number) {
-        if (!withinUint8Range(value)) {
-            throw new Error(`Key ${value} is not within the uint8 range`);
-        }
-
-        this._key = value;
-    }
-
-    get press(): boolean {
-        return this._press;
-    }
-
-    set press(value: boolean) {
-        this._press = value;
-    }
-
-    constructor(key: number, press: boolean) {
-        super(HID_RPC_MESSAGE_TYPES.KeypressReport);
-        this.key = key;
-        this.press = press;
-    }
-
-    marshal(): Uint8Array {
-        return new Uint8Array([
-            this.messageType,
-            this.key,
-            this.press ? 1 : 0,
-        ]);
-    }
-
-    public static unmarshal(data: Uint8Array): KeypressReportMessage | undefined {
-        if (data.length < 1) {
-            throw new Error(`Invalid keypress report message length: ${data.length}`);
-        }
-
-        return new KeypressReportMessage(data[0], data[1] === 1);
-    }
-}
-
-export class KeyboardReportMessage extends RpcMessage {
-    private _keys: number[] = [];
-    private _modifier = 0;
-
-    get keys(): number[] {
-        return this._keys;
-    }
-
-    set keys(value: number[]) {
-        value.forEach((k) => {
-            if (!withinUint8Range(k)) {
-                throw new Error(`Key ${k} is not within the uint8 range`);
-            }
-        });
-
-        this._keys = value;
-    }
-
-    get modifier(): number {
-        return this._modifier;
-    }
-
-    set modifier(value: number) {
-        if (!withinUint8Range(value)) {
-            throw new Error(`Modifier ${value} is not within the uint8 range`);
-        }
-
-        this._modifier = value;
-    }
-
-    constructor(keys: number[], modifier: number) {
-        super(HID_RPC_MESSAGE_TYPES.KeyboardReport);
-        this.keys = keys;
-        this.modifier = modifier;
-    }
-
-    marshal(): Uint8Array {
-        return new Uint8Array([
-            this.messageType,
-            this.modifier,
-            ...this.keys,
-        ]);
-    }
-
-    public static unmarshal(data: Uint8Array): KeyboardReportMessage | undefined {
-        if (data.length < 1) {
-            throw new Error(`Invalid keyboard report message length: ${data.length}`);
-        }
-
-        return new KeyboardReportMessage(Array.from(data.slice(1)), data[0]);
-    }
-}
-
-export class KeyboardLedStateMessage extends RpcMessage {
-    keyboardLedState: KeyboardLedState;
-
-    constructor(keyboardLedState: KeyboardLedState) {
-        super(HID_RPC_MESSAGE_TYPES.KeyboardLedState);
-        this.keyboardLedState = keyboardLedState;
-    }
-
-    public static unmarshal(data: Uint8Array): KeyboardLedStateMessage | undefined {
-        if (data.length < 1) {
-            throw new Error(`Invalid keyboard led state message length: ${data.length}`);
-        }
-
-        const s = data[0];
-
-        const state = {
-            num_lock: (s & keyboardLedStateMasks.num_lock) !== 0,
-            caps_lock: (s & keyboardLedStateMasks.caps_lock) !== 0,
-            scroll_lock: (s & keyboardLedStateMasks.scroll_lock) !== 0,
-            compose: (s & keyboardLedStateMasks.compose) !== 0,
-            kana: (s & keyboardLedStateMasks.kana) !== 0,
-            shift: (s & keyboardLedStateMasks.shift) !== 0,
-        } as KeyboardLedState;
-
-        return new KeyboardLedStateMessage(state);
-    }
-}
-
-export class KeysDownStateMessage extends RpcMessage {
-    keysDownState: KeysDownState;
-
-    constructor(keysDownState: KeysDownState) {
-        super(HID_RPC_MESSAGE_TYPES.KeysDownState);
-        this.keysDownState = keysDownState;
-    }
-
-    public static unmarshal(data: Uint8Array): KeysDownStateMessage | undefined {
-        if (data.length < 1) {
-            throw new Error(`Invalid keys down state message length: ${data.length}`);
-        }
-
-        return new KeysDownStateMessage({
-            modifier: data[0],
-            keys: Array.from(data.slice(1))
-        });
-    }
-}
-
-export class PointerReportMessage extends RpcMessage {
-    x: number;
-    y: number;
-    buttons: number;
-
-    constructor(x: number, y: number, buttons: number) {
-        super(HID_RPC_MESSAGE_TYPES.PointerReport);
-        this.x = x;
-        this.y = y;
-        this.buttons = buttons;
-    }
-
-    marshal(): Uint8Array {
-        return new Uint8Array([
-            this.messageType,
-            ...fromInt32toUint8(this.x),
-            ...fromInt32toUint8(this.y),
-            this.buttons,
-        ]);
-    }
-}
-
-export class MouseReportMessage extends RpcMessage {
-    dx: number;
-    dy: number;
-    buttons: number;
-
-    constructor(dx: number, dy: number, buttons: number) {
-        super(HID_RPC_MESSAGE_TYPES.MouseReport);
-        this.dx = dx;
-        this.dy = dy;
-        this.buttons = buttons;
-    }
-
-    marshal(): Uint8Array {
-        return new Uint8Array([
-            this.messageType,
-            fromInt8ToUint8(this.dx),
-            fromInt8ToUint8(this.dy),
-            this.buttons,
-        ]);
-    }
-}
-
-export const messageRegistry = {
-    [HID_RPC_MESSAGE_TYPES.Handshake]: HandshakeMessage,
-    [HID_RPC_MESSAGE_TYPES.KeysDownState]: KeysDownStateMessage,
-    [HID_RPC_MESSAGE_TYPES.KeyboardLedState]: KeyboardLedStateMessage,
-    [HID_RPC_MESSAGE_TYPES.KeyboardReport]: KeyboardReportMessage,
-    [HID_RPC_MESSAGE_TYPES.KeypressReport]: KeypressReportMessage,
-}
-
-export const unmarshalHidRpcMessage = (data: Uint8Array): RpcMessage | undefined => {
-    if (data.length < 1) {
-        throw new Error(`Invalid HID RPC message length: ${data.length}`);
-    }
-
-    const payload = data.slice(1);
-
-    const messageType = data[0];
-    if (!(messageType in messageRegistry)) {
-        throw new Error(`Unknown HID RPC message type: ${messageType}`);
-    }
-
-    return messageRegistry[messageType].unmarshal(payload);
-};

ui/src/hooks/stores.ts

@@ -108,8 +108,8 @@ export interface RTCState {
   rpcHidProtocolVersion: number | null;
   setRpcHidProtocolVersion: (version: number) => void;
 
-  rpcHidChannel: RTCDataChannel | null;
   setRpcHidChannel: (channel: RTCDataChannel) => void;
+  rpcHidChannel: RTCDataChannel | null;
 
   peerConnectionState: RTCPeerConnectionState | null;
   setPeerConnectionState: (state: RTCPeerConnectionState) => void;

ui/src/hooks/useHidRpc.ts

@@ -1,99 +1,208 @@
 import { useCallback, useEffect, useMemo } from "react";
 
-import { useRTCStore } from "@/hooks/stores";
+import { KeyboardLedState, KeysDownState, useRTCStore } from "@/hooks/stores";
 
-import {
+export const HID_RPC_MESSAGE_TYPES = {
-  HID_RPC_VERSION,
+  Handshake: 0x01,
-  HandshakeMessage,
+  KeyboardReport: 0x02,
-  KeyboardReportMessage,
+  PointerReport: 0x03,
-  KeypressReportMessage,
+  WheelReport: 0x04,
-  MouseReportMessage,
+  KeypressReport: 0x05,
-  PointerReportMessage,
+  MouseReport: 0x06,
-  RpcMessage,
+  KeyboardLedState: 0x32,
-  unmarshalHidRpcMessage,
+  KeysDownState: 0x33,
-} from "./hidRpc";
+}
 
-export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
+export type HidRpcMessageType = typeof HID_RPC_MESSAGE_TYPES[keyof typeof HID_RPC_MESSAGE_TYPES];
+
+const withinUint8Range = (value: number) => {
+  return value >= 0 && value <= 255;
+};
+
+const fromInt32toUint8 = (n: number) => {
+  if (n !== n >> 0) {
+    throw new Error(`Number ${n} is not within the int32 range`);
+  }
+
+  return new Uint8Array([
+    (n >> 24) & 0xFF,
+    (n >> 16) & 0xFF,
+    (n >> 8) & 0xFF,
+    (n >> 0) & 0xFF,
+  ]);
+};
+
+const fromInt8ToUint8 = (n: number) => {
+  if (n < -128 || n > 127) {
+    throw new Error(`Number ${n} is not within the int8 range`);
+  }
+
+  return (n >> 0) & 0xFF;
+};
+
+const keyboardLedStateMasks = {
+  num_lock: 1 << 0,
+  caps_lock: 1 << 1,
+  scroll_lock: 1 << 2,
+  compose: 1 << 3,
+  kana: 1 << 4,
+  shift: 1 << 6,
+}
+
+export const toKeyboardLedState = (s: number): KeyboardLedState => {
+  if (!withinUint8Range(s)) {
+    throw new Error(`State ${s} is not within the uint8 range`);
+  }
+
+  return {
+    num_lock: (s & keyboardLedStateMasks.num_lock) !== 0,
+    caps_lock: (s & keyboardLedStateMasks.caps_lock) !== 0,
+    scroll_lock: (s & keyboardLedStateMasks.scroll_lock) !== 0,
+    compose: (s & keyboardLedStateMasks.compose) !== 0, // TODO: check if this is correct
+    kana: (s & keyboardLedStateMasks.kana) !== 0,
+    shift: (s & keyboardLedStateMasks.shift) !== 0,
+  } as KeyboardLedState;
+};
+
+const toPointerReportEvent = (x: number, y: number, buttons: number) => {
+  if (!withinUint8Range(buttons)) {
+    throw new Error(`Buttons ${buttons} is not within the uint8 range`);
+  }
+
+  return new Uint8Array([
+    HID_RPC_MESSAGE_TYPES.PointerReport,
+    ...fromInt32toUint8(x),
+    ...fromInt32toUint8(y),
+    buttons,
+  ]);
+};
+
+const toMouseReportEvent = (dx: number, dy: number, buttons: number) => {
+  if (!withinUint8Range(buttons)) {
+    throw new Error(`Buttons ${buttons} is not within the uint8 range`);
+  }
+  return new Uint8Array([
+    HID_RPC_MESSAGE_TYPES.MouseReport,
+    fromInt8ToUint8(dx),
+    fromInt8ToUint8(dy),
+    buttons,
+  ]);
+};
+
+const toKeyboardReportEvent = (keys: number[], modifier: number) => {
+  if (!withinUint8Range(modifier)) {
+    throw new Error(`Modifier ${modifier} is not within the uint8 range`);
+  }
+
+  keys.forEach((k) => {
+    if (!withinUint8Range(k)) {
+      throw new Error(`Key ${k} is not within the uint8 range`);
+    }
+  });
+
+  return new Uint8Array([
+    HID_RPC_MESSAGE_TYPES.KeyboardReport,
+    modifier,
+    ...keys,
+  ]);
+};
+
+const toKeypressReportEvent = (key: number, press: boolean) => {
+  if (!withinUint8Range(key)) {
+    throw new Error(`Key ${key} is not within the uint8 range`);
+  }
+
+  return new Uint8Array([
+    HID_RPC_MESSAGE_TYPES.KeypressReport,
+    key,
+    press ? 1 : 0,
+  ]);
+};
+
+const toHandshakeMessage = () => {
+  return new Uint8Array([HID_RPC_MESSAGE_TYPES.Handshake]);
+};
+
+export interface HidRpcMessage {
+  type: HidRpcMessageType;
+  keysDownState?: KeysDownState;
+}
+
+const unmarshalHidRpcMessage = (data: Uint8Array): HidRpcMessage | undefined => {
+  if (data.length < 1) {
+    throw new Error(`Invalid HID RPC message length: ${data.length}`);
+  }
+
+  const payload = data.slice(1);
+
+  switch (data[0]) {
+    case HID_RPC_MESSAGE_TYPES.Handshake:
+      return {
+        type: HID_RPC_MESSAGE_TYPES.Handshake,
+      };
+    case HID_RPC_MESSAGE_TYPES.KeysDownState:
+      return {
+        type: HID_RPC_MESSAGE_TYPES.KeysDownState,
+        keysDownState: {
+          modifier: payload[0],
+          keys: Array.from(payload.slice(1))
+        },
+      };
+    default:
+      throw new Error(`Unknown HID RPC message type: ${data[0]}`);
+  }
+};
+
+export function useHidRpc(onHidRpcMessage?: (payload: HidRpcMessage) => void) {
   const { rpcHidChannel, setRpcHidProtocolVersion, rpcHidProtocolVersion } = useRTCStore();
   const rpcHidReady = useMemo(() => {
     return rpcHidChannel?.readyState === "open" && rpcHidProtocolVersion !== null;
   }, [rpcHidChannel, rpcHidProtocolVersion]);
 
-  const rpcHidStatus = useMemo(() => {
-    if (!rpcHidChannel) return "N/A";
-    if (rpcHidChannel.readyState !== "open") return rpcHidChannel.readyState;
-    if (!rpcHidProtocolVersion) return "handshaking";
-    return `ready (v${rpcHidProtocolVersion})`;
-  }, [rpcHidChannel, rpcHidProtocolVersion]);
-
-  const sendMessage = useCallback((message: RpcMessage, ignoreHandshakeState = false) => {
-    if (rpcHidChannel?.readyState !== "open") return;
-    if (!rpcHidReady && !ignoreHandshakeState) return;
-
-    let data: Uint8Array | undefined;
-    try {
-      data = message.marshal();
-    } catch (e) {
-      console.error("Failed to send HID RPC message", e);
-    }
-    if (!data) return;
-
-    rpcHidChannel?.send(data as unknown as ArrayBuffer);
-  }, [rpcHidChannel, rpcHidReady]);
-
   const reportKeyboardEvent = useCallback(
     (keys: number[], modifier: number) => {
-      sendMessage(new KeyboardReportMessage(keys, modifier));
+      if (!rpcHidReady) return;
-    }, [sendMessage],
+      rpcHidChannel?.send(toKeyboardReportEvent(keys, modifier));
+    },
+    [rpcHidChannel, rpcHidReady],
   );
 
   const reportKeypressEvent = useCallback(
     (key: number, press: boolean) => {
-      sendMessage(new KeypressReportMessage(key, press));
+      if (!rpcHidReady) return;
+      rpcHidChannel?.send(toKeypressReportEvent(key, press));
     },
-    [sendMessage],
+    [rpcHidChannel, rpcHidReady],
   );
 
   const reportAbsMouseEvent = useCallback(
     (x: number, y: number, buttons: number) => {
-      sendMessage(new PointerReportMessage(x, y, buttons));
+      if (!rpcHidReady) return;
+      rpcHidChannel?.send(toPointerReportEvent(x, y, buttons));
     },
-    [sendMessage],
+    [rpcHidChannel, rpcHidReady],
   );
 
   const reportRelMouseEvent = useCallback(
     (dx: number, dy: number, buttons: number) => {
-      sendMessage(new MouseReportMessage(dx, dy, buttons));
+      if (!rpcHidReady) return;
+      rpcHidChannel?.send(toMouseReportEvent(dx, dy, buttons));
     },
-    [sendMessage],
+    [rpcHidChannel, rpcHidReady],
   );
 
-  const sendHandshake = useCallback(() => {
+  const doHandshake = useCallback(() => {
     if (rpcHidProtocolVersion) return;
     if (!rpcHidChannel) return;
 
-    sendMessage(new HandshakeMessage(HID_RPC_VERSION), true);
+    rpcHidChannel?.send(toHandshakeMessage());
-  }, [rpcHidChannel, rpcHidProtocolVersion, sendMessage]);
+  }, [rpcHidChannel, rpcHidProtocolVersion]);
-
-  const handleHandshake = useCallback((message: HandshakeMessage) => {
-    if (!message.version) {
-      console.error("Received handshake message without version", message);
-      return;
-    }
-
-    if (message.version < HID_RPC_VERSION) {
-      console.error("Server is using an older HID RPC version than the client", message);
-      return;
-    }
-
-    setRpcHidProtocolVersion(message.version);
-  }, [setRpcHidProtocolVersion]);
 
   useEffect(() => {
     if (!rpcHidChannel) return;
 
     // send handshake message
-    sendHandshake();
+    doHandshake();
 
     const messageHandler = (e: MessageEvent) => {
       if (typeof e.data === "string") {
@@ -101,20 +210,16 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
         return;
       }
 
+      console.debug("Received HID RPC message", e.data);
+
       const message = unmarshalHidRpcMessage(new Uint8Array(e.data));
       if (!message) {
         console.warn("Received invalid HID RPC message", e.data);
         return;
       }
 
-      console.debug("Received HID RPC message", message);
+      if (message.type === HID_RPC_MESSAGE_TYPES.Handshake) {
-      switch (message.constructor) {
+        setRpcHidProtocolVersion(1);
-        case HandshakeMessage:
-          handleHandshake(message as HandshakeMessage);
-          break;
-        default:
-          // not all events are handled here, the rest are handled by the onHidRpcMessage callback
-          break;
       }
 
       onHidRpcMessage?.(message);
@@ -130,8 +235,8 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
       rpcHidChannel,
       onHidRpcMessage,
       setRpcHidProtocolVersion,
-      sendHandshake,
+      doHandshake,
-      handleHandshake,
+      rpcHidReady,
     ],
   );
 
@@ -142,6 +247,5 @@ export function useHidRpc(onHidRpcMessage?: (payload: RpcMessage) => void) {
     reportRelMouseEvent,
     rpcHidProtocolVersion,
     rpcHidReady,
-    rpcHidStatus,
   };
 }

ui/src/hooks/useKeyboard.ts

@@ -2,14 +2,13 @@ import { useCallback } from "react";
 
 import { hidErrorRollOver, hidKeyBufferSize, KeysDownState, useHidStore, useRTCStore } from "@/hooks/stores";
 import { JsonRpcResponse, useJsonRpc } from "@/hooks/useJsonRpc";
-import { useHidRpc } from "@/hooks/useHidRpc";
+import { HID_RPC_MESSAGE_TYPES, useHidRpc } from "@/hooks/useHidRpc";
-import { KeyboardLedStateMessage, KeysDownStateMessage } from "@/hooks/hidRpc";
 import { hidKeyToModifierMask, keys, modifiers } from "@/keyboardMappings";
 
 export default function useKeyboard() {
   const { send } = useJsonRpc();
   const { rpcDataChannel } = useRTCStore();
-  const { keysDownState, setKeysDownState, setKeyboardLedState } = useHidStore();
+  const { keysDownState, setKeysDownState } = useHidStore();
 
   // INTRODUCTION: The earlier version of the JetKVM device shipped with all keyboard state
   // being tracked on the browser/client-side. When adding the keyPressReport API to the
@@ -25,16 +24,13 @@ export default function useKeyboard() {
 
   // HidRPC is a binary format for exchanging keyboard and mouse events
   const { reportKeyboardEvent, reportKeypressEvent, rpcHidReady } = useHidRpc((message) => {
-    switch (message.constructor) {
+    if (message.type === HID_RPC_MESSAGE_TYPES.KeysDownState) {
-      case KeysDownStateMessage:
+      if (!message.keysDownState) {
-        setKeysDownState((message as KeysDownStateMessage).keysDownState);
+        return;
-        setkeyPressReportApiAvailable(true);
+      }
-        break;
+
-      case KeyboardLedStateMessage:
+      setKeysDownState(message.keysDownState);
-        setKeyboardLedState((message as KeyboardLedStateMessage).keyboardLedState);
+      setkeyPressReportApiAvailable(true);
-        break;
-      default:
-        break;
     }
   });
 
@@ -99,7 +95,7 @@ export default function useKeyboard() {
       if (rpcHidReady) {
         console.debug("Sending keypress event via HidRPC");
         reportKeypressEvent(key, press);
-        return;
+        return; 
       }
 
       send("keypressReport", { key, press }, (resp: JsonRpcResponse) => {

usb.go

@@ -27,13 +27,13 @@ func initUsbGadget() {
 
 	gadget.SetOnKeyboardStateChange(func(state usbgadget.KeyboardState) {
 		if currentSession != nil {
-			currentSession.reportHidRPCKeyboardLedState(state)
+			reportHidRpcKeyboardLedState(state, currentSession)
 		}
 	})
 
 	gadget.SetOnKeysDownChange(func(state usbgadget.KeysDownState) {
 		if currentSession != nil {
-			currentSession.reportHidRPCKeysDownState(state)
+			reportHidRpcKeysDownState(state, currentSession)
 		}
 	})
 

webrtc.go

@@ -6,12 +6,10 @@ import (
 	"encoding/json"
 	"net"
 	"strings"
-	"sync"
 
 	"github.com/coder/websocket"
 	"github.com/coder/websocket/wsjson"
 	"github.com/gin-gonic/gin"
-	"github.com/jetkvm/kvm/internal/hidrpc"
 	"github.com/jetkvm/kvm/internal/logging"
 	"github.com/pion/webrtc/v4"
 	"github.com/rs/zerolog"
@@ -25,11 +23,9 @@ type Session struct {
 	HidChannel               *webrtc.DataChannel
 	shouldUmountVirtualMedia bool
 
-	rpcQueue chan webrtc.DataChannelMessage
+	hidRpcAvailable bool
-
+	hidQueue        chan webrtc.DataChannelMessage
-	hidRPCAvailable bool
+	rpcQueue        chan webrtc.DataChannelMessage
-	hidQueueLock    sync.Mutex
-	hidQueue        []chan webrtc.DataChannelMessage
 }
 
 type SessionConfig struct {
@@ -74,23 +70,6 @@ func (s *Session) ExchangeOffer(offerStr string) (string, error) {
 	return base64.StdEncoding.EncodeToString(localDescription), nil
 }
 
-func (s *Session) initQueues() {
-	s.hidQueueLock.Lock()
-	defer s.hidQueueLock.Unlock()
-
-	s.hidQueue = make([]chan webrtc.DataChannelMessage, 0)
-	for i := 0; i < 4; i++ {
-		q := make(chan webrtc.DataChannelMessage, 256)
-		s.hidQueue = append(s.hidQueue, q)
-	}
-}
-
-func (s *Session) handleQueues(index int) {
-	for msg := range s.hidQueue[index] {
-		onHidMessage(msg.Data, s)
-	}
-}
-
 func newSession(config SessionConfig) (*Session, error) {
 	webrtcSettingEngine := webrtc.SettingEngine{
 		LoggerFactory: logging.GetPionDefaultLoggerFactory(),
@@ -132,7 +111,7 @@ func newSession(config SessionConfig) (*Session, error) {
 
 	session := &Session{peerConnection: peerConnection}
 	session.rpcQueue = make(chan webrtc.DataChannelMessage, 256)
-	session.initQueues()
+	session.hidQueue = make(chan webrtc.DataChannelMessage, 1024)
 
 	go func() {
 		for msg := range session.rpcQueue {
@@ -141,51 +120,38 @@ func newSession(config SessionConfig) (*Session, error) {
 		}
 	}()
 
-	for i := 0; i < len(session.hidQueue); i++ {
+	go func() {
-		go session.handleQueues(i)
+		for msg := range session.hidQueue {
-	}
+			onHidMessage(msg.Data, session)
+		}
+	}()
 
 	peerConnection.OnDataChannel(func(d *webrtc.DataChannel) {
 		defer func() {
 			if r := recover(); r != nil {
-				scopedLogger.Error().Interface("error", r).Msg("Recovered from panic in DataChannel handler")
+				scopedLogger.Warn().Interface("error", r).Msg("Recovered from panic in DataChannel handler")
 			}
 		}()
 
 		scopedLogger.Info().Str("label", d.Label()).Uint16("id", *d.ID()).Msg("New DataChannel")
-
 		switch d.Label() {
 		case "hidrpc":
 			session.HidChannel = d
 			d.OnMessage(func(msg webrtc.DataChannelMessage) {
-				l := scopedLogger.With().Str("data", string(msg.Data)).Int("length", len(msg.Data)).Logger()
-
 				if msg.IsString {
-					l.Warn().Msg("received string data in HID RPC message handler")
+					scopedLogger.Warn().Str("data", string(msg.Data)).Msg("received string data in HID RPC message handler")
 					return
 				}
 
 				if len(msg.Data) < 1 {
-					l.Warn().Msg("received empty data in HID RPC message handler")
+					scopedLogger.Warn().Int("length", len(msg.Data)).Msg("received empty data in HID RPC message handler")
 					return
 				}
 
-				l.Trace().Msg("received data in HID RPC message handler")
+				scopedLogger.Debug().Str("data", string(msg.Data)).Msg("received data in HID RPC message handler")
 
 				// Enqueue to ensure ordered processing
-				queueIndex := hidrpc.GetQueueIndex(hidrpc.MessageType(msg.Data[0]))
+				session.hidQueue <- msg
-				if queueIndex >= len(session.hidQueue) || queueIndex < 0 {
-					l.Warn().Int("queueIndex", queueIndex).Msg("received data in HID RPC message handler, but queue index not found")
-					queueIndex = 3
-				}
-
-				queue := session.hidQueue[queueIndex]
-				if queue != nil {
-					queue <- msg
-				} else {
-					l.Warn().Int("queueIndex", queueIndex).Msg("received data in HID RPC message handler, but queue is nil")
-					return
-				}
 			})
 		case "rpc":
 			session.RPCChannel = d
@@ -269,13 +235,6 @@ func newSession(config SessionConfig) (*Session, error) {
 				close(session.rpcQueue)
 				session.rpcQueue = nil
 			}
-
-			// Stop HID RPC processor
-			for i := 0; i < len(session.hidQueue); i++ {
-				close(session.hidQueue[i])
-				session.hidQueue[i] = nil
-			}
-
 			if session.shouldUmountVirtualMedia {
 				if err := rpcUnmountImage(); err != nil {
 					scopedLogger.Warn().Err(err).Msg("unmount image failed on connection close")