No OneTemporary
Actions

Size

85 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/program/lib/Roundcube/html.php b/program/lib/Roundcube/html.php
	index 33b766c44..522a82305 100644
	--- a/program/lib/Roundcube/html.php
	+++ b/program/lib/Roundcube/html.php
	@@ -1,846 +1,847 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2011, 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: \|
	\| Helper class to create valid XHTML code \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Class for HTML code creation
	*
	* @package Framework
	* @subpackage HTML
	*/
	class html
	{
	protected $tagname;
	protected $attrib = array();
	protected $allowed = array();
	protected $content;

	public static $doctype = 'xhtml';
	public static $lc_tags = true;
	public static $common_attrib = array('id','class','style','title','align');
	public static $containers = array('iframe','div','span','p','h1','h2','h3','form','textarea','table','thead','tbody','tr','th','td','style','script');

	/**
	* Constructor
	*
	* @param array $attrib Hash array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}
	}

	/**
	* Return the tag code
	*
	* @return string The finally composed HTML tag
	*/
	public function show()
	{
	return self::tag($this->tagname, $this->attrib, $this->content, array_merge(self::$common_attrib, $this->allowed));
	}

	/**** STATIC METHODS *****/

	/**
	* Generic method to create a HTML tag
	*
	* @param string $tagname Tag name
	* @param array $attrib Tag attributes as key/value pairs
	* @param string $content Optinal Tag content (creates a container tag)
	* @param array $allowed_attrib List with allowed attributes, omit to allow all
	* @return string The XHTML tag
	*/
	public static function tag($tagname, $attrib = array(), $content = null, $allowed_attrib = null)
	{
	if (is_string($attrib))
	$attrib = array('class' => $attrib);

	$inline_tags = array('a','span','img');
	$suffix = $attrib['nl'] \|\| ($content && $attrib['nl'] !== false && !in_array($tagname, $inline_tags)) ? "\n" : '';

	$tagname = self::$lc_tags ? strtolower($tagname) : $tagname;
	if (isset($content) \|\| in_array($tagname, self::$containers)) {
	$suffix = $attrib['noclose'] ? $suffix : '</' . $tagname . '>' . $suffix;
	unset($attrib['noclose'], $attrib['nl']);
	return '<' . $tagname . self::attrib_string($attrib, $allowed_attrib) . '>' . $content . $suffix;
	}
	else {
	return '<' . $tagname . self::attrib_string($attrib, $allowed_attrib) . '>' . $suffix;
	}
	}

	/**
	*
	*/
	public static function doctype($type)
	{
	$doctypes = array(
	'html5' => '<!DOCTYPE html>',
	'xhtml' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-trans' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
	'xhtml-strict' => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
	);

	if ($doctypes[$type]) {
	self::$doctype = preg_replace('/-\w+$/', '', $type);
	return $doctypes[$type];
	}

	return '';
	}

	/**
	* Derrived method for <div> containers
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Div content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function div($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('div', $attr, $cont, array_merge(self::$common_attrib, array('onclick')));
	}

	/**
	* Derrived method for <p> blocks
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Paragraph content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function p($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('p', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method to create <img />
	*
	* @param mixed $attr Hash array with tag attributes or string with image source (src)
	* @return string HTML code
	* @see html::tag()
	*/
	public static function img($attr = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	return self::tag('img', $attr + array('alt' => ''), null, array_merge(self::$common_attrib,
	array('src','alt','width','height','border','usemap','onclick')));
	}

	/**
	* Derrived method for link tags
	*
	* @param mixed $attr Hash array with tag attributes or string with link location (href)
	* @param string $cont Link content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function a($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('href' => $attr);
	}
	return self::tag('a', $attr, $cont, array_merge(self::$common_attrib,
	- array('href','target','name','rel','onclick','onmouseover','onmouseout','onmousedown','onmouseup')));
	+ array('href','target','name','rel','onclick','onmouseover','onmouseout','onmousedown','onmouseup')));
	}

	/**
	* Derrived method for inline span tags
	*
	* @param mixed $attr Hash array with tag attributes or string with class name
	* @param string $cont Tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function span($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}
	return self::tag('span', $attr, $cont, self::$common_attrib);
	}

	/**
	* Derrived method for form element labels
	*
	* @param mixed $attr Hash array with tag attributes or string with 'for' attrib
	* @param string $cont Tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function label($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('for' => $attr);
	}
	return self::tag('label', $attr, $cont, array_merge(self::$common_attrib, array('for')));
	}

	/**
	* Derrived method to create <iframe></iframe>
	*
	* @param mixed $attr Hash array with tag attributes or string with frame source (src)
	* @return string HTML code
	* @see html::tag()
	*/
	public static function iframe($attr = null, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	return self::tag('iframe', $attr, $cont, array_merge(self::$common_attrib,
	array('src','name','width','height','border','frameborder')));
	}

	/**
	* Derrived method to create <script> tags
	*
	* @param mixed $attr Hash array with tag attributes or string with script source (src)
	* @param string $cont Javascript code to be placed as tag content
	* @return string HTML code
	* @see html::tag()
	*/
	public static function script($attr, $cont = null)
	{
	if (is_string($attr)) {
	$attr = array('src' => $attr);
	}
	if ($cont) {
	if (self::$doctype == 'xhtml')
	$cont = "\n/* <![CDATA[ /\n" . $cont . "\n/ ]]> */\n";
	else
	$cont = "\n" . $cont . "\n";
	}

	return self::tag('script', $attr + array('type' => 'text/javascript', 'nl' => true),
	$cont, array_merge(self::$common_attrib, array('src','type','charset')));
	}

	/**
	* Derrived method for line breaks
	*
	* @return string HTML code
	* @see html::tag()
	*/
	public static function br($attrib = array())
	{
	return self::tag('br', $attrib);
	}

	/**
	* Create string with attributes
	*
	* @param array $attrib Associative arry with tag attributes
	* @param array $allowed List of allowed attributes
	* @return string Valid attribute string
	*/
	public static function attrib_string($attrib = array(), $allowed = null)
	{
	if (empty($attrib)) {
	return '';
	}

	$allowed_f = array_flip((array)$allowed);
	$attrib_arr = array();
	foreach ($attrib as $key => $value) {
	// skip size if not numeric
	if ($key == 'size' && !is_numeric($value)) {
	continue;
	}

	// ignore "internal" or not allowed attributes
	if ($key == 'nl' \|\| ($allowed && !isset($allowed_f[$key])) \|\| $value === null) {
	continue;
	}

	// skip empty eventhandlers
	if (preg_match('/^on[a-z]+/', $key) && !$value) {
	continue;
	}

	// attributes with no value
	if (in_array($key, array('checked', 'multiple', 'disabled', 'selected'))) {
	if ($value) {
	$attrib_arr[] = $key . '="' . $key . '"';
	}
	}
	else {
	$attrib_arr[] = $key . '="' . self::quote($value) . '"';
	}
	}

	return count($attrib_arr) ? ' '.implode(' ', $attrib_arr) : '';
	}

	/**
	* Convert a HTML attribute string attributes to an associative array (name => value)
	*
	* @param string Input string
	* @return array Key-value pairs of parsed attributes
	*/
	public static function parse_attrib_string($str)
	{
	$attrib = array();
	$regexp = '/\s([-_a-z]+)=(["\'])??(?(2)([^\2])\2\|(\S+?))/Ui';

	preg_match_all($regexp, stripslashes($str), $regs, PREG_SET_ORDER);

	// convert attributes to an associative array (name => value)
	if ($regs) {
	foreach ($regs as $attr) {
	$attrib[strtolower($attr[1])] = html_entity_decode($attr[3] . $attr[4]);
	}
	}

	return $attrib;
	}

	/**
	* Replacing specials characters in html attribute value
	*
	* @param string $str Input string
	*
	* @return string The quoted string
	*/
	public static function quote($str)
	{
	return @htmlspecialchars($str, ENT_COMPAT, RCUBE_CHARSET);
	}
	}


	/**
	* Class to create an HTML input field
	*
	* @package HTML
	*/
	class html_inputfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'text';
	protected $allowed = array(
	'type','name','value','size','tabindex','autocapitalize',
	'autocomplete','checked','onchange','onclick','disabled','readonly',
	'spellcheck','results','maxlength','src','multiple','placeholder',
	);

	/**
	* Object constructor
	*
	* @param array $attrib Associative array with tag attributes
	*/
	public function __construct($attrib = array())
	{
	if (is_array($attrib)) {
	$this->attrib = $attrib;
	}

	if ($attrib['type']) {
	$this->type = $attrib['type'];
	}
	}

	/**
	* Compose input tag
	*
	* @param string $value Field value
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = null, $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	if ($value !== null) {
	$this->attrib['value'] = $value;
	}
	// set type
	$this->attrib['type'] = $this->type;
	return parent::show();
	}
	}

	/**
	* Class to create an HTML password field
	*
	* @package HTML
	*/
	class html_passwordfield extends html_inputfield
	{
	protected $type = 'password';
	}

	/**
	* Class to create an hidden HTML input field
	*
	* @package HTML
	*/

	class html_hiddenfield extends html
	{
	protected $tagname = 'input';
	protected $type = 'hidden';
	protected $fields_arr = array();
	protected $allowed = array('type','name','value','onchange','disabled','readonly');

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = null)
	{
	if (is_array($attrib)) {
	$this->add($attrib);
	}
	}

	/**
	* Add a hidden field to this instance
	*
	* @param array $attrib Named tag attributes
	*/
	public function add($attrib)
	{
	$this->fields_arr[] = $attrib;
	}

	/**
	* Create HTML code for the hidden fields
	*
	* @return string Final HTML code
	*/
	public function show()
	{
	$out = '';
	foreach ($this->fields_arr as $attrib) {
	$out .= self::tag($this->tagname, array('type' => $this->type) + $attrib);
	}
	return $out;
	}
	}

	/**
	* Class to create HTML radio buttons
	*
	* @package HTML
	*/
	class html_radiobutton extends html_inputfield
	{
	protected $type = 'radio';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create HTML checkboxes
	*
	* @package HTML
	*/
	class html_checkbox extends html_inputfield
	{
	protected $type = 'checkbox';

	/**
	* Get HTML code for this object
	*
	* @param string $value Value of the checked field
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// set value attribute
	$this->attrib['checked'] = ((string)$value == (string)$this->attrib['value']);

	return parent::show();
	}
	}

	/**
	* Class to create an HTML textarea
	*
	* @package HTML
	*/
	class html_textarea extends html
	{
	protected $tagname = 'textarea';
	protected $allowed = array('name','rows','cols','wrap','tabindex',
	'onchange','disabled','readonly','spellcheck');

	/**
	* Get HTML code for this object
	*
	* @param string $value Textbox value
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($value = '', $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	// take value attribute as content
	if (empty($value) && !empty($this->attrib['value'])) {
	$value = $this->attrib['value'];
	}

	// make shure we don't print the value attribute
	if (isset($this->attrib['value'])) {
	unset($this->attrib['value']);
	}

	if (!empty($value) && empty($this->attrib['is_escaped'])) {
	$value = self::quote($value);
	}

	return self::tag($this->tagname, $this->attrib, $value,
	array_merge(self::$common_attrib, $this->allowed));
	}
	}

	/**
	* Builder for HTML drop-down menus
	* Syntax:<pre>
	* // create instance. arguments are used to set attributes of select-tag
	* $select = new html_select(array('name' => 'fieldname'));
	*
	* // add one option
	* $select->add('Switzerland', 'CH');
	*
	* // add multiple options
	* $select->add(array('Switzerland','Germany'), array('CH','DE'));
	*
	* // generate pulldown with selection 'Switzerland' and return html-code
	* // as second argument the same attributes available to instanciate can be used
	* print $select->show('CH');
	* </pre>
	*
	* @package HTML
	*/
	class html_select extends html
	{
	protected $tagname = 'select';
	protected $options = array();
	protected $allowed = array('name','size','tabindex','autocomplete',
	'multiple','onchange','disabled','rel');

	/**
	* Add a new option to this drop-down
	*
	* @param mixed $names Option name or array with option names
	* @param mixed $values Option value or array with option values
	*/
	public function add($names, $values = null)
	{
	if (is_array($names)) {
	foreach ($names as $i => $text) {
	$this->options[] = array('text' => $text, 'value' => $values[$i]);
	}
	}
	else {
	$this->options[] = array('text' => $names, 'value' => $values);
	}
	}

	/**
	* Get HTML code for this object
	*
	* @param string $select Value of the selection option
	* @param array $attrib Additional attributes to override
	* @return string HTML output
	*/
	public function show($select = array(), $attrib = null)
	{
	// overwrite object attributes
	if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	}

	$this->content = "\n";
	$select = (array)$select;
	foreach ($this->options as $option) {
	$attr = array(
	'value' => $option['value'],
	'selected' => (in_array($option['value'], $select, true) \|\|
	in_array($option['text'], $select, true)) ? 1 : null);

	$option_content = $option['text'];
	if (empty($this->attrib['is_escaped'])) {
	$option_content = self::quote($option_content);
	}

	$this->content .= self::tag('option', $attr, $option_content);
	}

	return parent::show();
	}
	}


	/**
	* Class to build an HTML table
	*
	* @package HTML
	*/
	class html_table extends html
	{
	protected $tagname = 'table';
	protected $allowed = array('id','class','style','width','summary',
	'cellpadding','cellspacing','border');

	private $header = array();
	private $rows = array();
	private $rowindex = 0;
	private $colindex = 0;

	/**
	* Constructor
	*
	* @param array $attrib Named tag attributes
	*/
	public function __construct($attrib = array())
	{
	$default_attrib = self::$doctype == 'xhtml' ? array('summary' => '', 'border' => 0) : array();
	$this->attrib = array_merge($attrib, $default_attrib);
	}

	/**
	* Add a table cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	- $cell->attrib = $attr;
	+ $cell->attrib = $attr;
	$cell->content = $cont;

	$this->rows[$this->rowindex]->cells[$this->colindex] = $cell;
	$this->colindex += max(1, intval($attr['colspan']));

	if ($this->attrib['cols'] && $this->colindex >= $this->attrib['cols']) {
	$this->add_row();
	}
	}

	/**
	* Add a table header cell
	*
	* @param array $attr Cell attributes
	* @param string $cont Cell content
	*/
	public function add_header($attr, $cont)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	$cell = new stdClass;
	- $cell->attrib = $attr;
	- $cell->content = $cont;
	+ $cell->attrib = $attr;
	+ $cell->content = $cont;
	$this->header[] = $cell;
	}

	- /**
	+ /**
	* Remove a column from a table
	* Useful for plugins making alterations
	- *
	- * @param string $class
	+ *
	+ * @param string $class
	*/
	public function remove_column($class)
	{
	// Remove the header
	foreach ($this->header as $index=>$header){
	if ($header->attrib['class'] == $class){
	unset($this->header[$index]);
	break;
	}
	}

	// Remove cells from rows
	foreach ($this->rows as $i=>$row){
	foreach ($row->cells as $j=>$cell){
	if ($cell->attrib['class'] == $class){
	unset($this->rows[$i]->cells[$j]);
	break;
	}
	}
	}
	}

	/**
	* Jump to next row
	*
	* @param array $attr Row attributes
	*/
	public function add_row($attr = array())
	{
	$this->rowindex++;
	$this->colindex = 0;
	$this->rows[$this->rowindex] = new stdClass;
	$this->rows[$this->rowindex]->attrib = $attr;
	$this->rows[$this->rowindex]->cells = array();
	}

	/**
	* Set row attributes
	*
	* @param array $attr Row attributes
	* @param int $index Optional row index (default current row index)
	*/
	public function set_row_attribs($attr = array(), $index = null)
	{
	if (is_string($attr)) {
	$attr = array('class' => $attr);
	}

	if ($index === null) {
	$index = $this->rowindex;
	}

	$this->rows[$index]->attrib = $attr;
	}

	/**
	* Get row attributes
	*
	* @param int $index Row index
	*
	* @return array Row attributes
	*/
	public function get_row_attribs($index = null)
	{
	if ($index === null) {
	$index = $this->rowindex;
	}

	return $this->rows[$index] ? $this->rows[$index]->attrib : null;
	}

	/**
	* Build HTML output of the table data
	*
	* @param array $attrib Table attributes
	* @return string The final table HTML code
	*/
	public function show($attrib = null)
	{
	- if (is_array($attrib))
	+ if (is_array($attrib)) {
	$this->attrib = array_merge($this->attrib, $attrib);
	+ }

	$thead = $tbody = "";

	// include <thead>
	if (!empty($this->header)) {
	$rowcontent = '';
	foreach ($this->header as $c => $col) {
	$rowcontent .= self::tag('td', $col->attrib, $col->content);
	}
	$thead = self::tag('thead', null, self::tag('tr', null, $rowcontent, parent::$common_attrib));
	}

	foreach ($this->rows as $r => $row) {
	$rowcontent = '';
	foreach ($row->cells as $c => $col) {
	$rowcontent .= self::tag('td', $col->attrib, $col->content);
	}

	if ($r < $this->rowindex \|\| count($row->cells)) {
	$tbody .= self::tag('tr', $row->attrib, $rowcontent, parent::$common_attrib);
	}
	}

	if ($this->attrib['rowsonly']) {
	return $tbody;
	}

	// add <tbody>
	$this->content = $thead . self::tag('tbody', null, $tbody);

	unset($this->attrib['cols'], $this->attrib['rowsonly']);
	return parent::show();
	}

	/**
	* Count number of rows
	*
	* @return The number of rows
	*/
	public function size()
	{
	- return count($this->rows);
	+ return count($this->rows);
	}

	/**
	* Remove table body (all rows)
	*/
	public function remove_body()
	{
	$this->rows = array();
	$this->rowindex = 0;
	}

	}
	diff --git a/program/lib/Roundcube/rcube_addressbook.php b/program/lib/Roundcube/rcube_addressbook.php
	index a8f274a8f..98d8f98ee 100644
	--- a/program/lib/Roundcube/rcube_addressbook.php
	+++ b/program/lib/Roundcube/rcube_addressbook.php
	@@ -1,530 +1,530 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2006-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: \|
	\| Interface to the local address book database \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/


	/**
	* Abstract skeleton of an address book/repository
	*
	* @package Framework
	* @subpackage Addressbook
	*/
	abstract class rcube_addressbook
	{
	/ constants for error reporting /
	const ERROR_READ_ONLY = 1;
	const ERROR_NO_CONNECTION = 2;
	const ERROR_VALIDATE = 3;
	const ERROR_SAVING = 4;
	const ERROR_SEARCH = 5;

	/** public properties (mandatory) */
	public $primary_key;
	public $groups = false;
	public $readonly = true;
	public $searchonly = false;
	public $undelete = false;
	public $ready = false;
	public $group_id = null;
	public $list_page = 1;
	public $page_size = 10;
	public $sort_col = 'name';
	public $sort_order = 'ASC';
	public $coltypes = array('name' => array('limit'=>1), 'firstname' => array('limit'=>1), 'surname' => array('limit'=>1), 'email' => array('limit'=>1));

	protected $error;

	/**
	* Returns addressbook name (e.g. for addressbooks listing)
	*/
	abstract function get_name();

	/**
	* Save a search string for future listings
	*
	* @param mixed Search params to use in listing method, obtained by get_search_set()
	*/
	abstract function set_search_set($filter);

	/**
	* Getter for saved search properties
	*
	* @return mixed Search properties used by this class
	*/
	abstract function get_search_set();

	/**
	* Reset saved results and search parameters
	*/
	abstract function reset();

	/**
	* Refresh saved search set after data has changed
	*
	* @return mixed New search set
	*/
	function refresh_search()
	{
	return $this->get_search_set();
	}

	/**
	* List the current set of contact records
	*
	* @param array List of cols to show
	* @param int Only return this number of records, use negative values for tail
	* @return array Indexed list of contact records, each a hash array
	*/
	abstract function list_records($cols=null, $subset=0);

	/**
	* Search records
	*
	* @param array List of fields to search in
	* @param string Search value
	* @param int Matching mode:
	* 0 - partial (abc),
	* 1 - strict (=),
	* 2 - prefix (abc*)
	* @param boolean True if results are requested, False if count only
	* @param boolean True to skip the count query (select only)
	* @param array List of fields that cannot be empty
	* @return object rcube_result_set List of contact records and 'count' value
	*/
	abstract function search($fields, $value, $mode=0, $select=true, $nocount=false, $required=array());

	/**
	* Count number of available contacts in database
	*
	* @return rcube_result_set Result set with values for 'count' and 'first'
	*/
	abstract function count();

	/**
	* Return the last result set
	*
	* @return rcube_result_set Current result set or NULL if nothing selected yet
	*/
	abstract function get_result();

	/**
	* Get a specific contact record
	*
	* @param mixed record identifier(s)
	* @param boolean True to return record as associative array, otherwise a result set is returned
	*
	* @return mixed Result object with all record fields or False if not found
	*/
	abstract function get_record($id, $assoc=false);

	/**
	* Returns the last error occured (e.g. when updating/inserting failed)
	*
	* @return array Hash array with the following fields: type, message
	*/
	function get_error()
	{
	- return $this->error;
	+ return $this->error;
	}

	/**
	* Setter for errors for internal use
	*
	* @param int Error type (one of this class' error constants)
	* @param string Error message (name of a text label)
	*/
	protected function set_error($type, $message)
	{
	- $this->error = array('type' => $type, 'message' => $message);
	+ $this->error = array('type' => $type, 'message' => $message);
	}

	/**
	* Close connection to source
	* Called on script shutdown
	*/
	function close() { }

	/**
	* Set internal list page
	*
	* @param number Page number to list
	* @access public
	*/
	function set_page($page)
	{
	$this->list_page = (int)$page;
	}

	/**
	* Set internal page size
	*
	* @param number Number of messages to display on one page
	* @access public
	*/
	function set_pagesize($size)
	{
	$this->page_size = (int)$size;
	}

	/**
	* Set internal sort settings
	*
	* @param string $sort_col Sort column
	* @param string $sort_order Sort order
	*/
	function set_sort_order($sort_col, $sort_order = null)
	{
	if ($sort_col != null && ($this->coltypes[$sort_col] \|\| in_array($sort_col, $this->coltypes))) {
	$this->sort_col = $sort_col;
	}
	if ($sort_order != null) {
	$this->sort_order = strtoupper($sort_order) == 'DESC' ? 'DESC' : 'ASC';
	}
	}

	/**
	* Check the given data before saving.
	* If input isn't valid, the message to display can be fetched using get_error()
	*
	* @param array Assoziative array with data to save
	* @param boolean Attempt to fix/complete record automatically
	* @return boolean True if input is valid, False if not.
	*/
	public function validate(&$save_data, $autofix = false)
	{
	$rcube = rcube::get_instance();

	// check validity of email addresses
	foreach ($this->get_col_values('email', $save_data, true) as $email) {
	if (strlen($email)) {
	if (!rcube_utils::check_email(rcube_utils::idn_to_ascii($email))) {
	$error = $rcube->gettext(array('name' => 'emailformaterror', 'vars' => array('email' => $email)));
	$this->set_error(self::ERROR_VALIDATE, $error);
	return false;
	}
	}
	}

	return true;
	}


	/**
	* Create a new contact record
	*
	* @param array Assoziative array with save data
	* Keys: Field name with optional section in the form FIELD:SECTION
	* Values: Field value. Can be either a string or an array of strings for multiple values
	* @param boolean True to check for duplicates first
	* @return mixed The created record ID on success, False on error
	*/
	function insert($save_data, $check=false)
	{
	/* empty for read-only address books */
	}

	/**
	* Create new contact records for every item in the record set
	*
	* @param object rcube_result_set Recordset to insert
	* @param boolean True to check for duplicates first
	* @return array List of created record IDs
	*/
	function insertMultiple($recset, $check=false)
	{
	$ids = array();
	if (is_object($recset) && is_a($recset, rcube_result_set)) {
	while ($row = $recset->next()) {
	if ($insert = $this->insert($row, $check))
	$ids[] = $insert;
	}
	}
	return $ids;
	}

	/**
	* Update a specific contact record
	*
	* @param mixed Record identifier
	* @param array Assoziative array with save data
	* Keys: Field name with optional section in the form FIELD:SECTION
	* Values: Field value. Can be either a string or an array of strings for multiple values
	* @return boolean True on success, False on error
	*/
	function update($id, $save_cols)
	{
	/* empty for read-only address books */
	}

	/**
	* Mark one or more contact records as deleted
	*
	* @param array Record identifiers
	* @param bool Remove records irreversible (see self::undelete)
	*/
	function delete($ids, $force=true)
	{
	/* empty for read-only address books */
	}

	/**
	* Unmark delete flag on contact record(s)
	*
	* @param array Record identifiers
	*/
	function undelete($ids)
	{
	/* empty for read-only address books */
	}

	/**
	* Mark all records in database as deleted
	*/
	function delete_all()
	{
	/* empty for read-only address books */
	}

	/**
	* Setter for the current group
	* (empty, has to be re-implemented by extending class)
	*/
	function set_group($gid) { }

	/**
	* List all active contact groups of this source
	*
	* @param string Optional search string to match group name
	* @return array Indexed list of contact groups, each a hash array
	*/
	function list_groups($search = null)
	{
	/* empty for address books don't supporting groups */
	return array();
	}

	/**
	* Get group properties such as name and email address(es)
	*
	* @param string Group identifier
	* @return array Group properties as hash array
	*/
	function get_group($group_id)
	{
	/* empty for address books don't supporting groups */
	return null;
	}

	/**
	* Create a contact group with the given name
	*
	* @param string The group name
	* @return mixed False on error, array with record props in success
	*/
	function create_group($name)
	{
	/* empty for address books don't supporting groups */
	return false;
	}

	/**
	* Delete the given group and all linked group members
	*
	* @param string Group identifier
	* @return boolean True on success, false if no data was changed
	*/
	function delete_group($gid)
	{
	/* empty for address books don't supporting groups */
	return false;
	}

	/**
	* Rename a specific contact group
	*
	* @param string Group identifier
	* @param string New name to set for this group
	* @param string New group identifier (if changed, otherwise don't set)
	* @return boolean New name on success, false if no data was changed
	*/
	function rename_group($gid, $newname, &$newid)
	{
	/* empty for address books don't supporting groups */
	return false;
	}

	/**
	* Add the given contact records the a certain group
	*
	* @param string Group identifier
	* @param array List of contact identifiers to be added
	* @return int Number of contacts added
	*/
	function add_to_group($group_id, $ids)
	{
	/* empty for address books don't supporting groups */
	return 0;
	}

	/**
	* Remove the given contact records from a certain group
	*
	* @param string Group identifier
	* @param array List of contact identifiers to be removed
	* @return int Number of deleted group members
	*/
	function remove_from_group($group_id, $ids)
	{
	/* empty for address books don't supporting groups */
	return 0;
	}

	/**
	* Get group assignments of a specific contact record
	*
	* @param mixed Record identifier
	*
	* @return array List of assigned groups as ID=>Name pairs
	* @since 0.5-beta
	*/
	function get_record_groups($id)
	{
	/* empty for address books don't supporting groups */
	return array();
	}


	/**
	* Utility function to return all values of a certain data column
	* either as flat list or grouped by subtype
	*
	* @param string Col name
	* @param array Record data array as used for saving
	* @param boolean True to return one array with all values, False for hash array with values grouped by type
	* @return array List of column values
	*/
	function get_col_values($col, $data, $flat = false)
	{
	$out = array();
	foreach ((array)$data as $c => $values) {
	if ($c === $col \|\| strpos($c, $col.':') === 0) {
	if ($flat) {
	$out = array_merge($out, (array)$values);
	}
	else {
	list($f, $type) = explode(':', $c);
	$out[$type] = array_merge((array)$out[$type], (array)$values);
	}
	}
	}

	// remove duplicates
	if ($flat && !empty($out)) {
	$out = array_unique($out);
	}

	return $out;
	}


	/**
	* Normalize the given string for fulltext search.
	* Currently only optimized for Latin-1 characters; to be extended
	*
	* @param string Input string (UTF-8)
	* @return string Normalized string
	* @deprecated since 0.9-beta
	*/
	protected static function normalize_string($str)
	{
	return rcube_utils::normalize_string($str);
	}

	/**
	* Compose a valid display name from the given structured contact data
	*
	* @param array Hash array with contact data as key-value pairs
	* @param bool Don't attempt to extract components from the email address
	*
	* @return string Display name
	*/
	public static function compose_display_name($contact, $full_email = false)
	{
	$contact = rcube::get_instance()->plugins->exec_hook('contact_displayname', $contact);
	$fn = $contact['name'];

	if (!$fn) // default display name composition according to vcard standard
	$fn = trim(join(' ', array_filter(array($contact['prefix'], $contact['firstname'], $contact['middlename'], $contact['surname'], $contact['suffix']))));

	// use email address part for name
	$email = is_array($contact['email']) ? $contact['email'][0] : $contact['email'];

	if ($email && (empty($fn) \|\| $fn == $email)) {
	// return full email
	if ($full_email)
	return $email;

	list($emailname) = explode('@', $email);
	if (preg_match('/(.)[\.\-\_](.)/', $emailname, $match))
	$fn = trim(ucfirst($match[1]).' '.ucfirst($match[2]));
	else
	$fn = ucfirst($emailname);
	}

	return $fn;
	}


	/**
	* Compose the name to display in the contacts list for the given contact record.
	* This respects the settings parameter how to list conacts.
	*
	* @param array Hash array with contact data as key-value pairs
	* @return string List name
	*/
	public static function compose_list_name($contact)
	{
	static $compose_mode;

	if (!isset($compose_mode)) // cache this
	$compose_mode = rcube::get_instance()->config->get('addressbook_name_listing', 0);

	if ($compose_mode == 3)
	$fn = join(' ', array($contact['surname'] . ',', $contact['firstname'], $contact['middlename']));
	else if ($compose_mode == 2)
	$fn = join(' ', array($contact['surname'], $contact['firstname'], $contact['middlename']));
	else if ($compose_mode == 1)
	$fn = join(' ', array($contact['firstname'], $contact['middlename'], $contact['surname']));
	else
	$fn = !empty($contact['name']) ? $contact['name'] : join(' ', array($contact['prefix'], $contact['firstname'], $contact['middlename'], $contact['surname'], $contact['suffix']));

	$fn = trim($fn, ', ');

	// fallback to display name
	if (empty($fn) && $contact['name'])
	$fn = $contact['name'];

	// fallback to email address
	$email = is_array($contact['email']) ? $contact['email'][0] : $contact['email'];
	if (empty($fn) && $email)
	return $email;

	return $fn;
	}

	}

	diff --git a/program/lib/Roundcube/rcube_session.php b/program/lib/Roundcube/rcube_session.php
	index 69eaabedc..1aa5d5856 100644
	--- a/program/lib/Roundcube/rcube_session.php
	+++ b/program/lib/Roundcube/rcube_session.php
	@@ -1,629 +1,656 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2012, The Roundcube Dev Team \|
	\| Copyright (C) 2011, Kolab Systems AG \|
	\| \|
	\| 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 database supported session management \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Author: Aleksander Machniak <alec@alec.pl> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Class to provide database supported session storage
	*
	* @package Framework
	* @subpackage Core
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @author Aleksander Machniak <alec@alec.pl>
	*/
	class rcube_session
	{
	- private $db;
	- private $ip;
	- private $start;
	- private $changed;
	- private $unsets = array();
	- private $gc_handlers = array();
	- private $cookiename = 'roundcube_sessauth';
	- private $vars;
	- private $key;
	- private $now;
	- private $secret = '';
	- private $ip_check = false;
	- private $logging = false;
	- private $memcache;
	-
	- /**
	- * Default constructor
	- */
	- public function __construct($db, $config)
	- {
	- $this->db = $db;
	- $this->start = microtime(true);
	- $this->ip = $_SERVER['REMOTE_ADDR'];
	- $this->logging = $config->get('log_session', false);
	-
	- $lifetime = $config->get('session_lifetime', 1) * 60;
	- $this->set_lifetime($lifetime);
	-
	- // use memcache backend
	- if ($config->get('session_storage', 'db') == 'memcache') {
	- $this->memcache = rcube::get_instance()->get_memcache();
	-
	- // set custom functions for PHP session management if memcache is available
	- if ($this->memcache) {
	- session_set_save_handler(
	- array($this, 'open'),
	- array($this, 'close'),
	- array($this, 'mc_read'),
	- array($this, 'mc_write'),
	- array($this, 'mc_destroy'),
	- array($this, 'gc'));
	- }
	- else {
	- rcube::raise_error(array('code' => 604, 'type' => 'db',
	- 'line' => __LINE__, 'file' => __FILE__,
	- 'message' => "Failed to connect to memcached. Please check configuration"),
	- true, true);
	- }
	+ private $db;
	+ private $ip;
	+ private $start;
	+ private $changed;
	+ private $unsets = array();
	+ private $gc_handlers = array();
	+ private $cookiename = 'roundcube_sessauth';
	+ private $vars;
	+ private $key;
	+ private $now;
	+ private $secret = '';
	+ private $ip_check = false;
	+ private $logging = false;
	+ private $memcache;
	+
	+
	+ /**
	+ * Default constructor
	+ */
	+ public function __construct($db, $config)
	+ {
	+ $this->db = $db;
	+ $this->start = microtime(true);
	+ $this->ip = $_SERVER['REMOTE_ADDR'];
	+ $this->logging = $config->get('log_session', false);
	+
	+ $lifetime = $config->get('session_lifetime', 1) * 60;
	+ $this->set_lifetime($lifetime);
	+
	+ // use memcache backend
	+ if ($config->get('session_storage', 'db') == 'memcache') {
	+ $this->memcache = rcube::get_instance()->get_memcache();
	+
	+ // set custom functions for PHP session management if memcache is available
	+ if ($this->memcache) {
	+ session_set_save_handler(
	+ array($this, 'open'),
	+ array($this, 'close'),
	+ array($this, 'mc_read'),
	+ array($this, 'mc_write'),
	+ array($this, 'mc_destroy'),
	+ array($this, 'gc'));
	+ }
	+ else {
	+ rcube::raise_error(array('code' => 604, 'type' => 'db',
	+ 'line' => __LINE__, 'file' => __FILE__,
	+ 'message' => "Failed to connect to memcached. Please check configuration"),
	+ true, true);
	+ }
	+ }
	+ else {
	+ // set custom functions for PHP session management
	+ session_set_save_handler(
	+ array($this, 'open'),
	+ array($this, 'close'),
	+ array($this, 'db_read'),
	+ array($this, 'db_write'),
	+ array($this, 'db_destroy'),
	+ array($this, 'db_gc'));
	+ }
	}
	- else {
	- // set custom functions for PHP session management
	- session_set_save_handler(
	- array($this, 'open'),
	- array($this, 'close'),
	- array($this, 'db_read'),
	- array($this, 'db_write'),
	- array($this, 'db_destroy'),
	- array($this, 'db_gc'));
	- }
	- }
	-
	-
	- public function open($save_path, $session_name)
	- {
	- return true;
	- }
	-
	-
	- public function close()
	- {
	- return true;
	- }
	-
	-
	- /**
	- * Delete session data for the given key
	- *
	- * @param string Session ID
	- */
	- public function destroy($key)
	- {
	- return $this->memcache ? $this->mc_destroy($key) : $this->db_destroy($key);
	- }
	-
	-
	- /**
	- * Read session data from database
	- *
	- * @param string Session ID
	- * @return string Session vars
	- */
	- public function db_read($key)
	- {
	- $sql_result = $this->db->query(
	- "SELECT vars, ip, changed FROM ".$this->db->table_name('session')
	- ." WHERE sess_id = ?", $key);
	-
	- if ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	- $this->changed = strtotime($sql_arr['changed']);
	- $this->ip = $sql_arr['ip'];
	- $this->vars = base64_decode($sql_arr['vars']);
	- $this->key = $key;
	-
	- return !empty($this->vars) ? (string) $this->vars : '';
	+
	+
	+ public function open($save_path, $session_name)
	+ {
	+ return true;
	+ }
	+
	+
	+ public function close()
	+ {
	+ return true;
	}

	- return null;
	- }
	-
	-
	- /**
	- * Save session data.
	- * handler for session_read()
	- *
	- * @param string Session ID
	- * @param string Serialized session vars
	- * @return boolean True on success
	- */
	- public function db_write($key, $vars)
	- {
	- $ts = microtime(true);
	- $now = $this->db->fromunixtime((int)$ts);
	-
	- // no session row in DB (db_read() returns false)
	- if (!$this->key) {
	- $oldvars = null;
	+
	+ /**
	+ * Delete session data for the given key
	+ *
	+ * @param string Session ID
	+ */
	+ public function destroy($key)
	+ {
	+ return $this->memcache ? $this->mc_destroy($key) : $this->db_destroy($key);
	+ }
	+
	+
	+ /**
	+ * Read session data from database
	+ *
	+ * @param string Session ID
	+ *
	+ * @return string Session vars
	+ */
	+ public function db_read($key)
	+ {
	+ $sql_result = $this->db->query(
	+ "SELECT vars, ip, changed FROM ".$this->db->table_name('session')
	+ ." WHERE sess_id = ?", $key);
	+
	+ if ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	+ $this->changed = strtotime($sql_arr['changed']);
	+ $this->ip = $sql_arr['ip'];
	+ $this->vars = base64_decode($sql_arr['vars']);
	+ $this->key = $key;
	+
	+ return !empty($this->vars) ? (string) $this->vars : '';
	+ }
	+
	+ return null;
	}
	- // use internal data from read() for fast requests (up to 0.5 sec.)
	- else if ($key == $this->key && (!$this->vars \|\| $ts - $this->start < 0.5)) {
	- $oldvars = $this->vars;
	+
	+
	+ /**
	+ * Save session data.
	+ * handler for session_read()
	+ *
	+ * @param string Session ID
	+ * @param string Serialized session vars
	+ *
	+ * @return boolean True on success
	+ */
	+ public function db_write($key, $vars)
	+ {
	+ $ts = microtime(true);
	+ $now = $this->db->fromunixtime((int)$ts);
	+
	+ // no session row in DB (db_read() returns false)
	+ if (!$this->key) {
	+ $oldvars = null;
	+ }
	+ // use internal data from read() for fast requests (up to 0.5 sec.)
	+ else if ($key == $this->key && (!$this->vars \|\| $ts - $this->start < 0.5)) {
	+ $oldvars = $this->vars;
	+ }
	+ else { // else read data again from DB
	+ $oldvars = $this->db_read($key);
	+ }
	+
	+ if ($oldvars !== null) {
	+ $newvars = $this->_fixvars($vars, $oldvars);
	+
	+ if ($newvars !== $oldvars) {
	+ $this->db->query(
	+ sprintf("UPDATE %s SET vars=?, changed=%s WHERE sess_id=?",
	+ $this->db->table_name('session'), $now),
	+ base64_encode($newvars), $key);
	+ }
	+ else if ($ts - $this->changed > $this->lifetime / 2) {
	+ $this->db->query("UPDATE ".$this->db->table_name('session')
	+ ." SET changed=$now WHERE sess_id=?", $key);
	+ }
	+ }
	+ else {
	+ $this->db->query(
	+ sprintf("INSERT INTO %s (sess_id, vars, ip, created, changed) ".
	+ "VALUES (?, ?, ?, %s, %s)",
	+ $this->db->table_name('session'), $now, $now),
	+ $key, base64_encode($vars), (string)$this->ip);
	+ }
	+
	+ return true;
	+ }
	+
	+
	+ /**
	+ * Merge vars with old vars and apply unsets
	+ */
	+ private function _fixvars($vars, $oldvars)
	+ {
	+ if ($oldvars !== null) {
	+ $a_oldvars = $this->unserialize($oldvars);
	+ if (is_array($a_oldvars)) {
	+ foreach ((array)$this->unsets as $k)
	+ unset($a_oldvars[$k]);
	+
	+ $newvars = $this->serialize(array_merge(
	+ (array)$a_oldvars, (array)$this->unserialize($vars)));
	+ }
	+ else {
	+ $newvars = $vars;
	+ }
	+ }
	+
	+ $this->unsets = array();
	+ return $newvars;
	}
	- else { // else read data again from DB
	- $oldvars = $this->db_read($key);
	+
	+
	+ /**
	+ * Handler for session_destroy()
	+ *
	+ * @param string Session ID
	+ *
	+ * @return boolean True on success
	+ */
	+ public function db_destroy($key)
	+ {
	+ if ($key) {
	+ $this->db->query(sprintf("DELETE FROM %s WHERE sess_id = ?",
	+ $this->db->table_name('session')), $key);
	+ }
	+
	+ return true;
	}

	- if ($oldvars !== null) {
	- $newvars = $this->_fixvars($vars, $oldvars);

	- if ($newvars !== $oldvars) {
	+ /**
	+ * Garbage collecting function
	+ *
	+ * @param string Session lifetime in seconds
	+ * @return boolean True on success
	+ */
	+ public function db_gc($maxlifetime)
	+ {
	+ // just delete all expired sessions
	$this->db->query(
	- sprintf("UPDATE %s SET vars=?, changed=%s WHERE sess_id=?",
	- $this->db->table_name('session'), $now),
	- base64_encode($newvars), $key);
	- }
	- else if ($ts - $this->changed > $this->lifetime / 2) {
	- $this->db->query("UPDATE ".$this->db->table_name('session')." SET changed=$now WHERE sess_id=?", $key);
	- }
	+ sprintf("DELETE FROM %s WHERE changed < %s",
	+ $this->db->table_name('session'), $this->db->fromunixtime(time() - $maxlifetime)));
	+
	+ $this->gc();
	+
	+ return true;
	+ }
	+
	+
	+ /**
	+ * Read session data from memcache
	+ *
	+ * @param string Session ID
	+ * @return string Session vars
	+ */
	+ public function mc_read($key)
	+ {
	+ if ($value = $this->memcache->get($key)) {
	+ $arr = unserialize($value);
	+ $this->changed = $arr['changed'];
	+ $this->ip = $arr['ip'];
	+ $this->vars = $arr['vars'];
	+ $this->key = $key;
	+
	+ return !empty($this->vars) ? (string) $this->vars : '';
	+ }
	+
	+ return null;
	+ }
	+
	+
	+ /**
	+ * Save session data.
	+ * handler for session_read()
	+ *
	+ * @param string Session ID
	+ * @param string Serialized session vars
	+ *
	+ * @return boolean True on success
	+ */
	+ public function mc_write($key, $vars)
	+ {
	+ $ts = microtime(true);
	+
	+ // no session data in cache (mc_read() returns false)
	+ if (!$this->key)
	+ $oldvars = null;
	+ // use internal data for fast requests (up to 0.5 sec.)
	+ else if ($key == $this->key && (!$this->vars \|\| $ts - $this->start < 0.5))
	+ $oldvars = $this->vars;
	+ else // else read data again
	+ $oldvars = $this->mc_read($key);
	+
	+ $newvars = $oldvars !== null ? $this->_fixvars($vars, $oldvars) : $vars;
	+
	+ if ($newvars !== $oldvars \|\| $ts - $this->changed > $this->lifetime / 2) {
	+ return $this->memcache->set($key, serialize(array('changed' => time(), 'ip' => $this->ip, 'vars' => $newvars)),
	+ MEMCACHE_COMPRESSED, $this->lifetime);
	+ }
	+
	+ return true;
	+ }
	+
	+
	+ /**
	+ * Handler for session_destroy() with memcache backend
	+ *
	+ * @param string Session ID
	+ *
	+ * @return boolean True on success
	+ */
	+ public function mc_destroy($key)
	+ {
	+ if ($key) {
	+ // #1488592: use 2nd argument
	+ $this->memcache->delete($key, 0);
	+ }
	+
	+ return true;
	+ }
	+
	+
	+ /**
	+ * Execute registered garbage collector routines
	+ */
	+ public function gc()
	+ {
	+ foreach ($this->gc_handlers as $fct) {
	+ call_user_func($fct);
	+ }
	}
	- else {
	- $this->db->query(
	- sprintf("INSERT INTO %s (sess_id, vars, ip, created, changed) ".
	- "VALUES (?, ?, ?, %s, %s)",
	- $this->db->table_name('session'), $now, $now),
	- $key, base64_encode($vars), (string)$this->ip);
	+
	+
	+ /**
	+ * Register additional garbage collector functions
	+ *
	+ * @param mixed Callback function
	+ */
	+ public function register_gc_handler($func)
	+ {
	+ foreach ($this->gc_handlers as $handler) {
	+ if ($handler == $func) {
	+ return;
	+ }
	+ }
	+
	+ $this->gc_handlers[] = $func;
	}

	- return true;
	- }
	-
	-
	- /**
	- * Merge vars with old vars and apply unsets
	- */
	- private function _fixvars($vars, $oldvars)
	- {
	- if ($oldvars !== null) {
	- $a_oldvars = $this->unserialize($oldvars);
	- if (is_array($a_oldvars)) {
	- foreach ((array)$this->unsets as $k)
	- unset($a_oldvars[$k]);
	-
	- $newvars = $this->serialize(array_merge(
	- (array)$a_oldvars, (array)$this->unserialize($vars)));
	- }
	- else
	- $newvars = $vars;
	+
	+ /**
	+ * Generate and set new session id
	+ *
	+ * @param boolean $destroy If enabled the current session will be destroyed
	+ */
	+ public function regenerate_id($destroy=true)
	+ {
	+ session_regenerate_id($destroy);
	+
	+ $this->vars = null;
	+ $this->key = session_id();
	+
	+ return true;
	}

	- $this->unsets = array();
	- return $newvars;
	- }
	-
	-
	- /**
	- * Handler for session_destroy()
	- *
	- * @param string Session ID
	- *
	- * @return boolean True on success
	- */
	- public function db_destroy($key)
	- {
	- if ($key) {
	- $this->db->query(sprintf("DELETE FROM %s WHERE sess_id = ?", $this->db->table_name('session')), $key);
	+
	+ /**
	+ * Unset a session variable
	+ *
	+ * @param string Varibale name
	+ * @return boolean True on success
	+ */
	+ public function remove($var=null)
	+ {
	+ if (empty($var)) {
	+ return $this->destroy(session_id());
	+ }
	+
	+ $this->unsets[] = $var;
	+ unset($_SESSION[$var]);
	+
	+ return true;
	+ }
	+
	+
	+ /**
	+ * Kill this session
	+ */
	+ public function kill()
	+ {
	+ $this->vars = null;
	+ $this->ip = $_SERVER['REMOTE_ADDR']; // update IP (might have changed)
	+ $this->destroy(session_id());
	+ rcube_utils::setcookie($this->cookiename, '-del-', time() - 60);
	+ }
	+
	+
	+ /**
	+ * Re-read session data from storage backend
	+ */
	+ public function reload()
	+ {
	+ if ($this->key && $this->memcache)
	+ $data = $this->mc_read($this->key);
	+ else if ($this->key)
	+ $data = $this->db_read($this->key);
	+
	+ if ($data)
	+ session_decode($data);
	+ }
	+
	+
	+ /**
	+ * Serialize session data
	+ */
	+ private function serialize($vars)
	+ {
	+ $data = '';
	+ if (is_array($vars)) {
	+ foreach ($vars as $var=>$value)
	+ $data .= $var.'\|'.serialize($value);
	+ }
	+ else {
	+ $data = 'b:0;';
	+ }
	+
	+ return $data;
	}

	- return true;
	- }
	-
	-
	- /**
	- * Garbage collecting function
	- *
	- * @param string Session lifetime in seconds
	- * @return boolean True on success
	- */
	- public function db_gc($maxlifetime)
	- {
	- // just delete all expired sessions
	- $this->db->query(
	- sprintf("DELETE FROM %s WHERE changed < %s",
	- $this->db->table_name('session'), $this->db->fromunixtime(time() - $maxlifetime)));
	-
	- $this->gc();
	-
	- return true;
	- }
	-
	-
	- /**
	- * Read session data from memcache
	- *
	- * @param string Session ID
	- * @return string Session vars
	- */
	- public function mc_read($key)
	- {
	- if ($value = $this->memcache->get($key)) {
	- $arr = unserialize($value);
	- $this->changed = $arr['changed'];
	- $this->ip = $arr['ip'];
	- $this->vars = $arr['vars'];
	- $this->key = $key;
	-
	- return !empty($this->vars) ? (string) $this->vars : '';
	+
	+ /**
	+ * Unserialize session data
	+ * http://www.php.net/manual/en/function.session-decode.php#56106
	+ */
	+ private function unserialize($str)
	+ {
	+ $str = (string)$str;
	+ $endptr = strlen($str);
	+ $p = 0;
	+
	+ $serialized = '';
	+ $items = 0;
	+ $level = 0;
	+
	+ while ($p < $endptr) {
	+ $q = $p;
	+ while ($str[$q] != '\|')
	+ if (++$q >= $endptr)
	+ break 2;
	+
	+ if ($str[$p] == '!') {
	+ $p++;
	+ $has_value = false;
	+ }
	+ else {
	+ $has_value = true;
	+ }
	+
	+ $name = substr($str, $p, $q - $p);
	+ $q++;
	+
	+ $serialized .= 's:' . strlen($name) . ':"' . $name . '";';
	+
	+ if ($has_value) {
	+ for (;;) {
	+ $p = $q;
	+ switch (strtolower($str[$q])) {
	+ case 'n': // null
	+ case 'b': // boolean
	+ case 'i': // integer
	+ case 'd': // decimal
	+ do $q++;
	+ while ( ($q < $endptr) && ($str[$q] != ';') );
	+ $q++;
	+ $serialized .= substr($str, $p, $q - $p);
	+ if ($level == 0)
	+ break 2;
	+ break;
	+ case 'r': // reference
	+ $q+= 2;
	+ for ($id = ''; ($q < $endptr) && ($str[$q] != ';'); $q++)
	+ $id .= $str[$q];
	+ $q++;
	+ // increment pointer because of outer array
	+ $serialized .= 'R:' . ($id + 1) . ';';
	+ if ($level == 0)
	+ break 2;
	+ break;
	+ case 's': // string
	+ $q+=2;
	+ for ($length=''; ($q < $endptr) && ($str[$q] != ':'); $q++)
	+ $length .= $str[$q];
	+ $q+=2;
	+ $q+= (int)$length + 2;
	+ $serialized .= substr($str, $p, $q - $p);
	+ if ($level == 0)
	+ break 2;
	+ break;
	+ case 'a': // array
	+ case 'o': // object
	+ do $q++;
	+ while ($q < $endptr && $str[$q] != '{');
	+ $q++;
	+ $level++;
	+ $serialized .= substr($str, $p, $q - $p);
	+ break;
	+ case '}': // end of array\|object
	+ $q++;
	+ $serialized .= substr($str, $p, $q - $p);
	+ if (--$level == 0)
	+ break 2;
	+ break;
	+ default:
	+ return false;
	+ }
	+ }
	+ }
	+ else {
	+ $serialized .= 'N;';
	+ $q += 2;
	+ }
	+ $items++;
	+ $p = $q;
	+ }
	+
	+ return unserialize( 'a:' . $items . ':{' . $serialized . '}' );
	}

	- return null;
	- }
	-
	-
	- /**
	- * Save session data.
	- * handler for session_read()
	- *
	- * @param string Session ID
	- * @param string Serialized session vars
	- * @return boolean True on success
	- */
	- public function mc_write($key, $vars)
	- {
	- $ts = microtime(true);
	-
	- // no session data in cache (mc_read() returns false)
	- if (!$this->key)
	- $oldvars = null;
	- // use internal data for fast requests (up to 0.5 sec.)
	- else if ($key == $this->key && (!$this->vars \|\| $ts - $this->start < 0.5))
	- $oldvars = $this->vars;
	- else // else read data again
	- $oldvars = $this->mc_read($key);
	-
	- $newvars = $oldvars !== null ? $this->_fixvars($vars, $oldvars) : $vars;
	-
	- if ($newvars !== $oldvars \|\| $ts - $this->changed > $this->lifetime / 2)
	- return $this->memcache->set($key, serialize(array('changed' => time(), 'ip' => $this->ip, 'vars' => $newvars)), MEMCACHE_COMPRESSED, $this->lifetime);
	-
	- return true;
	- }
	-
	-
	- /**
	- * Handler for session_destroy() with memcache backend
	- *
	- * @param string Session ID
	- *
	- * @return boolean True on success
	- */
	- public function mc_destroy($key)
	- {
	- if ($key) {
	- // #1488592: use 2nd argument
	- $this->memcache->delete($key, 0);
	+
	+ /**
	+ * Setter for session lifetime
	+ */
	+ public function set_lifetime($lifetime)
	+ {
	+ $this->lifetime = max(120, $lifetime);
	+
	+ // valid time range is now - 1/2 lifetime to now + 1/2 lifetime
	+ $now = time();
	+ $this->now = $now - ($now % ($this->lifetime / 2));
	}

	- return true;
	- }

	+ /**
	+ * Getter for remote IP saved with this session
	+ */
	+ public function get_ip()
	+ {
	+ return $this->ip;
	+ }

	- /**
	- * Execute registered garbage collector routines
	- */
	- public function gc()
	- {
	- foreach ($this->gc_handlers as $fct) {
	- call_user_func($fct);
	+
	+ /**
	+ * Setter for cookie encryption secret
	+ */
	+ function set_secret($secret)
	+ {
	+ $this->secret = $secret;
	}
	- }
	-
	-
	- /**
	- * Register additional garbage collector functions
	- *
	- * @param mixed Callback function
	- */
	- public function register_gc_handler($func)
	- {
	- foreach ($this->gc_handlers as $handler) {
	- if ($handler == $func) {
	- return;
	- }
	+
	+
	+ /**
	+ * Enable/disable IP check
	+ */
	+ function set_ip_check($check)
	+ {
	+ $this->ip_check = $check;
	}

	- $this->gc_handlers[] = $func;
	- }
	-
	-
	- /**
	- * Generate and set new session id
	- *
	- * @param boolean $destroy If enabled the current session will be destroyed
	- */
	- public function regenerate_id($destroy=true)
	- {
	- session_regenerate_id($destroy);
	-
	- $this->vars = null;
	- $this->key = session_id();
	-
	- return true;
	- }
	-
	-
	- /**
	- * Unset a session variable
	- *
	- * @param string Varibale name
	- * @return boolean True on success
	- */
	- public function remove($var=null)
	- {
	- if (empty($var))
	- return $this->destroy(session_id());
	-
	- $this->unsets[] = $var;
	- unset($_SESSION[$var]);
	-
	- return true;
	- }
	-
	-
	- /**
	- * Kill this session
	- */
	- public function kill()
	- {
	- $this->vars = null;
	- $this->ip = $_SERVER['REMOTE_ADDR']; // update IP (might have changed)
	- $this->destroy(session_id());
	- rcube_utils::setcookie($this->cookiename, '-del-', time() - 60);
	- }
	-
	-
	- /**
	- * Re-read session data from storage backend
	- */
	- public function reload()
	- {
	- if ($this->key && $this->memcache)
	- $data = $this->mc_read($this->key);
	- else if ($this->key)
	- $data = $this->db_read($this->key);
	-
	- if ($data)
	- session_decode($data);
	- }
	-
	-
	- /**
	- * Serialize session data
	- */
	- private function serialize($vars)
	- {
	- $data = '';
	- if (is_array($vars))
	- foreach ($vars as $var=>$value)
	- $data .= $var.'\|'.serialize($value);
	- else
	- $data = 'b:0;';
	- return $data;
	- }
	-
	-
	- /**
	- * Unserialize session data
	- * http://www.php.net/manual/en/function.session-decode.php#56106
	- */
	- private function unserialize($str)
	- {
	- $str = (string)$str;
	- $endptr = strlen($str);
	- $p = 0;
	-
	- $serialized = '';
	- $items = 0;
	- $level = 0;
	-
	- while ($p < $endptr) {
	- $q = $p;
	- while ($str[$q] != '\|')
	- if (++$q >= $endptr) break 2;
	-
	- if ($str[$p] == '!') {
	- $p++;
	- $has_value = false;
	- } else {
	- $has_value = true;
	- }
	-
	- $name = substr($str, $p, $q - $p);
	- $q++;
	-
	- $serialized .= 's:' . strlen($name) . ':"' . $name . '";';
	-
	- if ($has_value) {
	- for (;;) {
	- $p = $q;
	- switch (strtolower($str[$q])) {
	- case 'n': /* null */
	- case 'b': /* boolean */
	- case 'i': /* integer */
	- case 'd': /* decimal */
	- do $q++;
	- while ( ($q < $endptr) && ($str[$q] != ';') );
	- $q++;
	- $serialized .= substr($str, $p, $q - $p);
	- if ($level == 0) break 2;
	- break;
	- case 'r': /* reference */
	- $q+= 2;
	- for ($id = ''; ($q < $endptr) && ($str[$q] != ';'); $q++) $id .= $str[$q];
	- $q++;
	- $serialized .= 'R:' . ($id + 1) . ';'; /* increment pointer because of outer array */
	- if ($level == 0) break 2;
	- break;
	- case 's': /* string */
	- $q+=2;
	- for ($length=''; ($q < $endptr) && ($str[$q] != ':'); $q++) $length .= $str[$q];
	- $q+=2;
	- $q+= (int)$length + 2;
	- $serialized .= substr($str, $p, $q - $p);
	- if ($level == 0) break 2;
	- break;
	- case 'a': /* array */
	- case 'o': /* object */
	- do $q++;
	- while ( ($q < $endptr) && ($str[$q] != '{') );
	- $q++;
	- $level++;
	- $serialized .= substr($str, $p, $q - $p);
	- break;
	- case '}': /* end of array\|object */
	- $q++;
	- $serialized .= substr($str, $p, $q - $p);
	- if (--$level == 0) break 2;
	- break;
	- default:
	- return false;
	- }
	+
	+ /**
	+ * Setter for the cookie name used for session cookie
	+ */
	+ function set_cookiename($cookiename)
	+ {
	+ if ($cookiename) {
	+ $this->cookiename = $cookiename;
	}
	- } else {
	- $serialized .= 'N;';
	- $q += 2;
	- }
	- $items++;
	- $p = $q;
	}

	- return unserialize( 'a:' . $items . ':{' . $serialized . '}' );
	- }
	-
	-
	- /**
	- * Setter for session lifetime
	- */
	- public function set_lifetime($lifetime)
	- {
	- $this->lifetime = max(120, $lifetime);
	-
	- // valid time range is now - 1/2 lifetime to now + 1/2 lifetime
	- $now = time();
	- $this->now = $now - ($now % ($this->lifetime / 2));
	- }
	-
	-
	- /**
	- * Getter for remote IP saved with this session
	- */
	- public function get_ip()
	- {
	- return $this->ip;
	- }
	-
	-
	- /**
	- * Setter for cookie encryption secret
	- */
	- function set_secret($secret)
	- {
	- $this->secret = $secret;
	- }
	-
	-
	- /**
	- * Enable/disable IP check
	- */
	- function set_ip_check($check)
	- {
	- $this->ip_check = $check;
	- }
	-
	-
	- /**
	- * Setter for the cookie name used for session cookie
	- */
	- function set_cookiename($cookiename)
	- {
	- if ($cookiename)
	- $this->cookiename = $cookiename;
	- }
	-
	-
	- /**
	- * Check session authentication cookie
	- *
	- * @return boolean True if valid, False if not
	- */
	- function check_auth()
	- {
	- $this->cookie = $_COOKIE[$this->cookiename];
	- $result = $this->ip_check ? $_SERVER['REMOTE_ADDR'] == $this->ip : true;
	-
	- if (!$result)
	- $this->log("IP check failed for " . $this->key . "; expected " . $this->ip . "; got " . $_SERVER['REMOTE_ADDR']);
	-
	- if ($result && $this->_mkcookie($this->now) != $this->cookie) {
	- $this->log("Session auth check failed for " . $this->key . "; timeslot = " . date('Y-m-d H:i:s', $this->now));
	- $result = false;
	-
	- // Check if using id from a previous time slot
	- for ($i = 1; $i <= 2; $i++) {
	- $prev = $this->now - ($this->lifetime / 2) * $i;
	- if ($this->_mkcookie($prev) == $this->cookie) {
	- $this->log("Send new auth cookie for " . $this->key . ": " . $this->cookie);
	- $this->set_auth_cookie();
	- $result = true;
	+
	+ /**
	+ * Check session authentication cookie
	+ *
	+ * @return boolean True if valid, False if not
	+ */
	+ function check_auth()
	+ {
	+ $this->cookie = $_COOKIE[$this->cookiename];
	+ $result = $this->ip_check ? $_SERVER['REMOTE_ADDR'] == $this->ip : true;
	+
	+ if (!$result) {
	+ $this->log("IP check failed for " . $this->key . "; expected " . $this->ip . "; got " . $_SERVER['REMOTE_ADDR']);
	}
	- }
	+
	+ if ($result && $this->_mkcookie($this->now) != $this->cookie) {
	+ $this->log("Session auth check failed for " . $this->key . "; timeslot = " . date('Y-m-d H:i:s', $this->now));
	+ $result = false;
	+
	+ // Check if using id from a previous time slot
	+ for ($i = 1; $i <= 2; $i++) {
	+ $prev = $this->now - ($this->lifetime / 2) * $i;
	+ if ($this->_mkcookie($prev) == $this->cookie) {
	+ $this->log("Send new auth cookie for " . $this->key . ": " . $this->cookie);
	+ $this->set_auth_cookie();
	+ $result = true;
	+ }
	+ }
	+ }
	+
	+ if (!$result) {
	+ $this->log("Session authentication failed for " . $this->key
	+ . "; invalid auth cookie sent; timeslot = " . date('Y-m-d H:i:s', $prev));
	+ }
	+
	+ return $result;
	+ }
	+
	+
	+ /**
	+ * Set session authentication cookie
	+ */
	+ function set_auth_cookie()
	+ {
	+ $this->cookie = $this->_mkcookie($this->now);
	+ rcube_utils::setcookie($this->cookiename, $this->cookie, 0);
	+ $_COOKIE[$this->cookiename] = $this->cookie;
	}

	- if (!$result)
	- $this->log("Session authentication failed for " . $this->key . "; invalid auth cookie sent; timeslot = " . date('Y-m-d H:i:s', $prev));
	-
	- return $result;
	- }
	-
	-
	- /**
	- * Set session authentication cookie
	- */
	- function set_auth_cookie()
	- {
	- $this->cookie = $this->_mkcookie($this->now);
	- rcube_utils::setcookie($this->cookiename, $this->cookie, 0);
	- $_COOKIE[$this->cookiename] = $this->cookie;
	- }
	-
	-
	- /**
	- * Create session cookie from session data
	- *
	- * @param int Time slot to use
	- */
	- function _mkcookie($timeslot)
	- {
	- $auth_string = "$this->key,$this->secret,$timeslot";
	- return "S" . (function_exists('sha1') ? sha1($auth_string) : md5($auth_string));
	- }
	-
	- /**
	- * Writes debug information to the log
	- */
	- function log($line)
	- {
	- if ($this->logging)
	- rcube::write_log('session', $line);
	- }

	+ /**
	+ * Create session cookie from session data
	+ *
	+ * @param int Time slot to use
	+ */
	+ function _mkcookie($timeslot)
	+ {
	+ $auth_string = "$this->key,$this->secret,$timeslot";
	+ return "S" . (function_exists('sha1') ? sha1($auth_string) : md5($auth_string));
	+ }
	+
	+ /**
	+ * Writes debug information to the log
	+ */
	+ function log($line)
	+ {
	+ if ($this->logging) {
	+ rcube::write_log('session', $line);
	+ }
	+ }
	}
	diff --git a/program/lib/Roundcube/rcube_string_replacer.php b/program/lib/Roundcube/rcube_string_replacer.php
	index 68288f54c..0fe982b26 100644
	--- a/program/lib/Roundcube/rcube_string_replacer.php
	+++ b/program/lib/Roundcube/rcube_string_replacer.php
	@@ -1,187 +1,187 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2009-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: \|
	\| Handle string replacements based on preg_replace_callback \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+
	*/

	/**
	* Helper class for string replacements based on preg_replace_callback
	*
	* @package Framework
	* @subpackage Utils
	*/
	class rcube_string_replacer
	{
	- public static $pattern = '/##str_replacement\[([0-9]+)\]##/';
	- public $mailto_pattern;
	- public $link_pattern;
	- private $values = array();
	-
	-
	- function __construct()
	- {
	- // Simplified domain expression for UTF8 characters handling
	- // Support unicode/punycode in top-level domain part
	- $utf_domain = '[^?&@"\'\\/()\s\r\t\n]+\\.?([^\\x00-\\x2f\\x3b-\\x40\\x5b-\\x60\\x7b-\\x7f]{2,}\|xn--[a-zA-Z0-9]{2,})';
	- $url1 = '.:;,';
	- $url2 = 'a-zA-Z0-9%=#$@+?!&\\/_~\\[\\]{}\*-';
	-
	- $this->link_pattern = "/([\w]+:\/\/\|\W[Ww][Ww][Ww]\.\|^[Ww][Ww][Ww]\.)($utf_domain([$url1]?[$url2]+)*)/";
	- $this->mailto_pattern = "/("
	- ."[-\w!\#\$%&\'+~\/^`\|{}=]+(?:\.[-\w!\#\$%&\'+~\/^`\|{}=]+)*" // local-part
	- ."@$utf_domain" // domain-part
	- ."(\?[$url1$url2]+)?" // e.g. ?subject=test...
	- .")/";
	- }
	-
	- /**
	- * Add a string to the internal list
	- *
	- * @param string String value
	- * @return int Index of value for retrieval
	- */
	- public function add($str)
	- {
	- $i = count($this->values);
	- $this->values[$i] = $str;
	- return $i;
	- }
	-
	- /**
	- * Build replacement string
	- */
	- public function get_replacement($i)
	- {
	- return '##str_replacement['.$i.']##';
	- }
	-
	- /**
	- * Callback function used to build HTML links around URL strings
	- *
	- * @param array Matches result from preg_replace_callback
	- * @return int Index of saved string value
	- */
	- public function link_callback($matches)
	- {
	- $i = -1;
	- $scheme = strtolower($matches[1]);
	-
	- if (preg_match('!^(http\|ftp\|file)s?://!i', $scheme)) {
	- $url = $matches[1] . $matches[2];
	+ public static $pattern = '/##str_replacement\[([0-9]+)\]##/';
	+ public $mailto_pattern;
	+ public $link_pattern;
	+ private $values = array();
	+
	+
	+ function __construct()
	+ {
	+ // Simplified domain expression for UTF8 characters handling
	+ // Support unicode/punycode in top-level domain part
	+ $utf_domain = '[^?&@"\'\\/()\s\r\t\n]+\\.?([^\\x00-\\x2f\\x3b-\\x40\\x5b-\\x60\\x7b-\\x7f]{2,}\|xn--[a-zA-Z0-9]{2,})';
	+ $url1 = '.:;,';
	+ $url2 = 'a-zA-Z0-9%=#$@+?!&\\/_~\\[\\]{}\*-';
	+
	+ $this->link_pattern = "/([\w]+:\/\/\|\W[Ww][Ww][Ww]\.\|^[Ww][Ww][Ww]\.)($utf_domain([$url1]?[$url2]+)*)/";
	+ $this->mailto_pattern = "/("
	+ ."[-\w!\#\$%&\'+~\/^`\|{}=]+(?:\.[-\w!\#\$%&\'+~\/^`\|{}=]+)*" // local-part
	+ ."@$utf_domain" // domain-part
	+ ."(\?[$url1$url2]+)?" // e.g. ?subject=test...
	+ .")/";
	}
	- else if (preg_match('/^(\W*)(www\.)$/i', $matches[1], $m)) {
	- $url = $m[2] . $matches[2];
	- $url_prefix = 'http://';
	- $prefix = $m[1];
	+
	+ /**
	+ * Add a string to the internal list
	+ *
	+ * @param string String value
	+ * @return int Index of value for retrieval
	+ */
	+ public function add($str)
	+ {
	+ $i = count($this->values);
	+ $this->values[$i] = $str;
	+ return $i;
	}

	- if ($url) {
	- $suffix = $this->parse_url_brackets($url);
	- $i = $this->add($prefix . html::a(array(
	- 'href' => $url_prefix . $url,
	- 'target' => '_blank'
	- ), rcube::Q($url)) . $suffix);
	+ /**
	+ * Build replacement string
	+ */
	+ public function get_replacement($i)
	+ {
	+ return '##str_replacement['.$i.']##';
	}

	- // Return valid link for recognized schemes, otherwise, return the unmodified string for unrecognized schemes.
	- return $i >= 0 ? $this->get_replacement($i) : $matches[0];
	- }
	-
	- /**
	- * Callback function used to build mailto: links around e-mail strings
	- *
	- * @param array Matches result from preg_replace_callback
	- * @return int Index of saved string value
	- */
	- public function mailto_callback($matches)
	- {
	- $href = $matches[1];
	- $suffix = $this->parse_url_brackets($href);
	- $i = $this->add(html::a('mailto:' . $href, rcube::Q($href)) . $suffix);
	-
	- return $i >= 0 ? $this->get_replacement($i) : '';
	- }
	-
	- /**
	- * Look up the index from the preg_replace matches array
	- * and return the substitution value.
	- *
	- * @param array Matches result from preg_replace_callback
	- * @return string Value at index $matches[1]
	- */
	- public function replace_callback($matches)
	- {
	- return $this->values[$matches[1]];
	- }
	-
	- /**
	- * Replace all defined (link\|mailto) patterns with replacement string
	- *
	- * @param string $str Text
	- *
	- * @return string Text
	- */
	- public function replace($str)
	- {
	- // search for patterns like links and e-mail addresses
	- $str = preg_replace_callback($this->link_pattern, array($this, 'link_callback'), $str);
	- $str = preg_replace_callback($this->mailto_pattern, array($this, 'mailto_callback'), $str);
	-
	- return $str;
	- }
	-
	- /**
	- * Replace substituted strings with original values
	- */
	- public function resolve($str)
	- {
	- return preg_replace_callback(self::$pattern, array($this, 'replace_callback'), $str);
	- }
	-
	- /**
	- * Fixes bracket characters in URL handling
	- */
	- public static function parse_url_brackets(&$url)
	- {
	- // #1487672: special handling of square brackets,
	- // URL regexp allows [] characters in URL, for example:
	- // "http://example.com/?a[b]=c". However we need to handle
	- // properly situation when a bracket is placed at the end
	- // of the link e.g. "[http://example.com]"
	- if (preg_match('/(\\[\|\\])/', $url)) {
	- $in = false;
	- for ($i=0, $len=strlen($url); $i<$len; $i++) {
	- if ($url[$i] == '[') {
	- if ($in)
	- break;
	- $in = true;
	+ /**
	+ * Callback function used to build HTML links around URL strings
	+ *
	+ * @param array Matches result from preg_replace_callback
	+ * @return int Index of saved string value
	+ */
	+ public function link_callback($matches)
	+ {
	+ $i = -1;
	+ $scheme = strtolower($matches[1]);
	+
	+ if (preg_match('!^(http\|ftp\|file)s?://!i', $scheme)) {
	+ $url = $matches[1] . $matches[2];
	+ }
	+ else if (preg_match('/^(\W*)(www\.)$/i', $matches[1], $m)) {
	+ $url = $m[2] . $matches[2];
	+ $url_prefix = 'http://';
	+ $prefix = $m[1];
	}
	- else if ($url[$i] == ']') {
	- if (!$in)
	- break;
	- $in = false;
	+
	+ if ($url) {
	+ $suffix = $this->parse_url_brackets($url);
	+ $i = $this->add($prefix . html::a(array(
	+ 'href' => $url_prefix . $url,
	+ 'target' => '_blank'
	+ ), rcube::Q($url)) . $suffix);
	}
	- }

	- if ($i<$len) {
	- $suffix = substr($url, $i);
	- $url = substr($url, 0, $i);
	- }
	+ // Return valid link for recognized schemes, otherwise
	+ // return the unmodified string for unrecognized schemes.
	+ return $i >= 0 ? $this->get_replacement($i) : $matches[0];
	}

	- return $suffix;
	- }
	+ /**
	+ * Callback function used to build mailto: links around e-mail strings
	+ *
	+ * @param array Matches result from preg_replace_callback
	+ * @return int Index of saved string value
	+ */
	+ public function mailto_callback($matches)
	+ {
	+ $href = $matches[1];
	+ $suffix = $this->parse_url_brackets($href);
	+ $i = $this->add(html::a('mailto:' . $href, rcube::Q($href)) . $suffix);
	+
	+ return $i >= 0 ? $this->get_replacement($i) : '';
	+ }

	+ /**
	+ * Look up the index from the preg_replace matches array
	+ * and return the substitution value.
	+ *
	+ * @param array Matches result from preg_replace_callback
	+ * @return string Value at index $matches[1]
	+ */
	+ public function replace_callback($matches)
	+ {
	+ return $this->values[$matches[1]];
	+ }
	+
	+ /**
	+ * Replace all defined (link\|mailto) patterns with replacement string
	+ *
	+ * @param string $str Text
	+ *
	+ * @return string Text
	+ */
	+ public function replace($str)
	+ {
	+ // search for patterns like links and e-mail addresses
	+ $str = preg_replace_callback($this->link_pattern, array($this, 'link_callback'), $str);
	+ $str = preg_replace_callback($this->mailto_pattern, array($this, 'mailto_callback'), $str);
	+
	+ return $str;
	+ }
	+
	+ /**
	+ * Replace substituted strings with original values
	+ */
	+ public function resolve($str)
	+ {
	+ return preg_replace_callback(self::$pattern, array($this, 'replace_callback'), $str);
	+ }
	+
	+ /**
	+ * Fixes bracket characters in URL handling
	+ */
	+ public static function parse_url_brackets(&$url)
	+ {
	+ // #1487672: special handling of square brackets,
	+ // URL regexp allows [] characters in URL, for example:
	+ // "http://example.com/?a[b]=c". However we need to handle
	+ // properly situation when a bracket is placed at the end
	+ // of the link e.g. "[http://example.com]"
	+ if (preg_match('/(\\[\|\\])/', $url)) {
	+ $in = false;
	+ for ($i=0, $len=strlen($url); $i<$len; $i++) {
	+ if ($url[$i] == '[') {
	+ if ($in)
	+ break;
	+ $in = true;
	+ }
	+ else if ($url[$i] == ']') {
	+ if (!$in)
	+ break;
	+ $in = false;
	+ }
	+ }
	+
	+ if ($i < $len) {
	+ $suffix = substr($url, $i);
	+ $url = substr($url, 0, $i);
	+ }
	+ }
	+
	+ return $suffix;
	+ }
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 6:31 AM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 166125
Default Alt Text: (85 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions