NAME

Mail::SpamAssassin::Plugin - SpamAssassin plugin base class

SYNOPSIS

loadplugin MyPlugin /path/to/myplugin.pm

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 register_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-compatibility, 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.

$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 superclass 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; instead this should be stored on the PerMsgStatus 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:

$plugin->finish_parsing_start ( { options ... } )

Signals that the system-wide configuration has been completely read, but internal data structures are not yet created. It is possible to use this hook to dynamically change the configuration already read in or add new config options.

"options" is a reference to a hash containing these options:

$plugin->finish_parsing_end ( { options ... } )

Signals that the system-wide configuration parsing has just finished, and SpamAssassin is nearly ready to check messages.

"options" is a reference to a hash containing these options:

$plugin->user_conf_parsing_start ( { options ... } )

Signals that the per-user configuration has been completely read, but not converted to internal data structures. It is possible to use this hook to dynamically change the configuration already read in or add new config options.

If "allow_user_rules" is enabled in the configuration, it is possible that additional rules have been added since the "finish_parsing_start" plugin hook invocation was called.

$plugin->user_conf_parsing_end ( { options ... } )

Signals that the per-user configuration parsing has just finished, and SpamAssassin is nearly ready to check messages. If "allow_user_rules" is enabled in the configuration, it is possible that additional rules have been added since the "finish_parsing_end" plugin hook invocation was called.

"options" is a reference to a hash containing these options:

$plugin->signal_user_changed ( { options ... } )

Signals that the current user has changed for a new one.

$plugin->services_authorized_for_username ( { options ... } )

Validates that a given username is authorized to use certain services.

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

$plugin->compile_now_start ( { options ... } )

This is called at the beginning of Mail::SpamAssassin::compile_now() so plugins can do any necessary initialization for multi-process SpamAssassin (such as spamd or mass-check -j).

$plugin->compile_now_finish ( { options ... } )

This is called at the end of Mail::SpamAssassin::compile_now() so plugins can do any necessary initialization for multi-process SpamAssassin (such as spamd or mass-check -j).

$plugin->check_start ( { options ... } )

Signals that a message check operation is starting.

$plugin->check_main ( { options ... } )

Signals that a message should be checked. Note that implementations of this hook should return 1.

$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.

$plugin->check_dnsbl ( { options ... } )

Called when DNSBL or other network lookups are being launched, implying current running priority of -100. This is the place to start your own asynchronously-started network lookups.

$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.

$plugin->check_cleanup ( { options ... } )

Called just before message check is finishing and before possible auto-learning. This is guaranteed to be always called, unlike check_tick and check_post_dnsbl. Used for cleaning up left callbacks or forked children etc, last chance to make rules hit.

$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-learning happens, this is the place to do it.

$plugin->check_end ( { options ... } )

Signals that a message check operation has just finished, and the results are about to be returned to the caller.

$plugin->finish_tests ( { options ... } )

Called via "Mail::SpamAssassin::finish". This should clear up any tests that a plugin has added to the namespace.

In certain circumstances, plugins may find it useful to compile perl functions from the ruleset, on the fly. It is important to remove these once the "Mail::SpamAssassin" object is deleted, however, and this API allows this.

Each plugin is responsible for its own generated perl functions.

$plugin->extract_metadata ( { options ... } )

Signals that a message is being mined for metadata. Some plugins may wish to add their own metadata as well.

$plugin->parsed_metadata ( { options ... } )

Signals that a message's metadata has been parsed, and can now be accessed by the plugin.

$plugin->start_rules ( { options ... } )

Called before testing a set of rules of a given type and priority.

$plugin->hit_rule ( { options ... } )

Called when a rule fires.

$plugin->ran_rule ( { options ... } )

Called after a rule has been tested, whether or not it fired. When the rule fires, the hit_rule callback is always called before this.

$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 message as spam, 0 to learn as ham, or "undef" to not learn from the message at all.

$plugin->autolearn ( { options ... } )

Signals that a message is about to be auto-learned as either ham or spam.

$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.

$plugin->have_shortcircuited ( { options ... } )

Has the current scan operation 'short-circuited'? In other words, can further scanning be skipped, since the message is already definitively classified as either spam or ham?

Plugins should return 0 to indicate that scanning should continue, or 1 to indicate that short-circuiting has taken effect.

$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.

$plugin->bayes_forget ( { options ... } )

Called at the end of a bayes forget operation.

$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.

$plugin->plugin_report ( { options ... } )

Called if the message is to be reported as spam. If the reporting system is available, the variable "$options->{report}->report_available}" should be set to 1; if the reporting system successfully reported the message, the variable "$options->{report}->report_return}" should be set to 1.

$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->{revoke}->revoke_available}" should be set to 1; if the reporting system successfully revoked the message, the variable "$options->{revoke}->revoke_return}" should be set to 1.

$plugin->welcomelist_address( { options ... } )

Previously whitelist_address which will work interchangeably until 4.1.

Called when a request is made to add an address to a persistent address list.

$plugin->blocklist_address( { options ... } )

Previously blacklist_address which will work interchangeably until 4.1.

