/*
 * example.conf por Danial Hawton, alias Osiris (osiris@unrealircd.org).
 * Traducido al castellano por Severus_Snape (javiersnape@gmail.com).
 * 
 * Funciona desde Unreal3.2 hacia adelante
 * 
 * Ok. Este es el nuevo example.conf. Es muy similar a C++.
 * De todas formas lleva tiempo hacer esto. En un principio, es dificil de comprender pero
 * con un poco de práctica y lectura lo comprenderás.
 *
 * Simplemente copia este archivo al directorio principal de unrealircd y cambiale el nombre a 'unrealircd.conf'.
 * 
 * NOTA: Todas las líneas, a excepción de la línea de apertura ( { ) terminan en ;, incluyendo la
 * línea de cierre ( } ). El IRCd ignorará las lineas comentadas.
 *
 * ¡POR FAVOR LEE doc/unreal32docs.es.html! La versión online esta disponible en:
 * www.vulnscan.org/UnrealIRCd/unreal32docs.es.html
 * Contiene mucha información acerca del archivo de configuración: Da información acerca de
 * cada bloque, variable, etc.
 * ¡Si intentas editar este archivo sin leer bien la documentación
 * estas destinado a fallar!
 */

/* Tipos de Comentarios */
#Comentario tipo 1 (Estilo Shell)
// Comentario tipo 2 (Estilo C++)
/* Comentario tipo 3 (Estilo C) */
#Estas líneas son ignoradas por el IRCd.

/*
 * UnrealIRCd soporta módulos, cargar algunos de ellos es requerido.
 * Al menos debes cargar el módulo de los comandos y un módulo de cifrado (cloaking).
 */

/* PARA *NIX, descomenta las siguientes 2 líneas: */
//loadmodule "src/modules/commands.so";
//loadmodule "src/modules/cloak.so";

/* PARA Windows, descomenta las siguientes 2 líneas: */
//loadmodule "modules/commands.dll";
//loadmodule "modules/cloak.dll";

/*
 * Además pudes incluir otros archivos de configuración.
 * help.conf contiene todo el contenido de /helpop. Los archivos badwords.*.conf
 * contienen todas las entradas de badwords para el modo +G...
 * spamfilter.conf contiene algunas buenas reglas para los troyanos actuales.
 * Probablemente quieres incluirlos:
 */
include "help.conf";
include "badwords.channel.conf";
include "badwords.message.conf";
include "badwords.quit.conf";
include "spamfilter.conf";

/*
 * NUEVO: me {} 
 * VIEJO: M:Line 
 * me {} define el nombre, la descripción y el número de servidor
 * para este server. La Sintaxis es: 
 * me { 
 *  name "nombre.del.servidor"; 
 *  info "Descripción del Servidor";
 *  numeric (número del servidor*);
 * }; 
 *  * = Si estas enlazando este server, el número no debe ser usado por otro server en la red.
 */
me
{
	name "irc.foonet.com";
	info "FooNet Server";
	numeric 1;
};

/*
 * NUEVO: admin {} 
 * VIEJO: A:Line
 * /Admin te da la información acerca del administrador del servidor. Tu
 * puedes poner cuantas líneas quieras debajo de admin {.
 * La sintaxis es:
 * admin {
 *   "primera línea"; 
 *   "segunda línea"; 
 *   [etc]
 * };
 */
admin {
	"Bob Smith";
	"bob";
	"widely@used.name";
};

/*
 * NUEVO: class {} 
 * VIEJO: Y:line (old was confusing) 
 * Esto define la configuración para las clases. Una clase es una configuración en grupo para las
 * conexiones. Por ejemplo, las conexiones de los servidores, en vez de ir a la clase de los clientes.
 * la diriges a la clase de servidores. La sintaxis es la siguiente:
 * class (nombre de la clase)
 * {
 *     pingfreq (que tan seguido pingueara a el servidor/cliente en segundos);
 *     maxclients (cuantas conexiones para esta clase);
 *     sendq (cola máxima de envios para la conexión);
 *     recvq (cola máxima de mensajes recibidos desde la conexión [Control de Flood]);
 *  };
 */

class           clients
{
	pingfreq 90;
	maxclients 500;
	sendq 100000;
	recvq 8000;
};

class           servers
{
	pingfreq 90;
	maxclients 10;		/* Cantidad máxima de servers que podemos enlazar a la vez */
	sendq 1000000;
	connfreq 100; /* Cuentos segundos entre cada intento de conexión */
};

/*
 * NUEVO: allow {} 
 * VIEJO: I:Line
 * Esto define los permisos de las conexiones...
 * Fundamentalmente para los clientes, les permite conectarse así tu puedes tener un poco de
 * control y/o poner una contraseña. 
 * La sintaxis es la siguiente: 
 * allow {
 *    ip (IP/IPs a permitir);
 *    hostname (nombre de host);
 *    class (clase asignada a esta conexión [ver class {}]);
 *    password "(contraseña)"; (opcional)
 *    maxperip (cuantas conexiones por IP); (opcional) 
 * };
 */

allow {
	ip             *@*;
	hostname       *@*;
	class           clients;
	maxperip 5;
};

/* allow {} con contraseña */
allow {
	ip             *@255.255.255.255;
	hostname       *@*.gente.fea.con.clave;
	class           clients;
	password "f00Ness";
	maxperip 1;
};

/*
 * NUEVO: allow channel {} 
 * VIEJO: chrestrict 
 * Permite a un usuario unirse a un canal...
 * como una expeción de deny channel.
 * Sintaxis:
 * allow channel {
 *   channel "#nombredelcanal";
 * };
 */
allow           channel {
	channel "#WarezApestan";
};

/*
 * NUEVO: oper {} 
 * VIEJO: O:Line 
 * Define a un Operador de IRC
 * Los Operadores de IRC estan para mantener al servidor "sano" y usualmente
 * mantenerlo y tenerlo conectado a la red. 
 * La sintaxis es la siguiente: 
 * oper (login) { 
 *     class (clase para ponerlos, si es difirente de la que esta en allow {], los mueve a la nueva clase); 
 *     from { 
 *        userhost (ident@host);
 *        userhost (ident@host);
 *     }; 
 *     flags
 *     { 
 *       (las flags aqui*);
 *     };
 *     O
 *     flags "flags antiguas como, OAaRD";
 * };
 */


/* Para una lista de banderas de operador, lea doc/unreal32docs.es.html#operblock
 * [lectura ALTAMENTE recomendada]
 */

oper bobsmith {
	class           clients;
	from {
		userhost bob@smithco.com;
	};
	password "f00";
	flags
	{
		netadmin;
		can_zline;
		can_gzline;
		can_gkline;
		global;
	};
};

/*
 * NUEVO: listen {}
 * VIEJO: P:Line
 * Esto define el puerto/IP a el que el IRCd debe escuchar y unirse, esto
 * permite a los usuarios/servidores conectarse al servidor.
 * La sintaxis es:
 * listen (Dirección IP):(número de puerto) 
 * { 
 *   options {
 *     (opciones aqui);
 *   };
 * };
 * o simplemente
 * listen: listen (ip):(puerto);
 * 
 * NOTA: para IPs IPv6 (3ffe:b80:2:51d::2, etc.), use listen [ip]:puerto;
 * 
 * Eso también funciona.
 */

/* Opciones para listen {}:
	VIEJAS	| 	NUEVAS	| 	SIGNIFICADO
	S		serversonly		Sólo Servidores
	C		clientsonly		Sólo Clientes
	J		java		Sólo Clientes Java
	s		ssl		Conexion Cifrada (SSL)
	*		standard	Standard
*/

/* NOTA EN PUERTOS SSL: Los puertos SSL no están estandarizados,
 * muchos puertos SSL estan en números muy altos, algunas personas dicen que deberias hacerlo
 * en el puerto 994 por que ese es el puerto SSL oficial... ¡pero eso
 * requiere acceso root! Además, el puerto 194 es el puerto oficial de IRC... y
 * has visto alguna vez ver un IRCd corriendo en ese puerto? Usan el 6667.
 * Asi que, nuestra sugerencia es que uses el puerto 6697 para SSL, ese puerto es usado por
 * una cantidad de redes decente y es reconozido por ejemplo: por StunTour.
 * Además eres libre de abrir cuantos puertos SSL quieras, pero
 * correr uno en 6697 ayudaría al mundo a estandarizarlo un poco mas :).
 */
listen         *:6697
{
	options
	{
		ssl;
		clientsonly;
	};
};

listen         *:8067;
listen         *:6667;

/* NOTA: Si estas en shell IRCd con multiples IPs, normalmente
 *       obtendras un error como 'La dirección ya esta en uso/Address already in use' en tus logs
 *       y el IRCd no iniciará. Esto significa que tu DEBES unir el IRCd
 *       a una IP específica en vez de '*', por ejemplo:
 *       listen 1.2.3.4:6667;
 *       Obviamente, reemplaza esa IP con la IP que se te fue asignada.
 */

/*
 * NUEVO: link {}
 * VIEJO: C/N:Lines
 * Esto define los enlazes entre servidores.
 * NOTA: ¡LOS DOS SERVIDORES NECESITAN UN BLOQUE LINK {} PARA ENLAZARSE BIEN!
 * La sintaxis es:
 * link (nombre.del.servidor)
 * {
 *	username	(nombre de usuario, * también funciona);
 * 	hostname	(dirección IP/máscara de host);
 *	bind-ip		(A que IP unirse cuando se estan enlazando, o *);
 *	port		(Puerto al cual conectarse);
 *	hub (Si esto es un hub, * funciona.);
 *	[o leaf *;]
 *	password-connect "(contraseña a enviar)";
 *	password-receive "(contraseña que deberiamos)";
 *	class		(Clase a donde dirigir los servers);
 *	options {
 *		(las opciones van aqui*);
 *	};
 *      // Si tu uses SSL, debes escoger que cifrado usar en el modo SSL
 *      // Obtiene una lista con "openssl ciphers", separa los métodos de cifrados con ":"
 *      
 *      ciphers "DES-CBC3-MD5";
 * 
 * };
*/

/*
	opciones:
	VIEJAS	|	NUEVAS	|	SIGNIFICADO
	S		ssl		Usar SSL
	Z		zip		Comprimir los datos enviados.
	N/A		autoconnect	su servidor intentará conectar automáticamente.
					El tiempo usado entre intentos es el que especificó en class::connfreq
					(se recomienda para un sólo lado, de leaf a hub)
	N/A		quarantine	Aislar
	N/A		nodnscache	No usar Caché DNS (Muy útil para DDNS)
*/


link            hub.mynet.com
{
	username	*;
	hostname 	1.2.3.4;
	bind-ip 	*;
	port 		7029;
	hub             *;
	password-connect "LiNk";
	password-receive "LiNk";
	class           servers;
		options {
			/* Nota: No deberias usar autoconnect cuando conectas servicios */
			autoconnect;
			ssl;
			zip;
		};
};
/*
 *
 * NUEVO: ulines {}
 * VIEJO: U:Line
 * Las ulines {} le dan a los servidores mas poder/comandos, ¡esto SOLO debe ser usado
 * para los servidores de servicios/estadísticas y NUNCA para servidores UnrealIRCd normales!.
 * (Para un buen funcionamiento, todos los servidores deberían tener los mismos U:Lines)
 * La Sintaxis es la siguiente:
 * ulines {
 *	(servidor a ulinear);
 *	(servidor a ulinear);
 *  [etc]
 * };
*/
ulines {
	services.roxnet.org;
	stats.roxnet.org;
};

/*
 * NUEVO: {}
 * VIEJO: X:Line
 * Esto define las contraseñas para /die y /restart.
 * La sintaxis es:
 * drpass { 
 *  restart		"(contraseña para reiniciar)";
 *  die		        "(contraseña para matar al IRCd)";
 * };
 */
drpass {
	restart "amo-reiniciar";
	die "muere-inepto";
};

/*
 * NUEVO: log {} 
 * VIEJO: N/A
 * Le dice al IRCd donde y que loguear. Puedes tener cuantos tu quieras.
 * 
 * FLAGS: errors, kills, tkl, connects, server-connects, oper
 * 
 * Sintaxis: 
 * log "archivo.log" 
 * {
 *    flags
 *    {
 *        flag;
 *        flag; 
 *        etc... 
 *    }; 
 * };
 */

log "ircd.log" {
	/* Borra el archivo e inicia uno nuevo cuando logre 2MB, no uses esto para siempre usar el mismo log */
	maxsize 2097152;
	flags {
		oper;
		connects;
		server-connects;
		kills;
		errors;
		sadmin-commands;
		chg-commands;
		oper-override;
		spamfilter;
	};
};

/*
 * NUEVO: alias {}
 * VIEJO: N/A
 * Esto te permite hacer aliases de comandos como /nickserv, /chanserv, etc.
 * FLAGS: services, stats, normal
 *
 * Sintaxis:
 * alias "nombre" {
 *	target "apunta a";
 *	type aliastype;
 * };
 *
 * [NOTA: Tu también puedes usar un archivo de aliases-predefinidos, lea doc/unreal32docs.es.html sección 2.9]
 */

// Esto apunta el comando a /nickserv a el usuario NickServ el cual esta conectado con el servidor de set::services-server.
/*alias NickServ {
	target "NickServ";
	type services;
};*/

// Si tu quieres el comando que apunta al el mismo nick que el comando, puedes dejar la entrada "nick" vacia.
//alias ChanServ { type services; };

// Apunta el comando /statserv a el usuario StatServ en el servidor set::stats-server.
//alias StatServ { type stats; };

// Apunta el comando /superbot a el usuario SuperBot
//alias SuperBot { type normal; };


/* Aliases Standard */
alias NickServ { type services; };
alias ChanServ { type services; };
alias OperServ { type services; };
alias HelpServ { type services; };
alias StatServ { type stats; };

/*
 * NUEVO: alias {}
 * VIEJO: N/A
 * Esto te permite configurar aliases de comandos como /identify, /services, etc.
 *
 * Sintaxis:
 * alias "nombre" {
 *	format "Formato de la Cadena" {
 *		target "apunta a";
 *              type tipodealias;
 *		parameters "parametros a enviar";
 *	};
 *	type command;
 * };
 */
/* Esto es mostrado separadamente por que hasta tiene el mismo nombre que la directiva anterioir as, es muy diferente en sintaxis,
 * pero provee una función muy similar.
 */
/*
alias "identify" {
	format "^#" {
		target "chanserv";
		type services;
		parameters "IDENTIFY %1-";
	};
	format "^[^#]" {
		target "nickserv";
		type services;
		parameters "IDENTIFY %1-";
	};
	type command;
};
*/
/* La directiva alias::format es una expresión regular. El primer formato coincide con el comando /identify cuando
 * el primer carácter es #. Luego pasa esto a ChanServ con los parámetros IDENTIFY
 * %1-. El segundo formato coincide con /identify cuando el primer caracter no es un #. Entonces
 * el comando pasa a nickserv con los parámetros IDENTIFY %1-.
 */

/* El alias::format::parameters es similar a los lenguajes de scripting. %N (donde N es un número) representa el
 * parámetro enviado al comando (en este caso, /identify). Si especificas %N- significa "todos los parámetros desde
 * N hasta el último parámetro en la cadena". También puedes especificar %n que es reemplazado por el nick del usuario.
*/

/* Aliases Standard */
alias "services" {
	format "^#" {
		target "chanserv";
		type services;
		parameters "%1-";
	};
	format "^[^#]" {
		target "nickserv";
		type services;
		parameters "%1-";
	};
	type command;
};

alias "identify" {
	format "^#" {
		target "chanserv";
		type services;
		parameters "IDENTIFY %1-";
	};
	format "^[^#]" {
		target "nickserv";
		type services;
		parameters "IDENTIFY %1-";
	};
	type command;
};

/* Este es un ejemplo de un alias de comando real */
/* Esto redirije /GLINEBOT a /GLINE <parámetro> Los Bots 2D... */
alias "glinebot" {
	format ".+" {
		command "gline";
		type real;
		parameters "%1 Los Bots 2D no están permitidos en este servidor, para mas información lea la faq en http://www.ejemplo.com/faq/123";
	};
	type command;
};

/*
 * NUEVO: files {}
 * VIEJO: include/config.h
 *
 * Este bloque se sobrepone con el dirctorio principal del IRCd para cargar cosas
 * como el MOTD, el PIPfile, o escribir/cargar el tunefile. La
 * existencia de este bloque permite una instalación de UnrealIRCd a
 * soportar múltiples instancias corriendo cuando es combinado con la opción -c
 * en la línea de comandos.
 *
 * Usualmente. Los directorios relativos son interpretados relativamente a el directorio
 * donde UnrealIRCd encuentra unrealircd.conf si -c -no-
 * es especificado en la línea de comandos.
 */
files
{
	/* El Mensaje del Dia (MOTD - Message of the Day) mostrado a los usuarios que se conectan: */
	/* motd ircd.motd; */

	/*
	 * Un MOTD corto. Si el archivo existe, sera mostrado a
	 * el usuario en vez del MOTD. Los usuarios todavia podrán ver el
	 * MOTD completo usando el comando /MOTD.
	 */
	/* shortmotd ircd.smotd; */

	/* Mostrado cuando un operador usa /OPER y se loguea exitosamente. */
	/* opermotd oper.motd; */

	/* El MOTD de los Servicios. */
	/* svsmotd ircd.svsmotd; */

	/* El MOTD de los Bots */
	/* botmotd bot.motd; */

	/* Las reglas que se muestran al usar /RULES */
	/* rules ircd.rules; */

	/*
	 * Donde el IRCd guarda y carga algunos parámetros que deberían
	 * ser persistentes entre reinicios del servidor. Debe apuntar a un
	 * archivo existente el cual el IRCd tiene permiso para alterarlo o un
	 * archivo en una carpeta donde el IRCd puede crear archivos.
	 */
	/* tunefile ircd.tune; */

	/* Donde guardar el PID del IRCd. Debería ser modificable por el IRCd. */
	/* pidfile ircd.pid; */
};

/*
 * NUEVO: tld {}
 * VIEJO: T:Line
 * Esto configura MOTDs y RULES distintos
 * dependiendo en la máscara de host del cliente.
 * La sintaxis es: 
 * tld {
 *    mask (ident@host);
 *    motd "(archivo-motd)";
 *    rules "(archivo-rules)";
 * };
 */

tld {
	mask *@*.fr;
	motd "ircd.motd.fr";
	rules "ircd.rules.fr";
};

/* NOTA: tu puedes simplemente borrar el bloque de ejemplo aqui arriba,
 * en ese caso los MOTD/RULES normales (ircd.motd, ircd.rules)
 * serán usados para todos.
 */

/*
 * NUEVO: ban nick {}
 * VIEJO: Q:Line
 * Banea a un nick, así no puede ser usado.
 * La sintaxis es la siguiente:
 * ban nick {
 *	mask "(nick a banear)";
 *	reason "(rasón)";
 * };
*/
ban nick {
	mask "*C*h*a*n*S*e*r*v*";
	reason "Reservado para los Servicios";
};
/*
 * NUEVO: ban ip {}
 * VIEJO: Z:Line
 * Banea una IP de conectarse a la red.
 * Sintaxis:
 * ban ip { mask (ip/hostmask); reason "(rasón)"; };
*/
ban ip {
	mask 195.86.232.81;
	reason "Servidor delinkeado";
};
/*
 * NUEVO: ban server {}
 * VIEJO: Server Q:Line
 * Prohibe a un servidor de conectarse a la red.
 * Si el servidor se linkea a un servidor remoto, el servidor local
 * se desconectará de la red.
 * La sintaxis es la siguiente:
 * ban server {
 *	mask "(nombre.del.servidor)";
 *	reason "(Rasón)";
 * };
*/

ban server {
	mask eris.berkeley.edu;
	reason "Fuera de aca.";
};
/*
 * NUEVO: ban user {}
 * VIEJO: K:Line
 * Esto hace que un usuario con una máscara de host determinada no se pueda conectar
 * a tu servidor.
 * Sintaxis:
 * ban user { mask (hostmask/ip); reason "(rasón)"; };
*/

ban user {
	mask *tirc@*.saturn.bbn.com;
        reason "Idiota";
};

/*
 * NUEVO: ban realname {}
 * VIEJO: n:Line
 * Este bloque banea a un determinado realname (nombre real) de ser usado.
 * Sintaxis:
 * ban realname {
 *	mask "(nombre real)";
 * 	reason "(rasón)";
 * };
*/

ban realname {
	mask "Swat Team";
	reason "mIRKFORCE";
};

ban realname {
	mask "sub7server";
	reason "sub7";
};

/*
 * NOTA PARA TODOS LOS BANS, puedes repetirlos para agregar mas!
 * 
 * NUEVO: except ban {} 
 * VIEJO: E:Line
 * Eso hace que no puedas ser baneado.
 * Sintaxis:
 * except ban { mask (ident@host); };
 * Repite el except ban {} cuantas veces quieras
 * para diferentes bans.
 */

except ban {
	/* no banees a stskeeps */
	mask           *stskeeps@212.*;
};

/*
 * NUEVO: deny dcc {} 
 * VIEJO: dccdeny.conf
 * Use este block para denegar DCC SENDs...
 * detiene a los virus mejor.
 * Sintaxis
 * deny dcc 
 * { 
 *   filename "(archivo a bloquear (por ejemplo: *.exe"));
 *   reason ("rasón");
 * };
 */
deny dcc {
	filename "*sub7*";
	reason "Posiblemente un virus Sub7";
};

/*
 * NUEVO: deny channel {}
 * VIEJO: N/A (NUEVO)
 * Esto bloquea canales de ser creados.
 * Sintaxis:
 * deny channel {
 * 	channel "(canal)";
 * 	reason "rasón";
 * };
*/
deny channel {
	channel "*warez*";
	reason "El Warez es ilegal";
};

/*
 * NEW: vhost {}
 * OLD: Vhost.conf file
 * Setea una IP para los no-operadores, o
 * para opers muy flojos para hacer /sethost :P
 * Sintaxis:  
 *   vhost { 
 *       vhost (vhost.com); 
 *       from {
 *            userhost (ident@host.a.permitir.usar.el.vhost);
 *       };
 *       login (nombre del login);
 *       password (contraseña);
 *   };
 *        para usar este vhost, usa /vhost (login) (contraseña) en IRC
 */
vhost {
	vhost           i.hate.microsefrs.com;
	from {
		userhost       *@*.image.dk;
	};
	login           stskeeps;
	password        moocowsrulemyworld;
};

/* Puedes incluir otros archivos de configuración */
/* include "klines.conf"; */

/* Configuración de la red */
set {
	network-name 		"ROXnet";
	default-server 		"irc.roxnet.org";
	services-server 	"services.roxnet.org";
	stats-server 		"stats.roxnet.org";
	help-channel 		"#ROXnet";
	hiddenhost-prefix	"rox";
	/* prefix-quit 		"no"; */
	/* Las llaves de cifrado (cloak keys) deberían ser las mismas en toda la red.
	 * Son usadas para generar hosts "enmascarados" y mantenerlos secretos.
	 * Las llaves deben ser 3 cadenas aleatorias de 5 a 100 carácteres
	 * (de 10 a 20 es aceptable también) y deben tener una minúscula (a-z),
	 * mayúscula (A-Z) y dígitos (0-9) [mira el ejemplo de la primera llave].
	 * CONSEJO: En *NIX puedes ejecutar './unreal gencloak' en tu shell para hacer que
	 *       Unreal genere tres cadenas aleatorias por ti.
	 */
	cloak-keys {
		"aoAr1HnR6gl3sJ7hVz4Zb7x4YwpW";
		"and another one";
		"and another one";
	};
	/* host para los operadores */
	hosts {
		local		"locop.roxnet.org";
		global		"ircop.roxnet.org";
		coadmin		"coadmin.roxnet.org";
		admin		"admin.roxnet.org";
		servicesadmin 	"csops.roxnet.org";
		netadmin 	"netadmin.roxnet.org";
		host-on-oper-up "no";
	};
};

/* Configuración específica del servidor */

set {
	kline-address "configura.este@email";
	modes-on-connect "+ixw";
	modes-on-oper	 "+xwgs";
	oper-auto-join "#opers";
	options {
		hide-ulines;
		/* Puedes habilitar el chequeo de ident si quieres*/
		/* identd-check; */
		show-connect-info;
	};

	maxchannelsperuser 10;
	/* El tiempo mínimo que un usuario debe estar conectado antes de usar un mensaje QUIT,
	 * Esto podria detener el spam */
	anti-spam-quit-message-time 10s;
	/* Hace que el mensaje en static-quit se muestr en todos kis quits - significando que
           no se permiten quits personalizados en este servidor */
	/* static-quit "El Cliente se desconectó";	*/

	/* También puedes bloquear todas las razones de part, descomentando el siguiente comentario y poniendo 'yes',
	 * o especificar otro mensaje (ejemplo: "¡Adiós!") para usar siempre como razón. */
	/* static-part yes; */

	/* Esto permite que pudas hacer algunos comandos de /stats solo para uso de los operadores, use * para ocultar todos los stats,
	 * dejelo en blanco para permitir a los usuarios ver todos los /stats. Escriba '/stats' para una lista completa.
	 * Algunos administradores querrán remover los stats "kGs" para prohibir a los usuarios normales ver los
	 * klines, glines y shuns.
	 */
	oper-only-stats "okfGsMRUEelLCXzdD";

	/* Regulación de Conexiones: este ejemplo setea un límite de 3 intentos de conexión cada 60 segundos (por host). */
	throttle {
		connections 3;
		period 60s;
	};

	/* Protección anti-flood */
	anti-flood {
		nick-flood 3:60;	/* 3 cambios de nick por cada 60 segunos (por defecto) */
	};

	/* Filtro de Spam */
	spamfilter {
		ban-time 1d; /* duración de un *line puesto por spamfilter (filtro de spam) */
		ban-reason "Spam/Publicidad"; /* razón */
		virus-help-channel "#help"; /* canal para usar para la acción "viruchan" */
		/* exceptuar "#help"; el canal "#help" esta libre de filtro */
	};
};

/*
 * Problemas o necesitas mas ayuda?
 * 1) www.vulnscan.org/UnrealIRCd/unreal32docs.es.html
 * 2) www.vulnscan.org/UnrealIRCd/faq/ (en inglés)<- ¡contiene el 80% de tus preguntas!
 * 3) Si sigues teniendo problemas, ve a irc.unrealircd.org #unreal-support,
 *    ¡nótese que NECESITAMOS que leas la DOCUMENTACIÓN y la FAQ antes de preguntarnos!
 */