PHP rcube_utils::max_upload_size方法代码示例

 function save()
 {
     // Init plugin and handle managesieve connection
     $error = $this->start();
     // get request size limits (#1488648)
     $max_post = max(array(ini_get('max_input_vars'), ini_get('suhosin.request.max_vars'), ini_get('suhosin.post.max_vars')));
     $max_depth = max(array(ini_get('suhosin.request.max_array_depth'), ini_get('suhosin.post.max_array_depth')));
     // check request size limit
     if ($max_post && count($_POST, COUNT_RECURSIVE) >= $max_post) {
         rcube::raise_error(array('code' => 500, 'type' => 'php', 'file' => __FILE__, 'line' => __LINE__, 'message' => "Request size limit exceeded (one of max_input_vars/suhosin.request.max_vars/suhosin.post.max_vars)"), true, false);
         $this->rc->output->show_message('managesieve.filtersaveerror', 'error');
     } else {
         if ($max_depth && count($_POST['_header']) > $max_depth) {
             rcube::raise_error(array('code' => 500, 'type' => 'php', 'file' => __FILE__, 'line' => __LINE__, 'message' => "Request size limit exceeded (one of suhosin.request.max_array_depth/suhosin.post.max_array_depth)"), true, false);
             $this->rc->output->show_message('managesieve.filtersaveerror', 'error');
         } else {
             if (!empty($_POST['_newset'])) {
                 $name = rcube_utils::get_input_value('_name', rcube_utils::INPUT_POST, true);
                 $copy = rcube_utils::get_input_value('_copy', rcube_utils::INPUT_POST, true);
                 $from = rcube_utils::get_input_value('_from', rcube_utils::INPUT_POST);
                 $exceptions = $this->rc->config->get('managesieve_filename_exceptions');
                 $kolab = $this->rc->config->get('managesieve_kolab_master');
                 $name_uc = mb_strtolower($name);
                 $list = $this->list_scripts();
                 if (!$name) {
                     $this->errors['name'] = $this->plugin->gettext('cannotbeempty');
                 } else {
                     if (mb_strlen($name) > 128) {
                         $this->errors['name'] = $this->plugin->gettext('nametoolong');
                     } else {
                         if (!empty($exceptions) && in_array($name, (array) $exceptions)) {
                             $this->errors['name'] = $this->plugin->gettext('namereserved');
                         } else {
                             if (!empty($kolab) && in_array($name_uc, array('MASTER', 'USER', 'MANAGEMENT'))) {
                                 $this->errors['name'] = $this->plugin->gettext('namereserved');
                             } else {
                                 if (in_array($name, $list)) {
                                     $this->errors['name'] = $this->plugin->gettext('setexist');
                                 } else {
                                     if ($from == 'file') {
                                         // from file
                                         if (is_uploaded_file($_FILES['_file']['tmp_name'])) {
                                             $file = file_get_contents($_FILES['_file']['tmp_name']);
                                             $file = preg_replace('/\\r/', '', $file);
                                             // for security don't save script directly
                                             // check syntax before, like this...
                                             $this->sieve->load_script($file);
                                             if (!$this->save_script($name)) {
                                                 $this->errors['file'] = $this->plugin->gettext('setcreateerror');
                                             }
                                         } else {
                                             // upload failed
                                             $err = $_FILES['_file']['error'];
                                             if ($err == UPLOAD_ERR_INI_SIZE || $err == UPLOAD_ERR_FORM_SIZE) {
                                                 $msg = $this->rc->gettext(array('name' => 'filesizeerror', 'vars' => array('size' => $this->rc->show_bytes(rcube_utils::max_upload_size()))));
                                             } else {
                                                 $this->errors['file'] = $this->plugin->gettext('fileuploaderror');
                                             }
                                         }
                                     } else {
                                         if (!$this->sieve->copy($name, $from == 'set' ? $copy : '')) {
                                             $error = 'managesieve.setcreateerror';
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
                 if (!$error && empty($this->errors)) {
                     // Find position of the new script on the list
                     $list[] = $name;
                     asort($list, SORT_LOCALE_STRING);
                     $list = array_values($list);
                     $index = array_search($name, $list);
                     $this->rc->output->show_message('managesieve.setcreated', 'confirmation');
                     $this->rc->output->command('parent.managesieve_updatelist', 'setadd', array('name' => $name, 'index' => $index));
                 } else {
                     if ($msg) {
                         $this->rc->output->command('display_message', $msg, 'error');
                     } else {
                         if ($error) {
                             $this->rc->output->show_message($error, 'error');
                         }
                     }
                 }
             } else {
                 if (isset($_POST['_name'])) {
                     $name = trim(rcube_utils::get_input_value('_name', rcube_utils::INPUT_POST, true));
                     $fid = trim(rcube_utils::get_input_value('_fid', rcube_utils::INPUT_POST));
                     $join = trim(rcube_utils::get_input_value('_join', rcube_utils::INPUT_POST));
                     // and arrays
                     $headers = rcube_utils::get_input_value('_header', rcube_utils::INPUT_POST);
                     $cust_headers = rcube_utils::get_input_value('_custom_header', rcube_utils::INPUT_POST);
                     $cust_vars = rcube_utils::get_input_value('_custom_var', rcube_utils::INPUT_POST);
                     $ops = rcube_utils::get_input_value('_rule_op', rcube_utils::INPUT_POST);
                     $sizeops = rcube_utils::get_input_value('_rule_size_op', rcube_utils::INPUT_POST);
                     $sizeitems = rcube_utils::get_input_value('_rule_size_item', rcube_utils::INPUT_POST);
                     $sizetargets = rcube_utils::get_input_value('_rule_size_target', rcube_utils::INPUT_POST);
                     $targets = rcube_utils::get_input_value('_rule_target', rcube_utils::INPUT_POST, true);
//.........这里部分代码省略.........

 /**
  * Key import (page) handler
  */
 private function key_import()
 {
     // Import process
     if ($data = rcube_utils::get_input_value('_keys', rcube_utils::INPUT_POST)) {
         $this->enigma->load_engine();
         $this->enigma->engine->password_handler();
         $result = $this->enigma->engine->import_key($data);
         if (is_array($result)) {
             if (rcube_utils::get_input_value('_generated', rcube_utils::INPUT_POST)) {
                 $this->rc->output->command('enigma_key_create_success');
                 $this->rc->output->show_message('enigma.keygeneratesuccess', 'confirmation');
             } else {
                 $this->rc->output->show_message('enigma.keysimportsuccess', 'confirmation', array('new' => $result['imported'], 'old' => $result['unchanged']));
                 if ($result['imported'] && !empty($_POST['_refresh'])) {
                     $this->rc->output->command('enigma_list', 1, false);
                 }
             }
         } else {
             $this->rc->output->show_message('enigma.keysimportfailed', 'error');
         }
         $this->rc->output->send();
     } else {
         if ($_FILES['_file']['tmp_name'] && is_uploaded_file($_FILES['_file']['tmp_name'])) {
             $this->enigma->load_engine();
             $result = $this->enigma->engine->import_key($_FILES['_file']['tmp_name'], true);
             if (is_array($result)) {
                 // reload list if any keys has been added
                 if ($result['imported']) {
                     $this->rc->output->command('parent.enigma_list', 1);
                 } else {
                     $this->rc->output->command('parent.enigma_loadframe');
                 }
                 $this->rc->output->show_message('enigma.keysimportsuccess', 'confirmation', array('new' => $result['imported'], 'old' => $result['unchanged']));
             } else {
                 if ($result instanceof enigma_error && $result->getCode() == enigma_error::BADPASS) {
                     $this->password_prompt($result);
                 } else {
                     $this->rc->output->show_message('enigma.keysimportfailed', 'error');
                 }
             }
             $this->rc->output->send('iframe');
         } else {
             if ($err = $_FILES['_file']['error']) {
                 if ($err == UPLOAD_ERR_INI_SIZE || $err == UPLOAD_ERR_FORM_SIZE) {
                     $this->rc->output->show_message('filesizeerror', 'error', array('size' => $this->rc->show_bytes(rcube_utils::max_upload_size())));
                 } else {
                     $this->rc->output->show_message('fileuploaderror', 'error');
                 }
                 $this->rc->output->send('iframe');
             }
         }
     }
     $this->rc->output->add_handlers(array('importform' => array($this, 'tpl_key_import_form')));
     $this->rc->output->set_pagetitle($this->enigma->gettext('keyimport'));
     $this->rc->output->send('enigma.keyimport');
 }

 /**
  * Initializes file uploading interface.
  *
  * @param int $max_size Optional maximum file size in bytes
  *
  * @return string Human-readable file size limit
  */
 public function upload_init($max_size = null)
 {
     // Enable upload progress bar
     if ($seconds = $this->config->get('upload_progress')) {
         if (function_exists('uploadprogress_get_info')) {
             $field_name = 'UPLOAD_IDENTIFIER';
         }
         if (!$field_name && filter_var(ini_get('apc.rfc1867'), FILTER_VALIDATE_BOOLEAN)) {
             $field_name = ini_get('apc.rfc1867_name');
         }
         if (!$field_name && filter_var(ini_get('session.upload_progress.enabled'), FILTER_VALIDATE_BOOLEAN)) {
             $field_name = ini_get('session.upload_progress.name');
         }
         if ($field_name) {
             $this->output->set_env('upload_progress_name', $field_name);
             $this->output->set_env('upload_progress_time', (int) $seconds);
         }
     }
     // find max filesize value
     $max_filesize = rcube_utils::max_upload_size();
     if ($max_size && $max_size < $max_filesize) {
         $max_filesize = $max_size;
     }
     $max_filesize_txt = $this->show_bytes($max_filesize);
     $this->output->set_env('max_filesize', $max_filesize);
     $this->output->set_env('filesizeerror', $this->gettext(array('name' => 'filesizeerror', 'vars' => array('size' => $max_filesize_txt))));
     if ($max_filecount = ini_get('max_file_uploads')) {
         $this->output->set_env('max_filecount', $max_filecount);
         $this->output->set_env('filecounterror', $this->gettext(array('name' => 'filecounterror', 'vars' => array('count' => $max_filecount))));
     }
     return $max_filesize_txt;
 }