src/IRC/Irc.pl

   1 #
   2 #    Irc.pl: IRC core stuff.
   3 #    Author: dms
   4 #   Version: 20000126
   5 #      NOTE: Based on code by Kevin Lenzo & Patrick Cole  (c) 1997
   6 #
   7
   8 if (&IsParam("useStrict")) { use strict; }
   9
  10 use vars qw($nickserv);
  11 $nickserv       = 0;
  12
  13 # static scalar variables.
  14 $mask{ip}       = '(\d+)\.(\d+)\.(\d+)\.(\d+)';
  15 $mask{host}     = '[\d\w\_\-\/]+\.[\.\d\w\_\-\/]+';
  16 $mask{chan}     = '[\#\&]\S*|_default';
  17 my $isnick1     = 'a-zA-Z\[\]\{\}\_\`\^\|\\\\';
  18 my $isnick2     = '0-9\-';
  19 $mask{nick}     = "[$isnick1]{1}[$isnick1$isnick2]*";
  20 $mask{nuh}      = '\S*!\S*\@\S*';
  21
  22 sub ircloop {
  23     my $error   = 0;
  24     my $lastrun = 0;
  25
  26 loop:;
  27     while (my $host = shift @ircServers) {
  28         # JUST IN CASE. irq was complaining about this.
  29         if ($lastrun == time()) {
  30             &DEBUG("ircloop: hrm... lastrun == time()");
  31             $error++;
  32             sleep 10;
  33             next;
  34         }
  35
  36         if (!defined $host) {
  37             &DEBUG("ircloop: ircServers[x] = NULL.");
  38             $lastrun = time();
  39             next;
  40         }
  41         next unless (exists $ircPort{$host});
  42
  43         my $retval      = &irc($host, $ircPort{$host});
  44         next unless (defined $retval and $retval == 0);
  45         $error++;
  46
  47         if ($error % 3 == 0 and $error != 0) {
  48             &status("IRC: Could not connect.");
  49             &status("IRC: ");
  50             next;
  51         }
  52
  53         if ($error >= 3*2) {
  54             &status("IRC: cannot connect to any IRC servers; stopping.");
  55             &shutdown();
  56             exit 1;
  57         }
  58     }
  59
  60     &status("IRC: ok, done one cycle of IRC servers; trying again.");
  61
  62     &loadIRCServers();
  63     goto loop;
  64 }
  65
  66 sub irc {
  67     my ($server,$port) = @_;
  68
  69     my $iaddr = inet_aton($server);
  70     my $paddr = sockaddr_in($port, $iaddr);
  71     my $proto = getprotobyname('tcp');
  72
  73     select STDOUT;
  74     &status("Connecting to port $port of server $server ...");
  75
  76     # host->ip.
  77     if ($server =~ /\D$/) {
  78         my $packed = scalar(gethostbyname($server));
  79
  80         if (!defined $packed) {
  81             &status("  cannot resolve $server.");
  82             return 0;
  83         }
  84
  85         my $resolve = inet_ntoa($packed);
  86         &status("  resolved to $resolve.");
  87         ### warning in Sys/Hostname line 78???
  88         ### caused inside Net::IRC?
  89     }
  90
  91     $irc = new Net::IRC;
  92
  93     my %args = (
  94                 Nick    => $param{'ircNick'},
  95                 Server  => $server,
  96                 Port    => $port,
  97                 Ircname => $param{'ircName'},
  98     );
  99     $args{'LocalAddr'} = $param{'ircHost'} if ($param{'ircHost'});
 100
 101     $conn = $irc->newconn(%args);
 102
 103     if (!defined $conn) {
 104         &ERROR("irc: conn was not created!defined!!!");
 105         return 1;
 106     }
 107
 108     &clearIRCVars();
 109
 110     # change internal timeout value for scheduler.
 111     $irc->{_timeout}    = 10;   # how about 60?
 112     # Net::IRC debugging.
 113     $irc->{_debug}      = 1;
 114
 115     $ircstats{'Server'} = "$server:$port";
 116
 117     # handler stuff.
 118         $conn->add_handler('caction',   \&on_action);
 119         $conn->add_handler('cdcc',      \&on_dcc);
 120         $conn->add_handler('cping',     \&on_ping);
 121         $conn->add_handler('crping',    \&on_ping_reply);
 122         $conn->add_handler('cversion',  \&on_version);
 123         $conn->add_handler('crversion', \&on_crversion);
 124         $conn->add_handler('dcc_open',  \&on_dcc_open);
 125         $conn->add_handler('dcc_close', \&on_dcc_close);
 126         $conn->add_handler('chat',      \&on_chat);
 127         $conn->add_handler('msg',       \&on_msg);
 128         $conn->add_handler('public',    \&on_public);
 129         $conn->add_handler('join',      \&on_join);
 130         $conn->add_handler('part',      \&on_part);
 131         $conn->add_handler('topic',     \&on_topic);
 132         $conn->add_handler('invite',    \&on_invite);
 133         $conn->add_handler('kick',      \&on_kick);
 134         $conn->add_handler('mode',      \&on_mode);
 135         $conn->add_handler('nick',      \&on_nick);
 136         $conn->add_handler('quit',      \&on_quit);
 137         $conn->add_handler('notice',    \&on_notice);
 138         $conn->add_handler('whoischannels', \&on_whoischannels);
 139         $conn->add_handler('useronchannel', \&on_useronchannel);
 140         $conn->add_handler('whois',     \&on_whois);
 141         $conn->add_handler('other',     \&on_other);
 142         $conn->add_global_handler('disconnect', \&on_disconnect);
 143         $conn->add_global_handler([251,252,253,254,255], \&on_init);
 144 ###     $conn->add_global_handler([251,252,253,254,255,302], \&on_init);
 145         $conn->add_global_handler(315, \&on_endofwho);
 146         $conn->add_global_handler(422, \&on_endofwho); # nomotd.
 147         $conn->add_global_handler(324, \&on_modeis);
 148         $conn->add_global_handler(333, \&on_topicinfo);
 149         $conn->add_global_handler(352, \&on_who);
 150         $conn->add_global_handler(353, \&on_names);
 151         $conn->add_global_handler(366, \&on_endofnames);
 152         $conn->add_global_handler(376, \&on_endofmotd); # on_connect.
 153         $conn->add_global_handler(433, \&on_nick_taken);
 154         $conn->add_global_handler(439, \&on_targettoofast);
 155         # for proper joinnextChan behaviour
 156         $conn->add_global_handler(471, \&on_chanfull);
 157         $conn->add_global_handler(473, \&on_inviteonly);
 158         $conn->add_global_handler(474, \&on_banned);
 159         $conn->add_global_handler(475, \&on_badchankey);
 160
 161     # end of handler stuff.
 162
 163     $irc->start;
 164 }
 165
 166 ######################################################################
 167 ######## IRC ALIASES   IRC ALIASES   IRC ALIASES   IRC ALIASES #######
 168 ######################################################################
 169
 170 sub rawout {
 171     my ($buf) = @_;
 172     $buf =~ s/\n//gi;
 173
 174     # slow down a bit if traffic is "high".
 175     # need to take into account time of last message sent.
 176     if ($last{buflen} > 256 and length($buf) > 256) {
 177         sleep 1;
 178     }
 179
 180     $conn->sl($buf) if (&whatInterface() =~ /IRC/);
 181
 182     $last{buflen} = length($buf);
 183 }
 184
 185 sub say {
 186     my ($msg) = @_;
 187     if (!defined $msg) {
 188         $msg ||= "NULL";
 189         &WARN("say: msg == $msg.");
 190         return;
 191     }
 192
 193     &status("</$talkchannel> $msg");
 194     if (&whatInterface() =~ /IRC/) {
 195         $msg    = "zero" if ($msg =~ /^0+$/);
 196         my $t   = time();
 197
 198         if ($t == $pubtime) {
 199             $pubcount++;
 200             $pubsize += length $msg;
 201
 202             my $i = &getChanConfDefault("sendPublicLimitLines", 3);
 203             my $j = &getChanConfDefault("sendPublicLimitBytes", 1000);
 204
 205             if ( ($pubcount % $i) == 0 and $pubcount) {
 206                 sleep 1;
 207             } elsif ($pubsize > $j) {
 208                 sleep 1;
 209                 $pubsize -= $j;
 210             }
 211
 212         } else {
 213             $pubcount   = 0;
 214             $pubtime    = $t;
 215             $pubsize    = length $msg;
 216         }
 217
 218         $conn->privmsg($talkchannel, $msg);
 219     }
 220 }
 221
 222 sub msg {
 223     my ($nick, $msg) = @_;
 224     if (!defined $nick) {
 225         &ERROR("msg: nick == NULL.");
 226         return;
 227     }
 228
 229     if (!defined $msg) {
 230         $msg ||= "NULL";
 231         &WARN("msg: msg == $msg.");
 232         return;
 233     }
 234
 235     if ($msgType =~ /chat/i) {
 236         # todo: warn that we're using msg() to do DCC CHAT?
 237         &dccsay($nick, $msg);
 238         # todo: make dccsay deal with flood protection?
 239         return;
 240     }
 241
 242     &status(">$nick< $msg");
 243
 244     if (&whatInterface() =~ /IRC/) {
 245         my $t = time();
 246
 247         if ($t == $msgtime) {
 248             $msgcount++;
 249             $msgsize += length $msg;
 250
 251             my $i = &getChanConfDefault("sendPrivateLimitLines", 3);
 252             my $j = &getChanConfDefault("sendPrivateLimitBytes", 1000);
 253             if ( ($msgcount % $i) == 0 and $msgcount) {
 254                 sleep 1;
 255             } elsif ($msgsize > $j) {
 256                 sleep 1;
 257                 $msgsize -= $j;
 258             }
 259
 260         } else {
 261             $msgcount   = 0;
 262             $msgtime    = $t;
 263             $msgsize    = length $msg;
 264         }
 265
 266         $conn->privmsg($nick, $msg);
 267     }
 268 }
 269
 270 # Usage: &action(nick || chan, txt);
 271 sub action {
 272     my ($target, $txt) = @_;
 273     if (!defined $txt) {
 274         &WARN("action: txt == NULL.");
 275         return;
 276     }
 277
 278     my $rawout = "PRIVMSG $target :\001ACTION $txt\001";
 279     if (length $rawout > 510) {
 280         &status("action: txt too long; truncating.");
 281
 282         chop($rawout) while (length($rawout) > 510);
 283         $rawout .= "\001";
 284     }
 285
 286     &status("* $ident/$target $txt");
 287     rawout($rawout);
 288 }
 289
 290 # Usage: &notice(nick || chan, txt);
 291 sub notice {
 292     my ($target, $txt) = @_;
 293     if (!defined $txt) {
 294         &WARN("notice: txt == NULL.");
 295         return;
 296     }
 297
 298     &status("-$target- $txt");
 299
 300     my $t       = time();
 301
 302     if ($t == $nottime) {
 303         $notcount++;
 304         $notsize += length $txt;
 305
 306         my $i = &getChanConfDefault("sendNoticeLimitLines", 3);
 307         my $j = &getChanConfDefault("sendNoticeLimitBytes", 1000);
 308
 309         if ( ($notcount % $i) == 0 and $notcount) {
 310             sleep 1;
 311         } elsif ($notsize > $j) {
 312             sleep 1;
 313             $notsize -= $j;
 314         }
 315
 316     } else {
 317         $notcount       = 0;
 318         $nottime        = $t;
 319         $notsize        = length $txt;
 320     }
 321
 322     $conn->notice($target, $txt);
 323 }
 324
 325 sub DCCBroadcast {
 326     my ($txt,$flag) = @_;
 327
 328     ### FIXME: flag not supported yet.
 329
 330     foreach (keys %{ $dcc{'CHAT'} }) {
 331         $conn->privmsg($dcc{'CHAT'}{$_}, $txt);
 332     }
 333 }
 334
 335 ##########
 336 ### perform commands.
 337 ###
 338
 339 # Usage: &performReply($reply);
 340 sub performReply {
 341     my ($reply) = @_;
 342     $reply =~ /([\.\?\s]+)$/;
 343
 344     &checkMsgType($reply);
 345
 346     if ($msgType eq 'public') {
 347         if (rand() < 0.5 or $reply =~ /[\.\?]$/) {
 348             $reply = "$orig{who}: ".$reply;
 349         } else {
 350             $reply = "$reply, ".$orig{who};
 351         }
 352         &say($reply);
 353     } elsif ($msgType eq 'private') {
 354         if (rand() < 0.5) {
 355             $reply = $reply;
 356         } else {
 357             $reply = "$reply, ".$orig{who};
 358         }
 359         &msg($who, $reply);
 360     } elsif ($msgType eq 'chat') {
 361         if (!exists $dcc{'CHAT'}{$who}) {
 362             &VERB("pSR: dcc{'CHAT'}{$who} does not exist.",2);
 363             return;
 364         }
 365         $conn->privmsg($dcc{'CHAT'}{$who}, $reply);
 366     } else {
 367         &ERROR("PR: msgType invalid? ($msgType).");
 368     }
 369 }
 370
 371 # ...
 372 sub performAddressedReply {
 373     return unless ($addressed);
 374     &performReply(@_);
 375 }
 376
 377 sub pSReply {
 378     &performStrictReply(@_);
 379 }
 380
 381 # Usage: &performStrictReply($reply);
 382 sub performStrictReply {
 383     my ($reply) = @_;
 384
 385     &checkMsgType($reply);
 386
 387     if ($msgType eq 'private') {
 388         &msg($who, $reply);
 389     } elsif ($msgType eq 'public') {
 390         &say($reply);
 391     } elsif ($msgType eq 'chat') {
 392         &dccsay(lc $who, $reply);
 393     } else {
 394         &ERROR("pSR: msgType invalid? ($msgType).");
 395     }
 396 }
 397
 398 sub dccsay {
 399     my($who, $reply) = @_;
 400
 401     if (!defined $reply or $reply =~ /^\s*$/) {
 402         &WARN("dccsay: reply == NULL.");
 403         return;
 404     }
 405
 406     if (!exists $dcc{'CHAT'}{$who}) {
 407         &VERB("pSR: dcc{'CHAT'}{$who} does not exist. (2)",2);
 408         return;
 409     }
 410
 411     &status("=>$who<= $reply");         # dcc chat.
 412     $conn->privmsg($dcc{'CHAT'}{$who}, $reply);
 413 }
 414
 415 sub dcc_close {
 416     my($who) = @_;
 417     my $type;
 418
 419     foreach $type (keys %dcc) {
 420         &FIXME("dcc_close: $who");
 421         my @who = grep /^\Q$who\E$/i, keys %{ $dcc{$type} };
 422         next unless (scalar @who);
 423         $who = $who[0];
 424         &DEBUG("dcc_close... close $who!");
 425     }
 426 }
 427
 428 sub joinchan {
 429     my ($chankey) = @_;
 430     my $chan = lc $chankey;
 431
 432     if ($chankey =~ s/^($mask{chan}),\S+/ /) {
 433         $chan = lc $1;
 434     }
 435
 436     # hopefully validChan is right.
 437     if (&validChan($chan)) {
 438         &status("join: already on $chan");
 439     } else {
 440         &status("joining $b_blue$chan$ob");
 441         if (!$conn->join($chan)) {
 442             &DEBUG("joinchan: join failed. trying connect!");
 443             $conn->connect();
 444         }
 445     }
 446 }
 447
 448 sub part {
 449     my $chan;
 450
 451     foreach $chan (@_) {
 452         next if ($chan eq "");
 453         $chan =~ tr/A-Z/a-z/;   # lowercase.
 454
 455         if ($chan !~ /^$mask{chan}$/) {
 456             &WARN("part: chan is invalid ($chan)");
 457             next;
 458         }
 459
 460         &status("parting $chan");
 461         if (!&validChan($chan)) {
 462             &WARN("part: not on $chan; doing anyway");
 463 #           next;
 464         }
 465
 466         rawout("PART $chan");
 467         # deletion of $channels{chan} is done in &entryEvt().
 468     }
 469 }
 470
 471 sub mode {
 472     my ($chan, @modes) = @_;
 473     my $modes = join(" ", @modes);
 474
 475     if (&validChan($chan) == 0) {
 476         &ERROR("mode: invalid chan => '$chan'.");
 477         return;
 478     }
 479
 480     &DEBUG("mode: MODE $chan $modes");
 481
 482     rawout("MODE $chan $modes");
 483 }
 484
 485 sub op {
 486     my ($chan, @who) = @_;
 487     my $os      = "o" x scalar(@who);
 488
 489     &mode($chan, "+$os @who");
 490 }
 491
 492 sub deop {
 493     my ($chan, @who) = @_;
 494     my $os = "o" x scalar(@who);
 495
 496     &mode($chan, "-$os ".@who);
 497 }
 498
 499 sub kick {
 500     my ($nick,$chan,$msg) = @_;
 501     my (@chans) = ($chan eq "") ? (keys %channels) : lc($chan);
 502
 503     if ($chan ne "" and &validChan($chan) == 0) {
 504         &ERROR("kick: invalid channel $chan.");
 505         return;
 506     }
 507
 508     $nick =~ tr/A-Z/a-z/;
 509
 510     foreach $chan (@chans) {
 511         if (!&IsNickInChan($nick,$chan)) {
 512             &status("Kick: $nick is not on $chan.") if (scalar @chans == 1);
 513             next;
 514         }
 515
 516         if (!exists $channels{$chan}{o}{$ident}) {
 517             &status("Kick: do not have ops on $chan :(");
 518             next;
 519         }
 520
 521         &status("Kicking $nick from $chan.");
 522         if ($msg eq "") {
 523             &rawout("KICK $chan $nick");
 524         } else {
 525             &rawout("KICK $chan $nick :$msg");
 526         }
 527     }
 528 }
 529
 530 sub ban {
 531     my ($mask,$chan) = @_;
 532     my (@chans) = ($chan =~ /^\*?$/) ? (keys %channels) : lc($chan);
 533     my $ban     = 0;
 534
 535     if ($chan !~ /^\*?$/ and &validChan($chan) == 0) {
 536         &ERROR("ban: invalid channel $chan.");
 537         return;
 538     }
 539
 540     foreach $chan (@chans) {
 541         if (!exists $channels{$chan}{o}{$ident}) {
 542             &status("Ban: do not have ops on $chan :(");
 543             next;
 544         }
 545
 546         &status("Banning $mask from $chan.");
 547         &rawout("MODE $chan +b $mask");
 548         $ban++;
 549     }
 550
 551     return $ban;
 552 }
 553
 554 sub unban {
 555     my ($mask,$chan) = @_;
 556     my (@chans) = ($chan =~ /^\*?$/) ? (keys %channels) : lc($chan);
 557     my $ban     = 0;
 558
 559     &DEBUG("unban: mask = $mask, chan = @chans");
 560
 561     foreach $chan (@chans) {
 562         if (!exists $channels{$chan}{o}{$ident}) {
 563             &status("unBan: do not have ops on $chan :(");
 564             next;
 565         }
 566
 567         &status("Removed ban $mask from $chan.");
 568         &rawout("MODE $chan -b $mask");
 569         $ban++;
 570     }
 571
 572     return $ban;
 573 }
 574
 575 sub quit {
 576     my ($quitmsg) = @_;
 577     &status("QUIT $param{'ircNick'} has quit IRC ($quitmsg)");
 578     if (defined $conn) {
 579         $conn->quit($quitmsg);
 580     } else {
 581         &WARN("quit: could not quit!");
 582     }
 583 }
 584
 585 sub nick {
 586     my ($nick) = @_;
 587
 588     if (!defined $nick) {
 589         &ERROR("nick: nick == NULL.");
 590         return;
 591     }
 592
 593     if (defined $ident and $nick eq $ident) {
 594         &WARN("nick: nick == ident == '$ident'.");
 595     }
 596
 597     my $bad     = 0;
 598     $bad++ if (exists $nuh{ $param{'ircNick'} });
 599     $bad++ if (&IsNickInAnyChan($param{'ircNick'}));
 600
 601     if ($bad) {
 602         &WARN("Nick: not going to try and get my nick back. [".
 603                 scalar(localtime). "]");
 604         return;
 605     }
 606
 607     if ($nick =~ /^$mask{nick}$/) {
 608         rawout("NICK ".$nick);
 609
 610         if (defined $ident) {
 611             &status("nick: Changing nick to $nick (from $ident)");
 612         } else {
 613             &DEBUG("first time nick change.");
 614             $ident      = $nick;
 615         }
 616
 617         return 1;
 618     }
 619     &DEBUG("nick: failed... why oh why (nick => $nick)");
 620
 621     return 0;
 622 }
 623
 624 sub invite {
 625     my($who, $chan) = @_;
 626     rawout("INVITE $who $chan");
 627 }
 628
 629
 630 ##########
 631 # Channel related functions...
 632 #
 633
 634 # Usage: &joinNextChan();
 635 sub joinNextChan {
 636     if (scalar @joinchan) {
 637         $chan = shift @joinchan;
 638         &joinchan($chan);
 639
 640         if (my $i = scalar @joinchan) {
 641             &status("joinNextChan: $i chans to join.");
 642         }
 643
 644         return;
 645     }
 646
 647     # !scalar @joinchan:
 648     my @c       = &getJoinChans();
 649     if (exists $cache{joinTime} and scalar @c) {
 650         my $delta       = time() - $cache{joinTime} - 5;
 651         my $timestr     = &Time2String($delta);
 652         my $rate        = sprintf("%.1f", $delta / @c);
 653         delete $cache{joinTime};
 654
 655         &DEBUG("time taken to join all chans: $timestr; rate: $rate sec/join");
 656     }
 657
 658     # chanserv check: global channels, in case we missed one.
 659     foreach ( &ChanConfList("chanServ_ops") ) {
 660         &chanServCheck($_);
 661     }
 662 }
 663
 664 # Usage: &getNickInChans($nick);
 665 sub getNickInChans {
 666     my ($nick) = @_;
 667     my @array;
 668
 669     foreach (keys %channels) {
 670         next unless (grep /^\Q$nick\E$/i, keys %{ $channels{$_}{''} });
 671         push(@array, $_);
 672     }
 673
 674     return @array;
 675 }
 676
 677 # Usage: &getNicksInChan($chan);
 678 sub getNicksInChan {
 679     my ($chan) = @_;
 680     my @array;
 681
 682     return keys %{ $channels{$chan}{''} };
 683 }
 684
 685 sub IsNickInChan {
 686     my ($nick,$chan) = @_;
 687
 688     $chan =~ tr/A-Z/a-z/;       # not lowercase unfortunately.
 689
 690     if (&validChan($chan) == 0) {
 691         &ERROR("INIC: invalid channel $chan.");
 692         return 0;
 693     }
 694
 695     if (grep /^\Q$nick\E$/i, keys %{ $channels{$chan}{''} }) {
 696         return 1;
 697     } else {
 698         foreach (keys %channels) {
 699             next unless (/[A-Z]/);
 700             &DEBUG("iNIC: hash channels contains mixed cased chan!!!");
 701         }
 702         return 0;
 703     }
 704 }
 705
 706 sub IsNickInAnyChan {
 707     my ($nick) = @_;
 708
 709     foreach $chan (keys %channels) {
 710         next unless (grep /^\Q$nick\E$/i, keys %{ $channels{$chan}{''}  });
 711         return 1;
 712     }
 713     return 0;
 714 }
 715
 716 # Usage: &validChan($chan);
 717 sub validChan {
 718     my ($chan) = @_;
 719
 720     if (lc $chan ne $chan) {
 721         &WARN("validChan: lc chan != chan. ($chan); fixing.");
 722         $chan =~ tr/A-Z/a-z/;
 723     }
 724
 725     if (exists $channels{$chan}) {
 726         return 1;
 727     } else {
 728         return 0;
 729     }
 730 }
 731
 732 ###
 733 # Usage: &delUserInfo($nick,@chans);
 734 sub delUserInfo {
 735     my ($nick,@chans) = @_;
 736     my ($mode,$chan);
 737
 738     foreach $chan (@chans) {
 739         foreach $mode (keys %{ $channels{$chan} }) {
 740             # use grep here?
 741             next unless (exists $channels{$chan}{$mode}{$nick});
 742
 743             delete $channels{$chan}{$mode}{$nick};
 744         }
 745     }
 746 }
 747
 748 sub clearChanVars {
 749     my ($chan) = @_;
 750
 751     delete $channels{$chan};
 752 }
 753
 754 sub clearIRCVars {
 755 #    &DEBUG("clearIRCVars() called!");
 756     undef %channels;
 757     undef %floodjoin;
 758
 759     @joinchan           = &getJoinChans(1);
 760     $cache{joinTime}    = time();
 761 }
 762
 763 sub getJoinChans {
 764     my($show)   = @_;
 765     my @chans;
 766     my @skip;
 767
 768     foreach (keys %chanconf) {
 769         next if ($_ eq "_default");
 770
 771         my $val = $chanconf{$_}{autojoin};
 772         my $skip = 0;
 773
 774         if (defined $val) {
 775             $skip++ if ($val eq "0");
 776         } else {
 777             $skip++;
 778         }
 779
 780         if ($skip) {
 781             push(@skip, $_);
 782             next;
 783         }
 784
 785         push(@chans, $_);
 786     }
 787
 788     my $str;
 789     if (scalar @skip) {
 790         $str = "channels not auto-joining: @skip (joining: @chans)";
 791     } else {
 792         $str = "auto-joining all chans: @chans";
 793     }
 794
 795     &status("Chans: ".$str) if ($show);
 796
 797     return @chans;
 798 }
 799
 800 sub closeDCC {
 801 #    &DEBUG("closeDCC called.");
 802
 803     foreach $type (keys %dcc) {
 804         next if ($type ne uc($type));
 805
 806         foreach $nick (keys %{ $dcc{$type} }) {
 807             next unless (defined $nick);
 808             &status("DCC CHAT: closing DCC $type to $nick.");
 809             next unless (defined $dcc{$type}{$nick});
 810
 811             my $ref = $dcc{$type}{$nick};
 812             &dccsay($nick, "bye bye, $nick") if ($type =~ /^chat$/i);
 813             $dcc{$type}{$nick}->close();
 814             delete $dcc{$type}{$nick};
 815             &DEBUG("after close for $nick");
 816         }
 817         delete $dcc{$type};
 818     }
 819 }
 820
 821 sub joinfloodCheck {
 822     my($who,$chan,$userhost) = @_;
 823
 824     return unless (&IsChanConf("joinfloodCheck"));
 825
 826     if (exists $netsplit{lc $who}) {    # netsplit join.
 827         &DEBUG("joinfloodCheck: $who was in netsplit; not checking.");
 828     }
 829
 830     if (exists $floodjoin{$chan}{$who}{Time}) {
 831         &WARN("floodjoin{$chan}{$who} already exists?");
 832     }
 833
 834     $floodjoin{$chan}{$who}{Time} = time();
 835     $floodjoin{$chan}{$who}{Host} = $userhost;
 836
 837     ### Check...
 838     foreach (keys %floodjoin) {
 839         my $c = $_;
 840         my $count = scalar keys %{ $floodjoin{$c} };
 841         next unless ($count > 5);
 842         &DEBUG("joinflood: count => $count");
 843
 844         my $time;
 845         foreach (keys %{ $floodjoin{$c} }) {
 846             $time += $floodjoin{$c}{$_}{Time};
 847         }
 848         &DEBUG("joinflood: time => $time");
 849         $time /= $count;
 850
 851         &DEBUG("joinflood: new time => $time");
 852     }
 853
 854     ### Clean it up.
 855     my $delete = 0;
 856     my $time = time();
 857     foreach $chan (keys %floodjoin) {
 858         foreach $who (keys %{ $floodjoin{$chan} }) {
 859             my $t       = $floodjoin{$chan}{$who}{Time};
 860             next unless (defined $t);
 861
 862             my $delta   = $time - $t;
 863             next unless ($delta > 10);
 864
 865             delete $floodjoin{$chan}{$who};
 866             $delete++;
 867         }
 868     }
 869
 870     &DEBUG("joinfloodCheck: $delete deleted.") if ($delete);
 871 }
 872
 873 sub getHostMask {
 874     my($n) = @_;
 875
 876     if (exists $nuh{$n}) {
 877         return &makeHostMask($nuh{$n});
 878     } else {
 879         $cache{on_who_Hack} = 1;
 880         &rawout("WHO $n");
 881     }
 882 }
 883
 884 1;