path: root/docs/perl.txt

 Installation problems
 ---------------------

You'll need to have perl support compiled with irssi. If "/LOAD"
doesn't show perl in list of loaded modules, you have a problem. See
INSTALL file for information about perl problems.


 Running scripts
 ---------------

Scripts are run with /SCRIPT LOAD command, or the default /RUN alias.
"/SCRIPT" shows list of running script, and /SCRIPT UNLOAD can unload
scripts.

Scripts should be placed to ~/.irssi/scripts/ or
/usr/local/lib/irssi/scripts/ (or depending on where irssi was
installed) directories. After that /RUN script_name should work, you
don't need to add the .pl suffix.


 Creating/replacing /COMMANDS
 ----------------------------

You can create your own commands, or replace existing ones with
Irssi::command_bind(). The command handling work internally pretty much
the same as signal handlers, so if you replace existing command and don't
wish to let it run, call Irssi::signal_stop().

Here's an example:

  # Usage: /HELLO [<nick>]
  sub cmd_hello {
    # data - contains the parameters for /HELLO
    # server - the active server in window
    # witem - the active window item (eg. channel, query)
    #         or undef if the window is empty
    my ($data, $server, $witem) = @_;

    if (!$server || !$server->{connected}) {
      Irssi::print("Not connected to server");
      return;
    }

    if ($data) {
      $server->command("MSG $data Hello!");
    } elsif ($witem && ($witem->{type} eq "CHANNEL" ||
                        $witem->{type} eq "QUERY")) {
      # there's query/channel active in window
      $witem->command("MSG ".$witem->{name}." Hello!");
    } else {
      Irssi::print("Nick not given, and no active channel/query in window");
    }
  }

  Irssi::command_bind('hello', 'cmd_hello');


 Message levels
 --------------

Several functions expect message levels. They're used to roughly
classify messages. They're used by a lot of things including logging,
ignoring, highlighting, etc. so you should use as good level as
possible. It's possible to have several levels in one message, like
ACTIONS+PUBLIC or ACTIONS+MSGS.

Here's all the levels that irssi supports currently:

  CRAP, MSGS, PUBLIC, NOTICES, SNOTES, CTCPS, ACTIONS, JOINS, PARTS
  QUITS, KICKS, MODES, TOPICS, WALLOPS, INVITES, NICKS, DCC, DCCMSGS,
  CLIENTNOTICE, CLIENTCRAP, CLIENTERROR

And a few special ones that could be included with the levels above:

  HILIGHT - text is highlighted
  NOHILIGHT - don't check highlighting for this message
  NO_ACT - don't trigger channel activity when printing this message
  NEVER - never ignore or log this message (not a good idea usually)

You can use them with a MSGLEVEL_ prefix, for example:

  $server->print("#channel", 'Hello, world', MSGLEVEL_CLIENTCRAP);

Writes text to #channel window with CLIENTCRAP level.




 Functions that you can use in Irssi's Perl scripts
 --------------------------------------------------

If there's a "Xxxx::" text before the command, it means that it belongs to
that package. Like "Server::command" means that you should either call it as
  Irssi::Server::command($server, $cmd);
or more easily:
  $server->command($cmd);

Commands that don't have the Xxxx prefix are called as Irssi::command();

Information from most objects can be fetched with $object->{data}, for
example current nick in server could be read with $server->{nick}. List
of all the information that are in objects are in "Object->{}" sections
below.

Commands are split in two groups, generic ones that could be used with
any chat protocol, and IRC specific commands. If you want to use IRC
specific commands, or use IRC specific ->{data} in your scripts, you'll
need to add "use Irssi::Irc" to your scripts. IRC specific commands are
listed after the generic ones.


 *** General



print(str[, level])
  Print `str'. Default level is MSGLEVEL_CLIENTNOTICE.

command(cmd)
  Send a command `cmd' (in current channel). The '/' char isn't needed.


 *** Themes



 *** Settings


 *** Signals

  *** timeouts / IO listener / pidwait



 *** Message levels



 *** Commands




 *** Windows



Windowitem window_item_find(name)
Server::window_item_find(name)

window_refnum_prev(refnum, wrap)
window_refnum_next(refnum, wrap)
  Return refnum for window that's previous/next in windows list.

windows_refnum_last()
  Return refnum for last window.


 *** Server Connects

Connect->{}
  type - "SERVER CONNECT" text
  chat_type - String ID of chat protocol, for example "IRC"

  address - Address where we connected (irc.blah.org)
  port - Port where we connected
  chatnet - Chat network

  password - Password we used in connection.
  wanted_nick - Nick which we would prefer to use
  username - User name
  realname - Real name

Connect
server_create_conn(address[, port=6667[, password=''[, nick=''[, channels='']]]])
  Create new server connection.


 *** Server functions



 *** Server reconnections



 *** Chat networks



 *** Server redirections

This is a powerful feature of Irssi that I haven't seen in other IRC
clients. You can EASILY grab the server's reply for a command you send
to server without any horrible kludges.

