program/include/rcmail.php.orig

   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   /**
 920    * Load a localization package
 921    *
 922    * @param string Language ID
 923    */
 924   public function load_language($lang = null, $add = array())
 925   {
 926     $lang = $this->language_prop(($lang ? $lang : $_SESSION['language']));
 927
 928     // load localized texts
 929     if (empty($this->texts) || $lang != $_SESSION['language']) {
 930       $this->texts = array();
 931
 932       // handle empty lines after closing PHP tag in localization files
 933       ob_start();
 934
 935       // get english labels (these should be complete)
 936       @include(INSTALL_PATH . 'program/localization/en_US/labels.inc');
 937       @include(INSTALL_PATH . 'program/localization/en_US/messages.inc');
 938
 939       if (is_array($labels))
 940         $this->texts = $labels;
 941       if (is_array($messages))
 942         $this->texts = array_merge($this->texts, $messages);
 943
 944       // include user language files
 945       if ($lang != 'en' && is_dir(INSTALL_PATH . 'program/localization/' . $lang)) {
 946         include_once(INSTALL_PATH . 'program/localization/' . $lang . '/labels.inc');
 947         include_once(INSTALL_PATH . 'program/localization/' . $lang . '/messages.inc');
 948
 949         if (is_array($labels))
 950           $this->texts = array_merge($this->texts, $labels);
 951         if (is_array($messages))
 952           $this->texts = array_merge($this->texts, $messages);
 953       }
 954
 955       ob_end_clean();
 956
 957       $_SESSION['language'] = $lang;
 958     }
 959
 960     // append additional texts (from plugin)
 961     if (is_array($add) && !empty($add))
 962       $this->texts += $add;
 963   }
 964
 965
 966   /**
 967    * Read directory program/localization and return a list of available languages
 968    *
 969    * @return array List of available localizations
 970    */
 971   public function list_languages()
 972   {
 973     static $sa_languages = array();
 974
 975     if (!sizeof($sa_languages)) {
 976       @include(INSTALL_PATH . 'program/localization/index.inc');
 977
 978       if ($dh = @opendir(INSTALL_PATH . 'program/localization')) {
 979         while (($name = readdir($dh)) !== false) {
 980           if ($name[0] == '.' || !is_dir(INSTALL_PATH . 'program/localization/' . $name))
 981             continue;
 982
 983           if ($label = $rcube_languages[$name])
 984             $sa_languages[$name] = $label;
 985         }
 986         closedir($dh);
 987       }
 988     }
 989
 990     return $sa_languages;
 991   }
 992
 993
 994   /**
 995    * Check the auth hash sent by the client against the local session credentials
 996    *
 997    * @return boolean True if valid, False if not
 998    */
 999   function authenticate_session()
