mirror of
https://github.com/mofeng-git/One-KVM.git
synced 2025-12-12 01:00:29 +08:00
422 lines
15 KiB
Python
422 lines
15 KiB
Python
# ========================================================================== #
|
||
# #
|
||
# KVMD - The main Pi-KVM daemon. #
|
||
# #
|
||
# Copyright (C) 2018 Maxim Devaev <mdevaev@gmail.com> #
|
||
# #
|
||
# This program is free software: you can redistribute it and/or modify #
|
||
# it under the terms of the GNU General Public License as published by #
|
||
# the Free Software Foundation, either version 3 of the License, or #
|
||
# (at your option) any later version. #
|
||
# #
|
||
# This program is distributed in the hope that it will be useful, #
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of #
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the #
|
||
# GNU General Public License for more details. #
|
||
# #
|
||
# You should have received a copy of the GNU General Public License #
|
||
# along with this program. If not, see <https://www.gnu.org/licenses/>. #
|
||
# #
|
||
# ========================================================================== #
|
||
|
||
|
||
import os
|
||
import multiprocessing
|
||
import dataclasses
|
||
import contextlib
|
||
import queue
|
||
import struct
|
||
import time
|
||
|
||
from typing import Tuple
|
||
from typing import List
|
||
from typing import Dict
|
||
from typing import Iterable
|
||
from typing import Generator
|
||
from typing import AsyncGenerator
|
||
|
||
from ....logging import get_logger
|
||
|
||
from ....keyboard.mappings import KEYMAP
|
||
|
||
from .... import tools
|
||
from .... import aiotools
|
||
from .... import aiomulti
|
||
from .... import aioproc
|
||
|
||
from ....yamlconf import Option
|
||
|
||
from ....validators.basic import valid_bool
|
||
from ....validators.basic import valid_int_f0
|
||
from ....validators.basic import valid_int_f1
|
||
from ....validators.basic import valid_float_f01
|
||
from ....validators.hw import valid_gpio_pin_optional
|
||
|
||
from .. import BaseHid
|
||
|
||
from .gpio import Gpio
|
||
|
||
|
||
# =====
|
||
class _RequestError(Exception):
|
||
def __init__(self, msg: str, online: bool=False) -> None:
|
||
super().__init__(msg)
|
||
self.msg = msg
|
||
self.online = online
|
||
|
||
|
||
class _PermRequestError(_RequestError):
|
||
pass
|
||
|
||
|
||
class _TempRequestError(_RequestError):
|
||
pass
|
||
|
||
|
||
# =====
|
||
class _BaseEvent:
|
||
def make_command(self) -> bytes:
|
||
raise NotImplementedError
|
||
|
||
|
||
class _ClearEvent(_BaseEvent):
|
||
def make_command(self) -> bytes:
|
||
return b"\x10\x00\x00\x00\x00"
|
||
|
||
|
||
@dataclasses.dataclass(frozen=True)
|
||
class _KeyEvent(_BaseEvent):
|
||
name: str
|
||
state: bool
|
||
|
||
def __post_init__(self) -> None:
|
||
assert self.name in KEYMAP
|
||
|
||
def make_command(self) -> bytes:
|
||
code = KEYMAP[self.name].serial.code
|
||
return struct.pack(">BBBxx", 0x11, code, int(self.state))
|
||
|
||
|
||
@dataclasses.dataclass(frozen=True)
|
||
class _MouseButtonEvent(_BaseEvent):
|
||
name: str
|
||
state: bool
|
||
|
||
def __post_init__(self) -> None:
|
||
assert self.name in ["left", "right", "middle", "up", "down"]
|
||
|
||
def make_command(self) -> bytes:
|
||
(code, state_pressed, is_main) = {
|
||
"left": (0b10000000, 0b00001000, True),
|
||
"right": (0b01000000, 0b00000100, True),
|
||
"middle": (0b00100000, 0b00000010, True),
|
||
"up": (0b10000000, 0b00001000, False), # Back
|
||
"down": (0b01000000, 0b00000100, False), # Forward
|
||
}[self.name]
|
||
if self.state:
|
||
code |= state_pressed
|
||
if is_main:
|
||
main_code = code
|
||
extra_code = 0
|
||
else:
|
||
main_code = 0
|
||
extra_code = code
|
||
return struct.pack(">BBBxx", 0x13, main_code, extra_code)
|
||
|
||
|
||
@dataclasses.dataclass(frozen=True)
|
||
class _MouseMoveEvent(_BaseEvent):
|
||
to_x: int
|
||
to_y: int
|
||
|
||
def __post_init__(self) -> None:
|
||
assert -32768 <= self.to_x <= 32767
|
||
assert -32768 <= self.to_y <= 32767
|
||
|
||
def make_command(self) -> bytes:
|
||
return struct.pack(">Bhh", 0x12, self.to_x, self.to_y)
|
||
|
||
|
||
@dataclasses.dataclass(frozen=True)
|
||
class _MouseWheelEvent(_BaseEvent):
|
||
delta_x: int
|
||
delta_y: int
|
||
|
||
def __post_init__(self) -> None:
|
||
assert -127 <= self.delta_x <= 127
|
||
assert -127 <= self.delta_y <= 127
|
||
|
||
def make_command(self) -> bytes:
|
||
# Горизонтальная прокрутка пока не поддерживается
|
||
return struct.pack(">Bxbxx", 0x14, self.delta_y)
|
||
|
||
|
||
# =====
|
||
class BasePhyConnection:
|
||
def send(self, request: bytes, receive: int) -> bytes:
|
||
raise NotImplementedError
|
||
|
||
|
||
class BasePhy:
|
||
def has_device(self) -> bool:
|
||
raise NotImplementedError
|
||
|
||
@contextlib.contextmanager
|
||
def connected(self) -> Generator[BasePhyConnection, None, None]:
|
||
raise NotImplementedError
|
||
|
||
|
||
class BaseMcuHid(BaseHid, multiprocessing.Process): # pylint: disable=too-many-instance-attributes
|
||
def __init__( # pylint: disable=too-many-arguments,super-init-not-called
|
||
self,
|
||
phy: BasePhy,
|
||
|
||
reset_pin: int,
|
||
reset_delay: float,
|
||
|
||
read_retries: int,
|
||
common_retries: int,
|
||
retries_delay: float,
|
||
errors_threshold: int,
|
||
noop: bool,
|
||
) -> None:
|
||
|
||
multiprocessing.Process.__init__(self, daemon=True)
|
||
|
||
self.__read_retries = read_retries
|
||
self.__common_retries = common_retries
|
||
self.__retries_delay = retries_delay
|
||
self.__errors_threshold = errors_threshold
|
||
self.__noop = noop
|
||
|
||
self.__phy = phy
|
||
self.__gpio = Gpio(reset_pin, reset_delay)
|
||
|
||
self.__events_queue: "multiprocessing.Queue[_BaseEvent]" = multiprocessing.Queue()
|
||
|
||
self.__notifier = aiomulti.AioProcessNotifier()
|
||
self.__state_flags = aiomulti.AioSharedFlags({
|
||
"online": True,
|
||
"caps": False,
|
||
"scroll": False,
|
||
"num": False,
|
||
}, self.__notifier)
|
||
|
||
self.__stop_event = multiprocessing.Event()
|
||
|
||
@classmethod
|
||
def get_plugin_options(cls) -> Dict:
|
||
return {
|
||
"reset_pin": Option(-1, type=valid_gpio_pin_optional),
|
||
"reset_delay": Option(0.1, type=valid_float_f01),
|
||
|
||
"read_retries": Option(10, type=valid_int_f1),
|
||
"common_retries": Option(100, type=valid_int_f1),
|
||
"retries_delay": Option(0.1, type=valid_float_f01),
|
||
"errors_threshold": Option(5, type=valid_int_f0),
|
||
"noop": Option(False, type=valid_bool),
|
||
}
|
||
|
||
def sysprep(self) -> None:
|
||
self.__gpio.open()
|
||
get_logger(0).info("Starting HID daemon ...")
|
||
self.start()
|
||
|
||
async def get_state(self) -> Dict:
|
||
state = await self.__state_flags.get()
|
||
return {
|
||
"online": state["online"],
|
||
"keyboard": {
|
||
"online": state["online"],
|
||
"leds": {
|
||
"caps": state["caps"],
|
||
"scroll": state["scroll"],
|
||
"num": state["num"],
|
||
},
|
||
},
|
||
"mouse": {"online": state["online"]},
|
||
}
|
||
|
||
async def poll_state(self) -> AsyncGenerator[Dict, None]:
|
||
prev_state: Dict = {}
|
||
while True:
|
||
state = await self.get_state()
|
||
if state != prev_state:
|
||
yield state
|
||
prev_state = state
|
||
await self.__notifier.wait()
|
||
|
||
@aiotools.atomic
|
||
async def reset(self) -> None:
|
||
await self.__gpio.reset()
|
||
|
||
@aiotools.atomic
|
||
async def cleanup(self) -> None:
|
||
logger = get_logger(0)
|
||
try:
|
||
if self.is_alive():
|
||
logger.info("Stopping HID daemon ...")
|
||
self.__stop_event.set()
|
||
if self.exitcode is not None:
|
||
self.join()
|
||
if self.__phy.has_device():
|
||
get_logger().info("Clearing HID events ...")
|
||
try:
|
||
with self.__phy.connected() as conn:
|
||
self.__process_command(conn, b"\x10\x00\x00\x00\x00")
|
||
except Exception:
|
||
logger.exception("Can't clear HID events")
|
||
finally:
|
||
self.__gpio.close()
|
||
|
||
# =====
|
||
|
||
def send_key_events(self, keys: Iterable[Tuple[str, bool]]) -> None:
|
||
for (key, state) in keys:
|
||
self.__queue_event(_KeyEvent(key, state))
|
||
|
||
def send_mouse_button_event(self, button: str, state: bool) -> None:
|
||
self.__queue_event(_MouseButtonEvent(button, state))
|
||
|
||
def send_mouse_move_event(self, to_x: int, to_y: int) -> None:
|
||
self.__queue_event(_MouseMoveEvent(to_x, to_y))
|
||
|
||
def send_mouse_wheel_event(self, delta_x: int, delta_y: int) -> None:
|
||
self.__queue_event(_MouseWheelEvent(delta_x, delta_y))
|
||
|
||
def clear_events(self) -> None:
|
||
# FIXME: Если очистка производится со стороны процесса хида, то возможна гонка между
|
||
# очисткой и добавлением события _ClearEvent. Неприятно, но не смертельно.
|
||
# Починить блокировкой после перехода на асинхронные очереди.
|
||
tools.clear_queue(self.__events_queue)
|
||
self.__queue_event(_ClearEvent())
|
||
|
||
def __queue_event(self, event: _BaseEvent) -> None:
|
||
if not self.__stop_event.is_set():
|
||
self.__events_queue.put_nowait(event)
|
||
|
||
def run(self) -> None: # pylint: disable=too-many-branches
|
||
logger = get_logger(0)
|
||
|
||
logger.info("Started HID pid=%d", os.getpid())
|
||
aioproc.ignore_sigint()
|
||
aioproc.rename_process("hid")
|
||
|
||
while not self.__stop_event.is_set():
|
||
try:
|
||
if self.__phy.has_device():
|
||
with self.__phy.connected() as conn:
|
||
while not (self.__stop_event.is_set() and self.__events_queue.qsize() == 0):
|
||
try:
|
||
event = self.__events_queue.get(timeout=0.1)
|
||
except queue.Empty:
|
||
self.__process_command(conn, b"\x01\x00\x00\x00\x00") # Ping
|
||
else:
|
||
if not self.__process_command(conn, event.make_command()):
|
||
self.clear_events()
|
||
else:
|
||
logger.error("Missing HID device")
|
||
time.sleep(1)
|
||
except Exception:
|
||
self.clear_events()
|
||
logger.exception("Unexpected HID error")
|
||
time.sleep(1)
|
||
|
||
def __process_command(self, conn: BasePhyConnection, command: bytes) -> bool:
|
||
return self.__process_request(conn, self.__make_request(command))
|
||
|
||
def __process_request(self, conn: BasePhyConnection, request: bytes) -> bool: # pylint: disable=too-many-branches
|
||
logger = get_logger()
|
||
error_messages: List[str] = []
|
||
live_log_errors = False
|
||
|
||
common_retries = self.__common_retries
|
||
read_retries = self.__read_retries
|
||
error_retval = False
|
||
|
||
while common_retries and read_retries:
|
||
response = self.__send_request(conn, request)
|
||
try:
|
||
if len(response) < 4:
|
||
read_retries -= 1
|
||
raise _TempRequestError(f"No response from HID: request={request!r}")
|
||
|
||
assert len(response) == 4, response
|
||
if self.__make_crc16(response[-4:-2]) != struct.unpack(">H", response[-2:])[0]:
|
||
request = self.__make_request(b"\x02\x00\x00\x00\x00") # Repeat an answer
|
||
raise _TempRequestError("Invalid response CRC; requesting response again ...")
|
||
|
||
code = response[1]
|
||
if code == 0x48: # Request timeout # pylint: disable=no-else-raise
|
||
raise _TempRequestError(f"Got request timeout from HID: request={request!r}")
|
||
elif code == 0x40: # CRC Error
|
||
raise _TempRequestError(f"Got CRC error of request from HID: request={request!r}")
|
||
elif code == 0x45: # Unknown command
|
||
raise _PermRequestError(f"HID did not recognize the request={request!r}", online=True)
|
||
elif code == 0x24: # Rebooted?
|
||
raise _PermRequestError("No previous command state inside HID, seems it was rebooted", online=True)
|
||
elif code == 0x20: # Done
|
||
self.__state_flags.update(online=True)
|
||
return True
|
||
elif code & 0x80: # Pong with leds
|
||
self.__state_flags.update(
|
||
online=True,
|
||
caps=bool(code & 0b00000001),
|
||
scroll=bool(code & 0x00000010),
|
||
num=bool(code & 0x00000100),
|
||
)
|
||
return True
|
||
raise _TempRequestError(f"Invalid response from HID: request={request!r}; code=0x{code:02X}")
|
||
|
||
except _RequestError as err:
|
||
common_retries -= 1
|
||
self.__state_flags.update(online=err.online)
|
||
error_retval = err.online
|
||
|
||
if live_log_errors:
|
||
logger.error(err.msg)
|
||
else:
|
||
error_messages.append(err.msg)
|
||
if len(error_messages) > self.__errors_threshold:
|
||
for msg in error_messages:
|
||
logger.error(msg)
|
||
error_messages = []
|
||
live_log_errors = True
|
||
|
||
if isinstance(err, _PermRequestError):
|
||
break
|
||
if common_retries and read_retries:
|
||
time.sleep(self.__retries_delay)
|
||
|
||
for msg in error_messages:
|
||
logger.error(msg)
|
||
if not (common_retries and read_retries):
|
||
logger.error("Can't process HID request due many errors: %r", request)
|
||
return error_retval
|
||
|
||
def __send_request(self, conn: BasePhyConnection, request: bytes) -> bytes:
|
||
if not self.__noop:
|
||
response = conn.send(request, 4)
|
||
else:
|
||
response = b"\x33\x20" # Magic + OK
|
||
response += struct.pack(">H", self.__make_crc16(response))
|
||
return response
|
||
|
||
def __make_request(self, command: bytes) -> bytes:
|
||
request = b"\x33" + command
|
||
request += struct.pack(">H", self.__make_crc16(request))
|
||
assert len(request) == 8, (request, command)
|
||
return request
|
||
|
||
def __make_crc16(self, data: bytes) -> int:
|
||
crc = 0xFFFF
|
||
for byte in data:
|
||
crc = crc ^ byte
|
||
for _ in range(8):
|
||
if crc & 0x0001 == 0:
|
||
crc = crc >> 1
|
||
else:
|
||
crc = crc >> 1
|
||
crc = crc ^ 0xA001
|
||
return crc
|