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 / SQL.pm < prev   
Text File  |  2006-11-29  |  59KB  |  2,351 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::SQL - SQL Bayesian Storage Module Implementation
  21.  
  22. =head1 SYNOPSIS
  23.  
  24. =head1 DESCRIPTION
  25.  
  26. This module implementes a SQL based bayesian storage module.
  27.  
  28. =cut
  29.  
  30. package Mail::SpamAssassin::BayesStore::SQL;
  31.  
  32. use strict;
  33. use warnings;
  34. use bytes;
  35.  
  36. use Mail::SpamAssassin::BayesStore;
  37. use Mail::SpamAssassin::Logger;
  38. use Digest::SHA1 qw(sha1);
  39.  
  40. use vars qw( @ISA );
  41.  
  42. @ISA = qw( Mail::SpamAssassin::BayesStore );
  43.  
  44. use constant HAS_DBI => eval { require DBI; };
  45.  
  46. =head1 METHODS
  47.  
  48. =head2 new
  49.  
  50. public class (Mail::SpamAssassin::BayesStore::SQL) new (Mail::Spamassassin::Bayes $bayes)
  51.  
  52. Description:
  53. This methods creates a new instance of the Mail::SpamAssassin::BayesStore::SQL
  54. object.  It expects to be passed an instance of the Mail::SpamAssassin:Bayes
  55. object which is passed into the Mail::SpamAssassin::BayesStore parent object.
  56.  
  57. This method sets up the database connection and determines the username to
  58. use in queries.
  59.  
  60. =cut
  61.  
  62. sub new {
  63.   my $class = shift;
  64.   $class = ref($class) || $class;
  65.  
  66.   my $self = $class->SUPER::new(@_);
  67.  
  68.   $self->{supported_db_version} = 3;
  69.   $self->{db_writable_p} = 0;
  70.  
  71.   if (!$self->{bayes}->{conf}->{bayes_sql_dsn}) {
  72.     dbg("bayes: invalid config, must set bayes_sql_dsn config variable\n");
  73.     return undef;
  74.   }
  75.  
  76.   $self->{_dsn} = $self->{bayes}->{conf}->{bayes_sql_dsn};
  77.   $self->{_dbuser} = $self->{bayes}->{conf}->{bayes_sql_username};
  78.   $self->{_dbpass} = $self->{bayes}->{conf}->{bayes_sql_password};
  79.  
  80.   $self->{_dbh} = undef;
  81.  
  82.   unless (HAS_DBI) {
  83.     dbg("bayes: unable to connect to database: DBI module not available: $!");
  84.   }
  85.  
  86.   if ($self->{bayes}->{conf}->{bayes_sql_override_username}) {
  87.     $self->{_username} = $self->{bayes}->{conf}->{bayes_sql_override_username};
  88.   }
  89.   else {
  90.     $self->{_username} = $self->{bayes}->{main}->{username};
  91.  
  92.     # Need to make sure that a username is set, so just in case there is
  93.     # no username set in main, set one here.
  94.     unless ($self->{_username}) {
  95.       $self->{_username} = "GLOBALBAYES";
  96.     }
  97.   }
  98.   dbg("bayes: using username: ".$self->{_username});
  99.  
  100.   return $self;
  101. }
  102.  
  103. =head2 tie_db_readonly
  104.  
  105. public instance (Boolean) tie_db_readonly ();
  106.  
  107. Description:
  108. This method ensures that the database connection is properly setup
  109. and working.  If necessary it will initialize a user's bayes variables
  110. so that they can begin using the database immediately.
  111.  
  112. =cut
  113.  
  114. sub tie_db_readonly {
  115.   my ($self) = @_;
  116.  
  117.   return 0 unless (HAS_DBI);
  118.  
  119.   if ($self->{_dbh}) {
  120.     # already connected, but connection has now become readonly
  121.     $self->{db_writable_p} = 0;
  122.     return 1;
  123.   }
  124.  
  125.   my $main = $self->{bayes}->{main};
  126.  
  127.   $self->read_db_configs();
  128.  
  129.   return 0 unless ($self->_connect_db());
  130.  
  131.   my $db_ver = $self->_get_db_version();
  132.   $self->{db_version} = $db_ver;
  133.   dbg("bayes: found bayes db version ".$self->{db_version});
  134.  
  135.   if ( $db_ver != $self->DB_VERSION ) {
  136.     warn("bayes: database version $db_ver is different than we understand (".$self->DB_VERSION."), aborting!");
  137.     $self->untie_db();
  138.     return 0;
  139.   }
  140.  
  141.   unless ($self->_initialize_db(0)) {
  142.     dbg("bayes: unable to initialize database for ".$self->{_username}." user, aborting!");
  143.     $self->untie_db();
  144.     return 0;
  145.   }
  146.  
  147.   return 1;
  148. }
  149.  
  150. =head2 tie_db_writable
  151.  
  152. public instance (Boolean) tie_db_writable ()
  153.  
  154. Description:
  155. This method ensures that the database connetion is properly setup
  156. and working. If necessary it will initialize a users bayes variables
  157. so that they can begin using the database immediately.
  158.  
  159. =cut
  160.  
  161. sub tie_db_writable {
  162.   my ($self) = @_;
  163.  
  164.   return 0 unless (HAS_DBI);
  165.  
  166.   if ($self->{_dbh}) {
  167.     # already connected, but now it will be writable
  168.     $self->{db_writable_p} = 1;
  169.     return 1;
  170.   }
  171.  
  172.   my $main = $self->{bayes}->{main};
  173.  
  174.   $self->read_db_configs();
  175.  
  176.   return 0 unless ($self->_connect_db());
  177.  
  178.   my $db_ver = $self->_get_db_version();
  179.   $self->{db_version} = $db_ver;
  180.   dbg("bayes: found bayes db version ".$self->{db_version});
  181.  
  182.   if ( $db_ver != $self->DB_VERSION ) {
  183.     warn("bayes: database version $db_ver is different than we understand (".$self->DB_VERSION."), aborting!");
  184.     $self->untie_db();
  185.     return 0;
  186.   }
  187.  
  188.   unless ($self->_initialize_db(1)) {
  189.     dbg("bayes: unable to initialize database for ".$self->{_username}." user, aborting!");
  190.  
  191.     $self->untie_db();
  192.     return 0;
  193.   }
  194.  
  195.   $self->{db_writable_p} = 1;
  196.  
  197.   return 1;
  198. }
  199.  
  200.  
  201. =head2 untie_db
  202.  
  203. public instance () untie_db ()
  204.  
  205. Description:
  206. This method is unused for the SQL based implementation.
  207.  
  208. =cut
  209.  
  210. sub untie_db {
  211.   my ($self) = @_;
  212.  
  213.   return unless (defined($self->{_dbh}));
  214.  
  215.   $self->{db_writable_p} = 0;
  216.  
  217.   $self->{_dbh}->disconnect();
  218.   $self->{_dbh} = undef;
  219. }
  220.  
  221. =head2 calculate_expire_delta
  222.  
  223. public instance (%) calculate_expire_delta (Integer $newest_atime,
  224.                                              Integer $start,
  225.                                              Integer $max_expire_mult)
  226.  
  227. Description:
  228. This method performs a calculation on the data to determine the optimum
  229. atime for token expiration.
  230.  
  231. =cut
  232.  
  233. sub calculate_expire_delta {
  234.   my ($self, $newest_atime, $start, $max_expire_mult) = @_;
  235.  
  236.   my %delta = (); # use a hash since an array is going to be very sparse
  237.  
  238.   return %delta unless (defined($self->{_dbh}));
  239.  
  240.   my $sql = "SELECT count(*)
  241.                FROM bayes_token
  242.               WHERE id = ?
  243.                 AND (? - atime) > ?";
  244.  
  245.   my $sth = $self->{_dbh}->prepare_cached($sql);
  246.     
  247.   unless (defined($sth)) {
  248.     dbg("bayes: calculate_expire_delta: SQL Error: ".$self->{_dbh}->errstr());
  249.     return %delta;
  250.   }
  251.  
  252.   for (my $i = 1; $i <= $max_expire_mult; $i<<=1) {
  253.     my $rc = $sth->execute($self->{_userid}, $newest_atime, $start * $i);
  254.  
  255.     unless ($rc) {
  256.       dbg("bayes: calculate_expire_delta: SQL error: ".$self->{_dbh}->errstr());
  257.       return undef;
  258.     }
  259.  
  260.     my ($count) = $sth->fetchrow_array();
  261.  
  262.     $delta{$i} = $count;
  263.   }
  264.   $sth->finish();
  265.  
  266.   return %delta;
  267. }
  268.  
  269. =head2 token_expiration
  270.  
  271. public instance (Integer, Integer,
  272.                  Integer, Integer) token_expiration(\% $opts,
  273.                                                     Integer $newdelta,
  274.                                                     @ @vars)
  275.  
  276. Description:
  277. This method performs the database specific expiration of tokens based on
  278. the passed in C<$newdelta> and C<@vars>.
  279.  
  280. =cut
  281.  
  282. sub token_expiration {
  283.   my ($self, $opts, $newdelta, @vars) = @_;
  284.  
  285.   my $num_hapaxes;
  286.   my $num_lowfreq;
  287.   my $deleted;
  288.  
  289.   # Figure out how old is too old...
  290.   my $too_old = $vars[10] - $newdelta; # tooold = newest - delta
  291.  
  292.   # if token atime > newest, reset to newest ...
  293.   my $sql = "UPDATE bayes_token SET atime = ?
  294.               WHERE id  = ?
  295.                 AND atime > ?";
  296.  
  297.   my $rows = $self->{_dbh}->do($sql, undef, $vars[10], $self->{_userid}, $vars[10]);
  298.  
  299.   unless (defined($rows)) {
  300.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  301.     $deleted = 0;
  302.     goto token_expiration_final;
  303.   }
  304.  
  305.   # Check to make sure the expire won't remove too many tokens
  306.   $sql = "SELECT count(token) FROM bayes_token
  307.            WHERE id = ?
  308.              AND atime < ?";
  309.  
  310.   my $sth = $self->{_dbh}->prepare_cached($sql);
  311.  
  312.   unless (defined($sth)) {
  313.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  314.     $deleted = 0;
  315.     goto token_expiration_final;
  316.   }
  317.  
  318.   my $rc = $sth->execute($self->{_userid}, $too_old);
  319.   
  320.   unless ($rc) {
  321.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  322.     $deleted = 0;
  323.     goto token_expiration_final;
  324.   }
  325.  
  326.   my ($count) = $sth->fetchrow_array();
  327.  
  328.   $sth->finish();
  329.  
  330.   # Sanity check: if we expired too many tokens, abort!
  331.   if ($vars[3] - $count < 100000) {
  332.     dbg("bayes: token expiration would expire too many tokens, aborting");
  333.     # set these appropriately so the next expire pass does the first pass
  334.     $deleted = 0;
  335.     $newdelta = 0;
  336.   }
  337.   else {
  338.     # Do the expire
  339.     $sql = "DELETE from bayes_token
  340.              WHERE id = ?
  341.                AND atime < ?";
  342.  
  343.     $rows = $self->{_dbh}->do($sql, undef, $self->{_userid}, $too_old);
  344.  
  345.     unless (defined($rows)) {
  346.       dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  347.       $deleted = 0;
  348.       goto token_expiration_final;
  349.     }
  350.  
  351.     $deleted = $rows;
  352.   }
  353.  
  354.   # Update the magic tokens as appropriate
  355.   $sql = "UPDATE bayes_vars SET token_count = token_count - ?,
  356.                                 last_expire = ?,
  357.                                 last_atime_delta = ?,
  358.                                 last_expire_reduce = ?
  359.                 WHERE id = ?";
  360.  
  361.   $rows = $self->{_dbh}->do($sql, undef, $deleted, time(), $newdelta, $deleted, $self->{_userid});
  362.  
  363.   unless (defined($rows)) {
  364.     # Very bad, we actually deleted the tokens, but were unable to update
  365.     # bayes_vars with the new data.
  366.     dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  367.     dbg("bayes: bayes database now in inconsistent state, suggest a backup/restore");
  368.     goto token_expiration_final;
  369.   }
  370.  
  371.   # If we didn't remove any tokens, the oldest token age wouldn't have changed
  372.   if ($deleted) {
  373.     # Now lets update the oldest_token_age value, shouldn't need to worry about
  374.     # newest_token_age. There is a slight race condition here, but the chance is
  375.     # small that we'll insert a new token with such an old atime
  376.     my $oldest_token_age = $self->_get_oldest_token_age();
  377.  
  378.     $sql = "UPDATE bayes_vars SET oldest_token_age = ? WHERE id = ?";
  379.  
  380.     $rows = $self->{_dbh}->do($sql, undef, $oldest_token_age, $self->{_userid});
  381.  
  382.     unless (defined($rows)) {
  383.       # not much more we can do here, so just warn the user and bail out
  384.       dbg("bayes: token_expiration: SQL error: ".$self->{_dbh}->errstr());
  385.       # yeah I know it's the next thing anyway, but here in case someone adds
  386.       # additional code below this block
  387.       goto token_expiration_final; 
  388.     }
  389.   }
  390.  
  391. token_expiration_final:
  392.   my $kept = $vars[3] - $deleted;
  393.  
  394.   $num_hapaxes = $self->_get_num_hapaxes() if ($opts->{verbose});
  395.   $num_lowfreq = $self->_get_num_lowfreq() if ($opts->{verbose});
  396.  
  397.   # Call untie_db() first so we unlock correctly etc. first
  398.   $self->untie_db();
  399.  
  400.   return ($kept, $deleted, $num_hapaxes, $num_lowfreq);
  401. }
  402.  
  403. =head2 sync_due
  404.  
  405. public instance (Boolean) sync_due ()
  406.  
  407. Description:
  408. This method determines if a database sync is currently required.
  409.  
  410. Unused for SQL based implementation.
  411.  
  412. =cut
  413.  
  414. sub sync_due {
  415.   my ($self) = @_;
  416.  
  417.   return 0;
  418. }
  419.  
  420. =head2 seen_get
  421.  
  422. public instance (String) seen_get (string $msgid)
  423.  
  424. Description:
  425. This method retrieves the stored value, if any, for C<$msgid>.  The return value
  426. is the stored string ('s' for spam and 'h' for ham) or undef if C<$msgid> is not
  427. found.
  428.  
  429. =cut
  430.  
  431. sub seen_get {
  432.   my ($self, $msgid) = @_;
  433.  
  434.   return undef unless (defined($self->{_dbh}));
  435.  
  436.   my $sql = "SELECT flag FROM bayes_seen
  437.               WHERE id = ?
  438.                 AND msgid = ?";
  439.  
  440.   my $sth = $self->{_dbh}->prepare_cached($sql);
  441.  
  442.   unless (defined($sth)) {
  443.     dbg("bayes: seen_get: SQL Error: ".$self->{_dbh}->errstr());
  444.     return undef;
  445.   }
  446.  
  447.   my $rc = $sth->execute($self->{_userid}, $msgid);
  448.   
  449.   unless ($rc) {
  450.     dbg("bayes: seen_get: SQL error: ".$self->{_dbh}->errstr());
  451.     return undef;
  452.   }
  453.  
  454.   my ($flag) = $sth->fetchrow_array();
  455.  
  456.   $sth->finish();
  457.   
  458.   return $flag;
  459. }
  460.  
  461. =head2 seen_put
  462.  
  463. public (Boolean) seen_put (string $msgid, char $flag)
  464.  
  465. Description:
  466. This method records C<$msgid> as the type given by C<$flag>.  C<$flag> is one of
  467. two values 's' for spam and 'h' for ham.
  468.  
  469. =cut
  470.  
  471. sub seen_put {
  472.   my ($self, $msgid, $flag) = @_;
  473.  
  474.   return 0 if (!$msgid);
  475.   return 0 if (!$flag);
  476.   
  477.   return 0 unless (defined($self->{_dbh}));
  478.  
  479.   my $sql = "INSERT INTO bayes_seen (id, msgid, flag)
  480.              VALUES (?,?,?)";
  481.   
  482.   my $rows = $self->{_dbh}->do($sql,
  483.                    undef,
  484.                    $self->{_userid}, $msgid, $flag);
  485.   
  486.   unless (defined($rows)) {
  487.     dbg("bayes: seen_put: SQL error: ".$self->{_dbh}->errstr());
  488.     return 0;
  489.   }
  490.  
  491.   dbg("bayes: seen ($msgid) put");
  492.   return 1;
  493. }
  494.  
  495. =head2 seen_delete
  496.  
  497. public instance (Boolean) seen_delete (string $msgid)
  498.  
  499. Description:
  500. This method removes C<$msgid> from the database.
  501.  
  502. =cut
  503.  
  504. sub seen_delete {
  505.   my ($self, $msgid) = @_;
  506.  
  507.   return 0 if (!$msgid);
  508.  
  509.   return 0 unless (defined($self->{_dbh}));
  510.  
  511.   my $sql = "DELETE FROM bayes_seen
  512.               WHERE id = ?
  513.                 AND msgid = ?";
  514.   
  515.   my $rows = $self->{_dbh}->do($sql,
  516.                    undef,
  517.                    $self->{_userid}, $msgid);
  518.  
  519.   unless (defined($rows)) {
  520.     dbg("bayes: seen_delete: SQL error: ".$self->{_dbh}->errstr());
  521.     return 0;
  522.   }
  523.  
  524.   return 1;
  525. }
  526.  
  527. =head2 get_storage_variables
  528.  
  529. public instance (@) get_storage_variables ()
  530.  
  531. Description:
  532. This method retrieves the various administrative variables used by
  533. the Bayes process and database.
  534.  
  535. The values returned in the array are in the following order:
  536.  
  537. 0: scan count base
  538.  
  539. 1: number of spam
  540.  
  541. 2: number of ham
  542.  
  543. 3: number of tokens in db
  544.  
  545. 4: last expire atime
  546.  
  547. 5: oldest token in db atime
  548.  
  549. 6: db version value
  550.  
  551. 7: last journal sync
  552.  
  553. 8: last atime delta
  554.  
  555. 9: last expire reduction count
  556.  
  557. 10: newest token in db atime
  558.  
  559. =cut
  560.  
  561. sub get_storage_variables {
  562.   my ($self) = @_;
  563.   my @values;
  564.  
  565.   return (0,0,0,0,0,0,0,0,0,0,0) unless (defined($self->{_dbh}));
  566.  
  567.   my $sql = "SELECT spam_count, ham_count, token_count, last_expire,
  568.                     last_atime_delta, last_expire_reduce, oldest_token_age,
  569.                     newest_token_age
  570.                FROM bayes_vars
  571.               WHERE id = ?";
  572.  
  573.   my $sth = $self->{_dbh}->prepare_cached($sql);
  574.  
  575.   unless (defined($sth)) {
  576.     dbg("bayes: get_storage_variables: SQL error: ".$self->{_dbh}->errstr());
  577.     return (0,0,0,0,0,0,0,0,0,0,0);
  578.   }
  579.  
  580.   my $rc = $sth->execute($self->{_userid});
  581.  
  582.   unless ($rc) {
  583.     dbg("bayes: get_storage_variables: SQL error: ".$self->{_dbh}->errstr());
  584.     return (0,0,0,0,0,0,0,0,0,0,0);
  585.   }
  586.  
  587.   my ($spam_count, $ham_count, $token_count,
  588.       $last_expire, $last_atime_delta, $last_expire_reduce,
  589.       $oldest_token_age, $newest_token_age) = $sth->fetchrow_array();
  590.  
  591.   $sth->finish();
  592.  
  593.   my $db_ver = $self->DB_VERSION;
  594.  
  595.   @values = (
  596.              0,
  597.              $spam_count,
  598.              $ham_count,
  599.              $token_count,
  600.              $last_expire,
  601.              $oldest_token_age,
  602.              $db_ver,
  603.              0, # we do not do journal syncs
  604.              $last_atime_delta,
  605.              $last_expire_reduce,
  606.              $newest_token_age
  607.              );
  608.  
  609.   return @values;
  610. }
  611.  
  612. =head2 dump_db_toks
  613.  
  614. public instance () dump_db_toks (String $template, String $regex, Array @vars)
  615.  
  616. Description:
  617. This method loops over all tokens, computing the probability for the token and then
  618. printing it out according to the passed in token.
  619.  
  620. =cut
  621.  
  622. sub dump_db_toks {
  623.   my ($self, $template, $regex, @vars) = @_;
  624.  
  625.   return unless (defined($self->{_dbh}));
  626.  
  627.   # 0/0 tokens don't count, but in theory we shouldn't have any
  628.   my $token_select = $self->_token_select_string();
  629.  
  630.   my $sql = "SELECT $token_select, spam_count, ham_count, atime
  631.                FROM bayes_token
  632.               WHERE id = ?
  633.                 AND (spam_count > 0 OR ham_count > 0)";
  634.  
  635.   my $sth = $self->{_dbh}->prepare($sql);
  636.  
  637.   unless (defined($sth)) {
  638.     dbg("bayes: dump_db_toks: SQL error: ".$self->{_dbh}->errstr());
  639.     return;
  640.   }
  641.  
  642.   my $rc = $sth->execute($self->{_userid});
  643.  
  644.   unless ($rc) {
  645.     dbg("bayes: dump_db_toks: SQL error: ".$self->{_dbh}->errstr());
  646.     return;
  647.   }  
  648.  
  649.   while (my ($token, $spam_count, $ham_count, $atime) = $sth->fetchrow_array()) {
  650.     my $prob = $self->{bayes}->compute_prob_for_token($token, $vars[1], $vars[2],
  651.                               $spam_count, $ham_count);
  652.     $prob ||= 0.5;
  653.  
  654.     my $encoded_token = unpack("H*", $token);
  655.     
  656.     printf $template,$prob,$spam_count,$ham_count,$atime,$encoded_token;
  657.   }
  658.  
  659.   $sth->finish();
  660.  
  661.   return;
  662. }
  663.  
  664. =head2 set_last_expire
  665.  
  666. public instance (Boolean) set_last_expire (Integer $time)
  667.  
  668. Description:
  669. This method sets the last expire time.
  670.  
  671. =cut
  672.  
  673. sub set_last_expire {
  674.   my ($self, $time) = @_;
  675.  
  676.   return 0 unless (defined($time));
  677.  
  678.   return 0 unless (defined($self->{_dbh}));
  679.  
  680.   my $sql = "UPDATE bayes_vars SET last_expire = ? WHERE id = ?";
  681.  
  682.   my $rows = $self->{_dbh}->do($sql,
  683.                    undef,
  684.                    $time,
  685.                    $self->{_userid});
  686.  
  687.   unless (defined($rows)) {
  688.     dbg("bayes: set_last_expire: SQL error: ".$self->{_dbh}->errstr());
  689.     return 0;
  690.   }
  691.  
  692.   return 1;
  693. }
  694.  
  695. =head2 get_running_expire_tok
  696.  
  697. public instance (String $time) get_running_expire_tok ()
  698.  
  699. Description:
  700. This method determines if an expire is currently running and returns
  701. the last time set.
  702.  
  703. There can be multiple times, so we just pull the greatest (most recent)
  704. value.
  705.  
  706. =cut
  707.  
  708. sub get_running_expire_tok {
  709.   my ($self) = @_;
  710.  
  711.   return 0 unless (defined($self->{_dbh}));
  712.  
  713.   my $sql = "SELECT max(runtime) from bayes_expire WHERE id = ?";
  714.  
  715.   my $sth = $self->{_dbh}->prepare_cached($sql);
  716.  
  717.   unless (defined($sth)) {
  718.     dbg("bayes: get_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  719.     return 0;
  720.   }
  721.  
  722.   my $rc = $sth->execute($self->{_userid});
  723.  
  724.   unless ($rc) {
  725.     dbg("bayes: get_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  726.     return 0;
  727.   }
  728.  
  729.   my ($runtime) = $sth->fetchrow_array();
  730.  
  731.   $sth->finish();
  732.  
  733.   return $runtime;
  734. }
  735.  
  736. =head2 set_running_expire_tok
  737.  
  738. public instance (String $time) set_running_expire_tok ()
  739.  
  740. Description:
  741. This method sets the time that an expire starts running.
  742.  
  743. =cut
  744.  
  745. sub set_running_expire_tok {
  746.   my ($self) = @_;
  747.  
  748.   return 0 unless (defined($self->{_dbh}));
  749.  
  750.   my $sql = "INSERT INTO bayes_expire (id,runtime) VALUES (?,?)";
  751.  
  752.   my $time = time();
  753.  
  754.   my $rows = $self->{_dbh}->do($sql,
  755.                    undef,
  756.                    $self->{_userid}, $time);
  757.   unless (defined($rows)) {
  758.     dbg("bayes: set_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  759.     return undef;
  760.   }
  761.  
  762.   return $time;
  763. }
  764.  
  765. =head2 remove_running_expire_tok
  766.  
  767. public instance (Boolean) remove_running_expire_tok ()
  768.  
  769. Description:
  770. This method removes the row in the database that indicates that
  771. and expire is currently running.
  772.  
  773. =cut
  774.  
  775. sub remove_running_expire_tok {
  776.   my ($self) = @_;
  777.  
  778.   return 0 unless (defined($self->{_dbh}));
  779.  
  780.   my $sql = "DELETE from bayes_expire
  781.               WHERE id = ?";
  782.  
  783.   my $rows = $self->{_dbh}->do($sql, undef, $self->{_userid});
  784.  
  785.   unless (defined($rows)) {
  786.     dbg("bayes: remove_running_expire_tok: SQL error: ".$self->{_dbh}->errstr());
  787.     return 0;
  788.   }
  789.  
  790.   return 1;
  791. }
  792.  
  793. =head2 tok_get
  794.  
  795. public instance (Integer, Integer, Integer) tok_get (String $token)
  796.  
  797. Description:
  798. This method retrieves a specificed token (C<$token>) from the database
  799. and returns it's spam_count, ham_count and last access time.
  800.  
  801. =cut
  802.  
  803. sub tok_get {
  804.   my ($self, $token) = @_;
  805.  
  806.   return (0,0,0) unless (defined($self->{_dbh}));
  807.  
  808.   my $sql = "SELECT spam_count, ham_count, atime
  809.                FROM bayes_token
  810.               WHERE id = ?
  811.                 AND token = ?";
  812.  
  813.   my $sth = $self->{_dbh}->prepare_cached($sql);
  814.  
  815.   unless (defined($sth)) {
  816.     dbg("bayes: tok_get: SQL error: ".$self->{_dbh}->errstr());
  817.     return (0,0,0);
  818.   }
  819.  
  820.   my $rc = $sth->execute($self->{_userid}, $token);
  821.  
  822.   unless ($rc) {
  823.     dbg("bayes: tok_get: SQL error: ".$self->{_dbh}->errstr());
  824.     return (0,0,0);
  825.   }
  826.  
  827.   my ($spam_count, $ham_count, $atime) = $sth->fetchrow_array();
  828.  
  829.   $sth->finish();
  830.  
  831.   $spam_count = 0 if (!$spam_count || $spam_count < 0);
  832.   $ham_count = 0 if (!$ham_count || $ham_count < 0);
  833.   $atime = 0 if (!$atime);
  834.  
  835.   return ($spam_count, $ham_count, $atime)
  836. }
  837.  
  838. =head2 tok_get_all
  839.  
  840. public instance (\@) tok_get (@ $tokens)
  841.  
  842. Description:
  843. This method retrieves the specified tokens (C<$tokens>) from storage and returns
  844. an array ref of arrays spam count, ham acount and last access time.
  845.  
  846. =cut
  847.  
  848. sub tok_get_all {
  849.   my ($self, @tokens) = @_;
  850.  
  851.   return [] unless (defined($self->{_dbh}));
  852.  
  853.   my $token_list_size = scalar(@tokens);
  854.   dbg("bayes: tok_get_all: token count: $token_list_size");
  855.   my @tok_results;
  856.  
  857.   my $search_index = 0;
  858.   my $results_index = 0;
  859.   my $bunch_end;
  860.  
  861.   my $token_select = $self->_token_select_string();
  862.  
  863.   my $multi_sql = "SELECT $token_select, spam_count, ham_count, atime
  864.                      FROM bayes_token
  865.                     WHERE id = ?
  866.                       AND token IN ";
  867.  
  868.   # fetch tokens in bunches of 100 until there are <= 100 left, then just fetch the rest
  869.   while ($token_list_size > $search_index) {
  870.     my $bunch_size;
  871.     if ($token_list_size - $search_index > 100) {
  872.       $bunch_size = 100;
  873.     }
  874.     else {
  875.       $bunch_size = $token_list_size - $search_index;
  876.     }
  877.     while ($token_list_size - $search_index >= $bunch_size) {
  878.       my @bindings;
  879.       my $bindcount;
  880.       my $in_str = '(';
  881.  
  882.       $bunch_end = $search_index + $bunch_size;
  883.       for ( ; $search_index < $bunch_end; $search_index++) {
  884.     $in_str .= '?,';
  885.     push(@bindings, $tokens[$search_index]);
  886.       }
  887.       chop $in_str;
  888.       $in_str .= ')';
  889.  
  890.       my $dynamic_sql = $multi_sql . $in_str;
  891.  
  892.       my $sth = $self->{_dbh}->prepare($dynamic_sql);
  893.  
  894.       unless (defined($sth)) {
  895.     dbg("bayes: tok_get_all: SQL error: ".$self->{_dbh}->errstr());
  896.     return [];
  897.       }
  898.  
  899.       my $rc = $sth->execute($self->{_userid}, @bindings);
  900.  
  901.       unless ($rc) {
  902.     dbg("bayes: tok_get_all: SQL error: ".$self->{_dbh}->errstr());
  903.     return [];
  904.       }
  905.  
  906.       my $results = $sth->fetchall_arrayref();
  907.  
  908.       $sth->finish();
  909.  
  910.       foreach my $result (@{$results}) {
  911.     # Make sure that spam_count and ham_count are not negative
  912.     $result->[1] = 0 if (!$result->[1] || $result->[1] < 0);
  913.     $result->[2] = 0 if (!$result->[2] || $result->[2] < 0);
  914.     # Make sure that atime has a value
  915.     $result->[3] = 0 if (!$result->[3]);
  916.     $tok_results[$results_index++] = $result;
  917.       }
  918.     }
  919.   }
  920.  
  921.   return \@tok_results;
  922. }
  923.  
  924. =head2 tok_count_change
  925.  
  926. public instance (Boolean) tok_count_change (Integer $spam_count,
  927.                         Integer $ham_count,
  928.                         String $token,
  929.                         String $atime)
  930.  
  931. Description:
  932. This method takes a C<$spam_count> and C<$ham_count> and adds it to
  933. C<$tok> along with updating C<$tok>s atime with C<$atime>.
  934.  
  935. =cut
  936.  
  937. sub tok_count_change {
  938.   my ($self, $spam_count, $ham_count, $token, $atime) = @_;
  939.  
  940.   $atime = 0 unless defined $atime;
  941.  
  942.   $self->_put_token($token, $spam_count, $ham_count, $atime);
  943. }
  944.  
  945. =head2 multi_tok_count_change
  946.  
  947. public instance (Boolean) multi_tok_count_change (Integer $spam_count,
  948.                                Integer $ham_count,
  949.                                \% $tokens,
  950.                               String $atime)
  951.  
  952. Description:
  953. This method takes a C<$spam_count> and C<$ham_count> and adds it to all
  954. of the tokens in the C<$tokens> hash ref along with updating each tokens
  955. atime with C<$atime>.
  956.  
  957. =cut
  958.  
  959. sub multi_tok_count_change {
  960.   my ($self, $spam_count, $ham_count, $tokens, $atime) = @_;
  961.  
  962.   $atime = 0 unless defined $atime;
  963.  
  964.   $self->_put_tokens($tokens, $spam_count, $ham_count, $atime);
  965. }
  966.  
  967. =head2 nspam_nham_get
  968.  
  969. public instance ($spam_count, $ham_count) nspam_nham_get ()
  970.  
  971. Description:
  972. This method retrieves the total number of spam and the total number of
  973. ham learned.
  974.  
  975. =cut
  976.  
  977. sub nspam_nham_get {
  978.   my ($self) = @_;
  979.  
  980.   return (0,0) unless (defined($self->{_dbh}));
  981.  
  982.   my @vars = $self->get_storage_variables();
  983.  
  984.   return ($vars[1] || 0, $vars[2] || 0);
  985. }
  986.  
  987. =head2 nspam_nham_change
  988.  
  989. public instance (Boolean) nspam_nham_change (Integer $num_spam,
  990.                                              Integer $num_ham)
  991.  
  992. Description:
  993. This method updates the number of spam and the number of ham in the database.
  994.  
  995. =cut
  996.  
  997. sub nspam_nham_change {
  998.   my ($self, $num_spam, $num_ham) = @_;
  999.  
  1000.   return 0 unless (defined($self->{_dbh}));
  1001.  
  1002.   my $sql;
  1003.   my @bindings;
  1004.  
  1005.   if ($num_spam != 0 && $num_ham != 0) {
  1006.     $sql = "UPDATE bayes_vars
  1007.                SET spam_count = spam_count + ?,
  1008.                    ham_count = ham_count + ?
  1009.              WHERE id = ?";
  1010.     @bindings = ($num_spam, $num_ham, $self->{_userid});
  1011.   }
  1012.   elsif ($num_spam != 0) {
  1013.     $sql = "UPDATE bayes_vars
  1014.               SET spam_count = spam_count + ?
  1015.              WHERE id = ?";
  1016.     @bindings = ($num_spam, $self->{_userid});
  1017.   }
  1018.   elsif ($num_ham != 0) {
  1019.     $sql = "UPDATE bayes_vars
  1020.                SET ham_count = ham_count + ?
  1021.             WHERE id = ?";
  1022.     @bindings = ($num_ham, $self->{_userid});
  1023.   }
  1024.   else {
  1025.     # For some reason called with no delta, it's ok though so just return
  1026.     dbg("bayes: nspam_nham_change: Called with no delta on spam or ham");
  1027.     return 1;
  1028.   }
  1029.  
  1030.   my $rows = $self->{_dbh}->do($sql,
  1031.                    undef,
  1032.                    @bindings);
  1033.  
  1034.   unless (defined($rows)) {
  1035.     dbg("bayes: nspam_nham_change: SQL error: ".$self->{_dbh}->errstr());
  1036.     return 0;
  1037.   }
  1038.  
  1039.   return 1;
  1040. }
  1041.  
  1042. =head2 tok_touch
  1043.  
  1044. public instance (Boolean) tok_touch (String $token,
  1045.                                      String $atime)
  1046.  
  1047. Description:
  1048. This method updates the given tokens (C<$token>) atime.
  1049.  
  1050. The assumption is that the token already exists in the database.
  1051.  
  1052. =cut
  1053.  
  1054. sub tok_touch {
  1055.   my ($self, $token, $atime) = @_;
  1056.  
  1057.   return 0 unless (defined($self->{_dbh}));
  1058.  
  1059.   # shortcut, will only update atime for the token if the atime is less than
  1060.   # what we are updating to
  1061.   my $sql = "UPDATE bayes_token
  1062.                 SET atime = ?
  1063.               WHERE id = ?
  1064.                 AND token = ?
  1065.                 AND atime < ?";
  1066.  
  1067.   my $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid},
  1068.                    $token, $atime);
  1069.  
  1070.   unless (defined($rows)) {
  1071.     dbg("bayes: tok_touch: SQL error: ".$self->{_dbh}->errstr());
  1072.     return 0;
  1073.   }
  1074.  
  1075.   # if we didn't update a row then no need to update newest_token_age
  1076.   return 1 if ($rows eq '0E0');
  1077.  
  1078.   # need to check newest_token_age
  1079.   # no need to check oldest_token_age since we would only update if the
  1080.   # atime was newer than what is in the database
  1081.   $sql = "UPDATE bayes_vars
  1082.              SET newest_token_age = ?
  1083.            WHERE id = ?
  1084.              AND newest_token_age < ?";
  1085.  
  1086.   $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  1087.  
  1088.   unless (defined($rows)) {
  1089.     dbg("bayes: tok_touch: SQL error: ".$self->{_dbh}->errstr());
  1090.     return 0;
  1091.   }
  1092.  
  1093.   return 1;
  1094. }
  1095.  
  1096. =head2 tok_touch_all
  1097.  
  1098. public instance (Boolean) tok_touch (\@ $tokens
  1099.                                      String $atime)
  1100.  
  1101. Description:
  1102. This method does a mass update of the given list of tokens C<$tokens>, if the existing token
  1103. atime is < C<$atime>.
  1104.  
  1105. The assumption is that the tokens already exist in the database.
  1106.  
  1107. We should never be touching more than N_SIGNIFICANT_TOKENS, so we can make
  1108. some assumptions about how to handle the data (ie no need to batch like we
  1109. do in tok_get_all)
  1110.  
  1111. =cut
  1112.  
  1113. sub tok_touch_all {
  1114.   my ($self, $tokens, $atime) = @_;
  1115.  
  1116.   return 0 unless (defined($self->{_dbh}));
  1117.  
  1118.   return 1 unless (scalar(@{$tokens}));
  1119.  
  1120.   my $sql = "UPDATE bayes_token SET atime = ? WHERE id = ? AND token IN (";
  1121.  
  1122.   my @bindings = ($atime, $self->{_userid});
  1123.   foreach my $token (@{$tokens}) {
  1124.     $sql .= "?,";
  1125.     push(@bindings, $token);
  1126.   }
  1127.   chop($sql); # get rid of trailing ,
  1128.  
  1129.   $sql .= ") AND atime < ?";
  1130.   push(@bindings, $atime);
  1131.  
  1132.   my $rows = $self->{_dbh}->do($sql, undef, @bindings);
  1133.  
  1134.   unless (defined($rows)) {
  1135.     dbg("bayes: tok_touch_all: SQL error: ".$self->{_dbh}->errstr());
  1136.     return 0;
  1137.   }
  1138.  
  1139.   # if we didn't update a row then no need to update newest_token_age
  1140.   return 1 if ($rows eq '0E0');
  1141.  
  1142.   # need to check newest_token_age
  1143.   # no need to check oldest_token_age since we would only update if the
  1144.   # atime was newer than what is in the database
  1145.   $sql = "UPDATE bayes_vars
  1146.              SET newest_token_age = ?
  1147.            WHERE id = ?
  1148.              AND newest_token_age < ?";
  1149.  
  1150.   $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  1151.  
  1152.   unless (defined($rows)) {
  1153.     dbg("bayes: tok_touch_all: SQL error: ".$self->{_dbh}->errstr());
  1154.     return 0;
  1155.   }
  1156.  
  1157.   return 1;
  1158. }
  1159.  
  1160. =head2 cleanup
  1161.  
  1162. public instance (Boolean) cleanup ()
  1163.  
  1164. Description:
  1165. This method peroms any cleanup necessary before moving onto the next
  1166. operation.
  1167.  
  1168. =cut
  1169.  
  1170. sub cleanup {
  1171.   my ($self) = @_;
  1172.  
  1173.  
  1174.   return 1 unless ($self->{needs_cleanup});
  1175.  
  1176.   # cleanup was needed, go ahead and clear the cleanup flag
  1177.   $self->{needs_cleanup} = 0;
  1178.  
  1179.   my $sql = "DELETE from bayes_token
  1180.               WHERE id = ?
  1181.                 AND spam_count = 0
  1182.                 AND ham_count = 0";
  1183.  
  1184.   my $toks_deleted = $self->{_dbh}->do($sql, undef, $self->{_userid});
  1185.  
  1186.   unless (defined($toks_deleted)) {
  1187.     dbg("bayes: cleanup: SQL error: ".$self->{_dbh}->errstr());
  1188.     return 0;
  1189.   }       
  1190.  
  1191.   # check to see if any tokens where deleted
  1192.   return 1 if ($toks_deleted eq '0E0');
  1193.  
  1194.   $sql = "UPDATE bayes_vars SET token_count = token_count - $toks_deleted
  1195.            WHERE id = ?";
  1196.  
  1197.   my $rows = $self->{_dbh}->do($sql, undef, $self->{_userid});
  1198.  
  1199.   unless (defined($rows)) {
  1200.     dbg("bayes: cleanup: SQL error: ".$self->{_dbh}->errstr());
  1201.     return 0;
  1202.   }       
  1203.  
  1204.   return 1;
  1205. }
  1206.  
  1207. =head2 get_magic_re
  1208.  
  1209. public instance get_magic_re (String)
  1210.  
  1211. Description:
  1212. This method returns a regexp which indicates a magic token.
  1213.  
  1214. Unused in SQL implementation.
  1215.  
  1216. =cut
  1217.  
  1218. sub get_magic_re {
  1219.   my ($self) = @_;
  1220.   undef;
  1221. }
  1222.  
  1223. =head2 sync
  1224.  
  1225. public instance (Boolean) sync (\% $opts)
  1226.  
  1227. Description:
  1228. This method performs a sync of the database
  1229.  
  1230. =cut
  1231.  
  1232. sub sync {
  1233.   my ($self, $opts) = @_;
  1234.  
  1235.   # Not used for this implementation
  1236.  
  1237.   return 1;
  1238. }
  1239.  
  1240. =head2 perform_upgrade
  1241.  
  1242. public instance (Boolean) perform_upgrade (\% $opts);
  1243.  
  1244. Description:
  1245. Performs an upgrade of the database from one version to another, not
  1246. currently used in this implementation.
  1247.  
  1248. =cut
  1249.  
  1250. sub perform_upgrade {
  1251.   my ($self) = @_;
  1252.  
  1253.   return 1;
  1254. }
  1255.  
  1256. =head2 clear_database
  1257.  
  1258. public instance (Boolean) clear_database ()
  1259.  
  1260. Description:
  1261. This method deletes all records for a particular user.
  1262.  
  1263. Callers should be aware that any errors returned by this method
  1264. could causes the database to be inconsistent for the given user.
  1265.  
  1266. =cut
  1267.  
  1268. sub clear_database {
  1269.   my ($self) = @_;
  1270.  
  1271.   # We want to open readonly first, because if they don't already have
  1272.   # a db entry, we want to avoid creating one, just to delete it in a few secs
  1273.   if ($self->tie_db_readonly()) {
  1274.     # Ok, they must have had a db entry, so now make the connection writable
  1275.     $self->tie_db_writable();
  1276.   }
  1277.   else {
  1278.     # If we were unable to create a readonly connection then they must
  1279.     # not have a db entry, so no need to clear.
  1280.     # But it should be considered a success.
  1281.     return 1;
  1282.   }
  1283.  
  1284.   return 0 unless (defined($self->{_dbh}));
  1285.  
  1286.   my $rows = $self->{_dbh}->do("DELETE FROM bayes_vars WHERE id = ?",
  1287.                    undef,
  1288.                    $self->{_userid});
  1289.   unless (defined($rows)) {
  1290.     dbg("bayes: SQL error removing user (bayes_vars) data: ".$self->{_dbh}->errstr());
  1291.     return 0;
  1292.   }
  1293.  
  1294.   $rows = $self->{_dbh}->do("DELETE FROM bayes_seen WHERE id = ?",
  1295.                 undef,
  1296.                 $self->{_userid});
  1297.   unless (defined($rows)) {
  1298.     dbg("bayes: SQL error removing seen data: ".$self->{_dbh}->errstr());
  1299.     return 0;
  1300.   }
  1301.  
  1302.   $rows = $self->{_dbh}->do("DELETE FROM bayes_token WHERE id = ?",
  1303.                 undef,
  1304.                 $self->{_userid});
  1305.   unless (defined($rows)) {
  1306.     dbg("bayes: SQL error removing token data: ".$self->{_dbh}->errstr());
  1307.     return 0;
  1308.   }
  1309.  
  1310.   return 1;
  1311. }
  1312.  
  1313. =head2 backup_database
  1314.  
  1315. public instance (Boolean) backup_database ()
  1316.  
  1317. Description:
  1318. This method will dump the users database in a marchine readable format.
  1319.  
  1320. =cut
  1321.  
  1322. sub backup_database {
  1323.   my ($self) = @_;
  1324.  
  1325.   return 0 unless ($self->tie_db_readonly());
  1326.  
  1327.   return 0 unless (defined($self->{_dbh}));
  1328.  
  1329.   my @vars = $self->get_storage_variables();
  1330.  
  1331.   my $num_spam = $vars[1] || 0;
  1332.   my $num_ham = $vars[2] || 0;
  1333.  
  1334.   print "v\t$vars[6]\tdb_version # this must be the first line!!!\n";
  1335.   print "v\t$num_spam\tnum_spam\n";
  1336.   print "v\t$num_ham\tnum_nonspam\n";
  1337.  
  1338.   my $token_select = $self->_token_select_string();
  1339.  
  1340.   my $token_sql = "SELECT spam_count, ham_count, atime, $token_select
  1341.                      FROM bayes_token
  1342.                     WHERE id = ?
  1343.                       AND (spam_count > 0 OR ham_count > 0)";
  1344.  
  1345.   my $seen_sql = "SELECT flag, msgid
  1346.                     FROM bayes_seen
  1347.                    WHERE id = ?";
  1348.  
  1349.   my $sth = $self->{_dbh}->prepare_cached($token_sql);
  1350.  
  1351.   unless (defined ($sth)) {
  1352.     dbg("bayes: backup_database: SQL error: ".$self->{_dbh}->errstr());
  1353.     return 0;
  1354.   }
  1355.  
  1356.   my $rc = $sth->execute($self->{_userid});
  1357.  
  1358.   unless ($rc) {
  1359.     dbg("bayes: backup_database: SQL error: ".$self->{_dbh}->errstr());
  1360.     return 0;
  1361.   }
  1362.  
  1363.   while (my @values = $sth->fetchrow_array()) {
  1364.     $values[3] = unpack("H*", $values[3]);
  1365.     print "t\t" . join("\t", @values) . "\n";
  1366.   }
  1367.  
  1368.   $sth->finish();
  1369.  
  1370.   $sth = $self->{_dbh}->prepare_cached($seen_sql);
  1371.  
  1372.   unless (defined ($sth)) {
  1373.     dbg("bayes: backup_database: SQL error: ".$self->{_dbh}->errstr());
  1374.     return 0;
  1375.   }
  1376.  
  1377.   $rc = $sth->execute($self->{_userid});
  1378.  
  1379.   unless ($rc) {
  1380.     dbg("bayes: backup_database: SQL error: ".$self->{_dbh}->errstr());
  1381.     return 0;
  1382.   }
  1383.  
  1384.   while (my @values = $sth->fetchrow_array()) {
  1385.     print "s\t" . join("\t",@values) . "\n";
  1386.   }
  1387.  
  1388.   $sth->finish();
  1389.  
  1390.   $self->untie_db();
  1391.  
  1392.   return 1;
  1393. }
  1394.  
  1395. =head2 restore_database
  1396.  
  1397. public instance (Boolean) restore_database (String $filename, Boolean $showdots)
  1398.  
  1399. Description:
  1400. This method restores a database from the given filename, C<$filename>.
  1401.  
  1402. Callers should be aware that any errors returned by this method
  1403. could causes the database to be inconsistent for the given user.
  1404.  
  1405. =cut
  1406.  
  1407. sub restore_database {
  1408.   my ($self, $filename, $showdots) = @_;
  1409.  
  1410.   if (!open(DUMPFILE, '<', $filename)) {
  1411.     dbg("bayes: unable to open backup file $filename: $!");
  1412.     return 0;
  1413.   }
  1414.  
  1415.   # This is the critical phase (moving sql around), so don't allow it
  1416.   # to be interrupted.
  1417.   local $SIG{'INT'} = 'IGNORE';
  1418.   local $SIG{'HUP'} = 'IGNORE' if (!Mail::SpamAssassin::Util::am_running_on_windows());
  1419.   local $SIG{'TERM'} = 'IGNORE';
  1420.  
  1421.   unless ($self->clear_database()) {
  1422.     return 0;
  1423.   }
  1424.  
  1425.   # we need to go ahead close the db connection so we can then open it up
  1426.   # in a fresh state after clearing
  1427.   $self->untie_db();
  1428.  
  1429.   unless ($self->tie_db_writable()) {
  1430.     return 0;
  1431.   }
  1432.  
  1433.   my $token_count = 0;
  1434.   my $db_version;
  1435.   my $num_spam;
  1436.   my $num_ham;
  1437.   my $error_p = 0;
  1438.   my $line_count = 0;
  1439.  
  1440.   my $line = <DUMPFILE>;
  1441.   $line_count++;
  1442.   # We require the database version line to be the first in the file so we can
  1443.   # figure out how to properly deal with the file.  If it is not the first
  1444.   # line then fail
  1445.   if ($line =~ m/^v\s+(\d+)\s+db_version/) {
  1446.     $db_version = $1;
  1447.   }
  1448.   else {
  1449.     dbg("bayes: database version must be the first line in the backup file, correct and re-run");
  1450.     return 0;
  1451.   }
  1452.  
  1453.   unless ($db_version == 2 || $db_version == 3) {
  1454.     warn("bayes: database version $db_version is unsupported, must be version 2 or 3");
  1455.     return 0;
  1456.   }
  1457.  
  1458.   my $token_error_count = 0;
  1459.   my $seen_error_count = 0;
  1460.  
  1461.   while (my $line = <DUMPFILE>) {
  1462.     chomp($line);
  1463.     $line_count++;
  1464.  
  1465.     if ($line_count % 1000 == 0) {
  1466.       print STDERR "." if ($showdots);
  1467.     }
  1468.  
  1469.     if ($line =~ /^v\s+/) { # variable line
  1470.       my @parsed_line = split(/\s+/, $line, 3);
  1471.       my $value = $parsed_line[1] + 0;
  1472.       if ($parsed_line[2] eq 'num_spam') {
  1473.     $num_spam = $value;
  1474.       }
  1475.       elsif ($parsed_line[2] eq 'num_nonspam') {
  1476.     $num_ham = $value;
  1477.       }
  1478.       else {
  1479.     dbg("bayes: restore_database: skipping unknown line: $line");
  1480.       }
  1481.     }
  1482.     elsif ($line =~ /^t\s+/) { # token line
  1483.       my @parsed_line = split(/\s+/, $line, 5);
  1484.       my $spam_count = $parsed_line[1] + 0;
  1485.       my $ham_count = $parsed_line[2] + 0;
  1486.       my $atime = $parsed_line[3] + 0;
  1487.       my $token = $parsed_line[4];
  1488.  
  1489.       my $token_warn_p = 0;
  1490.       my @warnings;
  1491.  
  1492.       if ($spam_count < 0) {
  1493.     $spam_count = 0;
  1494.     push(@warnings, 'spam count < 0, resetting');
  1495.     $token_warn_p = 1;
  1496.       }
  1497.       if ($ham_count < 0) {
  1498.     $ham_count = 0;
  1499.     push(@warnings, 'ham count < 0, resetting');
  1500.     $token_warn_p = 1;
  1501.       }
  1502.  
  1503.       if ($spam_count == 0 && $ham_count == 0) {
  1504.     dbg("bayes: token has zero spam and ham count, skipping");
  1505.     next;
  1506.       }
  1507.  
  1508.       if ($atime > time()) {
  1509.     $atime = time();
  1510.     push(@warnings, 'atime > current time, resetting');
  1511.     $token_warn_p = 1;
  1512.       }
  1513.  
  1514.       if ($token_warn_p) {
  1515.     dbg("bayes: token ($token) has the following warnings:\n".join("\n",@warnings));
  1516.       }
  1517.  
  1518.       if ($db_version < 3) {
  1519.     # versions < 3 use plain text tokens, so we need to convert to hash
  1520.     $token = substr(sha1($token), -5);
  1521.       }
  1522.       else {
  1523.     # turn unpacked binary token back into binary value
  1524.     $token = pack("H*",$token);
  1525.       }
  1526.  
  1527.       unless ($self->_put_token($token, $spam_count, $ham_count, $atime)) {
  1528.     dbg("bayes: error inserting token for line: $line");
  1529.     $token_error_count++;
  1530.       }
  1531.       $token_count++;
  1532.     }
  1533.     elsif ($line =~ /^s\s+/) { # seen line
  1534.       my @parsed_line = split(/\s+/, $line, 3);
  1535.       my $flag = $parsed_line[1];
  1536.       my $msgid = $parsed_line[2];
  1537.  
  1538.       unless ($flag eq 'h' || $flag eq 's') {
  1539.     dbg("bayes: unknown seen flag ($flag) for line: $line, skipping");
  1540.     next;
  1541.       }
  1542.  
  1543.       unless ($msgid) {
  1544.     dbg("bayes: blank msgid for line: $line, skipping");
  1545.     next;
  1546.       }
  1547.  
  1548.       unless ($self->seen_put($msgid, $flag)) {
  1549.     dbg("bayes: error inserting msgid in seen table for line: $line");
  1550.     $seen_error_count++;
  1551.       }
  1552.     }
  1553.     else {
  1554.       dbg("bayes: skipping unknown line: $line");
  1555.       next;
  1556.     }
  1557.  
  1558.     if ($token_error_count >= 20) {
  1559.       warn "bayes: encountered too many errors (20) while parsing token line, reverting to empty database and exiting\n";
  1560.       $self->clear_database();
  1561.       return 0;
  1562.     }
  1563.  
  1564.     if ($seen_error_count >= 20) {
  1565.       warn "bayes: encountered too many errors (20) while parsing seen lines, reverting to empty database and exiting\n";
  1566.       $self->clear_database();
  1567.       return 0;
  1568.     }
  1569.   }
  1570.   close(DUMPFILE);
  1571.  
  1572.   print STDERR "\n" if ($showdots);
  1573.  
  1574.   unless (defined($num_spam)) {
  1575.     dbg("bayes: unable to find num spam, please check file");
  1576.     $error_p = 1;
  1577.   }
  1578.  
  1579.   unless (defined($num_ham)) {
  1580.     dbg("bayes: unable to find num ham, please check file");
  1581.     $error_p = 1;
  1582.   }
  1583.  
  1584.   if ($error_p) {
  1585.     dbg("bayes: error(s) while attempting to load $filename, clearing database, correct and re-run");
  1586.     $self->clear_database();
  1587.     return 0;
  1588.   }
  1589.  
  1590.   if ($num_spam || $num_ham) {
  1591.     unless ($self->nspam_nham_change($num_spam, $num_ham)) {
  1592.       dbg("bayes: error updating num spam and num ham, clearing database");
  1593.       $self->clear_database();
  1594.       return 0;
  1595.     }
  1596.   }
  1597.  
  1598.   dbg("bayes: parsed $line_count lines");
  1599.   dbg("bayes: created database with $token_count tokens based on $num_spam spam messages and $num_ham ham messages");
  1600.  
  1601.   $self->untie_db();
  1602.  
  1603.   return 1;
  1604. }
  1605.  
  1606. =head2 db_readable
  1607.  
  1608. public instance (Boolean) db_readable()
  1609.  
  1610. Description:
  1611. This method returns a boolean value indicating if the database is in a
  1612. readable state.
  1613.  
  1614. =cut
  1615.  
  1616. sub db_readable {
  1617.   my ($self) = @_;
  1618.  
  1619.   # if there's a database handle, we can read...
  1620.   return defined $self->{_dbh};
  1621. }
  1622.  
  1623. =head2 db_writable
  1624.  
  1625. public instance (Boolean) db_writeable()
  1626.  
  1627. Description:
  1628. This method returns a boolean value indicating if the database is in a
  1629. writable state.
  1630.  
  1631. =cut
  1632.  
  1633. sub db_writable {
  1634.   my ($self) = @_;
  1635.  
  1636.   return (defined $self->{_dbh} && $self->{db_writable_p})
  1637. }
  1638.  
  1639. =head1 Private Methods
  1640.  
  1641. =head2 _connect_db
  1642.  
  1643. private instance (Boolean) _connect_db ()
  1644.  
  1645. Description:
  1646. This method connects to the SQL database.
  1647.  
  1648. =cut
  1649.  
  1650. sub _connect_db {
  1651.   my ($self) = @_;
  1652.  
  1653.   $self->{_dbh} = undef;
  1654.  
  1655.   # Turn off PrintError and explicitly set AutoCommit to off
  1656.   my $dbh = DBI->connect($self->{_dsn}, $self->{_dbuser}, $self->{_dbpass},
  1657.                         {'PrintError' => 0, 'AutoCommit' => 1});
  1658.  
  1659.   if (!$dbh) {
  1660.     dbg("bayes: unable to connect to database: ".DBI->errstr());
  1661.     return 0;
  1662.   }
  1663.   else {
  1664.     dbg("bayes: database connection established");
  1665.   }
  1666.  
  1667.   $self->{_dbh} = $dbh;
  1668.  
  1669.  return 1;
  1670. }
  1671.  
  1672. =head2 _get_db_version
  1673.  
  1674. private instance (Integer) _get_db_version ()
  1675.  
  1676. Description:
  1677. Gets the current version of the database from the special global vars
  1678. tables.
  1679.  
  1680. =cut
  1681.  
  1682. sub _get_db_version {
  1683.   my ($self) = @_;
  1684.  
  1685.   return 0 unless (defined($self->{_dbh}));
  1686.  
  1687.   return ($self->{_db_version_cache}) if (defined($self->{_db_version_cache}));
  1688.  
  1689.   my $sql = "SELECT value FROM bayes_global_vars WHERE variable = 'VERSION'";
  1690.  
  1691.   my $sth = $self->{_dbh}->prepare_cached($sql);
  1692.  
  1693.   unless (defined($sth)) {
  1694.     dbg("bayes: _get_db_version: SQL error: ".$self->{_dbh}->errstr());
  1695.     return 0;
  1696.   }
  1697.  
  1698.   my $rc = $sth->execute();
  1699.  
  1700.   unless ($rc) {
  1701.     dbg("bayes: _get_db_version: SQL error: ".$self->{_dbh}->errstr());
  1702.     return 0;
  1703.   }
  1704.  
  1705.   my ($version) = $sth->fetchrow_array();
  1706.  
  1707.   $sth->finish();
  1708.  
  1709.   $self->{_db_version_cache} = $version;
  1710.  
  1711.   return $version;
  1712. }
  1713.  
  1714. =head2 _initialize_db
  1715.  
  1716. private instance (Boolean) _initialize_db ()
  1717.  
  1718. Description:
  1719. This method will check to see if a user has had their bayes variables
  1720. initialized. If not then it will perform this initialization.
  1721.  
  1722. =cut
  1723.  
  1724. sub _initialize_db {
  1725.   my ($self, $create_entry_p) = @_;
  1726.  
  1727.   return 0 unless (defined($self->{_dbh}));
  1728.  
  1729.   return 0 if (!$self->{_username});
  1730.  
  1731.   # Check to see if we should call the services_authorized_for_username plugin
  1732.   # hook to see if this user is allowed/able to use bayes.  If not, do nothing
  1733.   # and return 0.
  1734.   if ($self->{bayes}->{conf}->{bayes_sql_username_authorized}) {
  1735.     my $services = { 'bayessql' => 0 };
  1736.     $self->{bayes}->{main}->call_plugins("services_allowed_for_username",
  1737.                      { services => $services,
  1738.                        username => $self->{_username},
  1739.                        conf => $self->{bayes}->{conf},
  1740.                      });
  1741.     
  1742.     unless ($services->{bayessql}) {
  1743.       dbg("bayes: username not allowed by services_allowed_for_username plugin call");
  1744.       return 0;
  1745.     }
  1746.   }
  1747.  
  1748.   my $sqlselect = "SELECT id FROM bayes_vars WHERE username = ?";
  1749.  
  1750.   my $sthselect = $self->{_dbh}->prepare_cached($sqlselect);
  1751.  
  1752.   unless (defined($sthselect)) {
  1753.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  1754.     return 0;
  1755.   }
  1756.  
  1757.   my $rc = $sthselect->execute($self->{_username});
  1758.  
  1759.   unless ($rc) {
  1760.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  1761.     return 0;
  1762.   }
  1763.  
  1764.   my ($id) = $sthselect->fetchrow_array();
  1765.  
  1766.   if ($id) {
  1767.     $self->{_userid} = $id;
  1768.     dbg("bayes: Using userid: ".$self->{_userid});
  1769.     $sthselect->finish();
  1770.     return 1;
  1771.   }
  1772.  
  1773.   # Do not create an entry for this user unless we were specifically asked to
  1774.   return 0 unless ($create_entry_p);
  1775.  
  1776.   # For now let the database setup the other variables as defaults
  1777.   my $sqlinsert = "INSERT INTO bayes_vars (username) VALUES (?)";
  1778.  
  1779.   my $rows = $self->{_dbh}->do($sqlinsert,
  1780.                    undef,
  1781.                    $self->{_username});
  1782.   unless (defined($rows)) {
  1783.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  1784.     return 0;
  1785.   }
  1786.  
  1787.   # Now we need to figure out what id we inserted them at, in a perfect
  1788.   # world the database driver would handle this for us (ie mysql_insert_id)
  1789.   # but this is far from a perfect world, however since in theory we only
  1790.   # ever do this once it's ok to take the hit
  1791.   $rc = $sthselect->execute($self->{_username});
  1792.  
  1793.   unless ($rc) {
  1794.     dbg("bayes: _initialize_db: SQL error: ".$self->{_dbh}->errstr());
  1795.     return 0;
  1796.   }
  1797.  
  1798.   ($id) = $sthselect->fetchrow_array();
  1799.  
  1800.   $sthselect->finish();
  1801.  
  1802.   if ($id) {
  1803.     $self->{_userid} = $id;
  1804.     dbg("bayes: using userid: ".$self->{_userid});
  1805.     return 1;
  1806.   }
  1807.  
  1808.   return 1;
  1809. }
  1810.  
  1811. =head2 _put_token
  1812.  
  1813. private instance (Boolean) _put_token (string $token,
  1814.                                        integer $spam_count,
  1815.                                        integer $ham_count,
  1816.                        string $atime)
  1817.  
  1818. Description:
  1819. This method performs the work of either inserting or updating a token in
  1820. the database.
  1821.  
  1822. =cut
  1823.  
  1824. sub _put_token {
  1825.   my ($self, $token, $spam_count, $ham_count, $atime) = @_;
  1826.  
  1827.   return 0 unless (defined($self->{_dbh}));
  1828.  
  1829.   $spam_count ||= 0;
  1830.   $ham_count ||= 0;
  1831.  
  1832.   if ($spam_count == 0 && $ham_count == 0) {
  1833.     return 1;
  1834.   }
  1835.  
  1836.   my ($existing_spam_count,
  1837.       $existing_ham_count,
  1838.       $existing_atime) = $self->tok_get($token);
  1839.  
  1840.   if (!$existing_atime) {
  1841.  
  1842.     # You can't create a new entry for a token with a negative count, so just return
  1843.     # if we are unable to find an entry.
  1844.     return 1 if ($spam_count < 0 || $ham_count < 0);
  1845.  
  1846.     my $sql = "INSERT INTO bayes_token
  1847.                (id, token, spam_count, ham_count, atime)
  1848.                VALUES (?,?,?,?,?)";
  1849.  
  1850.     my $sth = $self->{_dbh}->prepare_cached($sql);
  1851.  
  1852.     unless (defined($sth)) {
  1853.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1854.       return 0;
  1855.     }
  1856.  
  1857.     my $rc = $sth->execute($self->{_userid},
  1858.                $token,
  1859.                $spam_count,
  1860.                $ham_count,
  1861.                $atime);
  1862.     
  1863.     unless ($rc) {
  1864.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1865.       return 0;
  1866.     }
  1867.  
  1868.     $sth->finish();
  1869.  
  1870.     $sql = "UPDATE bayes_vars SET token_count = token_count + 1
  1871.              WHERE id = ?";
  1872.  
  1873.     my $rows = $self->{_dbh}->do($sql, undef, $self->{_userid});
  1874.     
  1875.     unless (defined($rows)) {
  1876.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1877.       return 0;
  1878.     }
  1879.  
  1880.     $sql = "UPDATE bayes_vars SET newest_token_age = ?
  1881.              WHERE id = ? AND newest_token_age < ?";
  1882.  
  1883.     $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  1884.  
  1885.     unless (defined($rows)) {
  1886.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1887.       return 0;
  1888.     }
  1889.  
  1890.     if ($rows eq '0E0') {
  1891.       # no need to update oldest_token_age if we updated newest_token_age
  1892.       
  1893.       $sql = "UPDATE bayes_vars SET oldest_token_age = ?
  1894.                WHERE id = ? AND oldest_token_age > ?";
  1895.  
  1896.       $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  1897.       
  1898.       unless (defined($rows)) {
  1899.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1900.     return 0;
  1901.       }
  1902.     }
  1903.   }
  1904.   else {
  1905.  
  1906.     if ($spam_count < 0 || $ham_count < 0) {
  1907.       # we only need to cleanup when we subtract counts for a token and the
  1908.       # counts may have both reached 0
  1909.       # XXX - future optimization, since we have the existing spam/ham counts
  1910.       # we can make an educated guess on if the count would reach 0, for
  1911.       # instance, if we are decreasing spam_count but spam_count is currently
  1912.       # > 1000, then there is no possible why this update or any others that
  1913.       # might currently be happening could reduce that value to 0, so there
  1914.       # would be no need to set the needs_cleanup flag
  1915.       $self->{needs_cleanup} = 1;
  1916.     }
  1917.  
  1918.     my $update_atime_p = 1;
  1919.     my $updated_atime_p = 0;
  1920.  
  1921.     # if the existing atime is already >= the one we are going to set, then
  1922.     # don't bother
  1923.     $update_atime_p = 0 if ($existing_atime >= $atime);
  1924.  
  1925.     # These SQL statements include as part of the WHERE clause something like
  1926.     # "AND spam_count + ? >= 0" or "AND ham_count + ? >= 0".  This is to keep
  1927.     # the count from going negative.
  1928.  
  1929.     if ($spam_count) {
  1930.       my $sql;
  1931.       my @args;
  1932.       if ($update_atime_p) {
  1933.     $sql = "UPDATE bayes_token
  1934.                    SET spam_count = spam_count + ?,
  1935.                        atime = ?
  1936.                  WHERE id = ?
  1937.                    AND token = ?
  1938.                    AND spam_count + ? >= 0";
  1939.     @args = ($spam_count, $atime, $self->{_userid}, $token, $spam_count);
  1940.     $updated_atime_p = 1; # note the fact that we did do it
  1941.       }
  1942.       else {
  1943.     $sql = "UPDATE bayes_token
  1944.                    SET spam_count = spam_count + ?
  1945.                  WHERE id = ?
  1946.                    AND token = ?
  1947.                    AND spam_count + ? >= 0";
  1948.     @args = ($spam_count, $self->{_userid}, $token, $spam_count);
  1949.       }
  1950.  
  1951.       my $rows = $self->{_dbh}->do($sql, undef, @args);
  1952.  
  1953.       unless (defined($rows)) {
  1954.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1955.     return 0;
  1956.       }
  1957.     }
  1958.  
  1959.     if ($ham_count) {
  1960.       my $sql;
  1961.       my @args;
  1962.       if ($update_atime_p && !$updated_atime_p) {
  1963.     $sql = "UPDATE bayes_token
  1964.                    SET ham_count = ham_count + ?,
  1965.                        atime = ?
  1966.                  WHERE id = ?
  1967.                    AND token = ?
  1968.                    AND ham_count + ? >= 0";
  1969.     @args = ($ham_count, $atime, $self->{_userid}, $token, $ham_count);
  1970.     $updated_atime_p = 1; # note the fact that we did do it
  1971.       }
  1972.       else {
  1973.     $sql = "UPDATE bayes_token
  1974.                    SET ham_count = ham_count + ?
  1975.                  WHERE id = ?
  1976.                    AND token = ?
  1977.                    AND ham_count + ? >= 0";
  1978.     @args = ($ham_count, $self->{_userid}, $token, $ham_count);
  1979.       }
  1980.  
  1981.       my $rows = $self->{_dbh}->do($sql, undef, @args);
  1982.  
  1983.       unless (defined($rows)) {
  1984.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  1985.     return 0;
  1986.       }
  1987.     }
  1988.  
  1989.     if ($updated_atime_p) {
  1990.       # we updated the atime, so we need to check and update bayes_vars
  1991.       # we only need to worry about newest_token_age since we would have
  1992.       # only updated the atime if it was > the previous value
  1993.       my $sql = "UPDATE bayes_vars SET newest_token_age = ?
  1994.                   WHERE id = ? AND newest_token_age < ?";
  1995.  
  1996.       my $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  1997.  
  1998.       unless (defined($rows)) {
  1999.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2000.     return 0;
  2001.       }
  2002.     }
  2003.   }
  2004.  
  2005.   return 1;
  2006. }
  2007.  
  2008. =head2 _put_tokens
  2009.  
  2010. private instance (Boolean) _put_tokens (\% $tokens,
  2011.                                         integer $spam_count,
  2012.                                         integer $ham_count,
  2013.                          string $atime)
  2014.  
  2015. Description:
  2016. This method performs the work of either inserting or updating tokens in
  2017. the database.
  2018.  
  2019. =cut
  2020.  
  2021. sub _put_tokens {
  2022.   my ($self, $tokens, $spam_count, $ham_count, $atime) = @_;
  2023.  
  2024.   return 0 unless (defined($self->{_dbh}));
  2025.  
  2026.   $spam_count ||= 0;
  2027.   $ham_count ||= 0;
  2028.  
  2029.   if ($spam_count == 0 && $ham_count == 0) {
  2030.     return 1;
  2031.   }
  2032.  
  2033.   my $atime_updated_p = 0;
  2034.   my $atime_inserted_p = 0;
  2035.   my $new_tokens = 0;
  2036.  
  2037.   my $insertsql = "INSERT INTO bayes_token
  2038.                    (id, token, spam_count, ham_count, atime)
  2039.                    VALUES (?,?,?,?,?)";
  2040.  
  2041.   my $insertsth = $self->{_dbh}->prepare_cached($insertsql);
  2042.  
  2043.   unless (defined($insertsth)) {
  2044.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2045.     return 0;
  2046.   }
  2047.  
  2048.   foreach my $token (keys %{$tokens}) {
  2049.     my ($existing_spam_count,
  2050.     $existing_ham_count,
  2051.     $existing_atime) = $self->tok_get($token);
  2052.  
  2053.     if (!$existing_atime) {
  2054.  
  2055.       # You can't create a new entry for a token with a negative count, so
  2056.       # just skip to the next one if we are unable to find an entry.
  2057.       next if ($spam_count < 0 || $ham_count < 0);
  2058.  
  2059.  
  2060.       my $rc = $insertsth->execute($self->{_userid},
  2061.                    $token,
  2062.                    $spam_count,
  2063.                    $ham_count,
  2064.                    $atime);
  2065.     
  2066.       unless ($rc) {
  2067.     dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2068.     next;
  2069.       }
  2070.  
  2071.       $insertsth->finish();
  2072.  
  2073.       $atime_inserted_p = 1;
  2074.       $new_tokens++;
  2075.     }
  2076.     else {
  2077.  
  2078.       if ($spam_count < 0 || $ham_count < 0) {
  2079.     # we only need to cleanup when we subtract counts for a token and the
  2080.     # counts may have both reached 0
  2081.     # XXX - future optimization, since we have the existing spam/ham counts
  2082.     # we can make an educated guess on if the count would reach 0, for
  2083.     # instance, if we are decreasing spam_count but spam_count is currently
  2084.     # > 1000, then there is no possible why this update or any others that
  2085.     # might currently be happening could reduce that value to 0, so there
  2086.     # would be no need to set the needs_cleanup flag
  2087.     $self->{needs_cleanup} = 1;
  2088.       }
  2089.  
  2090.       my $update_atime_p = 1;
  2091.  
  2092.       # if the existing atime is already >= the one we are going to set, then
  2093.       # don't bother
  2094.       $update_atime_p = 0 if ($existing_atime >= $atime);
  2095.       
  2096.       # These SQL statements include as part of the WHERE clause something like
  2097.       # "AND spam_count + ? >= 0" or "AND ham_count + ? >= 0".  This is to keep
  2098.       # the count from going negative.
  2099.       
  2100.       if ($spam_count) {
  2101.     my $sql;
  2102.     my @args;
  2103.     if ($update_atime_p) {
  2104.       $sql = "UPDATE bayes_token
  2105.                      SET spam_count = spam_count + ?,
  2106.                          atime = ?
  2107.                    WHERE id = ?
  2108.                      AND token = ?
  2109.                      AND spam_count + ? >= 0";
  2110.       @args = ($spam_count, $atime, $self->{_userid}, $token, $spam_count);
  2111.       $atime_updated_p = 1;
  2112.     }
  2113.     else {
  2114.       $sql = "UPDATE bayes_token
  2115.                      SET spam_count = spam_count + ?
  2116.                    WHERE id = ?
  2117.                      AND token = ?
  2118.                      AND spam_count + ? >= 0";
  2119.       @args = ($spam_count, $self->{_userid}, $token, $spam_count);
  2120.     }
  2121.  
  2122.     my $rows = $self->{_dbh}->do($sql, undef, @args);
  2123.  
  2124.     unless (defined($rows)) {
  2125.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2126.     }
  2127.       }
  2128.  
  2129.       if ($ham_count) {
  2130.     my $sql;
  2131.     my @args;
  2132.     # if $spam_count then we already updated the atime
  2133.     if ($update_atime_p && !$spam_count) { 
  2134.       $sql = "UPDATE bayes_token
  2135.                      SET ham_count = ham_count + ?,
  2136.                          atime = ?
  2137.                    WHERE id = ?
  2138.                      AND token = ?
  2139.                      AND ham_count + ? >= 0";
  2140.       @args = ($ham_count, $atime, $self->{_userid}, $token, $ham_count);
  2141.       $atime_updated_p = 1;
  2142.     }
  2143.     else {
  2144.       $sql = "UPDATE bayes_token
  2145.                      SET ham_count = ham_count + ?
  2146.                    WHERE id = ?
  2147.                      AND token = ?
  2148.                      AND ham_count + ? >= 0";
  2149.       @args = ($ham_count, $self->{_userid}, $token, $ham_count);
  2150.     }
  2151.     
  2152.     my $rows = $self->{_dbh}->do($sql, undef, @args);
  2153.  
  2154.     unless (defined($rows)) {
  2155.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2156.     }
  2157.       }
  2158.     }
  2159.   }
  2160.  
  2161.   if ($new_tokens) {
  2162.     my $sql = "UPDATE bayes_vars SET token_count = token_count + ?
  2163.                 WHERE id = ?";
  2164.  
  2165.     my $rows = $self->{_dbh}->do($sql, undef, $new_tokens, $self->{_userid});
  2166.  
  2167.     unless (defined($rows)) {
  2168.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2169.     }
  2170.   }
  2171.  
  2172.   if ($atime_updated_p || $atime_inserted_p) {
  2173.     # we updated the atime, so we need to check and update bayes_vars
  2174.     # we only need to worry about newest_token_age since we would have
  2175.     # only updated the atime if it was > the previous value
  2176.     my $sql = "UPDATE bayes_vars SET newest_token_age = ?
  2177.                 WHERE id = ? AND newest_token_age < ?";
  2178.  
  2179.     my $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  2180.  
  2181.     unless (defined($rows)) {
  2182.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2183.     }
  2184.   }
  2185.  
  2186.  
  2187.   # If we inserted then we might need to update oldest_token_age
  2188.   # but if we already updated newest_token_age then there is no need
  2189.  
  2190.   if ($atime_inserted_p) {
  2191.     my $sql = "UPDATE bayes_vars SET oldest_token_age = ?
  2192.                 WHERE id = ? AND oldest_token_age > ?";
  2193.  
  2194.     my $rows = $self->{_dbh}->do($sql, undef, $atime, $self->{_userid}, $atime);
  2195.  
  2196.     unless (defined($rows)) {
  2197.       dbg("bayes: _put_token: SQL error: ".$self->{_dbh}->errstr());
  2198.     }
  2199.   }
  2200.  
  2201.   return 1;
  2202. }
  2203.  
  2204. =head2 _get_oldest_token_age
  2205.  
  2206. private instance (Integer) _get_oldest_token_age ()
  2207.  
  2208. Description:
  2209. This method finds the atime of the oldest token in the database.
  2210.  
  2211. The use of min(atime) in the SQL is ugly and but really the most efficient
  2212. way of getting the oldest_token_age after we've done a mass expire.  It should
  2213. only be called at expire time.
  2214.  
  2215. =cut
  2216.  
  2217. sub _get_oldest_token_age {
  2218.   my ($self) = @_;
  2219.  
  2220.   return 0 unless (defined($self->{_dbh}));
  2221.  
  2222.   my $sql = "SELECT min(atime) FROM bayes_token
  2223.               WHERE id = ?";
  2224.  
  2225.   my $sth = $self->{_dbh}->prepare_cached($sql);
  2226.  
  2227.   unless (defined($sth)) {
  2228.     dbg("bayes: _get_oldest_token_age: SQL error: ".$self->{_dbh}->errstr());
  2229.     return 0;
  2230.   }
  2231.  
  2232.   my $rc = $sth->execute($self->{_userid});
  2233.  
  2234.   unless ($rc) {
  2235.     dbg("bayes: _get_oldest_token_age: SQL error: ".$self->{_dbh}->errstr());
  2236.     return 0;
  2237.   }
  2238.  
  2239.   my ($atime) = $sth->fetchrow_array();
  2240.  
  2241.   $sth->finish();
  2242.  
  2243.   return $atime;
  2244. }
  2245.  
  2246.  
  2247. =head2 _get_num_hapaxes
  2248.  
  2249. private instance (Integer) _get_num_hapaxes ()
  2250.  
  2251. Description:
  2252. This method gets the total number of hapaxes (spam_count + ham_count == 1) in
  2253. the token database for a user.
  2254.  
  2255. =cut
  2256.  
  2257. sub _get_num_hapaxes {
  2258.   my ($self) = @_;
  2259.  
  2260.   return 0 unless (defined($self->{_dbh}));
  2261.  
  2262.   my $sql = "SELECT count(*)
  2263.                FROM bayes_token
  2264.               WHERE id = ?
  2265.                 AND spam_count + ham_count = 1";
  2266.  
  2267.   my $sth = $self->{_dbh}->prepare_cached($sql);
  2268.  
  2269.   unless (defined($sth)) {
  2270.     dbg("bayes: _get_num_hapaxes: SQL error: ".$self->{_dbh}->errstr());
  2271.     return 0;
  2272.   }
  2273.  
  2274.   my $rc = $sth->execute($self->{_userid});
  2275.  
  2276.   unless ($rc) {
  2277.     dbg("bayes: _get_num_hapaxes: SQL error: ".$self->{_dbh}->errstr());
  2278.     return 0;
  2279.   }
  2280.  
  2281.   
  2282.   my ($num_hapaxes) = $sth->fetchrow_array();
  2283.  
  2284.   $sth->finish();
  2285.  
  2286.   return $num_hapaxes;
  2287. }
  2288.  
  2289. =head2 _get_num_lowfreq
  2290.  
  2291. private instance (Integer) _get_num_lowfreq ()
  2292.  
  2293. Description:
  2294. This method gets the total number of lowfreq tokens (spam_count < 8 and
  2295. ham_count < 8) in the token database for a user
  2296.  
  2297. =cut
  2298.  
  2299. sub _get_num_lowfreq {
  2300.   my ($self) = @_;
  2301.  
  2302.   return 0 unless (defined($self->{_dbh}));
  2303.  
  2304.   my $sql = "SELECT count(*)
  2305.                FROM bayes_token
  2306.               WHERE id = ?
  2307.                 AND (spam_count >= 0 AND spam_count < 8)
  2308.                 AND (ham_count >= 0 AND ham_count < 8)
  2309.                 AND spam_count + ham_count != 1";
  2310.  
  2311.   my $sth = $self->{_dbh}->prepare_cached($sql);
  2312.  
  2313.   unless (defined($sth)) {
  2314.     dbg("bayes: _get_num_lowfreq: SQL error: ".$self->{_dbh}->errstr());
  2315.     return 0;
  2316.   }
  2317.  
  2318.   my $rc = $sth->execute($self->{_userid});
  2319.  
  2320.   unless ($rc) {
  2321.     dbg("bayes: _get_num_lowfreq: SQL error: ".$self->{_dbh}->errstr());
  2322.     return 0;
  2323.   }
  2324.  
  2325.   my ($num_lowfreq) = $sth->fetchrow_array();
  2326.  
  2327.   $sth->finish();
  2328.  
  2329.   return $num_lowfreq;
  2330. }
  2331.  
  2332. =head2 _token_select_string
  2333.  
  2334. private instance (String) _token_select_string
  2335.  
  2336. Description:
  2337. This method returns the string to be used in SELECT statements to represent
  2338. the token column.
  2339.  
  2340. The default is to use the RPAD function to pad the token out to 5 characters.
  2341.  
  2342. =cut
  2343.  
  2344. sub _token_select_string {
  2345.   return "RPAD(token, 5, ' ')";
  2346. }
  2347.  
  2348. sub sa_die { Mail::SpamAssassin::sa_die(@_); }
  2349.  
  2350. 1;
  2351.