Running Perl scripts -------------------- First you'll need to have Perl support on. By default irssi compiles Perl as a module, so /LOAD perl probably helps. After that you can run scripts with /RUN script (you don't need to give the .pl extension). If /RUN complains about "unknown command", you don't have Perl module loaded, or maybe Perl support wasn't compiled at all. Place new scripts to ~/.irssi/scripts/ or /usr/local/lib/irssi/scripts/ directory. Scripts in ~/.irssi/scripts/autorun/ directory are automatically run at startup. Using /PERLFLUSH closes and reopens the perl interpreter removing all Perl scripts from memory. There's currently no way to unload a single Perl script (/SCRIPT REMOVE will probably work soon). You can however run same script multiple times, and irssi will remove the old version from memory before running the new version. Irssi's signals --------------- Irssi is pretty much based on sending and handling different signals. Like when you receive a message from server, say :nick!user@there.org PRIVMSG you :blahblah Irssi will first send a signal: "server incoming", SERVER_REC, "nick!user@there PRIVMSG ..." You probably don't want to use this signal. Default handler for this signal interprets the header and sends a signal: "server event", SERVER_REC, "PRIVMSG ...", "nick", "user@there.org" You probably don't want to use this either, since this signal's default handler parses the event string and sends a signal: "event privmsg", SERVER_REC, "you :blahblah", "nick", "user@there.org" You can at any point grab the signal, do whatever you want to do with it and optionally stop it from going any further by calling Irssi::signal_stop(); For example: sub event_privmsg { # $data = "nick/#channel :text" my ($server, $data, $nick, $address) = @_; my ($target, $text) = split(/ :/, $data, 2); Irssi::signal_stop() if ($text =~ /free.*porn/ || $nick =~ /idiot/); } Irssi::signal_add("event privmsg", "event_privmsg") This will hide all public or private messages that match the regexp "free.*porn" or the sender's nick contain the word "idiot". Yes, you could use /IGNORE instead for both of these :) You can also use signal_add_last() if you wish to let the Irssi's internal functions be run before yours. A list of signals that irssi send can be found from signals.txt file. 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 - message is highlighted NOHILIGHT - don't check highlighting from 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 Window active_win() - return active window Server active_server() - return server in active window windows() - return list of all windows servers() - return list of all servers reconnects() - return list of all server reconnections channels() - return list of all channels queries() - return list of all queries commands() - return list of all commands logs() - return list of all log files ignores() - returns list of all ignores Server::channels() - return list of channels in server Server::queries() - return list of queries in server print(str[, level]) Server::print(channel, str[, level]) Window::print(str[, level]) Windowitem::print(str[, level]) Print `str'. Default level is MSGLEVEL_CLIENTNOTICE. command(cmd) Server::command(cmd) Window::command(cmd) Windowitem::command(cmd) Send a command `cmd' (in current channel). This will work just as if you had typed `cmd' in command line, so you'll need to use /COMMANDS or the text will be sent to the channel. Just like above, except different calling method. *** Themes You can have user configurable texts in scripts that work just like irssi's internal texts that can be changed in themes. First you'll have to register the formats: Irssi::theme_register([ 'format_name', '{hilight my perl format!}', 'format2', 'testing.. nick = $0, channel = $1' ]); Printing happens with one of the functions: printformat(level, format, ...) Window::printformat(level, format, ...) Server::printformat(target, level, format, ...) Windowitem::printformat(level, format, ...) For example: $channel->printformat(MSGLEVEL_CRAP, 'format2', 'nick', $channel->{name}); *** Settings settings_get_str(key) settings_get_int(key) settings_get_bool(key) Return value for setting. settings_add_str(section, key, def) settings_add_int(section, key, def) settings_add_bool(section, key, def) Create new setting. settings_remove(key) Remove a setting. *** Signals signal_emit(signal, ...) Send signal `signal'. You can give 6 parameters at maximum. signal_add(signal, func) Bind `signal' to function `func'. signal_add_first(signal, func) Bind `signal' to function `func'. Call `func' as soon as possible. signal_add_last(signal, func) Bind `signal' to function `func'. Call `func' as late as possible. signal_remove(signal, func) Unbind `signal' from function `func'. signal_stop() Stop the signal that's currently being emitted. signal_stop_by_name(signal) Stop the signal with name `signal' that's currently being emitted. *** timeouts / IO listener timeout_add(msecs, func, data) Call `func' every `msecs' milliseconds (1000 = 1 second) with parameter `data'. Returns tag which can be used to stop the timeout. timeout_remove(tag) Remove timeout with tag. input_add(source, condition, func, data) Call `func' with parameter `data' when specified IO happens. `source' is the file handle that is being listened. `condition' can be INPUT_READ, INPUT_WRITE or both. Returns tag which can be used to remove the listener. input_remove(tag) Remove listener with tag. *** Message levels level2bits(level) Level string -> number bits2level(bits) Level number -> string combine_level(level, str) Combine level number to level string ("+level -level"). Return new level number. *** Commands Command->{}: cmd - Command name category - Category command_bind(cmd, func[, category]) Bind command `cmd' to call function `func'. `category' is the category where the command is displayed in /HELP. command_unbind(cmd, func) Unbind command `cmd' from function 'func. *** Windows Window::items() Return a list of items in window. Window window_create(automatic) Windowitem::window_create(automatic) Create a new window. Window::destroy() Destroy the window. Irssi::Window Windowitem::window() Returns parent window for window item. Window window_find_name(name) Find window with name. Window window_find_refnum(refnum) Find window with reference number. Window window_find_level(level) Server::window_find_level(level) Find window with level. Window window_find_closest(name, level) Server::window_find_closest(name, level) Find window that matches best to given arguments. `name' can be either window name or name of one of the window items. Window window_find_item(name) Server::window_find_item(name) Find window which contains window item with specified name/server. Windowitem window_item_find(name) Server::window_item_find(name) Window::item_find(server, name) Find window item that matches best to given arguments. 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. Window::item_add(item, automatic) Window::item_remove(item) Window::item_destroy(item) Add/remove/destroy window item Window::set_active() Set window active. Window::change_server(server) Window::set_refnum(refnum) Window::set_name(name) Window::set_level(level) Change server/refnum/name/level in window. Windowitem::set_active() Change window item active in parent window. Window::item_prev() Window::item_next() Change to previous/next window item. Windowitem::change_server(server) Change server in window item. Windowitem::is_active() Returns 1 if window item is the active item in parent window. Window::get_active_name() Return active item's name, or if none is active, window's name *** 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->{} type - "SERVER" text chat_type - String ID of chat protocol, for example "IRC" (..contains all the same data as Connect above..) connect_time - Time when connect() to server finished real_connect_time - Time when server sent "connected" message tag - Unique server tag nick - Current nick connected - Is connection finished? 1|0 connection_lost - Did we lose the connection (1) or was the connection just /DISCONNECTed (0) rawlog - Rawlog object for the server version - Server version last_invite - Last channel we were invited to server_operator - Are we server operator (IRC op) 1|0 usermode_away - Are we marked as away? 1|0 away_reason - Away reason message banned - Were we banned from this server? 1|0 Server Connect::connect() Connect to server. Server::disconnect() Disconnect from server. Server server_find_tag(tag) Find server with tag Server server_find_chatnet(chatnet) Find first server that is in `chatnet' Server::isnickflag(flag) Returns 1 if flag is a nick mode flag (@, + or % in IRC) Server::ischannel(data) Returns 1 if start of `data' seems to mean channel. Server::get_nick_flags() Returns nick flag characters in order: op, voice, halfop ("@+%" in IRC). Server::send_message(target, msg) Sends a message to nick/channel. *** Server reconnections Reconnect->{} type - "RECONNECT" text chat_type - String ID of chat protocol, for example "IRC" (..contains all the same data as Connect above..) tag - Unique numeric tag next_connect - Unix time stamp when the next connection occurs *** Server redirections WARNING: It's easy to mess up the Irssi's internal server expectations with these commands! 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. Server::redirect_init(command, last, ...) Initialize redirection for specified command. This needs to be done only once. Irssi already initializes commands WHOIS, WHO, LIST, USERHOST and ISON. `command' is the whole name of the signal, like "command whois". `last' specifies how many of the items in `...' is considered as the "last event" from the command. Example: $server->redirection_init('command who', 2, # 2 first events will finish the command 'event 401', # unknown nick (finished) 'event 315', # end of who (finished) 'event 352'); # who line (wait..) Server::redirect_event(arg, last, ...) Add redirection. `arg' is a space separated list of arguments that should match before Irssi will redirect the event (think of /WHOIS nick nick and doing another to different nick immediately after it, there's no way of knowing which will return first. so, arg would be in this case 'nick'). `last' specifies how many of the following events are considered as "last event" from command - just like in redirect_init(). `...' is `event, signal, argpos, ...`, where `event' is the event we're waiting from server. `signal' is the signal we will send after receiving the event. It should always start with 'redir ' so that Irssi's perl handler knows to send correct arguments to signal handler. `argpos' is the argument position in event's data or -1 if it should be ignored. Example: $server->send_raw('WHOIS :cras'); $server->redirect_event('cras', 2, "event 318", "redir end_of_whois", 1, "event 402", "redir no_such_server", 1, "event 401", "redir no_such_nick", 1, "event 311", "redir whois", 1, "event 301", "redir whois_away", 1, "event 312", "redir whois_server", 1, "event 313", "redir whois_oper", 1, "event 317", "redir whois_idle", 1, "event 319", "redir whois_channels", 1); In the 402-case we tried "/WHOIS nick nick" but nick didn't exist. If you need to handle "/WHOIS server nick" situation, you should put both to arg with "server nick". Server::redirect_single_event(arg, last, group, event, signal, argpos) Same as redirect_event() except you can set it up in pieces. If `group' is 0, it will create new group and return it's id. *** Window items Windowitem->{} type - Type of the window item, for example "CHANNEL" or "QUERY" chat_type - String ID of chat protocol, for example "IRC" server - Active server for item name - Name of the item createtime - Time the window item was created new_data - 0=no new data, 1=text, 2=msg, 3=highlighted text last_color - Color of the last highlighted text *** Channels Channel->{} type - "CHANNEL" text chat_type - String ID of chat protocol, for example "IRC" (..contains all the same data as Windowitem above..) topic - Chanenl topic no_modes - Channel is modeless mode - Channel mode limit - Max. users in channel (+l mode) key - Channel key (password) chanop - You are channel operator names_got - /NAMES list has been received wholist - /WHO list has been received synced - Channel is fully synchronized joined - JOIN event for this channel has been received left - You just left the channel (for "channel destroyed" event) kicked - You was just kicked out of the channel (for "channel destroyed" event) Server::channels_join(channels, automatic) Join to channels in server. `channels' may also contain keys for channels just like with /JOIN command. `automatic' specifies if this channel was joined "automatically" or if it was joined because join was requested by user. If channel join is "automatic", irssi doesn't jump to the window where the channel was joined. Channel Server::channel_create(name, automatic) Create new channel. Channel channel_create(chat_type, name, automatic) Create new channel with specified chat type. FIXME: should this be removed? is this useful for anything? Channel::destroy() Destroy channel. Channel channel_find(channel) Find channel from any server. Channel Server::channel_find(channel) Find channel from specified server. *** Nick list Nick->{} type - "NICK" text chat_type - String ID of chat protocol, for example "IRC" nick - Plain nick host - Host address realname - Real name hops - Hop count to the server the nick is using gone, serverop - User status, 1 or 0 op, voice, halfop - Channel status, 1 or 0 last_check - timestamp when last checked gone/ircop status. send_massjoin - Waiting to be sent in a "massjoin" signal, 1 or 0 Nick Channel::nick_insert(nick, op, voice, send_massjoin) Add nick to nicklist. Channel::nick_remove(nick) Remove nick from nicklist. Nick Channel::nick_find(mask) Find nick from nicklist. Channel::nicks(channel) Return a list of all nicks in channel. Server::nicks_get_same(nick) Return all nick objects in all channels in server. List is in format: Channel, Nick, Channel, ... *** Queries Query->{} type - "QUERY" text chat_type - String ID of chat protocol, for example "IRC" (..contains all the same data as Windowitem above..) address - Host address of the queries nick server_tag - Server tag used for this nick (doesn't get erased if server gets disconnected) unwanted - 1 if the other side closed or some error occured (DCC chats) Query query_create(chat_type, server_tag, nick, automatic) Create a new query. Query::destroy() Destroy the query. Query::query_change_server(server) Change the active server of the 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. *** Rawlog Rawlog rawlog_create() Create a new rawlog. Rawlog::destroy() Destroy the rawlog. rawlog_set_size(lines) Set the default rawlog size for new rawlogs. Rawlog::open(filename) Start logging new messages in rawlog to specified file. Rawlog::close() Stop logging to file. Rawlog::save(filename) Save the current rawlog history to specified file. Rawlog::input(str) Send `str' to raw log as input text. Rawlog::output(str) Send `str' to raw log as output text. Rawlog::redirect(str) Send `str' to raw log as redirection text. *** Logging Log->{} fname - Log file name opened - Log file is open level - Log only these levels last - Timestamp when last message was written autoopen - Automatically open log at startup failed - Opening log failed last time temp - Log isn't saved to config file items - List of log items Logitem->{} type - 0=target, 1=window refnum name - Name servertag - Server tag Log log_create_rec(fname, level) Create log file. Log::update() Add log to list of logs / save changes to config file. Log log_find(fname) Find log with file name. Log::close() Destroy log file. Log::start_logging() Open log file and start logging. Log::stop_logging() Close log file. Log::item_add(type, name, server) Add log item to log. Log::item_destroy(item) Remove log item from log. Logitem Log::item_find(type, item, server) Find item from log. *** Ignores Ignore->{} mask - Ignore mask servertag - Ignore only in server channels - Ignore only in channels (list of names) pattern - Ignore text pattern level - Ignore level except_level - Ignore exception levels regexp - Regexp pattern matching fullword - Pattern matches only full words ignore_add_rec(ignore) Add ignore record. ignore_update_rec(ignore) Update ignore record in configuration ignore_check(nick, host, channel, text, level) Server::ignore_check(nick, host, channel, text, level) Return 1 if ignoring matched. *** *** 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", 2, 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. *** IRC channels Ban->{} ban - The ban setby - Nick of who set the ban time - Timestamp when ban was set Channel Server::channel_create(name, automatic) Create new channel. Channel::bans() Return a list of bans in channel. Channel::ebans() Return a list of ban exceptions in channel. Channel::invites() Return invite list (+I) of channel. Channel::ban_get_mask(nick) Get ban mask for `nick'. Channel::banlist_add(ban, nick, time) Add a new ban to channel. Channel::banlist_remove(ban) Remove a ban from channel. Channel::banlist_exception_add(ban, nick, time) Add a new ban exception to channel. Channel::banlist_exception_remove(ban) Remove a ban exception from channel. Channel::invitelist_add(mask) Add a new invite mask to channel. Channel::invitelist_remove(mask) Remove invite mask from channel. modes_join(old, mode, channel) Add `mode' to `old' - return newly allocated mode. If `channel' is 1, we're parsing channel mode and we should try to join mode arguments too. *** DCC Dcc->{} type - Type of the DCC: chat, send, get created - Time stamp when the DCC record was created server - Server where the DCC was initiated. nick - Other side's nick name. chat - Dcc chat record if the request came through DCC chat ircnet - IRC network where the DCC was initiated. mynick - Our nick to use in DCC chat. arg - Given argument .. file name usually file - The real file name which we use. addr - Other side's IP address. port - Port we're connecting in. size - File size transfd - Bytes transferred skipped - Bytes skipped from start (resuming file) starttime - Unix time stamp when the DCC transfer was started dccs() - return list of all dcc connections Dcc::destroy() Destroy DCC connection. Dcc dcc_find_item(type, nick, arg) Find DCC connection. Dcc dcc_find_by_port(nick, port) Find DCC connection by port. Dcc Windowitem::get_dcc(item) If `item' is a query of a =nick, return DCC chat record of nick. Dcc::chat_send(data) Send `data' to dcc chat. Server::dcc_ctcp_message(target, notice, msg) Dcc::ctcp_message(target, notice, msg) Send a CTCP message/notify to target. *** 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 Netsplit Server::netsplit_find(nick, address) Check if nick!address is on the other side of netsplit. Netsplit records are automatically removed after 30 minutes (current default).. Nick Server::netsplit_find_channel(nick, address, channel) Find nick record for nick!address in channel `channel'. *** Notify list Notifylist->{} mask - Notify nick mask away_check - Notify away status changes idle_check_time - Notify when idle time is reset and idle was bigger than this (seconds) ircnets - List of ircnets (strings) the notify is checked 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. Notifylist::ircnets_match(ircnet) Returns 1 if notify is checked in `ircnet'. *** Autoignoring Autoignore->{} nick - Ignored nick timeleft - Seconds left to ignore level - Ignoring level number Server::autoignore_add(nick, level) Add new autoignore. Server::autoignore_remove(mask, level) Remove autoignore.