jrd/irssi
1
0
Fork 0
forked from PsychoticNinja/irssi
Code Issues Pull Requests Projects Releases Wiki Activity

and the docs

Browse Source 
git-svn-id: http://svn.irssi.org/repos/irssi/trunk@173 dbcabf3a-b0e7-0310-adc4-f8d773084564
This commit is contained in:
Timo Sirainen 2000-04-26 08:11:21 +00:00 committed by cras
parent d29ca0b107
commit 94b37a898b
7 changed files with 1507 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
docs/Makefile.am
View File

@ -1,9 +1,10 @@
EXTRA_DIST = \ EXTRA_DIST = \
FAQ \ FAQ \
COMMANDS \ botnet.txt \
FORMATS \ commands.txt \
PERL \ formats.txt \
SIGNALS \ perl.txt \
botnet.txt signals.txt \
special_vars.txt
SUBDIRS = help SUBDIRS = help

423
docs/commands.txt Normal file
View File

@ -0,0 +1,423 @@
** Some definitions
"Level" usually means that you can use these words there:
CRAP - Can be almost anything
MSGS - Private messages
PUBLIC - Public messages in channel
NOTICES - Notices
SNOTES - Server notices
CTCPS - CTCP messages
ACTIONS - Actions (/me)
JOINS - Someone joins a channel
PARTS - Someone parts a channel
QUITS - Someone quits IRC
KICKS - Someone gets kicked from channel
MODES - Channel mode is changed
TOPICS - Channel topic is changed
WALLS - WALL is received (not all servers support this)
WALLOPS - Wallop is received
INVITES - Invite is received
NICKS - Someone changes nick
DCC - DCC messages
CLIENTNOTICES - Irssi's notices
CLIENTERRORS - Irssi's error messages
CLIENTCRAP - Some other messages from Irssi
HILIGHT - Hilighted text
** Server handling
CONNECT <address> [port [password [nick]]]
Connect to specified server, if there's no password set it to -
DISCONNECT <* / tag> [message]
Disconnect from server
SERVER [+]<address> [port [password [nick]]]
Disconnect from current server and connect to new one, or with
/SERVER +address it creates a new window and connects to server
there without disconnecting.
SERVERS
Display a list of servers
RMRECONNS
Remove all servers from reconnection list
** Basic IRC commands
QUIT [message]
Quit irssi
JOIN <channel> [key] [, channel...]
Join to channel(s)
PART [channel] [message]
Leave from channel
QUERY <nick>
Create query window
UNQUERY <nick>
Close query window
MSG <nick/channel> <message>
Send message to nick/channel
ME <message>
Send action to channel (/me thinks..)
NOTICE <nick/channel> <message>
Send notice to nick/channel
WHOIS [server/nick] <nick>
Send WHOIS query, you can also specify from what server to ask the
information. If you type the nick twice it will ask from the same
server what nick is using.
AWAY [-all] [message]
Sets yourself away/unaway. If -all is used, it will set away
status in all servers
WHO <nick/channel>
Show WHO list
NAMES [channel]
List nicks (in channel)
** Bit more advanced commands
MODE <channel/nick> <mode>
Get/set channel/nick mode.
Get channel modes:
b - Get ban list
e - Get ban exception list
I - Get invite list
Set channel modes (use +/- before these):
b *!ban@mask - Set/remove ban
e *!ban@mask - Set/remove ban exception
I *!ban@mask - Set/remove channel invite
o nick - Set/remove op status
v nick - Set/remove voice status
l limit - Set remove max. people limit in channel
k key - Set/remove channel key
s - Secret
p - Private
m - Moderated
i - Invite only
n - No external messages
t - Only ops can change topic
User modes:
i - Invisible
w - Show wallops
s - Show server notices
TOPIC [channel] [topic]
Get/set channel topic
INVITE <nick> [channel]
Invite nick to channel
CTCP <nick/channel> <command>
Send CTCP request to nick/channel (PING, VERSION, ..)
NCTCP <nick/channel> <reply>
Send CTCP reply to nick/channel
PING <nick>
Send CTCP PING to nick and tell how long it took to receive the reply
ISON [nick [nick...]]
Ask if nicks are in IRC.
WALL [channel] <message>
Send notice message to all operators in channel.
OP, DEOP, VOICE, DEVOICE [channel] [nick [nick...]
Op/deop/voice/devoice nick(s) in channel
KICK [channel] <nick> <reason>
Kick nick from channel
KICKBAN [channel] <nick> <reason>
Kick+ban nick from channel
KNOCKOUT [secs] <nick> <reason>
Kick+ban+delay (default to 5min)+unban
BAN [channel] [nick [nick...]]
Ban nick(s) in channel
UNBAN [channel] [mask [mask...]]
Remove ban(s) from channel
BANSTAT [channel]
List bans and ban exceptions in channel
BANTYPE <normal/host/domain/custom>
Set ban type:
Normal - *!user@*.domain.net
Host - *!*@host.domain.net
Domain - *!*@*.domain.net
Custom [nick] [user] [host] [domain]
eg. /bantype custom nick domain - nick!*@*.domain.net
eg. /bantype custom user host - *!user@host.domain.net
INVITELIST [channel]
List invites (+I) in channel
VERSION [server]
Displays irssi version and asks IRC server's version
VER [nick/channel]
Sends CTCP VERSION request to nick/channel
SV [nick/channel]
Sends irssi version text to nick/channel
KILL <nick> <message>
Kill nick from irc network. [irc ops only]
WALLOPS <message>
Write wallops message. [irc ops only]
QUOTE <message>
Send raw data to irc server - DON'T USE THIS unless you really know
what you're doing!
** DCC handling
DCC
List DCC connections (same as DCC LIST)
DCC CHAT <nick>
Open DCC chat
DCC SEND <nick> <filename>
Send file to nick
DCC GET <nick> [filename]
Get file offered by nick
DCC RESUME <nick> [filename]
(MIRC) Resume getting file offered by nick
DCC CLOSE <type> <nick> [filename]
Close DCC connection
DCC LIST
List DCC connections
MIRCDCC [n]
Set MIRC style CTCPs on/off
** User interface handling
WINDOW <NEW/CLOSE/SERVER/PREV/NEXT/GOTO/LEVEL>
NEW [HIDDEN/TAB]
Create new window (in tab)
CLOSE
Close the current window
SERVER <tag>
Change which server to use in current window
PREV/NEXT/GOTO <N>
Go to previous/next/Nth window
LEVEL <[+/-]pub/msgs/...>
Change window level, eg.
/window level msgs - creates messages window
/window level all -msgs - creates status window
CLEAR
Clear screen
ECHO <text>
Print text to screen
MODES
Open channel modes dialog (GTK/GNOME version)
GWHOIS <nick>
Display WHOIS information in dialog (GTK/GNOME version)
LAST [-pub -msgs...] <text>
Display (only public/msgs/..) lines where <text> appears
(Text version only)
** Configuration
SET [key [value]]
Get/set configuration. Boolean values also need to be changed
with ON/OFF/TOGGLE values (not yes/no). Settings aren't saved
to disk until you use /SAVE.
TOGGLE key [ON|OFF]
Same as /SET <key> TOGGLE, or if ON or OFF parameter is given
it will work just like /SET.
SAVE
Save configuration to disk.
/ALIAS [-]<alias> [<command>]
Show, add or remove aliases. Typing extra / before /command
(//command) ignores any aliases
/UNALIAS <alias>
Remove alias, same as /ALIAS -alias
IGNORE [-regexp | -word] [-pattern <pattern>] [-except]
[-channels <channel>] <mask> <levels> <^levels>
-regexp: `pattern' is a regular expression
-word: `pattern' must match to full words
-pattern: <pattern> must match to the message's text
-except: *DON'T* ignore
-channels: ignore only in channels
<mask>: either a nick mask or list of channels
<levels>: list of levels to ignore
<^levels>: list of levels to NOT ignore
(/ignore -except nick notices = /ignore nick ^notices)
UNIGNORE <ref#> | <mask>
Remove ignore.
NOTIFY [-away] [-idle [minutes]] <mask> [ircnet [ircnet...]]
Add mask (nick) to notify list for specified ircnets..
-away notifies about away-status changes
-idle notifies if idle time is first larger than `minutes'
(default is hour) and then it drops down.
UNNOTIFY <mask>
Remove mask from notify list.
HILIGHT [-nick | -regexp | -fullword] [-color <color>]
[-level <level>] [-channels <channels>] <text>
-nick: match only for nick
-regexp: `text' is a regular expression
-fullword: `text' must match to full words
-color: print the reply with `color' - color can be a bold (^B),
underline (^_) etc. too
-level: match only for `level' messages, default is
publics,msgs,notices,actions
-channels: match only in `channels'
DEHILIGHT <ref#> | <text>
Remove hilight
LOG <CREATE/CLOSE/START/STOP/LIST>
CREATE <filename> [<+/->level ...] [#channel/nick [
[<+/->level ...] ...]
Create and start logging to file
Example: /log create mylog -all +msgs #linux +chan +public
(or simply #linux +all logs everything that appears in #linux
window).
CLOSE <filename>
Close log and remove from configuration
START <filename>
Start logging to file
STOP <filename>
Stop logging to file
LIST
List logs.

117
docs/design.txt Normal file
View File

@ -0,0 +1,117 @@
Irssi's hierarchy is something like this:
sub1 sub2
\ /
xxx IRC COMMON ICQ yyy
|____|___________|____|____|
|
GUI (gtk/gnome, qt/kde, text, none)
|
sub1 sub2 |
\ / |
xxx IRC | COMMON ICQ yyy
|____|_____|_____|____|____|
|
COMMON UI
|
sub1 sub2 |
\ / |
xxx IRC | ICQ yyy
|____|_____|_____|____|
|
CORE
/ \
lib-config lib-popt
(IRC, ICQ, xxx and yyy are chat protocols ..)
(sub1 and sub2 are submodules of IRC module, like DCC and flood protect)
Chat protocols and frontends are kept in separate modules. Common UI
and GUI modules also have the common parts which don't know anything
about the chat protocols. This should allow implementing modules to
whatever chat protocols and with whatever frontends easily.
** lib-popt
CORE depends on this for command line parameter handling.
(distributed with irssi)
** lib-config
Irssi depends on this for reading and saving configuration.
(created by me for irssi)
** CORE module
Provides some functionality that all other modules can use:
- signal handling
- keeping list of settings
- keeping list of /commands
- keeping track of loaded modules
- networking functions (with nonblocking connects, IPv6 support)
- handles connecting to servers
- raw logging of server's input/output data
- /EVAL support
- fgets() like function line_split() without any maximum line limits
- command line parameter handling
- miscellaneous useful little functions
- handles logging
** COMMON UI module
- knows basics about windows and window items (=channels, queries, ..)
- printtext() - parsing texts and feeding it for GUI to print.
- themes
- translation tables
- text hilighting
- command history
- user interface (/commands) for CORE's functionality
** GUI modules
- all the rest of the functionality needed for a working client.
** IRC module
* CORE
- IRC specific /commands
- flood protecting commands sent to server
- creating IRC masks based on nick/address for bans, ignores, etc.
- keeps list of channels, nicks, channel modes, bans, etc.
- keeps list of servers, server settings, irc networks,
server reconnections and irc network splits
- redirection of commands' replies
- lag detection
- ctcp support and flood protection
- Handles ignoring people
* DCC
- DCC chat, send and get
* FLOOD
- detects private or channel flooding and sends "flood" signal
- automatic ignoring when flooding
* NOTIFYLIST
- handles notifylist
** IRC UI module
- placing channels and queries in windows
- nick completion
- printing infomation of some events

19
docs/formats.txt Normal file
View File

@ -0,0 +1,19 @@
text text background
---------------------------------------------------------------------
%k %K %0 black bold black black
%r %R %1 red bold red red
%g %G %2 green bold green green
%y %Y %3 yellow bold yellow yellow
%b %B %4 blue bold blue blue
%m %M %5 magenta bold magenta magenta
%p %P magenta (think: purple)
%c %C %6 cyan bold cyan cyan
%w %W %7 white bold white white
%n All colors turned off
%U Underline on/off
%8 Reverse on/off
%9 %_ Bold on/off
%: Insert newline
%| Marks the indentation position
%% A single %

621
docs/perl.txt Normal file
View File

@ -0,0 +1,621 @@
Running Perl scripts
--------------------
Place new scripts to ~/.irssi/scripts/, or /usr/lib/irssi/scripts/
directory and run then with /RUN script. Or you could also run the
script from another place by specifying the whole path to it. 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. Also, Irssi doesn't check if you run the same script twice or
different scripts use signal_add() for the same named function - it will
probably crash or do some weird things then.
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
"server incoming" signal with the raw line as it's first parameter. You
probably don't want to use this signal. Next thing Irssi does is to
interpret the header and send a "server event" signal with arguments
"PRIVMSG you...", server, "nick", "user@there.org". You probably don't
want to use this either, since next irssi will send an "event privmsg"
signal with the "you :blahblah" as it's argument. 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 returning from the function with value 1.
For example:
--------------------------------------------------------
sub event_privmsg {
# $data = "nick/#channel :text"
my ($data, $server, $nick, $address) = @_;
my ($target, $text) = $data =~ /^(\S*)\s:(.*)/;
return 1 if ($text =~ /free.*porn/);
return 1 if ($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".
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 file.
Message levels
--------------
Several functions expect message levels. Sometimes numeric and sometimes
alphabetic. Yes, it's stupid, will fix it :) For now you can use
Irssi::level2bits() function to convert the level string to numeric. Here's
all the levels that irssi supports currently:
CRAP, MSGS, PUBLIC, NOTICES, SNOTES, CTCPS, ACTIONS, JOINS, PARTS
QUITS, KICKS, MODES, SMODES, TOPICS, WALLOPS, INVITES, NICKS, PONGS
DCC, CLIENTNOTICE, CLIENTCRAP, CLIENTERROR, HILIGHT
(and NOHILIGHT if you don't want the message to be hilighted ever..)
For example:
$server->printtext("#channel", Irssi::level2bits('clientcrap'), 'Hello, world');
Writes text to #channel window with clientcrap level.
Functions that you can use in Irssi's Perl scripts
--------------------------------------------------
This is just my very first implementation and things will probably change.
Commands marked with (!!) mean that you shouldn't use it unless you
know what you're doing..
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();
*** General
Channel cur_channel() - return current channel
Server cur_server() - return current server
channels() - return list of all channels
servers() - return list of all servers
commands() - return list of all commands
dccs() - return list of all dcc connections
logs() - return list of all log files
plugins() - return list of all plugins
print(str)
Print `str' to current window as "Irssi notice".
command(cmd, [Server server, [Channel channel]])
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.
Server::command(cmd, [Channel channel])
Just like above, except different calling method.
Channel::command(cmd)
Just like above, except different calling method.
Server::printtext(channel, level, str)
Print `str'.
setup_get(option)
Get value of `option' from setup and return it.
*** 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.
*** Signals / timeouts
signal_emit(signal, ...)
Send signal `signal'
signal_add(signal, func)
Bind `signal' to function `func'
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'
tag 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.
*** Commands
Command::values()
Get some information about command. This function returns a reference to
hash table. Hash table has keys:
"cmd" - Command
"category" - Category
command_bind(cmd, category, func)
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.
Server::irc_send_cmd_split(cmd, arg, max_nicks)
Split the `cmd' into several commands so `arg' argument has only
`max_nicks' number of nicks.
Example: $server->irc_send_cmd_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 Connects
This is a record where we keep connection information. All Servers and
Reconnects records have pointer to one of these.
Connect::values()
Get some information about connect. This function returns a reference to
hash table. Hash table has keys:
"address" - Address where we connected (irc.blah.org)
"port" - Port where we connected
"password" - Password we used in connection.
"ircnet" - IRC network
"wanted_nick" - Nick which we would prefer to use
"alternate_nick" - Alternate 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::values()
Get some information about server. This function returns a reference to
hash table. Hash table has keys:
"address" - Address where we connected (irc.blah.org)
"port" - Port where we connected
"password" - Password we used in connection.
"ircnet" - IRC network
"wanted_nick" - Nick which we would prefer to use
"alternate_nick" - Alternate nick which we would prefer to use
"username" - User name
"realname" - Real name
"tag" - Unique server tag.
"real_address" - Who the server thinks it is (irc1.blah.org)
"nick" - Current nick
"usermode" - Current user mode
"usermode_away" - Are we marked as away? 1|0
"away_reason" - Away reason
"connected" - Is connection finished? 1|0
"connection_lost" - Did we lose the connection (1) or was
the connection meant to be disconnected (0)
Example:
%server_info = %{Irssi::cur_server->values()};
Irssi::print("Current server = ".$server_info{'address'});
Server Connect::connect()
Connect to server.
Server::disconnect()
Disconnect from server.
Server server_find_tag(tag)
Find server with tag
Server server_find_ircnet(ircnet)
Find first server that is in `ircnet'
Channel channel_find(channel)
Find `channel' from any server
Channel Server::channel_find_level(level)
Find channel with level `level' preferably from specified server, but
fallbacks to any channel the matching level.
Server::send_raw(cmd)
Send raw message to server, it will be flood protected so you
don't need to worry about it.
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.
*** 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 can'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" 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..
group 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.
*** IRC masks
irc_mask_match(mask, nick, user, host)
Return 1 if `mask' matches nick!user@host.
irc_mask_match_address(mask, nick, address)
Return 1 if `mask' matches nick!address.
irc_masks_match(masks, nick, address)
Return 1 if any mask in the `masks' (string separated with spaces)
matches nick!address.
irc_get_mask(nick, host, flags)
Create IRC mask from nick!host.
flags = you need to combine these:
(FIXME: export the IRC_xxx defines to perl (or something))
IRC_MASK_NICK 0x01
IRC_MASK_USER 0x02
IRC_MASK_HOST 0x04
IRC_MASK_DOMAIN 0x08
*** Channels
Channel::values()
Get some information about channel. This function returns a reference to
hash table. Hash table has keys:
"server" - Server of the channel
"name" - Channel name
"type" - Channel type ("channel", "query", "dcc chat", "empty")
"topic" - Channel topic
"key" - Channel key (password)
"limit" - Max. users in channel (+l mode)
"level" - Channel's level number.
"new_data" - 0=no new data, 1=text, 2=msg, 3=msg for you
"synced" - Channel is synchronized
"wholist" - Channel has received /WHO list
"names_got" - Channel has received /NAMES list
"chanop" - You are channel operator
"left" - You just left the channel (for "channel destroyed" event)
"kicked" - You was just kicked out of the channel (for
"channel destroyed" event)
Channel Server::channel_create(channel, type, automatic)
Create new channel with name `channel'. `type' is one of:
(FIXME: export these to perl somehow)
CHANNEL_TYPE_CHANNEL 0
CHANNEL_TYPE_QUERY 1
CHANNEL_TYPE_DCC_CHAT 2
CHANNEL_TYPE_EMPTY 3
`automatic' means that channel is created "automatically" and
Irssi will NOT change the active window to it.
Channel::destroy()
Destroy channel.
Channel::change_name(name)
Change channel's name
Channel::get_mode()
Return channel's mode
Channel Server::channel_find(channel)
Find `channel' in server.
Channel Server::channel_find_closest(channel, level)
Find `channel' or if not found, some other channel that has
level `level' (number).
Channel channel_find_level(level)
Find channel with level `level'.
*** Channel modes
Ban::values()
Get some information about ban. This function returns a reference to
hash table. Hash table has keys:
"ban" - The ban
"setby" - Nick of who set the ban
"time" - Timestamp when ban was set
Ban Channel::ban_add(ban, nick, time)
Add new ban. (!!)
Channel::ban_remove(ban)
Remove ban. (!!)
Ban Channel::ban_exception_add(ban, nick, time)
Add ban exception (!!)
Channel::ban_exception_remove(ban)
Remove ban exception (!!)
Channel::invitelist_add(mask)
Add invite (!!)
Channel::invitelist_remove(mask)
Remove invite (!!)
Channel::modes_parse_channel(setby, modestr)
Parse mode string (!!)
Channel::ban_get_mask(nick)
Get ban mask for `nick'.
Channel::modes_set(data, mode)
Set mode `mode' ("+o", "-o", etc.) to all nicks in `data'
separated with spaces.
*** Nick list
Nick::values()
Get some information about nick. This function returns a reference to
hash table. Hash table has keys:
"nick" - Plain nick
"host" - Host (blah@there.org)
"name" - Real name
"hops" - Hop count to the server nick is using
"op", "voice", "gone", "ircop" - 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::nicklist_insert(nick, op, voice, send_massjoin)
Add nick to nicklist. (!!)
Channel::nicklist_remove(nick)
Remove nick from nicklist. (!!)
Nick Channel::nicklist_find(mask)
Find nick from nicklist.
Channel::nicklist_getnicks(channel)
Return a list of all nicks (Nick packages) in channel.
*** DCC
Dcc:destroy()
Destroy DCC connection. (!!)
dcc_type2str(type)
DCC type number to string
dcc_str2type(type)
DCC type string to number
Dcc dcc_find_item(type, nick, arg)
Find DCC connection.
Dcc dcc_find_by_port(nick, port)
Find DCC connection by port.
*** Reconnects
Reconnect::values()
Get some information about reconnect. This function returns a reference to
hash table. Hash table has keys:
"tag" - Unique numeric tag
"next_connect" - Unix time stamp when the next connection occurs
"address" - Address where we connected (irc.blah.org)
"port" - Port where we connected
"password" - Password we used in connection.
"ircnet" - IRC network
"wanted_nick" - Nick which we would prefer to use
"alternate_nick" - Alternate nick which we would prefer to use
"username" - User name
"realname" - Real name
*** Netsplits
Netsplit::values()
Get some information about netsplit. This function returns a reference to
hash table. Hash table has keys:
"nick" - Nick
"address" - Nick's host
"server" - The server nick was in
"destserver" - The other server where split occured.
"destroy" - Timestamp when this record should be destroyed
/*FIXME: add list of channels the nick was in;*/
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_add(nick, ircnet)
Add `nick' to notify list in irc network `ircnet'
Server notifylist_ison(nick, ircnets)
Check if `nick' is in IRC. `ircnets' is a space separated
list of irc networks. If it's empty string, all servers will be checked.
Server::notifylist_ison_server(nick)
Check if `nick' is on IRC server.
*** Rawlog
Server::rawlog_input(str)
Send `str' to raw log as input text. (!!)
Server::rawlog_output(str)
Send `str' to raw log as output text. (!!)
Server::rawlog_redirect(str)
Send `str' to raw log as redirection text. (!!)
*** Ignores
Autoignore::values()
Get some information about autoignore. This function returns a reference to
hash table. Hash table has keys:
"nick" - Ignored nick
"timeleft" - Seconds left to ignore
"level" - Ignoring level number
ignore_add(mask, level)
Ignore `mask' with level string
ignore_remove(mask, level)
Unignore level string from `mask'
Server::ignore_check(nick, host, type)
Return 1 if nick!host is ignored with level number `type'.
Server::autoignore_add(type, nick)
Autoignore `nick' in server with level number `type'.
Server::autoignore_remove(mask, level)
Remove autoignoring `nick' from server. `level' is a string.
*** Logging
Log::values()
Get some information about log. This function returns a reference to
hash table. Hash table has keys:
"fname" - Log file name
"autoopen_log" - Automatically open log at startup
"last" - Timestamp when last write occured.
"level" - Global logging level.
/*FIXME: add list of Logitems;*/
Logitem::values()
Get some information about logitem. This function returns a reference to
hash table. Hash table has keys:
"name" - Log item name.
"level" - Logging level number.
Log log_create(fname, data)
Create log file. `data' = logging level ("-all #channel +public")
Log log_create_with_level(fname, level)
Create log file with level number.
Log log_file_find(fname)
Find log file.
Log::destroy()
Destroy log file
Log::open()
Start logging
Log::close()
Stop logging
Log::append_item(name, level)
Append log item with level number `level' to log file. (!!)
Log::remove_item(log, name)
Remove log item. (!!)
*** Plugins
Plugin::values()
Get some information about plugin. This function returns a reference to
hash table. Hash table has keys:
"name" - Plugin name
"description" - Plugin description
plugin_load(name, args)
Load plugin.
plugin_get_description(name)
Get plugin description string.
Plugin plugin_find(name)
Find plugin.

222
docs/signals.txt Normal file
View File

@ -0,0 +1,222 @@
IRC base
--------
* Requires to work properly:
"gui exit"
"gui channel open", CHANNEL_REC
"send command", char *command, SERVER_REC, CHANNEL_REC
* Provides signals:
irc.c:
"send command", char *args, SERVER_REC
"command "<cmd>, char *args, SERVER_REC, CHANNEL_REC
"default command", char *args, SERVER_REC, CHANNEL_REC
"server event", char *data, SERVER_REC, char *sender_nick, char *sender_address
"event "<cmd>, char *args, SERVER_REC, char *sender_nick, char *sender_address
"default event", char *data, SERVER_REC, char *sender_nick, char *sender_address
"server incoming", SERVER_REC, char *data
(for perl parser..)
"redir "<cmd>, char *args, SERVER_REC, char *sender_nick, char *sender_address
bans.c:
"ban new", BAN_REC
"ban remove", BAN_REC
"ban exception new", BAN_REC
"ban exception remove", BAN_REC
"ban type changed", char *bantype
commands.c:
"commandlist new", COMMAND_REC
"commandlist remove", COMMAND_REC
channels.c:
"channel created", CHANNEL_REC
"channel destroyed", CHANNEL_REC
"channel name changed", CHANNEL_REC
"channel topic changed", CHANNEL_REC
"channel server changed", CHANNEL_REC, SERVER_REC *oldserver
"channel query", CHANNEL_REC
"channel wholist", CHANNEL_REC
"channel sync", CHANNEL_REC
ctcp.c:
"ctcp msg "<cmd>, char *args, SERVER_REC, char *nick, char *addr, char *target
"default ctcp msg", char *args, SERVER_REC, char *nick, char *addr, char *target
"ctcp reply "<cmd>, char *args, SERVER_REC, char *nick, char *addr, char *target
"default ctcp reply", char *args, SERVER_REC, char *nick, char *addr, char *target
lag.c:
"server lag", SERVER_REC
"server lag disconnect", SERVER_REC
"lag", char *server, int lag
modes.c:
"invitelist new", CHANNEL_REC, char *mask
"invitelist remove", CHANNEL_REC, char *mask
"channel mode changed", CHANNEL_REC
"user mode changed", SERVER_REC
"nick mode changed", CHANNEL_REC, NICK_REC
netsplit.c:
"netsplit add", NETSPLIT_REC
"netsplit remove", NETSPLIT_REC
nicklist.c:
"nicklist new", CHANNEL_REC, NICK_REC
"nicklist remove", CHANNEL_REC, NICK_REC
"nicklist changed", CHANNEL_REC, NICK_REC, char *oldnick
"nick gone changed", CHANNEL_REC, NICK_REC
"nick ircop changed", CHANNEL_REC, NICK_REC
"server nick changed", SERVER_REC
"massjoin", CHANNEL_REC, GSList of NICK_RECs
rawlog.c:
"rawlog", SERVER_REC, char *data
server.c:
"server connect failed", SERVER_REC
"server connected", SERVER_REC
"server connecting", SERVER_REC, ulong *ip
"server looking", SERVER_REC
"server disconnected", SERVER_REC
"event connected", SERVER_REC
server-reconnect.c:
"server reconnect new", RECONNECT_REC
"server reconnect remove", RECONNECT_REC
"server reconnect not found", char *tag
signal.c:
"signal", char *name, ...
"last signal", char *name, ...
IRC extra
---------
* Requires to work properly:
"print text stripped", SERVER_REC, char *channel, int level, char *text
"plugin add menu", char *menuitem, void (*func) (gpointer, PLUGIN_REC), PLUGIN_REC
* Provides signals:
dcc.c:
"dcc ctcp "<cmd>, char *args, DCC_REC
"default dcc ctcp", char *args, DCC_REC
"dcc unknown ctcp", char *args, char *sender, char *sendaddr
"dcc reply "<cmd>, char *args, DCC_REC
"default dcc reply", char *args, DCC_REC
"dcc unknown reply", char *args, char *sender, char *sendaddr
"dcc chat message", DCC_REC, char *msg
"dcc created", DCC_REC
"dcc destroyed", DCC_REC
"dcc connected", DCC_REC
"dcc rejecting", DCC_REC
"dcc closed", DCC_REC
"dcc chat message", DCC_REC, char *msg
"dcc transfer update", DCC_REC
"dcc request", DCC_REC
"dcc get receive", DCC_REC
"dcc error connect", DCC_REC
"dcc error file create", DCC_REC, char *filename
"dcc error file not found", char *nick, char *filename
"dcc error get not found", char *nick
"dcc error send exists", char *nick, char *filename
"dcc error unknown type", char *type
"dcc error close not found", char *type, char *nick, char *filename
flood.c:
"flood", SERVER_REC, char *nick, char *host, char *level, char *target
ignore.c:
"autoignore new", SERVER_REC, AUTOIGNORE_REC
"autoignore remove", SERVER_REC, AUTOIGNORE_REC
log.c:
"log new", LOG_REC
"log remove", LOG_REC
"log locked", LOG_REC
"log started", LOG_REC
"log stopped", LOG_REC
"log written", LOG_REC, char *line
notifylist.c:
"notifylist new", NOTIFYLIST_REC
"notifylist remove", NOTIFYLIST_REC
"notifylist joined", SERVER_REC, char *nick, char *user, char *host, char *realname, char *awaymsg
"notifylist away changed", SERVER_REC, char *nick, char *user, char *host, char *realname, char *awaymsg
"notifylist unidle", SERVER_REC, char *nick, char *user, char *host, char *realname, char *awaymsg
"notifylist left", SERVER_REC, char *nick, char *user, char *host, char *realname, char *awaymsg
plugins.c:
"plugin created", PLUGIN_REC
"plugin loaded", PLUGIN_REC
"plugin destroyed", PLUGIN_REC
"plugin error already loaded", char *plugin
"plugin error invalid", char *plugin
"plugin error load", char *plugin, char *error
"plugin error not loaded", char *plugin
"plugin error version", char *plugin
UI common
---------
* Requires to work properly:
"gui print text", CHANNEL_REC, int fg, int bg, int flags, char *text
"gui window goto", int number
* Can be used to determine when all "gui print text"s are sent (not required)
"print text finished", CHANNEL_REC
* Provides signals:
ui-keyboard.c:
"keyinfo created", KEYINFO_REC
"keyinfo destroyed", KEYINFO_REC
ui-printtext.c:
"print text", SERVER_REC, char *channel, int level, char *text
"print text stripped", SERVER_REC, char *channel, int level, char *text
ui-themes.c:
"theme created", THEME_REC
"theme destroyed", THEME_REC
ui-windows.c:
"window created", WINDOW_REC
"window destroyed", WINDOW_REC

99
docs/special_vars.txt Normal file
View File

@ -0,0 +1,99 @@
NOTE: This is just a slightly modified file taken from EPIC's help.
'!' at start of the line means that the feature doesn't work yet..
Special Variables and Expandos
Irssi supports a number of reserved, dynamic variables, sometimes
referred to as expandos. They are special in that the client is
constantly updating their values automatically. There are also
numerous variable modifiers available.
Modifier Description
$variable A normal variable, expanding to the first match of:
| 1) an internal SET variable
| 2) an environment variable
$[num]variable Expands to the variables value, with 'num' width. If
| the number is negative, the value is right-aligned.
| The value is padded to meet the width with the
| character given after number (default is space).
| The value is truncated to specified width unless
| '!' character precedes the number.
$#variable Expands to the number of words in $variable. If $variable
| is omitted, it assumes $*
$@variable Expands to the number of characters in $variable. if
| $variable is omitted, it assumes $*
$($subvariable) This is somewhat similar to a pointer, in that the
| value of $subvar is taken as the name of the
| variable to expand to. Nesting is allowed.
${expression} Permits the value to be embedded in another string
| unambiguously.
$!history! Expands to a matching entry in the client's command
| history, wildcards allowed.
Whenever an alias is called, these expandos are set to the arguments passed
to it. If none of these expandos are used in the alias, or the $() form
shown above, any arguments passed will automatically be appended to the last
command in the alias.
Expando Description
$* expands to all arguments passed to an alias
$n expands to argument 'n' passed to an alias (counting from zero)
$n-m expands to arguments 'n' through 'm' passed to an alias
$n- expands to all arguments from 'n' on passed to an alias
$-m expands to all arguments up to 'm' passed to an alias
$~ expands to the last argument passed to an alias
These variables are set and updated dynamically by the client. The case of
$A .. $Z is important.
Variable Description
$, last person who sent you a MSG
$. last person to whom you sent a MSG
$: last person to join a channel you are on
$; last person to send a public message to a channel you are on
$A text of your AWAY message, if any
$B body of last MSG you sent
$C current channel
$D last person that NOTIFY detected a signon for
$E idle time
$F time client was started, $time() format
$H current server numeric being processed
$I channel you were last INVITEd to
$J client version text string
$K current value of CMDCHARS
$L current contents of the input line
$M modes of current channel, if any
$N current nickname
$O value of STATUS_OPER if you are an irc operator
$P if you are a channel operator in $C, expands to a '@'
$Q nickname of whomever you are QUERYing
$R version of current server
$S current server name
$T target of current input (channel or QUERY nickname)
! $U value of cutbuffer
$V client release date (numeric version string)
$W current working directory
$X your /userhost $N address (user@host)
$Y value of REALNAME
$Z time of day (hh:mm)
$$ a literal '$'
For example, assume you have the following alias:
alias blah msg $D Hi there!
If /blah is passed any arguments, they will automatically be appended to the
MSG text. For example:
/blah oops /* command as entered */
"Hi there! oops" /* text sent to $D */
Another useful form is ${}. In general, variables can be embedded inside
strings without problems, assuming the surrounding text could not be
misinterpreted as part of the variable name. This form guarantees that
surrounding text will not affect the expression's return value.
/eval echo foo$Nfoo /* breaks, looks for $nfoo */
/eval echo foo${N}foo /* ${N} returns current nickname */
fooYourNickfoo /* returned by above command */