Adding upstream version 20231031.upstream/20231031upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 412 insertions, 0 deletions

diff --git a/scripts/autoopper.pl b/scripts/autoopper.pl
new file mode 100644
index 0000000..61882f3
--- /dev/null
+++ b/scripts/autoopper.pl
@@ -0,0 +1,412 @@
+use strict;
+use Irssi;
+use POSIX;
+use Socket;
+use vars qw($VERSION %IRSSI);
+
+$VERSION = "3.7";
+%IRSSI = (
+	authors     => 'Toni Salomäki',
+	name        => 'autoopper',
+	contact     => 'Toni@IRCNet',
+	description => 'Auto-op script with dynamic address support and random delay',
+	license     => 'GNU GPLv2 or later',
+	url         => 'http://vinku.dyndns.org/irssi_scripts/'
+);
+
+# This is a script to auto-op people on a certain channel (all or, represented with *).
+# Users are auto-opped on join with random delay.
+# There is a possibility to use dns aliases (for example dyndns.org) for getting the correct address.
+# The auto-op list is stored into ~/.irssi/autoop
+#
+# To get the dynamic addresses to be refreshed automatically, set value to autoop_dynamic_refresh (in hours)
+# The value will be used next time the script is loaded (at startup or manual load)
+#
+# NOTICE: the datafile is in completely different format than in 1.0 and this version cannot read it. Sorry.
+#
+
+# COMMANDS:
+#
+# autoop_show - Displays list of auto-opped hostmasks & channels
+#               The current address of dynamic host is displayed in parenthesis
+#
+# autoop_add - Add new auto-op. Parameters hostmask, channel (or *) and dynamic flag
+#
+#    Dynamic flag has 3 different values:
+#      0: treat host as a static ip
+#      1: treat host as an alias for dynamic ip
+#      2: treat host as an alias for dynamic ip, but do not resolve the ip (not normally needed)
+#
+# autoop_del - Remove auto-op
+#
+# autoop_save - Save auto-ops to file (done normally automatically)
+#
+# autoop_load - Load auto-ops from file (use this if you have edited the autoop -file manually)
+#
+# autoop_check - Check all channels and op people needed
+#
+# autoop_dynamic - Refresh dynamic addresses (automatically if parameter set)
+#
+# Data is stored in ~/.irssi/autoop
+# format: host	channels	flag
+# channels separated with comma
+# one host per line
+
+my (%oplist);
+my (@opitems);
+srand();
+
+#resolve dynamic host
+sub resolve_host {
+	my ($host, $dyntype) = @_;
+
+	if (my $iaddr = inet_aton($host)) {
+		if ($dyntype ne "2") {
+			if (my $newhost = gethostbyaddr($iaddr, AF_INET)) {
+				return $newhost;
+			} else {
+				return inet_ntoa($iaddr);
+			}
+		} else {
+			return inet_ntoa($iaddr);
+		}
+	}
+	return "error";
+}
+
+# return list of dynamic hosts with real addresses
+sub fetch_dynamic_hosts {
+	my %hostcache;
+	my $resultext;
+	foreach my $item (@opitems) {
+		next if ($item->{dynamic} ne "1" && $item->{dynamic} ne "2");
+
+		my (undef, $host) = split(/\@/, $item->{mask}, 2);
+
+		# fetch the host's real address (if not cached)
+		unless ($hostcache{$host}) {
+			$hostcache{$host} = resolve_host($host, $item->{dynamic});
+			$resultext .= $host . "\t" . $hostcache{$host} . "\n";
+		}
+	}
+	chomp $resultext;
+	return $resultext;
+}
+
+# fetch real addresses for dynamic hosts
+sub cmd_change_dynamic_hosts {
+	pipe READ, WRITE;
+	my $pid = fork();
+
+	unless (defined($pid)) {
+		Irssi::print("Can't fork - aborting");
+		return;
+	}
+
+	if ($pid > 0) {
+		# the original process, just add a listener for pipe
+		close (WRITE);
+		Irssi::pidwait_add($pid);
+		my $target = {fh => \*READ, tag => undef};
+		$target->{tag} = Irssi::input_add(fileno(READ), INPUT_READ, \&read_dynamic_hosts, $target);
+	} else {
+		# the new process, fetch addresses and write to the pipe
+		print WRITE fetch_dynamic_hosts;
+		close (READ);
+		close (WRITE);
+		POSIX::_exit(1);
+	}
+}
+
+# get dynamic hosts from pipe and change them to users
+sub read_dynamic_hosts {
+ 	my $target = shift;
+	my $rh = $target->{fh};
+	my %hostcache;
+
+	while (<$rh>) {
+		chomp;
+		my ($dynhost, $realhost, undef) = split (/\t/, $_, 3);
+		$hostcache{$dynhost} = $realhost;
+	}
+
+	close($target->{fh});
+	Irssi::input_remove($target->{tag});
+
+	my $mask;
+	my $count = 0;
+	undef %oplist if (%oplist);
+
+	foreach my $item (@opitems) {
+		if ($item->{dynamic} eq "1" || $item->{dynamic} eq "2") {
+			my ($user, $host) = split(/\@/, $item->{mask}, 2);
+
+			$count++ if ($item->{dynmask} ne $hostcache{$host});
+			$item->{dynmask} = $hostcache{$host};
+			$mask = $user . "\@" . $hostcache{$host};
+		} else {
+			$mask = $item->{mask};
+		}
+
+		foreach my $channel (split (/,/,$item->{chan})) {
+			$oplist{$channel} .= "$mask ";
+		}
+	}
+	chop %oplist;
+	Irssi::print("$count dynamic hosts changed") if ($count > 0);
+}
+
+# Save data to file
+sub cmd_save_autoop {
+	my $file = Irssi::get_irssi_dir."/autoop";
+	open FILE, ">", "$file" or return;
+
+	foreach my $item (@opitems) {
+		printf FILE ("%s\t%s\t%s\n", $item->{mask}, $item->{chan}, $item->{dynamic});
+	}
+
+	close FILE;
+	Irssi::print("Auto-op list saved to $file");
+}
+
+# Load data from file
+sub cmd_load_autoop {
+	my $file = Irssi::get_irssi_dir."/autoop";
+	open FILE, "<","$file" or return;
+	undef @opitems if (@opitems);
+
+	while (<FILE>) {
+		chomp;
+		my ($mask, $chan, $dynamic, undef) = split (/\t/, $_, 4);
+		my $item = {mask=>$mask, chan=>$chan, dynamic=>$dynamic, dynmask=>undef};
+		push (@opitems, $item);
+	}
+
+	close FILE;
+	Irssi::print("Auto-op list reloaded from $file");
+	cmd_change_dynamic_hosts;
+}
+
+# Show who's being auto-opped
+sub cmd_show_autoop {
+	my %list;
+	foreach my $item (@opitems) {
+		foreach my $channel (split (/,/,$item->{chan})) {
+			$list{$channel} .= "\n" . $item->{mask};
+			$list{$channel} .= " (" . $item->{dynmask} . ")" if ($item->{dynmask});
+		}
+	}
+
+	Irssi::print("All channels:" . $list{"*"}) if (exists $list{"*"});
+	delete $list{"*"}; #this is already printed, so remove it
+	foreach my $channel (sort (keys %list)) {
+		Irssi::print("$channel:" . $list{$channel});
+	}
+}
+
+# Add new auto-op
+sub cmd_add_autoop {
+	my ($data) = @_;
+	my ($mask, $chan, $dynamic, undef) = split(" ", $data, 4);
+	my $found = 0;
+
+	if ($chan eq "" || $mask eq "" || !($mask =~ /.+!.+@.+/)) {
+		Irssi::print("Invalid hostmask. It must contain both ! and @.") if (!($mask =~ /.+!.+@.+/));
+		Irssi::print("Usage: /autoop_add <hostmask> <*|#channel> [dynflag]");
+		Irssi::print("Dynflag: 0 normal, 1 dynamic, 2 dynamic without resolving");
+		return;
+	}
+
+	foreach my $item (@opitems) {
+		next unless ($item->{mask} eq $mask);
+		$found = 1;
+		$item->{chan} .= ",$chan";
+		last;
+	}
+
+	if ($found == 0) {
+		$dynamic = "0" unless ($dynamic eq "1" || $dynamic eq "2");
+		my $item = {mask=>$mask, chan=>$chan, dynamic=>$dynamic, dynmask=>undef};
+		push (@opitems, $item);
+	}
+
+	$oplist{$chan} .= " $mask";
+
+	Irssi::print("Added auto-op: $chan: $mask");
+}
+
+# Remove autoop
+sub cmd_del_autoop {
+	my ($data) = @_;
+	my ($mask, $channel, undef) = split(" ", $data, 3);
+
+	if ($channel eq "" || $mask eq "") {
+		Irssi::print("Usage: /autoop_del <hostmask> <*|#channel>");
+		return;
+	}
+
+	my $i=0;
+	foreach my $item (@opitems) {
+		if ($item->{mask} eq $mask) {
+			if ($channel eq "*" || $item->{chan} eq $channel) {
+				splice @opitems, $i, 1;
+				Irssi::print("Removed: $mask");
+			} else {
+				my $newchan;
+				foreach my $currchan (split (/,/,$item->{chan})) {
+					if ($channel eq $currchan) {
+						Irssi::print("Removed: $channel from $mask");
+					} else {
+						$newchan .= $currchan . ",";
+					}
+				}
+				chop $newchan;
+				Irssi::print("Couldn't remove $channel from $mask") if ($item->{chan} eq $newchan);
+				$item->{chan} = $newchan;
+			}
+			last;
+		}
+		$i++;
+	}
+}
+
+# Do the actual opping
+sub do_autoop {
+	my $target = shift;
+
+	Irssi::timeout_remove($target->{tag});
+
+	# nick has to be fetched again, because $target->{nick}->{op} is not updated
+	my $nick = $target->{chan}->nick_find($target->{nick}->{nick});
+
+	# if nick is changed during delay, it will probably be lost here...
+	if ($nick->{nick} ne "") {
+		if ($nick->{host} eq $target->{nick}->{host}) {
+			$target->{chan}->command("op " . $nick->{nick}) unless ($nick->{op});
+		} else {
+			Irssi::print("Host changed for nick during delay: " . $nick->{nick});
+		}
+	}
+	undef $target;
+}
+
+# Someone joined, might be multiple person. Check if opping is needed
+sub event_massjoin {
+	my ($channel, $nicklist) = @_;
+	my @nicks = @{$nicklist};
+
+	return if (!$channel->{chanop});
+
+	my $masks = $oplist{"*"} . " " . $oplist{$channel->{name}};
+
+	foreach my $nick (@nicks) {
+		my $host = $nick->{host};
+		$host=~ s/^~//g; # remove this if you don't want to strip ~ from username (no ident)
+		next unless ($channel->{server}->masks_match($masks, $nick->{nick}, $host));
+
+		my $min_delay = Irssi::settings_get_int("autoop_min_delay");
+		my $max_delay = Irssi::settings_get_int("autoop_max_delay") - $min_delay;
+		my $delay = int(rand($max_delay)) + $min_delay;
+
+		my $target = {nick => $nick, chan => $channel, tag => undef};
+
+		$target->{tag} = Irssi::timeout_add($delay, 'do_autoop', $target);
+	}
+
+}
+
+# Check channel op status
+sub do_channel_check {
+	my $target = shift;
+
+	Irssi::timeout_remove($target->{tag});
+
+	my $channel = $target->{chan};
+	my $server = $channel->{server};
+	my $masks = $oplist{"*"} . " " . $oplist{$channel->{name}};
+	my $nicks = "";
+
+	foreach my $nick ($channel->nicks()) {
+		next if ($nick->{op});
+
+		my $host = $nick->{host};
+		$host=~ s/^~//g; # remove this if you don't want to strip ~ from username (no ident)
+
+		if ($server->masks_match($masks, $nick->{nick}, $host)) {
+			$nicks = $nicks . " " . $nick->{nick};
+		}
+	}
+	$channel->command("op" . $nicks) unless ($nicks eq "");
+
+	undef $target;
+}
+
+#check people needing opping after getting ops
+sub event_nickmodechange {
+	my ($channel, $nick, $setby, $mode, $type) = @_;
+
+	return unless (($mode eq '@') && ($type eq '+'));
+
+	my $server = $channel->{server};
+
+	return unless ($server->{nick} eq $nick->{nick});
+
+	my $min_delay = Irssi::settings_get_int("autoop_min_delay");
+	my $max_delay = Irssi::settings_get_int("autoop_max_delay") - $min_delay;
+	my $delay = int(rand($max_delay)) + $min_delay;
+
+	my $target = {chan => $channel, tag => undef};
+
+	$target->{tag} = Irssi::timeout_add($delay, 'do_channel_check', $target);
+}
+
+#Check all channels / all users if someone needs to be opped
+sub cmd_autoop_check {
+	my ($data, $server, $witem) = @_;
+
+	foreach my $channel ($server->channels()) {
+		Irssi::print("Checking: " . $channel->{name});
+		next if (!$channel->{chanop});
+
+		my $masks = $oplist{"*"} . " " . $oplist{$channel->{name}};
+
+		foreach my $nick ($channel->nicks()) {
+			next if ($nick->{op});
+
+			my $host = $nick->{host};
+			$host=~ s/^~//g; # remove this if you don't want to strip ~ from username (no ident)
+
+			if ($server->masks_match($masks, $nick->{nick}, $host)) {
+				$channel->command("op " . $nick->{nick}) if (!$nick->{op});
+			}
+		}
+	}
+}
+
+#Set dynamic refresh period.
+sub set_dynamic_refresh {
+	my $refresh = Irssi::settings_get_int("autoop_dynamic_refresh");
+	return if ($refresh == 0);
+
+	Irssi::print("Dynamic host refresh set for $refresh hours");
+	Irssi::timeout_add($refresh*3600000, 'cmd_change_dynamic_hosts', undef);
+}
+
+Irssi::command_bind('autoop_show', 'cmd_show_autoop');
+Irssi::command_bind('autoop_add', 'cmd_add_autoop');
+Irssi::command_bind('autoop_del', 'cmd_del_autoop');
+Irssi::command_bind('autoop_save', 'cmd_save_autoop');
+Irssi::command_bind('autoop_load', 'cmd_load_autoop');
+Irssi::command_bind('autoop_check', 'cmd_autoop_check');
+Irssi::command_bind('autoop_dynamic', 'cmd_change_dynamic_hosts');
+Irssi::signal_add_last('massjoin', 'event_massjoin');
+Irssi::signal_add_last('setup saved', 'cmd_save_autoop');
+Irssi::signal_add_last('setup reread', 'cmd_load_autoop');
+Irssi::signal_add_last("nick mode changed", "event_nickmodechange");
+Irssi::settings_add_int('autoop', 'autoop_max_delay', 15000);
+Irssi::settings_add_int('autoop', 'autoop_min_delay', 1000);
+Irssi::settings_add_int('autoop', 'autoop_dynamic_refresh', 0);
+
+
+cmd_load_autoop;
+set_dynamic_refresh;