You are here: Home > Modules > Umod4

How to install UnrealIRCd 4 Modules

How to install 3rd party modules?

In UnrealIRCd 4 you should place the .c file in your src/modules/third/ directory of the UnrealIRCd source directory.

cp somemodule.c /home/irc/unrealircd-4.0.0/src/modules/third

Then from your UnrealIRCd source directory you just run make and make install:

cd /home/irc/unrealircd-4.0.0
make install

UnrealIRCd will automatically detect any .c files in the src/modules/third directory and compile them.

You should no longer use make custommodule, use the method described above instead!

The method from above ensures that when you reconfigure or recompile UnrealIRCd the third party modules will be recompiled as well. Also when you upgrade to a new version, UnrealIRCd 4 will automatically copy the 3rd party modules from your previous UnrealIRCd installation (based on your input of the 1st ./Config question)

All modules should be loaded on all servers, unless otherwise specified

Click HERE to go to the modules download page

Module Description


Allows privileged opers to set TKL exceptions at runtime (like except tkl). Since it's similar to that shit you should always pass it an [email protected] mask. The host bit is the real hostname, or an IP in case of just a GZ:Line exception. These E:Lines persist through a rehash/restart as well cuz they're saved in data/tklexcept.db. Allow certain operclasses to use it by simply adding a top-level privilege eline.

Config block:

