1Mail::SpamAssassin::PluUgsienr(3C)ontributed Perl DocumeMnatialt:i:oSnpamAssassin::Plugin(3)
2
6 Mail::SpamAssassin::Plugin - SpamAssassin plugin base class
7
9 SpamAssassin configuration:
10 loadplugin MyPlugin /path/to/myplugin.pm
11 Perl code:
13 package MyPlugin;
14 use Mail::SpamAssassin::Plugin;
16 our @ISA = qw(Mail::SpamAssassin::Plugin);
17 sub new {
19 my ($class, $mailsa) = @_;
20 # the usual perlobj boilerplate to create a subclass object
22 $class = ref($class) || $class;
23 my $self = $class->SUPER::new($mailsa);
24 bless ($self, $class);
25 # then register an eval rule, if desired...
27 $self->register_eval_rule ("check_for_foo");
28 # and return the new plugin object
30 return $self;
31 }
32 ...methods...
34 1;
36
38 This is the base class for SpamAssassin plugins; all plugins must be
39 objects that implement this class.
40 This class provides no-op stub methods for all the callbacks that a
42 plugin can receive. It is expected that your plugin will override one
43 or more of these stubs to perform its actions.
44 SpamAssassin implements a plugin chain; each callback event is passed
46 to each of the registered plugin objects in turn. Any plugin can call
47 "$self->inhibit_further_callbacks()" to block delivery of that event to
48 later plugins in the chain. This is useful if the plugin has handled
49 the event, and there will be no need for later plugins to handle it as
50 well.
51 If you're looking to write a simple eval rule, skip straight to
53 "register_eval_rule()", below.
54
56 In all the plugin APIs below, "options" refers to a reference to a hash
57 containing name-value pairs. This is used to ensure future-
58 compatibility, in that we can add new options in future without
59 affecting objects built to an earlier version of the API.
60 For example, here would be how to print out the "line" item in a
62 "parse_config()" method:
63 sub parse_config {
65 my ($self, $opts) = @_;
66 print "MyPlugin: parse_config got ".$opts->{line}."\n";
67 }
68
70 The following methods can be overridden by subclasses to handle events.
71 $plugin = MyPluginClass->new ($mailsaobject)
73 Constructor. Plugins that need to register themselves will need to
74 define their own; the default super-class constructor will work
75 fine for plugins that just override a method.
76 Note that subclasses must provide the $mailsaobject to the
78 superclass constructor, like so:
79 my $self = $class->SUPER::new($mailsaobject);
81 Lifecycle note: plugins that will need to store per-scan state
83 should not store that on the Plugin object; instead this should be
84 stored on the PerMsgStatus object, see "check_start()" below. It
85 is also likewise recommended that configuration settings be stored
86 on the Conf object; see "parse_config()".
87 $plugin->parse_config ( { options ... } )
89 Parse a configuration line that hasn't already been handled.
90 "options" is a reference to a hash containing these options:
91 line
93 The line of configuration text to parse. This has leading and
94 trailing whitespace, and comments, removed.
95 key The configuration key; ie. the first "word" on the line.
97 value
99 The configuration value; everything after the first "word" and
100 any whitespace after that.
101 conf
103 The "Mail::SpamAssassin::Conf" object on which the
104 configuration data should be stored.
105 user_config
107 A boolean: 1 if reading a user's configuration, 0 if reading
108 the system-wide configuration files.
109 If the configuration line was a setting that is handled by this
111 plugin, the method implementation should call
112 "$self->inhibit_further_callbacks()".
113 If the setting is not handled by this plugin, the method should
115 return 0 so that a later plugin may handle it, or so that
116 SpamAssassin can output a warning message to the user if no plugin
117 understands it.
118 Lifecycle note: it is suggested that configuration be stored on the
120 "Mail::SpamAssassin::Conf" object in use, instead of the plugin
121 object itself. That can be found as "$plugin->{main}->{conf}", or
122 as "conf" in the $options hash reference above. By storing it on
123 "conf", this allows per-user and system-wide configuration
124 precedence to be dealt with correctly.
125 $plugin->finish_parsing_start ( { options ... } )
127 Signals that the system-wide configuration has been completely
128 read, but internal data structures are not yet created. It is
129 possible to use this hook to dynamically change the configuration
130 already read in or add new config options.
131 "options" is a reference to a hash containing these options:
133 conf
135 The "Mail::SpamAssassin::Conf" object on which the
136 configuration data should be stored.
137 Note: there are no guarantees that the internal data structures of
139 SpamAssassin will not change from release to release. In
140 particular to this plugin hook, if you modify the rules data
141 structures in a third-party plugin, all bets are off until such
142 time that an API is present for modifying that configuration data.
143 $plugin->finish_parsing_end ( { options ... } )
145 Signals that the system-wide configuration parsing has just
146 finished, and SpamAssassin is nearly ready to check messages.
147 "options" is a reference to a hash containing these options:
149 conf
151 The "Mail::SpamAssassin::Conf" object on which the
152 configuration data should be stored.
153 Note: there are no guarantees that the internal data structures of
155 SpamAssassin will not change from release to release. In
156 particular to this plugin hook, if you modify the rules data
157 structures in a third-party plugin, all bets are off until such
158 time that an API is present for modifying that configuration data.
159 $plugin->user_conf_parsing_start ( { options ... } )
161 Signals that the per-user configuration has been completely read,
162 but not converted to internal data structures. It is possible to
163 use this hook to dynamically change the configuration already read
164 in or add new config options.
165 If "allow_user_rules" is enabled in the configuration, it is
167 possible that additional rules have been added since the
168 "finish_parsing_start" plugin hook invocation was called.
169 conf
171 The "Mail::SpamAssassin::Conf" object on which the
172 configuration data should be stored.
173 Note: there are no guarantees that the internal data structures of
175 SpamAssassin will not change from release to release. In
176 particular to this plugin hook, if you modify the rules data
177 structures in a third-party plugin, all bets are off until such
178 time that an API is present for modifying that configuration data.
179 $plugin->user_conf_parsing_end ( { options ... } )
181 Signals that the per-user configuration parsing has just finished,
182 and SpamAssassin is nearly ready to check messages. If
183 "allow_user_rules" is enabled in the configuration, it is possible
184 that additional rules have been added since the
185 "finish_parsing_end" plugin hook invocation was called.
186 "options" is a reference to a hash containing these options:
188 conf
190 The "Mail::SpamAssassin::Conf" object on which the
191 configuration data should be stored.
192 Note: there are no guarantees that the internal data structures of
194 SpamAssassin will not change from release to release. In
195 particular to this plugin hook, if you modify the rules data
196 structures in a third-party plugin, all bets are off until such
197 time that an API is present for modifying that configuration data.
198 $plugin->signal_user_changed ( { options ... } )
200 Signals that the current user has changed for a new one.
201 username
203 The new user's username.
204 user_dir
206 The new user's home directory. (equivalent to "~".)
207 userstate_dir
209 The new user's storage directory. (equivalent to
210 "~/.spamassassin".)
211 $plugin->services_authorized_for_username ( { options ... } )
213 Validates that a given username is authorized to use certain
214 services.
215 In order to authorize a user, the plugin should first check that it
217 can handle any of the services passed into the method and then set
218 the value for each allowed service to true (or any non-negative
219 value).
220 The current supported services are: bayessql
222 username
224 A username
225 services
227 Reference to a hash containing the services you want to check.
228 {
230 'bayessql' => 0
232 }
234 conf
236 The "Mail::SpamAssassin::Conf" object on which the
237 configuration data should be stored.
238 $plugin->compile_now_start ( { options ... } )
240 This is called at the beginning of
241 Mail::SpamAssassin::compile_now() so plugins can do any necessary
242 initialization for multi-process SpamAssassin (such as spamd or
243 mass-check -j).
244 use_user_prefs
246 The value of $use_user_prefs option in compile_now().
247 keep_userstate
249 The value of $keep_userstate option in compile_now().
250 $plugin->compile_now_finish ( { options ... } )
252 This is called at the end of Mail::SpamAssassin::compile_now() so
253 plugins can do any necessary initialization for multi-process
254 SpamAssassin (such as spamd or mass-check -j).
255 use_user_prefs
257 The value of $use_user_prefs option in compile_now().
258 keep_userstate
260 The value of $keep_userstate option in compile_now().
261 $plugin->check_start ( { options ... } )
263 Signals that a message check operation is starting.
264 permsgstatus
266 The "Mail::SpamAssassin::PerMsgStatus" context object for this
267 scan.
268 Lifecycle note: it is recommended that rules that need to track
270 test state on a per-scan basis should store that state on this
271 object, not on the plugin object itself, since the plugin
272 object will be shared between all active scanners.
273 The message being scanned is accessible through the
275 "$permsgstatus->get_message()" API; there are a number of other
276 public APIs on that object, too. See
277 "Mail::SpamAssassin::PerMsgStatus" perldoc.
278 $plugin->check_main ( { options ... } )
280 Signals that a message should be checked. Note that
281 implementations of this hook should return 1.
282 permsgstatus
284 The "Mail::SpamAssassin::PerMsgStatus" context object for this
285 scan.
286 $plugin->check_tick ( { options ... } )
288 Called periodically during a message check operation. A callback
289 set for this method is a good place to run through an event loop
290 dealing with network events triggered in a "parse_metadata" method,
291 for example.
292 permsgstatus
294 The "Mail::SpamAssassin::PerMsgStatus" context object for this
295 scan.
296 $plugin->check_post_dnsbl ( { options ... } )
298 Called after the DNSBL results have been harvested. This is a good
299 place to harvest your own asynchronously-started network lookups.
300 permsgstatus
302 The "Mail::SpamAssassin::PerMsgStatus" context object for this
303 scan.
304 $plugin->check_post_learn ( { options ... } )
306 Called after auto-learning may (or may not) have taken place. If
307 you wish to perform additional learning, whether or not auto-
308 learning happens, this is the place to do it.
309 permsgstatus
311 The "Mail::SpamAssassin::PerMsgStatus" context object for this
312 scan.
313 $plugin->check_end ( { options ... } )
315 Signals that a message check operation has just finished, and the
316 results are about to be returned to the caller.
317 permsgstatus
319 The "Mail::SpamAssassin::PerMsgStatus" context object for this
320 scan. The current score, names of rules that hit, etc. can be
321 retrieved using the public APIs on this object.
322 $plugin->finish_tests ( { options ... } )
324 Called via "Mail::SpamAssassin::finish". This should clear up any
325 tests that a plugin has added to the namespace.
326 In certain circumstances, plugins may find it useful to compile
328 perl functions from the ruleset, on the fly. It is important to
329 remove these once the "Mail::SpamAssassin" object is deleted,
330 however, and this API allows this.
331 Each plugin is responsible for its own generated perl functions.
333 conf
335 The "Mail::SpamAssassin::Conf" object on which the
336 configuration data should be stored.
337 See also the "register_generated_rule_method" helper API, below.
339 $plugin->extract_metadata ( { options ... } )
341 Signals that a message is being mined for metadata. Some plugins
342 may wish to add their own metadata as well.
343 msg The "Mail::SpamAssassin::Message" object for this message.
345 permsgstatus
347 The "Mail::SpamAssassin::PerMsgStatus" context object for this
348 scan.
349 $plugin->parsed_metadata ( { options ... } )
351 Signals that a message's metadata has been parsed, and can now be
352 accessed by the plugin.
353 permsgstatus
355 The "Mail::SpamAssassin::PerMsgStatus" context object for this
356 scan.
357 $plugin->start_rules ( { options ... } )
359 Called before testing a set of rules of a given type and priority.
360 permsgstatus
362 The "Mail::SpamAssassin::PerMsgStatus" context object for this
363 scan.
364 ruletype
366 The type of the rules about to be performed.
367 priority
369 The priority level of the rules about to be performed.
370 $plugin->hit_rule ( { options ... } )
372 Called when a rule fires.
373 permsgstatus
375 The "Mail::SpamAssassin::PerMsgStatus" context object for this
376 scan.
377 ruletype
379 The type of the rule that fired.
380 rulename
382 The name of the rule that fired.
383 score
385 The rule's score in the active scoreset.
386 $plugin->ran_rule ( { options ... } )
388 Called after a rule has been tested, whether or not it fired. When
389 the rule fires, the hit_rule callback is always called before this.
390 permsgstatus
392 The "Mail::SpamAssassin::PerMsgStatus" context object for this
393 scan.
394 ruletype
396 The type of the rule that was tested.
397 rulename
399 The name of the rule that was tested.
400 $plugin->autolearn_discriminator ( { options ... } )
402 Control whether a just-scanned message should be learned as either
403 spam or ham. This method should return one of 1 to learn the
404 message as spam, 0 to learn as ham, or "undef" to not learn from
405 the message at all.
406 permsgstatus
408 The "Mail::SpamAssassin::PerMsgStatus" context object for this
409 scan.
410 $plugin->autolearn ( { options ... } )
412 Signals that a message is about to be auto-learned as either ham or
413 spam.
414 permsgstatus
416 The "Mail::SpamAssassin::PerMsgStatus" context object for this
417 scan.
418 isspam
420 1 if the message is spam, 0 if ham.
421 $plugin->per_msg_finish ( { options ... } )
423 Signals that a "Mail::SpamAssassin::PerMsgStatus" object is being
424 destroyed, and any per-scan context held on that object by this
425 plugin should be destroyed as well.
426 Normally, any member variables on the "PerMsgStatus" object will be
428 cleaned up automatically -- but if your plugin has made a circular
429 reference on that object, this is the place to break them so that
430 garbage collection can operate correctly.
431 permsgstatus
433 The "Mail::SpamAssassin::PerMsgStatus" context object for this
434 scan.
435 $plugin->have_shortcircuited ( { options ... } )
437 Has the current scan operation 'short-circuited'? In other words,
438 can further scanning be skipped, since the message is already
439 definitively classified as either spam or ham?
440 Plugins should return 0 to indicate that scanning should continue,
442 or 1 to indicate that short-circuiting has taken effect.
443 permsgstatus
445 The "Mail::SpamAssassin::PerMsgStatus" context object for this
446 scan.
447 $plugin->bayes_learn ( { options ... } )
449 Called at the end of a bayes learn operation.
450 This phase is the best place to map the raw (original) token value
452 to the SHA1 hashed value.
453 toksref
455 Reference to hash returned by call to tokenize. The hash takes
456 the format of:
457 {
459 'SHA1 Hash Value' => 'raw (original) value',
460 ...
461 }
462 NOTE: This data structure has changed since it was originally
464 introduced in version 3.0.0. The values are no longer perl
465 anonymous hashes, they are a single string containing the raw
466 token value. You can test for backward compatibility by
467 checking to see if the value for a key is a reference to a perl
468 HASH, for instance:
469 if (ref($toksref->{$sometokenkey}) eq 'HASH') {...
471 If it is, then you are using the old interface, otherwise you
473 are using the current interface.
474 isspam
476 Boolean value stating what flavor of message the tokens
477 represent, if true then message was specified as spam, false is
478 nonspam. Note, when function is scan then isspam value is not
479 valid.
480 msgid
482 Generated message id of the message just learned.
483 msgatime
485 Received date of the current message or current time if
486 received date could not be determined. In addition, if the
487 receive date is more than 24 hrs into the future it will be
488 reset to current datetime.
489 $plugin->bayes_forget ( { options ... } )
491 Called at the end of a bayes forget operation.
492 toksref
494 Reference to hash returned by call to tokenize. See
495 bayes_learn documentation for additional information on the
496 format.
497 isspam
499 Boolean value stating what flavor of message the tokens
500 represent, if true then message was specified as spam, false is
501 nonspam. Note, when function is scan then isspam value is not
502 valid.
503 msgid
505 Generated message id of the message just forgotten.
506 $plugin->bayes_scan ( { options ... } )
508 Called at the end of a bayes scan operation. NOTE: Will not be
509 called in case of error or if the message is otherwise skipped.
510 toksref
512 Reference to hash returned by call to tokenize. See
513 bayes_learn documentation for additional information on the
514 format.
515 probsref
517 Reference to hash of calculated probabilities for tokens found
518 in the database.
519 {
521 'SHA1 Hash Value' => {
522 'prob' => 'calculated probability',
523 'spam_count' => 'Total number of spam msgs w/ token',
524 'ham_count' => 'Total number of ham msgs w/ token',
525 'atime' => 'Atime value for token in database'
526 }
527 }
528 score
530 Score calculated for this particular message.
531 msgatime
533 Calculated atime of the message just learned, note it may have
534 been adjusted if it was determined to be too far into the
535 future.
536 significant_tokens
538 Array ref of the tokens found to be significant in determining
539 the score for this message.
540 $plugin->plugin_report ( { options ... } )
542 Called if the message is to be reported as spam. If the reporting
543 system is available, the variable
544 "$options->{report}->report_available}" should be set to 1; if the
545 reporting system successfully reported the message, the variable
546 "$options->{report}->report_return}" should be set to 1.
547 report
549 Reference to the Reporter object ("$options->{report}" in the
550 paragraph above.)
551 text
553 Reference to a markup removed copy of the message in scalar
554 string format.
555 msg Reference to the original message object.
557 $plugin->plugin_revoke ( { options ... } )
559 Called if the message is to be reported as ham (revokes a spam
560 report). If the reporting system is available, the variable
561 "$options->{revoke}->revoke_available}" should be set to 1; if the
562 reporting system successfully revoked the message, the variable
563 "$options->{revoke}->revoke_return}" should be set to 1.
564 revoke
566 Reference to the Reporter object ("$options->{revoke}" in the
567 paragraph above.)
568 text
570 Reference to a markup removed copy of the message in scalar
571 string format.
572 msg Reference to the original message object.
574 $plugin->whitelist_address( { options ... } )
576 Called when a request is made to add an address to a persistent
577 address list.
578 address
580 Address you wish to add.
581 cli_p
583 Indicate if the call is being made from a command line
584 interface.
585 $plugin->blacklist_address( { options ... } )
587 Called when a request is made to add an address to a persistent
588 address list.
589 address
591 Address you wish to add.
592 cli_p
594 Indicate if the call is being made from a command line
595 interface.
596 $plugin->remove_address( { options ... } )
598 Called when a request is made to remove an address to a persistent
599 address list.
600 address
602 Address you wish to remove.
603 cli_p
605 Indicate if the call is being made from a command line
606 interface.
607 $plugin->spamd_child_init ()
609 Called in each new child process when it starts up under spamd.
610 $plugin->log_scan_result ( { options ... } )
612 Called when spamd has completed scanning a message. Currently,
613 only spamd calls this API.
614 result
616 The 'result: ...' line for this scan. Format is as described
617 at http://wiki.apache.org/spamassassin/SpamdSyslogFormat.
618 $plugin->spamd_child_post_connection_close ()
620 Called when child returns from handling a connection.
621 If there was an accept failure, the child will die and this code
623 will not be called.
624 $plugin->finish ()
626 Called when the "Mail::SpamAssassin" object is destroyed.
627 $plugin->learner_new ()
629 Used to support human-trained probabilistic classifiers like the
630 BAYES_* ruleset. Called when a new "Mail::SpamAssassin::Bayes"
631 object has been created; typically when a new user's scan is about
632 to start.
633 $plugin->learn_message ()
635 Train the classifier with a training message.
636 isspam
638 1 if the message is spam, 0 if it's non-spam.
639 msg The message's "Mail::SpamAssassin::Message" object.
641 id An optional message-identification string, used internally to
643 tag the message. If it is "undef", one will be generated. It
644 should be unique to that message.
645 $plugin->forget_message ()
647 Tell the classifier to 'forget' its training about a specific
648 message.
649 msg The message's "Mail::SpamAssassin::Message" object.
651 id An optional message-identification string, used internally to
653 tag the message. If it is "undef", one will be generated. It
654 should be unique to that message.
655 $plugin->learner_sync ()
657 Tell the classifier to 'sync' any pending changes against the
658 current user's training database. This is called by "sa-learn
659 --sync".
660 If you do not need to implement these for your classifier, create
662 an implementation that just contains "return 1".
663 $plugin->learner_expire_old_training ()
665 Tell the classifier to perform infrequent, time-consuming cleanup
666 of the current user's training database. This is called by
667 "sa-learn --force-expire".
668 If you do not need to implement these for your classifier, create
670 an implementation that just contains "return 1".
671 $plugin->learner_is_scan_available ()
673 Should return 1 if it is possible to use the current user's
674 training data for a message-scan operation, or 0 otherwise.
675 $plugin->learner_dump_database ()
677 Dump information about the current user's training data to
678 "stdout". This is called by "sa-learn --dump".
679 magic
681 Set to 1 if "magic" name-value metadata should be dumped.
682 toks
684 Set to 1 if the database of tokens should be dumped.
685 regex
687 Either "undef" to dump all tokens, or a value which specifies a
688 regular expression subset of the tokens to dump.
689 $plugin->learner_close ()
691 Close any open databases.
692 quiet
694 Set to 1 if warning messages should be suppressed.
695
697 These methods provide an API for plugins to register themselves to
698 receive specific events, or control the callback chain behaviour.
699 $plugin->register_eval_rule ($nameofevalsub)
701 Plugins that implement an eval test will need to call this, so that
702 SpamAssassin calls into the object when that eval test is
703 encountered. See the REGISTERING EVAL RULES section for full
704 details.
705 $plugin->register_generated_rule_method ($nameofsub)
707 In certain circumstances, plugins may find it useful to compile
708 perl functions from the ruleset, on the fly. It is important to
709 remove these once the "Mail::SpamAssassin" object is deleted,
710 however, and this API allows this.
711 Once the method $nameofsub has been generated, call this API with
713 the name of the method (including full package scope). This
714 indicates that it's a temporary piece of generated code, built from
715 the SpamAssassin ruleset, and when "Mail::SpamAssassin::finish()"
716 is called, the method will be destroyed.
717 This API was added in SpamAssassin 3.2.0.
719 $plugin->register_method_priority($methodname, $priority)
721 Indicate that the method named $methodname on the current object
722 has a callback priority of $priority.
723 This is used by the plugin handler to determine the relative order
725 of callbacks; plugins with lower-numbered priorities are called
726 before plugins with higher-numbered priorities. Each method can
727 have a different priority value. The default value is 0. The
728 ordering of callbacks to methods with equal priority is undefined.
729 Typically, you only need to worry about this if you need to ensure
731 your plugin's method is called before another plugin's
732 implementation of that method. It should be called from your
733 plugin's constructor.
734 This API was added in SpamAssassin 3.2.0.
736 $plugin->inhibit_further_callbacks()
738 Tells the plugin handler to inhibit calling into other plugins in
739 the plugin chain for the current callback. Frequently used when
740 parsing configuration settings using "parse_config()".
741
743 Mail::SpamAssassin::Plugin::dbg($message)
744 Output a debugging message $message, if the SpamAssassin object is
745 running with debugging turned on.
746 NOTE: This function is not available in the package namespace of
748 general plugins and can't be called via $self->dbg(). If a plugin
749 wishes to output debug information, it should call
750 "Mail::SpamAssassin::Plugin::dbg($msg)".
751 Mail::SpamAssassin::Plugin::info($message)
753 Output an informational message $message, if the SpamAssassin
754 object is running with informational messages turned on.
755 NOTE: This function is not available in the package namespace of
757 general plugins and can't be called via $self->info(). If a plugin
758 wishes to output debug information, it should call
759 "Mail::SpamAssassin::Plugin::info($msg)".
760 In general, it is better for plugins to use the
762 "Mail::SpamAssassin::Logger" module to import "dbg" and "info"
763 directly, like so:
764 use Mail::SpamAssassin::Logger;
766 dbg("some message");
767 info("some other message");
768
770 Plugins that implement an eval test must register the methods that can
771 be called from rules in the configuration files, in the plugin class'
772 constructor.
773 For example,
775 $plugin->register_eval_rule ('check_for_foo')
777 will cause "$plugin->check_for_foo()" to be called for this
779 SpamAssassin rule:
780 header FOO_RULE eval:check_for_foo()
782 Note that eval rules are passed the following arguments:
784 - The plugin object itself
786 - The "Mail::SpamAssassin::PerMsgStatus" object calling the rule
787 - standard arguments for the rule type in use
788 - any and all arguments as specified in the configuration file
789 In other words, the eval test method should look something like this:
791 sub check_for_foo {
793 my ($self, $permsgstatus, ...arguments...) = @_;
794 ...code returning 0 or 1
795 }
796 Note that the headers can be accessed using the "get()" method on the
798 "Mail::SpamAssassin::PerMsgStatus" object, and the body by
799 "get_decoded_stripped_body_text_array()" and other similar methods.
800 Similarly, the "Mail::SpamAssassin::Conf" object holding the current
801 configuration may be accessed through "$permsgstatus->{main}->{conf}".
802 The eval rule should return 1 for a hit, or 0 if the rule is not hit.
804 State for a single message being scanned should be stored on the
806 $permsgstatus object, not on the $self object, since $self persists
807 between scan operations. See the 'lifecycle note' on the
808 "check_start()" method above.
809
811 Plugins will be called with the same arguments as a standard EvalTest.
812 Different rule types receive different information by default:
813 - header tests: no extra arguments
815 - body tests: fully rendered message as array reference
816 - rawbody tests: fully decoded message as array reference
817 - full tests: pristine message as scalar reference
818 The configuration file arguments will be passed in after the standard
820 arguments.
821
823 Note that if you write a plugin and need to determine if a particular
824 helper method is supported on "Mail::SpamAssassin::Plugin", you can do
825 this:
826 if ($self->can("name_of_method")) {
828 eval {
829 $self->name_of_method(); # etc.
830 }
831 } else {
832 # take fallback action
833 }
834 The same applies for the public APIs on objects of other types, such as
836 "Mail::SpamAssassin::PerMsgStatus".
837
839 Mail::SpamAssassin(3)
840 Mail::SpamAssassin::PerMsgStatus(3)
842 http://wiki.apache.org/spamassassin/PluginWritingTips
844 http://issues.apache.org/SpamAssassin/show_bug.cgi?id=2163
846perl v5.30.1 2020-02-03 Mail::SpamAssassin::Plugin(3)