Adding upstream version 20231031.upstream/20231031upstream

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

1 files changed, 2719 insertions, 0 deletions

diff --git a/scripts/friends_shasta.pl b/scripts/friends_shasta.pl
new file mode 100644
index 0000000..f05dd1a
--- /dev/null
+++ b/scripts/friends_shasta.pl
@@ -0,0 +1,2719 @@
+#!/usr/bin/perl -w
+#
+# This script may not work with irssi older than 0.8.5!
+#
+# Historical author of this script is Erkki Seppala <flux@inside.org>
+# Now it's maintained by me, so i'm listed as an author.
+# 
+# $Id: friends.pl,v 1.3 2003/11/09 21:11:45 shasta Exp $ 
+
+use strict;
+use vars qw($VERSION %IRSSI);
+
+$VERSION = "2.4.9";
+%IRSSI = (
+    authors	=> 'Jakub Jankowski',
+    contact	=> 'shasta@toxcorp.com',
+    name	=> 'Friends',
+    description	=> 'Maintains list of people you know.',
+    license	=> 'GNU GPLv2 or later',
+    url		=> 'http://toxcorp.com/irc/irssi/friends/',
+    changed	=> 'Sun Oct 9 22:12:43 2003'
+);
+
+use Irssi 20011201.0100 ();
+use Irssi::Irc;
+
+# friends.pl
+my $friends_version = $VERSION . " (20031109)";
+
+# release note, if any
+my $release_note = "Please read http://toxcorp.com/irc/irssi/friends/current/README\n";
+
+##############################################
+# These variables are adjustable with /set
+# but here are some 'safe' defaults:
+
+# do you want to process CTCP queries?
+my $default_friends_use_ctcp = 1;
+
+# space-separated list of allowed (implemented ;) CTCP commands
+my $default_friends_ctcp_commands = "OP VOICE LIMIT KEY INVITE PASS IDENT UNBAN";
+
+# do you want to learn new users?
+my $default_friends_learn = 1;
+
+# do you want to autovoice already opped nicks?
+my $default_friends_voice_opped = 0;
+
+# do you want to show additional info with /whois?
+my $default_friends_show_whois_extra = 1;
+
+# which flags do you want to add automatically with /addfriend? (case *sensitive*)
+my $default_friends_default_flags = "";
+
+# default path to friendlist
+my $default_friends_file = Irssi::get_irssi_dir() . "/friends";
+
+# do you want to save friendlist every time irssi's setup is saved
+my $default_friends_autosave = 0;
+
+# do you want to backup your friendlist upon a save
+my $default_friends_backup_friendlist = 1;
+
+# backup suffix to use (unixtime if empty)
+my $default_friends_backup_suffix = ".backup";
+
+# do you want to show friend's flags while he joins a channel?
+my $default_friends_show_flags_on_join = 1;
+
+# do you want to revenge?
+my $default_friends_revenge = 1;
+
+# revenge mode:
+# 0 Deop the user.
+# 1 Deop the user and give them the +D flag for the channel.
+# 2 Deop the user, give them the +D flag for the channel, and kick them.
+# 3 Deop the user, give them the +D flag for the channel, kick, and ban them.
+my $default_friends_revenge_mode = 0;
+
+# do you want /findfriends to print info in separate windows for separate chans?
+my $default_friends_findfriends_to_windows = 0;
+
+# maximum size of operationQueue
+my $default_friends_max_queue_size = 20;
+
+# min delaytime
+my $default_delay_min = 10;
+
+# max delaytime
+my $default_delay_max = 60;
+
+###############################################################
+
+# registering themes
+Irssi::theme_register([
+	'friends_empty',		'Your friendlist is empty. Add items with /ADDFRIEND',
+	'friends_notenoughargs',	'Not enough arguments. Usage: $0',
+	'friends_badargs',		'Bad arguments. Usage: $0',
+	'friends_nosuch',		'No such friend %R$0%n',
+	'friends_notonchan',		'Not on channel {hilight $0}',
+	'friends_endof',		'End of $0 $1',
+	'friends_badhandle',		'Wrong handle: %R$0%n. $1',
+	'friends_notuniqhandle',	'Handle %R$0%n already exists, choose another one',
+	'friends_version',		'friends.pl\'s version: {hilight $0} [$1]',
+	'friends_file_written',		'friendlist written on: {hilight $0}',
+	'friends_file_version',		'friendlist written with: {hilight $0} [$1]',
+	'friends_filetooold',		'Friendfile too old, loading aborted',
+	'friends_loaded',		'Loaded {hilight $0} friends from $1',
+	'friends_saved',		'Saved {hilight $0} friends to $1',
+	'friends_duplicate',		'Skipping %R$0%n [duplicate?]',
+	'friends_checking',		'Checking {hilight $0} took {hilight $1} secs [on $2]',
+	'friends_line_head',		'[$[!-3]0] Handle: %R$1%n, flags: %C$2%n [password: $3]',
+	'friends_line_hosts',		'$[-6]9 Hosts: $0',
+	'friends_line_chan',		'$[-6]9 Channel {hilight $0}: Flags: %c$1%n, Delay: $2',
+	'friends_line_comment',		'$[-6]9 Comment: $0',
+	'friends_line_currentnick',	'$[-6]9 [$1] Current nick: {nick $0}',
+	'friends_line_channelson',	'$[-6]9 [$1] Currently sharing with you: $0',
+	'friends_joined',		'{nick $0} is a friend, handle: %R$1%n, global flags: %C$2%n, flags for {hilight $3}: %C$4%n',
+	'friends_whois',		'{whois friend handle: {hilight $0}, global flags: $1}',
+	'friends_queue_empty',		'Operation queue is empty',
+	'friends_queue_line1',		'[$[!-2]0] Operation: %R$1%n secs left before {hilight $2}',
+	'friends_queue_line2',		'     (Server: {hilight $0}, Channel: {hilight $1}, Nicklist: $2)',
+	'friends_queue_nosuch',		'No such entry in operation queue ($0)',
+	'friends_queue_removed',	'$0 queues: {hilight $1} [$2]',
+	'friends_friendlist',		'{hilight Friendlist} [$0]:',
+	'friends_friendlist_count',	'Listed {hilight $0} friend$1',
+	'friends_findfriends',		'Looking for %R$2%n on channel {hilight $0} [on $1]:',
+	'friends_already_added',	'Nick {hilight $0} matches one of %R$1%n\'s hosts',
+	'friends_added',		'Added %R$0%n to friendlist',
+	'friends_removed',		'Removed %R$0%n from friendlist',
+	'friends_comment_added',	'Added comment line to %R$0%n ($1)',
+	'friends_comment_removed',	'Removed comment line from %R$0%n',
+	'friends_host_added',		'Added {hilight $1} to %R$0%n',
+	'friends_host_removed',		'Removed {hilight $1} from %R$0%n',
+	'friends_host_exists',		'Hostmask {hilight $1} overlaps with one of the already added to %R$0%n',
+	'friends_host_notexists',	'%R$0%n does not have {hilight $1} in hostlist',
+	'friends_chanrec_removed',	'Removed {hilight $1} record from %R$0%n',
+	'friends_chanrec_notexists',	'%R$0%n does not have {hilight $1} record',
+	'friends_changed_handle',	'Changed {hilight $0} to %R$1%n',
+	'friends_changed_delay',	'Changed %R$0%n\'s delay value on {hilight $1} to %c$2%n',
+	'friends_chflagexec',		'Executing %c$0%n for %R$1%n ($2)',
+	'friends_currentflags',		'Current {channel $2} flags for %R$1%n are: %c$0%n',
+	'friends_chpassexec',		'Altered password for %R$0%n',
+	'friends_ctcprequest',		'%R$0%n asks for {hilight $1} on {hilight $2}',
+	'friends_ctcppass',		'Password for %R$0%n altered by $1',
+	'friends_ctcpident',		'CTCP IDENT for %R$0%n from {hilight $1} succeeded',
+	'friends_ctcpfail',		'Failed CTCP {hilight $0} from %R$1%n. $2',
+	'friends_optree_header',	'Opping tree:',
+	'friends_optree_line1',		'%R$0%n has opped these:',
+	'friends_optree_line2',		'{hilight $[!-4]0} times: $1',
+	'friends_general',		'$0',
+	'friends_notice',		'[%RN%n] $0'
+]);
+
+my @friends = ();
+my $all_regexp_hosts = {};
+my $all_hosts = {};
+my $all_handles = {};
+my @operationQueue = ();
+my $timerHandle = undef;
+my $friends_file_version;
+my $friends_file_written;
+
+my $friends_PLAIN_HOSTS = 0;
+my $friends_REGEXP_HOSTS = 1;
+
+# Idea of moving userhost to a regexp and
+# the subroutine userhost_to_regexp were adapted from people.pl,
+# an userlist script made by Marcin 'Qrczak' Kowalczyk.
+# You can get that script from http://qrnik.knm.org.pl/~qrczak/irssi/people.pl
+# or from http://scripts.irssi.org/
+
+# HostToRegexp
+my %htr = ();
+# fill the hash
+foreach my $i (0..255) {
+	my $ch = chr($i);
+	$htr{$ch} = "\Q$ch\E";
+}
+# wildcards to regexp
+$htr{'?'} = '.';
+$htr{'*'} = '.*';
+
+# str userhost_to_regexp($userhost)
+# translates userhost to a regexp
+# lowercases host-part
+sub userhost_to_regexp($) {
+	my ($mask) = @_;
+	$mask = lowercase_hostpart($mask);
+	$mask =~ s/(.)/$htr{$1}/g;
+	return $mask;
+}
+
+# str lowercase_hostpart($userhost)
+# returns userhost with host-part loweracased
+sub lowercase_hostpart($) {
+	my ($host) = @_;
+	$host =~ s/(.+)\@(.+)/sprintf("%s@%s", $1, lc($2));/eg;
+	return $host;
+}
+
+# void print_version($what)
+# print's version of script/userlist
+sub print_version($) {
+	my ($what) = @_;
+	$what = lc($what);
+
+	if ($what eq "filever") {
+		if ($friends_file_version) {
+			my ($verbal, $numeric) = $friends_file_version =~ /^(.+)\ \(([0-9]+)\)$/;
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_file_version', $verbal, $numeric);
+		} else {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_empty');
+		}
+	} elsif ($what eq "filewritten" && $friends_file_written) {
+		my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($friends_file_written);
+		my $written = sprintf("%4d%02d%02d %02d:%02d:%02d", ($year+1900), ($mon+1), $mday, $hour, $min, $sec);
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_file_written', $written);
+	} else {
+		my ($verbal, $numerical) = $friends_version =~ /^(.+)\ \(([0-9]+)\)$/;
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_version', $verbal, $numerical);
+	}
+}
+
+# void print_releasenote()
+# suprisingly, prints a release note ;^)
+sub print_releasenote {
+	foreach my $line (split(/\n/, $release_note)) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notice', $line);
+	}
+}
+
+# str friends_crypt($plain)
+# returns crypt()ed $plain, using random salt;
+# or "" if $plain is empty
+sub friends_crypt {
+	return if ($_[0] eq "");
+	return crypt("$_[0]", (join '', ('.', '/', 0..9, 'A'..'Z', 'a'..'z')[rand 64, rand 64]));
+}
+
+# bool friend_passwdok($idx, $pwd)
+# returns 1 if password is ok, 0 if isn't
+sub friends_passwdok {
+	my ($idx, $pwd) = @_;
+	return 1 if (crypt("$pwd", $friends[$idx]->{password}) eq $friends[$idx]->{password});
+	return 0;
+}
+
+# arr get_friends_channels($idx)
+# returns list of $friends[$idx] channels
+sub get_friends_channels {
+	return keys(%{$friends[$_[0]]->{channels}});
+}
+
+# arr get_friends_hosts($idx, $type)
+# returns list of $friends[$idx] regexp-hostmask if $type=$friends_REGEXP_HOSTS
+# returns list of plain-hostmasks if $type=$friends_PLAIN_HOSTS
+sub get_friends_hosts($$) {
+	if ($_[1] == $friends_REGEXP_HOSTS) {
+		return keys(%{$friends[$_[0]]->{regexp_hosts}});
+	} elsif ($_[1] == $friends_PLAIN_HOSTS) {
+		return keys(%{$friends[$_[0]]->{hosts}});
+	}
+	return undef;
+}
+
+# str get_friends_flags($idx[, $chan])
+# returns list of $chan flags for $idx
+# $chan can be also 'global' or undef
+# case insensitive about the $chan
+sub get_friends_flags {
+	my ($idx, $chan) = @_;
+	$chan = lc($chan);
+	if ($chan eq "" || $chan eq "global") {
+		return $friends[$idx]->{globflags};
+	} else {
+		foreach my $friendschan (get_friends_channels($idx)) {
+			if ($chan eq lc($friendschan)) {
+				return $friends[$idx]->{channels}->{$friendschan}->{flags};
+			}
+		}
+	}
+	return;
+}
+
+# str get_friends_delay($idx[, $chan])
+# returns $chan delay for $idx
+# returns "" if $chan is 'global' or undef
+# case insensitive about the $chan
+sub get_friends_delay {
+	my ($idx, $chan) = @_;
+	$chan = lc($chan);
+	if ($chan && $chan ne "global") {
+		foreach my $friendschan (get_friends_channels($idx)) {
+			if ($chan eq lc($friendschan)) {
+				return undef if ($friends[$idx]->{channels}->{$friendschan}->{delay} eq '');
+				return $friends[$idx]->{channels}->{$friendschan}->{delay};
+			}
+		}
+	}
+	return;
+}
+
+# struct friend new_friend($handle, $hoststr, $globflags, $chanflagstr, $password, $comment)
+# hoststr is: *!foo@host1 *!bar@host2 *!?baz@host3
+# chanstr is: #chan1,flags,delay #chan2,flags,delay
+sub new_friend {
+	my $friend = {};
+	my $idx = scalar(@friends);
+	$friend->{handle} = $_[0];
+	$all_handles->{lc($_[0])} = $idx;
+	$friend->{globflags} = $_[2];
+	$friend->{password} = $_[4];
+	$friend->{comment} = $_[5];
+	$friend->{friends} = [];
+
+	foreach my $host (split(/ +/, $_[1])) {
+		my $regexp_host = userhost_to_regexp($host);
+		my ($firstalpha) = $host =~ /\@(.)/;
+		$firstalpha = lc($firstalpha);
+
+		$friend->{hosts}->{$host} = $regexp_host;
+		$friend->{regexp_hosts}->{$regexp_host} = $host;
+		$all_regexp_hosts->{allhosts}->{$regexp_host} = lc($_[0]);
+		$all_regexp_hosts->{$firstalpha}->{$regexp_host} = lc($_[0]);
+		$all_hosts->{$host} = lc($_[0]);
+	}
+
+	foreach my $cfd (split(/ +/, $_[3])) {
+		# $cfd format: #foobar,oikl,15 (channelname,flags,delay)
+		my ($channel, $flags, $delay) = split(",", $cfd, 3);
+		$friend->{channels}->{$channel}->{exist} = 1;
+		$friend->{channels}->{$channel}->{flags} = $flags;
+		$friend->{channels}->{$channel}->{delay} = $delay;
+	}
+
+	return $friend;
+}
+
+# get_regexp_hosts_by_letter($letter)
+# returns those regexp masks whose host part begins with $letter, '?' or '*'
+sub get_regexp_hosts_by_letter($) {
+	my $l = lc(substr($_[0], 0, 1));
+	my @tmphosts = ();
+	push(@tmphosts, keys(%{$all_regexp_hosts->{$l}}));
+	push(@tmphosts, keys(%{$all_regexp_hosts->{'?'}}));
+	push(@tmphosts, keys(%{$all_regexp_hosts->{'*'}}));
+	return @tmphosts;
+}
+
+# bool is_allowed_flag($flag)
+# will be obsolete, soon.
+sub is_allowed_flag { return 1; }
+
+# bool is_ctcp_command($command)
+# check if $command is one of the implemented ctcp commands
+sub is_ctcp_command {
+	my ($command) = @_;
+	$command = uc($command);
+	foreach my $allowed (split(/[,\ \|]+/, uc(Irssi::settings_get_str('friends_ctcp_commands')))) {
+		return 1 if ($command eq $allowed);
+	}
+	return 0;
+}
+
+# int get_idx($nick, $userhost)
+# returns idx of the friend or -1 if not a friend
+# The New Approach (TM) :)
+sub get_idx($$) {
+	my ($nick, $userhost) = @_;
+	$userhost = lowercase_hostpart($nick.'!'.$userhost);
+	my ($letter) = $userhost =~ /\@(.)/;
+	my $idx = -1;
+
+	foreach my $regexp_host (get_regexp_hosts_by_letter($letter)) {
+		if ($userhost =~ /^$regexp_host$/) {
+			return get_idxbyhand($all_regexp_hosts->{allhosts}->{$regexp_host});
+		}
+	}
+
+	return -1;
+}
+
+# int get_idxbyhand($handle)
+# returns $idx of friend with $handle or -1 if no such handle
+# case insensitive
+sub get_idxbyhand($) {
+	my $handle = lc($_[0]);
+	if (exists $all_handles->{$handle}) {
+		return $all_handles->{$handle};
+	}
+	return -1;
+}
+
+# int get_handbyidx($idx)
+# returns $handle of friend with $idx or undef if no such $idx
+# case sensitive
+sub get_handbyidx($) {
+	my ($idx) = @_;
+	return undef unless ($idx > -1 && $idx < scalar(@friends));
+	return $friends[$idx]->{handle};
+}
+
+# bool friend_has_host($idx, $host)
+# checks wheter $host matches any of $friend[$idx]'s hostmasks
+# The New Approach (TM)
+sub friend_has_host($$) {
+	my ($idx, $host) = @_;
+	$host = lowercase_hostpart($host);
+	foreach my $regexp_host (keys (%{$friends[$idx]->{regexp_hosts}})) {
+		return 1 if ($host =~ /^$regexp_host$/);
+	}
+	return 0;
+}
+
+# void add_host($idx, $host)
+# adds $host wherever it's needed
+# $friends[$idx]->{handle} is A MUST for add_host() to work properly.
+sub add_host($$) {
+	my ($idx, $host) = @_;
+	my $regexp_host = userhost_to_regexp($host);
+	my ($firstalpha) = $host =~ /\@(.)/;
+	$firstalpha = lc($firstalpha);
+
+	$friends[$idx]->{hosts}->{$host} = $regexp_host;
+	$friends[$idx]->{regexp_hosts}->{$regexp_host} = $host;
+	$all_regexp_hosts->{allhosts}->{$regexp_host} = lc($friends[$idx]->{handle});
+	$all_regexp_hosts->{$firstalpha}->{$regexp_host} = lc($friends[$idx]->{handle});
+	$all_hosts->{$host} = lc($friends[$idx]->{handle});
+}
+
+# int del_host($idx, $host)
+# deletes $host from wherever it is
+# if given $host arg is '*', removes all hosts of this friend
+sub del_host($$) {
+	my ($idx, $host) = @_;
+	my $deleted = 0;
+
+	foreach my $regexp_host (keys (%{$friends[$idx]->{regexp_hosts}})) {
+		if ($host eq '*' || $host =~ /^$regexp_host$/) {
+			my $plain_host = $friends[$idx]->{regexp_hosts}->{$regexp_host};
+			my ($l) = $plain_host =~ /\@(.)/;
+
+			delete $friends[$idx]->{hosts}->{$plain_host};
+			delete $friends[$idx]->{regexp_hosts}->{$regexp_host};
+			delete $all_regexp_hosts->{allhosts}->{$regexp_host};
+			delete $all_regexp_hosts->{$l}->{$regexp_host};
+			delete $all_hosts->{$plain_host};
+			$deleted++;
+		}
+	}
+	return $deleted;
+}
+
+# bool friend_has_chanrec($idx, $chan)
+# checks wheter $friend[$idx] has a $chan record
+# case insensitive
+sub friend_has_chanrec {
+	my ($idx, $chan) = @_;
+	$chan = lc($chan);
+	foreach my $friendschan (get_friends_channels($idx)) {
+		return 1 if ($chan eq lc($friendschan));
+	}
+	return 0;
+}
+
+# bool add_chanrec($idx, $chan)
+# adds an empty $chan record to $friends[$idx]
+# case sensitive
+sub add_chanrec {
+	my ($idx, $chan) = @_;
+	return 0 unless ($idx > -1 && $idx < scalar(@friends));
+	$friends[$idx]->{channels}->{$chan}->{exist} = 1;
+	return 1;
+}
+
+# bool del_chanrec($idx, $chan)
+# deletes $chan record from $friends[$idx]
+# case *in*sensitive
+sub del_chanrec {
+	my ($idx, $chan) = @_;
+	my $deleted = 0;
+	foreach my $friendschan (get_friends_channels($idx)) {
+		if (lc($chan) eq lc($friendschan)) {
+			delete $friends[$idx]->{channels}->{$friendschan};
+			$deleted = 1;
+		}
+	}
+	return $deleted;
+}
+
+# arr del_friend($idxs)
+# removes friends
+# removes all hosts corresponding to this friend
+# returns array of removed friends
+sub del_friend($) {
+	my ($idxlist) = @_;
+	my @idxs = split(/ /, $idxlist);
+	return -1 unless (scalar(@idxs) > 0);
+	my @tmp = ();
+	my @result = ();
+	my @todelete = ();
+
+	foreach my $idx (@idxs) {
+		my $handle = get_handbyidx($idx);
+		if (!(!defined $handle || grep(/^\Q$handle\E$/i, @todelete))) {
+			push(@todelete, $handle);
+			del_host($idx, '*');
+		}
+	}
+	for (my $idx = 0; $idx < @friends; $idx++) {
+		if (grep(/^\Q$friends[$idx]->{handle}\E$/i, @todelete)) {
+			push(@result, $friends[$idx]);
+		} else {
+			push(@tmp, $friends[$idx]);
+		}
+	}
+	@friends = @tmp;
+	update_allhandles();
+	return @result;
+}
+
+# void update_all_handles()
+# updates $all_handles
+sub update_allhandles {
+	$all_handles = {};
+	for (my $idx = 0; $idx < @friends; $idx++) {
+		$all_handles->{lc($friends[$idx]->{handle})} = $idx
+	}
+}
+
+# bool is_unique_handle($handle)
+# checks if the $handle is unique for the whole friendlist
+# returns 1 if there's no such $handle
+# returns 0 if there is one.
+sub is_unique_handle($) {
+	return !exists $all_handles->{lc($_[0])};
+}
+
+# str choose_handle($proposed)
+# tries to choose a handle, closest to the $proposed one
+sub choose_handle {
+	my ($proposed) = @_;
+	my $counter = 0;
+	my $handle = $proposed;
+
+	# do this until we have an unique handle
+	while (!is_unique_handle($handle)) {
+		if (($handle !~ /([0-9]+)$/) && !$counter) {
+			# first, if handle doesn't end with a digit, append '2'
+			# (but only in first step)
+			$handle .= "2";
+		} elsif ($counter < 85) {
+			# later, increase the trailing number by one
+			# do that 84 times
+			my ($number) = $handle =~ /([0-9]+)$/;
+			++$number;
+			$handle =~ s/([0-9]+)$/$number/;
+		} elsif ($counter == 85) {
+			# then, if it didn't helped, make $handle = $proposed."_"
+			$handle = $proposed . "_";
+		} elsif ($counter < 90) {
+			# if still unsuccessful, append "_" to the handle
+			# do that 4 times
+			$handle .= "_";
+		} else {
+			# if THAT didn't help -- make some silly handle
+			# and exit the loop
+			$handle = $proposed.'_'.(join '', (0..9, 'a'..'z')[rand 36, rand 36, rand 36, rand 36]);
+			last;
+		}
+		++$counter;
+	}
+
+	# return our glorious handle ;-)
+	return $handle;
+}
+
+# bool friend_has_flag($idx, $flag[, $chan])
+# returns true if $friends[$idx] has $flag for $chan
+# (checks global flags, if $chan is 'global' or undef)
+# returns false if hasn't
+# case sensitive about the FLAG
+# case insensitive about the chan.
+sub friend_has_flag {
+	my ($idx, $flag, $chan) = @_;
+	$chan = "global" unless ($chan ne '');
+
+	return 1 if (get_friends_flags($idx, $chan) =~ /\Q$flag\E/);
+	return 0;
+}
+
+# bool friend_is_wrapper($idx, $chan, $goodflag, $badflag)
+# something to replace friend_is_* subs
+# true on: ($channel +$goodflag OR global +$goodflag) AND ($badflag == "" OR NOT $channel +$badflag))
+sub friend_is_wrapper($$$$) {
+	my ($idx, $chan, $goodflag, $badflag) = @_;
+	return 0 unless ($idx > -1);
+	if ((friend_has_flag($idx, $goodflag, $chan) ||
+		 friend_has_flag($idx, $goodflag, undef)) && 
+		($badflag eq "" || !friend_has_flag($idx, $badflag, $chan))) {
+		return 1;
+	}
+	return 0;
+}
+
+# bool add_flag($idx, $flag[, $chan])
+# adds $flag to $idx's $chan flags
+# $chan can be 'global' or undef
+# case insensitive about the $chan -- chooses the proper case.
+# returns 1 on success
+sub add_flag {
+	my ($idx, $flag, $chan) = @_;
+	$chan = lc($chan);
+	if ($chan eq "" || $chan eq "global") {
+		$friends[$idx]->{globflags} .= $flag;
+		return 1;
+	} else {
+		foreach my $friendschan (get_friends_channels($idx)) {
+			if ($chan eq lc($friendschan)) {
+				$friends[$idx]->{channels}->{$friendschan}->{flags} .= $flag;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+# bool del_flag($idx, $flag[, $chan])
+# removes $flag from $idx's $chan flags
+# $chan can be 'global' or undef
+# case insensitive about the $chan -- chooses the proper case.
+sub del_flag {
+	my ($idx, $flag, $chan) = @_;
+	$chan = lc($chan);
+	if ($chan eq "" || $chan eq "global") {
+		$friends[$idx]->{globflags} =~ s/\Q$flag\E//g;
+		return 1;
+	} else {
+		foreach my $friendschan (get_friends_channels($idx)) {
+			if ($chan eq lc($friendschan)) {
+				$friends[$idx]->{channels}->{$friendschan}->{flags} =~ s/\Q$flag\E//i;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+# bool change_delay($idx, $delay, $chan)
+# alters $idx's delay time for $chan
+# fails if $chan is 'global' or undef
+sub change_delay {
+	my ($idx, $delay, $chan) = @_;
+	$chan = lc($chan);
+	if ($chan && $chan ne "global") {
+		foreach my $friendschan (get_friends_channels($idx)) {
+			if ($chan eq lc($friendschan)) {
+				$friends[$idx]->{channels}->{$friendschan}->{delay} = $delay;
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
+# void list_friend($window, $who, @data)
+# prints an info line about certain friend.
+# $who may be handle or idx
+# if you want to improve the look of the script, you should
+# change /format friends_*, probably.
+sub list_friend {
+	my ($win, $who, @data) = @_;
+	my $idx = $who;
+
+	$idx = get_idxbyhand($who) unless ($who =~ /^[0-9]+$/);
+
+	return unless ($idx > -1 && $idx < scalar(@friends));
+
+	my $globflags = get_friends_flags($idx, undef);
+
+	$win = Irssi::active_win() unless ($win);
+
+	$win->printformat(MSGLEVEL_CRAP, 'friends_line_head',
+		$idx,
+		get_handbyidx($idx),
+		(($globflags) ? "$globflags" : "[none]"),
+		(($friends[$idx]->{password}) ? "yes" : "no"));
+
+	$win->printformat(MSGLEVEL_CRAP, 'friends_line_hosts',
+		join(", ", get_friends_hosts($idx, $friends_PLAIN_HOSTS)) );
+
+	foreach my $chan (get_friends_channels($idx)) {
+		my $flags = get_friends_flags($idx, $chan);
+		my $delay = get_friends_delay($idx, $chan);
+		$win->printformat(MSGLEVEL_CRAP, 'friends_line_chan', 
+			$chan,
+			(($flags) ? "$flags" : "[none]"),
+			(defined($delay) ? "$delay" : "random"));
+	}
+
+	if ($friends[$idx]->{comment}) {
+		$win->printformat(MSGLEVEL_CRAP, 'friends_line_comment', $friends[$idx]->{comment});
+	}
+
+	for my $item (@data) {
+		my ($ircnet, $nick, $chanstr) = split(" ", $item);
+		next unless (defined $ircnet);
+		$win->printformat(MSGLEVEL_CRAP, 'friends_line_currentnick', $nick, $ircnet) if ($nick ne '');;
+		$win->printformat(MSGLEVEL_CRAP, 'friends_line_channelson', join(", ", split(/,/, $chanstr)), $ircnet) if ($chanstr ne '');
+	}
+}
+
+# void add_operation($server, "#channel", "op|voice|deop|devoice|kick|kickban", timeout, "nick1", "nick2", ...)
+# adds a delayed (or not) operation
+sub add_operation {
+	my ($server, $channel, $operation, $timeout, @nicks) = @_;
+
+	# my dear queue, don't grow too big, mmkay? ;^)
+	my $maxsize = Irssi::settings_get_int('friends_max_queue_size');
+	$maxsize = $default_friends_max_queue_size unless ($maxsize > 0);
+	return if (@operationQueue >= $maxsize);
+
+	push(@operationQueue,
+	{
+		server=>$server,		# server object
+		left=>$timeout,			# seconds left
+		nicks=>[ @nicks ],		# array of nicks
+		channel=>$channel,		# channel name
+		operation=>$operation	# operation ("op", "voice" and so on)
+	});
+
+	$timerHandle = Irssi::timeout_add(1000, 'timer_handler', 0) unless (defined $timerHandle);
+}
+
+# void timer_handler()
+# handles delay timer
+sub timer_handler {
+	my @ops = ();
+
+	# splice out expired timeouts. if they are expired, move them to
+	# local ops-queue. this allows creating new operations to the queue
+	# in the operation. (we're not (yet) doing that)
+
+	for (my $c = 0; $c < @operationQueue;) {
+		if ($operationQueue[$c]->{left} <= 0) {
+			push(@ops, splice(@operationQueue, $c, 1));
+		} else {
+			++$c;
+		}
+	}
+
+	for (my $c = 0; $c < @ops; ++$c) {
+		my $op = $ops[$c];
+		my $channel = $op->{server}->channel_find($op->{channel});
+
+		# check if $channel is still active (you might've parted)
+		if ($channel) {
+			my @operationNicks = ();
+			foreach my $nickStr (@{$op->{nicks}}) {
+				my $nick = $channel->nick_find($nickStr);
+				# check if there's still such nick (it might've quit/parted)
+				if ($nick) {
+					if ($op->{operation} eq "op" && !$nick->{op}) {
+						push(@operationNicks, $nick->{nick});
+					}
+					if ($op->{operation} eq "voice" && !$nick->{voice} &&
+						(!$nick->{op} || Irssi::settings_get_bool('friends_voice_opped'))) {
+						push(@operationNicks, $nick->{nick});
+					}
+					if ($op->{operation} eq "deop" && $nick->{op}) {
+						push(@operationNicks, $nick->{nick});
+					}
+					if ($op->{operation} eq "devoice" && $nick->{voice}) {
+						push(@operationNicks, $nick->{nick});
+					}
+					if ($op->{operation} eq "kick") {
+						push(@operationNicks, $nick->{nick});
+					}
+					if ($op->{operation} eq "kickban") {
+						push(@operationNicks, $nick->{nick});
+					}
+				}
+			}
+			# final stage: issue desired command if we're a chanop
+			$channel->command($op->{operation}." ".join(" ", @operationNicks)) if ($channel->{chanop});
+		}
+	}
+
+	# decrement timeouts.
+	for (my $c = 0; $c < @operationQueue; ++$c) {
+		--$operationQueue[$c]->{left};
+	}
+
+	# if operation queue is empty, remove timer.
+	if (!@operationQueue && $timerHandle) {
+		Irssi::timeout_remove($timerHandle);
+		$timerHandle = undef;
+	}
+}
+
+# str replace_home($string)
+# replaces '~' with current $ENV{HOME}
+sub replace_home($) {
+	my ($string) = @_;
+	my $home = $ENV{HOME};
+	return undef unless ($string);
+	$string =~ s/^\~/$home/;
+	return $string;
+}
+
+# void load_friends($inputfile)
+# loads friends from file. uses $inputfile if supplied.
+# if not, uses friends_file setting. if this setting is empty,
+# uses default -- $friends_file
+sub load_friends {
+	my ($inputfile) = @_;
+	my $friendfile = undef;
+
+	if (defined($inputfile)) {
+		$friendfile = replace_home($inputfile);
+	} else {
+		$friendfile = replace_home(Irssi::settings_get_str('friends_file'));
+	}
+
+	$friendfile = $default_friends_file unless (defined $friendfile);
+
+	if (-e $friendfile && -r $friendfile) {
+		@friends = ();
+		$all_hosts = {};
+		$all_regexp_hosts = {};
+		$all_handles = {};
+
+		local *F;
+		open(F, "<", $friendfile) or return -1;
+		local $/ = "\n";
+		while (<F>) {
+			my ($handle, $hosts, $globflags, $chanstr, $password, $comment);
+			chop;
+
+			# dealing with empty lines
+			next if (/^[\w]*$/);
+
+			# dealing with comments
+			if (/^\#/) {
+				# script version
+				if (/^\# version = (.+)/) { $friends_file_version = $1; }
+				# timestamp
+				if (/^\# written = ([0-9]+)/) { $friends_file_written = $1; }
+				next;
+			}
+
+			# split by '%'
+			my @fields = split("%", $_);
+			foreach my $field (@fields) {
+				if ($field =~ /^handle=(.*)$/) { $handle = $1; }
+				elsif ($field =~ /^hosts=(.*)$/) { $hosts = $1; }
+				elsif ($field =~ /^globflags=(.*)$/) { $globflags = $1; }
+				elsif ($field =~ /^chanflags=(.*)$/) { $chanstr = $1; }
+				elsif ($field =~ /^password=(.*)$/) { $password = $1; }
+				elsif ($field =~ /^comment=(.*)$/) { $comment = $1; }
+			}
+
+			# handle cannot start with a digit
+			# skip friend if it does
+			next if ($handle =~ /^[0-9]/);
+
+			# if all fields were processed, and $handle is unique,
+			# make a friend and add it to $friends
+			if (is_unique_handle($handle)) {
+				push(@friends, new_friend($handle, $hosts, $globflags, $chanstr, $password, $comment));
+			} else {
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_duplicate', $handle);
+			}
+		}
+
+		close(F);
+
+		# if everything's ok -- print a message
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_loaded', scalar(@friends), $friendfile);
+	} else {
+		# whoops, bail out, but do not clear the friendlist.
+		Irssi::print("Cannot load $friendfile");
+	}
+}
+
+# void cmd_loadfriends($data, $server, $channel)
+# handles /loadfriends [file]
+sub cmd_loadfriends {
+	my ($file) = split(/ +/, $_[0]);
+	load_friends($file);
+}
+
+# void save_friends($auto)
+# saving friends to file
+sub save_friends {
+	my ($auto, $inputfile) = @_;
+	local *F;
+	my $friendfile = undef;
+	my $backup_suffix = Irssi::settings_get_str('friends_backup_suffix');
+	$backup_suffix = "." . time if ($backup_suffix eq '');
+
+	if (defined $inputfile) {
+		$friendfile = replace_home($inputfile);
+	} else {
+		$friendfile = replace_home(Irssi::settings_get_str('friends_file'));
+	}
+	$friendfile = $default_friends_file unless (defined $friendfile);
+
+	my $backupfile = $friendfile . $backup_suffix;
+	my $tmpfile = $friendfile . ".tmp" . time;
+
+	# be sane
+	my $old_umask = umask(077);
+
+	if (!defined open(F, ">", $tmpfile)) {
+		Irssi::print("Couldn't open $tmpfile for writing");
+		return 0;
+	}
+
+	# write script's version and update corresponding variable
+	$friends_file_version = $friends_version;
+	print(F "# version = $friends_file_version\n");
+	# write current unixtime and update corresponding variable
+	$friends_file_written = time;
+	print(F "# written = $friends_file_written\n");
+
+	# go through all entries
+	for (my $idx = 0; $idx < @friends; ++$idx) {
+		# get friend's channels, corresponding flags and delay values
+		# then put them as c,f,d fields into @chanstr
+		my @chanstr = ();
+		foreach my $chan (get_friends_channels($idx)) {
+			$chan =~ s/\%//g;
+			push(@chanstr, $chan.",".(get_friends_flags($idx, $chan)).",".
+				(get_friends_delay($idx, $chan)));
+		}
+
+		# write the actual line
+		print(F join("%",
+			"handle=".get_handbyidx($idx),
+			"hosts=".(join(" ", get_friends_hosts($idx, $friends_PLAIN_HOSTS))),
+			"globflags=".(get_friends_flags($idx, undef)),
+			"chanflags=".(join(" ", @chanstr)),
+			"password=".$friends[$idx]->{password},
+			"comment=".$friends[$idx]->{comment},
+			"\n"));
+	}
+	# done.
+
+	close(F);
+
+	rename($friendfile, $backupfile) if (Irssi::settings_get_bool('friends_backup_friendlist'));
+	rename($tmpfile, $friendfile);
+
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_saved', scalar(@friends), $friendfile) unless ($auto);
+
+	# restore umask
+	umask($old_umask);
+}
+
+# void cmd_savefriends($data, $server, $channel)
+# handles /savefriends [filename]
+sub cmd_savefriends {
+	my ($file) = split(/ +/, $_[0]);
+	eval {
+		save_friends(0, $file);
+	};
+	Irssi::print("Saving friendlist failed: $?") if ($?);
+}
+
+# void event_setup_saved($config, $auto)
+# calls save_friends to save friendslist while saving irssi's setup
+# (if friends_autosave is turned on)
+sub event_setup_saved {
+	my ($config, $auto) = @_;
+	return unless (Irssi::settings_get_bool('friends_autosave'));
+	eval {
+		save_friends($auto);
+	};
+	Irssi::print("Saving friendlist failed: $?") if ($?);
+}
+
+# void event_setup_reread($config)
+# calls load_friends() while setup is re-readed
+# (if friends_autosave is turned on)
+sub event_setup_reread {
+	load_friends() if (Irssi::settings_get_bool('friends_autosave'));
+}
+
+# int calculate_delay($idx, $chan)
+# calculates delay
+sub calculate_delay {
+	my ($idx, $chan) = @_;
+	my $delay = get_friends_delay($idx, $chan);
+	my $min = Irssi::settings_get_int('friends_delay_min');
+	my $max = Irssi::settings_get_int('friends_delay_max');
+
+	# lazy man's sanity checks :-P
+	$min = $default_delay_min if $min < 0;
+	$max = $default_delay_max if $min > $max;
+	$max = $max + $min if $min > $max;
+
+	# make a random delay unless we've got a fixed delay time already
+	$delay = int(rand ($max - $min)) + $min unless ($delay =~ /^[0-9]+$/);
+
+	return $delay;
+}
+
+# void check_friends($server, $channelstr, $options, @nickstocheck)
+# checks the given nicklist, channelname and server against the friendlist
+sub check_friends {
+	my ($server, $channelName, $options, @nicks) = @_;
+	my $channel = $server->channel_find($channelName);
+	my $delay = 30;
+	my %opList = ();
+	my %voiceList = ();
+
+	# server and channel -- a must.
+	return unless ($server && $channelName);
+
+	# proper !channels support, hopefully
+	my $noPrefix = $channelName;
+	$noPrefix = '!' . substr($channelName, 6) if ($channelName =~ /^\!/);
+
+	# get settings
+	my $voice_opped = Irssi::settings_get_bool('friends_voice_opped');
+
+	# for each nick from the given list
+	foreach my $nick (@nicks) {
+		# check if $nick is a friend
+		if ((my $idx = get_idx($nick->{nick}, $nick->{host})) > -1) {
+
+			# notify about the join if "showjoins" is set
+			if ($options =~ /showjoins/) {
+				my $globflags = get_friends_flags($idx, undef);
+				my $chanflags = get_friends_flags($idx, $noPrefix);
+
+				my $win = $server->window_item_find($channelName);
+				$win = Irssi::active_win() unless ($win);
+				$win->printformat(MSGLEVEL_CRAP, 'friends_joined',
+					$nick->{nick},
+					get_handbyidx($idx),
+					($globflags) ? $globflags : "[none]",
+					$noPrefix,
+					($chanflags) ? $chanflags : "[none]");
+			}
+
+			# notice1: password doesn't matter in this loop
+			# notice2: channel flags take precedence over the global ones
+
+			# handle auto-(op|voice)
+			if (friend_is_wrapper($idx, $noPrefix, "a", undef)) {
+				# add $nick to opList{delay} if he is a valid op
+				# and isn't opped already
+				# 'valid op' means: (chanflag +o OR globflag +o) AND NOT chanflag +d
+				if (friend_is_wrapper($idx, $noPrefix, "o", "d") && !$nick->{op}) {
+					# calculate delay, add to $opList{$delay}
+					$delay = calculate_delay($idx, $noPrefix);
+					$opList{$delay}->{$nick->{nick}} = 1;
+				}
+				# add $nick to voiceList{delay} if he is a valid voice
+				# and isn't voiced already
+				if (friend_is_wrapper($idx, $noPrefix, "v", undef) && !$nick->{voice} &&
+					(!$nick->{op} || $voice_opped)) {
+					# calculate delay, add to $voiceList{$delay}
+					$delay = calculate_delay($idx, $noPrefix);
+					$voiceList{$delay}->{$nick->{nick}} = 1;
+				}
+			}
+		}
+	}
+
+	# opping
+	foreach my $delay (keys %opList) {
+		add_operation($server, $channelName, "op", $delay, keys %{$opList{$delay}});
+	}
+	# voicing
+	foreach my $delay (keys %voiceList) {
+		add_operation($server, $channelName, "voice", $delay, keys %{$voiceList{$delay}});
+	}
+
+	timer_handler();
+}
+
+# void event_kick($server, $data, $nick)
+# handles kicks (for revenging)
+sub event_kick {
+	my ($server, $data, $kicker) = @_;
+	my ($channel, $kicked, $reason) = $data =~ /^([^ ]+) ([^ ]+) :(.*)$/;
+	my $channelInfo = $server->channel_find($channel);
+	my $myNick = $server->{nick};
+	my $victimInfo = undef;
+	my $kickerInfo = undef;
+	my $victimIdx = -1;
+	my $kickerIdx = -1;
+	my $noPrefix = $channel;
+	$noPrefix = '!' . substr($channel, 6) if ($channel =~ /^\!/);
+
+	return unless ($channelInfo);
+
+	# don't bother checking our own kicks, or self-kicks
+	return if ($kicker eq $myNick || $kicker eq $kicked);
+
+	$victimInfo = $channelInfo->nick_find($kicked);
+	$kickerInfo = $channelInfo->nick_find($kicker);
+	# we'll need both
+	return unless ($victimInfo && $kickerInfo);
+
+	$victimIdx = get_idx($victimInfo->{nick}, $victimInfo->{host});
+	$kickerIdx = get_idx($kickerInfo->{nick}, $kickerInfo->{host});
+
+	# check if we know the victim, and it wasn't a master who deopped
+	if ($victimIdx > -1 && !friend_is_wrapper($kickerIdx, $noPrefix, "m", undef)) {
+		# RRRRREVENGE!
+		my $revengemode = Irssi::settings_get_int('friends_revenge_mode');
+		if (Irssi::settings_get_bool('friends_revenge') && ($revengemode > -1 && $revengemode < 4) &&
+		    friend_is_wrapper($victimIdx, $noPrefix, "p", undef)) {
+			# 0 Deop the user.
+			add_operation($server, $channel, "deop", 1, $kicker);
+			if ($revengemode > 0) {
+				# 1 Deop the user and give them the +D flag for the channel.
+				if ($kickerIdx < 0) {
+					push(@friends, new_friend(
+						choose_handle("bad1"),		# handle
+						"*!".$kickerInfo->{host}, 	# hostmask
+						undef,				# globflags
+						$noPrefix.",D,",		# channel,chanflags,chandelay
+						undef,				# password
+						"Kicked ".get_handbyidx($victimIdx)." off $noPrefix on $server->{tag}"));
+				} else {
+					friends_chflags($kickerIdx, "+D", $noPrefix);
+				}
+				if ($revengemode > 1 && $channelInfo->{chanop}) {
+					# 2 Deop the user, give them the +D flag for the channel, and kick them.
+					$channelInfo->command("KICK ". $channel . " ".$kicker. " Don't mess with my friends[.pl]");
+					if ($revengemode > 2) {
+						# 3 Deop the user, give them the +D flag for the channel, kick, and ban them.
+						$channelInfo->command("MODE ". $channel ." +b *!".$kickerInfo->{host});
+					}
+				}
+			}
+		}
+	}
+}
+
+# void event_modechange($server, $data, $nick)
+# handles modechanges and learning
+sub event_modechange {
+	my ($server, $data, $nick) = @_;
+	my ($channel, $modeStr, $nickStr) = $data =~ /^([^ ]+) ([^ ]+) (.*)$/;
+	my @modeargs = split(" ", $nickStr);
+	my $ptr = 0;
+	my $mode = undef;
+	my $gotOpped = 0;
+	my $learnFriends = Irssi::settings_get_bool('friends_learn');
+	my $opperInfo = undef;
+	my $opperIdx = -1;
+	my $learnFromOpper = 0;
+	my $channelInfo = $server->channel_find($channel);
+	my $myNick = $server->{nick};
+	# !channels support :)
+	my $noPrefix = $channel;
+	$noPrefix = '!' . substr($channel, 6) if ($channel =~ /^\!/);
+
+	# don't bother checking our own modes
+	return if ($nick eq $myNick);
+
+	# we need $channelInfo to do almost every other things;
+	return unless (defined $channelInfo);
+
+	$opperInfo = $channelInfo->nick_find($nick);
+	$opperIdx = get_idx($opperInfo->{nick}, $opperInfo->{host}) if ($opperInfo);
+
+	# learn if learning is enabled, 
+	# we know the opper, and we're allowed to learn from him
+	if ($learnFriends && $opperIdx > -1 &&
+	    (friend_is_wrapper($opperIdx, $noPrefix, "F", undef))) {
+		$learnFromOpper = 1;
+	}
+
+	# process the mode string
+	foreach my $char (split(//, $modeStr)) {
+
+		if ($char eq "+") { $mode = "+";
+		} elsif ($char eq "-") { $mode = "-";
+
+		# op/deop, it wasn't a self-op/deop
+		} elsif (lc($char) eq "o" && ($nick ne $modeargs[$ptr])) {
+			my $victim = $channelInfo->nick_find($modeargs[$ptr]);
+			my $victimIdx = -1;
+			$victimIdx = get_idx($victim->{nick}, $victim->{host}) if ($victim);
+
+			# someone +o foobar
+			if ($mode eq "+") {
+				# hooray, i got opped!
+				if ($modeargs[$ptr] eq $myNick) {
+					$gotOpped = 1;
+				# should learn?
+				} elsif ($learnFromOpper && $victim) {
+					# handle the learning stuff.
+					my $friend;
+
+					if ($victimIdx == -1) {
+						# we got someone not known before
+						# choose a handle for him and add him to our friendlist with +L $noPrefix
+						$friend = new_friend(
+							choose_handle($modeargs[$ptr]),		# handle
+							"*!".$victim->{host}, 			# hostmask
+							undef,					# globflags
+							$noPrefix.",L,",			# channel,chanflags,chandelay
+							undef,					# password
+							"Learnt (opped by $friends[$opperIdx]->{handle} on $noPrefix\@$server->{tag})"	# comment
+						);
+						push(@friends, $friend);
+					} else {
+						# we know him already
+						$friend = $friends[$victimIdx];
+					}
+
+					if ($victimIdx == -1 || get_friends_flags($victimIdx, $noPrefix) eq "L") {
+						# add him to the opper's friendlist
+						# ($opperIdx != -1, we've checked that with $learnFromOpper earlier)
+						push(@{$friends[$opperIdx]->{friends}}, $friend);
+					}
+
+				} elsif (friend_is_wrapper($victimIdx, $noPrefix, "D", undef) && !friend_is_wrapper($opperIdx, $noPrefix, "m", undef)) {
+					add_operation($server, $channel, "deop", 1, $modeargs[$ptr]);
+				}
+
+			# deop
+			} elsif ($mode eq "-") {
+				if ($victim) {
+					# check if we know the victim, and it wasn't a master who deopped
+					if ($victimIdx > -1 && !friend_is_wrapper($opperIdx, $noPrefix, "m", undef)) {
+						# RRRRREVENGE!
+						my $revengemode = Irssi::settings_get_int('friends_revenge_mode');
+						if (Irssi::settings_get_bool('friends_revenge') && ($revengemode > -1 && $revengemode < 4) &&
+						    friend_is_wrapper($victimIdx, $noPrefix, "p", undef)) {
+							# 0 Deop the user.
+							add_operation($server, $channel, "deop", 1, $nick);
+							if ($revengemode > 0 && $opperInfo) {
+								# 1 Deop the user and give them the +D flag for the channel.
+								if ($opperIdx < 0) {
+									push(@friends, new_friend(
+										choose_handle("bad1"),		# handle
+										"*!".$opperInfo->{host}, 	# hostmask
+										undef,				# globflags
+										$noPrefix.",D,",		# channel,chanflags,chandelay
+										undef,				# password
+										"Deopped ".get_handbyidx($victimIdx)." on $noPrefix\@$server->{tag}"));
+								} else {
+									friends_chflags($opperIdx, "+D", $noPrefix);
+								}
+
+								if ($revengemode > 1 && $channelInfo->{chanop}) {
+									# 2 Deop the user, give them the +D flag for the channel, and kick them.
+									$channelInfo->command("KICK ". $channel . " ".$opperInfo->{nick}. " Don't mess with my friends[.pl]");
+									if ($revengemode > 2) {
+										# 3 Deop the user, give them the +D flag for the channel, kick, and ban them.
+										$channelInfo->command("MODE ". $channel ." +b *!".$opperInfo->{host});
+									}
+								}
+							}
+						}
+						# if a +r'ed person was deopped, perform a reop
+						if (friend_is_wrapper($victimIdx, $noPrefix, "r", "d")) {
+							add_operation($server, $channel, "op", calculate_delay($victimIdx, $channel), $modeargs[$ptr])
+						}
+					}
+				}
+			}
+			# increase pointer, 'o' mode has argument, *always*
+			$ptr++;
+		} elsif ($char =~ /[beIqdhvk]/ || ($char eq "l" && $mode eq "+")) {
+			# increase pointer, these modes have arguments as well
+			$ptr++;
+		}
+	}
+
+	if ($gotOpped) {
+		# calling check_friends with !BLARHchannel, since removing BLARH is done there
+		check_friends($server, $channel, undef, $channelInfo->nicks());
+	}
+}
+
+# void event_massjoin($channel, $nicklist)
+# handles join event
+sub event_massjoin {
+	my ($channel, $nicksList) = @_;
+	my @nicks = @{$nicksList};
+	my $server = $channel->{'server'};
+	my $channelName = $channel->{name};
+	my $options;
+	$options = "showjoins|" if Irssi::settings_get_bool("friends_show_flags_on_join");
+
+	my $begin = time;
+
+	check_friends($server, $channelName, $options, @nicks);
+
+	if ((my $duration = time - $begin) >= 1) {
+		# if checking took more than 1 second -- print a message about it
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_checking', $channelName, $duration, $server->{address});
+	}
+}
+
+# void event_nicklist_changed($channel, $nick, $oldnick)
+# some kind of nick-tracking
+# alters operationQueue if someone from there has changed nick
+sub event_nicklist_changed {
+	my ($channel, $nick, $oldnick) = @_;
+
+	# nicknames are case insensitive
+	return if (lc($oldnick) eq lc($nick->{nick}));
+
+	# cycle through all operation queues
+	for (my $c = 0; $c < @operationQueue; ++$c) {
+		# temporary array
+		my @nickarr = ();
+		# is there any nick in this queue that needs altering?
+		my $found = 0;
+
+		# skip if tags don't match
+		next unless ($operationQueue[$c]->{server}->{tag} eq $channel->{server}->{tag});
+
+		# cycle through all nicks in single operation queue
+		foreach my $opnick (@{$operationQueue[$c]->{nicks}}) {
+			# if $oldnick was in the queue
+			if (lc($oldnick) eq lc($opnick)) {
+				# ... replace it with the new one
+				push(@nickarr, $nick->{nick});
+				$found = 1;
+			} else {
+				# ... else -- keep the old one
+				push(@nickarr, $opnick);
+			}
+		}
+
+		# replace $opQ[$c]->{nicks} with our new nicklist if any nick needed updating
+		$operationQueue[$c]->{nicks} = [ @nickarr ] if ($found);
+	}
+}
+
+# void event_server_disconnected($server, $anything)
+# removes all queues related to $server from @operationQueue
+sub event_server_disconnected {
+	my ($server, $anything) = @_;
+	my @removed = ();
+
+	# cycle through all operation queues
+	for (my $c = 0; $c < @operationQueue;) {
+		if ($operationQueue[$c]->{server}->{tag} eq $server->{tag}) {
+			push(@removed, splice(@operationQueue, $c, 1));
+		} else {
+			++$c;
+		}
+	}
+
+	# if operation queue is empty, remove the timer.
+	if (scalar(@removed) && !@operationQueue && $timerHandle) {
+		Irssi::timeout_remove($timerHandle);
+		$timerHandle = undef;
+	}
+}
+
+# void cmd_opfriends($data, $server, $channel)
+# handles /opfriends #channel
+sub cmd_opfriends {
+	my ($data, $server, $channel) = @_;
+	my ($chan) = split(/ +/, $data);
+	my $usage = "/OPFRIENDS [channel]";
+	my @chanstocheck = ();
+
+	if (!$server) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "No server item in current window");
+		return;
+	}
+
+	# no argument given
+	if ($chan eq "") {
+		if (!$channel) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "No usable channel item in current window");
+			return;
+		} elsif ($channel->{type} ne "CHANNEL") {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "Current window item is not a channel");
+			return;
+		} else {
+			push(@chanstocheck, $channel->{name});
+		}
+	# all channels on current server
+	} elsif ($chan eq "*") {
+		foreach my $c ($server->channels()) {
+			push(@chanstocheck, $c->{name});
+		}
+	# specified channel on current server
+	} else {
+		push(@chanstocheck, $chan);
+	}
+
+	foreach my $channelName (@chanstocheck) {
+		my $chanInfo = $server->channel_find($channelName);
+		if (!$chanInfo) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_notonchan', $channelName);
+			next;
+		}
+
+		# !channels support
+		my $noPrefix = $chanInfo->{name};
+		$noPrefix = '!' . substr($chanInfo->{name}, 6) if ($chanInfo->{name} =~ /^\!/);
+
+		my @opnicks = ();
+		foreach my $nick ($chanInfo->nicks()) {
+			# skip already opped nicks
+			next if ($nick->{op});
+			# check for friends
+			my $idx = get_idx($nick->{nick}, $nick->{host});
+			# skip not-friends
+			next unless ($idx > -1);
+			# add $nick's nick to oplist if enough flags for this channel
+			push(@opnicks, $nick->{nick}) if (friend_is_wrapper($idx, $noPrefix, "o", "d"));
+		}
+
+		# add stuff to the operation queue
+		add_operation($server, $noPrefix, "op", "0", @opnicks);
+	}
+
+	timer_handler();
+}
+
+# void cmd_queue($data, $server, $channel)
+# expands to queue show|purge|flush
+sub cmd_queue($$$) {
+	my ($data, $server, $channel) = @_;
+	Irssi::command_runsub("queue", $data, $server, $channel);
+}
+
+# bool queue_flush_expand(%what)
+# "... and few lines of The Magic Code. Now. Your poison is ready."
+sub queue_flush_expand {
+	my ($flush) = @_;
+	my $result = 0;
+
+	foreach my $s (keys(%{$flush})) {
+		# is this server active?
+		my $server = Irssi::server_find_tag($s);
+		next unless (defined $server);
+
+		foreach my $c (keys(%{$flush->{$s}})) {
+			# is this channel active?
+			my $channel = $server->channel_find($c);
+			next unless (defined $channel);
+
+			# for each pending operation
+			foreach my $o (sort keys(%{$flush->{$s}->{$c}})) {
+				my @nicklist = ();
+				foreach my $nickStr (sort keys(%{$flush->{$s}->{$c}->{$o}})) {
+					# is this nick still here?
+					if (my $nick = $channel->nick_find($nickStr)) {
+						push(@nicklist, $nick->{nick});
+					}
+				}
+
+				if (my $nickstr = join(" ", @nicklist)) {
+					$channel->command($o." ".$nickstr);
+					$result = 1;
+				}
+			}
+		}
+	}
+	return $result;
+}
+
+# void queue_show($data, $server, $channel)
+# handles /QUEUE SHOW
+# prints @operationQueue's contents
+sub cmd_queue_show {
+	if (!@operationQueue) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_empty');
+		return;
+	}
+
+	# cycle through all operation queues
+	for (my $c = 0; $c < @operationQueue; ++$c) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_line1', 
+			$c,
+			$operationQueue[$c]->{left},
+			$operationQueue[$c]->{operation}
+		);
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_line2', 
+			$operationQueue[$c]->{server}->{address},
+			$operationQueue[$c]->{channel},
+			join(", ", @{$operationQueue[$c]->{nicks}})
+		);
+	}
+}
+
+# void cmd_queue_flush($data, $server, $channel)
+# handles /QUEUE FLUSH <number|all>
+# flushes given/all queue(s)
+sub cmd_queue_flush {
+	my ($data) = split(/ +/, $_[0]);
+	my $usage = "/QUEUE FLUSH <number|all>";
+	my @flushqueue = ();
+	my $flushdata = {};
+	my @removed = ();
+
+	if (!@operationQueue) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_empty');
+		return;
+	}
+
+	if ($data eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	if ($data =~ /^all/i) {
+		@flushqueue = @operationQueue;
+		@operationQueue = ();
+		push(@removed, $data);
+	} elsif ($data =~ /^[0-9,]+$/) {
+		my $numstr = join(" ", split(/,/, $data));
+		for (my $num = 0; $num < @operationQueue;) {
+			if ($numstr =~ /\b$num\b/) {
+				push(@flushqueue, splice(@operationQueue, $num, 1));
+				push(@removed, $num);
+			} else {
+				$num++
+			}
+		}
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badargs', $usage);
+		return;
+	}
+
+	if (@flushqueue) {
+		# don't ask... ;^)
+		foreach my $q (@flushqueue) {
+			my $s = $q->{server}->{tag};
+			my $c = $q->{channel};
+			my $o = $q->{operation};
+			foreach my $n (@{$q->{nicks}}) {
+				$flushdata->{$s}->{$c}->{$o}->{$n} = 1 unless ($o eq "voice" && 
+					exists $flushdata->{$s}->{$c}->{op}->{$n} && 
+					!Irssi::settings_get_bool('friends_voice_opped'));
+			}
+		}
+		my $result = ((queue_flush_expand($flushdata)) ? "seems ok" : "looks like nothing done");
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_removed', "Flushed", join(", ", @removed), $result);
+	}
+
+	if (!@operationQueue && $timerHandle) {
+		Irssi::timeout_remove($timerHandle);
+		$timerHandle = undef;
+	}
+}
+
+# void cmd_queue_purge($data, $server, $channel)
+# handles /QUEUE PURGE <number|all>
+# removes given/all queue(s)
+sub cmd_queue_purge {
+	my ($data) = split(/ +/, $_[0]);
+	my $usage = "/QUEUE PURGE <number|all>";
+	my $result;
+	my @removed;
+
+	if (!@operationQueue) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_empty');
+		return;
+	}
+
+	if ($data eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	if ($data =~ /^all/i) {
+		@operationQueue = ();
+		$result = "OK";
+		push(@removed, $data);
+	} elsif ($data =~ /^[0-9,]+$/) {
+		my $numstr = join(" ", split(/,/, $data));
+		for (my $num = 0; $num < @operationQueue;) {
+			if ($numstr =~ /\b$num\b/) {
+				splice(@operationQueue, $num, 1);
+				push(@removed, $num);
+				$result = "OK";
+			} else {
+				$num++
+			}
+		}
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badargs', $usage);
+		return;
+	}
+
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_queue_removed', "Purged", join(", ", @removed), $result) if (defined $result);
+
+	if (!@operationQueue && $timerHandle) {
+		Irssi::timeout_remove($timerHandle);
+		$timerHandle = undef;
+	}
+}
+
+# void friends_chflags($idx, $string[, $chan])
+# parses the $string and calls add_flag() or del_flag()
+sub friends_chflags {
+	my ($idx, $string, $chan) = @_;
+	my $mode = undef;
+	my $char;
+
+	$chan = "global" if ($chan eq "" || lc($chan) eq "global");
+
+	foreach my $char (split(//, $string)) {
+		if ($char eq "+") { $mode = "+";
+		} elsif ($char eq "-") { $mode = "-";
+		} elsif ($mode) {
+			if ($mode eq "+") {
+				# ADDING flags
+				# add chan record, if needed
+				add_chanrec($idx, $chan) if ($chan ne "global" && !friend_has_chanrec($idx, $chan));
+				if (!friend_has_flag($idx, $char, $chan)) {
+					# add this flag if he doesn't have it yet
+					add_flag($idx, $char, $chan);
+				}
+			} elsif ($mode eq "-") {
+				# REMOVING flags
+				if ($chan eq "global" || friend_has_chanrec($idx, $chan)) {
+					del_flag($idx, $char, $chan);
+				}
+			}
+		}
+	}
+}
+
+# void cmd_chflags($data, $server, $channel)
+# handles /chflags <handle> <+-flags> [#channel]
+sub cmd_chflags {
+	my ($handle, $flags, @chans) = split(/ +/, $_[0]);
+	my $usage = "/CHFLAGS <handle> <+/-flags> [#channel1] [#channel2] ...";
+
+	# strip %'s
+	$handle =~ s/\%//g;
+
+	# not enough args
+	if ($handle eq "" || $flags eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# bad args
+	# if the 'flags' part doesn't start with + or -
+	if ($flags !~ /^[\+\-]/) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it isn't valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# if #channel wasn't specified -- we'll deal with global flags
+	push(@chans, "global") unless (@chans);
+
+	# go through all channels specified
+	foreach my $chan (@chans) {
+		# strip %'s
+		$chan =~ s/\%//g;
+
+		# 'executing +foo-bar for someone (where)'
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_chflagexec', $flags, get_handbyidx($idx), $chan);
+		# make changes
+		friends_chflags($idx, $flags, $chan);
+
+		my $flagstr = get_friends_flags($idx, $chan);
+		# 'current $chan flags for someone are: +blah/[none]'
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_currentflags', (($flagstr) ? $flagstr : "[none]"), get_handbyidx($idx), $chan);
+	}
+}
+
+# void cmd_chhandle($data, $server, $channel)
+# handles /chhandle <oldhandle> <newhandle>
+sub cmd_chhandle {
+	my ($oldhandle, $newhandle) = split(/ +/, $_[0]);
+	my $usage = "/CHHANDLE <oldhandle> <newhandle>";
+
+	# strip %'s
+	$newhandle =~ s/\%//g;
+
+	# not enough args
+	if ($oldhandle eq "" || $newhandle eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($oldhandle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $oldhandle);
+		return;
+	}
+
+	# proper case for later printformat
+	$oldhandle = get_handbyidx($idx);
+
+	# handle cannot start with a digit
+	if ($newhandle =~ /^[0-9]/) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badhandle', $newhandle, 
+			"Handle may not start with a digit");
+		return;
+	}
+
+	if (lc($newhandle) eq lc($oldhandle)) {
+		# funny case, only changes case of letters, omit the whole change_handle()
+		$friends[$idx]->{handle} = $newhandle;
+	} else {
+		# check if $newhandle is unique
+		# if not, print appropriate message and return
+		if (!is_unique_handle($newhandle)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_notuniqhandle', $newhandle);
+			return;
+		}
+		# ok, everything seems fine now, let's change the handle.
+		change_handle($oldhandle, $newhandle);
+	}
+
+	# ... and print a message
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_changed_handle', $oldhandle, $newhandle);
+}
+
+# void change_handle($oldhandle, $newhandle)
+# changes handle in appropriate structures
+sub change_handle($$) {
+	my ($old, $new) = @_;
+	my $idx = get_idxbyhand($old);
+	my $lc_new = lc($new);
+	foreach my $host (get_friends_hosts($idx, $friends_PLAIN_HOSTS)) {
+		my ($l) = $host =~ /\@(.)/;
+		my $regexp_host = userhost_to_regexp($host);
+		$all_regexp_hosts->{allhosts}->{$regexp_host} = $lc_new;
+		$all_regexp_hosts->{lc($l)}->{$regexp_host} = $lc_new;
+		$all_hosts->{$host} = $lc_new;
+		delete $all_handles->{lc($old)};
+		$all_handles->{$lc_new} = $idx;
+		$friends[$idx]->{handle} = $new;
+	}
+}
+
+# void cmd_chpass($data, $server, $channel)
+# handles /chpass <handle> [pass]
+# if pass is empty, removes password
+# otherwise, crypts it and sets as current one
+sub cmd_chpass {
+	my ($handle, $pass) = split(/ +/, $_[0]);
+	my $usage = "/CHPASS <handle> [newpassword]";
+
+	# not enough args
+	if ($handle eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# crypt and set password. then print a message
+	$friends[$idx]->{password} = friends_crypt("$pass");
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_chpassexec', get_handbyidx($idx));
+}
+
+# void cmd_chdelay($data, $server, $channel)
+# handles /chdelay <handle> <delay> <#channel>
+# use delay=0 to get instant opping
+# use delay>0 to get fixed opping delay
+# use delay='random' or delay='none' or delay = 'remove'
+#  to remove fixed delay (make it random)
+sub cmd_chdelay {
+	my ($handle, $delay, $chan) = split(/ +/, $_[0]);
+	my $usage = "/CHDELAY <handle> <delay> <#channel>";
+	my $value = undef;
+
+	# strip %'s
+	$chan =~ s/\%//g;
+
+	# not enough args
+	if ($handle eq "" || $delay eq "" || $chan eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# if $chan doesn't start with one of the [!&#+]
+	if ($chan !~ /^[\!\&\#\+]/) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badargs', $usage);
+		return;
+	}
+
+	# check validness of $delay
+	if ($delay =~ /^[0-9]+$/) {
+		# numeric value
+		$value = $delay;
+	} elsif ($delay =~ /^(remove|random|none)$/i) {
+		# 'remove', 'random' or 'none'
+		$value = undef;
+	} else {
+		# badargs, return
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# check if $idx has got $chan record.
+	# add one if needed
+	add_chanrec($idx, $chan) unless (friend_has_chanrec($idx, $chan));
+
+	# finally, set it, and print a message
+	change_delay($idx, $value, $chan);
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_changed_delay', get_handbyidx($idx),
+		$chan, (defined($value) ? $value : "[random]"));
+}
+
+# void cmd_comment($data, $server, $channel)
+# handles /comment <handle> [comment]
+# if comment is empty, removes it
+# otherwise, sets it as the current one
+sub cmd_comment {
+	my ($handle, $comment) = split(" ", $_[0], 2);
+	my $usage = "/COMMENT <handle> [comment]";
+
+	# not enough args
+	if ($handle eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# remove %'s and trailing spaces (just-in-case ;)
+	$comment =~ s/\%//g;
+	$comment =~ s/[\ ]+$//;
+
+	# finally, set it, and print a message
+	$friends[$idx]->{comment} = $comment;
+
+	if ($comment ne '') {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_comment_added', get_handbyidx($idx), $comment);
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_comment_removed', get_handbyidx($idx));
+	}
+}
+
+# void cmd_listfriend($data, $server, $chanel)
+# handles /listfriends [what]
+# 'what' can be either handle, channel name, 1,2,5,15-style, host mask or empty.
+sub cmd_listfriends {
+	if (@friends == 0) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_empty');
+	} else {
+		my ($data) = @_;
+		my $counter = 0;
+		# remove whitespaces
+		$data =~ s/[\t\ ]+//g;
+		my $win = Irssi::active_win();
+
+		if ($data =~ /^[\!\&\#\+]/) {
+			# deal with channel
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist', "channel " . $data);
+			for (my $idx = 0; $idx < @friends; ++$idx) {
+				if (friend_has_chanrec($idx, $data)) {
+					list_friend($win, $idx, undef);
+					$counter++;
+				}
+			}
+		} elsif ($data =~ /^[0-9,]+$/) {
+			# deal with 1,2,5,15 style
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist', $data);
+			foreach my $idx (split(/,/, $data)) {
+				if ($idx < @friends) {
+					list_friend($win, $idx, undef);
+					$counter++;
+				}
+			}
+		} elsif ($data =~ /^.*\!.*\@.*$/) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist', "matching " . $data);
+			# /* FIXME */
+			my $regexp_data = userhost_to_regexp($data);
+			for (my $idx = 0; $idx < @friends; ++$idx) {
+				foreach my $regexp_host (get_friends_hosts($idx, $friends_REGEXP_HOSTS)) {
+					if ($data =~ /^$regexp_host$/ || $friends[$idx]->{regexp_hosts}->{$regexp_host} =~ /^$regexp_data$/) {
+						list_friend($win, $idx, undef);
+						$counter++;
+						last;
+					}
+				}
+			}
+		} elsif ($data ne "") {
+			if ((my $idx = get_idxbyhand($data)) > -1) {
+				# deal with handle
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist', $data);
+				list_friend($win, $idx, undef);
+				$counter++;
+			} else {
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $data);
+			}
+		} else {
+			# deal with every entry
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist', "all");
+			for (my $idx = 0; $idx < @friends; ++$idx) {
+				list_friend($win, $idx, undef);
+				$counter++;
+			}
+		}
+		if ($counter) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_friendlist_count', $counter, (($counter > 1) ? "s" : ""));
+		}
+	}
+}
+
+# void cmd_addfriend($data, $server, $channel)
+# handles /addfriend <handle> <hostmask> [flags]
+# if 'flags' is empty, uses friends_default_flags instead
+sub cmd_addfriend {
+	my ($handle, $host, $flags) = split(/ +/, $_[0]);
+	my $server = $_[1];
+	my $usage = "/ADDFRIEND <handle|nick> [<hostmask> [flags]]";
+
+	# strip %'s
+	$handle =~ s/\%//g;
+	$host =~ s/\%//g;
+
+	# not enough args
+	if ($handle eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# handle cannot start with a digit
+	if ($handle =~ /^[0-9]/) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_badhandle', $handle, "Handle may not start with a digit");
+		return;
+	}
+
+	# assume we want /addfriend somenick
+	if ($host eq "") {
+		# no server item in current window
+		if (!$server) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "No server item in current window");
+			return;
+		}
+
+		# redirect userhost reply to event_isfriend_userhost()
+		# caution: This works only with Irssi 0.7.98.CVS (20011117) and newer
+		$server->redirect_event("userhost", 1, $handle, 0, undef, {
+					"event 302" => "redir userhost_addfriend"});
+		# send our query
+		$server->send_raw("USERHOST :$handle");
+		return;
+	}
+
+	# check must be unique
+	if (!is_unique_handle($handle)) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notuniqhandle', $handle);
+		return;
+	}
+
+	# add friend.
+	push(@friends, new_friend($handle, $host, undef, undef, undef, undef));
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_added', $handle);
+
+	# check 'flags' parameter, add default flags if empty.
+	$flags = Irssi::settings_get_str('friends_default_flags') unless ($flags);
+
+	# add flags and print them if needed
+	if ($flags) {
+		# check if $flags start with a '+'. if not, prepend one.
+		$flags = "+".$flags unless ($flags =~ /^\+/);
+
+		# our new friend should have $idx=(scalar(@friends)-1) now, so we'll use it.
+		my $idx = scalar(@friends) - 1;
+
+		friends_chflags($idx, $flags, "global");
+		$flags = get_friends_flags($idx, undef);
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_currentflags', $flags, $handle, "global") if ($flags);
+	}
+}
+
+# void event_addfriend_userhost($server, $reply, $servername)
+# handles redirected USERHOST replies
+# (part of /addfriend)
+sub event_addfriend_userhost {
+	my ($mynick, $reply) = split(/ +/, $_[1]);
+	my $server = $_[0];
+	my ($nick, $user, $host) = $reply =~ /^:?([^\*=]*)\*?=.(.*)@(.*)/;
+	my $string = $nick . '!' . $user . '@' . $host;
+	my $friend_matched = 0;
+
+	# try matching ONLY if the response is positive
+	if (defined $nick && defined $user && defined $host) {
+		if ((my $idx = get_idx($nick, $user.'@'.$host)) > -1) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_already_added', $nick, get_handbyidx($idx));
+			return;
+		}
+		# handle
+		my $handle = choose_handle($nick);
+		# *~^=-ident
+		$user =~ s/^[\~\+\-\^\=]+/\*/;
+
+		# add friend.
+		push(@friends, new_friend($handle, '*!'.$user.'@'.$host, undef, undef, undef, undef));
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_added', $handle);
+		return;
+	}
+
+	# failed
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "No such nick");
+}
+
+# void cmd_delfriend($data, $server, $channel)
+# handles /delfriend <handle|number>
+# supports /delfriend 2-5,foohand,1,4,10,11-22
+sub cmd_delfriend {
+	my ($who) = split(/ +/, $_[0]);
+	my $usage = "/DELFRIEND <handle|number>";
+
+	# strip %'s
+	$who =~ s/\%//g;
+
+	# not enough args
+	if ($who eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	my @todelete = ();
+	foreach my $what (split(/[\ ,]/, $who)) {
+		if ($what =~ /^[0-9]+$/) {
+			# /delfriend 15
+			next unless ($what > -1 && $what < scalar(@friends));
+			push(@todelete, $what) unless (grep(/^$what$/, @todelete));
+		} elsif ($what =~ /^([0-9]+)\-([0-9]+)$/) {
+			# /delfriend 2-10
+			my ($start, $end) = $what =~ /([0-9]+)\-([0-9]+)/;
+			next if ($start > $end);
+			for my $i ($start .. $end) {
+				next unless ($i > -1 && $i < scalar(@friends));
+				push(@todelete, $i) unless (grep(/^$i$/, @todelete));
+			}
+		} else {
+			# /delfriend foobar
+			my $delidx = get_idxbyhand($what);
+			push(@todelete, $delidx) unless ($delidx < 0 || grep(/^$delidx$/, @todelete));
+		}
+	}
+	@todelete = sort {$a <=> $b} @todelete;
+
+	return unless (@todelete);
+
+	my @result = del_friend(join(" ", @todelete));
+	foreach my $deleted (@result) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_removed', $deleted->{handle});
+	}
+}
+
+# void cmd_addhost($data, $server, $channel)
+# handles /addhost <handle> <hostmask1> [hostmask2] ...
+# hostmask may not overlap with any of the current ones
+sub cmd_addhost {
+	my ($handle, @hosts) = split(/ +/, $_[0]);
+	my $usage = "/ADDHOST <handle> <hostmask1> [hostmask2] [hostmask3] ...";
+
+	# not enough args
+	if ($handle eq "" || !@hosts) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	for (my $i = 0; $i < scalar(@hosts); $i++) {
+		my $data = $hosts[$i];
+		$data =~ s/\%//g;
+		my $regexp_data = userhost_to_regexp($data);
+		my $found = 0;
+		my $who = "";
+
+		# /* FIXME */
+		foreach my $plain_host (keys %{$all_hosts}) {
+			if (!$found && $plain_host =~ /^$regexp_data$/) {
+				$found = 1;
+				$who = get_handbyidx(get_idxbyhand($all_hosts->{$plain_host}));
+				last;
+			}
+		}
+
+		# /* FIXME again */
+		foreach my $regexp_host (get_friends_hosts($idx, $friends_REGEXP_HOSTS)) {
+			last if ($found);
+			if ($data =~ /^$regexp_host$/ || $friends[$idx]->{regexp_hosts}->{$regexp_host} =~ /^$regexp_data$/) {
+				$found = 1;
+				$who = get_handbyidx($idx);
+				last;
+			}
+		}
+
+		if (!$found) {
+			add_host($idx, $data);
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_host_added', get_handbyidx($idx), $data);
+		} else {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_host_exists', $who, $data);
+		}
+	}
+}
+
+# void cmd_delhost($data, $server, $channel)
+# handles /delhost <handle> <hostmask>
+# hostmask should be EXACTLY the same as one in $friends[$idx]->{hosts}
+sub cmd_delhost {
+	my ($handle, $host) = split(/ +/, $_[0]);
+	my $usage = "/DELHOST <handle> <hostmask>";
+
+	# strip %'s
+	$host =~ s/\%//g;
+
+	# not enough args
+	if ($handle eq "" || $host eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# delete host, print appropriate message
+	if (del_host($idx, $host)) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_host_removed', get_handbyidx($idx), $host);
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_host_notexists', get_handbyidx($idx), $host);
+	}
+}
+
+# void cmd_delchanrec($data, $server, $channel)
+# handles /delchanrec <handle> <#channel>
+sub cmd_delchanrec {
+	my ($handle, $chan) = split(/ +/, $_[0]);
+	my $usage = "/DELCHANREC <handle> <#channel>";
+
+	# strip %'s
+	$chan =~ s/\%//g;
+
+	# not enough args
+	if ($handle eq "" || $chan eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# get idx, yell and return if it's not valid
+	my $idx = get_idxbyhand($handle);
+	if ($idx == -1) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $handle);
+		return;
+	}
+
+	# delete chanrec, print appropriate message
+	if (del_chanrec($idx, $chan)) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_chanrec_removed', get_handbyidx($idx), $chan);
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_chanrec_notexists', get_handbyidx($idx), $chan);
+	}
+}
+
+# void cmd_findfriends($data, $server, $channel)
+# handles /findfriends [handle]
+# prints online friends
+sub cmd_findfriends {
+	my ($data) = split(/ +/, $_[0]);
+	my $f2w = Irssi::settings_get_str('friends_findfriends_to_windows');
+	my $win = undef;
+	my $lc_data = lc($data);
+	$win = Irssi::active_win() unless ($f2w || $data eq '');
+
+	# gathering info
+	my $by_hand = {};
+	foreach my $channel (Irssi::channels()) {
+		my $myNick = $channel->{server}->{nick};
+		my $tag = lc($channel->{server}->{tag});
+		foreach my $nick ($channel->nicks()) {
+			# don't count myself
+			next if ($nick->{nick} eq $myNick);
+			if ((my $idx = get_idx($nick->{nick}, $nick->{host})) > -1) {
+				$by_hand->{lc($friends[$idx]->{handle})}->{$tag}->{$channel->{name}} = $nick->{nick};
+			}
+		}
+	}
+
+	# looking for a specified handle
+	if ($data ne '') {
+		my $handle = undef;
+		foreach my $h (keys %{$by_hand}) {
+			next if ($lc_data ne $h);
+			$handle = $h;
+			last;
+		}
+		return unless (defined $handle);
+
+		# tricky part.
+		my @data = ();
+		foreach my $ircnet (keys %{$by_hand->{$handle}}) {
+			my ($nick, $chan);
+			foreach $chan (keys %{$by_hand->{$handle}->{$ircnet}}) {
+				$nick = $by_hand->{$handle}->{$ircnet}->{$chan};
+				last;
+			}
+			my $chanstr = join(",", sort keys %{$by_hand->{$handle}->{$ircnet}});
+			push(@data, join(" ", $ircnet, $nick, $chanstr));
+		}
+		# list them.
+		list_friend(Irssi::active_win(), $handle, @data);
+
+	# looking for anyone
+	} else {
+		foreach my $handle (keys %{$by_hand}) {
+			foreach my $ircnet (keys %{$by_hand->{$handle}}) {
+				my $server = Irssi::server_find_tag($ircnet);
+				next unless (defined $server);
+				foreach my $chan (sort keys %{$by_hand->{$handle}->{$ircnet}}) {
+					my @data = ();
+					my $nick = $by_hand->{$handle}->{$ircnet}->{$chan};
+					$win = $server->window_item_find($chan);
+					$win = Irssi::active_win() unless (defined $win && $f2w);
+					my $chanstr = join(",", sort keys %{$by_hand->{$handle}->{$ircnet}});
+					push(@data, join(" ", $ircnet, $nick, $chanstr));
+					list_friend($win, $handle, @data);
+				}
+			}
+		}
+	}
+}
+
+# void cmd_isfriend($data, $server, $channel)
+# handles /isfriend <nick>
+sub cmd_isfriend {
+	my ($data, $server, $channel) = @_;
+	my $usage = "/ISFRIEND <nick>";
+
+	# remove trailing spaces
+	$data =~ s/[\t\ ]+$//;
+
+	# not enough args
+	if ($data eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_notenoughargs', $usage);
+		return;
+	}
+
+	# no server item in current window
+	if (!$server) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "No server item in current window");
+		return;
+	}
+
+	# redirect userhost reply to event_isfriend_userhost()
+	# caution: This works only with Irssi 0.7.98.CVS (20011117) and newer
+	$server->redirect_event("userhost", 1, $data, 0, undef, {
+				"event 302" => "redir userhost_friends"});
+	# send our query
+	$server->send_raw("USERHOST :$data");
+}
+
+# void event_isfriend_userhost($server, $reply, $servername)
+# handles redirected USERHOST replies
+# (part of /isfriend)
+sub event_isfriend_userhost {
+	my ($mynick, $reply) = split(/ +/, $_[1]);
+	my $server = $_[0];
+	my ($nick, $user, $host) = $reply =~ /^:?([^\*=]*)\*?=.(.*)@(.*)/;
+	my $string = $nick . '!' . $user . '@' . $host;
+	my $friend_matched = 0;
+
+	# try matching ONLY if the response is positive
+	if (defined $nick && defined $user && defined $host) {
+		if ((my $idx = get_idx($nick, $user.'@'.$host)) > -1) {
+			my @chans = ();
+			foreach my $channel ($server->channels()) {
+				push(@chans, $channel->{name}) if ($channel->nick_find($nick));
+			}
+			my $chanstr = join(",", @chans);
+			list_friend(Irssi::active_win(), $idx, join(" ", $server->{tag}, $nick, $chanstr));
+			$friend_matched++;
+		}
+	}
+
+	# print message
+	if ($friend_matched) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_endof', "/isfriend", $nick);
+	} else {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_nosuch', $nick);
+	}
+}
+
+# void event_whois($server, $text, $servername)
+# handles additional whois data
+sub event_whois {
+	my ($server, $text, $servername) = @_;
+	return unless (Irssi::settings_get_bool('friends_show_whois_extra'));
+
+	my ($on, $nick, $user, $host, $as, $rn) = split(/[\ ]:?/, $text, 6);
+	my $idx = get_idx($nick, $user.'@'.$host);
+	return unless ($idx > -1);
+
+	$server->printformat($nick, MSGLEVEL_CRAP, 'friends_whois', get_handbyidx($idx), ($friends[$idx]->{globflags} ? $friends[$idx]->{globflags} : "none"));
+}
+
+# void cmd_flushlearnt($data, $server, $channel)
+# cycles through all users and removes every chanrec with flag L
+# then, if no other stuff left (specific delay, other chanrecs,
+# global flags, password maybe) -- deletes user.
+# clears the opping tree too
+sub cmd_flushlearnt {
+	my @todelete = ();
+	# cycle through the whole friendlist
+	for (my $idx = 0; $idx < @friends; ++$idx) {
+		my $was_learnt = 0;
+
+		# foreach friend, clear his opping tree
+		$friends[$idx]->{friends} = [];
+
+		# now go through all friend's channel entries
+		foreach my $chan (get_friends_channels($idx)) {
+			# if 'L' is the only flag for this chan
+			if (get_friends_flags($idx, $chan) eq "L") {
+				# remove channel record and print a message
+				$was_learnt = del_chanrec($idx, $chan);
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_chanrec_removed', get_handbyidx($idx), $chan);
+			}
+		}
+
+		# delete friend, if he has exactly 1 host, no global flags,
+		# neither password, nor chanrecs, and he was learnt.
+		if ($was_learnt && scalar(get_friends_hosts($idx, $friends_REGEXP_HOSTS)) == 1  && !get_friends_flags($idx, undef) &&
+			!get_friends_channels($idx) && !$friends[$idx]->{password}) {
+			push(@todelete, $idx) unless (grep(/^$idx$/, @todelete));
+		}
+	}
+	return unless @todelete;
+
+	@todelete = sort {$a <=> $b} @todelete;
+	my @result = del_friend(join(" ", @todelete));
+	foreach my $deleted (@result) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_removed', $deleted->{handle});
+	}
+}
+
+# void cmd_opping_tree($data, $server, $channel)
+# prints the Opping Tree
+sub cmd_oppingtree {
+	my $found = 0;
+	# cycle through the whole friendlist
+	for (my $idx = 0; $idx < @friends; ++$idx) {
+		# get friend's friends
+		my @friendFriends = @{$friends[$idx]->{friends}};
+		if (@friendFriends) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "Opping tree:") unless ($found);
+			$found = 1;
+			# print info about our friend
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_optree_line1', get_handbyidx($idx));
+			my %masks;
+			# get all masks opped by him
+			foreach my $friend (@friendFriends) {
+				foreach my $host (keys(%{$friend->{hosts}})) {
+					$masks{$host}++;
+					last;
+				}
+			}
+			# print them, along with the opcount
+			foreach my $friend (sort keys %masks) {
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_optree_line2', $masks{$friend}, $friend);
+			}
+		}
+	}
+	Irssi::printformat(MSGLEVEL_CRAP, 'friends_general', "Opping tree is empty.") unless ($found);
+}
+
+# void event_ctcpmsg($server, $args, $sender, $senderhsot, $target)
+# handles ctcp requests
+sub event_ctcpmsg {
+	my ($server, $args, $sender, $userhost, $target) = @_;
+
+	# return, if ctcp is not for us
+	my $myNick = $server->{nick};
+	return if (lc($target) ne lc($myNick));
+
+	# return, if we don't process ctcp requests
+	return unless (Irssi::settings_get_bool('friends_use_ctcp'));
+
+	# return in case of strange things
+	return unless (defined $sender && defined $userhost);
+
+	my @cmdargs = split(/ +/, $args);
+
+	# prepare arguments:
+	# get 1st arg, uppercase it
+	my $command = uc($cmdargs[0]);
+	# get 2nd arg
+	my $channelName = $cmdargs[1];
+	# get 3rd arg
+	my $password = $cmdargs[2];
+
+	# check if $command is one of friends_ctcp_commands. return if it isn't
+	return unless (is_ctcp_command($command));
+
+	# this is supposed to be processed BEFORE any other ctcp commands
+	# /ctcp nick IDENT handle password
+	if ($command eq "IDENT") {
+		my $idxguess = get_idxbyhand($channelName);
+		# looks like a valid friend, password already set, provided password looks fine
+		if ($idxguess > -1 && $friends[$idxguess]->{password} ne "" && friends_passwdok($idxguess, $password)) {
+			# do the IDENT stuff here.
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpident', $channelName, $sender.'!'.$userhost);
+			add_host($idxguess, "*!$userhost");
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_host_added', $channelName, '*!'.$userhost);
+			$server->command("/^NOTICE $sender Identified as " . get_handbyidx($idxguess));
+		} else {
+			my $reason = "No reason ;)";
+			if ($idxguess < 0) {
+				$reason = "No such handle: $channelName";
+			} elsif ($friends[$idxguess]->{password} eq "") {
+				$reason = "Can't IDENT $channelName without password set";
+			} elsif (!friends_passwdok($idxguess, $password)) {
+				$reason = "Bad password for $channelName";
+			}
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $sender.'!'.$userhost, $reason);
+		}
+		goto SIGSTOP;
+	}
+
+	my $idx = get_idx($sender, $userhost);
+
+	# if get_idx* failed, return.
+	if ($idx == -1) {
+		my $reason = "Not a friend" . (($command ne "PASS") ? " for $channelName" : "");
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $sender.'!'.$userhost, $reason);
+		goto SIGSTOP;
+	}
+
+	# we'll use handle instead of $sender!$userhost in messages
+	my $handle = get_handbyidx($idx);
+
+	# check if $channelName was supplied.
+	# (first argument, should be always given)
+	if ($channelName eq "") {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough arguments");
+		goto SIGSTOP;
+	}
+
+	# /ctcp nick PASS pass [newpass]
+	if ($command eq "PASS") {
+		# if someone has password already set - we can only *change* it
+		if ($friends[$idx]->{password}) {
+			# if cmdargs[1] ($channelName, that is) is a valid password (current)
+			if (!friends_passwdok($idx, $channelName)) {
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+				goto SIGSTOP;
+			}
+			# and $cmdargs[2] ($password, that is) contains something ...
+			if (defined $password) {
+				# ... process allowed password change.
+				# in this case, old password is in $channelName
+				# and new password is in $password
+				$friends[$idx]->{password} = friends_crypt("$password");
+				Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcppass', $handle, $sender."!".$userhost);
+				# send a quiet notice to sender
+				$server->command("/^NOTICE $sender Password changed to: $password");
+			} else {
+				# in this case, notify sender about his current password quietly
+				$server->command("/^NOTICE $sender You already have a password set");
+			}
+		# if $idx doesn't have a password, we will *set* it
+		} else {
+			# in this case, new password is in $channelName
+			# and $password is unused
+			$friends[$idx]->{password} = friends_crypt("$channelName");
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcppass', $handle, $sender.'!'.$userhost);
+			# send a quiet notice to sender
+			$server->command("/^NOTICE $sender Password set to: $channelName");
+		}
+		goto SIGSTOP;
+	}
+
+	# get channel object. if not found -- yell, stop the signal, and return
+	my $channel = $server->channel_find($channelName);
+	if (!$channel) {
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not on channel $channelName");
+		goto SIGSTOP;
+	}
+
+	my $sender_rec = $channel->nick_find($sender);
+
+	# /ctcp nick OP #channel password
+	if ($command eq "OP") {
+		if (!friend_is_wrapper($idx, $channelName, "o", "d")) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		# process allowed opping
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		$channel->command("op $sender") if ($sender_rec && !$sender_rec->{op});
+		goto SIGSTOP;
+
+	# /ctcp nick VOICE #channel password
+	} elsif ($command eq "VOICE") {
+		if (!friend_is_wrapper($idx, $channelName, "v", undef)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		# process allowed voicing
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		$channel->command("voice $sender") if ($sender_rec && !$sender_rec->{voice});
+		goto SIGSTOP;
+
+	# /ctcp nick INVITE #channel password
+	} elsif ($command eq "INVITE") {
+		if (!friend_is_wrapper($idx, $channelName, "i", undef)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		if (!$channel->{chanop} && !$sender_rec) {
+			# friend is outside channel, but we're not opped
+			$server->command("/^NOTICE $sender I'm not opped on $channelName");
+		} elsif (!$sender_rec) {
+			# process allowed invite
+			$channel->command("invite $sender");
+		}
+		goto SIGSTOP;
+
+	# /ctcp nick KEY #channel password
+	} elsif ($command eq "KEY") {
+		if (!friend_is_wrapper($idx, $channelName, "k", undef)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		# process allowed key giving
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		if ($channel->{key} && !$sender_rec) {
+			# give a key if channel is +k'ed and $sender is not on $channelName
+			$server->command("/^NOTICE $sender Key for $channelName is: $channel->{key}");
+		}
+		goto SIGSTOP;
+
+	# /ctcp nick UNBAN #channel password
+	} elsif ($command eq "UNBAN") {
+		if (!friend_is_wrapper($idx, $channelName, "u", undef)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		if (!$channel->{chanop}) {
+			# notify him that we're not opped, unless he's here and he can see that ;^)
+			$server->command("/^NOTICE $sender I'm not opped on $channelName") if (!$sender_rec);
+		} else {
+			# process allowed unban
+			foreach my $ban ($channel->bans()) {
+				if ($server->mask_match_address($ban->{ban}, $sender, $userhost)) {
+					$server->command("MODE $channelName -b $ban->{ban}");
+				}
+			}
+		}
+		goto SIGSTOP;
+
+	# /ctcp nick LIMIT #channel password
+	} elsif ($command eq "LIMIT") {
+		if (!friend_is_wrapper($idx, $channelName, "l", undef)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Not enough flags");
+			goto SIGSTOP;
+		}
+		if (!friends_passwdok($idx, $password)) {
+			Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcpfail', $command, $handle, "Bad password");
+			goto SIGSTOP;
+		}
+
+		# process allowed limit raising
+		Irssi::printformat(MSGLEVEL_CRAP, 'friends_ctcprequest', $handle, $command, $channelName);
+		if (!$channel->{chanop}) {
+			# notify him that we're not opped, unless he's here and he can see that ;^)
+			$server->command("/^NOTICE $sender I'm not opped on $channelName") if (!$sender_rec);
+		} else {
+			my @nicks = $channel->nicks();
+			if ($channel->{limit} && $channel->{limit} <= scalar(@nicks)) {
+				# raise the limit if it's needed
+				$server->command("MODE $channelName +l " . (scalar(@nicks) + 1));
+			}
+		}
+		goto SIGSTOP;
+	}
+
+	# stop the signal if we processed the request
+SIGSTOP:
+	Irssi::signal_stop();
+}
+
+# void cmd_friendsversion($data, $server, $channel)
+# handles /friendsversion
+# prints script's and friendlist's version
+sub cmd_friendsversion() {
+	print_version("script");
+	print_version("filever");
+	print_version("filewritten");
+}
+
+# settings
+Irssi::settings_add_int('misc', 'friends_delay_min', $default_delay_min);
+Irssi::settings_add_int('misc', 'friends_delay_max', $default_delay_max);
+Irssi::settings_add_int('misc', 'friends_max_queue_size', $default_friends_max_queue_size);
+Irssi::settings_add_int('misc', 'friends_revenge_mode', $default_friends_revenge_mode);
+Irssi::settings_add_bool('misc', 'friends_revenge', $default_friends_revenge);
+Irssi::settings_add_bool('misc', 'friends_learn', $default_friends_learn);
+Irssi::settings_add_bool('misc', 'friends_voice_opped', $default_friends_voice_opped);
+Irssi::settings_add_bool('misc', 'friends_use_ctcp', $default_friends_use_ctcp);
+Irssi::settings_add_bool('misc', 'friends_autosave', $default_friends_autosave);
+Irssi::settings_add_bool('misc', 'friends_backup_friendlist', $default_friends_backup_friendlist);
+Irssi::settings_add_bool('misc', 'friends_show_flags_on_join', $default_friends_show_flags_on_join);
+Irssi::settings_add_bool('misc', 'friends_findfriends_to_windows', $default_friends_findfriends_to_windows);
+Irssi::settings_add_bool('misc', 'friends_show_whois_extra', $default_friends_show_whois_extra);
+Irssi::settings_add_str('misc', 'friends_ctcp_commands', $default_friends_ctcp_commands);
+Irssi::settings_add_str('misc', 'friends_default_flags', $default_friends_default_flags);
+Irssi::settings_add_str('misc', 'friends_file', $default_friends_file);
+Irssi::settings_add_str('misc', 'friends_backup_suffix', $default_friends_backup_suffix);
+
+# commands
+Irssi::command_bind('addfriend', 'cmd_addfriend');
+Irssi::command_bind('delfriend', 'cmd_delfriend');
+Irssi::command_bind('addhost', 'cmd_addhost');
+Irssi::command_bind('delhost', 'cmd_delhost');
+Irssi::command_bind('delchanrec', 'cmd_delchanrec');
+Irssi::command_bind('chhandle', 'cmd_chhandle');
+Irssi::command_bind('chdelay', 'cmd_chdelay');
+Irssi::command_bind('loadfriends', 'cmd_loadfriends');
+Irssi::command_bind('savefriends', 'cmd_savefriends');
+Irssi::command_bind('listfriends', 'cmd_listfriends');
+Irssi::command_bind('findfriends', 'cmd_findfriends');
+Irssi::command_bind('isfriend', 'cmd_isfriend');
+Irssi::command_bind('chflags', 'cmd_chflags');
+Irssi::command_bind('chpass', 'cmd_chpass');
+Irssi::command_bind('comment', 'cmd_comment');
+Irssi::command_bind('oppingtree', 'cmd_oppingtree');
+Irssi::command_bind('opfriends', 'cmd_opfriends');
+Irssi::command_bind('queue', 'cmd_queue');
+Irssi::command_bind('queue show', 'cmd_queue_show');
+Irssi::command_bind('queue flush', 'cmd_queue_flush');
+Irssi::command_bind('queue purge', 'cmd_queue_purge');
+Irssi::command_bind('flushlearnt', 'cmd_flushlearnt');
+Irssi::command_bind('friendsversion', 'cmd_friendsversion');
+
+# events
+Irssi::signal_add_last('massjoin', 'event_massjoin');
+Irssi::signal_add_last('event mode', 'event_modechange');
+Irssi::signal_add_last('event 311', 'event_whois');
+Irssi::signal_add('default ctcp msg', 'event_ctcpmsg');
+Irssi::signal_add('redir userhost_friends', 'event_isfriend_userhost');
+Irssi::signal_add('redir userhost_addfriend', 'event_addfriend_userhost');
+Irssi::signal_add('setup saved', 'event_setup_saved');
+Irssi::signal_add('setup reread', 'event_setup_reread');
+Irssi::signal_add('nicklist changed', 'event_nicklist_changed');
+Irssi::signal_add('server disconnected', 'event_server_disconnected');
+Irssi::signal_add('server connect failed', 'event_server_disconnected');
+Irssi::signal_add_first('event kick', 'event_kick');
+
+print_releasenote() if (defined($release_note));
+load_friends();