mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-20 12:32:17 +01:00
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint) (push) Waiting to run
Tests / test (push) Waiting to run
Tests / web-coverage (push) Waiting to run
repo-contract / repo contract (push) Waiting to run
kuhy 2026-11-11: game-design research needs Librarian (app 4197610) actually played during the 6-day total block. New root command total-block-research --until T opens ONE window per lock: <= 48 h, never past the lock end, a rerun never extends it. The command only validates and records (/var/lib/steam-backlog- enforcer, root 0700; lock id + deadline + two latches). The daemon opens and closes everything: Steam hosts names, the store block, the total-block chain (IP cache kept) and the steam package, reinstalled with only guard-lib's package-block hook masked for that one pacman call (--hookdir, proved in a guest). Lock file, hook and end date are never touched. Browser-game sites stay null-routed. Only Librarian may run: loop-local allowed set, strict mode (no whitelist exceptions, no zero-achievement games), launchers and counted games killed; state.json is never read or written. Expiry latches the record, then the ordinary tick re-applies hosts (now reconciled each tick), chain, uninstall and purge; the normal store block is restored once, unconditionally. Failure modes: missing/corrupt/unparseable record = no window and a corrupt one also refuses a new window (fail closed); a clock set back cannot reopen a latched window. Checked: 3290 tests at 100% coverage; whole-tree pylint 10/10 run in three parts (the hook exceeds the 60 s cap, so SKIP=pylint here); vmbox guest with real guardctl package-block and the real unit, window opened, Librarian-only enforced, clock moved past the deadline and the full block re-applied. Not verified on the host. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWWzuCEg1m87jpKyRrw
148 lines
4.9 KiB
Python
148 lines
4.9 KiB
Python
"""/etc/hosts null-routing for the total gaming block.
|
|
|
|
Deliberately distinct from :mod:`store_blocker`'s own BLOCKED_DOMAINS /
|
|
STEAM_ENFORCER hosts section, so ending a total block never disturbs the
|
|
user's normal ``config.block_store`` entries. The iptables half of the same
|
|
block lives in :mod:`steam_backlog_enforcer._total_block_iptables`.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import subprocess
|
|
|
|
from steam_backlog_enforcer._hosts_protection import (
|
|
_disable_hosts_protection,
|
|
_enable_hosts_protection,
|
|
_sudo_write_hosts,
|
|
)
|
|
from steam_backlog_enforcer._total_block_domains import (
|
|
_ALL_TOTAL_BLOCK_DOMAINS,
|
|
NULL_ROUTE_IP,
|
|
RESEARCH_BLOCKED_DOMAINS,
|
|
)
|
|
from steam_backlog_enforcer.config import HOSTS_FILE
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_HOSTS_BLOCK_BEGIN = "# BEGIN steam-backlog-enforcer total-block\n"
|
|
_HOSTS_BLOCK_END = "# END steam-backlog-enforcer total-block\n"
|
|
|
|
|
|
def _expected_block(*, steam_open: bool = False) -> str:
|
|
"""The enforcer's /etc/hosts section as it should currently read.
|
|
|
|
With *steam_open* (a research window) the section lists the game sites only.
|
|
"""
|
|
domains = RESEARCH_BLOCKED_DOMAINS if steam_open else _ALL_TOTAL_BLOCK_DOMAINS
|
|
lines = [_HOSTS_BLOCK_BEGIN]
|
|
lines += [f"{NULL_ROUTE_IP} {domain}\n" for domain in domains]
|
|
lines.append(_HOSTS_BLOCK_END)
|
|
return "".join(lines)
|
|
|
|
|
|
def apply_total_block_hosts() -> bool:
|
|
"""Append the total-block domain block to /etc/hosts, if not present."""
|
|
try:
|
|
content = HOSTS_FILE.read_text(encoding="utf-8")
|
|
except OSError:
|
|
logger.exception("Failed to read /etc/hosts")
|
|
return False
|
|
|
|
if _HOSTS_BLOCK_BEGIN in content:
|
|
return True
|
|
|
|
new_content = content if content.endswith("\n") else content + "\n"
|
|
new_content += _expected_block()
|
|
|
|
try:
|
|
_disable_hosts_protection()
|
|
_sudo_write_hosts(new_content)
|
|
except OSError, subprocess.SubprocessError:
|
|
logger.exception("Failed to write total-block hosts entries")
|
|
return False
|
|
finally:
|
|
_enable_hosts_protection()
|
|
return True
|
|
|
|
|
|
def _write_hosts(content: str, failure: str) -> bool:
|
|
"""Write *content* through the guard-lib unlock/relock; False on failure."""
|
|
try:
|
|
_disable_hosts_protection()
|
|
_sudo_write_hosts(content)
|
|
except OSError, subprocess.SubprocessError:
|
|
logger.exception(failure)
|
|
return False
|
|
finally:
|
|
_enable_hosts_protection()
|
|
return True
|
|
|
|
|
|
def refresh_total_block_hosts(*, steam_open: bool = False) -> bool:
|
|
"""Bring an existing section in line with the current domain list.
|
|
|
|
Unlike :func:`apply_total_block_hosts` (which leaves a present section
|
|
alone, so the 3 s tick stays cheap), this replaces the section when its
|
|
text differs -- how a list change reaches an already-active block, and how
|
|
the full list returns when a research window ends. Only the text between
|
|
the markers changes; a BEGIN without END, or an unreadable file, is left
|
|
untouched (False). A missing section is installed (the full one, or with
|
|
*steam_open* the research one).
|
|
|
|
Args:
|
|
steam_open: Write the research-window section (game sites only).
|
|
"""
|
|
try:
|
|
content = HOSTS_FILE.read_text(encoding="utf-8")
|
|
except OSError:
|
|
logger.exception("Failed to read /etc/hosts")
|
|
return False
|
|
|
|
expected = _expected_block(steam_open=steam_open)
|
|
start = content.find(_HOSTS_BLOCK_BEGIN)
|
|
if start == -1:
|
|
if not steam_open:
|
|
return apply_total_block_hosts()
|
|
head = content if content.endswith("\n") else content + "\n"
|
|
return _write_hosts(head + expected, "Failed to write research hosts entries")
|
|
end_at = content.find(_HOSTS_BLOCK_END, start)
|
|
if end_at == -1:
|
|
logger.error("total-block section has no END marker; not touching hosts")
|
|
return False
|
|
|
|
end = end_at + len(_HOSTS_BLOCK_END)
|
|
if content[start:end] == expected:
|
|
return True
|
|
return _write_hosts(
|
|
content[:start] + expected + content[end:],
|
|
"Failed to refresh total-block hosts entries",
|
|
)
|
|
|
|
|
|
def remove_total_block_hosts() -> bool:
|
|
"""Remove the total-block domain block from /etc/hosts, if present."""
|
|
try:
|
|
content = HOSTS_FILE.read_text(encoding="utf-8")
|
|
except OSError:
|
|
logger.exception("Failed to read /etc/hosts")
|
|
return False
|
|
|
|
if _HOSTS_BLOCK_BEGIN not in content:
|
|
return True
|
|
|
|
start = content.index(_HOSTS_BLOCK_BEGIN)
|
|
end_marker_at = content.index(_HOSTS_BLOCK_END, start)
|
|
end = end_marker_at + len(_HOSTS_BLOCK_END)
|
|
new_content = content[:start] + content[end:]
|
|
|
|
try:
|
|
_disable_hosts_protection()
|
|
_sudo_write_hosts(new_content)
|
|
except OSError, subprocess.SubprocessError:
|
|
logger.exception("Failed to remove total-block hosts entries")
|
|
return False
|
|
finally:
|
|
_enable_hosts_protection()
|
|
return True
|