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 through 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-2017 The SquirrelMail Project Team
  51.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  52.  * @version $Id: db_prefs.php 14643 2017-01-27 20:34:08Z pdontthink $
  53.  * @package squirrelmail
  54.  * @subpackage prefs
  55.  * @since 1.1.3
  56.  */
  57.  
  58. /** @ignore */
  59. if (!defined('SM_PATH')) define('SM_PATH','../');
  60.  
  61. /** Unknown database */
  62. define('SMDB_UNKNOWN'0);
  63. /** MySQL */
  64. define('SMDB_MYSQL'1);
  65. /** PostgreSQL */
  66. define('SMDB_PGSQL'2);
  67.  
  68. /**
  69.  * Needs either PDO or the DB functions
  70.  * Don't display errors here. (no code execution in functions/*.php).
  71.  * will handle error in dbPrefs class.
  72.  */
  73. global $use_pdo$disable_pdo;
  74. if (empty($disable_pdo&& class_exists('PDO'))
  75.     $use_pdo TRUE;
  76. else
  77.     $use_pdo FALSE;
  78.  
  79. if (!$use_pdo)
  80.     @include_once('DB.php');
  81.  
  82. global $prefs_are_cached$prefs_cache;
  83.  
  84. /**
  85.  * @ignore
  86.  */
  87. function cachePrefValues($username{
  88.     global $prefs_are_cached$prefs_cache;
  89.  
  90.     sqgetGlobalVar('prefs_are_cached'$prefs_are_cachedSQ_SESSION );
  91.     if ($prefs_are_cached{
  92.         sqgetGlobalVar('prefs_cache'$prefs_cacheSQ_SESSION );
  93.         return;
  94.     }
  95.  
  96.     sqsession_unregister('prefs_cache');
  97.     sqsession_unregister('prefs_are_cached');
  98.  
  99.     $db new dbPrefs;
  100.     if(isset($db->error)) {
  101.         printf_("Preference database error (%s). Exiting abnormally"),
  102.               $db->error);
  103.         exit;
  104.     }
  105.  
  106.     $db->fillPrefsCache($username);
  107.     if (isset($db->error)) {
  108.         printf_("Preference database error (%s). Exiting abnormally"),
  109.               $db->error);
  110.         exit;
  111.     }
  112.  
  113.     $prefs_are_cached true;
  114.  
  115.     sqsession_register($prefs_cache'prefs_cache');
  116.     sqsession_register($prefs_are_cached'prefs_are_cached');
  117. }
  118.  
  119. /**
  120.  * Class used to handle connections to prefs database and operations with preferences
  121.  *
  122.  * @package squirrelmail
  123.  * @subpackage prefs
  124.  * @since 1.1.3
  125.  *
  126.  */
  127. class dbPrefs {
  128.     /**
  129.      * Table used to store preferences
  130.      * @var string 
  131.      */
  132.     var $table = 'userprefs';
  133.  
  134.     /**
  135.      * Field used to store owner of preference
  136.      * @var string 
  137.      */
  138.     var $user_field = 'user';
  139.  
  140.     /**
  141.      * Field used to store preference name
  142.      * @var string 
  143.      */
  144.     var $key_field = 'prefkey';
  145.  
  146.     /**
  147.      * Field used to store preference value
  148.      * @var string 
  149.      */
  150.     var $val_field = 'prefval';
  151.  
  152.     /**
  153.      * Database connection object
  154.      * @var object 
  155.      */
  156.     var $dbh   = NULL;
  157.  
  158.     /**
  159.      * Error messages
  160.      * @var string 
  161.      */
  162.     var $error = NULL;
  163.  
  164.     /**
  165.      * Database type (SMDB_* constants)
  166.      * Is used in setKey().
  167.      * @var integer 
  168.      */
  169.     var $db_type = SMDB_UNKNOWN;
  170.  
  171.     /**
  172.      * Character used to quote database table
  173.      * and field names
  174.      * @var string 
  175.      */
  176.     var $identifier_quote_char = '';
  177.  
  178.     /**
  179.      * Default preferences
  180.      * @var array 
  181.      */
  182.     var $default = Array('theme_default' => 0,
  183.                          'include_self_reply_all' => '0',
  184.                          'do_not_reply_to_self' => '1',
  185.                          'show_html_default' => '0');
  186.  
  187.     /**
  188.      * Preference owner field size
  189.      * @var integer 
  190.      * @since 1.5.1
  191.      */
  192.     var $user_size = 128;
  193.  
  194.     /**
  195.      * Preference key field size
  196.      * @var integer 
  197.      * @since 1.5.1
  198.      */
  199.     var $key_size = 64;
  200.  
  201.     /**
  202.      * Preference value field size
  203.      * @var integer 
  204.      * @since 1.5.1
  205.      */
  206.     var $val_size = 65536;
  207.  
  208.  
  209.  
  210.     /**
  211.      * Constructor (PHP5 style, required in some future version of PHP)
  212.      * initialize the default preferences array.
  213.      *
  214.      */
  215.     function __construct({
  216.         // Try and read the default preferences file.
  217.         $default_pref SM_PATH 'config/default_pref';
  218.         if (@file_exists($default_pref)) {
  219.             if ($file @fopen($default_pref'r')) {
  220.                 while (!feof($file)) {
  221.                     $pref fgets($file1024);
  222.                     $i strpos($pref'=');
  223.                     if ($i 0{
  224.                         $this->default[trim(substr($pref0$i))trim(substr($pref$i 1));
  225.                     }
  226.                 }
  227.                 fclose($file);
  228.             }
  229.         }
  230.     }
  231.  
  232.     /**
  233.      * Constructor (PHP4 style, kept for compatibility reasons)
  234.      * initialize the default preferences array.
  235.      *
  236.      */
  237.     function dbPrefs({
  238.        self::__construct();
  239.     }
  240.  
  241.     /**
  242.      * initialize DB connection object
  243.      *
  244.      * @return boolean true, if object is initialized
  245.      *
  246.      */
  247.     function open({
  248.         global $prefs_dsn$prefs_table$use_pdo$pdo_identifier_quote_char;
  249.         global $prefs_user_size$prefs_key_size$prefs_val_size;
  250.  
  251.         /* test if PDO or Pear DB classes are available and freak out if necessary */
  252.         if (!$use_pdo && !class_exists('DB')) {
  253.             // same error also in abook_database.php
  254.             $error  _("Could not find or include PHP PDO or PEAR database functions required for the database backend.""\n";
  255.             $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?")'DB.php'"\n";
  256.             $error .= _("Please contact your system administrator and report this error.");
  257.             return false;
  258.         }
  259.  
  260.         if(isset($this->dbh)) {
  261.             return true;
  262.         }
  263.  
  264.         if (strpos($prefs_dsn'mysql'=== 0{
  265.             $this->db_type = SMDB_MYSQL;
  266.         else if (strpos($prefs_dsn'pgsql'=== 0{
  267.             $this->db_type = SMDB_PGSQL;
  268.         }
  269.  
  270.         // figure out identifier quoting (only used for PDO, though we could change that)
  271.         if (empty($pdo_identifier_quote_char)) {
  272.             if ($this->db_type == SMDB_MYSQL)
  273.                 $this->identifier_quote_char = '`';
  274.             else
  275.                 $this->identifier_quote_char = '"';
  276.         else if ($pdo_identifier_quote_char === 'none')
  277.             $this->identifier_quote_char = '';
  278.         else
  279.             $this->identifier_quote_char = $pdo_identifier_quote_char;
  280.  
  281.         if (!empty($prefs_table)) {
  282.             $this->table = $prefs_table;
  283.         }
  284.         if (!empty($prefs_user_field)) {
  285.             $this->user_field = $prefs_user_field;
  286.         }
  287.  
  288.         // the default user field is "user", which in PostgreSQL
  289.         // is an identifier and causes errors if not escaped
  290.         //
  291.         if ($this->db_type == SMDB_PGSQL{
  292.            $this->user_field = '"' $this->user_field . '"';
  293.         }
  294.  
  295.         if (!empty($prefs_key_field)) {
  296.             $this->key_field = $prefs_key_field;
  297.         }
  298.         if (!empty($prefs_val_field)) {
  299.             $this->val_field = $prefs_val_field;
  300.         }
  301.         if (!empty($prefs_user_size)) {
  302.             $this->user_size = (int) $prefs_user_size;
  303.         }
  304.         if (!empty($prefs_key_size)) {
  305.             $this->key_size = (int) $prefs_key_size;
  306.         }
  307.         if (!empty($prefs_val_size)) {
  308.             $this->val_size = (int) $prefs_val_size;
  309.         }
  310.  
  311.         // connect, create database connection object
  312.         //
  313.         if ($use_pdo{
  314.             // parse and convert DSN to PDO style
  315.             // Pear's full DSN syntax is one of the following:
  316.             //    phptype(dbsyntax)://username:password@protocol+hostspec/database?option=value
  317.             //    phptype(syntax)://user:pass@protocol(proto_opts)/database
  318.             //
  319.             // $matches will contain:
  320.             // 1: database type
  321.             // 2: username
  322.             // 3: password
  323.             // 4: hostname (and possible port number) OR protocol (and possible protocol options)
  324.             // 5: database name (and possible options)
  325.             // 6: port number (moved from match number 4)
  326.             // 7: options (moved from match number 5)
  327.             // 8: protocol (instead of hostname)
  328.             // 9: protocol options (moved from match number 4/8)
  329. //TODO: do we care about supporting cases where no password is given? (this is a legal DSN, but causes an error below)
  330.             if (!preg_match('|^(.+)://(.+):(.+)@(.+)/(.+)$|i'$prefs_dsn$matches)) {
  331.                 $this->error = _("Could not parse prefs DSN");
  332.                 return false;
  333.             }
  334.             $matches[6NULL;
  335.             $matches[7NULL;
  336.             $matches[8NULL;
  337.             $matches[9NULL;
  338.             if (preg_match('|^(.+):(\d+)$|'$matches[4]$host_port_matches)) {
  339.                 $matches[4$host_port_matches[1];
  340.                 $matches[6$host_port_matches[2];
  341.             
  342.             if (preg_match('|^(.+?)\((.+)\)$|'$matches[4]$protocol_matches)) {
  343.                 $matches[8$protocol_matches[1];
  344.                 $matches[9$protocol_matches[2];
  345.                 $matches[4NULL;
  346.                 $matches[6NULL;
  347.             
  348. //TODO: currently we just ignore options specified on the end of the DSN
  349.             if (preg_match('|^(.+?)\?(.+)$|'$matches[5]$database_name_options_matches)) {
  350.                 $matches[5$database_name_options_matches[1];
  351.                 $matches[7$database_name_options_matches[2];
  352.             
  353.             if ($matches[8=== 'unix' && !empty($matches[9]))
  354.                 $pdo_prefs_dsn $matches[1':unix_socket=' $matches[9';dbname=' $matches[5];
  355.             else
  356.                 $pdo_prefs_dsn $matches[1':host=' $matches[4(!empty($matches[6]';port=' $matches[6''';dbname=' $matches[5];
  357.             try {
  358.                 $dbh new PDO($pdo_prefs_dsn$matches[2]$matches[3]);
  359.             catch (Exception $e{
  360.                 $this->error = $e->getMessage();
  361.                 return false;
  362.             }
  363.         else {
  364.             $dbh DB::connect($prefs_dsntrue);
  365.  
  366.             if(DB::isError($dbh)) {
  367.                 $this->error = DB::errorMessage($dbh);
  368.                 return false;
  369.             }
  370.         }
  371.  
  372.         $this->dbh = $dbh;
  373.         return true;
  374.     }
  375.  
  376.     /**
  377.      * Function used to handle database connection errors
  378.      *
  379.      * @param object PEAR Error object
  380.      *
  381.      */
  382.     function failQuery($res NULL{
  383.         global $use_pdo;
  384.         if($res == NULL{
  385.             printf(_("Preference database error (%s). Exiting abnormally"),
  386.                   $this->error);
  387.         else {
  388.             printf(_("Preference database error (%s). Exiting abnormally"),
  389.                   ($use_pdo implode(' - '$res->errorInfo()) DB::errorMessage($res)));
  390.         }
  391.         exit;
  392.     }
  393.  
  394.     /**
  395.      * Get user's prefs setting
  396.      *
  397.      * @param string $user user name
  398.      * @param string $key preference name
  399.      * @param mixed $default (since 1.2.5) default value
  400.      *
  401.      * @return mixed preference value
  402.      *
  403.      */
  404.     function getKey($user$key$default ''{
  405.         global $prefs_cache;
  406.  
  407.         $temp array(&$user&$key);
  408.         $result do_hook('get_pref_override'$temp);
  409.         if (is_null($result)) {
  410.             cachePrefValues($user);
  411.  
  412.             if (isset($prefs_cache[$key])) {
  413.                 $result $prefs_cache[$key];
  414.             else {
  415. //FIXME: is there a justification for having two prefs hooks so close?  who uses them?
  416.                 $temp array(&$user&$key);
  417.                 $result do_hook('get_pref'$temp);
  418.                 if (is_null($result)) {
  419.                     if (isset($this->default[$key])) {
  420.                         $result $this->default[$key];
  421.                     else {
  422.                         $result $default;
  423.                     }
  424.                 }
  425.             }
  426.         }
  427.         return $result;
  428.     }
  429.  
  430.     /**
  431.      * Delete user's prefs setting
  432.      *
  433.      * @param string $user user name
  434.      * @param string $key  preference name
  435.      *
  436.      * @return boolean 
  437.      *
  438.      */
  439.     function deleteKey($user$key{
  440.         global $prefs_cache$use_pdo$pdo_show_sql_errors;
  441.  
  442.         if (!$this->open()) {
  443.             return false;
  444.         }
  445.         if ($use_pdo{
  446.             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 . ' = ?'))) {
  447.                 if ($pdo_show_sql_errors)
  448.                     $this->error = implode(' - '$this->dbh->errorInfo());
  449.                 else
  450.                     $this->error = _("Could not prepare query");
  451.                 $this->failQuery();
  452.             }
  453.             if (!($res $sth->execute(array($user$key)))) {
  454.                 if ($pdo_show_sql_errors)
  455.                     $this->error = implode(' - '$sth->errorInfo());
  456.                 else
  457.                     $this->error = _("Could not execute query");
  458.                 $this->failQuery();
  459.             }
  460.         else {
  461.             $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  462.                              $this->table,
  463.                              $this->user_field,
  464.                              $this->dbh->quoteString($user),
  465.                              $this->key_field,
  466.                              $this->dbh->quoteString($key));
  467.  
  468.             $res $this->dbh->simpleQuery($query);
  469.             if(DB::isError($res)) {
  470.                 $this->failQuery($res);
  471.             }
  472.         }
  473.  
  474.         unset($prefs_cache[$key]);
  475.  
  476.         return true;
  477.     }
  478.  
  479.     /**
  480.      * Set user's preference
  481.      *
  482.      * @param string $user  user name
  483.      * @param string $key   preference name
  484.      * @param mixed  $value preference value
  485.      *
  486.      * @return boolean 
  487.      *
  488.      */
  489.     function setKey($user$key$value{
  490.         global $use_pdo$pdo_show_sql_errors;
  491.         if (!$this->open()) {
  492.             return false;
  493.         }
  494.  
  495.         /**
  496.          * Check if username fits into db field
  497.          */
  498.         if (strlen($user$this->user_size{
  499.             $this->error = "Oversized username value."
  500.                 ." Your preferences can't be saved."
  501.                 ." See the administrator's manual or contact your system administrator.";
  502.  
  503.             /**
  504.              * Debugging function. Can be used to log all issues that trigger
  505.              * oversized field errors. Function should be enabled in all three
  506.              * strlen checks. See http://www.php.net/error-log
  507.              */
  508.             // error_log($user.'|'.$key.'|'.$value."\n",3,'/tmp/oversized_log');
  509.  
  510.             // error is fatal
  511.             $this->failQuery(null);
  512.         }
  513.         /**
  514.          * Check if preference key fits into db field
  515.          */
  516.         if (strlen($key$this->key_size{
  517.             $err_msg "Oversized user's preference key."
  518.                 ." Some preferences were not saved."
  519.                 ." See the administrator's manual or contact your system administrator.";
  520.             // error is not fatal. Only some preference is not saved.
  521.             trigger_error($err_msg,E_USER_WARNING);
  522.             return false;
  523.         }
  524.         /**
  525.          * Check if preference value fits into db field
  526.          */
  527.         if (strlen($value$this->val_size{
  528.             $err_msg "Oversized user's preference value."
  529.                 ." Some preferences were not saved."
  530.                 ." See the administrator's manual or contact your system administrator.";
  531.             // error is not fatal. Only some preference is not saved.
  532.             trigger_error($err_msg,E_USER_WARNING);
  533.             return false;
  534.         }
  535.  
  536.  
  537.         if ($this->db_type == SMDB_MYSQL{
  538.             if ($use_pdo{
  539.                 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 (?, ?, ?)'))) {
  540.                     if ($pdo_show_sql_errors)
  541.                         $this->error = implode(' - '$this->dbh->errorInfo());
  542.                     else
  543.                         $this->error = _("Could not prepare query");
  544.                     $this->failQuery();
  545.                 }
  546.                 if (!($res $sth->execute(array($user$key$value)))) {
  547.                     if ($pdo_show_sql_errors)
  548.                         $this->error = implode(' - '$sth->errorInfo());
  549.                     else
  550.                         $this->error = _("Could not execute query");
  551.                     $this->failQuery();
  552.                 }
  553.             else {
  554.                 $query sprintf("REPLACE INTO %s (%s, %s, %s) ".
  555.                                  "VALUES('%s','%s','%s')",
  556.                                  $this->table,
  557.                                  $this->user_field,
  558.                                  $this->key_field,
  559.                                  $this->val_field,
  560.                                  $this->dbh->quoteString($user),
  561.                                  $this->dbh->quoteString($key),
  562.                                  $this->dbh->quoteString($value));
  563.  
  564.                 $res $this->dbh->simpleQuery($query);
  565.                 if(DB::isError($res)) {
  566.                     $this->failQuery($res);
  567.                 }
  568.             }
  569.         elseif ($this->db_type == SMDB_PGSQL{
  570.             if ($use_pdo{
  571.                 if ($this->dbh->exec('BEGIN TRANSACTION'=== FALSE{
  572.                     if ($pdo_show_sql_errors)
  573.                         $this->error = implode(' - '$this->dbh->errorInfo());
  574.                     else
  575.                         $this->error = _("Could not execute query");
  576.                     $this->failQuery();
  577.                 }
  578.                 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 . ' = ?'))) {
  579.                     if ($pdo_show_sql_errors)
  580.                         $this->error = implode(' - '$this->dbh->errorInfo());
  581.                     else
  582.                         $this->error = _("Could not prepare query");
  583.                     $this->failQuery();
  584.                 }
  585.                 if (!($res $sth->execute(array($user$key)))) {
  586.                     if ($pdo_show_sql_errors)
  587.                         $this->error = implode(' - '$sth->errorInfo());
  588.                     else
  589.                         $this->error = _("Could not execute query");
  590.                     $this->dbh->exec('ROLLBACK TRANSACTION');
  591.                     $this->failQuery();
  592.                 }
  593.                 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 (?, ?, ?)'))) {
  594.                     if ($pdo_show_sql_errors)
  595.                         $this->error = implode(' - '$this->dbh->errorInfo());
  596.                     else
  597.                         $this->error = _("Could not prepare query");
  598.                     $this->failQuery();
  599.                 }
  600.                 if (!($res $sth->execute(array($user$key$value)))) {
  601.                     if ($pdo_show_sql_errors)
  602.                         $this->error = implode(' - '$sth->errorInfo());
  603.                     else
  604.                         $this->error = _("Could not execute query");
  605.                     $this->dbh->exec('ROLLBACK TRANSACTION');
  606.                     $this->failQuery();
  607.                 }
  608.                 if ($this->dbh->exec('COMMIT TRANSACTION'=== FALSE{
  609.                     if ($pdo_show_sql_errors)
  610.                         $this->error = implode(' - '$this->dbh->errorInfo());
  611.                     else
  612.                         $this->error = _("Could not execute query");
  613.                     $this->failQuery();
  614.                 }
  615.             else {
  616.                 $this->dbh->simpleQuery("BEGIN TRANSACTION");
  617.                 $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  618.                                  $this->table,
  619.                                  $this->user_field,
  620.                                  $this->dbh->quoteString($user),
  621.                                  $this->key_field,
  622.                                  $this->dbh->quoteString($key));
  623.                 $res $this->dbh->simpleQuery($query);
  624.                 if (DB::isError($res)) {
  625.                     $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  626.                     $this->failQuery($res);
  627.                 }
  628.                 $query sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  629.                                  $this->table,
  630.                                  $this->user_field,
  631.                                  $this->key_field,
  632.                                  $this->val_field,
  633.                                  $this->dbh->quoteString($user),
  634.                                  $this->dbh->quoteString($key),
  635.                                  $this->dbh->quoteString($value));
  636.                 $res $this->dbh->simpleQuery($query);
  637.                 if (DB::isError($res)) {
  638.                     $this->dbh->simpleQuery("ROLLBACK TRANSACTION");
  639.                     $this->failQuery($res);
  640.                 }
  641.                 $this->dbh->simpleQuery("COMMIT TRANSACTION");
  642.             }
  643.         else {
  644.             if ($use_pdo{
  645.                 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 . ' = ?'))) {
  646.                     if ($pdo_show_sql_errors)
  647.                         $this->error = implode(' - '$this->dbh->errorInfo());
  648.                     else
  649.                         $this->error = _("Could not prepare query");
  650.                     $this->failQuery();
  651.                 }
  652.                 if (!($res $sth->execute(array($user$key)))) {
  653.                     if ($pdo_show_sql_errors)
  654.                         $this->error = implode(' - '$sth->errorInfo());
  655.                     else
  656.                         $this->error = _("Could not execute query");
  657.                     $this->failQuery();
  658.                 }
  659.                 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 (?, ?, ?)'))) {
  660.                     if ($pdo_show_sql_errors)
  661.                         $this->error = implode(' - '$this->dbh->errorInfo());
  662.                     else
  663.                         $this->error = _("Could not prepare query");
  664.                     $this->failQuery();
  665.                 }
  666.                 if (!($res $sth->execute(array($user$key$value)))) {
  667.                     if ($pdo_show_sql_errors)
  668.                         $this->error = implode(' - '$sth->errorInfo());
  669.                     else
  670.                         $this->error = _("Could not execute query");
  671.                     $this->failQuery();
  672.                 }
  673.             else {
  674.                 $query sprintf("DELETE FROM %s WHERE %s='%s' AND %s='%s'",
  675.                                  $this->table,
  676.                                  $this->user_field,
  677.                                  $this->dbh->quoteString($user),
  678.                                  $this->key_field,
  679.                                  $this->dbh->quoteString($key));
  680.                 $res $this->dbh->simpleQuery($query);
  681.                 if (DB::isError($res)) {
  682.                     $this->failQuery($res);
  683.                 }
  684.                 $query sprintf("INSERT INTO %s (%s, %s, %s) VALUES ('%s', '%s', '%s')",
  685.                                  $this->table,
  686.                                  $this->user_field,
  687.                                  $this->key_field,
  688.                                  $this->val_field,
  689.                                  $this->dbh->quoteString($user),
  690.                                  $this->dbh->quoteString($key),
  691.                                  $this->dbh->quoteString($value));
  692.                 $res $this->dbh->simpleQuery($query);
  693.                 if (DB::isError($res)) {
  694.                     $this->failQuery($res);
  695.                 }
  696.             }
  697.         }
  698.  
  699.         return true;
  700.     }
  701.  
  702.     /**
  703.      * Fill preference cache array
  704.      *
  705.      * @param string $user user name
  706.      *
  707.      * @since 1.2.3
  708.      *
  709.      */
  710.     function fillPrefsCache($user{
  711.         global $prefs_cache$use_pdo$pdo_show_sql_errors;
  712.  
  713.         if (!$this->open()) {
  714.             return;
  715.         }
  716.  
  717.         $prefs_cache array();
  718.         if ($use_pdo{
  719.             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 . ' = ?'))) {
  720.                 if ($pdo_show_sql_errors)
  721.                     $this->error = implode(' - '$this->dbh->errorInfo());
  722.                 else
  723.                     $this->error = _("Could not prepare query");
  724.                 $this->failQuery();
  725.             }
  726.             if (!($res $sth->execute(array($user)))) {
  727.                 if ($pdo_show_sql_errors)
  728.                     $this->error = implode(' - '$sth->errorInfo());
  729.                 else
  730.                     $this->error = _("Could not execute query");
  731.                 $this->failQuery();
  732.             }
  733.  
  734.             while ($row $sth->fetch(PDO::FETCH_ASSOC)) {
  735.                 $prefs_cache[$row['prefkey']] $row['prefval'];
  736.             }
  737.         else {
  738.             $query sprintf("SELECT %s as prefkey, %s as prefval FROM %s ".
  739.                              "WHERE %s = '%s'",
  740.                              $this->key_field,
  741.                              $this->val_field,
  742.                              $this->table,
  743.                              $this->user_field,
  744.                              $this->dbh->quoteString($user));
  745.             $res $this->dbh->query($query);
  746.             if (DB::isError($res)) {
  747.                 $this->failQuery($res);
  748.             }
  749.  
  750.             while ($row $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  751.                 $prefs_cache[$row['prefkey']] $row['prefval'];
  752.             }
  753.         }
  754.     }
  755.  
  756. /* end class dbPrefs */
  757.  
  758.  
  759. /**
  760.  * Returns the value for the requested preference
  761.  * @ignore
  762.  */
  763. function getPref($data_dir$username$pref_name$default ''{
  764.     $db new dbPrefs;
  765.     if(isset($db->error)) {
  766.         printf_("Preference database error (%s). Exiting abnormally"),
  767.               $db->error);
  768.         exit;
  769.     }
  770.  
  771.     return $db->getKey($username$pref_name$default);
  772. }
  773.  
  774. /**
  775.  * Remove the desired preference setting ($pref_name)
  776.  * @ignore
  777.  */
  778. function removePref($data_dir$username$pref_name{
  779.     global $prefs_cache;
  780.     $db new dbPrefs;
  781.     if(isset($db->error)) {
  782.         $db->failQuery();
  783.     }
  784.  
  785.     $db->deleteKey($username$pref_name);
  786.  
  787.     if (isset($prefs_cache[$pref_name])) {
  788.         unset($prefs_cache[$pref_name]);
  789.     }
  790.  
  791.     sqsession_register($prefs_cache 'prefs_cache');
  792.     return;
  793. }
  794.  
  795. /**
  796.  * Sets the desired preference setting ($pref_name) to whatever is in $value
  797.  * @ignore
  798.  */
  799. function setPref($data_dir$username$pref_name$value{
  800.     global $prefs_cache;
  801.  
  802.     if (isset($prefs_cache[$pref_name]&& ($prefs_cache[$pref_name== $value)) {
  803.         return;
  804.     }
  805.  
  806.     if ($value === ''{
  807.         removePref($data_dir$username$pref_name);
  808.         return;
  809.     }
  810.  
  811.     $db new dbPrefs;
  812.     if(isset($db->error)) {
  813.         $db->failQuery();
  814.     }
  815.  
  816.     $db->setKey($username$pref_name$value);
  817.     $prefs_cache[$pref_name$value;
  818.     assert_options(ASSERT_ACTIVE1);
  819.     assert_options(ASSERT_BAIL1);
  820.     assert ('$value == $prefs_cache[$pref_name]');
  821.     sqsession_register($prefs_cache 'prefs_cache');
  822.     return;
  823. }
  824.  
  825. /**
  826.  * This checks if the prefs are available
  827.  * @ignore
  828.  */
  829. function checkForPrefs($data_dir$username{
  830.     $db new dbPrefs;
  831.     if(isset($db->error)) {
  832.         $db->failQuery();
  833.     }
  834. }
  835.  
  836. /**
  837.  * Writes the Signature
  838.  * @ignore
  839.  */
  840. function setSig($data_dir$username$number$value{
  841.     if ($number == "g"{
  842.         $key '___signature___';
  843.     else {
  844.         $key sprintf('___sig%s___'$number);
  845.     }
  846.     setPref($data_dir$username$key$value);
  847.     return;
  848. }
  849.  
  850. /**
  851.  * Gets the signature
  852.  * @ignore
  853.  */
  854. function getSig($data_dir$username$number{
  855.     if ($number == "g"{
  856.         $key '___signature___';
  857.     else {
  858.         $key sprintf('___sig%d___'$number);
  859.     }
  860.     return getPref($data_dir$username$key);
  861. }

Documentation generated on Wed, 24 May 2017 04:23:36 +0200 by phpDocumentor 1.4.3