No OneTemporary
Actions

Size

169 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CHANGELOG b/CHANGELOG
	index 2189aa630..c29db7066 100644
	--- a/CHANGELOG
	+++ b/CHANGELOG
	@@ -1,506 +1,507 @@
	CHANGELOG RoundCube Webmail
	===========================

	+- Fix Answered/Forwarded flag setting for messages in subfolders
	- Fix autocomplete problem with capital letters (#1485792)
	- Support UUencode content encoding (#1485839)
	- Minimize chance of race condition in session handling (#1485659, #1484678)
	- Fix session handling on non-session SQL query error (#1485734)
	- Fix html editor mode setting when reopening draft message (#1485834)
	- Added quick search box menu (#1484304)
	- Fix wrong column sort order icons (#1485823)
	- Updated TinyMCE to 3.2.3 version
	- Fix attachment names encoding when charset isn't specified in attachment part (#1484969)
	- Fix message normal priority problem (#1485820)
	- Fix autocomplete spinning wheel does not disappear (#1485804)
	- Added log_date_format option (#1485709)
	- Fix text wrapping in HTML editor after switching from plain text to HTML (#1485521)
	- Fix auto-complete function hangs with plus sign (#1485815)
	- Fix AJAX requests errors handler (#1485000)
	- Speed up message list displaying on IE
	- Fix read/write database recognition (#1485811)
	- Fix quicksearchbox look in Chrome and Konqueror (#1484841)
	- Fix UTF-8 byte-order mark removing (#1485514)
	- Fix folders subscribtions on Konqueror (#1484841)
	- Fix debug console on Konqueror and Safari
	- Fix messagelist focus issue when modifying status of selected messages (#1485807)
	- Support STARTTLS in IMAP connection (#1485284)
	- Fix DEL key problem in search boxes (#1485528)
	- Support several e-mail addresses per user from virtuser_file (#1485678)
	- Fix drag&drop with scrolling on IE (#1485786)
	- Fix adding signature separator in html mode (#1485350)
	- Fix opening attachment marks message as read (#1485803)
	- Fix 'temp_dir' does not support relative path under Windows (#1484529)
	- Fix "Initialize Database" button missing from installer (#1485802)
	- Fix compose window doesn't fit 1024x768 window (#1485396)
	- Fix service not available error when pressing back from compose dialog (#1485552)
	- Fix using mail() on Windows (#1485779)
	- Fix word wrapping in message-part's <PRE>s for printing (#1485787)
	- Fix incorrect word wrapping in outgoing plaintext multibyte messages (#1485714)
	- Fix double footer in HTML message with embedded images
	- Fix TNEF implementation bug (#1485773)
	- Fix incorrect row id parsing for LDAP contacts list (#1485784)
	- Fix 'mode' parameter in sqlite DSN (#1485772)

	RELEASE 0.2.1
	------------------
	- Use US-ASCII as failover when Unicode searching fails (#1485762)
	- Fix errors handling in IMAP command continuations (#1485762)
	- Fix FETCH result parsing for servers returning flags at the end of result (#1485763)
	- Fix datetime columns defaults in mysql's DDL (#1485641)
	- Fix attaching more than nine inline images (#1485759)
	- Support 'UNICODE-1-1-UTF-7' alias for UTF-7 encoding (#1485758)
	- Fix mime-type detection using a hard-coded map (#1485311)
	- Don't return empty string if charset conversion failed (#1485757)
	- Disable concurrent autocomplete query results display (#1485743)
	- Fix new lines stripped from message footer (#1485751)
	- Fix IE problem with mouse click autocomplete (#1485739)
	- Fix html body washing on reply/forward + fix attachments handling (#1485676)
	- Fix multiple recipients input parsing (#1485733)
	- Fix replying to message with html attachment (#1485676)
	- Use default_charset for messages without specified charset (#1485661, #1484961)
	- Support non-standard "GMT-XXXX" literal in date header (#1485729)
	- Added TNEF support to decode MS Outlook attachments (winmail.dat)
	- Fix "value continuation" MIME headers by adding required semicolon (#1485727)
	- Fix pressing select all/unread multiple times (#1485723)
	- Fix selecting all unread does not honor new messages (#1485724)
	- Fix some base64 encoded attachments handling (#1485725)
	- Support NGINX as IMAP backend: better BAD response handling (#1485720)
	- Performance fix: don't fetch attachment parts headers twice to parse filename
	- Fix checking for recent messages on various IMAP servers (#1485702)
	- Performance fix: Don't fetch quota and recent messages in "message view" mode
	- Fix displaying of alternative-inside-alternative messages (#1485713)
	- Fix MDNSent flag checking, use arbitrary keywords (asterisk) flag (#1485706)
	- Fix creation of folders with '&' sign in name
	- Fix parsing of email addresses without angle brackets (#1485693)
	- Save spellcheck corrections when switching from plain to html editor (and spellchecking is on)
	- Fix large search results on server without SORT capability (#1485668)
	- Get rid of preg_replace() with eval modifier and create_function usage (#1485686)
	- Bring back <base> and <link> tags in HTML messages
	- Fix XSS vulnerability through background attributes as reported by Julien Cayssol
	- Fix problems with backslash as IMAP hierarchy delimiter (#1484467)
	- Secure vcard export by getting rid of preg's 'e' modifier use (#1485689)
	- Fix authentication when submitting form with existing session (#1485679)
	- Allow absolute URLs to images in HTML messages/sigs (#1485666)
	- Fix message body which contains both inline attachments and emotions
	- Fix SQL query execution errors handling in rcube_mdb2 class (#1485509)
	- Fix address names with '@' sign handling (#1485654)
	- Improve messages display performance
	- Fix messages searching with 'to:' modifier

	RELEASE 0.2-STABLE
	------------------
	- Fix mark popup in IE 7 (#1485369)
	- Fix line-break issue when copy & paste in Firefox (#1485425)
	- Fix autocomplete "unknown server error" (#1485637)
	- Fix STARTTLS before AUTH in SMTP connection (#1484883)
	- Support multiple quota values in QUOTAROOT resonse (#1485626)
	- Only abbreviate file name for IE < 7 browsers (#1485063)
	- Performance: allow setting imap rootdir and delimiter before connect (#1485172)
	- Fix sorting of folders with more than 2 levels (#1485569)
	- Fix search results page jumps in LDAP addressbook (#1485253)
	- Fix empty line before the signature in IE (#1485351)
	- Fix horizontal scrollbar in preview pane on IE (#1484633)
	- Add Robots meta tag in login page and installer (#1484846)
	- Added 'show_images' option, removed 'addrbook_show_images' (#1485597)
	- Option to check for new mails in all folders (#1484374)
	- Don't set client busy when checking for new messages (#1485276)
	- Allow UTF-8 folder names in config (#1485579)
	- Add junk_mbox option configuration in installer (#1485579)
	- Do serverside addressbook queries for autocompletion (#1485531)
	- Allow setting attachment col position in 'list_cols' option
	- Allow override 'list_cols' via skin (#1485577)
	- Fix 'cache' table cleanup on session destroy (#1485516)
	- Increase speed of session destroy and garbage clean up
	- Fix session timeout when DB server got clock skew (#1485490)
	- Fix handling of some malformed messages (#1484438)
	- Speed up raw message body handling
	- Better HTML entities conversion in html2text (#1485519)
	- Fix big memory consumption and speed up searching on servers without SORT capability
	- Fix setting locale to tr_TR, ku and az_AZ (#1485470)
	- Use SORT for searching on servers with SORT capability
	- Added message status filter
	- Fix empty file sending (#1485389)
	- Improved searching with many criterias (calling one SEARCH command)
	- Fix HTML editor initialization on IE (#1485304)
	- Add warning when switching editor mode from html to plain (#1485488)
	- Make identities list scrollable (#1485538)
	- Fix problem with numeric folder names (#1485527)
	- Added BYE response simple support to prevent from endless loops in imap.inc (#1483956)
	- Fix unread message unintentionally marked as read if read_when_deleted=true (#1485409)
	- Remove port number from SERVER_NAME in smtp_helo_host (#1485518)
	- Don't send disposition notification receipts for messages marked as 'read' (#1485523)
	- Added 'keep_alive' and 'min_keep_alive' options (#1485360)
	- Added option 'identities_level', removed 'multiple_identities'
	- Allow deleting identities when multiple_identities=false (#1485435)
	- Added option focus_on_new_message (#1485374)
	- Fix html2text class autoloading on Windows (#1485505)
	- Fix html signature formatting when identity save error occured (#1485426)
	- Add feedback and set busy when moving folder (#1485497)
	- Fix 'Empty' link visibility for some languages e.g. Slovak (#1485489)
	- Fix messages count bar overlapping (#1485270)
	- Fix adding signature in drafts compose mode (#1485484)
	- Fix iil_C_Sort() to support very long and/or divided responses (#1485283)
	- Fix matching case sensitivity when setting identity on reply (#1485480)
	- Prefer default identity on reply
	- Fix imap searching on ISMail server (#1485466)
	- Add css class for flagged messages (#1485464)
	- Write username instead of id in sendmail log (#1485477)
	- Fix htmlspecialchars() use for PHP version < 5.2.3 (#1485475)
	- Fix js keywords escaping in json_serialize() for IE/Opera (#1485472)
	- Added bin/killcache.php script (#1485434)
	- Add support for SJIS, GB2312, BIG5 in rc_detect_encoding()
	- Fix vCard file encoding detection for non-UTF-8 strings (#1485410)
	- Add 'skip_deleted' option in User Preferences (#1485445)
	- Minimize "inline" javascript scripts use (#1485433)
	- Fix css class setting for folders with names matching defined classes names (#1485355)
	- Fix race conditions when changing mailbox
	- Fix spellchecking when switching to html editor (#1485362)
	- Fix compose window width/height (#1485396)
	- Allow calling msgimport.sh/msgexport.sh from any directory (#1485431)
	- Localized filesize units (#1485340)
	- Better handling of "no identity" and "no email in identity" situations (#1485117)
	- Added 'mime_param_folding' option with possibility to choose long/non-ascii attachment names encoding eg. to be readable in MS Outlook/OE (#1485320)
	- Added "advanced options" feature in User Preferences
	- Fix unread counter when displaying cached massage in preview panel (#1485290)
	- Fix htmleditor spellchecking on MS Windows (#1485397)
	- Fix problem with non-ascii attachment names in Mail_mime (#1485267, #1485096)
	- Fix language autodetection (#1485401)
	- Fix button label in folders management (#1485405)
	- Fix collapsed folder not indicating unread msgs count of all subfolders (#1485403)
	- Fix handling of apostrophes in filenames decoded according to rfc2231

	RELEASE 0.2-BETA
	----------------
	- Made config files location configurable (#1485215)
	- Reduced memory footprint when forwarding attachments (#1485345)
	- Allow and use spellcheck attribute for input/textarea fields (#1485060)
	- Added icons for forwarded/forwarded+replied messages (#1485257)
	- Added Reply-To to forwarded emails (#1485315)
	- Display progress message for folders create/delete/rename (#1485357)
	- Smart Tags and NOBR tag support in html messages (#1485363, #1485327)
	- Redesign of the identities settings (#1484042)
	- Add config option to disable creation/deletion of identities (#1484498)
	- Added 'sendmail_delay' option to restrict messages sending interval (#1484491)
	- Added vertical splitter for folders list resizing
	- Added possibility to view all headers in message view
	- Fixed splitter drag/resize on Opera (#1485170)
	- Fixed quota img height/width setting from template (#1484857)
	- Refactor drag & drop functionality. Don't rely on browser events anymore (#1484453)
	- Insert "virtual" folders in subscription list (#1484779)
	- Added link to open message in new window
	- Enable export of address book contacts as vCard
	- Add feature to import contacts from vcard files (#1326103)
	- Respect Content-Location headers in multipart/related messages according to RFC2110 (#1484946)
	- Allowed max. attachment size now indicated in compose screen (#1485030)
	- Also capture backspace key in list mode (#1484566)
	- Allow application/pgp parts to be displayed (#1484753)
	- Correctly handle options in mailto-links (#1485228)
	- Immediately save sort_col/sort_order in user prefs (#1485265)
	- Truncate very long (above 50 characters) attachment filenames when displaying
	- Allow to auto-detect client language if none set (#1484434)
	- Auto-detect the client timezone (user configurable)
	- Add RFC2231 header value continuations support for attachment filenames + hack for servers that not support that feature
	- Fix Reply-To header displaying (#1485314)
	- Mark form buttons that provide the most obvious operation (mainaction)
	- Added option 'quota_zero_as_unlimited' (#1484604)
	- Added PRE handling in html2text class (#1484740)
	- Added folder hierarchy collapsing
	- Added options to use syslog instead of log file (#1484850)
	- Added Logging & Debugging section in Installer
	- Fix In-Reply-To and References headers when composing saved draft message (#1485288)
	- Fix html message charset conversion for charsets with underline (#1485287)
	- Fix buttons status after contacts deletion (#1485233)
	- Fix escaping of To: and From: fields when building message body for reply or forward in the HTML editor (#1484904)
	- Use current mailbox name in template (#1485256)
	- Better fix for skipping untagged responses (#1485261)
	- Added pspell support patch by Kris Steinhoff (#1483960)
	- Enable spellchecker for HTML editor (#1485114)
	- Respect spellcheck_uri in tinyMCE spellchecker (#1484196)
	- Case insensitive contacts searching using PostgreSQL (#1485259)
	- Make default imap folders configurable for each user (#1485075)
	- Save outgoing mail to selectable folder (#1324581)
	- Fix hiding of mark menu when clicking th button again (#1484944)
	- Use long date format in print mode (#1485191)
	- Updated TinyMCE to version 3.1.0.1
	- Re-enable autocomplete attribute for login form (#1485211)
	- Check PERMANENTFLAGS before saving $MDNSent flag (#1484963, #1485163)
	- Added flag column on messages list (#1484623)
	- Patched Mail/MimePart.php (http://pear.php.net/bugs/bug.php?id=14232)
	- Allow trash/junk subfolders to be purged (#1485085)
	- Store compose parameters in session and redirect to a unique URL
	- Fixed CRAM-MD5 authentication (#1484819)
	- Fixed forwarding messages with one HTML attachment (#1484442)
	- Fixed encoding of message/rfc822 attachments and image/pjpeg handling (#1484914)
	- Added option to select skin in user preferences
	- Added option to configure displaying of attached images below the message body
	- Added option to display images in messages from known senders (#1484601)
	- User preferences grouped in more fieldsets
	- Fix corrupted MIME headers of messages in Sent folder (#1485111)
	- Fixed bug in MDB2 package: http://pear.php.net/bugs/bug.php?id=14124
	- Use keypress instead of keydown to select list's row (#1484816)
	- Don't call expunge and don't remove message row after message move if flag_for_deletion is set to true (#1485002)

	RELEASE 0.2-ALPHA
	-----------------
	- Added option to disable autocompletion from selected LDAP address books (#1484922)
	- TLS support in LDAP connections: 'use_tls' property (#1485104)
	- Fixed removing messages from search set after deleting them (#1485106)
	- imap.inc: Fixed iil_C_FetchStructureString() to handle many
	literal strings in response (#1484969)
	- Support for subfolders in default/protected folders (#1484665)
	- Disallowed delimiter in folder name (#1484803)
	- Support " and \ in folder names
	- Escape \ in login (#1484614)
	- Better HTML sanitization with the DOM-based washtml script (#1484701)
	- Fixed sorting of folders with non-ascii characters
	- Fixed Mysql DDL for default identities creation (#1485070)
	- In Preferences added possibility to configure 'read_when_deleted',
	'mdn_requests', 'flag_for_deletion' options
	- Made IMAP auth type configurable (#1483825)
	- Fixed empty values with FROM_UNIXTIME() in rcube_mdb2 (#1485055)
	- Fixed attachment list on IE 6/7 (#1484807)
	- Fixed JavaScript in compose.html that shows cc/bcc fields if populated
	- Make password input fields of type password in installer (#1484886)
	- Don't attempt to delete cache entries if enable_caching is FALSE (#1485051)
	- Optimized messages sorting on servers without sort capability (#1485049)
	- Corrected message headers decoding when charset isn't specified and improved
	support for native languages (#1485050, #1485048)
	- Expanded LDAP configuration options to support LDAP server writes.
	- Installer: encode special characters in DB username/password (#1485042)
	- Fixed management of folders with national characters in names (#1485036, #1485001)
	- Fixed identities saving when using MDB2 pgsql driver (#1485032)
	- Fixed BCC header reset (#1484997)
	- Improved messages list performance - patch from Justin Heesemann
	- Append skin_path to images location only when it starts with '/' sign (#1484859)
	- Fix IMAP response in message body when message has no body (#1484964)
	- Fixed non-RFC dates formatting (#1484901)
	- Fixed typo in set_charset() (#1484991)
	- Decode entities when inserting HTML signature to plain text message (#1484990)
	- HTML editing is now working with PHP5 updates and TinyMCE v3.0.6
	- Fixed signature loading on Windows (#1484545)
	- Added language support to HTML editing (#1484862)
	- Fixed remove signature when replying (#1333167)
	- Fixed problem with line with a space at the end (#1484916)
	- Fixed <!DOCTYPE> tag filtering (#1484391)
	- Fixed <?xml> tag filtering (#1484403)
	- Added sections (fieldset+label) in Settings interface
	- Mark as read in one action with message preview (#1484972)
	- Deleted redundant quota reads (#1484972)
	- Added options for empty trash and expunge inbox on logout (#1483863)
	- Removed lines wrapping when displaying message
	- Fixed month localization
	- Changed codebase to PHP5 with autoloader

	RELEASE 0.1.1
	-------------
	- Clear selection when selecting single item (#1484942)
	- Remove hard-coded image size in skin templates (#1484893)
	- Database schema improvements (dropped unnecessary indexes)
	- Fixed creating a new folder with a comma in its name (#1484681)
	- Fixed sorting of messages when default mailbox is empty (#1484317)
	- Improve message previewpane - less loading (#1484316)
	- Fixed login form autoompletion (#1484839)
	- Fixed virtuser_query option for mdb2 backend (#1484874)
	- Fixed attachment resoting from Drafts when message body was empty (#1484506)
	- Fixed usage of ob_gzhandler (#1484851)
	- Fixed message part window in IE6 (#1484610)
	- Fixed decoding of mime-encoded strings (#1484191)
	- Fixed some iconv/mb_string problems (#1484598)
	- Correctly quote mailbox name when using in URL (#1484313)
	- Fixed "headers already sent" errors (#1484860)

	RELEASE 0.1-STABLE
	------------------
	- Added interactive installer script
	- Fix folder adding/renaming inspired by #1484800
	- Localize folder name in page title (#1484785)
	- Fix code using wrong variable name (#1484018)
	- Allow to send mail with BCC recipients only
	- condense TinyMCE toolbar down to one line, removing table buttons (#1484747)
	- Add function to mark the selected messages as read/unread (#1457360)
	- Also do charset decoding as suggested in RFC 2231 (fix #1484321)
	- Show message count in folder list and hint when creating a subfolder
	- Distinguish ssl and tls for imap connections (#1484667)
	- Added some charset aliases to fix typical mis-labelling (#1484565)
	- Remember decision to display images for a certain message during session (#1484754)
	- Truncate attachment filenames to 55 characters due to an IE bug (#1484757)
	- Make sending of read receipts configurable
	- Respect config when localize folder names (#1484707)
	- Also respect receipt and priority settings when re-opening a draft message
	- Remember search results (closes #1483883), patch by the_glu
	- Add Received header on outgoing mail
	- Upgrade to TinyMCE 2.1.3
	- Allow inserting image attachments into HTML messages while composing (#1484557)
	- Implement Message-Disposition-Notification (Receipts)
	- Fix overriding of session vars when register_globals is on (#1484670)
	- Fix bug with case-sensitive folder names (#1484245)
	- Don't create default folders by default
	- Fixed some potential security risks (audited by Andris)
	- Only show new messages if they match the current search (#1484176)
	- Switch to/from when searcing in Sent folder (#1484555)
	- Correctly read the References header (#1484646)
	- Unset old cookie before sending a new value (#1484639)
	- Correctly decode attachments when downloading them (#1484645 and #1484642)
	- Suppress IE errors when clearing attachments form (#1484356)
	- Log error when login fails due to auto_create_user turned off
	- Filter linked/imported CSS files (closes #1484056)
	- Improve message compose screen (closes #1484383)
	- Select next row after removing one from list (#1484387)

	RELEASE 0.1-RC2
	---------------
	- Enable drag-&-dropping of folders to a new parent and allow to create subfolders (#1457344)
	- Suppress IE errors when clearing attachments form (#1484356)
	- Set preferences field in user table to NULL (#1484386)
	- Log error when login fails due to auto_create_user turned off
	- Filter linked/imported CSS files (closes #1484056)
	- Improve message compose screen (closes #1484383)
	- Select next row after removing one from list (#1484387)
	- Make smtp HELO/EHLO hostname configurable (#1484067)
	- IPv6 Compatability (#1484322), Patch #1484373
	- Unlock interface when message sending fails (#1484570)
	- Eval PHP code in template includes (if configured)
	- Show message when folder is empty. Mo more static text in table (#1484395)
	- Only display unread count in page title when new messages arrived
	- Fixed wrong delete button tooltip (#1483965)
	- Fixed charset encoding bug (#1484429)
	- Applied patch for LDAP version (#1484552)
	- Improved XHTML validation
	- Fix message list selection (#1484550)
	- Better fix lowercased usernames (#1484473)
	- Update pngbehavior Script as suggested in #1484490
	- Fixed moving/deleting messages when more than 1 is selected
	- Applied patch for LDAP contacts listing by Glen Ogilvie
	- Applied patch for more address fields in LDAP contacts (#1484402)
	- Add alternative for getallheaders() (fix #1484508)
	- Identify mailboxes case-sensitive
	- Sort mailbox list case-insensitive (closes #1484338)
	- Fix display of multipart messages from Apple Mail (closes #1484027)
	- Protect AJAX request from being fetched by a foreign site (XSS)
	- Make autocomplete for loginform configurable by the skin template
	- Fix compose function from address book (closes #1484426)
	- Added //IGNORE to iconv call (patch #1484420, closes #1484023)
	- Check if mbstring supports charset (#1484290 and #1484292)
	- Prefer iconv over mbstring (as suggested in #1484292)
	- Check filesize of template includes (#1484409)
	- Fixed bug with buttons not dimming/enabling properly after switching folders
	- Fixed compose window becoming unresponsive after saving a draft (#1484487)
	- Re-enabled "Back" button in compose window now that bug #1484487 is fixed
	- Fixed unresponsive interface issue when downloading attachments (#1484496)
	- Lowered status message time from 5 to 3 seconds to improve responsiveness
	- Raised .htaccess upload_max_filesize from 2M to 5M to differ from default php.ini
	- Increased "mailboxcontrols" mail.css width from 160 to 170px to fix non-english languages (#1484499)
	- Fix status message bug #1484464 with regard to #1484353
	- Fix address adding bug reported by David Koblas
	- Applied socket error patch by Thomas Mangin
	- Pass-by-reference workarround for PHP5 in sendmail.inc
	- Fixed buggy imap_root settings (closes #1484379)
	- Prevent default events on subject links (#1484399)
	- Use HTTP-POST requests for actions that change state

	RELEASE 0.1-RC1
	---------------
	- Use global filters and bind username/ for Ldap searches (#1484159)
	- Hide quota display if imap server does not support it
	- Hide address groups if no LDAP servers configured
	- Add link to message subjects (closes #1484257)
	- Better SQL query for contact listing/search (closes #1484369)
	- Fixed marking as read in preview pane (closes #1484364)
	- CSS hack to display attachments correctly in IE6
	- Wrap message body text (closes #1484148)
	- LDAP access is back in address book (closes #1484087)
	- Added search function for contacts
	- New Template parsing and output encoding
	- Fixed bugs #1484119 and #1483978
	- Fixed message moving procedure (closes #1484308)
	- Fixed display of multiple attachments (closes #1466563)
	- Fixed check for new messages (closes #1484310)
	- List attachments without filename
	- New session authentication: Change sessid cookie when login, authentication with sessauth cookie is now configurable.
	Should close bugs #1483951 and #1484299
	- Correctly translate mailbox names (closes #1484276)
	- Quote e-mail address links (closes #1484300)
	- Updated PEAR::Mail_mime package
	- Accept single quotes for HTML attributes when modifying message body (thanks Jason)
	- Sanitize input for new users/identities (thanks Colin Alston)
	- Don't download HTML message parts
	- Convert HTML parts to plaintext if 'prefer_html' is off
	- Correctly parse message/rfc822 parts (closes #1484045)
	- Also use user_id for unique key in messages table (closes #1484074)
	- Hide contacts drop down on blur (closes #1484203)
	- Make entries in contacts drop down clickable
	- Turn off browser autocompletion on login page
	- Quote <? in text/html message parts
	- Hide border around radio buttons
	- Applied patch for attachment download by crichardson (closes #1484198)
	- Fixed bug in Postgres DB handling (closes #1484068)
	- Fixed bug of invalid calls to fetchRow() in rcube_db.inc (closes #1484280)
	- Fixed array_merge bug (closes #1484281)
	- Fixed flag for deletion in list view (closes #1484264)
	- Finally support semicolons as recipient separator (closes ##1484251)
	- Fixed message headers (subject) encoding
	- check if safe mode is on or not (closes #1484269)
	- Show "no subject" in message list if subject is missing (closes #1484243)
	- Solved page caching of message preview (closes #1484153)
	- Only use gzip compression if configured (closes #1484236)
	- Fixed priority selector issue (#1484150)
	- Fixed some CSS issues in default skin (closes #1484210 and #1484161)
	- Prevent from double quoting of numeric HTML character references (closes #1484253)
	- Fixed display of HTML message attachments (closes #1484178)
	- Applied patch for preview caching (closes #1484186)
	- Added error handling for attachment uploads
	- Use multibyte safe string functions where necessary (closes #1483988)
	- Applied security patch to validate the submitted host value (by Kees Cook)
	- Applied security patch to validate input values when deleting contacts (by Kees Cook)
	- Applied security patch that sanitizes emoticon paths when attaching them (by Kees Cook)
	- Applied a patch to more aggressively sanitize a HTML message
	- Visualize blocked images in HTML messages
	- Fixed wrong message listing when showing search results (closes #1484131)
	- Show remote images when opening HTML message part as attachment
	- Improve memory usage when sending mail (closes #1484098)
	- Mark messages as read once the preview is loaded (closes #1484132)
	- Include smtp final response in log (closes #1484081)
	- Corrected date string in sent message header (closes #1484125)
	- Correclty choose "To" column in sent and draft mailboxes (closes #1483943)
	- Changed srong tooltips for message browse buttons (closes #1483930)
	- Fixed signature delimeter character to be standard (Bug #1484035)
	- Fixed XSS vulnerability (Bug #1484109)
	- Remove newlines from mail headers (Bug #1484031)
	- Selection issues when moving/deleting (Bug #1484044)
	- Applied patch of Clement Moulin for imap host auto-selection
	- ISO-encode IMAP password for plaintext login (Bugs #1483977 & #1483886)
	- Fixed folder name encoding in subscription list (Bug #1484113)
	- Fixed JS errors in identity list (Bug #1484120)
	- Translate foldernames in folder form (closes #1484113)
	- Added first and last buttons to message list, address book
	and message detail
	- Pressing Shift-Del bypasses Trash folder
	- Enable purge command for Junk folder
	- Fetch all aliases if virtuser_query is used instead
	- Re-enabled multi select of contacts (Bug #1484017)
	- Enable contact editing right after creation (Bug #1459641)
	- Correct UTF-7 to UTF-8 conversion if mbstring is not available
	- Fixed IMAP fetch of message body (Bug #1484019)
	- Fixed safe_mode problems (Bug #1418381)
	- Fixed wrong header encoding (Bug #1483976)
	- Made automatic draft saving configurable
	- Fixed JS bug when renaming folders (Bug #1483989)
	- Added quota display as image (by Brett Patterson)
	- Corrected creation of a message-id
	- New indentation for quoted message text
	- Improved HTML validity
	- Fixed URL character set (Ticket #1445501)
	- Fixed saving of contact into MySQL from LDAP query results (Ticket #1483820)
	- Fixed folder renaming: unsubscribe before rename (Bug #1483920)
	- Finalized new message parsing (+ chaching)
	- Fixed wrong usage of mbstring (Bug #1462439)
	- Set default spelling language (Ticket #1483938)
	- Added support for Nox Spell Server
	- Re-built message parsing (Bug #1327068)
	Now based on the message structure delivered by the IMAP server.
	- Fixed some XSS and SQL injection issues
	- Fixed charset problems with folder renaming




	diff --git a/program/include/rcube_imap.php b/program/include/rcube_imap.php
	index 6d44efb4b..67be40346 100644
	--- a/program/include/rcube_imap.php
	+++ b/program/include/rcube_imap.php
	@@ -1,3133 +1,3136 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/include/rcube_imap.php \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| IMAP wrapper that implements the Iloha IMAP Library (IIL) \|
	\| See http://ilohamail.org/ for details \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	/*
	* Obtain classes from the Iloha IMAP library
	*/
	require_once('lib/imap.inc');
	require_once('lib/mime.inc');
	require_once('lib/tnef_decoder.inc');


	/**
	* Interface class for accessing an IMAP server
	*
	* This is a wrapper that implements the Iloha IMAP Library (IIL)
	*
	* @package Mail
	* @author Thomas Bruederli <roundcube@gmail.com>
	* @version 1.40
	* @link http://ilohamail.org
	*/
	class rcube_imap
	{
	var $db;
	var $conn;
	var $root_ns = '';
	var $root_dir = '';
	var $mailbox = 'INBOX';
	var $list_page = 1;
	var $page_size = 10;
	var $sort_field = 'date';
	var $sort_order = 'DESC';
	var $delimiter = NULL;
	var $caching_enabled = FALSE;
	var $default_charset = 'ISO-8859-1';
	var $struct_charset = NULL;
	var $default_folders = array('INBOX');
	var $default_folders_lc = array('inbox');
	var $fetch_add_headers = '';
	var $cache = array();
	var $cache_keys = array();
	var $cache_changes = array();
	var $uid_id_map = array();
	var $msg_headers = array();
	var $skip_deleted = FALSE;
	var $search_set = NULL;
	var $search_string = '';
	var $search_charset = '';
	var $search_sort_field = '';
	var $debug_level = 1;
	var $error_code = 0;
	var $options = array('imap' => 'check');


	/**
	* Object constructor
	*
	* @param object DB Database connection
	*/
	function __construct($db_conn)
	{
	$this->db = $db_conn;
	}


	/**
	* Connect to an IMAP server
	*
	* @param string Host to connect
	* @param string Username for IMAP account
	* @param string Password for IMAP account
	* @param number Port to connect to
	* @param string SSL schema (either ssl or tls) or null if plain connection
	* @return boolean TRUE on success, FALSE on failure
	* @access public
	*/
	function connect($host, $user, $pass, $port=143, $use_ssl=null)
	{
	global $ICL_SSL, $ICL_PORT, $IMAP_USE_INTERNAL_DATE;

	// check for Open-SSL support in PHP build
	if ($use_ssl && extension_loaded('openssl'))
	$ICL_SSL = $use_ssl == 'imaps' ? 'ssl' : $use_ssl;
	else if ($use_ssl)
	{
	raise_error(array('code' => 403, 'type' => 'imap', 'file' => __FILE__,
	'message' => 'Open SSL not available;'), TRUE, FALSE);
	$port = 143;
	}

	$ICL_PORT = $port;
	$IMAP_USE_INTERNAL_DATE = false;

	$this->conn = iil_Connect($host, $user, $pass, $this->options);
	$this->host = $host;
	$this->user = $user;
	$this->pass = $pass;
	$this->port = $port;
	$this->ssl = $use_ssl;

	// print trace mesages
	if ($this->conn && ($this->debug_level & 8))
	console($this->conn->message);

	// write error log
	else if (!$this->conn && $GLOBALS['iil_error'])
	{
	$this->error_code = $GLOBALS['iil_errornum'];
	raise_error(array('code' => 403,
	'type' => 'imap',
	'message' => $GLOBALS['iil_error']), TRUE, FALSE);
	}

	// get server properties
	if ($this->conn)
	{
	if (!empty($this->conn->delimiter))
	$this->delimiter = $this->conn->delimiter;
	if (!empty($this->conn->rootdir))
	{
	$this->set_rootdir($this->conn->rootdir);
	$this->root_ns = preg_replace('/[.\/]$/', '', $this->conn->rootdir);
	}
	}

	return $this->conn ? TRUE : FALSE;
	}


	/**
	* Close IMAP connection
	* Usually done on script shutdown
	*
	* @access public
	*/
	function close()
	{
	if ($this->conn)
	iil_Close($this->conn);
	}


	/**
	* Close IMAP connection and re-connect
	* This is used to avoid some strange socket errors when talking to Courier IMAP
	*
	* @access public
	*/
	function reconnect()
	{
	$this->close();
	$this->connect($this->host, $this->user, $this->pass, $this->port, $this->ssl);

	// issue SELECT command to restore connection status
	if ($this->mailbox)
	iil_C_Select($this->conn, $this->mailbox);
	}

	/**
	* Set options to be used in iil_Connect()
	*/
	function set_options($opt)
	{
	$this->options = array_merge($this->options, (array)$opt);
	}

	/**
	* Set a root folder for the IMAP connection.
	*
	* Only folders within this root folder will be displayed
	* and all folder paths will be translated using this folder name
	*
	* @param string Root folder
	* @access public
	*/
	function set_rootdir($root)
	{
	if (preg_match('/[.\/]$/', $root)) //(substr($root, -1, 1)==='/')
	$root = substr($root, 0, -1);

	$this->root_dir = $root;
	$this->options['rootdir'] = $root;

	if (empty($this->delimiter))
	$this->get_hierarchy_delimiter();
	}


	/**
	* Set default message charset
	*
	* This will be used for message decoding if a charset specification is not available
	*
	* @param string Charset string
	* @access public
	*/
	function set_charset($cs)
	{
	$this->default_charset = $cs;
	}


	/**
	* This list of folders will be listed above all other folders
	*
	* @param array Indexed list of folder names
	* @access public
	*/
	function set_default_mailboxes($arr)
	{
	if (is_array($arr))
	{
	$this->default_folders = $arr;
	$this->default_folders_lc = array();

	// add inbox if not included
	if (!in_array_nocase('INBOX', $this->default_folders))
	array_unshift($this->default_folders, 'INBOX');

	// create a second list with lower cased names
	foreach ($this->default_folders as $mbox)
	$this->default_folders_lc[] = strtolower($mbox);
	}
	}


	/**
	* Set internal mailbox reference.
	*
	* All operations will be perfomed on this mailbox/folder
	*
	* @param string Mailbox/Folder name
	* @access public
	*/
	function set_mailbox($new_mbox)
	{
	$mailbox = $this->_mod_mailbox($new_mbox);

	if ($this->mailbox == $mailbox)
	return;

	$this->mailbox = $mailbox;

	// clear messagecount cache for this mailbox
	$this->_clear_messagecount($mailbox);
	}


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


	/**
	* Save a set of message ids for future message listing methods
	*
	* @param string IMAP Search query
	* @param array List of message ids or NULL if empty
	* @param string Charset of search string
	* @param string Sorting field
	*/
	function set_search_set($str=null, $msgs=null, $charset=null, $sort_field=null)
	{
	if (is_array($str) && $msgs == null)
	list($str, $msgs, $charset, $sort_field) = $str;
	if ($msgs != null && !is_array($msgs))
	$msgs = split(',', $msgs);

	$this->search_string = $str;
	$this->search_set = $msgs;
	$this->search_charset = $charset;
	$this->search_sort_field = $sort_field;
	}


	/**
	* Return the saved search set as hash array
	* @return array Search set
	*/
	function get_search_set()
	{
	return array($this->search_string, $this->search_set, $this->search_charset, $this->search_sort_field);
	}


	/**
	* Returns the currently used mailbox name
	*
	* @return string Name of the mailbox/folder
	* @access public
	*/
	function get_mailbox_name()
	{
	return $this->conn ? $this->_mod_mailbox($this->mailbox, 'out') : '';
	}


	/**
	* Returns the IMAP server's capability
	*
	* @param string Capability name
	* @return mixed Capability value or TRUE if supported, FALSE if not
	* @access public
	*/
	function get_capability($cap)
	{
	return iil_C_GetCapability($this->conn, strtoupper($cap));
	}


	/**
	* Checks the PERMANENTFLAGS capability of the current mailbox
	* and returns true if the given flag is supported by the IMAP server
	*
	* @param string Permanentflag name
	* @return mixed True if this flag is supported
	* @access public
	*/
	function check_permflag($flag)
	{
	$flag = strtoupper($flag);
	$imap_flag = $GLOBALS['IMAP_FLAGS'][$flag];
	return (in_array_nocase($imap_flag, $this->conn->permanentflags));
	}


	/**
	* Returns the delimiter that is used by the IMAP server for folder separation
	*
	* @return string Delimiter string
	* @access public
	*/
	function get_hierarchy_delimiter()
	{
	if ($this->conn && empty($this->delimiter))
	$this->delimiter = iil_C_GetHierarchyDelimiter($this->conn);

	if (empty($this->delimiter))
	$this->delimiter = '/';

	return $this->delimiter;
	}


	/**
	* Public method for mailbox listing.
	*
	* Converts mailbox name with root dir first
	*
	* @param string Optional root folder
	* @param string Optional filter for mailbox listing
	* @return array List of mailboxes/folders
	* @access public
	*/
	function list_mailboxes($root='', $filter='*')
	{
	$a_out = array();
	$a_mboxes = $this->_list_mailboxes($root, $filter);

	foreach ($a_mboxes as $mbox_row)
	{
	$name = $this->_mod_mailbox($mbox_row, 'out');
	if (strlen($name))
	$a_out[] = $name;
	}

	// INBOX should always be available
	if (!in_array_nocase('INBOX', $a_out))
	array_unshift($a_out, 'INBOX');

	// sort mailboxes
	$a_out = $this->_sort_mailbox_list($a_out);

	return $a_out;
	}


	/**
	* Private method for mailbox listing
	*
	* @return array List of mailboxes/folders
	* @see rcube_imap::list_mailboxes()
	* @access private
	*/
	function _list_mailboxes($root='', $filter='*')
	{
	$a_defaults = $a_out = array();

	// get cached folder list
	$a_mboxes = $this->get_cache('mailboxes');
	if (is_array($a_mboxes))
	return $a_mboxes;

	// Give plugins a chance to provide a list of mailboxes
	$data = rcmail::get_instance()->plugins->exec_hook('list_mailboxes',array('root'=>$root,'filter'=>$filter));
	if (isset($data['folders'])) {
	$a_folders = $data['folders'];
	}
	else{
	// retrieve list of folders from IMAP server
	$a_folders = iil_C_ListSubscribed($this->conn, $this->_mod_mailbox($root), $filter);
	}


	if (!is_array($a_folders) \|\| !sizeof($a_folders))
	$a_folders = array();

	// write mailboxlist to cache
	$this->update_cache('mailboxes', $a_folders);

	return $a_folders;
	}


	/**
	* Get message count for a specific mailbox
	*
	* @param string Mailbox/folder name
	* @param string Mode for count [ALL\|UNSEEN\|RECENT]
	* @param boolean Force reading from server and update cache
	* @return int Number of messages
	* @access public
	*/
	function messagecount($mbox_name='', $mode='ALL', $force=FALSE)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	return $this->_messagecount($mailbox, $mode, $force);
	}


	/**
	* Private method for getting nr of messages
	*
	* @access private
	* @see rcube_imap::messagecount()
	*/
	function _messagecount($mailbox='', $mode='ALL', $force=FALSE)
	{
	$a_mailbox_cache = FALSE;
	$mode = strtoupper($mode);

	if (empty($mailbox))
	$mailbox = $this->mailbox;

	// count search set
	if ($this->search_string && $mailbox == $this->mailbox && $mode == 'ALL' && !$force)
	return count((array)$this->search_set);

	$a_mailbox_cache = $this->get_cache('messagecount');

	// return cached value
	if (!$force && is_array($a_mailbox_cache[$mailbox]) && isset($a_mailbox_cache[$mailbox][$mode]))
	return $a_mailbox_cache[$mailbox][$mode];

	// RECENT count is fetched a bit different
	if ($mode == 'RECENT')
	$count = iil_C_CheckForRecent($this->conn, $mailbox);

	// use SEARCH for message counting
	else if ($this->skip_deleted)
	{
	$search_str = "ALL UNDELETED";

	// get message count and store in cache
	if ($mode == 'UNSEEN')
	$search_str .= " UNSEEN";

	// get message count using SEARCH
	// not very performant but more precise (using UNDELETED)
	$count = 0;
	$index = $this->_search_index($mailbox, $search_str);
	if (is_array($index))
	{
	$str = implode(",", $index);
	if (!empty($str))
	$count = count($index);
	}
	}
	else
	{
	if ($mode == 'UNSEEN')
	$count = iil_C_CountUnseen($this->conn, $mailbox);
	else
	$count = iil_C_CountMessages($this->conn, $mailbox);
	}

	if (!is_array($a_mailbox_cache[$mailbox]))
	$a_mailbox_cache[$mailbox] = array();

	$a_mailbox_cache[$mailbox][$mode] = (int)$count;

	// write back to cache
	$this->update_cache('messagecount', $a_mailbox_cache);

	return (int)$count;
	}


	/**
	* Public method for listing headers
	* convert mailbox name with root dir first
	*
	* @param string Mailbox/folder name
	* @param int Current page to list
	* @param string Header field to sort by
	* @param string Sort order [ASC\|DESC]
	* @return array Indexed array with message header objects
	* @access public
	*/
	function list_headers($mbox_name='', $page=NULL, $sort_field=NULL, $sort_order=NULL)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	return $this->_list_headers($mailbox, $page, $sort_field, $sort_order);
	}


	/**
	* Private method for listing message headers
	*
	* @access private
	* @see rcube_imap::list_headers
	*/
	function _list_headers($mailbox='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $recursive=FALSE)
	{
	if (!strlen($mailbox))
	return array();

	// use saved message set
	if ($this->search_string && $mailbox == $this->mailbox)
	return $this->_list_header_set($mailbox, $page, $sort_field, $sort_order);

	$this->_set_sort_order($sort_field, $sort_order);

	$max = $this->_messagecount($mailbox);
	$start_msg = ($this->list_page-1) * $this->page_size;

	list($begin, $end) = $this->_get_message_range($max, $page);

	// mailbox is empty
	if ($begin >= $end)
	return array();

	$headers_sorted = FALSE;
	$cache_key = $mailbox.'.msg';
	$cache_status = $this->check_cache_status($mailbox, $cache_key);

	// cache is OK, we can get all messages from local cache
	if ($cache_status>0)
	{
	$a_msg_headers = $this->get_message_cache($cache_key, $start_msg, $start_msg+$this->page_size, $this->sort_field, $this->sort_order);
	$headers_sorted = TRUE;
	}
	// cache is dirty, sync it
	else if ($this->caching_enabled && $cache_status==-1 && !$recursive)
	{
	$this->sync_header_index($mailbox);
	return $this->_list_headers($mailbox, $page, $this->sort_field, $this->sort_order, TRUE);
	}
	else
	{
	// retrieve headers from IMAP
	if ($this->get_capability('sort') && ($msg_index = iil_C_Sort($this->conn, $mailbox, $this->sort_field, $this->skip_deleted ? 'UNDELETED' : '')))
	{
	$mymsgidx = array_slice ($msg_index, $begin, $end-$begin);
	$msgs = join(",", $mymsgidx);
	}
	else
	{
	$msgs = sprintf("%d:%d", $begin+1, $end);
	$msg_index = range($begin, $end);
	}


	// fetch reuested headers from server
	$a_msg_headers = array();
	$deleted_count = $this->_fetch_headers($mailbox, $msgs, $a_msg_headers, $cache_key);

	// delete cached messages with a higher index than $max+1
	// Changed $max to $max+1 to fix this bug : #1484295
	$this->clear_message_cache($cache_key, $max + 1);

	// kick child process to sync cache
	// ...
	}

	// return empty array if no messages found
	if (!is_array($a_msg_headers) \|\| empty($a_msg_headers)) {
	return array();
	}

	// if not already sorted
	if (!$headers_sorted)
	{
	// use this class for message sorting
	$sorter = new rcube_header_sorter();
	$sorter->set_sequence_numbers($msg_index);
	$sorter->sort_headers($a_msg_headers);

	if ($this->sort_order == 'DESC')
	$a_msg_headers = array_reverse($a_msg_headers);
	}

	return array_values($a_msg_headers);
	}


	/**
	* Private method for listing a set of message headers (search results)
	*
	* @param string Mailbox/folder name
	* @param int Current page to list
	* @param string Header field to sort by
	* @param string Sort order [ASC\|DESC]
	* @return array Indexed array with message header objects
	* @access private
	* @see rcube_imap::list_header_set()
	*/
	function _list_header_set($mailbox, $page=NULL, $sort_field=NULL, $sort_order=NULL)
	{
	if (!strlen($mailbox) \|\| empty($this->search_set))
	return array();

	$msgs = $this->search_set;
	$a_msg_headers = array();
	$start_msg = ($this->list_page-1) * $this->page_size;

	$this->_set_sort_order($sort_field, $sort_order);

	// sorted messages, so we can first slice array and then fetch only wanted headers
	if ($this->get_capability('sort')) // SORT searching result
	{
	// reset search set if sorting field has been changed
	if ($this->sort_field && $this->search_sort_field != $this->sort_field)
	{
	$msgs = $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
	}

	// return empty array if no messages found
	if (empty($msgs))
	return array();

	if ($sort_order == 'DESC')
	$msgs = array_reverse($msgs);

	// get messages uids for one page
	$msgs = array_slice(array_values($msgs), $start_msg, min(count($msgs)-$start_msg, $this->page_size));

	// fetch headers
	$this->_fetch_headers($mailbox, join(',',$msgs), $a_msg_headers, NULL);

	$sorter = new rcube_header_sorter();
	$sorter->set_sequence_numbers($msgs);
	$sorter->sort_headers($a_msg_headers);

	return array_values($a_msg_headers);
	}
	else { // SEARCH searching result, need sorting
	$cnt = count($msgs);
	if ($cnt > 300 && $cnt > $this->page_size) { // experimantal value for best result
	// use memory less expensive (and quick) method for big result set
	$a_index = $this->message_index('', $this->sort_field, $this->sort_order);
	// get messages uids for one page...
	$msgs = array_slice($a_index, $start_msg, min($cnt-$start_msg, $this->page_size));
	// ...and fetch headers
	$this->_fetch_headers($mailbox, join(',', $msgs), $a_msg_headers, NULL);

	// return empty array if no messages found
	if (!is_array($a_msg_headers) \|\| empty($a_msg_headers))
	return array();

	$sorter = new rcube_header_sorter();
	$sorter->set_sequence_numbers($msgs);
	$sorter->sort_headers($a_msg_headers);

	return array_values($a_msg_headers);
	}
	else {
	// for small result set we can fetch all messages headers
	$this->_fetch_headers($mailbox, join(',', $msgs), $a_msg_headers, NULL);

	// return empty array if no messages found
	if (!is_array($a_msg_headers) \|\| empty($a_msg_headers))
	return array();

	// if not already sorted
	$a_msg_headers = iil_SortHeaders($a_msg_headers, $this->sort_field, $this->sort_order);

	// only return the requested part of the set
	return array_slice(array_values($a_msg_headers), $start_msg, min($cnt-$start_msg, $this->page_size));
	}
	}
	}


	/**
	* Helper function to get first and last index of the requested set
	*
	* @param int message count
	* @param mixed page number to show, or string 'all'
	* @return array array with two values: first index, last index
	* @access private
	*/
	function _get_message_range($max, $page)
	{
	$start_msg = ($this->list_page-1) * $this->page_size;

	if ($page=='all')
	{
	$begin = 0;
	$end = $max;
	}
	else if ($this->sort_order=='DESC')
	{
	$begin = $max - $this->page_size - $start_msg;
	$end = $max - $start_msg;
	}
	else
	{
	$begin = $start_msg;
	$end = $start_msg + $this->page_size;
	}

	if ($begin < 0) $begin = 0;
	if ($end < 0) $end = $max;
	if ($end > $max) $end = $max;

	return array($begin, $end);
	}



	/**
	* Fetches message headers
	* Used for loop
	*
	* @param string Mailbox name
	* @param string Message index to fetch
	* @param array Reference to message headers array
	* @param array Array with cache index
	* @return int Number of deleted messages
	* @access private
	*/
	function _fetch_headers($mailbox, $msgs, &$a_msg_headers, $cache_key)
	{
	// cache is incomplete
	$cache_index = $this->get_message_cache_index($cache_key);

	// fetch reuested headers from server
	$a_header_index = iil_C_FetchHeaders($this->conn, $mailbox, $msgs, false, $this->fetch_add_headers);
	$deleted_count = 0;

	if (!empty($a_header_index))
	{
	foreach ($a_header_index as $i => $headers)
	{
	if ($headers->deleted && $this->skip_deleted)
	{
	// delete from cache
	if ($cache_index[$headers->id] && $cache_index[$headers->id] == $headers->uid)
	$this->remove_message_cache($cache_key, $headers->uid);

	$deleted_count++;
	continue;
	}

	// add message to cache
	if ($this->caching_enabled && $cache_index[$headers->id] != $headers->uid)
	$this->add_message_cache($cache_key, $headers->id, $headers);

	$a_msg_headers[$headers->uid] = $headers;
	}
	}

	return $deleted_count;
	}


	/**
	* Return sorted array of message IDs (not UIDs)
	*
	* @param string Mailbox to get index from
	* @param string Sort column
	* @param string Sort order [ASC, DESC]
	* @return array Indexed array with message ids
	*/
	function message_index($mbox_name='', $sort_field=NULL, $sort_order=NULL)
	{
	$this->_set_sort_order($sort_field, $sort_order);

	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	$key = "{$mailbox}:{$this->sort_field}:{$this->sort_order}:{$this->search_string}.msgi";

	// we have a saved search result. get index from there
	if (!isset($this->cache[$key]) && $this->search_string && $mailbox == $this->mailbox)
	{
	$this->cache[$key] = array();

	if ($this->get_capability('sort'))
	{
	if ($this->sort_field && $this->search_sort_field != $this->sort_field)
	$this->search('', $this->search_string, $this->search_charset, $this->sort_field);

	if ($this->sort_order == 'DESC')
	$this->cache[$key] = array_reverse($this->search_set);
	else
	$this->cache[$key] = $this->search_set;
	}
	else
	{
	$a_index = iil_C_FetchHeaderIndex($this->conn, $mailbox, join(',', $this->search_set), $this->sort_field, false);

	if ($this->sort_order=="ASC")
	asort($a_index);
	else if ($this->sort_order=="DESC")
	arsort($a_index);

	$this->cache[$key] = array_keys($a_index);
	}
	}

	// have stored it in RAM
	if (isset($this->cache[$key]))
	return $this->cache[$key];

	// check local cache
	$cache_key = $mailbox.'.msg';
	$cache_status = $this->check_cache_status($mailbox, $cache_key);

	// cache is OK
	if ($cache_status>0)
	{
	$a_index = $this->get_message_cache_index($cache_key, TRUE, $this->sort_field, $this->sort_order);
	return array_keys($a_index);
	}

	// fetch complete message index
	$msg_count = $this->_messagecount($mailbox);
	if ($this->get_capability('sort') && ($a_index = iil_C_Sort($this->conn, $mailbox, $this->sort_field, '')))
	{
	if ($this->sort_order == 'DESC')
	$a_index = array_reverse($a_index);

	$this->cache[$key] = $a_index;
	}
	else
	{
	$a_index = iil_C_FetchHeaderIndex($this->conn, $mailbox, "1:$msg_count", $this->sort_field);

	if ($this->sort_order=="ASC")
	asort($a_index);
	else if ($this->sort_order=="DESC")
	arsort($a_index);

	$this->cache[$key] = array_keys($a_index);
	}

	return $this->cache[$key];
	}


	/**
	* @access private
	*/
	function sync_header_index($mailbox)
	{
	$cache_key = $mailbox.'.msg';
	$cache_index = $this->get_message_cache_index($cache_key);
	$msg_count = $this->_messagecount($mailbox);

	// fetch complete message index
	$a_message_index = iil_C_FetchHeaderIndex($this->conn, $mailbox, "1:$msg_count", 'UID');

	foreach ($a_message_index as $id => $uid)
	{
	// message in cache at correct position
	if ($cache_index[$id] == $uid)
	{
	unset($cache_index[$id]);
	continue;
	}

	// message in cache but in wrong position
	if (in_array((string)$uid, $cache_index, TRUE))
	{
	unset($cache_index[$id]);
	}

	// other message at this position
	if (isset($cache_index[$id]))
	{
	$this->remove_message_cache($cache_key, $cache_index[$id]);
	unset($cache_index[$id]);
	}


	// fetch complete headers and add to cache
	$headers = iil_C_FetchHeader($this->conn, $mailbox, $id, false, $this->fetch_add_headers);
	$this->add_message_cache($cache_key, $headers->id, $headers);
	}

	// those ids that are still in cache_index have been deleted
	if (!empty($cache_index))
	{
	foreach ($cache_index as $id => $uid)
	$this->remove_message_cache($cache_key, $uid);
	}
	}


	/**
	* Invoke search request to IMAP server
	*
	* @param string mailbox name to search in
	* @param string search string
	* @param string search string charset
	* @param string header field to sort by
	* @return array search results as list of message ids
	* @access public
	*/
	function search($mbox_name='', $str=NULL, $charset=NULL, $sort_field=NULL)
	{
	if (!$str)
	return false;

	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;

	$results = $this->_search_index($mailbox, $str, $charset, $sort_field);

	// try search with US-ASCII charset (should be supported by server)
	// only if UTF-8 search is not supported
	if (empty($results) && !is_array($results) && !empty($charset) && $charset!='US-ASCII')
	{
	// convert strings to US_ASCII
	if(preg_match_all('/\{([0-9]+)\}\r\n/', $str, $matches, PREG_OFFSET_CAPTURE))
	{
	$last = 0; $res = '';
	foreach($matches[1] as $m)
	{
	$string_offset = $m[1] + strlen($m[0]) + 4; // {}\r\n
	$string = substr($str, $string_offset - 1, $m[0]);
	$string = rcube_charset_convert($string, $charset, 'US-ASCII');
	if (!$string) continue;
	$res .= sprintf("%s{%d}\r\n%s", substr($str, $last, $m[1] - $last - 1), strlen($string), $string);
	$last = $m[0] + $string_offset - 1;
	}
	if ($last < strlen($str))
	$res .= substr($str, $last, strlen($str)-$last);
	}
	else // strings for conversion not found
	$res = $str;

	$results = $this->search($mbox_name, $res, 'US-ASCII', $sort_field);
	}

	$this->set_search_set($str, $results, $charset, $sort_field);

	return $results;
	}


	/**
	* Private search method
	*
	* @return array search results as list of message ids
	* @access private
	* @see rcube_imap::search()
	*/
	function _search_index($mailbox, $criteria='ALL', $charset=NULL, $sort_field=NULL)
	{
	if ($sort_field && $this->get_capability('sort'))
	{
	$charset = $charset ? $charset : $this->default_charset;
	$a_messages = iil_C_Sort($this->conn, $mailbox, $sort_field, $criteria, FALSE, $charset);
	}
	else
	$a_messages = iil_C_Search($this->conn, $mailbox, ($charset ? "CHARSET $charset " : '') . $criteria);

	// clean message list (there might be some empty entries)
	if (is_array($a_messages))
	{
	foreach ($a_messages as $i => $val)
	if (empty($val))
	unset($a_messages[$i]);
	}

	return $a_messages;
	}


	/**
	* Refresh saved search set
	*
	* @return array Current search set
	*/
	function refresh_search()
	{
	if (!empty($this->search_string))
	$this->search_set = $this->search('', $this->search_string, $this->search_charset, $this->search_sort_field);

	return $this->get_search_set();
	}


	/**
	* Check if the given message ID is part of the current search set
	*
	* @return boolean True on match or if no search request is stored
	*/
	function in_searchset($msgid)
	{
	if (!empty($this->search_string))
	return in_array("$msgid", (array)$this->search_set, true);
	else
	return true;
	}


	/**
	* Return message headers object of a specific message
	*
	* @param int Message ID
	* @param string Mailbox to read from
	* @param boolean True if $id is the message UID
	* @param boolean True if we need also BODYSTRUCTURE in headers
	* @return object Message headers representation
	*/
	function get_headers($id, $mbox_name=NULL, $is_uid=TRUE, $bodystr=FALSE)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	$uid = $is_uid ? $id : $this->_id2uid($id);

	// get cached headers
	if ($uid && ($headers = &$this->get_cached_message($mailbox.'.msg', $uid)))
	return $headers;

	$headers = iil_C_FetchHeader($this->conn, $mailbox, $id, $is_uid, $bodystr, $this->fetch_add_headers);

	// write headers cache
	if ($headers)
	{
	if ($headers->uid && $headers->id)
	$this->uid_id_map[$mailbox][$headers->uid] = $headers->id;

	$this->add_message_cache($mailbox.'.msg', $headers->id, $headers);
	}

	return $headers;
	}


	/**
	* Fetch body structure from the IMAP server and build
	* an object structure similar to the one generated by PEAR::Mail_mimeDecode
	*
	* @param int Message UID to fetch
	* @param string Message BODYSTRUCTURE string (optional)
	* @return object rcube_message_part Message part tree or False on failure
	*/
	function &get_structure($uid, $structure_str='')
	{
	$cache_key = $this->mailbox.'.msg';
	$headers = &$this->get_cached_message($cache_key, $uid, true);

	// return cached message structure
	if (is_object($headers) && is_object($headers->structure)) {
	return $headers->structure;
	}

	// resolve message sequence number
	if (!($msg_id = $this->_uid2id($uid))) {
	return FALSE;
	}

	if (!$structure_str)
	$structure_str = iil_C_FetchStructureString($this->conn, $this->mailbox, $msg_id);
	$structure = iml_GetRawStructureArray($structure_str);
	$struct = false;

	// parse structure and add headers
	if (!empty($structure))
	{
	$this->_msg_id = $msg_id;
	$headers = $this->get_headers($uid);

	// set message charset from message headers
	if ($headers->charset)
	$this->struct_charset = $headers->charset;
	else
	$this->struct_charset = $this->_structure_charset($structure);

	$struct = &$this->_structure_part($structure);
	$struct->headers = get_object_vars($headers);

	// don't trust given content-type
	if (empty($struct->parts) && !empty($struct->headers['ctype']))
	{
	$struct->mime_id = '1';
	$struct->mimetype = strtolower($struct->headers['ctype']);
	list($struct->ctype_primary, $struct->ctype_secondary) = explode('/', $struct->mimetype);
	}

	// write structure to cache
	if ($this->caching_enabled)
	$this->add_message_cache($cache_key, $msg_id, $headers, $struct);
	}

	return $struct;
	}


	/**
	* Build message part object
	*
	* @access private
	*/
	function &_structure_part($part, $count=0, $parent='', $raw_headers=null)
	{
	$struct = new rcube_message_part;
	$struct->mime_id = empty($parent) ? (string)$count : "$parent.$count";

	// multipart
	if (is_array($part[0]))
	{
	$struct->ctype_primary = 'multipart';

	// find first non-array entry
	for ($i=1; $i<count($part); $i++)
	if (!is_array($part[$i]))
	{
	$struct->ctype_secondary = strtolower($part[$i]);
	break;
	}

	$struct->mimetype = 'multipart/'.$struct->ctype_secondary;

	// build parts list for headers pre-fetching
	for ($i=0, $count=0; $i<count($part); $i++)
	if (is_array($part[$i]) && count($part[$i]) > 3)
	// fetch message headers if message/rfc822 or named part (could contain Content-Location header)
	if (strtolower($part[$i][0]) == 'message' \|\|
	(in_array('name', (array)$part[$i][2]) && (empty($part[$i][3]) \|\| $part[$i][3]=='NIL'))) {
	$part_headers[] = $struct->mime_id ? $struct->mime_id.'.'.$i+1 : $i+1;
	}

	// pre-fetch headers of all parts (in one command for better performance)
	if ($part_headers)
	$part_headers = iil_C_FetchMIMEHeaders($this->conn, $this->mailbox, $this->_msg_id, $part_headers);

	$struct->parts = array();
	for ($i=0, $count=0; $i<count($part); $i++)
	if (is_array($part[$i]) && count($part[$i]) > 3)
	$struct->parts[] = $this->_structure_part($part[$i], ++$count, $struct->mime_id,
	$part_headers[$struct->mime_id ? $struck->mime_id.'.'.$i+1 : $i+1]);

	return $struct;
	}


	// regular part
	$struct->ctype_primary = strtolower($part[0]);
	$struct->ctype_secondary = strtolower($part[1]);
	$struct->mimetype = $struct->ctype_primary.'/'.$struct->ctype_secondary;

	// read content type parameters
	if (is_array($part[2]))
	{
	$struct->ctype_parameters = array();
	for ($i=0; $i<count($part[2]); $i+=2)
	$struct->ctype_parameters[strtolower($part[2][$i])] = $part[2][$i+1];

	if (isset($struct->ctype_parameters['charset']))
	$struct->charset = $struct->ctype_parameters['charset'];
	}

	// read content encoding
	if (!empty($part[5]) && $part[5]!='NIL')
	{
	$struct->encoding = strtolower($part[5]);
	$struct->headers['content-transfer-encoding'] = $struct->encoding;
	}

	// get part size
	if (!empty($part[6]) && $part[6]!='NIL')
	$struct->size = intval($part[6]);

	// read part disposition
	$di = count($part) - 2;
	if ((is_array($part[$di]) && count($part[$di]) == 2 && is_array($part[$di][1])) \|\|
	(is_array($part[--$di]) && count($part[$di]) == 2))
	{
	$struct->disposition = strtolower($part[$di][0]);

	if (is_array($part[$di][1]))
	for ($n=0; $n<count($part[$di][1]); $n+=2)
	$struct->d_parameters[strtolower($part[$di][1][$n])] = $part[$di][1][$n+1];
	}

	// get child parts
	if (is_array($part[8]) && $di != 8)
	{
	$struct->parts = array();
	for ($i=0, $count=0; $i<count($part[8]); $i++)
	if (is_array($part[8][$i]) && count($part[8][$i]) > 5)
	$struct->parts[] = $this->_structure_part($part[8][$i], ++$count, $struct->mime_id);
	}

	// get part ID
	if (!empty($part[3]) && $part[3]!='NIL')
	{
	$struct->content_id = $part[3];
	$struct->headers['content-id'] = $part[3];

	if (empty($struct->disposition))
	$struct->disposition = 'inline';
	}

	// fetch message headers if message/rfc822 or named part (could contain Content-Location header)
	if ($struct->ctype_primary == 'message' \|\| ($struct->ctype_parameters['name'] && !$struct->content_id)) {
	if (empty($raw_headers))
	$raw_headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $this->_msg_id, $struct->mime_id);
	$struct->headers = $this->_parse_headers($raw_headers) + $struct->headers;
	}

	if ($struct->ctype_primary=='message') {
	if (is_array($part[8]) && empty($struct->parts))
	$struct->parts[] = $this->_structure_part($part[8], ++$count, $struct->mime_id);
	}

	// normalize filename property
	$this->_set_part_filename($struct, $raw_headers);

	return $struct;
	}


	/**
	* Set attachment filename from message part structure
	*
	* @access private
	* @param object rcube_message_part Part object
	* @param string Part's raw headers
	*/
	function _set_part_filename(&$part, $headers=null)
	{
	if (!empty($part->d_parameters['filename']))
	$filename_mime = $part->d_parameters['filename'];
	else if (!empty($part->d_parameters['filename*']))
	$filename_encoded = $part->d_parameters['filename*'];
	else if (!empty($part->ctype_parameters['name*']))
	$filename_encoded = $part->ctype_parameters['name*'];
	// RFC2231 value continuations
	// TODO: this should be rewrited to support RFC2231 4.1 combinations
	else if (!empty($part->d_parameters['filename*0'])) {
	$i = 0;
	while (isset($part->d_parameters['filename*'.$i])) {
	$filename_mime .= $part->d_parameters['filename*'.$i];
	$i++;
	}
	// some servers (eg. dovecot-1.x) have no support for parameter value continuations
	// we must fetch and parse headers "manually"
	if ($i<2) {
	if (!$headers)
	$headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $this->_msg_id, $part->mime_id);
	$filename_mime = '';
	$i = 0;
	while (preg_match('/filename\'.$i.'\s=\s"([^"\n;]+)[";]*/', $headers, $matches)) {
	$filename_mime .= $matches[1];
	$i++;
	}
	}
	}
	else if (!empty($part->d_parameters['filename0'])) {
	$i = 0;
	while (isset($part->d_parameters['filename'.$i.''])) {
	$filename_encoded .= $part->d_parameters['filename'.$i.''];
	$i++;
	}
	if ($i<2) {
	if (!$headers)
	$headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $this->_msg_id, $part->mime_id);
	$filename_encoded = '';
	$i = 0; $matches = array();
	while (preg_match('/filename\'.$i.'\\s=\s"([^"\n;]+)[";]/', $headers, $matches)) {
	$filename_encoded .= $matches[1];
	$i++;
	}
	}
	}
	else if (!empty($part->ctype_parameters['name*0'])) {
	$i = 0;
	while (isset($part->ctype_parameters['name*'.$i])) {
	$filename_mime .= $part->ctype_parameters['name*'.$i];
	$i++;
	}
	if ($i<2) {
	if (!$headers)
	$headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $this->_msg_id, $part->mime_id);
	$filename_mime = '';
	$i = 0; $matches = array();
	while (preg_match('/\s+name\'.$i.'\s=\s"([^"\n;]+)[";]*/', $headers, $matches)) {
	$filename_mime .= $matches[1];
	$i++;
	}
	}
	}
	else if (!empty($part->ctype_parameters['name0'])) {
	$i = 0;
	while (isset($part->ctype_parameters['name'.$i.''])) {
	$filename_encoded .= $part->ctype_parameters['name'.$i.''];
	$i++;
	}
	if ($i<2) {
	if (!$headers)
	$headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $this->_msg_id, $part->mime_id);
	$filename_encoded = '';
	$i = 0; $matches = array();
	while (preg_match('/\s+name\'.$i.'\\s=\s"([^"\n;]+)[";]/', $headers, $matches)) {
	$filename_encoded .= $matches[1];
	$i++;
	}
	}
	}
	// read 'name' after rfc2231 parameters as it may contains truncated filename (from Thunderbird)
	else if (!empty($part->ctype_parameters['name']))
	$filename_mime = $part->ctype_parameters['name'];
	// Content-Disposition
	else if (!empty($part->headers['content-description']))
	$filename_mime = $part->headers['content-description'];
	else
	return;

	// decode filename
	if (!empty($filename_mime)) {
	$part->filename = rcube_imap::decode_mime_string($filename_mime,
	$part->charset ? $part->charset : $this->struct_charset ? $this->struct_charset :
	rc_detect_encoding($filename_mime, $this->default_charset));
	}
	else if (!empty($filename_encoded)) {
	// decode filename according to RFC 2231, Section 4
	if (preg_match("/^([^'])'[^']'(.*)$/", $filename_encoded, $fmatches)) {
	$filename_charset = $fmatches[1];
	$filename_encoded = $fmatches[2];
	}
	$part->filename = rcube_charset_convert(urldecode($filename_encoded), $filename_charset);
	}
	}


	/**
	* Get charset name from message structure (first part)
	*
	* @access private
	* @param array Message structure
	* @return string Charset name
	*/
	function _structure_charset($structure)
	{
	while (is_array($structure)) {
	if (is_array($structure[2]) && $structure[2][0] == 'charset')
	return $structure[2][1];
	$structure = $structure[0];
	}
	}


	/**
	* Fetch message body of a specific message from the server
	*
	* @param int Message UID
	* @param string Part number
	* @param object rcube_message_part Part object created by get_structure()
	* @param mixed True to print part, ressource to write part contents in
	* @param resource File pointer to save the message part
	* @return string Message/part body if not printed
	*/
	function &get_message_part($uid, $part=1, $o_part=NULL, $print=NULL, $fp=NULL)
	{
	if (!($msg_id = $this->_uid2id($uid)))
	return FALSE;

	// get part encoding if not provided
	if (!is_object($o_part))
	{
	$structure_str = iil_C_FetchStructureString($this->conn, $this->mailbox, $msg_id);
	$structure = iml_GetRawStructureArray($structure_str);
	$part_type = iml_GetPartTypeCode($structure, $part);
	$o_part = new rcube_message_part;
	$o_part->ctype_primary = $part_type==0 ? 'text' : ($part_type==2 ? 'message' : 'other');
	$o_part->encoding = strtolower(iml_GetPartEncodingString($structure, $part));
	$o_part->charset = iml_GetPartCharset($structure, $part);
	}

	// TODO: Add caching for message parts

	if (!$part) $part = 'TEXT';

	$body = iil_C_HandlePartBody($this->conn, $this->mailbox, $msg_id, $part,
	$o_part->encoding, $print, $fp);

	if ($fp \|\| $print)
	return true;

	// convert charset (if text or message part)
	if ($o_part->ctype_primary=='text' \|\| $o_part->ctype_primary=='message') {
	// assume default if no charset specified
	if (empty($o_part->charset))
	$o_part->charset = $this->default_charset;

	$body = rcube_charset_convert($body, $o_part->charset);
	}

	return $body;
	}


	/**
	* Fetch message body of a specific message from the server
	*
	* @param int Message UID
	* @return string Message/part body
	* @see rcube_imap::get_message_part()
	*/
	function &get_body($uid, $part=1)
	{
	$headers = $this->get_headers($uid);
	return rcube_charset_convert($this->get_message_part($uid, $part, NULL),
	$headers->charset ? $headers->charset : $this->default_charset);
	}


	/**
	* Returns the whole message source as string
	*
	* @param int Message UID
	* @return string Message source string
	*/
	function &get_raw_body($uid)
	{
	if (!($msg_id = $this->_uid2id($uid)))
	return FALSE;

	return iil_C_HandlePartBody($this->conn, $this->mailbox, $msg_id);
	}


	/**
	* Returns the message headers as string
	*
	* @param int Message UID
	* @return string Message headers string
	*/
	function &get_raw_headers($uid)
	{
	if (!($msg_id = $this->_uid2id($uid)))
	return FALSE;

	$headers = iil_C_FetchPartHeader($this->conn, $this->mailbox, $msg_id, NULL);

	return $headers;
	}


	/**
	* Sends the whole message source to stdout
	*
	* @param int Message UID
	*/
	function print_raw_body($uid)
	{
	if (!($msg_id = $this->_uid2id($uid)))
	return FALSE;

	iil_C_HandlePartBody($this->conn, $this->mailbox, $msg_id, NULL, NULL, true);
	}


	/**
	* Set message flag to one or several messages
	*
	* @param mixed Message UIDs as array or as comma-separated string
	* @param string Flag to set: SEEN, UNDELETED, DELETED, RECENT, ANSWERED, DRAFT, MDNSENT
	+ * @param string Folder name
	* @return boolean True on success, False on failure
	*/
	- function set_flag($uids, $flag)
	+ function set_flag($uids, $flag, $mbox_name=NULL)
	{
	+ $mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	+
	$flag = strtoupper($flag);
	if (!is_array($uids))
	$uids = explode(',',$uids);

	if ($flag=='UNDELETED')
	- $result = iil_C_Undelete($this->conn, $this->mailbox, join(',', $uids));
	+ $result = iil_C_Undelete($this->conn, $mailbox, join(',', $uids));
	else if ($flag=='UNSEEN')
	- $result = iil_C_Unseen($this->conn, $this->mailbox, join(',', $uids));
	+ $result = iil_C_Unseen($this->conn, $mailbox, join(',', $uids));
	else if ($flag=='UNFLAGGED')
	- $result = iil_C_UnFlag($this->conn, $this->mailbox, join(',', $uids), 'FLAGGED');
	+ $result = iil_C_UnFlag($this->conn, $mailbox, join(',', $uids), 'FLAGGED');
	else
	- $result = iil_C_Flag($this->conn, $this->mailbox, join(',', $uids), $flag);
	+ $result = iil_C_Flag($this->conn, $mailbox, join(',', $uids), $flag);

	// reload message headers if cached
	- $cache_key = $this->mailbox.'.msg';
	+ $cache_key = $mailbox.'.msg';
	if ($this->caching_enabled)
	{
	foreach ($uids as $uid)
	if ($cached_headers = $this->get_cached_message($cache_key, $uid))
	$this->remove_message_cache($cache_key, $uid);

	// close and re-open connection
	// this prevents connection problems with Courier
	$this->reconnect();
	}

	// set nr of messages that were flaged
	$count = count($uids);

	// clear message count cache
	if ($result && $flag=='SEEN')
	- $this->_set_messagecount($this->mailbox, 'UNSEEN', $count*(-1));
	+ $this->_set_messagecount($mailbox, 'UNSEEN', $count*(-1));
	else if ($result && $flag=='UNSEEN')
	- $this->_set_messagecount($this->mailbox, 'UNSEEN', $count);
	+ $this->_set_messagecount($mailbox, 'UNSEEN', $count);
	else if ($result && $flag=='DELETED')
	- $this->_set_messagecount($this->mailbox, 'ALL', $count*(-1));
	+ $this->_set_messagecount($mailbox, 'ALL', $count*(-1));

	return $result;
	}


	/**
	* Append a mail message (source) to a specific mailbox
	*
	* @param string Target mailbox
	* @param string Message source
	* @return boolean True on success, False on error
	*/
	function save_message($mbox_name, &$message)
	{
	$mailbox = $this->_mod_mailbox($mbox_name);

	// make sure mailbox exists
	if (($mailbox == 'INBOX') \|\| in_array($mailbox, $this->_list_mailboxes()))
	$saved = iil_C_Append($this->conn, $mailbox, $message);

	if ($saved)
	{
	// increase messagecount of the target mailbox
	$this->_set_messagecount($mailbox, 'ALL', 1);
	}

	return $saved;
	}


	/**
	* Move a message from one mailbox to another
	*
	* @param string List of UIDs to move, separated by comma
	* @param string Target mailbox
	* @param string Source mailbox
	* @return boolean True on success, False on error
	*/
	function move_message($uids, $to_mbox, $from_mbox='')
	{
	$to_mbox = $this->_mod_mailbox($to_mbox);
	$from_mbox = $from_mbox ? $this->_mod_mailbox($from_mbox) : $this->mailbox;

	// make sure mailbox exists
	if ($to_mbox != 'INBOX' && !in_array($to_mbox, $this->_list_mailboxes()))
	{
	if (in_array($to_mbox_in, $this->default_folders))
	$this->create_mailbox($to_mbox_in, TRUE);
	else
	return FALSE;
	}

	// convert the list of uids to array
	$a_uids = is_string($uids) ? explode(',', $uids) : (is_array($uids) ? $uids : NULL);

	// exit if no message uids are specified
	if (!is_array($a_uids) \|\| empty($a_uids))
	return false;

	$iil_move = iil_C_Move($this->conn, join(',', $a_uids), $from_mbox, $to_mbox);
	$moved = !($iil_move === false \|\| $iil_move < 0);

	// send expunge command in order to have the moved message
	// really deleted from the source mailbox
	if ($moved) {
	// but only when flag_for_deletion is set to false
	if (!rcmail::get_instance()->config->get('flag_for_deletion', false))
	{
	$this->_expunge($from_mbox, FALSE);
	$this->_clear_messagecount($from_mbox);
	$this->_clear_messagecount($to_mbox);
	}
	}
	// moving failed
	else if (rcmail::get_instance()->config->get('delete_always', false)) {
	return iil_C_Delete($this->conn, $from_mbox, join(',', $a_uids));
	}

	// remove message ids from search set
	if ($moved && $this->search_set && $from_mbox == $this->mailbox) {
	foreach ($a_uids as $uid)
	$a_mids[] = $this->_uid2id($uid, $from_mbox);
	$this->search_set = array_diff($this->search_set, $a_mids);
	}
	// update cached message headers
	$cache_key = $from_mbox.'.msg';
	if ($moved && ($a_cache_index = $this->get_message_cache_index($cache_key)))
	{
	$start_index = 100000;
	foreach ($a_uids as $uid)
	{
	if (($index = array_search($uid, $a_cache_index)) !== FALSE)
	$start_index = min($index, $start_index);
	}

	// clear cache from the lowest index on
	$this->clear_message_cache($cache_key, $start_index);
	}

	return $moved;
	}


	/**
	* Mark messages as deleted and expunge mailbox
	*
	* @param string List of UIDs to move, separated by comma
	* @param string Source mailbox
	* @return boolean True on success, False on error
	*/
	function delete_message($uids, $mbox_name='')
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;

	// convert the list of uids to array
	$a_uids = is_string($uids) ? explode(',', $uids) : (is_array($uids) ? $uids : NULL);

	// exit if no message uids are specified
	if (!is_array($a_uids) \|\| empty($a_uids))
	return false;

	$deleted = iil_C_Delete($this->conn, $mailbox, join(',', $a_uids));

	// send expunge command in order to have the deleted message
	// really deleted from the mailbox
	if ($deleted)
	{
	$this->_expunge($mailbox, FALSE);
	$this->_clear_messagecount($mailbox);
	unset($this->uid_id_map[$mailbox]);
	}

	// remove message ids from search set
	if ($deleted && $this->search_set && $mailbox == $this->mailbox) {
	foreach ($a_uids as $uid)
	$a_mids[] = $this->_uid2id($uid, $mailbox);
	$this->search_set = array_diff($this->search_set, $a_mids);
	}

	// remove deleted messages from cache
	$cache_key = $mailbox.'.msg';
	if ($deleted && ($a_cache_index = $this->get_message_cache_index($cache_key)))
	{
	$start_index = 100000;
	foreach ($a_uids as $uid)
	{
	if (($index = array_search($uid, $a_cache_index)) !== FALSE)
	$start_index = min($index, $start_index);
	}

	// clear cache from the lowest index on
	$this->clear_message_cache($cache_key, $start_index);
	}

	return $deleted;
	}


	/**
	* Clear all messages in a specific mailbox
	*
	* @param string Mailbox name
	* @return int Above 0 on success
	*/
	function clear_mailbox($mbox_name=NULL)
	{
	$mailbox = !empty($mbox_name) ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	$msg_count = $this->_messagecount($mailbox, 'ALL');

	if ($msg_count>0)
	{
	$cleared = iil_C_ClearFolder($this->conn, $mailbox);

	// make sure the message count cache is cleared as well
	if ($cleared)
	{
	$this->clear_message_cache($mailbox.'.msg');
	$a_mailbox_cache = $this->get_cache('messagecount');
	unset($a_mailbox_cache[$mailbox]);
	$this->update_cache('messagecount', $a_mailbox_cache);
	}

	return $cleared;
	}
	else
	return 0;
	}


	/**
	* Send IMAP expunge command and clear cache
	*
	* @param string Mailbox name
	* @param boolean False if cache should not be cleared
	* @return boolean True on success
	*/
	function expunge($mbox_name='', $clear_cache=TRUE)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	return $this->_expunge($mailbox, $clear_cache);
	}


	/**
	* Send IMAP expunge command and clear cache
	*
	* @see rcube_imap::expunge()
	* @access private
	*/
	function _expunge($mailbox, $clear_cache=TRUE)
	{
	$result = iil_C_Expunge($this->conn, $mailbox);

	if ($result>=0 && $clear_cache)
	{
	$this->clear_message_cache($mailbox.'.msg');
	$this->_clear_messagecount($mailbox);
	}

	return $result;
	}


	/* --------------------------------
	* folder managment
	* --------------------------------*/


	/**
	* Get a list of all folders available on the IMAP server
	*
	* @param string IMAP root dir
	* @return array Indexed array with folder names
	*/
	function list_unsubscribed($root='')
	{
	static $sa_unsubscribed;

	if (is_array($sa_unsubscribed))
	return $sa_unsubscribed;

	// retrieve list of folders from IMAP server
	$a_mboxes = iil_C_ListMailboxes($this->conn, $this->_mod_mailbox($root), '*');

	// modify names with root dir
	foreach ($a_mboxes as $mbox_name)
	{
	$name = $this->_mod_mailbox($mbox_name, 'out');
	if (strlen($name))
	$a_folders[] = $name;
	}

	// filter folders and sort them
	$sa_unsubscribed = $this->_sort_mailbox_list($a_folders);
	return $sa_unsubscribed;
	}


	/**
	* Get mailbox quota information
	* added by Nuny
	*
	* @return mixed Quota info or False if not supported
	*/
	function get_quota()
	{
	if ($this->get_capability('QUOTA'))
	return iil_C_GetQuota($this->conn);

	return FALSE;
	}


	/**
	* Subscribe to a specific mailbox(es)
	*
	* @param array Mailbox name(s)
	* @return boolean True on success
	*/
	function subscribe($a_mboxes)
	{
	if (!is_array($a_mboxes))
	$a_mboxes = array($a_mboxes);

	// let this common function do the main work
	return $this->_change_subscription($a_mboxes, 'subscribe');
	}


	/**
	* Unsubscribe mailboxes
	*
	* @param array Mailbox name(s)
	* @return boolean True on success
	*/
	function unsubscribe($a_mboxes)
	{
	if (!is_array($a_mboxes))
	$a_mboxes = array($a_mboxes);

	// let this common function do the main work
	return $this->_change_subscription($a_mboxes, 'unsubscribe');
	}


	/**
	* Create a new mailbox on the server and register it in local cache
	*
	* @param string New mailbox name (as utf-7 string)
	* @param boolean True if the new mailbox should be subscribed
	* @param string Name of the created mailbox, false on error
	*/
	function create_mailbox($name, $subscribe=FALSE)
	{
	$result = FALSE;

	// reduce mailbox name to 100 chars
	$name = substr($name, 0, 100);

	$abs_name = $this->_mod_mailbox($name);
	$a_mailbox_cache = $this->get_cache('mailboxes');

	if (strlen($abs_name) && (!is_array($a_mailbox_cache) \|\| !in_array($abs_name, $a_mailbox_cache)))
	$result = iil_C_CreateFolder($this->conn, $abs_name);

	// try to subscribe it
	if ($result && $subscribe)
	$this->subscribe($name);

	return $result ? $name : FALSE;
	}


	/**
	* Set a new name to an existing mailbox
	*
	* @param string Mailbox to rename (as utf-7 string)
	* @param string New mailbox name (as utf-7 string)
	* @return string Name of the renames mailbox, False on error
	*/
	function rename_mailbox($mbox_name, $new_name)
	{
	$result = FALSE;

	// encode mailbox name and reduce it to 100 chars
	$name = substr($new_name, 0, 100);

	// make absolute path
	$mailbox = $this->_mod_mailbox($mbox_name);
	$abs_name = $this->_mod_mailbox($name);

	// check if mailbox is subscribed
	$a_subscribed = $this->_list_mailboxes();
	$subscribed = in_array($mailbox, $a_subscribed);

	// unsubscribe folder
	if ($subscribed)
	iil_C_UnSubscribe($this->conn, $mailbox);

	if (strlen($abs_name))
	$result = iil_C_RenameFolder($this->conn, $mailbox, $abs_name);

	if ($result)
	{
	$delm = $this->get_hierarchy_delimiter();

	// check if mailbox children are subscribed
	foreach ($a_subscribed as $c_subscribed)
	if (preg_match('/^'.preg_quote($mailbox.$delm, '/').'/', $c_subscribed))
	{
	iil_C_UnSubscribe($this->conn, $c_subscribed);
	iil_C_Subscribe($this->conn, preg_replace('/^'.preg_quote($mailbox, '/').'/', $abs_name, $c_subscribed));
	}

	// clear cache
	$this->clear_message_cache($mailbox.'.msg');
	$this->clear_cache('mailboxes');
	}

	// try to subscribe it
	if ($result && $subscribed)
	iil_C_Subscribe($this->conn, $abs_name);

	return $result ? $name : FALSE;
	}


	/**
	* Remove mailboxes from server
	*
	* @param string Mailbox name
	* @return boolean True on success
	*/
	function delete_mailbox($mbox_name)
	{
	$deleted = FALSE;

	if (is_array($mbox_name))
	$a_mboxes = $mbox_name;
	else if (is_string($mbox_name) && strlen($mbox_name))
	$a_mboxes = explode(',', $mbox_name);

	$all_mboxes = iil_C_ListMailboxes($this->conn, $this->_mod_mailbox($root), '*');

	if (is_array($a_mboxes))
	foreach ($a_mboxes as $mbox_name)
	{
	$mailbox = $this->_mod_mailbox($mbox_name);

	// unsubscribe mailbox before deleting
	iil_C_UnSubscribe($this->conn, $mailbox);

	// send delete command to server
	$result = iil_C_DeleteFolder($this->conn, $mailbox);
	if ($result>=0)
	$deleted = TRUE;

	foreach ($all_mboxes as $c_mbox)
	{
	$regex = preg_quote($mailbox . $this->delimiter, '/');
	$regex = '/^' . $regex . '/';
	if (preg_match($regex, $c_mbox))
	{
	iil_C_UnSubscribe($this->conn, $c_mbox);
	$result = iil_C_DeleteFolder($this->conn, $c_mbox);
	if ($result>=0)
	$deleted = TRUE;
	}
	}
	}

	// clear mailboxlist cache
	if ($deleted)
	{
	$this->clear_message_cache($mailbox.'.msg');
	$this->clear_cache('mailboxes');
	}

	return $deleted;
	}


	/**
	* Create all folders specified as default
	*/
	function create_default_folders()
	{
	$a_folders = iil_C_ListMailboxes($this->conn, $this->_mod_mailbox(''), '*');
	$a_subscribed = iil_C_ListSubscribed($this->conn, $this->_mod_mailbox(''), '*');

	// create default folders if they do not exist
	foreach ($this->default_folders as $folder)
	{
	$abs_name = $this->_mod_mailbox($folder);
	if (!in_array_nocase($abs_name, $a_folders))
	$this->create_mailbox($folder, TRUE);
	else if (!in_array_nocase($abs_name, $a_subscribed))
	$this->subscribe($folder);
	}
	}



	/* --------------------------------
	* internal caching methods
	* --------------------------------*/

	/**
	* @access private
	*/
	function set_caching($set)
	{
	if ($set && is_object($this->db))
	$this->caching_enabled = TRUE;
	else
	$this->caching_enabled = FALSE;
	}

	/**
	* @access private
	*/
	function get_cache($key)
	{
	// read cache
	if (!isset($this->cache[$key]) && $this->caching_enabled)
	{
	$cache_data = $this->_read_cache_record('IMAP.'.$key);
	$this->cache[$key] = strlen($cache_data) ? unserialize($cache_data) : FALSE;
	}

	return $this->cache[$key];
	}

	/**
	* @access private
	*/
	function update_cache($key, $data)
	{
	$this->cache[$key] = $data;
	$this->cache_changed = TRUE;
	$this->cache_changes[$key] = TRUE;
	}

	/**
	* @access private
	*/
	function write_cache()
	{
	if ($this->caching_enabled && $this->cache_changed)
	{
	foreach ($this->cache as $key => $data)
	{
	if ($this->cache_changes[$key])
	$this->_write_cache_record('IMAP.'.$key, serialize($data));
	}
	}
	}

	/**
	* @access private
	*/
	function clear_cache($key=NULL)
	{
	if (!$this->caching_enabled)
	return;

	if ($key===NULL)
	{
	foreach ($this->cache as $key => $data)
	$this->_clear_cache_record('IMAP.'.$key);

	$this->cache = array();
	$this->cache_changed = FALSE;
	$this->cache_changes = array();
	}
	else
	{
	$this->_clear_cache_record('IMAP.'.$key);
	$this->cache_changes[$key] = FALSE;
	unset($this->cache[$key]);
	}
	}

	/**
	* @access private
	*/
	function _read_cache_record($key)
	{
	$cache_data = FALSE;

	if ($this->db)
	{
	// get cached data from DB
	$sql_result = $this->db->query(
	"SELECT cache_id, data
	FROM ".get_table_name('cache')."
	WHERE user_id=?
	AND cache_key=?",
	$_SESSION['user_id'],
	$key);

	if ($sql_arr = $this->db->fetch_assoc($sql_result))
	{
	$cache_data = $sql_arr['data'];
	$this->cache_keys[$key] = $sql_arr['cache_id'];
	}
	}

	return $cache_data;
	}

	/**
	* @access private
	*/
	function _write_cache_record($key, $data)
	{
	if (!$this->db)
	return FALSE;

	// check if we already have a cache entry for this key
	if (!isset($this->cache_keys[$key]))
	{
	$sql_result = $this->db->query(
	"SELECT cache_id
	FROM ".get_table_name('cache')."
	WHERE user_id=?
	AND cache_key=?",
	$_SESSION['user_id'],
	$key);

	if ($sql_arr = $this->db->fetch_assoc($sql_result))
	$this->cache_keys[$key] = $sql_arr['cache_id'];
	else
	$this->cache_keys[$key] = FALSE;
	}

	// update existing cache record
	if ($this->cache_keys[$key])
	{
	$this->db->query(
	"UPDATE ".get_table_name('cache')."
	SET created=". $this->db->now().", data=?
	WHERE user_id=?
	AND cache_key=?",
	$data,
	$_SESSION['user_id'],
	$key);
	}
	// add new cache record
	else
	{
	$this->db->query(
	"INSERT INTO ".get_table_name('cache')."
	(created, user_id, cache_key, data)
	VALUES (".$this->db->now().", ?, ?, ?)",
	$_SESSION['user_id'],
	$key,
	$data);
	}
	}

	/**
	* @access private
	*/
	function _clear_cache_record($key)
	{
	$this->db->query(
	"DELETE FROM ".get_table_name('cache')."
	WHERE user_id=?
	AND cache_key=?",
	$_SESSION['user_id'],
	$key);
	}



	/* --------------------------------
	* message caching methods
	* --------------------------------*/


	/**
	* Checks if the cache is up-to-date
	*
	* @param string Mailbox name
	* @param string Internal cache key
	* @return int -3 = off, -2 = incomplete, -1 = dirty
	*/
	function check_cache_status($mailbox, $cache_key)
	{
	if (!$this->caching_enabled)
	return -3;

	$cache_index = $this->get_message_cache_index($cache_key, TRUE);
	$msg_count = $this->_messagecount($mailbox);
	$cache_count = count($cache_index);

	// console("Cache check: $msg_count !== ".count($cache_index));

	if ($cache_count==$msg_count)
	{
	// get highest index
	$header = iil_C_FetchHeader($this->conn, $mailbox, "$msg_count", false, $this->fetch_add_headers);
	$cache_uid = array_pop($cache_index);

	// uids of highest message matches -> cache seems OK
	if ($cache_uid == $header->uid)
	return 1;

	// cache is dirty
	return -1;
	}
	// if cache count differs less than 10% report as dirty
	else if (abs($msg_count - $cache_count) < $msg_count/10)
	return -1;
	else
	return -2;
	}

	/**
	* @access private
	*/
	function get_message_cache($key, $from, $to, $sort_field, $sort_order)
	{
	$cache_key = "$key:$from:$to:$sort_field:$sort_order";
	$db_header_fields = array('idx', 'uid', 'subject', 'from', 'to', 'cc', 'date', 'size');

	if (!in_array($sort_field, $db_header_fields))
	$sort_field = 'idx';

	if ($this->caching_enabled && !isset($this->cache[$cache_key]))
	{
	$this->cache[$cache_key] = array();
	$sql_result = $this->db->limitquery(
	"SELECT idx, uid, headers
	FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	ORDER BY ".$this->db->quoteIdentifier($sort_field)." ".
	strtoupper($sort_order),
	$from,
	$to-$from,
	$_SESSION['user_id'],
	$key);

	while ($sql_arr = $this->db->fetch_assoc($sql_result))
	{
	$uid = $sql_arr['uid'];
	$this->cache[$cache_key][$uid] = unserialize($sql_arr['headers']);

	// featch headers if unserialize failed
	if (empty($this->cache[$cache_key][$uid]))
	$this->cache[$cache_key][$uid] = iil_C_FetchHeader($this->conn, preg_replace('/.msg$/', '', $key), $uid, true, $this->fetch_add_headers);
	}
	}

	return $this->cache[$cache_key];
	}

	/**
	* @access private
	*/
	function &get_cached_message($key, $uid, $struct=false)
	{
	$internal_key = '__single_msg';

	if ($this->caching_enabled && (!isset($this->cache[$internal_key][$uid]) \|\|
	($struct && empty($this->cache[$internal_key][$uid]->structure))))
	{
	$sql_select = "idx, uid, headers" . ($struct ? ", structure" : '');
	$sql_result = $this->db->query(
	"SELECT $sql_select
	FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	AND uid=?",
	$_SESSION['user_id'],
	$key,
	$uid);

	if ($sql_arr = $this->db->fetch_assoc($sql_result))
	{
	$this->cache[$internal_key][$uid] = unserialize($sql_arr['headers']);
	if (is_object($this->cache[$internal_key][$uid]) && !empty($sql_arr['structure']))
	$this->cache[$internal_key][$uid]->structure = unserialize($sql_arr['structure']);
	}
	}

	return $this->cache[$internal_key][$uid];
	}

	/**
	* @access private
	*/
	function get_message_cache_index($key, $force=FALSE, $sort_field='idx', $sort_order='ASC')
	{
	static $sa_message_index = array();

	// empty key -> empty array
	if (!$this->caching_enabled \|\| empty($key))
	return array();

	if (!empty($sa_message_index[$key]) && !$force)
	return $sa_message_index[$key];

	$sa_message_index[$key] = array();
	$sql_result = $this->db->query(
	"SELECT idx, uid
	FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	ORDER BY ".$this->db->quote_identifier($sort_field)." ".$sort_order,
	$_SESSION['user_id'],
	$key);

	while ($sql_arr = $this->db->fetch_assoc($sql_result))
	$sa_message_index[$key][$sql_arr['idx']] = $sql_arr['uid'];

	return $sa_message_index[$key];
	}

	/**
	* @access private
	*/
	function add_message_cache($key, $index, $headers, $struct=null)
	{
	if (empty($key) \|\| !is_object($headers) \|\| empty($headers->uid))
	return;

	// add to internal (fast) cache
	$this->cache['__single_msg'][$headers->uid] = $headers;
	$this->cache['__single_msg'][$headers->uid]->structure = $struct;

	// no further caching
	if (!$this->caching_enabled)
	return;

	// check for an existing record (probly headers are cached but structure not)
	$sql_result = $this->db->query(
	"SELECT message_id
	FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	AND uid=?
	AND del<>1",
	$_SESSION['user_id'],
	$key,
	$headers->uid);

	// update cache record
	if ($sql_arr = $this->db->fetch_assoc($sql_result))
	{
	$this->db->query(
	"UPDATE ".get_table_name('messages')."
	SET idx=?, headers=?, structure=?
	WHERE message_id=?",
	$index,
	serialize($headers),
	is_object($struct) ? serialize($struct) : NULL,
	$sql_arr['message_id']
	);
	}
	else // insert new record
	{
	$this->db->query(
	"INSERT INTO ".get_table_name('messages')."
	(user_id, del, cache_key, created, idx, uid, subject, ".$this->db->quoteIdentifier('from').", ".$this->db->quoteIdentifier('to').", cc, date, size, headers, structure)
	VALUES (?, 0, ?, ".$this->db->now().", ?, ?, ?, ?, ?, ?, ".$this->db->fromunixtime($headers->timestamp).", ?, ?, ?)",
	$_SESSION['user_id'],
	$key,
	$index,
	$headers->uid,
	(string)substr($this->decode_header($headers->subject, TRUE), 0, 128),
	(string)substr($this->decode_header($headers->from, TRUE), 0, 128),
	(string)substr($this->decode_header($headers->to, TRUE), 0, 128),
	(string)substr($this->decode_header($headers->cc, TRUE), 0, 128),
	(int)$headers->size,
	serialize($headers),
	is_object($struct) ? serialize($struct) : NULL
	);
	}
	}

	/**
	* @access private
	*/
	function remove_message_cache($key, $uid)
	{
	if (!$this->caching_enabled)
	return;

	$this->db->query(
	"DELETE FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	AND uid=?",
	$_SESSION['user_id'],
	$key,
	$uid);
	}

	/**
	* @access private
	*/
	function clear_message_cache($key, $start_index=1)
	{
	if (!$this->caching_enabled)
	return;

	$this->db->query(
	"DELETE FROM ".get_table_name('messages')."
	WHERE user_id=?
	AND cache_key=?
	AND idx>=?",
	$_SESSION['user_id'],
	$key,
	$start_index);
	}




	/* --------------------------------
	* encoding/decoding methods
	* --------------------------------*/

	/**
	* Split an address list into a structured array list
	*
	* @param string Input string
	* @param int List only this number of addresses
	* @param boolean Decode address strings
	* @return array Indexed list of addresses
	*/
	function decode_address_list($input, $max=null, $decode=true)
	{
	$a = $this->_parse_address_list($input, $decode);
	$out = array();
	// Special chars as defined by RFC 822 need to in quoted string (or escaped).
	$special_chars = '[\<\>\\\.\[\]@,;:"]';

	if (!is_array($a))
	return $out;

	$c = count($a);
	$j = 0;

	foreach ($a as $val)
	{
	$j++;
	$address = $val['address'];
	$name = preg_replace(array('/^[\'"]/', '/[\'"]$/'), '', trim($val['name']));
	if ($name && $address && $name != $address)
	$string = sprintf('%s <%s>', preg_match("/$special_chars/", $name) ? '"'.addcslashes($name, '"').'"' : $name, $address);
	else if ($address)
	$string = $address;
	else if ($name)
	$string = $name;

	$out[$j] = array('name' => $name,
	'mailto' => $address,
	'string' => $string);

	if ($max && $j==$max)
	break;
	}

	return $out;
	}


	/**
	* Decode a Microsoft Outlook TNEF part (winmail.dat)
	*
	* @param object rcube_message_part Message part to decode
	* @param string UID of the message
	* @return array List of rcube_message_parts extracted from windmail.dat
	*/
	function tnef_decode(&$part, $uid)
	{
	if (!isset($part->body))
	$part->body = $this->get_message_part($uid, $part->mime_id, $part);

	$pid = 0;
	$tnef_parts = array();
	$tnef_arr = tnef_decode($part->body);
	foreach ($tnef_arr as $winatt) {
	$tpart = new rcube_message_part;
	$tpart->filename = $winatt["name"];
	$tpart->encoding = 'stream';
	$tpart->ctype_primary = $winatt["type0"];
	$tpart->ctype_secondary = $winatt["type1"];
	$tpart->mimetype = strtolower($winatt["type0"] . "/" . $winatt["type1"]);
	$tpart->mime_id = "winmail." . $part->mime_id . ".$pid";
	$tpart->size = $winatt["size"];
	$tpart->body = $winatt['stream'];

	$tnef_parts[] = $tpart;
	$pid++;
	}

	return $tnef_parts;
	}


	/**
	* Decode a message header value
	*
	* @param string Header value
	* @param boolean Remove quotes if necessary
	* @return string Decoded string
	*/
	function decode_header($input, $remove_quotes=FALSE)
	{
	$str = rcube_imap::decode_mime_string((string)$input, $this->default_charset);
	if ($str{0}=='"' && $remove_quotes)
	$str = str_replace('"', '', $str);

	return $str;
	}


	/**
	* Decode a mime-encoded string to internal charset
	*
	* @param string $input Header value
	* @param string $fallback Fallback charset if none specified
	*
	* @return string Decoded string
	* @static
	*/
	public static function decode_mime_string($input, $fallback=null)
	{
	// Initialize variable
	$out = '';

	// Iterate instead of recursing, this way if there are too many values we don't have stack overflows
	// rfc: all line breaks or other characters not found
	// in the Base64 Alphabet must be ignored by decoding software
	// delete all blanks between MIME-lines, differently we can
	// receive unnecessary blanks and broken utf-8 symbols
	$input = preg_replace("/\?=\s+=\?/", '?==?', $input);

	// Check if there is stuff to decode
	if (strpos($input, '=?') !== false) {
	// Loop through the string to decode all occurences of =? ?= into the variable $out
	while(($pos = strpos($input, '=?')) !== false) {
	// Append everything that is before the text to be decoded
	$out .= substr($input, 0, $pos);

	// Get the location of the text to decode
	$end_cs_pos = strpos($input, "?", $pos+2);
	$end_en_pos = strpos($input, "?", $end_cs_pos+1);
	$end_pos = strpos($input, "?=", $end_en_pos+1);

	// Extract the encoded string
	$encstr = substr($input, $pos+2, ($end_pos-$pos-2));
	// Extract the remaining string
	$input = substr($input, $end_pos+2);

	// Decode the string fragement
	$out .= rcube_imap::_decode_mime_string_part($encstr);
	}

	// Deocde the rest (if any)
	if (strlen($input) != 0)
	$out .= rcube_imap::decode_mime_string($input, $fallback);

	// return the results
	return $out;
	}

	// no encoding information, use fallback
	return rcube_charset_convert($input,
	!empty($fallback) ? $fallback : rcmail::get_instance()->config->get('default_charset', 'ISO-8859-1'));
	}


	/**
	* Decode a part of a mime-encoded string
	*
	* @access private
	*/
	function _decode_mime_string_part($str)
	{
	$a = explode('?', $str);
	$count = count($a);

	// should be in format "charset?encoding?base64_string"
	if ($count >= 3)
	{
	for ($i=2; $i<$count; $i++)
	$rest.=$a[$i];

	if (($a[1]=="B")\|\|($a[1]=="b"))
	$rest = base64_decode($rest);
	else if (($a[1]=="Q")\|\|($a[1]=="q"))
	{
	$rest = str_replace("_", " ", $rest);
	$rest = quoted_printable_decode($rest);
	}

	return rcube_charset_convert($rest, $a[0]);
	}
	else
	return $str; // we dont' know what to do with this
	}


	/**
	* Decode a mime part
	*
	* @param string Input string
	* @param string Part encoding
	* @return string Decoded string
	* @access private
	*/
	function mime_decode($input, $encoding='7bit')
	{
	switch (strtolower($encoding))
	{
	case 'quoted-printable':
	return quoted_printable_decode($input);
	break;

	case 'base64':
	return base64_decode($input);
	break;

	case 'x-uuencode':
	case 'x-uue':
	case 'uue':
	case 'uuencode':
	return convert_uudecode($input);
	break;

	case '7bit':
	default:
	return $input;
	}
	}


	/**
	* Convert body charset to UTF-8 according to the ctype_parameters
	*
	* @param string Part body to decode
	* @param string Charset to convert from
	* @return string Content converted to internal charset
	*/
	function charset_decode($body, $ctype_param)
	{
	if (is_array($ctype_param) && !empty($ctype_param['charset']))
	return rcube_charset_convert($body, $ctype_param['charset']);

	// defaults to what is specified in the class header
	return rcube_charset_convert($body, $this->default_charset);
	}


	/**
	* Translate UID to message ID
	*
	* @param int Message UID
	* @param string Mailbox name
	* @return int Message ID
	*/
	function get_id($uid, $mbox_name=NULL)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	return $this->_uid2id($uid, $mailbox);
	}


	/**
	* Translate message number to UID
	*
	* @param int Message ID
	* @param string Mailbox name
	* @return int Message UID
	*/
	function get_uid($id,$mbox_name=NULL)
	{
	$mailbox = $mbox_name ? $this->_mod_mailbox($mbox_name) : $this->mailbox;
	return $this->_id2uid($id, $mailbox);
	}



	/* --------------------------------
	* private methods
	* --------------------------------*/


	/**
	* @access private
	*/
	function _mod_mailbox($mbox_name, $mode='in')
	{
	if ((!empty($this->root_ns) && $this->root_ns == $mbox_name) \|\| $mbox_name == 'INBOX')
	return $mbox_name;

	if (!empty($this->root_dir) && $mode=='in')
	$mbox_name = $this->root_dir.$this->delimiter.$mbox_name;
	else if (strlen($this->root_dir) && $mode=='out')
	$mbox_name = substr($mbox_name, strlen($this->root_dir)+1);

	return $mbox_name;
	}

	/**
	* Validate the given input and save to local properties
	* @access private
	*/
	function _set_sort_order($sort_field, $sort_order)
	{
	if ($sort_field != null)
	$this->sort_field = asciiwords($sort_field);
	if ($sort_order != null)
	$this->sort_order = strtoupper($sort_order) == 'DESC' ? 'DESC' : 'ASC';
	}

	/**
	* Sort mailboxes first by default folders and then in alphabethical order
	* @access private
	*/
	function _sort_mailbox_list($a_folders)
	{
	$a_out = $a_defaults = $folders = array();

	$delimiter = $this->get_hierarchy_delimiter();

	// find default folders and skip folders starting with '.'
	foreach ($a_folders as $i => $folder)
	{
	if ($folder{0}=='.')
	continue;

	if (($p = array_search(strtolower($folder), $this->default_folders_lc)) !== false && !$a_defaults[$p])
	$a_defaults[$p] = $folder;
	else
	$folders[$folder] = rc_strtolower(rcube_charset_convert($folder, 'UTF-7'));
	}

	// sort folders and place defaults on the top
	asort($folders, SORT_LOCALE_STRING);
	ksort($a_defaults);
	$folders = array_merge($a_defaults, array_keys($folders));

	// finally we must rebuild the list to move
	// subfolders of default folders to their place...
	// ...also do this for the rest of folders because
	// asort() is not properly sorting case sensitive names
	while (list($key, $folder) = each($folders)) {
	// set the type of folder name variable (#1485527)
	$a_out[] = (string) $folder;
	unset($folders[$key]);
	$this->_rsort($folder, $delimiter, $folders, $a_out);
	}

	return $a_out;
	}


	/**
	* @access private
	*/
	function _rsort($folder, $delimiter, &$list, &$out)
	{
	while (list($key, $name) = each($list)) {
	if (strpos($name, $folder.$delimiter) === 0) {
	// set the type of folder name variable (#1485527)
	$out[] = (string) $name;
	unset($list[$key]);
	$this->_rsort($name, $delimiter, $list, $out);
	}
	}
	reset($list);
	}


	/**
	* @access private
	*/
	function _uid2id($uid, $mbox_name=NULL)
	{
	if (!$mbox_name)
	$mbox_name = $this->mailbox;

	if (!isset($this->uid_id_map[$mbox_name][$uid]))
	$this->uid_id_map[$mbox_name][$uid] = iil_C_UID2ID($this->conn, $mbox_name, $uid);

	return $this->uid_id_map[$mbox_name][$uid];
	}

	/**
	* @access private
	*/
	function _id2uid($id, $mbox_name=NULL)
	{
	if (!$mbox_name)
	$mbox_name = $this->mailbox;

	$index = array_flip((array)$this->uid_id_map[$mbox_name]);
	if (isset($index[$id]))
	$uid = $index[$id];
	else
	{
	$uid = iil_C_ID2UID($this->conn, $mbox_name, $id);
	$this->uid_id_map[$mbox_name][$uid] = $id;
	}

	return $uid;
	}


	/**
	* Subscribe/unsubscribe a list of mailboxes and update local cache
	* @access private
	*/
	function _change_subscription($a_mboxes, $mode)
	{
	$updated = FALSE;

	if (is_array($a_mboxes))
	foreach ($a_mboxes as $i => $mbox_name)
	{
	$mailbox = $this->_mod_mailbox($mbox_name);
	$a_mboxes[$i] = $mailbox;

	if ($mode=='subscribe')
	$result = iil_C_Subscribe($this->conn, $mailbox);
	else if ($mode=='unsubscribe')
	$result = iil_C_UnSubscribe($this->conn, $mailbox);

	if ($result>=0)
	$updated = TRUE;
	}

	// get cached mailbox list
	if ($updated)
	{
	$a_mailbox_cache = $this->get_cache('mailboxes');
	if (!is_array($a_mailbox_cache))
	return $updated;

	// modify cached list
	if ($mode=='subscribe')
	$a_mailbox_cache = array_merge($a_mailbox_cache, $a_mboxes);
	else if ($mode=='unsubscribe')
	$a_mailbox_cache = array_diff($a_mailbox_cache, $a_mboxes);

	// write mailboxlist to cache
	$this->update_cache('mailboxes', $this->_sort_mailbox_list($a_mailbox_cache));
	}

	return $updated;
	}


	/**
	* Increde/decrese messagecount for a specific mailbox
	* @access private
	*/
	function _set_messagecount($mbox_name, $mode, $increment)
	{
	$a_mailbox_cache = FALSE;
	$mailbox = $mbox_name ? $mbox_name : $this->mailbox;
	$mode = strtoupper($mode);

	$a_mailbox_cache = $this->get_cache('messagecount');

	if (!is_array($a_mailbox_cache[$mailbox]) \|\| !isset($a_mailbox_cache[$mailbox][$mode]) \|\| !is_numeric($increment))
	return FALSE;

	// add incremental value to messagecount
	$a_mailbox_cache[$mailbox][$mode] += $increment;

	// there's something wrong, delete from cache
	if ($a_mailbox_cache[$mailbox][$mode] < 0)
	unset($a_mailbox_cache[$mailbox][$mode]);

	// write back to cache
	$this->update_cache('messagecount', $a_mailbox_cache);

	return TRUE;
	}


	/**
	* Remove messagecount of a specific mailbox from cache
	* @access private
	*/
	function _clear_messagecount($mbox_name='')
	{
	$a_mailbox_cache = FALSE;
	$mailbox = $mbox_name ? $mbox_name : $this->mailbox;

	$a_mailbox_cache = $this->get_cache('messagecount');

	if (is_array($a_mailbox_cache[$mailbox]))
	{
	unset($a_mailbox_cache[$mailbox]);
	$this->update_cache('messagecount', $a_mailbox_cache);
	}
	}


	/**
	* Split RFC822 header string into an associative array
	* @access private
	*/
	function _parse_headers($headers)
	{
	$a_headers = array();
	$lines = explode("\n", $headers);
	$c = count($lines);
	for ($i=0; $i<$c; $i++)
	{
	if ($p = strpos($lines[$i], ': '))
	{
	$field = strtolower(substr($lines[$i], 0, $p));
	$value = trim(substr($lines[$i], $p+1));
	if (!empty($value))
	$a_headers[$field] = $value;
	}
	}

	return $a_headers;
	}


	/**
	* @access private
	*/
	function _parse_address_list($str, $decode=true)
	{
	// remove any newlines and carriage returns before
	$a = rcube_explode_quoted_string('[,;]', preg_replace( "/[\r\n]/", " ", $str));
	$result = array();

	foreach ($a as $key => $val)
	{
	$val = preg_replace("/([\"\w])</", "$1 <", $val);
	$sub_a = rcube_explode_quoted_string(' ', $decode ? $this->decode_header($val) : $val);
	$result[$key]['name'] = '';

	foreach ($sub_a as $k => $v)
	{
	// use angle brackets in regexp to not handle names with @ sign
	if (preg_match('/^<\S+@\S+>$/', $v))
	$result[$key]['address'] = trim($v, '<>');
	else
	$result[$key]['name'] .= (empty($result[$key]['name'])?'':' ').str_replace("\"",'',stripslashes($v));
	}

	if (empty($result[$key]['name']))
	$result[$key]['name'] = $result[$key]['address'];
	elseif (empty($result[$key]['address']))
	$result[$key]['address'] = $result[$key]['name'];
	}

	return $result;
	}

	} // end class rcube_imap


	/**
	* Class representing a message part
	*
	* @package Mail
	*/
	class rcube_message_part
	{
	var $mime_id = '';
	var $ctype_primary = 'text';
	var $ctype_secondary = 'plain';
	var $mimetype = 'text/plain';
	var $disposition = '';
	var $filename = '';
	var $encoding = '8bit';
	var $charset = '';
	var $size = 0;
	var $headers = array();
	var $d_parameters = array();
	var $ctype_parameters = array();

	}


	/**
	* Class for sorting an array of iilBasicHeader objects in a predetermined order.
	*
	* @package Mail
	* @author Eric Stadtherr
	*/
	class rcube_header_sorter
	{
	var $sequence_numbers = array();

	/**
	* Set the predetermined sort order.
	*
	* @param array Numerically indexed array of IMAP message sequence numbers
	*/
	function set_sequence_numbers($seqnums)
	{
	$this->sequence_numbers = array_flip($seqnums);
	}

	/**
	* Sort the array of header objects
	*
	* @param array Array of iilBasicHeader objects indexed by UID
	*/
	function sort_headers(&$headers)
	{
	/*
	* uksort would work if the keys were the sequence number, but unfortunately
	* the keys are the UIDs. We'll use uasort instead and dereference the value
	* to get the sequence number (in the "id" field).
	*
	* uksort($headers, array($this, "compare_seqnums"));
	*/
	uasort($headers, array($this, "compare_seqnums"));
	}

	/**
	* Sort method called by uasort()
	*/
	function compare_seqnums($a, $b)
	{
	// First get the sequence number from the header object (the 'id' field).
	$seqa = $a->id;
	$seqb = $b->id;

	// then find each sequence number in my ordered list
	$posa = isset($this->sequence_numbers[$seqa]) ? intval($this->sequence_numbers[$seqa]) : -1;
	$posb = isset($this->sequence_numbers[$seqb]) ? intval($this->sequence_numbers[$seqb]) : -1;

	// return the relative position as the comparison value
	return $posa - $posb;
	}
	}


	/**
	* Add quoted-printable encoding to a given string
	*
	* @param string String to encode
	* @param int Add new line after this number of characters
	* @param boolean True if spaces should be converted into =20
	* @return string Encoded string
	*/
	function quoted_printable_encode($input, $line_max=76, $space_conv=false)
	{
	$hex = array('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
	$lines = preg_split("/(?:\r\n\|\r\|\n)/", $input);
	$eol = "\r\n";
	$escape = "=";
	$output = "";

	while( list(, $line) = each($lines))
	{
	//$line = rtrim($line); // remove trailing white space -> no =20\r\n necessary
	$linlen = strlen($line);
	$newline = "";
	for($i = 0; $i < $linlen; $i++)
	{
	$c = substr( $line, $i, 1 );
	$dec = ord( $c );
	if ( ( $i == 0 ) && ( $dec == 46 ) ) // convert first point in the line into =2E
	{
	$c = "=2E";
	}
	if ( $dec == 32 )
	{
	if ( $i == ( $linlen - 1 ) ) // convert space at eol only
	{
	$c = "=20";
	}
	else if ( $space_conv )
	{
	$c = "=20";
	}
	}
	else if ( ($dec == 61) \|\| ($dec < 32 ) \|\| ($dec > 126) ) // always encode "\t", which is not required
	{
	$h2 = floor($dec/16);
	$h1 = floor($dec%16);
	$c = $escape.$hex["$h2"].$hex["$h1"];
	}

	if ( (strlen($newline) + strlen($c)) >= $line_max ) // CRLF is not counted
	{
	$output .= $newline.$escape.$eol; // soft line break; " =\r\n" is okay
	$newline = "";
	// check if newline first character will be point or not
	if ( $dec == 46 )
	{
	$c = "=2E";
	}
	}
	$newline .= $c;
	} // end of for
	$output .= $newline.$eol;
	} // end of while

	return trim($output);
	}


	diff --git a/program/steps/mail/compose.inc b/program/steps/mail/compose.inc
	index b31d73775..2cd603005 100644
	--- a/program/steps/mail/compose.inc
	+++ b/program/steps/mail/compose.inc
	@@ -1,920 +1,924 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/mail/compose.inc \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Compose a new mail message with all headers and attachments \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/

	// define constants for message compose mode
	define('RCUBE_COMPOSE_REPLY', 0x0106);
	define('RCUBE_COMPOSE_FORWARD', 0x0107);
	define('RCUBE_COMPOSE_DRAFT', 0x0108);

	$MESSAGE_FORM = NULL;
	$MESSAGE = NULL;

	// Nothing below is called during message composition, only at "new/forward/reply/draft" initialization or
	// if a compose-ID is given (i.e. when the compose step is opened in a new window/tab).
	// Since there are many ways to leave the compose page improperly, it seems necessary to clean-up an old
	// compose when a "new/forward/reply/draft" is called - otherwise the old session attachments will appear

	if (!is_array($_SESSION['compose']) \|\| $_SESSION['compose']['id'] != get_input_value('_id', RCUBE_INPUT_GET))
	{
	rcmail_compose_cleanup();
	- $_SESSION['compose'] = array('id' => uniqid(rand()), 'param' => array_map('strip_tags', $_GET));
	+ $_SESSION['compose'] = array(
	+ 'id' => uniqid(rand()),
	+ 'param' => array_map('strip_tags', $_GET),
	+ 'mailbox' => $IMAP->get_mailbox_name()
	+ );

	// process values like "mailto:foo@bar.com?subject=new+message&cc=another"
	if ($_SESSION['compose']['param']['_to']) {
	$mailto = explode('?', $_SESSION['compose']['param']['_to']);
	if (count($mailto) > 1) {
	$_SESSION['compose']['param']['_to'] = $mailto[0];
	parse_str($mailto[1], $query);
	foreach ($query as $f => $val)
	$_SESSION['compose']['param']["_$f"] = $val;
	}
	}

	// redirect to a unique URL with all parameters stored in session
	$OUTPUT->redirect(array('_action' => 'compose', '_id' => $_SESSION['compose']['id']));
	}

	// add some labels to client
	$OUTPUT->add_label('nosubject', 'nosenderwarning', 'norecipientwarning', 'nosubjectwarning',
	'nobodywarning', 'notsentwarning', 'savingmessage', 'sendingmessage', 'messagesaved',
	'converting', 'editorwarning', 'searching');

	// add config parameters to client script
	if (!empty($CONFIG['drafts_mbox'])) {
	$OUTPUT->set_env('drafts_mailbox', $CONFIG['drafts_mbox']);
	$OUTPUT->set_env('draft_autosave', $CONFIG['draft_autosave']);
	}
	// set current mailbox in client environment
	$OUTPUT->set_env('mailbox', $IMAP->get_mailbox_name());

	// get reference message and set compose mode
	if ($msg_uid = $_SESSION['compose']['param']['_reply_uid'])
	$compose_mode = RCUBE_COMPOSE_REPLY;
	else if ($msg_uid = $_SESSION['compose']['param']['_forward_uid'])
	$compose_mode = RCUBE_COMPOSE_FORWARD;
	else if ($msg_uid = $_SESSION['compose']['param']['_draft_uid']) {
	$RCMAIL->imap->set_mailbox($CONFIG['drafts_mbox']);
	$compose_mode = RCUBE_COMPOSE_DRAFT;
	}

	if (!empty($msg_uid))
	{
	// similar as in program/steps/mail/show.inc
	$MESSAGE = new rcube_message($msg_uid);

	if (!empty($MESSAGE->headers->charset))
	$IMAP->set_charset($MESSAGE->headers->charset);

	if ($compose_mode == RCUBE_COMPOSE_REPLY)
	{
	$_SESSION['compose']['reply_uid'] = $msg_uid;
	$_SESSION['compose']['reply_msgid'] = $MESSAGE->headers->messageID;
	$_SESSION['compose']['references'] = trim($MESSAGE->headers->references . " " . $MESSAGE->headers->messageID);

	if (!empty($_SESSION['compose']['param']['_all']))
	$MESSAGE->reply_all = 1;
	}
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT)
	{
	if($MESSAGE->headers->in_reply_to)
	{
	// TODO: how to get reply_uid/forward_uid value, maybe we must set X-Reply-UID/X-Forward-UID
	// $_SESSION['compose']['reply_uid'] = ?
	// $_SESSION['compose']['forward_uid'] = ?
	$_SESSION['compose']['reply_msgid'] = '<'.$MESSAGE->headers->in_reply_to.'>';
	}
	$_SESSION['compose']['references'] = $MESSAGE->headers->references;
	}
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD)
	{
	$_SESSION['compose']['forward_uid'] = $msg_uid;
	}
	}

	/**** compose mode functions ******/


	function rcmail_compose_headers($attrib)
	{
	global $IMAP, $MESSAGE, $DB, $compose_mode;
	static $sa_recipients = array();

	list($form_start, $form_end) = get_form_tags($attrib);

	$out = '';
	$part = strtolower($attrib['part']);

	switch ($part)
	{
	case 'from':
	return rcmail_compose_header_from($attrib);

	case 'to':
	$fname = '_to';
	$header = 'to';

	// we have a set of recipients stored is session
	if (($mailto_id = $_SESSION['compose']['param']['_mailto']) && $_SESSION['mailto'][$mailto_id])
	$fvalue = urldecode($_SESSION['mailto'][$mailto_id]);

	case 'cc':
	if (!$fname)
	{
	$fname = '_cc';
	$header = 'cc';
	}
	case 'bcc':
	if (!$fname)
	{
	$fname = '_bcc';
	$header = 'bcc';
	}

	$allow_attrib = array('id', 'class', 'style', 'cols', 'rows', 'tabindex');
	$field_type = 'html_textarea';
	break;

	case 'replyto':
	case 'reply-to':
	$fname = '_replyto';
	$allow_attrib = array('id', 'class', 'style', 'size', 'tabindex');
	$field_type = 'html_inputfield';
	break;
	}

	if ($fname && !empty($_POST[$fname]))
	$fvalue = get_input_value($fname, RCUBE_INPUT_POST, TRUE);
	else if ($fname && !$fvalue && !empty($_SESSION['compose']['param'][$fname]))
	$fvalue = $_SESSION['compose']['param'][$fname];

	else if ($header && $compose_mode == RCUBE_COMPOSE_REPLY)
	{
	// get recipent address(es) out of the message headers
	if ($header=='to' && !empty($MESSAGE->headers->replyto))
	$fvalue = $MESSAGE->headers->replyto;

	else if ($header=='to' && !empty($MESSAGE->headers->from))
	$fvalue = $MESSAGE->headers->from;

	// add recipent of original message if reply to all
	else if ($header=='cc' && !empty($MESSAGE->reply_all))
	{
	if ($v = $MESSAGE->headers->to)
	$fvalue .= $v;

	if ($v = $MESSAGE->headers->cc)
	$fvalue .= (!empty($fvalue) ? ', ' : '') . $v;
	}

	// split recipients and put them back together in a unique way
	if (!empty($fvalue))
	{
	$to_addresses = $IMAP->decode_address_list($fvalue);
	$fvalue = '';

	foreach ($to_addresses as $addr_part)
	{
	if (!empty($addr_part['mailto'])
	&& !in_array($addr_part['mailto'], $sa_recipients)
	&& (!$MESSAGE->compose_from
	\|\| !in_array_nocase($addr_part['mailto'], $MESSAGE->compose_from)
	\|\| (count($to_addresses)==1 && $header=='to'))) // allow reply to yourself
	{
	$fvalue .= (strlen($fvalue) ? ', ':'').$addr_part['string'];
	$sa_recipients[] = $addr_part['mailto'];
	}
	}
	}
	}
	else if ($header && $compose_mode == RCUBE_COMPOSE_DRAFT)
	{
	// get drafted headers
	if ($header=='to' && !empty($MESSAGE->headers->to))
	$fvalue = $MESSAGE->get_header('to');

	if ($header=='cc' && !empty($MESSAGE->headers->cc))
	$fvalue = $MESSAGE->get_header('cc');

	if ($header=='bcc' && !empty($MESSAGE->headers->bcc))
	$fvalue = $MESSAGE->get_header('bcc');
	}


	if ($fname && $field_type)
	{
	// pass the following attributes to the form class
	$field_attrib = array('name' => $fname, 'spellcheck' => 'false');
	foreach ($attrib as $attr => $value)
	if (in_array($attr, $allow_attrib))
	$field_attrib[$attr] = $value;

	// create teaxtarea object
	$input = new $field_type($field_attrib);
	$out = $input->show($fvalue);
	}

	if ($form_start)
	$out = $form_start.$out;

	return $out;
	}



	function rcmail_compose_header_from($attrib)
	{
	global $IMAP, $MESSAGE, $DB, $USER, $OUTPUT, $compose_mode;

	// pass the following attributes to the form class
	$field_attrib = array('name' => '_from');
	foreach ($attrib as $attr => $value)
	if (in_array($attr, array('id', 'class', 'style', 'size', 'tabindex')))
	$field_attrib[$attr] = $value;

	// extract all recipients of the reply-message
	$a_recipients = array();
	if ($compose_mode == RCUBE_COMPOSE_REPLY && is_object($MESSAGE->headers))
	{
	$MESSAGE->compose_from = array();

	$a_to = $IMAP->decode_address_list($MESSAGE->headers->to);
	foreach ($a_to as $addr)
	{
	if (!empty($addr['mailto']))
	$a_recipients[] = rc_strtolower($addr['mailto']);
	}

	if (!empty($MESSAGE->headers->cc))
	{
	$a_cc = $IMAP->decode_address_list($MESSAGE->headers->cc);
	foreach ($a_cc as $addr)
	{
	if (!empty($addr['mailto']))
	$a_recipients[] = rc_strtolower($addr['mailto']);
	}
	}
	}

	// get this user's identities
	$sql_result = $USER->list_identities();

	if ($DB->num_rows($sql_result))
	{
	$from_id = 0;
	$a_signatures = array();

	$field_attrib['onchange'] = JS_OBJECT_NAME.".change_identity(this)";
	$select_from = new html_select($field_attrib);

	while ($sql_arr = $DB->fetch_assoc($sql_result))
	{
	$identity_id = $sql_arr['identity_id'];
	$select_from->add(format_email_recipient($sql_arr['email'], $sql_arr['name']), $identity_id);

	// add signature to array
	if (!empty($sql_arr['signature']) && empty($_SESSION['compose']['param']['_nosig']))
	{
	$a_signatures[$identity_id]['text'] = $sql_arr['signature'];
	$a_signatures[$identity_id]['is_html'] = ($sql_arr['html_signature'] == 1) ? true : false;
	if ($a_signatures[$identity_id]['is_html'])
	{
	$h2t = new html2text($a_signatures[$identity_id]['text'], false, false);
	$a_signatures[$identity_id]['plain_text'] = trim($h2t->get_text());
	}
	}

	if ($compose_mode == RCUBE_COMPOSE_REPLY && is_array($MESSAGE->compose_from))
	$MESSAGE->compose_from[] = $sql_arr['email'];

	if (empty($_POST['_from']))
	{
	// set draft's identity
	if ($compose_mode == RCUBE_COMPOSE_DRAFT && strstr($MESSAGE->headers->from, $sql_arr['email']))
	$from_id = $sql_arr['identity_id'];
	// set identity if it's one of the reply-message recipients (with prio for default identity)
	else if (in_array(rc_strtolower($sql_arr['email']), $a_recipients) && (empty($from_id) \|\| $sql_arr['standard']))
	$from_id = $sql_arr['identity_id'];
	}
	}

	// overwrite identity selection with post parameter
	if (!empty($_POST['_from']))
	$from_id = get_input_value('_from', RCUBE_INPUT_POST);

	$out = $select_from->show($from_id);

	// add signatures to client
	$OUTPUT->set_env('signatures', $a_signatures);
	}
	else
	{
	$input_from = new html_inputfield($field_attrib);
	$out = $input_from->show($_POST['_from']);
	}

	if ($form_start)
	$out = $form_start.$out;

	return $out;
	}


	function rcmail_compose_body($attrib)
	{
	global $RCMAIL, $CONFIG, $OUTPUT, $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	if (empty($attrib['id']))
	$attrib['id'] = 'rcmComposeMessage';

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

	if ($CONFIG['htmleditor'])
	$isHtml = true;
	else
	$isHtml = false;

	$body = '';

	// use posted message body
	if (!empty($_POST['_message']))
	{
	$body = get_input_value('_message', RCUBE_INPUT_POST, true);
	}
	else if ($compose_mode)
	{
	if (($isHtml \|\| $compose_mode == RCUBE_COMPOSE_DRAFT) && $MESSAGE->has_html_part())
	{
	$body = $MESSAGE->first_html_part();
	$isHtml = true;
	}
	else
	{
	$body = $MESSAGE->first_text_part();
	$isHtml = false;
	}

	// compose reply-body
	if ($compose_mode == RCUBE_COMPOSE_REPLY)
	$body = rcmail_create_reply_body($body, $isHtml);
	// forward message body inline
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD)
	$body = rcmail_create_forward_body($body, $isHtml);
	// load draft message body
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT)
	$body = rcmail_create_draft_body($body, $isHtml);
	}
	else if (!empty($_SESSION['compose']['param']['_body']))
	{
	$body = $_SESSION['compose']['param']['_body'];
	}

	$out = $form_start ? "$form_start\n" : '';

	$saveid = new html_hiddenfield(array('name' => '_draft_saveid', 'value' => $compose_mode==RCUBE_COMPOSE_DRAFT ? str_replace(array('<','>'), "", $MESSAGE->headers->messageID) : ''));
	$out .= $saveid->show();

	$drafttoggle = new html_hiddenfield(array('name' => '_draft', 'value' => 'yes'));
	$out .= $drafttoggle->show();

	$msgtype = new html_hiddenfield(array('name' => '_is_html', 'value' => ($isHtml?"1":"0")));
	$out .= $msgtype->show();

	// If desired, set this textarea to be editable by TinyMCE
	if ($isHtml) $attrib['class'] = 'mce_editor';
	$textarea = new html_textarea($attrib);
	$out .= $textarea->show($body);
	$out .= $form_end ? "\n$form_end" : '';

	// include HTML editor
	rcube_html_editor();

	// include GoogieSpell
	if (!empty($CONFIG['enable_spellcheck'])) {

	$lang = strtolower(substr($_SESSION['language'], 0, 2));

	$spellcheck_langs = (array)$RCMAIL->config->get('spellcheck_languages', array('da'=>'Dansk', 'de'=>'Deutsch', 'en' => 'English', 'es'=>'Español', 'fr'=>'Français', 'it'=>'Italiano', 'nl'=>'Nederlands', 'pl'=>'Polski', 'pt'=>'Português', 'fi'=>'Suomi', 'sv'=>'Svenska'));
	if (!$spellcheck_langs[$lang])
	$lang = 'en';

	$editor_lang_set = array();
	foreach ($spellcheck_langs as $key => $name) {
	$editor_lang_set[] = ($key == $lang ? '+' : '') . JQ($name).'='.JQ($key);
	}

	$OUTPUT->include_script('googiespell.js');
	$OUTPUT->add_script(sprintf(
	"var googie = new GoogieSpell('\$__skin_path/images/googiespell/','%s&_action=spell&lang=');\n".
	"googie.lang_chck_spell = \"%s\";\n".
	"googie.lang_rsm_edt = \"%s\";\n".
	"googie.lang_close = \"%s\";\n".
	"googie.lang_revert = \"%s\";\n".
	"googie.lang_no_error_found = \"%s\";\n".
	"googie.setLanguages(%s);\n".
	"googie.setCurrentLanguage('%s');\n".
	"googie.setSpellContainer('spellcheck-control');\n".
	"googie.decorateTextarea('%s');\n".
	"%s.set_env('spellcheck', googie);",
	$RCMAIL->comm_path,
	JQ(Q(rcube_label('checkspelling'))),
	JQ(Q(rcube_label('resumeediting'))),
	JQ(Q(rcube_label('close'))),
	JQ(Q(rcube_label('revertto'))),
	JQ(Q(rcube_label('nospellerrors'))),
	json_serialize($spellcheck_langs),
	$lang,
	$attrib['id'],
	JS_OBJECT_NAME), 'foot');

	$OUTPUT->add_label('checking');
	$OUTPUT->set_env('spellcheck_langs', join(',', $editor_lang_set));
	}

	$out .= "\n".'<iframe name="savetarget" src="program/blank.gif" style="width:0;height:0;border:none;visibility:hidden;"></iframe>';

	return $out;
	}


	function rcmail_create_reply_body($body, $bodyIsHtml)
	{
	global $IMAP, $MESSAGE, $OUTPUT;

	if (! $bodyIsHtml)
	{
	// try to remove the signature
	if (($sp = strrpos($body, '-- ')) !== false && ($sp == 0 \|\| $body{$sp-1} == "\n"))
	{
	if ($body{$sp+3}==' ' \|\| $body{$sp+3}=="\n" \|\| $body{$sp+3}=="\r")
	$body = substr($body, 0, max(0, $sp-1));
	}

	// soft-wrap message first
	$body = rcmail_wrap_quoted($body, 75);

	$body = rtrim($body, "\r\n");

	if ($body) {
	// split body into single lines
	$a_lines = preg_split('/\r?\n/', $body);

	// add > to each line
	for($n=0; $n<sizeof($a_lines); $n++) {
	if (strpos($a_lines[$n], '>')===0)
	$a_lines[$n] = '>'.$a_lines[$n];
	else
	$a_lines[$n] = '> '.$a_lines[$n];
	}

	$body = join("\n", $a_lines);
	}

	// add title line(s)
	$prefix = rc_wordwrap(sprintf("On %s, %s wrote:\n",
	$MESSAGE->headers->date,
	$MESSAGE->get_header('from')), 76);

	$suffix = '';
	}
	else
	{
	// save inline images to files
	$cid_map = rcmail_write_inline_attachments($MESSAGE);
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);
	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);

	// build reply (quote content)
	$prefix = sprintf("On %s, %s wrote:<br />\n",
	$MESSAGE->headers->date,
	htmlspecialchars(Q($MESSAGE->get_header('from'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset()));
	$prefix .= '<blockquote type="cite" style="padding-left:5px; border-left:#1010ff 2px solid; margin-left:5px; width:100%">';
	$suffix = "</blockquote><p></p>";
	}

	return $prefix.$body.$suffix;
	}


	function rcmail_create_forward_body($body, $bodyIsHtml)
	{
	global $IMAP, $MESSAGE, $OUTPUT;

	// add attachments
	if (!isset($_SESSION['compose']['forward_attachments']) && is_array($MESSAGE->mime_parts))
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);

	if (!$bodyIsHtml)
	{
	$prefix = "\n\n\n-------- Original Message --------\n";
	$prefix .= 'Subject: ' . $MESSAGE->subject . "\n";
	$prefix .= 'Date: ' . $MESSAGE->headers->date . "\n";
	$prefix .= 'From: ' . $MESSAGE->get_header('from') . "\n";
	$prefix .= 'To: ' . $MESSAGE->get_header('to') . "\n";
	if ($MESSAGE->headers->replyto && $MESSAGE->headers->replyto != $MESSAGE->headers->from)
	$prefix .= 'Reply-To: ' . $MESSAGE->get_header('replyto') . "\n";
	$prefix .= "\n";
	}
	else
	{
	// set is_safe flag (we need this for html body washing)
	rcmail_check_safe($MESSAGE);
	// clean up html tags
	$body = rcmail_wash_html($body, array('safe' => $MESSAGE->is_safe), $cid_map);

	$prefix = sprintf(
	"<br><br>-------- Original Message --------" .
	"<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\"><tbody>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Subject: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Date: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">From: </th><td>%s</td></tr>" .
	"<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">To: </th><td>%s</td></tr>",
	Q($MESSAGE->subject),
	Q($MESSAGE->headers->date),
	htmlspecialchars(Q($MESSAGE->get_header('from'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true),
	htmlspecialchars(Q($MESSAGE->get_header('to'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true));

	if ($MESSAGE->headers->replyto && $MESSAGE->headers->replyto != $MESSAGE->headers->from)
	$prefix .= sprintf("<tr><th align=\"right\" nowrap=\"nowrap\" valign=\"baseline\">Reply-To: </th><td>%s</td></tr>",
	htmlspecialchars(Q($MESSAGE->get_header('replyto'), 'replace'), ENT_COMPAT, $OUTPUT->get_charset(), true));

	$prefix .= "</tbody></table><br>";
	}

	return $prefix.$body;
	}


	function rcmail_create_draft_body($body, $bodyIsHtml)
	{
	global $MESSAGE, $OUTPUT;

	/**
	* add attachments
	* sizeof($MESSAGE->mime_parts can be 1 - e.g. attachment, but no text!
	*/
	if (!isset($_SESSION['compose']['forward_attachments'])
	&& is_array($MESSAGE->mime_parts)
	&& count($MESSAGE->mime_parts) > 0)
	{
	$cid_map = rcmail_write_compose_attachments($MESSAGE, $bodyIsHtml);

	// replace cid with href in inline images links
	if ($cid_map)
	$body = str_replace(array_keys($cid_map), array_values($cid_map), $body);
	}

	return $body;
	}


	function rcmail_write_compose_attachments(&$message, $bodyIsHtml)
	{
	global $OUTPUT;

	$cid_map = array();
	foreach ((array)$message->mime_parts as $pid => $part)
	{
	if (($part->ctype_primary != 'message' \|\| !$bodyIsHtml) &&
	($part->disposition=='attachment' \|\| $part->disposition=='inline' \|\| $part->headers['content-id']
	\|\| (empty($part->disposition) && $part->filename)))
	{
	if ($attachment = rcmail_save_attachment($message, $pid)) {
	$_SESSION['compose']['attachments'][$attachment['id']] = $attachment;
	if ($bodyIsHtml && $part->filename && $part->content_id) {
	$cid_map['cid:'.$part->content_id] = $OUTPUT->app->comm_path.'&_action=display-attachment&_file=rcmfile'.$attachment['id'];
	}
	}
	}
	}

	$_SESSION['compose']['forward_attachments'] = true;

	return $cid_map;
	}


	function rcmail_write_inline_attachments(&$message)
	{
	global $OUTPUT;

	$cid_map = array();
	foreach ((array)$message->mime_parts as $pid => $part) {
	if ($part->content_id && $part->filename) {
	if ($attachment = rcmail_save_attachment($message, $pid)) {
	$_SESSION['compose']['attachments'][$attachment['id']] = $attachment;
	$cid_map['cid:'.$part->content_id] = $OUTPUT->app->comm_path.'&_action=display-attachment&_file=rcmfile'.$attachment['id'];
	}
	}
	}

	return $cid_map;
	}

	function rcmail_save_attachment(&$message, $pid)
	{
	$part = $message->mime_parts[$pid];

	$attachment = array(
	'name' => $part->filename,
	'mimetype' => $part->ctype_primary . '/' . $part->ctype_secondary,
	'content_id' => $part->content_id,
	'data' => $message->get_part_content($pid),
	);

	$attachment = rcmail::get_instance()->plugins->exec_hook('save_attachment', $attachment);
	if ($attachment['status']) {
	unset($attachment['data'], $attachment['status']);
	return $attachment;
	}

	return false;
	}


	function rcmail_compose_subject($attrib)
	{
	global $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	$attrib['name'] = '_subject';
	$attrib['spellcheck'] = 'true';
	$textfield = new html_inputfield($attrib);

	$subject = '';

	// use subject from post
	if (isset($_POST['_subject'])) {
	$subject = get_input_value('_subject', RCUBE_INPUT_POST, TRUE);
	}
	// create a reply-subject
	else if ($compose_mode == RCUBE_COMPOSE_REPLY) {
	if (preg_match('/^re:/i', $MESSAGE->subject))
	$subject = $MESSAGE->subject;
	else
	$subject = 'Re: '.$MESSAGE->subject;
	}
	// create a forward-subject
	else if ($compose_mode == RCUBE_COMPOSE_FORWARD) {
	if (preg_match('/^fwd:/i', $MESSAGE->subject))
	$subject = $MESSAGE->subject;
	else
	$subject = 'Fwd: '.$MESSAGE->subject;
	}
	// creeate a draft-subject
	else if ($compose_mode == RCUBE_COMPOSE_DRAFT) {
	$subject = $MESSAGE->subject;
	}
	else if (!empty($_SESSION['compose']['param']['_subject'])) {
	$subject = $_SESSION['compose']['param']['_subject'];
	}

	$out = $form_start ? "$form_start\n" : '';
	$out .= $textfield->show($subject);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_compose_attachment_list($attrib)
	{
	global $OUTPUT, $CONFIG;

	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmAttachmentList';

	$out = "\n";

	if (is_array($_SESSION['compose']['attachments']))
	{
	if ($attrib['deleteicon'])
	$button = html::img(array(
	'src' => $CONFIG['skin_path'] . $attrib['deleteicon'],
	'alt' => rcube_label('delete')
	));
	else
	$button = Q(rcube_label('delete'));

	foreach ($_SESSION['compose']['attachments'] as $id => $a_prop)
	{
	if (empty($a_prop))
	continue;

	$out .= html::tag('li', array('id' => "rcmfile".$id),
	html::a(array(
	'href' => "#delete",
	'title' => rcube_label('delete'),
	'onclick' => sprintf("return %s.command('remove-attachment','rcmfile%s', this)", JS_OBJECT_NAME, $id)),
	$button) . Q($a_prop['name']));
	}
	}

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

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


	function rcmail_compose_attachment_form($attrib)
	{
	global $OUTPUT;

	// add ID if not given
	if (!$attrib['id'])
	$attrib['id'] = 'rcmUploadbox';

	$button = new html_inputfield(array('type' => 'button', 'class' => 'button'));

	$out = html::div($attrib,
	$OUTPUT->form_tag(array('name' => 'form', 'method' => 'post', 'enctype' => 'multipart/form-data'),
	html::div(null, rcmail_compose_attachment_field(array())) .
	html::div('hint', rcube_label(array('name' => 'maxuploadsize', 'vars' => array('size' => show_bytes(parse_bytes(ini_get('upload_max_filesize'))))))) .
	html::div('buttons',
	$button->show(rcube_label('close'), array('onclick' => "document.getElementById('$attrib[id]').style.visibility='hidden'")) . ' ' .
	$button->show(rcube_label('upload'), array('onclick' => JS_OBJECT_NAME . ".command('send-attachment', this.form)"))
	)
	)
	);

	$OUTPUT->add_gui_object('uploadbox', $attrib['id']);
	return $out;
	}


	function rcmail_compose_attachment_field($attrib)
	{
	$attrib['type'] = 'file';
	$attrib['name'] = '_attachments[]';
	$field = new html_inputfield($attrib);
	return $field->show();
	}


	function rcmail_priority_selector($attrib)
	{
	global $MESSAGE;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

	$attrib['name'] = '_priority';
	$selector = new html_select($attrib);

	$selector->add(array(rcube_label('lowest'),
	rcube_label('low'),
	rcube_label('normal'),
	rcube_label('high'),
	rcube_label('highest')),
	array(5, 4, 0, 2, 1));

	if (isset($_POST['_priority']))
	$sel = $_POST['_priority'];
	else if (intval($MESSAGE->headers->priority) != 3)
	$sel = intval($MESSAGE->headers->priority);
	else
	$sel = 0;

	$out = $form_start ? "$form_start\n" : '';
	$out .= $selector->show($sel);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_receipt_checkbox($attrib)
	{
	global $MESSAGE, $compose_mode;

	list($form_start, $form_end) = get_form_tags($attrib);
	unset($attrib['form']);

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

	$attrib['name'] = '_receipt';
	$attrib['value'] = '1';
	$checkbox = new html_checkbox($attrib);

	$out = $form_start ? "$form_start\n" : '';
	$out .= $checkbox->show(
	$compose_mode == RCUBE_COMPOSE_DRAFT && $MESSAGE->headers->mdn_to ? 1 : 0);
	$out .= $form_end ? "\n$form_end" : '';

	return $out;
	}


	function rcmail_editor_selector($attrib)
	{
	global $CONFIG, $MESSAGE, $compose_mode;

	// determine whether HTML or plain text should be checked
	$useHtml = $CONFIG['htmleditor'] ? true : false;

	if ($compose_mode)
	$useHtml = ($useHtml && $MESSAGE->has_html_part());

	if (empty($attrib['editorid']))
	$attrib['editorid'] = 'rcmComposeMessage';

	if (empty($attrib['name']))
	$attrib['name'] = 'editorSelect';

	- $attrib['onchange'] = "return rcmail_toggle_editor(this.value=='html', '".$attrib['editorid']."', '_is_html')";
	+ $attrib['onchange'] = "return rcmail_toggle_editor(this.value=='html', '".$attrib['editorid']."', '_is_html')";

	$select = new html_select($attrib);

	$select->add(Q(rcube_label('htmltoggle')), 'html');
	$select->add(Q(rcube_label('plaintoggle')), 'plain');

	return $select->show($useHtml ? 'html' : 'plain');

	foreach ($choices as $value => $text)
	{
	$attrib['id'] = '_' . $value;
	$attrib['value'] = $value;
	$selector .= $radio->show($chosenvalue, $attrib) . html::label($attrib['id'], Q(rcube_label($text)));
	}

	return $selector;
	}


	function rcmail_store_target_selection($attrib)
	{
	$attrib['name'] = '_store_target';
	$select = rcmail_mailbox_select(array_merge($attrib, array('noselection' => '- '.rcube_label('dontsave').' -')));
	return $select->show(rcmail::get_instance()->config->get('sent_mbox'), $attrib);
	}


	function get_form_tags($attrib)
	{
	global $RCMAIL, $MESSAGE_FORM;

	$form_start = '';
	if (!strlen($MESSAGE_FORM))
	{
	$hiddenfields = new html_hiddenfield(array('name' => '_task', 'value' => $RCMAIL->task));
	$hiddenfields->add(array('name' => '_action', 'value' => 'send'));

	$form_start = empty($attrib['form']) ? $RCMAIL->output->form_tag(array('name' => "form", 'method' => "post")) : '';
	$form_start .= $hiddenfields->show();
	}

	$form_end = (strlen($MESSAGE_FORM) && !strlen($attrib['form'])) ? '</form>' : '';
	$form_name = !empty($attrib['form']) ? $attrib['form'] : 'form';

	if (!strlen($MESSAGE_FORM))
	$RCMAIL->output->add_gui_object('messageform', $form_name);

	$MESSAGE_FORM = $form_name;

	return array($form_start, $form_end);
	}


	// register UI objects
	$OUTPUT->add_handlers(array(
	'composeheaders' => 'rcmail_compose_headers',
	'composesubject' => 'rcmail_compose_subject',
	'composebody' => 'rcmail_compose_body',
	'composeattachmentlist' => 'rcmail_compose_attachment_list',
	'composeattachmentform' => 'rcmail_compose_attachment_form',
	'composeattachment' => 'rcmail_compose_attachment_field',
	'priorityselector' => 'rcmail_priority_selector',
	'editorselector' => 'rcmail_editor_selector',
	'receiptcheckbox' => 'rcmail_receipt_checkbox',
	'storetarget' => 'rcmail_store_target_selection',
	));

	$OUTPUT->send('compose');

	?>
	diff --git a/program/steps/mail/sendmail.inc b/program/steps/mail/sendmail.inc
	index 742322602..4ebf4893c 100644
	--- a/program/steps/mail/sendmail.inc
	+++ b/program/steps/mail/sendmail.inc
	@@ -1,524 +1,524 @@
	<?php

	/*
	+-----------------------------------------------------------------------+
	\| program/steps/mail/sendmail.inc \|
	\| \|
	\| This file is part of the RoundCube Webmail client \|
	\| Copyright (C) 2005-2009, RoundCube Dev. - Switzerland \|
	\| Licensed under the GNU GPL \|
	\| \|
	\| PURPOSE: \|
	\| Compose a new mail message with all headers and attachments \|
	\| and send it using the PEAR::Net_SMTP class or with PHP mail() \|
	\| \|
	+-----------------------------------------------------------------------+
	\| Author: Thomas Bruederli <roundcube@gmail.com> \|
	+-----------------------------------------------------------------------+

	$Id$

	*/


	// remove all scripts and act as called in frame
	$OUTPUT->reset();
	$OUTPUT->framed = TRUE;

	$savedraft = !empty($_POST['_draft']) ? TRUE : FALSE;

	/**** checks ******/

	if (!isset($_SESSION['compose']['id'])) {
	raise_error(array('code' => 500, 'type' => 'smtp', 'file' => __FILE__, 'message' => "Invalid compose ID"), true, false);
	console("Sendmail error", $_SESSION['compose']);
	$OUTPUT->show_message("An internal error occured. Please try again.", 'error');
	$OUTPUT->send('iframe');
	}

	if (!$savedraft) {
	if (empty($_POST['_to']) && empty($_POST['_cc']) && empty($_POST['_bcc'])
	&& empty($_POST['_subject']) && $_POST['_message']) {
	$OUTPUT->show_message('sendingfailed', 'error');
	$OUTPUT->send('iframe');
	}

	if(!empty($CONFIG['sendmail_delay'])) {
	$wait_sec = time() - intval($CONFIG['sendmail_delay']) - intval($CONFIG['last_message_time']);
	if($wait_sec < 0) {
	$OUTPUT->show_message('senttooquickly', 'error', array('sec' => $wait_sec * -1));
	$OUTPUT->send('iframe');
	}
	}
	}


	/**** message sending functions ******/

	// get identity record
	function rcmail_get_identity($id)
	{
	global $USER, $OUTPUT;

	if ($sql_arr = $USER->get_identity($id))
	{
	$out = $sql_arr;
	$out['mailto'] = $sql_arr['email'];

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

	$out['string'] = rcube_charset_convert($name, RCMAIL_CHARSET, $OUTPUT->get_charset());
	if ($sql_arr['email'])
	$out['string'] .= ' <' . $sql_arr['email'] . '>';

	return $out;
	}

	return FALSE;
	}

	/**
	* go from this:
	* <img src=".../tiny_mce/plugins/emotions/images/smiley-cool.gif" border="0" alt="Cool" title="Cool" />
	*
	* to this:
	*
	* <IMG src="cid:smiley-cool.gif"/>
	* ...
	* ------part...
	* Content-Type: image/gif
	* Content-Transfer-Encoding: base64
	* Content-ID: <smiley-cool.gif>
	*/
	function rcmail_attach_emoticons(&$mime_message)
	{
	global $CONFIG;

	$body = $mime_message->getHtmlBody();

	// remove any null-byte characters before parsing
	$body = preg_replace('/\x00/', '', $body);

	$searchstr = 'program/js/tiny_mce/plugins/emotions/img/';
	$offset = 0;

	// keep track of added images, so they're only added once
	$included_images = array();

	if (preg_match_all('# src=[\'"]([^\'"]+)#', $body, $matches, PREG_OFFSET_CAPTURE)) {
	foreach ($matches[1] as $m) {
	// find emoticon image tags
	if (preg_match('#'.$searchstr.'(.*)$#', $m[0], $imatches)) {
	$image_name = $imatches[1];

	// sanitize image name so resulting attachment doesn't leave images dir
	$image_name = preg_replace('/[^a-zA-Z0-9_\.\-]/i', '', $image_name);
	$img_file = INSTALL_PATH . '/' . $searchstr . $image_name;

	if (! in_array($image_name, $included_images)) {
	// add the image to the MIME message
	if(! $mime_message->addHTMLImage($img_file, 'image/gif', '', true, $image_name))
	$OUTPUT->show_message("emoticonerror", 'error');
	array_push($included_images, $image_name);
	}

	$body = substr_replace($body, $img_file, $m[1] + $offset, strlen($m[0]));
	$offset += strlen($img_file) - strlen($m[0]);
	}
	}
	}

	$mime_message->setHTMLBody($body);

	return $body;
	}

	// parse email address input
	function rcmail_mailto_format($mailto)
	{
	$regexp = array('/[,;]\s[\r\n]+/', '/[\r\n]+/', '/[,;]\s$/m', '/;/', '/(\S{1})(<\S+@\S+>)/U');
	$replace = array(', ', ', ', '', ',', '\\1 \\2');

	// replace new lines and strip ending ', ', make address input more valid
	$mailto = trim(preg_replace($regexp, $replace, $mailto));

	$result = array();
	$items = rcube_explode_quoted_string(',', $mailto);

	foreach($items as $item) {
	$item = trim($item);
	// address in brackets without name (do nothing)
	if (preg_match('/^<\S+@\S+>$/', $item)) {
	$result[] = $item;
	// address without brackets and without name (add brackets)
	} else if (preg_match('/^\S+@\S+$/', $item)) {
	$result[] = '<'.$item.'>';
	// address with name (handle name)
	} else if (preg_match('/\S+@\S+>*$/', $item, $matches)) {
	$address = $matches[0];
	$name = str_replace($address, '', $item);
	$name = trim($name);
	if ($name && ($name[0] != '"' \|\| $name[strlen($name)-1] != '"')
	&& preg_match('/[\<\>\\\.\[\]@,;:"]/', $name)) {
	$name = '"'.addcslashes($name, '"').'"';
	}
	if (!preg_match('/^<\S+@\S+>$/', $address))
	$address = '<'.$address.'>';

	$result[] = $name.' '.$address;
	} else if (trim($item)) {
	// @TODO: handle errors
	}
	}

	return implode(', ', $result);
	}

	/**** compose message ******/

	if (strlen($_POST['_draft_saveid']) > 3)
	$olddraftmessageid = get_input_value('_draft_saveid', RCUBE_INPUT_POST);

	$message_id = sprintf('<%s@%s>', md5(uniqid('rcmail'.rand(),true)), $RCMAIL->config->mail_domain($_SESSION['imap_host']));

	// set default charset
	$input_charset = $OUTPUT->get_charset();
	$message_charset = isset($_POST['_charset']) ? $_POST['_charset'] : $input_charset;

	$mailto = rcmail_mailto_format(get_input_value('_to', RCUBE_INPUT_POST, TRUE, $message_charset));
	$mailcc = rcmail_mailto_format(get_input_value('_cc', RCUBE_INPUT_POST, TRUE, $message_charset));
	$mailbcc = rcmail_mailto_format(get_input_value('_bcc', RCUBE_INPUT_POST, TRUE, $message_charset));

	if (empty($mailto) && !empty($mailcc)) {
	$mailto = $mailcc;
	$mailcc = null;
	}
	else if (empty($mailto))
	$mailto = 'undisclosed-recipients:;';

	// get sender name and address
	$from = get_input_value('_from', RCUBE_INPUT_POST);
	$identity_arr = rcmail_get_identity($from);

	if ($identity_arr)
	$from = $identity_arr['mailto'];

	if (empty($identity_arr['string']))
	$identity_arr['string'] = $from;

	// compose headers array
	$headers = array('Date' => date('r'),
	'From' => rcube_charset_convert($identity_arr['string'], RCMAIL_CHARSET, $message_charset),
	'To' => $mailto);

	// additional recipients
	if (!empty($mailcc))
	$headers['Cc'] = $mailcc;

	if (!empty($mailbcc))
	$headers['Bcc'] = $mailbcc;

	if (!empty($identity_arr['bcc']))
	$headers['Bcc'] = ($headers['Bcc'] ? $headers['Bcc'].', ' : '') . $identity_arr['bcc'];

	// add subject
	$headers['Subject'] = trim(get_input_value('_subject', RCUBE_INPUT_POST, TRUE, $message_charset));

	if (!empty($identity_arr['organization']))
	$headers['Organization'] = $identity_arr['organization'];

	if (!empty($_POST['_replyto']))
	$headers['Reply-To'] = rcmail_mailto_format(get_input_value('_replyto', RCUBE_INPUT_POST, TRUE, $message_charset));
	else if (!empty($identity_arr['reply-to']))
	$headers['Reply-To'] = $identity_arr['reply-to'];

	if (!empty($_SESSION['compose']['reply_msgid']))
	$headers['In-Reply-To'] = $_SESSION['compose']['reply_msgid'];

	if (!empty($_SESSION['compose']['references']))
	$headers['References'] = $_SESSION['compose']['references'];

	if (!empty($_POST['_priority']))
	{
	$priority = intval($_POST['_priority']);
	$a_priorities = array(1=>'highest', 2=>'high', 4=>'low', 5=>'lowest');
	if ($str_priority = $a_priorities[$priority])
	$headers['X-Priority'] = sprintf("%d (%s)", $priority, ucfirst($str_priority));
	}

	if (!empty($_POST['_receipt']))
	{
	$headers['Return-Receipt-To'] = $identity_arr['string'];
	$headers['Disposition-Notification-To'] = $identity_arr['string'];
	}

	// additional headers
	if ($CONFIG['http_received_header'])
	{
	$nldlm = $RCMAIL->config->header_delimiter() . "\t";
	$headers['Received'] = wordwrap('from ' . (isset($_SERVER['HTTP_X_FORWARDED_FOR']) ?
	gethostbyaddr($_SERVER['HTTP_X_FORWARDED_FOR']).' ['.$_SERVER['HTTP_X_FORWARDED_FOR'].']'.$nldlm.' via ' : '') .
	gethostbyaddr($_SERVER['REMOTE_ADDR']).' ['.$_SERVER['REMOTE_ADDR'].']'.$nldlm.'with ' .
	$_SERVER['SERVER_PROTOCOL'].' ('.$_SERVER['REQUEST_METHOD'].'); ' . date('r'),
	69, $nldlm);
	}

	$headers['Message-ID'] = $message_id;
	$headers['X-Sender'] = $from;

	if (!empty($CONFIG['useragent']))
	$headers['User-Agent'] = $CONFIG['useragent'];

	$isHtmlVal = strtolower(get_input_value('_is_html', RCUBE_INPUT_POST));
	$isHtml = ($isHtmlVal == "1");

	// fetch message body
	$message_body = get_input_value('_message', RCUBE_INPUT_POST, TRUE, $message_charset);

	if (!$savedraft) {
	// remove signature's div ID
	if ($isHtml)
	$message_body = preg_replace('/\s*id="_rc_sig"/', '', $message_body);

	// generic footer for all messages
	if (!empty($CONFIG['generic_message_footer'])) {
	$footer = file_get_contents(realpath($CONFIG['generic_message_footer']));
	$footer = rcube_charset_convert($footer, 'UTF-8', $message_charset);
	}
	}

	// create extended PEAR::Mail_mime instance
	$MAIL_MIME = new rcube_mail_mime($RCMAIL->config->header_delimiter());

	// For HTML-formatted messages, construct the MIME message with both
	// the HTML part and the plain-text part

	if ($isHtml) {
	$plugin = $RCMAIL->plugins->exec_hook('outgoing_message_body', array('body' => $message_body, 'type' => 'html', 'message' => $MAIL_MIME));
	$MAIL_MIME->setHTMLBody($plugin['body'] . ($footer ? "\r\n<pre>".$footer.'</pre>' : ''));

	// add a plain text version of the e-mail as an alternative part.
	$h2t = new html2text($plugin['body'], false, true, 0);
	$plainTextPart = rc_wordwrap($h2t->get_text(), 75, "\r\n") . ($footer ? "\r\n".$footer : '');
	$plainTextPart = wordwrap($plainTextPart, 998, "\r\n", true);
	if (!strlen($plainTextPart)) {
	// empty message body breaks attachment handling in drafts
	$plainTextPart = "\r\n";
	}
	$plugin = $RCMAIL->plugins->exec_hook('outgoing_message_body', array('body' => $plainTextPart, 'type' => 'alternative', 'message' => $MAIL_MIME));
	$MAIL_MIME->setTXTBody($plugin['body']);

	// look for "emoticon" images from TinyMCE and copy into message as attachments
	$message_body = rcmail_attach_emoticons($MAIL_MIME);
	}
	else
	{
	$message_body = rc_wordwrap($message_body, 75, "\r\n");
	if ($footer)
	$message_body .= "\r\n" . $footer;
	$message_body = wordwrap($message_body, 998, "\r\n", true);
	if (!strlen($message_body)) {
	// empty message body breaks attachment handling in drafts
	$message_body = "\r\n";
	}
	$plugin = $RCMAIL->plugins->exec_hook('outgoing_message_body', array('body' => $message_body, 'type' => 'plain', 'message' => $MAIL_MIME));
	$MAIL_MIME->setTXTBody($plugin['body'], false, true);
	}

	// chose transfer encoding
	$charset_7bit = array('ASCII', 'ISO-2022-JP', 'ISO-8859-1', 'ISO-8859-2', 'ISO-8859-15');
	$transfer_encoding = in_array(strtoupper($message_charset), $charset_7bit) ? '7bit' : '8bit';

	// add stored attachments, if any
	if (is_array($_SESSION['compose']['attachments'])) {
	foreach ($_SESSION['compose']['attachments'] as $id => $attachment) {
	// This hook retrieves the attachment contents from the file storage backend
	$attachment = $RCMAIL->plugins->exec_hook('get_attachment', $attachment);

	$dispurl = '/\ssrc\s=\s[\'"]\S+display-attachment\S+file=rcmfile' . preg_quote($attachment['id']) . '[\s\'"]\s/';
	$message_body = $MAIL_MIME->getHTMLBody();
	if ($isHtml && (preg_match($dispurl, $message_body) > 0)) {
	$message_body = preg_replace($dispurl, ' src="'.$attachment['name'].'" ', $message_body);
	$MAIL_MIME->setHTMLBody($message_body);

	if ($attachment['data'])
	$MAIL_MIME->addHTMLImage($attachment['data'], $attachment['mimetype'], $attachment['name'], false);
	else
	$MAIL_MIME->addHTMLImage($attachment['path'], $attachment['mimetype'], $attachment['name'], true);
	}
	else {
	$ctype = str_replace('image/pjpeg', 'image/jpeg', $attachment['mimetype']); // #1484914
	$file = $attachment['data'] ? $attachment['data'] : $attachment['path'];

	// .eml attachments send inline
	$MAIL_MIME->addAttachment($file,
	$ctype,
	$attachment['name'],
	($attachment['data'] ? false : true),
	($ctype == 'message/rfc822' ? $transfer_encoding : 'base64'),
	($ctype == 'message/rfc822' ? 'inline' : 'attachment'),
	$message_charset, '', '',
	$CONFIG['mime_param_folding'] ? 'quoted-printable' : NULL,
	$CONFIG['mime_param_folding'] == 2 ? 'quoted-printable' : NULL
	);
	}
	}
	}

	// add submitted attachments
	if (is_array($_FILES['_attachments']['tmp_name'])) {
	foreach ($_FILES['_attachments']['tmp_name'] as $i => $filepath) {
	$ctype = $files['type'][$i];
	$ctype = str_replace('image/pjpeg', 'image/jpeg', $ctype); // #1484914

	$MAIL_MIME->addAttachment($filepath, $ctype, $files['name'][$i], true,
	$ctype == 'message/rfc822' ? $transfer_encoding : 'base64',
	'attachment', $message_charset, '', '',
	$CONFIG['mime_param_folding'] ? 'quoted-printable' : NULL,
	$CONFIG['mime_param_folding'] == 2 ? 'quoted-printable' : NULL
	);
	}
	}

	// encoding settings for mail composing
	$MAIL_MIME->setParam(array(
	'text_encoding' => $transfer_encoding,
	'html_encoding' => 'quoted-printable',
	'head_encoding' => 'quoted-printable',
	'head_charset' => $message_charset,
	'html_charset' => $message_charset,
	'text_charset' => $message_charset,
	));

	$data = $RCMAIL->plugins->exec_hook('outgoing_message_headers', array('headers' => $headers));
	$headers = $data['headers'];

	// encoding subject header with mb_encode provides better results with asian characters
	if (function_exists("mb_encode_mimeheader"))
	{
	mb_internal_encoding($message_charset);
	$headers['Subject'] = mb_encode_mimeheader($headers['Subject'], $message_charset, 'Q');
	mb_internal_encoding(RCMAIL_CHARSET);
	}

	// pass headers to message object
	$MAIL_MIME->headers($headers);

	// Begin SMTP Delivery Block
	if (!$savedraft)
	{
	// check for 'From' address (identity may be incomplete)
	if ($identity_arr && !$identity_arr['mailto']) {
	$OUTPUT->show_message('nofromaddress', 'error');
	$OUTPUT->send('iframe');
	}

	$sent = rcmail_deliver_message($MAIL_MIME, $from, $mailto);

	// return to compose page if sending failed
	if (!$sent)
	{
	$OUTPUT->show_message("sendingfailed", 'error');
	$OUTPUT->send('iframe');
	}

	// save message sent time
	if (!empty($CONFIG['sendmail_delay']))
	$RCMAIL->user->save_prefs(array('last_message_time' => time()));

	// set replied/forwarded flag
	if ($_SESSION['compose']['reply_uid'])
	- $IMAP->set_flag($_SESSION['compose']['reply_uid'], 'ANSWERED');
	+ $IMAP->set_flag($_SESSION['compose']['reply_uid'], 'ANSWERED', $_SESSION['compose']['mailbox']);
	else if ($_SESSION['compose']['forward_uid'])
	- $IMAP->set_flag($_SESSION['compose']['forward_uid'], 'FORWARDED');
	+ $IMAP->set_flag($_SESSION['compose']['forward_uid'], 'FORWARDED', $_SESSION['compose']['mailbox']);

	} // End of SMTP Delivery Block



	// Determine which folder to save message
	if ($savedraft)
	$store_target = $CONFIG['drafts_mbox'];
	else
	$store_target = isset($_POST['_store_target']) ? get_input_value('_store_target', RCUBE_INPUT_POST) : $CONFIG['sent_mbox'];

	if ($store_target)
	{
	// check if mailbox exists
	if (!in_array_nocase($store_target, $IMAP->list_mailboxes()))
	{
	// folder may be existing but not subscribed (#1485241)
	if (!in_array_nocase($store_target, $IMAP->list_unsubscribed()))
	$store_folder = $IMAP->create_mailbox($store_target, TRUE);
	else if ($IMAP->subscribe($store_target))
	$store_folder = TRUE;
	}
	else
	$store_folder = TRUE;

	// append message to sent box
	if ($store_folder)
	$saved = $IMAP->save_message($store_target, $MAIL_MIME->getMessage());

	// raise error if saving failed
	if (!$saved)
	{
	raise_error(array('code' => 800, 'type' => 'imap', 'file' => __FILE__,
	'message' => "Could not save message in $store_target"), TRUE, FALSE);

	if ($savedraft) {
	$OUTPUT->show_message('errorsaving', 'error');
	$OUTPUT->send('iframe');
	}
	}

	if ($olddraftmessageid)
	{
	// delete previous saved draft
	$a_deleteid = $IMAP->search($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$olddraftmessageid);

	$deleted = $IMAP->delete_message($IMAP->get_uid($a_deleteid[0], $CONFIG['drafts_mbox']), $CONFIG['drafts_mbox']);

	// raise error if deletion of old draft failed
	if (!$deleted)
	raise_error(array('code' => 800, 'type' => 'imap', 'file' => __FILE__,
	'message' => "Could not delete message from ".$CONFIG['drafts_mbox']), TRUE, FALSE);
	}
	}

	if ($savedraft)
	{
	$msgid = strtr($message_id, array('>' => '', '<' => ''));

	// remember new draft-uid
	$draftids = $IMAP->search($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$msgid);
	$_SESSION['compose']['param']['_draft_uid'] = $IMAP->get_uid($draftids[0], $CONFIG['drafts_mbox']);

	// display success
	$OUTPUT->show_message('messagesaved', 'confirmation');

	// update "_draft_saveid" and the "cmp_hash" to prevent "Unsaved changes" warning
	$OUTPUT->command('set_draft_id', $msgid);
	$OUTPUT->command('compose_field_hash', true);

	// start the auto-save timer again
	$OUTPUT->command('auto_save_start');

	$OUTPUT->send('iframe');
	}
	else
	{
	rcmail_compose_cleanup();

	if ($store_folder && !$saved)
	$OUTPUT->command('sent_successfully', 'error', rcube_label('errorsavingsent'));
	else
	$OUTPUT->command('sent_successfully', 'confirmation', rcube_label('messagesent'));
	$OUTPUT->send('iframe');
	}

	?>

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 2:17 PM (19 m, 41 s)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 167239
Default Alt Text: (169 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions