#!/usr/bin/perl use strict; use warnings; BEGIN { unless (exists $::{"Irssi::"}) { require Pod::Usage; Pod::Usage::pod2usage(-verbose => 2); } } use Irssi; our $VERSION = '0.05'; our %IRSSI = ( authors => 'aluser', name => 'autovoice', description => 'autovoice', license => 'GPL', ); our %bad;
/script load autovoice
/autovoice add #somechannel
Idle on #somechannel as [half]op, and you will voice people :)
This is certainly not a new concept, but I dislike many implementations of autovoicing because they are not as intelligent as they could be. Blindly voicing everyone who joins your channel is dumb, because it removes the protection that +m is supposed to give you. A troublemake need merely to rejoin the channel to get his voice back. You probably want to voice newcomers to your channel, so a password or hostmask system is no good. Besides, it's intuitive that anybody leaving the channel without voice and quickly rejoining is trying to leverage your autovoicer! So, the main purpose of this script is to automatically detect these people and not voice them.
The other important feature is fine-grained control over where you voice people. You might want to autovoice in efnet #foo but not in dalnet #foo. The /autovoice add command gives you -server and -ircnet options to control on which channels you will autovoice, even if the channels have identical names.
I still consider this script to be lightly tested, but I do hope that it is well documented enough that it can be debugged well.
Just place this script in ~/.irssi/scripts. To have it load automatically when you start Irssi, do this:
mkdir -p ~/.irssi/scripts/autorun
ln -s ../autovoice.pl ~/.irssi/scripts/autorun/
If you haven't figured it out yet, you can run the script outside of Irssi to get a man page type document, like this:
chmod +x autovoice.pl
./autovoice.pl
This is a helper to add channels to autovoice_channels for you. I'm going to explain this by example:
/autovoice add #channelfoo
/autovoice add -server irc.foo.com #barbarfoo
/autovoice add -ircnet EFNet #perlhelp
/autovoice add -server irc.efnet.org -ircnet Undernet #irssi
Note that the last example actually adds two ``channels'' to the setting, both named #irssi. The channel will be valid on Undernet or the server irc.efnet.org.
This is a helper to remove channels from autovoice_channels for you. Example:
/autovoice remove #somechannel
/autovoice remove #channel1 #channel2
Mostly for debugging, this dumps the perl hash containing blacklisted nicks to your screen.
Flush the blacklists.
Set autovoicing on or off.
Control which channels we will autovoice. The simplest form is
#channel1 , #channel2 , #channel3
Space before the commas is mandatory; after is optional. For any channel in the list, you may specify a chatnet or a server like this:
#channel1 , #channel2 =>SOMECHATNET , #channel3 @some.server.com
Space after the channels and before the => or @ is required. Space after the => or @ is optional. (not shown)
See autovoice add and autovoice remove for wrappers to this.
Control the amount of time, in seconds, for which we remember that a nick left a channel without voice.
Whether or not to give voice to people who already have op or halfop
Whether to distinguish between nicks which have the same host but different user names. (nick![ident@host] vs nick!ident@[host])
Plenty.
&add will add duplicate channels
Error checking in &add is weak.
Setting autovoice_use_ident causes the existing blacklists to be ineffective.
parse_channels and deparse_channels mix up the ordering of the channels in the autovoice_channels setting. This is a property of the hash used to represent the setting.
remove doesn't let you remove only one channel when several use the same name.
Setting autovoice_cycletime does not change the timing for entries already in the badlist, only for entries made after the setting is changed. As far as I can tell, the alternatives are to A) Have a potentially ever-growing %bad, or B) to run a cleanup on a timer which must traverse all of %bad.
This section is for people interested in tweaking/fixing/improving/developing/hacking this script. It describes every subroutine and data structure in the script. If you do not know Perl you should stop reading here.
Variables ending in _rec are Irssi objects of some sort. I also use _text to indicate normal strings.
This hash holds the badlists for all channels. Each key is a tag as supplied by $server_rec-{tag}>. Each value is a hash reference as follows:
Each key is a lowercased channel name as given by lc $channel_rec->{name} . Each value is a hash referenc described as follows:
Each key is a lowercased host. If the host was marked bad while autovoice_use_ident was set, it is in the form ``username@host.com''. If not, it is just ``host.com''. Each value is a tag as returned by Irssi::timeout_add. This is used to remove the callback which is planning to remove the entry from the badlist after autovoice_cycletime expires.
This hash holds the commands invoked as /autovoice <command> [ arg1 arg2 ... ]. Each key is the lowercased name of a command, and each value is a reference to a subroutine. The subroutine should expect an Irssi Server object, a WindowItem object, and a list of user supplied arguments. The case of the arguments is left as supplied by the user.
The nicks in the array referenced by $nicks_ray are joining $channel_rec. This is an irssi signal handler.
sub massjoin { my ($channel_rec, $nicks_ray) = @_; voicem($channel_rec, @$nicks_ray); }
A nick is parting a channel. $addr and $reason are not used. This is an irssi signal handler.
sub message_part { my ($server_rec, $channel_text, $nick_text) = @_; #Irssi::print("chan: $channel_text, nick: $nick_text"); #return unless defined $nick_text; # happens if the part was us no warnings; my $channel_rec = $server_rec->channel_find($channel_text); use warnings; return unless defined $channel_rec; my $nick_rec = $channel_rec->nick_find($nick_text); partem($channel_rec, $nick_rec); }
A nick is quiting the server. $addr and $reason are not used. This is an irssi signal handler.
sub message_quit { my ($server_rec, $nick_text, $addr, $reason) = @_; my $chanstring = $server_rec->get_channels(); $chanstring =~ s/ .*//; #strip channel keys my @channels_text = split /,/, $chanstring; no warnings; my @channels_rec = map { $server_rec->channel_find($_) } @channels_text; use warnings; for (@channels_rec) { my $nick_rec = $_->nick_find($nick_text); if (defined $nick_rec) { partem($_, $nick_rec); } } }
Called when a nick is kicked from a channel. This is an Irssi signal handler.
sub message_kick { my ($server_rec, $channel_text, $nick_text) = @_; my $channel_rec = $server_rec->channel_find($channel_text); return unless defined $channel_rec; my $nick_rec = $channel_rec->nick_find($nick_text); partem($channel_rec, $nick_rec); }
This voices all of @nicks on $channel_rec, provided they aren't in the blacklist.
sub voicem { my ($channel_rec, @nicks) = @_; if (is_auto($channel_rec)) { for my $nick_rec (@nicks) { unless (is_bad($channel_rec, $nick_rec) or $nick_rec->{voice}) { if (get_voiceops() or !($nick_rec->{op} or $nick_rec->{halfop})) { my $nick_text = $nick_rec->{nick}; $channel_rec->command("voice $nick_text"); } } } } }
Called when a nick is leaving a channel, by any means. This is what decides whether the nick does or does not have voice.
sub partem { my ($channel_rec, $nick_rec) = @_; #$channel_rec->print("partem called"); if (is_auto($channel_rec)) { #$channel_rec->print("this channel is autovoiced."); if (not $nick_rec->{voice} and not $nick_rec->{op} and not $nick_rec->{halfop}) { #$channel_rec->print("nick leaving with no voice"); make_bad($channel_rec, $nick_rec); } else { make_unbad($channel_rec, $nick_rec); } } }
Returns 1 if $nick_rec is blacklisted on $channel_rec, 0 otherwise.
sub is_bad { my ($channel_rec, $nick_rec) = @_; my $server_tag = $channel_rec->{server}->{tag}; my $channel_text = lc $channel_rec->{name}; my $host_text = lc $nick_rec->{host}; if (not get_useident()) { $host_text =~ s/.*?\@//; } #$channel_rec->print("calling is_bad {$server_tag}{$channel_text}{$host_text}"); return exists $bad{$server_tag} && exists $bad{$server_tag}{$channel_text} && exists $bad{$server_tag}{$channel_text}{$host_text}; }
Blacklist $nick_rec on $channel_rec for autovoice_cycletime seconds.
sub make_bad { my ($channel_rec, $nick_rec) = @_; my $tag = $channel_rec->{server}->{tag}; my $channel_text = lc $channel_rec->{name}; my $host_text = lc $nick_rec->{host}; if (not get_useident()) { $host_text =~ s/.*?\@//; } #$channel_rec->print("channel_rec: ".ref($channel_rec)."nick_rec: ".ref($nick_rec).". make bad $tag, $channel_text, $host_text"); Irssi::timeout_remove($bad{$tag}{$channel_text}{$host_text}) if exists $bad{$tag}{$channel_text}{$host_text}; $bad{$tag}{$channel_text}{$host_text} = Irssi::timeout_add(get_cycletime(), 'timeout', [ $channel_rec, $nick_rec ]); }
This is the irssi timeout callback which removes $nick_rec from the blacklist for $channel_rec when autovoice_cycletime seconds have elapsed. make_unbad finds the tag in the badlist in order to keep this from being called again. Note that it only takes one argument, an array ref
sub timeout { my ($channel_rec, $nick_rec) = @{$_[0]}; #$channel_rec->print("timing out"); make_unbad($channel_rec, $nick_rec); }
Remove $nick_rec from the blacklist for $channel_rec
sub make_unbad { my ($channel_rec, $nick_rec) = @_; my $tag = $channel_rec->{server}->{tag}; my $channel_text = lc $channel_rec->{name}; my $host_text = lc $nick_rec->{host}; if (not get_useident()) { $host_text =~ s/.*\@//; } if (exists $bad{$tag}{$channel_text}{$host_text}) { Irssi::timeout_remove($bad{$tag}{$channel_text}{$host_text}); delete $bad{$tag}{$channel_text}{$host_text}; if (not keys %{$bad{$tag}{$channel_text}}) { delete $bad{$tag}{$channel_text}; } if (not keys %{$bad{$tag}}) { delete $bad{$tag}; } } }
Examine autovoice_channels and return a hash reference. Each key is a channel name, lowercased. Each value is a hash with one to three keys, 'server', 'chatnet', and/or 'plain'. If server, it holds an array ref with all servers on which the channel is autovoice. If chatnet, it holds an array ref with all the chatnets on which the channel is autovoice. If plain, it just has the value 1.
sub parse_channels { my $chanstring = lc Irssi::settings_get_str('autovoice_channels'); $chanstring =~ s/^\s+//; $chanstring =~ s/\s+$//; my @fields = split /\s+,\s*/, $chanstring; my %hash; keys %hash = scalar @fields; for (@fields) { if (/\s=>/) { my ($channel, $chatnet) = split /\s+=>\s*/, $_, 2; add_channel_to_parsed(\%hash, $channel, $chatnet, undef); } elsif (/\s\@/) { my ($channel, $server) = split /\s+\@\s*/, $_, 2; add_channel_to_parsed(\%hash, $channel, undef, $server); } else { my ($channel) = /(\S+)/; add_channel_to_parsed(\%hash, $channel, undef, undef); } } return \%hash; }
Take a hash ref like that produced by parse_channels and convert it into a string suitable for autovoice_channels
sub deparse_channels { my $hashr = shift; my @fields; for my $channel (keys %$hashr) { my $s = $channel; push(@fields, $s) if exists $hashr->{$channel}->{plain}; if (exists $hashr->{$channel}->{server}) { for (@{$hashr->{$channel}->{server}}) { push(@fields, $s.' @ '.$_); } } if (exists $hashr->{$channel}->{chatnet}) { for (@{$hashr->{$channel}->{chatnet}}) { push(@fields, $s.' => '.$_); } } } return join ' , ', @fields; }
Returns 1 if $channel_rec is an autovoiced channel as defined by autovoice_channels, 0 otherwise.
sub is_auto { unless (Irssi::settings_get_bool('autovoice')) { return 0; } my $channel_rec = shift; my $channel_text = lc $channel_rec->{name}; my $parsedchannels = parse_channels(); return 0 unless exists $parsedchannels->{$channel_text}; if (exists $parsedchannels->{$channel_text}->{plain}) { return 1; } elsif (exists $parsedchannels->{$channel_text}->{chatnet}) { #Irssi::print("looking at chatnet @{$parsedchannels->{$channel_text}->{chatnet}}"); for (@{$parsedchannels->{$channel_text}->{chatnet}}) { return 1 if $_ eq lc $channel_rec->{server}->{chatnet}; } return 0; } else { for (@{$parsedchannels->{$channel_text}->{server}}) { return 1 if $_ eq lc $channel_rec->{server}->{address}; } return 0; } } our %commands = ( dump => \&dump, add => \&add, remove => \&remove, flush => \&flush, );
Irssi command handler which dispatches all the /autovoice * commands. Autovoice commands are given ($server_rec, $witem, @args), where @args is the result of split ' ', $data minus the first element (``autovoice''). Note that the case of @args is not changed.
sub autovoice_cmd { my ($data, $server, $witem) = @_; my ($cmd, @args) = (split ' ', $data); $cmd = lc $cmd; if (exists $commands{$cmd}) { $commands{$cmd}->($server, $witem, @args) } else { Irssi::print("No such command: autovoice $cmd"); } }
Invoked as /autovoice dump, this requires Data::Dumper and dumps the blacklist hash to the current window. @args and $server_rec are ignored.
sub dump { require Data::Dumper; my $witem = $_[1]; my $string = Data::Dumper->Dump([\%bad], ['bad']); chomp $string; if ($witem) { $witem->print($string); } else { Irssi::print($string); } }
Invoked as /autovoice add (args). This adds channels to autovoice_channels. See autovoice add in COMMANDS for usage.
sub add { my ($server_rec, $witem, @args) = @_; @args = map {lc} @args; my $parsedchannels = parse_channels(); my ($server, $chatnet, $channel); for (my $i = 0; $i < @args; ++$i) { if ($args[$i] eq '-ircnet') { if (defined $chatnet) { Irssi::print("autovoice add: warning: -ircnet given twice, using the second value."); } $chatnet = $args[$i+1]; splice(@args, $i, 1) } elsif ($args[$i] eq '-server') { if (defined $server) { Irssi::print("autovoice add: warning: -server given twice, using the second value."); } $server = $args[$i+1]; splice(@args, $i, 1); } else { if (defined $channel) { Irssi::print("autovoice add: warning: more than one channel specified, using the last one."); } $channel = $args[$i]; $channel = '#'.$channel unless $server_rec->ischannel($channel); } } unless (defined $channel) { Irssi::print("autovoice add: no channel specified"); return; } add_channel_to_parsed($parsedchannels, $channel, $chatnet, $server); Irssi::settings_set_str('autovoice_channels' => deparse_channels($parsedchannels)); if ($witem) { $witem->command("set autovoice_channels"); } else { Irssi::command("set autovoice_channels"); } }
Adds a channel to a hash ref like that returned by &parse_channels. If $chatnet is defined but $server is not, restrict it to the chatnet. If $server is defined but $chatnet is not, restrict it to the server. If both are defined, add to channels, one restricted to the server and the other to the chatnet. (Both with the same name) If neither is defined, do not restrict the channel to a chatnet or server.
sub add_channel_to_parsed { my ($parsedchannels, $channel, $chatnet, $server) = @_; if (defined $chatnet) { push @{$parsedchannels->{$channel}->{chatnet}}, $chatnet; } if (defined $server) { push @{$parsedchannels->{$channel}->{server}}, $server; } if (not defined($chatnet) and not defined($server)) { $parsedchannels->{$channel}->{plain} = 1; } }
Invoked as
/autovoice remove [-ircnet IRCNET] [-server SERVER] #chan1 [-ircnet IRCNET] [-server SERVER] #chan2
Removes all channels matching those specified. An -ircnet or -server option only applies to the channel following it, and must be specified before its channel name. A channel without -ircnet or -server options removes all channels with that name.
sub remove { my ($server_rec, $witem, @args) = @_; my %parsedchannels = %{parse_channels()}; my ($wantserver, $wantchatnet, $server, $chatnet); for (@args) { $_ = lc; if ($wantserver) { $wantserver = 0; $server = $_; } elsif ($wantchatnet) { $wantchatnet = 0; $chatnet = $_; } elsif ($_ eq '-server') { $wantserver = 1; } elsif ($_ eq '-ircnet') { $wantchatnet = 1; } elsif (exists $parsedchannels{$_}) { my $chan = $_; if (defined $server and exists $parsedchannels{$chan}{server}) { @{$parsedchannels{$chan}{server}} = grep {$_ ne $server} @{$parsedchannels{$chan}{server}}; } if (defined $chatnet and exists $parsedchannels{$chan}{chatnet}) { @{$parsedchannels{$chan}{chatnet}} = grep {$_ ne $chatnet} @{$parsedchannels{$chan}{chatnet}}; } if (not defined $server and not defined $chatnet) { delete $parsedchannels{$chan}; } else { if (exists $parsedchannels{$chan}{server} and not @{$parsedchannels{$chan}{server}}) { delete $parsedchannels{$chan}{server}; } if (exists $parsedchannels{$chan}{chatnet} and not @{$parsedchannels{$chan}{chatnet}}) { delete $parsedchannels{$chan}{chatnet}; } } } } Irssi::settings_set_str('autovoice_channels' => deparse_channels(\%parsedchannels)); if ($witem) { $witem->command("set autovoice_channels"); } else { Irssi::command("set autovoice_channels"); } }
Flush the badlist.
sub flush { %bad = (); }
Checks autovoice_cycletime and returns the cycle time in milliseconds.
sub get_cycletime { 1000 * Irssi::settings_get_int("autovoice_cycletime"); }
Return the value of autovoice_voice_ops
sub get_voiceops { Irssi::settings_get_bool("autovoice_voice_ops"); }
Return the value of autovoice_use_ident
sub get_useident { Irssi::settings_get_bool("autovoice_use_ident"); }
Irssi::signal_add_first('message part', 'message_part'); Irssi::signal_add_first('message quit', 'message_quit'); Irssi::signal_add_first('message kick', 'message_kick'); Irssi::signal_add_last('massjoin', 'massjoin'); Irssi::settings_add_str('autovoice', 'autovoice_channels' => ""); Irssi::settings_add_int('autovoice', 'autovoice_cycletime' => 600); Irssi::settings_add_bool('autovoice', 'autovoice_voice_ops' => 0); Irssi::settings_add_bool('autovoice', 'autovoice_use_ident' => 0); Irssi::settings_add_bool('autovoice', 'autovoice' => 1); Irssi::command_bind(autovoice => 'autovoice_cmd');