From 5e80e84041731d558c7e57cee5a5c63d335c13ea Mon Sep 17 00:00:00 2001 From: randogoth Date: Sat, 26 Sep 2026 15:30:09 +0300 Subject: [PATCH] fix: serve a one-item menu at the Gopher root, not raw prose RFC 4266 defines a bare gopher://host/ (no item-type prefix in the URL) as defaulting to type '1' -- a menu -- so every RFC-following client, Lagrange included, parses whatever the empty selector returns as tab-delimited menu lines rather than displaying it as text. Handing back the homepage's own rendered prose there has no tabs in it, so it parses as zero valid entries and renders blank. Only the truly empty selector gets the synthetic menu; its one item points at the homepage under "/", a distinguishable non-empty selector that still resolves to real content exactly as before. This still isn't directory browsing -- there's still no listing of the content tree, just the one link needed to make the root itself navigable. Co-Authored-By: Claude Sonnet 5 --- src/smolweb/cli.py | 2 +- src/smolweb/servers/gopher.py | 30 ++++++++++++++-- tests/test_gopher.py | 68 +++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+), 3 deletions(-) create mode 100644 tests/test_gopher.py diff --git a/src/smolweb/cli.py b/src/smolweb/cli.py index d7aff01..d60c1d8 100644 --- a/src/smolweb/cli.py +++ b/src/smolweb/cli.py @@ -77,7 +77,7 @@ def main(argv=None) -> int: if args.gopher: gopher_addr = _parse_address(args.gopher) - threads.append(_serve_in_thread(GopherServer(gopher_addr, site), "gopher", gopher_addr)) + threads.append(_serve_in_thread(GopherServer(gopher_addr, site, args.host), "gopher", gopher_addr)) if not threads: sys.stderr.write("smolweb: every listener disabled, nothing to do\n") diff --git a/src/smolweb/servers/gopher.py b/src/smolweb/servers/gopher.py index 0bae210..0f32912 100644 --- a/src/smolweb/servers/gopher.py +++ b/src/smolweb/servers/gopher.py @@ -7,6 +7,17 @@ folder has no use for); the response for a text document is dot-stuffed and terminated with a lone "." line per RFC 1436, then the connection closes. Raw files are streamed as-is with no terminator, matching how binary Gopher items are conventionally served. + +One exception to "no gophermaps": a bare `gopher://host/` with no +item-type prefix is defined by RFC 4266 to default to type '1' (a menu), +and real clients (Lagrange included) parse whatever comes back from an +empty selector as tab-delimited menu lines, not prose -- serving the +homepage's own text there produces zero valid menu entries and an empty +page. So the empty selector alone gets a one-item synthetic menu pointing +at the homepage under a distinguishable non-empty selector ("/"); every +other selector, including that one, is served as real content exactly as +before. This is not directory browsing -- there is still no listing of +the content tree -- just the one link needed to make the root navigable. """ from __future__ import annotations @@ -51,7 +62,9 @@ class GopherHandler(socketserver.StreamRequestHandler): self._send_text(b"Internal error.\n") return - if isinstance(resource, RawFile): + if not selector and not isinstance(resource, RawFile): + self._send_menu([("0", "Home", "/", self.server.host, self.server.port)]) + elif isinstance(resource, RawFile): self._send_raw(resource.data) else: self._send_text(resource.gopher) @@ -71,11 +84,24 @@ class GopherHandler(socketserver.StreamRequestHandler): except OSError: pass + def _send_menu(self, items) -> None: + lines = [ + f"{item_type}{display}\t{item_selector}\t{host}\t{port}\r\n" + for item_type, display, item_selector, host, port in items + ] + try: + self.wfile.write("".join(lines).encode("utf-8")) + self.wfile.write(b".\r\n") + except OSError: + pass + class GopherServer(socketserver.ThreadingTCPServer): daemon_threads = True allow_reuse_address = True - def __init__(self, address, site: Site) -> None: + def __init__(self, address, site: Site, host: str) -> None: self.site = site + self.host = host + self.port = address[1] super().__init__(address, GopherHandler) diff --git a/tests/test_gopher.py b/tests/test_gopher.py new file mode 100644 index 0000000..798f805 --- /dev/null +++ b/tests/test_gopher.py @@ -0,0 +1,68 @@ +"""Gopher listener: the RFC 4266 root-menu compatibility fix, dot-stuffing.""" +from __future__ import annotations + +import socket +import threading + +import pytest + +from smolweb.servers.gopher import GopherServer +from smolweb.site import Site + + +def _free_port() -> int: + with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe: + probe.bind(("127.0.0.1", 0)) + return probe.getsockname()[1] + + +@pytest.fixture +def gopher_server(site: Site): + port = _free_port() + server = GopherServer(("127.0.0.1", port), site, "localhost") + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + yield server + server.shutdown() + server.server_close() + + +def _request(server: GopherServer, selector: str) -> bytes: + with socket.create_connection(("127.0.0.1", server.port), timeout=5) as sock: + sock.sendall(f"{selector}\r\n".encode("utf-8")) + chunks = [] + while True: + chunk = sock.recv(65536) + if not chunk: + break + chunks.append(chunk) + return b"".join(chunks) + + +class TestGopherRootMenu: + def test_empty_selector_returns_a_one_item_menu(self, gopher_server: GopherServer): + # A bare gopher://host/ has no item-type prefix, which RFC 4266 + # defines as defaulting to type '1' (menu) -- real clients parse + # the response as tab-delimited menu lines, not prose, so the + # homepage's own rendered text must never be sent back here. + response = _request(gopher_server, "") + assert response == f"0Home\t/\tlocalhost\t{gopher_server.port}\r\n.\r\n".encode("utf-8") + + def test_menu_link_selector_resolves_to_real_content(self, gopher_server: GopherServer): + # The menu's own selector ("/") must not trigger the same + # menu-synthesis branch -- only the truly empty selector does. + response = _request(gopher_server, "/") + assert response.endswith(b".\r\n") + assert b"Hello." in response + assert not response.startswith(b"0Home\t") + + def test_non_root_selector_is_unaffected(self, gopher_server: GopherServer): + response = _request(gopher_server, "about") + assert b"Body." in response + assert not response.startswith(b"0Home\t") + + +class TestGopherDotStuffing: + def test_not_found_response_is_well_formed(self, gopher_server: GopherServer): + response = _request(gopher_server, "nope") + assert response == b"Not found.\n.\r\n"