IRC en FreeBSD vs Linux: diferencias que importan

Mis primeros servidores IRC corrieron en FreeBSD. No por eleccion tecnica consciente — en 2001, la mitad de los operadores de red que conoci usaban FreeBSD porque \"siempre se habia hecho asi\". IRC y BSD tienen una historia compartida que precede a Linux. Cuando IRC nacio en 1988, BSD era el Unix dominante en universidades y centros de investigacion. Los primeros IRCds se desarrollaron en BSD. Las primeras redes grandes (EFnet, Undernet) corrian en servidores BSD. La inercia duro decadas.

Historia: por que IRC y BSD

Jarkko Oikarinen escribio el primer IRCd en la Universidad de Oulu (Finlandia) en un sistema Unix que, como la mayoria de sistemas universitarios de la epoca, era BSD o descendiente de BSD. Los sockets Berkeley — la API de networking que IRC usa — fueron creados para BSD. Literalmente se llaman Berkeley sockets.

Cuando las primeras redes IRC crecieron en los 90, FreeBSD era la opcion obvia para servidores. Tenia el mejor stack de red, era gratuito (a diferencia de SunOS/Solaris comercial), y los administradores de sistemas que mantenian servidores IRC venian del mundo Unix/BSD. Linux existia pero era joven e inestable para produccion de red.

Para mediados de los 2000, Linux alcanzo y supero a FreeBSD en adopcion general. Los IRCds empezaron a ser testeados y optimizados primero para Linux. Hoy, la mayoria de servidores IRC corren en Linux. Pero FreeBSD sigue siendo relevante, especialmente para operadores que valoran la simplicidad del sistema y la calidad del networking.

Networking: kqueue vs epoll

El mecanismo de I/O asincronico es critico para un IRCd. Un servidor IRC necesita gestionar miles de conexiones simultaneas, cada una enviando y recibiendo datos de forma impredecible. El IRCd necesita monitorizar todas estas conexiones eficientemente.

FreeBSD usa kqueue. Linux usa epoll. Ambos resuelven el mismo problema (monitorizar muchos file descriptors), pero con diferente API y diferente implementacion interna.

# kqueue (FreeBSD) — conceptos:
# - Un kqueue es una cola de eventos
# - Los "kevents" describen que monitorizar (lectura, escritura, senal)
# - Una sola llamada a kevent() registra filtros Y recoge eventos
# - Soporta timers, senales, filesystem changes, y sockets en la misma API

# epoll (Linux) — conceptos:
# - Un epoll fd es una lista de interes
# - epoll_ctl() registra/modifica/elimina descriptores
# - epoll_wait() recoge eventos
# - Solo monitoriza I/O; timers y senales requieren APIs separadas
#   (timerfd_create, signalfd)

# En la practica para un IRCd:
# - Ambos manejan 10.000+ conexiones sin problema
# - kqueue es algo mas elegante (API unificada)
# - epoll esta mas optimizado en kernels Linux recientes
# - La diferencia de rendimiento real es insignificante
#   para cargas IRC tipicas

La verdad es que para un IRCd, la diferencia entre kqueue y epoll es academica. Ambos escalan a decenas de miles de conexiones. El bottleneck de un IRCd moderno no esta en el I/O multiplexing — esta en el procesamiento de mensajes, la gestion de buffers, y el ancho de banda de red. Si alguien te dice que \"FreeBSD tiene mejor networking que Linux\", la afirmacion era verdad en 2005. En 2025, ambos son excelentes.

Jails vs containers

Si quieres aislar tu IRCd del resto del sistema (buena practica de seguridad), FreeBSD tiene Jails y Linux tiene containers (Docker/LXC/Podman).

# FreeBSD Jail para IRCd:

# Crear un jail basico:
zfs create zroot/jails/ircd
bsdinstall jail /jails/ircd

# En /etc/jail.conf:
ircd {
  host.hostname = "irc.tudominio.com";
  ip4.addr = "10.0.0.2";
  ip6.addr = "2001:db8::2";
  path = "/jails/ircd";
  mount.devfs;
  exec.start = "/bin/sh /etc/rc";
  exec.stop = "/bin/sh /etc/rc.shutdown";
  allow.raw_sockets;    # Necesario para ICMP (ping)
}

# Iniciar el jail:
service jail start ircd
jexec ircd /bin/sh     # Shell dentro del jail

# Dentro del jail, instalar el IRCd normalmente.
# El jail tiene su propio filesystem, su propia IP,
# y no puede ver ni afectar el sistema host.

# Linux container (Podman/Docker) para IRCd:

# Dockerfile:
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y \
  unrealircd
COPY unrealircd.conf /etc/unrealircd/
EXPOSE 6697
CMD ["unrealircd", "-F"]  # Foreground

# Ejecutar:
podman run -d --name ircd \
  -p 6697:6697 \
  -v ./conf:/etc/unrealircd:ro \
  -v ./data:/var/lib/unrealircd \
  mi-ircd:latest

Los Jails de FreeBSD son mas maduros (existen desde 2000, antes que Docker). Son mas ligeros que Docker (sin capa de imagenes). Pero Docker/Podman tienen un ecosistema enorme de imagenes prebuilt y herramientas de orquestacion. Para un solo IRCd, ambos funcionan. Para un despliegue complejo con multiples servicios, el ecosistema Docker es dificil de superar.

Compilar un IRCd en FreeBSD

# FreeBSD usa pkg (paquetes) o ports (compilacion desde fuente)

# Opcion 1: Paquete binario
pkg install unrealircd
# O:
pkg install inspircd

# Opcion 2: Ports (mas control)
cd /usr/ports/irc/unrealircd
make config    # Seleccionar opciones de compilacion
make install clean

# Opcion 3: Desde fuente (como en Linux)
pkg install git cmake openssl pkgconf
git clone https://github.com/unrealircd/unrealircd.git
cd unrealircd
./Config
make
make install

# Diferencias con Linux:
# - Los headers de OpenSSL estan en /usr/include/openssl (base system)
# - El compilador base es clang, no gcc (funciona igual)
# - Paths por defecto pueden diferir: /usr/local/etc/ vs /etc/
# - rc scripts en vez de systemd:
# /usr/local/etc/rc.d/unrealircd start

# Habilitar al arranque:
sysrc unrealircd_enable="YES"
# Equivalente a systemctl enable en Linux

La compilacion en FreeBSD es generalmente sin problemas. Los IRCds principales (UnrealIRCd, InspIRCd) soportan FreeBSD oficialmente. Los unicos issues que he encontrado son: scripts de deteccion que asumen Linux (buscan systemctl en vez de service), y dependencias que tienen nombres diferentes en pkg vs apt.

PF: el firewall de FreeBSD

FreeBSD usa PF (Packet Filter), originario de OpenBSD. La sintaxis es diferente a iptables/nftables de Linux pero mas legible:

# /etc/pf.conf para un servidor IRC:

# Macros:
tcp_services = "{ 6697, 7000 }"  # 6697=clientes, 7000=servers
icmp_types = "{ echoreq }"        # Permitir ping

# Tablas:
table  persist

# Reglas:
set skip on lo0                   # No filtrar loopback

# Anti-flood:
pass in on egress proto tcp to port 6697 \
  flags S/SA keep state \
  (max-src-conn 10, max-src-conn-rate 5/30, \
   overload  flush global)

# Bloquear IPs en tabla bruteforce:
block in quick from 

# Permitir SSH (para administracion):
pass in on egress proto tcp to port 22

# Permitir IRC clientes:
pass in on egress proto tcp to port $tcp_services

# Permitir ICMP:
pass in on egress inet proto icmp icmp-type $icmp_types

# Permitir todo saliente:
pass out all

# Limpiar tabla periodicamente:
# cron: pfctl -t bruteforce -T expire 86400

# Activar PF:
pfctl -f /etc/pf.conf
sysrc pf_enable="YES"
service pf start

PF es mas expresivo que iptables para reglas de rate-limiting. La clausula overload con max-src-conn-rate es particularmente util para IRC: limita conexiones nuevas por IP y automaticamente anade los abusivos a una tabla de bloqueo. El equivalente en iptables requiere modulos adicionales (-m recent, -m connlimit).

Rendimiento real

He administrado IRCds en ambos sistemas. Mis observaciones (no benchmarks de laboratorio, sino experiencia operativa):

• Para menos de 5.000 usuarios simultaneos, la diferencia de rendimiento es cero. Ambos sistemas manejan esta carga sin sudar.
• FreeBSD tiende a tener latencias de red ligeramente mas predecibles bajo carga. Menos jitter. Esto puede importar para la experiencia de usuario en canales con mucho trafico.
• Linux tiene mejor soporte de hardware y mas drivers. Si tu servidor tiene hardware exotico, Linux es mas seguro.
• FreeBSD consume menos memoria para la misma carga, gracias a un kernel mas pequeño y menos servicios corriendo por defecto.
• Las actualizaciones de seguridad de FreeBSD son menos frecuentes pero mas predecibles. Linux (especialmente con kernels nuevos) requiere mas atencion a parches.

Como elegir

Usa FreeBSD si: ya lo conoces, valoras la simplicidad del sistema, quieres ZFS nativo, o administras una red IRC pura donde el networking es lo unico que importa.

Usa Linux si: necesitas compatibilidad con software variado, quieres Docker/Kubernetes, tu equipo ya sabe Linux, o tu proveedor de hosting lo ofrece por defecto (la mayoria).

No uses ninguno como argumento en una flame war. Ambos son sistemas excelentes para correr un IRCd. La eleccion es casi siempre pragmatica: que conoces mejor, que ofrece tu hosting, que prefiere tu equipo.