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