PHP rcube_utils::mem_check方法代码示例

 /**
  * Fetch message headers and body structure from the IMAP server and build
  * an object structure.
  *
  * @param int    $uid    Message UID to fetch
  * @param string $folder Folder to read from
  *
  * @return object rcube_message_header Message data
  */
 public function get_message($uid, $folder = null)
 {
     if (!strlen($folder)) {
         $folder = $this->folder;
     }
     // decode combined UID-folder identifier
     if (preg_match('/^\\d+-.+/', $uid)) {
         list($uid, $folder) = explode('-', $uid, 2);
     }
     // Check internal cache
     if (!empty($this->icache['message'])) {
         if (($headers = $this->icache['message']) && $headers->uid == $uid) {
             return $headers;
         }
     }
     $headers = $this->get_message_headers($uid, $folder);
     // message doesn't exist?
     if (empty($headers)) {
         return null;
     }
     // structure might be cached
     if (!empty($headers->structure)) {
         return $headers;
     }
     $this->msg_uid = $uid;
     if (!$this->check_connection()) {
         return $headers;
     }
     if (empty($headers->bodystructure)) {
         $headers->bodystructure = $this->conn->getStructure($folder, $uid, true);
     }
     $structure = $headers->bodystructure;
     if (empty($structure)) {
         return $headers;
     }
     // set message charset from message headers
     if ($headers->charset) {
         $this->struct_charset = $headers->charset;
     } else {
         $this->struct_charset = $this->structure_charset($structure);
     }
     $headers->ctype = @strtolower($headers->ctype);
     // Here we can recognize malformed BODYSTRUCTURE and
     // 1. [@TODO] parse the message in other way to create our own message structure
     // 2. or just show the raw message body.
     // Example of structure for malformed MIME message:
     // ("text" "plain" NIL NIL NIL "7bit" 2154 70 NIL NIL NIL)
     if ($headers->ctype && !is_array($structure[0]) && $headers->ctype != 'text/plain' && strtolower($structure[0] . '/' . $structure[1]) == 'text/plain') {
         // A special known case "Content-type: text" (#1488968)
         if ($headers->ctype == 'text') {
             $structure[1] = 'plain';
             $headers->ctype = 'text/plain';
         } else {
             if (preg_match('/^(text|application)\\/(.*)/', $headers->ctype, $m)) {
                 $structure[0] = $m[1];
                 $structure[1] = $m[2];
             } else {
                 // Try to parse the message using rcube_mime_decode.
                 // We need a better solution, it parses message
                 // in memory, which wouldn't work for very big messages,
                 // (it uses up to 10x more memory than the message size)
                 // it's also buggy and not actively developed
                 if ($headers->size && rcube_utils::mem_check($headers->size * 10)) {
                     $raw_msg = $this->get_raw_body($uid);
                     $struct = rcube_mime::parse_message($raw_msg);
                 } else {
                     return $headers;
                 }
             }
         }
     }
     if (empty($struct)) {
         $struct = $this->structure_part($structure, 0, '', $headers);
     }
     // some workarounds on simple messages...
     if (empty($struct->parts)) {
         // ...don't trust given content-type
         if (!empty($headers->ctype)) {
             $struct->mime_id = '1';
             $struct->mimetype = strtolower($headers->ctype);
             list($struct->ctype_primary, $struct->ctype_secondary) = explode('/', $struct->mimetype);
         }
         // ...and charset (there's a case described in #1488968 where invalid content-type
         // results in invalid charset in BODYSTRUCTURE)
         if (!empty($headers->charset) && $headers->charset != $struct->ctype_parameters['charset']) {
             $struct->charset = $headers->charset;
             $struct->ctype_parameters['charset'] = $headers->charset;
         }
     }
     $headers->structure = $struct;
     return $this->icache['message'] = $headers;
//.........这里部分代码省略.........

 /**
  * Check if we have enough memory to load specified image
  */
 private function mem_check($props)
 {
     // image size is unknown, we can't calculate required memory
     if (!$props['width']) {
         return true;
     }
     // channels: CMYK - 4, RGB - 3
     $multip = ($props['channels'] ?: 3) + 1;
     // calculate image size in memory (in bytes)
     $size = $props['width'] * $props['height'] * $multip;
     return rcube_utils::mem_check($size);
 }

 /**
  * Import events from iCalendar format
  *
  * @param  string vCalendar input
  * @param  string Input charset (from envelope)
  * @param  boolean True if parsing exceptions should be forwarded to the caller
  * @return array List of events extracted from the input
  */
 public function import($vcal, $charset = 'UTF-8', $forward_exceptions = false, $memcheck = true)
 {
     // TODO: convert charset to UTF-8 if other
     try {
         // estimate the memory usage and try to avoid fatal errors when allowed memory gets exhausted
         if ($memcheck) {
             $count = substr_count($vcal, 'BEGIN:VEVENT') + substr_count($vcal, 'BEGIN:VTODO');
             $expected_memory = $count * 70 * 1024;
             // assume ~ 70K per event (empirically determined)
             if (!rcube_utils::mem_check($expected_memory)) {
                 throw new Exception("iCal file too big");
             }
         }
         $vobject = VObject\Reader::read($vcal, VObject\Reader::OPTION_FORGIVING | VObject\Reader::OPTION_IGNORE_INVALID_LINES);
         if ($vobject) {
             return $this->import_from_vobject($vobject);
         }
     } catch (Exception $e) {
         if ($forward_exceptions) {
             throw $e;
         } else {
             rcube::raise_error(array('code' => 600, 'type' => 'php', 'file' => __FILE__, 'line' => __LINE__, 'message' => "iCal data parse error: " . $e->getMessage()), true, false);
         }
     }
     return array();
 }

function rcmail_mem_check($need)
{
    return rcube_utils::mem_check($need);
}

 /**
  * Fetch message headers and body structure from the IMAP server and build
  * an object structure similar to the one generated by PEAR::Mail_mimeDecode
  *
  * @param int     $uid      Message UID to fetch
  * @param string  $folder   Folder to read from
  *
  * @return object rcube_message_header Message data
  */
 public function get_message($uid, $folder = null)
 {
     if (!strlen($folder)) {
         $folder = $this->folder;
     }
     // Check internal cache
     if (!empty($this->icache['message'])) {
         if (($headers = $this->icache['message']) && $headers->uid == $uid) {
             return $headers;
         }
     }
     $headers = $this->get_message_headers($uid, $folder);
     // message doesn't exist?
     if (empty($headers)) {
         return null;
     }
     // structure might be cached
     if (!empty($headers->structure)) {
         return $headers;
     }
     $this->msg_uid = $uid;
     if (!$this->check_connection()) {
         return $headers;
     }
     if (empty($headers->bodystructure)) {
         $headers->bodystructure = $this->conn->getStructure($folder, $uid, true);
     }
     $structure = $headers->bodystructure;
     if (empty($structure)) {
         return $headers;
     }
     // set message charset from message headers
     if ($headers->charset) {
         $this->struct_charset = $headers->charset;
     } else {
         $this->struct_charset = $this->structure_charset($structure);
     }
     $headers->ctype = strtolower($headers->ctype);
     // Here we can recognize malformed BODYSTRUCTURE and
     // 1. [@TODO] parse the message in other way to create our own message structure
     // 2. or just show the raw message body.
     // Example of structure for malformed MIME message:
     // ("text" "plain" NIL NIL NIL "7bit" 2154 70 NIL NIL NIL)
     if ($headers->ctype && !is_array($structure[0]) && $headers->ctype != 'text/plain' && strtolower($structure[0] . '/' . $structure[1]) == 'text/plain') {
         // we can handle single-part messages, by simple fix in structure (#1486898)
         if (preg_match('/^(text|application)\\/(.*)/', $headers->ctype, $m)) {
             $structure[0] = $m[1];
             $structure[1] = $m[2];
         } else {
             // Try to parse the message using Mail_mimeDecode package
             // We need a better solution, Mail_mimeDecode parses message
             // in memory, which wouldn't work for very big messages,
             // (it uses up to 10x more memory than the message size)
             // it's also buggy and not actively developed
             if ($headers->size && rcube_utils::mem_check($headers->size * 10)) {
                 $raw_msg = $this->get_raw_body($uid);
                 $struct = rcube_mime::parse_message($raw_msg);
             } else {
                 return $headers;
             }
         }
     }
     if (empty($struct)) {
         $struct = $this->structure_part($structure, 0, '', $headers);
     }
     // don't trust given content-type
     if (empty($struct->parts) && !empty($headers->ctype)) {
         $struct->mime_id = '1';
         $struct->mimetype = strtolower($headers->ctype);
         list($struct->ctype_primary, $struct->ctype_secondary) = explode('/', $struct->mimetype);
     }
     $headers->structure = $struct;
     return $this->icache['message'] = $headers;
 }

function rcmail_mem_check($need)
{
    _deprecation_warning(__FUNCTION__);
    return rcube_utils::mem_check($need);
}