redirect_register(command, remote, timeout, start, stop, opt)
   Register new redirection command. By default irssi has already
   registered at least: whois, whowas, who, list, ison, userhost, ping,
   "mode channel" (/MODE #channel), "mode b" (/MODE #channel b), "mode e"
   and "mode I".

   `command' specifies the name of the command to register, it doesn't
   have to be a real command name, but something you just specify to
   redirect_event() when using this redirection.

   `remote' specifies if the command is by default a remote command
   (eg. sent to another server). redirect_event() may override this.

   `timeout' - If remote is TRUE, specifies how many seconds to wait for
   reply before aborting.

   `start', `stop', `opt' - hash references with "event" => argpos entries.
   List of events that start and stop this redirection.
   Start event list may be empty, but there must be at least one
   stop event. Optional events are checked only if they are received
   immediately after one of the stop-events. `argpos' specifies the
   word number in event string which is compared to wanted argument,
   -1 = don't compare, TRUE always.

  Example (already done by irssi):

  Irssi::redirect_register('mode channel', 0, 0,
  	undef, # no start events
	{ # stop events
	  "event 324" => 1, # MODE-reply
	  "event 403" => 1, # no such channel
	  "event 442" => 1, # "you're not on that channel"
	  "event 479" => 1  # "Cannot join channel (illegal name)"
	}, { # optional events
	  "event 329", 1 # Channel create time
	} );

Server::redirect_event(command, count, arg, remote, failure_signal, signals)
   Specify that the next command sent to server will be redirected.
   NOTE: This command MUST be called before sending the command to server.

   `command' - Name of the registered redirection that we're using.

   `count' - How many times to execute the redirection. Some commands may
   send multiple stop events, like MODE #a,#b.

   `arg' - The argument to be compared in event strings. You can give multiple
   arguments separated with space.

   `remote' - Specifies if the command is a remote command, -1 = use default.

   `failure_signal' - If irssi can't find the stop signal for the redirection,
   this signal is called.

   `signals' - hash reference with "event" => "redir signal" entries.
   If the event is "", all the events belonging to the redirection but not
   specified here, will be sent there.

  Example:

  # ignore all events generated by whois query, except 311.
  $server->redirect_event("whois", 1, "cras", 0, undef, {
			  "event 311" => "redir whois",
			  "" => "event empty" });
  $server->send_raw("WHOIS :cras");


 *** Window items



 *** Channels



 *** Nick list


 *** Queries


Query
query_create(chat_type, server_tag, nick, automatic)
  Create a new query.

Query
query_find(nick)
  Find query from any server.

Query
Server::query_find(nick)
  Find query from specified server.


 *** Masks

You should use the Server version of the function if possible, since
with different chat protocols the mask matching could be different.

mask_match(mask, nick, user, host)
Server::mask_match(mask, nick, user, host)
  Return 1 if `mask' matches nick!user@host.

mask_match_address(mask, nick, address)
Server::mask_match_address(mask, nick, address)
  Return 1 if `mask' matches nick!address.

masks_match(masks, nick, address)
Server::masks_match(masks, nick, address)
  Return 1 if any mask in the `masks' (string separated with spaces)
  matches nick!address.




 *** Logging



 *** Ignores


 *** /EXEC processes



 ***
 *** IRC specific functions. All objects below this are prefixed with Irc::
 ***

 *** IRC servers

Irc::Server->{}
  (..contains all the same data as core Server object..)
  real_address - Address the IRC server gives
  usermode - User mode in server
  userhost - Your user host in server

Irc::Connect->{}
  (..contains all the same data as core Connect object..)
  alternate_nick - Alternate nick to use if default nick is taken.

Connect::connect()
  Connect to IRC server.

Server::get_channels(server)
  Return a string of all channels (and keys, if any have them) in server,
  like "#a,#b,#c,#d x,b_chan_key,x,x" or just "#e,#f,#g"

Server::send_raw(cmd)
  Send raw message to server, it will be flood protected so you
  don't need to worry about it.

Server::send_raw_now(cmd)
  Send raw message to server immediately without flood protection.

Server::send_raw_split(cmd, nickarg, max_nicks)
  Split the `cmd' into several commands so `nickarg' argument has only
  `max_nicks' number of nicks.

  Example:
    $server->send_raw_split("KICK #channel nick1,nick2,nick3 :byebye", 3, 2);

  Irssi will send commands "KICK #channel nick1,nick2 :byebye" and
  "KICK #channel nick3 :byebye" to server.

Server::ctcp_send_reply(data)
  Send CTCP reply. This will be "CTCP flood protected" so if there's too
  many CTCP requests in buffer, this reply might not get sent. The data
  is the full raw command to be sent to server, like
    "NOTICE nick :\001VERSION irssi\001"

Server::isupport(name)
  Returns the value of the named item in the ISUPPORT (005) numeric to the
  script. If the item is not present returns undef, if the item has no value
  then "" is returned use defined $server->isupport("name") if you need to
  check whether a property is present.
  See http://tools.ietf.org/id/draft-brocklesby-irc-isupport-03.txt
  for more information on the ISUPPORT numeric.

 *** IRC channels



 *** DCC





 *** Netsplits

Netsplit->{}
  nick - Nick
  address - Nick's host
  destroy - Timestamp when this record should be destroyed
  server - Netsplitserver object
  channels - list of channels (Netsplitchannel objects) the nick was in

Netsplitserver->{}
  server - The server nick was in
  destserver - The other server where split occured.
  count - Number of splits in server

Netsplitchannel->{}
  name - Channel name
  nick - Nick object



 *** Notify list


notifies() - Return list of all notifies

Notifylist
notifylist_add(mask, ircnets, away_check, idle_check_time)
  Add new item to notify list.

notifylist_remove(mask)
  Remove item from notify list.

Notifylist
notifylist_find(mask, ircnet)
  Find notify.

Server
notifylist_ison(nick, serverlist)
  Check if `nick' is in IRC. `serverlist' is a space separated
  list of server tags. If it's empty string, all servers will be checked.

Server::notifylist_ison_server(nick)
  Check if `nick' is on IRC server.

 *** Proxy clients


 
All the content of this site is copyright © 2000-2010 The Irssi project.