Gopher

Vad det är

Gopher är ett nätverksprotokoll för att hämta dokument och menyer
över internet, där en klient öppnar en TCP-anslutning, skickar en
rad som namnger det den vill ha, läser svaret och är klar. Formellt
är det Internet Gopher-protokollet, dess adresser börjar med
`gopher://`, och en webbplats som publiceras över det kallas oftast
ett Gopher-hål. Det härstammar från 1991, och RFC 1436 beskrev det i
mars 1993.

Utbytet är så kort att det går att skriva för hand. Klienten
ansluter till port 70 och skickar en selektor (en sträng som servern
har delat ut tidigare, och som kan vara tom) följd av ett tecken för
vagnretur och ett för radmatning, och servern svarar och stänger
anslutningen. Servern minns ingenting mellan två förfrågningar:
ingen session, ingen cookie, inga headers. En tom selektor ber om
serverns översta meny.

Menyn är kärnan i det hela. Varje rad i en meny är ett objekt, som
består av ett enda typtecken, en visningssträng och sedan en
selektor, ett värdnamn och en port, åtskilda av tabbar. En rad som
bara innehåller en punkt avslutar menyn. Här är en liten meny, med
varje tabb skriven som `<TAB>`:

```text
0About this server<TAB>/about.txt<TAB>example.org<TAB>70
1Reports<TAB>/reports<TAB>example.org<TAB>70
7Search the reports<TAB>/search<TAB>example.org<TAB>70
i.		engineer.company	70
```

Typtecknet talar om för klienten vad den kommer att få innan den
frågar. RFC 1436 definierar `0` för en textfil, `1` för en annan
meny, `7` för en sökning som tar emot en fråga, `9` för en binärfil,
`g` för en GIF-bild och en handfull till. Två typer som används
brett i dag kommer från praxis snarare än från RFC:n: `i` för en rad
vanlig text som visas inuti en meny, och `h` för ett HTML-dokument,
som klienter också använder för att lämna över en webbadress till en
webbläsare.

Designen är medvetet liten. RFC 1436 har ett avsnitt med rubriken
”Simplicity is intentional”, och den är en RFC av typen
Informational, inte en internetstandard. Adressformatet `gopher://`
kom senare, i RFC 4266, där det första tecknet i sökvägen är
objekttypen och resten är selektorn.

Varför det spelar roll

Gopher betyder i dag mindre som ett sätt att nå en stor publik än
som en tydlig bild av vad ett dokument behöver och vad det klarar
sig utan. En meny är navigering skalad ned till skelettet: varje väg
ut från en sida är listad, typad och står på en egen rad, och inget
döljs bakom en hovring eller ett skript. Att publicera där tvingar
fram frågor som HTML låter en skribent skjuta upp. Vad heter den här
sidan? Vilka är dess verkliga länkar? Är texten fortfarande
begriplig när länkarna har tagits bort ur den?

För en organisation är ett Gopher-hål en extra ytterdörr, aldrig en
ersättning för webben. Läsarna behöver en särskild klient, och de är
få. Vad dörren kostar beror helt på hur den byggs. Underhållen för
hand som en andra kopia av webbplatsen glider den isär första gången
den ena kopian redigeras och den andra glöms bort. Genererad från
samma källa av samma bygge kostar den en mall och lite diskutrymme,
och den fungerar framför allt som ett stresstest av texten.

Det andra att förstå är säkerheten. Gopher har inget lager för
kryptering. Varje selektor, och därmed varje sida som en läsare ber
om, korsar nätverket i klartext, och det gör varje svar också. RFC
1436 har inget för inloggning, och den fråga som en läsare skriver
in i ett sökobjekt färdas också i klartext. Det är acceptabelt för
publika dokument och fel för allt annat, och det betyder att
operatörens egna loggar förtjänar lika mycket eftertanke som
innehållet.

Det är också billigt att felsöka. Eftersom det varken finns TLS,
headers eller tillstånd visar en enda kommandorad exakt vilka byte
en klient tar emot, vilket gör Gopher-kopian till en av de versioner
av en webbplats som är enklast att kontrollera.

Så ser det ut i praktiken

Den här webbplatsen är ett Gopher-hål lika väl som en webbplats.
Sidan Engineer i en terminal ger adressen,
`gopher://engineer.company/`, beskriver Gopher som ett menyprotokoll
från 1991 med ren TCP, ingen kryptering och inga skript, och säger
att webbplatsen där är en uppsättning menyer, en per katalog. Den
nämner Lynx, Bombadillo och gopher-cli som klienter och visar en
förfrågan som görs för hand med `printf` och `nc` på port 70, hela
protokollet på en rad.

