X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;ds=sidebyside;f=src%2FIRC%2FSchedulers.pl;h=65819a176656d3fa77583264b67f2338f106d3aa;hb=df70f89d2839b126d02b6037228ad48b918c60f5;hp=5cdefac20ec30f6230ed989895aa9a9b18cf45c9;hpb=cb247d59cc568b5f282464cc0bc4be0ad6823661;p=infobot.git

diff --git a/src/IRC/Schedulers.pl b/src/IRC/Schedulers.pl
index 5cdefac..65819a1 100644
--- a/src/IRC/Schedulers.pl
+++ b/src/IRC/Schedulers.pl
@@ -1,77 +1,120 @@
 #
 # ProcessExtra.pl: Extensions to Process.pl
 #          Author: dms
-#         Version: v0.4b (20000923)
+#         Version: v0.5 (20010124)
 #         Created: 20000117
 #
 
 if (&IsParam("useStrict")) { use strict; }
 
+use POSIX qw(strftime);
+use vars qw(%sched);
+
 sub setupSchedulers {
     &VERB("Starting schedulers...",2);
 
     # ONCE OFF.
 
     # REPETITIVE.
-    &uptimeCycle(1)	if (&IsParam("uptime"));
-    &randomQuote(1)	if (&IsParam("randomQuote"));
-    &randomFactoid(1)	if (&IsParam("randomFactoid"));
-    &logCycle(1)	if ($loggingstatus and &IsParam("logFile") and &IsParam("maxLogSize"));
-    &limitCheck(1)	if (&IsParam("limitcheck"));
+    &uptimeLoop(1);
+    &randomQuote(2);
+    &randomFactoid(2);
+    &randomFreshmeat(2);
+    &logLoop(1);
+    &chanlimitCheck(1);
     &netsplitCheck(1);	# mandatory
-    &floodCycle(1);	# mandatory
-    &seenFlush(1)	if (&IsParam("seen") and &IsParam("seenFlushInterval"));
-    &leakCheck(1);	# mandatory
-    &ignoreListCheck(1);# mandatory
-    &seenFlushOld(1)	if (&IsParam("seen"));
+    &floodLoop(1);	# mandatory
+    &seenFlush(2);
+    &leakCheck(2);	# mandatory
+    &ignoreCheck(1);	# mandatory
+    &seenFlushOld(2);
     &ircCheck(1);	# mandatory
-    &miscCheck(1);	# mandatory
+    &miscCheck(2);	# mandatory
     &shmFlush(1);	# mandatory
-    &slashdotCycle(1)	if (&IsParam("slashdot") and &IsParam("slashdotAnnounce"));
-    &freshmeatCycle(1)	if (&IsParam("freshmeat") and &IsParam("freshmeatAnnounce"));
-    &kernelCycle(1)	if (&IsParam("kernel") and &IsParam("kernelAnnounce"));
-    &wingateWriteFile(1) if (&IsParam("wingate"));
-    &factoidCheck(1)	if (&IsParam("factoidDeleteDelay"));
+    &slashdotLoop(2);
+    &freshmeatLoop(2);
+    &kernelLoop(2);
+    &wingateWriteFile(2);
+    &factoidCheck(2);
+
+#    my $count = map { exists $sched{$_}{TIME} } keys %sched;
+    my $count	= 0;
+    foreach (keys %sched) {
+#	next unless (exists $sched{$_}{TIME});
+	my $time = $sched{$_}{TIME};
+	next unless (defined $time and $time > time());
+
+	$count++;
+    }
+
+    &status("Schedulers: $count will be running.");
+###    &scheduleList();
 }
 
 sub ScheduleThis {
     my ($interval, $codename, @args) = @_;
     my $waittime = &getRandomInt($interval);
 
-    &VERB("Scheduling \&$codename() for ".&Time2String($waittime),3);
-    $conn->schedule($waittime, \&$codename, @args);
+    if (!defined $waittime) {
+	&WARN("interval == waittime == UNDEF for $codename.");
+	return;
+    }
+
+    my $time = $sched{$codename}{TIME};
+    if (defined $time and $time > time()) {
+	&WARN("Sched for $codename already exists.");
+	return;
+    }
+
+#    &VERB("Scheduling \&$codename() for ".&Time2String($waittime),3);
+
+    my $retval = $conn->schedule($waittime, \&$codename, @args);
+    $sched{$codename}{LABEL}	= $retval;
+    $sched{$codename}{TIME}	= time()+$waittime;
+    $sched{$codename}{RUNNING}	= 1;
 }
 
