Un servidor Gopher en 9 líneas de Python
No hay mejor forma de aprender una especificación que implementarla.
Hace muy poco he pasado de ser lector ocasional de Gopher a escritor. Poco a poco entiendo el cariño que le tiene su comunidad, y las razones por las que sigue vivo más allá de la nostalgia.
Volviendo al asunto que nos ocupa, soy de esas personas a las que les cuesta trabajar con una tecnología que no entiendo, aunque sea parcialmente. Así que me puse a leer la RFC 1436 (la especificación de Gopher). Navegando por el gopherespacio con comandos de Unix (nc, grep, sed, etc.), y consultando ocasionalmente su especificación, aprendí cómo funciona el protocolo y cómo se implementa. Por ello me decidí a escribir un servidor Gopher en Python. No como medio de sustituir el software existente, que es maduro y estable, sino como un ejercicio más para profundizar.
Como curiosidad, Python tuvo su propia biblioteca para Gopher, gopherlib, que desapareció en Python 2.6. Tampoco la echarás mucho de menos, un servidor cabe en 9 líneas de código.
import socket as Socket
socket = Socket.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0)
socket.setsockopt(Socket.SOL_SOCKET, Socket.SO_REUSEADDR, 1)
socket.bind(("0.0.0.0", 70))
socket.listen(5)
while True:
connection, client_address = socket.accept()
connection.send(str.encode("iHello world\t\tlocalhost\t70\r\n.\r\n"))
connection.close()
Si lo lanzas, y te conectas con un cliente Gopher a gopher://localhost, encontrarás un "Hello world" clásico. Te aviso de que en Linux necesitarás sudo para abrir el puerto 70 por ser un puerto privilegiado.
¡Y ya está!
Vayamos línea por línea, es muy interesante ver cómo funciona Gopher por dentro.
Servidor mínimo
socket = Socket.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0)
socket.setsockopt(Socket.SOL_SOCKET, Socket.SO_REUSEADDR, 1)
socket.bind(("0.0.0.0", 70))
socket.listen(5)
Las primeras líneas son el servidor TCP: crear el socket, escuchar y esperar clientes de uno en uno. Gopher es un protocolo de texto que funciona sobre TCP, así que no hay nada más que hacer. Cada petición es una conexión nueva, y el servidor no recuerda nada de la anterior.
La RFC dice explícitamente que el servidor no guarda estado, lo cual simplifica mucho la implementación: sin cookies, sesiones, autenticación, etc.
Además, no necesita cifrado, así que nos olvidamos de TLS y de certificados. Y escucha en el puerto 70, el que la IANA asignó a Gopher, igual que HTTP tiene el 80.
while True:
connection, client_address = socket.accept()
El bucle infinito atiende a los clientes. accept() se queda esperando hasta que alguien se conecta y nos devuelve connection, un socket para hablar con ese cliente. client_address es su IP y puerto: en este servidor no lo usamos.
connection.send(str.encode("iHello world\t\tlocalhost\t70\r\n.\r\n"))
Gopher no tiene cabeceras ni códigos de estado. Cada respuesta puede ser un menú o un fichero de texto.
En este caso, respondemos con un menú que tiene un único elemento: "Hello world". La línea termina con \r\n, y el menú entero termina con una línea que solo contiene un punto (.). Por lo tanto, estamos enviando dos líneas: la del elemento y la del punto final.
Cada línea de un menú tiene 5 partes:
| Parte | En el ejemplo | Para qué sirve |
|---|---|---|
| Tipo | i |
Un carácter que dice qué es el elemento |
| Texto | Hello world |
Lo que ve el usuario |
| Selector | (vacío) | Lo que enviará el cliente si lo pulsa. En este ejemplo no lo usamos |
| Host | localhost |
El servidor donde vive ese elemento. Podría ser otro si queremos apuntar a otro servidor Gopher |
| Puerto | 70 |
Su puerto |
El tipo, la i en este caso, va pegado al texto. El resto de partes se separan con un tabulador (\t), y la línea termina en \r\n.
El tipo i es una línea informativa: solo texto, sin enlace. Como curiosidad, ¡no aparece en la RFC! Es una extensión que casi todos los clientes aceptan. El resto de tipos irán apareciendo en los siguientes ejemplos.
connection.close()
Por último, cerramos la conexión. Según la RFC, es el servidor quien la cierra tras responder. Una petición, una respuesta, adiós.
El diagrama de secuencia de la interacción con el cliente queda así:
sequenceDiagram
participant C as Cliente
participant S as Servidor (puerto 70)
C->>S: Abre una conexión TCP
C->>S: Selector + CRLF
S->>C: Menú o fichero, terminado en "."
S->>C: Cierra la conexión
Ya tenemos la base del servidor.
Gopher puede devolver menús y ficheros de texto. Ya sabemos devolver un menú: nos falta la segunda parte.
Servir menús y ficheros de texto
Un menú y un fichero son respuestas muy distintas. Un menú son líneas con las 5 partes que acabamos de ver. Un fichero es texto plano, tal cual, terminado en una línea con un punto. Sin tipo, sin tabuladores, sin host.
Pero si no hay cabeceras, ¿cómo sabe el cliente qué va a recibir? Por el tipo del enlace que ha pulsado. Si pulsó un elemento de tipo 1, espera un menú. Si pulsó uno de tipo 0, espera un fichero de texto. El tipo va en el enlace, no en la respuesta.
¿Y qué envía el cliente al pulsar? El selector de esa línea, tal cual, terminado en \r\n. Para el servidor es una cadena opaca: parece una ruta, pero podría ser pepe o 42. Cada servidor la interpreta como quiere. Si llega vacía, el cliente está pidiendo el menú principal.
Con estas piezas montaremos una pequeña navegación. El menú principal tendrá un elemento de tipo 1, "Documents", que lleva a otro menú. Es la pieza central de Gopher: menús que enlazan a menús, como carpetas dentro de carpetas. Dentro habrá un elemento de tipo 0, "About me", con el selector /docs/about.txt. Cuando el usuario lo pulse en su cliente, o lo pida a mano con nc, el servidor recibirá /docs/about.txt\r\n y responderá con el contenido del fichero.
En resumen, el flujo de interacción será el siguiente:
sequenceDiagram
participant C as Cliente
participant S as Servidor
C->>S: "" + CRLF
S->>C: 1Documents TAB /docs TAB localhost TAB 70
S->>C: Cierra la conexión
Note over C: El usuario pulsa "Documents"
C->>S: /docs + CRLF
S->>C: 0About me TAB /docs/about.txt TAB localhost TAB 70
S->>C: Cierra la conexión
Note over C: El usuario pulsa "About me"
C->>S: /docs/about.txt + CRLF
S->>C: Contenido del fichero + "."
S->>C: Cierra la conexión
Y si se pide un selector que no existe, contestaremos con un elemento de tipo 3, que es el tipo de error de la RFC (equivalente a un 40x o 50x de HTTP).
Vamos a la implementación.
Creamos about.txt junto al script:
Hi! I am Bob.
This text file is served over Gopher.
En el servidor, dentro del bucle infinito, leemos la petición del cliente y nos quedamos con su primera línea: el selector. Según su valor, devolvemos un menú, un fichero de texto o un error.
data = connection.recv(1024).decode()
selector = data.split("\r\n")[0]
if selector in ("", "/"):
# El menú principal
response = f"1Documents\t/docs\t{host}\t{port}\r\n.\r\n"
elif selector == "/docs":
# Un submenú
response = f"0About me\t/docs/about.txt\t{host}\t{port}\r\n.\r\n"
elif selector == "/docs/about.txt":
# Servimos el contenido del fichero
with open("about.txt") as file:
response = file.read() + ".\r\n"
else:
# Error
response = f"3Not Found\t\t{host}\t{port}\r\n.\r\n"
connection.send(str.encode(response))
Todo junto queda así:
import socket as Socket
host = "localhost"
port = 70
socket = Socket.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0)
socket.setsockopt(Socket.SOL_SOCKET, Socket.SO_REUSEADDR, 1)
socket.bind(("0.0.0.0", port))
socket.listen(5)
while True:
connection, client_address = socket.accept()
data = connection.recv(1024).decode()
selector = data.split("\r\n")[0]
if selector in ("", "/"):
response = f"1Documents\t/docs\t{host}\t{port}\r\n.\r\n"
elif selector == "/docs":
response = f"0About me\t/docs/about.txt\t{host}\t{port}\r\n.\r\n"
elif selector == "/docs/about.txt":
with open("about.txt") as file:
response = file.read() + ".\r\n"
else:
response = f"3Not Found\t\t{host}\t{port}\r\n.\r\n"
connection.send(str.encode(response))
connection.close()
Hemos movido el host y el puerto a variables para no repetirlos.
Abre gopher://localhost y verás un único elemento, "Documents", que tu cliente marcará como carpeta. Púlsalo y entrarás en un menú nuevo con "About me", un documento de texto. Púlsalo y aparecerá el contenido del fichero, tal cual.
Hemos logrado hacer un flujo de interacción completo, con menús y ficheros de texto.
Ahora vamos a hacer nuestro sitio un poco más interactivo con el tipo 7, el equivalente a un input.
Inputs y búsquedas
Gopher no tiene formularios ni inputs, pero sí un tipo que permite hacer búsquedas: en la RFC se llama Index-Search server. Aunque esté pensado para buscadores, nada nos impide usarlo para cualquier otra cosa.
Un elemento de tipo 7 se escribe igual que cualquier otra línea del menú. Si se pulsa, un cliente debe preguntar al usuario por un texto. Después envía el selector, un tabulador y lo que haya escrito.
Si escribimos "Cat" y el selector es /hello-user, el cliente enviará:
/hello-user\tCat\r\n
Según la RFC, la respuesta a una búsqueda es siempre un menú. Y eso haremos: preguntaremos el nombre del usuario y le devolveremos un menú con una línea informativa que lo salude.
El flujo de interacción será el siguiente:
sequenceDiagram
participant C as Cliente
participant S as Servidor
C->>S: "" + CRLF
S->>C: 7Say hello TAB /hello-user TAB localhost TAB 70
S->>C: Cierra la conexión
Note over C: El usuario pulsa "Say hello" y escribe "Cat"
C->>S: /hello-user TAB Cat + CRLF
S->>C: iHello Cat TAB TAB localhost TAB 70
S->>C: Cierra la conexión
Volvamos a la implementación.
Ahora la primera línea de la petición puede traer dos partes separadas por un tabulador. Con partition("\t") las separamos: a un lado queda el selector y al otro, el texto del usuario. Si no hay tabulador, query queda vacío y todo funciona como antes.
data = connection.recv(1024).decode()
selector, _, query = data.split("\r\n")[0].partition("\t")
if selector in ("", "/"):
# El menú principal, con un elemento de búsqueda
response = f"7Say hello\t/hello-user\t{host}\t{port}\r\n.\r\n"
elif selector == "/hello-user":
# Un menú con el saludo
response = f"iHello {query}\t\t{host}\t{port}\r\n.\r\n"
else:
# Error
response = f"3Not Found\t\t{host}\t{port}\r\n.\r\n"
connection.send(str.encode(response))
Todo junto queda así:
import socket as Socket
host = "localhost"
port = 70
socket = Socket.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0)
socket.setsockopt(Socket.SOL_SOCKET, Socket.SO_REUSEADDR, 1)
socket.bind(("0.0.0.0", port))
socket.listen(5)
while True:
connection, client_address = socket.accept()
data = connection.recv(1024).decode()
selector, _, query = data.split("\r\n")[0].partition("\t")
if selector in ("", "/"):
response = f"7Say hello\t/hello-user\t{host}\t{port}\r\n.\r\n"
elif selector == "/hello-user":
response = f"iHello {query}\t\t{host}\t{port}\r\n.\r\n"
else:
response = f"3Not Found\t\t{host}\t{port}\r\n.\r\n"
connection.send(str.encode(response))
connection.close()
Abre gopher://localhost con tu cliente favorito y verás un único elemento, "Say hello", que tu cliente marcará como búsqueda. Púlsalo y te pedirá un texto. Escribe un nombre, por ejemplo "Cat", y confirma. El servidor te responderá con un menú nuevo: "Hello Cat".
Generando contenido al vuelo
Cada respuesta la escribe nuestro código en el momento, así que nada nos obliga a que sea fija: podemos generar contenido en tiempo real. Por ejemplo, listar lo más votado de la portada de Hacker News.
Usaremos la API de Algolia, que con una sola petición nos devuelve las 10 noticias de la portada con más puntos. Construiremos una línea del menú por cada una.
Cada noticia será un elemento de tipo h, un enlace web. Su selector empieza por URL: seguido de la dirección. Igual que i, no está en la RFC: es otra extensión que la mayoría de clientes entienden.
Las noticias sin enlace externo, como las "Ask HN", apuntarán a su página de discusión.
import json
import socket as Socket
from urllib.request import urlopen
host = "localhost"
port = 70
api = "https://hn.algolia.com/api/v1"
socket = Socket.socket(Socket.AF_INET, Socket.SOCK_STREAM, 0)
socket.setsockopt(Socket.SOL_SOCKET, Socket.SO_REUSEADDR, 1)
socket.bind(("0.0.0.0", port))
socket.listen(5)
while True:
connection, client_address = socket.accept()
data = connection.recv(1024).decode()
selector = data.split("\r\n")[0]
if selector in ("", "/"):
response = f"iMost voted on the Hacker News front page\t\t{host}\t{port}\r\n"
with urlopen(f"{api}/search?tags=front_page&hitsPerPage=10") as page:
stories = json.load(page)["hits"]
for position, story in enumerate(stories, start=1):
discussion = f"https://news.ycombinator.com/item?id={story['objectID']}"
url = story["url"] or discussion
response += f"h{position}. {story['title']}\tURL:{url}\t{host}\t{port}\r\n"
response += ".\r\n"
else:
response = f"3Not Found\t\t{host}\t{port}\r\n.\r\n"
connection.send(str.encode(response))
connection.close()
Entra y verás un título seguido de diez enlaces numerados. Pulsa cualquiera y tu cliente abrirá la noticia en el navegador. Así se veía el 18 de noviembre de 2026:
Most voted on the Hacker News front page
1. Java4Shell: RCE in OpenJDK when processing Base64
2. Quad9's withdrawal from France: A canary in the coal mine
3. Highly classified US national security communications network goes down
4. Nvidia stopped disclosing Singapore sales as revenues hit $104B
5. Google's AI answers reducing search traffic by 40%
6. ID.me terms required for IRS sign-in
7. Phrack 73
8. Microsoft's ONNX Runtime has disappeared from GitHub
9. MAI Code 2 and Code 2 Flash
10. 350 years ago, Ole Rømer discovered that light has a finite speed
El menú se genera en cada petición, así que si vuelves dentro de unas horas verás otras noticias.
Con esto se nos abren infinitas posibilidades: juegos, chats, interacción con LLMs, etc.
Conclusión
Si quieres montar un servidor Gopher más serio, faltarían detalles de la RFC que no hemos abordado, como enviar solo texto ASCII o duplicar los puntos al inicio de línea. Dado que es un ejercicio académico, no merece la pena complicarlo más.
Por mi lado solo me queda decirte que he aprendido mucho, y espero que tú también te hayas divertido. Gopher es un protocolo sencillo, pero con mucho potencial. Y ya que estamos, no sería mala idea empezar a usarlo para tus propios proyectos.
Te leo en el gopherespacio.
- Servidor mínimo
- Servir menús y ficheros de texto
- Inputs y búsquedas
- Generando contenido al vuelo
- Conclusión
Este trabajo está bajo una licencia Attribution-NonCommercial-NoDerivatives 4.0 International.
Ayúdame a seguir escribiendo
Cada café me da un empujón para escribir el siguiente artículo.
¡Claro, te invito!
Comentarios
Todavía no hay ningún comentario.