###############################################################################

#

# Shows WHOIS: info including realname and channel names on joins to

# channels.

#

# This script is based on the autorealname script, and shares a little

# code and many ideas with that script. I use the same globals as they do,

# but with totally different fields because their structure was not really

# easy to adapt to a situation where more info is used on one query.

#

# Rewrote all that code, except for parts of request_whois and some init code

#

# I would like to thank Timo 'cras' Sirainen and Bastian Blank for writing

# the autorealname script. It was a good example.

#

# The script contains very simple flood protection in the form that it will

# not allow for more then $max_queued_requests per server at one time to be

# running. It tries to be smart about netsplits, so this should be okay.

# We have a 5-second timeout to make sure we really don't flood, ans also to

# make sure that we don't wait indefinitely for answers that won't come.

#

# Themes:

# You can change the way the WHOIS messages look using the /format command,

# For example:

# /FORMAT ji_whois_success %GWHOIS:%n {channick_hilight $0} \

# is "{hilight $1}"%n on {channel $2}

#

# Will add a green WHOIS: to the line to make it stand out, save your

# formatting in irssi using '/SAVE -formats'

#

# Add 'server: "{hilight $3}"' to the format string to also print the

# server name (Thanks to Svein Skogen for suggesting this)

#

# Add 'flags: "{hilight $4}"' to the format string to also print

# some additional flags for the user. These flags are tailored for

# some unknown irc network but also work quite well on IRCNet and EFNet

# after the 'idle' modifications I added to them. Thanks to

# Francesco Rolando for providing me with the initial patch.

#

# Commands (/JOININFO ...)

# INFO - Show info on and contents of the current cache of this script

# GC - Manually run the garbage collector once

# FORCE - Fake join of a nick to a chan (/JOININFO FORCE ichiban) use with

# care. Useful for testing theme changes, timeouts and the garbage

# collector on a quiet day or network. Will ignore your own nick.

# HELP - Shows help

#

# Settings

# /SET whois_expire_time # time to expire one saves record

# # until this age has been reched no

# # new WHOISs will be put on the server

#

# /SET whois_max_requests # max concurrent requests per server

# # flood protection, keep low

#

# /SET whois_timeout_ms # timeout after which a whois is lost (ms)

# # (default: 5000)

#

# /SET whois_gc_interval_ms # run gc ever x MS (default: 300000)

# # Requires script reload when changed.

#

# /SET whois_debug # 0 = show no debug info, 1 = debug info

#

# /SET whois_printing_level # Level at which all non-debug output is

# # printed, influences logging and IGNORE

# # (default: JOINS)

#

# ChangeLog:

# - Tue Jul 15 2003, pbijdens

# Initial release version 0.5.1

# - Thu Jul 17 2003, pbijdens

# Version 0.5.2

# Added garbage collection for the stored info.

# Added /AWINFO and /AWGC commands to show info and to run the garbage

# collector manually respectively

# Added timeout for the putserv WHOIS making sure we do not record too many

# jobs as BUSY.

# - Thu Jul 17 2003, pbijdens

# Version 0.5.3

# Added settings (whois_...) to the irssi config so there is no need to

# modify the script when changing them

# - Thu Jul 17 2003, pbijdens

# Version 0.5.5

# Making sure the settings are reloaded when they are changed. Added a

# signal handler for that

# - Thu Jul 17 2003, pbijdens

# Version 0.6.0

# Added setting for whois_debug

# Added theme support

# Bugfix for servers sending 401 without 318 no need to wait for

# timeout anymore on those

# Added configurable printing level for the realname+channel messages.

# use /SET whois_printing_level

# Added /AWFORCE command (see above)

# - Mon Jul 28 2003, pbijdens

# Version 0.6.1

# Various updates and bug fixes

# Changed awforce command to strip spaces

# - Wed Aug 13 2003, pbijdens

# Version 0.7.0

# Fixed typo in comment line

# Changed /AW* commands to be /JOININFO <subcommand> and added a

# /JOININFO HELP command. Renamed some subs to make their purpose

# more clear.

# - Wed Feb 2 2004, pbijdens

# Added features for filtering channels from the list, and adding

# support for hilighting channels in colors.

# - Mon Mar 8 2004, pbijdens

# Fixed bug where also on SILCNET the WHOIS queries would be run, now

# this service is restricted to IRC networks. Thanks to Tony den Haan

# for supplying this patch.

# - Mon Mar 8 2004, pbijdens

# Added support for printing the servername also in the output for those

# who want to see it. Thanks to Svein Skogen for suggesting this and

# sending me a patch.

# NOTE: Requires you to add {hilight $3} to your format string manually.

# By default the information is not diplayed.

# - Mon Mar 8 2004, pbijdens

# Added support for additional flags to the WHOIS output. This is stuff

# like IrcOP, Away, Idle and more. Thanks to Francesco Rolando for

# providing the additional patch, which I modified.

# NOTE: Requires you to add {hilight $4} to your format string manually.

# By default the information is not diplayed.

# - Tue Mar 1 2005, pbijdens

# Updated the script for compliance with a wider range of servers,

# and removed some functionality that generally did not work, or break

# on some servers. Been runing on 4 networks now with these patches for

# many months, declaring stable and releasing 1.0.

#

################################################################################

use Irssi 20011207;

use strict;

use vars qw($VERSION %IRSSI);

use integer;

################################################################################

$VERSION = "1.0.0";

%IRSSI = (

authors => "Pieter-Bas IJdens",

contact => "irssi-scripts\@nospam.mi4.org.uk",

name => "joininfo",

description => "Reports WHOIS information and channel list for those who join a channel",

license => "GPLv2 or later",

url => "http://pieter-bas.ijdens.com/irssi/",

changed => "2005-03-10"

);

################################################################################

# Note that all settings below can and should be changed with /SET, see

# /joininfo help or /set whois

# The maximum acceeptable age for a cached whois record is 60 seconds

# after this amount of time the cache record is discareded

my $whois_maxage = 60;

# The maximum number of requests queued at a time, if the queue reaches

# a lrger size, ignore new requets until we have space left. This could

# happen in a netjoin preceded by a very long netsplit

my $max_queued_requests = 7;

# Timeout after which a whois request is assumed not having been answered

# by the server. In milliseconds

my $whois_timeout = 5000;

# Interval for the times at which GC takes place automatically. In milliseconds

my $whois_gc_interval = 300000;

# Debug poutput on or off

my $whois_debug = 0;

# Output level (the whois_printing_level_n is the numeric information for the

# output level)

my $whois_printing_level = "JOINS";

my $whois_printing_level_n;

################################################################################

# Cached records per server, plus information about the amount of queued

# reuests

my %servers;

################################################################################

# Registers the theme messages with irssi so they can be changed later by the

# user using the /FORMAT command

sub register_messages

{

Irssi::theme_register([

'ji_whois_success',

'{channick_hilight $0} is "{hilight $1}"%n on {channel $2}',

'ji_whois_list_header',

'Server: {hilight $0} ($1 pending)',

'ji_whois_list_nick',

'{channick_hilight $0} is "{hilight $1}"%n on {channel $2}',

'ji_whois_list_status',

'Status: $0; Record age: $1s; Server tag: $2'

]);

}

################################################################################

# Register the settings we use, and specify a DEFAULT for when Irssi

# did not have them saved yet. Allows users to use /SET later.

sub register_settings

{

Irssi::settings_add_int(

"joininfo",

"whois_expire_time",

$whois_maxage

);

Irssi::settings_add_int(

"joininfo",

"whois_max_requests",

$max_queued_requests

);

Irssi::settings_add_int(

"joininfo",

"whois_timeout_ms",

$whois_timeout

);

Irssi::settings_add_int(

"joininfo",

"whois_gc_interval_ms",

$whois_gc_interval

);

Irssi::settings_add_int(

"joininfo",

"whois_debug",

$whois_debug

);

Irssi::settings_add_str(

"joininfo",

"whois_printing_level",

$whois_printing_level

);

}

################################################################################

# Now (re-)read the settings, those saved in the config will be returned,

# unless not present in which case the default will be returned

# This function is called once on script start, and later is run as an

# event handler when irssi notifies us of a change in settings.

sub load_settings

{

$whois_maxage = Irssi::settings_get_int("whois_expire_time");

$max_queued_requests = Irssi::settings_get_int("whois_max_requests");

$whois_timeout = Irssi::settings_get_int("whois_timeout_ms");

$whois_gc_interval = Irssi::settings_get_int("whois_gc_interval_ms");

$whois_debug = Irssi::settings_get_int("whois_debug");

$whois_printing_level = Irssi::settings_get_str("whois_printing_level");

$whois_printing_level = uc($whois_printing_level);

$whois_printing_level =~ s/[^A-Z]//gi;

my($definedlvl);

eval("\$definedlvl = defined(MSGLEVEL_" . $whois_printing_level. ");");

if (!$definedlvl)

{

Irssi::print(

"%RJOININFO:%n illegal /set whois_printing_level, see /help levels".

" for more informations. Assuming JOINS in stead of ".

"\"$whois_printing_level\"."

);

$whois_printing_level = "JOINS";

$whois_printing_level_n = MSGLEVEL_JOINS;

return;

}

eval("\$whois_printing_level_n = MSGLEVEL_" . $whois_printing_level . ";");

if ($whois_printing_level_n == 0)

{

Irssi::print(

"%RJOININFO:%n illegal /set whois_printing_level, see /help levels".

" for more informations. Assuming JOINS in stead of ".

"\"$whois_printing_level\"."

);

$whois_printing_level = "JOINS";

$whois_printing_level_n = MSGLEVEL_JOINS;

return;

}

}

################################################################################

# We keep records of all nicks that ever joined a channel in our memory,

# without ever freeing them up. This can get quite large over time, therefore

# evere once in a while we go out and remove the garbage

#

# Now this function also corrects the pending counter in case strange things

# happen on strange nets

sub garbage_collector

{

my($runtime) = time();

foreach my $tag (keys(%servers))

{

my($busy) = 0;

my($rec) = $servers{$tag};

foreach my $nick (keys %{$rec->{nicks}})

{

my($age) = $runtime - $rec->{nicks}->{$nick}->{record_time};

if ($rec->{nicks}->{$nick}->{busy})

{

# Re-calculate the number of pending requests

$busy = $busy + 1;

# we can safely delete it because 600 seconds should have

# caused a good oldfashioned ping timeout anyway

# if the server is not still going to respond after 10

# minutes we can crash for all I care

if ($age > 600)

{

Irssi::print(

"%RWHOIS:%n Giving up on %c$nick%n, because 600 " .

"seconds have passed since we first asked %c$tag%n.%N"

) if ($whois_debug);

# We have one request less to process now

$busy = $busy - 1;

# Drop the request completely and forget all about this

# nick

delete $rec->{nicks}->{$nick};

}

}

elsif ($age >= 2 * $whois_maxage)

{

delete $rec->{nicks}->{$nick};

}

$rec->{processing} = $busy;

}

}

}

################################################################################

# This is a very simple job to warp the call to the garbage collector. Used to

# be self-scheduling, but irssi happily does that for us

#

# Pointless function, waste of memory, need one of those in every good

# program, here is mine.

sub aw_gc_scheduler

{

garbage_collector();

}

################################################################################

# Show information about the autowhois stuff and about who we still know

# Basically displays the cache contents. Some stuff may still be in the cache

# though it is already outdated, The barbage collector will take care of

# those entries

sub cmd_joininfo_info

{

my($runtime) = time();

foreach my $tag (keys(%servers))

{

my($rec) = $servers{$tag};

Irssi::printformat(

MSGLEVEL_CRAP,

'ji_whois_list_header',

$tag,

$rec->{processing}

);

foreach my $nick (keys %{$rec->{nicks}})

{

my($age) = $runtime - $rec->{nicks}->{$nick}->{record_time};

my($status) = "OK";

if ($rec->{nicks}->{$nick}->{busy})

{

$status = "BUSY";

}

elsif ($rec->{nicks}->{$nick}->{aborted})

{

$status = "ABORTED";

if ($rec->{nicks}->{$nick}->{known})

{

$status = $status . " but KNOWN";

}

}

else

{

$status = "COMPLETE";

}

Irssi::printformat(

MSGLEVEL_CRAP,

'ji_whois_list_nick',

$nick,

$rec->{nicks}->{$nick}->{realname},

$rec->{nicks}->{$nick}->{channels},

$rec->{nicks}->{$nick}->{server},

$rec->{nicks}->{$nick}->{flags}

);

Irssi::printformat(

MSGLEVEL_CRAP,

'ji_whois_list_status',

$status,

$age,

$tag

);

}

}

}

################################################################################

# A timeout is put for this function just after the WHOIS has been sent to

# the server. When the server does not reply, then we will mark the action as

# aborted. If a reply still ariives later (due to lag) that is not a problem

# as it will simply be reported then. The only thing this function makes sure

# of is that the system is not marked busy anymore so other WHOIS requests

# can go through

sub server_whois_timeout

{

my ($server, $nick) = @{$_[0]};

my $rec = $servers{$server->{tag}};

if ((defined($rec->{nicks}->{$nick}))

&& ($rec->{nicks}->{$nick}->{busy} == 1)

)

{

$rec->{nicks}->{$nick}->{aborted} = 1;

$rec->{nicks}->{$nick}->{busy} = 0;

$rec->{processing} = $rec->{processing} - 1;

Irssi::print(

"%RWHOIS:%n whois timeout for nick %C$nick%n ".

"(still running $rec->{processing} requests)"

) if ($whois_debug);

}

# Run once, so we remove this job

Irssi::timeout_remove($rec->{nicks}->{$nick}->{timeout_job});

}

################################################################################

# Put a whois request on the server (for one nick only) if and only if the

# number of outstanding rrequests on that server is not too high

#

# Also installs an event handler for the next related SHOIS event that the

# server throws at us

sub request_whois

{

my ($server, $nick) = @_;

my $rec = $servers{$server->{tag}};

return if $server->{chat_type} ne "IRC";

if ($rec->{processing} > $max_queued_requests)

{

Irssi::print(

"%RWHOIS:%n Ignoring WHOIS request for %C$nick%n (too busy)%N"

) if ($whois_debug);

record_reset($server, $nick);

return;

}

$server->redirect_event(

"whois",

1,

$nick,

0,

"redir autowhois_default",

{

"event 311" => "redir autowhois_realname",

"event 319" => "redir autowhois_channels",

"event 312" => "redir autowhois_server",

"event 301" => "redir autowhois_away",

"event 307" => "redir autowhois_identified",

"event 275" => "redir autowhois_ssl",

"event 310" => "redir autowhois_irchelp",

"event 313" => "redir autowhois_ircop",

"event 325" => "redir autowhois_ircbot",

"event 317" => "redir autowhois_idle",

# "event 263" => "redir autowhois_busy",

"event 318" => "redir autowhois_end",

"event 401" => "redir autowhois_unknown",

"" => "event empty"

}

);

$rec->{processing} = $rec->{processing} + 1;

# This format requests additional information on $nick

# used to be: $server->send_raw("WHOIS $nick :$nick");

$server->send_raw("WHOIS $nick");

$rec->{nicks}->{$nick}->{timeout_job} = Irssi::timeout_add(

$whois_timeout,

\&server_whois_timeout,

[$server, $nick]

);

}

################################################################################

# A whois record is built as and when server messages with info for a specific

# user arrive. After the WHOIS END message has arrived for that user, we can

# report the stored whois information with this function.

sub report_stored_whois_info

