functions/db_prefs.php

   1 <?php
   2
   3 /**
   4  * db_prefs.php
   5  *
   6  * This contains functions for manipulating user preferences
   7  * stored in a database, accessed though the Pear DB layer.
   8  *
   9  * Database:
  10  *
  11  * The preferences table should have three columns:
  12  *    user       char  \  primary
  13  *    prefkey    char  /  key
  14  *    prefval    blob
  15  *
  16  *   CREATE TABLE userprefs (user CHAR(128) NOT NULL DEFAULT '',
  17  *                           prefkey CHAR(64) NOT NULL DEFAULT '',
  18  *                           prefval BLOB NOT NULL DEFAULT '',
  19  *                           primary key (user,prefkey));
  20  *
  21  * Configuration of databasename, username and password is done
  22  * by using conf.pl or the administrator plugin
  23  *
  24  * @copyright &copy; 1999-2006 The SquirrelMail Project Team
  25  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  26  * @version $Id$
  27  * @package squirrelmail
  28  * @subpackage prefs
  29  * @since 1.1.3
  30  */
  31
  32 /** @ignore */
  33 if (!defined('SM_PATH')) define('SM_PATH','../');
  34
  35 /** Unknown database */
  36 define('SMDB_UNKNOWN', 0);
  37 /** MySQL */
  38 define('SMDB_MYSQL', 1);
  39 /** PostgreSQL */
  40 define('SMDB_PGSQL', 2);
  41
  42 require_once(SM_PATH . 'config/config.php');
  43 if (!include_once('DB.php')) {
  44     // same error also in abook_database.php
  45     require_once(SM_PATH . 'functions/display_messages.php');
  46     $error  = _("Could not include PEAR database functions required for the database backend.") . "<br />\n";
  47     $error .= sprintf(_("Is PEAR installed, and is the include path set correctly to find %s?"),
  48                         '<tt>DB.php</tt>') . "<br />\n";
  49     $error .= _("Please contact your system administrator and report this error.");
  50     error_box($error, $color);
  51     exit;
  52 }
  53
  54 global $prefs_are_cached, $prefs_cache;
  55
  56 /**
  57  * @ignore
  58  */
  59 function cachePrefValues($username) {
  60     global $prefs_are_cached, $prefs_cache;
  61
  62     sqgetGlobalVar('prefs_are_cached', $prefs_are_cached, SQ_SESSION );
  63     if ($prefs_are_cached) {
  64         sqgetGlobalVar('prefs_cache', $prefs_cache, SQ_SESSION );
  65         return;
  66     }
  67
  68     sqsession_unregister('prefs_cache');
  69     sqsession_unregister('prefs_are_cached');
  70
  71     $db = new dbPrefs;
  72     if(isset($db->error)) {
  73         printf( _("Preference database error (%s). Exiting abnormally"),
  74               $db->error);
  75         exit;
  76     }
  77
  78     $db->fillPrefsCache($username);
  79     if (isset($db->error)) {
  80         printf( _("Preference database error (%s). Exiting abnormally"),
  81               $db->error);
  82         exit;
  83     }
  84
  85     $prefs_are_cached = true;
  86
  87     sqsession_register($prefs_cache, 'prefs_cache');
  88     sqsession_register($prefs_are_cached, 'prefs_are_cached');
  89 }
  90
  91 /**
  92  * Class used to handle connections to prefs database and operations with preferences
  93  * @package squirrelmail
  94  * @subpackage prefs
  95  * @since 1.1.3
  96  */
  97 class dbPrefs {
  98     /**
  99      * Table used to store preferences
 100      * @var string
 101      */
 102     var $table = 'userprefs';
 103     /**
 104      * Field used to store owner of preference
 105      * @var string
 106      */
 107     var $user_field = 'user';
 108     /**
 109      * Field used to store preference name
 110      * @var string
 111      */
 112     var $key_field = 'prefkey';
 113     /**
 114      * Field used to store preference value
 115      * @var string
 116      */
 117     var $val_field = 'prefval';
 118
 119     /**
 120      * Database connection object
 121      * @var object
 122      */
 123     var $dbh   = NULL;
 124     /**
 125      * Error messages
 126      * @var string
 127      */
 128     var $error = NULL;
 129     /**
 130      * Database type (SMDB_* constants)
 131      * Is used in setKey().
 132      * @var integer
 133      */
 134     var $db_type = SMDB_UNKNOWN;
 135
 136     /**
 137      * Default preferences
 138      * @var array
 139      */
 140     var $default = Array('theme_default' => 0,
 141                          'show_html_default' => '0');
 142
 143     /**
 144      * Preference owner field size
 145      * @var integer
 146      * @since 1.5.1
 147      */
 148     var $user_size = 128;
 149     /**
 150      * Preference key field size
 151      * @var integer
 152      * @since 1.5.1
 153      */
 154     var $key_size = 64;
 155     /**
 156      * Preference value field size
 157      * @var integer
 158      * @since 1.5.1
 159      */
 160     var $val_size = 65536;
 161
 162     /**
 163      * initialize DB connection object
 164      * @return boolean true, if object is initialized
 165      */
 166     function open() {
 167         global $prefs_dsn, $prefs_table;
 168         global $prefs_user_field, $prefs_key_field, $prefs_val_field;
 169         global $prefs_user_size, $prefs_key_size, $prefs_val_size;
 170
 171         if(isset($this->dbh)) {
 172             return true;
 173         }
 174
 175         if (preg_match('/^mysql/', $prefs_dsn)) {
 176             $this->db_type = SMDB_MYSQL;
 177         } elseif (preg_match('/^pgsql/', $prefs_dsn)) {
 178             $this->db_type = SMDB_PGSQL;
 179         }
 180
 181         if (!empty($prefs_table)) {
 182             $this->table = $prefs_table;
 183         }
 184         if (!empty($prefs_user_field)) {
 185             $this->user_field = $prefs_user_field;
 186         }
 187         if (!empty($prefs_key_field)) {
 188             $this->key_field = $prefs_key_field;
 189         }
 190         if (!empty($prefs_val_field)) {
 191             $this->val_field = $prefs_val_field;
 192         }
 193         if (!empty($prefs_user_size)) {
 194             $this->user_size = (int) $prefs_user_size;
 195         }
 196         if (!empty($prefs_key_size)) {
 197             $this->key_size = (int) $prefs_key_size;
 198         }
 199         if (!empty($prefs_val_size)) {
 200             $this->val_size = (int) $prefs_val_size;
 201         }
 202         $dbh = DB::connect($prefs_dsn, true);
 203
 204         if(DB::isError($dbh)) {
 205             $this->error = DB::errorMessage($dbh);
 206             return false;
 207         }
 208
 209         $this->dbh = $dbh;
 210         return true;
 211     }
 212
 213     /**
 214      * Function used to handle database connection errors
 215      * @param object PEAR Error object
 216      */
 217     function failQuery($res = NULL) {
 218         if($res == NULL) {
 219             printf(_("Preference database error (%s). Exiting abnormally"),
 220                   $this->error);
 221         } else {
 222             printf(_("Preference database error (%s). Exiting abnormally"),
 223                   DB::errorMessage($res));
 224         }
 225         exit;
 226     }
 227
 228     /**
 229      * Get user's prefs setting
 230      * @param string $user user name
 231      * @param string $key preference name
 232      * @param mixed $default (since 1.2.5) default value
 233      * @return mixed preference value
 234      */
 235     function getKey($user, $key, $default = '') {
 236         global $prefs_cache;
 237
 238         cachePrefValues($user);
 239
 240         if (isset($prefs_cache[$key])) {
 241             return $prefs_cache[$key];
 242         } else {
 243             if (isset($this->default[$key])) {
 244                 return $this->default[$key];
 245             } else {
 246                 return $default;
 247             }
 248         }
 249     }
 250
 251     /**
 252      * Delete user's prefs setting
 253      * @param string $user user name
 254      * @param string $key preference name
 255      * @return boolean
 256      */
 257     function deleteKey($user, $key) {
 258         global $prefs_cache;
 259
 260         if (!$this->open()) {
 261             return false;
 262         }
 263         $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
 264                          $this->table,
 265                          $this->user_field,
 266                          $this->dbh->quoteString($user),
 267                          $this->key_field,
 268                          $this->dbh->quoteString($key));
 269
 270         $res = $this->dbh->simpleQuery($query);
 271         if(DB::isError($res)) {
 272             $this->failQuery($res);
 273         }
 274
 275         unset($prefs_cache[$key]);
 276
 277         return true;
 278     }
 279
 280     /**
 281      * Set user's preference
 282      * @param string $user user name
 283      * @param string $key preference name
 284      * @param mixed $value preference value
 285      * @return boolean
 286      */
 287     function setKey($user, $key, $value) {
 288         if (!$this->open()) {
 289             return false;
 290         }
 291
 292         /**
 293          * Check if username fits into db field
 294          */
 295         if (strlen($user) > $this->user_size) {
 296             $this->error = "Oversized username value."
 297                 ." Your preferences can't be saved."
 298                 ." See doc/db-backend.txt or contact your system administrator.";
 299
 300             /**
 301              * Debugging function. Can be used to log all issues that trigger
 302              * oversized field errors. Function should be enabled in all three
 303              * strlen checks. See http://www.php.net/error-log
 304              */
 305             // error_log($user.'|'.$key.'|'.$value."\n",3,'/tmp/oversized_log');
 306
 307             // error is fatal
 308             $this->failQuery(null);
 309         }
 310         /**
 311          * Check if preference key fits into db field
 312          */
 313         if (strlen($key) > $this->key_size) {
 314             $err_msg = "Oversized user's preference key."
 315                 ." Some preferences were not saved."
 316                 ." See doc/db-backend.txt or contact your system administrator.";
 317             // error is not fatal. Only some preference is not saved.
 318             trigger_error($err_msg,E_USER_WARNING);
 319             return false;
 320         }
 321         /**
 322          * Check if preference value fits into db field
 323          */
 324         if (strlen($value) > $this->val_size) {
 325             $err_msg = "Oversized user's preference value."
 326                 ." Some preferences were not saved."
 327                 ." See doc/db-backend.txt or contact your system administrator.";
 328             // error is not fatal. Only some preference is not saved.
 329             trigger_error($err_msg,E_USER_WARNING);
 330             return false;
 331         }
 332
 333
 334         if ($this->db_type == SMDB_MYSQL) {
 335             $query = sprintf("REPLACE INTO %s (%s, %s, %s) ".
 336                              "VALUES('%s','%s','%s')",
 337                              $this->table,
 338                              $this->user_field,
 339                              $this->key_field,
 340                              $this->val_field,
 341                              $this->dbh->quoteString($user),
 342                              $this->dbh->quoteString($key),
 343                              $this->dbh->quoteString($value));
 344
 345             $res = $this->dbh->simpleQuery($query);
 346             if(DB::isError($res)) {
 347                 $this->failQuery($res);
 348             }
 349         } elseif ($this->db_type == SMDB_PGSQL) {
 350             $this->dbh->simpleQuery("BEGIN TRANSACTION");
 351             $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
 352                              $this->table,
 353                              $this->user_field,
 354                              $this->dbh->quoteString($user),
 355                              $this->key_field,
 356                              $this->dbh->quoteString($key));
 357             $res = $this->dbh->simpleQuery($query);
 358             if (DB::isError($res)) {
 359                 $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
 360                 $this->failQuery($res);
 361             }
 362             $query = sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
 363                              $this->table,
 364                              $this->user_field,
 365                              $this->key_field,
 366                              $this->val_field,
 367                              $this->dbh->quoteString($user),
 368                              $this->dbh->quoteString($key),
 369                              $this->dbh->quoteString($value));
 370             $res = $this->dbh->simpleQuery($query);
 371             if (DB::isError($res)) {
 372                 $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
 373                 $this->failQuery($res);
 374             }
 375             $this->dbh->simpleQuery("COMMIT TRANSACTION");
 376         } else {
 377             $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
 378                              $this->table,
 379                              $this->user_field,
 380                              $this->dbh->quoteString($user),
 381                              $this->key_field,
 382                              $this->dbh->quoteString($key));
 383             $res = $this->dbh->simpleQuery($query);
 384             if (DB::isError($res)) {
 385                 $this->failQuery($res);
 386             }
 387             $query = sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
 388                              $this->table,
 389                              $this->user_field,
 390                              $this->key_field,
 391                              $this->val_field,
 392                              $this->dbh->quoteString($user),
 393                              $this->dbh->quoteString($key),
 394                              $this->dbh->quoteString($value));
 395             $res = $this->dbh->simpleQuery($query);
 396             if (DB::isError($res)) {
 397                 $this->failQuery($res);
 398             }
 399         }
 400
 401         return true;
 402     }
 403
 404     /**
 405      * Fill preference cache array
 406      * @param string $user user name
 407      * @since 1.2.3
 408      */
 409     function fillPrefsCache($user) {
 410         global $prefs_cache;
 411
 412         if (!$this->open()) {
 413             return;
 414         }
 415
 416         $prefs_cache = array();
 417         $query = sprintf("SELECT %s as prefkey, %s as prefval FROM %s ".
 418                          "WHERE %s = '%s'",
 419                          $this->key_field,
 420                          $this->val_field,
 421                          $this->table,
 422                          $this->user_field,
 423                          $this->dbh->quoteString($user));
 424         $res = $this->dbh->query($query);
 425         if (DB::isError($res)) {
 426             $this->failQuery($res);
 427         }
 428
 429         while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
 430             $prefs_cache[$row['prefkey']] = $row['prefval'];
 431         }
 432     }
 433
 434 } /* end class dbPrefs */
 435
 436
 437 /**
 438  * returns the value for the pref $string
 439  * @ignore
 440  */
 441 function getPref($data_dir, $username, $string, $default = '') {
 442     $db = new dbPrefs;
 443     if(isset($db->error)) {
 444         printf( _("Preference database error (%s). Exiting abnormally"),
 445               $db->error);
 446         exit;
 447     }
 448
 449     return $db->getKey($username, $string, $default);
 450 }
 451
 452 /**
 453  * Remove the pref $string
 454  * @ignore
 455  */
 456 function removePref($data_dir, $username, $string) {
 457     global $prefs_cache;
 458     $db = new dbPrefs;
 459     if(isset($db->error)) {
 460         $db->failQuery();
 461     }
 462
 463     $db->deleteKey($username, $string);
 464
 465     if (isset($prefs_cache[$string])) {
 466         unset($prefs_cache[$string]);
 467     }
 468
 469     sqsession_register($prefs_cache , 'prefs_cache');
 470     return;
 471 }
 472
 473 /**
 474  * sets the pref, $string, to $set_to
 475  * @ignore
 476  */
 477 function setPref($data_dir, $username, $string, $set_to) {
 478     global $prefs_cache;
 479
 480     if (isset($prefs_cache[$string]) && ($prefs_cache[$string] == $set_to)) {
 481         return;
 482     }
 483
 484     if ($set_to === '') {
 485         removePref($data_dir, $username, $string);
 486         return;
 487     }
 488
 489     $db = new dbPrefs;
 490     if(isset($db->error)) {
 491         $db->failQuery();
 492     }
 493
 494     $db->setKey($username, $string, $set_to);
 495     $prefs_cache[$string] = $set_to;
 496     assert_options(ASSERT_ACTIVE, 1);
 497     assert_options(ASSERT_BAIL, 1);
 498     assert ('$set_to == $prefs_cache[$string]');
 499     sqsession_register($prefs_cache , 'prefs_cache');
 500     return;
 501 }
 502
 503 /**
 504  * This checks if the prefs are available
 505  * @ignore
 506  */
 507 function checkForPrefs($data_dir, $username) {
 508     $db = new dbPrefs;
 509     if(isset($db->error)) {
 510         $db->failQuery();
 511     }
 512 }
 513
 514 /**
 515  * Writes the Signature
 516  * @ignore
 517  */
 518 function setSig($data_dir, $username, $number, $string) {
 519     if ($number == "g") {
 520         $key = '___signature___';
 521     } else {
 522         $key = sprintf('___sig%s___', $number);
 523     }
 524     setPref($data_dir, $username, $key, $string);
 525     return;
 526 }
 527
 528 /**
 529  * Gets the signature
 530  * @ignore
 531  */
 532 function getSig($data_dir, $username, $number) {
 533     if ($number == "g") {
 534         $key = '___signature___';
 535     } else {
 536         $key = sprintf('___sig%d___', $number);
 537     }
 538     return getPref($data_dir, $username, $key);
 539 }
 540
 541 // vim: et ts=4
 542 ?>