protected function decode($value)
 {
     $decoded = '';
     $parts = imap_mime_header_decode($value);
     try {
         foreach ($parts as $part) {
             $charset = 'default' == $part->charset ? 'auto' : $part->charset;
             //Ajout COGIVEA fix encoding :
             $charset = $this->charset != '' && $charset == 'auto' ? $this->charset : $charset;
             //print $part->text."#".$this->charset."/".$charset."#"."\n";
             // imap_utf8 doesn't seem to work properly, so use Transcoder instead
             // Got from: https://github.com/Sawered/imap/commit/e739b7221c6e57521b38f7b56f78ba399acda888 and changed to UndetectableEncodingException
             try {
                 $decoded .= Transcoder::create()->transcode($part->text, $charset);
             } catch (IllegalCharacterException $e) {
                 //no warn, itis reality
                 //FIX COGIVEA
             } catch (UndetectableEncodingException $e) {
                 //no warn, it is reality, handle it somehow
                 $decoded = imap_utf8($part->text);
             }
         }
     } catch (Exception $e) {
     }
     return $decoded;
 }

 /**
  * @return stdClass
  * @throws Exception
  */
 public function fetchOverview()
 {
     $result = imap_fetch_overview($this->stream, $this->number);
     if (FALSE === $result) {
         throw new Exception('FetchOverview failed: ' . imap_last_error());
     }
     list($result) = $result;
     foreach ($result as &$prop) {
         $prop = imap_utf8($prop);
     }
     return $result;
 }

 function mimedecode($text, $encoding = 'UTF-8')
 {
     if (function_exists('imap_mime_header_decode') && ($parts = imap_mime_header_decode($text))) {
         $str = '';
         foreach ($parts as $part) {
             $str .= Charset::transcode($part->text, $part->charset, $encoding);
         }
         $text = $str;
     } elseif ($text[0] == '=' && function_exists('iconv_mime_decode')) {
         $text = iconv_mime_decode($text, 0, $encoding);
     } elseif (!strcasecmp($encoding, 'utf-8') && function_exists('imap_utf8')) {
         $text = imap_utf8($text);
     }
     return $text;
 }

 /**
  * @return bool
  */
 public function getNewMessages()
 {
     $query = imap_search(self::__connect(), 'UNSEEN');
     $data = false;
     $messages = [];
     if (is_array($query)) {
         foreach ($query as $number) {
             $messages[] = imap_fetch_overview(self::__connect(), $number)[0];
         }
         for ($i = 0; $i < count($messages); $i++) {
             $data[$i]['msgno'] = $messages[$i]->msgno;
             $data[$i]['subject'] = imap_mime_header_decode(imap_utf8(mb_convert_encoding($messages[$i]->subject, 'UTF8', 'KOI8-R')))[0]->text;
         }
     }
     return $data;
 }

 function decode($what, $errors = false)
 {
     if (function_exists('imap_mime_header_decode') && ($parts = imap_mime_header_decode($text))) {
         $str = '';
         foreach ($parts as $part) {
             $str .= Format::encode($part->text, $part->charset, $encoding);
         }
         return $str;
     } elseif ($text[0] == '=' && function_exists('iconv_mime_decode')) {
         return iconv_mime_decode($text, 0, $encoding);
         // TODO: Use a pure-PHP version to perform the decoding
     } elseif (!strcasecmp($encoding, 'utf-8') && function_exists('imap_utf8')) {
         return imap_utf8($text);
     }
     return $text;
 }

 public function __construct(stdClass $headers)
 {
     // Store all headers as lowercase
     $this->array = array_change_key_case((array) $headers);
     // Decode subject, as it may be UTF-8 encoded
     if (isset($headers->subject)) {
         $subject = '';
         foreach (imap_mime_header_decode($headers->subject) as $part) {
             // $part->charset can also be 'default', i.e. plain US-ASCII
             if (function_exists('iconv')) {
                 $charset = $part->charset == 'default' ? 'UTF-8' : $part->charset;
                 $subject .= iconv($charset, 'UTF-8', $part->text);
             } else {
                 $charset = $part->charset == 'default' ? 'auto' : $part->charset;
                 $subject .= mb_convert_encoding($part->text, 'UTF-8', $charset);
             }
         }
         $this->array['subject'] = $subject;
     }
     $this->array['msgno'] = (int) $this->array['msgno'];
     foreach (array('answered', 'deleted', 'draft') as $flag) {
         $this->array[$flag] = (bool) trim($this->array[$flag]);
     }
     if (isset($this->array['date'])) {
         $this->array['date'] = preg_replace('/(.*)\\(.*\\)/', '$1', $this->array['date']);
         // $this->array['date'] = new DateTime($this->array['date']);
     }
     if (isset($this->array['from'])) {
         $from = current($this->array['from']);
         $this->array['from'] = new Mirasvit_Ddeboer_Imap_Message_EmailAddress($from->mailbox, $from->host, isset($from->personal) ? imap_utf8($from->personal) : null);
     }
     if (isset($this->array['to'])) {
         $recipients = array();
         foreach ($this->array['to'] as $to) {
             $recipients[] = new Mirasvit_Ddeboer_Imap_Message_EmailAddress(str_replace('\'', '', $to->mailbox), str_replace('\'', '', $to->host), isset($to->personal) ? imap_utf8($to->personal) : null);
         }
         $this->array['to'] = $recipients;
     } else {
         $this->array['to'] = array();
     }
     if (isset($this->array['reply_to'])) {
         $from = current($this->array['reply_to']);
         $this->array['reply_to'] = new Mirasvit_Ddeboer_Imap_Message_EmailAddress($from->mailbox, $from->host, isset($from->personal) ? imap_utf8($from->personal) : null);
     }
 }

 public function showEmails()
 {
     $connect_to = '{imap.gmail.com:993/imap/ssl/novalidate-cert}INBOX';
     $user = '[email protected]';
     $password = '77andy77';
     $inbox = imap_open($connect_to, $user, $password) or die("Can't connect to '{$connect_to}': " . imap_last_error());
     $folders = imap_list($inbox, "{imap.gmail.com:993/imap/ssl}", "*");
     //return dd($folders);
     //return $message_count = imap_num_msg($inbox);
     $emails = imap_search($inbox, 'SINCE ' . date('d-M-Y', strtotime("-2 week")));
     $output = [];
     $emailCount = imap_num_msg($inbox);
     rsort($emails);
     $i = 0;
     foreach ($emails as $mail) {
         $headerInfo = imap_headerinfo($inbox, $mail);
         //return var_dump(dd($headerInfo));
         $message = "";
         $output[$i]['subject'] = isset($headerInfo->Subject) ? imap_utf8($headerInfo->Subject) : "0";
         $output[$i]['from'] = imap_utf8($headerInfo->from[0]->personal);
         $output[$i]['toaddress'] = $headerInfo->toaddress;
         $output[$i]['to'] = array_shift($headerInfo->to);
         $output[$i]['date'] = $headerInfo->date[0];
         $output[$i]['fromaddress'] = $headerInfo->fromaddress[0];
         $output[$i]['reply_toaddress'] = $headerInfo->reply_toaddress[0];
         $output[$i]['date'] = date('d-m-Y ' . '[' . 'H:i' . ']', strtotime($headerInfo->date) + 3600);
         $output[$i]['unseen'] = $headerInfo->Unseen;
         $output[$i]['flagged'] = $headerInfo->Flagged;
         $message = imap_fetchbody($inbox, $mail, 2);
         if (base64_decode($message, true)) {
             //message body if base64 encoded
             $message = base64_decode($message);
         } else {
             //message body is not base64 encoded
             $message = imap_fetchbody($inbox, $mail, 1);
         }
         $output[$i]['body'] = $message;
         $i++;
     }
     return dd($output);
     //return view('aßdministration.email.showEmails')->with('output', $output);
 }

 public function getMessages($email)
 {
     $messages = [];
     foreach ($this->query(['to' => $email, 'on' => date('d F Y'), 'unseen' => false]) as $messageId) {
         $structure = imap_fetchstructure($this->connections[$email], $messageId);
         $encoding = isset($structure->parts) ? reset($structure->parts) : $structure;
         $message = imap_fetch_overview($this->connections[$email], $messageId);
         $message = reset($message);
         $processFunction = $this->detectProcessFunction($encoding->encoding);
         $message->subject = $processFunction($message->subject);
         $message->body = $this->getMessageBody($email, $messageId, $processFunction, reset($structure->parameters));
         foreach (['from', 'to'] as $direction) {
             $address = imap_rfc822_parse_adrlist(imap_utf8($message->{$direction}), '');
             $address = reset($address);
             $message->{$direction} = "{$address->mailbox}@{$address->host}";
         }
         $messages[] = (array) $message;
         imap_delete($this->connections[$email], $messageId);
     }
     return $messages;
 }

 private function read()
 {
     $allMails = imap_search($this->conn, 'ALL');
     if ($allMails) {
         rsort($allMails);
         foreach ($allMails as $email_number) {
             $overview = imap_fetch_overview($this->conn, $email_number, 0);
             $structure = imap_fetchstructure($this->conn, $email_number);
             $body = '';
             if (isset($structure->parts) && is_array($structure->parts) && isset($structure->parts[1])) {
                 $part = $structure->parts[1];
                 $body = imap_fetchbody($this->conn, $email_number, 2);
                 if ($part->encoding == 3) {
                     $body = imap_base64($body);
                 } else {
                     if ($part->encoding == 1) {
                         $body = imap_8bit($body);
                     } else {
                         $body = imap_qprint($body);
                     }
                 }
             }
             $body = utf8_decode($body);
             $fromaddress = utf8_decode(imap_utf7_encode($overview[0]->from));
             $subject = mb_decode_mimeheader($overview[0]->subject);
             $date = utf8_decode(imap_utf8($overview[0]->date));
             $date = date('Y-m-d H:i:s', strtotime($date));
             $key = md5($fromaddress . $subject . $body);
             //save to MySQL
             $sql = "SELECT count(*) FROM EMAIL_INFORMATION WHERE IDMAIL = " . $this->id . " AND CHECKVERS = \"" . $key . "\"";
             $resul = $this->pdo->query($sql)->fetch();
             if ($resul[0] == 0) {
                 $this->pdo->prepare("INSERT INTO EMAIL_INFORMATION (IDMAIL,FROMADDRESS,SUBJECT,DATE,BODY,CHECKVERS) VALUES (?,?,?,?,?,?)");
                 $this->pdo->execute(array($this->id, $fromaddress, $subject, $date, $body, $key));
             }
         }
     }
 }

 /**
  * Mime header value decoder. Usually unicode characters are encoded
  * according to RFC-2047. This function will decode RFC-2047 encoded
  * header values as well as detect headers which are not encoded.
  *
  * Caveats:
  * If headers contain non-ascii characters the result of this function
  * is completely undefined. If osTicket is corrupting your email
  * headers, your mail software is not encoding the header text
  * correctly.
  *
  * Returns:
  * Header value, transocded to UTF-8
  */
 function mime_decode($text, $encoding = 'utf-8')
 {
     // Handle poorly or completely un-encoded header values (
     if (function_exists('mb_detect_encoding')) {
         if (($src_enc = mb_detect_encoding($text)) && strcasecmp($src_enc, 'ASCII') !== 0) {
             return Charset::transcode($text, $src_enc, $encoding);
         }
     }
     // Handle ASCII text and RFC-2047 encoding
     $str = '';
     $parts = imap_mime_header_decode($text);
     foreach ($parts as $part) {
         $str .= $this->mime_encode($part->text, $part->charset, $encoding);
     }
     return $str ? $str : imap_utf8($text);
 }

 protected function initMailPart(IncomingMail $mail, $partStructure, $partNum, $markAsSeen = true)
 {
     $options = FT_UID;
     if (!$markAsSeen) {
         $options |= FT_PEEK;
     }
     $data = $partNum ? imap_fetchbody($this->getImapStream(), $mail->id, $partNum, $options) : imap_body($this->getImapStream(), $mail->id, $options);
     if ($partStructure->encoding == 1) {
         $data = imap_utf8($data);
     } elseif ($partStructure->encoding == 2) {
         $data = imap_binary($data);
     } elseif ($partStructure->encoding == 3) {
         $data = preg_replace('~[^a-zA-Z0-9+=/]+~s', '', $data);
         // https://github.com/barbushin/php-imap/issues/88
         $data = imap_base64($data);
     } elseif ($partStructure->encoding == 4) {
         $data = quoted_printable_decode($data);
     }
     $params = array();
     if (!empty($partStructure->parameters)) {
         foreach ($partStructure->parameters as $param) {
             $params[strtolower($param->attribute)] = $param->value;
         }
     }
     if (!empty($partStructure->dparameters)) {
         foreach ($partStructure->dparameters as $param) {
             $paramName = strtolower(preg_match('~^(.*?)\\*~', $param->attribute, $matches) ? $matches[1] : $param->attribute);
             if (isset($params[$paramName])) {
                 $params[$paramName] .= $param->value;
             } else {
                 $params[$paramName] = $param->value;
             }
         }
     }
     // attachments
     $attachmentId = $partStructure->ifid ? trim($partStructure->id, " <>") : (isset($params['filename']) || isset($params['name']) ? mt_rand() . mt_rand() : null);
     if ($attachmentId) {
         if (empty($params['filename']) && empty($params['name'])) {
             $fileName = $attachmentId . '.' . strtolower($partStructure->subtype);
         } else {
             $fileName = !empty($params['filename']) ? $params['filename'] : $params['name'];
             $fileName = $this->decodeMimeStr($fileName, $this->serverEncoding);
             $fileName = $this->decodeRFC2231($fileName, $this->serverEncoding);
         }
         $attachment = new IncomingMailAttachment();
         $attachment->id = $attachmentId;
         $attachment->name = $fileName;
         $attachment->disposition = isset($partStructure->disposition) ? $partStructure->disposition : null;
         if ($this->attachmentsDir) {
             $replace = array('/\\s/' => '_', '/[^0-9a-zа-яіїє_\\.]/iu' => '', '/_+/' => '_', '/(^_)|(_$)/' => '');
             $fileSysName = preg_replace('~[\\\\/]~', '', $mail->id . '_' . $attachmentId . '_' . preg_replace(array_keys($replace), $replace, $fileName));
             $attachment->filePath = $this->attachmentsDir . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'public' . DIRECTORY_SEPARATOR . $fileSysName;
             file_put_contents($attachment->filePath, $data);
         }
         $mail->addAttachment($attachment);
     } else {
         if (!empty($params['charset'])) {
             $data = $this->convertStringEncoding($data, $params['charset'], $this->serverEncoding);
         }
         if ($partStructure->type == 0 && $data) {
             if (strtolower($partStructure->subtype) == 'plain') {
                 $mail->textPlain .= $data;
             } else {
                 $mail->textHtml .= $data;
             }
         } elseif ($partStructure->type == 2 && $data) {
             $mail->textPlain .= trim($data);
         }
     }
     if (!empty($partStructure->parts)) {
         foreach ($partStructure->parts as $subPartNum => $subPartStructure) {
             if ($partStructure->type == 2 && $partStructure->subtype == 'RFC822') {
                 $this->initMailPart($mail, $subPartStructure, $partNum, $markAsSeen);
             } else {
                 $this->initMailPart($mail, $subPartStructure, $partNum . '.' . ($subPartNum + 1), $markAsSeen);
             }
         }
     }
 }

 // reads messages number
 $totalMessages = imap_num_msg($inbox);
 echo "<b>Total messages:</b> {$totalMessages}<br/><br/>";
 if ($totalMessages > 0) {
     // browses all messages
     for ($m = $totalMessages; $m > 0; $m--) {
         print "Processing message " . $m . " ----------------------------------<br>";
         $headers = imap_headerinfo($inbox, $m);
         $sender = $headers->from[0]->mailbox . "@" . $headers->from[0]->host;
         // checks if sender is allowed to forward messages
         if (checkAllowedSender($sender)) {
             //printf("mittente: %s<br><br>", $mittente);
             /*foreach($headers as $key) {
             			printf("key: %s<br>", $key);
             		}*/
             $subject = utf8_decode(imap_utf8($headers->subject));
             // extracts recipients rule from subject
             $ruleEndPos = strpos($subject, "]");
             $rule = "";
             if ($ruleEndPos !== false && $ruleEndPos > 1) {
                 $rule = substr($subject, 0, $ruleEndPos + 1);
                 // trims white spaces
                 $rule = trim($rule);
                 // trims white spaces
                 $rule = trim($rule, "[]");
                 //
                 // trims rule prefix
                 $subject = substr($subject, $ruleEndPos + 1);
                 // trims white spaces
                 $subject = trim($subject);
             }

 private function parseAddresses($list)
 {
     $addresses = [];
     foreach ($list as $item) {
         $address = (object) $item;
         if (!property_exists($address, 'mailbox')) {
             $address->mailbox = false;
         }
         if (!property_exists($address, 'host')) {
             $address->host = false;
         }
         if (!property_exists($address, 'personal')) {
             $address->personal = false;
         }
         $address->personal = imap_utf8($address->personal);
         $address->mail = $address->mailbox && $address->host ? $address->mailbox . '@' . $address->host : false;
         $address->full = $address->personal ? $address->personal . ' <' . $address->mail . '>' : $address->mail;
         $addresses[] = $address;
     }
     return $addresses;
 }

 /**
  * get message headers
  *
  * @param string|Expressomail_Model_Message $_messageId
  * @param boolean $_readOnly
  * @return array
  * @throws Expressomail_Exception_IMAPMessageNotFound
  */
 public function getMessageHeaders($_messageId, $_partId = null, $_readOnly = false)
 {
     if (!$_messageId instanceof Expressomail_Model_Message) {
         $message = $this->_backend->get($_messageId);
     } else {
         $message = $_messageId;
     }
     if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) {
         Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' Fetching headers for message uid ' . $message->messageuid . ' (part:' . $_partId . ')');
     }
     try {
         $imapBackend = $this->_getBackendAndSelectFolder($message->folder_id);
     } catch (Zend_Mail_Storage_Exception $zmse) {
         if (Tinebase_Core::isLogLevel(Zend_Log::WARN)) {
             Tinebase_Core::getLogger()->warn(__METHOD__ . '::' . __LINE__ . ' ' . $zmse->getMessage());
         }
         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) {
             Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__ . ' ' . $zmse->getTraceAsString());
         }
         throw new Expressomail_Exception_IMAPMessageNotFound('Folder not found');
     }
     if ($imapBackend === null) {
         throw new Expressomail_Exception('Failed to get imap backend');
     }
     $section = $_partId === null ? 'HEADER' : $_partId . '.HEADER';
     try {
         $rawHeaders = $imapBackend->getRawContent($message->messageuid, $section, $_readOnly);
         if (strtolower(mb_detect_encoding($rawHeaders)) == 'utf-8') {
             $rawHeaders = utf8_decode(imap_utf8($rawHeaders));
         }
     } catch (Expressomail_Exception_IMAPMessageNotFound $feimnf) {
         $this->_backend->delete($message->getId());
         throw $feimnf;
     }
     if (Tinebase_Core::isLogLevel(Zend_Log::TRACE)) {
         Tinebase_Core::getLogger()->trace(__METHOD__ . '::' . __LINE__ . ' Fetched Headers: ' . $rawHeaders);
     }
     Zend_Mime_Decode::splitMessage($rawHeaders, $headers, $null);
     return $headers;
 }

 protected function initMailPart(IncomingMail $mail, $partStructure, $partNum)
 {
     $data = $partNum ? imap_fetchbody($this->getImapStream(), $mail->id, $partNum, FT_UID) : imap_body($this->getImapStream(), $mail->id, FT_UID);
     if ($partStructure->encoding == 1) {
         $data = imap_utf8($data);
     } elseif ($partStructure->encoding == 2) {
         $data = imap_binary($data);
     } elseif ($partStructure->encoding == 3) {
         $data = imap_base64($data);
     } elseif ($partStructure->encoding == 4) {
         $data = imap_qprint($data);
     }
     $params = array();
     if (!empty($partStructure->parameters)) {
         foreach ($partStructure->parameters as $param) {
             $params[strtolower($param->attribute)] = $param->value;
         }
     }
     if (!empty($partStructure->dparameters)) {
         foreach ($partStructure->dparameters as $param) {
             $paramName = strtolower(preg_match('~^(.*?)\\*~', $param->attribute, $matches) ? $matches[1] : $param->attribute);
             if (isset($params[$paramName])) {
                 $params[$paramName] .= $param->value;
             } else {
                 $params[$paramName] = $param->value;
             }
         }
     }
     if (!empty($params['charset'])) {
         $data = iconv(strtoupper($params['charset']), $this->serverEncoding . '//IGNORE', $data);
     }
     // attachments
     $attachmentId = $partStructure->ifid ? trim($partStructure->id, " <>") : (isset($params['filename']) || isset($params['name']) ? mt_rand() . mt_rand() : null);
     if ($attachmentId) {
         if (empty($params['filename']) && empty($params['name'])) {
             $fileName = $attachmentId . '.' . strtolower($partStructure->subtype);
         } else {
             $fileName = !empty($params['filename']) ? $params['filename'] : $params['name'];
             $fileName = $this->decodeMimeStr($fileName, $this->serverEncoding);
             $fileName = $this->decodeRFC2231($fileName, $this->serverEncoding);
         }
         $attachment = new IncomingMailAttachment();
         $attachment->id = $attachmentId;
         $attachment->name = $fileName;
         if ($this->attachmentsDir) {
             $replace = array('/\\s/' => '_', '/[^0-9a-zA-Z_\\.]/' => '', '/_+/' => '_', '/(^_)|(_$)/' => '');
             $fileSysName = preg_replace('~[\\\\/]~', '', $mail->id . '_' . $attachmentId . '_' . preg_replace(array_keys($replace), $replace, $fileName));
             $attachment->filePath = $this->attachmentsDir . DIRECTORY_SEPARATOR . $fileSysName;
             file_put_contents($attachment->filePath, $data);
         }
         $mail->addAttachment($attachment);
     } elseif ($partStructure->type == 0 && $data) {
         if (strtolower($partStructure->subtype) == 'plain') {
             $mail->textPlain .= $data;
         } else {
             $mail->textHtml .= $data;
         }
     } elseif ($partStructure->type == 2 && $data) {
         $mail->textPlain .= trim($data);
     }
     if (!empty($partStructure->parts)) {
         foreach ($partStructure->parts as $subPartNum => $subPartStructure) {
             if ($partStructure->type == 2 && $partStructure->subtype == 'RFC822') {
                 $this->initMailPart($mail, $subPartStructure, $partNum);
             } else {
                 $this->initMailPart($mail, $subPartStructure, $partNum . '.' . ($subPartNum + 1));
             }
         }
     }
 }

 /**
  * Returns an array of parts as file objects
  *
  * @param
  * @param $structure
  *   A message structure, usually used to recurse into specific parts
  * @param $max_depth
  *   Maximum Depth to recurse into parts.
  * @param $depth
  *   The current recursion depth.
  * @param $part_number
  *   A message part number to track position in a message during recursion.
  * @return
  *   An array of file objects.
  */
 function get_parts($stream, $msg_number, $max_depth = 10, $depth = 0, $structure = FALSE, $part_number = 1)
 {
     $parts = array();
     // Load Structure.
     if (!$structure && !($structure = imap_fetchstructure($stream, $msg_number))) {
         watchdog('mailhandler', 'Could not fetch structure for message number %msg_number', array('%msg_number' => $msg_number), WATCHDOG_NOTICE);
         return $parts;
     }
     // Recurse into multipart messages.
     if ($structure->type == TYPEMULTIPART) {
         // Restrict recursion depth.
         if ($depth >= $max_depth) {
             watchdog('mailhandler', 'Maximum recursion depths met in mailhander_get_structure_part for message number %msg_number.', array('%msg_number' => $msg_number), WATCHDOG_NOTICE);
             return $parts;
         }
         $prefix = '';
         foreach ($structure->parts as $index => $sub_structure) {
             // If a part number was passed in and we are a multitype message, prefix the
             // the part number for the recursive call to match the imap4 dot seperated part indexing.
             if ($part_number) {
                 $prefix = $part_number . '.';
             }
             $sub_parts = $this->get_parts($stream, $msg_number, $max_depth, $depth + 1, $sub_structure, $prefix . ($index + 1));
             $parts = array_merge($parts, $sub_parts);
         }
         return $parts;
     }
     // Per Part Parsing.
     // Initalize file object like part structure.
     $part = new stdClass();
     $part->attributes = array();
     $part->filename = 'unnamed_attachment';
     if (!($part->filemime = $this->get_mime_type($structure))) {
         watchdog('mailhandler', 'Could not fetch mime type for message part. Defaulting to application/octet-stream.', array(), WATCHDOG_NOTICE);
         $part->filemime = 'application/octet-stream';
     }
     if ($structure->ifparameters) {
         foreach ($structure->parameters as $parameter) {
             switch (drupal_strtoupper($parameter->attribute)) {
                 case 'NAME':
                 case 'FILENAME':
                     $part->filename = $parameter->value;
                     break;
                 default:
                     // put every thing else in the attributes array;
                     $part->attributes[$parameter->attribute] = $parameter->value;
             }
         }
     }
     // Handle Content-Disposition parameters for non-text types.
     if ($structure->type != TYPETEXT && $structure->ifdparameters) {
         foreach ($structure->dparameters as $parameter) {
             switch (drupal_strtoupper($parameter->attribute)) {
                 case 'NAME':
                 case 'FILENAME':
                     $part->filename = $parameter->value;
                     break;
                     // put every thing else in the attributes array;
                 // put every thing else in the attributes array;
                 default:
                     $part->attributes[$parameter->attribute] = $parameter->value;
             }
         }
     }
     // Store part id for reference.
     if (!empty($structure->id)) {
         $part->id = $structure->id;
     }
     // Retrieve part and convert MIME encoding to UTF-8
     if (!($part->data = imap_fetchbody($stream, $msg_number, $part_number, FT_PEEK))) {
         watchdog('mailhandler', 'No Data!!', array(), WATCHDOG_ERROR);
         return $parts;
     }
     // Decode as necessary.
     if ($structure->encoding == ENCBASE64) {
         $part->data = imap_base64($part->data);
     } elseif ($structure->encoding == ENCQUOTEDPRINTABLE) {
         $part->data = quoted_printable_decode($part->data);
     } elseif ($structure->type == TYPETEXT) {
         $part->data = imap_utf8($part->data);
     }
     // Always return an array to satisfy array_merge in recursion catch, and
     // array return value.
     $parts[] = $part;
     return $parts;
//.........这里部分代码省略.........

 /**
  * @name: getmails
  * holt x Mails aus dem Postfach und parst diese nach Parts, oder sucht nur nach $subject
  *
  * @param $subject
  * @return Boolean
  */
 public function getmails($subject = 0)
 {
     imap_expunge($this->connection);
     $check = imap_mailboxmsginfo($this->connection);
     if (isset($subject) && !empty($subject)) {
         $mails = imap_search($this->connection, 'UNSEEN SUBJECT "' . substr(urldecode(subject), 0, 45) . '"', SE_UID);
     } else {
         $mails[0] = '*';
     }
     $mails = imap_fetch_overview($this->connection, "1:" . $mails[0], FT_UID);
     // Holt eine Uebersicht aller Emails
     $size = count($mails);
     // Anzahl der Nachrichten
     if ($size >= $this->config['counter']) {
         $size = $this->config['counter'];
     }
     for ($i = 0; $i < $size; $i++) {
         if ($i >= $this->config['counter']) {
             break;
         }
         $mails[$i]->subject = imap_utf8($mails[$i]->subject);
         $header = imap_fetchheader($this->connection, $mails[$i]->msgno);
         $struct = imap_fetchstructure($this->connection, $mails[$i]->msgno);
         $report = imap_fetchbody($this->connection, $mails[$i]->msgno, 2);
         $body = imap_fetchbody($this->connection, $mails[$i]->msgno, 1);
         $logs = imap_fetchbody($this->connection, $mails[$i]->msgno, 3);
         $this->mail[$i] = array('header' => $header, 'body' => $body, 'report' => $report, 'logs' => $logs, 'structur' => $struct, 'all' => $mails[$i]);
         $this->msgnr = $mails[$i]->msgno;
         if ($this->config['afterparse'] == 'delete') {
             imap_delete($this->connection, $mails[$i]->msgno . ':*');
         } elseif ($this->config['afterparse'] == 'move') {
             imap_mail_move($this->connection, $mails[$i]->msgno, $config['ordner'] . '.' . $this->config['movebox']);
         }
     }
     if ($this->config['afterparse'] == 'delete_all') {
         imap_delete($this->connection, "*");
     }
     imap_expunge($this->connection);
     if (!is_array($mails)) {
         $this->mail = 0;
     }
     return $this->mail;
 }

 protected function initMailPart($mbox, $mail, $partStructure, $partNum)
 {
     $data = $partNum ? imap_fetchbody($mbox, $mail['id'], $partNum, FT_UID | FT_PEEK) : imap_body($mbox, $mail['id'], FT_UID | FT_PEEK);
     if ($partStructure->encoding == 1) {
         $data = imap_utf8($data);
     } elseif ($partStructure->encoding == 2) {
         $data = imap_binary($data);
     } elseif ($partStructure->encoding == 3) {
         $data = imap_base64($data);
     } elseif ($partStructure->encoding == 4) {
         $data = imap_qprint($data);
     }
     $params = array();
     if (!empty($partStructure->parameters)) {
         foreach ($partStructure->parameters as $param) {
             $params[strtolower($param->attribute)] = $param->value;
         }
     }
     if (!empty($partStructure->dparameters)) {
         foreach ($partStructure->dparameters as $param) {
             $paramName = strtolower(preg_match('~^(.*?)\\*~', $param->attribute, $matches) ? $matches[1] : $param->attribute);
             if (isset($params[$paramName])) {
                 $params[$paramName] .= $param->value;
             } else {
                 $params[$paramName] = $param->value;
             }
         }
     }
     if (!empty($params['charset'])) {
         $data = iconv(strtoupper($params['charset']), 'utf-8', $data);
     }
     $attachmentId = $partStructure->ifid ? trim($partStructure->id, " <>") : (isset($params['filename']) || isset($params['name']) ? mt_rand() . mt_rand() : null);
     if ($attachmentId) {
         if (empty($params['filename']) && empty($params['name'])) {
             $fileName = $attachmentId . '.' . strtolower($partStructure->subtype);
         } else {
             $fileName = !empty($params['filename']) ? $params['filename'] : $params['name'];
             $fileName = self::decodeMimeStr($fileName);
             $fileName = self::decodeRFC2231($fileName);
         }
         $mail['attachments'][$attachmentId]['filename'] = $fileName;
         $mail['attachments'][$attachmentId]['attachment'] = $data;
     } elseif ($partStructure->type == 0 && $data) {
         if (base64_decode($data, true)) {
             $data = base64_decode($data);
         }
         if (strtolower($partStructure->subtype) == 'plain') {
             $mail['textPlain'] .= $data;
         } else {
             $mail['textHtml'] .= $data;
         }
     } elseif ($partStructure->type == 2 && $data) {
         $mail['textPlain'] .= trim($data);
     }
     if (!empty($partStructure->parts)) {
         foreach ($partStructure->parts as $subPartNum => $subPartStructure) {
             if ($partStructure->type == 2 && $partStructure->subtype == 'RFC822') {
                 $mail = self::initMailPart($mbox, $mail, $subPartStructure, $partNum);
             } else {
                 $mail = self::initMailPart($mbox, $mail, $subPartStructure, $partNum . '.' . ($subPartNum + 1));
             }
         }
     }
     return $mail;
 }

 require_once "modules/Webmails/MailParse.php";
 require_once 'modules/Webmails/MailBox.php';
 $mailInfo = getMailServerInfo($current_user);
 $temprow = $adb->fetch_array($mailInfo);
 $MailBox = new MailBox($mailbox);
 $mbox = $MailBox->mbox;
 $webmail = new Webmails($mbox, $mailid);
 $array_tab = array();
 $webmail->loadMail($array_tab);
 $hdr = @imap_headerinfo($mbox, $mailid);
 $smarty->assign('WEBMAIL', "true");
 $smarty->assign('mailid', $mailid);
 $smarty->assign('mailbox', $mailbox);
 $temp_id = $MailBox->boxinfo['mail_id'];
 $smarty->assign('from_add', $temp_id);
 $webmail->subject = utf8_decode(utf8_encode(imap_utf8($webmail->subject)));
 if ($_REQUEST["reply"] == "all") {
     $smarty->assign('TO_MAIL', $webmail->from . ",");
     //added to remove the emailid of webmail client from cc list....to fix the issue #3818
     $cc_address = '';
     $use_to_header = htmlentities($webmail->to_header, ENT_QUOTES, $default_charset);
     $use_cc_address = htmlentities($hdr->ccaddress, ENT_QUOTES, $default_charset);
     $cc_array = explode(',', $use_to_header . ',' . $use_cc_address);
     for ($i = 0; $i < count($cc_array); $i++) {
         if (trim($cc_array[$i]) != trim($temp_id)) {
             $cc_address .= $cc_array[$i];
             $cc_address = $i != count($cc_array) - 1 ? $cc_address . ',' : $cc_address;
         }
     }
     if (trim($cc_address) != '') {
         $cc_address = trim($cc_address, ",") . ",";

 function mime_decode($text, $encoding = 'utf-8')
 {
     if (function_exists('mb_detect_encoding')) {
         if (($src_enc = mb_detect_encoding($text)) && strcasecmp($src_enc, 'ASCII') !== 0) {
             return Format::encode($text, $src_enc, $encoding);
         }
     }
     $str = '';
     $parts = imap_mime_header_decode($text);
     foreach ($parts as $part) {
         $str .= $this->mime_encode($part->text, $part->charset, $encoding);
     }
     return $str ? $str : imap_utf8($text);
 }