Source for file db_prefs.php

Documentation is available at 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 1999-2014 The SquirrelMail Project Team
  25.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  26.  * @version $Id: db_prefs.php 14440 2014-01-25 02:24:58Z pdontthink $
  27.  * @package squirrelmail
  28.  * @subpackage prefs
  29.  * @since 1.1.3
  30.  */
  31.  
  32. /** Unknown database */
  33. define('SMDB_UNKNOWN'0);
  34. /** MySQL */
  35. define('SMDB_MYSQL'1);
  36. /** PostgreSQL */
  37. define('SMDB_PGSQL'2);
  38.  
  39. if (!include_once('DB.php')) {
  40.     // same error also in abook_database.php
  41.     require_once(SM_PATH 'functions/display_messages.php');
  42.     $error  _("Could not include PEAR database functions required for the database backend.""<br />\n";
  43.     $error .= sprintf(_("Is PEAR installed, and is the include path set correctly to find %s?"),
  44.                         '<tt>DB.php</tt>'"<br />\n";
  45.     $error .= _("Please contact your system administrator and report this error.");
  46.     error_box($error$color);
  47.     exit;
  48. }
  49.  
  50. global $prefs_are_cached$prefs_cache;
  51.  
  52. /**
  53.  * @ignore
  54.  */
  55. function cachePrefValues($username{
  56.     global $prefs_are_cached$prefs_cache;
  57.  
  58.     sqgetGlobalVar('prefs_are_cached'$prefs_are_cachedSQ_SESSION );
  59.     if ($prefs_are_cached{
  60.         sqgetGlobalVar('prefs_cache'$prefs_cacheSQ_SESSION );
  61.         return;
  62.     }
  63.  
  64.     sqsession_unregister('prefs_cache');
  65.     sqsession_unregister('prefs_are_cached');
  66.  
  67.     $db new dbPrefs;
  68.     if(isset($db->error)) {
  69.         printf_("Preference database error (%s). Exiting abnormally"),
  70.               $db->error);
  71.         exit;
  72.     }
  73.  
  74.     $db->fillPrefsCache($username);
  75.     if (isset($db->error)) {
  76.         printf_("Preference database error (%s). Exiting abnormally"),
  77.               $db->error);
  78.         exit;
  79.     }
  80.  
  81.     $prefs_are_cached true;
  82.  
  83.     sqsession_register($prefs_cache'prefs_cache');
  84.     sqsession_register($prefs_are_cached'prefs_are_cached');
  85. }
  86.  
  87. /**
  88.  * Completely undocumented class - someone document it!
  89.  * @package squirrelmail
  90.  */
  91. class dbPrefs {
  92.     var $table = 'userprefs';
  93.     var $user_field = 'user';
  94.     var $key_field = 'prefkey';
  95.     var $val_field = 'prefval';
  96.  
  97.     var $dbh   = NULL;
  98.     var $error = NULL;
  99.     var $db_type = SMDB_UNKNOWN;
  100.  
  101.     var $default = Array('theme_default' => 0,
  102.                          'show_html_default' => '0');
  103.  
  104.     function open({
  105.         global $prefs_dsn$prefs_table;
  106.         global $prefs_user_field$prefs_key_field$prefs_val_field;
  107.  
  108.         if(isset($this->dbh)) {
  109.             return true;
  110.         }
  111.  
  112.         if (preg_match('/^mysql/'$prefs_dsn)) {
  113.             $this->db_type = SMDB_MYSQL;
  114.         elseif (preg_match('/^pgsql/'$prefs_dsn)) {
  115.             $this->db_type = SMDB_PGSQL;
  116.         }
  117.  
  118.         if (!empty($prefs_table)) {
  119.             $this->table = $prefs_table;
  120.         }
  121.         if (!empty($prefs_user_field)) {
  122.             $this->user_field = $prefs_user_field;
  123.         }
  124.  
  125.         // the default user field is "user", which in PostgreSQL
  126.         // is an identifier and causes errors if not escaped
  127.         //
  128.         if ($this->db_type == SMDB_PGSQL{
  129.            $this->user_field = '"' $this->user_field . '"';
  130.         }
  131.  
  132.         if (!empty($prefs_key_field)) {
  133.             $this->key_field = $prefs_key_field;
  134.         }
  135.         if (!empty($prefs_val_field)) {
  136.             $this->val_field = $prefs_val_field;
  137.         }
  138.         $dbh DB::connect($prefs_dsntrue);
  139.  
  140.         if(DB::isError($dbh)) {
  141.             $this->error = DB::errorMessage($dbh);
  142.             return false;
  143.         }
  144.  
  145.         $this->dbh = $dbh;
  146.         return true;
  147.     }
  148.  
  149.     function failQuery($res NULL{
  150.         if($res == NULL{
  151.             printf(_("Preference database error (%s). Exiting abnormally"),
  152.                   $this->error);
  153.         else {
  154.             printf(_("Preference database error (%s). Exiting abnormally"),
  155.                   DB::errorMessage($res));
  156.         }
  157.         exit;
  158.     }
  159.  
  160.  
  161.     function getKey($user$key$default ''{
  162.         global $prefs_cache;
  163.  
  164.         $result NULL;
  165.         $result do_hook_function('get_pref_override'array($user$key$default));
  166. // FIXME: ideally, we'd have a better way to determine if the return value from the hook above should be respected, even if it is NULL, but this is as good as it gets for now... previously the test was more weak: if (!$result)
  167.         if (is_null($result)) {
  168.             cachePrefValues($user);
  169.  
  170.             if (isset($prefs_cache[$key])) {
  171.                 $result $prefs_cache[$key];
  172.             else {
  173. //FIXME: is there justification for having these TWO hooks so close together?  who uses these?
  174.                 $result do_hook_function('get_pref'array($user$key));
  175. //FIXME: testing below for !$result means that a plugin cannot fetch its own pref value of 0, '0', '', FALSE, or anything else that evaluates to boolean FALSE.
  176.                 if (!$result{
  177.                     if (isset($this->default[$key])) {
  178.                         $result $this->default[$key];
  179.                     else {
  180.                         $result $default;
  181.                     }
  182.                 }
  183.             }
  184.         }
  185.         return $result;
  186.     }
  187.  
  188.     function deleteKey($user$key{
  189.         global $prefs_cache;
  190.  
  191.         if (!$this->open()) {
  192.             return false;
  193.         }
  194.         $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  195.                          $this->table,
  196.                          $this->user_field,
  197.                          $this->dbh->quoteString($user),
  198.                          $this->key_field,
  199.                          $this->dbh->quoteString($key));
  200.  
  201.         $res $this->dbh->simpleQuery($query);
  202.         if(DB::isError($res)) {
  203.             $this->failQuery($res);
  204.         }
  205.  
  206.         unset($prefs_cache[$key]);
  207.  
  208.         return true;
  209.     }
  210.  
  211.     function setKey($user$key$value{
  212.         if (!$this->open()) {
  213.             return false;
  214.         }
  215.         if ($this->db_type == SMDB_MYSQL{
  216.             $query sprintf("REPLACE INTO %s (%s, %s, %s) ".
  217.                              "VALUES('%s','%s','%s')",
  218.                              $this->table,
  219.                              $this->user_field,
  220.                              $this->key_field,
  221.                              $this->val_field,
  222.                              $this->dbh->quoteString($user),
  223.                              $this->dbh->quoteString($key),
  224.                              $this->dbh->quoteString($value));
  225.  
  226.             $res $this->dbh->simpleQuery($query);
  227.             if(DB::isError($res)) {
  228.                 $this->failQuery($res);
  229.             }
  230.         elseif ($this->db_type == SMDB_PGSQL{
  231.             $this->dbh->simpleQuery("BEGIN TRANSACTION");
  232.             $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  233.                              $this->table,
  234.                              $this->user_field,
  235.                              $this->dbh->quoteString($user),
  236.                              $this->key_field,
  237.                              $this->dbh->quoteString($key));
  238.             $res $this->dbh->simpleQuery($query);
  239.             if (DB::isError($res)) {
  240.                 $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  241.                 $this->failQuery($res);
  242.             }
  243.             $query sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  244.                              $this->table,
  245.                              $this->user_field,
  246.                              $this->key_field,
  247.                              $this->val_field,
  248.                              $this->dbh->quoteString($user),
  249.                              $this->dbh->quoteString($key),
  250.                              $this->dbh->quoteString($value));
  251.             $res $this->dbh->simpleQuery($query);
  252.             if (DB::isError($res)) {
  253.                 $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  254.                 $this->failQuery($res);
  255.             }
  256.             $this->dbh->simpleQuery("COMMIT TRANSACTION");
  257.         else {
  258.             $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  259.                              $this->table,
  260.                              $this->user_field,
  261.                              $this->dbh->quoteString($user),
  262.                              $this->key_field,
  263.                              $this->dbh->quoteString($key));
  264.             $res $this->dbh->simpleQuery($query);
  265.             if (DB::isError($res)) {
  266.                 $this->failQuery($res);
  267.             }
  268.             $query sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  269.                              $this->table,
  270.                              $this->user_field,
  271.                              $this->key_field,
  272.                              $this->val_field,
  273.                              $this->dbh->quoteString($user),
  274.                              $this->dbh->quoteString($key),
  275.                              $this->dbh->quoteString($value));
  276.             $res $this->dbh->simpleQuery($query);
  277.             if (DB::isError($res)) {
  278.                 $this->failQuery($res);
  279.             }
  280.         }
  281.  
  282.         return true;
  283.     }
  284.  
  285.     function fillPrefsCache($user{
  286.         global $prefs_cache;
  287.  
  288.         if (!$this->open()) {
  289.             return;
  290.         }
  291.  
  292.         $prefs_cache array();
  293.         $query sprintf("SELECT %s as prefkey, %s as prefval FROM %s ".
  294.                          "WHERE %s = '%s'",
  295.                          $this->key_field,
  296.                          $this->val_field,
  297.                          $this->table,
  298.                          $this->user_field,
  299.                          $this->dbh->quoteString($user));
  300.         $res $this->dbh->query($query);
  301.         if (DB::isError($res)) {
  302.             $this->failQuery($res);
  303.         }
  304.  
  305.         while ($row $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  306.             $prefs_cache[$row['prefkey']] $row['prefval'];
  307.         }
  308.     }
  309.  
  310. /* end class dbPrefs */
  311.  
  312.  
  313. /**
  314.  * returns the value for the pref $string
  315.  * @ignore
  316.  */
  317. function getPref($data_dir$username$string$default ''{
  318.     $db new dbPrefs;
  319.     if(isset($db->error)) {
  320.         printf_("Preference database error (%s). Exiting abnormally"),
  321.               $db->error);
  322.         exit;
  323.     }
  324.  
  325.     return $db->getKey($username$string$default);
  326. }
  327.  
  328. /**
  329.  * Remove the pref $string
  330.  * @ignore
  331.  */
  332. function removePref($data_dir$username$string{
  333.     global $prefs_cache;
  334.     $db new dbPrefs;
  335.     if(isset($db->error)) {
  336.         $db->failQuery();
  337.     }
  338.  
  339.     $db->deleteKey($username$string);
  340.  
  341.     if (isset($prefs_cache[$string])) {
  342.         unset($prefs_cache[$string]);
  343.     }
  344.  
  345.     sqsession_register($prefs_cache 'prefs_cache');
  346.     return;
  347. }
  348.  
  349. /**
  350.  * sets the pref, $string, to $set_to
  351.  * @ignore
  352.  */
  353. function setPref($data_dir$username$string$set_to{
  354.     global $prefs_cache;
  355.  
  356.     if (isset($prefs_cache[$string]&& ($prefs_cache[$string== $set_to)) {
  357.         return;
  358.     }
  359.  
  360.     if ($set_to === ''{
  361.         removePref($data_dir$username$string);
  362.         return;
  363.     }
  364.  
  365.     $db new dbPrefs;
  366.     if(isset($db->error)) {
  367.         $db->failQuery();
  368.     }
  369.  
  370.     $db->setKey($username$string$set_to);
  371.     $prefs_cache[$string$set_to;
  372.     assert_options(ASSERT_ACTIVE1);
  373.     assert_options(ASSERT_BAIL1);
  374.     assert ('$set_to == $prefs_cache[$string]');
  375.     sqsession_register($prefs_cache 'prefs_cache');
  376.     return;
  377. }
  378.  
  379. /**
  380.  * This checks if the prefs are available
  381.  * @ignore
  382.  */
  383. function checkForPrefs($data_dir$username{
  384.     $db new dbPrefs;
  385.     if(isset($db->error)) {
  386.         $db->failQuery();
  387.     }
  388. }
  389.  
  390. /**
  391.  * Writes the Signature
  392.  * @ignore
  393.  */
  394. function setSig($data_dir$username$number$string{
  395.     if ($number == "g"{
  396.         $key '___signature___';
  397.     else {
  398.         $key sprintf('___sig%s___'$number);
  399.     }
  400.     setPref($data_dir$username$key$string);
  401.     return;
  402. }
  403.  
  404. /**
  405.  * Gets the signature
  406.  * @ignore
  407.  */
  408. function getSig($data_dir$username$number{
  409.     if ($number == "g"{
  410.         $key '___signature___';
  411.     else {
  412.         $key sprintf('___sig%d___'$number);
  413.     }
  414.     return getPref($data_dir$username$key);
  415. }

Documentation generated on Thu, 18 Dec 2014 04:20:39 +0100 by phpDocumentor 1.4.3