NAME

Mail::SpamAssassin - Spam detector and markup engine

SYNOPSIS

  my $spamtest = Mail::SpamAssassin->new();
  my $mail = $spamtest->parse($message);
  my $status = $spamtest->check($mail);
  if ($status->is_spam()) {
    $message = $status->rewrite_mail();
  }
  else {
    ...
  }
  ...
  $status->finish();
  $mail->finish();
  $spamtest->finish();

DESCRIPTION

Mail::SpamAssassin is a module to identify spam using several methods including text analysis, internet-based realtime blocklists, statistical analysis, and internet-based hashing algorithms.

Using its rule base, it uses a wide range of heuristic tests on mail headers and body text to identify "spam", also known as unsolicited bulk email. Once identified as spam, the mail can then be tagged as spam for later filtering using the user's own mail user agent application or at the mail transfer agent.

If you wish to use a command-line filter tool, try the "spamassassin" or the "spamd"/"spamc" tools provided.

METHODS

$t = Mail::SpamAssassin->new( { opt => val, ... } )

Constructs a new "Mail::SpamAssassin" object. You may pass a hash reference to the constructor which may contain the following attribute- value pairs.

parse($message, $parse_now [, $suppl_attrib])

Parse will return a Mail::SpamAssassin::Message object with just the headers parsed. When calling this function, there are two optional parameters that can be passed in: $message is either undef (which will use STDIN), a scalar - a string containing an entire message, a reference to such string, an array reference of the message with one line per array element, or either a file glob or an IO::File object which holds the entire contents of the message; and $parse_now, which specifies whether or not to create a MIME tree at parse time or later as necessary.

The $parse_now option, by default, is set to false (0). This allows SpamAssassin to not have to generate the tree of internal data nodes if the information is not going to be used. This is handy, for instance, when running "spamassassin -d", which only needs the pristine header and body which is always parsed and stored by this function.

The optional last argument $suppl_attrib provides a way for a caller to pass additional information about a message to SpamAssassin. It is either undef, or a ref to a hash where each key/value pair provides some supplementary attribute of the message, typically information that cannot be deduced from the message itself, or is hard to do so reliably, or would represent unnecessary work for SpamAssassin to obtain it. The argument will be stored to a Mail::SpamAssassin::Message object as 'suppl_attrib', thus made available to the rest of the code as well as to plugins. Possible attributes are:

    $msg = $sa->parse($message,0, {
        body_size       => 24284293,
        master_deadline => time() + 60,
        return_path     => 'foo@example.com',
        originating     => 0,
        rule_hits       => {
            rule   => '__TRUNCATED',
            score  => -0.1,
            area   => 'RAW: ',
            tflags => 'nice',
            descr  => "Message size truncated to 10485760 B" }
    });

$status = $f->check ($mail)

Check a mail, encapsulated in a "Mail::SpamAssassin::Message" object, to determine if it is spam or not.

Returns a "Mail::SpamAssassin::PerMsgStatus" object which can be used to test or manipulate the mail message.

Note that the "Mail::SpamAssassin" object can be re-used for further messages without affecting this check; in OO terminology, the "Mail::SpamAssassin" object is a "factory". However, if you do this, be sure to call the finish() method on the status objects when you're done with them.

$status = $f->check_message_text ($mailtext)

Check a mail, encapsulated in a plain string $mailtext, to determine if it is spam or not.

Otherwise identical to check() above.

$status = $f->learn ($mail, $id, $isspam, $forget)

Learn from a mail, encapsulated in a "Mail::SpamAssassin::Message" object.

If $isspam is set, the mail is assumed to be spam, otherwise it will be learnt as non-spam.

If $forget is set, the attributes of the mail will be removed from both the non-spam and spam learning databases.

$id is an optional message-identification string, used internally to tag the message. If it is "undef", the Message-Id of the message will be used. It should be unique to that message.

Returns a "Mail::SpamAssassin::PerMsgLearner" object which can be used to manipulate the learning process for each mail.

Note that the "Mail::SpamAssassin" object can be re-used for further messages without affecting this check; in OO terminology, the "Mail::SpamAssassin" object is a "factory". However, if you do this, be sure to call the finish() method on the learner objects when you're done with them.

learn() and check() can be run using the same factory. init_learner() must be called before using this method.

