No OneTemporary
Actions

Size

156 KB

Referenced Files

None

Subscribers

None

View Options

This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.

	diff --git a/config/main.inc.php.dist b/config/main.inc.php.dist
	index 56e5a793e..71c238069 100644
	--- a/config/main.inc.php.dist
	+++ b/config/main.inc.php.dist
	@@ -1,720 +1,725 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| Main configuration file \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2010, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	+-----------------------------------------------------------------------+

	*/

	$rcmail_config = array();

	// ----------------------------------
	// LOGGING/DEBUGGING
	// ----------------------------------

	// system error reporting: 1 = log; 2 = report (not implemented yet), 4 = show, 8 = trace
	$rcmail_config['debug_level'] = 1;

	// log driver: 'syslog' or 'file'.
	$rcmail_config['log_driver'] = 'file';

	// date format for log entries
	// (read http://php.net/manual/en/function.date.php for all format characters)
	$rcmail_config['log_date_format'] = 'd-M-Y H:i:s O';

	// Syslog ident string to use, if using the 'syslog' log driver.
	$rcmail_config['syslog_id'] = 'roundcube';

	// Syslog facility to use, if using the 'syslog' log driver.
	// For possible values see installer or http://php.net/manual/en/function.openlog.php
	$rcmail_config['syslog_facility'] = LOG_USER;

	// Log sent messages to <log_dir>/sendmail or to syslog
	$rcmail_config['smtp_log'] = true;

	// Log successful logins to <log_dir>/userlogins or to syslog
	$rcmail_config['log_logins'] = false;

	// Log SQL queries to <log_dir>/sql or to syslog
	$rcmail_config['sql_debug'] = false;

	// Log IMAP conversation to <log_dir>/imap or to syslog
	$rcmail_config['imap_debug'] = false;

	// Log LDAP conversation to <log_dir>/ldap or to syslog
	$rcmail_config['ldap_debug'] = false;

	// Log SMTP conversation to <log_dir>/smtp or to syslog
	$rcmail_config['smtp_debug'] = false;

	// ----------------------------------
	// IMAP
	// ----------------------------------

	// the mail host chosen to perform the log-in
	// leave blank to show a textbox at login, give a list of hosts
	// to display a pulldown menu or set one host as string.
	// To use SSL/TLS connection, enter hostname with prefix ssl:// or tls://
	// Supported replacement variables:
	// %n - http hostname ($_SERVER['SERVER_NAME'])
	// %d - domain (http hostname without the first part)
	// %s - domain name after the '@' from e-mail address provided at login screen
	// For example %n = mail.domain.tld, %d = domain.tld
	$rcmail_config['default_host'] = '';

	// TCP port used for IMAP connections
	$rcmail_config['default_port'] = 143;

	// IMAP AUTH type (DIGEST-MD5, CRAM-MD5, LOGIN, PLAIN or empty to use
	// best server supported one)
	$rcmail_config['imap_auth_type'] = null;

	// If you know your imap's folder delimiter, you can specify it here.
	// Otherwise it will be determined automatically
	$rcmail_config['imap_delimiter'] = null;

	// If IMAP server doesn't support NAMESPACE extension, but you're
	// using shared folders or personal root folder is non-empty, you'll need to
	// set these options. All can be strings or arrays of strings.
	// Folders need to be ended with directory separator, e.g. "INBOX."
	// (special directory "~" is an exception to this rule)
	// These can be used also to overwrite server's namespaces
	$rcmail_config['imap_ns_personal'] = null;
	$rcmail_config['imap_ns_other'] = null;
	$rcmail_config['imap_ns_shared'] = null;

	// By default IMAP capabilities are readed after connection to IMAP server
	// In some cases, e.g. when using IMAP proxy, there's a need to refresh the list
	// after login. Set to True if you've got this case.
	$rcmail_config['imap_force_caps'] = false;

	// By default list of subscribed folders is determined using LIST-EXTENDED
	// extension if available. Some servers (dovecot 1.x) returns wrong results
	// for shared namespaces in this case. http://trac.roundcube.net/ticket/1486225
	// Enable this option to force LSUB command usage instead.
	$rcmail_config['imap_force_lsub'] = false;

	// IMAP connection timeout, in seconds. Default: 0 (no limit)
	$rcmail_config['imap_timeout'] = 0;

	// Optional IMAP authentication identifier to be used as authorization proxy
	$rcmail_config['imap_auth_cid'] = null;

	// Optional IMAP authentication password to be used for imap_auth_cid
	$rcmail_config['imap_auth_pw'] = null;

	// Type of IMAP indexes cache. Supported values: 'db', 'apc' and 'memcache'.
	$rcmail_config['imap_cache'] = null;

	// Enables messages cache. Only 'db' cache is supported.
	$rcmail_config['messages_cache'] = false;


	// ----------------------------------
	// SMTP
	// ----------------------------------

	// SMTP server host (for sending mails).
	// To use SSL/TLS connection, enter hostname with prefix ssl:// or tls://
	// If left blank, the PHP mail() function is used
	// Supported replacement variables:
	// %h - user's IMAP hostname
	// %n - http hostname ($_SERVER['SERVER_NAME'])
	// %d - domain (http hostname without the first part)
	// %z - IMAP domain (IMAP hostname without the first part)
	// For example %n = mail.domain.tld, %d = domain.tld
	$rcmail_config['smtp_server'] = '';

	// SMTP port (default is 25; 465 for SSL)
	$rcmail_config['smtp_port'] = 25;

	// SMTP username (if required) if you use %u as the username Roundcube
	// will use the current username for login
	$rcmail_config['smtp_user'] = '';

	// SMTP password (if required) if you use %p as the password Roundcube
	// will use the current user's password for login
	$rcmail_config['smtp_pass'] = '';

	// SMTP AUTH type (DIGEST-MD5, CRAM-MD5, LOGIN, PLAIN or empty to use
	// best server supported one)
	$rcmail_config['smtp_auth_type'] = '';

	// Optional SMTP authentication identifier to be used as authorization proxy
	$rcmail_config['smtp_auth_cid'] = null;

	// Optional SMTP authentication password to be used for smtp_auth_cid
	$rcmail_config['smtp_auth_pw'] = null;

	// SMTP HELO host
	// Hostname to give to the remote server for SMTP 'HELO' or 'EHLO' messages
	// Leave this blank and you will get the server variable 'server_name' or
	// localhost if that isn't defined.
	$rcmail_config['smtp_helo_host'] = '';

	// SMTP connection timeout, in seconds. Default: 0 (no limit)
	$rcmail_config['smtp_timeout'] = 0;

	// ----------------------------------
	// SYSTEM
	// ----------------------------------

	// THIS OPTION WILL ALLOW THE INSTALLER TO RUN AND CAN EXPOSE SENSITIVE CONFIG DATA.
	// ONLY ENABLE IT IF YOU'RE REALLY SURE WHAT YOU'RE DOING!
	$rcmail_config['enable_installer'] = false;

	// use this folder to store log files (must be writeable for apache user)
	// This is used by the 'file' log driver.
	$rcmail_config['log_dir'] = 'logs/';

	// use this folder to store temp files (must be writeable for apache user)
	$rcmail_config['temp_dir'] = 'temp/';

	// lifetime of message cache
	// possible units: s, m, h, d, w
	$rcmail_config['message_cache_lifetime'] = '10d';

	// enforce connections over https
	// with this option enabled, all non-secure connections will be redirected.
	// set the port for the ssl connection as value of this option if it differs from the default 443
	$rcmail_config['force_https'] = false;

	// tell PHP that it should work as under secure connection
	// even if it doesn't recognize it as secure ($_SERVER['HTTPS'] is not set)
	// e.g. when you're running Roundcube behind a https proxy
	$rcmail_config['use_https'] = false;

	// Allow browser-autocompletion on login form.
	// 0 - disabled, 1 - username and host only, 2 - username, host, password
	$rcmail_config['login_autocomplete'] = 0;

	// If users authentication is not case sensitive this must be enabled.
	// You can also use it to force conversion of logins to lower case.
	// After enabling it all user records need to be updated, e.g. with query:
	// UPDATE users SET username = LOWER(username);
	$rcmail_config['login_lc'] = false;

	// automatically create a new Roundcube user when log-in the first time.
	// a new user will be created once the IMAP login succeeds.
	// set to false if only registered users can use this service
	$rcmail_config['auto_create_user'] = true;

	// replace Roundcube logo with this image
	// specify an URL relative to the document root of this Roundcube installation
	$rcmail_config['skin_logo'] = null;

	// Includes should be interpreted as PHP files
	$rcmail_config['skin_include_php'] = false;

	// Session lifetime in minutes
	// must be greater than 'keep_alive'/60
	$rcmail_config['session_lifetime'] = 10;

	// session domain: .example.org
	$rcmail_config['session_domain'] = '';

	// Backend to use for session storage. Can either be 'db' (default) or 'memcache'
	// If set to memcache, a list of servers need to be specified in 'memcache_hosts'
	// Make sure the Memcache extension (http://pecl.php.net/package/memcache) version >= 2.0.0 is installed
	$rcmail_config['session_storage'] = 'db';

	// Use these hosts for accessing memcached
	// Define any number of hosts in the form hostname:port
	$rcmail_config['memcache_hosts'] = null; // e.g. array( 'localhost:11211', '192.168.1.12:11211' );

	// check client IP in session athorization
	$rcmail_config['ip_check'] = false;

	// check referer of incoming requests
	$rcmail_config['referer_check'] = false;

	// this key is used to encrypt the users imap password which is stored
	// in the session record (and the client cookie if remember password is enabled).
	// please provide a string of exactly 24 chars.
	$rcmail_config['des_key'] = 'rcmail-!24ByteDESkey*Str';

	// Automatically add this domain to user names for login
	// Only for IMAP servers that require full e-mail addresses for login
	// Specify an array with 'host' => 'domain' values to support multiple hosts
	// Supported replacement variables:
	// %h - user's IMAP hostname
	// %n - http hostname ($_SERVER['SERVER_NAME'])
	// %d - domain (http hostname without the first part)
	// %z - IMAP domain (IMAP hostname without the first part)
	// For example %n = mail.domain.tld, %d = domain.tld
	$rcmail_config['username_domain'] = '';

	// This domain will be used to form e-mail addresses of new users
	// Specify an array with 'host' => 'domain' values to support multiple hosts
	// Supported replacement variables:
	// %h - user's IMAP hostname
	// %n - http hostname ($_SERVER['SERVER_NAME'])
	// %d - domain (http hostname without the first part)
	// %z - IMAP domain (IMAP hostname without the first part)
	// For example %n = mail.domain.tld, %d = domain.tld
	$rcmail_config['mail_domain'] = '';

	// Password charset.
	// Use it if your authentication backend doesn't support UTF-8.
	// Defaults to ISO-8859-1 for backward compatibility
	$rcmail_config['password_charset'] = 'ISO-8859-1';

	// How many seconds must pass between emails sent by a user
	$rcmail_config['sendmail_delay'] = 0;

	// Maximum number of recipients per message. Default: 0 (no limit)
	$rcmail_config['max_recipients'] = 0;

	// Maximum allowednumber of members of an address group. Default: 0 (no limit)
	// If 'max_recipients' is set this value should be less or equal
	$rcmail_config['max_group_members'] = 0;

	// add this user-agent to message headers when sending
	$rcmail_config['useragent'] = 'Roundcube Webmail/'.RCMAIL_VERSION;

	// use this name to compose page titles
	$rcmail_config['product_name'] = 'Roundcube Webmail';

	// try to load host-specific configuration
	// see http://trac.roundcube.net/wiki/Howto_Config for more details
	$rcmail_config['include_host_config'] = false;

	// path to a text file which will be added to each sent message
	// paths are relative to the Roundcube root folder
	$rcmail_config['generic_message_footer'] = '';

	// path to a text file which will be added to each sent HTML message
	// paths are relative to the Roundcube root folder
	$rcmail_config['generic_message_footer_html'] = '';

	// add a received header to outgoing mails containing the creators IP and hostname
	$rcmail_config['http_received_header'] = false;

	// Whether or not to encrypt the IP address and the host name
	// these could, in some circles, be considered as sensitive information;
	// however, for the administrator, these could be invaluable help
	// when tracking down issues.
	$rcmail_config['http_received_header_encrypt'] = false;

	// This string is used as a delimiter for message headers when sending
	// a message via mail() function. Leave empty for auto-detection
	$rcmail_config['mail_header_delimiter'] = NULL;

	// number of chars allowed for line when wrapping text.
	// text wrapping is done when composing/sending messages
	$rcmail_config['line_length'] = 72;

	// send plaintext messages as format=flowed
	$rcmail_config['send_format_flowed'] = true;

	// don't allow these settings to be overriden by the user
	$rcmail_config['dont_override'] = array();

	// Set identities access level:
	// 0 - many identities with possibility to edit all params
	// 1 - many identities with possibility to edit all params but not email address
	// 2 - one identity with possibility to edit all params
	// 3 - one identity with possibility to edit all params but not email address
	$rcmail_config['identities_level'] = 0;

	// mime magic database
	$rcmail_config['mime_magic'] = '/usr/share/misc/magic';

	// path to imagemagick identify binary
	$rcmail_config['im_identify_path'] = null;

	// path to imagemagick convert binary
	$rcmail_config['im_convert_path'] = null;

	// maximum size of uploaded contact photos in pixel
	$rcmail_config['contact_photo_size'] = 160;

	// Enable DNS checking for e-mail address validation
	$rcmail_config['email_dns_check'] = false;

	// ----------------------------------
	// PLUGINS
	// ----------------------------------

	// List of active plugins (in plugins/ directory)
	$rcmail_config['plugins'] = array();

	// ----------------------------------
	// USER INTERFACE
	// ----------------------------------

	// default messages sort column. Use empty value for default server's sorting,
	// or 'arrival', 'date', 'subject', 'from', 'to', 'size', 'cc'
	$rcmail_config['message_sort_col'] = '';

	// default messages sort order
	$rcmail_config['message_sort_order'] = 'DESC';

	// These cols are shown in the message list. Available cols are:
	// subject, from, to, cc, replyto, date, size, status, flag, attachment
	$rcmail_config['list_cols'] = array('subject', 'status', 'from', 'date', 'size', 'flag', 'attachment');

	// the default locale setting (leave empty for auto-detection)
	// RFC1766 formatted language name like en_US, de_DE, de_CH, fr_FR, pt_BR
	$rcmail_config['language'] = null;

	// use this format for short date display (date or strftime format)
	$rcmail_config['date_short'] = 'D H:i';

	// use this format for detailed date/time formatting (date or strftime format)
	$rcmail_config['date_long'] = 'd.m.Y H:i';

	// use this format for today's date display (date or strftime format)
	// Note: $ character will be replaced with 'Today' label
	$rcmail_config['date_today'] = 'H:i';

	// use this format for date display without time (date or strftime format)
	$rcmail_config['date_format'] = 'Y-m-d';

	// store draft message is this mailbox
	// leave blank if draft messages should not be stored
	// NOTE: Use folder names with namespace prefix (INBOX. on Courier-IMAP)
	$rcmail_config['drafts_mbox'] = 'Drafts';

	// store spam messages in this mailbox
	// NOTE: Use folder names with namespace prefix (INBOX. on Courier-IMAP)
	$rcmail_config['junk_mbox'] = 'Junk';

	// store sent message is this mailbox
	// leave blank if sent messages should not be stored
	// NOTE: Use folder names with namespace prefix (INBOX. on Courier-IMAP)
	$rcmail_config['sent_mbox'] = 'Sent';

	// move messages to this folder when deleting them
	// leave blank if they should be deleted directly
	// NOTE: Use folder names with namespace prefix (INBOX. on Courier-IMAP)
	$rcmail_config['trash_mbox'] = 'Trash';

	// display these folders separately in the mailbox list.
	// these folders will also be displayed with localized names
	// NOTE: Use folder names with namespace prefix (INBOX. on Courier-IMAP)
	$rcmail_config['default_imap_folders'] = array('INBOX', 'Drafts', 'Sent', 'Junk', 'Trash');

	// automatically create the above listed default folders on login
	$rcmail_config['create_default_folders'] = false;

	// protect the default folders from renames, deletes, and subscription changes
	$rcmail_config['protect_default_folders'] = true;

	// if in your system 0 quota means no limit set this option to true
	$rcmail_config['quota_zero_as_unlimited'] = false;

	// Make use of the built-in spell checker. It is based on GoogieSpell.
	// Since Google only accepts connections over https your PHP installatation
	// requires to be compiled with Open SSL support
	$rcmail_config['enable_spellcheck'] = true;

	// Set the spell checking engine. 'googie' is the default. 'pspell' is also available,
	// but requires the Pspell extensions. When using Nox Spell Server, also set 'googie' here.
	$rcmail_config['spellcheck_engine'] = 'googie';

	// For a locally installed Nox Spell Server, please specify the URI to call it.
	// Get Nox Spell Server from http://orangoo.com/labs/?page_id=72
	// Leave empty to use the Google spell checking service, what means
	// that the message content will be sent to Google in order to check spelling
	$rcmail_config['spellcheck_uri'] = '';

	// These languages can be selected for spell checking.
	// Configure as a PHP style hash array: array('en'=>'English', 'de'=>'Deutsch');
	// Leave empty for default set of available language.
	$rcmail_config['spellcheck_languages'] = NULL;

	// don't let users set pagesize to more than this value if set
	$rcmail_config['max_pagesize'] = 200;

	// Minimal value of user's 'keep_alive' setting (in seconds)
	// Must be less than 'session_lifetime'
	$rcmail_config['min_keep_alive'] = 60;

	// Enables files upload indicator. Requires APC installed and enabled apc.rfc1867 option.
	// By default refresh time is set to 1 second. You can set this value to true
	// or any integer value indicating number of seconds.
	$rcmail_config['upload_progress'] = false;

	+// Specifies for how many seconds the Undo button will be available
	+// after object delete action. Currently used with supporting address book sources.
	+// Setting it to 0, disables the feature.
	+$rcmail_config['undo_timeout'] = 0;
	+
	// ----------------------------------
	// ADDRESSBOOK SETTINGS
	// ----------------------------------

	// This indicates which type of address book to use. Possible choises:
	// 'sql' (default) and 'ldap'.
	// If set to 'ldap' then it will look at using the first writable LDAP
	// address book as the primary address book and it will not display the
	// SQL address book in the 'Address Book' view.
	$rcmail_config['address_book_type'] = 'sql';

	// In order to enable public ldap search, configure an array like the Verisign
	// example further below. if you would like to test, simply uncomment the example.
	// Array key must contain only safe characters, ie. a-zA-Z0-9_
	$rcmail_config['ldap_public'] = array();

	// If you are going to use LDAP for individual address books, you will need to
	// set 'user_specific' to true and use the variables to generate the appropriate DNs to access it.
	//
	// The recommended directory structure for LDAP is to store all the address book entries
	// under the users main entry, e.g.:
	//
	// o=root
	// ou=people
	// uid=user@domain
	// mail=contact@contactdomain
	//
	// So the base_dn would be uid=%fu,ou=people,o=root
	// The bind_dn would be the same as based_dn or some super user login.
	/*
	* example config for Verisign directory
	*
	$rcmail_config['ldap_public']['Verisign'] = array(
	'name' => 'Verisign.com',
	// Replacement variables supported in host names:
	// %h - user's IMAP hostname
	// %n - http hostname ($_SERVER['SERVER_NAME'])
	// %d - domain (http hostname without the first part)
	// %z - IMAP domain (IMAP hostname without the first part)
	// For example %n = mail.domain.tld, %d = domain.tld
	'hosts' => array('directory.verisign.com'),
	'port' => 389,
	'use_tls' => false,
	'ldap_version' => 3, // using LDAPv3
	'user_specific' => false, // If true the base_dn, bind_dn and bind_pass default to the user's IMAP login.
	// %fu - The full username provided, assumes the username is an email
	// address, uses the username_domain value if not an email address.
	// %u - The username prior to the '@'.
	// %d - The domain name after the '@'.
	// %dc - The domain name hierarchal string e.g. "dc=test,dc=domain,dc=com"
	// %dn - DN found by ldap search when search_filter/search_base_dn are used
	'base_dn' => '',
	'bind_dn' => '',
	'bind_pass' => '',
	// It's possible to bind for an individual address book
	// The login name is used to search for the DN to bind with
	'search_base_dn' => '',
	'search_filter' => '', // e.g. '(&(objectClass=posixAccount)(uid=%u))'
	// Optional authentication identifier to be used as SASL authorization proxy
	// bind_dn need to be empty
	'auth_cid' => '',
	// SASL authentication method (for proxy auth), e.g. DIGEST-MD5
	'auth_method' => '',
	// Indicates if we can write to the LDAP directory or not.
	// If writable is true then these fields need to be populated:
	// LDAP_Object_Classes, required_fields, LDAP_rdn
	'writable' => false,
	// To create a new contact these are the object classes to specify
	// (or any other classes you wish to use).
	'LDAP_Object_Classes' => array('top', 'inetOrgPerson'),
	// The RDN field that is used for new entries, this field needs
	// to be one of the search_fields, the base of base_dn is appended
	// to the RDN to insert into the LDAP directory.
	'LDAP_rdn' => 'mail',
	// The required fields needed to build a new contact as required by
	// the object classes (can include additional fields not required by the object classes).
	'required_fields' => array('cn', 'sn', 'mail'),
	'search_fields' => array('mail', 'cn'), // fields to search in
	// mapping of contact fields to directory attributes
	'fieldmap' => array(
	// Roundcube => LDAP
	'name' => 'cn',
	'surname' => 'sn',
	'firstname' => 'givenName',
	'email' => 'mail',
	'phone:home' => 'homePhone',
	'phone:work' => 'telephoneNumber',
	'phone:mobile' => 'mobile',
	'street' => 'street',
	'zipcode' => 'postalCode',
	'locality' => 'l',
	'country' => 'c',
	'organization' => 'o',
	),
	'sort' => 'cn', // The field to sort the listing by.
	'scope' => 'sub', // search mode: sub\|base\|list
	'filter' => '(objectClass=inetOrgPerson)', // used for basic listing (if not empty) and will be &'d with search queries. example: status=act
	'fuzzy_search' => true, // server allows wildcard search
	'vlv' => false, // Enable Virtual List View to more efficiently fetch paginated data (if server supports it)
	'numsub_filter' => '(objectClass=organizationalUnit)', // with VLV, we also use numSubOrdinates to query the total number of records. Set this filter to get all numSubOrdinates attributes for counting
	'sizelimit' => '0', // Enables you to limit the count of entries fetched. Setting this to 0 means no limit.
	'timelimit' => '0', // Sets the number of seconds how long is spend on the search. Setting this to 0 means no limit.

	// definition for contact groups (uncomment if no groups are supported)
	// for the groups base_dn, the user replacements %fu, %u, $d and %dc work as for base_dn (see above)
	// if the groups base_dn is empty, the contact base_dn is used for the groups as well
	// -> in this case, assure that groups and contacts are separated due to the concernig filters!
	'groups' => array(
	'base_dn' => '',
	'filter' => '(objectClass=groupOfNames)',
	'object_classes' => array("top", "groupOfNames"),
	),
	);
	*/

	// An ordered array of the ids of the addressbooks that should be searched
	// when populating address autocomplete fields server-side. ex: array('sql','Verisign');
	$rcmail_config['autocomplete_addressbooks'] = array('sql');

	// The minimum number of characters required to be typed in an autocomplete field
	// before address books will be searched. Most useful for LDAP directories that
	// may need to do lengthy results building given overly-broad searches
	$rcmail_config['autocomplete_min_length'] = 1;

	// show address fields in this order
	// available placeholders: {street}, {locality}, {zipcode}, {country}, {region}
	$rcmail_config['address_template'] = '{street}<br/>{locality} {zipcode}<br/>{country} {region}';

	// ----------------------------------
	// USER PREFERENCES
	// ----------------------------------

	// Use this charset as fallback for message decoding
	$rcmail_config['default_charset'] = 'ISO-8859-1';

	// skin name: folder from skins/
	$rcmail_config['skin'] = 'default';

	// show up to X items in list view
	$rcmail_config['pagesize'] = 40;

	// use this timezone to display date/time
	$rcmail_config['timezone'] = 'auto';

	// is daylight saving On?
	$rcmail_config['dst_active'] = (bool)date('I');

	// prefer displaying HTML messages
	$rcmail_config['prefer_html'] = true;

	// display remote inline images
	// 0 - Never, always ask
	// 1 - Ask if sender is not in address book
	// 2 - Always show inline images
	$rcmail_config['show_images'] = 0;

	// compose html formatted messages by default
	// 0 - never, 1 - always, 2 - on reply to HTML message only
	$rcmail_config['htmleditor'] = 0;

	// show pretty dates as standard
	$rcmail_config['prettydate'] = true;

	// save compose message every 300 seconds (5min)
	$rcmail_config['draft_autosave'] = 300;

	// default setting if preview pane is enabled
	$rcmail_config['preview_pane'] = false;

	// Mark as read when viewed in preview pane (delay in seconds)
	// Set to -1 if messages in preview pane should not be marked as read
	$rcmail_config['preview_pane_mark_read'] = 0;

	// Clear Trash on logout
	$rcmail_config['logout_purge'] = false;

	// Compact INBOX on logout
	$rcmail_config['logout_expunge'] = false;

	// Display attached images below the message body
	$rcmail_config['inline_images'] = true;

	// Encoding of long/non-ascii attachment names:
	// 0 - Full RFC 2231 compatible
	// 1 - RFC 2047 for 'name' and RFC 2231 for 'filename' parameter (Thunderbird's default)
	// 2 - Full 2047 compatible
	$rcmail_config['mime_param_folding'] = 1;

	// Set true if deleted messages should not be displayed
	// This will make the application run slower
	$rcmail_config['skip_deleted'] = false;

	// Set true to Mark deleted messages as read as well as deleted
	// False means that a message's read status is not affected by marking it as deleted
	$rcmail_config['read_when_deleted'] = true;

	// Set to true to newer delete messages immediately
	// Use 'Purge' to remove messages marked as deleted
	$rcmail_config['flag_for_deletion'] = false;

	// Default interval for keep-alive/check-recent requests (in seconds)
	// Must be greater than or equal to 'min_keep_alive' and less than 'session_lifetime'
	$rcmail_config['keep_alive'] = 60;

	// If true all folders will be checked for recent messages
	$rcmail_config['check_all_folders'] = false;

	// If true, after message delete/move, the next message will be displayed
	$rcmail_config['display_next'] = false;

	// 0 - Do not expand threads
	// 1 - Expand all threads automatically
	// 2 - Expand only threads with unread messages
	$rcmail_config['autoexpand_threads'] = 0;

	// When replying place cursor above original message (top posting)
	$rcmail_config['top_posting'] = false;

	// When replying strip original signature from message
	$rcmail_config['strip_existing_sig'] = true;

	// Show signature:
	// 0 - Never
	// 1 - Always
	// 2 - New messages only
	// 3 - Forwards and Replies only
	$rcmail_config['show_sig'] = 1;

	// When replying or forwarding place sender's signature above existing message
	$rcmail_config['sig_above'] = false;

	// Use MIME encoding (quoted-printable) for 8bit characters in message body
	$rcmail_config['force_7bit'] = false;

	// Defaults of the search field configuration.
	// The array can contain a per-folder list of header fields which should be considered when searching
	// The entry with key '*' stands for all folders which do not have a specific list set.
	// Please note that folder names should to be in sync with $rcmail_config['default_imap_folders']
	$rcmail_config['search_mods'] = null; // Example: array('*' => array('subject'=>1, 'from'=>1), 'Sent' => array('subject'=>1, 'to'=>1));

	// Defaults of the addressbook search field configuration.
	$rcmail_config['addressbook_search_mods'] = null; // Example: array('name'=>1, 'firstname'=>1, 'surname'=>1, 'email'=>1, '*'=>1);

	// 'Delete always'
	// This setting reflects if mail should be always deleted
	// when moving to Trash fails. This is necessary in some setups
	// when user is over quota and Trash is included in the quota.
	$rcmail_config['delete_always'] = false;

	// Behavior if a received message requests a message delivery notification (read receipt)
	// 0 = ask the user, 1 = send automatically, 2 = ignore (never send or ask)
	// 3 = send automatically if sender is in addressbook, otherwise ask the user
	// 4 = send automatically if sender is in addressbook, otherwise ignore
	$rcmail_config['mdn_requests'] = 0;

	// Return receipt checkbox default state
	$rcmail_config['mdn_default'] = 0;

	// Delivery Status Notification checkbox default state
	$rcmail_config['dsn_default'] = 0;

	// Place replies in the folder of the message being replied to
	$rcmail_config['reply_same_folder'] = false;

	// Sets default mode of Forward feature to "forward as attachment"
	$rcmail_config['forward_attachment'] = false;

	// Defines address book (internal index) to which new contacts will be added
	// By default it is the first writeable addressbook.
	// Note: Use '0' for built-in address book.
	$rcmail_config['default_addressbook'] = null;

	// Enables spell checking before sending a message.
	$rcmail_config['spellcheck_before_send'] = false;

	// end of config file
	diff --git a/program/include/rcube_addressbook.php b/program/include/rcube_addressbook.php
	index 3581b83d1..45ad0be5d 100644
	--- a/program/include/rcube_addressbook.php
	+++ b/program/include/rcube_addressbook.php
	@@ -1,460 +1,461 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_addressbook.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2006-2011, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Interface to the local address book database \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


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

	/** public properties (mandatory) */
	public $primary_key;
	public $groups = false;
	public $readonly = true;
	public $undelete = false;
	public $ready = false;
	public $group_id = null;
	public $list_page = 1;
	public $page_size = 10;
	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 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, $strict=false, $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;
	}

	/**
	* 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);
	}

	/**
	* 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;
	}


	/**
	* 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
	* @return boolean True if input is valid, False if not.
	*/
	public function validate($save_data)
	{
	// check validity of email addresses
	foreach ($this->get_col_values('email', $save_data, true) as $email) {
	if (strlen($email)) {
	if (!check_email(rcube_idn_to_ascii($email))) {
	$this->set_error('warning', rcube_label(array('name' => 'emailformaterror', 'vars' => array('email' => $email))));
	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)
	+ 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();
	}

	/**
	* 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 ($data as $c => $values) {
	if (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);
	}
	}
	}

	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
	*/
	protected static function normalize_string($str)
	{
	// split by words
	$arr = explode(" ", preg_replace(
	array('/[\s;\+\-\/]+/i', '/(\d)[-.\s]+(\d)/', '/\s\w{1,3}\s/'),
	array(' ', '\\1\\2', ' '),
	$str));

	foreach ($arr as $i => $part) {
	if (utf8_encode(utf8_decode($part)) == $part) { // is latin-1 ?
	$arr[$i] = utf8_encode(strtr(strtolower(strtr(utf8_decode($part),
	'ÇçäâàåéêëèïîìÅÉöôòüûùÿøØáíóúñÑÁÂÀãÃÊËÈÍÎÏÓÔõÕÚÛÙýÝ',
	'ccaaaaeeeeiiiaeooouuuyooaiounnaaaaaeeeiiioooouuuyy')),
	array('ß' => 'ss', 'ae' => 'a', 'oe' => 'o', 'ue' => 'u')));
	}
	else
	$arr[$i] = mb_strtolower($part);
	}

	return join(" ", $arr);
	}


	/**
	* Compose a valid display name from the given structured contact data
	*
	* @param array Hash array with contact data as key-value pairs
	* @return string Display name
	*/
	public static function compose_display_name($contact)
	{
	$contact = rcmail::get_instance()->plugins->exec_hook('contact_displayname', $contact);
	$fn = $contact['name'];

	if (!$fn)
	$fn = 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)) {
	list($emailname) = explode('@', $email);
	if (preg_match('/(.)[\.\-\_](.)/', $emailname, $match))
	$fn = trim(ucfirst($match[1]).' '.ucfirst($match[2]));
	else
	$fn = ucfirst($emailname);
	}

	return $fn;
	}

	}

	diff --git a/program/include/rcube_contacts.php b/program/include/rcube_contacts.php
	index 52667fab3..799d59618 100644
	--- a/program/include/rcube_contacts.php
	+++ b/program/include/rcube_contacts.php
	@@ -1,906 +1,907 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_contacts.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2006-2011, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Interface to the local address book database \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	/**
	* Model class for the local address book database
	*
	* @package Addressbook
	*/
	class rcube_contacts extends rcube_addressbook
	{
	// protected for backward compat. with some plugins
	protected $db_name = 'contacts';
	protected $db_groups = 'contactgroups';
	protected $db_groupmembers = 'contactgroupmembers';

	/**
	* Store database connection.
	*
	* @var rcube_mdb2
	*/
	private $db = null;
	private $user_id = 0;
	private $filter = null;
	private $result = null;
	private $name;
	private $cache;
	private $table_cols = array('name', 'email', 'firstname', 'surname');
	private $fulltext_cols = array('name', 'firstname', 'surname', 'middlename', 'nickname',
	'jobtitle', 'organization', 'department', 'maidenname', 'email', 'phone',
	'address', 'street', 'locality', 'zipcode', 'region', 'country', 'website', 'im', 'notes');

	// public properties
	public $primary_key = 'contact_id';
	public $readonly = false;
	public $groups = true;
	public $undelete = true;
	public $list_page = 1;
	public $page_size = 10;
	public $group_id = 0;
	public $ready = false;
	public $coltypes = array('name', 'firstname', 'surname', 'middlename', 'prefix', 'suffix', 'nickname',
	'jobtitle', 'organization', 'department', 'assistant', 'manager',
	'gender', 'maidenname', 'spouse', 'email', 'phone', 'address',
	'birthday', 'anniversary', 'website', 'im', 'notes', 'photo');


	/**
	* Object constructor
	*
	* @param object Instance of the rcube_db class
	* @param integer User-ID
	*/
	function __construct($dbconn, $user)
	{
	$this->db = $dbconn;
	$this->user_id = $user;
	$this->ready = $this->db && !$this->db->is_error();
	}


	/**
	* Returns addressbook name
	*/
	function get_name()
	{
	return $this->name;
	}


	/**
	* Save a search string for future listings
	*
	* @param string SQL params to use in listing method
	*/
	function set_search_set($filter)
	{
	$this->filter = $filter;
	$this->cache = null;
	}


	/**
	* Getter for saved search properties
	*
	* @return mixed Search properties used by this class
	*/
	function get_search_set()
	{
	return $this->filter;
	}


	/**
	* Setter for the current group
	* (empty, has to be re-implemented by extending class)
	*/
	function set_group($gid)
	{
	$this->group_id = $gid;
	$this->cache = null;
	}


	/**
	* Reset all saved results and search parameters
	*/
	function reset()
	{
	$this->result = null;
	$this->filter = null;
	$this->cache = null;
	}


	/**
	* List all active contact groups of this source
	*
	* @param string Search string to match group name
	* @return array Indexed list of contact groups, each a hash array
	*/
	function list_groups($search = null)
	{
	$results = array();

	if (!$this->groups)
	return $results;

	$sql_filter = $search ? " AND " . $this->db->ilike('name', '%'.$search.'%') : '';

	$sql_result = $this->db->query(
	"SELECT * FROM ".get_table_name($this->db_groups).
	" WHERE del<>1".
	" AND user_id=?".
	$sql_filter.
	" ORDER BY name",
	$this->user_id);

	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$sql_arr['ID'] = $sql_arr['contactgroup_id'];
	$results[] = $sql_arr;
	}

	return $results;
	}


	/**
	* List the current set of contact records
	*
	* @param array List of cols to show, Null means all
	* @param int Only return this number of records, use negative values for tail
	* @param boolean True to skip the count query (select only)
	* @return array Indexed list of contact records, each a hash array
	*/
	function list_records($cols=null, $subset=0, $nocount=false)
	{
	if ($nocount \|\| $this->list_page <= 1) {
	// create dummy result, we don't need a count now
	$this->result = new rcube_result_set();
	} else {
	// count all records
	$this->result = $this->count();
	}

	$start_row = $subset < 0 ? $this->result->first + $this->page_size + $subset : $this->result->first;
	$length = $subset != 0 ? abs($subset) : $this->page_size;

	if ($this->group_id)
	$join = " LEFT JOIN ".get_table_name($this->db_groupmembers)." AS m".
	" ON (m.contact_id = c.".$this->primary_key.")";

	$sql_result = $this->db->limitquery(
	"SELECT * FROM ".get_table_name($this->db_name)." AS c" .
	$join .
	" WHERE c.del<>1" .
	" AND c.user_id=?" .
	($this->group_id ? " AND m.contactgroup_id=?" : "").
	($this->filter ? " AND (".$this->filter.")" : "") .
	" ORDER BY ". $this->db->concat('c.name', 'c.email'),
	$start_row,
	$length,
	$this->user_id,
	$this->group_id);

	// determine whether we have to parse the vcard or if only db cols are requested
	$read_vcard = !$cols \|\| count(array_intersect($cols, $this->table_cols)) < count($cols);

	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$sql_arr['ID'] = $sql_arr[$this->primary_key];

	if ($read_vcard)
	$sql_arr = $this->convert_db_data($sql_arr);
	else
	$sql_arr['email'] = preg_split('/,\s*/', $sql_arr['email']);

	// make sure we have a name to display
	if (empty($sql_arr['name'])) {
	if (empty($sql_arr['email']))
	$sql_arr['email'] = $this->get_col_values('email', $sql_arr, true);
	$sql_arr['name'] = $sql_arr['email'][0];
	}

	$this->result->add($sql_arr);
	}

	$cnt = count($this->result->records);

	// update counter
	if ($nocount)
	$this->result->count = $cnt;
	else if ($this->list_page <= 1) {
	if ($cnt < $this->page_size && $subset == 0)
	$this->result->count = $cnt;
	else if (isset($this->cache['count']))
	$this->result->count = $this->cache['count'];
	else
	$this->result->count = $this->_count();
	}

	return $this->result;
	}


	/**
	* Search contacts
	*
	* @param mixed $fields The field name of array of field names to search in
	* @param mixed $value Search value (or array of values when $fields is array)
	* @param boolean $strict True for strict (=), False for partial (LIKE) matching
	* @param boolean $select True if results are requested, False if count only
	* @param boolean $nocount True to skip the count query (select only)
	* @param array $required List of fields that cannot be empty
	*
	* @return object rcube_result_set Contact records and 'count' value
	*/
	function search($fields, $value, $strict=false, $select=true, $nocount=false, $required=array())
	{
	if (!is_array($fields))
	$fields = array($fields);
	if (!is_array($required) && !empty($required))
	$required = array($required);

	$where = $and_where = array();

	foreach ($fields as $idx => $col) {
	// direct ID search
	if ($col == 'ID' \|\| $col == $this->primary_key) {
	$ids = !is_array($value) ? explode(',', $value) : $value;
	$ids = $this->db->array2list($ids, 'integer');
	$where[] = 'c.' . $this->primary_key.' IN ('.$ids.')';
	continue;
	}
	// fulltext search in all fields
	else if ($col == '*') {
	$words = array();
	foreach (explode(" ", self::normalize_string($value)) as $word)
	$words[] = $this->db->ilike('words', '%'.$word.'%');
	$where[] = '(' . join(' AND ', $words) . ')';
	}
	else {
	$val = is_array($value) ? $value[$idx] : $value;
	// table column
	if (in_array($col, $this->table_cols)) {
	if ($strict) {
	$where[] = $this->db->quoteIdentifier($col).' = '.$this->db->quote($val);
	}
	else {
	$where[] = $this->db->ilike($col, '%'.$val.'%');
	}
	}
	// vCard field
	else {
	if (in_array($col, $this->fulltext_cols)) {
	foreach (explode(" ", self::normalize_string($val)) as $word)
	$words[] = $this->db->ilike('words', '%'.$word.'%');
	$where[] = '(' . join(' AND ', $words) . ')';
	}
	if (is_array($value))
	$post_search[$col] = mb_strtolower($val);
	}
	}
	}

	foreach ($required as $col) {
	$and_where[] = $this->db->quoteIdentifier($col).' <> '.$this->db->quote('');
	}

	if (!empty($where)) {
	// use AND operator for advanced searches
	$where = join(is_array($value) ? ' AND ' : ' OR ', $where);
	}

	if (!empty($and_where))
	$where = ($where ? "($where) AND " : '') . join(' AND ', $and_where);

	// Post-searching in vCard data fields
	// we will search in all records and then build a where clause for their IDs
	if (!empty($post_search)) {
	$ids = array(0);
	// build key name regexp
	$regexp = '/^(' . implode(array_keys($post_search), '\|') . ')(?:.*)$/';
	// use initial WHERE clause, to limit records number if possible
	if (!empty($where))
	$this->set_search_set($where);

	// count result pages
	$cnt = $this->count();
	$pages = ceil($cnt / $this->page_size);
	$scnt = count($post_search);

	// get (paged) result
	for ($i=0; $i<$pages; $i++) {
	$this->list_records(null, $i, true);
	while ($row = $this->result->next()) {
	$id = $row[$this->primary_key];
	$found = array();
	foreach (preg_grep($regexp, array_keys($row)) as $col) {
	$pos = strpos($col, ':');
	$colname = $pos ? substr($col, 0, $pos) : $col;
	$search = $post_search[$colname];
	foreach ((array)$row[$col] as $value) {
	// composite field, e.g. address
	if (is_array($value)) {
	$value = implode($value);
	}
	$value = mb_strtolower($value);
	if (($strict && $value == $search) \|\| (!$strict && strpos($value, $search) !== false)) {
	$found[$colname] = true;
	break;
	}
	}
	}
	// all fields match
	if (count($found) >= $scnt) {
	$ids[] = $id;
	}
	}
	}

	// build WHERE clause
	$ids = $this->db->array2list($ids, 'integer');
	$where = 'c.' . $this->primary_key.' IN ('.$ids.')';
	// reset counter
	unset($this->cache['count']);

	// when we know we have an empty result
	if ($ids == '0') {
	$this->set_search_set($where);
	return ($this->result = new rcube_result_set(0, 0));
	}
	}

	if (!empty($where)) {
	$this->set_search_set($where);
	if ($select)
	$this->list_records(null, 0, $nocount);
	else
	$this->result = $this->count();
	}

	return $this->result;
	}


	/**
	* Count number of available contacts in database
	*
	* @return rcube_result_set Result object
	*/
	function count()
	{
	$count = isset($this->cache['count']) ? $this->cache['count'] : $this->_count();

	return new rcube_result_set($count, ($this->list_page-1) * $this->page_size);
	}


	/**
	* Count number of available contacts in database
	*
	* @return int Contacts count
	*/
	private function _count()
	{
	if ($this->group_id)
	$join = " LEFT JOIN ".get_table_name($this->db_groupmembers)." AS m".
	" ON (m.contact_id=c.".$this->primary_key.")";

	// count contacts for this user
	$sql_result = $this->db->query(
	"SELECT COUNT(c.contact_id) AS rows".
	" FROM ".get_table_name($this->db_name)." AS c".
	$join.
	" WHERE c.del<>1".
	" AND c.user_id=?".
	($this->group_id ? " AND m.contactgroup_id=?" : "").
	($this->filter ? " AND (".$this->filter.")" : ""),
	$this->user_id,
	$this->group_id
	);

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

	$this->cache['count'] = (int) $sql_arr['rows'];

	return $this->cache['count'];
	}


	/**
	* Return the last result set
	*
	* @return mixed Result array or NULL if nothing selected yet
	*/
	function get_result()
	{
	return $this->result;
	}


	/**
	* Get a specific contact record
	*
	* @param mixed record identifier(s)
	* @return mixed Result object with all record fields or False if not found
	*/
	function get_record($id, $assoc=false)
	{
	// return cached result
	if ($this->result && ($first = $this->result->first()) && $first[$this->primary_key] == $id)
	return $assoc ? $first : $this->result;

	$this->db->query(
	"SELECT * FROM ".get_table_name($this->db_name).
	" WHERE contact_id=?".
	" AND user_id=?".
	" AND del<>1",
	$id,
	$this->user_id
	);

	if ($sql_arr = $this->db->fetch_assoc()) {
	$record = $this->convert_db_data($sql_arr);
	$this->result = new rcube_result_set(1);
	$this->result->add($record);
	}

	return $assoc && $record ? $record : $this->result;
	}


	/**
	* Get group assignments of a specific contact record
	*
	* @param mixed Record identifier
	* @return array List of assigned groups as ID=>Name pairs
	*/
	function get_record_groups($id)
	{
	$results = array();

	if (!$this->groups)
	return $results;

	$sql_result = $this->db->query(
	"SELECT cgm.contactgroup_id, cg.name FROM " . get_table_name($this->db_groupmembers) . " AS cgm" .
	" LEFT JOIN " . get_table_name($this->db_groups) . " AS cg ON (cgm.contactgroup_id = cg.contactgroup_id AND cg.del<>1)" .
	" WHERE cgm.contact_id=?",
	$id
	);
	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$results[$sql_arr['contactgroup_id']] = $sql_arr['name'];
	}

	return $results;
	}


	/**
	* Check the given data before saving.
	* If input not valid, the message to display can be fetched using get_error()
	*
	* @param array Assoziative array with data to save
	* @return boolean True if input is valid, False if not.
	*/
	public function validate($save_data)
	{
	// validate e-mail addresses
	$valid = parent::validate($save_data);

	// require at least one e-mail address (syntax check is already done)
	if ($valid && !array_filter($this->get_col_values('email', $save_data, true))) {
	$this->set_error('warning', 'noemailwarning');
	$valid = false;
	}

	return $valid;
	}


	/**
	* Create a new contact record
	*
	* @param array Associative array with save data
	* @return integer\|boolean The created record ID on success, False on error
	*/
	function insert($save_data, $check=false)
	{
	if (!is_array($save_data))
	return false;

	$insert_id = $existing = false;

	if ($check) {
	foreach ($save_data as $col => $values) {
	if (strpos($col, 'email') === 0) {
	foreach ((array)$values as $email) {
	if ($existing = $this->search('email', $email, false, false))
	break 2;
	}
	}
	}
	}

	$save_data = $this->convert_save_data($save_data);
	$a_insert_cols = $a_insert_values = array();

	foreach ($save_data as $col => $value) {
	$a_insert_cols[] = $this->db->quoteIdentifier($col);
	$a_insert_values[] = $this->db->quote($value);
	}

	if (!$existing->count && !empty($a_insert_cols)) {
	$this->db->query(
	"INSERT INTO ".get_table_name($this->db_name).
	" (user_id, changed, del, ".join(', ', $a_insert_cols).")".
	" VALUES (".intval($this->user_id).", ".$this->db->now().", 0, ".join(', ', $a_insert_values).")"
	);

	$insert_id = $this->db->insert_id($this->db_name);
	}

	// also add the newly created contact to the active group
	if ($insert_id && $this->group_id)
	$this->add_to_group($this->group_id, $insert_id);

	$this->cache = null;

	return $insert_id;
	}


	/**
	* Update a specific contact record
	*
	* @param mixed Record identifier
	* @param array Assoziative array with save data
	* @return boolean True on success, False on error
	*/
	function update($id, $save_cols)
	{
	$updated = false;
	$write_sql = array();
	$record = $this->get_record($id, true);
	$save_cols = $this->convert_save_data($save_cols, $record);

	foreach ($save_cols as $col => $value) {
	$write_sql[] = sprintf("%s=%s", $this->db->quoteIdentifier($col), $this->db->quote($value));
	}

	if (!empty($write_sql)) {
	$this->db->query(
	"UPDATE ".get_table_name($this->db_name).
	" SET changed=".$this->db->now().", ".join(', ', $write_sql).
	" WHERE contact_id=?".
	" AND user_id=?".
	" AND del<>1",
	$id,
	$this->user_id
	);

	$updated = $this->db->affected_rows();
	$this->result = null; // clear current result (from get_record())
	}

	return $updated;
	}
	-
	-
	+
	+
	private function convert_db_data($sql_arr)
	{
	$record = array();
	$record['ID'] = $sql_arr[$this->primary_key];
	-
	+
	if ($sql_arr['vcard']) {
	unset($sql_arr['email']);
	$vcard = new rcube_vcard($sql_arr['vcard']);
	$record += $vcard->get_assoc() + $sql_arr;
	}
	else {
	$record += $sql_arr;
	$record['email'] = preg_split('/,\s*/', $record['email']);
	}
	-
	+
	return $record;
	}


	private function convert_save_data($save_data, $record = array())
	{
	$out = array();
	$words = '';

	// copy values into vcard object
	$vcard = new rcube_vcard($record['vcard'] ? $record['vcard'] : $save_data['vcard']);
	$vcard->reset();
	foreach ($save_data as $key => $values) {
	list($field, $section) = explode(':', $key);
	$fulltext = in_array($field, $this->fulltext_cols);
	foreach ((array)$values as $value) {
	if (isset($value))
	$vcard->set($field, $value, $section);
	if ($fulltext && is_array($value))
	$words .= ' ' . self::normalize_string(join(" ", $value));
	else if ($fulltext && strlen($value) >= 3)
	$words .= ' ' . self::normalize_string($value);
	}
	}
	$out['vcard'] = $vcard->export(false);

	foreach ($this->table_cols as $col) {
	$key = $col;
	if (!isset($save_data[$key]))
	$key .= ':home';
	if (isset($save_data[$key]))
	$out[$col] = is_array($save_data[$key]) ? join(',', $save_data[$key]) : $save_data[$key];
	}

	// save all e-mails in database column
	$out['email'] = join(", ", $vcard->email);

	// join words for fulltext search
	$out['words'] = join(" ", array_unique(explode(" ", $words)));

	return $out;
	}


	/**
	* Mark one or more contact records as deleted
	*
	- * @param array Record identifiers
	+ * @param array Record identifiers
	+ * @param boolean Remove record(s) irreversible (unsupported)
	*/
	- function delete($ids)
	+ function delete($ids, $force=true)
	{
	if (!is_array($ids))
	$ids = explode(',', $ids);

	$ids = $this->db->array2list($ids, 'integer');

	- // flag record as deleted
	+ // flag record as deleted (always)
	$this->db->query(
	"UPDATE ".get_table_name($this->db_name).
	" SET del=1, changed=".$this->db->now().
	" WHERE user_id=?".
	" AND contact_id IN ($ids)",
	$this->user_id
	);

	$this->cache = null;

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


	/**
	* Undelete one or more contact records
	*
	* @param array Record identifiers
	*/
	function undelete($ids)
	{
	if (!is_array($ids))
	$ids = explode(',', $ids);

	$ids = $this->db->array2list($ids, 'integer');

	- // flag record as deleted
	+ // clear deleted flag
	$this->db->query(
	"UPDATE ".get_table_name($this->db_name).
	" SET del=0, changed=".$this->db->now().
	" WHERE user_id=?".
	" AND contact_id IN ($ids)",
	$this->user_id
	);

	$this->cache = null;

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


	/**
	* Remove all records from the database
	*/
	function delete_all()
	{
	$this->cache = null;

	$this->db->query("UPDATE ".get_table_name($this->db_name).
	" SET del=1, changed=".$this->db->now().
	" WHERE user_id = ?", $this->user_id);

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


	/**
	* 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)
	{
	$result = false;

	// make sure we have a unique name
	$name = $this->unique_groupname($name);

	$this->db->query(
	"INSERT INTO ".get_table_name($this->db_groups).
	" (user_id, changed, name)".
	" VALUES (".intval($this->user_id).", ".$this->db->now().", ".$this->db->quote($name).")"
	);

	if ($insert_id = $this->db->insert_id($this->db_groups))
	$result = array('id' => $insert_id, 'name' => $name);

	return $result;
	}


	/**
	* 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)
	{
	// flag group record as deleted
	$sql_result = $this->db->query(
	"UPDATE ".get_table_name($this->db_groups).
	" SET del=1, changed=".$this->db->now().
	" WHERE contactgroup_id=?",
	$gid
	);

	$this->cache = null;

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


	/**
	* Rename a specific contact group
	*
	* @param string Group identifier
	* @param string New name to set for this group
	* @return boolean New name on success, false if no data was changed
	*/
	function rename_group($gid, $newname)
	{
	// make sure we have a unique name
	$name = $this->unique_groupname($newname);

	$sql_result = $this->db->query(
	"UPDATE ".get_table_name($this->db_groups).
	" SET name=?, changed=".$this->db->now().
	" WHERE contactgroup_id=?",
	$name, $gid
	);

	return $this->db->affected_rows() ? $name : 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)
	{
	if (!is_array($ids))
	$ids = explode(',', $ids);

	$added = 0;
	$exists = array();

	// get existing assignments ...
	$sql_result = $this->db->query(
	"SELECT contact_id FROM ".get_table_name($this->db_groupmembers).
	" WHERE contactgroup_id=?".
	" AND contact_id IN (".$this->db->array2list($ids, 'integer').")",
	$group_id
	);
	while ($sql_result && ($sql_arr = $this->db->fetch_assoc($sql_result))) {
	$exists[] = $sql_arr['contact_id'];
	}
	// ... and remove them from the list
	$ids = array_diff($ids, $exists);

	foreach ($ids as $contact_id) {
	$this->db->query(
	"INSERT INTO ".get_table_name($this->db_groupmembers).
	" (contactgroup_id, contact_id, created)".
	" VALUES (?, ?, ".$this->db->now().")",
	$group_id,
	$contact_id
	);

	if (!$this->db->db_error)
	$added++;
	}

	return $added;
	}


	/**
	* 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)
	{
	if (!is_array($ids))
	$ids = explode(',', $ids);

	$ids = $this->db->array2list($ids, 'integer');

	$sql_result = $this->db->query(
	"DELETE FROM ".get_table_name($this->db_groupmembers).
	" WHERE contactgroup_id=?".
	" AND contact_id IN ($ids)",
	$group_id
	);

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


	/**
	* Check for existing groups with the same name
	*
	* @param string Name to check
	* @return string A group name which is unique for the current use
	*/
	private function unique_groupname($name)
	{
	$checkname = $name;
	$num = 2; $hit = false;

	do {
	$sql_result = $this->db->query(
	"SELECT 1 FROM ".get_table_name($this->db_groups).
	" WHERE del<>1".
	" AND user_id=?".
	" AND name=?",
	$this->user_id,
	$checkname);

	// append number to make name unique
	if ($hit = $this->db->num_rows($sql_result))
	$checkname = $name . ' ' . $num++;
	} while ($hit > 0);

	return $checkname;
	}

	}
	diff --git a/program/include/rcube_ldap.php b/program/include/rcube_ldap.php
	index 4ea4f6046..4205df271 100644
	--- a/program/include/rcube_ldap.php
	+++ b/program/include/rcube_ldap.php
	@@ -1,1409 +1,1410 @@
	<?php
	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_ldap.php \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2006-2011, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Interface to an LDAP address directory \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	\| Andreas Dick <andudi (at) gmx (dot) ch> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	/**
	* Model class to access an LDAP address directory
	*
	* @package Addressbook
	*/
	class rcube_ldap extends rcube_addressbook
	{
	/** public properties */
	public $primary_key = 'ID';
	public $groups = false;
	public $readonly = true;
	public $ready = false;
	public $group_id = 0;
	public $list_page = 1;
	public $page_size = 10;
	public $coltypes = array();

	/** private properties */
	protected $conn;
	protected $prop = array();
	protected $fieldmap = array();

	protected $filter = '';
	protected $result = null;
	protected $ldap_result = null;
	protected $sort_col = '';
	protected $mail_domain = '';
	protected $debug = false;

	private $base_dn = '';
	private $groups_base_dn = '';
	private $group_cache = array();
	private $group_members = array();

	private $vlv_active = false;
	private $vlv_count = 0;


	/**
	* Object constructor
	*
	* @param array LDAP connection properties
	* @param boolean Enables debug mode
	* @param string Current user mail domain name
	* @param integer User-ID
	*/
	function __construct($p, $debug=false, $mail_domain=NULL)
	{
	$this->prop = $p;

	// check if groups are configured
	if (is_array($p['groups']) and count($p['groups']))
	$this->groups = true;

	// fieldmap property is given
	if (is_array($p['fieldmap'])) {
	foreach ($p['fieldmap'] as $rf => $lf)
	$this->fieldmap[$rf] = $this->_attr_name(strtolower($lf));
	}
	else {
	// read deprecated *_field properties to remain backwards compatible
	foreach ($p as $prop => $value)
	if (preg_match('/^(.+)_field$/', $prop, $matches))
	$this->fieldmap[$matches[1]] = $this->_attr_name(strtolower($value));
	}

	// use fieldmap to advertise supported coltypes to the application
	foreach ($this->fieldmap as $col => $lf) {
	list($col, $type) = explode(':', $col);
	if (!is_array($this->coltypes[$col])) {
	$subtypes = $type ? array($type) : null;
	$this->coltypes[$col] = array('limit' => 2, 'subtypes' => $subtypes);
	}
	elseif ($type) {
	$this->coltypes[$col]['subtypes'][] = $type;
	$this->coltypes[$col]['limit']++;
	}
	if ($type && !$this->fieldmap[$col])
	$this->fieldmap[$col] = $lf;
	}

	if ($this->fieldmap['street'] && $this->fieldmap['locality'])
	$this->coltypes['address'] = array('limit' => 1);
	else if ($this->coltypes['address'])
	$this->coltypes['address'] = array('type' => 'textarea', 'childs' => null, 'limit' => 1, 'size' => 40);

	// make sure 'required_fields' is an array
	if (!is_array($this->prop['required_fields']))
	$this->prop['required_fields'] = (array) $this->prop['required_fields'];

	foreach ($this->prop['required_fields'] as $key => $val)
	$this->prop['required_fields'][$key] = $this->_attr_name(strtolower($val));

	$this->sort_col = is_array($p['sort']) ? $p['sort'][0] : $p['sort'];
	$this->debug = $debug;
	$this->mail_domain = $mail_domain;

	$this->_connect();
	}


	/**
	* Establish a connection to the LDAP server
	*/
	private function _connect()
	{
	global $RCMAIL;

	if (!function_exists('ldap_connect'))
	raise_error(array('code' => 100, 'type' => 'ldap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "No ldap support in this installation of PHP"),
	true, true);

	if (is_resource($this->conn))
	return true;

	if (!is_array($this->prop['hosts']))
	$this->prop['hosts'] = array($this->prop['hosts']);

	if (empty($this->prop['ldap_version']))
	$this->prop['ldap_version'] = 3;

	foreach ($this->prop['hosts'] as $host)
	{
	$host = idn_to_ascii(rcube_parse_host($host));
	$this->_debug("C: Connect [$host".($this->prop['port'] ? ':'.$this->prop['port'] : '')."]");

	if ($lc = @ldap_connect($host, $this->prop['port']))
	{
	if ($this->prop['use_tls']===true)
	if (!ldap_start_tls($lc))
	continue;

	$this->_debug("S: OK");

	ldap_set_option($lc, LDAP_OPT_PROTOCOL_VERSION, $this->prop['ldap_version']);
	$this->prop['host'] = $host;
	$this->conn = $lc;
	break;
	}
	$this->_debug("S: NOT OK");
	}

	if (is_resource($this->conn))
	{
	$this->ready = true;

	$bind_pass = $this->prop['bind_pass'];
	$bind_user = $this->prop['bind_user'];
	$bind_dn = $this->prop['bind_dn'];
	$this->base_dn = $this->prop['base_dn'];

	// User specific access, generate the proper values to use.
	if ($this->prop['user_specific']) {
	// No password set, use the session password
	if (empty($bind_pass)) {
	$bind_pass = $RCMAIL->decrypt($_SESSION['password']);
	}

	// Get the pieces needed for variable replacement.
	$fu = $RCMAIL->user->get_username();
	list($u, $d) = explode('@', $fu);
	$dc = 'dc='.strtr($d, array('.' => ',dc=')); // hierarchal domain string

	$replaces = array('%dc' => $dc, '%d' => $d, '%fu' => $fu, '%u' => $u);

	if ($this->prop['search_base_dn'] && $this->prop['search_filter']) {
	// Search for the dn to use to authenticate
	$this->prop['search_base_dn'] = strtr($this->prop['search_base_dn'], $replaces);
	$this->prop['search_filter'] = strtr($this->prop['search_filter'], $replaces);

	$this->_debug("S: searching with base {$this->prop['search_base_dn']} for {$this->prop['search_filter']}");

	$res = ldap_search($this->conn, $this->prop['search_base_dn'], $this->prop['search_filter'], array('uid'));
	if ($res && ($entry = ldap_first_entry($this->conn, $res))) {
	$bind_dn = ldap_get_dn($this->conn, $entry);

	$this->_debug("S: search returned dn: $bind_dn");

	if ($bind_dn) {
	$dn = ldap_explode_dn($bind_dn, 1);
	$replaces['%dn'] = $dn[0];
	}
	}
	}
	// Replace the bind_dn and base_dn variables.
	$bind_dn = strtr($bind_dn, $replaces);
	$this->base_dn = strtr($this->base_dn, $replaces);

	if (empty($bind_user)) {
	$bind_user = $u;
	}
	}

	if (!empty($bind_pass)) {
	if (!empty($bind_dn)) {
	$this->ready = $this->_bind($bind_dn, $bind_pass);
	}
	else if (!empty($this->prop['auth_cid'])) {
	$this->ready = $this->_sasl_bind($this->prop['auth_cid'], $bind_pass, $bind_user);
	}
	else {
	$this->ready = $this->_sasl_bind($bind_user, $bind_pass);
	}
	}
	}
	else
	raise_error(array('code' => 100, 'type' => 'ldap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Could not connect to any LDAP server, last tried $host:{$this->prop[port]}"), true);

	// See if the directory is writeable.
	if ($this->prop['writable']) {
	$this->readonly = false;
	} // end if
	}


	/**
	* Bind connection with (SASL-) user and password
	*
	* @param string $authc Authentication user
	* @param string $pass Bind password
	* @param string $authz Autorization user
	*
	* @return boolean True on success, False on error
	*/
	private function _sasl_bind($authc, $pass, $authz=null)
	{
	if (!$this->conn) {
	return false;
	}

	if (!function_exists('ldap_sasl_bind')) {
	raise_error(array('code' => 100, 'type' => 'ldap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Unable to bind: ldap_sasl_bind() not exists"),
	true, true);
	}

	if (!empty($authz)) {
	$authz = 'u:' . $authz;
	}

	if (!empty($this->prop['auth_method'])) {
	$method = $this->prop['auth_method'];
	}
	else {
	$method = 'DIGEST-MD5';
	}

	$this->_debug("C: Bind [mech: $method, authc: $authc, authz: $authz] [pass: $pass]");

	if (ldap_sasl_bind($this->conn, NULL, $pass, $method, NULL, $authc, $authz)) {
	$this->_debug("S: OK");
	return true;
	}

	$this->_debug("S: ".ldap_error($this->conn));

	raise_error(array(
	'code' => ldap_errno($this->conn), 'type' => 'ldap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Bind failed for authcid=$authc ".ldap_error($this->conn)),
	true);

	return false;
	}


	/**
	* Bind connection with DN and password
	*
	* @param string Bind DN
	* @param string Bind password
	*
	* @return boolean True on success, False on error
	*/
	private function _bind($dn, $pass)
	{
	if (!$this->conn) {
	return false;
	}

	$this->_debug("C: Bind [dn: $dn] [pass: $pass]");

	if (@ldap_bind($this->conn, $dn, $pass)) {
	$this->_debug("S: OK");
	return true;
	}

	$this->_debug("S: ".ldap_error($this->conn));

	raise_error(array(
	'code' => ldap_errno($this->conn), 'type' => 'ldap',
	'file' => __FILE__, 'line' => __LINE__,
	'message' => "Bind failed for dn=$dn: ".ldap_error($this->conn)),
	true);

	return false;
	}


	/**
	* Close connection to LDAP server
	*/
	function close()
	{
	if ($this->conn)
	{
	$this->_debug("C: Close");
	ldap_unbind($this->conn);
	$this->conn = null;
	}
	}


	/**
	* Returns address book name
	*
	* @return string Address book name
	*/
	function get_name()
	{
	return $this->prop['name'];
	}


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


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


	/**
	* Save a search string for future listings
	*
	* @param string $filter Filter string
	*/
	function set_search_set($filter)
	{
	$this->filter = $filter;
	}


	/**
	* Getter for saved search properties
	*
	* @return mixed Search properties used by this class
	*/
	function get_search_set()
	{
	return $this->filter;
	}


	/**
	* Reset all saved results and search parameters
	*/
	function reset()
	{
	$this->result = null;
	$this->ldap_result = null;
	$this->filter = '';
	}


	/**
	* List the current set of contact records
	*
	* @param array List of cols to show
	* @param int Only return this number of records
	*
	* @return array Indexed list of contact records, each a hash array
	*/
	function list_records($cols=null, $subset=0)
	{
	// add general filter to query
	if (!empty($this->prop['filter']) && empty($this->filter))
	{
	$filter = $this->prop['filter'];
	$this->set_search_set($filter);
	}

	// exec LDAP search if no result resource is stored
	if ($this->conn && !$this->ldap_result)
	$this->_exec_search();

	// count contacts for this user
	$this->result = $this->count();

	// we have a search result resource
	if ($this->ldap_result && $this->result->count > 0)
	{
	if ($this->sort_col && $this->prop['scope'] !== 'base' && !$this->vlv_active)
	ldap_sort($this->conn, $this->ldap_result, $this->sort_col);

	$start_row = $this->vlv_active ? 0 : $this->result->first;
	$start_row = $subset < 0 ? $start_row + $this->page_size + $subset : $start_row;
	$last_row = $this->result->first + $this->page_size;
	$last_row = $subset != 0 ? $start_row + abs($subset) : $last_row;

	$entries = ldap_get_entries($this->conn, $this->ldap_result);
	for ($i = $start_row; $i < min($entries['count'], $last_row); $i++)
	$this->result->add($this->_ldap2result($entries[$i]));
	}

	// temp hack for filtering group members
	if ($this->groups and $this->group_id)
	{
	$result = new rcube_result_set();
	while ($record = $this->result->iterate())
	{
	if ($this->group_members[$record['ID']])
	{
	$result->add($record);
	$result->count++;
	}
	}
	$this->result = $result;
	}

	return $this->result;
	}


	/**
	* Search contacts
	*
	* @param mixed $fields The field name of array of field names to search in
	* @param mixed $value Search value (or array of values when $fields is array)
	* @param boolean $strict True for strict, False for partial (fuzzy) matching
	* @param boolean $select True if results are requested, False if count only
	* @param boolean $nocount (Not used)
	* @param array $required List of fields that cannot be empty
	*
	* @return array Indexed list of contact records and 'count' value
	*/
	function search($fields, $value, $strict=false, $select=true, $nocount=false, $required=array())
	{
	// special treatment for ID-based search
	if ($fields == 'ID' \|\| $fields == $this->primary_key)
	{
	$ids = !is_array($value) ? explode(',', $value) : $value;
	$result = new rcube_result_set();
	foreach ($ids as $id)
	{
	if ($rec = $this->get_record($id, true))
	{
	$result->add($rec);
	$result->count++;
	}
	}
	return $result;
	}

	// use AND operator for advanced searches
	$filter = is_array($value) ? '(&' : '(\|';
	$wc = !$strict && $this->prop['fuzzy_search'] ? '*' : '';

	if ($fields == '*')
	{
	// search_fields are required for fulltext search
	if (empty($this->prop['search_fields']))
	{
	$this->set_error(self::ERROR_SEARCH, 'nofulltextsearch');
	$this->result = new rcube_result_set();
	return $this->result;
	}
	if (is_array($this->prop['search_fields']))
	{
	foreach ($this->prop['search_fields'] as $field) {
	$filter .= "($field=$wc" . $this->_quote_string($value) . "$wc)";
	}
	}
	}
	else
	{
	foreach ((array)$fields as $idx => $field) {
	$val = is_array($value) ? $value[$idx] : $value;
	if ($f = $this->_map_field($field)) {
	$filter .= "($f=$wc" . $this->_quote_string($val) . "$wc)";
	}
	}
	}
	$filter .= ')';

	// add required (non empty) fields filter
	$req_filter = '';
	foreach ((array)$required as $field)
	if ($f = $this->_map_field($field))
	$req_filter .= "($f=*)";

	if (!empty($req_filter))
	$filter = '(&' . $req_filter . $filter . ')';

	// avoid double-wildcard if $value is empty
	$filter = preg_replace('/\+/', '', $filter);

	// add general filter to query
	if (!empty($this->prop['filter']))
	$filter = '(&(' . preg_replace('/^$\|$$/', '', $this->prop['filter']) . ')' . $filter . ')';

	// set filter string and execute search
	$this->set_search_set($filter);
	$this->_exec_search();

	if ($select)
	$this->list_records();
	else
	$this->result = $this->count();

	return $this->result;
	}


	/**
	* Count number of available contacts in database
	*
	* @return object rcube_result_set Resultset with values for 'count' and 'first'
	*/
	function count()
	{
	$count = 0;
	if ($this->conn && $this->ldap_result) {
	$count = $this->vlv_active ? $this->vlv_count : ldap_count_entries($this->conn, $this->ldap_result);
	} // end if
	elseif ($this->conn) {
	// We have a connection but no result set, attempt to get one.
	if (empty($this->filter)) {
	// The filter is not set, set it.
	$this->filter = $this->prop['filter'];
	} // end if
	$this->_exec_search(true);
	if ($this->ldap_result) {
	$count = ldap_count_entries($this->conn, $this->ldap_result);
	} // end if
	} // end else

	return new rcube_result_set($count, ($this->list_page-1) * $this->page_size);
	}


	/**
	* Return the last result set
	*
	* @return object rcube_result_set Current resultset or NULL if nothing selected yet
	*/
	function get_result()
	{
	return $this->result;
	}


	/**
	* Get a specific contact record
	*
	* @param mixed Record identifier
	* @param boolean Return as associative array
	*
	* @return mixed Hash array or rcube_result_set with all record fields
	*/
	function get_record($dn, $assoc=false)
	{
	$res = null;
	if ($this->conn && $dn)
	{
	$dn = base64_decode($dn);

	$this->_debug("C: Read [dn: $dn] [(objectclass=*)]");

	if ($this->ldap_result = @ldap_read($this->conn, $dn, '(objectclass=*)', array_values($this->fieldmap)))
	$entry = ldap_first_entry($this->conn, $this->ldap_result);
	else
	$this->_debug("S: ".ldap_error($this->conn));

	if ($entry && ($rec = ldap_get_attributes($this->conn, $entry)))
	{
	$this->_debug("S: OK"/* . print_r($rec, true)*/);

	$rec = array_change_key_case($rec, CASE_LOWER);

	// Add in the dn for the entry.
	$rec['dn'] = $dn;
	$res = $this->_ldap2result($rec);
	$this->result = new rcube_result_set(1);
	$this->result->add($res);
	}
	}

	return $assoc ? $res : $this->result;
	}


	/**
	* Check the given data before saving.
	* If input not valid, the message to display can be fetched using get_error()
	*
	* @param array Assoziative array with data to save
	*
	* @return boolean True if input is valid, False if not.
	*/
	public function validate($save_data)
	{
	// check for name input
	if (empty($save_data['name'])) {
	$this->set_error('warning', 'nonamewarning');
	return false;
	}

	// validate e-mail addresses
	return parent::validate($save_data);
	}


	/**
	* Create a new contact record
	*
	* @param array Hash array with save data
	*
	* @return encoded record ID on success, False on error
	*/
	function insert($save_cols)
	{
	// Map out the column names to their LDAP ones to build the new entry.
	$newentry = array();
	$newentry['objectClass'] = $this->prop['LDAP_Object_Classes'];
	foreach ($this->fieldmap as $col => $fld) {
	$val = $save_cols[$col];
	if (is_array($val))
	$val = array_filter($val); // remove empty entries
	if ($fld && $val) {
	// The field does exist, add it to the entry.
	$newentry[$fld] = $val;
	} // end if
	} // end foreach

	// Verify that the required fields are set.
	foreach ($this->prop['required_fields'] as $fld) {
	$missing = null;
	if (!isset($newentry[$fld])) {
	$missing[] = $fld;
	}
	}

	// abort process if requiered fields are missing
	// TODO: generate message saying which fields are missing
	if ($missing) {
	$this->set_error(self::ERROR_INCOMPLETE, 'formincomplete');
	return false;
	}

	// Build the new entries DN.
	$dn = $this->prop['LDAP_rdn'].'='.$this->_quote_string($newentry[$this->prop['LDAP_rdn']], true).','.$this->base_dn;

	$this->_debug("C: Add [dn: $dn]: ".print_r($newentry, true));

	$res = ldap_add($this->conn, $dn, $newentry);
	if ($res === FALSE) {
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	} // end if

	$this->_debug("S: OK");

	// add new contact to the selected group
	if ($this->groups)
	$this->add_to_group($this->group_id, base64_encode($dn));

	return base64_encode($dn);
	}


	/**
	* Update a specific contact record
	*
	* @param mixed Record identifier
	* @param array Hash array with save data
	*
	* @return boolean True on success, False on error
	*/
	function update($id, $save_cols)
	{
	$record = $this->get_record($id, true);
	$result = $this->get_result();
	$record = $result->first();

	$newdata = array();
	$replacedata = array();
	$deletedata = array();

	foreach ($this->fieldmap as $col => $fld) {
	$val = $save_cols[$col];
	if ($fld) {
	// remove empty array values
	if (is_array($val))
	$val = array_filter($val);
	// The field does exist compare it to the ldap record.
	if ($record[$col] != $val) {
	// Changed, but find out how.
	if (!isset($record[$col])) {
	// Field was not set prior, need to add it.
	$newdata[$fld] = $val;
	} // end if
	elseif ($val == '') {
	// Field supplied is empty, verify that it is not required.
	if (!in_array($fld, $this->prop['required_fields'])) {
	// It is not, safe to clear.
	$deletedata[$fld] = $record[$col];
	} // end if
	} // end elseif
	else {
	// The data was modified, save it out.
	$replacedata[$fld] = $val;
	} // end else
	} // end if
	} // end if
	} // end foreach

	$dn = base64_decode($id);

	// Update the entry as required.
	if (!empty($deletedata)) {
	// Delete the fields.
	$this->_debug("C: Delete [dn: $dn]: ".print_r($deletedata, true));
	if (!ldap_mod_del($this->conn, $dn, $deletedata)) {
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	}
	$this->_debug("S: OK");
	} // end if

	if (!empty($replacedata)) {
	// Handle RDN change
	if ($replacedata[$this->prop['LDAP_rdn']]) {
	$newdn = $this->prop['LDAP_rdn'].'='
	.$this->_quote_string($replacedata[$this->prop['LDAP_rdn']], true)
	.','.$this->base_dn;
	if ($dn != $newdn) {
	$newrdn = $this->prop['LDAP_rdn'].'='
	.$this->_quote_string($replacedata[$this->prop['LDAP_rdn']], true);
	unset($replacedata[$this->prop['LDAP_rdn']]);
	}
	}
	// Replace the fields.
	if (!empty($replacedata)) {
	$this->_debug("C: Replace [dn: $dn]: ".print_r($replacedata, true));
	if (!ldap_mod_replace($this->conn, $dn, $replacedata)) {
	$this->_debug("S: ".ldap_error($this->conn));
	return false;
	}
	$this->_debug("S: OK");
	} // end if
	} // end if

	if (!empty($newdata)) {
	// Add the fields.
	$this->_debug("C: Add [dn: $dn]: ".print_r($newdata, true));
	if (!ldap_mod_add($this->conn, $dn, $newdata)) {
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	}
	$this->_debug("S: OK");
	} // end if

	// Handle RDN change
	if (!empty($newrdn)) {
	$this->_debug("C: Rename [dn: $dn] [dn: $newrdn]");
	if (!ldap_rename($this->conn, $dn, $newrdn, NULL, TRUE)) {
	$this->_debug("S: ".ldap_error($this->conn));
	return false;
	}
	$this->_debug("S: OK");

	// change the group membership of the contact
	if ($this->groups)
	{
	$group_ids = $this->get_record_groups(base64_encode($dn));
	foreach ($group_ids as $group_id)
	{
	$this->remove_from_group($group_id, base64_encode($dn));
	$this->add_to_group($group_id, base64_encode($newdn));
	}
	}
	return base64_encode($newdn);
	}

	return true;
	}


	/**
	* Mark one or more contact records as deleted
	*
	- * @param array Record identifiers
	+ * @param array Record identifiers
	+ * @param boolean Remove record(s) irreversible (unsupported)
	*
	* @return boolean True on success, False on error
	*/
	- function delete($ids)
	+ function delete($ids, $force=true)
	{
	if (!is_array($ids)) {
	// Not an array, break apart the encoded DNs.
	$dns = explode(',', $ids);
	} // end if

	foreach ($dns as $id) {
	$dn = base64_decode($id);
	$this->_debug("C: Delete [dn: $dn]");
	// Delete the record.
	$res = ldap_delete($this->conn, $dn);
	if ($res === FALSE) {
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	} // end if
	$this->_debug("S: OK");

	// remove contact from all groups where he was member
	if ($this->groups)
	{
	$group_ids = $this->get_record_groups(base64_encode($dn));
	foreach ($group_ids as $group_id)
	{
	$this->remove_from_group($group_id, base64_encode($dn));
	}
	}
	} // end foreach

	return count($dns);
	}


	/**
	* Execute the LDAP search based on the stored credentials
	*/
	private function _exec_search($count = false)
	{
	if ($this->ready)
	{
	$filter = $this->filter ? $this->filter : '(objectclass=*)';
	$function = $this->prop['scope'] == 'sub' ? 'ldap_search' : ($this->prop['scope'] == 'base' ? 'ldap_read' : 'ldap_list');

	$this->_debug("C: Search [".$filter."]");

	// when using VLV, we get the total count by...
	if (!$count && $function != 'ldap_read' && $this->prop['vlv']) {
	// ...either reading numSubOrdinates attribute
	if ($this->prop['numsub_filter'] && ($result_count = @$function($this->conn, $this->base_dn, $this->prop['numsub_filter'], array('numSubOrdinates'), 0, 0, 0))) {
	$counts = ldap_get_entries($this->conn, $result_count);
	for ($this->vlv_count = $j = 0; $j < $counts['count']; $j++)
	$this->vlv_count += $counts[$j]['numsubordinates'][0];
	$this->_debug("D: total numsubordinates = " . $this->vlv_count);
	}
	else // ...or by fetching all records dn and count them
	$this->vlv_count = $this->_exec_search(true);

	$this->vlv_active = $this->_vlv_set_controls();
	}

	// only fetch dn for count (should keep the payload low)
	$attrs = $count ? array('dn') : array_values($this->fieldmap);
	if ($this->ldap_result = @$function($this->conn, $this->base_dn, $filter,
	$attrs, 0, (int)$this->prop['sizelimit'], (int)$this->prop['timelimit']))
	{
	$this->_debug("S: ".ldap_count_entries($this->conn, $this->ldap_result)." record(s)");
	if ($err = ldap_errno($this->conn))
	$this->_debug("S: Error: " .ldap_err2str($err));
	return true;
	}
	else
	{
	$this->_debug("S: ".ldap_error($this->conn));
	}
	}

	return false;
	}

	/**
	* Set server controls for Virtual List View (paginated listing)
	*/
	private function _vlv_set_controls()
	{
	$sort_ctrl = array('oid' => "1.2.840.113556.1.4.473", 'value' => $this->_sort_ber_encode((array)$this->prop['sort']));
	$vlv_ctrl = array('oid' => "2.16.840.1.113730.3.4.9", 'value' => $this->_vlv_ber_encode(($offset = ($this->list_page-1) * $this->page_size + 1), $this->page_size), 'iscritical' => true);

	$this->_debug("C: set controls sort=" . join(' ', unpack('H'.(strlen($sort_ctrl['value'])*2), $sort_ctrl['value'])) . " ({$this->sort_col});"
	. " vlv=" . join(' ', (unpack('H'.(strlen($vlv_ctrl['value'])*2), $vlv_ctrl['value']))) . " ($offset)");

	if (!ldap_set_option($this->conn, LDAP_OPT_SERVER_CONTROLS, array($sort_ctrl, $vlv_ctrl))) {
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SEARCH, 'vlvnotsupported');
	return false;
	}

	return true;
	}


	/**
	* Converts LDAP entry into an array
	*/
	private function _ldap2result($rec)
	{
	$out = array();

	if ($rec['dn'])
	$out[$this->primary_key] = base64_encode($rec['dn']);

	foreach ($this->fieldmap as $rf => $lf)
	{
	for ($i=0; $i < $rec[$lf]['count']; $i++) {
	if (!($value = $rec[$lf][$i]))
	continue;
	if ($rf == 'email' && $this->mail_domain && !strpos($value, '@'))
	$out[$rf][] = sprintf('%s@%s', $value, $this->mail_domain);
	else if (in_array($rf, array('street','zipcode','locality','country','region')))
	$out['address'][$i][$rf] = $value;
	else if ($rec[$lf]['count'] > 1)
	$out[$rf][] = $value;
	else
	$out[$rf] = $value;
	}
	}

	return $out;
	}


	/**
	* Return real field name (from fields map)
	*/
	private function _map_field($field)
	{
	return $this->fieldmap[$field];
	}


	/**
	* Returns unified attribute name (resolving aliases)
	*/
	private static function _attr_name($name)
	{
	// list of known attribute aliases
	$aliases = array(
	'gn' => 'givenname',
	'rfc822mailbox' => 'email',
	'userid' => 'uid',
	'emailaddress' => 'email',
	'pkcs9email' => 'email',
	);
	return isset($aliases[$name]) ? $aliases[$name] : $name;
	}


	/**
	* Prints debug info to the log
	*/
	private function _debug($str)
	{
	if ($this->debug)
	write_log('ldap', $str);
	}


	/**
	* Quotes attribute value string
	*
	* @param string $str Attribute value
	* @param bool $dn True if the attribute is a DN
	*
	* @return string Quoted string
	*/
	private static function _quote_string($str, $dn=false)
	{
	// take firt entry if array given
	if (is_array($str))
	$str = reset($str);

	if ($dn)
	$replace = array(','=>'\2c', '='=>'\3d', '+'=>'\2b', '<'=>'\3c',
	'>'=>'\3e', ';'=>'\3b', '\\'=>'\5c', '"'=>'\22', '#'=>'\23');
	else
	$replace = array('*'=>'\2a', '('=>'\28', ')'=>'\29', '\\'=>'\5c',
	'/'=>'\2f');

	return strtr($str, $replace);
	}


	/**
	* Setter for the current group
	* (empty, has to be re-implemented by extending class)
	*/
	function set_group($group_id)
	{
	if ($group_id)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$cache_members = $this->group_cache[$group_id]['members'];

	$members = array();
	for ($i=1; $i<$cache_members["count"]; $i++)
	{
	$members[base64_encode($cache_members[$i])] = 1;
	}
	$this->group_members = $members;
	$this->group_id = $group_id;
	}
	else
	$this->group_id = 0;
	}

	/**
	* 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)
	{
	global $RCMAIL;

	if (!$this->groups)
	return array();

	$this->groups_base_dn = ($this->prop['groups']['base_dn']) ?
	$this->prop['groups']['base_dn'] : $this->base_dn;

	// replace user specific dn
	if ($this->prop['user_specific'])
	{
	$fu = $RCMAIL->user->get_username();
	list($u, $d) = explode('@', $fu);
	$dc = 'dc='.strtr($d, array('.' => ',dc='));
	$replaces = array('%dc' => $dc, '%d' => $d, '%fu' => $fu, '%u' => $u);

	$this->groups_base_dn = strtr($this->groups_base_dn, $replaces);;
	}

	$base_dn = $this->groups_base_dn;
	$filter = $this->prop['groups']['filter'];

	$res = ldap_search($this->conn, $base_dn, $filter, array('cn','member'));
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return array();
	}
	$ldap_data = ldap_get_entries($this->conn, $res);

	$groups = array();
	$group_sortnames = array();
	for ($i=0; $i<$ldap_data["count"]; $i++)
	{
	$group_name = $ldap_data[$i]['cn'][0];
	$group_id = base64_encode($group_name);
	$groups[$group_id]['ID'] = $group_id;
	$groups[$group_id]['name'] = $group_name;
	$groups[$group_id]['members'] = $ldap_data[$i]['member'];
	$group_sortnames[] = strtolower($group_name);
	}
	array_multisort($group_sortnames, SORT_ASC, SORT_STRING, $groups);
	$this->group_cache = $groups;

	return $groups;
	}

	/**
	* 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($group_name)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$base_dn = $this->groups_base_dn;
	$new_dn = "cn=$group_name,$base_dn";
	$new_gid = base64_encode($group_name);

	$new_entry = array(
	'objectClass' => $this->prop['groups']['object_classes'],
	'cn' => $group_name,
	'member' => '',
	);

	$res = ldap_add($this->conn, $new_dn, $new_entry);
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	}
	return array('id' => $new_gid, 'name' => $group_name);
	}

	/**
	* 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($group_id)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$base_dn = $this->groups_base_dn;
	$group_name = $this->group_cache[$group_id]['name'];

	$del_dn = "cn=$group_name,$base_dn";
	$res = ldap_delete($this->conn, $del_dn);
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	}
	return true;
	}

	/**
	* 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($group_id, $new_name, &$new_gid)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$base_dn = $this->groups_base_dn;
	$group_name = $this->group_cache[$group_id]['name'];
	$old_dn = "cn=$group_name,$base_dn";
	$new_rdn = "cn=$new_name";
	$new_gid = base64_encode($new_name);

	$res = ldap_rename($this->conn, $old_dn, $new_rdn, NULL, TRUE);
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return false;
	}
	return $new_name;
	}

	/**
	* 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, $contact_ids)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$base_dn = $this->groups_base_dn;
	$group_name = $this->group_cache[$group_id]['name'];
	$group_dn = "cn=$group_name,$base_dn";

	$new_attrs = array();
	foreach (explode(",", $contact_ids) as $id)
	$new_attrs['member'][] = base64_decode($id);

	$res = ldap_mod_add($this->conn, $group_dn, $new_attrs);
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return 0;
	}
	return count($new_attrs['member']);
	}

	/**
	* 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, $contact_ids)
	{
	if (!$this->group_cache)
	$this->list_groups();

	$base_dn = $this->groups_base_dn;
	$group_name = $this->group_cache[$group_id]['name'];
	$group_dn = "cn=$group_name,$base_dn";

	$del_attrs = array();
	foreach (explode(",", $contact_ids) as $id)
	$del_attrs['member'][] = base64_decode($id);

	$res = ldap_mod_del($this->conn, $group_dn, $del_attrs);
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return 0;
	}
	return count($del_attrs['member']);
	}

	/**
	* 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($contact_id)
	{
	if (!$this->groups)
	return array();

	$base_dn = $this->groups_base_dn;
	$contact_dn = base64_decode($contact_id);
	$filter = "(member=$contact_dn)";

	$res = ldap_search($this->conn, $base_dn, $filter, array('cn'));
	if ($res === false)
	{
	$this->_debug("S: ".ldap_error($this->conn));
	$this->set_error(self::ERROR_SAVING, 'errorsaving');
	return array();
	}
	$ldap_data = ldap_get_entries($this->conn, $res);

	$groups = array();
	for ($i=0; $i<$ldap_data["count"]; $i++)
	{
	$group_name = $ldap_data[$i]['cn'][0];
	$group_id = base64_encode($group_name);
	$groups[$group_id] = $group_id;
	}
	return $groups;
	}


	/**
	* Generate BER encoded string for Virtual List View option
	*
	* @param integer List offset (first record)
	* @param integer Records per page
	* @return string BER encoded option value
	*/
	private function _vlv_ber_encode($offset, $rpp)
	{
	# this string is ber-encoded, php will prefix this value with:
	# 04 (octet string) and 10 (length of 16 bytes)
	# the code behind this string is broken down as follows:
	# 30 = ber sequence with a length of 0e (14) bytes following
	# 20 = type integer (in two's complement form) with 2 bytes following (beforeCount): 01 00 (ie 0)
	# 20 = type integer (in two's complement form) with 2 bytes following (afterCount): 01 18 (ie 25-1=24)
	# a0 = type context-specific/constructed with a length of 06 (6) bytes following
	# 20 = type integer with 2 bytes following (offset): 01 01 (ie 1)
	# 20 = type integer with 2 bytes following (contentCount): 01 00
	# the following info was taken from the ISO/IEC 8825-1:2003 x.690 standard re: the
	# encoding of integer values (note: these values are in
	# two-complement form so since offset will never be negative bit 8 of the
	# leftmost octet should never by set to 1):
	# 8.3.2: If the contents octets of an integer value encoding consist
	# of more than one octet, then the bits of the first octet (rightmost) and bit 8
	# of the second (to the left of first octet) octet:
	# a) shall not all be ones; and
	# b) shall not all be zero

	# construct the string from right to left
	$str = "020100"; # contentCount

	$ber_val = self::_ber_encode_int($offset); // returns encoded integer value in hex format

	// calculate octet length of $ber_val
	$str = self::_ber_addseq($ber_val, '02') . $str;

	// now compute length over $str
	$str = self::_ber_addseq($str, 'a0');

	// now tack on records per page
	$str = sprintf("0201000201%02x", min(255, $rpp)-1) . $str;

	// now tack on sequence identifier and length
	$str = self::_ber_addseq($str, '30');

	return pack('H'.strlen($str), $str);
	}


	/**
	* create ber encoding for sort control
	*
	* @pararm array List of cols to sort by
	* @return string BER encoded option value
	*/
	private function _sort_ber_encode($sortcols)
	{
	$str = '';
	foreach (array_reverse((array)$sortcols) as $col) {
	$ber_val = self::_string2hex($col);

	# 30 = ber sequence with a length of octet value
	# 04 = octet string with a length of the ascii value
	$oct = self::_ber_addseq($ber_val, '04');
	$str = self::_ber_addseq($oct, '30') . $str;
	}

	// now tack on sequence identifier and length
	$str = self::_ber_addseq($str, '30');

	return pack('H'.strlen($str), $str);
	}

	/**
	* Add BER sequence with correct length and the given identifier
	*/
	private static function _ber_addseq($str, $identifier)
	{
	$len = dechex(strlen($str)/2);
	if (strlen($len) % 2 != 0)
	$len = '0'.$len;

	return $identifier . $len . $str;
	}

	/**
	* Returns BER encoded integer value in hex format
	*/
	private static function _ber_encode_int($offset)
	{
	$val = dechex($offset);
	$prefix = '';

	// check if bit 8 of high byte is 1
	if (preg_match('/^[89abcdef]/', $val))
	$prefix = '00';

	if (strlen($val)%2 != 0)
	$prefix .= '0';

	return $prefix . $val;
	}

	/**
	* Returns ascii string encoded in hex
	*/
	private static function _string2hex($str) {
	$hex = '';
	for ($i=0; $i < strlen($str); $i++)
	$hex .= dechex(ord($str[$i]));
	return $hex;
	}

	}
	diff --git a/program/steps/addressbook/delete.inc b/program/steps/addressbook/delete.inc
	index f11752b70..b0b255e27 100644
	--- a/program/steps/addressbook/delete.inc
	+++ b/program/steps/addressbook/delete.inc
	@@ -1,162 +1,163 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/addressbook/delete.inc \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2009, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Delete the submitted contacts (CIDs) from the users address book \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/

	// process ajax requests only
	if (!$OUTPUT->ajax_call)
	return;

	$cids = rcmail_get_cids();
	$delcnt = 0;

	// remove previous deletes
	+$undo_time = $RCMAIL->config->get('undo_timeout', 0);
	$RCMAIL->session->remove('contact_undo');

	foreach ($cids as $source => $cid)
	{
	$CONTACTS = rcmail_contact_source($source);

	if ($CONTACTS->readonly) {
	// more sources? do nothing, probably we have search results from
	// more than one source, some of these sources can be readonly
	if (count($cids) == 1) {
	$OUTPUT->show_message('contactdelerror', 'error');
	$OUTPUT->command('list_contacts');
	$OUTPUT->send();
	}
	continue;
	}

	$plugin = $RCMAIL->plugins->exec_hook('contact_delete', array(
	'id' => $cid, 'source' => $source));

	- $deleted = !$plugin['abort'] ? $CONTACTS->delete($cid) : $plugin['result'];
	+ $deleted = !$plugin['abort'] ? $CONTACTS->delete($cid, $undo_time < 1) : $plugin['result'];

	if (!$deleted) {
	$OUTPUT->show_message($plugin['message'] ? $plugin['message'] : 'contactdelerror', 'error');
	$OUTPUT->command('list_contacts');
	$OUTPUT->send();
	}
	else {
	$delcnt += $deleted;

	- // store deleted contacts IDs in session for undelete
	- if ($CONTACTS->undelete) {
	+ // store deleted contacts IDs in session for undo action
	+ if ($undo_time > 0 && $CONTACTS->undelete) {
	$_SESSION['contact_undo']['data'][$source] = $cid;
	}
	}
	}

	$page = isset($_SESSION['page']) ? $_SESSION['page'] : 1;

	// update saved search after data changed
	if (($search_request = $_REQUEST['_search']) && isset($_SESSION['search'][$search_request])) {
	$search = (array)$_SESSION['search'][$search_request];
	$records = array();

	// Get records from all sources (refresh search)
	foreach ($search as $s => $set) {
	$source = $RCMAIL->get_address_book($s);

	// reset page
	$source->set_page(1);
	$source->set_pagesize(9999);
	$source->set_search_set($set);

	// get records
	$result = $source->list_records(array('name', 'email'));

	if (!$result->count) {
	unset($search[$s]);
	continue;
	}

	while ($row = $result->next()) {
	$row['sourceid'] = $s;
	$key = $row['name'] . ':' . $row['sourceid'];
	$records[$key] = $row;
	}
	unset($result);

	$search[$s] = $source->get_search_set();
	}

	$_SESSION['search'][$search_request] = $search;

	// create resultset object
	$count = count($records);
	$first = ($page-1) * $CONFIG['pagesize'];
	$result = new rcube_result_set($count, $first);

	// get records from the next page to add to the list
	$pages = ceil((count($records) + $delcnt) / $CONFIG['pagesize']);
	if ($_GET['_from'] != 'show' && $pages > 1 && $page < $pages) {
	// sort the records
	ksort($records, SORT_LOCALE_STRING);

	$first += $CONFIG['pagesize'];
	// create resultset object
	$res = new rcube_result_set($count, $first - $delcnt);

	if ($CONFIG['pagesize'] < $count) {
	$records = array_slice($records, $first - $delcnt, $delcnt);
	}

	$res->records = array_values($records);
	$records = $res;
	}
	else {
	unset($records);
	}
	}
	else {
	// count contacts for this user
	$result = $CONTACTS->count();

	// get records from the next page to add to the list
	$pages = ceil(($result->count + $delcnt) / $CONFIG['pagesize']);
	if ($_GET['_from'] != 'show' && $pages > 1 && $page < $pages) {
	$CONTACTS->set_page($page);
	$records = $CONTACTS->list_records(null, -$delcnt);
	}
	}

	// update message count display
	$OUTPUT->set_env('pagecount', ceil($result->count / $CONFIG['pagesize']));
	$OUTPUT->command('set_rowcount', rcmail_get_rowcount_text($result));

	if (!empty($_SESSION['contact_undo'])) {
	$_SESSION['contact_undo']['ts'] = time();
	$msg = html::span(null, rcube_label(array('name' => 'itemsdeleted', 'vars' => array('num' => $deleted))))
	. ' ' . html::a(array('onclick' => JS_OBJECT_NAME.".command('undo', '', this)"), rcube_label('undo'));

	- $OUTPUT->show_message($msg, 'confirmation', null, true, $RCMAIL->config->get('undo_timeout', 15));
	+ $OUTPUT->show_message($msg, 'confirmation', null, true, $undo_time);
	}
	else {
	$OUTPUT->show_message('contactdeleted', 'confirmation');
	}

	// add new rows from next page (if any)
	if (!empty($records)) {
	rcmail_js_contacts_list($records);
	}

	// send response
	$OUTPUT->send();
	diff --git a/program/steps/addressbook/func.inc b/program/steps/addressbook/func.inc
	index a895b617f..62c61ecd0 100644
	--- a/program/steps/addressbook/func.inc
	+++ b/program/steps/addressbook/func.inc
	@@ -1,728 +1,729 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/addressbook/func.inc \|
	\| \|
	\| This file is part of the Roundcube Webmail client \|
	\| Copyright (C) 2005-2007, The Roundcube Dev Team \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Provide addressbook functionality and GUI objects \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/

	$SEARCH_MODS_DEFAULT = array('name'=>1, 'firstname'=>1, 'surname'=>1, 'email'=>1, '*'=>1);

	// general definition of contact coltypes
	$CONTACT_COLTYPES = array(
	'name' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('name'), 'category' => 'main'),
	'firstname' => array('type' => 'text', 'size' => 19, 'limit' => 1, 'label' => rcube_label('firstname'), 'category' => 'main'),
	'surname' => array('type' => 'text', 'size' => 19, 'limit' => 1, 'label' => rcube_label('surname'), 'category' => 'main'),
	'email' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('email'), 'subtypes' => array('home','work','other'), 'category' => 'main'),
	'middlename' => array('type' => 'text', 'size' => 19, 'limit' => 1, 'label' => rcube_label('middlename'), 'category' => 'main'),
	'prefix' => array('type' => 'text', 'size' => 8, 'limit' => 1, 'label' => rcube_label('nameprefix'), 'category' => 'main'),
	'suffix' => array('type' => 'text', 'size' => 8, 'limit' => 1, 'label' => rcube_label('namesuffix'), 'category' => 'main'),
	'nickname' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('nickname'), 'category' => 'main'),
	'jobtitle' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('jobtitle'), 'category' => 'main'),
	'organization' => array('type' => 'text', 'size' => 19, 'limit' => 1, 'label' => rcube_label('organization'), 'category' => 'main'),
	'department' => array('type' => 'text', 'size' => 19, 'limit' => 1, 'label' => rcube_label('department'), 'category' => 'main'),
	'gender' => array('type' => 'select', 'limit' => 1, 'label' => rcube_label('gender'), 'options' => array('male' => rcube_label('male'), 'female' => rcube_label('female')), 'category' => 'personal'),
	'maidenname' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('maidenname'), 'category' => 'personal'),
	'phone' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('phone'), 'subtypes' => array('home','home2','work','work2','mobile','main','homefax','workfax','car','pager','video','assistant','other'), 'category' => 'main'),
	'address' => array('type' => 'composite', 'label' => rcube_label('address'), 'subtypes' => array('home','work','other'), 'childs' => array(
	'street' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('street'), 'category' => 'main'),
	'locality' => array('type' => 'text', 'size' => 28, 'label' => rcube_label('locality'), 'category' => 'main'),
	'zipcode' => array('type' => 'text', 'size' => 8, 'label' => rcube_label('zipcode'), 'category' => 'main'),
	'region' => array('type' => 'text', 'size' => 12, 'label' => rcube_label('region'), 'category' => 'main'),
	'country' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('country'), 'category' => 'main'),
	), 'category' => 'main'),
	'birthday' => array('type' => 'date', 'size' => 12, 'label' => rcube_label('birthday'), 'limit' => 1, 'render_func' => 'rcmail_format_date_col', 'category' => 'personal'),
	'anniversary' => array('type' => 'date', 'size' => 12, 'label' => rcube_label('anniversary'), 'limit' => 1, 'render_func' => 'rcmail_format_date_col', 'category' => 'personal'),
	'website' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('website'), 'subtypes' => array('homepage','work','blog','other'), 'category' => 'main'),
	'im' => array('type' => 'text', 'size' => 40, 'label' => rcube_label('instantmessenger'), 'subtypes' => array('aim','icq','msn','yahoo','jabber','skype','other'), 'category' => 'main'),
	'notes' => array('type' => 'textarea', 'size' => 40, 'rows' => 15, 'label' => rcube_label('notes'), 'limit' => 1),
	'photo' => array('type' => 'image', 'limit' => 1, 'category' => 'main'),
	'assistant' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('assistant'), 'category' => 'personal'),
	'manager' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('manager'), 'category' => 'personal'),
	'spouse' => array('type' => 'text', 'size' => 40, 'limit' => 1, 'label' => rcube_label('spouse'), 'category' => 'personal'),
	// TODO: define fields for vcards like GEO, KEY
	);


	// Addressbook UI
	if (!$RCMAIL->action && !$OUTPUT->ajax_call) {
	// add list of address sources to client env
	$js_list = $RCMAIL->get_address_sources();

	$source = get_input_value('_source', RCUBE_INPUT_GPC);

	// use first directory by default
	if (!strlen($source) \|\| !isset($js_list[$source]))
	$source = $js_list[key($js_list)]['id'];

	// count writeable sources
	$writeable = 0;
	foreach ($js_list as $s) {
	if (!$s['readonly']) {
	$writeable++;
	}
	}

	$search_mods = $RCMAIL->config->get('addressbook_search_mods', $SEARCH_MODS_DEFAULT);
	$OUTPUT->set_env('search_mods', $search_mods);
	$OUTPUT->set_env('address_sources', $js_list);
	$OUTPUT->set_env('writable_source', $writeable);

	$OUTPUT->set_pagetitle(rcube_label('addressbook'));
	$_SESSION['addressbooks_count'] = count($js_list);
	$_SESSION['addressbooks_count_writeable'] = $writeable;

	$CONTACTS = rcmail_contact_source($source, true);
	}

	// remove undo information...
	if ($undo = $_SESSION['contact_undo']) {
	- // ...after 30 seconds
	- if ($undo['ts'] < time() - 30)
	+ // ...after timeout
	+ $undo_time = $RCMAIL->config->get('undo_timeout', 0);
	+ if ($undo['ts'] < time() - $undo_time)
	$RCMAIL->session->remove('contact_undo');
	}

	// instantiate a contacts object according to the given source
	function rcmail_contact_source($source=null, $init_env=false)
	{
	global $RCMAIL, $OUTPUT, $CONFIG, $CONTACT_COLTYPES;

	if (!strlen($source)) {
	$source = get_input_value('_source', RCUBE_INPUT_GPC);
	}

	if (!strlen($source)) {
	return null;
	}

	// Get object
	$CONTACTS = $RCMAIL->get_address_book($source);
	$CONTACTS->set_pagesize($CONFIG['pagesize']);

	// set list properties and session vars
	if (!empty($_GET['_page']))
	$CONTACTS->set_page(($_SESSION['page'] = intval($_GET['_page'])));
	else
	$CONTACTS->set_page(isset($_SESSION['page']) ? $_SESSION['page'] : 1);

	if (!empty($_REQUEST['_gid']))
	$CONTACTS->set_group(get_input_value('_gid', RCUBE_INPUT_GPC));

	if (!$init_env)
	return $CONTACTS;

	$OUTPUT->set_env('readonly', $CONTACTS->readonly);
	$OUTPUT->set_env('source', $source);

	// reduce/extend $CONTACT_COLTYPES with specification from the current $CONTACT object
	if (is_array($CONTACTS->coltypes)) {
	// remove cols not listed by the backend class
	$contact_cols = $CONTACTS->coltypes[0] ? array_flip($CONTACTS->coltypes) : $CONTACTS->coltypes;
	$CONTACT_COLTYPES = array_intersect_key($CONTACT_COLTYPES, $contact_cols);
	// add associative coltypes definition
	if (!$CONTACTS->coltypes[0]) {
	foreach ($CONTACTS->coltypes as $col => $colprop)
	$CONTACT_COLTYPES[$col] = $CONTACT_COLTYPES[$col] ? array_merge($CONTACT_COLTYPES[$col], $colprop) : $colprop;
	}
	}

	$OUTPUT->set_env('photocol', is_array($CONTACT_COLTYPES['photo']));

	return $CONTACTS;
	}


	function rcmail_default_source($writable=false)
	{
	global $RCMAIL;

	// get list of address sources
	$list = $RCMAIL->get_address_sources($writable);

	// use first directory by default
	return $list[key($list)]['id'];
	}


	function rcmail_directory_list($attrib)
	{
	global $RCMAIL, $OUTPUT;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmdirectorylist';

	$out = '';
	$local_id = '0';
	$jsdata = array();

	$line_templ = html::tag('li', array(
	'id' => 'rcmli%s', 'class' => '%s'),
	html::a(array('href' => '%s',
	'rel' => '%s',
	'onclick' => "return ".JS_OBJECT_NAME.".command('list','%s',this)"), '%s'));

	$sources = (array) $OUTPUT->env['address_sources'];
	reset($sources);

	// currently selected source
	$current = get_input_value('_source', RCUBE_INPUT_GPC);
	if (!strlen($current) \|\| !isset($sources[$source]))
	$current = strval(key($sources));

	foreach ($sources as $j => $source) {
	$id = strval($source['id'] ? $source['id'] : $j);
	$js_id = JQ($id);

	// set class name(s)
	$class_name = 'addressbook';
	if ($current === $id)
	$class_name .= ' selected';
	if ($source['readonly'])
	$class_name .= ' readonly';
	if ($source['class_name'])
	$class_name .= ' ' . $source['class_name'];

	$out .= sprintf($line_templ,
	html_identifier($id),
	$class_name,
	Q(rcmail_url(null, array('_source' => $id))),
	$source['id'],
	$js_id, (!empty($source['name']) ? Q($source['name']) : Q($id)));

	$groupdata = array('out' => $out, 'jsdata' => $jsdata, 'source' => $id);
	if ($source['groups'])
	$groupdata = rcmail_contact_groups($groupdata);
	$jsdata = $groupdata['jsdata'];
	$out = $groupdata['out'];
	}

	$OUTPUT->set_env('contactgroups', $jsdata);
	$OUTPUT->add_gui_object('folderlist', $attrib['id']);

	return html::tag('ul', $attrib, $out, html::$common_attrib);
	}


	function rcmail_contact_groups($args)
	{
	global $RCMAIL;

	$groups = $RCMAIL->get_address_book($args['source'])->list_groups();

	if (!empty($groups)) {
	$line_templ = html::tag('li', array(
	'id' => 'rcmliG%s', 'class' => 'contactgroup'),
	html::a(array('href' => '#',
	'rel' => '%s:%s',
	'onclick' => "return ".JS_OBJECT_NAME.".command('listgroup',{'source':'%s','id':'%s'},this)"), '%s'));

	$jsdata = array();
	foreach ($groups as $group) {
	$args['out'] .= sprintf($line_templ,
	html_identifier($args['source'] . $group['ID']),
	$args['source'], $group['ID'],
	$args['source'], $group['ID'], Q($group['name'])
	);
	$args['jsdata']['G'.$args['source'].$group['ID']] = array(
	'source' => $args['source'], 'id' => $group['ID'],
	'name' => $group['name'], 'type' => 'group');
	}
	}

	return $args;
	}


	// return the message list as HTML table
	function rcmail_contacts_list($attrib)
	{
	global $CONTACTS, $OUTPUT;

	// define list of cols to be displayed
	$a_show_cols = array('name');

	// count contacts for this user
	$result = $CONTACTS->list_records($a_show_cols);

	// add id to message list table if not specified
	if (!strlen($attrib['id']))
	$attrib['id'] = 'rcmAddressList';

	// create XHTML table
	$out = rcube_table_output($attrib, $result->records, $a_show_cols, $CONTACTS->primary_key);

	// set client env
	$OUTPUT->add_gui_object('contactslist', $attrib['id']);
	$OUTPUT->set_env('current_page', (int)$CONTACTS->list_page);
	$OUTPUT->set_env('pagecount', ceil($result->count/$CONTACTS->page_size));
	$OUTPUT->include_script('list.js');

	// add some labels to client
	$OUTPUT->add_label('deletecontactconfirm');

	return $out;
	}


	function rcmail_js_contacts_list($result, $prefix='')
	{
	global $OUTPUT;

	if (empty($result) \|\| $result->count == 0)
	return;

	// define list of cols to be displayed
	$a_show_cols = array('name');

	while ($row = $result->next()) {
	$a_row_cols = array();

	// build contact ID with source ID
	if (isset($row['sourceid'])) {
	$row['ID'] = $row['ID'].'-'.$row['sourceid'];
	}

	// format each col
	foreach ($a_show_cols as $col)
	$a_row_cols[$col] = Q($row[$col]);

	$OUTPUT->command($prefix.'add_contact_row', $row['ID'], $a_row_cols);
	}
	}


	// similar function as /steps/settings/identities.inc::rcmail_identity_frame()
	function rcmail_contact_frame($attrib)
	{
	global $OUTPUT;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmcontactframe';

	$attrib['name'] = $attrib['id'];

	$OUTPUT->set_env('contentframe', $attrib['name']);
	$OUTPUT->set_env('blankpage', $attrib['src'] ? $OUTPUT->abs_url($attrib['src']) : 'program/blank.gif');

	return html::iframe($attrib);
	}


	function rcmail_rowcount_display($attrib)
	{
	global $OUTPUT;

	if (!$attrib['id'])
	$attrib['id'] = 'rcmcountdisplay';

	$OUTPUT->add_gui_object('countdisplay', $attrib['id']);

	return html::span($attrib, rcmail_get_rowcount_text());
	}


	function rcmail_get_rowcount_text($result=null)
	{
	global $CONTACTS, $CONFIG;

	// read nr of contacts
	if (!$result) {
	$result = $CONTACTS->get_result();
	}
	if (!$result) {
	$result = $CONTACTS->count();
	}

	if ($result->count == 0)
	$out = rcube_label('nocontactsfound');
	else
	$out = rcube_label(array(
	'name' => 'contactsfromto',
	'vars' => array(
	'from' => $result->first + 1,
	'to' => min($result->count, $result->first + $CONFIG['pagesize']),
	'count' => $result->count)
	));

	return $out;
	}


	function rcmail_get_type_label($type)
	{
	$label = 'type'.$type;
	if (rcube_label_exists($label))
	return rcube_label($label);
	else if (preg_match('/\w+(\d+)$/', $label, $m)
	&& ($label = preg_replace('/(\d+)$/', '', $label))
	&& rcube_label_exists($label))
	return rcube_label($label) . ' ' . $m[1];

	return ucfirst($type);
	}


	function rcmail_contact_form($form, $record, $attrib = null)
	{
	global $RCMAIL, $CONFIG;

	// Allow plugins to modify contact form content
	$plugin = $RCMAIL->plugins->exec_hook('contact_form', array(
	'form' => $form, 'record' => $record));

	$form = $plugin['form'];
	$record = $plugin['record'];
	$edit_mode = $RCMAIL->action != 'show';
	$del_button = $attrib['deleteicon'] ? html::img(array('src' => $CONFIG['skin_path'] . $attrib['deleteicon'], 'alt' => rcube_label('delete'))) : rcube_label('delete');
	unset($attrib['deleteicon']);
	$out = '';

	// get default coltypes
	$coltypes = $GLOBALS['CONTACT_COLTYPES'];
	$coltype_labels = array();

	foreach ($coltypes as $col => $prop) {
	if ($prop['subtypes']) {
	$subtype_names = array_map('rcmail_get_type_label', $prop['subtypes']);
	$select_subtype = new html_select(array('name' => '_subtype_'.$col.'[]', 'class' => 'contactselectsubtype'));
	$select_subtype->add($subtype_names, $prop['subtypes']);
	$coltypes[$col]['subtypes_select'] = $select_subtype->show();
	}
	if ($prop['childs']) {
	foreach ($prop['childs'] as $childcol => $cp)
	$coltype_labels[$childcol] = array('label' => $cp['label']);
	}
	}

	foreach ($form as $section => $fieldset) {
	// skip empty sections
	if (empty($fieldset['content']))
	continue;

	$select_add = new html_select(array('class' => 'addfieldmenu', 'rel' => $section));
	$select_add->add(rcube_label('addfield'), '');

	// render head section with name fields (not a regular list of rows)
	if ($section == 'head') {
	$content = '';

	// unset display name if it is composed from name parts (same composition function as in save.inc)
	if ($record['name'] == rcube_addressbook::compose_display_name(array('name' => '') + (array)$record))
	unset($record['name']);

	// group fields
	$field_blocks = array(
	'names' => array('prefix','firstname','middlename','surname','suffix'),
	'displayname' => array('name'),
	'nickname' => array('nickname'),
	'jobnames' => array('organization','department','jobtitle'),
	);
	foreach ($field_blocks as $blockname => $colnames) {
	$fields = '';
	foreach ($colnames as $col) {
	// skip cols unknown to the backend
	if (!$coltypes[$col])
	continue;

	// only string values are expected here
	if (is_array($record[$col]))
	$record[$col] = join(' ', $record[$col]);

	if ($RCMAIL->action == 'show') {
	if (!empty($record[$col]))
	$fields .= html::span('namefield ' . $col, Q($record[$col])) . " ";
	}
	else {
	$colprop = (array)$fieldset['content'][$col] + (array)$coltypes[$col];
	$colprop['id'] = 'ff_'.$col;
	if (empty($record[$col]) && !$colprop['visible']) {
	$colprop['style'] = 'display:none';
	$select_add->add($colprop['label'], $col);
	}
	$fields .= rcmail_get_edit_field($col, $record[$col], $colprop, $colprop['type']);
	}
	}
	$content .= html::div($blockname, $fields);
	}

	if ($edit_mode)
	$content .= html::p('addfield', $select_add->show(null));

	$out .= html::tag('fieldset', $attrib, (!empty($fieldset['name']) ? html::tag('legend', null, Q($fieldset['name'])) : '') . $content) ."\n";
	continue;
	}

	$content = '';
	if (is_array($fieldset['content'])) {
	foreach ($fieldset['content'] as $col => $colprop) {
	// remove subtype part of col name
	list($field, $subtype) = explode(':', $col);
	if (!$subtype) $subtype = 'home';
	$fullkey = $col.':'.$subtype;

	// skip cols unknown to the backend
	if (!$coltypes[$field])
	continue;

	// merge colprop with global coltype configuration
	$colprop += $coltypes[$field];
	$label = isset($colprop['label']) ? $colprop['label'] : rcube_label($col);

	// prepare subtype selector in edit mode
	if ($edit_mode && is_array($colprop['subtypes'])) {
	$subtype_names = array_map('rcmail_get_type_label', $colprop['subtypes']);
	$select_subtype = new html_select(array('name' => '_subtype_'.$col.'[]', 'class' => 'contactselectsubtype'));
	$select_subtype->add($subtype_names, $colprop['subtypes']);
	}
	else
	$select_subtype = null;

	if (!empty($colprop['value'])) {
	$values = (array)$colprop['value'];
	}
	else {
	// iterate over possible subtypes and collect values with their subtype
	if (is_array($colprop['subtypes'])) {
	$values = $subtypes = array();
	foreach ($colprop['subtypes'] as $i => $st) {
	$newval = false;
	if ($record[$field.':'.$st]) {
	$subtypes[count($values)] = $st;
	$newval = $record[$field.':'.$st];
	}
	else if ($i == 0 && $record[$field]) {
	$subtypes[count($values)] = $st;
	$newval = $record[$field];
	}
	if ($newval !== false) {
	if (is_array($newval) && isset($newval[0]))
	$values = array_merge($values, $newval);
	else
	$values[] = $newval;
	}
	}
	}
	else {
	$values = $record[$fullkey] ? $record[$fullkey] : $record[$field];
	$subtypes = null;
	}
	}

	// hack: create empty values array to force this field to be displayed
	if (empty($values) && $colprop['visible'])
	$values[] = '';

	$rows = '';
	foreach ((array)$values as $i => $val) {
	if ($subtypes[$i])
	$subtype = $subtypes[$i];

	// render composite field
	if ($colprop['type'] == 'composite') {
	$composite = array(); $j = 0;
	$template = $RCMAIL->config->get($col . '_template', '{'.join('} {', array_keys($colprop['childs'])).'}');
	foreach ($colprop['childs'] as $childcol => $cp) {
	$childvalue = $val[$childcol] ? $val[$childcol] : $val[$j];

	if ($edit_mode) {
	if ($colprop['subtypes'] \|\| $colprop['limit'] != 1) $cp['array'] = true;
	$composite['{'.$childcol.'}'] = rcmail_get_edit_field($childcol, $childvalue, $cp, $cp['type']) . " ";
	}
	else {
	$childval = $cp['render_func'] ? call_user_func($cp['render_func'], $childvalue, $childcol) : Q($childvalue);
	$composite['{'.$childcol.'}'] = html::span('data ' . $childcol, $childval) . " ";
	}
	$j++;
	}

	$coltypes[$field] += (array)$colprop;
	$coltypes[$field]['count']++;
	$val = strtr($template, $composite);
	}
	else if ($edit_mode) {
	// call callback to render/format value
	if ($colprop['render_func'])
	$val = call_user_func($colprop['render_func'], $val, $col);

	$coltypes[$field] = (array)$colprop + $coltypes[$field];

	if ($colprop['subtypes'] \|\| $colprop['limit'] != 1)
	$colprop['array'] = true;

	$val = rcmail_get_edit_field($col, $val, $colprop, $colprop['type']);
	$coltypes[$field]['count']++;
	}
	else if ($colprop['render_func'])
	$val = call_user_func($colprop['render_func'], $val, $col);
	else if (is_array($colprop['options']) && isset($colprop['options'][$val]))
	$val = $colprop['options'][$val];
	else
	$val = Q($val);

	// use subtype as label
	if ($colprop['subtypes'])
	$label = rcmail_get_type_label($subtype);

	// add delete button/link
	if ($edit_mode && !($colprop['visible'] && $colprop['limit'] == 1))
	$val .= html::a(array('href' => '#del', 'class' => 'contactfieldbutton deletebutton', 'title' => rcube_label('delete'), 'rel' => $col), $del_button);

	// display row with label
	if ($label) {
	$rows .= html::div('row',
	html::div('contactfieldlabel label', $select_subtype ? $select_subtype->show($subtype) : Q($label)) .
	html::div('contactfieldcontent '.$colprop['type'], $val));
	}
	else // row without label
	$rows .= html::div('row', html::div('contactfield', $val));
	}

	// add option to the add-field menu
	if (!$colprop['limit'] \|\| $coltypes[$field]['count'] < $colprop['limit']) {
	$select_add->add($colprop['label'], $col);
	$select_add->_count++;
	}

	// wrap rows in fieldgroup container
	$content .= html::tag('fieldset', array('class' => 'contactfieldgroup ' . ($colprop['subtypes'] ? 'contactfieldgroupmulti ' : '') . 'contactcontroller' . $col, 'style' => ($rows ? null : 'display:none')),
	($colprop['subtypes'] ? html::tag('legend', null, Q($colprop['label'])) : ' ') .
	$rows);
	}

	// also render add-field selector
	if ($edit_mode)
	$content .= html::p('addfield', $select_add->show(null, array('style' => $select_add->_count ? null : 'display:none')));

	$content = html::div(array('id' => 'contactsection' . $section), $content);
	}
	else {
	$content = $fieldset['content'];
	}

	$out .= html::tag('fieldset', null, html::tag('legend', null, Q($fieldset['name'])) . $content) ."\n";
	}

	if ($edit_mode) {
	$RCMAIL->output->set_env('coltypes', $coltypes + $coltype_labels);
	$RCMAIL->output->set_env('delbutton', $del_button);
	$RCMAIL->output->add_label('delete');
	}

	return $out;
	}


	function rcmail_contact_photo($attrib)
	{
	global $SOURCE_ID, $CONTACTS, $CONTACT_COLTYPES, $RCMAIL, $CONFIG;

	if (!$CONTACT_COLTYPES['photo'])
	return '';

	if ($result = $CONTACTS->get_result())
	$record = $result->first();

	$photo_img = $attrib['placeholder'] ? $CONFIG['skin_path'] . $attrib['placeholder'] : 'program/blank.gif';
	$RCMAIL->output->set_env('photo_placeholder', $photo_img);
	unset($attrib['placeholder']);

	if (strpos($record['photo'], 'http:') === 0)
	$photo_img = $record['photo'];
	else if ($record['photo'])
	$photo_img = $RCMAIL->url(array('_action' => 'photo', '_cid' => $record['ID'], '_source' => $SOURCE_ID));
	else
	$ff_value = '-del-'; // will disable delete-photo action

	$img = html::img(array('src' => $photo_img, 'border' => 1, 'alt' => ''));
	$content = html::div($attrib, $img);

	if ($RCMAIL->action == 'edit' \|\| $RCMAIL->action == 'add') {
	$RCMAIL->output->add_gui_object('contactphoto', $attrib['id']);
	$hidden = new html_hiddenfield(array('name' => '_photo', 'id' => 'ff_photo', 'value' => $ff_value));
	$content .= $hidden->show();
	}

	return $content;
	}


	function rcmail_format_date_col($val)
	{
	global $RCMAIL;
	return format_date($val, $RCMAIL->config->get('date_format', 'Y-m-d'));
	}


	/**
	* Returns contact ID(s) and source(s) from GET/POST data
	*
	* @return array List of contact IDs per-source
	*/
	function rcmail_get_cids()
	{
	// contact ID (or comma-separated list of IDs) is provided in two
	// forms. If _source is an empty string then the ID is a string
	// containing contact ID and source name in form: <ID>-<SOURCE>

	$cid = get_input_value('_cid', RCUBE_INPUT_GPC);
	$source = (string) get_input_value('_source', RCUBE_INPUT_GPC);

	if (!preg_match('/^[a-zA-Z0-9\+\/=_-]+(,[a-zA-Z0-9\+\/=_-]+)*$/', $cid)) {
	return array();
	}

	$cid = explode(',', $cid);
	$got_source = strlen($source);
	$result = array();

	// create per-source contact IDs array
	foreach ($cid as $id) {
	// if _source is not specified we'll find it from decoded ID
	if (!$got_source) {
	list ($c, $s) = explode('-', $id, 2);
	if (strlen($s)) {
	$result[(string)$s][] = $c;
	}
	}
	else {
	$result[$source][] = $id;
	}
	}

	return $result;
	}

	// register UI objects
	$OUTPUT->add_handlers(array(
	'directorylist' => 'rcmail_directory_list',
	// 'groupslist' => 'rcmail_contact_groups',
	'addresslist' => 'rcmail_contacts_list',
	'addressframe' => 'rcmail_contact_frame',
	'recordscountdisplay' => 'rcmail_rowcount_display',
	'searchform' => array($OUTPUT, 'search_form')
	));

	// register action aliases
	$RCMAIL->register_action_map(array(
	'add' => 'edit.inc',
	'photo' => 'show.inc',
	'upload-photo' => 'save.inc',
	'group-create' => 'groups.inc',
	'group-rename' => 'groups.inc',
	'group-delete' => 'groups.inc',
	'group-addmembers' => 'groups.inc',
	'group-delmembers' => 'groups.inc',
	));

File Metadata

Mime Type: text/x-diff
Expires: Mon, Sep 7, 11:27 AM (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1357627
Default Alt Text: (156 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions