/*
 * example.conf by Daniel Hawton AKA Osiris (osiris@unrealircd.org).
 * $Id: example.conf,v 1.1.1.1.2.24 2009/04/13 11:03:55 syzop Exp $
 *
 * Works for Unreal3.2 and up
 *
 * Okay guys.  This is the new example.conf. Its look is much like C++, kinda.
 * Anyway it is time to go over this.  It's hard to pick up at first, but
 * with some pratice and reading you'll understand.
 *
 * Just copy this file to your main unrealircd dir and call it 
'unrealircd.conf'.
 *
 * NOTE:  All lines, except the opening { line, end in an ;, including the
 * closing } line. The IRCd will ignore commented lines.
 *
 * PLEASE READ doc/unreal32docs.html! The online version is also available at:
 * www.vulnscan.org/UnrealIRCd/unreal32docs.html
 * It contains a lot information about the configfile: gives information about
 * every block, variable, etc..
 * If you try to edit this file without reading the documentation properly
 * then you are pretty much guaranteed to fail!
 */

/* Type of comments */
#Comment type 1 (Shell type)
// Comment type 2(C++ style)
/* Comment type 3 (C Style) */
#those lines are ignored by the ircd.

/*
 * UnrealIRCd supports modules, loading some of them is required.
 * You need at least the commands module and a cloaking module.
 */

/* FOR *NIX, uncomment the following 2lines: */
loadmodule "src/modules/commands.so";
loadmodule "src/modules/cloak.so";

/* FOR Windows, uncomment the following 2 lines: */
//loadmodule "modules/commands.dll";
//loadmodule "modules/cloak.dll";

/*
 * You can also include other configuration files.
 * help.conf contains all the /helpop text. The badwords.*.conf
 * files contain all the badword entries for mode +G...
 * spamfilter.conf contains some good rules for current trojans.
 * You probably want to include them:
 */
include "help.conf";
include "badwords.channel.conf";
include "badwords.message.conf";
include "badwords.quit.conf";
include "spamfilter.conf";

/*
 * NEW: me {}
 * OLD: M:Line
 * me {} defines the name, description and unreal server numeric for
 * this server. Syntax is as follows:
 * me {
 *  name "server.name";
 *  info "Server Description";
 *  numeric (server numeric*);
 * };
 * If linking, this numeric may not be used by any other server on the network.
 */
me
{
        name "safe.ircd.com";
        info "The Server";
        numeric 1;
};

/*
 * NEW: admin {}
 * OLD: A:Line
 * Admin gives information on the server admin. you
 * may put as many lines under admin { as you wish.
 * Syntax is as follows:
 * admin {
 *   "first line";
 *   "second line";
 *   [etc]
 * };
 */
admin {
        "Geox";
        "Geox";
        "widely@used.name";
};

/*
 * NEW: class {}
 * OLD: Y:line (old was confusing)
 * These define settings for classes. A class is a group setting for
 * connections. Example, server connections, instead of going to a client's
 * class, you direct it to the server class. Syntax is as follows
 * class (class name)
 * {
 *     pingfreq (how often to ping a user/server in seconds);
 *     maxclients (how many connections for this class);
 *     sendq (maximum send queue from a connection);
 *     recvq (maximum receive queue from a connection [flood control]);
 *  };
 */

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

class           servers
{
        pingfreq 90;
        maxclients 10;          /* Max servers we can have linked at a time */
        sendq 100000;
        connfreq 100; /* How many seconds between each connection attempt */
};

/*
 * NEW: allow {}
 * OLD: I:Line
 * This defines allowing of connections...
 * Basically for clients, it allows them to connect so you can have some
 * control and/or set a password.
 * Syntax is as follows:
 * allow {
 *    ip (ip mask to allow);
 *    hostname (host mask);
 *    class (class to send them to [see class {}]);
 *    password "(password)"; (optional)
 *    maxperip (how many connections per ip); (optional)
 * };
 */

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

/* Passworded allow line */
allow {
        ip             *@255.255.255.255;
        hostname       *@*.passworded.ugly.people;
        class           clients;
        password "f00Ness";
        maxperip 1;
};

/*
 * NEW: allow channel {}
 * OLD: chrestrict
 * Allows a user to join a channel...
 * like an except from deny channel.
 * Syntax:
 * allow channel {
 *   channel "channel name";
 * };
 */
allow           channel {
        channel "#X";
};

/*
 * NEW: oper {}
 * OLD: O:Line
 * Defines an IRC Operator
 * IRC operators are there to keep sanity to the server and usually keep 
it
 * maintained and connected to the network.
 * The syntax is as follows:
 * oper (login) {
 *     class (class to put them in, if different from I, moves them to 
new
 *                class);
 *     from {
 *        userhost (ident@host);
 *        userhost (ident@host);
 *     };
 *     flags
 *     {
 *       (flags here*);
 *     };
 *     OR
 *     flags "old type flags, like OAaRD";
 * };
 */


/* For a list of oper flags, see doc/unreal32docs.html#operblock
 * [HIGHLY recommended to read]
 */

oper Geox {
        class           clients;
        from {
                userhost *@* ;
        };
        password "$Tj4W3m8C$c+22RU44552NK2VUL7BUg==";
        flags
        {
                netadmin;
                can_zline;
                can_gzline;
                can_gkline;
                global;
        };
};



/*
 * NEW: listen {}
 * OLD: P:Line
 * This defines a port for the ircd to bind to, to
 * allow users/servers to connect to the server.
 * Syntax is as follows:
 * listen (ip number):(port number)
 * {
 *   options {
 *     (options here);
 *   };
 * };
 * or for a plain
 * listen: listen (ip):(port);
 *
 * NOTICE: for ipv6 ips (3ffe:b80:2:51d::2 etc), use listen [ip]:port;
 *
 * That works also.
 */

/* Options for listen:
        OLD     |       NEW
        S               serversonly
        C               clientsonly
        J               java
        s               ssl
        *               standard
*/

/* NOTE ON SSL PORTS: SSL ports are pretty non-standardized,
 * besides numerous high-SSL ports, some people say you should run
 * it at 994 because that's the official SSL port.. but that
 * requires root! Besides, port 194 is the official irc port and
 * have you ever seen an ircd running on that?
 * So, our suggestion is to use port 6697 for SSL, this is used by
 * quite some networks and is recognized by for example StunTour.
 * You are free to open up as many SSL ports as you want, but
 * by (also) using 6697 you help the world standardize a bit ;).
 */
/*listen         *:6697
 *{
 *      options
 *      {
 *              ssl;
 *              clientsonly;
 *      };
};*/

 /*listen         *:8067;*/
listen         *:3303;

/* NOTE: If you are on an IRCd shell with multiple IP's you are
 *       likely to get 'Address already in use' errors in your log
 *       and the ircd won't start. This means you MUST bind
 *       to a specific IP instead of '*', so for example:
 *       listen 1.2.3.4:6667;
 *       Obviously, replace the IP with the IP that was assigned to you.
 */

/*
 * NEW: link {}
 * OLD: C/N:Lines
 * This defines an okay for a server connection.
 * NOTE: BOTH SERVERS NEED A LINK {} SETTING TO CONNECT PROPERLY!
 * Syntax is as follows:
 * link (server name)
 * {
 *      username        (username, * works too);
 *      hostname        (ip number/hostmask);
 *      bind-ip         (What IP to bind to when connecting, or *);
 *      port            (port to connect to, if any);
 *      hub (If this is a hub, * works, or servermasks it may bring in);
 *      [or leaf *;]
 *      password-connect "(pass to send)";
 *      password-receive "(pass we should receive)";
 *      class           (class to direct servers into);
 *      options {
 *              (options here*);
 *      };
 *      // If we use SSL, we can choose what cipher to use in SSL mode
 *      // Retrieve a list by "openssl ciphers", separate ciphers with 
:'s
 *
 *      ciphers "DES-CBC3-MD5";
 *
 * };
*/

/*
        options:
        OLD     |       NEW
        S               ssl
        Z               zip
        N/A             autoconnect
        N/A             quarantine
        N/A             nodnscache
*/

#link            ircd.com
#{
#        username        *;
#        hostname        95.110.133.78;
#        bind-ip         *;
#        port            53;
#        hub             *;
#        password-connect "server";
#        password-receive "server";
#        class           servers;
#                options {
#                        /* Note: You should not use autoconnect when linking services */
#                        autoconnect;
#/*                      ssl;*/
#/*                      zip;*/
#                };
#};

/*link            services.ircd.com
*{
*        username        *;
*        hostname        127.0.0.1;
*        bind-ip         *;
*        port            3303;
*        hub             *;
*        password-connect "services";
*        password-receive "services";
*        class           servers;
*                options {
*                        /* Note: You should not use autoconnect when linking services */
*                        autoconnect;
/*                      ssl;*/
/*                      zip;*/
*                };
*};
*/



/*
 *
 * NEW: ulines {}
 * OLD: U:Line
 * U-lines give servers more power/commands, this should ONLY be set
 * for services/stats servers and NEVER for normal UnrealIRCd servers!
 * Syntax is as follows:
 * ulines {
 *      (server to uline);
 *      (server to uline);
 *  [etc]
 * };
*/
ulines {
#        services.ircd.com;
};

/*
 * NEW: drpass {}
 * OLD: X:Line
 * This defines the passwords for /die and /restart.
 * Syntax is as follows:
 * drpass {
 *  restart             "(password for restarting)";
 *  die                 "(password for die)";
 * };
 */
drpass {
        restart "restart";
        die "die";
};

/*
 * NEW: log {} OLD: N/A Tells the ircd where and what to log(s). You can 
have
 * as many as you wish.
 *
 * FLAGS: errors, kills, tkl, connects, server-connects, kline, oper
 *
 * Syntax:
 * log "log file"
 * {
 *    flags
 *    {
 *        flag;
 *        flag;
 *        etc..
 *    };
 * };
 */

log "ircd.log" {
        /* Delete the log file and start a new one when it reaches 2MB, leave this out to always use the
           same log */
        maxsize 2097152;
        flags {
                oper;
                kline;
                connects;
                server-connects;
                kills;
                errors;
                sadmin-commands;
                chg-commands;
                oper-override;
                spamfilter;
        };
};

/*
 * NEW: alias {}
 * OLD: N/A
 * This allows you to set command aliases such as /nickserv, /chanserv 
etc
 * FLAGS: services, stats, normal
 *
 * Syntax:
 * alias "name" {
 *      target "points to";
 *      type aliastype;
 * };
 *
 * [NOTE: You could also include a pre-defined alias file here, see 
doc/unreal32docs.html section 2.9]
 */

// This points the command /nickserv to the user NickServ who is connected to the set::services-server server
/*alias NickServ {
        target "NickServ";
        type services;
};*/

// If you want the command to point to the same nick as the command, you can leave the nick entry out
//alias ChanServ { type services; };

// Points the /statserv command to the user StatServ on the set::stats-server server
//alias StatServ { type stats; };

// Points the /superbot command to the user SuperBot
//alias SuperBot { type normal; };


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

/*
 * NEW: alias {}
 * OLD: N/A
 * This allows you to set command aliases such as /identify, /services, etc
 *
 * Syntax:
 * alias "name" {
 *      format "format string" {
 *              target "points to";
 *              type aliastype;
 *              parameters "parameters to send";
 *      };
 *      type command;
 * };
 */
/* This is shown seperately because even though it has teh same name as the previous directive, it is very
 * different in syntax, although it provides a similar function and relys on the standard aliases to work.
 */
/*
alias "identify" {
        format "^#" {
                target "chanserv";
                type services;
                parameters "IDENTIFY %1-";
        };
        format "^[^#]" {
                target "nickserv";
                type services;
                parameters "IDENTIFY %1-";
        };
        type command;
};
*/
/* The alias::format directive is a regular expression. The first format matches the /identify command when
 * the first character is a #. It then passes this along to the chanserv alias with the parameters IDENTIFY
 * %1-. The second format matches then /identify command when the first character is not a #. It then
 * passes the command to the nickserv alias with parameters IDENTIFY %1-.
 */

/* The alias::format::parameters is similar to scripting languages. %N (where N is a number) represents a
 * parameter sent to the command (in this case /identify). If you specify %N- it means all parameters from
 * N until the last parameter in the string. You may also specify %n which is replaced by
 * the user's nickname.
*/

/* Standard aliases */
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;
};

/* This is an example of a real command alias */
/* This maps /GLINEBOT to /GLINE <parameter> 2d etc... */
alias "glinebot" {
        format ".+" {
                command "gline";
                type real;
                parameters "%1 2d Bots are not allowed on this server, please read the faq at http://www.example.com/faq/123";
        };
        type command;
};



/*
 * NEW: tld {}
 * OLD: T:Line
 * This sets a different motd and rules files
 * depending on the clients hostmask.
 * Syntax is as follows:
 * tld {
 *    mask (ident@host);
 *    motd "(motd file)";
 *    rules "(rules file)";
 * };
 */

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

/* note: you can just delete the example block above,
 * in which case the defaults motd/rules files (ircd.motd, ircd.rules)
 * will be used for everyone.
 */

/*
 * NEW: ban nick {}
 * OLD: Q:Line
 * Bans a nickname, so it can't be used.
 * Syntax is as follows:
 * ban nick {
 *      mask "(nick to ban)";
 *      reason "(reason)";
 * };
*/
ban nick {
        mask "*C*h*a*n*S*e*r*v*";
        reason "Reserved for Services";
};
/*
 * NEW: ban ip {}
 * OLD: Z:Line
 * Bans an ip from connecting to the network.
 * Syntax:
 * ban ip { mask (ip number/hostmask); reason "(reason)"; };
*/
ban ip {
        mask 195.86.232.81;
        reason "Delinked server";
};
/*
 * NEW: ban server {}
 * OLD: Server Q:Line
 * Disables a server from connecting to the network.
 * if the server links to a remote server, local server
 * will disconnect from the network.
 * Syntax is as follows:
 * ban server {
 *      mask "(server name)";
 *      reason "(reason to give)";
 * };
*/

ban server {
        mask eris.berkeley.edu;
        reason "Get out of here.";
};
/*
 * NEW: ban user {}
 * OLD: K:Line
 * This makes it so a user from a certain mask can't connect
 * to your server.
 * Syntax:
 * ban user { mask (hostmask/ip number); reason "(reason)"; };
*/

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

/*
 * NEW: ban realname {}
 * OLD: n:Line
 * This bans a certain realname from being used.
 * Syntax:
 * ban realname {
 *      mask "(real name)";
 *      reason "(reason)";
 * };
*/

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

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

/*
 * NOTE FOR ALL BANS, they may be repeated for addition entries!
 *
 * NEW: except ban {}
 * OLD: E:Line
 * This makes it so you can't get banned.
 * Syntax:
 * except ban { mask (ident@host); };
 * Repeat the except ban {} as many times
 * as you want for different hosts.
 */

except ban {
        /* don't ban stskeeps */
        mask           *Gex@*;
};

/*
 * NEW: deny dcc {}
 * OLD: dccdeny.conf
 * Use this to block dcc send's... stops
 * viruses better.
 * Syntax:
 * deny dcc
 * {
 *   filename "file to block (ie, *exe)";
 *   reason "reason";
 * };
 */
deny dcc {
        filename "*sub7*";
        reason "Possible Sub7 Virus";
};

/*
 * NEW: deny channel {}
 * OLD: N/A (NEW)
 * This blocks channels from being joined.
 * Syntax:
 * deny channel {
 *      channel "(channel)";
 *      reason "reason";
 * };
*/
deny channel {
        channel "*warez*";
        reason "Warez is illegal";
};