$f->init_learner ( [ { opt => val, ... } ] )

Initialise learning. You may pass the following attribute-value pairs to this method.

$f->rebuild_learner_caches ({ opt => val })

Rebuild any cache databases; should be called after the learning process. Options include: "verbose", which will output diagnostics to "stdout" if set to 1.

$f->finish_learner ()

Finish learning.

$f->dump_bayes_db()

Dump the contents of the Bayes DB

$f->signal_user_changed ( [ { opt => val, ... } ] )

Signals that the current user has changed (possibly using "setuid"), meaning that SpamAssassin should close any per-user databases it has open, and re-open using ones appropriate for the new user.

Note that this should be called after reading any per-user configuration, as that data may override some paths opened in this method. You may pass the following attribute-value pairs:

$f->report_as_spam ($mail, $options)

Report a mail, encapsulated in a "Mail::SpamAssassin::Message" object, as human-verified spam. This will submit the mail message to live, collaborative, spam-blocker databases, allowing other users to block this message.

It will also submit the mail to SpamAssassin's Bayesian learner.

Options is an optional reference to a hash of options. Currently these can be:

$f->revoke_as_spam ($mail, $options)

Revoke a mail, encapsulated in a "Mail::SpamAssassin::Message" object, as human-verified ham (non-spam). This will revoke the mail message from live, collaborative, spam-blocker databases, allowing other users to block this message.

It will also submit the mail to SpamAssassin's Bayesian learner as nonspam.

Options is an optional reference to a hash of options. Currently these can be:

$f->add_address_to_welcomelist ($addr, $cli_p)

Previously add_address_to_whitelist which will work interchangeably until 4.1.

Given a string containing an email address, add it to the automatic welcomelist database.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$f->add_all_addresses_to_welcomelist ($mail, $cli_p)

Previously add_all_addresses_to_whitelist which will work interchangeably until 4.1.

Given a mail message, find as many addresses in the usual headers (To, Cc, From etc.), and the message body, and add them to the automatic welcomelist database.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$f->remove_address_from_welcomelist ($addr, $cli_p)

Previously remove_address_from_whitelist which will work interchangeably until 4.1.

Given a string containing an email address, remove it from the automatic welcomelist database.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$f->remove_all_addresses_from_welcomelist ($mail, $cli_p)

Previously remove_all_addresses_from_whitelist which will work interchangeably until 4.1.

Given a mail message, find as many addresses in the usual headers (To, Cc, From etc.), and the message body, and remove them from the automatic welcomelist database.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$f->add_address_to_blocklist ($addr, $cli_p)

Previously add_address_to_blacklist which will work interchangeably until 4.1.

Given a string containing an email address, add it to the automatic welcomelist database with a high score, effectively blocklisting them.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$f->add_all_addresses_to_blocklist ($mail, $cli_p)

Previously add_all_addresses_to_blacklist which will work interchangeably until 4.1.

Given a mail message, find addresses in the From headers and add them to the automatic welcomelist database with a high score, effectively blocklisting them.

Note that To and Cc addresses are not used.

If $cli_p is set then underlying plugin may give visual feedback on additions/failures.

$text = $f->remove_spamassassin_markup ($mail)

Returns the text of the message, with any SpamAssassin-added text (such as the report, or X-Spam-Status headers) stripped.

Note that the $mail object is not modified.

Warning: if the input message in $mail contains a mixture of CR-LF (Windows-style) and LF (UNIX-style) line endings, it will be "canonicalized" to use one or the other consistently throughout.

$f->read_scoreonly_config ($filename)

Read a configuration file and parse user preferences from it.

User preferences are as defined in the "Mail::SpamAssassin::Conf" manual page. In other words, they include scoring options, scores, welcomelists and blocklists, and so on, but do not include rule definitions, privileged settings, etc. unless "allow_user_rules" is enabled; and they never include the administrator settings.

$f->load_scoreonly_sql ($username)

Read configuration parameters from SQL database and parse scores from it. This will only take effect if the perl "DBI" module is installed, and the configuration parameters "user_scores_dsn", "user_scores_sql_username", and "user_scores_sql_password" are set correctly.

The username in $username will also be used for the "username" attribute of the Mail::SpamAssassin object.

$f->load_scoreonly_ldap ($username)

Read configuration parameters from an LDAP server and parse scores from it. This will only take effect if the perl "Net::LDAP" and "URI" modules are installed, and the configuration parameters "user_scores_dsn", "user_scores_ldap_username", and "user_scores_ldap_password" are set correctly.

The username in $username will also be used for the "username" attribute of the Mail::SpamAssassin object.

$f->set_persistent_address_list_factory ($factoryobj)

Set the persistent address list factory, used to create objects for the automatic welcomelist algorithm's persistent-storage back-end. See "Mail::SpamAssassin::PersistentAddrList" for the API these factory objects must implement, and the API the objects they produce must implement.

$f->compile_now ($use_user_prefs, $keep_userstate)

Compile all patterns, load all configuration files, and load all possibly-required Perl modules.

Normally, Mail::SpamAssassin uses lazy evaluation where possible, but if you plan to fork() or start a new perl interpreter thread to process a message, this is suboptimal, as each process/thread will have to perform these actions.

Call this function in the master thread or process to perform the actions straight away, so that the sub-processes will not have to.

If $use_user_prefs is 0, this will initialise the SpamAssassin configuration without reading the per-user configuration file and it will assume that you will call "read_scoreonly_config" at a later point.

If $keep_userstate is true, compile_now() will revert any configuration options which have a default with __userstate__ in it post-init(), and then re-change the option before returning. This lets you change $ENV{'HOME'} to a temp directory, have compile_now() and create any files there as necessary without disturbing the actual files as changed by a configuration option. By default, this is disabled.

$f->debug_diagnostics ()

Output some diagnostic information, useful for debugging SpamAssassin problems.

$failed = $f->lint_rules ()

Syntax-check the current set of rules. Returns the number of syntax errors discovered, or 0 if the configuration is valid.

$f->finish()

Destroy this object, so that it will be garbage-collected once it goes out of scope. The object will no longer be usable after this method is called.

$fullpath = $f->find_rule_support_file ($filename)

Find a rule-support file, such as "languages" or "triplets.txt", in the system-wide rules directory, and return its full path if it exists, or undef if it doesn't exist.

(This API was added in SpamAssassin 3.1.1.)

$f->create_default_prefs ($filename, $username [ , $userdir ] )

Copy default preferences file into home directory for later use and modification, if it does not already exist and "dont_copy_prefs" is not set.

$f->copy_config ( [ $source ], [ $dest ] )

Used for daemons to keep a persistent Mail::SpamAssassin object's configuration correct if switching between users. Pass an associative array reference as either $source or $dest, and set the other to 'undef' so that the object will use its current configuration. i.e.:

  # create object w/ configuration
  my $spamtest = Mail::SpamAssassin->new( ... );
  # backup configuration to %conf_backup
  my %conf_backup;
  $spamtest->copy_config(undef, \%conf_backup) ||
    die "config: error returned from copy_config!\n";
  ... do stuff, perhaps modify the config, etc ...
  # reset the configuration back to the original
  $spamtest->copy_config(\%conf_backup, undef) ||
    die "config: error returned from copy_config!\n";
    

Note that the contents of the associative arrays should be considered opaque by calling code.

@plugins = $f->get_loaded_plugins_list ( )

Return the list of plugins currently loaded by this SpamAssassin object's configuration; each entry in the list is an object of type "Mail::SpamAssassin::Plugin".

(This API was added in SpamAssassin 3.2.0.)

PREREQUISITES

"HTML::Parser" "Sys::Syslog"

MORE DOCUMENTATION

See also <https://spamassassin.apache.org/> and <https://wiki.apache.org/spamassassin/> for more information.

SEE ALSO

Mail::SpamAssassin::Conf(3) Mail::SpamAssassin::PerMsgStatus(3) spamassassin(1) sa-update(1)

BUGS

See <https://bz.apache.org/SpamAssassin/>

AUTHORS

The SpamAssassin(tm) Project <https://spamassassin.apache.org/>

COPYRIGHT

SpamAssassin is distributed under the Apache License, Version 2.0, as described in the file "LICENSE" included with the distribution.

AVAILABILITY

The latest version of this library is likely to be available from CPAN as well as:

<https://spamassassin.apache.org/>