{

my ($server, $nick) = @_;

my $rec = $servers{$server->{tag}};

if (!defined($rec->{nicks}->{$nick}))

{

Irssi::print(

"%RWHOIS:%n Report called for undefined hash %C$nick%N"

) if ($whois_debug);

return;

}

foreach my $channame (@{$rec->{nicks}->{$nick}->{queued_channels}})

{

my $chanrec = $server->channel_find($channame);

if ($chanrec)

{

$rec->{nicks}->{$nick}->{flags} =~ s/[ ]{1,}$//;

$chanrec->printformat(

$whois_printing_level_n,

'ji_whois_success',

$nick,

$rec->{nicks}->{$nick}->{realname},

$rec->{nicks}->{$nick}->{channels},

$rec->{nicks}->{$nick}->{server},

$rec->{nicks}->{$nick}->{flags}

);

}

else

{

Irssi::print(

"%RWHOIS:%n chanrec not found for %W$channame%n :-(%N"

) if ($whois_debug);

}

}

$rec->{nicks}->{$nick}->{queued_channels} = [];

}

################################################################################

# Create an empty record for this nick on that server, we will gradually fill

# out this record as and when we go along.

sub record_reset

{

my ($server, $nick) = @_;

my $rec = $servers{$server->{tag}};

if (defined($rec->{nicks}->{$nick}))

{

delete $rec->{nicks}->{$nick};

}

$rec->{nicks}->{$nick} =

{

record_time => time(),

queued_channels => [],

realname => "(unknown)",

channels => "(unknown)",

server => "(unknown)",

flags => "",

aborted => 0,

busy => 0,

known => 0,

timeout_job => 0

};

}

################################################################################

# Sent when a user joins a channel we are on, whic is where we check if we

# have the user info cached, if it is still valid, and if not we put

# a WHOIS request on the server for this user and are done.

sub event_join

{

my ($server, $channame, $nick, $host) = @_;

return if $server->{chat_type} ne "IRC";

$channame =~ s/^://;

my $rec = $servers{$server->{tag}};

return if ($nick eq $server->{nick});

return if ($server->netsplit_find($nick, $host));

if (!defined($rec->{nicks}->{$nick}))

{

# If the nick has no requests joined yet, we will create a new

# empty record for the nick, so we can assume later it does

# exist

record_reset($server, $nick);

}

if (($rec->{nicks}->{$nick}->{known})

&& ((time() - $rec->{nicks}->{$nick}->{record_time}) <= $whois_maxage)

)

{

# If we asked less than whois_maxage seconds ago for a WHOIS on this

# nick, we will not re-issue a request.

#

# NOTE: When a person (manually) joins multiple channels you are

# on, this may cause you not seeing all channels in the

# channel list, You can set this to something like 5

# seconds to reduce the probability of this happening

push @{$rec->{nicks}->{$nick}->{queued_channels}}, $channame;

report_stored_whois_info($server, $nick);

}

elsif ($rec->{nicks}->{$nick}->{busy} == 1)

{

# If we already issued a WHOIS request for this nick but did not

# receive a result yet, we just push this channel name on the

# list of channels that want a report when the result is known

push @{$rec->{nicks}->{$nick}->{queued_channels}}, $channame;

}

else

{

# Finally, we are not already processing this nick, and either

# we have no information for it, or the information we have is

# too old, so we send a WHOIS request to the server.

push @{$rec->{nicks}->{$nick}->{queued_channels}}, $channame;

$rec->{nicks}->{$nick}->{busy} = 1;

request_whois($server, $nick);

}

}

################################################################################

# Implementation of the WFORCE <nick> command. Useful for testing purposes

# only, for example to see if the theme changes you made are correct, if the

# timeouts are interpreted properly, and if the garbage collector works

sub cmd_joininfo_force

{

my ($data, $server, $window) = @_;

$data =~ s/^[ ]{1,}//g;

$data =~ s/[ ]{1,}$//g;

if (!$server || !$server->{connected})

{

Irssi::print("Not connected.");

return;

}

if ($window->{type} ne "CHANNEL")

{

Irssi::print("Not a channel window.");

return;

}

event_join($server, $window->{name}, $data, "testuser\@test.example.com");

}

################################################################################

# Event handler for the whois realname line returned by the server. When we

# issue a whois request, we bind an event handler for whois info for that

# nick.

#

# Does nothing, except for updating the record for that nick.

sub event_whois_realname

{

my ($server, $data) = @_;

my ($num, $nick, $user, $host, $empty, $realname) = split(/ +/, $data, 6);

$realname =~ s/^://;

my $rec = $servers{$server->{tag}};

$rec->{nicks}->{$nick}->{realname} = $realname;

}

################################################################################

# Event handler for the whois channels line returned by the server. When we

# issue a whois request, we bind an event handler for whois info for that

# nick.

#

# Does nothing, except for updating the record for that nick.

sub event_whois_channels

{

my ($server, $data) = @_;

my ($num, $nick, $channels) = split(/ +/, $data, 3);

$channels =~ s/^://;

my $rec = $servers{$server->{tag}};

$channels =~ s/[ ]{1,}$//;

$rec->{nicks}->{$nick}->{channels} = $channels;

}

################################################################################

# Event handler for the whois server line returned by the server. When we

# issue a whois request, we bind an event handler for whois info for that

# nick.

#

# Does nothing, except for updating the record for that nick.

#

# NOTE: In the default report the server is not repported, it is however

# stored in the record, so if you need it, you can simply update the

# reporting function to show it.

sub event_whois_server

{

my ($server, $data) = @_;

my ($num, $nick, $serverstr) = split(/ +/, $data, 3);

$serverstr =~ s/^://;

my $rec = $servers{$server->{tag}};

$serverstr =~ s/ :.*$//;

$rec->{nicks}->{$nick}->{server} = $serverstr;

}

################################################################################

# This is the end of the whois request, all info available we should have

# now, so we mark the record as know, not bust, timestamp it so we can

# expire it later and we report back to the user on those channels waiting

# for whois info for nick

#

# Note that a No Such Nick error is not always followed by a WHOIS END.

# hyb7-based servers interpret the RFC differently from for example hyb6

# and the IRCNet servers and will not send the WHOIS END line, but just

# the No Such Nick error (401).

sub event_whois_end

{

my($server, $data) = @_;

my ($num, $nick, $serverstr) = split(/ +/, $data, 3);

my $rec = $servers{$server->{tag}};

$rec->{nicks}->{$nick}->{record_time} = time();

$rec->{nicks}->{$nick}->{known} = 1;

$rec->{nicks}->{$nick}->{busy} = 0;

if (!$rec->{nicks}->{$nick}->{aborted})

{

$rec->{processing} = $rec->{processing} - 1;

}

report_stored_whois_info($server, $nick);

}

################################################################################

# Some servers (hyb7) do not send an end of whois when the nick is

# not known, they just send a 401 unknown message. Ircnet sends both, hyb6

# sends both, but other servers seem to interpret the RFC differently. We

# just treat this event_whois_unknown as a 318 tag, and mark the lookup

# aborted (which it is in some way)

sub event_whois_unknown

{

my($server, $data) = @_;

my ($num, $nick, $serverstr) = split(/ +/, $data, 3);

my $rec = $servers{$server->{tag}};

# Fill out the record with some bogus information, so when we

# end up reporting it, we can at least see what is going on.

$rec->{nicks}->{$nick}->{record_time} = time();

$rec->{nicks}->{$nick}->{known} = 1;

$rec->{nicks}->{$nick}->{busy} = 0;

$rec->{nicks}->{$nick}->{realname} = "(unknown)";

$rec->{nicks}->{$nick}->{channels} = "(unknown)";

$rec->{nicks}->{$nick}->{server} = "(unknown)";

$rec->{nicks}->{$nick}->{flags} = "(unknown)";

if (!$rec->{nicks}->{$nick}->{aborted})

{

$rec->{processing} = $rec->{processing} - 1;

$rec->{nicks}->{$nick}->{aborted} = 1;

}

report_stored_whois_info($server, $nick);

}

################################################################################

# If the server is busy

sub event_whois_busy

{

my($server, $data) = @_;

my($num, $nick, $serverstr) = split(/ +/, $data, 3);

my($rec) = $servers{$server->{tag}};

Irssi::print("******************* SERVER BUSY *******************************");

}

################################################################################

# No clue what this is for, maybe I should read the irssi documentation

# (if it existed....)

#

# Judging from the debug output this function is never called.

sub event_whois_default

{

my($server, $nick) = @_;

my $rec = $servers{$server->{tag}};

Irssi::print(

"%RWHOIS:%n Got event_whois_default, ignoring."

) if ($whois_debug);

}

################################################################################

# Some chat networks support extra falgs for their users and display those

# in WHOIS results. The following fields allow this information to be

# stored in the channel records and to be displayed as well.

sub event_whois_away

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."Away ";

}

################################################################################

sub event_whois_identified

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."NickREG ";

}

################################################################################

sub event_whois_ssl

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."SSL ";

}

################################################################################

sub event_whois_irchelp

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."IrcHELP ";

}

################################################################################

sub event_whois_ircop

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."IrcOP ";

}

################################################################################

sub event_whois_ircbot

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."IrcBOT ";

}

################################################################################

sub number_to_timestr

{

my($number) = @_;

my ($result) = "";

# Force integer

$number = 1 * $number;

my($days) = $number / 86400;

$number = $number % 86400;

my($hours) = $number / 3600;

$number = $number % 3600;

my($minutes) = $number / 60;

$number = $number % 60;

my($seconds) = $number;

if ($days) { $result = $result . "${days}d"; }

if ($hours || $result) { $result = $result . "${hours}h"; }

if ($minutes || $result) { $result = $result . "${minutes}m"; }

$result = $result . "${seconds}s";

return $result;

}

################################################################################

sub event_whois_idle

{

my ($server, $data) = @_;

my $rec = $servers{$server->{tag}};

my ($num, $nick, $msg) = split(/ +/, $data, 3);

$msg =~ s/^://;

if ($msg =~ /^([0-9]{1,}) ([0-9]{1,}) :.*$/)

{

my($idle) = 1 * $1;

my($signon) = 1 * $2;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}

. "Idle=" . number_to_timestr($idle). " ";

}

elsif ($msg =~ /^([0-9]{1,}) :.*$/)

{

my($idle) = 1 * $1;

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}

. "Idle=" . number_to_timestr($idle). " ";

}

else

{

$rec->{nicks}->{$nick}->{flags} = $rec->{nicks}->{$nick}->{flags}."SameSRV ";

}

}

################################################################################

# Initializes a server record for the autowhois. Either called when a server

# does connect to the network, or on script load for all connected servers at

# that time

sub event_connected

{

my($server) = @_;

$servers{$server->{tag}} = {

processing => 0, # waiting reply for WHOIS request

nicks => {} # nick => [ #chan1, #chan2, .. ]

};

}

################################################################################

# Deletes a server record for the autowhois. We do this on disconnect

sub event_disconnected

{

my($server) = @_;

delete $servers{$server->{tag}};

}

################################################################################

# Implementation of what I call the /JOININFO umbrella command. Below

# we bind all subcommands for this command already, so all we need to

# do is hand off the event to irssi again so it can call the right

# implementation function for it.

sub cmd_joininfo

{

my ($data, $server, $item) = @_;

$data =~ s/\s+$//g;

Irssi::command_runsub ('joininfo', $data, $server, $item);

}

################################################################################

# Shows help

sub cmd_joininfo_help

{

Irssi::print( <<EOF

JOININFO FORCE <nick>

JOININFO GC

JOININFO INFO

JOININFO HELP

JOININFO FORCE <nick>

Fakes the join of a certain nick to the channel, and shows you

what the WHOIS line would look like.