1000   {
1001     // advanced session authentication
1002     if ($this->config->get('double_auth')) {
1003       $now = time();
1004       $valid = ($_COOKIE['sessauth'] == $this->get_auth_hash(session_id(), $_SESSION['auth_time']) ||
1005                 $_COOKIE['sessauth'] == $this->get_auth_hash(session_id(), $_SESSION['last_auth']));
1006
1007       // renew auth cookie every 5 minutes (only for GET requests)
1008       if (!$valid || ($_SERVER['REQUEST_METHOD']!='POST' && $now - $_SESSION['auth_time'] > 300)) {
1009         $_SESSION['last_auth'] = $_SESSION['auth_time'];
1010         $_SESSION['auth_time'] = $now;
1011         rcmail::setcookie('sessauth', $this->get_auth_hash(session_id(), $now), 0);
1012       }
1013     }
1014     else {
1015       $valid = $this->config->get('ip_check') ? $_SERVER['REMOTE_ADDR'] == $this->session->get_ip() : true;
1016     }
1017
1018     // check session filetime
1019     $lifetime = $this->config->get('session_lifetime');
1020     $sess_ts = $this->session->get_ts();
1021     if (!empty($lifetime) && !empty($sess_ts) && $sess_ts + $lifetime*60 < time()) {
1022       $valid = false;
1023     }
1024
1025     return $valid;
1026   }
1027
1028
1029   /**
1030    * Destroy session data and remove cookie
1031    */
1032   public function kill_session()
1033   {
1034     $this->plugins->exec_hook('session_destroy');
1035
1036     $this->session->remove();
1037     $_SESSION = array('language' => $this->user->language, 'auth_time' => time(), 'temp' => true);
1038     rcmail::setcookie('sessauth', '-del-', time() - 60);
1039     $this->user->reset();
1040   }
1041
1042
1043   /**
1044    * Do server side actions on logout
1045    */
1046   public function logout_actions()
1047   {
1048     $config = $this->config->all();
1049
1050     // on logout action we're not connected to imap server
1051     if (($config['logout_purge'] && !empty($config['trash_mbox'])) || $config['logout_expunge']) {
1052       if (!$this->authenticate_session())
1053         return;
1054
1055       $this->imap_connect();
1056     }
1057
1058     if ($config['logout_purge'] && !empty($config['trash_mbox'])) {
1059       $this->imap->clear_mailbox($config['trash_mbox']);
1060     }
1061
1062     if ($config['logout_expunge']) {
1063       $this->imap->expunge('INBOX');
1064     }
1065   }
1066
1067
1068   /**
1069    * Function to be executed in script shutdown
1070    * Registered with register_shutdown_function()
1071    */
1072   public function shutdown()
1073   {
1074     if (is_object($this->smtp))
1075       $this->smtp->disconnect();
1076
1077     foreach ($this->books as $book)
1078       if (is_object($book))
1079         $book->close();
1080
1081     if (is_object($this->imap))
1082       $this->imap->close();
1083
1084     // before closing the database connection, write session data
1085     if ($_SERVER['REMOTE_ADDR'])
1086       session_write_close();
1087
1088     // write performance stats to logs/console
1089     if ($this->config->get('devel_mode')) {
1090       if (function_exists('memory_get_usage'))
1091         $mem = show_bytes(memory_get_usage());
1092       if (function_exists('memory_get_peak_usage'))
1093         $mem .= '/'.show_bytes(memory_get_peak_usage());
1094
1095       $log = $this->task . ($this->action ? '/'.$this->action : '') . ($mem ? " [$mem]" : '');
1096       if (defined('RCMAIL_START'))
1097         rcube_print_time(RCMAIL_START, $log);
1098       else
1099         console($log);
1100     }
1101   }
1102
1103
1104   /**
1105    * Generate a unique token to be used in a form request
1106    *
1107    * @return string The request token
1108    */
1109   public function get_request_token()
1110   {
1111     $sess_id = $_COOKIE[ini_get('session.name')];
1112     if (!$sess_id) $sess_id = session_id();
1113     return md5('RT' . $this->task . $this->config->get('des_key') . $sess_id);
1114   }
1115
1116
1117   /**
1118    * Check if the current request contains a valid token
1119    *
1120    * @param int Request method
1121    * @return boolean True if request token is valid false if not
1122    */
1123   public function check_request($mode = RCUBE_INPUT_POST)
1124   {
1125     $token = get_input_value('_token', $mode);
1126     $sess_id = $_COOKIE[ini_get('session.name')];
1127     return !empty($sess_id) && $token == $this->get_request_token();
1128   }
1129
1130
1131   /**
1132    * Create unique authorization hash
1133    *
1134    * @param string Session ID
1135    * @param int Timestamp
1136    * @return string The generated auth hash
1137    */
1138   private function get_auth_hash($sess_id, $ts)
1139   {
1140     $auth_string = sprintf('rcmail*sess%sR%s*Chk:%s;%s',
1141       $sess_id,
1142       $ts,
1143       $this->config->get('ip_check') ? $_SERVER['REMOTE_ADDR'] : '***.***.***.***',
1144       $_SERVER['HTTP_USER_AGENT']);
1145
1146     if (function_exists('sha1'))
1147       return sha1($auth_string);
1148     else
1149       return md5($auth_string);
1150   }
1151
1152
1153   /**
1154    * Encrypt using 3DES
1155    *
1156    * @param string $clear clear text input
1157    * @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
1158    * @param boolean $base64 whether or not to base64_encode() the result before returning
1159    *
1160    * @return string encrypted text
1161    */
1162   public function encrypt($clear, $key = 'des_key', $base64 = true)
1163   {
1164     if (!$clear)
1165       return '';
1166     /*-
1167      * Add a single canary byte to the end of the clear text, which
1168      * will help find out how much of padding will need to be removed
1169      * upon decryption; see http://php.net/mcrypt_generic#68082
1170      */
1171     $clear = pack("a*H2", $clear, "80");
1172
1173     if (function_exists('mcrypt_module_open') &&
1174         ($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, "")))
1175     {
1176       $iv = $this->create_iv(mcrypt_enc_get_iv_size($td));
1177       mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
1178       $cipher = $iv . mcrypt_generic($td, $clear);
1179       mcrypt_generic_deinit($td);
1180       mcrypt_module_close($td);
1181     }
1182     else {
1183       @include_once('lib/des.inc');
1184
1185       if (function_exists('des')) {
1186         $des_iv_size = 8;
1187         $iv = $this->create_iv($des_iv_size);
1188         $cipher = $iv . des($this->config->get_crypto_key($key), $clear, 1, 1, $iv);
1189       }
1190       else {
1191         raise_error(array(
1192           'code' => 500, 'type' => 'php',
1193           'file' => __FILE__, 'line' => __LINE__,
1194           'message' => "Could not perform encryption; make sure Mcrypt is installed or lib/des.inc is available"
1195         ), true, true);
1196       }
1197     }
1198
1199     return $base64 ? base64_encode($cipher) : $cipher;
1200   }
1201
1202   /**
1203    * Decrypt 3DES-encrypted string
1204    *
1205    * @param string $cipher encrypted text
1206    * @param string $key encryption key to retrieve from the configuration, defaults to 'des_key'
1207    * @param boolean $base64 whether or not input is base64-encoded
1208    *
1209    * @return string decrypted text
1210    */
1211   public function decrypt($cipher, $key = 'des_key', $base64 = true)
1212   {
1213     if (!$cipher)
1214       return '';
1215
1216     $cipher = $base64 ? base64_decode($cipher) : $cipher;
1217
1218     if (function_exists('mcrypt_module_open') &&
1219         ($td = mcrypt_module_open(MCRYPT_TripleDES, "", MCRYPT_MODE_CBC, "")))
1220     {
1221       $iv_size = mcrypt_enc_get_iv_size($td);
1222       $iv = substr($cipher, 0, $iv_size);
1223
1224       // session corruption? (#1485970)
1225       if (strlen($iv) < $iv_size)
1226         return '';
1227
1228       $cipher = substr($cipher, $iv_size);
1229       mcrypt_generic_init($td, $this->config->get_crypto_key($key), $iv);
1230       $clear = mdecrypt_generic($td, $cipher);
1231       mcrypt_generic_deinit($td);
1232       mcrypt_module_close($td);
1233     }
1234     else {
1235       @include_once('lib/des.inc');
1236
1237       if (function_exists('des')) {
1238         $des_iv_size = 8;
1239         $iv = substr($cipher, 0, $des_iv_size);
1240         $cipher = substr($cipher, $des_iv_size);
1241         $clear = des($this->config->get_crypto_key($key), $cipher, 0, 1, $iv);
1242       }
1243       else {
1244         raise_error(array(
1245           'code' => 500, 'type' => 'php',
1246           'file' => __FILE__, 'line' => __LINE__,
1247           'message' => "Could not perform decryption; make sure Mcrypt is installed or lib/des.inc is available"
1248         ), true, true);
1249       }
1250     }
1251
1252     /*-
1253      * Trim PHP's padding and the canary byte; see note in
1254      * rcmail::encrypt() and http://php.net/mcrypt_generic#68082
1255      */
1256     $clear = substr(rtrim($clear, "\0"), 0, -1);
1257
1258     return $clear;
1259   }
1260
1261   /**
1262    * Generates encryption initialization vector (IV)
1263    *
1264    * @param int Vector size
1265    * @return string Vector string
1266    */
1267   private function create_iv($size)
1268   {
1269     // mcrypt_create_iv() can be slow when system lacks entrophy
1270     // we'll generate IV vector manually
1271     $iv = '';
1272     for ($i = 0; $i < $size; $i++)
1273         $iv .= chr(mt_rand(0, 255));
1274     return $iv;
1275   }
1276
1277   /**
1278    * Build a valid URL to this instance of Roundcube
1279    *
1280    * @param mixed Either a string with the action or url parameters as key-value pairs
1281    * @return string Valid application URL
1282    */
1283   public function url($p)
1284   {
1285     if (!is_array($p))
1286       $p = array('_action' => @func_get_arg(0));
1287
1288     $task = $p['_task'] ? $p['_task'] : ($p['task'] ? $p['task'] : $this->task);
1289     $p['_task'] = $task;
1290     unset($p['task']);
1291
1292     $url = './';
1293     $delm = '?';
1294     foreach (array_reverse($p) as $key => $val)
1295     {
1296       if (!empty($val)) {
1297         $par = $key[0] == '_' ? $key : '_'.$key;
1298         $url .= $delm.urlencode($par).'='.urlencode($val);
1299         $delm = '&';
1300       }
1301     }
1302     return $url;
1303   }
1304
1305
1306   /**
1307    * Helper method to set a cookie with the current path and host settings
1308    *
1309    * @param string Cookie name
1310    * @param string Cookie value
1311    * @param string Expiration time
1312    */
1313   public static function setcookie($name, $value, $exp = 0)
1314   {
1315     if (headers_sent())
1316       return;
1317
1318     $cookie = session_get_cookie_params();
1319
1320     setcookie($name, $value, $exp, $cookie['path'], $cookie['domain'],
1321       rcube_https_check(), true);
1322   }
1323 }
1324
1325