/*
 * NEW: vhost {}
 * OLD: Vhost.conf file
 * This sets a fake ip for non-opers, or
 * opers too lazy to /sethost :P
 * Syntax:
 *   vhost {
 *       vhost (vhost.com);
 *       from {
 *            userhost (ident@host to allow to use it);
 *       };
 *       login (login name);
 *       password (password);
 *   };
 *        then to use this vhost, do /vhost (login) (password) in IRC
 */
vhost {
        vhost           localhost;
        from {
                userhost       *@*;
        };
        login           Geox;
        password        Geox;
};

/* You can include other configuration files */
/* include "klines.conf"; */

/* Network configuration */
set {
        network-name            "ircd";
        default-server          "ircd.com";
        services-server         "services.ircd.com";
        stats-server            "stats.ircd.com";
        help-channel            "#X";
        hiddenhost-prefix       "no";
        /* prefix-quit          "no"; */
        /* Cloak keys should be the same at all servers on the network.
         * They are used for generating masked hosts and should be kept 
secret.
         * The keys should be 3 random strings of 5-100 characters
         * (10-20 chars is just fine) and must consist of lowcase (a-z),
         * upcase (A-Z) and digits (0-9) [see first key example].
         * HINT: On *NIX, you can run './unreal gencloak' in your shell 
to let
         *       Unreal generate 3 random strings for you.
         */
        cloak-keys {
                "KYr1v0056270B1E";
                "U3BsCA8t3BRE3Y85";
                "8tPkpa8NF2iBf8G3J";
        };
        /* on-oper host */
        hosts {
                local           "localhost";
                global          "localhost";
                coadmin         "coadmin.ircd.com";
                admin           "admin.ircd.com";
                servicesadmin   "csops.ircd.com";
                netadmin        "netadmin.ircd.com";
                host-on-oper-up "yes";
        };
};

/* Server specific configuration */

set {
        kline-address "sugipula@yahoo.com";
        modes-on-connect "+iw";
        modes-on-oper    "+wgs";
        modes-on-join    "+mus";
        oper-auto-join "#X";
        options {
                hide-ulines;
                /* You can enable ident checking here if you want */
                /* identd-check; */
                show-connect-info;
        };

        maxchannelsperuser 10;
        /* The minimum time a user must be connected before being allowed to use a QUIT message,
         * This will hopefully help stop spam */
        anti-spam-quit-message-time 10s;
        /* Make the message in static-quit show in all quits - meaning no
           custom quits are allowed on local server */
        /* static-quit "Client quit";   */

        /* You can also block all part reasons by uncommenting this and 
say 'yes',
         * or specify some other text (eg: "Bye bye!") to always use as 
a comment.. */
        /* static-part yes; */

        /* This allows you to make certain stats oper only, use * for 
all stats,
         * leave it out to allow users to see all stats. Type '/stats' 
for a full list.
         * Some admins might want to remove the 'kGs' to allow normal 
users to list
         * klines, glines and shuns.
         */
        oper-only-stats "okfGsMRUEelLCXzdD";

        /* Throttling: this example sets a limit of 3 connection 
attempts per 60s (per host). */
        throttle {
                connections 3;
                period 60s;
        };

        /* Anti flood protection */
        anti-flood {
                nick-flood 3:60;        /* 3 nickchanges per 60 seconds 
(the default) */
        };

        /* Spam filter */
        spamfilter {
                ban-time 1d; /* default duration of a *line ban set by 
spamfilter */
                ban-reason "Spam/Advertising"; /* default reason */
                virus-help-channel "#help"; /* channel to use for 
'viruschan' action */
                /* except "#help"; channel to exempt from filtering */
        };
};

/*
 * Problems or need more help?
 * 1) www.vulnscan.org/UnrealIRCd/unreal32docs.html
 * 2) www.vulnscan.org/UnrealIRCd/faq/ <- contains 80% of your 
questions!
 * 3) If you still have problems you can go irc.ircsystems.net 
#unreal-support,
 *    note that we require you to READ THE DOCUMENTATION and FAQ first!
 */