program/include/rcmail.php

   1 <?php
   2
   3 /*
   4  +-----------------------------------------------------------------------+
   5  | program/include/rcmail.php                                            |
   6  |                                                                       |
   7  | This file is part of the Roundcube Webmail client                     |
   8  | Copyright (C) 2008-2010, Roundcube Dev. - Switzerland                 |
   9  | Licensed under the GNU GPL                                            |
  10  |                                                                       |
  11  | PURPOSE:                                                              |
  12  |   Application class providing core functions and holding              |
  13  |   instances of all 'global' objects like db- and imap-connections     |
  14  +-----------------------------------------------------------------------+
  15  | Author: Thomas Bruederli <roundcube@gmail.com>                        |
  16  +-----------------------------------------------------------------------+
  17
  18  $Id: rcmail.php 4779 2011-05-17 15:35:14Z alec $
  19
  20 */
  21
  22
  23 /**
  24  * Application class of Roundcube Webmail
  25  * implemented as singleton
  26  *
  27  * @package Core
  28  */
  29 class rcmail
  30 {
  31   /**
  32    * Main tasks.
  33    *
  34    * @var array
  35    */
  36   static public $main_tasks = array('mail','settings','addressbook','login','logout','utils','dummy');
  37
  38   /**
  39    * Singleton instace of rcmail
  40    *
  41    * @var rcmail
  42    */
  43   static private $instance;
  44
  45   /**
  46    * Stores instance of rcube_config.
  47    *
  48    * @var rcube_config
  49    */
  50   public $config;
  51
  52   /**
  53    * Stores rcube_user instance.
  54    *
  55    * @var rcube_user
  56    */
  57   public $user;
  58
  59   /**
  60    * Instace of database class.
  61    *
  62    * @var rcube_mdb2
  63    */
  64   public $db;
  65
  66   /**
  67    * Instace of rcube_session class.
  68    *
  69    * @var rcube_session
  70    */
  71   public $session;
  72
  73   /**
  74    * Instance of rcube_smtp class.
  75    *
  76    * @var rcube_smtp
  77    */
  78   public $smtp;
  79
  80   /**
  81    * Instance of rcube_imap class.
  82    *
  83    * @var rcube_imap
  84    */
  85   public $imap;
  86
  87   /**
  88    * Instance of rcube_template class.
  89    *
  90    * @var rcube_template
  91    */
  92   public $output;
  93
  94   /**
  95    * Instance of rcube_plugin_api.
  96    *
  97    * @var rcube_plugin_api
  98    */
  99   public $plugins;
 100
 101   /**
 102    * Current task.
 103    *
 104    * @var string
 105    */
 106   public $task;
 107
 108   /**
 109    * Current action.
 110    *
 111    * @var string
 112    */
 113   public $action = '';
 114   public $comm_path = './';
 115
 116   private $texts;
 117   private $books = array();
 118
 119
 120   /**
 121    * This implements the 'singleton' design pattern
 122    *
 123    * @return rcmail The one and only instance
 124    */
 125   static function get_instance()
 126   {
 127     if (!self::$instance) {
 128       self::$instance = new rcmail();
 129       self::$instance->startup();  // init AFTER object was linked with self::$instance
 130     }
 131
 132     return self::$instance;
 133   }
 134
 135
 136   /**
 137    * Private constructor
 138    */
 139   private function __construct()
 140   {
 141     // load configuration
 142     $this->config = new rcube_config();
 143
 144     register_shutdown_function(array($this, 'shutdown'));
 145   }
 146
 147
 148   /**
 149    * Initial startup function
 150    * to register session, create database and imap connections
 151    *
 152    * @todo Remove global vars $DB, $USER
 153    */
 154   private function startup()
 155   {
 156     // initialize syslog
 157     if ($this->config->get('log_driver') == 'syslog') {
 158       $syslog_id = $this->config->get('syslog_id', 'roundcube');
 159       $syslog_facility = $this->config->get('syslog_facility', LOG_USER);
 160       openlog($syslog_id, LOG_ODELAY, $syslog_facility);
 161     }
 162
 163     // connect to database
 164     $GLOBALS['DB'] = $this->get_dbh();
 165
 166     // start session
 167     $this->session_init();
 168
 169     // create user object
 170     $this->set_user(new rcube_user($_SESSION['user_id']));
 171
 172     // configure session (after user config merge!)
 173     $this->session_configure();
 174
 175     // set task and action properties
 176     $this->set_task(get_input_value('_task', RCUBE_INPUT_GPC));
 177     $this->action = asciiwords(get_input_value('_action', RCUBE_INPUT_GPC));
 178
 179     // reset some session parameters when changing task
 180     if ($this->task != 'utils') {
 181       if ($this->session && $_SESSION['task'] != $this->task)
 182         $this->session->remove('page');
 183       // set current task to session
 184       $_SESSION['task'] = $this->task;
 185     }
 186
 187     // init output class
 188     if (!empty($_REQUEST['_remote']))
 189       $GLOBALS['OUTPUT'] = $this->json_init();
 190     else
 191       $GLOBALS['OUTPUT'] = $this->load_gui(!empty($_REQUEST['_framed']));
 192
 193     // create plugin API and load plugins
 194     $this->plugins = rcube_plugin_api::get_instance();
 195
 196     // init plugins
 197     $this->plugins->init();
 198   }
 199
 200
 201   /**
 202    * Setter for application task
 203    *
 204    * @param string Task to set
 205    */
 206   public function set_task($task)
 207   {
 208     $task = asciiwords($task);
 209
 210     if ($this->user && $this->user->ID)
 211       $task = !$task ? 'mail' : $task;
 212     else
 213       $task = 'login';
 214
 215     $this->task = $task;
 216     $this->comm_path = $this->url(array('task' => $this->task));
 217
 218     if ($this->output)
 219       $this->output->set_env('task', $this->task);
 220   }
 221
 222
 223   /**
 224    * Setter for system user object
 225    *
 226    * @param rcube_user Current user instance
 227    */
 228   public function set_user($user)
 229   {
 230     if (is_object($user)) {
 231       $this->user = $user;
 232       $GLOBALS['USER'] = $this->user;
 233
 234       // overwrite config with user preferences
 235       $this->config->set_user_prefs((array)$this->user->get_prefs());
 236     }
 237
 238     $_SESSION['language'] = $this->user->language = $this->language_prop($this->config->get('language', $_SESSION['language']));
 239
 240     // set localization
 241     setlocale(LC_ALL, $_SESSION['language'] . '.utf8', 'en_US.utf8');
 242
 243     // workaround for http://bugs.php.net/bug.php?id=18556
 244     if (in_array($_SESSION['language'], array('tr_TR', 'ku', 'az_AZ')))
 245       setlocale(LC_CTYPE, 'en_US' . '.utf8');
 246   }
 247
 248
 249   /**
 250    * Check the given string and return a valid language code
 251    *
 252    * @param string Language code
 253    * @return string Valid language code
 254    */
 255   private function language_prop($lang)
 256   {
 257     static $rcube_languages, $rcube_language_aliases;
 258
 259     // user HTTP_ACCEPT_LANGUAGE if no language is specified
 260     if (empty($lang) || $lang == 'auto') {
 261        $accept_langs = explode(',', $_SERVER['HTTP_ACCEPT_LANGUAGE']);
 262        $lang = str_replace('-', '_', $accept_langs[0]);
 263      }
 264
 265     if (empty($rcube_languages)) {
 266       @include(INSTALL_PATH . 'program/localization/index.inc');
 267     }
 268
 269     // check if we have an alias for that language
 270     if (!isset($rcube_languages[$lang]) && isset($rcube_language_aliases[$lang])) {
 271       $lang = $rcube_language_aliases[$lang];
 272     }
 273     // try the first two chars
 274     else if (!isset($rcube_languages[$lang])) {
 275       $short = substr($lang, 0, 2);
 276
 277       // check if we have an alias for the short language code
 278       if (!isset($rcube_languages[$short]) && isset($rcube_language_aliases[$short])) {
 279         $lang = $rcube_language_aliases[$short];
 280       }
 281       // expand 'nn' to 'nn_NN'
 282       else if (!isset($rcube_languages[$short])) {
 283         $lang = $short.'_'.strtoupper($short);
 284       }
 285     }
 286
 287     if (!isset($rcube_languages[$lang]) || !is_dir(INSTALL_PATH . 'program/localization/' . $lang)) {
 288       $lang = 'en_US';
 289     }
 290
 291     return $lang;
 292   }
 293
 294
 295   /**
 296    * Get the current database connection
 297    *
 298    * @return rcube_mdb2  Database connection object
 299    */
 300   public function get_dbh()
 301   {
 302     if (!$this->db) {
 303       $config_all = $this->config->all();
 304
 305       $this->db = new rcube_mdb2($config_all['db_dsnw'], $config_all['db_dsnr'], $config_all['db_persistent']);
 306       $this->db->sqlite_initials = INSTALL_PATH . 'SQL/sqlite.initial.sql';
 307       $this->db->set_debug((bool)$config_all['sql_debug']);
 308     }
 309
 310     return $this->db;
 311   }
 312
 313
 314   /**
 315    * Return instance of the internal address book class
 316    *
 317    * @param string  Address book identifier
 318    * @param boolean True if the address book needs to be writeable
 319    * @return rcube_contacts Address book object
 320    */
 321   public function get_address_book($id, $writeable = false)
 322   {
 323     $contacts = null;
 324     $ldap_config = (array)$this->config->get('ldap_public');
 325     $abook_type = strtolower($this->config->get('address_book_type'));
 326
 327     $plugin = $this->plugins->exec_hook('addressbook_get', array('id' => $id, 'writeable' => $writeable));
 328
 329     // plugin returned instance of a rcube_addressbook
 330     if ($plugin['instance'] instanceof rcube_addressbook) {
 331       $contacts = $plugin['instance'];
 332     }
 333     else if ($id && $ldap_config[$id]) {
 334       $contacts = new rcube_ldap($ldap_config[$id], $this->config->get('ldap_debug'), $this->config->mail_domain($_SESSION['imap_host']));
 335     }
 336     else if ($id === '0') {
 337       $contacts = new rcube_contacts($this->db, $this->user->ID);
 338     }
 339     else if ($abook_type == 'ldap') {
 340       // Use the first writable LDAP address book.
 341       foreach ($ldap_config as $id => $prop) {
 342         if (!$writeable || $prop['writable']) {
 343           $contacts = new rcube_ldap($prop, $this->config->get('ldap_debug'), $this->config->mail_domain($_SESSION['imap_host']));
 344           break;
 345         }
 346       }
 347     }
 348     else { // $id == 'sql'
 349       $contacts = new rcube_contacts($this->db, $this->user->ID);
 350     }
 351
 352     // add to the 'books' array for shutdown function
 353     if (!in_array($contacts, $this->books))
 354       $this->books[] = $contacts;
 355
 356     return $contacts;
 357   }
 358
 359
 360   /**
 361    * Return address books list
 362    *
 363    * @param boolean True if the address book needs to be writeable
 364    * @return array  Address books array
 365    */
 366   public function get_address_sources($writeable = false)
 367   {
 368     $abook_type = strtolower($this->config->get('address_book_type'));
 369     $ldap_config = $this->config->get('ldap_public');
 370     $autocomplete = (array) $this->config->get('autocomplete_addressbooks');
 371     $list = array();
 372
 373     // We are using the DB address book
 374     if ($abook_type != 'ldap') {
 375       $contacts = new rcube_contacts($this->db, null);
 376       $list['0'] = array(
 377         'id' => 0,
 378         'name' => rcube_label('personaladrbook'),
 379         'groups' => $contacts->groups,
 380         'readonly' => false,
 381         'autocomplete' => in_array('sql', $autocomplete)
 382       );
 383     }
 384
 385     if ($ldap_config) {
 386       $ldap_config = (array) $ldap_config;
 387       foreach ($ldap_config as $id => $prop)
 388         $list[$id] = array(
 389           'id' => $id,
 390           'name' => $prop['name'],
 391           'groups' => false,
 392           'readonly' => !$prop['writable'],
 393           'autocomplete' => in_array('sql', $autocomplete)
 394         );
 395     }
 396
 397     $plugin = $this->plugins->exec_hook('addressbooks_list', array('sources' => $list));
 398     $list = $plugin['sources'];
 399
 400     if ($writeable && !empty($list)) {
 401       foreach ($list as $idx => $item) {
 402         if ($item['readonly']) {
 403           unset($list[$idx]);
 404         }
 405       }
 406     }
 407
 408     return $list;
 409   }
 410
 411
 412   /**
 413    * Init output object for GUI and add common scripts.
 414    * This will instantiate a rcmail_template object and set
 415    * environment vars according to the current session and configuration
 416    *
 417    * @param boolean True if this request is loaded in a (i)frame
 418    * @return rcube_template Reference to HTML output object
 419    */
 420   public function load_gui($framed = false)
 421   {
 422     // init output page
 423     if (!($this->output instanceof rcube_template))
 424       $this->output = new rcube_template($this->task, $framed);
 425
 426     // set keep-alive/check-recent interval
 427     if ($this->session && ($keep_alive = $this->session->get_keep_alive())) {
 428       $this->output->set_env('keep_alive', $keep_alive);
 429     }
 430
 431     if ($framed) {
 432       $this->comm_path .= '&_framed=1';
 433       $this->output->set_env('framed', true);
 434     }
 435
 436     $this->output->set_env('task', $this->task);
 437     $this->output->set_env('action', $this->action);
 438     $this->output->set_env('comm_path', $this->comm_path);
 439     $this->output->set_charset(RCMAIL_CHARSET);
 440
 441     // add some basic label to client
 442     $this->output->add_label('loading', 'servererror');
 443
 444     return $this->output;
 445   }
 446
 447
 448   /**
 449    * Create an output object for JSON responses
 450    *
 451    * @return rcube_json_output Reference to JSON output object
 452    */
 453   public function json_init()
 454   {
 455     if (!($this->output instanceof rcube_json_output))
 456       $this->output = new rcube_json_output($this->task);
 457
 458     return $this->output;
 459   }
 460
 461
 462   /**
 463    * Create SMTP object and connect to server
 464    *
 465    * @param boolean True if connection should be established
 466    */
 467   public function smtp_init($connect = false)
 468   {
 469     $this->smtp = new rcube_smtp();
 470
 471     if ($connect)
 472       $this->smtp->connect();
 473   }
 474
 475
 476   /**
 477    * Create global IMAP object and connect to server
 478    *
 479    * @param boolean True if connection should be established
 480    * @todo Remove global $IMAP
 481    */
 482   public function imap_init($connect = false)
 483   {
 484     // already initialized
 485     if (is_object($this->imap))
 486       return;
 487
 488     $this->imap = new rcube_imap($this->db);
 489     $this->imap->debug_level = $this->config->get('debug_level');
 490     $this->imap->skip_deleted = $this->config->get('skip_deleted');
 491
 492     // enable caching of imap data
 493     if ($this->config->get('enable_caching')) {
 494       $this->imap->set_caching(true);
 495     }
 496
 497     // set pagesize from config
 498     $this->imap->set_pagesize($this->config->get('pagesize', 50));
 499
 500     // Setting root and delimiter before establishing the connection
 501     // can save time detecting them using NAMESPACE and LIST
 502     $options = array(
 503       'auth_method' => $this->config->get('imap_auth_type', 'check'),
 504       'auth_cid'    => $this->config->get('imap_auth_cid'),
 505       'auth_pw'     => $this->config->get('imap_auth_pw'),
 506       'debug'       => (bool) $this->config->get('imap_debug', 0),
 507       'force_caps'  => (bool) $this->config->get('imap_force_caps'),
 508       'timeout'     => (int) $this->config->get('imap_timeout', 0),
 509     );
 510
 511     $this->imap->set_options($options);
 512
 513     // set global object for backward compatibility
 514     $GLOBALS['IMAP'] = $this->imap;
 515
 516     $hook = $this->plugins->exec_hook('imap_init', array('fetch_headers' => $this->imap->fetch_add_headers));
 517     if ($hook['fetch_headers'])
 518       $this->imap->fetch_add_headers = $hook['fetch_headers'];
 519
 520     // support this parameter for backward compatibility but log warning
 521     if ($connect) {
 522       $this->imap_connect();
 523       raise_error(array(
 524         'code' => 800, 'type' => 'imap',
 525         'file' => __FILE__, 'line' => __LINE__,
 526         'message' => "rcube::imap_init(true) is deprecated, use rcube::imap_connect() instead"),
 527         true, false);
 528     }
 529   }
 530
 531
 532   /**
 533    * Connect to IMAP server with stored session data
 534    *
 535    * @return bool True on success, false on error
 536    */
 537   public function imap_connect()
 538   {
 539     if (!$this->imap)
 540       $this->imap_init();
 541
 542     if ($_SESSION['imap_host'] && !$this->imap->conn->connected()) {
 543       if (!$this->imap->connect($_SESSION['imap_host'], $_SESSION['username'], $this->decrypt($_SESSION['password']), $_SESSION['imap_port'], $_SESSION['imap_ssl'])) {
 544         if ($this->output)
 545           $this->output->show_message($this->imap->get_error_code() == -1 ? 'imaperror' : 'sessionerror', 'error');
 546       }
 547       else {
 548         $this->set_imap_prop();
 549         return $this->imap->conn;
 550       }
 551     }
 552
 553     return false;
 554   }
 555
 556
 557   /**
 558    * Create session object and start the session.
 559    */
 560   public function session_init()
 561   {
 562     // session started (Installer?)
 563     if (session_id())
 564       return;
 565
 566     $lifetime = $this->config->get('session_lifetime', 0) * 60;
 567
 568     // set session domain
 569     if ($domain = $this->config->get('session_domain')) {
 570       ini_set('session.cookie_domain', $domain);
 571     }
 572     // set session garbage collecting time according to session_lifetime
 573     if ($lifetime) {
 574       ini_set('session.gc_maxlifetime', $lifetime * 2);
 575     }
 576
 577     ini_set('session.cookie_secure', rcube_https_check());
 578     ini_set('session.name', 'roundcube_sessid');
 579     ini_set('session.use_cookies', 1);
 580     ini_set('session.use_only_cookies', 1);
 581     ini_set('session.serialize_handler', 'php');
 582
 583     // use database for storing session data
 584     $this->session = new rcube_session($this->get_dbh(), $lifetime);
 585
 586     $this->session->register_gc_handler('rcmail_temp_gc');
 587     if ($this->config->get('enable_caching'))
 588       $this->session->register_gc_handler('rcmail_cache_gc');
 589
 590     // start PHP session (if not in CLI mode)
 591     if ($_SERVER['REMOTE_ADDR'])
 592       session_start();
 593
 594     // set initial session vars
 595     if (!isset($_SESSION['auth_time'])) {
 596       $_SESSION['auth_time'] = time();
 597       $_SESSION['temp'] = true;
 598     }
 599   }
 600
 601
 602   /**
 603    * Configure session object internals
 604    */
 605   public function session_configure()
 606   {
 607     if (!$this->session)
 608       return;
 609
 610     $lifetime = $this->config->get('session_lifetime', 0) * 60;
 611
 612     // set keep-alive/check-recent interval
 613     if ($keep_alive = $this->config->get('keep_alive')) {
 614       // be sure that it's less than session lifetime
 615       if ($lifetime)
 616         $keep_alive = min($keep_alive, $lifetime - 30);
 617       $keep_alive = max(60, $keep_alive);
 618       $this->session->set_keep_alive($keep_alive);
 619     }
 620   }
 621
 622
 623   /**
 624    * Perfom login to the IMAP server and to the webmail service.
 625    * This will also create a new user entry if auto_create_user is configured.
 626    *
 627    * @param string IMAP user name
 628    * @param string IMAP password
 629    * @param string IMAP host
 630    * @return boolean True on success, False on failure
 631    */
 632   function login($username, $pass, $host=NULL)
 633   {
 634     $user = NULL;
 635     $config = $this->config->all();
 636
 637     if (!$host)
 638       $host = $config['default_host'];
 639
 640     // Validate that selected host is in the list of configured hosts
 641     if (is_array($config['default_host'])) {
 642       $allowed = false;
 643       foreach ($config['default_host'] as $key => $host_allowed) {
 644         if (!is_numeric($key))
 645           $host_allowed = $key;
 646         if ($host == $host_allowed) {
 647           $allowed = true;
 648           break;
 649         }
 650       }
 651       if (!$allowed)
 652         return false;
 653       }
 654     else if (!empty($config['default_host']) && $host != rcube_parse_host($config['default_host']))
 655       return false;
 656
 657     // parse $host URL
 658     $a_host = parse_url($host);
 659     if ($a_host['host']) {
 660       $host = $a_host['host'];
 661       $imap_ssl = (isset($a_host['scheme']) && in_array($a_host['scheme'], array('ssl','imaps','tls'))) ? $a_host['scheme'] : null;
 662       if (!empty($a_host['port']))
 663         $imap_port = $a_host['port'];
 664       else if ($imap_ssl && $imap_ssl != 'tls' && (!$config['default_port'] || $config['default_port'] == 143))
 665         $imap_port = 993;
 666     }
 667
 668     $imap_port = $imap_port ? $imap_port : $config['default_port'];
 669
 670     /* Modify username with domain if required
 671        Inspired by Marco <P0L0_notspam_binware.org>
 672     */
 673     // Check if we need to add domain
 674     if (!empty($config['username_domain']) && strpos($username, '@') === false) {
 675       if (is_array($config['username_domain']) && isset($config['username_domain'][$host]))
 676         $username .= '@'.rcube_parse_host($config['username_domain'][$host], $host);
 677       else if (is_string($config['username_domain']))
 678         $username .= '@'.rcube_parse_host($config['username_domain'], $host);
 679     }
 680
 681     // Convert username to lowercase. If IMAP backend
 682     // is case-insensitive we need to store always the same username (#1487113)
 683     if ($config['login_lc']) {
 684       $username = mb_strtolower($username);
 685     }
 686
 687     // try to resolve email address from virtuser table
 688     if (strpos($username, '@') && ($virtuser = rcube_user::email2user($username))) {
 689       $username = $virtuser;
 690     }
 691
 692     // Here we need IDNA ASCII
 693     // Only rcube_contacts class is using domain names in Unicode
 694     $host = rcube_idn_to_ascii($host);
 695     if (strpos($username, '@')) {
 696       // lowercase domain name
 697       list($local, $domain) = explode('@', $username);
 698       $username = $local . '@' . mb_strtolower($domain);
 699       $username = rcube_idn_to_ascii($username);
 700     }
 701
 702     // user already registered -> overwrite username
 703     if ($user = rcube_user::query($username, $host))
 704       $username = $user->data['username'];
 705
 706     if (!$this->imap)
 707       $this->imap_init();
 708
 709     // try IMAP login
 710     if (!($imap_login = $this->imap->connect($host, $username, $pass, $imap_port, $imap_ssl))) {
 711       // try with lowercase
 712       $username_lc = mb_strtolower($username);
 713       if ($username_lc != $username) {
 714         // try to find user record again -> overwrite username
 715         if (!$user && ($user = rcube_user::query($username_lc, $host)))
 716           $username_lc = $user->data['username'];
 717
 718         if ($imap_login = $this->imap->connect($host, $username_lc, $pass, $imap_port, $imap_ssl))
 719           $username = $username_lc;
 720       }
 721     }
 722
 723     // exit if IMAP login failed
 724     if (!$imap_login)
 725       return false;
 726
 727     $this->set_imap_prop();
 728
 729     // user already registered -> update user's record
 730     if (is_object($user)) {
 731       // create default folders on first login
 732       if (!$user->data['last_login'] && $config['create_default_folders'])
 733         $this->imap->create_default_folders();
 734       $user->touch();
 735     }
 736     // create new system user
 737     else if ($config['auto_create_user']) {
 738       if ($created = rcube_user::create($username, $host)) {
 739         $user = $created;
 740         // create default folders on first login
 741         if ($config['create_default_folders'])
 742           $this->imap->create_default_folders();
 743       }
 744       else {
 745         raise_error(array(
 746           'code' => 600, 'type' => 'php',
 747           'file' => __FILE__, 'line' => __LINE__,
 748           'message' => "Failed to create a user record. Maybe aborted by a plugin?"
 749           ), true, false);
 750       }
 751     }
 752     else {
 753       raise_error(array(
 754         'code' => 600, 'type' => 'php',
 755         'file' => __FILE__, 'line' => __LINE__,
 756         'message' => "Acces denied for new user $username. 'auto_create_user' is disabled"
 757         ), true, false);
 758     }
 759
 760     // login succeeded
 761     if (is_object($user) && $user->ID) {
 762       $this->set_user($user);
 763
 764       // set session vars
 765       $_SESSION['user_id']   = $user->ID;
 766       $_SESSION['username']  = $user->data['username'];
 767       $_SESSION['imap_host'] = $host;
 768       $_SESSION['imap_port'] = $imap_port;
 769       $_SESSION['imap_ssl']  = $imap_ssl;
 770       $_SESSION['password']  = $this->encrypt($pass);
 771       $_SESSION['login_time'] = mktime();
 772
 773       if (isset($_REQUEST['_timezone']) && $_REQUEST['_timezone'] != '_default_')
 774         $_SESSION['timezone'] = floatval($_REQUEST['_timezone']);
 775
 776       // force reloading complete list of subscribed mailboxes
 777       $this->imap->clear_cache('mailboxes');
 778
 779       return true;
 780     }
 781
 782     return false;
 783   }
 784
 785
 786   /**
 787    * Set root dir and last stored mailbox
 788    * This must be done AFTER connecting to the server!
 789    */
 790   public function set_imap_prop()
 791   {
 792     $this->imap->set_charset($this->config->get('default_charset', RCMAIL_CHARSET));
 793
 794     if ($default_folders = $this->config->get('default_imap_folders')) {
 795       $this->imap->set_default_mailboxes($default_folders);
 796     }
 797     if (isset($_SESSION['mbox'])) {
 798       $this->imap->set_mailbox($_SESSION['mbox']);
 799     }
 800     if (isset($_SESSION['page'])) {
 801       $this->imap->set_page($_SESSION['page']);
 802     }
 803   }
 804
 805
 806   /**
 807    * Auto-select IMAP host based on the posted login information
 808    *
 809    * @return string Selected IMAP host
 810    */
 811   public function autoselect_host()
 812   {
 813     $default_host = $this->config->get('default_host');
 814     $host = null;
 815
 816     if (is_array($default_host)) {
 817       $post_host = get_input_value('_host', RCUBE_INPUT_POST);
 818
 819       // direct match in default_host array
 820       if ($default_host[$post_host] || in_array($post_host, array_values($default_host))) {
 821         $host = $post_host;
 822       }
 823
 824       // try to select host by mail domain
 825       list($user, $domain) = explode('@', get_input_value('_user', RCUBE_INPUT_POST));
 826       if (!empty($domain)) {
 827         foreach ($default_host as $imap_host => $mail_domains) {
 828           if (is_array($mail_domains) && in_array($domain, $mail_domains)) {
 829             $host = $imap_host;
 830             break;
 831           }
 832         }
 833       }
 834
 835       // take the first entry if $host is still an array
 836       if (empty($host)) {
 837         $host = array_shift($default_host);
 838       }
 839     }
 840     else if (empty($default_host)) {
 841       $host = get_input_value('_host', RCUBE_INPUT_POST);
 842     }
 843     else
 844       $host = rcube_parse_host($default_host);
 845
 846     return $host;
 847   }
 848
 849
 850   /**
 851    * Get localized text in the desired language
 852    *
 853    * @param mixed Named parameters array or label name
 854    * @return string Localized text
 855    */
 856   public function gettext($attrib, $domain=null)
 857   {
 858     // load localization files if not done yet
 859     if (empty($this->texts))
 860       $this->load_language();
 861
 862     // extract attributes
 863     if (is_string($attrib))
 864       $attrib = array('name' => $attrib);
 865
 866     $nr = is_numeric($attrib['nr']) ? $attrib['nr'] : 1;
 867     $name = $attrib['name'] ? $attrib['name'] : '';
 868
 869     // check for text with domain
 870     if ($domain && ($text_item = $this->texts[$domain.'.'.$name]))
 871       ;
 872     // text does not exist
 873     else if (!($text_item = $this->texts[$name])) {
 874       return "[$name]";
 875     }
 876
 877     // make text item array
 878     $a_text_item = is_array($text_item) ? $text_item : array('single' => $text_item);
 879
 880     // decide which text to use
 881     if ($nr == 1) {
 882       $text = $a_text_item['single'];
 883     }
 884     else if ($nr > 0) {
 885       $text = $a_text_item['multiple'];
 886     }
 887     else if ($nr == 0) {
 888       if ($a_text_item['none'])
 889         $text = $a_text_item['none'];
 890       else if ($a_text_item['single'])
 891         $text = $a_text_item['single'];
 892       else if ($a_text_item['multiple'])
 893         $text = $a_text_item['multiple'];
 894     }
 895
 896     // default text is single
 897     if ($text == '') {
 898       $text = $a_text_item['single'];
 899     }
 900
 901     // replace vars in text
 902     if (is_array($attrib['vars'])) {
 903       foreach ($attrib['vars'] as $var_key => $var_value)
 904         $text = str_replace($var_key[0]!='$' ? '$'.$var_key : $var_key, $var_value, $text);
 905     }
 906
 907     // format output
 908     if (($attrib['uppercase'] && strtolower($attrib['uppercase']=='first')) || $attrib['ucfirst'])
 909       return ucfirst($text);
 910     else if ($attrib['uppercase'])
 911       return mb_strtoupper($text);
 912     else if ($attrib['lowercase'])
 913       return mb_strtolower($text);
 914
 915     return $text;
 916   }
 917
 918   /**
 919    * Check if the given text lable exists
 920    *
 921    * @param string Label name
 922    * @return boolean True if text exists (either in the current language or in en_US)
 923    */
 924   public function text_exists($name, $domain=null)
 925   {
 926     // load localization files if not done yet
 927     if (empty($this->texts))
 928       $this->load_language();
 929
 930     // check for text with domain first
 931     return ($domain && isset($this->texts[$domain.'.'.$name])) || isset($this->texts[$name]);
 932   }
 933
 934   /**
 935    * Load a localization package
 936    *
 937    * @param string Language ID
 938    */
 939   public function load_language($lang = null, $add = array())
 940   {
 941     $lang = $this->language_prop(($lang ? $lang : $_SESSION['language']));
 942
 943     // load localized texts
 944     if (empty($this->texts) || $lang != $_SESSION['language']) {
 945       $this->texts = array();
 946
 947       // handle empty lines after closing PHP tag in localization files
 948       ob_start();
 949
 950       // get english labels (these should be complete)
 951       @include(INSTALL_PATH . 'program/localization/en_US/labels.inc');
 952       @include(INSTALL_PATH . 'program/localization/en_US/messages.inc');
 953
 954       if (is_array($labels))
 955         $this->texts = $labels;
 956       if (is_array($messages))
 957         $this->texts = array_merge($this->texts, $messages);
 958
 959       // include user language files
 960       if ($lang != 'en' && is_dir(INSTALL_PATH . 'program/localization/' . $lang)) {
 961         include_once(INSTALL_PATH . 'program/localization/' . $lang . '/labels.inc');
 962         include_once(INSTALL_PATH . 'program/localization/' . $lang . '/messages.inc');
 963
 964         if (is_array($labels))
 965           $this->texts = array_merge($this->texts, $labels);
 966         if (is_array($messages))
 967           $this->texts = array_merge($this->texts, $messages);
 968       }
 969
 970       ob_end_clean();
 971
 972       $_SESSION['language'] = $lang;
 973     }
 974
 975     // append additional texts (from plugin)
 976     if (is_array($add) && !empty($add))
 977       $this->texts += $add;
 978   }
 979
 980
 981   /**
 982    * Read directory program/localization and return a list of available languages
 983    *
 984    * @return array List of available localizations
 985    */
 986   public function list_languages()
 987   {
 988     static $sa_languages = array();
 989
 990     if (!sizeof($sa_languages)) {
 991       @include(INSTALL_PATH . 'program/localization/index.inc');
 992
 993       if ($dh = @opendir(INSTALL_PATH . 'program/localization')) {
 994         while (($name = readdir($dh)) !== false) {
 995           if ($name[0] == '.' || !is_dir(INSTALL_PATH . 'program/localization/' . $name))
 996             continue;
 997
 998           if ($label = $rcube_languages[$name])
 999             $sa_languages[$name] = $label;
1000         }
1001         closedir($dh);
1002       }
1003     }
1004
1005     return $sa_languages;
1006   }
1007
1008
1009   /**
1010    * Check the auth hash sent by the client against the local session credentials
1011    *
1012    * @return boolean True if valid, False if not
1013    */
1014   function authenticate_session()
1015   {
1016     // advanced session authentication
1017     if ($this->config->get('double_auth')) {
1018       $now = time();
1019       $valid = ($_COOKIE['sessauth'] == $this->get_auth_hash(session_id(), $_SESSION['auth_time']) ||
1020                 $_COOKIE['sessauth'] == $this->get_auth_hash(session_id(), $_SESSION['last_auth']));
1021
1022       // renew auth cookie every 5 minutes (only for GET requests)
1023       if (!$valid || ($_SERVER['REQUEST_METHOD']!='POST' && $now - $_SESSION['auth_time'] > 300)) {
1024         $_SESSION['last_auth'] = $_SESSION['auth_time'];
1025         $_SESSION['auth_time'] = $now;
1026         rcmail::setcookie('sessauth', $this->get_auth_hash(session_id(), $now), 0);
1027       }
1028     }
1029     else {
1030       $valid = $this->config->get('ip_check') ? $_SERVER['REMOTE_ADDR'] == $this->session->get_ip() : true;
1031     }
1032
1033     // check session filetime
1034     $lifetime = $this->config->get('session_lifetime');
1035     $sess_ts = $this->session->get_ts();
1036     if (!empty($lifetime) && !empty($sess_ts) && $sess_ts + $lifetime*60 < time()) {
1037       $valid = false;
1038     }
1039
1040     return $valid;
1041   }
1042
1043
1044   /**
1045    * Destroy session data and remove cookie
1046    */
1047   public function kill_session()
1048   {
1049     $this->plugins->exec_hook('session_destroy');
1050
1051     $this->session->remove();
1052     $_SESSION = array('language' => $this->user->language, 'auth_time' => time(), 'temp' => true);
1053     rcmail::setcookie('sessauth', '-del-', time() - 60);
1054     $this->user->reset();
1055   }
1056
1057
1058   /**
1059    * Do server side actions on logout
1060    */
1061   public function logout_actions()
1062   {
1063     $config = $this->config->all();
1064
1065     // on logout action we're not connected to imap server
1066     if (($config['logout_purge'] && !empty($config['trash_mbox'])) || $config['logout_expunge']) {
1067       if (!$this->authenticate_session())
1068         return;
1069
1070       $this->imap_connect();
1071     }
1072
1073     if ($config['logout_purge'] && !empty($config['trash_mbox'])) {
1074       $this->imap->clear_mailbox($config['trash_mbox']);
1075     }
1076
1077     if ($config['logout_expunge']) {
1078       $this->imap->expunge('INBOX');
1079     }
1080   }
1081
1082
1083   /**
1084    * Function to be executed in script shutdown
1085    * Registered with register_shutdown_function()
1086    */
1087   public function shutdown()
1088   {
1089     if (is_object($this->smtp))
1090       $this->smtp->disconnect();
1091
1092     foreach ($this->books as $book)
1093       if (is_object($book))
1094         $book->close();
1095
1096     if (is_object($this->imap))
1097       $this->imap->close();
1098
1099     // before closing the database connection, write session data
1100     if ($_SERVER['REMOTE_ADDR'])
1101       session_write_close();
1102
1103     // write performance stats to logs/console
1104     if ($this->config->get('devel_mode')) {
1105       if (function_exists('memory_get_usage'))
1106         $mem = show_bytes(memory_get_usage());
1107       if (function_exists('memory_get_peak_usage'))
1108         $mem .= '/'.show_bytes(memory_get_peak_usage());
1109
1110       $log = $this->task . ($this->action ? '/'.$this->action : '') . ($mem ? " [$mem]" : '');
1111       if (defined('RCMAIL_START'))
1112         rcube_print_time(RCMAIL_START, $log);
1113       else
1114         console($log);
1115     }
1116   }
1117
1118
1119   /**
1120    * Generate a unique token to be used in a form request
1121    *
1122    * @return string The request token
1123    */
1124   public function get_request_token()
1125   {
1126     $sess_id = $_COOKIE[ini_get('session.name')];
1127     if (!$sess_id) $sess_id = session_id();
1128     return md5('RT' . $this->task . $this->config->get('des_key') . $sess_id);
1129   }
1130
1131
1132   /**
1133    * Check if the current request contains a valid token
1134    *
1135    * @param int Request method
1136    * @return boolean True if request token is valid false if not
1137    */
1138   public function check_request($mode = RCUBE_INPUT_POST)
1139   {
1140     $token = get_input_value('_token', $mode);
1141     $sess_id = $_COOKIE[ini_get('session.name')];
1142     return !empty($sess_id) && $token == $this->get_request_token();
1143   }
1144
1145
1146   /**
1147    * Create unique authorization hash
1148    *
1149    * @param string Session ID
1150    * @param int Timestamp
1151    * @return string The generated auth hash
1152    */
1153   private function get_auth_hash($sess_id, $ts)
1154   {
1155     $auth_string = sprintf('rcmail*sess%sR%s*Chk:%s;%s',
1156       $sess_id,
1157       $ts,
1158       $this->config->get('ip_check') ? $_SERVER['REMOTE_ADDR'] : '***.***.***.***',
1159       $_SERVER['HTTP_USER_AGENT']);
1160
1161     if (function_exists('sha1'))
1162       return sha1($auth_string);
1163     else
1164       return md5($auth_string);
1165   }
1166
1167
1168   /**
1169    * Encrypt using 3DES
1170    *
1171    * @param string $clear clear text input
1172    * @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
1173    * @param boolean $base64 whether or not to base64_encode() the result before returning
1174    *
1175    * @return string encrypted text
1176    */
1177   public function encrypt($clear, $key = 'des_key', $base64 = true)
1178   {
1179     if (!$clear)
1180       return '';
1181     /*-
1182      * Add a single canary byte to the end of the clear text, which
1183      * will help find out how much of padding will need to be removed
1184      * upon decryption; see http://php.net/mcrypt_generic#68082
1185      */
1186     $clear = pack("a*H2", $clear, "80");
1187
1188     if (function_exists('mcrypt_module_open') &&
1189         ($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, "")))
1190     {
1191       $iv = $this->create_iv(mcrypt_enc_get_iv_size($td));
1192       mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
1193       $cipher = $iv . mcrypt_generic($td, $clear);
1194       mcrypt_generic_deinit($td);
1195       mcrypt_module_close($td);
1196     }
1197     else {
1198       //@include_once('lib/des.inc'); (not shipped with this distribution)
1199
1200       if (function_exists('des')) {
1201         $des_iv_size = 8;
1202         $iv = $this->create_iv($des_iv_size);
1203         $cipher = $iv . des($this->config->get_crypto_key($key), $clear, 1, 1, $iv);
1204       }
1205       else {
1206         raise_error(array(
1207           'code' => 500, 'type' => 'php',
1208           'file' => __FILE__, 'line' => __LINE__,
1209           'message' => "Could not perform encryption; make sure Mcrypt is installed or lib/des.inc is available"
1210         ), true, true);
1211       }
1212     }
1213
1214     return $base64 ? base64_encode($cipher) : $cipher;
1215   }
1216
1217   /**
1218    * Decrypt 3DES-encrypted string
1219    *
1220    * @param string $cipher encrypted text
1221    * @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
1222    * @param boolean $base64 whether or not input is base64-encoded
1223    *
1224    * @return string decrypted text
1225    */
1226   public function decrypt($cipher, $key = 'des_key', $base64 = true)
1227   {
1228     if (!$cipher)
1229       return '';
1230
1231     $cipher = $base64 ? base64_decode($cipher) : $cipher;
1232
1233     if (function_exists('mcrypt_module_open') &&
1234         ($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, "")))
1235     {
1236       $iv_size = mcrypt_enc_get_iv_size($td);
1237       $iv = substr($cipher, 0, $iv_size);
1238
1239       // session corruption? (#1485970)
1240       if (strlen($iv) < $iv_size)
1241         return '';
1242
1243       $cipher = substr($cipher, $iv_size);
1244       mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
1245       $clear = mdecrypt_generic($td, $cipher);
1246       mcrypt_generic_deinit($td);
1247       mcrypt_module_close($td);
1248     }
1249     else {
1250       // @include_once('lib/des.inc'); (not shipped with this distribution)
1251
1252       if (function_exists('des')) {
1253         $des_iv_size = 8;
1254         $iv = substr($cipher, 0, $des_iv_size);
1255         $cipher = substr($cipher, $des_iv_size);
1256         $clear = des($this->config->get_crypto_key($key), $cipher, 0, 1, $iv);
1257       }
1258       else {
1259         raise_error(array(
1260           'code' => 500, 'type' => 'php',
1261           'file' => __FILE__, 'line' => __LINE__,
1262           'message' => "Could not perform decryption; make sure Mcrypt is installed or lib/des.inc is available"
1263         ), true, true);
1264       }
1265     }
1266
1267     /*-
1268      * Trim PHP's padding and the canary byte; see note in
1269      * rcmail::encrypt() and http://php.net/mcrypt_generic#68082
1270      */
1271     $clear = substr(rtrim($clear, "\0"), 0, -1);
1272
1273     return $clear;
1274   }
1275
1276   /**
1277    * Generates encryption initialization vector (IV)
1278    *
1279    * @param int Vector size
1280    * @return string Vector string
1281    */
1282   private function create_iv($size)
1283   {
1284     // mcrypt_create_iv() can be slow when system lacks entrophy
1285     // we'll generate IV vector manually
1286     $iv = '';
1287     for ($i = 0; $i < $size; $i++)
1288         $iv .= chr(mt_rand(0, 255));
1289     return $iv;
1290   }
1291
1292   /**
1293    * Build a valid URL to this instance of Roundcube
1294    *
1295    * @param mixed Either a string with the action or url parameters as key-value pairs
1296    * @return string Valid application URL
1297    */
1298   public function url($p)
1299   {
1300     if (!is_array($p))
1301       $p = array('_action' => @func_get_arg(0));
1302
1303     $task = $p['_task'] ? $p['_task'] : ($p['task'] ? $p['task'] : $this->task);
1304     $p['_task'] = $task;
1305     unset($p['task']);
1306
1307     $url = './';
1308     $delm = '?';
1309     foreach (array_reverse($p) as $key => $val)
1310     {
1311       if (!empty($val)) {
1312         $par = $key[0] == '_' ? $key : '_'.$key;
1313         $url .= $delm.urlencode($par).'='.urlencode($val);
1314         $delm = '&';
1315       }
1316     }
1317     return $url;
1318   }
1319
1320
1321   /**
1322    * Helper method to set a cookie with the current path and host settings
1323    *
1324    * @param string Cookie name
1325    * @param string Cookie value
1326    * @param string Expiration time
1327    */
1328   public static function setcookie($name, $value, $exp = 0)
1329   {
1330     if (headers_sent())
1331       return;
1332
1333     $cookie = session_get_cookie_params();
1334
1335     setcookie($name, $value, $exp, $cookie['path'], $cookie['domain'],
1336       rcube_https_check(), true);
1337   }
1338 }
1339
1340