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

Documentation generated on Fri, 02 Dec 2016 04:23:48 +0100 by phpDocumentor 1.4.3