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.  * or PDO, the latter taking precedence if available.
  9.  *
  10.  * Database:
  11.  *
  12.  * The preferences table should have three columns:
  13.  *    user       char  \  primary
  14.  *    prefkey    char  /  key
  15.  *    prefval    blob
  16.  *
  17.  *   CREATE TABLE userprefs (user CHAR(128) NOT NULL DEFAULT '',
  18.  *                           prefkey CHAR(64) NOT NULL DEFAULT '',
  19.  *                           prefval BLOB NOT NULL DEFAULT '',
  20.  *                           primary key (user,prefkey));
  21.  *
  22.  * Configuration of databasename, username and password is done
  23.  * by using conf.pl or the administrator plugin
  24.  *
  25.  * Three settings that control PDO behavior can be specified in
  26.  * config/config_local.php if needed:
  27.  *    boolean $disable_pdo SquirrelMail uses PDO by default to access the
  28.  *                         user preferences and address book databases, but
  29.  *                         setting this to TRUE will cause SquirrelMail to
  30.  *                         fall back to using Pear DB instead.
  31.  *    boolean $pdo_show_sql_errors When database errors are encountered,
  32.  *                                 setting this to TRUE causes the actual
  33.  *                                 database error to be displayed, otherwise
  34.  *                                 generic errors are displayed, preventing
  35.  *                                 internal database information from being
  36.  *                                 exposed. This should be enabled only for
  37.  *                                 debugging purposes.
  38.  *    string $pdo_identifier_quote_char By default, SquirrelMail will quote
  39.  *                                      table and field names in database
  40.  *                                      queries with what it thinks is the
  41.  *                                      appropriate quote character for the
  42.  *                                      database type being used (backtick
  43.  *                                      for MySQL (and thus MariaDB), double
  44.  *                                      quotes for all others), but you can
  45.  *                                      override the character used by
  46.  *                                      putting it here, or tell SquirrelMail
  47.  *                                      NOT to quote identifiers by setting
  48.  *                                      this to "none"
  49.  *
  50.  * @copyright 1999-2020 The SquirrelMail Project Team
  51.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  52.  * @version $Id: db_prefs.php 14840 2020-01-07 07:42:38Z pdontthink $
  53.  * @package squirrelmail
  54.  * @subpackage prefs
  55.  * @since 1.1.3
  56.  */
  57.  
  58. /** Unknown database */
  59. define('SMDB_UNKNOWN', 0);
  60. /** MySQL */
  61. define('SMDB_MYSQL', 1);
  62. /** PostgreSQL */
  63. define('SMDB_PGSQL', 2);
  64.  
  65. global $disable_pdo, $use_pdo;
  66. if (empty($disable_pdo) && class_exists('PDO'))
  67.     $use_pdo = TRUE;
  68. else
  69.     $use_pdo = FALSE;
  70.  
  71. if (!$use_pdo && !include_once('DB.php')) {
  72.     // same error also in abook_database.php
  73.     require_once(SM_PATH . 'functions/display_messages.php');
  74.     $error  = _("Could not find or include PHP PDO or PEAR database functions required for the database backend.") . "<br />\n";
  75.     if (!empty($disable_pdo))
  76.         $error .= _("You have set \$disable_pdo - please try removing that.") . "<br />\n";
  77.     $error .= sprintf(_("PDO should come preinstalled with PHP version 5.1 or higher. Otherwise, is PEAR installed, and is the include path set correctly to find %s?"), '<tt>DB.php</tt>') . "<br />\n";
  78.     $error .= _("Please contact your system administrator and report this error.");
  79.     error_box($error, $color);
  80.     exit;
  81. }
  82.  
  83. global $prefs_are_cached, $prefs_cache;
  84.  
  85. /**
  86.  * @ignore
  87.  */
  88. function cachePrefValues($username) {
  89.     global $prefs_are_cached, $prefs_cache;
  90.  
  91.     sqgetGlobalVar('prefs_are_cached', $prefs_are_cached, SQ_SESSION );
  92.     if ($prefs_are_cached) {
  93.         sqgetGlobalVar('prefs_cache', $prefs_cache, SQ_SESSION );
  94.         return;
  95.     }
  96.  
  97.     sqsession_unregister('prefs_cache');
  98.     sqsession_unregister('prefs_are_cached');
  99.  
  100.     $db = new dbPrefs;
  101.     if(isset($db->error)) {
  102.         printf( _("Preference database error (%s). Exiting abnormally"),
  103.               $db->error);
  104.         exit;
  105.     }
  106.  
  107.     $db->fillPrefsCache($username);
  108.     if (isset($db->error)) {
  109.         printf( _("Preference database error (%s). Exiting abnormally"),
  110.               $db->error);
  111.         exit;
  112.     }
  113.  
  114.     $prefs_are_cached = true;
  115.  
  116.     sqsession_register($prefs_cache, 'prefs_cache');
  117.     sqsession_register($prefs_are_cached, 'prefs_are_cached');
  118. }
  119.  
  120. /**
  121.  * Completely undocumented class - someone document it!
  122.  * @package squirrelmail
  123.  */
  124. class dbPrefs {
  125.     var $table = 'userprefs';
  126.     var $user_field = 'user';
  127.     var $key_field = 'prefkey';
  128.     var $val_field = 'prefval';
  129.  
  130.     var $dbh   = NULL;
  131.     var $error = NULL;
  132.     var $db_type = SMDB_UNKNOWN;
  133.  
  134.     var $identifier_quote_char = '';
  135.  
  136.     var $default = Array('theme_default' => 0,
  137.                          'include_self_reply_all' => 0,
  138.                          'do_not_reply_to_self' => 1,
  139.                          'show_html_default' => '0');
  140.  
  141.     /**
  142.      * Constructor (PHP5 style, required in some future version of PHP)
  143.      * initialize the default preferences array.
  144.      *
  145.      */
  146.     function __construct() {
  147.         // Try and read the default preferences file.
  148.         $default_pref = SM_PATH . 'data/default_pref';
  149.         if (@file_exists($default_pref)) {
  150.             if ($file = @fopen($default_pref, 'r')) {
  151.                 while (!feof($file)) {
  152.                     $pref = fgets($file, 1024);
  153.                     $i = strpos($pref, '=');
  154.                     if ($i > 0) {
  155.                         $this->default[trim(substr($pref, 0, $i))] = trim(substr($pref, $i + 1));
  156.                     }
  157.                 }
  158.                 fclose($file);
  159.             }
  160.         }
  161.     }
  162.  
  163.     /**
  164.      * Constructor (PHP4 style, kept for compatibility reasons)
  165.      * initialize the default preferences array.
  166.      *
  167.      */
  168.     function dbPrefs() {
  169.        self::__construct();
  170.     }
  171.  
  172.     function open() {
  173.         global $prefs_dsn, $prefs_table, $use_pdo, $pdo_identifier_quote_char;
  174.         global $prefs_user_field, $prefs_key_field, $prefs_val_field;
  175.  
  176.         if(isset($this->dbh)) {
  177.             return true;
  178.         }
  179.  
  180.         if (strpos($prefs_dsn, 'mysql') === 0) {
  181.             $this->db_type = SMDB_MYSQL;
  182.         } else if (strpos($prefs_dsn, 'pgsql') === 0) {
  183.             $this->db_type = SMDB_PGSQL;
  184.         }
  185.  
  186.         // figure out identifier quoting (only used for PDO, though we could change that)
  187.         if (empty($pdo_identifier_quote_char)) {
  188.             if ($this->db_type == SMDB_MYSQL)
  189.                 $this->identifier_quote_char = '`';
  190.             else
  191.                 $this->identifier_quote_char = '"';
  192.         } else if ($pdo_identifier_quote_char === 'none')
  193.             $this->identifier_quote_char = '';
  194.         else
  195.             $this->identifier_quote_char = $pdo_identifier_quote_char;
  196.  
  197.         if (!empty($prefs_table)) {
  198.             $this->table = $prefs_table;
  199.         }
  200.         if (!empty($prefs_user_field)) {
  201.             $this->user_field = $prefs_user_field;
  202.         }
  203.  
  204.         // the default user field is "user", which in PostgreSQL
  205.         // is an identifier and causes errors if not escaped
  206.         //
  207.         if ($this->db_type == SMDB_PGSQL) {
  208.            $this->user_field = '"' . $this->user_field . '"';
  209.         }
  210.  
  211.         if (!empty($prefs_key_field)) {
  212.             $this->key_field = $prefs_key_field;
  213.         }
  214.         if (!empty($prefs_val_field)) {
  215.             $this->val_field = $prefs_val_field;
  216.         }
  217.  
  218.         // connect, create database connection object
  219.         //
  220.         if ($use_pdo) {
  221.             // parse and convert DSN to PDO style
  222.             // Pear's full DSN syntax is one of the following:
  223.             //    phptype(dbsyntax)://username:password@protocol+hostspec/database?option=value
  224.             //    phptype(syntax)://user:pass@protocol(proto_opts)/database
  225.             //
  226.             // $matches will contain:
  227.             // 1: database type
  228.             // 2: username
  229.             // 3: password
  230.             // 4: hostname (and possible port number) OR protocol (and possible protocol options)
  231.             // 5: database name (and possible options)
  232.             // 6: port number (moved from match number 4)
  233.             // 7: options (moved from match number 5)
  234.             // 8: protocol (instead of hostname)
  235.             // 9: protocol options (moved from match number 4/8)
  236. //TODO: do we care about supporting cases where no password is given? (this is a legal DSN, but causes an error below)
  237.             if (!preg_match('|^(.+)://(.+):(.+)@(.+)/(.+)$|i', $prefs_dsn, $matches)) {
  238.                 $this->error = _("Could not parse prefs DSN");
  239.                 return false;
  240.             }
  241.             $matches[6] = NULL;
  242.             $matches[7] = NULL;
  243.             $matches[8] = NULL;
  244.             $matches[9] = NULL;
  245.             if (preg_match('|^(.+):(\d+)$|', $matches[4], $host_port_matches)) {
  246.                 $matches[4] = $host_port_matches[1];
  247.                 $matches[6] = $host_port_matches[2];
  248.             }
  249.             if (preg_match('|^(.+?)\((.+)\)$|', $matches[4], $protocol_matches)) {
  250.                 $matches[8] = $protocol_matches[1];
  251.                 $matches[9] = $protocol_matches[2];
  252.                 $matches[4] = NULL;
  253.                 $matches[6] = NULL;
  254.             }
  255. //TODO: currently we just ignore options specified on the end of the DSN
  256.             if (preg_match('|^(.+?)\?(.+)$|', $matches[5], $database_name_options_matches)) {
  257.                 $matches[5] = $database_name_options_matches[1];
  258.                 $matches[7] = $database_name_options_matches[2];
  259.             }
  260.             if ($matches[8] === 'unix' && !empty($matches[9]))
  261.                 $pdo_prefs_dsn = $matches[1] . ':unix_socket=' . $matches[9] . ';dbname=' . $matches[5];
  262.             else
  263.                 $pdo_prefs_dsn = $matches[1] . ':host=' . $matches[4] . (!empty($matches[6]) ? ';port=' . $matches[6] : '') . ';dbname=' . $matches[5];
  264.             try {
  265.                 $dbh = new PDO($pdo_prefs_dsn, $matches[2], $matches[3]);
  266.             } catch (Exception $e) {
  267.                 $this->error = $e->getMessage();
  268.                 return false;
  269.             }
  270.         } else {
  271.             $dbh = DB::connect($prefs_dsn, true);
  272.  
  273.             if(DB::isError($dbh)) {
  274.                 $this->error = DB::errorMessage($dbh);
  275.                 return false;
  276.             }
  277.         }
  278.  
  279.         $this->dbh = $dbh;
  280.         return true;
  281.     }
  282.  
  283.     function failQuery($res = NULL) {
  284.         global $use_pdo;
  285.         if($res == NULL) {
  286.             printf(_("Preference database error (%s). Exiting abnormally"),
  287.                   $this->error);
  288.         } else {
  289.             printf(_("Preference database error (%s). Exiting abnormally"),
  290.                   ($use_pdo ? implode(' - ', $res->errorInfo()) : DB::errorMessage($res)));
  291.         }
  292.         exit;
  293.     }
  294.  
  295.  
  296.     function getKey($user, $key, $default = '') {
  297.         global $prefs_cache;
  298.  
  299.         $result = NULL;
  300.         $result = do_hook_function('get_pref_override', array($user, $key, $default));
  301. // 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)
  302.         if (is_null($result)) {
  303.             cachePrefValues($user);
  304.  
  305.             if (isset($prefs_cache[$key])) {
  306.                 $result = $prefs_cache[$key];
  307.             } else {
  308. //FIXME: is there justification for having these TWO hooks so close together?  who uses these?
  309.                 $result = do_hook_function('get_pref', array($user, $key));
  310. //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.
  311.                 if (!$result) {
  312.                     if (isset($this->default[$key])) {
  313.                         $result = $this->default[$key];
  314.                     } else {
  315.                         $result = $default;
  316.                     }
  317.                 }
  318.             }
  319.         }
  320.         return $result;
  321.     }
  322.  
  323.     function deleteKey($user, $key) {
  324.         global $prefs_cache, $use_pdo, $pdo_show_sql_errors;
  325.  
  326.         if (!$this->open()) {
  327.             return false;
  328.         }
  329.         if ($use_pdo) {
  330.             if (!($sth = $this->dbh->prepare('DELETE FROM ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' WHERE ' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ' = ? AND ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ' = ?'))) {
  331.                 if ($pdo_show_sql_errors)
  332.                     $this->error = implode(' - ', $this->dbh->errorInfo());
  333.                 else
  334.                     $this->error = _("Could not prepare query");
  335.                 $this->failQuery();
  336.             }
  337.             if (!($res = $sth->execute(array($user, $key)))) {
  338.                 if ($pdo_show_sql_errors)
  339.                     $this->error = implode(' - ', $sth->errorInfo());
  340.                 else
  341.                     $this->error = _("Could not execute query");
  342.                 $this->failQuery();
  343.             }
  344.         } else {
  345.             $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  346.                              $this->table,
  347.                              $this->user_field,
  348.                              $this->dbh->quoteString($user),
  349.                              $this->key_field,
  350.                              $this->dbh->quoteString($key));
  351.  
  352.             $res = $this->dbh->simpleQuery($query);
  353.             if(DB::isError($res)) {
  354.                 $this->failQuery($res);
  355.             }
  356.         }
  357.  
  358.         unset($prefs_cache[$key]);
  359.  
  360.         return true;
  361.     }
  362.  
  363.     function setKey($user, $key, $value) {
  364.         global $use_pdo, $pdo_show_sql_errors;
  365.         if (!$this->open()) {
  366.             return false;
  367.         }
  368.         if ($this->db_type == SMDB_MYSQL) {
  369.             if ($use_pdo) {
  370.                 if (!($sth = $this->dbh->prepare('REPLACE INTO ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' (' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->val_field . $this->identifier_quote_char . ') VALUES (?, ?, ?)'))) {
  371.                     if ($pdo_show_sql_errors)
  372.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  373.                     else
  374.                         $this->error = _("Could not prepare query");
  375.                     $this->failQuery();
  376.                 }
  377.                 if (!($res = $sth->execute(array($user, $key, $value)))) {
  378.                     if ($pdo_show_sql_errors)
  379.                         $this->error = implode(' - ', $sth->errorInfo());
  380.                     else
  381.                         $this->error = _("Could not execute query");
  382.                     $this->failQuery();
  383.                 }
  384.             } else {
  385.                 $query = sprintf("REPLACE INTO %s (%s, %s, %s) ".
  386.                                  "VALUES('%s','%s','%s')",
  387.                                  $this->table,
  388.                                  $this->user_field,
  389.                                  $this->key_field,
  390.                                  $this->val_field,
  391.                                  $this->dbh->quoteString($user),
  392.                                  $this->dbh->quoteString($key),
  393.                                  $this->dbh->quoteString($value));
  394.  
  395.                 $res = $this->dbh->simpleQuery($query);
  396.                 if(DB::isError($res)) {
  397.                     $this->failQuery($res);
  398.                 }
  399.             }
  400.         } elseif ($this->db_type == SMDB_PGSQL) {
  401.             if ($use_pdo) {
  402.                 if ($this->dbh->exec('BEGIN TRANSACTION') === FALSE) {
  403.                     if ($pdo_show_sql_errors)
  404.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  405.                     else
  406.                         $this->error = _("Could not execute query");
  407.                     $this->failQuery();
  408.                 }
  409.                 if (!($sth = $this->dbh->prepare('DELETE FROM ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' WHERE ' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ' = ? AND ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ' = ?'))) {
  410.                     if ($pdo_show_sql_errors)
  411.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  412.                     else
  413.                         $this->error = _("Could not prepare query");
  414.                     $this->failQuery();
  415.                 }
  416.                 if (!($res = $sth->execute(array($user, $key)))) {
  417.                     if ($pdo_show_sql_errors)
  418.                         $this->error = implode(' - ', $sth->errorInfo());
  419.                     else
  420.                         $this->error = _("Could not execute query");
  421.                     $this->dbh->exec('ROLLBACK TRANSACTION');
  422.                     $this->failQuery();
  423.                 }
  424.                 if (!($sth = $this->dbh->prepare('INSERT INTO ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' (' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->val_field . $this->identifier_quote_char . ') VALUES (?, ?, ?)'))) {
  425.                     if ($pdo_show_sql_errors)
  426.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  427.                     else
  428.                         $this->error = _("Could not prepare query");
  429.                     $this->failQuery();
  430.                 }
  431.                 if (!($res = $sth->execute(array($user, $key, $value)))) {
  432.                     if ($pdo_show_sql_errors)
  433.                         $this->error = implode(' - ', $sth->errorInfo());
  434.                     else
  435.                         $this->error = _("Could not execute query");
  436.                     $this->dbh->exec('ROLLBACK TRANSACTION');
  437.                     $this->failQuery();
  438.                 }
  439.                 if ($this->dbh->exec('COMMIT TRANSACTION') === FALSE) {
  440.                     if ($pdo_show_sql_errors)
  441.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  442.                     else
  443.                         $this->error = _("Could not execute query");
  444.                     $this->failQuery();
  445.                 }
  446.             } else {
  447.                 $this->dbh->simpleQuery("BEGIN TRANSACTION");
  448.                 $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  449.                                  $this->table,
  450.                                  $this->user_field,
  451.                                  $this->dbh->quoteString($user),
  452.                                  $this->key_field,
  453.                                  $this->dbh->quoteString($key));
  454.                 $res = $this->dbh->simpleQuery($query);
  455.                 if (DB::isError($res)) {
  456.                     $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  457.                     $this->failQuery($res);
  458.                 }
  459.                 $query = sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  460.                                  $this->table,
  461.                                  $this->user_field,
  462.                                  $this->key_field,
  463.                                  $this->val_field,
  464.                                  $this->dbh->quoteString($user),
  465.                                  $this->dbh->quoteString($key),
  466.                                  $this->dbh->quoteString($value));
  467.                 $res = $this->dbh->simpleQuery($query);
  468.                 if (DB::isError($res)) {
  469.                     $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  470.                     $this->failQuery($res);
  471.                 }
  472.                 $this->dbh->simpleQuery("COMMIT TRANSACTION");
  473.             }
  474.         } else {
  475.             if ($use_pdo) {
  476.                 if (!($sth = $this->dbh->prepare('DELETE FROM ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' WHERE ' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ' = ? AND ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ' = ?'))) {
  477.                     if ($pdo_show_sql_errors)
  478.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  479.                     else
  480.                         $this->error = _("Could not prepare query");
  481.                     $this->failQuery();
  482.                 }
  483.                 if (!($res = $sth->execute(array($user, $key)))) {
  484.                     if ($pdo_show_sql_errors)
  485.                         $this->error = implode(' - ', $sth->errorInfo());
  486.                     else
  487.                         $this->error = _("Could not execute query");
  488.                     $this->failQuery();
  489.                 }
  490.                 if (!($sth = $this->dbh->prepare('INSERT INTO ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' (' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ', ' . $this->identifier_quote_char . $this->val_field . $this->identifier_quote_char . ') VALUES (?, ?, ?)'))) {
  491.                     if ($pdo_show_sql_errors)
  492.                         $this->error = implode(' - ', $this->dbh->errorInfo());
  493.                     else
  494.                         $this->error = _("Could not prepare query");
  495.                     $this->failQuery();
  496.                 }
  497.                 if (!($res = $sth->execute(array($user, $key, $value)))) {
  498.                     if ($pdo_show_sql_errors)
  499.                         $this->error = implode(' - ', $sth->errorInfo());
  500.                     else
  501.                         $this->error = _("Could not execute query");
  502.                     $this->failQuery();
  503.                 }
  504.             } else {
  505.                 $query = sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  506.                                  $this->table,
  507.                                  $this->user_field,
  508.                                  $this->dbh->quoteString($user),
  509.                                  $this->key_field,
  510.                                  $this->dbh->quoteString($key));
  511.                 $res = $this->dbh->simpleQuery($query);
  512.                 if (DB::isError($res)) {
  513.                     $this->failQuery($res);
  514.                 }
  515.                 $query = sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  516.                                  $this->table,
  517.                                  $this->user_field,
  518.                                  $this->key_field,
  519.                                  $this->val_field,
  520.                                  $this->dbh->quoteString($user),
  521.                                  $this->dbh->quoteString($key),
  522.                                  $this->dbh->quoteString($value));
  523.                 $res = $this->dbh->simpleQuery($query);
  524.                 if (DB::isError($res)) {
  525.                     $this->failQuery($res);
  526.                 }
  527.             }
  528.         }
  529.  
  530.         return true;
  531.     }
  532.  
  533.     function fillPrefsCache($user) {
  534.         global $prefs_cache, $use_pdo, $pdo_show_sql_errors;
  535.  
  536.         if (!$this->open()) {
  537.             return;
  538.         }
  539.  
  540.         $prefs_cache = array();
  541.         if ($use_pdo) {
  542.             if (!($sth = $this->dbh->prepare('SELECT ' . $this->identifier_quote_char . $this->key_field . $this->identifier_quote_char . ' AS prefkey, ' . $this->identifier_quote_char . $this->val_field . $this->identifier_quote_char . ' AS prefval FROM ' . $this->identifier_quote_char . $this->table . $this->identifier_quote_char . ' WHERE ' . $this->identifier_quote_char . $this->user_field . $this->identifier_quote_char . ' = ?'))) {
  543.                 if ($pdo_show_sql_errors)
  544.                     $this->error = implode(' - ', $this->dbh->errorInfo());
  545.                 else
  546.                     $this->error = _("Could not prepare query");
  547.                 $this->failQuery();
  548.             }
  549.             if (!($res = $sth->execute(array($user)))) {
  550.                 if ($pdo_show_sql_errors)
  551.                     $this->error = implode(' - ', $sth->errorInfo());
  552.                 else
  553.                     $this->error = _("Could not execute query");
  554.                 $this->failQuery();
  555.             }
  556.  
  557.             while ($row = $sth->fetch(PDO::FETCH_ASSOC)) {
  558.                 $prefs_cache[$row['prefkey']] = $row['prefval'];
  559.             }
  560.         } else {
  561.             $query = sprintf("SELECT %s as prefkey, %s as prefval FROM %s ".
  562.                              "WHERE %s = '%s'",
  563.                              $this->key_field,
  564.                              $this->val_field,
  565.                              $this->table,
  566.                              $this->user_field,
  567.                              $this->dbh->quoteString($user));
  568.             $res = $this->dbh->query($query);
  569.             if (DB::isError($res)) {
  570.                 $this->failQuery($res);
  571.             }
  572.  
  573.             while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  574.                 $prefs_cache[$row['prefkey']] = $row['prefval'];
  575.             }
  576.         }
  577.     }
  578.  
  579. } /* end class dbPrefs */
  580.  
  581.  
  582. /**
  583.  * returns the value for the pref $string
  584.  * @ignore
  585.  */
  586. function getPref($data_dir, $username, $string, $default = '') {
  587.     $db = new dbPrefs;
  588.     if(isset($db->error)) {
  589.         printf( _("Preference database error (%s). Exiting abnormally"),
  590.               $db->error);
  591.         exit;
  592.     }
  593.  
  594.     return $db->getKey($username, $string, $default);
  595. }
  596.  
  597. /**
  598.  * Remove the pref $string
  599.  * @ignore
  600.  */
  601. function removePref($data_dir, $username, $string) {
  602.     global $prefs_cache;
  603.     $db = new dbPrefs;
  604.     if(isset($db->error)) {
  605.         $db->failQuery();
  606.     }
  607.  
  608.     $db->deleteKey($username, $string);
  609.  
  610.     if (isset($prefs_cache[$string])) {
  611.         unset($prefs_cache[$string]);
  612.     }
  613.  
  614.     sqsession_register($prefs_cache , 'prefs_cache');
  615.     return;
  616. }
  617.  
  618. /**
  619.  * sets the pref, $string, to $set_to
  620.  * @ignore
  621.  */
  622. function setPref($data_dir, $username, $string, $set_to) {
  623.     global $prefs_cache;
  624.  
  625.     if (isset($prefs_cache[$string]) && ($prefs_cache[$string] == $set_to)) {
  626.         return;
  627.     }
  628.  
  629.     if ($set_to === '') {
  630.         removePref($data_dir, $username, $string);
  631.         return;
  632.     }
  633.  
  634.     $db = new dbPrefs;
  635.     if(isset($db->error)) {
  636.         $db->failQuery();
  637.     }
  638.  
  639.     $db->setKey($username, $string, $set_to);
  640.     $prefs_cache[$string] = $set_to;
  641.     assert_options(ASSERT_ACTIVE, 1);
  642.     assert_options(ASSERT_BAIL, 1);
  643.     assert ('$set_to == $prefs_cache[$string]');
  644.     sqsession_register($prefs_cache , 'prefs_cache');
  645.     return;
  646. }
  647.  
  648. /**
  649.  * This checks if the prefs are available
  650.  * @ignore
  651.  */
  652. function checkForPrefs($data_dir, $username) {
  653.     $db = new dbPrefs;
  654.     if(isset($db->error)) {
  655.         $db->failQuery();
  656.     }
  657. }
  658.  
  659. /**
  660.  * Writes the Signature
  661.  * @ignore
  662.  */
  663. function setSig($data_dir, $username, $number, $string) {
  664.     if ($number == "g") {
  665.         $key = '___signature___';
  666.     } else {
  667.         $key = sprintf('___sig%s___', $number);
  668.     }
  669.     setPref($data_dir, $username, $key, $string);
  670.     return;
  671. }
  672.  
  673. /**
  674.  * Gets the signature
  675.  * @ignore
  676.  */
  677. function getSig($data_dir, $username, $number) {
  678.     if ($number == "g") {
  679.         $key = '___signature___';
  680.     } else {
  681.         $key = sprintf('___sig%d___', $number);
  682.     }
  683.     return getPref($data_dir, $username, $key);
  684. }

Documentation generated on Mon, 13 Jan 2020 04:24:28 +0100 by phpDocumentor 1.4.3