Bygget bakom det beskrivs i redogörelsen för hur webbplatsen
speglades till Gemini och Gopher. Samma bygge som skriver HTML-koden
skrev också 777 Gopher-menyer i det dokumenterade
implementeringsskedet, driftsatta i samma träd och serverade av en
liten daemon på samma värddator. En menyrad är en uppsättning
tabbseparerade fält, så det finns inget sätt att placera en länk
inuti en mening, och prosan radbryts hårt vid sextioåtta kolumner
medan webbplatsen byggs. Att arbeta inom den ramen skärpte texten.

Mallarna visar hur varje sida blir en meny. Länkar inuti texten
behåller sina ord och förlorar sina mål, rubriker förlorar sina
brädgårdstecken, listpunkter blir indragna asterisker och prosan
radbryts vid 68 kolumner. Kod är undantaget och passerar utan
radbrytning, eftersom en kodrad som bryts vid kolumn 68 är ett annat
program. Kategorier och tjänster blir objekt av typen `1` som pekar
på sina egna menyer, och längst ned på varje sida finns ett
`h`-objekt vars selektor `URL:` leder till webbversionen av samma
sida.

Att driva ett Gopher-hål lärde också webbplatsen något om loggar.
Sidan Integritet förklarar att webbplatsen sedan september 2026 bara
räknar hur många förfrågningar Gemini- och Gopher-kopiorna besvarade
varje dag, och inget mer: ingen adress, ingen sida, ingen besökare.
Den dag räkningen började visade det sig att operativsystemet
startar Gopher-kopian på nytt för varje besökare och döper det
ögonblicket efter den adress besökaren kom från, i en egen logg. Den
loggen rensas nu efter trettio dagar, som allt annat som webbplatsen
sparar.

Var det går fel

En sida stannar halvvägs och listar katalogen

En läsare öppnar en sida och får den första halvan av den, följd av
en lista över filerna i mappen. Servrar som Gophernicus läser en
gophermap innan de skickar den, och en rad utan tabbar vars första
tecken är ett av deras direktiv behandlas som en instruktion: `#`
döljer den som en kommentar, `=` tar in en annan fil, och `*` eller
`.` stoppar menyn. Den här webbplatsen stötte på det när en rad CSS
i dess ukrainska anteckning om understrykningar i Safari började med
den stjärna som avslutar en CSS-kommentar, och servern i drift
klippte sidan där och skrev ut index.html, index.md och index.gmi i
stället. Skriv varje sådan rad som ett uttryckligt `i`-objekt, och
låt bygget misslyckas på varje naken rad som fortfarande börjar med
ett direktivtecken.

Märkning och entiteter kommer fram som text

Ett stycke dyker upp som en enda mycket lång rad full av
vinkelparenteser, eller med ett et-tecken som fortfarande är
utskrivet som sin HTML-entitet. Konverteraren kopierade HTML till
ett format som inte har någon aning om vad HTML är. Ta bort taggarna
men behåll länktexten, avkoda entiteterna och låt inline-kod vara i
fred så att dess symboler överlever.

Raderna rinner över högerkanten

Prosan rinner ut utanför skärmen, eller så klipps visningssträngar
mitt i ett ord. Gopher-klienter är inte skyldiga att bryta om
någonting, och RFC 1436 ber om visningssträngar på under 70 tecken.
Radbryt prosan under bygget, korta menyetiketter avsiktligt och håll
koden utanför radbrytningen.

En länk hämtar fel sak

En `gopher://`-adress öppnar ett felmeddelande eller ett objekt som
inte hör dit. RFC 4266 läser det första tecknet i sökvägen som
objekttypen, så `gopher://example.org/reports` ber om typen `r` och
selektorn `eports`. Sätt typen framför selektorn, som i
`gopher://example.org/1/reports`, och kopiera adresser från en meny
som fungerar i stället för att skriva in dem.

Läslistan färdas i klartext

Varje sida som en läsare öppnar syns för alla längs nätverksvägen,
och kanske i loggar som ingen hade tänkt spara. Publicera bara det
som skulle gå bra på ett vykort, läs loggarna för hela maskinen och
inte bara daemonens, och ge var och en av dem ett utgångsdatum.

Läs mer

  * RFC 1436: The Internet Gopher Protocol — den ursprungliga
beskrivningen: cykeln med förfrågan och svar, menyraderna,
objekttyperna och skälen till att hålla det enkelt.

  * RFC 4266: The gopher URI Scheme — hur en `gopher://`-adress
kodar värdnamn, port, objekttyp och selektor.

  * IANA Service Name and Transport Protocol Port Number Registry —
den officiella registreringen av port 70 som porten för Gopher.

  * Gophernicus — källkod och dokumentation för en aktuell
Gopher-server, inklusive det gophermap-format som den läser.

hDen här sidan på webben	URL:https://engineer.company/sv/glossary/gopher/	engineer.company	70