+####
+#### LET THE FUN BEGIN.
+####
+
 sub randomQuote {
+    my $interval = &getChanConfDefault("randomQuoteInterval", 60);
+    if (@_) {
+	&ScheduleThis($interval, "randomQuote");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"randomQuote"}{RUNNING};
+    }
+
     my $line = &getRandomLineFromFile($bot_misc_dir. "/blootbot.randtext");
     if (!defined $line) {
 	&ERROR("random Quote: weird error?");
 	return;
     }
 
-    my @channels = split(/[\s\t]+/, lc $param{'randomQuoteChannels'});
-    @channels    = keys(%channels) unless (scalar @channels);
-
-    my $good = 0;
-    foreach (@channels) {
+    foreach ( &ChanConfList("randomQuote") ) {
 	next unless (&validChan($_));
 
 	&status("sending random Quote to $_.");
 	&action($_, "Ponders: ".$line);
-	$good++;
-    }
-
-    if (!$good and scalar @channels) {
-	&WARN("randomQuote: no valid channels?");
     }
-
-    my $interval = $param{'randomQuoteInterval'} || 60;
-    &ScheduleThis($interval, "randomQuote") if (@_);
+    ### TODO: if there were no channels, don't reschedule until channel
+    ###		configuration is modified.
 }
 
 sub randomFactoid {
     my ($key,$val);
     my $error = 0;
+
+    my $interval = &getChanConfDefault("randomFactoidInterval", 60);
+    if (@_) {
+	&ScheduleThis($interval, "randomFactoid");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"randomFactoid"}{RUNNING};
+    }
+
     while (1) {
 	($key,$val) = &randKey("factoids","factoid_key,factoid_value");
 ###	$val =~ tr/^[A-Z]/[a-z]/;	# blah is Good => blah is good.
@@ -83,30 +126,54 @@ sub randomFactoid {
 	}
     }
 
-    my @channels = split(/[\s\t]+/, lc $param{'randomFactoidChannels'});
-    @channels    = keys(%channels) unless (scalar @channels);
-
-    my $good = 0;
-    foreach (@channels) {
+    foreach ( &ChanConfList("randomFactoid") ) {
 	next unless (&validChan($_));
 
 	&status("sending random Factoid to $_.");
-###	&msg($_, "$key is $val");
 	&action($_, "Thinks: \037$key\037 is $val");
 	### FIXME: Use &getReply() on above to format factoid properly?
 	$good++;
     }
+}
+
+sub randomFreshmeat {
+    my $interval = &getChanConfDefault("randomFresheatInterval", 60);
 
-    if (!$good and scalar @channels) {
-	&WARN("randomFactoid: no valid channels?");
+    if (@_) {
+	&ScheduleThis($interval, "randomFreshmeat");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"randomFreshmeat"}{RUNNING};
     }
 
-    my $interval = $param{'randomFactoidInterval'} || 60;
-    &ScheduleThis($interval, "randomFactoid") if (@_);
+    my @chans = &ChanConfList("randomFreshmeat");
+    return unless (scalar @chans);
+
+    &Forker("freshmeat", sub {
+	my $retval = &Freshmeat::randPackage();
+
+	foreach (@chans) {
+	    next unless (&validChan($_));
+
+	    &status("sending random Freshmeat to $_.");
+	    &say($_, $line);
+	}
+    } );
 }
 
-sub logCycle {
-    # check if current size is too large.
+sub logLoop {
+    if (@_) {
+	&ScheduleThis(60, "logLoop");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"logLoop"}{RUNNING};
+    }
+
+    return unless (defined fileno LOG);
+    return unless (&IsParam("logfile"));
+    return unless (&IsParam("maxLogSize"));
+
+    ### check if current size is too large.
     if ( -s $file{log} > $param{'maxLogSize'}) {
 	my $date = sprintf("%04d%02d%02d", (localtime)[5,4,3]);
 	$file{log} = $param{'logfile'} ."-". $date;
@@ -124,24 +191,24 @@ sub logCycle {
 	}
 
 	&closeLog();
-	system("/bin/mv '$param{'logfile'}' '$file{log}'");
+	CORE::system("/bin/mv '$param{'logfile'}' '$file{log}'");
 	&compress($file{log});
 	&openLog();
 	&status("cycling log file.");
     }
 
-    # check if all the logs exceed size.
+    ### check if all the logs exceed size.
     my $logdir = "$bot_base_dir/log/";
     if (opendir(LOGS, $logdir)) {
 	my $tsize = 0;
 	my (%age, %size);
 
 	while (defined($_ = readdir LOGS)) {
-	    my $logfile = "$logdir/$_";
+	    my $logfile		= "$logdir/$_";
 
 	    next unless ( -f $logfile);
-	    my $size = -s $logfile;
-	    my $age = (stat $logfile)[9]; ### or 8 ?
+	    my $size		= -s $logfile;
+	    my $age		= (stat $logfile)[9];
 
 	    $age{$age}		= $logfile;
 	    $size{$logfile}	= $size;
@@ -150,13 +217,13 @@ sub logCycle {
 	}
 	closedir LOGS;
 
-	my $delete = 0;
+	my $delete	= 0;
 	while ($tsize > $param{'maxLogSize'}) {
 	    &status("LOG: current size > max ($tsize > $param{'maxLogSize'})");
-	    my $oldest = (sort {$a <=> $b} keys %age)[0];
+	    my $oldest	= (sort {$a <=> $b} keys %age)[0];
 	    &status("LOG: unlinking $age{$oldest}.");
 	    unlink $age{$oldest};
-	    $tsize -= $oldest;
+	    $tsize	-= $oldest;
 	    $delete++;
 	}
 
@@ -166,11 +233,22 @@ sub logCycle {
 	&WARN("could not open dir $logdir");
     }
 
-    &ScheduleThis(60, "logCycle") if (@_);
 }
 
 sub seenFlushOld {
-    my $max_time = $param{'seenMaxDays'}*60*60*24;
+    if (@_) {
+	&ScheduleThis(1440, "seenFlushOld");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"seenFlushOld"}{RUNNING};
+    }
+
+    # is this global-only?
+    return unless (&IsChanConf("seen") > 0);
+    return unless (&IsChanConf("seenFlushInterval") > 0);
+
+    # global setting. does not make sense for per-channel.
+    my $max_time = &getChanConfDefault("seenMaxDays", 30) *60*60*24;
     my $delete   = 0;
 
     if ($param{'DBType'} =~ /^pg|postgres|mysql/i) {
@@ -201,40 +279,58 @@ sub seenFlushOld {
     }
     &VERB("SEEN deleted $delete seen entries.",2);
 
-    &ScheduleThis(1440, "seenFlushOld") if (@_);
 }
 
-sub limitCheck {
-    my $limitplus = $param{'limitcheckPlus'} || 5;
-    my @channels = split(/[\s\t]+/, lc $param{'limitcheck'});
+sub chanlimitCheck {
+    my $interval = &getChanConfDefault("chanlimitcheckInterval", 10);
 
-    foreach (@channels) {
-	next unless (&validChan($_));
+    if (@_) {
+	&ScheduleThis($interval, "chanlimitCheck");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"chanlimitCheck"}{RUNNING};
+    }
 
-	my $newlimit = scalar(keys %{$channels{$_}{''}}) + $limitplus;
-	my $limit = $channels{$_}{'l'};
+    foreach $chan ( &ChanConfList("chanlimitcheck") ) {
+	next unless (&validChan($chan));
 
-	next unless (!defined $limit or $limit != $newlimit);
+	my $limitplus	= &getChanConfDefault("chanlimitcheckPlus", 5, $chan);
+	my $newlimit	= scalar(keys %{$channels{$chan}{''}}) + $limitplus;
+	my $limit	= $channels{$chan}{'l'};
 
-	if (scalar keys %netsplit and $limit) {
-	    &status("Removing limit for $_ [netsplit!!!]");
-	    &rawout("MODE $_ -l");
+	if (defined $limit and scalar keys %{$channels{$chan}{''}} > $limit) {
+	    &FIXME("LIMIT: set too low!!! FIXME");
+	    ### run NAMES again and flush it.
 	}
 
-	if (!exists $channels{$_}{'o'}{$ident}) {
-	    &ERROR("limitcheck: dont have ops on $_.");
+	next unless (!defined $limit or $limit != $newlimit);
+
+	if (!exists $channels{$chan}{'o'}{$ident}) {
+	    &ERROR("chanlimitcheck: dont have ops on $chan.") unless (exists $cache{warn}{chanlimit}{$chan});
+	    $cache{warn}{chanlimit}{$chan} = 1;
+	    ### TODO: check chanserv?
 	    next;
 	}
-	&rawout("MODE $_ +l $newlimit");
-    }
+	delete $cache{warn}{chanlimit}{$chan};
 
-    my $interval = $param{'limitcheckInterval'} || 10;
-    &ScheduleThis($interval, "limitCheck") if (@_);
+	if (!defined $limit) {
+	    &DEBUG("setting limit for first time or from netsplit for $chan");
+	}
+
+	&rawout("MODE $chan +l $newlimit");
+    }
 }
 
 sub netsplitCheck {
     my ($s1,$s2);
 
+    if (@_) {
+	&ScheduleThis(30, "netsplitCheck");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"netsplitCheck"}{RUNNING};
+    }
+
     foreach $s1 (keys %netsplitservers) {
 	foreach $s2 (keys %{$netsplitservers{$s1}}) {
 	    if (time() - $netsplitservers{$s1}{$s2} > 3600) {
@@ -245,44 +341,67 @@ sub netsplitCheck {
     }
 
     # %netsplit hash checker.
+    my $count	= scalar keys %netsplit;
     foreach (keys %netsplit) {
 	if (&IsNickInAnyChan($_)) {
 	    &DEBUG("netsplitC: $_ is in some chan; removing from netsplit list.");
 	    delete $netsplit{$_};
 	}
-	next unless (time() - $netsplit{$_} > 60*60*2); # 2 hours.
-	next if (&IsNickInAnyChan($_));
+	next unless (time() - $netsplit{$_} > 60*10);
 
-	&DEBUG("netsplitC: $_ didn't come back from netsplit in 2 hours; removing from netsplit list.");
+	&DEBUG("netsplitC: $_ didn't come back from netsplit; removing from netsplit list.");
 	delete $netsplit{$_};
     }
 
-    &ScheduleThis(30, "netsplitCheck") if (@_);
+    if ($count and !scalar keys %netsplit) {
+	&DEBUG("ok, netsplit is hopefully gone. reinstating chanlimit check.");
+	&chanlimitCheck();
+    }
 }
 
-sub floodCycle {
-    my $interval = $param{'floodInterval'} || 60;	# seconds.
-    my $delete = 0;
-
+sub floodLoop {
+    my $delete   = 0;
     my $who;
+
+    if (@_) {
+	&ScheduleThis(60, "floodLoop");	# minutes.
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"floodLoop"}{RUNNING};
+    }
+
+    my $time		= time();
+    my $interval	= &getChanConfDefault("floodCycle",60);
+
     foreach $who (keys %flood) {
 	foreach (keys %{$flood{$who}}) {
-	    if (time() - $flood{$who}{$_} > $interval) {
+	    if (!exists $flood{$who}{$_}) {
+		&WARN("flood{$who}{$_} undefined?");
+		next;
+	    }
+
+	    if ($time - $flood{$who}{$_} > $interval) {
 		delete $flood{$who}{$_};
 		$delete++;
 	    }
 	}
     }
-    &VERB("floodCycle: deleted $delete items.",2);
-
-    &ScheduleThis($interval, "floodCycle") if (@_);	# minutes.
+    &VERB("floodLoop: deleted $delete items.",2);
 }
 
 sub seenFlush {
-    my $nick;
-    my $flushed = 0;
+    if (@_) {
+	my $interval = &getChanConfDefault("seenFlushInterval", 60);
+	&ScheduleThis($interval, "seenFlush");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"seenFlush"}{RUNNING};
+    }
+
     my %stats;
-    $stats{'count_old'} = &countKeys("seen");
+    my $nick;
+    my $flushed 	= 0;
+    $stats{'count_old'} = &countKeys("seen") || 0;
     $stats{'new'}	= 0;
     $stats{'old'}	= 0;
 
@@ -339,22 +458,26 @@ sub seenFlush {
 
     &status("Flushed $flushed seen entries.")		if ($flushed);
     &VERB(sprintf("  new seen: %03.01f%% (%d/%d)",
-	$stats{'new'}*100/$stats{'count_old'},
+	$stats{'new'}*100/($stats{'count_old'} || 1),
 	$stats{'new'}, $stats{'count_old'} ), 2)	if ($stats{'new'});
     &VERB(sprintf("  now seen: %3.1f%% (%d/%d)",
 	$stats{'old'}*100/&countKeys("seen"),
 	$stats{'old'}, &countKeys("seen") ), 2)		if ($stats{'old'});
 
     &WARN("scalar keys seenflush != 0!")	if (scalar keys %seenflush);
-
-    my $interval = $param{'seenFlushInterval'} || 60;
-    &ScheduleThis($interval, "seenFlush") if (@_);
 }
 
 sub leakCheck {
     my ($blah1,$blah2);
     my $count = 0;
 
+    if (@_) {
+	&ScheduleThis(240, "leakCheck");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"leakCheck"}{RUNNING};
+    }
+
     # flood.
     foreach $blah1 (keys %flood) {
 	foreach $blah2 (keys %{$flood{$blah1}}) {
@@ -374,34 +497,70 @@ sub leakCheck {
 	}
     }
 
-    &ScheduleThis(60, "leakCheck") if (@_);
+    my $delete	= 0;
+    foreach (keys %nuh) {
+	next if (&IsNickInAnyChan($_));
+	next if (exists $dcc{CHAT}{$_});
+
+	delete $nuh{$_};
+	$delete++;
+    }
+
+    &status("leakC: $delete nuh{} items deleted; now have ".
+				scalar(keys %nuh) ) if ($delete);
 }
 
-sub ignoreListCheck {
-    my $time = time();
-    my $count = 0;
+sub ignoreCheck {
+    if (@_) {
+	&ScheduleThis(60, "ignoreCheck");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"ignoreCheck"}{RUNNING};
+    }
 
-    foreach (keys %ignoreList) {
-	next if ($ignoreList{$_} == 1);
-	next unless ($time > $ignoreList{$_});
+    my $time	= time();
+    my $count	= 0;
 
-	delete $ignoreList{$_};
-	&status("ignore: $_ has expired.");
-	$count++;
+    foreach (keys %ignore) {
+	my $chan = $_;
+
+	foreach (keys %{ $ignore{$chan} }) {
+	    my @array = @{ $ignore{$chan}{$_} };
+
+	    next unless ($array[0] and $time > $array[0]);
+
+	    delete $ignore{$chan}{$_};
+	    &status("ignore: $_/$chan has expired.");
+	    $count++;
+	}
     }
     &VERB("ignore: $count items deleted.",2);
-
-    &ScheduleThis(30, "ignoreListCheck") if (@_);
 }
 
 sub ircCheck {
-    my @array = split /[\t\s]+/, $param{'join_channels'};
+
+    if (@_) {
+	&ScheduleThis(120, "ircCheck");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"ircCheck"}{RUNNING};
+    }
+
+    my @array = grep !/^_default$/, keys %chanconf;
     my $iconf = scalar(@array);
     my $inow  = scalar(keys %channels);
     if ($iconf > 2 and $inow * 2 <= $iconf) {
 	&FIXME("ircCheck: current channels * 2 <= config channels. FIXME.");
     }
 
+    # chanserv ops.
+    foreach ( &ChanConfList("chanServ_ops") ) {
+	next if (exists $channels{$chan}{'o'}{$ident});
+
+	&status("ChanServ ==> Requesting ops for $chan.");
+	&rawout("PRIVMSG ChanServ :OP $chan $ident");
+    }
+
     if (!$conn->connected and time - $msgtime > 3600) {
 	&WARN("ircCheck: no msg for 3600 and disco'd! reconnecting!");
 	$msgtime = time();	# just in case.
@@ -410,6 +569,12 @@ sub ircCheck {
 
     if ($ident !~ /^\Q$param{ircNick}\E$/) {
 	&WARN("ircCheck: ident($ident) != param{ircNick}($param{IrcNick}).");
+	if (! &IsNickInAnyChan( $param{ircNick} ) ) {
+	    &DEBUG("$param{ircNick} not in use... changing!");
+	    &nick( $param{ircNick} );
+	} else {
+	    &WARN("$param{ircNick} is still in use...");
+	}
     }
 
     &joinNextChan();
@@ -419,23 +584,42 @@ sub ircCheck {
     if (grep /^\s*$/, keys %channels) {
 	&WARN("we have a NULL chan in hash channels? removing!");
 	delete $channels{''};
-	&status("channels now:");
+
+	&DEBUG("channels now:");
 	foreach (keys %channels) {
 	    &status("  $_");
 	}
-    }
 
+	&DEBUG("channels END");
+    }
 
-    &ScheduleThis(240, "ircCheck") if (@_);
+    ### USER FILE.
+    if ($utime_userfile > $wtime_userfile and time() - $wtime_userfile > 3600) {
+	&writeUserFile();
+	$wtime_userfile = time();
+    }
+    ### CHAN FILE.
+    if ($utime_chanfile > $wtime_chanfile and time() - $wtime_chanfile > 3600) {
+	&writeChanFile();
+	$wtime_chanfile	= time();
+    }
 }
 
 sub miscCheck {
+    if (@_) {
+	&ScheduleThis(240, "miscCheck");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"miscCheck"}{RUNNING};
+    }
+
     # SHM check.
     my @ipcs;
     if ( -x "/usr/bin/ipcs") {
 	@ipcs = `/usr/bin/ipcs`;
     } else {
 	&WARN("ircCheck: no 'ipcs' binary.");
+	return;
     }
 
     # shmid stale remove.
@@ -447,33 +631,91 @@ sub miscCheck {
 
 	my ($shmid, $size) = ($2,$5);
 	next unless ($shmid != $shm and $size == 2000);
+	my $z	= &shmRead($shmid);
+	if ($z =~ /^(\d+): /) {
+	    my $time	= $1;
+	    next if (time() - $time < 60*60);
+
+	} else {
+	    &DEBUG("shm: $shmid is not ours or old blootbot => ($z)");
+	    next;
+	}
 
 	&status("SHM: nuking shmid $shmid");
-	system("/usr/bin/ipcrm shm $shmid >/dev/null");
+	CORE::system("/usr/bin/ipcrm shm $shmid >/dev/null");
+    }
+
+    # debian check.
+    opendir(DEBIAN, "$bot_base_dir/debian");
+    foreach ( grep /gz$/, readdir(DEBIAN) ) {
+	my $exit = CORE::system("gzip -t $bot_base_dir/debian/$_");
+	next unless ($exit);
+
+	&status("debian: unlinking file => $_");
+	unlink "$bot_base_dir/debian/$_";
+    }
+    closedir DEBIAN;
+
+    # user/chan file check.
+    foreach ("chan","users") {
+	my $f		= $bot_misc_dir."/blootbot.$_";
+	my $backup	= 0;
+
+	if ( -e "$f~" ) {
+	    $backup++ if ( -s $f > -s "$f~");
+	    $backup++ if ( (stat $f)[9] - (stat "$f~")[9] > 60*60*24*7);
+	} else {
+	    $backup++;
+	}
+	next unless ($backup);
+
+	### TODO: do internal copying.
+	&status("Backup: $f to $f~");
+	CORE::system("/bin/cp $f $f~");
+    }
+
+    # flush cache{lobotomy}
+    foreach (keys %{ $cache{lobotomy} }) {
+	next unless (time() - $cache{lobotomy}{$_} > 60*60);
+	delete $cache{lobotomy}{$_};
     }
 
     ### check modules if they've been modified. might be evil.
     &reloadAllModules();
-
-    &ScheduleThis(240, "miscCheck") if (@_);
 }
 
 sub shmFlush {
+    return if ($$ != $::bot_pid); # fork protection.
+
+    if (@_) {
+	&ScheduleThis(5, "shmFlush");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"shmFlush"}{RUNNING};
+    }
+
+    my $time;
     my $shmmsg = &shmRead($shm);
     $shmmsg =~ s/\0//g;         # remove padded \0's.
+    if ($shmmsg =~ s/^(\d+): //) {
+	$time	= $1;
+    }
 
     foreach (split '\|\|', $shmmsg) {
+	next if (/^$/);
 	&VERB("shm: Processing '$_'.",2);
 
 	if (/^DCC SEND (\S+) (\S+)$/) {
 	    my ($nick,$file) = ($1,$2);
 	    if (exists $dcc{'SEND'}{$who}) {
-		&msg($nick,"DCC already active.");
+		&msg($nick, "DCC already active.");
 	    } else {
 		&DEBUG("shm: dcc sending $2 to $1.");
 		$conn->new_send($1,$2);
 		$dcc{'SEND'}{$who} = time();
 	    }
+	} elsif (/^SET FORKPID (\S+) (\S+)/) {
+	    $forked{$1}{PID} = $2;
 	} elsif (/^DELETE FORK (\S+)$/) {
 	    delete $forked{$1};
 	} elsif (/^EVAL (.*)$/) {
@@ -485,58 +727,125 @@ sub shmFlush {
     }
 
     &shmWrite($shm,"") if ($shmmsg ne "");
-
-    &ScheduleThis(5, "shmFlush") if (@_);
 }
 
 ### this is semi-scheduled
 sub getNickInUse {
+    if (@_) {
+	&ScheduleThis(30, "getNickInUse");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"getNickInUse"}{RUNNING};
+    }
+
     if ($ident eq $param{'ircNick'}) {
 	&status("okay, got my nick back.");
 	return;
     }
 
     &status("Trying to get my nick back.");
-    &nick($param{'ircNick'});
-
-    &ScheduleThis(5, "getNickInUse") if (@_);
+    &nick( $param{'ircNick'} );
 }
 
-sub uptimeCycle {
-    &uptimeWriteFile();
+sub uptimeLoop {
+    return unless &IsChanConf("uptime");
+
+    if (@_) {
+	&ScheduleThis(60, "uptimeLoop");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"uptimeLoop"}{RUNNING};
+    }
 
-    &ScheduleThis(60, "uptimeCycle") if (@_);
+    &uptimeWriteFile();
 }
 
-sub slashdotCycle {
-    &Forker("slashdot", sub { &Slashdot::slashdotAnnounce(); } );
+sub slashdotLoop {
+
+    if (@_) {
+	&ScheduleThis(60, "slashdotLoop");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"slashdotLoop"}{RUNNING};
+    }
+
+    my @chans = &ChanConfList("slashdotAnnounce");
+    return unless (scalar @chans);
+
+    &Forker("slashdot", sub {
+	my $line = &Slashdot::slashdotAnnounce();
+	return unless (defined $line);
+
+	foreach (@chans) {
+	    next unless (&::validChan($_));
 
-    &ScheduleThis(60, "slashdotCycle") if (@_);
+	    &::status("sending slashdot update to $_.");
+	    &notice($_, "Slashdot: $line");
+	}
+    } );
 }
 
-sub freshmeatCycle {
-    &Forker("freshmeat", sub { &Freshmeat::freshmeatAnnounce(); } );
+sub freshmeatLoop {
+    if (@_) {
+	&ScheduleThis(60, "freshmeatLoop");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"freshmeatLoop"}{RUNNING};
+    }
 
-    &ScheduleThis(60, "freshmeatCycle") if (@_);
+    my @chans = &ChanConfList("freshmeatAnnounce");
+    return unless (scalar @chans);
+
+    &Forker("freshmeat", sub {
+	my $data = &Freshmeat::freshmeatAnnounce();
+
+	foreach (@chans) {
+	    next unless (&::validChan($_));
+
+	    &::status("sending freshmeat update to $_.");
+	    &msg($_, $data);
+	}
+    } );
 }
 
-sub kernelCycle {
-    &Forker("kernel", sub { &Kernel::kernelAnnounce(); } );
+sub kernelLoop {
+    if (@_) {
+	&ScheduleThis(240, "kernelLoop");
+	return if ($_[0] eq "2");
+    } else {
+	delete $sched{"kernelLoop"}{RUNNING};
+    }
+
+    my @chans = &ChanConfList("kernelAnnounce");
+    return unless (scalar @chans);
+
+    &Forker("kernel", sub {
+	my @data = &Kernel::kernelAnnounce();
+
+	foreach (@chans) {
+	    next unless (&::validChan($_));
 
-    &ScheduleThis(240, "kernelCycle") if (@_);
+	    &::status("sending kernel update to $_.");
+	    my $c = $_;
+	    foreach (@data) {
+		&notice($c, "Kernel: $_");
+	    }
+	}
+    } );
 }
 
 sub wingateCheck {
-    return unless &IsParam("wingate");
-    return unless ($param{'wingate'} =~ /^(.*\s+)?$chan(\s+.*)?$/i);
+    return unless &IsChanConf("wingate");
 
     ### FILE CACHE OF OFFENDING WINGATES.
     foreach (grep /^$host$/, @wingateBad) {
 	&status("Wingate: RUNNING ON $host BY $who");
-	&ban("*!*\@$host", "") if &IsParam("wingateBan");
+	&ban("*!*\@$host", "") if &IsChanConf("wingateBan");
+
+	my $reason	= &getChanConf("wingateKick");
 
-	next unless (&IsParam("wingateKick"));
-	&kick($who, "", $param{'wingateKick'})
+	next unless ($reason);
+	&kick($who, "", $reason)
     }
 
     ### RUN CACHE OF TRIED WINGATES.
@@ -547,7 +856,7 @@ sub wingateCheck {
 	&DEBUG("Already scanned $host. good.");
     }
 
-    my $interval = $param{'wingateInterval'} || 60;	# seconds.
+    my $interval = &getChanConfDefault("wingateInterval", 60); # seconds.
     return if (defined $forked{'wingate'});
     return if (time() - $wingaterun <= $interval);
     return unless (scalar(keys %wingateToDo));
@@ -560,6 +869,13 @@ sub wingateCheck {
 
 ### TODO.
 sub wingateWriteFile {
+    if (@_) {
+	&ScheduleThis(60, "wingateWriteFile");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"wingateWriteFile"}{RUNNING};
+    }
+
     return unless (scalar @wingateCache);
 
     my $file = "$bot_base_dir/$param{'ircUser'}.wingate";
@@ -585,29 +901,117 @@ sub wingateWriteFile {
     }
     close OUT;
 
-    &ScheduleThis(60, "wingateWriteFile") if (@_);
 }
 
 sub factoidCheck {
-    my @list = &searchTable("factoids", "factoid_key", "factoid_key", " #DEL#");
-    my $stale = $param{'factoidDeleteDelay'}*60*60*24;
+    if (@_) {
+	&ScheduleThis(1440, "factoidCheck");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"factoidCheck"}{RUNNING};
+    }
+
+    my @list	= &searchTable("factoids", "factoid_key", "factoid_key", " #DEL#");
+    my $stale	= &getChanConfDefault("factoidDeleteDelay", 30) *60*60*24;
+    my $time	= time();
 
     foreach (@list) {
 	my $age = &getFactInfo($_, "modified_time");	
-	next unless (time() - $age > $stale);
+	if (!defined $age or $age !~ /^\d+$/) {
+	    &WARN("age == NULL or not numeric.");
+	    next;
+	}
+
+	next unless ($time - $age > $stale);
 
 	my $fix = $_;
 	$fix =~ s/ #DEL#$//g;
-	&VERB("safedel: Removing $fix for good.",2);
+	&DEBUG("safedel: Removing $fix ($_) for good.");
+
 	&delFactoid($_);
     }
 
-    &ScheduleThis(1440, "factoidCheck") if (@_);
 }
 
-sub schedulerSTUB {
+sub dccStatus {
+    return unless (scalar keys %{ $dcc{CHAT} });
+
+    if (@_) {
+	&ScheduleThis(10, "dccStatus");
+	return if ($_[0] eq "2");	# defer.
+    } else {
+	delete $sched{"dccStatus"}{RUNNING};
+    }
+
+    my $time = strftime("%H:%M", localtime(time()) );
+
+    my $c;
+    foreach (keys %channels) {
+	my $c		= $_;
+	my $users	= keys %{ $channels{$c}{''} };
+	my $chops	= keys %{ $channels{$c}{o}  };
+	my $bans	= keys %{ $channels{$c}{b}  };
+
+	my $txt = "[$time] $c: $users members ($chops chops), $bans bans";
+	foreach (keys %{ $dcc{'CHAT'} }) {
+	    next unless (exists $channels{$c}{''}{lc $_});
+	    $conn->privmsg($dcc{'CHAT'}{$_}, $txt);
+	}
+    }
+}
+
+sub scheduleList {
+    ###
+    # custom:
+    #	a - time == now.
+    #	b - weird time.
+    ###
+
+    &DEBUG("sched:");
+    foreach (keys %{ $irc->{_queue} }) {
+	my $q = $_;
+
+	my $sched;
+	foreach (keys %sched) {
+	    next unless ($q eq $sched{$_});
+	    $sched = $_;
+	    last;
+	}
+
+	my $time = $irc->{_queue}->{$q}->[0] - time();
+
+	if (defined $sched) {
+	    &DEBUG("   $sched($q): ".&Time2String($time) );
+	} else {
+	    &DEBUG("   NULL($q): ".&Time2String($time) );
+	}
+    }
+
+    &DEBUG("end of sList.");
+}
+
+sub getChanConfDefault {
+    my($what, $default, $chan) = @_;
+
+    if (exists $param{$what}) {
+	if (!exists $cache{config}{$what}) {
+	    &status("conf: backward-compat: found param{$what} ($param{$what}) instead.");
+	    $cache{config}{$what} = 1;
+	}
+
+	return $param{$what};
+    }
+
+    my $val = &getChanConf($what, $chan);
+    if (defined $val) {
+	return $val;
+    }
+
+    $param{$what}	= $default;
+    &status("conf: auto-setting param{$what} = $default");
+    $cache{config}{$what} = 1;
 
-    &ScheduleThis(TIME_IN_MINUTES, "FUNCTION") if (@_);
+    return $default;
 }
 
 1;