mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-21 19:52:19 +01:00
The pinned howlongtobeatpy (1.0.23) takes a user agent in send_website_request_getcode and dropped parse_all_scripts; the call still matched 1.0.20, which only worked because the deployed env was behind its own pin. Now on the pinned API, and the env upgraded. Three modules carried the same executable/path constant block since the 250-line split; it is _store_tools. Four carried the same "restore the hours a refetch lost" loop; it is restore_prior_hours. Both detached launches go through one helper that returns the process. Thirteen try/except/else blocks are flat, dataclass fields come from dataclasses.fields, and the rest are one-line fixes. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HHCbkJWXHjtTUaqvnHRAqA
178 lines
5.7 KiB
Python
178 lines
5.7 KiB
Python
"""Enforce that only the assigned game may run."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import signal
|
|
import subprocess
|
|
|
|
from steam_backlog_enforcer._desktop_env import (
|
|
desktop_user_cmd,
|
|
resolve_desktop_user,
|
|
)
|
|
from steam_backlog_enforcer.game_uninstall import is_protected_app
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def get_running_steam_game_pids() -> dict[int, int]:
|
|
"""Scan /proc to find running Steam game processes.
|
|
|
|
Returns: dict mapping PID -> SteamAppId.
|
|
"""
|
|
running: dict[int, int] = {}
|
|
proc = Path("/proc")
|
|
|
|
for entry in proc.iterdir():
|
|
if not entry.name.isdigit():
|
|
continue
|
|
try:
|
|
environ = (entry / "environ").read_bytes()
|
|
pairs = environ.split(b"\x00")
|
|
for pair in pairs:
|
|
if pair.startswith(b"SteamAppId="):
|
|
value = pair.split(b"=", 1)[1].decode("utf-8", errors="replace")
|
|
if value.isdigit():
|
|
running[int(entry.name)] = int(value)
|
|
break
|
|
except PermissionError, OSError, ValueError:
|
|
continue
|
|
|
|
return running
|
|
|
|
|
|
def get_pids_by_process_names(names: frozenset[str]) -> dict[int, str]:
|
|
"""Scan /proc/*/comm for processes whose command name is in *names*.
|
|
|
|
The kernel truncates ``/proc/[pid]/comm`` to 15 characters (plus a null
|
|
terminator), so *names* longer than that (e.g. ``EpicGamesLauncher``,
|
|
``gdlauncher-carbon``) are matched against their own first 15 characters
|
|
- matching how the kernel actually stores them, not an exact string
|
|
that could never appear in ``comm``.
|
|
|
|
Returns: dict mapping PID -> matched comm string.
|
|
"""
|
|
truncated = {name[:15]: name for name in names}
|
|
running: dict[int, str] = {}
|
|
proc = Path("/proc")
|
|
|
|
for entry in proc.iterdir():
|
|
if not entry.name.isdigit():
|
|
continue
|
|
try:
|
|
comm = (entry / "comm").read_text(encoding="utf-8").strip()
|
|
except PermissionError, OSError, ValueError:
|
|
continue
|
|
if comm in truncated:
|
|
running[int(entry.name)] = truncated[comm]
|
|
|
|
return running
|
|
|
|
|
|
def kill_processes_by_name(names: frozenset[str]) -> list[tuple[int, str]]:
|
|
"""Kill (SIGTERM) every running process whose name is in *names*.
|
|
|
|
Matching is by ``/proc/[pid]/comm`` via :func:`get_pids_by_process_names`,
|
|
not the ``SteamAppId`` environment variable (unlike
|
|
:func:`get_running_steam_game_pids`) - this is for non-Steam processes
|
|
(the Steam client itself, and third-party game launchers) that don't set
|
|
that variable.
|
|
|
|
Returns: list of (pid, matched_name) actually killed.
|
|
"""
|
|
killed: list[tuple[int, str]] = []
|
|
for pid, name in get_pids_by_process_names(names).items():
|
|
if _kill_pid_by_name(pid, name):
|
|
killed.append((pid, name))
|
|
return killed
|
|
|
|
|
|
def _kill_pid_by_name(pid: int, name: str) -> bool:
|
|
"""Send SIGTERM to *pid*. Returns True if the signal was delivered."""
|
|
try:
|
|
os.kill(pid, signal.SIGTERM)
|
|
except ProcessLookupError:
|
|
return False
|
|
except PermissionError:
|
|
logger.exception("No permission to kill PID %d (%s).", pid, name)
|
|
return False
|
|
return True
|
|
|
|
|
|
def enforce_allowed_game(
|
|
allowed_app_ids: set[int],
|
|
*,
|
|
kill_unauthorized: bool = True,
|
|
) -> list[tuple[int, int]]:
|
|
"""Check running games; optionally kill unauthorized ones.
|
|
|
|
Args:
|
|
allowed_app_ids: Every app id the user may play right now — the
|
|
assignment plus any concurrent manual picks. Empty disables the
|
|
check entirely (nothing is assigned, so nothing is unauthorized).
|
|
kill_unauthorized: Whether to kill violating processes.
|
|
|
|
Returns list of (pid, app_id) that were killed or detected.
|
|
"""
|
|
if not allowed_app_ids:
|
|
return []
|
|
running = get_running_steam_game_pids()
|
|
violations: list[tuple[int, int]] = []
|
|
|
|
for pid, app_id in running.items():
|
|
if app_id in allowed_app_ids:
|
|
continue
|
|
# Skip Steam client itself (app_id 0 or very low IDs).
|
|
if app_id == 0:
|
|
continue
|
|
if is_protected_app(app_id):
|
|
continue
|
|
|
|
violations.append((pid, app_id))
|
|
if kill_unauthorized:
|
|
kill_process(pid, app_id)
|
|
|
|
return violations
|
|
|
|
|
|
def kill_process(pid: int, app_id: int) -> None:
|
|
"""Kill a process by PID."""
|
|
try:
|
|
logger.warning("Killing unauthorized game (AppID=%d, PID=%d)", app_id, pid)
|
|
os.kill(pid, signal.SIGTERM)
|
|
except ProcessLookupError:
|
|
logger.debug("Process %d already gone.", pid)
|
|
except PermissionError:
|
|
logger.exception("No permission to kill PID %d.", pid)
|
|
|
|
|
|
def send_notification(title: str, body: str) -> None:
|
|
"""Send a desktop notification into the real user's session.
|
|
|
|
The enforcer runs as root under systemd, where a bare ``notify-send`` has
|
|
no DBUS_SESSION_BUS_ADDRESS and so cannot reach the user's session bus —
|
|
it failed silently for every caller. Dropping to the desktop user supplies
|
|
the session variables it needs.
|
|
"""
|
|
_notify_send = shutil.which("notify-send") or "/usr/bin/notify-send"
|
|
cmd = desktop_user_cmd(
|
|
[_notify_send, title, body, "--icon=dialog-warning"],
|
|
resolve_desktop_user(),
|
|
)
|
|
try:
|
|
subprocess.run(
|
|
cmd,
|
|
capture_output=True,
|
|
timeout=5,
|
|
check=False,
|
|
)
|
|
except FileNotFoundError, OSError:
|
|
logger.debug("notify-send not available.")
|
|
except subprocess.TimeoutExpired:
|
|
# sudo can block where a bare notify-send would not; a dropped
|
|
# notification is better than an exception escaping the enforce loop.
|
|
logger.debug("notify-send timed out.")
|