# 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
.
```

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 utdata
från 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](/sv/cli/) 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](/sv/portfolio/mirrored-the-site-to-gemini-and-gopher-137/).
Samma bygge som skriver HTML-koden skriver också 777 Gopher-menyer, som driftsätts i samma träd och
serveras av en liten daemon på samma värddator. Redogörelsen namnger den svåraste begränsningen: 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](/sv/privacy/)
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](https://www.rfc-editor.org/rfc/rfc1436) — 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](https://www.rfc-editor.org/rfc/rfc4266) — hur en
  `gopher://`-adress kodar värdnamn, port, objekttyp och selektor.
- [IANA Service Name and Transport Protocol Port Number Registry](https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.xhtml)
  — den officiella registreringen av port 70 som porten för Gopher.
- [Gophernicus](https://github.com/gophernicus/gophernicus) — källkod och dokumentation för en
  aktuell Gopher-server, inklusive det gophermap-format som den läser.

<https://engineer.company/sv/glossary/gopher/>