Called when a request is made to add an address to a persistent address list.

$plugin->remove_address( { options ... } )

Called when a request is made to remove an address to a persistent address list.

$plugin->spamd_child_init ()

Called in each new child process when it starts up under spamd.

$plugin->log_scan_result ( { options ... } )

Called when spamd has completed scanning a message. Currently, only spamd calls this API.

$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.

$plugin->learner_new ()

Used to support human-trained probabilistic classifiers like the BAYES_* ruleset. Called when a new "Mail::SpamAssassin::Bayes" object has been created; typically when a new user's scan is about to start.

$plugin->learn_message ()

Train the classifier with a training message.

$plugin->forget_message ()

Tell the classifier to 'forget' its training about a specific message.

$plugin->learner_sync ()

Tell the classifier to 'sync' any pending changes against the current user's training database. This is called by "sa-learn --sync".

If you do not need to implement these for your classifier, create an implementation that just contains "return 1".

$plugin->learner_expire_old_training ()

Tell the classifier to perform infrequent, time-consuming cleanup of the current user's training database. This is called by "sa-learn --force-expire".

If you do not need to implement these for your classifier, create an implementation that just contains "return 1".

$plugin->learner_is_scan_available ()

Should return 1 if it is possible to use the current user's training data for a message-scan operation, or 0 otherwise.

$plugin->learner_dump_database ()

Dump information about the current user's training data to "stdout". This is called by "sa-learn --dump".

$plugin->learner_close ()

Close any open databases.

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, $ruletype)

Plugins that implement an eval test will need to call this, so that SpamAssassin calls into the object when that eval test is encountered. See the REGISTERING EVAL RULES section for full details.

Since 4.0, optional $ruletype can be specified to enforce that eval function cannot be called with wrong ruletype from configuration, for example user using "header FOO eval:foobar()" instead of "body FOO eval:foobar()". Mismatch will result in lint failure. $ruletype can be one of:

$Mail::SpamAssassin::Conf::TYPE_HEAD_EVALS
$Mail::SpamAssassin::Conf::TYPE_BODY_EVALS  (allows both body and rawbody)
$Mail::SpamAssassin::Conf::TYPE_RAWBODY_EVALS
$Mail::SpamAssassin::Conf::TYPE_FULL_EVALS

$plugin->register_generated_rule_method ($nameofsub)

In certain circumstances, plugins may find it useful to compile perl functions from the ruleset, on the fly. It is important to remove these once the "Mail::SpamAssassin" object is deleted, however, and this API allows this.

Once the method $nameofsub has been generated, call this API with the name of the method (including full package scope). This indicates that it's a temporary piece of generated code, built from the SpamAssassin ruleset, and when Mail::SpamAssassin::finish() is called, the method will be destroyed.

This API was added in SpamAssassin 3.2.0.

$plugin->register_method_priority($methodname, $priority)

Indicate that the method named $methodname on the current object has a callback priority of $priority.

This is used by the plugin handler to determine the relative order of callbacks; plugins with lower-numbered priorities are called before plugins with higher-numbered priorities. Each method can have a different priority value. The default value is 0. The ordering of callbacks to methods with equal priority is undefined.

Typically, you only need to worry about this if you need to ensure your plugin's method is called before another plugin's implementation of that method. It should be called from your plugin's constructor.

This API was added in SpamAssassin 3.2.0.

$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().

LOGGING

Mail::SpamAssassin::Plugin::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::SpamAssassin::Plugin::dbg($msg).

Mail::SpamAssassin::Plugin::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->info(). If a plugin wishes to output debug information, it should call Mail::SpamAssassin::Plugin::info($msg).

In general, it is better for plugins to use the "Mail::SpamAssassin::Logger" module to import "dbg" and "info" directly, like so:

use Mail::SpamAssassin::Logger;
dbg("some message");
info("some other message");

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', $Mail::SpamAssassin::Conf::TYPE_HEAD_EVALS)

will cause "$plugin->check_for_foo()" to be called for this SpamAssassin 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 (miss), 1 (hit), or undef (async function)
}

The eval rule should return 1 for a hit, or 0 if the rule is not hit. Special case of "return undef" must be used when result is not yet ready and it will be later declared with PerMsgStatus functions got_hit() or rule_ready() - see their documentation for more info. Make sure not to return undef by mistake.

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}".

State for a single message being scanned should be stored on the $permsgstatus 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.

BACKWARD COMPATIBILITY

Note that if you write a plugin and need to determine if a particular helper method is supported on "Mail::SpamAssassin::Plugin", you can do this:

if ($self->can("name_of_method")) {
  eval {
    $self->name_of_method();        # etc.
  }
} else {
  # take fallback action
}

The same applies for the public APIs on objects of other types, such as "Mail::SpamAssassin::PerMsgStatus".

SEE ALSO

Mail::SpamAssassin(3)

Mail::SpamAssassin::PerMsgStatus(3)

https://wiki.apache.org/spamassassin/PluginWritingTips

https://issues.apache.org/SpamAssassin/show_bug.cgi?id=2163