home *** CD-ROM | disk | FTP | other *** search
/ ftp.f-secure.com / 2014.06.ftp.f-secure.com.tar / ftp.f-secure.com / support / hotfix / fsis / IS-SpamControl.fsfix / iufssc / lib / Mail / SpamAssassin / BayesStore / MySQL.pm < prev    next >
Text File  |  2006-11-29  |  27KB  |  1,043 lines
  1. # <@LICENSE>
  2. # Licensed to the Apache Software Foundation (ASF) under one or more
  3. # contributor license agreements.  See the NOTICE file distributed with
  4. # this work for additional information regarding copyright ownership.
  5. # The ASF licenses this file to you under the Apache License, Version 2.0
  6. # (the "License"); you may not use this file except in compliance with
  7. # the License.  You may obtain a copy of the License at:
  8. # 
  9. #     http://www.apache.org/licenses/LICENSE-2.0
  10. # 
  11. # Unless required by applicable law or agreed to in writing, software
  12. # distributed under the License is distributed on an "AS IS" BASIS,
  13. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14. # See the License for the specific language governing permissions and
  15. # limitations under the License.
  16. # </@LICENSE>
  17.  
  18. =head1 NAME
  19.  
  20. Mail::SpamAssassin::BayesStore::MySQL - MySQL Specific Bayesian Storage Module Implementation
  21.  
  22. =head1 SYNOPSIS
  23.  
  24. =head1 DESCRIPTION
  25.  
  26. This module implements a MySQL specific based bayesian storage module.  It
  27. requires that you are running at least version 4.1 of MySQL, if you are running
  28. a version of MySQL < 4.1 then several aspects of this module will fail and
  29. possibly corrupt your bayes database data.
  30.  
  31. In addition, this module will support rollback on error, if you are
  32. using the InnoDB database table type in MySQL.  For more information
  33. please review the instructions in sql/README.bayes.
  34.  
  35. =cut
  36.  
  37. package Mail::SpamAssassin::BayesStore::MySQL;
  38.  
  39. use strict;
  40. use warnings;
  41. use bytes;
  42.  
  43. use Mail::SpamAssassin::BayesStore::SQL;
  44. use Mail::SpamAssassin::Logger;
  45.  
  46. use vars qw( @ISA );
  47.  
  48. @ISA = qw( Mail::SpamAssassin::BayesStore::SQL );
  49.  
  50. use constant HAS_DBI => eval { require DBI; };
  51.  
  52. =head1 METHODS
  53.  
  54. =head2 token_expiration
  55.  
  56. public instance (Integer, Integer,
  57.                  Integer, Integer) token_expiration(\% $opts,
  58.                                                     Integer $newdelta,
  59.                                                     @ @vars)
  60.  
  61. Description:
  62. This method performs the database specific expiration of tokens based on
  63. the passed in C<$newdelta> and C<@vars>.
  64.  
  65. =cut
  66.  
  67. sub token_expiration {
  68.   my ($self, $opts, $newdelta, @vars) = @_;
  69.  
  70.   my $num_hapaxes;
  71.   my $num_lowfreq;
  72.   my $deleted;
  73.  
  74.   # Figure out how old is too old...
  75.   my $too_old = $vars[10] - $newdelta; # tooold = newest - delta
  76.  
  77.   # if token atime > newest, reset to newest ...
  78.   my $sql = "UPDATE bayes_token SET atime = ?
  79.               WHERE id  = ?
  80.                 AND atime > ?";
  81.  
  82.   my $rows = $self->{_dbh}->do($sql, undef, $vars[10], $self->{_userid}, $vars[10]);
  83.  
  84.   unless (defined($rows)) {
  85.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  86.     $deleted = 0;
  87.     $self->{_dbh}->rollback();
  88.     goto token_expiration_final;
  89.   }
  90.  
  91.   # Check to make sure the expire won't remove too many tokens
  92.   $sql = "SELECT count(token) FROM bayes_token
  93.            WHERE id = ?
  94.              AND atime < ?";
  95.  
  96.   my $sth = $self->{_dbh}->prepare_cached($sql);
  97.  
  98.   unless (defined($sth)) {
  99.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  100.     $deleted = 0;
  101.     $self->{_dbh}->rollback();
  102.     goto token_expiration_final;
  103.   }
  104.  
  105.   my $rc = $sth->execute($self->{_userid}, $too_old);
  106.   
  107.   unless ($rc) {
  108.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  109.     $deleted = 0;
  110.     $self->{_dbh}->rollback();
  111.     goto token_expiration_final;
  112.   }
  113.  
  114.   my ($count) = $sth->fetchrow_array();
  115.  
  116.   $sth->finish();
  117.  
  118.   # Sanity check: if we expired too many tokens, abort!
  119.   if ($vars[3] - $count < 100000) {
  120.     dbg("bayes: token expiration would expire too many tokens, aborting");
  121.     # set these appropriately so the next expire pass does the first pass
  122.     $deleted = 0;
  123.     $newdelta = 0;
  124.   }
  125.   else {
  126.     # Do the expire
  127.     $sql = "DELETE from bayes_token
  128.              WHERE id = ?
  129.                AND atime < ?";
  130.  
  131.     $rows = $self->{_dbh}->do($sql, undef, $self->{_userid}, $too_old);
  132.  
  133.     unless (defined($rows)) {
  134.       dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  135.       $deleted = 0;
  136.       $self->{_dbh}->rollback();
  137.       goto token_expiration_final;
  138.     }
  139.  
  140.     $deleted = $rows;
  141.   }
  142.  
  143.   # Update the magic tokens as appropriate
  144.   $sql = "UPDATE bayes_vars SET token_count = token_count - ?,
  145.                                 last_expire = ?,
  146.                                 last_atime_delta = ?,
  147.                                 last_expire_reduce = ?,
  148.                                 oldest_token_age = (SELECT min(atime)
  149.                                                       FROM bayes_token
  150.                                                      WHERE id = ?)
  151.                 WHERE id = ?";
  152.  
  153.   $rows = $self->{_dbh}->do($sql, undef, $deleted, time(), $newdelta, $deleted, $self->{_userid}, $self->{_userid});
  154.  
  155.   unless (defined($rows)) {
  156.     # Very bad, we actually deleted the tokens, but were unable to update
  157.     # bayes_vars with the new data.
  158.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  159.     $self->{_dbh}->rollback();
  160.     $deleted = 0;
  161.     goto token_expiration_final;
  162.   }
  163.  
  164.   $self->{_dbh}->commit();
  165.  
  166. token_expiration_final:
  167.   my $kept = $vars[3] - $deleted;
  168.  
  169.   $num_hapaxes = $self->_get_num_hapaxes() if ($opts->{verbose});
  170.   $num_lowfreq = $self->_get_num_lowfreq() if ($opts->{verbose});
  171.  
  172.   # Call untie_db() first so we unlock correctly etc. first
  173.   $self->untie_db();
  174.  
  175.   return ($kept, $deleted, $num_hapaxes, $num_lowfreq);
  176. }
  177.  
  178. =head2 seen_put
  179.  
  180. public (Boolean) seen_put (string $msgid, char $flag)
  181.  
  182. Description:
  183. This method records C<$msgid> as the type given by C<$flag>.  C<$flag> is one of
  184. two values 's' for spam and 'h' for ham.
  185.  
  186. =cut
  187.  
  188. sub seen_put {
  189.   my ($self, $msgid, $flag) = @_;
  190.  
  191.   return 0 if (!$msgid);
  192.   return 0 if (!$flag);
  193.   
  194.   return 0 unless (defined($self->{_dbh}));
  195.  
  196.   my $sql = "INSERT INTO bayes_seen (id, msgid, flag)
  197.              VALUES (?,?,?)";
  198.   
  199.   my $rows = $self->{_dbh}->do($sql,
  200.                    undef,
  201.                    $self->{_userid}, $msgid, $flag);
  202.   
  203.   unless (defined($rows)) {
  204.     dbg("bayes: seen_put: SQL error: ".$self->{_dbh}->errstr());
  205.     $self->{_dbh}->rollback();
  206.     return 0;
  207.   }
  208.  
  209.   dbg("bayes: seen ($msgid) put");
  210.   $self->{_dbh}->commit();
  211.   return 1;
  212. }
  213.  
  214. =head2 seen_delete
  215.  
  216. public instance (Boolean) seen_delete (string $msgid)
  217.  
  218. Description:
  219. This method removes C<$msgid> from the database.
  220.  
  221. =cut
  222.  
  223. sub seen_delete {
  224.   my ($self, $msgid) = @_;
  225.  
  226.   return 0 if (!$msgid);
  227.  
  228.   return 0 unless (defined($self->{_dbh}));
  229.  
  230.   my $sql = "DELETE FROM bayes_seen
  231.               WHERE id = ?
  232.                 AND msgid = ?";
  233.   
  234.   my $rows = $self->{_dbh}->do($sql,
  235.                    undef,
  236.                    $self->{_userid}, $msgid);
  237.  
  238.   unless (defined($rows)) {
  239.     dbg("bayes: seen_delete: SQL error: ".$self->{_dbh}->errstr());
  240.     $self->{_dbh}->rollback();
  241.     return 0;
  242.   }
  243.  
  244.   $self->{_dbh}->commit();
  245.   return 1;
  246. }
  247.  
  248. =head2 set_last_expire
  249.  
  250. public instance (Boolean) set_last_expire (Integer $time)
  251.  
  252. Description:
  253. This method sets the last expire time.
  254.  
  255. =cut
  256.  
  257. sub set_last_expire {
  258.   my ($self, $time) = @_;
  259.  
  260.   return 0 unless (defined($time));
  261.  
  262.   return 0 unless (defined($self->{_dbh}));
  263.  
  264.   my $sql = "UPDATE bayes_vars SET last_expire = ? WHERE id = ?";
  265.  
  266.   my $rows = $self->{_dbh}->do($sql,
  267.                    undef,
  268.                    $time,
  269.                    $self->{_userid});
  270.  
  271.   unless (defined($rows)) {
  272.     dbg("bayes: set_last_expire: SQL error: ".$self->{_dbh}->errstr());
  273.     $self->{_dbh}->rollback();
  274.     return 0;
  275.   }
  276.  
  277.   $self->{_dbh}->commit();
  278.   return 1;
  279. }
  280.  
  281. =head2 set_running_expire_tok
  282.  
  283. public instance (String $time) set_running_expire_tok ()
  284.  
  285. Description:
  286. This method sets the time that an expire starts running.
  287.  
  288. =cut
  289.  
  290. sub set_running_expire_tok {
  291.   my ($self) = @_;
  292.  
  293.   return 0 unless (defined($self->{_dbh}));
  294.  
  295.   my $sql = "INSERT INTO bayes_expire (id,runtime) VALUES (?,?)";
  296.  
  297.   my $time = time();
  298.  
  299.   my $rows = $self->{_dbh}->do($sql,
  300.                    undef,
  301.                    $self->{_userid}, $time);
  302.   unless (defined($rows)) {
  303.     dbg("bayes: set_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  304.     $self->{_dbh}->rollback();
  305.     return undef;
  306.   }
  307.  
  308.   $self->{_dbh}->commit();
  309.   return $time;
  310. }
  311.  
  312. =head2 remove_running_expire_tok
  313.  
  314. public instance (Boolean) remove_running_expire_tok ()
  315.  
  316. Description:
  317. This method removes the row in the database that indicates that
  318. and expire is currently running.
  319.  
  320. =cut
  321.  
  322. sub remove_running_expire_tok {
  323.   my ($self) = @_;
  324.  
  325.   return 0 unless (defined($self->{_dbh}));
  326.  
  327.   my $sql = "DELETE from bayes_expire
  328.               WHERE id = ?";
  329.  
  330.   my $rows = $self->{_dbh}->do($sql, undef, $self->{_userid});
  331.  
  332.   unless (defined($rows)) {
  333.     dbg("bayes: remove_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  334.     $self->{_dbh}->rollback();
  335.     return 0;
  336.   }
  337.  
  338.   $self->{_dbh}->commit();
  339.   return 1;
  340. }
  341.  
  342. =head2 nspam_nham_change
  343.  
  344. public instance (Boolean) nspam_nham_change (Integer $num_spam,
  345.                                              Integer $num_ham)
  346.  
  347. Description:
  348. This method updates the number of spam and the number of ham in the database.
  349.  
  350. =cut
  351.  
  352. sub nspam_nham_change {
  353.   my ($self, $num_spam, $num_ham) = @_;
  354.  
  355.   return 0 unless (defined($self->{_dbh}));
  356.  
  357.   my $sql;
  358.   my @bindings;
  359.  
  360.   if ($num_spam != 0 && $num_ham != 0) {
  361.     $sql = "UPDATE bayes_vars
  362.                SET spam_count = spam_count + ?,
  363.                    ham_count = ham_count + ?
  364.              WHERE id = ?";
  365.     @bindings = ($num_spam, $num_ham, $self->{_userid});
  366.   }
  367.   elsif ($num_spam != 0) {
  368.     $sql = "UPDATE bayes_vars
  369.               SET spam_count = spam_count + ?
  370.              WHERE id = ?";
  371.     @bindings = ($num_spam, $self->{_userid});
  372.   }
  373.   elsif ($num_ham != 0) {
  374.     $sql = "UPDATE bayes_vars
  375.                SET ham_count = ham_count + ?
  376.             WHERE id = ?";
  377.     @bindings = ($num_ham, $self->{_userid});
  378.   }
  379.   else {
  380.     # For some reason called with no delta, it's ok though so just return
  381.     dbg("bayes: nspam_nham_change: Called with no delta on spam or ham");
  382.     return 1;
  383.   }
  384.  
  385.   my $rows = $self->{_dbh}->do($sql,
  386.                    undef,
  387.                    @bindings);
  388.  
  389.   unless (defined($rows)) {
  390.     dbg("bayes: nspam_nham_change: SQL error: ".$self->{_dbh}->errstr());
  391.     $self->{_dbh}->rollback();
  392.     return 0;
  393.   }
  394.  
  395.   $self->{_dbh}->commit();
  396.   return 1;
  397. }
  398.  
  399. =head2 tok_touch
  400.  
  401. public instance (Boolean) tok_touch (String $token,
  402.                                      String $atime)
  403.  
  404. Description:
  405. This method updates the given tokens (C<$token>) atime.
  406.  
  407. The assumption is that the token already exists in the database.
  408.  
  409. =cut
  410.  
  411. sub tok_touch {
  412.   my ($self, $token, $atime) = @_;
  413.  
  414.   return 0 unless (defined($self->{_dbh}));
  415.  
  416.   # shortcut, will only update atime for the token if the atime is less than
  417.   # what we are updating to
  418.   my $sql = "UPDATE bayes_token
  419.                 SET atime = ?
  420.               WHERE id = ?
  421.                 AND token = ?
  422.                 AND atime < ?";
  423.  
  424.   my $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid},
  425.                    $token, $atime);
  426.  
  427.   unless (defined($rows)) {
  428.     dbg("bayes: tok_touch: SQL error: ".$self->{_dbh}->errstr());
  429.     $self->{_dbh}->rollback();
  430.     return 0;
  431.   }
  432.  
  433.   # if we didn't update a row then no need to update newest_token_age
  434.   return 1 if ($rows eq '0E0');
  435.  
  436.   # need to check newest_token_age
  437.   # no need to check oldest_token_age since we would only update if the
  438.   # atime was newer than what is in the database
  439.   $sql = "UPDATE bayes_vars
  440.              SET newest_token_age = ?
  441.            WHERE id = ?
  442.              AND newest_token_age < ?";
  443.  
  444.   $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  445.  
  446.   unless (defined($rows)) {
  447.     dbg("bayes: tok_touch: SQL error: ".$self->{_dbh}->errstr());
  448.     $self->{_dbh}->rollback();
  449.     return 0;
  450.   }
  451.  
  452.   $self->{_dbh}->commit();
  453.   return 1;
  454. }
  455.  
  456. =head2 tok_touch_all
  457.  
  458. public instance (Boolean) tok_touch (\@ $tokens
  459.                                      String $atime)
  460.  
  461. Description:
  462. This method does a mass update of the given list of tokens C<$tokens>, if the existing token
  463. atime is < C<$atime>.
  464.  
  465. The assumption is that the tokens already exist in the database.
  466.  
  467. We should never be touching more than N_SIGNIFICANT_TOKENS, so we can make
  468. some assumptions about how to handle the data (ie no need to batch like we
  469. do in tok_get_all)
  470.  
  471. =cut
  472.  
  473. sub tok_touch_all {
  474.   my ($self, $tokens, $atime) = @_;
  475.  
  476.   return 0 unless (defined($self->{_dbh}));
  477.  
  478.   return 1 unless (scalar(@{$tokens}));
  479.  
  480.   my $sql = "UPDATE bayes_token SET atime = ? WHERE id = ? AND token IN (";
  481.  
  482.   my @bindings = ($atime, $self->{_userid});
  483.   foreach my $token (@{$tokens}) {
  484.     $sql .= "?,";
  485.     push(@bindings, $token);
  486.   }
  487.   chop($sql); # get rid of trailing ,
  488.  
  489.   $sql .= ") AND atime < ?";
  490.   push(@bindings, $atime);
  491.  
  492.   my $rows = $self->{_dbh}->do($sql, undef, @bindings);
  493.  
  494.   unless (defined($rows)) {
  495.     dbg("bayes: tok_touch_all: SQL error: ".$self->{_dbh}->errstr());
  496.     $self->{_dbh}->rollback();
  497.     return 0;
  498.   }
  499.  
  500.   # if we didn't update a row then no need to update newest_token_age
  501.   return 1 if ($rows eq '0E0');
  502.  
  503.   # need to check newest_token_age
  504.   # no need to check oldest_token_age since we would only update if the
  505.   # atime was newer than what is in the database
  506.   $sql = "UPDATE bayes_vars
  507.              SET newest_token_age = ?
  508.            WHERE id = ?
  509.              AND newest_token_age < ?";
  510.  
  511.   $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  512.  
  513.   unless (defined($rows)) {
  514.     dbg("bayes: tok_touch_all: SQL error: ".$self->{_dbh}->errstr());
  515.     $self->{_dbh}->rollback();
  516.     return 0;
  517.   }
  518.  
  519.   $self->{_dbh}->commit();
  520.   return 1;
  521. }
  522.  
  523. =head2 cleanup
  524.  
  525. public instance (Boolean) cleanup ()
  526.  
  527. Description:
  528. This method peroms any cleanup necessary before moving onto the next
  529. operation.
  530.  
  531. =cut
  532.  
  533. sub cleanup {
  534.   my ($self) = @_;
  535.  
  536.   return 1 unless ($self->{needs_cleanup});
  537.  
  538.   # cleanup was needed, go ahead and clear the cleanup flag
  539.   $self->{needs_cleanup} = 0;
  540.  
  541.   my $sql = "DELETE from bayes_token
  542.               WHERE id = ?
  543.                 AND spam_count <= 0
  544.                 AND ham_count <= 0";
  545.  
  546.   my $toks_deleted = $self->{_dbh}->do($sql, undef, $self->{_userid});
  547.  
  548.   unless (defined($toks_deleted)) {
  549.     dbg("bayes: cleanup: SQL error: ".$self->{_dbh}->errstr());
  550.     $self->{_dbh}->rollback();
  551.     return 0;
  552.   }       
  553.  
  554.   # check to see if any tokens where deleted
  555.   return 1 if ($toks_deleted eq '0E0');
  556.  
  557.   $sql = "UPDATE bayes_vars SET token_count = token_count - ? WHERE id = ?";
  558.  
  559.   my $rows = $self->{_dbh}->do($sql, undef, $toks_deleted, $self->{_userid});
  560.  
  561.   unless (defined($rows)) {
  562.     dbg("bayes: cleanup: SQL error: ".$self->{_dbh}->errstr());
  563.     $self->{_dbh}->rollback();
  564.     return 0;
  565.   }       
  566.  
  567.   $self->{_dbh}->commit();
  568.   return 1;
  569. }
  570.  
  571. =head2 clear_database
  572.  
  573. public instance (Boolean) clear_database ()
  574.  
  575. Description:
  576. This method deletes all records for a particular user.
  577.  
  578. Callers should be aware that any errors returned by this method
  579. could causes the database to be inconsistent for the given user.
  580.  
  581. =cut
  582.  
  583. sub clear_database {
  584.   my ($self) = @_;
  585.  
  586.   # We want to open readonly first, because if they don't already have
  587.   # a db entry, we want to avoid creating one, just to delete it in a few secs
  588.   if ($self->tie_db_readonly()) {
  589.     # Ok, they must have had a db entry, so now make the connection writable
  590.     $self->tie_db_writable();
  591.   }
  592.   else {
  593.     # If we were unable to create a readonly connection then they must
  594.     # not have a db entry, so no need to clear.
  595.     # But it should be considered a success.
  596.     return 1;
  597.   }
  598.  
  599.   return 0 unless (defined($self->{_dbh}));
  600.  
  601.   my $rows = $self->{_dbh}->do("DELETE FROM bayes_vars WHERE id = ?",
  602.                    undef,
  603.                    $self->{_userid});
  604.   unless (defined($rows)) {
  605.     dbg("bayes: SQL error removing user (bayes_vars) data: ".$self->{_dbh}->errstr());
  606.     $self->{_dbh}->rollback();
  607.     return 0;
  608.   }
  609.  
  610.   $rows = $self->{_dbh}->do("DELETE FROM bayes_seen WHERE id = ?",
  611.                 undef,
  612.                 $self->{_userid});
  613.   unless (defined($rows)) {
  614.     dbg("bayes: SQL error removing seen data: ".$self->{_dbh}->errstr());
  615.     $self->{_dbh}->rollback();
  616.     return 0;
  617.   }
  618.  
  619.   $rows = $self->{_dbh}->do("DELETE FROM bayes_token WHERE id = ?",
  620.                 undef,
  621.                 $self->{_userid});
  622.   unless (defined($rows)) {
  623.     dbg("bayes: SQL error removing token data: ".$self->{_dbh}->errstr());
  624.     $self->{_dbh}->rollback();
  625.     return 0;
  626.   }
  627.  
  628.   $self->{_dbh}->commit();
  629.   return 1;
  630. }
  631.  
  632. =head1 Private Methods
  633.  
  634. =head2 _connect_db
  635.  
  636. private instance (Boolean) _connect_db ()
  637.  
  638. Description:
  639. This method connects to the SQL database.
  640.  
  641. =cut
  642.  
  643. sub _connect_db {
  644.   my ($self) = @_;
  645.  
  646.   $self->{_dbh} = undef;
  647.  
  648.   # Turn off PrintError and explicitly set AutoCommit to off
  649.   my $dbh = DBI->connect($self->{_dsn}, $self->{_dbuser}, $self->{_dbpass},
  650.                         {'PrintError' => 0, 'AutoCommit' => 0});
  651.  
  652.   if (!$dbh) {
  653.     dbg("bayes: unable to connect to database: ".DBI->errstr());
  654.     return 0;
  655.   }
  656.   else {
  657.     dbg("bayes: database connection established");
  658.   }
  659.  
  660.   $self->{_dbh} = $dbh;
  661.  
  662.  return 1;
  663. }
  664.  
  665. =head2 _initialize_db
  666.  
  667. private instance (Boolean) _initialize_db ()
  668.  
  669. Description:
  670. This method will check to see if a user has had their bayes variables
  671. initialized. If not then it will perform this initialization.
  672.  
  673. =cut
  674.  
  675. sub _initialize_db {
  676.   my ($self, $create_entry_p) = @_;
  677.  
  678.   return 0 unless (defined($self->{_dbh}));
  679.  
  680.   return 0 if (!$self->{_username});
  681.  
  682.   # Check to see if we should call the services_authorized_for_username plugin
  683.   # hook to see if this user is allowed/able to use bayes.  If not, do nothing
  684.   # and return 0.
  685.   if ($self->{bayes}->{conf}->{bayes_sql_username_authorized}) {
  686.     my $services = { 'bayessql' => 0 };
  687.     $self->{bayes}->{main}->call_plugins("services_allowed_for_username",
  688.                      { services => $services,
  689.                        username => $self->{_username},
  690.                        conf => $self->{bayes}->{conf},
  691.                      });
  692.     
  693.     unless ($services->{bayessql}) {
  694.       dbg("bayes: username not allowed by services_allowed_for_username plugin call");
  695.       return 0;
  696.     }
  697.   }
  698.  
  699.   my $sqlselect = "SELECT id FROM bayes_vars WHERE username = ?";
  700.  
  701.   my $sthselect = $self->{_dbh}->prepare_cached($sqlselect);
  702.  
  703.   unless (defined($sthselect)) {
  704.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  705.     return 0;
  706.   }
  707.  
  708.   my $rc = $sthselect->execute($self->{_username});
  709.  
  710.   unless ($rc) {
  711.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  712.     return 0;
  713.   }
  714.  
  715.   my ($id) = $sthselect->fetchrow_array();
  716.  
  717.   if ($id) {
  718.     $self->{_userid} = $id;
  719.     dbg("bayes: Using userid: ".$self->{_userid});
  720.     $sthselect->finish();
  721.     return 1;
  722.   }
  723.  
  724.   # Do not create an entry for this user unless we were specifically asked to
  725.   return 0 unless ($create_entry_p);
  726.  
  727.   # For now let the database setup the other variables as defaults
  728.   my $sqlinsert = "INSERT INTO bayes_vars (username) VALUES (?)";
  729.  
  730.   my $rows = $self->{_dbh}->do($sqlinsert,
  731.                    undef,
  732.                    $self->{_username});
  733.   unless (defined($rows)) {
  734.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  735.     $self->{_dbh}->rollback();
  736.     return 0;
  737.   }
  738.  
  739.   $id = $self->{_dbh}->{'mysql_insertid'};
  740.  
  741.   $self->{_dbh}->commit();
  742.  
  743.   if ($id) {
  744.     $self->{_userid} = $id;
  745.     dbg("bayes: using userid: ".$self->{_userid});
  746.     return 1;
  747.   }
  748.  
  749.   return 1;
  750. }
  751.  
  752. =head2 _put_token
  753.  
  754. private instance (Boolean) _put_token (string $token,
  755.                                        integer $spam_count,
  756.                                        integer $ham_count,
  757.                        string $atime)
  758.  
  759. Description:
  760. This method performs the work of either inserting or updating a token in
  761. the database.
  762.  
  763. =cut
  764.  
  765. sub _put_token {
  766.   my ($self, $token, $spam_count, $ham_count, $atime) = @_;
  767.  
  768.   return 0 unless (defined($self->{_dbh}));
  769.  
  770.   $spam_count ||= 0;
  771.   $ham_count ||= 0;
  772.  
  773.   if ($spam_count == 0 && $ham_count == 0) {
  774.     return 1;
  775.   }
  776.  
  777.   # the case where spam_count of ham_count is < 0 is special, it assumes
  778.   # that there already exists a token (although there might actually not be
  779.   # be one) that will be updated.  So we just do the update, being careful
  780.   # to not allow the spam_count or ham_count to not drop below 0
  781.   # In addition, when lowering the spam_count or ham_count we will not be
  782.   # updating the atime value
  783.   if ($spam_count < 0 || $ham_count < 0) {
  784.     # we only need to cleanup when we subtract counts for a token and the
  785.     # counts may have both reached 0
  786.     $self->{needs_cleanup} = 1;
  787.  
  788.     my $sql = "UPDATE bayes_token SET spam_count = GREATEST(spam_count + ?, 0),
  789.                                       ham_count = GREATEST(ham_count + ?, 0)
  790.                 WHERE id = ?
  791.                   AND token = ?";
  792.  
  793.     my $sth = $self->{_dbh}->prepare_cached($sql);
  794.  
  795.     unless (defined($sth)) {
  796.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  797.       $self->{_dbh}->rollback();
  798.       return 0;
  799.     }
  800.  
  801.     my $rc = $sth->execute($spam_count,
  802.                $ham_count,
  803.                $self->{_userid},
  804.                $token);
  805.  
  806.     unless ($rc) {
  807.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  808.       $self->{_dbh}->rollback();
  809.       return 0;
  810.     }
  811.   }
  812.   else {
  813.     my $sql = "INSERT INTO bayes_token
  814.                (id, token, spam_count, ham_count, atime)
  815.                VALUES (?,?,?,?,?)
  816.                ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + ?, 0),
  817.                                        ham_count = GREATEST(ham_count + ?, 0),
  818.                                        atime = GREATEST(atime, ?)";
  819.  
  820.     my $sth = $self->{_dbh}->prepare_cached($sql);
  821.  
  822.     unless (defined($sth)) {
  823.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  824.       $self->{_dbh}->rollback();
  825.       return 0;
  826.     }
  827.  
  828.     my $rc = $sth->execute($self->{_userid},
  829.                $token,
  830.                $spam_count,
  831.                $ham_count,
  832.                $atime,
  833.                $spam_count,
  834.                $ham_count,
  835.                $atime);
  836.  
  837.     unless ($rc) {
  838.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  839.       $self->{_dbh}->rollback();
  840.       return 0;
  841.     }
  842.  
  843.     my $num_rows = $rc;
  844.  
  845.     $sth->finish();
  846.  
  847.     if ($num_rows == 1 || $num_rows == 2) {
  848.       my $token_count_update = '';
  849.       
  850.       $token_count_update = "token_count = token_count + 1," if ($num_rows == 1);
  851.       $sql = "UPDATE bayes_vars SET
  852.                      $token_count_update
  853.                      newest_token_age = GREATEST(newest_token_age, ?),
  854.                      oldest_token_age = LEAST(oldest_token_age, ?)
  855.                WHERE id = ?";
  856.  
  857.       $sth = $self->{_dbh}->prepare_cached($sql);
  858.  
  859.       unless (defined($sth)) {
  860.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  861.     $self->{_dbh}->rollback();
  862.     return 0;
  863.       }
  864.  
  865.       my $rc = $sth->execute($atime, $atime, $self->{_userid});
  866.  
  867.       unless ($rc) {
  868.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  869.     $self->{_dbh}->rollback();
  870.     return 0;
  871.       }
  872.     }
  873.     else {
  874.       # $num_rows was not what we expected
  875.       dbg("bayes: _put_token: Updated an unexpected number of rows.");
  876.       $self->{_dbh}->rollback();
  877.       return 0;
  878.     }
  879.   }
  880.  
  881.   $self->{_dbh}->commit();
  882.   return 1;
  883. }
  884.  
  885. =head2 _put_tokens
  886.  
  887. private instance (Boolean) _put_tokens (\% $tokens,
  888.                                         integer $spam_count,
  889.                                         integer $ham_count,
  890.                          string $atime)
  891.  
  892. Description:
  893. This method performs the work of either inserting or updating tokens in
  894. the database.
  895.  
  896. =cut
  897.  
  898. sub _put_tokens {
  899.   my ($self, $tokens, $spam_count, $ham_count, $atime) = @_;
  900.  
  901.   return 0 unless (defined($self->{_dbh}));
  902.  
  903.   $spam_count ||= 0;
  904.   $ham_count ||= 0;
  905.  
  906.   if ($spam_count == 0 && $ham_count == 0) {
  907.     return 1;
  908.   }
  909.  
  910.   # the case where spam_count of ham_count is < 0 is special, it assumes
  911.   # that there already exists a token (although there might actually not be
  912.   # be one) that will be updated.  So we just do the update, being careful
  913.   # to not allow the spam_count or ham_count to not drop below 0
  914.   # In addition, when lowering the spam_count or ham_count we will not be
  915.   # updating the atime value
  916.   if ($spam_count < 0 || $ham_count < 0) {
  917.     # we only need to cleanup when we subtract counts for a token and the
  918.     # counts may have both reached 0
  919.     $self->{needs_cleanup} = 1;
  920.  
  921.     my $sql = "UPDATE bayes_token SET spam_count = GREATEST(spam_count + ?, 0),
  922.                                       ham_count = GREATEST(ham_count + ?, 0)
  923.                 WHERE id = ?
  924.                   AND token = ?";
  925.  
  926.     my $sth = $self->{_dbh}->prepare_cached($sql);
  927.  
  928.     unless (defined($sth)) {
  929.       dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  930.       $self->{_dbh}->rollback();
  931.       return 0;
  932.     }
  933.  
  934.     my $error_p = 0;
  935.     foreach my $token (keys %{$tokens}) {
  936.       my $rc = $sth->execute($spam_count,
  937.                  $ham_count,
  938.                  $self->{_userid},
  939.                  $token);
  940.  
  941.       unless ($rc) {
  942.     dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  943.     $error_p = 1;
  944.       }
  945.     }
  946.  
  947.     $sth->finish();
  948.  
  949.     if ($error_p) {
  950.       $self->{_dbh}->rollback();
  951.       return 0;
  952.     }
  953.   }
  954.   else {
  955.     my $sql = "INSERT INTO bayes_token
  956.                (id, token, spam_count, ham_count, atime)
  957.                VALUES (?,?,?,?,?)
  958.                ON DUPLICATE KEY UPDATE spam_count = GREATEST(spam_count + ?, 0),
  959.                                        ham_count = GREATEST(ham_count + ?, 0),
  960.                                        atime = GREATEST(atime, ?)";
  961.  
  962.     my $sth = $self->{_dbh}->prepare_cached($sql);
  963.  
  964.     unless (defined($sth)) {
  965.       dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  966.       $self->{_dbh}->rollback();
  967.       return 0;
  968.     }
  969.  
  970.     my $error_p = 0;
  971.     my $new_tokens = 0;
  972.     my $need_atime_update_p = 0;
  973.     foreach my $token (keys %{$tokens}) {
  974.       my $rc = $sth->execute($self->{_userid},
  975.                  $token,
  976.                  $spam_count,
  977.                  $ham_count,
  978.                  $atime,
  979.                  $spam_count,
  980.                  $ham_count,
  981.                  $atime);
  982.  
  983.       if (!$rc) {
  984.     dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  985.     $error_p = 1;
  986.       }
  987.       else {
  988.     my $num_rows = $rc;
  989.  
  990.     $need_atime_update_p = 1 if ($num_rows == 1 || $num_rows == 2);
  991.     $new_tokens++ if ($num_rows == 1);
  992.       }
  993.     }
  994.  
  995.     $sth->finish();
  996.  
  997.     if ($error_p) {
  998.       $self->{_dbh}->rollback();
  999.       return 0;
  1000.     }
  1001.  
  1002.     if ($need_atime_update_p) {
  1003.       my $token_count_update = '';
  1004.       
  1005.       $token_count_update = "token_count = token_count + $new_tokens," if ($new_tokens);
  1006.       $sql = "UPDATE bayes_vars SET
  1007.                      $token_count_update
  1008.                      newest_token_age = GREATEST(newest_token_age, ?),
  1009.                      oldest_token_age = LEAST(oldest_token_age, ?)
  1010.                WHERE id = ?";
  1011.  
  1012.       $sth = $self->{_dbh}->prepare_cached($sql);
  1013.  
  1014.       unless (defined($sth)) {
  1015.     dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  1016.     $self->{_dbh}->rollback();
  1017.     return 0;
  1018.       }
  1019.  
  1020.       my $rc = $sth->execute($atime, $atime, $self->{_userid});
  1021.  
  1022.       unless ($rc) {
  1023.     dbg("bayes: _put_tokens: SQL error: ".$self->{_dbh}->errstr());
  1024.     $self->{_dbh}->rollback();
  1025.     return 0;
  1026.       }
  1027.     }
  1028.     else {
  1029.       # $num_rows was not what we expected
  1030.       dbg("bayes: _put_tokens: Updated an unexpected number of rows.");
  1031.       $self->{_dbh}->rollback();
  1032.       return 0;
  1033.     }
  1034.   }
  1035.  
  1036.   $self->{_dbh}->commit();
  1037.   return 1;
  1038. }
  1039.  
  1040. sub sa_die { Mail::SpamAssassin::sa_die(@_); }
  1041.  
  1042. 1;
  1043.