GitHub/pbot
3
0
Fork 0
mirror of https://github.com/pragma-/pbot.git synced 2024-11-25 21:39:27 +01:00
Code Issues Projects Releases Wiki Activity

Remove PBot getter/setters; move anti-flood registry defaults to AntiFlood.pm

Browse Source
This commit is contained in:
Pragmatic Software 2014-05-18 20:09:05 +00:00
parent bf4920b866
commit 30e3c5ce35
30 changed files with 687 additions and 802 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
PBot/AntiFlood.pm
View File

@ -49,10 +49,18 @@ sub initialize {
$self->{ban_whitelist} = PBot::DualIndexHashObject->new(name => 'BanWhitelist', filename => $filename);
$self->{ban_whitelist}->load;
$self->{pbot}->timer->register(sub { $self->adjust_offenses }, 60 * 60 * 1);
$self->{pbot}->{timer}->register(sub { $self->adjust_offenses }, 60 * 60 * 1);
$self->{pbot}->commands->register(sub { return $self->unbanme(@_) }, "unbanme", 0);
$self->{pbot}->commands->register(sub { return $self->whitelist(@_) }, "whitelist", 10);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'max_join_flood', $conf{max_join_flood} // 4);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'max_chat_flood', $conf{max_chat_flood} // 4);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'max_enter_flood', $conf{max_enter_flood} // 4);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'max_nick_flood', $conf{max_nick_flood} // 3);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_lines', $conf{enter_abuse_max_lines} // 4);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_seconds', $conf{enter_abuse_max_seconds} // 20);
$self->{pbot}->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_offenses', $conf{enter_abuse_max_offenses} // 3);
$self->{pbot}->{commands}->register(sub { return $self->unbanme(@_) }, "unbanme", 0);
$self->{pbot}->{commands}->register(sub { return $self->whitelist(@_) }, "whitelist", 10);
}
sub ban_whitelisted {
@ -60,7 +68,7 @@ sub ban_whitelisted {
$channel = lc $channel;
$mask = lc $mask;
#$self->{pbot}->logger->log("whitelist check: $channel, $mask\n");
#$self->{pbot}->{logger}->log("whitelist check: $channel, $mask\n");
return (exists $self->{ban_whitelist}->hash->{$channel}->{$mask} and defined $self->{ban_whitelist}->hash->{$channel}->{$mask}->{ban_whitelisted}) ? 1 : 0;
}
@ -162,7 +170,7 @@ sub check_flood {
my $account = $self->{pbot}->{messagehistory}->get_message_account($nick, $user, $host);
if($mode == $self->{pbot}->{messagehistory}->{MSG_NICKCHANGE}) {
$self->{pbot}->logger->log(sprintf("%-14s | %-65s | %s\n", "NICKCHANGE", $mask, $text));
$self->{pbot}->{logger}->log(sprintf("%-14s | %-65s | %s\n", "NICKCHANGE", $mask, $text));
my ($newnick) = $text =~ m/NICKCHANGE (.*)/;
if($newnick =~ m/^Guest\d+$/) {
@ -171,7 +179,7 @@ sub check_flood {
$self->{nickflood}->{$account}->{changes}++;
}
} else {
$self->{pbot}->logger->log(sprintf("%-14s | %-65s | %s\n", $channel eq $mask ? "QUIT" : $channel, $mask, $text));
$self->{pbot}->{logger}->log(sprintf("%-14s | %-65s | %s\n", $channel eq $mask ? "QUIT" : $channel, $mask, $text));
}
# handle QUIT events
@ -211,7 +219,7 @@ sub check_flood {
}
# do not do flood processing if channel is not in bot's channel list or bot is not set as chanop for the channel
return if ($channel =~ /^#/) and (not exists $self->{pbot}->channels->channels->hash->{$channel} or $self->{pbot}->channels->channels->hash->{$channel}{chanop} == 0);
return if ($channel =~ /^#/) and (not exists $self->{pbot}->{channels}->{channels}->hash->{$channel} or $self->{pbot}->{channels}->{channels}->hash->{$channel}{chanop} == 0);
if($channel =~ /^#/ and $mode == $self->{pbot}->{messagehistory}->{MSG_DEPARTURE}) {
# remove validation on PART so we check for ban-evasion when user returns at a later time
@ -223,7 +231,7 @@ sub check_flood {
}
if($max_messages > $self->{pbot}->{registry}->get_value('messagehistory', 'max_messages')) {
$self->{pbot}->logger->log("Warning: max_messages greater than max_messages limit; truncating.\n");
$self->{pbot}->{logger}->log("Warning: max_messages greater than max_messages limit; truncating.\n");
$max_messages = $self->{pbot}->{registry}->get_value('messagehistory', 'max_messages');
}
@ -232,14 +240,14 @@ sub check_flood {
if($mode == $self->{pbot}->{messagehistory}->{MSG_DEPARTURE}) {
# don't check for evasion on PART/KICK
} else {
$self->{pbot}->conn->whois($nick);
$self->{pbot}->{conn}->whois($nick);
$self->check_bans($account, $mask, $channel);
}
}
# do not do flood enforcement for this event if bot is lagging
if($self->{pbot}->lagchecker->lagging) {
$self->{pbot}->logger->log("Disregarding enforcement of anti-flood due to lag: " . $self->{pbot}->lagchecker->lagstring . "\n");
if($self->{pbot}->{lagchecker}->lagging) {
$self->{pbot}->{logger}->log("Disregarding enforcement of anti-flood due to lag: " . $self->{pbot}->{lagchecker}->lagstring . "\n");
return;
}
@ -260,20 +268,20 @@ sub check_flood {
if(++$channel_data->{enter_abuses} >= $enter_abuse_max_offenses) {
my $offenses = $channel_data->{enter_abuses} - $enter_abuse_max_offenses + 1;
my $ban_length = $offenses ** $offenses * $offenses * 30;
$self->{pbot}->chanops->ban_user_timed("*!$user\@$host", $channel, $ban_length);
$self->{pbot}->{chanops}->ban_user_timed("*!$user\@$host", $channel, $ban_length);
$ban_length = duration($ban_length);
$self->{pbot}->logger->log("$nick $channel enter abuse offense " . $channel_data->{enter_abuses} . " earned $ban_length ban\n");
$self->{pbot}->conn->privmsg($nick, "You have been muted due to abusing the enter key. Please do not split your sentences over multiple messages. You will be allowed to speak again in $ban_length.");
$self->{pbot}->{logger}->log("$nick $channel enter abuse offense " . $channel_data->{enter_abuses} . " earned $ban_length ban\n");
$self->{pbot}->{conn}->privmsg($nick, "You have been muted due to abusing the enter key. Please do not split your sentences over multiple messages. You will be allowed to speak again in $ban_length.");
} else {
#$self->{pbot}->logger->log("$nick $channel enter abuses counter incremented to " . $channel_data->{enter_abuses} . "\n");
#$self->{pbot}->{logger}->log("$nick $channel enter abuses counter incremented to " . $channel_data->{enter_abuses} . "\n");
}
} else {
#$self->{pbot}->logger->log("$nick $channel enter abuse counter incremented to " . $channel_data->{enter_abuse} . "\n");
#$self->{pbot}->{logger}->log("$nick $channel enter abuse counter incremented to " . $channel_data->{enter_abuse} . "\n");
}
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
} else {
if($channel_data->{enter_abuse} > 0) {
#$self->{pbot}->logger->log("$nick $channel more than $enter_abuse_max_seconds seconds since last message, enter abuse counter reset\n");
#$self->{pbot}->{logger}->log("$nick $channel more than $enter_abuse_max_seconds seconds since last message, enter abuse counter reset\n");
$channel_data->{enter_abuse} = 0;
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
}
@ -281,7 +289,7 @@ sub check_flood {
} else {
$self->{channels}->{$channel}->{last_spoken_nick} = $nick;
if($channel_data->{enter_abuse} > 0) {
#$self->{pbot}->logger->log("$nick $channel enter abuse counter reset\n");
#$self->{pbot}->{logger}->log("$nick $channel enter abuse counter reset\n");
$channel_data->{enter_abuse} = 0;
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
}
@ -307,17 +315,17 @@ sub check_flood {
return;
}
else {
$self->{pbot}->logger->log("Unknown flood mode [$mode] ... aborting flood enforcement.\n");
$self->{pbot}->{logger}->log("Unknown flood mode [$mode] ... aborting flood enforcement.\n");
return;
}
my $last = $self->{pbot}->{messagehistory}->{database}->recall_message_by_count($account, $channel, 0);
#$self->{pbot}->logger->log(" msg: [$msg->{timestamp}] $msg->{msg}\n");
#$self->{pbot}->logger->log("last: [$last->{timestamp}] $last->{msg}\n");
#$self->{pbot}->logger->log("Comparing message timestamps $last->{timestamp} - $msg->{timestamp} = " . ($last->{timestamp} - $msg->{timestamp}) . " against max_time $max_time\n");
#$self->{pbot}->{logger}->log(" msg: [$msg->{timestamp}] $msg->{msg}\n");
#$self->{pbot}->{logger}->log("last: [$last->{timestamp}] $last->{msg}\n");
#$self->{pbot}->{logger}->log("Comparing message timestamps $last->{timestamp} - $msg->{timestamp} = " . ($last->{timestamp} - $msg->{timestamp}) . " against max_time $max_time\n");
if($last->{timestamp} - $msg->{timestamp} <= $max_time && not $self->{pbot}->admins->loggedin($channel, "$nick!$user\@$host")) {
if($last->{timestamp} - $msg->{timestamp} <= $max_time && not $self->{pbot}->{admins}->loggedin($channel, "$nick!$user\@$host")) {
if($mode == $self->{pbot}->{messagehistory}->{MSG_JOIN}) {
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($account, $channel, 'offenses', 'last_offense', 'join_watch');
#$self->{pbot}->{logger}->log("$account offenses $channel_data->{offenses}, join watch $channel_data->{join_watch}, max messages $max_messages\n");
@ -328,16 +336,16 @@ sub check_flood {
my $timeout = (2 ** (($channel_data->{offenses} + 2) < 10 ? $channel_data->{offenses} + 2 : 10));
my $banmask = address_to_mask($host);
$self->{pbot}->chanops->ban_user_timed("*!$user\@$banmask\$##stop_join_flood", $channel, $timeout * 60 * 60);
$self->{pbot}->logger->log("$nick!$user\@$banmask banned for $timeout hours due to join flooding (offense #" . $channel_data->{offenses} . ").\n");
$self->{pbot}->conn->privmsg($nick, "You have been banned from $channel due to join flooding. If your connection issues have been fixed, or this was an accident, you may request an unban at any time by responding to this message with: unbanme $channel, otherwise you will be automatically unbanned in $timeout hours.");
$self->{pbot}->{chanops}->ban_user_timed("*!$user\@$banmask\$##stop_join_flood", $channel, $timeout * 60 * 60);
$self->{pbot}->{logger}->log("$nick!$user\@$banmask banned for $timeout hours due to join flooding (offense #" . $channel_data->{offenses} . ").\n");
$self->{pbot}->{conn}->privmsg($nick, "You have been banned from $channel due to join flooding. If your connection issues have been fixed, or this was an accident, you may request an unban at any time by responding to this message with: unbanme $channel, otherwise you will be automatically unbanned in $timeout hours.");
$channel_data->{join_watch} = $max_messages - 2; # give them a chance to rejoin
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
}
} elsif($mode == $self->{pbot}->{messagehistory}->{MSG_CHAT}) {
if($channel =~ /^#/) { #channel flood (opposed to private message or otherwise)
# don't increment offenses again if already banned
return if $self->{pbot}->chanops->{unban_timeout}->find_index($channel, "*!$user\@$host");
return if $self->{pbot}->{chanops}->{unban_timeout}->find_index($channel, "*!$user\@$host");
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($account, $channel, 'offenses', 'last_offense');
$channel_data->{offenses}++;
@ -346,14 +354,14 @@ sub check_flood {
my $length = $channel_data->{offenses} ** $channel_data->{offenses} * $channel_data->{offenses} * 30;
$self->{pbot}->chanops->ban_user_timed("*!$user\@$host", $channel, $length);
$self->{pbot}->{chanops}->ban_user_timed("*!$user\@$host", $channel, $length);
$length = duration($length);
$self->{pbot}->logger->log("$nick $channel flood offense " . $channel_data->{offenses} . " earned $length ban\n");
$self->{pbot}->conn->privmsg($nick, "You have been muted due to flooding. Please use a web paste service such as http://codepad.org for lengthy pastes. You will be allowed to speak again in $length.");
$self->{pbot}->{logger}->log("$nick $channel flood offense " . $channel_data->{offenses} . " earned $length ban\n");
$self->{pbot}->{conn}->privmsg($nick, "You have been muted due to flooding. Please use a web paste service such as http://codepad.org for lengthy pastes. You will be allowed to speak again in $length.");
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
}
else { # private message flood
return if exists ${ $self->{pbot}->ignorelist->{ignore_list} }{"$nick!$user\@$host"}{$channel};
return if exists ${ $self->{pbot}->{ignorelist}->{ignore_list} }{"$nick!$user\@$host"}{$channel};
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($account, $channel, 'offenses', 'last_offense');
$channel_data->{offenses}++;
@ -362,10 +370,10 @@ sub check_flood {
my $length = $channel_data->{offenses} ** $channel_data->{offenses} * $channel_data->{offenses} * 30;
$self->{pbot}->ignorelist->{commands}->ignore_user("", "floodcontrol", "", "", "$nick!$user\@$host $channel $length");
$self->{pbot}->{ignorelist}->{commands}->ignore_user("", "floodcontrol", "", "", "$nick!$user\@$host $channel $length");
$length = duration($length);
$self->{pbot}->logger->log("$nick msg flood offense " . $channel_data->{offenses} . " earned $length ignore\n");
$self->{pbot}->conn->privmsg($nick, "You have used too many commands in too short a time period, you have been ignored for $length.");
$self->{pbot}->{logger}->log("$nick msg flood offense " . $channel_data->{offenses} . " earned $length ignore\n");
$self->{pbot}->{conn}->privmsg($nick, "You have used too many commands in too short a time period, you have been ignored for $length.");
}
} elsif($mode == $self->{pbot}->{messagehistory}->{MSG_NICKCHANGE} and $self->{nickflood}->{$account}->{changes} >= $max_messages) {
($nick) = $text =~ m/NICKCHANGE (.*)/;
@ -378,12 +386,12 @@ sub check_flood {
my @channels = $self->{pbot}->{messagehistory}->{database}->get_channels($account);
foreach my $chan (@channels) {
$self->{pbot}->chanops->ban_user_timed("*!$user\@$host", $chan, $length);
$self->{pbot}->{chanops}->ban_user_timed("*!$user\@$host", $chan, $length);
}
$length = duration($length);
$self->{pbot}->logger->log("$nick nickchange flood offense " . $self->{nickflood}->{$account}->{offenses} . " earned $length ban\n");
$self->{pbot}->conn->privmsg($nick, "You have been temporarily banned due to nick-change flooding. You will be unbanned in $length.");
$self->{pbot}->{logger}->log("$nick nickchange flood offense " . $self->{nickflood}->{$account}->{offenses} . " earned $length ban\n");
$self->{pbot}->{conn}->privmsg($nick, "You have been temporarily banned due to nick-change flooding. You will be unbanned in $length.");
}
}
}
@ -409,16 +417,16 @@ sub unbanme {
my @nickserv_accounts = $self->{pbot}->{messagehistory}->{database}->get_nickserv_accounts($message_account);
foreach my $nickserv_account (@nickserv_accounts) {
my $baninfos = $self->{pbot}->bantracker->get_baninfo("$nick!$user\@$host", $channel, $nickserv_account);
my $baninfos = $self->{pbot}->{bantracker}->get_baninfo("$nick!$user\@$host", $channel, $nickserv_account);
if(defined $baninfos) {
foreach my $baninfo (@$baninfos) {
if($self->ban_whitelisted($baninfo->{channel}, $baninfo->{banmask})) {
$self->{pbot}->logger->log("anti-flood: [unbanme] $nick!$user\@$host banned as $baninfo->{banmask} in $baninfo->{channel}, but allowed through whitelist\n");
$self->{pbot}->{logger}->log("anti-flood: [unbanme] $nick!$user\@$host banned as $baninfo->{banmask} in $baninfo->{channel}, but allowed through whitelist\n");
} else {
if($channel eq lc $baninfo->{channel}) {
my $mode = $baninfo->{type} eq "+b" ? "banned" : "quieted";
$self->{pbot}->logger->log("anti-flood: [unbanme] $nick!$user\@$host $mode as $baninfo->{banmask} in $baninfo->{channel} by $baninfo->{owner}, unbanme rejected\n");
$self->{pbot}->{logger}->log("anti-flood: [unbanme] $nick!$user\@$host $mode as $baninfo->{banmask} in $baninfo->{channel} by $baninfo->{owner}, unbanme rejected\n");
return "/msg $nick You have been $mode as $baninfo->{banmask} by $baninfo->{owner}, unbanme will not work until it is removed.";
}
}
@ -431,7 +439,7 @@ sub unbanme {
return "/msg $nick You may only use unbanme for the first two offenses. You will be automatically unbanned in a few hours, and your offense counter will decrement once every 24 hours.";
}
$self->{pbot}->chanops->unban_user($mask, $channel);
$self->{pbot}->{chanops}->unban_user($mask, $channel);
return "/msg $nick You have been unbanned from $channel.";
}
@ -461,7 +469,7 @@ sub devalidate_accounts {
my ($self, $mask, $channel) = @_;
my @message_accounts;
#$self->{pbot}->logger->log("Devalidating accounts for $mask in $channel\n");
#$self->{pbot}->{logger}->log("Devalidating accounts for $mask in $channel\n");
if($mask =~ m/^\$a:(.*)/) {
my $ban_account = lc $1;
@ -474,7 +482,7 @@ sub devalidate_accounts {
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($account, $channel, 'validated');
if(defined $channel_data and $channel_data->{validated} & $self->{NICKSERV_VALIDATED}) {
$channel_data->{validated} &= ~$self->{NICKSERV_VALIDATED};
#$self->{pbot}->logger->log("Devalidating account $account\n");
#$self->{pbot}->{logger}->log("Devalidating account $account\n");
$self->{pbot}->{messagehistory}->{database}->update_channel_data($account, $channel, $channel_data);
}
}
@ -483,13 +491,13 @@ sub devalidate_accounts {
sub check_bans {
my ($self, $message_account, $mask, $channel) = @_;
#$self->{pbot}->logger->log("anti-flood: [check-bans] checking for bans on $mask in $channel\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] checking for bans on $mask in $channel\n");
my @nickserv_accounts = $self->{pbot}->{messagehistory}->{database}->get_nickserv_accounts($message_account);
my $current_nickserv_account = $self->{pbot}->{messagehistory}->{database}->get_current_nickserv_account($message_account);
if($current_nickserv_account) {
#$self->{pbot}->logger->log("anti-flood: [check-bans] current nickserv [$current_nickserv_account] found for $mask\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] current nickserv [$current_nickserv_account] found for $mask\n");
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($message_account, $channel, 'validated');
if($channel_data->{validated} & $self->{NEEDS_CHECKBAN}) {
$channel_data->{validated} &= ~$self->{NEEDS_CHECKBAN};
@ -502,7 +510,7 @@ sub check_bans {
$channel_data->{validated} |= $self->{NEEDS_CHECKBAN};
$self->{pbot}->{messagehistory}->{database}->update_channel_data($message_account, $channel, $channel_data);
}
#$self->{pbot}->logger->log("anti-flood: [check-bans] no account for $mask; marking for later validation\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] no account for $mask; marking for later validation\n");
}
my ($nick, $host) = $mask =~ m/^([^!]+)![^@]+\@(.*)$/;
@ -518,7 +526,7 @@ sub check_bans {
foreach my $nickserv_account (@nickserv_accounts) {
foreach my $key (@hostmask_nickserv_accounts) {
if($key eq $nickserv_account) {
#$self->{pbot}->logger->log("anti-flood: [check-bans] nickserv account for $hostmask->{hostmask} matches $nickserv_account\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] nickserv account for $hostmask->{hostmask} matches $nickserv_account\n");
$check_ban = 1;
goto CHECKBAN;
}
@ -528,7 +536,7 @@ sub check_bans {
# check if hosts match
my ($account_host) = $hostmask->{hostmask} =~ m/\@(.*)$/;
if($host eq $account_host) {
#$self->{pbot}->logger->log("anti-flood: [check-bans] host for $hostmask->{hostmask} matches $mask\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] host for $hostmask->{hostmask} matches $mask\n");
$check_ban = 1;
goto CHECKBAN;
}
@ -536,7 +544,7 @@ sub check_bans {
# check if nicks match
my ($account_nick) = $hostmask->{hostmask} =~ m/^([^!]+)/;
if($nick eq $account_nick) {
#$self->{pbot}->logger->log("anti-flood: [check-bans] nick for $hostmask->{hostmask} matches $mask\n");
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] nick for $hostmask->{hostmask} matches $mask\n");
$check_ban = 1;
goto CHECKBAN;
}
@ -548,13 +556,13 @@ sub check_bans {
}
foreach my $target_nickserv_account (@hostmask_nickserv_accounts) {
#$self->{pbot}->logger->log("anti-flood: [check-bans] checking for bans in $channel on $hostmask->{hostmask} using $target_nickserv_account\n");
my $baninfos = $self->{pbot}->bantracker->get_baninfo($hostmask->{hostmask}, $channel, $target_nickserv_account);
#$self->{pbot}->{logger}->log("anti-flood: [check-bans] checking for bans in $channel on $hostmask->{hostmask} using $target_nickserv_account\n");
my $baninfos = $self->{pbot}->{bantracker}->get_baninfo($hostmask->{hostmask}, $channel, $target_nickserv_account);
if(defined $baninfos) {
foreach my $baninfo (@$baninfos) {
if(time - $baninfo->{when} < 5) {
$self->{pbot}->logger->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} in $baninfo->{channel}, but within 5 seconds of establishing ban; giving another chance\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} in $baninfo->{channel}, but within 5 seconds of establishing ban; giving another chance\n");
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($message_account, $channel, 'validated');
if($channel_data->{validated} & $self->{NICKSERV_VALIDATED}) {
$channel_data->{validated} &= ~$self->{NICKSERV_VALIDATED};
@ -565,12 +573,12 @@ sub check_bans {
}
if($self->ban_whitelisted($baninfo->{channel}, $baninfo->{banmask})) {
$self->{pbot}->logger->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} in $baninfo->{channel}, but allowed through whitelist\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} in $baninfo->{channel}, but allowed through whitelist\n");
next;
}
if($baninfo->{type} eq '+b' and $baninfo->{banmask} =~ m/!\*@\*$/) {
$self->{pbot}->logger->log("anti-flood: [check-bans] Disregarding generic nick ban\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] Disregarding generic nick ban\n");
next;
}
@ -579,14 +587,14 @@ sub check_bans {
$banmask_regex =~ s/\\\?/./g;
if($baninfo->{type} eq '+q' and $mask =~ /^$banmask_regex$/i) {
$self->{pbot}->logger->log("anti-flood: [check-bans] Hostmask ($mask) matches quiet banmask ($banmask_regex), disregarding\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] Hostmask ($mask) matches quiet banmask ($banmask_regex), disregarding\n");
next;
}
my $skip_quiet_nickserv_mask = 0;
foreach my $nickserv_account (@nickserv_accounts) {
if($baninfo->{type} eq '+q' and $baninfo->{banmask} =~ /^\$a:(.*)/ and lc $1 eq $nickserv_account and $nickserv_account eq $current_nickserv_account) {
$self->{pbot}->logger->log("anti-flood: [check-bans] Hostmask ($mask) matches quiet on account ($nickserv_account), disregarding\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] Hostmask ($mask) matches quiet on account ($nickserv_account), disregarding\n");
$skip_quiet_nickserv_mask = 1;
} elsif($baninfo->{type} eq '+b' and $baninfo->{banmask} =~ /^\$a:(.*)/ and lc $1 eq $nickserv_account) {
$skip_quiet_nickserv_mask = 0;
@ -599,7 +607,7 @@ sub check_bans {
$bans = [];
}
$self->{pbot}->logger->log("anti-flood: [check-bans] Hostmask ($mask) matches $baninfo->{type} $baninfo->{banmask}, adding ban\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] Hostmask ($mask) matches $baninfo->{type} $baninfo->{banmask}, adding ban\n");
push @$bans, $baninfo;
next;
}
@ -613,10 +621,10 @@ sub check_bans {
my $banmask = "*!$1@" . address_to_mask($2);
foreach my $baninfo (@$bans) {
$self->{pbot}->logger->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} banned in $baninfo->{channel} by $baninfo->{owner}, banning $banmask\n");
$self->{pbot}->{logger}->log("anti-flood: [check-bans] $mask evaded $baninfo->{banmask} banned in $baninfo->{channel} by $baninfo->{owner}, banning $banmask\n");
my ($bannick) = $mask =~ m/^([^!]+)/;
$self->{pbot}->chanops->add_op_command($baninfo->{channel}, "kick $baninfo->{channel} $bannick Ban evasion");
$self->{pbot}->chanops->ban_user_timed($banmask, $baninfo->{channel}, 60 * 60 * 12);
$self->{pbot}->{chanops}->add_op_command($baninfo->{channel}, "kick $baninfo->{channel} $bannick Ban evasion");
$self->{pbot}->{chanops}->ban_user_timed($banmask, $baninfo->{channel}, 60 * 60 * 12);
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($message_account, $channel, 'validated');
if($channel_data->{validated} & $self->{NICKSERV_VALIDATED}) {
$channel_data->{validated} &= ~$self->{NICKSERV_VALIDATED};
@ -640,7 +648,7 @@ sub check_nickserv_accounts {
my $force_validation = 0;
my $message_account;
#$self->{pbot}->logger->log("Checking nickserv accounts for nick $nick with account $account and hostmask " . (defined $hostmask ? $hostmask : 'undef') . "\n");
#$self->{pbot}->{logger}->log("Checking nickserv accounts for nick $nick with account $account and hostmask " . (defined $hostmask ? $hostmask : 'undef') . "\n");
$account = lc $account;
@ -648,24 +656,24 @@ sub check_nickserv_accounts {
($message_account, $hostmask) = $self->{pbot}->{messagehistory}->{database}->find_message_account_by_nick($nick);
if(not defined $message_account) {
$self->{pbot}->logger->log("No message account found for nick $nick.\n");
$self->{pbot}->{logger}->log("No message account found for nick $nick.\n");
($message_account) = $self->{pbot}->{messagehistory}->{database}->find_message_accounts_by_nickserv($account);
if(not $message_account) {
$self->{pbot}->logger->log("No message account found for nickserv $account.\n");
$self->{pbot}->{logger}->log("No message account found for nickserv $account.\n");
return;
}
}
} else {
($message_account) = $self->{pbot}->{messagehistory}->{database}->find_message_accounts_by_mask($hostmask);
if(not $message_account) {
$self->{pbot}->logger->log("No message account found for hostmask $hostmask.\n");
$self->{pbot}->{logger}->log("No message account found for hostmask $hostmask.\n");
return;
}
$force_validation = 1;
}
#$self->{pbot}->logger->log("anti-flood: $message_account: setting nickserv account to [$account]\n");
#$self->{pbot}->{logger}->log("anti-flood: $message_account: setting nickserv account to [$account]\n");
$self->{pbot}->{messagehistory}->{database}->update_nickserv_account($message_account, $account, scalar gettimeofday);
$self->{pbot}->{messagehistory}->{database}->set_current_nickserv_account($message_account, $account);
@ -675,7 +683,7 @@ sub check_nickserv_accounts {
foreach my $channel (@channels) {
my $channel_data = $self->{pbot}->{messagehistory}->{database}->get_channel_data($message_account, $channel, 'validated');
if($force_validation or $channel_data->{validated} & $self->{NEEDS_CHECKBAN}) {
$self->{pbot}->logger->log("anti-flood: [check-account] $nick [nickserv: $account] needs check-ban validation for $hostmask in $channel.\n");
$self->{pbot}->{logger}->log("anti-flood: [check-account] $nick [nickserv: $account] needs check-ban validation for $hostmask in $channel.\n");
$self->check_bans($message_account, $hostmask, $channel);
}
}
@ -686,14 +694,14 @@ sub on_whoisaccount {
my $nick = $event->{args}[1];
my $account = lc $event->{args}[2];
$self->{pbot}->logger->log("$nick is using NickServ account [$account]\n");
$self->{pbot}->{logger}->log("$nick is using NickServ account [$account]\n");
$self->check_nickserv_accounts($nick, $account);
}
sub adjust_offenses {
my $self = shift;
#$self->{pbot}->logger->log("Adjusting offenses . . .\n");
#$self->{pbot}->{logger}->log("Adjusting offenses . . .\n");
# decrease offenses counter if 24 hours have elapsed since latest offense
my $channel_datas = $self->{pbot}->{messagehistory}->{database}->get_channel_datas_where_last_offense_older_than(gettimeofday - 60 * 60 * 24);
@ -703,7 +711,7 @@ sub adjust_offenses {
my $channel = delete $channel_data->{channel};
$channel_data->{offenses}--;
$channel_data->{last_offense} = gettimeofday;
#$self->{pbot}->logger->log("[adjust-offenses] [$id][$channel] 24 hours since last offense/decrease -- decreasing offenses to $channel_data->{offenses}\n");
#$self->{pbot}->{logger}->log("[adjust-offenses] [$id][$channel] 24 hours since last offense/decrease -- decreasing offenses to $channel_data->{offenses}\n");
$self->{pbot}->{messagehistory}->{database}->update_channel_data($id, $channel, $channel_data);
}
}
@ -713,7 +721,7 @@ sub adjust_offenses {
my $id = delete $channel_data->{id};
my $channel = delete $channel_data->{channel};
$channel_data->{enter_abuses}--;
#$self->{pbot}->logger->log("[adjust-offenses] [$id][$channel] decreasing enter abuse offenses to $channel_data->{enter_abuses}\n");
#$self->{pbot}->{logger}->log("[adjust-offenses] [$id][$channel] decreasing enter abuse offenses to $channel_data->{enter_abuses}\n");
$self->{pbot}->{messagehistory}->{database}->update_channel_data($id, $channel, $channel_data);
}

32
PBot/BanTracker.pm
View File

@ -36,7 +36,7 @@ sub initialize {
$self->{banlist} = {};
$pbot->commands->register(sub { return $self->dumpbans(@_) }, "dumpbans", 60);
$pbot->{commands}->register(sub { return $self->dumpbans(@_) }, "dumpbans", 60);
}
sub dumpbans {
@ -52,9 +52,9 @@ sub get_banlist {
delete $self->{banlist}->{$channel};
$self->{pbot}->logger->log("Retrieving banlist for $channel.\n");
$conn->sl("mode $channel +b");
$conn->sl("mode $channel +q");
$self->{pbot}->{logger}->log("Retrieving banlist for $channel.\n");
${conn}->sl("mode $channel +b");
${conn}->sl("mode $channel +q");
}
sub get_baninfo {
@ -64,7 +64,7 @@ sub get_baninfo {
$account = undef if $account eq '-1';
$account = lc $account if defined $account;
$self->{pbot}->logger->log("[get-baninfo] Getting baninfo for $mask in $channel using account " . (defined $account ? $account : "[undefined]") . "\n");
$self->{pbot}->{logger}->log("[get-baninfo] Getting baninfo for $mask in $channel using account " . (defined $account ? $account : "[undefined]") . "\n");
foreach my $mode (keys %{ $self->{banlist}{$channel} }) {
foreach my $banmask (keys %{ $self->{banlist}{$channel}{$mode} }) {
@ -90,7 +90,7 @@ sub get_baninfo {
$baninfo->{owner} = $self->{banlist}{$channel}{$mode}{$banmask_key}[0];
$baninfo->{when} = $self->{banlist}{$channel}{$mode}{$banmask_key}[1];
$baninfo->{type} = $mode;
$self->{pbot}->logger->log("get-baninfo: dump: " . Dumper($baninfo) . "\n");
$self->{pbot}->{logger}->log("get-baninfo: dump: " . Dumper($baninfo) . "\n");
push @$bans, $baninfo;
}
@ -109,7 +109,7 @@ sub on_quietlist_entry {
my $ago = ago(gettimeofday - $timestamp);
$self->{pbot}->logger->log("ban-tracker: [quietlist entry] $channel: $target quieted by $source $ago.\n");
$self->{pbot}->{logger}->log("ban-tracker: [quietlist entry] $channel: $target quieted by $source $ago.\n");
$self->{banlist}->{$channel}->{'+q'}->{$target} = [ $source, $timestamp ];
}
@ -122,7 +122,7 @@ sub on_banlist_entry {
my $ago = ago(gettimeofday - $timestamp);
$self->{pbot}->logger->log("ban-tracker: [banlist entry] $channel: $target banned by $source $ago.\n");
$self->{pbot}->{logger}->log("ban-tracker: [banlist entry] $channel: $target banned by $source $ago.\n");
$self->{banlist}->{$channel}->{'+b'}->{$target} = [ $source, $timestamp ];
}
@ -131,24 +131,24 @@ sub track_mode {
my ($source, $mode, $target, $channel) = @_;
if($mode eq "+b" or $mode eq "+q") {
$self->{pbot}->logger->log("ban-tracker: $target " . ($mode eq '+b' ? 'banned' : 'quieted') . " by $source in $channel.\n");
$self->{pbot}->{logger}->log("ban-tracker: $target " . ($mode eq '+b' ? 'banned' : 'quieted') . " by $source in $channel.\n");
$self->{banlist}->{$channel}->{$mode}->{$target} = [ $source, gettimeofday ];
$self->{pbot}->antiflood->devalidate_accounts($target, $channel);
$self->{pbot}->{antiflood}->devalidate_accounts($target, $channel);
}
elsif($mode eq "-b" or $mode eq "-q") {
$self->{pbot}->logger->log("ban-tracker: $target " . ($mode eq '-b' ? 'unbanned' : 'unquieted') . " by $source in $channel.\n");
$self->{pbot}->{logger}->log("ban-tracker: $target " . ($mode eq '-b' ? 'unbanned' : 'unquieted') . " by $source in $channel.\n");
delete $self->{banlist}->{$channel}->{$mode eq "-b" ? "+b" : "+q"}->{$target};
if($mode eq "-b") {
if($self->{pbot}->chanops->{unban_timeout}->find_index($channel, $target)) {
$self->{pbot}->chanops->{unban_timeout}->remove($channel, $target);
} elsif($self->{pbot}->chanops->{unban_timeout}->find_index($channel, "$target\$##stop_join_flood")) {
if($self->{pbot}->{chanops}->{unban_timeout}->find_index($channel, $target)) {
$self->{pbot}->{chanops}->{unban_timeout}->remove($channel, $target);
} elsif($self->{pbot}->{chanops}->{unban_timeout}->find_index($channel, "$target\$##stop_join_flood")) {
# freenode strips channel forwards from unban result if no ban exists with a channel forward
$self->{pbot}->chanops->{unban_timeout}->remove($channel, "$target\$##stop_join_flood");
$self->{pbot}->{chanops}->{unban_timeout}->remove($channel, "$target\$##stop_join_flood");
}
}
} else {
$self->{pbot}->logger->log("BanTracker: Unknown mode '$mode'\n");
$self->{pbot}->{logger}->log("BanTracker: Unknown mode '$mode'\n");
}
}

54
PBot/BotAdminCommands.pm
View File

@ -32,24 +32,24 @@ sub initialize {
$self->{pbot} = $pbot;
$pbot->commands->register(sub { return $self->login(@_) }, "login", 0);
$pbot->commands->register(sub { return $self->logout(@_) }, "logout", 0);
$pbot->commands->register(sub { return $self->join_channel(@_) }, "join", 45);
$pbot->commands->register(sub { return $self->part_channel(@_) }, "part", 45);
$pbot->commands->register(sub { return $self->ack_die(@_) }, "die", 50);
$pbot->commands->register(sub { return $self->adminadd(@_) }, "adminadd", 60);
$pbot->commands->register(sub { return $self->adminrem(@_) }, "adminrem", 60);
$pbot->commands->register(sub { return $self->adminset(@_) }, "adminset", 60);
$pbot->commands->register(sub { return $self->adminunset(@_) }, "adminunset", 60);
$pbot->commands->register(sub { return $self->sl(@_) }, "sl", 60);
$pbot->commands->register(sub { return $self->export(@_) }, "export", 60);
$pbot->{commands}->register(sub { return $self->login(@_) }, "login", 0);
$pbot->{commands}->register(sub { return $self->logout(@_) }, "logout", 0);
$pbot->{commands}->register(sub { return $self->join_channel(@_) }, "join", 45);
$pbot->{commands}->register(sub { return $self->part_channel(@_) }, "part", 45);
$pbot->{commands}->register(sub { return $self->ack_die(@_) }, "die", 50);
$pbot->{commands}->register(sub { return $self->adminadd(@_) }, "adminadd", 60);
$pbot->{commands}->register(sub { return $self->adminrem(@_) }, "adminrem", 60);
$pbot->{commands}->register(sub { return $self->adminset(@_) }, "adminset", 60);
$pbot->{commands}->register(sub { return $self->adminunset(@_) }, "adminunset", 60);
$pbot->{commands}->register(sub { return $self->sl(@_) }, "sl", 60);
$pbot->{commands}->register(sub { return $self->export(@_) }, "export", 60);
}
sub sl {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
$self->{pbot}->conn->sl($arguments);
$self->{pbot}->{conn}->sl($arguments);
return "Sent.\n";
}
@ -57,19 +57,19 @@ sub login {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
if($self->{pbot}->admins->loggedin($from, "$nick!$user\@$host")) {
if($self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host")) {
return "/msg $nick You are already logged into channel $from.";
}
my $result = $self->{pbot}->admins->login($from, "$nick!$user\@$host", $arguments);
my $result = $self->{pbot}->{admins}->login($from, "$nick!$user\@$host", $arguments);
return "/msg $nick $result";
}
sub logout {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
return "/msg $nick Uh, you aren't logged into channel $from." if(not $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host"));
$self->{pbot}->admins->logout($from, "$nick!$user\@$host");
return "/msg $nick Uh, you aren't logged into channel $from." if(not $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host"));
$self->{pbot}->{admins}->logout($from, "$nick!$user\@$host");
return "/msg $nick Good-bye, $nick.";
}
@ -114,7 +114,7 @@ sub adminset {
return "Usage: adminset <channel> <hostmask> <key> <value>";
}
return $self->{pbot}->admins->admins->set($channel, $hostmask, $key, $value);
return $self->{pbot}->{admins}->{admins}->set($channel, $hostmask, $key, $value);
}
sub adminunset {
@ -126,7 +126,7 @@ sub adminunset {
return "Usage: adminunset <channel> <hostmask> <key>";
}
return $self->{pbot}->admins->admins->unset($channel, $hostmask, $key);
return $self->{pbot}->{admins}->{admins}->unset($channel, $hostmask, $key);
}
@ -135,8 +135,8 @@ sub join_channel {
my ($from, $nick, $user, $host, $arguments) = @_;
foreach my $channel (split /\s+/, $arguments) {
$self->{pbot}->logger->log("$nick!$user\@$host made me join $channel\n");
$self->{pbot}->conn->join($channel);
$self->{pbot}->{logger}->log("$nick!$user\@$host made me join $channel\n");
$self->{pbot}->{conn}->join($channel);
}
return "/msg $nick Joining $arguments";
@ -149,8 +149,8 @@ sub part_channel {
$arguments = $from if not $arguments;
foreach my $channel (split /\s+/, $arguments) {
$self->{pbot}->logger->log("$nick!$user\@$host made me part $channel\n");
$self->{pbot}->conn->part($channel);
$self->{pbot}->{logger}->log("$nick!$user\@$host made me part $channel\n");
$self->{pbot}->{conn}->part($channel);
}
return "/msg $nick Parting $arguments";
@ -159,10 +159,10 @@ sub part_channel {
sub ack_die {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
$self->{pbot}->logger->log("$nick!$user\@$host made me exit.\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host made me exit.\n");
$self->{pbot}->atexit();
$self->{pbot}->conn->privmsg($from, "Good-bye.") if defined $from;
$self->{pbot}->conn->quit("Departure requested.");
$self->{pbot}->{conn}->privmsg($from, "Good-bye.") if defined $from;
$self->{pbot}->{conn}->quit("Departure requested.");
exit 0;
}
@ -179,11 +179,11 @@ sub export {
}
if($arguments =~ /^quotegrabs$/i) {
return $self->{pbot}->quotegrabs->export_quotegrabs;
return $self->{pbot}->{quotegrabs}->export_quotegrabs;
}
if($arguments =~ /^factoids$/i) {
return $self->{pbot}->factoids->export_factoids;
return $self->{pbot}->{factoids}->export_factoids;
}
if($arguments =~ /^admins$/i) {

56
PBot/BotAdmins.pm
View File

@ -58,11 +58,11 @@ sub add_admin {
$channel = lc $channel;
$hostmask = lc $hostmask;
$self->admins->hash->{$channel}->{$hostmask}->{name} = $name;
$self->admins->hash->{$channel}->{$hostmask}->{level} = $level;
$self->admins->hash->{$channel}->{$hostmask}->{password} = $password;
$self->{admins}->hash->{$channel}->{$hostmask}->{name} = $name;
$self->{admins}->hash->{$channel}->{$hostmask}->{level} = $level;
$self->{admins}->hash->{$channel}->{$hostmask}->{password} = $password;
$self->{pbot}->logger->log("Adding new level $level admin: [$name] [$hostmask] for channel [$channel]\n");
$self->{pbot}->{logger}->log("Adding new level $level admin: [$name] [$hostmask] for channel [$channel]\n");
$self->save_admins unless $dont_save;
}
@ -71,13 +71,13 @@ sub remove_admin {
my $self = shift;
my ($channel, $hostmask) = @_;
my $admin = delete $self->admins->hash->{$channel}->{$hostmask};
my $admin = delete $self->{admins}->hash->{$channel}->{$hostmask};
if(defined $admin) {
$self->{pbot}->logger->log("Removed level $admin->{level} admin [$admin->{name}] [$hostmask] from channel [$channel]\n");
$self->{pbot}->{logger}->log("Removed level $admin->{level} admin [$admin->{name}] [$hostmask] from channel [$channel]\n");
$self->save_admins;
return 1;
} else {
$self->{pbot}->logger->log("Attempt to remove non-existent admin [$hostmask] from channel [$channel]\n");
$self->{pbot}->{logger}->log("Attempt to remove non-existent admin [$hostmask] from channel [$channel]\n");
return 0;
}
}
@ -86,43 +86,43 @@ sub load_admins {
my $self = shift;
my $filename;
if(@_) { $filename = shift; } else { $filename = $self->admins->filename; }
if(@_) { $filename = shift; } else { $filename = $self->{admins}->filename; }
if(not defined $filename) {
Carp::carp "No admins path specified -- skipping loading of admins";
return;
}
$self->{pbot}->logger->log("Loading admins from $filename ...\n");
$self->{pbot}->{logger}->log("Loading admins from $filename ...\n");
$self->admins->load;
$self->{admins}->load;
my $i = 0;
foreach my $channel (keys %{ $self->admins->hash } ) {
foreach my $hostmask (keys %{ $self->admins->hash->{$channel} }) {
foreach my $channel (keys %{ $self->{admins}->hash } ) {
foreach my $hostmask (keys %{ $self->{admins}->hash->{$channel} }) {
$i++;
my $name = $self->admins->hash->{$channel}->{$hostmask}->{name};
my $level = $self->admins->hash->{$channel}->{$hostmask}->{level};
my $password = $self->admins->hash->{$channel}->{$hostmask}->{password};
my $name = $self->{admins}->hash->{$channel}->{$hostmask}->{name};
my $level = $self->{admins}->hash->{$channel}->{$hostmask}->{level};
my $password = $self->{admins}->hash->{$channel}->{$hostmask}->{password};
if(not defined $name or not defined $level or not defined $password) {
Carp::croak "Syntax error around line $i of $filename\n";
}
$self->{pbot}->logger->log("Adding new level $level admin: [$name] [$hostmask] for channel [$channel]\n");
$self->{pbot}->{logger}->log("Adding new level $level admin: [$name] [$hostmask] for channel [$channel]\n");
}
}
$self->{pbot}->logger->log(" $i admins loaded.\n");
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log(" $i admins loaded.\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save_admins {
my $self = shift;
$self->admins->save;
$self->{admins}->save;
$self->export_admins;
}
@ -143,10 +143,10 @@ sub find_admin {
$hostmask = '.*' if not defined $hostmask;
my $result = eval {
foreach my $channel_regex (keys %{ $self->admins->hash }) {
foreach my $channel_regex (keys %{ $self->{admins}->hash }) {
if($from !~ m/^#/) {
# if not from a channel, make sure that nick portion of hostmask matches $from
foreach my $hostmask_regex (keys %{ $self->admins->hash->{$channel_regex} }) {
foreach my $hostmask_regex (keys %{ $self->{admins}->hash->{$channel_regex} }) {
my $nick;
if($hostmask_regex =~ m/^([^!]+)!.*/) {
@ -155,11 +155,11 @@ sub find_admin {
$nick = $hostmask_regex;
}
return $self->admins->hash->{$channel_regex}->{$hostmask_regex} if($from =~ m/$nick/i and $hostmask =~ m/$hostmask_regex/i);
return $self->{admins}->hash->{$channel_regex}->{$hostmask_regex} if($from =~ m/$nick/i and $hostmask =~ m/$hostmask_regex/i);
}
} elsif($from =~ m/$channel_regex/i) {
foreach my $hostmask_regex (keys %{ $self->admins->hash->{$channel_regex} }) {
return $self->admins->hash->{$channel_regex}->{$hostmask_regex} if $hostmask =~ m/$hostmask_regex/i;
foreach my $hostmask_regex (keys %{ $self->{admins}->hash->{$channel_regex} }) {
return $self->{admins}->hash->{$channel_regex}->{$hostmask_regex} if $hostmask =~ m/$hostmask_regex/i;
}
}
}
@ -167,7 +167,7 @@ sub find_admin {
};
if($@) {
$self->{pbot}->logger->log("Error in find_admin parameters: $@\n");
$self->{pbot}->{logger}->log("Error in find_admin parameters: $@\n");
}
return $result;
@ -191,18 +191,18 @@ sub login {
my $admin = $self->find_admin($channel, $hostmask);
if(not defined $admin) {
$self->{pbot}->logger->log("Attempt to login non-existent [$channel][$hostmask] failed\n");
$self->{pbot}->{logger}->log("Attempt to login non-existent [$channel][$hostmask] failed\n");
return "You do not have an account in $channel.";
}
if($admin->{password} ne $password) {
$self->{pbot}->logger->log("Bad login password for [$channel][$hostmask]\n");
$self->{pbot}->{logger}->log("Bad login password for [$channel][$hostmask]\n");
return "I don't think so.";
}
$admin->{loggedin} = 1;
$self->{pbot}->logger->log("$hostmask logged into $channel\n");
$self->{pbot}->{logger}->log("$hostmask logged into $channel\n");
return "Logged into $channel.";
}

28
PBot/ChanOpCommands.pm
View File

@ -32,9 +32,9 @@ sub initialize {
$self->{pbot} = $pbot;
$pbot->commands->register(sub { return $self->ban_user(@_) }, "ban", 10);
$pbot->commands->register(sub { return $self->unban_user(@_) }, "unban", 10);
$pbot->commands->register(sub { return $self->kick_user(@_) }, "kick", 10);
$pbot->{commands}->register(sub { return $self->ban_user(@_) }, "ban", 10);
$pbot->{commands}->register(sub { return $self->unban_user(@_) }, "unban", 10);
$pbot->{commands}->register(sub { return $self->kick_user(@_) }, "kick", 10);
}
sub ban_user {
@ -43,7 +43,7 @@ sub ban_user {
my ($target, $length) = split(/\s+/, $arguments);
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}
@ -62,7 +62,7 @@ sub ban_user {
my $botnick = $self->{pbot}->{registry}->get_value('irc', 'botnick');
return "" if $target =~ /\Q$botnick\E/i;
$self->{pbot}->chanops->ban_user_timed($target, $from, $length);
$self->{pbot}->{chanops}->ban_user_timed($target, $from, $length);
return "/msg $nick $target banned in $from for $length seconds";
}
@ -71,7 +71,7 @@ sub unban_user {
my ($from, $nick, $user, $host, $arguments) = @_;
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}
@ -85,7 +85,7 @@ sub unban_user {
return "/msg $nick Usage for /msg: !unban $target <channel>" if $channel !~ /^#/;
$self->{pbot}->chanops->unban_user($target, $channel);
$self->{pbot}->{chanops}->unban_user($target, $channel);
return "/msg $nick $target has been unbanned from $channel.";
}
@ -94,29 +94,29 @@ sub kick_user {
my ($from, $nick, $user, $host, $arguments) = @_;
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}
# used in private message
if(not $from =~ /^#/) {
if(not $arguments =~ /(^#\S+) (\S+) (.*)/) {
$self->{pbot}->logger->log("$nick!$user\@$host: invalid arguments to kick\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host: invalid arguments to kick\n");
return "/msg $nick Usage from private message: kick <channel> <nick> <reason>";
}
$self->{pbot}->chanops->add_op_command($1, "kick $1 $2 $3");
$self->{pbot}->chanops->gain_ops($1);
$self->{pbot}->{chanops}->add_op_command($1, "kick $1 $2 $3");
$self->{pbot}->{chanops}->gain_ops($1);
return "/msg $nick Kicking $2 from $1 with reason '$3'";
}
# used in channel
if(not $arguments =~ /(.*?) (.*)/) {
$self->{pbot}->logger->log("$nick!$user\@$host: invalid arguments to kick\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host: invalid arguments to kick\n");
return "/msg $nick Usage: kick <nick> <reason>";
}
$self->{pbot}->chanops->add_op_command($from, "kick $from $1 $2");
$self->{pbot}->chanops->gain_ops($from);
$self->{pbot}->{chanops}->add_op_command($from, "kick $from $1 $2");
$self->{pbot}->{chanops}->gain_ops($from);
return "/msg $nick Kicking $1 from $from with reason '$2'";
}

24
PBot/ChanOps.pm
View File

@ -41,8 +41,8 @@ sub initialize {
$self->{commands} = PBot::ChanOpCommands->new(pbot => $pbot);
$pbot->timer->register(sub { $self->check_opped_timeouts }, 10);
$pbot->timer->register(sub { $self->check_unban_timeouts }, 10);
$pbot->{timer}->register(sub { $self->check_opped_timeouts }, 10);
$pbot->{timer}->register(sub { $self->check_unban_timeouts }, 10);
}
sub gain_ops {
@ -50,7 +50,7 @@ sub gain_ops {
my $channel = shift;
if(not exists $self->{is_opped}->{$channel}) {
$self->{pbot}->conn->privmsg("chanserv", "op $channel");
$self->{pbot}->{conn}->privmsg("chanserv", "op $channel");
$self->{is_opped}->{$channel}{timeout} = gettimeofday + 300; # assume we're going to be opped
} else {
$self->perform_op_commands($channel);
@ -60,7 +60,7 @@ sub gain_ops {
sub lose_ops {
my $self = shift;
my $channel = shift;
$self->{pbot}->conn->privmsg("chanserv", "op $channel -" . $self->{pbot}->{registry}->get_value('irc', 'botnick'));
$self->{pbot}->{conn}->privmsg("chanserv", "op $channel -" . $self->{pbot}->{registry}->get_value('irc', 'botnick'));
}
sub add_op_command {
@ -73,17 +73,17 @@ sub perform_op_commands {
my $channel = shift;
my $botnick = $self->{pbot}->{registry}->get_value('irc', 'botnick');
$self->{pbot}->logger->log("Performing op commands...\n");
$self->{pbot}->{logger}->log("Performing op commands...\n");
while(my $command = shift @{ $self->{op_commands}->{$channel} }) {
if($command =~ /^mode (.*?) (.*)/i) {
$self->{pbot}->conn->mode($1, $2);
$self->{pbot}->logger->log(" executing mode $1 $2\n");
$self->{pbot}->{conn}->mode($1, $2);
$self->{pbot}->{logger}->log(" executing mode $1 $2\n");
} elsif($command =~ /^kick (.*?) (.*?) (.*)/i) {
$self->{pbot}->conn->kick($1, $2, $3) unless $1 =~ /\Q$botnick\E/i;
$self->{pbot}->logger->log(" executing kick on $1 $2 $3\n");
$self->{pbot}->{conn}->kick($1, $2, $3) unless $1 =~ /\Q$botnick\E/i;
$self->{pbot}->{logger}->log(" executing kick on $1 $2 $3\n");
}
}
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub ban_user {
@ -97,7 +97,7 @@ sub ban_user {
sub unban_user {
my $self = shift;
my ($mask, $channel) = @_;
$self->{pbot}->logger->log("Unbanning $channel $mask\n");
$self->{pbot}->{logger}->log("Unbanning $channel $mask\n");
if($self->{unban_timeout}->find_index($channel, $mask)) {
$self->{unban_timeout}->hash->{$channel}->{$mask}{timeout} = gettimeofday + 7200; # try again in 2 hours if unban doesn't immediately succeed
$self->{unban_timeout}->save;
@ -141,7 +141,7 @@ sub check_opped_timeouts {
delete $self->{is_opped}->{$channel}; # assume chanserv is alive and deop will succeed
} else {
# my $timediff = $self->{is_opped}->{$channel}{timeout} - $now;
# $self->{pbot}->logger->log("deop $channel in $timediff seconds\n");
# $self->{pbot}->{logger}->log("deop $channel in $timediff seconds\n");
}
}
}

28
PBot/Channels.pm
View File

@ -31,11 +31,11 @@ sub initialize {
$self->{channels} = PBot::HashObject->new(pbot => $self->{pbot}, name => 'Channels', filename => delete $conf{filename});
$self->load_channels;
$self->{pbot}->commands->register(sub { $self->set(@_) }, "chanset", 40);
$self->{pbot}->commands->register(sub { $self->unset(@_) }, "chanunset", 40);
$self->{pbot}->commands->register(sub { $self->add(@_) }, "chanadd", 40);
$self->{pbot}->commands->register(sub { $self->remove(@_) }, "chanrem", 40);
$self->{pbot}->commands->register(sub { $self->list(@_) }, "chanlist", 10);
$self->{pbot}->{commands}->register(sub { $self->set(@_) }, "chanset", 40);
$self->{pbot}->{commands}->register(sub { $self->unset(@_) }, "chanunset", 40);
$self->{pbot}->{commands}->register(sub { $self->add(@_) }, "chanadd", 40);
$self->{pbot}->{commands}->register(sub { $self->remove(@_) }, "chanrem", 40);
$self->{pbot}->{commands}->register(sub { $self->list(@_) }, "chanlist", 10);
}
sub set {
@ -46,7 +46,7 @@ sub set {
return "Usage: chanset <channel> [key <value>]";
}
return $self->channels->set($channel, $key, $value);
return $self->{channels}->set($channel, $key, $value);
}
sub unset {
@ -57,7 +57,7 @@ sub unset {
return "Usage: chanunset <channel> <key>";
}
return "msg $nick " . $self->channels->unset($channel, $key);
return "msg $nick " . $self->{channels}->unset($channel, $key);
}
sub add {
@ -71,7 +71,7 @@ sub add {
$hash->{enabled} = 1;
$hash->{chanop} = 0;
return "/msg $nick " . $self->channels->add($arguments, $hash);
return "/msg $nick " . $self->{channels}->add($arguments, $hash);
}
sub remove {
@ -81,18 +81,18 @@ sub remove {
return "/msg $nick Usage: chanrem <channel>";
}
return "/msg $nick " . $self->channels->remove($arguments);
return "/msg $nick " . $self->{channels}->remove($arguments);
}
sub list {
my ($self, $from, $nick, $user, $host, $arguments) = @_;
my $result;
foreach my $index (sort keys %{ $self->channels->hash }) {
foreach my $index (sort keys %{ $self->{channels}->hash }) {
$result .= "$index: {";
my $comma = ' ';
foreach my $key (sort keys %{ ${ $self->channels->hash }{$index} }) {
$result .= "$comma$key => ${ $self->channels->hash }{$index}{$key}";
foreach my $key (sort keys %{ ${ $self->{channels}->hash }{$index} }) {
$result .= "$comma$key => ${ $self->{channels}->hash }{$index}{$key}";
$comma = ', ';
}
$result .= " }\n";
@ -103,13 +103,13 @@ sub list {
sub load_channels {
my $self = shift;
$self->channels->load_hash();
$self->{channels}->load_hash();
}
sub save_channels {
my $self = shift;
$self->channels->save_hash();
$self->{channels}->save_hash();
}
sub channels {

2
PBot/Commands.pm
View File

@ -80,7 +80,7 @@ sub interpreter {
my $pbot = $self->{pbot};
my $admin = $pbot->admins->loggedin($from, "$nick!$user\@$host");
my $admin = $pbot->{admins}->loggedin($from, "$nick!$user\@$host");
my $level = defined $admin ? $admin->{level} : 0;

296
PBot/FactoidCommands.pm
View File

@ -52,30 +52,30 @@ sub initialize {
$self->{pbot} = $pbot;
$pbot->commands->register(sub { return $self->factadd(@_) }, "learn", 0);
$pbot->commands->register(sub { return $self->factadd(@_) }, "factadd", 0);
$pbot->commands->register(sub { return $self->factrem(@_) }, "forget", 0);
$pbot->commands->register(sub { return $self->factrem(@_) }, "factrem", 0);
$pbot->commands->register(sub { return $self->factshow(@_) }, "factshow", 0);
$pbot->commands->register(sub { return $self->factinfo(@_) }, "factinfo", 0);
$pbot->commands->register(sub { return $self->factset(@_) }, "factset", 0);
$pbot->commands->register(sub { return $self->factunset(@_) }, "factunset", 0);
$pbot->commands->register(sub { return $self->factchange(@_) }, "factchange", 0);
$pbot->commands->register(sub { return $self->factalias(@_) }, "factalias", 0);
$pbot->commands->register(sub { return $self->call_factoid(@_) }, "fact", 0);
$pbot->commands->register(sub { return $self->factfind(@_) }, "factfind", 0);
$pbot->commands->register(sub { return $self->list(@_) }, "list", 0);
$pbot->commands->register(sub { return $self->top20(@_) }, "top20", 0);
$pbot->{commands}->register(sub { return $self->factadd(@_) }, "learn", 0);
$pbot->{commands}->register(sub { return $self->factadd(@_) }, "factadd", 0);
$pbot->{commands}->register(sub { return $self->factrem(@_) }, "forget", 0);
$pbot->{commands}->register(sub { return $self->factrem(@_) }, "factrem", 0);
$pbot->{commands}->register(sub { return $self->factshow(@_) }, "factshow", 0);
$pbot->{commands}->register(sub { return $self->factinfo(@_) }, "factinfo", 0);
$pbot->{commands}->register(sub { return $self->factset(@_) }, "factset", 0);
$pbot->{commands}->register(sub { return $self->factunset(@_) }, "factunset", 0);
$pbot->{commands}->register(sub { return $self->factchange(@_) }, "factchange", 0);
$pbot->{commands}->register(sub { return $self->factalias(@_) }, "factalias", 0);
$pbot->{commands}->register(sub { return $self->call_factoid(@_) }, "fact", 0);
$pbot->{commands}->register(sub { return $self->factfind(@_) }, "factfind", 0);
$pbot->{commands}->register(sub { return $self->list(@_) }, "list", 0);
$pbot->{commands}->register(sub { return $self->top20(@_) }, "top20", 0);
# the following commands have not yet been updated to use the new factoid structure
# DO NOT USE!! Factoid corruption may occur.
$pbot->commands->register(sub { return $self->add_regex(@_) }, "regex", 999);
$pbot->commands->register(sub { return $self->histogram(@_) }, "histogram", 999);
$pbot->commands->register(sub { return $self->count(@_) }, "count", 999);
$pbot->commands->register(sub { return $self->load_module(@_) }, "load", 999);
$pbot->commands->register(sub { return $self->unload_module(@_) }, "unload", 999);
$pbot->commands->register(sub { return $self->enable_command(@_) }, "enable", 999);
$pbot->commands->register(sub { return $self->disable_command(@_) }, "disable", 999);
$pbot->{commands}->register(sub { return $self->add_regex(@_) }, "regex", 999);
$pbot->{commands}->register(sub { return $self->histogram(@_) }, "histogram", 999);
$pbot->{commands}->register(sub { return $self->count(@_) }, "count", 999);
$pbot->{commands}->register(sub { return $self->load_module(@_) }, "load", 999);
$pbot->{commands}->register(sub { return $self->unload_module(@_) }, "unload", 999);
$pbot->{commands}->register(sub { return $self->enable_command(@_) }, "enable", 999);
$pbot->{commands}->register(sub { return $self->disable_command(@_) }, "disable", 999);
}
sub call_factoid {
@ -87,13 +87,13 @@ sub call_factoid {
return "Usage: fact <channel> <keyword> [arguments]";
}
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($chan, $keyword, $args, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($chan, $keyword, $args, 1);
if(not defined $trigger) {
return "No such factoid '$keyword' exists for channel '$chan'";
}
return $self->{pbot}->factoids->interpreter($channel, $nick, $user, $host, 1, $trigger, $args);
return $self->{pbot}->{factoids}->interpreter($channel, $nick, $user, $host, 1, $trigger, $args);
}
sub factset {
@ -105,7 +105,7 @@ sub factset {
return "Usage: factset <channel> <factoid> [key [value]]";
}
my $admininfo = $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host");
my $admininfo = $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host");
my $level = 0;
my $meta_level = 0;
@ -128,10 +128,10 @@ sub factset {
}
}
my ($owner_channel, $owner_trigger) = $self->{pbot}->factoids->find_factoid($channel, $trigger, undef, 1);
my ($owner_channel, $owner_trigger) = $self->{pbot}->{factoids}->find_factoid($channel, $trigger, undef, 1);
if(defined $owner_channel) {
my $factoid = $self->{pbot}->factoids->factoids->hash->{$owner_channel}->{$owner_trigger};
my $factoid = $self->{pbot}->{factoids}->{factoids}->hash->{$owner_channel}->{$owner_trigger};
my ($owner) = $factoid->{'owner'} =~ m/([^!]+)/;
@ -140,7 +140,7 @@ sub factset {
}
}
return $self->{pbot}->factoids->factoids->set($channel, $trigger, $key, $value);
return $self->{pbot}->{factoids}->{factoids}->set($channel, $trigger, $key, $value);
}
sub factunset {
@ -152,7 +152,7 @@ sub factunset {
return "Usage: factunset <channel> <factoid> <key>"
}
my $admininfo = $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host");
my $admininfo = $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host");
my $level = 0;
my $meta_level = 0;
@ -173,10 +173,10 @@ sub factunset {
}
}
my ($owner_channel, $owner_trigger) = $self->{pbot}->factoids->find_factoid($channel, $trigger, undef, 1);
my ($owner_channel, $owner_trigger) = $self->{pbot}->{factoids}->find_factoid($channel, $trigger, undef, 1);
if(defined $owner_channel) {
my $factoid = $self->{pbot}->factoids->factoids->hash->{$owner_channel}->{$owner_trigger};
my $factoid = $self->{pbot}->{factoids}->{factoids}->hash->{$owner_channel}->{$owner_trigger};
my ($owner) = $factoid->{'owner'} =~ m/([^!]+)/;
@ -185,7 +185,7 @@ sub factunset {
}
}
return $self->{pbot}->factoids->factoids->unset($channel, $trigger, $key);
return $self->{pbot}->{factoids}->{factoids}->unset($channel, $trigger, $key);
}
sub list {
@ -207,26 +207,26 @@ sub list {
my @results = eval {
my @ret;
foreach my $history_mask (keys %{ $self->{pbot}->antiflood->message_history }) {
foreach my $history_mask (keys %{ $self->{pbot}->{antiflood}->message_history }) {
my $nickserv = "(undef)";
$nickserv = $self->{pbot}->antiflood->message_history->{$history_mask}->{nickserv_account} if exists $self->{pbot}->antiflood->message_history->{$history_mask}->{nickserv_account};
$nickserv = $self->{pbot}->{antiflood}->message_history->{$history_mask}->{nickserv_account} if exists $self->{pbot}->{antiflood}->message_history->{$history_mask}->{nickserv_account};
if($history_mask =~ m/$mask_search/i) {
my $bot_trigger = $self->{pbot}->{registry}->get_value('general', 'trigger');
foreach my $history_channel (keys %{ $self->{pbot}->antiflood->message_history->{$history_mask}->{channels} }) {
foreach my $history_channel (keys %{ $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels} }) {
if($history_channel =~ m/$channel_search/i) {
my @messages = @{ $self->{pbot}->antiflood->message_history->{$history_mask}->{channels}->{$history_channel}{messages} };
my @messages = @{ $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels}->{$history_channel}{messages} };
for(my $i = 0; $i <= $#messages; $i++) {
next if $messages[$i]->{msg} =~ /^\Q$bot_trigger\E?login/; # don't reveal login passwords
print "$history_mask, $history_channel\n";
print "joinwatch: ", $self->{pbot}->antiflood->message_history->{$history_mask}->{channels}->{$history_channel}{join_watch}, "\n";
print "joinwatch: ", $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels}->{$history_channel}{join_watch}, "\n";
push @ret, {
offenses => $self->{pbot}->antiflood->message_history->{$history_mask}->{channels}->{$history_channel}{offenses},
last_offense_timestamp => $self->{pbot}->antiflood->message_history->{$history_mask}->{channels}->{$history_channel}{last_offense_timestamp},
join_watch => $self->{pbot}->antiflood->message_history->{$history_mask}->{channels}->{$history_channel}{join_watch},
offenses => $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels}->{$history_channel}{offenses},
last_offense_timestamp => $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels}->{$history_channel}{last_offense_timestamp},
join_watch => $self->{pbot}->{antiflood}->message_history->{$history_mask}->{channels}->{$history_channel}{join_watch},
text => $messages[$i]->{msg},
timestamp => $messages[$i]->{timestamp},
mask => $history_mask,
@ -242,7 +242,7 @@ sub list {
};
if($@) {
$self->{pbot}->logger->log("Error in search parameters: $@\n");
$self->{pbot}->{logger}->log("Error in search parameters: $@\n");
return "Error in search parameters: $@";
}
@ -259,7 +259,7 @@ sub list {
$text .= "[$msg->{channel}] " . localtime($msg->{timestamp}) . " <$msg->{mask}> " . $msg->{text} . "\n";
}
$self->{pbot}->logger->log($text);
$self->{pbot}->{logger}->log($text);
return "Messages:\n\n$text";
}
=cut
@ -267,9 +267,9 @@ sub list {
if($arguments =~ /^modules$/i) {
$from = '.*' if not defined $from or $from !~ /^#/;
$text = "Loaded modules for channel $from: ";
foreach my $channel (sort keys %{ $self->{pbot}->factoids->factoids->hash }) {
foreach my $command (sort keys %{ $self->{pbot}->factoids->factoids->hash->{$channel} }) {
if($self->{pbot}->factoids->factoids->hash->{$channel}->{$command}->{type} eq 'module') {
foreach my $channel (sort keys %{ $self->{pbot}->{factoids}->{factoids}->hash }) {
foreach my $command (sort keys %{ $self->{pbot}->{factoids}->{factoids}->hash->{$channel} }) {
if($self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$command}->{type} eq 'module') {
$text .= "$command ";
}
}
@ -279,7 +279,7 @@ sub list {
if($arguments =~ /^commands$/i) {
$text = "Registered commands: ";
foreach my $command (sort { $a->{name} cmp $b->{name} } @{ $self->{pbot}->commands->{handlers} }) {
foreach my $command (sort { $a->{name} cmp $b->{name} } @{ $self->{pbot}->{commands}->{handlers} }) {
$text .= "$command->{name} ";
$text .= "($command->{level}) " if $command->{level} > 0;
}
@ -287,23 +287,23 @@ sub list {
}
if($arguments =~ /^factoids$/i) {
return "For a list of factoids see " . $self->{pbot}->factoids->export_site;
return "For a list of factoids see " . $self->{pbot}->{factoids}->export_site;
}
if($arguments =~ /^admins$/i) {
$text = "Admins: ";
my $last_channel = "";
my $sep = "";
foreach my $channel (sort keys %{ $self->{pbot}->admins->admins->hash }) {
foreach my $channel (sort keys %{ $self->{pbot}->{admins}->{admins}->hash }) {
if($last_channel ne $channel) {
$text .= $sep . "Channel " . ($channel eq ".*" ? "all" : $channel) . ": ";
$last_channel = $channel;
$sep = "";
}
foreach my $hostmask (sort keys %{ $self->{pbot}->admins->admins->hash->{$channel} }) {
foreach my $hostmask (sort keys %{ $self->{pbot}->{admins}->{admins}->hash->{$channel} }) {
$text .= $sep;
$text .= "*" if exists $self->{pbot}->admins->admins->hash->{$channel}->{$hostmask}->{loggedin};
$text .= $self->{pbot}->admins->admins->hash->{$channel}->{$hostmask}->{name} . " (" . $self->{pbot}->admins->admins->hash->{$channel}->{$hostmask}->{level} . ")";
$text .= "*" if exists $self->{pbot}->{admins}->{admins}->hash->{$channel}->{$hostmask}->{loggedin};
$text .= $self->{pbot}->{admins}->{admins}->hash->{$channel}->{$hostmask}->{name} . " (" . $self->{pbot}->{admins}->{admins}->hash->{$channel}->{$hostmask}->{level} . ")";
$sep = "; ";
}
}
@ -323,32 +323,32 @@ sub factalias {
$chan = '.*' if $chan !~ /^#/;
my ($channel, $alias_trigger) = $self->{pbot}->factoids->find_factoid($chan, $alias, undef, 1);
my ($channel, $alias_trigger) = $self->{pbot}->{factoids}->find_factoid($chan, $alias, undef, 1);
if(defined $alias_trigger) {
$self->{pbot}->logger->log("attempt to overwrite existing command\n");
$self->{pbot}->{logger}->log("attempt to overwrite existing command\n");
return "/msg $nick '$alias_trigger' already exists for channel $channel";
}
$self->{pbot}->factoids->add_factoid('text', $chan, "$nick!$user\@$host", $alias, "/call $command");
$self->{pbot}->{factoids}->add_factoid('text', $chan, "$nick!$user\@$host", $alias, "/call $command");
$self->{pbot}->logger->log("$nick!$user\@$host [$chan] aliased $alias => $command\n");
$self->{pbot}->factoids->save_factoids();
$self->{pbot}->{logger}->log("$nick!$user\@$host [$chan] aliased $alias => $command\n");
$self->{pbot}->{factoids}->save_factoids();
return "/msg $nick '$alias' aliases '$command' for " . ($chan eq '.*' ? 'the global channel' : $chan);
}
sub add_regex {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my ($keyword, $text) = $arguments =~ /^(.*?)\s+(.*)$/ if defined $arguments;
$from = '.*' if not defined $from or $from !~ /^#/;
if(not defined $keyword) {
$text = "";
foreach my $trigger (sort keys %{ $factoids->{$from} }) {
if($factoids->{$from}->{$trigger}->{type} eq 'regex') {
foreach my $trigger (sort keys %{ ${factoids}->{$from} }) {
if(${factoids}->{$from}->{$trigger}->{type} eq 'regex') {
$text .= $trigger . " ";
}
}
@ -359,15 +359,15 @@ sub add_regex {
return "Usage: regex <regex> <command>";
}
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($from, $keyword, undef, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($from, $keyword, undef, 1);
if(defined $trigger) {
$self->{pbot}->logger->log("$nick!$user\@$host attempt to overwrite $trigger\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host attempt to overwrite $trigger\n");
return "/msg $nick $trigger already exists for channel $channel.";
}
$self->{pbot}->factoids->add_factoid('regex', $from, "$nick!$user\@$host", $keyword, $text);
$self->{pbot}->logger->log("$nick!$user\@$host added [$keyword] => [$text]\n");
$self->{pbot}->{factoids}->add_factoid('regex', $from, "$nick!$user\@$host", $keyword, $text);
$self->{pbot}->{logger}->log("$nick!$user\@$host added [$keyword] => [$text]\n");
return "/msg $nick $keyword added.";
}
@ -382,23 +382,23 @@ sub factadd {
$from_chan = '.*' if not $from_chan =~ m/^#/;
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($from_chan, $keyword, undef, 1, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($from_chan, $keyword, undef, 1, 1);
if(defined $trigger) {
$self->{pbot}->logger->log("$nick!$user\@$host attempt to overwrite $keyword\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host attempt to overwrite $keyword\n");
return "/msg $nick $keyword already exists for " . ($from_chan eq '.*' ? 'global channel' : $from_chan) . ".";
}
$self->{pbot}->factoids->add_factoid('text', $from_chan, "$nick!$user\@$host", $keyword, $text);
$self->{pbot}->{factoids}->add_factoid('text', $from_chan, "$nick!$user\@$host", $keyword, $text);
$self->{pbot}->logger->log("$nick!$user\@$host added [$from_chan] $keyword => $text\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host added [$from_chan] $keyword => $text\n");
return "/msg $nick '$keyword' added to " . ($from_chan eq '.*' ? 'global channel' : $from_chan) . ".";
}
sub factrem {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my ($from_chan, $from_trigger) = split / /, $arguments;
@ -406,44 +406,44 @@ sub factrem {
return "/msg $nick Usage: factrem <channel> <keyword>";
}
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($from_chan, $from_trigger, undef, 1, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($from_chan, $from_trigger, undef, 1, 1);
if(not defined $trigger) {
return "/msg $nick $from_trigger not found in channel $from_chan.";
}
if($factoids->{$channel}->{$trigger}->{type} eq 'module') {
$self->{pbot}->logger->log("$nick!$user\@$host attempted to remove $trigger [not factoid]\n");
if(${factoids}->{$channel}->{$trigger}->{type} eq 'module') {
$self->{pbot}->{logger}->log("$nick!$user\@$host attempted to remove $trigger [not factoid]\n");
return "/msg $nick $trigger is not a factoid.";
}
my ($owner) = $factoids->{$channel}->{$trigger}->{'owner'} =~ m/([^!]+)/;
my ($owner) = ${factoids}->{$channel}->{$trigger}->{'owner'} =~ m/([^!]+)/;
if((lc $nick ne lc $owner) and (not $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host"))) {
$self->{pbot}->logger->log("$nick!$user\@$host attempted to remove $trigger [not owner]\n");
if((lc $nick ne lc $owner) and (not $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host"))) {
$self->{pbot}->{logger}->log("$nick!$user\@$host attempted to remove $trigger [not owner]\n");
my $chan = ($channel eq '.*' ? 'the global channel' : $channel);
return "/msg $nick You are not the owner of '$trigger' for $chan";
}
if(exists $factoids->{$channel}->{$trigger}->{'locked'} and $factoids->{$channel}->{$trigger}->{'locked'} != 0) {
if(exists ${factoids}->{$channel}->{$trigger}->{'locked'} and ${factoids}->{$channel}->{$trigger}->{'locked'} != 0) {
return "$trigger is locked; unlock before deleting.";
}
$self->{pbot}->logger->log("$nick!$user\@$host removed [$channel][$trigger][" . $factoids->{$channel}->{$trigger}->{action} . "]\n");
$self->{pbot}->factoids->remove_factoid($channel, $trigger);
$self->{pbot}->{logger}->log("$nick!$user\@$host removed [$channel][$trigger][" . ${factoids}->{$channel}->{$trigger}->{action} . "]\n");
$self->{pbot}->{factoids}->remove_factoid($channel, $trigger);
return "/msg $nick $trigger removed from " . ($channel eq '.*' ? 'the global channel' : $channel) . ".";
}
sub histogram {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
my %hash;
my $factoid_count = 0;
foreach my $command (keys %{ $factoids }) {
if(exists $factoids->{$command}{text}) {
$hash{$factoids->{$command}{owner}}++;
if(exists ${factoids}->{$command}{text}) {
$hash{${factoids}->{$command}{owner}}++;
$factoid_count++;
}
}
@ -464,7 +464,7 @@ sub histogram {
sub factshow {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my ($chan, $trig) = split / /, $arguments;
@ -472,15 +472,15 @@ sub factshow {
return "Usage: factshow <channel> <trigger>";
}
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($chan, $trig, undef, 0, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($chan, $trig, undef, 0, 1);
if(not defined $trigger) {
return "/msg $nick '$trig' not found in channel '$chan'";
}
my $result = "$trigger: " . $factoids->{$channel}->{$trigger}->{action};
my $result = "$trigger: " . ${factoids}->{$channel}->{$trigger}->{action};
if($factoids->{$channel}->{$trigger}->{type} eq 'module') {
if(${factoids}->{$channel}->{$trigger}->{type} eq 'module') {
$result .= ' [module]';
}
@ -490,7 +490,7 @@ sub factshow {
sub factinfo {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my ($chan, $trig) = split / /, $arguments;
@ -498,30 +498,30 @@ sub factinfo {
return "Usage: factinfo <channel> <trigger>";
}
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($chan, $trig, undef, 0, 1);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($chan, $trig, undef, 0, 1);
if(not defined $trigger) {
return "'$trig' not found in channel '$chan'";
}
my $created_ago = ago(gettimeofday - $factoids->{$channel}->{$trigger}->{created_on});
my $ref_ago = ago(gettimeofday - $factoids->{$channel}->{$trigger}->{last_referenced_on}) if defined $factoids->{$channel}->{$trigger}->{last_referenced_on};
my $created_ago = ago(gettimeofday - ${factoids}->{$channel}->{$trigger}->{created_on});
my $ref_ago = ago(gettimeofday - ${factoids}->{$channel}->{$trigger}->{last_referenced_on}) if defined ${factoids}->{$channel}->{$trigger}->{last_referenced_on};
$chan = ($channel eq '.*' ? 'global channel' : $channel);
# factoid
if($factoids->{$channel}->{$trigger}->{type} eq 'text') {
return "$trigger: Factoid submitted by " . $factoids->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime($factoids->{$channel}->{$trigger}->{created_on}) . " [$created_ago], " . (defined $factoids->{$channel}->{$trigger}->{edited_by} ? "last edited by $factoids->{$channel}->{$trigger}->{edited_by} on " . localtime($factoids->{$channel}->{$trigger}->{edited_on}) . " [" . ago(gettimeofday - $factoids->{$channel}->{$trigger}->{edited_on}) . "], " : "") . "referenced " . $factoids->{$channel}->{$trigger}->{ref_count} . " times (last by " . $factoids->{$channel}->{$trigger}->{ref_user} . (exists $factoids->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime($factoids->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
if(${factoids}->{$channel}->{$trigger}->{type} eq 'text') {
return "$trigger: Factoid submitted by " . ${factoids}->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime(${factoids}->{$channel}->{$trigger}->{created_on}) . " [$created_ago], " . (defined ${factoids}->{$channel}->{$trigger}->{edited_by} ? "last edited by ${factoids}->{$channel}->{$trigger}->{edited_by} on " . localtime(${factoids}->{$channel}->{$trigger}->{edited_on}) . " [" . ago(gettimeofday - ${factoids}->{$channel}->{$trigger}->{edited_on}) . "], " : "") . "referenced " . ${factoids}->{$channel}->{$trigger}->{ref_count} . " times (last by " . ${factoids}->{$channel}->{$trigger}->{ref_user} . (exists ${factoids}->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime(${factoids}->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
}
# module
if($factoids->{$channel}->{$trigger}->{type} eq 'module') {
return "$trigger: Module loaded by " . $factoids->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime($factoids->{$channel}->{$trigger}->{created_on}) . " [$created_ago] -> http://code.google.com/p/pbot2-pl/source/browse/trunk/modules/" . $factoids->{$channel}->{$trigger}->{action} . ", used " . $factoids->{$channel}->{$trigger}->{ref_count} . " times (last by " . $factoids->{$channel}->{$trigger}->{ref_user} . (exists $factoids->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime($factoids->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
if(${factoids}->{$channel}->{$trigger}->{type} eq 'module') {
return "$trigger: Module loaded by " . ${factoids}->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime(${factoids}->{$channel}->{$trigger}->{created_on}) . " [$created_ago] -> http://code.google.com/p/pbot2-pl/source/browse/trunk/modules/" . ${factoids}->{$channel}->{$trigger}->{action} . ", used " . ${factoids}->{$channel}->{$trigger}->{ref_count} . " times (last by " . ${factoids}->{$channel}->{$trigger}->{ref_user} . (exists ${factoids}->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime(${factoids}->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
}
# regex
if($factoids->{$channel}->{$trigger}->{type} eq 'regex') {
return "$trigger: Regex created by " . $factoids->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime($factoids->{$channel}->{$trigger}->{created_on}) . " [$created_ago], " . (defined $factoids->{$channel}->{$trigger}->{edited_by} ? "last edited by $factoids->{$channel}->{$trigger}->{edited_by} on " . localtime($factoids->{$channel}->{$trigger}->{edited_on}) . " [" . ago(gettimeofday - $factoids->{$channel}->{$trigger}->{edited_on}) . "], " : "") . " used " . $factoids->{$channel}->{$trigger}->{ref_count} . " times (last by " . $factoids->{$channel}->{$trigger}->{ref_user} . (exists $factoids->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime($factoids->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
if(${factoids}->{$channel}->{$trigger}->{type} eq 'regex') {
return "$trigger: Regex created by " . ${factoids}->{$channel}->{$trigger}->{owner} . " for $chan on " . localtime(${factoids}->{$channel}->{$trigger}->{created_on}) . " [$created_ago], " . (defined ${factoids}->{$channel}->{$trigger}->{edited_by} ? "last edited by ${factoids}->{$channel}->{$trigger}->{edited_by} on " . localtime(${factoids}->{$channel}->{$trigger}->{edited_on}) . " [" . ago(gettimeofday - ${factoids}->{$channel}->{$trigger}->{edited_on}) . "], " : "") . " used " . ${factoids}->{$channel}->{$trigger}->{ref_count} . " times (last by " . ${factoids}->{$channel}->{$trigger}->{ref_user} . (exists ${factoids}->{$channel}->{$trigger}->{last_referenced_on} ? " on " . localtime(${factoids}->{$channel}->{$trigger}->{last_referenced_on}) . " [$ref_ago]" : "") . ")";
}
return "/msg $nick $trigger is not a factoid or a module";
@ -530,7 +530,7 @@ sub factinfo {
sub top20 {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my %hash = ();
my $text = "";
my $i = 0;
@ -544,9 +544,9 @@ sub top20 {
if(not defined $args) {
foreach my $chan (sort keys %{ $factoids }) {
next if lc $chan ne lc $channel;
foreach my $command (sort {$factoids->{$chan}->{$b}{ref_count} <=> $factoids->{$chan}->{$a}{ref_count}} keys %{ $factoids->{$chan} }) {
if($factoids->{$chan}->{$command}{ref_count} > 0 and $factoids->{$chan}->{$command}{type} eq 'text') {
$text .= "$command ($factoids->{$chan}->{$command}{ref_count}) ";
foreach my $command (sort {${factoids}->{$chan}->{$b}{ref_count} <=> ${factoids}->{$chan}->{$a}{ref_count}} keys %{ ${factoids}->{$chan} }) {
if(${factoids}->{$chan}->{$command}{ref_count} > 0 and ${factoids}->{$chan}->{$command}{type} eq 'text') {
$text .= "$command (${factoids}->{$chan}->{$command}{ref_count}) ";
$i++;
last if $i >= 20;
}
@ -561,9 +561,9 @@ sub top20 {
if(lc $args eq "recent") {
foreach my $chan (sort keys %{ $factoids }) {
next if lc $chan ne lc $channel;
foreach my $command (sort { $factoids->{$chan}->{$b}{created_on} <=> $factoids->{$chan}->{$a}{created_on} } keys %{ $factoids->{$chan} }) {
my $ago = ago(gettimeofday - $factoids->{$chan}->{$command}->{created_on});
$text .= " $command [$ago by $factoids->{$chan}->{$command}->{owner}]\n";
foreach my $command (sort { ${factoids}->{$chan}->{$b}{created_on} <=> ${factoids}->{$chan}->{$a}{created_on} } keys %{ ${factoids}->{$chan} }) {
my $ago = ago(gettimeofday - ${factoids}->{$chan}->{$command}->{created_on});
$text .= " $command [$ago by ${factoids}->{$chan}->{$command}->{owner}]\n";
$i++;
last if $i >= 50;
}
@ -576,12 +576,12 @@ sub top20 {
my $user = lc $args;
foreach my $chan (sort keys %{ $factoids }) {
next if lc $chan ne lc $channel;
foreach my $command (sort { ($factoids->{$chan}->{$b}{last_referenced_on} || 0) <=> ($factoids->{$chan}->{$a}{last_referenced_on} || 0) } keys %{ $factoids->{$chan} }) {
if($factoids->{$chan}->{$command}{ref_user} =~ /\Q$args\E/i) {
if($user ne lc $factoids->{$chan}->{$command}{ref_user} && not $user =~ /$factoids->{$chan}->{$command}{ref_user}/i) {
$user .= " ($factoids->{$chan}->{$command}{ref_user})";
foreach my $command (sort { (${factoids}->{$chan}->{$b}{last_referenced_on} || 0) <=> (${factoids}->{$chan}->{$a}{last_referenced_on} || 0) } keys %{ ${factoids}->{$chan} }) {
if(${factoids}->{$chan}->{$command}{ref_user} =~ /\Q$args\E/i) {
if($user ne lc ${factoids}->{$chan}->{$command}{ref_user} && not $user =~ /${factoids}->{$chan}->{$command}{ref_user}/i) {
$user .= " (${factoids}->{$chan}->{$command}{ref_user})";
}
my $ago = $factoids->{$chan}->{$command}{last_referenced_on} ? ago(gettimeofday - $factoids->{$chan}->{$command}{last_referenced_on}) : "unknown";
my $ago = ${factoids}->{$chan}->{$command}{last_referenced_on} ? ago(gettimeofday - ${factoids}->{$chan}->{$command}{last_referenced_on}) : "unknown";
$text .= " $command [$ago]\n";
$i++;
last if $i >= 20;
@ -596,7 +596,7 @@ sub top20 {
sub count {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
my $i = 0;
my $total = 0;
@ -608,9 +608,9 @@ sub count {
eval {
foreach my $command (keys %{ $factoids }) {
$total++ if exists $factoids->{$command}{text};
$total++ if exists ${factoids}->{$command}{text};
my $regex = qr/^\Q$arguments\E$/;
if($factoids->{$command}{owner} =~ /$regex/i && exists $factoids->{$command}{text}) {
if(${factoids}->{$command}{owner} =~ /$regex/i && exists ${factoids}->{$command}{text}) {
$i++;
}
}
@ -631,7 +631,7 @@ sub count {
sub factfind {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
if(not defined $arguments) {
return "/msg $nick Usage: factfind [-channel channel] [-owner nick] [-by nick] [text]";
@ -685,10 +685,10 @@ sub factfind {
eval {
foreach my $chan (sort keys %{ $factoids }) {
next if defined $channel and $chan !~ /$channel/i;
foreach my $trigger (sort keys %{ $factoids->{$chan} }) {
if($factoids->{$chan}->{$trigger}->{type} eq 'text' or $factoids->{$chan}->{$trigger}->{type} eq 'regex') {
if($factoids->{$chan}->{$trigger}->{owner} =~ /$owner/i && $factoids->{$chan}->{$trigger}->{ref_user} =~ /$by/i) {
next if($arguments ne "" && $factoids->{$chan}->{$trigger}->{action} !~ /$arguments/i && $trigger !~ /$arguments/i);
foreach my $trigger (sort keys %{ ${factoids}->{$chan} }) {
if(${factoids}->{$chan}->{$trigger}->{type} eq 'text' or ${factoids}->{$chan}->{$trigger}->{type} eq 'regex') {
if(${factoids}->{$chan}->{$trigger}->{owner} =~ /$owner/i && ${factoids}->{$chan}->{$trigger}->{ref_user} =~ /$by/i) {
next if($arguments ne "" && ${factoids}->{$chan}->{$trigger}->{action} !~ /$arguments/i && $trigger !~ /$arguments/i);
$i++;
@ -708,7 +708,7 @@ sub factfind {
if($i == 1) {
chop $text;
return "found one factoid submitted for " . ($last_chan eq '.*' ? 'global channel' : $last_chan) . " " . $argtype . ": $last_trigger is $factoids->{$last_chan}->{$last_trigger}->{action}";
return "found one factoid submitted for " . ($last_chan eq '.*' ? 'global channel' : $last_chan) . " " . $argtype . ": $last_trigger is ${factoids}->{$last_chan}->{$last_trigger}->{action}";
} else {
return "found $i factoids " . $argtype . ": $text" unless $i == 0;
@ -720,7 +720,7 @@ sub factfind {
sub factchange {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids->hash;
my $factoids = $self->{pbot}->{factoids}->{factoids}->hash;
my ($channel, $trigger, $keyword, $delim, $tochange, $changeto, $modifier);
if(defined $arguments) {
@ -741,27 +741,27 @@ sub factchange {
return "Usage: factchange <channel> <keyword> s/<pattern>/<replacement>/";
}
($channel, $trigger) = $self->{pbot}->factoids->find_factoid($channel, $keyword, undef, 0, 1);
($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($channel, $keyword, undef, 0, 1);
if(not defined $trigger) {
return "/msg $nick $keyword not found in channel $from.";
}
if(not $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host") and exists $factoids->{$channel}->{$trigger}->{'locked'} and $factoids->{$channel}->{$trigger}->{'locked'} != 0) {
if(not $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host") and exists ${factoids}->{$channel}->{$trigger}->{'locked'} and ${factoids}->{$channel}->{$trigger}->{'locked'} != 0) {
return "$trigger is locked and cannot be changed.";
}
my $ret = eval {
use re::engine::RE2 -strict => 1;
if(not $factoids->{$channel}->{$trigger}->{action} =~ s|$tochange|$changeto|) {
$self->{pbot}->logger->log("($from) $nick!$user\@$host: failed to change '$trigger' 's$delim$tochange$delim$changeto$delim\n");
if(not ${factoids}->{$channel}->{$trigger}->{action} =~ s|$tochange|$changeto|) {
$self->{pbot}->{logger}->log("($from) $nick!$user\@$host: failed to change '$trigger' 's$delim$tochange$delim$changeto$delim\n");
return "/msg $nick Change $trigger failed.";
} else {
$self->{pbot}->logger->log("($from) $nick!$user\@$host: changed '$trigger' 's/$tochange/$changeto/\n");
$factoids->{$channel}->{$trigger}->{edited_by} = "$nick!$user\@$host";
$factoids->{$channel}->{$trigger}->{edited_on} = gettimeofday;
$self->{pbot}->factoids->save_factoids();
return "Changed: $trigger is " . $factoids->{$channel}->{$trigger}->{action};
$self->{pbot}->{logger}->log("($from) $nick!$user\@$host: changed '$trigger' 's/$tochange/$changeto/\n");
${factoids}->{$channel}->{$trigger}->{edited_by} = "$nick!$user\@$host";
${factoids}->{$channel}->{$trigger}->{edited_on} = gettimeofday;
$self->{pbot}->{factoids}->save_factoids();
return "Changed: $trigger is " . ${factoids}->{$channel}->{$trigger}->{action};
}
};
return "/msg $nick Change $trigger: $@" if $@;
@ -771,20 +771,20 @@ sub factchange {
sub load_module {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
my ($keyword, $module) = $arguments =~ /^(.*?)\s+(.*)$/ if defined $arguments;
if(not defined $module) {
return "/msg $nick Usage: load <command> <module>";
}
if(not exists($factoids->{$keyword})) {
$factoids->{$keyword}{module} = $module;
$factoids->{$keyword}{enabled} = 1;
$factoids->{$keyword}{owner} = $nick;
$factoids->{$keyword}{created_on} = time();
$self->{pbot}->logger->log("$nick!$user\@$host loaded $keyword => $module\n");
$self->{pbot}->factoids->save_factoids();
if(not exists(${factoids}->{$keyword})) {
${factoids}->{$keyword}{module} = $module;
${factoids}->{$keyword}{enabled} = 1;
${factoids}->{$keyword}{owner} = $nick;
${factoids}->{$keyword}{created_on} = time();
$self->{pbot}->{logger}->log("$nick!$user\@$host loaded $keyword => $module\n");
$self->{pbot}->{factoids}->save_factoids();
return "/msg $nick Loaded $keyword => $module";
} else {
return "/msg $nick There is already a command named $keyword.";
@ -794,18 +794,18 @@ sub load_module {
sub unload_module {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
if(not defined $arguments) {
return "/msg $nick Usage: unload <module>";
} elsif(not exists $factoids->{$arguments}) {
} elsif(not exists ${factoids}->{$arguments}) {
return "/msg $nick $arguments not found.";
} elsif(not exists $factoids->{$arguments}{module}) {
} elsif(not exists ${factoids}->{$arguments}{module}) {
return "/msg $nick $arguments is not a module.";
} else {
delete $factoids->{$arguments};
$self->{pbot}->factoids->save_factoids();
$self->{pbot}->logger->log("$nick!$user\@$host unloaded module $arguments\n");
delete ${factoids}->{$arguments};
$self->{pbot}->{factoids}->save_factoids();
$self->{pbot}->{logger}->log("$nick!$user\@$host unloaded module $arguments\n");
return "/msg $nick $arguments unloaded.";
}
}
@ -813,16 +813,16 @@ sub unload_module {
sub enable_command {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
if(not defined $arguments) {
return "/msg $nick Usage: enable <command>";
} elsif(not exists $factoids->{$arguments}) {
} elsif(not exists ${factoids}->{$arguments}) {
return "/msg $nick $arguments not found.";
} else {
$factoids->{$arguments}{enabled} = 1;
$self->{pbot}->factoids->save_factoids();
$self->{pbot}->logger->log("$nick!$user\@$host enabled $arguments\n");
${factoids}->{$arguments}{enabled} = 1;
$self->{pbot}->{factoids}->save_factoids();
$self->{pbot}->{logger}->log("$nick!$user\@$host enabled $arguments\n");
return "/msg $nick $arguments enabled.";
}
}
@ -830,16 +830,16 @@ sub enable_command {
sub disable_command {
my $self = shift;
my ($from, $nick, $user, $host, $arguments) = @_;
my $factoids = $self->{pbot}->factoids->factoids;
my $factoids = $self->{pbot}->{factoids}->factoids;
if(not defined $arguments) {
return "/msg $nick Usage: disable <command>";
} elsif(not exists $factoids->{$arguments}) {
} elsif(not exists ${factoids}->{$arguments}) {
return "/msg $nick $arguments not found.";
} else {
$factoids->{$arguments}{enabled} = 0;
$self->{pbot}->factoids->save_factoids();
$self->{pbot}->logger->log("$nick!$user\@$host disabled $arguments\n");
${factoids}->{$arguments}{enabled} = 0;
$self->{pbot}->{factoids}->save_factoids();
$self->{pbot}->{logger}->log("$nick!$user\@$host disabled $arguments\n");
return "/msg $nick $arguments disabled.";
}
}

30
PBot/FactoidModuleLauncher.pm
View File

@ -44,29 +44,29 @@ sub execute_module {
$arguments = "" if not defined $arguments;
my ($channel, $trigger) = $self->{pbot}->factoids->find_factoid($from, $keyword);
my ($channel, $trigger) = $self->{pbot}->{factoids}->find_factoid($from, $keyword);
if(not defined $trigger) {
$self->{pbot}->{interpreter}->handle_result($from, $nick, $user, $host, $command, "$keyword $arguments", "/msg $nick Failed to find module for '$keyword' in channel $from\n", 1, 0);
return;
}
my $module = $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{action};
my $module = $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{action};
my $module_dir = $self->{pbot}->{registry}->get_value('general', 'module_dir');
$self->{pbot}->logger->log("(" . (defined $from ? $from : "(undef)") . "): $nick!$user\@$host: Executing module $module $arguments\n");
$self->{pbot}->{logger}->log("(" . (defined $from ? $from : "(undef)") . "): $nick!$user\@$host: Executing module $module $arguments\n");
$arguments =~ s/\$nick/$nick/g;
$arguments =~ s/\$channel/$from/g;
$arguments = quotemeta($arguments);
if(exists $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{unquote_spaces}) {
if(exists $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{unquote_spaces}) {
$arguments =~ s/\\ / /g;
}
if(exists $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{modulelauncher_subpattern}) {
if($self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{modulelauncher_subpattern} =~ m/s\/(.*?)\/(.*)\/(.*)/) {
if(exists $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{modulelauncher_subpattern}) {
if($self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{modulelauncher_subpattern} =~ m/s\/(.*?)\/(.*)\/(.*)/) {
my ($p1, $p2, $p3) = ($1, $2, $3);
my ($a, $b, $c, $d, $e, $f, $g, $h, $i, $before, $after);
if($p3 eq 'g') {
@ -87,9 +87,9 @@ sub execute_module {
$arguments =~ s/\$9/$i/g if defined $i;
$arguments =~ s/\$`/$before/g if defined $before;
$arguments =~ s/\$'/$after/g if defined $after;
#$self->{pbot}->logger->log("arguments subpattern: $arguments\n");
#$self->{pbot}->{logger}->log("arguments subpattern: $arguments\n");
} else {
$self->{pbot}->logger->log("Invalid module substitution pattern [" . $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{modulelauncher_subpattern}. "], ignoring.\n");
$self->{pbot}->{logger}->log("Invalid module substitution pattern [" . $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{modulelauncher_subpattern}. "], ignoring.\n");
}
}
@ -120,7 +120,7 @@ sub execute_module {
my $pid = fork;
if(not defined $pid) {
$self->{pbot}->logger->log("Could not fork module: $!\n");
$self->{pbot}->{logger}->log("Could not fork module: $!\n");
close $reader;
close $writer;
$self->{pbot}->{interpreter}->handle_result($from, $nick, $user, $host, $command, "$keyword $arguments", "/me groans loudly.\n", 1, 0);
@ -138,16 +138,16 @@ sub execute_module {
use warnings;
if(not chdir $module_dir) {
$self->{pbot}->logger->log("Could not chdir to '$module_dir': $!\n");
$self->{pbot}->{logger}->log("Could not chdir to '$module_dir': $!\n");
Carp::croak("Could not chdir to '$module_dir': $!");
}
# $self->{pbot}->logger->log("module arguments: [$arguments]\n");
# $self->{pbot}->{logger}->log("module arguments: [$arguments]\n");
$text = `$module_dir/$module $arguments`;
if(defined $tonick) {
$self->{pbot}->logger->log("($from): $nick!$user\@$host) sent to $tonick\n");
$self->{pbot}->{logger}->log("($from): $nick!$user\@$host) sent to $tonick\n");
if(defined $text && length $text > 0) {
# get rid of original caller's nick
$text =~ s/^\/([^ ]+) \Q$nick\E:\s+/\/$1 /;
@ -158,7 +158,7 @@ sub execute_module {
}
exit 0;
} else {
if(exists $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{add_nick} and $self->{pbot}->factoids->factoids->hash->{$channel}->{$trigger}->{add_nick} != 0) {
if(exists $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{add_nick} and $self->{pbot}->{factoids}->{factoids}->hash->{$channel}->{$trigger}->{add_nick} != 0) {
print $writer "$from $nick: $text";
$self->{pbot}->{interpreter}->handle_result($from, $nick, $user, $host, $command, "$keyword $arguments", "$nick: $text", 0, $preserve_whitespace);
} else {
@ -184,8 +184,8 @@ sub module_pipe_reader {
my ($self, $buf) = @_;
my ($channel, $text) = split / /, $buf, 2;
return if not defined $text or not length $text;
$text = $self->{pbot}->interpreter->truncate_result($channel, $self->{pbot}->{registry}->get_value('irc', 'botnick'), 'undef', $text, $text, 0);
$self->{pbot}->antiflood->check_flood($channel, $self->{pbot}->{registry}->get_value('irc', 'botnick'), $self->{pbot}->{registry}->get_value('irc', 'username'), 'localhost', $text, 0, 0, 0);
$text = $self->{pbot}->{interpreter}->truncate_result($channel, $self->{pbot}->{registry}->get_value('irc', 'botnick'), 'undef', $text, $text, 0);
$self->{pbot}->{antiflood}->check_flood($channel, $self->{pbot}->{registry}->get_value('irc', 'botnick'), $self->{pbot}->{registry}->get_value('irc', 'username'), 'localhost', $text, 0, 0, 0);
}
1;

216
PBot/Factoids.pm
View File

@ -56,28 +56,28 @@ sub initialize {
sub load_factoids {
my $self = shift;
$self->{pbot}->logger->log("Loading factoids from " . $self->factoids->filename . " ...\n");
$self->{pbot}->{logger}->log("Loading factoids from " . $self->{factoids}->filename . " ...\n");
$self->factoids->load;
$self->{factoids}->load;
my ($text, $regex, $modules);
foreach my $channel (keys %{ $self->factoids->hash }) {
foreach my $trigger (keys %{ $self->factoids->hash->{$channel} }) {
$text++ if $self->factoids->hash->{$channel}->{$trigger}->{type} eq 'text';
$regex++ if $self->factoids->hash->{$channel}->{$trigger}->{type} eq 'regex';
$modules++ if $self->factoids->hash->{$channel}->{$trigger}->{type} eq 'module';
foreach my $channel (keys %{ $self->{factoids}->hash }) {
foreach my $trigger (keys %{ $self->{factoids}->hash->{$channel} }) {
$text++ if $self->{factoids}->hash->{$channel}->{$trigger}->{type} eq 'text';
$regex++ if $self->{factoids}->hash->{$channel}->{$trigger}->{type} eq 'regex';
$modules++ if $self->{factoids}->hash->{$channel}->{$trigger}->{type} eq 'module';
}
}
$self->{pbot}->logger->log(" " . ($text + $regex + $modules) . " factoids loaded ($text text, $regex regexs, $modules modules).\n");
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log(" " . ($text + $regex + $modules) . " factoids loaded ($text text, $regex regexs, $modules modules).\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save_factoids {
my $self = shift;
$self->factoids->save;
$self->{factoids}->save;
$self->export_factoids;
}
@ -88,14 +88,14 @@ sub add_factoid {
$type = lc $type;
$channel = lc $channel;
$self->factoids->hash->{$channel}->{$trigger}->{enabled} = 1;
$self->factoids->hash->{$channel}->{$trigger}->{type} = $type;
$self->factoids->hash->{$channel}->{$trigger}->{action} = $action;
$self->factoids->hash->{$channel}->{$trigger}->{owner} = $owner;
$self->factoids->hash->{$channel}->{$trigger}->{created_on} = gettimeofday;
$self->factoids->hash->{$channel}->{$trigger}->{ref_count} = 0;
$self->factoids->hash->{$channel}->{$trigger}->{ref_user} = "nobody";
$self->factoids->hash->{$channel}->{$trigger}->{rate_limit} = 15;
$self->{factoids}->hash->{$channel}->{$trigger}->{enabled} = 1;
$self->{factoids}->hash->{$channel}->{$trigger}->{type} = $type;
$self->{factoids}->hash->{$channel}->{$trigger}->{action} = $action;
$self->{factoids}->hash->{$channel}->{$trigger}->{owner} = $owner;
$self->{factoids}->hash->{$channel}->{$trigger}->{created_on} = gettimeofday;
$self->{factoids}->hash->{$channel}->{$trigger}->{ref_count} = 0;
$self->{factoids}->hash->{$channel}->{$trigger}->{ref_user} = "nobody";
$self->{factoids}->hash->{$channel}->{$trigger}->{rate_limit} = 15;
$self->save_factoids unless $dont_save;
}
@ -106,10 +106,10 @@ sub remove_factoid {
$channel = lc $channel;
delete $self->factoids->hash->{$channel}->{$trigger};
delete $self->{factoids}->hash->{$channel}->{$trigger};
if(not scalar keys $self->factoids->hash->{$channel}) {
delete $self->factoids->hash->{$channel};
if(not scalar keys $self->{factoids}->hash->{$channel}) {
delete $self->{factoids}->hash->{$channel};
}
$self->save_factoids;
@ -135,15 +135,15 @@ sub export_factoids {
my $i = 0;
my $table_id = 1;
foreach my $channel (sort keys %{ $self->factoids->hash }) {
next if not scalar keys %{ $self->factoids->hash->{$channel} };
foreach my $channel (sort keys %{ $self->{factoids}->hash }) {
next if not scalar keys %{ $self->{factoids}->hash->{$channel} };
my $chan = $channel eq '.*' ? 'global' : $channel;
print FILE "<a href='#" . $chan . "'>" . encode_entities($chan) . "</a><br>\n";
}
foreach my $channel (sort keys %{ $self->factoids->hash }) {
next if not scalar keys %{ $self->factoids->hash->{$channel} };
foreach my $channel (sort keys %{ $self->{factoids}->hash }) {
next if not scalar keys %{ $self->{factoids}->hash->{$channel} };
my $chan = $channel eq '.*' ? 'global' : $channel;
print FILE "<a name='$chan'></a>\n";
print FILE "<hr>\n<h3>$chan</h3>\n<hr>\n";
@ -160,8 +160,8 @@ sub export_factoids {
print FILE "</tr>\n</thead>\n<tbody>\n";
$table_id++;
foreach my $trigger (sort keys %{ $self->factoids->hash->{$channel} }) {
if($self->factoids->hash->{$channel}->{$trigger}->{type} eq 'text') {
foreach my $trigger (sort keys %{ $self->{factoids}->hash->{$channel} }) {
if($self->{factoids}->hash->{$channel}->{$trigger}->{type} eq 'text') {
$i++;
if($i % 2) {
print FILE "<tr bgcolor=\"#dddddd\">\n";
@ -169,17 +169,17 @@ sub export_factoids {
print FILE "<tr>\n";
}
print FILE "<td>" . $self->factoids->hash->{$channel}->{$trigger}->{owner} . "</td>\n";
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->factoids->hash->{$channel}->{$trigger}->{created_on}) . "</td>\n";
print FILE "<td>" . $self->{factoids}->hash->{$channel}->{$trigger}->{owner} . "</td>\n";
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->{factoids}->hash->{$channel}->{$trigger}->{created_on}) . "</td>\n";
print FILE "<td>" . $self->factoids->hash->{$channel}->{$trigger}->{ref_count} . "</td>\n";
print FILE "<td>" . $self->{factoids}->hash->{$channel}->{$trigger}->{ref_count} . "</td>\n";
my $action = $self->factoids->hash->{$channel}->{$trigger}->{action};
my $action = $self->{factoids}->hash->{$channel}->{$trigger}->{action};
$action =~ s/(.*?)http(s?:\/\/[^ ]+)/encode_entities($1) . "<a href='http" . encode_entities($2) . "'>http" . encode_entities($2) . "<\/a>"/ge;
$action =~ s/(.*)<\/a>(.*$)/"$1<\/a>" . encode_entities($2)/e;
if(exists $self->factoids->hash->{$channel}->{$trigger}->{action_with_args}) {
my $with_args = $self->factoids->hash->{$channel}->{$trigger}->{action_with_args};
if(exists $self->{factoids}->hash->{$channel}->{$trigger}->{action_with_args}) {
my $with_args = $self->{factoids}->hash->{$channel}->{$trigger}->{action_with_args};
$with_args =~ s/(.*?)http(s?:\/\/[^ ]+)/encode_entities($1) . "<a href='http" . encode_entities($2) . "'>http" . encode_entities($2) . "<\/a>"/ge;
$with_args =~ s/(.*)<\/a>(.*$)/"$1<\/a>" . encode_entities($2)/e;
print FILE "<td width=100%><b>$trigger</b> is $action<br><br><b>with_args:</b> $with_args</td>\n";
@ -187,18 +187,18 @@ sub export_factoids {
print FILE "<td width=100%><b>$trigger</b> is $action</td>\n";
}
if(exists $self->factoids->hash->{$channel}->{$trigger}->{edited_by}) {
print FILE "<td>" . $self->factoids->hash->{$channel}->{$trigger}->{edited_by} . "</td>\n";
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->factoids->hash->{$channel}->{$trigger}->{edited_on}) . "</td>\n";
if(exists $self->{factoids}->hash->{$channel}->{$trigger}->{edited_by}) {
print FILE "<td>" . $self->{factoids}->hash->{$channel}->{$trigger}->{edited_by} . "</td>\n";
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->{factoids}->hash->{$channel}->{$trigger}->{edited_on}) . "</td>\n";
} else {
print FILE "<td></td>\n";
print FILE "<td></td>\n";
}
print FILE "<td>" . $self->factoids->hash->{$channel}->{$trigger}->{ref_user} . "</td>\n";
print FILE "<td>" . $self->{factoids}->hash->{$channel}->{$trigger}->{ref_user} . "</td>\n";
if(exists $self->factoids->hash->{$channel}->{$trigger}->{last_referenced_on}) {
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->factoids->hash->{$channel}->{$trigger}->{last_referenced_on}) . "</td>\n";
if(exists $self->{factoids}->hash->{$channel}->{$trigger}->{last_referenced_on}) {
print FILE "<td>" . encode_entities(strftime "%Y/%m/%d %H:%M:%S", localtime $self->{factoids}->hash->{$channel}->{$trigger}->{last_referenced_on}) . "</td>\n";
} else {
print FILE "<td></td>\n";
}
@ -226,7 +226,7 @@ sub export_factoids {
close(FILE);
#$self->{pbot}->logger->log("$i factoids exported to path: " . $self->export_path . ", site: " . $self->export_site . "\n");
#$self->{pbot}->{logger}->log("$i factoids exported to path: " . $self->export_path . ", site: " . $self->export_site . "\n");
return "$i factoids exported to " . $self->export_site;
}
@ -235,43 +235,43 @@ sub find_factoid {
my $debug = 0;
$self->{pbot}->logger->log("find_factoid: from: [$from], kw: [$keyword], args: [" . (defined $arguments ? $arguments : "undef") . "], " . (defined $exact_channel ? $exact_channel : "undef") . ", " . (defined $exact_trigger ? $exact_trigger : "undef") . "\n") if $debug;
$self->{pbot}->{logger}->log("find_factoid: from: [$from], kw: [$keyword], args: [" . (defined $arguments ? $arguments : "undef") . "], " . (defined $exact_channel ? $exact_channel : "undef") . ", " . (defined $exact_trigger ? $exact_trigger : "undef") . "\n") if $debug;
$from = '.*' if not defined $from or $from !~ /^#/;
$self->{pbot}->logger->log("from: $from\n") if $debug;
$self->{pbot}->{logger}->log("from: $from\n") if $debug;
my $string = "$keyword" . (defined $arguments ? " $arguments" : "");
$self->{pbot}->logger->log("string: $string\n") if $debug;
$self->{pbot}->{logger}->log("string: $string\n") if $debug;
my @result = eval {
foreach my $channel (sort keys %{ $self->factoids->hash }) {
foreach my $channel (sort keys %{ $self->{factoids}->hash }) {
if($exact_channel) {
next unless lc $from eq lc $channel or $from eq '.*' or $channel eq '.*';
}
foreach my $trigger (keys %{ $self->factoids->hash->{$channel} }) {
if(not $exact_trigger and $self->factoids->hash->{$channel}->{$trigger}->{type} eq 'regex') {
foreach my $trigger (keys %{ $self->{factoids}->hash->{$channel} }) {
if(not $exact_trigger and $self->{factoids}->hash->{$channel}->{$trigger}->{type} eq 'regex') {
if($string =~ m/$trigger/i) {
$self->{pbot}->logger->log("return regex $channel: $trigger\n") if $debug;
$self->{pbot}->{logger}->log("return regex $channel: $trigger\n") if $debug;
return ($channel, $trigger);
}
} else {
if($keyword =~ m/^\Q$trigger\E$/i) {
$self->{pbot}->logger->log("return $channel: $trigger\n") if $debug;
$self->{pbot}->{logger}->log("return $channel: $trigger\n") if $debug;
return ($channel, $trigger);
}
}
}
}
$self->{pbot}->logger->log("find_factoid: no match\n") if $debug;
$self->{pbot}->{logger}->log("find_factoid: no match\n") if $debug;
return undef;
};
if($@) {
$self->{pbot}->logger->log("find_factoid: bad regex: $@\n");
$self->{pbot}->{logger}->log("find_factoid: bad regex: $@\n");
return undef;
}
@ -288,11 +288,11 @@ sub interpreter {
$from = lc $from;
#$self->{pbot}->logger->log("factoids interpreter: from: [$from], ref_from: [" . (defined $ref_from ? $ref_from : "undef") . "]\n");
#$self->{pbot}->{logger}->log("factoids interpreter: from: [$from], ref_from: [" . (defined $ref_from ? $ref_from : "undef") . "]\n");
# search for factoid against global channel and current channel (from unless ref_from is defined)
my $original_keyword = $keyword;
#$self->{pbot}->logger->log("calling find_factoid in Factoids.pm, interpreter() to search for factoid against global/current\n");
#$self->{pbot}->{logger}->log("calling find_factoid in Factoids.pm, interpreter() to search for factoid against global/current\n");
($channel, $keyword) = $self->find_factoid($ref_from ? $ref_from : $from, $keyword, $arguments, 1);
if(not defined $ref_from or $ref_from eq '.*') {
@ -315,8 +315,8 @@ sub interpreter {
my ($fwd_chan, $fwd_trig);
# build string of which channels contain the keyword, keeping track of the last one and count
foreach my $chan (keys %{ $self->factoids->hash }) {
foreach my $trig (keys %{ $self->factoids->hash->{$chan} }) {
foreach my $chan (keys %{ $self->{factoids}->hash }) {
foreach my $trig (keys %{ $self->{factoids}->hash->{$chan} }) {
if(lc $trig eq lc $original_keyword) {
$chans .= $comma . $chan;
$comma = ", ";
@ -334,9 +334,9 @@ sub interpreter {
}
# if there's just one other channel that has this keyword, trigger that instance
elsif($found == 1) {
$pbot->logger->log("Found '$original_keyword' as '$fwd_trig' in [$fwd_chan]\n");
$pbot->{logger}->log("Found '$original_keyword' as '$fwd_trig' in [$fwd_chan]\n");
return $pbot->factoids->interpreter($from, $nick, $user, $host, ++$count, $fwd_trig, $arguments, $tonick, $fwd_chan);
return $pbot->{factoids}->interpreter($from, $nick, $user, $host, ++$count, $fwd_trig, $arguments, $tonick, $fwd_chan);
}
# otherwise keyword hasn't been found, display similiar matches for all channels
else {
@ -351,7 +351,7 @@ sub interpreter {
}
# otherwise find levenshtein closest matches from all channels
$matches = $self->factoids->levenshtein_matches('.*', lc $original_keyword);
$matches = $self->{factoids}->levenshtein_matches('.*', lc $original_keyword);
# don't say anything if nothing similiar was found
return undef if $matches eq 'none';
@ -360,10 +360,10 @@ sub interpreter {
}
}
my $type = $self->factoids->hash->{$channel}->{$keyword}->{type};
my $type = $self->{factoids}->hash->{$channel}->{$keyword}->{type};
# Check if it's an alias
if($self->factoids->hash->{$channel}->{$keyword}->{action} =~ /^\/call\s+(.*)$/) {
if($self->{factoids}->hash->{$channel}->{$keyword}->{action} =~ /^\/call\s+(.*)$/) {
my $command;
if(length $arguments) {
$command = "$1 $arguments";
@ -371,68 +371,68 @@ sub interpreter {
$command = $1;
}
$pbot->logger->log("[" . (defined $from ? $from : "stdin") . "] ($nick!$user\@$host) [$keyword] aliased to: [$command]\n");
$pbot->{logger}->log("[" . (defined $from ? $from : "stdin") . "] ($nick!$user\@$host) [$keyword] aliased to: [$command]\n");
$self->factoids->hash->{$channel}->{$keyword}->{ref_count}++;
$self->factoids->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_count}++;
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
return $pbot->interpreter->interpret($from, $nick, $user, $host, $count, $command, $tonick);
return $pbot->{interpreter}->interpret($from, $nick, $user, $host, $count, $command, $tonick);
}
my $last_ref_in = 0;
if(exists $self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on}) {
if(exists $self->factoids->hash->{$channel}->{$keyword}->{last_referenced_in}) {
if($self->factoids->hash->{$channel}->{$keyword}->{last_referenced_in} eq $from) {
if(exists $self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on}) {
if(exists $self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_in}) {
if($self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_in} eq $from) {
$last_ref_in = 1;
}
}
if(($last_ref_in == 1) and (gettimeofday - $self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on} < $self->factoids->hash->{$channel}->{$keyword}->{rate_limit})) {
return "/msg $nick $ref_from'$keyword' is rate-limited; try again in " . ($self->factoids->hash->{$channel}->{$keyword}->{rate_limit} - int(gettimeofday - $self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on})) . " seconds.";
if(($last_ref_in == 1) and (gettimeofday - $self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on} < $self->{factoids}->hash->{$channel}->{$keyword}->{rate_limit})) {
return "/msg $nick $ref_from'$keyword' is rate-limited; try again in " . ($self->{factoids}->hash->{$channel}->{$keyword}->{rate_limit} - int(gettimeofday - $self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on})) . " seconds.";
}
}
if($self->factoids->hash->{$channel}->{$keyword}->{enabled} == 0) {
$self->{pbot}->logger->log("$keyword disabled.\n");
if($self->{factoids}->hash->{$channel}->{$keyword}->{enabled} == 0) {
$self->{pbot}->{logger}->log("$keyword disabled.\n");
return "/msg $nick $ref_from$keyword is currently disabled.";
}
elsif($self->factoids->hash->{$channel}->{$keyword}->{type} eq 'module') {
$self->{pbot}->logger->log("Found module\n");
elsif($self->{factoids}->hash->{$channel}->{$keyword}->{type} eq 'module') {
$self->{pbot}->{logger}->log("Found module\n");
$self->factoids->hash->{$channel}->{$keyword}->{ref_count}++;
$self->factoids->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
$self->factoids->hash->{$channel}->{$keyword}->{last_referenced_in} = $from || "stdin";
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_count}++;
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
$self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_in} = $from || "stdin";
my $preserve_whitespace = $self->factoids->hash->{$channel}->{$keyword}->{preserve_whitespace};
my $preserve_whitespace = $self->{factoids}->hash->{$channel}->{$keyword}->{preserve_whitespace};
$preserve_whitespace = 0 if not defined $preserve_whitespace;
return $ref_from . $self->{factoidmodulelauncher}->execute_module($from, $tonick, $nick, $user, $host, "$keyword $arguments", $keyword, $arguments, $preserve_whitespace);
}
elsif($self->factoids->hash->{$channel}->{$keyword}->{type} eq 'text') {
$self->{pbot}->logger->log("Found factoid\n");
elsif($self->{factoids}->hash->{$channel}->{$keyword}->{type} eq 'text') {
$self->{pbot}->{logger}->log("Found factoid\n");
# Don't allow user-custom /msg factoids, unless factoid triggered by admin
if(($self->factoids->hash->{$channel}->{$keyword}->{action} =~ m/^\/msg/i) and (not $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host"))) {
$self->{pbot}->logger->log("[ABUSE] Bad factoid (contains /msg): " . $self->factoids->hash->{$channel}->{$keyword}->{action} . "\n");
if(($self->{factoids}->hash->{$channel}->{$keyword}->{action} =~ m/^\/msg/i) and (not $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host"))) {
$self->{pbot}->{logger}->log("[ABUSE] Bad factoid (contains /msg): " . $self->{factoids}->hash->{$channel}->{$keyword}->{action} . "\n");
return "You must login to use this command."
}
$self->factoids->hash->{$channel}->{$keyword}->{ref_count}++;
$self->factoids->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->factoids->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
$self->factoids->hash->{$channel}->{$keyword}->{last_referenced_in} = $from || "stdin";
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_count}++;
$self->{factoids}->hash->{$channel}->{$keyword}->{ref_user} = "$nick!$user\@$host";
$self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_on} = gettimeofday;
$self->{factoids}->hash->{$channel}->{$keyword}->{last_referenced_in} = $from || "stdin";
$result = $self->factoids->hash->{$channel}->{$keyword}->{action};
$result = $self->{factoids}->hash->{$channel}->{$keyword}->{action};
if(length $arguments) {
if(exists $self->factoids->hash->{$channel}->{$keyword}->{action_with_args}) {
$result = $self->factoids->hash->{$channel}->{$keyword}->{action_with_args};
if(exists $self->{factoids}->hash->{$channel}->{$keyword}->{action_with_args}) {
$result = $self->{factoids}->hash->{$channel}->{$keyword}->{action_with_args};
}
if(not $result =~ s/\$args/$arguments/gi and not exists $self->factoids->hash->{$channel}->{$keyword}->{action_with_args}) {
if(not $result =~ s/\$args/$arguments/gi and not exists $self->{factoids}->hash->{$channel}->{$keyword}->{action_with_args}) {
# factoid doesn't take an argument, so assume argument is a nick if it is a single-word 20 characters or less
# TODO - maintain list of channel nicks and compare against this list to ensure nick exists
if($arguments =~ /^[^.+-, ]{1,20}$/) {
@ -456,7 +456,7 @@ sub interpreter {
}
if(defined $tonick) { # !tell foo about bar
$self->{pbot}->logger->log("($from): $nick!$user\@$host) sent to $tonick\n");
$self->{pbot}->{logger}->log("($from): $nick!$user\@$host) sent to $tonick\n");
my $botnick = $self->{pbot}->{registry}->get_value('irc', 'botnick');
# get rid of original caller's nick
@ -470,35 +470,35 @@ sub interpreter {
$result = "/say $tonick: $keyword is $result";
}
$self->{pbot}->logger->log("result set to [$result]\n");
$self->{pbot}->{logger}->log("result set to [$result]\n");
}
$self->{pbot}->logger->log("(" . (defined $from ? $from : "(undef)") . "): $nick!$user\@$host: $keyword: Displaying text \"" . $result . "\"\n");
$self->{pbot}->{logger}->log("(" . (defined $from ? $from : "(undef)") . "): $nick!$user\@$host: $keyword: Displaying text \"" . $result . "\"\n");
$result =~ s/\$nick/$nick/g;
$result =~ s/\$channel/$from/g;
while ($result =~ /[^\\]\$([a-zA-Z0-9_\-]+)/g) {
#$self->{pbot}->logger->log("adlib: looking for [$1]\n");
#$self->{pbot}->logger->log("calling find_factoid in Factoids.pm, interpreter() to look for adlib");
#$self->{pbot}->{logger}->log("adlib: looking for [$1]\n");
#$self->{pbot}->{logger}->log("calling find_factoid in Factoids.pm, interpreter() to look for adlib");
my ($var_chan, $var) = $self->find_factoid($from, $1, undef, 0, 1);
if(defined $var && $self->factoids->hash->{$var_chan}->{$var}->{type} eq 'text') {
my $change = $self->factoids->hash->{$var_chan}->{$var}->{action};
if(defined $var && $self->{factoids}->hash->{$var_chan}->{$var}->{type} eq 'text') {
my $change = $self->{factoids}->hash->{$var_chan}->{$var}->{action};
my @list = split(/\s|(".*?")/, $change);
my @mylist;
#$self->{pbot}->logger->log("adlib: list [". join(':', @mylist) ."]\n");
#$self->{pbot}->{logger}->log("adlib: list [". join(':', @mylist) ."]\n");
for(my $i = 0; $i <= $#list; $i++) {
#$self->{pbot}->logger->log("adlib: pushing $i $list[$i]\n");
#$self->{pbot}->{logger}->log("adlib: pushing $i $list[$i]\n");
push @mylist, $list[$i] if $list[$i];
}
my $line = int(rand($#mylist + 1));
$mylist[$line] =~ s/"//g;
$result =~ s/\$$var/$mylist[$line]/;
#$self->{pbot}->logger->log("adlib: found: change: $result\n");
#$self->{pbot}->{logger}->log("adlib: found: change: $result\n");
} else {
$result =~ s/\$$var/$var/g;
#$self->{pbot}->logger->log("adlib: not found: change: $result\n");
#$self->{pbot}->{logger}->log("adlib: not found: change: $result\n");
}
}
@ -518,13 +518,13 @@ sub interpreter {
return "$keyword is $result";
}
}
} elsif($self->factoids->hash->{$channel}->{$keyword}->{type} eq 'regex') {
} elsif($self->{factoids}->hash->{$channel}->{$keyword}->{type} eq 'regex') {
$result = eval {
my $string = "$original_keyword" . (defined $arguments ? " $arguments" : "");
my $cmd;
if($string =~ m/$keyword/i) {
$self->{pbot}->logger->log("[$string] matches [$keyword] - calling [" . $self->factoids->hash->{$channel}->{$keyword}->{action} . "$']\n");
$cmd = $self->factoids->hash->{$channel}->{$keyword}->{action} . $';
$self->{pbot}->{logger}->log("[$string] matches [$keyword] - calling [" . $self->{factoids}->hash->{$channel}->{$keyword}->{action} . "$']\n");
$cmd = $self->{factoids}->hash->{$channel}->{$keyword}->{action} . $';
my ($a, $b, $c, $d, $e, $f, $g, $h, $i, $before, $after) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $`, $');
$cmd =~ s/\$1/$a/g;
$cmd =~ s/\$2/$b/g;
@ -540,21 +540,21 @@ sub interpreter {
$cmd =~ s/^\s+//;
$cmd =~ s/\s+$//;
} else {
$cmd = $self->factoids->hash->{$channel}->{$keyword}->{action};
$cmd = $self->{factoids}->hash->{$channel}->{$keyword}->{action};
}
$result = $pbot->interpreter->interpret($from, $nick, $user, $host, $count, $cmd, $tonick);
$result = $pbot->{interpreter}->interpret($from, $nick, $user, $host, $count, $cmd, $tonick);
return $result;
};
if($@) {
$self->{pbot}->logger->log("Regex fail: $@\n");
$self->{pbot}->{logger}->log("Regex fail: $@\n");
return "/msg $nick $ref_from" . "Fail.";
}
return $ref_from . $result;
} else {
$self->{pbot}->logger->log("($from): $nick!$user\@$host): Unknown command type for '$keyword'\n");
$self->{pbot}->{logger}->log("($from): $nick!$user\@$host): Unknown command type for '$keyword'\n");
return "/me blinks." . " $ref_from";
}

6
PBot/HashObject.pm
View File

@ -64,7 +64,7 @@ sub load_hash {
return;
}
$self->{pbot}->logger->log("Loading $self->{name} objects from $filename ...\n");
$self->{pbot}->{logger}->log("Loading $self->{name} objects from $filename ...\n");
if(not open(FILE, "< $filename")) {
Carp::carp "Couldn't open $filename: $!\n";
@ -111,7 +111,7 @@ sub load_hash {
close(FILE);
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save_hash {
@ -154,7 +154,7 @@ sub find_hash {
};
if($@) {
$self->{pbot}->logger->log("find_hash: bad regex: $@\n");
$self->{pbot}->{logger}->log("find_hash: bad regex: $@\n");
return undef;
}

22
PBot/IRC.pm
View File

@ -71,7 +71,7 @@ sub schedulequeue {
sub addconn {
my ($self, $conn) = @_;
$self->addfh( $conn->socket, $conn->can('parse'), ($_[2] || 'r'), $conn);
$self->addfh( ${conn}->socket, ${conn}->can('parse'), ($_[2] || 'r'), $conn);
}
# Adds a filehandle to the select loop. Tasty and flavorful.
@ -171,11 +171,11 @@ sub do_one_loop {
my $conn = $self->{_connhash}->{$sock};
$conn or next;
# $conn->[0] is a code reference to a handler sub.
# $conn->[1] is optionally an object which the
# ${conn}->[0] is a code reference to a handler sub.
# ${conn}->[1] is optionally an object which the
# handler sub may be a method of.
$conn->[0]->($conn->[1] ? ($conn->[1], $sock) : $sock);
${conn}->[0]->(${conn}->[1] ? (${conn}->[1], $sock) : $sock);
}
}
}
@ -194,7 +194,7 @@ sub newconn {
my $self = shift;
my $conn = PBot::IRC::Connection->new($self, @_); # pragma_ 2011/01/21
return if $conn->error;
return if ${conn}->error;
return $conn;
}
@ -237,7 +237,7 @@ sub dequeue_output_event {
sub removeconn {
my ($self, $conn) = @_;
$self->removefh( $conn->socket );
$self->removefh( ${conn}->socket );
}
# Given a filehandle, removes it from all select lists. You get the picture.
@ -295,11 +295,11 @@ and we'll be happy to help you out with bringing your bots into the modern era.
use Net::IRC;
$irc = new Net::IRC;
$conn = $irc->newconn(Nick => 'some_nick',
$conn = ${irc}->newconn(Nick => 'some_nick',
Server => 'some.irc.server.com',
Port => 6667,
Ircname => 'Some witty comment.');
$irc->start;
${irc}->start;
=head1 DESCRIPTION
@ -416,7 +416,7 @@ To that end, say something like this:
$irc = new Net::IRC;
$conn = $irc->newconn(Nick => 'some_nick',
$conn = ${irc}->newconn(Nick => 'some_nick',
Server => 'some.irc.server.com');
...or something similar. Acceptable parameters to newconn() are:
@ -531,7 +531,7 @@ When you've set up all your handlers, the following command will put your
program in an infinite loop, grabbing input from all open connections and
passing it off to the proper handlers:
$irc->start;
${irc}->start;
Note that new connections can be added and old ones dropped from within your
handlers even after you call this. Just don't expect any code below the call
@ -610,7 +610,7 @@ B<Optional:> A string containing any combination of the letters r, w or e
conditions you're expecting on that filehandle. For example, this line
select()s $fh (a filehandle, of course) for both reading and writing:
$irc->addfh( $fh, \&callback, "rw" );
${irc}->addfh( $fh, \&callback, "rw" );
=back

76
PBot/IRCHandlers.pm
View File

@ -37,15 +37,15 @@ sub initialize {
sub on_connect {
my ($self, $conn) = @_;
$self->{pbot}->logger->log("Connected!\n");
$conn->{connected} = 1;
$self->{pbot}->{logger}->log("Connected!\n");
${conn}->{connected} = 1;
}
sub on_disconnect {
my ($self, $conn, $event) = @_;
$self->{pbot}->logger->log("Disconnected, attempting to reconnect...\n");
$conn->connect();
if(not $conn->connected) {
$self->{pbot}->{logger}->log("Disconnected, attempting to reconnect...\n");
${conn}->connect();
if(not ${conn}->connected) {
sleep(5);
$self->on_disconnect($self, $conn, $event);
}
@ -55,7 +55,7 @@ sub on_init {
my ($self, $conn, $event) = @_;
my (@args) = ($event->args);
shift (@args);
$self->{pbot}->logger->log("*** @args\n");
$self->{pbot}->{logger}->log("*** @args\n");
}
sub on_public {
@ -67,7 +67,7 @@ sub on_public {
my $host = $event->host;
my $text = $event->{args}[0];
$self->{pbot}->interpreter->process_line($from, $nick, $user, $host, $text);
$self->{pbot}->{interpreter}->process_line($from, $nick, $user, $host, $text);
}
sub on_msg {
@ -87,18 +87,18 @@ sub on_notice {
my ($nick, $host) = ($event->nick, $event->host);
my $text = $event->{args}[0];
$self->{pbot}->logger->log("Received NOTICE from $nick $host '$text'\n");
$self->{pbot}->{logger}->log("Received NOTICE from $nick $host '$text'\n");
if($nick eq "NickServ" && $text =~ m/This nickname is registered/) {
$self->{pbot}->logger->log("Identifying with NickServ . . .\n");
$conn->privmsg("nickserv", "identify " . $self->{pbot}->{registry}->get_value('irc', 'identify_password'));
$self->{pbot}->{logger}->log("Identifying with NickServ . . .\n");
${conn}->privmsg("nickserv", "identify " . $self->{pbot}->{registry}->get_value('irc', 'identify_password'));
}
if($nick eq "NickServ" && $text =~ m/You are now identified/) {
foreach my $chan (keys %{ $self->{pbot}->channels->channels->hash }) {
if($self->{pbot}->channels->channels->hash->{$chan}{enabled}) {
$self->{pbot}->logger->log("Joining channel: $chan\n");
$conn->join($chan);
foreach my $chan (keys %{ $self->{pbot}->{channels}->{channels}->hash }) {
if($self->{pbot}->{channels}->{channels}->hash->{$chan}{enabled}) {
$self->{pbot}->{logger}->log("Joining channel: $chan\n");
${conn}->join($chan);
}
}
$self->{pbot}->{joined_channels} = 1;
@ -135,39 +135,39 @@ sub on_mode {
$mode = $modifier . $char;
$target = $event->{args}[++$i];
$self->{pbot}->logger->log("Got mode: source: $nick!$user\@$host, mode: $mode, target: " . (defined $target ? $target : "(undef)") . ", channel: $channel\n");
$self->{pbot}->{logger}->log("Got mode: source: $nick!$user\@$host, mode: $mode, target: " . (defined $target ? $target : "(undef)") . ", channel: $channel\n");
if($mode eq "-b" or $mode eq "+b" or $mode eq "-q" or $mode eq "+q") {
$self->{pbot}->bantracker->track_mode("$nick!$user\@$host", $mode, $target, $channel);
$self->{pbot}->{bantracker}->track_mode("$nick!$user\@$host", $mode, $target, $channel);
}
if(defined $target && $target eq $self->{pbot}->{registry}->get_value('irc', 'botnick')) { # bot targeted
if($mode eq "+o") {
$self->{pbot}->logger->log("$nick opped me in $channel\n");
$self->{pbot}->chanops->{is_opped}->{$channel}{timeout} = gettimeofday + 300; # 5 minutes
$self->{pbot}->chanops->perform_op_commands($channel);
$self->{pbot}->{logger}->log("$nick opped me in $channel\n");
$self->{pbot}->{chanops}->{is_opped}->{$channel}{timeout} = gettimeofday + 300; # 5 minutes
$self->{pbot}->{chanops}->perform_op_commands($channel);
}
elsif($mode eq "-o") {
$self->{pbot}->logger->log("$nick removed my ops in $channel\n");
delete $self->{pbot}->chanops->{is_opped}->{$channel};
$self->{pbot}->{logger}->log("$nick removed my ops in $channel\n");
delete $self->{pbot}->{chanops}->{is_opped}->{$channel};
}
elsif($mode eq "+b") {
$self->{pbot}->logger->log("Got banned in $channel, attempting unban.");
$conn->privmsg("chanserv", "unban $channel");
$self->{pbot}->{logger}->log("Got banned in $channel, attempting unban.");
${conn}->privmsg("chanserv", "unban $channel");
}
}
else { # bot not targeted
if($mode eq "+b") {
if($nick eq "ChanServ") {
$self->{pbot}->chanops->{unban_timeout}->hash->{$channel}->{$target}{timeout} = gettimeofday + 3600 * 2; # 2 hours
$self->{pbot}->chanops->{unban_timeout}->save;
$self->{pbot}->{chanops}->{unban_timeout}->hash->{$channel}->{$target}{timeout} = gettimeofday + 3600 * 2; # 2 hours
$self->{pbot}->{chanops}->{unban_timeout}->save;
}
}
elsif($mode eq "+e" && $channel eq $self->{pbot}->{registry}->get_value('irc', 'botnick')) {
foreach my $chan (keys %{ $self->{pbot}->channels->channels->hash }) {
if($self->channels->channels->hash->{$chan}{enabled}) {
$self->{pbot}->logger->log("Joining channel: $chan\n");
$self->{pbot}->conn->join($chan);
foreach my $chan (keys %{ $self->{pbot}->{channels}->{channels}->hash }) {
if($self->{channels}->{channels}->hash->{$chan}{enabled}) {
$self->{pbot}->{logger}->log("Joining channel: $chan\n");
$self->{pbot}->{conn}->join($chan);
}
}
@ -183,14 +183,14 @@ sub on_join {
my $message_account = $self->{pbot}->{messagehistory}->get_message_account($nick, $user, $host);
$self->{pbot}->{messagehistory}->add_message($message_account, "$nick!$user\@$host", $channel, "JOIN", $self->{pbot}->{messagehistory}->{MSG_JOIN});
$self->{pbot}->antiflood->check_flood($channel, $nick, $user, $host, "JOIN", $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_JOIN});
$self->{pbot}->{antiflood}->check_flood($channel, $nick, $user, $host, "JOIN", $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_JOIN});
}
sub on_kick {
my ($self, $conn, $event) = @_;
my ($nick, $user, $host, $target, $channel, $reason) = ($event->nick, $event->user, $event->host, $event->to, $event->{args}[0], $event->{args}[1]);
$self->{pbot}->logger->log("$nick!$user\@$host kicked $target from $channel ($reason)\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host kicked $target from $channel ($reason)\n");
my ($message_account) = $self->{pbot}->{messagehistory}->{database}->find_message_account_by_nick($target);
@ -201,7 +201,7 @@ sub on_kick {
my $text = "KICKED by $nick!$user\@$host ($reason)";
$self->{pbot}->{messagehistory}->add_message($message_account, "$nick!$user\@$host", $channel, $text, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
$self->{pbot}->antiflood->check_flood($channel, $target_nick, $target_user, $target_host, $text, $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
$self->{pbot}->{antiflood}->check_flood($channel, $target_nick, $target_user, $target_host, $text, $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
}
}
@ -225,12 +225,12 @@ sub on_departure {
$self->{pbot}->{messagehistory}->add_message($message_account, "$nick!$user\@$host", $channel, $text, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
}
$self->{pbot}->antiflood->check_flood($channel, $nick, $user, $host, $text, $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
$self->{pbot}->{antiflood}->check_flood($channel, $nick, $user, $host, $text, $self->{pbot}->{registry}->get_value('antiflood', 'max_join_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_DEPARTURE});
my $admin = $self->{pbot}->admins->find_admin($channel, "$nick!$user\@$host");
my $admin = $self->{pbot}->{admins}->find_admin($channel, "$nick!$user\@$host");
if(defined $admin and $admin->{loggedin}) {
$self->{pbot}->logger->log("Whoops, $nick left while still logged in.\n");
$self->{pbot}->logger->log("Logged out $nick.\n");
$self->{pbot}->{logger}->log("Whoops, $nick left while still logged in.\n");
$self->{pbot}->{logger}->log("Logged out $nick.\n");
delete $admin->{loggedin};
}
}
@ -239,7 +239,7 @@ sub on_nickchange {
my ($self, $conn, $event) = @_;
my ($nick, $user, $host, $newnick) = ($event->nick, $event->user, $event->host, $event->args);
$self->{pbot}->logger->log("$nick!$user\@$host changed nick to $newnick\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host changed nick to $newnick\n");
my $message_account = $self->{pbot}->{messagehistory}->{database}->get_message_account($nick, $user, $host);
$self->{pbot}->{messagehistory}->{database}->devalidate_all_channels($message_account);
@ -253,7 +253,7 @@ sub on_nickchange {
$self->{pbot}->{messagehistory}->{database}->devalidate_all_channels($newnick_account);
$self->{pbot}->{messagehistory}->{database}->update_hostmask_data($newnick_account, { last_seen => scalar gettimeofday });
$self->{pbot}->antiflood->check_flood("$nick!$user\@$host", $nick, $user, $host, "NICKCHANGE $newnick", $self->{pbot}->{registry}->get_value('antiflood', 'max_nick_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_NICKCHANGE});
$self->{pbot}->{antiflood}->check_flood("$nick!$user\@$host", $nick, $user, $host, "NICKCHANGE $newnick", $self->{pbot}->{registry}->get_value('antiflood', 'max_nick_flood'), 60 * 30, $self->{pbot}->{messagehistory}->{MSG_NICKCHANGE});
}
1;

20
PBot/IgnoreList.pm
View File

@ -37,7 +37,7 @@ sub initialize {
$self->load_ignores;
$self->{pbot}->timer->register(sub { $self->check_ignore_timeouts }, 10);
$self->{pbot}->{timer}->register(sub { $self->check_ignore_timeouts }, 10);
}
sub add {
@ -72,7 +72,7 @@ sub load_ignores {
return;
}
$self->{pbot}->logger->log("Loading ignorelist from $filename ...\n");
$self->{pbot}->{logger}->log("Loading ignorelist from $filename ...\n");
open(FILE, "< $filename") or Carp::croak "Couldn't open $filename: $!\n";
my @contents = <FILE>;
@ -97,8 +97,8 @@ sub load_ignores {
${ $self->{ignore_list} }{$hostmask}{$channel} = $length;
}
$self->{pbot}->logger->log(" $i entries in ignorelist\n");
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log(" $i entries in ignorelist\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save_ignores {
@ -152,8 +152,8 @@ sub check_ignore {
$self->{commands}->ignore_user("", "floodcontrol", "", "", ".* $channel 300");
$self->{ignore_flood_counter}->{$channel} = 0;
if($channel =~ /^#/) {
$pbot->conn->me($channel, "has been overwhelmed.");
$pbot->conn->me($channel, "lies down and falls asleep.");
$pbot->{conn}->me($channel, "has been overwhelmed.");
$pbot->{conn}->me($channel, "lies down and falls asleep.");
return 1;
}
}
@ -161,7 +161,7 @@ sub check_ignore {
foreach my $ignored (keys %{ $self->{ignore_list} }) {
foreach my $ignored_channel (keys %{ ${ $self->{ignore_list} }{$ignored} }) {
#$self->{pbot}->logger->log("check_ignore: comparing '$hostmask' against '$ignored' for channel '$channel'\n");
#$self->{pbot}->{logger}->log("check_ignore: comparing '$hostmask' against '$ignored' for channel '$channel'\n");
my $ignored_channel_escaped = quotemeta $ignored_channel;
my $ignored_escaped = quotemeta $ignored;
@ -169,7 +169,7 @@ sub check_ignore {
$ignored_escaped =~ s/\\(\.|\*)/$1/g;
if(($channel =~ /$ignored_channel_escaped/i) && ($hostmask =~ /$ignored_escaped/i)) {
$self->{pbot}->logger->log("$nick!$user\@$host message ignored in channel $channel (matches [$ignored] host and [$ignored_channel] channel)\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host message ignored in channel $channel (matches [$ignored] host and [$ignored_channel] channel)\n");
return 1;
}
}
@ -188,11 +188,11 @@ sub check_ignore_timeouts {
if($self->{ignore_list}->{$hostmask}{$channel} < $now) {
$self->{commands}->unignore_user("", "floodcontrol", "", "", "$hostmask $channel");
if($hostmask eq ".*") {
$self->{pbot}->conn->me($channel, "awakens.");
$self->{pbot}->{conn}->me($channel, "awakens.");
}
} else {
#my $timediff = $ignore_list{$host}{$channel} - $now;
#$logger->log "ignore: $host has $timediff seconds remaining\n"
#${logger}->log "ignore: $host has $timediff seconds remaining\n"
}
}
}

22
PBot/IgnoreListCommands.pm
View File

@ -33,8 +33,8 @@ sub initialize {
$self->{pbot} = $pbot;
$pbot->commands->register(sub { return $self->ignore_user(@_) }, "ignore", 10);
$pbot->commands->register(sub { return $self->unignore_user(@_) }, "unignore", 10);
$pbot->{commands}->register(sub { return $self->ignore_user(@_) }, "ignore", 10);
$pbot->{commands}->register(sub { return $self->unignore_user(@_) }, "unignore", 10);
}
sub ignore_user {
@ -53,9 +53,9 @@ sub ignore_user {
my $text = "Ignored: ";
my $sep = "";
foreach my $ignored (keys %{ $self->{pbot}->ignorelist->{ignore_list} }) {
foreach my $channel (keys %{ ${ $self->{pbot}->ignorelist->{ignore_list} }{$ignored} }) {
$text .= $sep . "[$ignored]->[$channel]->[" . (${ $self->{pbot}->ignorelist->{ignore_list} }{$ignored}{$channel} == -1 ? -1 : int(gettimeofday - ${ $self->{pbot}->ignorelist->{ignore_list} }{$ignored}{$channel})) . "]";
foreach my $ignored (keys %{ $self->{pbot}->{ignorelist}->{ignore_list} }) {
foreach my $channel (keys %{ ${ $self->{pbot}->{ignorelist}->{ignore_list} }{$ignored} }) {
$text .= $sep . "[$ignored]->[$channel]->[" . (${ $self->{pbot}->{ignorelist}->{ignore_list} }{$ignored}{$channel} == -1 ? -1 : int(gettimeofday - ${ $self->{pbot}->{ignorelist}->{ignore_list} }{$ignored}{$channel})) . "]";
$sep = ";\n";
}
}
@ -70,8 +70,8 @@ sub ignore_user {
$length = -1; # permanently
}
$self->{pbot}->logger->log("$nick added [$target][$channel] to ignore list for $length seconds\n");
$self->{pbot}->ignorelist->add($target, $channel, $length);
$self->{pbot}->{logger}->log("$nick added [$target][$channel] to ignore list for $length seconds\n");
$self->{pbot}->{ignorelist}->add($target, $channel, $length);
return "/msg $nick [$target][$channel] added to ignore list for $length seconds";
}
@ -88,13 +88,13 @@ sub unignore_user {
$channel = ".*";
}
if(not exists ${ $self->{pbot}->ignorelist->{ignore_list} }{$target}{$channel}) {
$self->{pbot}->logger->log("$nick attempt to remove nonexistent [$target][$channel] from ignore list\n");
if(not exists ${ $self->{pbot}->{ignorelist}->{ignore_list} }{$target}{$channel}) {
$self->{pbot}->{logger}->log("$nick attempt to remove nonexistent [$target][$channel] from ignore list\n");
return "/msg $nick [$target][$channel] not found in ignore list (use '!ignore list' to list ignores";
}
$self->{pbot}->ignorelist->remove($target, $channel);
$self->{pbot}->logger->log("$nick removed [$target][$channel] from ignore list\n");
$self->{pbot}->{ignorelist}->remove($target, $channel);
$self->{pbot}->{logger}->log("$nick removed [$target][$channel] from ignore list\n");
return "/msg $nick [$target][$channel] unignored";
}

56
PBot/Interpreter.pm
View File

@ -97,7 +97,7 @@ sub process_line {
my $message_account = $pbot->{messagehistory}->get_message_account($nick, $user, $host);
$pbot->{messagehistory}->add_message($message_account, "$nick!$user\@$host", $from, $text, $pbot->{messagehistory}->{MSG_CHAT});
$pbot->antiflood->check_flood($from, $nick, $user, $host, $text, $pbot->{registry}->get_value('antiflood', 'max_chat_flood'), 10, $pbot->{messagehistory}->{MSG_CHAT}) if defined $from;
$pbot->{antiflood}->check_flood($from, $nick, $user, $host, $text, $pbot->{registry}->get_value('antiflood', 'max_chat_flood'), 10, $pbot->{messagehistory}->{MSG_CHAT}) if defined $from;
$text =~ s/^\s+//;
$text =~ s/\s+$//;
@ -127,17 +127,17 @@ sub process_line {
if(defined $command || defined $has_url || defined $has_code) {
if((defined $command && $command !~ /^login/i) || defined $has_url || defined $has_code) {
if(defined $from && $pbot->ignorelist->check_ignore($nick, $user, $host, $from) && not $pbot->admins->loggedin($from, "$nick!$user\@$host")) {
if(defined $from && $pbot->{ignorelist}->check_ignore($nick, $user, $host, $from) && not $pbot->{admins}->loggedin($from, "$nick!$user\@$host")) {
# ignored hostmask
$pbot->logger->log("ignored text: [$from][$nick!$user\@$host\[$text\]\n");
$pbot->{logger}->log("ignored text: [$from][$nick!$user\@$host\[$text\]\n");
return;
}
}
if(defined $has_url) {
$self->{pbot}->factoids->{factoidmodulelauncher}->execute_module($from, undef, $nick, $user, $host, $text, "title", "$nick http://$has_url", $preserve_whitespace);
$self->{pbot}->{factoids}->{factoidmodulelauncher}->execute_module($from, undef, $nick, $user, $host, $text, "title", "$nick http://$has_url", $preserve_whitespace);
} elsif(defined $has_code) {
$self->{pbot}->factoids->{factoidmodulelauncher}->execute_module($from, undef, $nick, $user, $host, $text, "compiler_block", (defined $nick_override ? $nick_override : $nick) . " $from $has_code }", $preserve_whitespace);
$self->{pbot}->{factoids}->{factoidmodulelauncher}->execute_module($from, undef, $nick, $user, $host, $text, "compiler_block", (defined $nick_override ? $nick_override : $nick) . " $from $has_code }", $preserve_whitespace);
} else {
$self->handle_result($from, $nick, $user, $host, $text, $command, $self->interpret($from, $nick, $user, $host, 1, $command), 1, $preserve_whitespace);
}
@ -157,7 +157,7 @@ sub truncate_result {
}
my $trunc = "... [truncated; see $link for full text.]";
$self->{pbot}->logger->log("Message truncated -- pasted to $link\n") if $paste;
$self->{pbot}->{logger}->log("Message truncated -- pasted to $link\n") if $paste;
my $trunc_len = length $result < $max_msg_len ? length $result : $max_msg_len;
$result = substr($result, 0, $trunc_len);
@ -180,45 +180,45 @@ sub handle_result {
if($preserve_whitespace == 0 && defined $command) {
my ($cmd, $args) = split / /, $command, 2;
#$self->{pbot}->logger->log("calling find_factoid in Interpreter.pm, process_line() for preserve_whitespace\n");
my ($chan, $trigger) = $self->{pbot}->factoids->find_factoid($from, $cmd, $args, 0, 1);
#$self->{pbot}->{logger}->log("calling find_factoid in Interpreter.pm, process_line() for preserve_whitespace\n");
my ($chan, $trigger) = $self->{pbot}->{factoids}->find_factoid($from, $cmd, $args, 0, 1);
if(defined $trigger) {
$preserve_whitespace = $self->{pbot}->factoids->factoids->hash->{$chan}->{$trigger}->{preserve_whitespace};
$preserve_whitespace = $self->{pbot}->{factoids}->{factoids}->hash->{$chan}->{$trigger}->{preserve_whitespace};
$preserve_whitespace = 0 if not defined $preserve_whitespace;
}
}
$result =~ s/\s+/ /g unless $preserve_whitespace;
$result = $self->truncate_result($from, $nick, $text, $original_result, $result, 1);
$pbot->logger->log("Final result: [$result]\n");
$pbot->{logger}->log("Final result: [$result]\n");
if($result =~ s/^\/say\s+//i) {
$pbot->conn->privmsg($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->antiflood->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
$pbot->{conn}->privmsg($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->{antiflood}->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
} elsif($result =~ s/^\/me\s+//i) {
$pbot->conn->me($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->antiflood->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', '/me ' . $result, 0, 0, 0) if $checkflood;
$pbot->{conn}->me($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->{antiflood}->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', '/me ' . $result, 0, 0, 0) if $checkflood;
} elsif($result =~ s/^\/msg\s+([^\s]+)\s+//i) {
my $to = $1;
if($to =~ /,/) {
$pbot->logger->log("[HACK] Possible HACK ATTEMPT /msg multiple users: [$nick!$user\@$host] [$command] [$result]\n");
$pbot->{logger}->log("[HACK] Possible HACK ATTEMPT /msg multiple users: [$nick!$user\@$host] [$command] [$result]\n");
}
elsif($to =~ /.*serv$/i) {
$pbot->logger->log("[HACK] Possible HACK ATTEMPT /msg *serv: [$nick!$user\@$host] [$command] [$result]\n");
$pbot->{logger}->log("[HACK] Possible HACK ATTEMPT /msg *serv: [$nick!$user\@$host] [$command] [$result]\n");
}
elsif($result =~ s/^\/me\s+//i) {
$pbot->conn->me($to, $result) if $to !~ /\Q$mynick\E/i;
$pbot->antiflood->check_flood($to, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', '/me ' . $result, 0, 0, 0) if $checkflood;
$pbot->{conn}->me($to, $result) if $to !~ /\Q$mynick\E/i;
$pbot->{antiflood}->check_flood($to, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', '/me ' . $result, 0, 0, 0) if $checkflood;
} else {
$result =~ s/^\/say\s+//i;
$pbot->conn->privmsg($to, $result) if $to !~ /\Q$mynick\E/i;
$pbot->antiflood->check_flood($to, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
$pbot->{conn}->privmsg($to, $result) if $to !~ /\Q$mynick\E/i;
$pbot->{antiflood}->check_flood($to, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
}
} else {
$pbot->conn->privmsg($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->antiflood->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
$pbot->{conn}->privmsg($from, $result) if defined $from && $from !~ /\Q$mynick\E/i;
$pbot->{antiflood}->check_flood($from, $mynick, $pbot->{registry}->get_value('irc', 'username'), 'localhost', $result, 0, 0, 0) if $checkflood;
}
$pbot->logger->log("---------------------------------------------\n");
$pbot->{logger}->log("---------------------------------------------\n");
}
sub interpret {
@ -228,13 +228,13 @@ sub interpret {
my $text;
my $pbot = $self->pbot;
$pbot->logger->log("=== Enter interpret_command: [" . (defined $from ? $from : "(undef)") . "][$nick!$user\@$host][$count][$command]\n");
$pbot->{logger}->log("=== Enter interpret_command: [" . (defined $from ? $from : "(undef)") . "][$nick!$user\@$host][$count][$command]\n");
return "Too many levels of recursion, aborted." if(++$count > 5);
if(not defined $nick || not defined $user || not defined $host ||
not defined $command) {
$pbot->logger->log("Error 1, bad parameters to interpret_command\n");
$pbot->{logger}->log("Error 1, bad parameters to interpret_command\n");
return undef;
}
@ -248,8 +248,8 @@ sub interpret {
} elsif($command =~ /^([^ ]+)\s+is\s+(.*)$/i) {
my ($k, $a) = ($1, $2);
$self->{pbot}->logger->log("calling find_factoid in Interpreter.pm, interpret() for factadd\n");
my ($channel, $trigger) = $pbot->factoids->find_factoid($from, $k, $a, 1);
$self->{pbot}->{logger}->log("calling find_factoid in Interpreter.pm, interpret() for factadd\n");
my ($channel, $trigger) = $pbot->{factoids}->find_factoid($from, $k, $a, 1);
if(defined $trigger) {
($keyword, $arguments) = ($k, "is $a");
@ -278,7 +278,7 @@ sub interpret {
}
if(not defined $keyword) {
$pbot->logger->log("Error 2, no keyword\n");
$pbot->{logger}->log("Error 2, no keyword\n");
return undef;
}

8
PBot/LagChecker.pm
View File

@ -46,19 +46,19 @@ sub initialize {
$self->{lag_history} = []; # history of previous PING/PONG timings
$self->{pong_received} = undef; # tracks pong replies; undef if no ping sent; 0 if ping sent but no pong reply yet; 1 if ping/pong completed
$pbot->timer->register(sub { $self->send_ping }, $self->{LAG_HISTORY_INTERVAL});
$pbot->{timer}->register(sub { $self->send_ping }, $self->{LAG_HISTORY_INTERVAL});
$pbot->commands->register(sub { return $self->lagcheck(@_) }, "lagcheck", 0);
$pbot->{commands}->register(sub { return $self->lagcheck(@_) }, "lagcheck", 0);
}
sub send_ping {
my $self = shift;
return unless defined $self->{pbot}->conn;
return unless defined $self->{pbot}->{conn};
$self->{ping_send_time} = [gettimeofday];
$self->{pong_received} = 0;
$self->{pbot}->conn->sl("PING :lagcheck");
$self->{pbot}->{conn}->sl("PING :lagcheck");
}
sub on_pong {

8
PBot/MessageHistory.pm
View File

@ -44,7 +44,9 @@ sub initialize {
$self->{MSG_DEPARTURE} = 2; # PART, QUIT, KICK
$self->{MSG_NICKCHANGE} = 3; # CHANGED NICK
$self->{pbot}->commands->register(sub { $self->recall_message(@_) }, "recall", 0);
$self->{pbot}->{registry}->add_default('text', 'messagehistory', 'max_messages', $conf{max_messages} // 32);
$self->{pbot}->{commands}->register(sub { $self->recall_message(@_) }, "recall", 0);
$self->{pbot}->{atexit}->register(sub { $self->{database}->end(); return; });
}
@ -63,7 +65,7 @@ sub recall_message {
my ($self, $from, $nick, $user, $host, $arguments) = @_;
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}
@ -170,7 +172,7 @@ sub recall_message {
$recall_nick = $found_nick;
}
$self->{pbot}->logger->log("$nick ($from) recalled <$recall_nick/$recall_channel> $message->{msg}\n");
$self->{pbot}->{logger}->log("$nick ($from) recalled <$recall_nick/$recall_channel> $message->{msg}\n");
my $text = $message->{msg};
my $ago = ago(gettimeofday - $message->{timestamp});

84
PBot/MessageHistory_SQLite.pm
View File

@ -29,14 +29,14 @@ sub initialize {
$self->{pbot} = delete $conf{pbot} // Carp::croak("Missing pbot reference in " . __FILE__);
$self->{filename} = delete $conf{filename} // $self->{pbot}->{registry}->get_value('general', 'data_dir') . '/message_history.sqlite3';
$self->{pbot}->timer->register(sub { $self->commit_message_history }, 5);
$self->{pbot}->{timer}->register(sub { $self->commit_message_history }, 5);
$self->{new_entries} = 0;
}
sub begin {
my $self = shift;
$self->{pbot}->logger->log("Opening message history SQLite database: $self->{filename}\n");
$self->{pbot}->{logger}->log("Opening message history SQLite database: $self->{filename}\n");
$self->{dbh} = DBI->connect("dbi:SQLite:dbname=$self->{filename}", "", "", { RaiseError => 1, PrintError => 0, AutoInactiveDestroy => 1 }) or die $DBI::errstr;
@ -93,13 +93,13 @@ SQL
$self->{dbh}->begin_work();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub end {
my $self = shift;
$self->{pbot}->logger->log("Closing message history SQLite database\n");
$self->{pbot}->{logger}->log("Closing message history SQLite database\n");
if(exists $self->{dbh} and defined $self->{dbh}) {
$self->{dbh}->commit() if $self->{new_entries};
@ -117,7 +117,7 @@ sub get_nickserv_accounts {
$sth->execute();
return $sth->fetchall_arrayref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return map {$_->[0]} @$nickserv_accounts;
}
@ -131,7 +131,7 @@ sub set_current_nickserv_account {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub get_current_nickserv_account {
@ -143,7 +143,7 @@ sub get_current_nickserv_account {
$sth->execute();
return $sth->fetchrow_hashref()->{'nickserv'};
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $nickserv;
}
@ -159,13 +159,13 @@ sub create_nickserv {
my $rv = $sth->execute();
$self->{new_entries}++ if $sth->rows;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub update_nickserv_account {
my ($self, $id, $nickserv, $timestamp) = @_;
#$self->{pbot}->logger->log("Updating nickserv account for id $id to $nickserv with timestamp [$timestamp]\n");
#$self->{pbot}->{logger}->log("Updating nickserv account for id $id to $nickserv with timestamp [$timestamp]\n");
$self->create_nickserv($id, $nickserv);
@ -177,7 +177,7 @@ sub update_nickserv_account {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub add_message_account {
@ -207,7 +207,7 @@ sub add_message_account {
}
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $id;
}
@ -222,7 +222,7 @@ sub find_message_account_by_nick {
return ($row->{id}, $row->{hostmask});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
$hostmask =~ s/!.*$// if defined $hostmask;
return ($id, $hostmask);
}
@ -236,7 +236,7 @@ sub find_message_accounts_by_nickserv {
$sth->execute();
return $sth->fetchall_arrayref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return map {$_->[0]} @$accounts;
}
@ -253,7 +253,7 @@ sub find_message_accounts_by_mask {
$sth->execute();
return $sth->fetchall_arrayref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return map {$_->[0]} @$accounts;
}
@ -271,7 +271,7 @@ sub get_message_account {
my $rows = $sth->fetchall_arrayref({});
foreach my $row (@$rows) {
$self->{pbot}->logger->log("Found matching nick $row->{hostmask} with id $row->{id}\n");
$self->{pbot}->{logger}->log("Found matching nick $row->{hostmask} with id $row->{id}\n");
}
if(not defined $rows->[0]) {
@ -280,26 +280,26 @@ sub get_message_account {
$rows = $sth->fetchall_arrayref({});
foreach my $row (@$rows) {
$self->{pbot}->logger->log("Found matching user\@host mask $row->{hostmask} with id $row->{id}\n");
$self->{pbot}->{logger}->log("Found matching user\@host mask $row->{hostmask} with id $row->{id}\n");
}
}
return $rows;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
if(defined $rows->[0]) {
$self->{pbot}->logger->log("message-history: [get-account] $nick!$user\@$host linked to $rows->[0]->{hostmask} with id $rows->[0]->{id}\n");
$self->{pbot}->{logger}->log("message-history: [get-account] $nick!$user\@$host linked to $rows->[0]->{hostmask} with id $rows->[0]->{id}\n");
$self->add_message_account("$nick!$user\@$host", $rows->[0]->{id});
$self->devalidate_all_channels($rows->[0]->{id});
my @nickserv_accounts = $self->get_nickserv_accounts($rows->[0]->{id});
foreach my $nickserv_account (@nickserv_accounts) {
$self->{pbot}->logger->log("$nick!$user\@$host [$rows->[0]->{id}] seen with nickserv account [$nickserv_account]\n");
$self->{pbot}->antiflood->check_nickserv_accounts($nick, $nickserv_account, "$nick!$user\@$host");
$self->{pbot}->{logger}->log("$nick!$user\@$host [$rows->[0]->{id}] seen with nickserv account [$nickserv_account]\n");
$self->{pbot}->{antiflood}->check_nickserv_accounts($nick, $nickserv_account, "$nick!$user\@$host");
}
return $rows->[0]->{id};
}
$self->{pbot}->logger->log("No account found for mask [$mask], adding new account\n");
$self->{pbot}->{logger}->log("No account found for mask [$mask], adding new account\n");
return $self->add_message_account($mask);
}
@ -312,7 +312,7 @@ sub find_most_recent_hostmask {
$sth->execute();
return $sth->fetchrow_hashref()->{'hostmask'};
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $hostmask;
}
@ -341,7 +341,7 @@ sub update_hostmask_data {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub get_hostmasks_for_channel {
@ -354,14 +354,14 @@ sub get_hostmasks_for_channel {
return $sth->fetchall_arrayref({});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $hostmasks;
}
sub add_message {
my ($self, $id, $mask, $channel, $message) = @_;
#$self->{pbot}->logger->log("Adding message [$id][$mask][$channel][$message->{msg}][$message->{timestamp}][$message->{mode}]\n");
#$self->{pbot}->{logger}->log("Adding message [$id][$mask][$channel][$message->{msg}][$message->{timestamp}][$message->{mode}]\n");
eval {
my $sth = $self->{dbh}->prepare('INSERT INTO Messages VALUES (?, ?, ?, ?, ?)');
@ -373,7 +373,7 @@ sub add_message {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
$self->update_channel_data($id, $channel, { last_seen => $message->{timestamp} });
$self->update_hostmask_data($mask, { last_seen => $message->{timestamp} });
}
@ -402,7 +402,7 @@ SQL
$sth->execute();
return $sth->fetchall_arrayref({});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $messages;
}
@ -430,7 +430,7 @@ sub recall_message_by_count {
};
}
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
if(defined $ignore_command) {
my $botnick = $self->{pbot}->{registry}->get_value('irc', 'botnick');
@ -473,7 +473,7 @@ sub recall_message_by_text {
};
}
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
if(defined $ignore_command) {
my $bot_trigger = $self->{pbot}->{registry}->get_value('general', 'trigger');
@ -499,7 +499,7 @@ sub get_max_messages {
$sth->finish();
return $row->{'COUNT(*)'};
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
$count = 0 if not defined $count;
return $count;
}
@ -516,7 +516,7 @@ sub create_channel {
my $rv = $sth->execute();
$self->{new_entries}++ if $sth->rows;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub get_channels {
@ -528,7 +528,7 @@ sub get_channels {
$sth->execute();
return $sth->fetchall_arrayref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return map {$_->[0]} @$channels;
}
@ -557,7 +557,7 @@ sub get_channel_data {
$sth->execute();
return $sth->fetchrow_hashref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $channel_data;
}
@ -589,7 +589,7 @@ sub update_channel_data {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub get_channel_datas_where_last_offense_older_than {
@ -601,7 +601,7 @@ sub get_channel_datas_where_last_offense_older_than {
$sth->execute();
return $sth->fetchall_arrayref({});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $channel_datas;
}
@ -613,7 +613,7 @@ sub get_channel_datas_with_enter_abuses {
$sth->execute();
return $sth->fetchall_arrayref({});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $channel_datas;
}
@ -629,7 +629,7 @@ sub devalidate_all_channels {
$sth->execute();
$self->{new_entries}++;
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
# End of public API, the remaining are internal support routines for this module
@ -644,7 +644,7 @@ sub get_new_account_id {
return $row->{id};
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return ++$id;
}
@ -659,8 +659,8 @@ sub get_message_account_id {
return $row->{id};
};
$self->{pbot}->logger->log($@) if $@;
#$self->{pbot}->logger->log("get_message_account_id: returning id [". (defined $id ? $id: 'undef') . "] for mask [$mask]\n");
$self->{pbot}->{logger}->log($@) if $@;
#$self->{pbot}->{logger}->log("get_message_account_id: returning id [". (defined $id ? $id: 'undef') . "] for mask [$mask]\n");
return $id;
}
@ -668,12 +668,12 @@ sub commit_message_history {
my $self = shift;
if($self->{new_entries} > 0) {
#$self->{pbot}->logger->log("Commiting $self->{new_entries} messages to SQLite\n");
#$self->{pbot}->{logger}->log("Commiting $self->{new_entries} messages to SQLite\n");
eval {
$self->{dbh}->commit();
};
$self->{pbot}->logger->log("SQLite error $@ when committing $self->{new_entries} entries.\n") if $@;
$self->{pbot}->{logger}->log("SQLite error $@ when committing $self->{new_entries} entries.\n") if $@;
$self->{dbh}->begin_work();
$self->{new_entries} = 0;

190
PBot/PBot.pm
View File

@ -87,38 +87,29 @@ sub initialize {
$self->{registry}->add_default('text', 'irc', 'username', delete $conf{username} // "pbot3");
$self->{registry}->add_default('text', 'irc', 'ircname', delete $conf{ircname} // "http://code.google.com/p/pbot2-pl/");
$self->{registry}->add_default('text', 'irc', 'identify_password', delete $conf{identify_password} // 'none');
$self->{registry}->set('irc', 'SSL_ca_file', 'private', 1);
$self->{registry}->set('irc', 'SSL_ca_path', 'private', 1);
$self->{registry}->set('irc', 'identify_password', 'private', 1);
$self->{registry}->add_trigger('irc', 'botnick', sub { $self->change_botnick_trigger(@_) });
$self->{registry}->add_default('text', 'antiflood', 'max_join_flood', delete $conf{max_join_flood} // 4);
$self->{registry}->add_default('text', 'antiflood', 'max_chat_flood', delete $conf{max_chat_flood} // 4);
$self->{registry}->add_default('text', 'antiflood', 'max_enter_flood', delete $conf{max_enter_flood} // 4);
$self->{registry}->add_default('text', 'antiflood', 'max_nick_flood', delete $conf{max_nick_flood} // 3);
$self->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_lines', delete $conf{enter_abuse_max_lines} // 4);
$self->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_seconds', delete $conf{enter_abuse_max_seconds} // 20);
$self->{registry}->add_default('text', 'antiflood', 'enter_abuse_max_offenses', delete $conf{enter_abuse_max_offenses} // 3);
$self->{registry}->add_default('text', 'messagehistory', 'max_messages', delete $conf{max_messages} // 32);
$self->{select_handler} = PBot::SelectHandler->new(pbot => $self);
$self->{stdin_reader} = PBot::StdinReader->new(pbot => $self);
$self->{admins} = PBot::BotAdmins->new(pbot => $self, filename => delete $conf{admins_file});
$self->{bantracker} = PBot::BanTracker->new(pbot => $self);
$self->{lagchecker} = PBot::LagChecker->new(pbot => $self);
$self->{messagehistory} = PBot::MessageHistory->new(pbot => $self, filename => delete $conf{messagehistory_file});
$self->{antiflood} = PBot::AntiFlood->new(pbot => $self);
$self->{messagehistory} = PBot::MessageHistory->new(pbot => $self, filename => delete $conf{messagehistory_file}, %conf);
$self->{antiflood} = PBot::AntiFlood->new(pbot => $self, %conf);
$self->{ignorelist} = PBot::IgnoreList->new(pbot => $self, filename => delete $conf{ignorelist_file});
$self->{irc} = PBot::IRC->new();
$self->{irchandlers} = PBot::IRCHandlers->new(pbot => $self);
$self->{channels} = PBot::Channels->new(pbot => $self, filename => delete $conf{channels_file});
$self->{chanops} = PBot::ChanOps->new(pbot => $self);
$self->interpreter(PBot::Interpreter->new(pbot => $self));
$self->interpreter->register(sub { return $self->commands->interpreter(@_); });
$self->interpreter->register(sub { return $self->factoids->interpreter(@_); });
$self->{interpreter} = PBot::Interpreter->new(pbot => $self);
$self->{interpreter}->register(sub { return $self->{commands}->interpreter(@_); });
$self->{interpreter}->register(sub { return $self->{factoids}->interpreter(@_); });
$self->{factoids} = PBot::Factoids->new(
pbot => $self,
@ -139,11 +130,11 @@ sub initialize {
# create implicit bot-admin account for bot
my $botnick = $self->{registry}->get_value('irc', 'botnick');
$self->admins->add_admin($botnick, '.*', "$botnick!stdin\@localhost", 60, 'admin', 1);
$self->admins->login($botnick, "$botnick!stdin\@localhost", 'admin');
$self->{admins}->add_admin($botnick, '.*', "$botnick!stdin\@localhost", 60, 'admin', 1);
$self->{admins}->login($botnick, "$botnick!stdin\@localhost", 'admin');
# start timer
$self->timer->start();
$self->{timer}->start();
}
# TODO: add disconnect subroutine
@ -157,9 +148,9 @@ sub connect {
$server = $self->{registry}->get_value('irc', 'ircserver') if not defined $server;
$self->logger->log("Connecting to $server ...\n");
$self->{logger}->log("Connecting to $server ...\n");
$self->conn($self->irc->newconn(
$self->{conn} = $self->{irc}->newconn(
Nick => $self->{registry}->get_value('irc', 'botnick'),
Username => $self->{registry}->get_value('irc', 'username'),
Ircname => $self->{registry}->get_value('irc', 'ircname'),
@ -167,54 +158,43 @@ sub connect {
SSL => $self->{registry}->get_value('irc', 'SSL'),
SSL_ca_file => $self->{registry}->get_value('irc', 'SSL_ca_file'),
SSL_ca_path => $self->{registry}->get_value('irc', 'SSL_ca_path'),
Port => $self->{registry}->get_value('irc', 'port')))
Port => $self->{registry}->get_value('irc', 'port'))
or Carp::croak "$0: Can't connect to IRC server.\n";
$self->{connected} = 1;
#set up default handlers for the IRC engine
$self->conn->add_handler([ 251,252,253,254,302,255 ], sub { $self->irchandlers->on_init(@_) });
$self->conn->add_handler(376 , sub { $self->irchandlers->on_connect(@_) });
$self->conn->add_handler('disconnect' , sub { $self->irchandlers->on_disconnect(@_) });
$self->conn->add_handler('notice' , sub { $self->irchandlers->on_notice(@_) });
$self->conn->add_handler('caction' , sub { $self->irchandlers->on_action(@_) });
$self->conn->add_handler('public' , sub { $self->irchandlers->on_public(@_) });
$self->conn->add_handler('msg' , sub { $self->irchandlers->on_msg(@_) });
$self->conn->add_handler('mode' , sub { $self->irchandlers->on_mode(@_) });
$self->conn->add_handler('part' , sub { $self->irchandlers->on_departure(@_) });
$self->conn->add_handler('join' , sub { $self->irchandlers->on_join(@_) });
$self->conn->add_handler('kick' , sub { $self->irchandlers->on_kick(@_) });
$self->conn->add_handler('quit' , sub { $self->irchandlers->on_departure(@_) });
$self->conn->add_handler('nick' , sub { $self->irchandlers->on_nickchange(@_) });
$self->conn->add_handler('pong' , sub { $self->lagchecker->on_pong(@_) });
$self->conn->add_handler('whoisaccount' , sub { $self->antiflood->on_whoisaccount(@_) });
$self->conn->add_handler('banlist' , sub { $self->bantracker->on_banlist_entry(@_) });
$self->conn->add_handler('endofnames' , sub { $self->bantracker->get_banlist(@_) });
# freenode quietlist
$self->conn->add_handler(728 , sub { $self->bantracker->on_quietlist_entry(@_) });
$self->{conn}->add_handler([ 251,252,253,254,302,255 ], sub { $self->{irchandlers}->on_init(@_) });
$self->{conn}->add_handler(376 , sub { $self->{irchandlers}->on_connect(@_) });
$self->{conn}->add_handler('disconnect' , sub { $self->{irchandlers}->on_disconnect(@_) });
$self->{conn}->add_handler('notice' , sub { $self->{irchandlers}->on_notice(@_) });
$self->{conn}->add_handler('caction' , sub { $self->{irchandlers}->on_action(@_) });
$self->{conn}->add_handler('public' , sub { $self->{irchandlers}->on_public(@_) });
$self->{conn}->add_handler('msg' , sub { $self->{irchandlers}->on_msg(@_) });
$self->{conn}->add_handler('mode' , sub { $self->{irchandlers}->on_mode(@_) });
$self->{conn}->add_handler('part' , sub { $self->{irchandlers}->on_departure(@_) });
$self->{conn}->add_handler('join' , sub { $self->{irchandlers}->on_join(@_) });
$self->{conn}->add_handler('kick' , sub { $self->{irchandlers}->on_kick(@_) });
$self->{conn}->add_handler('quit' , sub { $self->{irchandlers}->on_departure(@_) });
$self->{conn}->add_handler('nick' , sub { $self->{irchandlers}->on_nickchange(@_) });
$self->{conn}->add_handler('pong' , sub { $self->{lagchecker}->on_pong(@_) });
$self->{conn}->add_handler('whoisaccount' , sub { $self->{antiflood}->on_whoisaccount(@_) });
$self->{conn}->add_handler('banlist' , sub { $self->{bantracker}->on_banlist_entry(@_) });
$self->{conn}->add_handler('endofnames' , sub { $self->{bantracker}->get_banlist(@_) });
$self->{conn}->add_handler(728 , sub { $self->{bantracker}->on_quietlist_entry(@_) });
}
#main loop
sub do_one_loop {
my $self = shift;
# process IRC events
$self->irc->do_one_loop();
# process SelectHandler
$self->{irc}->do_one_loop();
$self->{select_handler}->do_select();
}
sub start {
my $self = shift;
if(not $self->{connected}) {
$self->connect();
}
while(1) {
$self->do_one_loop();
}
$self->connect() if not $self->{connected};
while(1) { $self->do_one_loop(); }
}
sub register_signal_handlers {
@ -229,109 +209,7 @@ sub atexit {
sub change_botnick_trigger {
my ($self, $section, $item, $newvalue) = @_;
if($self->{connected}) {
$self->conn->nick($newvalue);
}
}
#-----------------------------------------------------------------------------------
# Getters/Setters
#-----------------------------------------------------------------------------------
sub irc {
my $self = shift;
return $self->{irc};
}
sub logger {
my $self = shift;
if(@_) { $self->{logger} = shift; }
return $self->{logger};
}
sub channels {
my $self = shift;
if(@_) { $self->{channels} = shift; }
return $self->{channels};
}
sub factoids {
my $self = shift;
if(@_) { $self->{factoids} = shift; }
return $self->{factoids};
}
sub timer {
my $self = shift;
if(@_) { $self->{timer} = shift; }
return $self->{timer};
}
sub conn {
my $self = shift;
if(@_) { $self->{conn} = shift; }
return $self->{conn};
}
sub irchandlers {
my $self = shift;
if(@_) { $self->{irchandlers} = shift; }
return $self->{irchandlers};
}
sub interpreter {
my $self = shift;
if(@_) { $self->{interpreter} = shift; }
return $self->{interpreter};
}
sub admins {
my $self = shift;
if(@_) { $self->{admins} = shift; }
return $self->{admins};
}
sub commands {
my $self = shift;
if(@_) { $self->{commands} = shift; }
return $self->{commands};
}
sub ignorelist {
my $self = shift;
if(@_) { $self->{ignorelist} = shift; }
return $self->{ignorelist};
}
sub bantracker {
my $self = shift;
if(@_) { $self->{bantracker} = shift; }
return $self->{bantracker};
}
sub lagchecker {
my $self = shift;
if(@_) { $self->{lagchecker} = shift; }
return $self->{lagchecker};
}
sub antiflood {
my $self = shift;
if(@_) { $self->{antiflood} = shift; }
return $self->{antiflood};
}
sub quotegrabs {
my $self = shift;
if(@_) { $self->{quotegrabs} = shift; }
return $self->{quotegrabs};
}
sub chanops {
my $self = shift;
if(@_) { $self->{chanops} = shift; }
return $self->{chanops};
$self->{conn}->nick($newvalue) if $self->{connected};
}
1;

16
PBot/Quotegrabs.pm
View File

@ -47,10 +47,10 @@ sub initialize {
#-------------------------------------------------------------------------------------
# The following could be in QuotegrabsCommands.pm, or they could be kept in here?
#-------------------------------------------------------------------------------------
$self->{pbot}->commands->register(sub { $self->grab_quotegrab(@_) }, "grab", 0);
$self->{pbot}->commands->register(sub { $self->show_quotegrab(@_) }, "getq", 0);
$self->{pbot}->commands->register(sub { $self->delete_quotegrab(@_) }, "delq", 0);
$self->{pbot}->commands->register(sub { $self->show_random_quotegrab(@_) }, "rq", 0);
$self->{pbot}->{commands}->register(sub { $self->grab_quotegrab(@_) }, "grab", 0);
$self->{pbot}->{commands}->register(sub { $self->show_quotegrab(@_) }, "getq", 0);
$self->{pbot}->{commands}->register(sub { $self->delete_quotegrab(@_) }, "delq", 0);
$self->{pbot}->{commands}->register(sub { $self->show_random_quotegrab(@_) }, "rq", 0);
}
sub uniq { my %seen; grep !$seen{$_}++, @_ }
@ -156,7 +156,7 @@ sub grab_quotegrab {
my ($self, $from, $nick, $user, $host, $arguments) = @_;
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}
@ -209,7 +209,7 @@ sub grab_quotegrab {
}
}
$self->{pbot}->logger->log("$nick ($from) grabbed <$grab_nick/$channel> $message->{msg}\n");
$self->{pbot}->{logger}->log("$nick ($from) grabbed <$grab_nick/$channel> $message->{msg}\n");
if(not defined $grab_nicks) {
$grab_nicks = $grab_nick;
@ -265,7 +265,7 @@ sub delete_quotegrab {
return "/msg $nick No quotegrab matching id $arguments found.";
}
if(not $self->{pbot}->admins->loggedin($from, "$nick!$user\@$host") and $quotegrab->{grabbed_by} ne "$nick!$user\@$host") {
if(not $self->{pbot}->{admins}->loggedin($from, "$nick!$user\@$host") and $quotegrab->{grabbed_by} ne "$nick!$user\@$host") {
return "You are not the grabber of this quote.";
}
@ -310,7 +310,7 @@ sub show_random_quotegrab {
my ($nick_search, $channel_search, $text_search);
if(not defined $from) {
$self->{pbot}->logger->log("Command missing ~from parameter!\n");
$self->{pbot}->{logger}->log("Command missing ~from parameter!\n");
return "";
}

8
PBot/Quotegrabs_Hashtable.pm
View File

@ -50,7 +50,7 @@ sub load_quotegrabs {
if(@_) { $filename = shift; } else { $filename = $self->{filename}; }
return if not defined $filename;
$self->{pbot}->logger->log("Loading quotegrabs from $filename ...\n");
$self->{pbot}->{logger}->log("Loading quotegrabs from $filename ...\n");
open(FILE, "< $filename") or die "Couldn't open $filename: $!\n";
my @contents = <FILE>;
@ -75,8 +75,8 @@ sub load_quotegrabs {
$quotegrab->{id} = $i + 1;
push @{ $self->{quotegrabs} }, $quotegrab;
}
$self->{pbot}->logger->log(" $i quotegrabs loaded.\n");
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log(" $i quotegrabs loaded.\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save_quotegrabs {
@ -151,7 +151,7 @@ sub get_random_quotegrab {
};
if($@) {
$self->{pbot}->logger->log("Error in show_random_quotegrab parameters: $@\n");
$self->{pbot}->{logger}->log("Error in show_random_quotegrab parameters: $@\n");
return undef;
}

16
PBot/Quotegrabs_SQLite.pm
View File

@ -33,7 +33,7 @@ sub initialize {
sub begin {
my $self = shift;
$self->{pbot}->logger->log("Opening quotegrabs SQLite database: $self->{filename}\n");
$self->{pbot}->{logger}->log("Opening quotegrabs SQLite database: $self->{filename}\n");
$self->{dbh} = DBI->connect("dbi:SQLite:dbname=$self->{filename}", "", "", { RaiseError => 1, PrintError => 0 }) or die $DBI::errstr;
@ -50,13 +50,13 @@ CREATE TABLE IF NOT EXISTS Quotegrabs (
SQL
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
sub end {
my $self = shift;
$self->{pbot}->logger->log("Closing quotegrabs SQLite database\n");
$self->{pbot}->{logger}->log("Closing quotegrabs SQLite database\n");
if(exists $self->{dbh} and defined $self->{dbh}) {
$self->{dbh}->disconnect();
@ -80,7 +80,7 @@ sub add_quotegrab {
return $self->{dbh}->sqlite_last_insert_rowid();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $id;
}
@ -94,7 +94,7 @@ sub get_quotegrab {
return $sth->fetchrow_hashref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $quotegrab;
}
@ -137,7 +137,7 @@ sub get_random_quotegrab {
return $sth->fetchrow_hashref();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $quotegrab;
}
@ -150,7 +150,7 @@ sub get_all_quotegrabs {
return $sth->fetchall_arrayref({});
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
return $quotegrabs;
}
@ -163,7 +163,7 @@ sub delete_quotegrab {
$sth->execute();
};
$self->{pbot}->logger->log($@) if $@;
$self->{pbot}->{logger}->log($@) if $@;
}
1;

4
PBot/Registry.pm
View File

@ -43,7 +43,7 @@ sub initialize {
sub load {
my $self = shift;
$self->{pbot}->logger->log("Loading registry from " . $self->{registry}->{filename} . " ...\n");
$self->{pbot}->{logger}->log("Loading registry from " . $self->{registry}->{filename} . " ...\n");
$self->{registry}->load;
@ -53,7 +53,7 @@ sub load {
}
}
$self->{pbot}->logger->log("Done.\n");
$self->{pbot}->{logger}->log("Done.\n");
}
sub save {

22
PBot/RegistryCommands.pm
View File

@ -27,13 +27,13 @@ sub initialize {
my $pbot = delete $conf{pbot} // Carp::croak("Missing pbot reference to FactoidCommands");
$self->{pbot} = $pbot;
$pbot->commands->register(sub { return $self->regadd(@_) }, "regadd", 60);
$pbot->commands->register(sub { return $self->regrem(@_) }, "regrem", 60);
$pbot->commands->register(sub { return $self->regshow(@_) }, "regshow", 0);
$pbot->commands->register(sub { return $self->regset(@_) }, "regset", 60);
$pbot->commands->register(sub { return $self->regunset(@_) }, "regunset", 60);
$pbot->commands->register(sub { return $self->regchange(@_) }, "regchange", 60);
$pbot->commands->register(sub { return $self->regfind(@_) }, "regfind", 0);
$pbot->{commands}->register(sub { return $self->regadd(@_) }, "regadd", 60);
$pbot->{commands}->register(sub { return $self->regrem(@_) }, "regrem", 60);
$pbot->{commands}->register(sub { return $self->regshow(@_) }, "regshow", 0);
$pbot->{commands}->register(sub { return $self->regset(@_) }, "regset", 60);
$pbot->{commands}->register(sub { return $self->regunset(@_) }, "regunset", 60);
$pbot->{commands}->register(sub { return $self->regchange(@_) }, "regchange", 60);
$pbot->{commands}->register(sub { return $self->regfind(@_) }, "regfind", 0);
}
sub regset {
@ -74,7 +74,7 @@ sub regadd {
$self->{pbot}->{registry}->add('text', $section, $item, $value);
$self->{pbot}->logger->log("$nick!$user\@$host added registry entry [$section] $item => $value\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host added registry entry [$section] $item => $value\n");
return "/msg $nick [$section] $item set to $value";
}
@ -95,7 +95,7 @@ sub regrem {
return "/msg $nick No such item $item in section $section.";
}
$self->{pbot}->logger->log("$nick!$user\@$host removed registry item [$section][$item]\n");
$self->{pbot}->{logger}->log("$nick!$user\@$host removed registry item [$section][$item]\n");
$self->{pbot}->{registry}->remove($section, $item);
return "/msg $nick Registry item $item removed from section $section.";
}
@ -224,10 +224,10 @@ sub regchange {
my $ret = eval {
use re::engine::RE2 -strict => 1;
if(not $registry->{$section}->{$item}->{value} =~ s|$tochange|$changeto|) {
$self->{pbot}->logger->log("($from) $nick!$user\@$host: failed to change [$section] $item 's$delim$tochange$delim$changeto$delim$modifier\n");
$self->{pbot}->{logger}->log("($from) $nick!$user\@$host: failed to change [$section] $item 's$delim$tochange$delim$changeto$delim$modifier\n");
return "/msg $nick Change [$section] $item failed.";
} else {
$self->{pbot}->logger->log("($from) $nick!$user\@$host: changed [$section] $item 's/$tochange/$changeto/\n");
$self->{pbot}->{logger}->log("($from) $nick!$user\@$host: changed [$section] $item 's/$tochange/$changeto/\n");
$self->{pbot}->{registry}->process_trigger($section, $item, 'value', $registry->{$section}->{$item}->{value});
$self->{pbot}->{registry}->save;
return "Changed: [$section] $item set to $registry->{$section}->{$item}->{value}";

4
PBot/SelectHandler.pm
View File

@ -45,7 +45,7 @@ sub do_select {
my $ret = sysread($fh, my $buf, 8192);
if(not defined $ret) {
$self->{pbot}->logger->log("Error with $fh: $!\n");
$self->{pbot}->{logger}->log("Error with $fh: $!\n");
$self->remove_reader($fh);
next;
}
@ -58,7 +58,7 @@ sub do_select {
chomp $buf;
if(not exists $self->{readers}->{$fh}) {
$self->{pbot}->logger->log("Error: no reader for $fh\n");
$self->{pbot}->{logger}->log("Error: no reader for $fh\n");
} else {
$self->{readers}->{$fh}->($buf);
}

6
PBot/StdinReader.pm
View File

@ -36,8 +36,8 @@ sub stdin_reader {
$self->{foreground} = (tcgetpgrp($self->{tty_fd}) == getpgrp()) ? 1 : 0;
return if not $self->{foreground};
$self->{pbot}->logger->log("---------------------------------------------\n");
$self->{pbot}->logger->log("Read '$input' from STDIN\n");
$self->{pbot}->{logger}->log("---------------------------------------------\n");
$self->{pbot}->{logger}->log("Read '$input' from STDIN\n");
my ($from, $text);
@ -49,7 +49,7 @@ sub stdin_reader {
$text = $self->{pbot}->{registry}->get_value('general', 'trigger') . $input;
}
return $self->{pbot}->interpreter->process_line($from, $self->{pbot}->{registry}->get_value('irc', 'botnick'), "stdin", "localhost", $text);
return $self->{pbot}->{interpreter}->process_line($from, $self->{pbot}->{registry}->get_value('irc', 'botnick'), "stdin", "localhost", $text);
}
1;

4
PBot/VERSION.pm
View File

@ -13,8 +13,8 @@ use warnings;
# These are set automatically by the build/commit script
use constant {
BUILD_NAME => "PBot",
BUILD_REVISION => 584,
BUILD_DATE => "2014-05-17",
BUILD_REVISION => 585,
BUILD_DATE => "2014-05-18",
};
1;

3
pbot.pl
View File

@ -77,9 +77,6 @@ my %config = (
# You shouldn't need to change anything below this line.
# -----------------------------------------------------
# Maximum messages to remember per nick/hostmask in message history
MAX_MESSAGES => 256,
# Path to data directory
data_dir => "$bothome/data",