operclass netadmin-eline {
    parent netadmin;
    privileges {

ELINE <typeflags> <[-]mask>

The - is obviously there so you can remove them too. ;] You can also use just /eline to view the built-in halp and /stats E to view all exceptions (this was already there).

Typeflags list (they're the same as except tkl):

  • G => G:Line
  • Z => Global Z:Line
  • Q => Global Q:Line
  • s => Shun
  • q => Local Q:Line


  • /ELINE GZQsq *@*.lan => Set an exception on all types for everyone on a LAN domain.
  • /ELINE GZ *@*.lan => Set an exception on G(Z):Lines for everyone on a LAN domain.
  • /ELINE * *@*.lan => Set an exception on all types for everyone on a LAN domain.
  • /ELINE * -*@*.lan => Remove an exception for all types. The mask should be an exact match (i.e. it doesn't do a wildcard match).


Adds a chanmode +j <delay> to prevent people from rejoining too fast after a kick. You can set a delay of between 1 and 20 seconds, as anything higher might be a bit much lol. You gotta have at least +o to set this shit. Opers and U:Lines are exempt, as well as servers (cuz just in case lol).

Updated shit:

  • Store the ModData struct with the client instead of channel to preserve memory (muh lifetimes lol)

m_commandsno (PORTED)

Guess who originally wrote this one?
Adds a snomask +C for opers so they can see what commands people use. ;3 Specify what commands may be monitored in the config, then set the snomask with /mode <nick> +s +C (or extend set::snomask-on-oper).

Config block:
I've kept the "location" the same as the original one but I did rename the directive. It's simply a comma-delimited list of commands. ;]

set {
    // Rest of the set block goes here obv, like kline-address, network-name, etc
    commandsno "version,admin,module";

m_clones (PORTED)

Yay for AngryWolf. =]
Adds a command /CLONES to list all users having the same IP address matching the given options. Clones are listed by a nickname or by a minimal number of concurrent sessions connecting from the local or the given server.

I made one change, which is instead of having /helpop clones (which requires you to add a block to all servers' help.conf files) you can now view a built-in halp thingay. =]

CLONES <min-num-of-sessions|nickname> [server]

Some examples:

  • /clones 2 => Lists local clones having 2 or more sessions
  • /clones Loser => Lists local clones of Loser
  • /clones 3 => Lists all clones with at least 3 sessions, which are connecting from
  • /clones => View built-in halp

m_operpasswd (PORTED)

Another port of one of AngryWolf's modules. =]
This basically lets you see the username and password for a failed OPER attempt, you gotta set an extra snomask flag to see them though. You can do this wit /mode <nick> +s +O or just use it in set::snomask-on-oper.

I made some changes to this module as it relied on "netadmins" which Unreal 4.x doesn't have n0 m0ar. So I came up with a new operclass privilege to indicate who is able to set the snomask. You also had to explicitly enable the snomask in the 3.x version, but it's now enabled by default. ;]

Config blocks:

operclass netadmin-operpasswd {
    parent netadmin;
    privileges {

operpasswd {
    enable-global-notices 1;
    enable-logging 0;
    max-failed-operups 3;
    failop-kill-reason "Too many failed OPER attempts lol";

Since snomask notices are only sent to a server's local opers, you gotta use enable-global-notices to broadcast that shit to errone. Also, you have to specify something for max-failed-operups in order to get the kill to work, since the module sorta assumes 0 which means "disable that shit fam". The kill reason defaults to "Too many failed OPER attempts".

m_netadmins (PORTED)

My port of AngryWolf's module for Unreal 3.x (
Even though Unreal 4.x doesn't have a rank system, I've kept the name and will use part of the original terminology here.

This module prevents "netadmins" from getting killed/*:Lined by "lower" opers and optionally by everyone but servers and U:Lines. Since ranks are no more, I went with a few operclass flags to indicate "netadmins" and their protection level. ;3 Also, TEMPSHUN wasn't overridden before but it is nao. =]

Config block:

operclass netadmin-protected {
    parent netadmin;
    privileges {
        m_netadmins { partial; };

The innermost bit can be either partial or full. The first one means only other "netadmins" can fuck with you, the latter excludes those too. So people with full will still be able to kill the ones with partial. Anyone with either of those flags will count as a "netadmin".

m_securequery (PORTED)

Originally written by Stealth, this is quite a simple module. It adds a umode +Z so people who aren't connected wit SSL can't message you, und ditto for the other way around. Simply set it on yourself or enforce it through the config, whatever fl0ats ur b0at fam.

m_chansno (PORTED)

My port of AngryWolf's module for Unreal 3.x (
Allows you to assign different channels for different types of server notifications. It works like the snomask system, but instead of receiving notifications in your private server console thingy, you will get the messages in channels. ;] Simply load the module and get to unrealircd.conf, see below for halp.

Config block:

chansno {
    msgtype privmsg;

    channel "#huehue" {
        server-connects; squits; oper-ups;

    channel "#kek" {
        mode-changes; topics; joins; parts; kicks;

The first directive, msgtype, can either be privmsg or notice. The first one dumps a plain message as if it were ein user, the second is a channel notice.

And here's a list of types you can use fam:

  • mode-changes => Mode changes inside channels
  • topics => Topic changes lol
  • joins => Join messages obv
  • parts => Part messages 0bv
  • kicks => Kick messages OBV
  • nickchanges => Nickname changes m8
  • connects => Local client connections
  • disconnects => Local client disconnections
  • server-connects => Local server connections
  • squits => Local server disconnections
  • unknown-users => Disconnections of unknown (local) clients
  • channel-creations => Channel creations (previously non-existent channels)
  • channel-destructions => Channel destructions (the last user parted from a channel), notify local users only (to prevent duplicates)
  • oper-ups => Successful oper-ups, displays opernick and opercla$$

You may have noticed the term local a lot above. This means the underlying hook only triggers for clients connected directly to that particular server. So people on server A doing a chanmode change won't cause server B to pick up on it. In this case A will simply broadcast it so everyone gets notified. =] The exception on this are channel destructions; every server will see the event so they will only broadcast it to their local users. I added dis because fuck dupes. ;3


Fantasy commands may sound familiar if you're using Anope IRC services or have fucked with InspIRCd at some point. They're basically aliases for certain commands and are visible to other users, since they're generally called like !cmd dicks. Unreal provides aliases too but afaik that only works for /cmd dicks, which isn't visible to others. You can also change the command prefix to like ?cmd or \cmd or whatever you want (one character max), just not /cmd. ;] It also supports a few special inline variables, more on that bel0w.

Furthermore, these aliases are limited to channel messages. There's not much you can do in private messages anyways, besides maybe ACTION shit.

Updated shit:

  • Removed $chan requirement kek
  • Allow multiple modeflags in the conf again, instead of trying to dynamically append shit
  • Special vars now go from 1 through 9 ;]
  • Special vars $1i and $2i
  • Added m0ar special vars $1h and $2h, see bel0 for an explanation fam

Special variables:
I'll put these before the config block so you'll have that info before you get to it. ;] You can use all the special variants for $1 through $9.

  • $chan => Will obv be replaced with the channel you dumped the command in
  • $1 => Will be replaced with the user's first argument
  • $1- => Becomes the first argument plus everything after it (greedy)
  • $1i => If the first arg is a nick, replace it with their ident/username
  • $1h => If the first arg is a nick, replace it with their hostname

You cannot use multiple greedy vars however, raisins should be obvious.

Config block:
Creating aliases might be a bit complex, so I'll just dump an example config right here and explain in-line with comments. =]

fantasy {
    // Change command prefix to \, so it becomes \dovoice etc
    //cmdchar \;

    // "!dovoice urmom" results in "/mode $chan +v urmom"
    dovoice     "MODE $chan +v $1";
    unvoice     "MODE $chan -v $1";

    // "!fgt urmom" is turned into "/kick $chan urmom :ayyyyy ur faget"
    fgt         "KICK $chan $1 :ayyyyy ur faget";

    // "!bitchnigga urmom dickface" results in a separate "/kick $chan $nick :nigga b0iiii" for both urmom and dickface
    bitchnigga  "KICK $chan $1- :nigga b0iiii";

    // "!ayylmao urmom u goddam fuckstick" becomes "/kick urmom :u goddam fuckstick"
    ayylmao     "KICK $chan $1 :$2-";

    // "!invex urmom" is majikked into "/mode $chan +I *!*@urmom.tld"
    invex       "MODE $chan +I *!*@$1h";
    uninvex     "MODE $chan -I *!*@$1h";

    // "!safe urmom" will become "/kick $chan urmom :$chan is a safe space lol m8 urmom"
    safe        "KICK $chan $1 :$chan is a safe space lol m8 $1";

    // It is also possible to have the same alias issue multiple commands ;]
    safe        "MODE $chan +b *!*@$1h";

    // You can also go through ChanServ, provided you have access with it
    n           "PRIVMSG ChanServ :KICK $chan $1 change your nick and rejoin lol";

As you may have noticed there are some colons in there. These are required, because otherwise there's no telling where the target arg stops and the message begins. Also, in case you do !devoice (so without ne args) it will try and voice the user who issued it. Permissions for using the resulting command are eventually checked by the do_cmd() call I have in hur. ;3


In the event of a netsplit, if someone tries to be funny by setting +b *!*@* on the main channel, nobody will be able to join until opers come in and fix it. This module allows you to deny such bans. =] Optionally, specify if opers are allowed to override it and if offenders should get a notice. I even went a bit further and also applied these restrictions to SAMODE. ;]

Config block:

denyban {
    allowopers 0;
    denynotice 1;
    mask BAN_ALL;
    mask *!*@*;

The mask *!*@* is kinda special, so you'll have to specify BAN_ALL to prevent people from doing MODE #chan +b *!*@* etc. For anything else it will do a wildcard match, as is usual. The directives allowopers and denynotice should be pretty clear. They default to 1 and 0, respectively.

I went with denyban over deny ban (notice the space) as I'm not sure if the latter will conflict with any of Unreal's internals (like deny dcc { } etc).

m_portsifresi (PORTED)

Using this module you can specify a different password for every port. This might be useful if you have like backup servers only certain people should be able to connect to. Or if you want a totally priv8 netw3rk. I think it was originally written by Sky-Dancer. The code seems to indicate the maximum password is 32 chars, so keep that in mind.

Config block:
I've kept the original format mostly, with the exception of stripping the required trailing :. ;]

psifre {
    pass "6667:hams";
    pass "6697:turds";

So any client connecting to port 6667 will first have to send a PASS hams command. People who use 6697 have to do PASS turds.


Some people may often type in caps which is annoying af really. So this module allows you to block these messages by means of an anticaps { } configuration block. It works for both channel and user private messages. ;] It disregards colour codes and control characters as well spaces while counting caps. U:Lines and opers are once again exempt.

Updated shit:

  • Allow for lowercasing of the message instead of bl0cking
  • Also limit the caps in NOTICE lol (tfw forgot about it xd)

Config block:

anticaps {
    capslimit 10;
    minlength 10;
    lowercase_it 1;

Above example would set a limit of 10% capital letters, with a minimum message length of 10. In other words, if the message is less than 10 characters it won't even bother checking. You can also set it to 0 to effectively disable it. They default to 50% and 30 chars respectively.

Set lowercase_it to 1 to lowercase the entire (plaintext) message instead of downright bl0cking it. ;]

m_joinmute (PORTED)

Originally written by Dvlpr, this module prevents people who just joined a channel from speaking for a set amount of seconds. It works with a new channel mode: +J <seconds>, for which you need to be chanop or higher to set. Furthermore, opers, U:Lines and anyone with any access mode (one or more of +vhoaq) will be able to talk right away. U:Lines are exempt since some services may join a channel, do something and part. =]


Some clients implement a command like /amsg <message>, which sends that message to all active tabs (both channels and private queries). This can get really spammy, so the module will allow the first message to go through and block the others for a short period of time. It will also strip colours and control codes, in case some people have edgy scripts for different markup across tabs. The offender will get an in-channel notice if the target is a channel and in the server console if otherwise.


Apply vhosts at connect time based on users' raw nick formats or IP addresses. The vhosts are entered in unrealircd.conf and they must be at least 5 chars in length. Furthermore, you can only enter the host part (so not [email protected]).

Updated shit:

  • Throw error if you try to configure an ident bit
  • Now displays a warning if you forgot to configure some vhost entries =]

Add a config block that looks like this:

autovhost {
    *!* big.heks;
    192.168.* premium.lan;

So everyone connecting from a typical LAN IP will get the vhost premium.lan, for example.


Adds a umode +c so you can prevent fucktards who don't share a channel with you from messaging you privately. Simply load it and do /mode <your_nick> +c. ;3 Opers and U:Lines are exempt from this (i.e. they can always send private messages), the reason why should be obvious imo tbh fam.

Updated shit:

  • Added BACKPORT thing for pre-4.0.10 IRCds cuz need to define muh own static int has_common_channels in that case
  • Allow sending to ulines imo tbh (in case of modes-on-connect "+c")

m_saprivmsg (MALV)

Inspired by SAJOIN and friends, this "forces" a PRIVMSG from a certain user. =] It comes with a new top-level operclass privilege saprivmsg. I wrote this just for lelz so bnice lmao.

SAPRIVMSG <channel> <nick> <msg>

There's also the shorter command SASAY. ;3 The module checks if channel exists, as well if nick is even in there and if they can speak (i.e. not banned etc). Opers and ulines are protected from this shit.

m_bancheck_access (UNC)

This one was mostly written for keks. It prevents chanops/hops from banning anyone who has +o, +a and/or +q. The module will check every banmask against people who have any of those access modes, using both their vhost and cloaked host. Opers can ban anyone regardless, but they can also still be affected by other bans if they don't have a high enough access mode. This is done to maintain fairness in the channel, but opers may sometimes need to set wide-ass and/or insane channel bans. Similar to m_fixhop, this mod will simply strip the affected masks and let the IRCd handle further error processing.

Note: Afaik Unreal is unable to "ask" your NickServ flavour about access lists from within a module. So if you have Anope and did /cs access #chan add <nick> 10 it will auto-op that person when they authenticate, but Unreal knows fuck all about this list. As such, it simply checks if they have the proper access mode right now.

Updated shit:

  • Reset conf defaults on rehash lol
  • Display in-channel notice in case certain masks are stripped (configurable), only the one user will see it obv

To enable above mentioned notices, simply slam this in the config somewhere: bancheck_access_notif 1;

m_fixhop (UNC)

In my opinion the +h access mode (channel halfops yo) is a little b0rked. So I made a qt3.14 module that implements some tweaks which you can enable at will in da config. ;3

Updated shit:

  • Also prevent them from changing certain channel modes like -t, -f etc
  • Reset conf defaults on rehash lol
  • Show config warning if widemask_notif is enabled but disallow_widemasks is not
  • Display in-channel notice in case certain masks are stripped (configurable), only the one user will see it obv
  • Don't blindly allow ulines anymore, as hops would be able to do /cs mode #chan +b <mask> for any mask lel

Just compile that shit, load it and add the tweaks you want to a top-level config block (disable one by simply removing/leaving out the directive):

fixhop {
    disallow_chmodes "ft";
  • allow_invite => Apparently when a chan is +i halfops can't invite people, this overrides that
  • disallow_widemasks => Hops can normally set a ban/exemption/invex for shit like *!*@*, this disallows that by stripping those masks
  • widemask_notif => Enable the in-channel notice
  • disallow_chmodes => Will strip the given channel modes in either direction, ne arguments should be taken into account
  • chmode_notif => Enable in-channel n0tice for dis

floodprot (UNC, MOD)

Some people have requested some additional features for chanmode +f. I contemplated implementing those with another module, but there aren't any proper mode flags available. xd So I just edited this shit instead. =] Remove the line that mentions loadmodule "chanmodes/floodprot" from ur modules.default.conf and add loadmodule "third/floodprot" instead. Since that file will be overwritten with the next upgrade, move it to a separate include and use that for your servers (you better be using remote includes lol)

Since I'm not gonna rehash Syzop's documentation, refer to for the current arguments. My modification implements the f0ll0wing:

  • An action D to just drop the message (I thought about using B but since there's also b this might get confuzzling)
  • A floodtype r that catches repeated messages (sort of like m_repeatprot but channel-bound instead of netwerk wide =])

An example m0dd could be: /mode #dicktits +f [2r#D]:15, so people using the same line twice in 15 seconds will be flagged. The third one will be dropped and a slightly cryptic message is shown to the spammer. Similar to m_repeatprot it will catch alternated messages. ;3

The new floodtype will detect repeats in channel notices/CTCP/messages/ACTIONs interchangeably, meaning one of each will trigger above example mode after the message. It currently only works with actions D and b (drop and kickban), but I may change that if people need moar. =]

Updated shit:

  • Improved the logic for determining whether something is repeated or simply text spam
  • Is now also markup/colour agnostic (i.e. bold/underline/etc and colours will be stripped before matching)

m_holidays (MALV)

Do some string replacements based on wat holiday it is atm. =]

m_repeatprot (UNC)

Sometimes there are faggots who spam the shit out of you, either through NOTICE or PRIVMSG. This module will GZ:Line their ass if they do. Other than specifying the triggers and exemptions, you can tweak the action a lil' bit:

  • action <block/kill/gzline> -- what action to take upon detecting a spammer, default is gzline
  • showblocked <0/1> -- display the ban message to the spammer when action == block, default = 0
  • banmsg <string> -- zline message obviously, default = Nice spam m8
  • tkltime <timestr> -- how long to zline for, format is like 60, 1h5m, etc; default = 60 (seconds)
  • threshold <int> -- after how many identical messages the action kicks in, default = 3

The module will keep track of people's last and first to last messages, so it will still catch people who alternate their spam. =] Also, channels are excluded as they probably have something better in place (like +C to disable CTCP in general).

Updated shit:

  • Reset conf defaults on rehash lol
  • Added new config directive timespan so you can "expire" the counters (simply don't specify it to never expire 'em)
  • Added trigger for INVITE spam
  • Added another action gline
  • Added trigger for CTCP yo
  • Is now also markup/colour agnostic (i.e. bold/underline/etc and colours will be stripped before matching)
  • Added detection for repeated OPER messages, will exclude the first one since that is usually legitimate (it only checks for duplicate OPER <user> too)
  • Also exempted sending to U:Lines as people sometimes fuck up their NickServ passwerds etc
  • Added exemption block
  • Renamed some variables/directives
  • Added showblocked directive
  • Added multiple actions, as well as the ability to choose between 'em
  • Renamed this shit to m_repeatprot lol
  • Moved everything into an encapsulating repeatprot { } block, with triggers { } one inside for the actual triggers

Config block example:

repeatprot {
    triggers {
    exemptions {
        [email protected];
        *[email protected]*;

    timespan 2m;
    action block;
    banmsg "Nice spam m8";
    showblocked 1;
    //tkltime 60;
    threshold 3;

You need at least one trigger obviously. The exemption masks must match *!*@*, so should be a full nick mask m9. The hostname used in exemptions should match the realhost, not a cloaked one.

m_md5fjert (UNC, LEAF-ONLY)

m_confprot's counterpart. Requires no additional configuration, but requires to be built with (from the Unreal sauce dir):
export EXLIBS='-DFJERT=\"${INCLUDEDIR}\"'; make

Updated shit:

  • Resend the digest if the hub seems to have split

m_confprot (UNC, HUB-ONLY)

This module allows the hub of a network to verify the leaves' configs (if remotely included, libcURL etc). It requires a configuration block confprot { } to be added and also supports a few additional options. If it encounters an error of any kind, it will block the leaf's IP of which opers will be notified. You can also optionally verify m_md5fjert itself.

Compile flags:
This shit requires a few custom flags to compile succesfully, but they depend heavily on the Unreal version. In all cases should you run the following from the Unreal sauce dir.

If you're on anything before 4.0.10, you should use:

export EXLIBS="-L<Unreal homedir>/curl/lib -lcurl -L<Unreal source dir>/extras/c-ares/lib <Unreal source dir>/extras/c-ares/lib/libcares.a"

If your version is 4.0.10 or greater, use:

export EXLIBS="-L<Unreal install dir>/lib -lcurl -L<Unreal install dir>/lib <Unreal install dir>/lib/"

It also assumes you're using a few sort-of-best practices:

  • You're only working with remote includes
  • Split network and hub/leaf configs (so unrealircd.conf contains just 2 include "httpx://..." lines) -- network comes before hub/leaf
  • Includes aren't nested more than once (top ones go in unrealircd.conf, those may contain only includes that don't include shit themselves)

Updated shit:

  • Added oper privilege cline
  • Renamed zlinetime to clinetime
  • Added a command /CLINE (see bel0w)
  • Now uses a custom so-called C:Line to prevent server connections (since some ZNC providers may get (G)Z:Lined entirely otherwise xd, see below)
  • Reset conf defaults on rehash lol
  • Moved everything into an encapsulating confprot { } block, with protected { } one inside for the actual entries

The confprot::protected block should contain entries for every leaf and can optionally contain NETWORK and FJERT entries (duplicate entries will be ignored). Other than that, there are the following optionals for in confprot { } itself:

  • allowunknown <0/1> -- allow links to happen despite errors, default = 0
  • clinetime <timestr> -- format is like 60, 1h5m, etc; default = 60 (seconds)
  • sslverify <0/1> -- verify SSL cert shit for the FJERT entry, default = 1

Any server that's not in the list will be allowed/denied, as specified with the directive confprot::allowunknown. The default is to deny, except ulines for obvious raisins. =] If set to 1, the module will still run through the checks as much as it can so you can still see when shit goes down (basically a dry run y0).

Example config section (UPDATED):

confprot {
    protected {
        NETWORK "https://includes.domain.tld/network.conf";
        FJERT "https://includes.domain.tld/m_md5fjert.c";
        myleaf.domain.tld "https://includes.domain.tld/myleaf.conf";
        myleaf2.domain.tld "https://includes.domain.tld/myleaf2.conf";
    allowunknown 0;
    clinetime 60;
    sslverify 0;

CLINE shit:
So the updated version comes with a new command, which you can use to list and remove C:Lines. /cline * and /cline will both remove the C:Line on (i.e. it supports wildcard masks). You can't use it to prevent servers from connecting, just jupe it if that's wat u want. Also, simply do /cline ? or /cline help to view the built-in help.

I'm using C:Lines because (G)Z:Lines may result in ZNC providers who run an IRCd on the same box to get fukt entirely. If I didn't use any *:Line at all it would result it running the cURL-related checks every goddamn time (with accompanying link established, read error messages (and a bunch of others)), which ain't gonna happen fam. Also, there's no expiration notice on C:Lines; if you see another denied notice you can safely assume it expired (according to clinetime obv). They're also not really timed, they just expire on the next run. ;] They also get cleared if you rehash.

To allow opers to list/remove C:Lines, give them the cline privilege:

operclass muhclass {
    parent netadmin-with-override;
    privileges {

m_tkl (UNC, MOD)

A slight modification of Syzop's built-in module, it prevents showing a message like Message blocked when using spamfilters of the type block.

Updated shit:

  • Now also resolves /gline <nick> to a [email protected] mask instead of *@host so ZNC providers don't get glined en masse xd

m_getlegitusers (PORTED)

Originally written by darko, this module simply counts how many legitimate clients you have on your network. People who are on more than one channel are seen as legitimate, while ones in no channels are marked "unknown". It also accounts for services boats.

Just run /getlegitusers and check your server console. =]


This module is quite similar to m_rmtkl in that you can clear "ban" lists based on masks with wildcards. So you could use a mask of *!*@* or even just * to clear errythang, it's pretty straightforward imo tbh. =]

Updated shit:

  • Apparently it didn't quite properly propagate removals of malformed masks, fixed that shit =]
  • Also removes all corrupted entries (like [email protected]* instead of butthams!*@*), cuz most (if not all) clients and the IRCd won't let you remove those

CLEARLIST <channel> <types> <mask>

Types list:

  • b => Ban
  • e => Ban exception
  • I => Invite exception


  • CLEARLIST #bighek b *
  • CLEARLIST #ayylmao Ie guest*!*@*
  • CLEARLIST #hambutt * *


So apparently someone with +v can still talk if they're banned (+b) or mutebanned (+b ~q:). This seems counterintuitive to me and probably a bunch of others, so the module rectifies that. Keep in mind that people with at least +h or IRC operator status (as well as ulines) can still talk through it.

Also, when you're not even voiced but have +b on you and you /notice #chan, you don't see a "you are banned" message. So I fixed that too. =]

Just load it and g0. =]

m_rmtkl (PORTED)

My port of AngryWolf's module for Unreal 3.x (
Removes all TKLs (bans) matching the given conditions and having any types you specify. The removal is done locally or globally, depending on whether the ban is global or not. With this command you can easily get rid of a group of no longer necessary bans. Wildcards are supported.

Updated shit:

  • Since Unreal 4 uses the operclass stuff, I've leveraged the system to ensure the proper permissions are checked. Depending on your operclass blocks, they may already be included (e.g. top-level permissions like tkl { zline } would allow opers to remove both global and local Z:Lines.
  • Apparently spamfilters fall under TKL as well (flags f and F for local and gl0bal, respectively), added support for dis. It skips over the default spamfilters carried by Unreal.
  • Added extra parameter -skipperm to skip over permanent *:lines (since they're there for a raisin ;3).

Operclass permissions overview):

  • (Local) K:Line: tkl:kline:remove
  • (Local) Q:Line: tkl:qline:local:remove
  • (Local) Z:Line: tkl:zline:local:remove
  • (Local) Spamfilter: tkl:spamfilter:local:remove
  • G:Line: tkl:gline:remove
  • Q:Line: tkl:qline:remove
  • S:Line: tkl:shun:remove
  • Global Z:Line: tkl:zline:remove
  • Global Spamfilter: tkl:spamfilter:remove

RMTKL <types to remove> <[email protected]/ip mask> [reason mask]

Types list:

  • K => Local K:Line
  • q => Local Q:Line
  • z => Local Z:Line
  • f => Local Spamfilter
  • G => G:Line
  • Q => Global Q:Line
  • s => Global S:Line
  • Z => Global Z:Line
  • F => Global Spamfilter
  • * => Everything but Q:Lines and Spamfilters

Also take a look at the built-in help by issuing simply /rmtkl.


This module allows easy installation and updating of modules from git through an IRC command. It requires access to a shell/pipe and the commands "make" and "git" (so may not work on Wind0ngs). The paths you can feed it may NOT start with a slash, and are always relative to $HOME. Also requires you to have the privilege git in yo opercla$$. =]

Oh yeah, it also throws a SNO_EYES snomask to notify IRC opers of the command usage. Every server it ran on returns one line of output regarding its success as well.

GIT INSTALL <Unreal source path> <build/tmp folder> <git clone URL> [-global]
GIT UPDATE <Unreal source path> <git module path> [-global]

Example: /git install build/unrealircd-4.0.5 build
This will clone the repo to the folder $HOME/build (of the server you are on) and copy .c files in there to $HOME/build/unrealircd-4.0.5/src/modules/third. It will then run make && make install.

Example 2: /git update build/unrealircd-4.0.5 build/somemodule -global
This will do a pull of the repo in $HOME/build/somemodule and again copies .c files to $HOME/build/unrealircd-4.0.5/src/modules/third before doing make && make install. Since -global is specified, all currently connected servers will do the same.

m_forward (PORTED)

Muh first attempt at porting ein module for UnrealIRCD 3.x to 4.x. =]
The Unreal 3 mod can be found at:

Updated shit:

  • While checking the target channel for +B there was a bug with casting a char * to void *, which fucked shit up xd
  • Channel mode +A is no longer known to UnrealIRCd it seems, so removed that shit =]
  • +b was checked last, seems to me it should be first in order to have the extended ~f: bantype override it
  • When checking for +B on target channel, it originally checked chptr (which is a pointer to the current channel's struct)
  • Cleaned up c0dd ein bit lel
  • better_override is now settable through unrealircd.conf, no need to recompile anymore (allows opers w/ OperOverride to simply /join restricted channels)

better_override defaults to 0/false so you can simply omit the configuration variable if you don't want this feature. Otherwise, add m_forward_override 1 to the global configuration.

I'll also include ze original readme sort of thing right here:
This module is based on the m_banlink module, but offers a more robust featureset. This module and the banlink module are incompatible with each other, so having both installed at once won't work (and why would you anyway?)

My module offers the following features:

  • +F <channel> channel mode to forward users that are unable to join to another channel (including invite only, keyed, etc. not just banned). Requires channel owner (+q) to set
  • +B channel mode to prevent users from being forwarded to your channel. Requires channel owner (+q) to set
  • +Q user mode to prevent yourself from being forwarded to other channels
  • ~f:#channel:[email protected] extended bantype to forward specific users to another channel (overrides +F)
  • Users will only be forwarded once. If they cannot join the second channel, nothing will happen (even if the second channel is +F)
  • Users will be given a descriptive message as to why they are unable to join the first channel (e.g. "channel is invite only" or "you are banned")
  • (Optional) You may choose to allow Opers to be able to directly join a channel via OperOverride (e.g. normally an oper must /invite themselves into a +i channel, this would allow them to just join. Either way an OperOverride message is given and logged). To enable this, see the Config section [in the source]