src/IRC/IrcHelpers.pl

   1 #
   2 # IrcHooks.pl: IRC Hooks stuff.
   3 #      Author: dms
   4 #     Version: 20010413
   5 #     Created: 20010413
   6 #        NOTE: Based on code by Kevin Lenzo & Patrick Cole  (c) 1997
   7 #
   8
   9 #######################################################################
  10 ####### IRC HOOK HELPERS   IRC HOOK HELPERS   IRC HOOK HELPERS ########
  11 #######################################################################
  12
  13 #####
  14 # Usage: &hookMode($nick, $modes, @targets);
  15 sub hookMode {
  16     my ($nick, $modes, @targets) = @_;
  17     my $parity  = 0;
  18
  19     if ($chan =~ tr/A-Z/a-z/) {
  20         &VERB("hookMode: cased $chan.",2);
  21     }
  22
  23     my $mode;
  24     foreach $mode (split(//, $modes)) {
  25         # sign.
  26         if ($mode =~ /[-+]/) {
  27             $parity = 1         if ($mode eq "+");
  28             $parity = 0         if ($mode eq "-");
  29             next;
  30         }
  31
  32         # mode with target.
  33         if ($mode =~ /[bklov]/) {
  34             my $target = shift @targets;
  35
  36             if ($parity) {
  37                 $chanstats{$chan}{'Op'}++    if ($mode eq "o");
  38                 $chanstats{$chan}{'Ban'}++   if ($mode eq "b");
  39             } else {
  40                 $chanstats{$chan}{'Deop'}++  if ($mode eq "o");
  41                 $chanstats{$chan}{'Unban'}++ if ($mode eq "b");
  42             }
  43
  44             # modes w/ target affecting nick => cache it.
  45             if ($mode =~ /[bov]/) {
  46                 $channels{$chan}{$mode}{$target}++      if  $parity;
  47                 delete $channels{$chan}{$mode}{$target} if !$parity;
  48
  49                 # lets do some custom stuff.
  50                 if ($mode eq "o" and $parity) {
  51                     if ($nick eq "ChanServ" and $target =~ /^\Q$ident\E$/i) {
  52                         &VERB("hookmode: chanserv deopped us! asking",2);
  53                         &chanServCheck($chan);
  54                     }
  55
  56                     &chanLimitVerify($chan);
  57                 }
  58             }
  59
  60             if ($mode =~ /[l]/) {
  61                 $channels{$chan}{$mode} = $target       if  $parity;
  62                 delete $channels{$chan}{$mode}          if !$parity;
  63             }
  64         }
  65
  66         # important channel modes, targetless.
  67         if ($mode =~ /[mt]/) {
  68             $channels{$chan}{$mode}++                   if  $parity;
  69             delete $channels{$chan}{$mode}              if !$parity;
  70         }
  71     }
  72 }
  73
  74 sub hookMsg {
  75     ($msgType, $chan, $who, $message) = @_;
  76     my $skipmessage     = 0;
  77     $addressed          = 0;
  78     $addressedother     = 0;
  79     $orig{message}      = $message;
  80     $orig{who}          = $who;
  81     $addrchar           = 0;
  82
  83     $message    =~ s/[\cA-\c_]//ig;     # strip control characters
  84     $message    =~ s/^\s+//;            # initial whitespaces.
  85     $who        =~ tr/A-Z/a-z/;         # lowercase.
  86
  87     &showProc();
  88
  89     # addressing.
  90     if ($msgType =~ /private/) {
  91         # private messages.
  92         $addressed = 1;
  93     } else {
  94         # public messages.
  95         # addressing revamped by the xk.
  96         ### below needs to be fixed...
  97         if (&IsParam("addressCharacter")) {
  98             if ($message =~ s/^\Q$param{'addressCharacter'}\E//) {
  99                 $addrchar  = 1;
 100                 $addressed = 1;
 101             }
 102         }
 103
 104         if ($message =~ /^($mask{nick})([\;\:\>\, ]+) */) {
 105             my $newmessage = $';
 106             if ($1 =~ /^\Q$ident\E$/i) {
 107                 $message   = $newmessage;
 108                 $addressed = 1;
 109             } else {
 110                 # ignore messages addressed to other people or unaddressed.
 111                 $skipmessage++ if ($2 ne "" and $2 !~ /^ /);
 112             }
 113         }
 114     }
 115
 116     # Determine floodwho.
 117     my $c       = "_default";
 118     if ($msgType =~ /public/i) {
 119         # public.
 120         $floodwho = $c = lc $chan;
 121     } elsif ($msgType =~ /private/i) {
 122         # private.
 123         $floodwho = lc $who;
 124     } else {
 125         # dcc?
 126         &FIXME("floodwho = ???");
 127     }
 128
 129     my $val = &getChanConfDefault("floodRepeat", "2:5", $c);
 130     my ($count, $interval) = split /:/, $val;
 131
 132     # flood repeat protection.
 133     if ($addressed) {
 134         my $time = $flood{$floodwho}{$message} || 0;
 135
 136         if ($msgType eq "public" and (time() - $time < $interval)) {
 137             ### public != personal who so the below is kind of pointless.
 138             my @who;
 139             foreach (keys %flood) {
 140                 next if (/^\Q$floodwho\E$/);
 141                 next if (defined $chan and /^\Q$chan\E$/);
 142
 143                 push(@who, grep /^\Q$message\E$/i, keys %{ $flood{$_} });
 144             }
 145
 146             return if ($lobotomized);
 147
 148             if (scalar @who) {
 149                 &msg($who, "you already said what ".
 150                                 join(' ', @who)." have said.");
 151             } else {
 152                 &msg($who,"Someone already said that ". (time - $time) ." seconds ago" );
 153             }
 154
 155             ### TODO: delete old floodwarn{} keys.
 156             my $floodwarn = 0;
 157             if (!exists $floodwarn{$floodwho}) {
 158                 $floodwarn++;
 159             } else {
 160                 $floodwarn++ if (time() - $floodwarn{$floodwho} > $interval);
 161             }
 162
 163             if ($floodwarn) {
 164                 &status("FLOOD repetition detected from $floodwho.");
 165                 $floodwarn{$floodwho} = time();
 166             }
 167
 168             return;
 169         }
 170
 171         if ($addrchar) {
 172             &status("$b_cyan$who$ob is short-addressing me");
 173         } elsif ($msgType eq "private") {       # private.
 174             &status("$b_cyan$who$ob is /msg'ing me");
 175         } else {                                # public?
 176             &status("$b_cyan$who$ob is addressing me");
 177         }
 178
 179         $flood{$floodwho}{$message} = time();
 180     } elsif ($msgType eq "public" and &IsChanConf("kickOnRepeat")) {
 181         # unaddressed, public only.
 182
 183         ### TODO: use a separate "short-time" hash.
 184         my @data;
 185         @data   = keys %{ $flood{$floodwho} } if (exists $flood{$floodwho});
 186     }
 187
 188     $val = &getChanConfDefault("floodMessages", "5:30", $c);
 189     ($count, $interval) = split /:/, $val;
 190
 191     # flood overflow protection.
 192     if ($addressed) {
 193         foreach (keys %{ $flood{$floodwho} }) {
 194             next unless (time() - $flood{$floodwho}{$_} > $interval);
 195             delete $flood{$floodwho}{$_};
 196         }
 197
 198         my $i = scalar keys %{ $flood{$floodwho} };
 199         if ($i > $count) {
 200             my $expire = $param{'ignoreAutoExpire'} || 5;
 201
 202 #           &msg($who,"overflow of messages ($i > $count)");
 203             &msg($who,"Too many queries from you, ignoring for $expire minutes.");
 204             &status("FLOOD overflow detected from $floodwho; ignoring");
 205
 206             &ignoreAdd("*!$uh", $chan, $expire, "flood overflow auto-detected.");
 207             return;
 208         }
 209
 210         $flood{$floodwho}{$message} = time();
 211     }
 212
 213     my @ignore;
 214     if ($msgType =~ /public/i) {                    # public.
 215         $talkchannel    = $chan;
 216         &status("<$orig{who}/$chan> $orig{message}");
 217         push(@ignore, keys %{ $ignore{$chan} }) if (exists $ignore{$chan});
 218     } elsif ($msgType =~ /private/i) {             # private.
 219         &status("[$orig{who}] $orig{message}");
 220         $talkchannel    = undef;
 221         $chan           = "_default";
 222     } else {
 223         &DEBUG("unknown msgType => $msgType.");
 224     }
 225     push(@ignore, keys %{ $ignore{"*"} }) if (exists $ignore{"*"});
 226
 227     if ((!$skipmessage or &IsChanConf("seenStoreAll") > 0) and
 228         &IsChanConf("seen") > 0 and
 229         $msgType =~ /public/
 230     ) {
 231         $seencache{$who}{'time'} = time();
 232         $seencache{$who}{'nick'} = $orig{who};
 233         $seencache{$who}{'host'} = $uh;
 234         $seencache{$who}{'chan'} = $talkchannel;
 235         $seencache{$who}{'msg'}  = $orig{message};
 236         $seencache{$who}{'msgcount'}++;
 237     }
 238
 239     return if ($skipmessage);
 240     return unless (&IsParam("minVolunteerLength") or $addressed);
 241
 242     foreach (@ignore) {
 243         s/\*/\\S*/g;
 244
 245         next unless (eval { $nuh =~ /^$_$/i } );
 246
 247         # better to ignore an extra message than to allow one to get
 248         # through, although it would be better to go through ignore
 249         # checking again.
 250         if (time() - ($cache{ignoreCheckTime} || 0) > 60) {
 251             &ignoreCheck();
 252         }
 253
 254         &status("IGNORE <$who> $message");
 255         return;
 256     }
 257
 258     if (defined $nuh) {
 259         if (!defined $userHandle) {
 260             &DEBUG("line 1074: need verifyUser?");
 261             &verifyUser($who, $nuh);
 262         }
 263     } else {
 264         &DEBUG("hookMsg: 'nuh' not defined?");
 265     }
 266
 267 ### For extra debugging purposes...
 268     if ($_ = &process()) {
 269 #       &DEBUG("IrcHooks: process returned '$_'.");
 270     }
 271
 272     # hack to remove +o from ppl with +O flag.
 273     if (exists $users{$userHandle} && exists $users{$userHandle}{FLAGS} &&
 274         $users{$userHandle}{FLAGS} =~ /O/
 275     ) {
 276         $users{$userHandle}{FLAGS} =~ s/o//g;
 277     }
 278
 279     return;
 280 }
 281
 282 # this is basically run on on_join or on_quit
 283 sub chanLimitVerify {
 284     my($c)      = @_;
 285     $chan       = $c;
 286     my $l       = $channels{$chan}{'l'};
 287
 288     return unless (&IsChanConf("chanlimitcheck"));
 289
 290     if (scalar keys %netsplit) {
 291         &WARN("clV: netsplit active (1, chan = $chan); skipping.");
 292         return;
 293     }
 294
 295     if (!defined $l) {
 296         &DEBUG("$chan: running chanlimitCheck from chanLimitVerify.");
 297         &chanlimitCheck();
 298         return;
 299     }
 300
 301     # only change it if it's not set.
 302     my $plus  = &getChanConfDefault("chanlimitcheckPlus", 5, $chan);
 303     my $count = scalar(keys %{ $channels{$chan}{''} });
 304     my $int   = &getChanConfDefault("chanlimitcheckInterval", 10, $chan);
 305
 306     my $delta = $count + $plus - $l;
 307 #   $delta    =~ s/^\-//;
 308
 309     if ($plus <= 3) {
 310         &WARN("clc: stupid to have plus at $plus, fix it!");
 311     }
 312
 313     if (exists $cache{chanlimitChange}{$chan}) {
 314         if (time() - $cache{chanlimitChange}{$chan} < $int*60) {
 315             return;
 316         }
 317     }
 318
 319     &chanServCheck($chan);
 320
 321     ### todo: unify code with chanlimitcheck()
 322     return if ($delta > 5);
 323
 324     &status("clc: big change in limit for $chan ($delta);".
 325                 "going for it. (was: $l; now: ".($count+$plus).")");
 326
 327     $conn->mode($chan, "+l", $count+$plus);
 328     $cache{chanlimitChange}{$chan} = time();
 329 }
 330
 331 sub chanServCheck {
 332     ($chan) = @_;
 333
 334     if (!defined $chan or $chan =~ /^\s*$/) {
 335         &WARN("chanServCheck: chan == NULL.");
 336         return 0;
 337     }
 338
 339     if ($chan =~ tr/A-Z/a-z/) {
 340         &DEBUG("chanServCheck: lowercased chan ($chan)");
 341     }
 342
 343     if (! &IsChanConf("chanServ_ops") ) {
 344         return 0;
 345     }
 346
 347     &VERB("chanServCheck($chan) called.",2);
 348
 349     if ( &IsParam("nickServ_pass") and !$nickserv) {
 350         $conn->who("NickServ");
 351         return 0;
 352     }
 353
 354     # check for first hash then for next hash.
 355     # todo: a function for &ischanop()? &isvoice()?
 356     if (exists $channels{$chan} and exists $channels{$chan}{'o'}{$ident}) {
 357         return 0;
 358     }
 359
 360     &status("ChanServ ==> Requesting ops for $chan. (chanServCheck)");
 361     &rawout("PRIVMSG ChanServ :OP $chan $ident");
 362     return 1;
 363 }
 364
 365 1;