|
Hopefully, this page is exactly what you are looking for, but if not, you can always find further assistance on Unix/Linux Forum!
Mail::SpamAssassin::PlUser(Contributed Perl DocumMail::SpamAssassin::Plugin(3)
NAME
Mail::SpamAssassin::Plugin - SpamAssassin plugin base class
SYNOPSIS
SpamAssassin configuration:
loadplugin MyPlugin /path/to/myplugin.pm
Perl code:
package MyPlugin;
use Mail::SpamAssassin::Plugin;
our @ISA = qw(Mail::SpamAssassin::Plugin);
sub new {
my ($class, $mailsa) = @_;
# the usual perlobj boilerplate to create a subclass object
$class = ref($class) ││ $class;
my $self = $class->SUPER::new($mailsa);
bless ($self, $class);
# then register an eval rule, if desired...
$self->register_eval_rule ("check_for_foo");
# and return the new plugin object
return $self;
}
...methods...
1;
DESCRIPTION
This is the base class for SpamAssassin plugins; all plugins must be
objects that implement this class.
This class provides no-op stub methods for all the callbacks that a
plugin can receive. It is expected that your plugin will override one
or more of these stubs to perform its actions.
SpamAssassin implements a plugin chain; each callback event is passed
to each of the registered plugin objects in turn. Any plugin can call
"$self->inhibit_further_callbacks()" to block delivery of that event to
later plugins in the chain. This is useful if the plugin has handled
the event, and there will be no need for later plugins to handle it as
well.
If you're looking to write a simple eval rule, skip straight to "regis-
ter_eval_rule()", below.
INTERFACE
In all the plugin APIs below, "options" refers to a reference to a hash
containing name-value pairs. This is used to ensure future-compati-
bility, in that we can add new options in future without affecting
objects built to an earlier version of the API.
For example, here would be how to print out the "line" item in a
"parse_config()" method:
sub parse_config {
my ($self, $opts) = @_;
print "MyPlugin: parse_config got ".$opts->{line}."\n";
}
METHODS
The following methods can be overridden by subclasses to handle events
that SpamAssassin will call back to:
$plugin = MyPluginClass->new ($mailsaobject)
Constructor. Plugins that need to register themselves will need to
define their own; the default super-class constructor will work
fine for plugins that just override a method.
Note that subclasses must provide the $mailsaobject to the super-
class constructor, like so:
my $self = $class->SUPER::new($mailsaobject);
Lifecycle note: plugins that will need to store per-scan state
should not store that on the Plugin object; see "check_start()"
below. It is also likewise recommended that configuration settings
be stored on the Conf object; see "parse_config()".
$plugin->parse_config ( { options ... } )
Parse a configuration line that hasn't already been handled.
"options" is a reference to a hash containing these options:
line
The line of configuration text to parse. This has leading and
trailing whitespace, and comments, removed.
key The configuration key; ie. the first "word" on the line.
value
The configuration value; everything after the first "word" and
any whitespace after that.
conf
The "Mail::SpamAssassin::Conf" object on which the configura-
tion data should be stored.
user_config
A boolean: 1 if reading a user's configuration, 0 if reading
the system-wide configuration files.
If the configuration line was a setting that is handled by this
plugin, the method implementation should call "$self->inhibit_fur-
ther_callbacks()".
If the setting is not handled by this plugin, the method should
return 0 so that a later plugin may handle it, or so that SpamAs-
sassin can output a warning message to the user if no plugin under-
stands it.
Lifecycle note: it is suggested that configuration be stored on the
"Mail::SpamAssassin::Conf" object in use, instead of the plugin
object itself. That can be found as "$plugin->{main}->{conf}".
This allows per-user and system-wide configuration to be dealt with
correctly, with per-user overriding system-wide.
$plugin->finish_parsing_end ( { options ... } )
Signals that the configuration parsing has just finished, and Spa-
mAssassin is nearly ready to check messages.
"options" is a reference to a hash containing these options:
conf
The "Mail::SpamAssassin::Conf" object on which the configura-
tion data should be stored.
Note: there are no guarantees that the internal data structures of
SpamAssassin will not change from release to release. In particu-
lar to this plugin hook, if you modify the rules data structures in
a third-party plugin, all bets are off until such time that an API
is present for modifying that configuration data.
$plugin->signal_user_changed ( { options ... } )
Signals that the current user has changed for a new one.
username
The new user's username.
user_dir
The new user's home directory. (equivalent to "~".)
userstate_dir
The new user's storage directory. (equivalent to "~/.spamassas-
sin".)
$plugin->services_authorized_for_username ( { options ... } )
Validates that a given username is authorized to use certain ser-
vices.
In order to authorize a user, the plugin should first check that it
can handle any of the services passed into the method and then set
the value for each allowed service to true (or any non-negative
value).
The current supported services are: bayessql
username
A username
services
Reference to a hash containing the services you want to check.
{
'bayessql' => 0
}
conf
The "Mail::SpamAssassin::Conf" object on which the configura-
tion data should be stored.
$plugin->check_start ( { options ... } )
Signals that a message check operation is starting.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
Lifecycle note: it is recommended that rules that need to track
test state on a per-scan basis should store that state on this
object, not on the plugin object itself, since the plugin
object will be shared between all active scanners.
The message being scanned is accessible through the "$perms-
gstatus->get_message()" API; there are a number of other public
APIs on that object, too. See "Mail::SpamAssassin::PerMsgSta-
tus" perldoc.
$plugin->extract_metadata ( { options ... } )
Signals that a message is being mined for metadata. Some plugins
may wish to add their own metadata as well.
msg The "Mail::SpamAssassin::Message" object for this message.
$plugin->parsed_metadata ( { options ... } )
Signals that a message's metadata has been parsed, and can now be
accessed by the plugin.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->check_tick ( { options ... } )
Called periodically during a message check operation. A callback
set for this method is a good place to run through an event loop
dealing with network events triggered in a "parse_metadata" method,
for example.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->check_post_dnsbl ( { options ... } )
Called after the DNSBL results have been harvested. This is a good
place to harvest your own asynchronously-started network lookups.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->check_post_learn ( { options ... } )
Called after auto-learning may (or may not) have taken place. If
you wish to perform additional learning, whether or not auto-learn-
ing happens, this is the place to do it.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->check_end ( { options ... } )
Signals that a message check operation has just finished, and the
results are about to be returned to the caller.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan. The current score, names of rules that hit, etc. can be
retrieved using the public APIs on this object.
$plugin->autolearn_discriminator ( { options ... } )
Control whether a just-scanned message should be learned as either
spam or ham. This method should return one of 1 to learn the mes-
sage as spam, 0 to learn as ham, or "undef" to not learn from the
message at all.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->autolearn ( { options ... } )
Signals that a message is about to be auto-learned as either ham or
spam.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
isspam
1 if the message is spam, 0 if ham.
$plugin->per_msg_finish ( { options ... } )
Signals that a "Mail::SpamAssassin::PerMsgStatus" object is being
destroyed, and any per-scan context held on that object by this
plugin should be destroyed as well.
Normally, any member variables on the "PerMsgStatus" object will be
cleaned up automatically -- but if your plugin has made a circular
reference on that object, this is the place to break them so that
garbage collection can operate correctly.
permsgstatus
The "Mail::SpamAssassin::PerMsgStatus" context object for this
scan.
$plugin->bayes_learn ( { options ... } )
Called at the end of a bayes learn operation.
This phase is the best place to map the raw (original) token value
to the SHA1 hashed value.
toksref
Reference to hash returned by call to tokenize. The hash takes
the format of:
{
'SHA1 Hash Value' => 'raw (original) value'
}
NOTE: This data structure has changed since it was originally
introduced in version 3.0.0. The values are no longer perl
anonymous hashes, they are a single string containing the raw
token value. You can test for backwards compatability by
checking to see if the value for a key is a reference to a perl
HASH, for instance:
if (ref($toksref->{$sometokenkey}) eq 'HASH') {...
If it is, then you are using the old interface, otherwise you
are using the current interface.
isspam
Boolean value stating what flavor of message the tokens repre-
sent, if true then message was specified as spam, false is non-
spam. Note, when function is scan then isspam value is not
valid.
msgid
Generated message id of the message just learned.
msgatime
Received date of the current message or current time if
received date could not be determined. In addition, if the
receive date is more than 24 hrs into the future it will be
reset to current datetime.
$plugin->bayes_forget ( { options ... } )
Called at the end of a bayes forget operation.
toksref
Reference to hash returned by call to tokenize. See
bayes_learn documentation for additional information on the
format.
isspam
Boolean value stating what flavor of message the tokens repre-
sent, if true then message was specified as spam, false is non-
spam. Note, when function is scan then isspam value is not
valid.
msgid
Generated message id of the message just forgotten.
$plugin->bayes_scan ( { options ... } )
Called at the end of a bayes scan operation. NOTE: Will not be
called in case of error or if the message is otherwise skipped.
toksref
Reference to hash returned by call to tokenize. See
bayes_learn documentation for additional information on the
format.
probsref
Reference to hash of calculated probabilities for tokens found
in the database.
{
'SHA1 Hash Value' => {
'prob' => 'calculated probability',
'spam_count' => 'Total number of spam msgs w/ token',
'ham_count' => 'Total number of ham msgs w/ token',
'atime' => 'Atime value for token in database'
}
}
score
Score calculated for this particular message.
msgatime
Calculated atime of the message just learned, note it may have
been adjusted if it was determined to be too far into the
future.
significant_tokens
Array ref of the tokens found to be significant in determining
the score for this message.
$plugin->plugin_report ( { options ... } )
Called if the message is to be reported as spam. If the reporting
system is available, the variable
"$options-<gt"{report}-><gt>report_available}> should be set to 1;
if the reporting system successfully reported the message, the
variable "$options-<gt"{report}-><gt>report_return}> should be set
to 1.
report
Reference to the Reporter object ("$options-<gt"{report}> in
the paragraph above.)
text
Reference to a markup removed copy of the message in scalar
string format.
msg Reference to the original message object.
$plugin->plugin_revoke ( { options ... } )
Called if the message is to be reported as ham (revokes a spam
report). If the reporting system is available, the variable
"$options-<gt"{revoke}-><gt>revoke_available}> should be set to 1;
if the reporting system successfully revoked the message, the vari-
able "$options-<gt"{revoke}-><gt>revoke_return}> should be set to
1.
revoke
Reference to the Reporter object ("$options-<gt"{revoke}> in
the paragraph above.)
text
Reference to a markup removed copy of the message in scalar
string format.
msg Reference to the original message object.
$plugin->whitelist_address( { options ... } )
Called when a request is made to add an address to a persistent
address list.
address
Address you wish to add.
$plugin->blacklist_address( { options ... } )
Called when a request is made to add an address to a persistent
address list.
address
Address you wish to add.
$plugin->remove_address( { options ... } )
Called when a request is made to remove an address to a persistent
address list.
address
Address you wish to remove.
$plugin->spamd_child_init ()
Called when a new child starts up under spamd.
$plugin->spamd_child_post_connection_close ()
Called when child returns from handling a connection.
If there was an accept failure, the child will die and this code
will not be called.
$plugin->finish ()
Called when the "Mail::SpamAssassin" object is destroyed.
HELPER APIS
These methods provide an API for plugins to register themselves to
receive specific events, or control the callback chain behaviour.
$plugin->register_eval_rule ($nameofevalsub)
Plugins that implement an eval test will need to call this, so that
SpamAssassin calls into the object when that eval test is encoun-
tered. See the REGISTERING EVAL RULES section for full details.
$plugin->inhibit_further_callbacks()
Tells the plugin handler to inhibit calling into other plugins in
the plugin chain for the current callback. Frequently used when
parsing configuration settings using "parse_config()".
dbg($message)
Output a debugging message $message, if the SpamAssassin object is
running with debugging turned on.
NOTE: This function is not available in the package namespace of
general plugins and can't be called via $self->dbg(). If a plugin
wishes to output debug information, it should call "Mail::SpamAs-
sassin::Plugin::dbg($msg)".
info($message)
Output an informational message $message, if the SpamAssassin
object is running with informational messages turned on.
NOTE: This function is not available in the package namespace of
general plugins and can't be called via $self->dbg(). If a plugin
wishes to output debug information, it should call "Mail::SpamAs-
sassin::Plugin::dbg($msg)".
REGISTERING EVAL RULES
Plugins that implement an eval test must register the methods that can
be called from rules in the configuration files, in the plugin class'
constructor.
For example,
$plugin->register_eval_rule ('check_for_foo')
will cause "$plugin->check_for_foo()" to be called for this SpamAssas-
sin rule:
header FOO_RULE eval:check_for_foo()
Note that eval rules are passed the following arguments:
- The plugin object itself
- The "Mail::SpamAssassin::PerMsgStatus" object calling the rule
- standard arguments for the rule type in use
- any and all arguments as specified in the configuration file
In other words, the eval test method should look something like this:
sub check_for_foo {
my ($self, $permsgstatus, ...arguments...) = @_;
...code returning 0 or 1
}
Note that the headers can be accessed using the "get()" method on the
"Mail::SpamAssassin::PerMsgStatus" object, and the body by
"get_decoded_stripped_body_text_array()" and other similar methods.
Similarly, the "Mail::SpamAssassin::Conf" object holding the current
configuration may be accessed through "$permsgstatus->{main}->{conf}".
The eval rule should return 1 for a hit, or 0 if the rule is not hit.
State for a single message being scanned should be stored on the
$checker object, not on the $self object, since $self persists between
scan operations. See the 'lifecycle note' on the "check_start()"
method above.
STANDARD ARGUMENTS FOR RULE TYPES
Plugins will be called with the same arguments as a standard EvalTest.
Different rule types receive different information by default:
- header tests: no extra arguments
- body tests: fully rendered message as array reference
- rawbody tests: fully decoded message as array reference
- full tests: pristine message as scalar reference
The configuration file arguments will be passed in after the standard
arguments.
SEE ALSO
"Mail::SpamAssassin"
"Mail::SpamAssassin::PerMsgStatus"
http://wiki.apache.org/spamassassin/PluginWritingTips
http://issues.apache.org/SpamAssassin/show_bug.cgi?id=2163
perl v5.8.8 2006-08-29 Mail::SpamAssassin::Plugin(3)
Man(1) output converted with
man2html and wrapped by fishsponge
This page was generated on Sat Sep 8 16:37:42 GMT 2007
|
Your favourite pages:
No pages logged yet.
Trying to save cookie... Top 10 most popular pages:
svn man page (6162 hits)
(FreeBSD 6.2)
sqlite3 man page (5598 hits)
(openSUSE 10.2)
adv_cap_autoneg man page (5045 hits)
(Solaris 10 11_06)
CPAN man page (4791 hits)
(Suse Linux 10.1)
ssh man page (4439 hits)
(Suse Linux 10.1)
ssh-socks5-proxy-connect man page (3525 hits)
(Solaris 10 11_06)
signal man page (3395 hits)
(Suse Linux 10.1)
netcat man page (3377 hits)
(Suse Linux 10.1)
pprosetup man page (2886 hits)
(Solaris 10 11_06)
startproc man page (2738 hits)
(Suse Linux 10.1)
|
Man Pages 
