No OneTemporary
Actions

Size

46 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/program/include/bc.php b/program/include/bc.php
	index 0ddfb3215..447876d37 100644
	--- a/program/include/bc.php
	+++ b/program/include/bc.php
	@@ -1,418 +1,428 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/bc.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| Provide deprecated functions aliases for backward compatibility \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Roundcube Webmail deprecated functions
	*
	* @package Core
	* @subpackage Legacy
	* @author Thomas Bruederli <roundcube@gmail.com>
	*/

	// constants for input reading
	define('RCUBE_INPUT_GET', rcube_utils::INPUT_GET);
	define('RCUBE_INPUT_POST', rcube_utils::INPUT_POST);
	define('RCUBE_INPUT_GPC', rcube_utils::INPUT_GPC);

	define('JS_OBJECT_NAME', rcmail_output::JS_OBJECT_NAME);
	define('RCMAIL_CHARSET', RCUBE_CHARSET);

	function get_table_name($table)
	{
	return rcmail::get_instance()->db->table_name($table);
	}

	function rcube_label($p, $domain=null)
	{
	return rcmail::get_instance()->gettext($p, $domain);
	}

	function rcube_label_exists($name, $domain=null, &$ref_domain = null)
	{
	return rcmail::get_instance()->text_exists($name, $domain, $ref_domain);
	}

	function rcmail_overwrite_action($action)
	{
	rcmail::get_instance()->overwrite_action($action);
	}

	function rcmail_url($action, $p=array(), $task=null)
	{
	return rcmail::get_instance()->url((array)$p + array('_action' => $action, 'task' => $task));
	}

	function rcmail_temp_gc()
	{
	rcmail::get_instance()->temp_gc();
	}

	function rcube_charset_convert($str, $from, $to=NULL)
	{
	return rcube_charset::convert($str, $from, $to);
	}

	function rc_detect_encoding($string, $failover='')
	{
	return rcube_charset::detect($string, $failover);
	}

	function rc_utf8_clean($input)
	{
	return rcube_charset::clean($input);
	}

	function json_serialize($input)
	{
	return rcube_output::json_serialize($input);
	}

	function rep_specialchars_output($str, $enctype='', $mode='', $newlines=true)
	{
	return rcube_utils::rep_specialchars_output($str, $enctype, $mode, $newlines);
	}

	function Q($str, $mode='strict', $newlines=true)
	{
	return rcube_utils::rep_specialchars_output($str, 'html', $mode, $newlines);
	}

	function JQ($str)
	{
	return rcube_utils::rep_specialchars_output($str, 'js');
	}

	function get_input_value($fname, $source, $allow_html=FALSE, $charset=NULL)
	{
	return rcube_utils::get_input_value($fname, $source, $allow_html, $charset);
	}

	function parse_input_value($value, $allow_html=FALSE, $charset=NULL)
	{
	return rcube_utils::parse_input_value($value, $allow_html, $charset);
	}

	function request2param($mode = RCUBE_INPUT_GPC, $ignore = 'task\|action')
	{
	return rcube_utils::request2param($mode, $ignore);
	}

	function html_identifier($str, $encode=false)
	{
	return rcube_utils::html_identifier($str, $encode);
	}

	function rcube_table_output($attrib, $table_data, $a_show_cols, $id_col)
	{
	return rcmail::get_instance()->table_output($attrib, $table_data, $a_show_cols, $id_col);
	}

	function rcmail_get_edit_field($col, $value, $attrib, $type='text')
	{
	return rcube_output::get_edit_field($col, $value, $attrib, $type);
	}

	function rcmail_mod_css_styles($source, $container_id, $allow_remote=false)
	{
	return rcube_utils::mod_css_styles($source, $container_id, $allow_remote);
	}

	function rcmail_xss_entity_decode($content)
	{
	return rcube_utils::xss_entity_decode($content);
	}

	function create_attrib_string($attrib, $allowed_attribs=array('id', 'class', 'style'))
	{
	return html::attrib_string($attrib, $allowed_attribs);
	}

	function parse_attrib_string($str)
	{
	return html::parse_attrib_string($str);
	}

	function format_date($date, $format=NULL, $convert=true)
	{
	return rcmail::get_instance()->format_date($date, $format, $convert);
	}

	function rcmail_mailbox_list($attrib)
	{
	return rcmail::get_instance()->folder_list($attrib);
	}

	function rcmail_mailbox_select($attrib = array())
	{
	return rcmail::get_instance()->folder_selector($attrib);
	}

	function rcmail_render_folder_tree_html(&$arrFolders, &$mbox_name, &$jslist, $attrib, $nestLevel = 0)
	{
	return rcmail::get_instance()->render_folder_tree_html($arrFolders, $mbox_name, $jslist, $attrib, $nestLevel);
	}

	function rcmail_render_folder_tree_select(&$arrFolders, &$mbox_name, $maxlength, &$select, $realnames = false, $nestLevel = 0, $opts = array())
	{
	return rcmail::get_instance()->render_folder_tree_select($arrFolders, $mbox_name, $maxlength, $select, $realnames, $nestLevel, $opts);
	}

	function rcmail_build_folder_tree(&$arrFolders, $folder, $delm = '/', $path = '')
	{
	return rcmail::get_instance()->build_folder_tree($arrFolders, $folder, $delm, $path);
	}

	function rcmail_folder_classname($folder_id)
	{
	return rcmail::get_instance()->folder_classname($folder_id);
	}

	function rcmail_localize_foldername($name)
	{
	return rcmail::get_instance()->localize_foldername($name);
	}

	function rcmail_localize_folderpath($path)
	{
	return rcmail::get_instance()->localize_folderpath($path);
	}

	function rcmail_quota_display($attrib)
	{
	return rcmail::get_instance()->quota_display($attrib);
	}

	function rcmail_quota_content($attrib = null)
	{
	return rcmail::get_instance()->quota_content($attrib);
	}

	function rcmail_display_server_error($fallback=null, $fallback_args=null, $suffix='')
	{
	rcmail::get_instance()->display_server_error($fallback, $fallback_args, $suffix);
	}

	function rcmail_filetype2classname($mimetype, $filename)
	{
	return rcube_utils::file2class($mimetype, $filename);
	}

	function rcube_html_editor($mode='')
	{
	rcmail::get_instance()->html_editor($mode);
	}

	function rcmail_replace_emoticons($html)
	{
	return rcmail::get_instance()->replace_emoticons($html);
	}

	function rcmail_deliver_message(&$message, $from, $mailto, &$smtp_error, &$body_file=null, $smtp_opts=null)
	{
	return rcmail::get_instance()->deliver_message($message, $from, $mailto, $smtp_error, $body_file, $smtp_opts);
	}

	function rcmail_gen_message_id()
	{
	return rcmail::get_instance()->gen_message_id();
	}

	function rcmail_user_date()
	{
	return rcmail::get_instance()->user_date();
	}

	function rcmail_mem_check($need)
	{
	return rcube_utils::mem_check($need);
	}

	function rcube_https_check($port=null, $use_https=true)
	{
	return rcube_utils::https_check($port, $use_https);
	}

	function rcube_sess_unset($var_name=null)
	{
	rcmail::get_instance()->session->remove($var_name);
	}

	function rcube_parse_host($name, $host='')
	{
	return rcube_utils::parse_host($name, $host);
	}

	function check_email($email, $dns_check=true)
	{
	return rcube_utils::check_email($email, $dns_check);
	}

	function console()
	{
	call_user_func_array(array('rcmail', 'console'), func_get_args());
	}

	function write_log($name, $line)
	{
	return rcmail::write_log($name, $line);
	}

	function rcmail_log_login()
	{
	return rcmail::get_instance()->log_login();
	}

	function rcmail_remote_ip()
	{
	return rcube_utils::remote_ip();
	}

	function rcube_check_referer()
	{
	return rcube_utils::check_referer();
	}

	function rcube_timer()
	{
	return rcmail::timer();
	}

	function rcube_print_time($timer, $label='Timer', $dest='console')
	{
	rcmail::print_timer($timer, $label, $dest);
	}

	function raise_error($arg=array(), $log=false, $terminate=false)
	{
	rcmail::raise_error($arg, $log, $terminate);
	}

	function rcube_log_bug($arg_arr)
	{
	rcmail::log_bug($arg_arr);
	}

	function rcube_upload_progress()
	{
	rcmail::get_instance()->upload_progress();
	}

	function rcube_upload_init()
	{
	return rcmail::get_instance()->upload_init();
	}

	function rcube_autocomplete_init()
	{
	rcmail::get_instance()->autocomplete_init();
	}

	function rcube_fontdefs($font = null)
	{
	return rcmail::font_defs($font);
	}

	function send_nocacheing_headers()
	{
	return rcmail::get_instance()->output->nocacheing_headers();
	}

	function show_bytes($bytes)
	{
	return rcmail::get_instance()->show_bytes($bytes);
	}

	function rc_wordwrap($string, $width=75, $break="\n", $cut=false, $charset=null)
	{
	return rcube_mime::wordwrap($string, $width, $break, $cut, $charset);
	}

	function rc_request_header($name)
	{
	return rcube_utils::request_header($name);
	}

	function rcube_explode_quoted_string($delimiter, $string)
	{
	return rcube_utils::explode_quoted_string($delimiter, $string);
	}

	function rc_mime_content_type($path, $name, $failover = 'application/octet-stream', $is_stream=false)
	{
	return rcube_mime::file_content_type($path, $name, $failover, $is_stream);
	}

	function rc_image_content_type($data)
	{
	return rcube_mime::image_content_type($data);
	}

	function rcube_strtotime($date)
	{
	return rcube_utils::strtotime($date);
	}

	function rcube_idn_to_ascii($str)
	{
	return rcube_utils::idn_to_ascii($str);
	}

	function rcube_idn_to_utf8($str)
	{
	return rcube_utils::idn_to_utf8($str);
	}

	function send_future_expire_header($offset = 2600000)
	{
	return rcmail::get_instance()->output->future_expire_header($offset);
	}

	function get_opt($aliases = array())
	{
	return rcube_utils::get_opt($aliases);
	}

	function prompt_silent($prompt = 'Password:')
	{
	return rcube_utils::prompt_silent($prompt);
	}

	function get_boolean($str)
	{
	return rcube_utils::get_boolean($str);
	}

	function enriched_to_html($data)
	{
	return rcube_enriched::to_html($data);
	}

	+function strip_quotes($str)
	+{
	+ return str_replace(array("'", '"'), '', $str);
	+}
	+
	+function strip_newlines($str)
	+{
	+ return preg_replace('/[\r\n]/', '', $str);
	+}
	+
	class rcube_html_page extends rcmail_html_page
	{
	}

	class washtml extends rcube_washtml
	{
	}

	class html2text extends rcube_html2text
	{
	}
	diff --git a/program/lib/Roundcube/bootstrap.php b/program/lib/Roundcube/bootstrap.php
	index b7e69cb2a..5a371d2f0 100644
	--- a/program/lib/Roundcube/bootstrap.php
	+++ b/program/lib/Roundcube/bootstrap.php
	@@ -1,515 +1,489 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube PHP suite \|
	\| Copyright (C) 2005-2013, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| CONTENTS: \|
	\| Roundcube Framework Initialization \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Roundcube Framework Initialization
	*
	* @package Framework
	* @subpackage Core
	*/

	$config = array(
	'error_reporting' => E_ALL &~ (E_NOTICE \| E_STRICT),
	// Some users are not using Installer, so we'll check some
	// critical PHP settings here. Only these, which doesn't provide
	// an error/warning in the logs later. See (#1486307).
	'mbstring.func_overload' => 0,
	'magic_quotes_runtime' => 0,
	'magic_quotes_sybase' => 0, // #1488506
	);

	// check these additional ini settings if not called via CLI
	if (php_sapi_name() != 'cli') {
	$config += array(
	'suhosin.session.encrypt' => 0,
	'session.auto_start' => 0,
	'file_uploads' => 1,
	);
	}

	foreach ($config as $optname => $optval) {
	if ($optval != ini_get($optname) && @ini_set($optname, $optval) === false) {
	$error = "ERROR: Wrong '$optname' option value and it wasn't possible to set it to required value ($optval).\n"
	. "Check your PHP configuration (including php_admin_flag).";
	if (defined('STDERR')) fwrite(STDERR, $error); else echo $error;
	exit(1);
	}
	}

	// framework constants
	define('RCUBE_VERSION', '1.0-git');
	define('RCUBE_CHARSET', 'UTF-8');

	if (!defined('RCUBE_LIB_DIR')) {
	define('RCUBE_LIB_DIR', dirname(__FILE__).'/');
	}

	if (!defined('RCUBE_INSTALL_PATH')) {
	define('RCUBE_INSTALL_PATH', RCUBE_LIB_DIR);
	}

	if (!defined('RCUBE_CONFIG_DIR')) {
	define('RCUBE_CONFIG_DIR', RCUBE_INSTALL_PATH . 'config/');
	}

	if (!defined('RCUBE_PLUGINS_DIR')) {
	define('RCUBE_PLUGINS_DIR', RCUBE_INSTALL_PATH . 'plugins/');
	}

	if (!defined('RCUBE_LOCALIZATION_DIR')) {
	define('RCUBE_LOCALIZATION_DIR', RCUBE_INSTALL_PATH . 'localization/');
	}

	// set internal encoding for mbstring extension
	if (extension_loaded('mbstring')) {
	mb_internal_encoding(RCUBE_CHARSET);
	@mb_regex_encoding(RCUBE_CHARSET);
	}

	// Register autoloader
	spl_autoload_register('rcube_autoload');

	// set PEAR error handling (will also load the PEAR main class)
	PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, 'rcube_pear_error');



	/**
	* Similar function as in_array() but case-insensitive
	*
	* @param string $needle Needle value
	* @param array $heystack Array to search in
	*
	* @return boolean True if found, False if not
	*/
	function in_array_nocase($needle, $haystack)
	{
	$needle = mb_strtolower($needle);
	foreach ((array)$haystack as $value) {
	if ($needle === mb_strtolower($value)) {
	return true;
	}
	}

	return false;
	}


	/**
	* Parse a human readable string for a number of bytes.
	*
	* @param string $str Input string
	*
	* @return float Number of bytes
	*/
	function parse_bytes($str)
	{
	if (is_numeric($str)) {
	return floatval($str);
	}

	if (preg_match('/([0-9\.]+)\s([a-z])/i', $str, $regs)) {
	$bytes = floatval($regs[1]);
	switch (strtolower($regs[2])) {
	case 'g':
	case 'gb':
	$bytes *= 1073741824;
	break;
	case 'm':
	case 'mb':
	$bytes *= 1048576;
	break;
	case 'k':
	case 'kb':
	$bytes *= 1024;
	break;
	}
	}

	return floatval($bytes);
	}


	/**
	* Make sure the string ends with a slash
	*/
	function slashify($str)
	{
	return unslashify($str).'/';
	}


	/**
	* Remove slashes at the end of the string
	*/
	function unslashify($str)
	{
	return preg_replace('/\/+$/', '', $str);
	}


	/**
	* Returns number of seconds for a specified offset string.
	*
	* @param string $str String representation of the offset (e.g. 20min, 5h, 2days, 1week)
	*
	* @return int Number of seconds
	*/
	function get_offset_sec($str)
	{
	if (preg_match('/^([0-9]+)\s*([smhdw])/i', $str, $regs)) {
	$amount = (int) $regs[1];
	$unit = strtolower($regs[2]);
	}
	else {
	$amount = (int) $str;
	$unit = 's';
	}

	switch ($unit) {
	case 'w':
	$amount *= 7;
	case 'd':
	$amount *= 24;
	case 'h':
	$amount *= 60;
	case 'm':
	$amount *= 60;
	}

	return $amount;
	}


	/**
	* Create a unix timestamp with a specified offset from now.
	*
	* @param string $offset_str String representation of the offset (e.g. 20min, 5h, 2days)
	* @param int $factor Factor to multiply with the offset
	*
	* @return int Unix timestamp
	*/
	function get_offset_time($offset_str, $factor=1)
	{
	return time() + get_offset_sec($offset_str) * $factor;
	}


	/**
	* Truncate string if it is longer than the allowed length.
	* Replace the middle or the ending part of a string with a placeholder.
	*
	* @param string $str Input string
	* @param int $maxlength Max. length
	* @param string $placeholder Replace removed chars with this
	* @param bool $ending Set to True if string should be truncated from the end
	*
	* @return string Abbreviated string
	*/
	function abbreviate_string($str, $maxlength, $placeholder='...', $ending=false)
	{
	$length = mb_strlen($str);

	if ($length > $maxlength) {
	if ($ending) {
	return mb_substr($str, 0, $maxlength) . $placeholder;
	}

	$placeholder_length = mb_strlen($placeholder);
	$first_part_length = floor(($maxlength - $placeholder_length)/2);
	$second_starting_location = $length - $maxlength + $first_part_length + $placeholder_length;

	$str = mb_substr($str, 0, $first_part_length) . $placeholder . mb_substr($str, $second_starting_location);
	}

	return $str;
	}


	/**
	* Get all keys from array (recursive).
	*
	* @param array $array Input array
	*
	* @return array List of array keys
	*/
	function array_keys_recursive($array)
	{
	$keys = array();

	if (!empty($array) && is_array($array)) {
	foreach ($array as $key => $child) {
	$keys[] = $key;
	foreach (array_keys_recursive($child) as $val) {
	$keys[] = $val;
	}
	}
	}

	return $keys;
	}


	/**
	* Remove all non-ascii and non-word chars except ., -, _
	*/
	function asciiwords($str, $css_id = false, $replace_with = '')
	{
	$allowed = 'a-z0-9\_\-' . (!$css_id ? '\.' : '');
	return preg_replace("/[^$allowed]/i", $replace_with, $str);
	}


	/**
	* Check if a string contains only ascii characters
	*
	* @param string $str String to check
	* @param bool $control_chars Includes control characters
	*
	* @return bool
	*/
	function is_ascii($str, $control_chars = true)
	{
	$regexp = $control_chars ? '/[^\x00-\x7F]/' : '/[^\x20-\x7E]/';
	return preg_match($regexp, $str) ? false : true;
	}


	-/**
	- * Remove single and double quotes from a given string
	- *
	- * @param string Input value
	- *
	- * @return string Dequoted string
	- */
	-function strip_quotes($str)
	-{
	- return str_replace(array("'", '"'), '', $str);
	-}
	-
	-
	-/**
	- * Remove new lines characters from given string
	- *
	- * @param string $str Input value
	- *
	- * @return string Stripped string
	- */
	-function strip_newlines($str)
	-{
	- return preg_replace('/[\r\n]/', '', $str);
	-}
	-
	-
	/**
	* Compose a valid representation of name and e-mail address
	*
	* @param string $email E-mail address
	* @param string $name Person name
	*
	* @return string Formatted string
	*/
	function format_email_recipient($email, $name = '')
	{
	$email = trim($email);

	if ($name && $name != $email) {
	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	if (preg_match('/[\<\>\\\.\[\]@,;:"]/', $name)) {
	$name = '"'.addcslashes($name, '"').'"';
	}

	return "$name <$email>";
	}

	return $email;
	}


	/**
	* Format e-mail address
	*
	* @param string $email E-mail address
	*
	* @return string Formatted e-mail address
	*/
	function format_email($email)
	{
	$email = trim($email);
	$parts = explode('@', $email);
	$count = count($parts);

	if ($count > 1) {
	$parts[$count-1] = mb_strtolower($parts[$count-1]);

	$email = implode('@', $parts);
	}

	return $email;
	}


	/**
	* Fix version number so it can be used correctly in version_compare()
	*
	* @param string $version Version number string
	*
	* @param return Version number string
	*/
	function version_parse($version)
	{
	return str_replace(
	array('-stable', '-git'),
	array('.0', '.99'),
	$version);
	}


	/**
	* mbstring replacement functions
	*/
	if (!extension_loaded('mbstring'))
	{
	function mb_strlen($str)
	{
	return strlen($str);
	}

	function mb_strtolower($str)
	{
	return strtolower($str);
	}

	function mb_strtoupper($str)
	{
	return strtoupper($str);
	}

	function mb_substr($str, $start, $len=null)
	{
	return substr($str, $start, $len);
	}

	function mb_strpos($haystack, $needle, $offset=0)
	{
	return strpos($haystack, $needle, $offset);
	}

	function mb_strrpos($haystack, $needle, $offset=0)
	{
	return strrpos($haystack, $needle, $offset);
	}
	}

	/**
	* intl replacement functions
	*/

	if (!function_exists('idn_to_utf8'))
	{
	function idn_to_utf8($domain, $flags=null)
	{
	static $idn, $loaded;

	if (!$loaded) {
	$idn = new Net_IDNA2();
	$loaded = true;
	}

	if ($idn && $domain && preg_match('/(^\|\.)xn--/i', $domain)) {
	try {
	$domain = $idn->decode($domain);
	}
	catch (Exception $e) {
	}
	}
	return $domain;
	}
	}

	if (!function_exists('idn_to_ascii'))
	{
	function idn_to_ascii($domain, $flags=null)
	{
	static $idn, $loaded;

	if (!$loaded) {
	$idn = new Net_IDNA2();
	$loaded = true;
	}

	if ($idn && $domain && preg_match('/[^\x20-\x7E]/', $domain)) {
	try {
	$domain = $idn->encode($domain);
	}
	catch (Exception $e) {
	}
	}
	return $domain;
	}
	}

	/**
	* Use PHP5 autoload for dynamic class loading
	*
	* @todo Make Zend, PEAR etc play with this
	* @todo Make our classes conform to a more straight forward CS.
	*/
	function rcube_autoload($classname)
	{
	$filename = preg_replace(
	array(
	'/Mail_(.+)/',
	'/Net_(.+)/',
	'/Auth_(.+)/',
	'/^html_.+/',
	'/^rcube(.*)/',
	'/^utf8$/',
	),
	array(
	'Mail/\\1',
	'Net/\\1',
	'Auth/\\1',
	'Roundcube/html',
	'Roundcube/rcube\\1',
	'utf8.class',
	),
	$classname
	);

	if ($fp = @fopen("$filename.php", 'r', true)) {
	fclose($fp);
	include_once "$filename.php";
	return true;
	}

	return false;
	}

	/**
	* Local callback function for PEAR errors
	*/
	function rcube_pear_error($err)
	{
	error_log(sprintf("%s (%s): %s",
	$err->getMessage(),
	$err->getCode(),
	$err->getUserinfo()), 0);
	}
	diff --git a/program/lib/Roundcube/rcube_user.php b/program/lib/Roundcube/rcube_user.php
	index 505b190d1..5e9c9af80 100644
	--- a/program/lib/Roundcube/rcube_user.php
	+++ b/program/lib/Roundcube/rcube_user.php
	@@ -1,735 +1,734 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| \|
	\| Licensed under the GNU General Public License version 3 or \|
	\| any later version with exceptions for skins & plugins. \|
	\| See the README file for a full license statement. \|
	\| \|
	\| PURPOSE: \|
	\| This class represents a system user linked and provides access \|
	\| to the related database records. \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class representing a system user
	*
	* @package Framework
	* @subpackage Core
	*/
	class rcube_user
	{
	public $ID;
	public $data;
	public $language;

	/**
	* Holds database connection.
	*
	* @var rcube_db
	*/
	private $db;

	/**
	* Framework object.
	*
	* @var rcube
	*/
	private $rc;

	/**
	* Internal identities cache
	*
	* @var array
	*/
	private $identities = array();

	const SEARCH_ADDRESSBOOK = 1;
	const SEARCH_MAIL = 2;

	/**
	* Object constructor
	*
	* @param int $id User id
	* @param array $sql_arr SQL result set
	*/
	function __construct($id = null, $sql_arr = null)
	{
	$this->rc = rcube::get_instance();
	$this->db = $this->rc->get_dbh();

	if ($id && !$sql_arr) {
	$sql_result = $this->db->query(
	"SELECT * FROM ".$this->db->table_name('users')." WHERE user_id = ?", $id);
	$sql_arr = $this->db->fetch_assoc($sql_result);
	}

	if (!empty($sql_arr)) {
	$this->ID = $sql_arr['user_id'];
	$this->data = $sql_arr;
	$this->language = $sql_arr['language'];
	}
	}


	/**
	* Build a user name string (as e-mail address)
	*
	* @param string $part Username part (empty or 'local' or 'domain', 'mail')
	* @return string Full user name or its part
	*/
	function get_username($part = null)
	{
	if ($this->data['username']) {
	// return real name
	if (!$part) {
	return $this->data['username'];
	}

	list($local, $domain) = explode('@', $this->data['username']);

	// at least we should always have the local part
	if ($part == 'local') {
	return $local;
	}
	// if no domain was provided...
	if (empty($domain)) {
	$domain = $this->rc->config->mail_domain($this->data['mail_host']);
	}

	if ($part == 'domain') {
	return $domain;
	}

	if (!empty($domain))
	return $local . '@' . $domain;
	else
	return $local;
	}

	return false;
	}


	/**
	* Get the preferences saved for this user
	*
	* @return array Hash array with prefs
	*/
	function get_prefs()
	{
	if (!empty($this->language))
	$prefs = array('language' => $this->language);

	if ($this->ID) {
	// Preferences from session (write-master is unavailable)
	if (!empty($_SESSION['preferences'])) {
	// Check last write attempt time, try to write again (every 5 minutes)
	if ($_SESSION['preferences_time'] < time() - 5 * 60) {
	$saved_prefs = unserialize($_SESSION['preferences']);
	$this->rc->session->remove('preferences');
	$this->rc->session->remove('preferences_time');
	$this->save_prefs($saved_prefs);
	}
	else {
	$this->data['preferences'] = $_SESSION['preferences'];
	}
	}

	if ($this->data['preferences']) {
	$prefs += (array)unserialize($this->data['preferences']);
	}
	}

	return $prefs;
	}


	/**
	* Write the given user prefs to the user's record
	*
	* @param array $a_user_prefs User prefs to save
	* @return boolean True on success, False on failure
	*/
	function save_prefs($a_user_prefs)
	{
	if (!$this->ID)
	return false;

	$config = $this->rc->config;
	$old_prefs = (array)$this->get_prefs();

	// merge (partial) prefs array with existing settings
	$save_prefs = $a_user_prefs + $old_prefs;
	unset($save_prefs['language']);

	// don't save prefs with default values if they haven't been changed yet
	foreach ($a_user_prefs as $key => $value) {
	if ($value === null \|\| (!isset($old_prefs[$key]) && ($value == $config->get($key))))
	unset($save_prefs[$key]);
	}

	$save_prefs = serialize($save_prefs);

	$this->db->query(
	"UPDATE ".$this->db->table_name('users').
	" SET preferences = ?".
	", language = ?".
	" WHERE user_id = ?",
	$save_prefs,
	$_SESSION['language'],
	$this->ID);

	$this->language = $_SESSION['language'];

	// Update success
	if ($this->db->affected_rows() !== false) {
	$config->set_user_prefs($a_user_prefs);
	$this->data['preferences'] = $save_prefs;

	if (isset($_SESSION['preferences'])) {
	$this->rc->session->remove('preferences');
	$this->rc->session->remove('preferences_time');
	}
	return true;
	}
	// Update error, but we are using replication (we have read-only DB connection)
	// and we are storing session not in the SQL database
	// we can store preferences in session and try to write later (see get_prefs())
	else if ($this->db->is_replicated() && $config->get('session_storage', 'db') != 'db') {
	$_SESSION['preferences'] = $save_prefs;
	$_SESSION['preferences_time'] = time();
	$config->set_user_prefs($a_user_prefs);
	$this->data['preferences'] = $save_prefs;
	}

	return false;
	}


	/**
	* Get default identity of this user
	*
	* @param int $id Identity ID. If empty, the default identity is returned
	* @return array Hash array with all cols of the identity record
	*/
	function get_identity($id = null)
	{
	$id = (int)$id;
	// cache identities for better performance
	if (!array_key_exists($id, $this->identities)) {
	$result = $this->list_identities($id ? 'AND identity_id = ' . $id : '');
	$this->identities[$id] = $result[0];
	}

	return $this->identities[$id];
	}


	/**
	* Return a list of all identities linked with this user
	*
	* @param string $sql_add Optional WHERE clauses
	* @param bool $formatted Format identity email and name
	*
	* @return array List of identities
	*/
	function list_identities($sql_add = '', $formatted = false)
	{
	$result = array();

	$sql_result = $this->db->query(
	"SELECT * FROM ".$this->db->table_name('identities').
	" WHERE del <> 1 AND user_id = ?".
	($sql_add ? " ".$sql_add : "").
	" ORDER BY ".$this->db->quoteIdentifier('standard')." DESC, name ASC, identity_id ASC",
	$this->ID);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	if ($formatted) {
	$ascii_email = format_email($sql_arr['email']);
	$utf8_email = format_email(rcube_utils::idn_to_utf8($ascii_email));

	$sql_arr['email_ascii'] = $ascii_email;
	$sql_arr['email'] = $utf8_email;
	$sql_arr['ident'] = format_email_recipient($ascii_email, $sql_arr['name']);
	}

	$result[] = $sql_arr;
	}

	return $result;
	}


	/**
	* Update a specific identity record
	*
	* @param int $iid Identity ID
	* @param array $data Hash array with col->value pairs to save
	* @return boolean True if saved successfully, false if nothing changed
	*/
	function update_identity($iid, $data)
	{
	if (!$this->ID)
	return false;

	$query_cols = $query_params = array();

	foreach ((array)$data as $col => $value) {
	$query_cols[] = $this->db->quoteIdentifier($col) . ' = ?';
	$query_params[] = $value;
	}
	$query_params[] = $iid;
	$query_params[] = $this->ID;

	$sql = "UPDATE ".$this->db->table_name('identities').
	" SET changed = ".$this->db->now().", ".join(', ', $query_cols).
	" WHERE identity_id = ?".
	" AND user_id = ?".
	" AND del <> 1";

	call_user_func_array(array($this->db, 'query'),
	array_merge(array($sql), $query_params));

	$this->identities = array();

	return $this->db->affected_rows();
	}


	/**
	* Create a new identity record linked with this user
	*
	* @param array $data Hash array with col->value pairs to save
	* @return int The inserted identity ID or false on error
	*/
	function insert_identity($data)
	{
	if (!$this->ID)
	return false;

	unset($data['user_id']);

	$insert_cols = $insert_values = array();
	foreach ((array)$data as $col => $value) {
	$insert_cols[] = $this->db->quoteIdentifier($col);
	$insert_values[] = $value;
	}
	$insert_cols[] = 'user_id';
	$insert_values[] = $this->ID;

	$sql = "INSERT INTO ".$this->db->table_name('identities').
	" (changed, ".join(', ', $insert_cols).")".
	" VALUES (".$this->db->now().", ".join(', ', array_pad(array(), sizeof($insert_values), '?')).")";

	call_user_func_array(array($this->db, 'query'),
	array_merge(array($sql), $insert_values));

	$this->identities = array();

	return $this->db->insert_id('identities');
	}


	/**
	* Mark the given identity as deleted
	*
	* @param int $iid Identity ID
	* @return boolean True if deleted successfully, false if nothing changed
	*/
	function delete_identity($iid)
	{
	if (!$this->ID)
	return false;

	$sql_result = $this->db->query(
	"SELECT count(*) AS ident_count FROM ".$this->db->table_name('identities').
	" WHERE user_id = ? AND del <> 1",
	$this->ID);

	$sql_arr = $this->db->fetch_assoc($sql_result);

	// we'll not delete last identity
	if ($sql_arr['ident_count'] <= 1)
	return -1;

	$this->db->query(
	"UPDATE ".$this->db->table_name('identities').
	" SET del = 1, changed = ".$this->db->now().
	" WHERE user_id = ?".
	" AND identity_id = ?",
	$this->ID,
	$iid);

	$this->identities = array();

	return $this->db->affected_rows();
	}


	/**
	* Make this identity the default one for this user
	*
	* @param int $iid The identity ID
	*/
	function set_default($iid)
	{
	if ($this->ID && $iid) {
	$this->db->query(
	"UPDATE ".$this->db->table_name('identities').
	" SET ".$this->db->quoteIdentifier('standard')." = '0'".
	" WHERE user_id = ?".
	" AND identity_id <> ?".
	" AND del <> 1",
	$this->ID,
	$iid);

	unset($this->identities[0]);
	}
	}


	/**
	* Update user's last_login timestamp
	*/
	function touch()
	{
	if ($this->ID) {
	$this->db->query(
	"UPDATE ".$this->db->table_name('users').
	" SET last_login = ".$this->db->now().
	" WHERE user_id = ?",
	$this->ID);
	}
	}


	/**
	* Clear the saved object state
	*/
	function reset()
	{
	$this->ID = null;
	$this->data = null;
	}


	/**
	* Find a user record matching the given name and host
	*
	* @param string $user IMAP user name
	* @param string $host IMAP host name
	* @return rcube_user New user instance
	*/
	static function query($user, $host)
	{
	$dbh = rcube::get_instance()->get_dbh();
	$config = rcube::get_instance()->config;

	// query for matching user name
	$sql_result = $dbh->query("SELECT * FROM " . $dbh->table_name('users')
	." WHERE mail_host = ? AND username = ?", $host, $user);

	$sql_arr = $dbh->fetch_assoc($sql_result);

	// username not found, try aliases from identities
	if (empty($sql_arr) && $config->get('user_aliases') && strpos($user, '@')) {
	$sql_result = $dbh->limitquery("SELECT u.*"
	." FROM " . $dbh->table_name('users') . " u"
	." JOIN " . $dbh->table_name('identities') . " i ON (i.user_id = u.user_id)"
	." WHERE email = ? AND del <> 1", 0, 1, $user);

	$sql_arr = $dbh->fetch_assoc($sql_result);
	}

	// user already registered -> overwrite username
	if ($sql_arr)
	return new rcube_user($sql_arr['user_id'], $sql_arr);
	else
	return false;
	}


	/**
	* Create a new user record and return a rcube_user instance
	*
	* @param string $user IMAP user name
	* @param string $host IMAP host
	* @return rcube_user New user instance
	*/
	static function create($user, $host)
	{
	$user_name = '';
	$user_email = '';
	$rcube = rcube::get_instance();
	$dbh = $rcube->get_dbh();

	// try to resolve user in virtuser table and file
	if ($email_list = self::user2email($user, false, true)) {
	$user_email = is_array($email_list[0]) ? $email_list[0]['email'] : $email_list[0];
	}

	$data = $rcube->plugins->exec_hook('user_create', array(
	'host' => $host,
	'user' => $user,
	'user_name' => $user_name,
	'user_email' => $user_email,
	'email_list' => $email_list,
	'language' => $_SESSION['language'],
	));

	// plugin aborted this operation
	if ($data['abort']) {
	return false;
	}

	$dbh->query(
	"INSERT INTO ".$dbh->table_name('users').
	" (created, last_login, username, mail_host, language)".
	" VALUES (".$dbh->now().", ".$dbh->now().", ?, ?, ?)",
	- strip_newlines($data['user']),
	- strip_newlines($data['host']),
	- strip_newlines($data['language']));
	+ $data['user'],
	+ $data['host'],
	+ $data['language']);

	if ($user_id = $dbh->insert_id('users')) {
	// create rcube_user instance to make plugin hooks work
	$user_instance = new rcube_user($user_id, array(
	'user_id' => $user_id,
	'username' => $data['user'],
	'mail_host' => $data['host'],
	'language' => $data['language'],
	));
	$rcube->user = $user_instance;
	$mail_domain = $rcube->config->mail_domain($data['host']);
	$user_name = $data['user_name'];
	$user_email = $data['user_email'];
	$email_list = $data['email_list'];

	if (empty($email_list)) {
	if (empty($user_email)) {
	$user_email = strpos($data['user'], '@') ? $user : sprintf('%s@%s', $data['user'], $mail_domain);
	}
	- $email_list[] = strip_newlines($user_email);
	+ $email_list[] = $user_email;
	}
	// identities_level check
	else if (count($email_list) > 1 && $rcube->config->get('identities_level', 0) > 1) {
	$email_list = array($email_list[0]);
	}

	if (empty($user_name)) {
	$user_name = $data['user'];
	}

	// create new identities records
	$standard = 1;
	foreach ($email_list as $row) {
	$record = array();

	if (is_array($row)) {
	if (empty($row['email'])) {
	continue;
	}
	$record = $row;
	}
	else {
	$record['email'] = $row;
	}

	if (empty($record['name'])) {
	$record['name'] = $user_name != $record['email'] ? $user_name : '';
	}

	- $record['name'] = strip_newlines($record['name']);
	$record['user_id'] = $user_id;
	$record['standard'] = $standard;

	$plugin = $rcube->plugins->exec_hook('identity_create',
	array('login' => true, 'record' => $record));

	if (!$plugin['abort'] && $plugin['record']['email']) {
	$rcube->user->insert_identity($plugin['record']);
	}
	$standard = 0;
	}
	}
	else {
	rcube::raise_error(array(
	'code' => 500,
	'type' => 'php',
	'line' => __LINE__,
	'file' => __FILE__,
	'message' => "Failed to create new user"), true, false);
	}

	return $user_id ? $user_instance : false;
	}


	/**
	* Resolve username using a virtuser plugins
	*
	* @param string $email E-mail address to resolve
	* @return string Resolved IMAP username
	*/
	static function email2user($email)
	{
	$rcube = rcube::get_instance();
	$plugin = $rcube->plugins->exec_hook('email2user',
	array('email' => $email, 'user' => NULL));

	return $plugin['user'];
	}


	/**
	* Resolve e-mail address from virtuser plugins
	*
	* @param string $user User name
	* @param boolean $first If true returns first found entry
	* @param boolean $extended If true returns email as array (email and name for identity)
	* @return mixed Resolved e-mail address string or array of strings
	*/
	static function user2email($user, $first=true, $extended=false)
	{
	$rcube = rcube::get_instance();
	$plugin = $rcube->plugins->exec_hook('user2email',
	array('email' => NULL, 'user' => $user,
	'first' => $first, 'extended' => $extended));

	return empty($plugin['email']) ? NULL : $plugin['email'];
	}


	/**
	* Return a list of saved searches linked with this user
	*
	* @param int $type Search type
	*
	* @return array List of saved searches indexed by search ID
	*/
	function list_searches($type)
	{
	$plugin = $this->rc->plugins->exec_hook('saved_search_list', array('type' => $type));

	if ($plugin['abort']) {
	return (array) $plugin['result'];
	}

	$result = array();

	$sql_result = $this->db->query(
	"SELECT search_id AS id, ".$this->db->quoteIdentifier('name')
	." FROM ".$this->db->table_name('searches')
	." WHERE user_id = ?"
	." AND ".$this->db->quoteIdentifier('type')." = ?"
	." ORDER BY ".$this->db->quoteIdentifier('name'),
	(int) $this->ID, (int) $type);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	$sql_arr['data'] = unserialize($sql_arr['data']);
	$result[$sql_arr['id']] = $sql_arr;
	}

	return $result;
	}


	/**
	* Return saved search data.
	*
	* @param int $id Row identifier
	*
	* @return array Data
	*/
	function get_search($id)
	{
	$plugin = $this->rc->plugins->exec_hook('saved_search_get', array('id' => $id));

	if ($plugin['abort']) {
	return $plugin['result'];
	}

	$sql_result = $this->db->query(
	"SELECT ".$this->db->quoteIdentifier('name')
	.", ".$this->db->quoteIdentifier('data')
	.", ".$this->db->quoteIdentifier('type')
	." FROM ".$this->db->table_name('searches')
	." WHERE user_id = ?"
	." AND search_id = ?",
	(int) $this->ID, (int) $id);

	while ($sql_arr = $this->db->fetch_assoc($sql_result)) {
	return array(
	'id' => $id,
	'name' => $sql_arr['name'],
	'type' => $sql_arr['type'],
	'data' => unserialize($sql_arr['data']),
	);
	}

	return null;
	}


	/**
	* Deletes given saved search record
	*
	* @param int $sid Search ID
	*
	* @return boolean True if deleted successfully, false if nothing changed
	*/
	function delete_search($sid)
	{
	if (!$this->ID)
	return false;

	$this->db->query(
	"DELETE FROM ".$this->db->table_name('searches')
	." WHERE user_id = ?"
	." AND search_id = ?",
	(int) $this->ID, $sid);

	return $this->db->affected_rows();
	}


	/**
	* Create a new saved search record linked with this user
	*
	* @param array $data Hash array with col->value pairs to save
	*
	* @return int The inserted search ID or false on error
	*/
	function insert_search($data)
	{
	if (!$this->ID)
	return false;

	$insert_cols[] = 'user_id';
	$insert_values[] = (int) $this->ID;
	$insert_cols[] = $this->db->quoteIdentifier('type');
	$insert_values[] = (int) $data['type'];
	$insert_cols[] = $this->db->quoteIdentifier('name');
	$insert_values[] = $data['name'];
	$insert_cols[] = $this->db->quoteIdentifier('data');
	$insert_values[] = serialize($data['data']);

	$sql = "INSERT INTO ".$this->db->table_name('searches')
	." (".join(', ', $insert_cols).")"
	." VALUES (".join(', ', array_pad(array(), sizeof($insert_values), '?')).")";

	call_user_func_array(array($this->db, 'query'),
	array_merge(array($sql), $insert_values));

	return $this->db->insert_id('searches');
	}

	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 9:20 AM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166529
Default Alt Text: (46 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions