function GetMessage($message_id, $external_id = 0)
 {
     if (!isset($this->_messageCash[$message_id])) {
         $raw_message = $this->_pop3->getMsg($message_id);
         require_once SYS . '/system/class/email/mime/mimeDecode.php';
         $params['include_bodies'] = true;
         $params['decode_bodies'] = true;
         $params['decode_headers'] = true;
         $decoder = new Mail_mimeDecode($raw_message);
         $msg = $decoder->decode($params);
         //				Dump($msg, true);
         $msg->external_id = $external_id;
         if (isset($msg->headers['date'])) {
             $msg->Moment = strtotime($msg->headers['date']);
         } else {
             $msg->Moment = 0;
         }
         $msg = $this->ProcessMessageBody($msg);
         if (strtoupper($msg->charset) == 'KOI8-R') {
             $msg->body = convert_cyr_string($msg->body, 'koi8-r', 'Windows-1251');
             $msg->headers['subject'] = convert_cyr_string($msg->headers['subject'], 'koi8-r', 'Windows-1251');
             $msg->charset = 'Windows-1251';
         }
         $this->_messageCash[$message_id] = $msg;
         $this->got_inner_body = null;
     }
     return $this->_messageCash[$message_id];
 }

function testMimeDecode($file, $new_file)
{
    if (!defined('LOGLEVEL')) {
        define('LOGLEVEL', LOGLEVEL_DEBUG);
    }
    if (!defined('LOGUSERLEVEL')) {
        define('LOGUSERLEVEL', LOGLEVEL_DEVICEID);
    }
    printf("TEST MIME DECODE\n");
    $mobj = new Mail_mimeDecode(file_get_contents($file));
    $message = $mobj->decode(array('decode_headers' => true, 'decode_bodies' => true, 'include_bodies' => true, 'charset' => 'utf-8'));
    $handle = fopen($new_file, "w");
    fwrite($handle, build_mime_message($message));
    fclose($handle);
    foreach ($message->headers as $k => $v) {
        if (is_array($v)) {
            foreach ($v as $vk => $vv) {
                printf("Header <%s> <%s> <%s>\n", $k, $vk, $vv);
            }
        } else {
            printf("Header <%s> <%s>\n", $k, $v);
        }
    }
    $text = $html = "";
    Mail_mimeDecode::getBodyRecursive($message, "plain", $text);
    Mail_mimeDecode::getBodyRecursive($message, "html", $html);
    printf("TEXT Body <%s>\n", $text);
    printf("HTML Body <%s>\n", $html);
}

 /**
  * メール受信時の処理
  * 
  * @access public
  * @author sakuragawa
  */
 function execute()
 {
     ini_set('memory_limit', -1);
     // 前処理
     $this->beforefilter();
     // メールの読み込み
     $source = file_get_contents("php://stdin");
     if (empty($source)) {
         return;
     }
     // \nをつけてるのは、そのままだとSoftbankの空メールが取得できなかったから
     $source .= "\n";
     $this->hookMail($source);
     // メールをデコード
     //$this->out($this->params2);
     $Decoder = new Mail_mimeDecode($source);
     $mail = $Decoder->decode($this->mailMimeDecodeParams);
     // Fromを取得
     $from = $this->_parseAddress($mail, 'from');
     $this->hookFromAddress($from);
     // Toを取得
     $to = $this->_parseAddress($mail, 'to');
     $this->hookToAddress($to);
     // 本文・添付等をパース
     $this->_parseBody($mail);
     $this->afterfilter();
     // Toを取得
     /*$to = $this->_getTo($mail);
       $this->getTo($to);*/
 }

function transport_email_receive($pMsg)
{
    global $gBitUser, $gBitSystem;
    // prolly dont need this
    // $connectionString = '{'.$gBitSystem->getConfig('transport_email_server','imap').':'.$gBitSystem->getConfig('transport_email_port','993').'/'.$gBitSystem->getConfig('transport_email_protocol','imap').'/ssl/novalidate-cert}';
    // Parse msg - get header, body, attachments, to, from, reply header
    if (include_once 'PEAR.php') {
        if (require_once 'Mail/mimeDecode.php') {
            $params['include_bodies'] = true;
            $params['decode_bodies'] = true;
            $params['decode_headers'] = true;
            $decoder = new Mail_mimeDecode($pMsg);
            if ($data = $decoder->decode($params)) {
                if ($handler($data)) {
                    transport_email_expunge($pMsg);
                }
            } else {
                //error
            }
        } else {
            //error
        }
    } else {
        //error
    }
}

 public function parse($input)
 {
     $decoder = new Mail_mimeDecode($input, "\r\n");
     $structure = $decoder->decode(array('include_bodies' => true, 'decode_bodies' => true));
     $raw_mail = (array) $structure;
     $raw_mail['body'] = $this->getBody($structure);
     return $raw_mail;
 }

function decodeEmail($input)
{
    $params['include_bodies'] = true;
    $params['decode_bodies'] = true;
    $params['decode_headers'] = true;
    $decoder = new Mail_mimeDecode($input);
    $structure = $decoder->decode($params);
    return $structure;
}

 public function process()
 {
     $this->init();
     ini_set('memory_limit', -1);
     $debug = app()->request->getParam('debug');
     $params = [];
     //SUPPLIER_PRICES_DIR
     $incoming = $debug ? file_get_contents($this->_rootPath . DS . "eml" . DS . "test.eml") : app()->request->getParam('@letter');
     if (!$incoming) {
         $this->log('не корректное получение письма', true);
     }
     $params = ['include_bodies' => true, 'decode_bodies' => true, 'decode_headers' => true];
     $decoder = new Mail_mimeDecode($incoming);
     $result = $decoder->decode($params);
     preg_match_all('/\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,3})+/', $result->headers["from"], $matches);
     $mail = $matches[0];
     //array with from emails
     if (!$mail) {
         $this->log("не установлен отправитель письма от {$result->headers['from']}", true);
     }
     $this->email = $mail[0];
     // временный тестовый лог
     if (isset($result->headers["subject"]) && is_array($result->headers["subject"])) {
         $this->log("ОШИБКА в ParseLetter-e \nДата: " . CJSON::encode($result), true);
     }
     // Пример: Subject: [supplierId 9255]
     if (isset($result->headers["subject"]) && strpos($result->headers["subject"], 'supplierId') !== false) {
         $subject = $result->headers["subject"];
         preg_match_all('/\\[.*?(\\d+)\\]/i', $subject, $matches);
         $idSupplier = $matches[1][0];
     } else {
         $query = app()->db->createCommand()->select('id_supplier, email')->from('supplier_email c')->join('supplier s', 'c.id_supplier = s.id')->where('email = "' . $this->email . '"')->andWhere('follow_manual = 1')->queryRow();
         $idSupplier = $query['id_supplier'];
     }
     if (!$idSupplier) {
         // $this->log("{$this->email} :: не установлен поставщик или для поставщика отключена настройка 'Следить вручную'", true); //временно выключаем
         Yii::app()->end();
     }
     $this->idSupplier = trim($idSupplier);
     $this->_destFileDir = $this->_rootPath . $this->idSupplier . DS . 'new';
     File::checkPermissions($this->_destFileDir);
     setlocale(LC_ALL, 'ru_RU.UTF8');
     if (isset($result->parts)) {
         foreach ($result->parts as $key => $part) {
             if ($part->ctype_primary == 'multipart') {
                 foreach ($part->parts as $k => $v) {
                     $this->mainProccess($v);
                 }
             } else {
                 $this->mainProccess($part);
             }
         }
     }
 }

 function decode()
 {
     $params = array('crlf' => "\r\n", 'input' => $this->mime_message, 'include_bodies' => $this->include_bodies, 'decode_headers' => $this->decode_headers, 'decode_bodies' => $this->decode_bodies);
     $this->splitBodyHeader();
     $this->struct = Mail_mimeDecode::decode($params);
     return PEAR::isError($this->struct) || !(count($this->struct->headers) > 1) ? FALSE : TRUE;
 }

 public static function processemail($emailsrc, $pdfout, $coverfile = '')
 {
     $combfilelist = array();
     # Process the email
     $emailparts = Mail_mimeDecode::decode(array('include_bodies' => true, 'decode_bodies' => true, 'decode_headers' => true, 'input' => file_get_contents($emailsrc), 'crlf' => "\r\n"));
     # Process the cover if it exists
     if ($coverfile !== '') {
         $combfilelist[] = self::processpart(file_get_contents($coverfile), mime_content_type($coverfile));
     }
     # Process the parts
     $combfilelist = array_merge($combfilelist, self::processparts($emailparts));
     # Create an intermediate file to build the pdf
     $tmppdffilename = sys_get_temp_dir() . '/e2p-' . (string) abs((int) (microtime(true) * 100000)) . '.pdf';
     # Build the command to combine all of the intermediate files into one
     $conbcom = str_replace(array_merge(array('INTFILE', 'COMBLIST'), array_keys(self::$driver_paths)), array_merge(array($tmppdffilename, implode(' ', $combfilelist)), array_values(self::$driver_paths)), self::$mime_drivers['gs']);
     exec($conbcom);
     # Remove the intermediate files
     foreach ($combfilelist as $combfilename) {
         unlink($combfilename);
     }
     # Write the intermediate file to the final destination
     $intfileres = fopen($tmppdffilename, 'rb');
     $outfileres = fopen($pdfout, 'ab');
     while (!feof($intfileres)) {
         fwrite($outfileres, fread($intfileres, 8192));
     }
     fclose($intfileres);
     fclose($outfileres);
     # Remove the intermediate file
     unlink($tmppdffilename);
 }

 /**
  * メールをデコード
  *
  * @access public
  * @param string メールの生データ
  */
 function decode($raw_mail)
 {
     $params['include_bodies'] = true;
     $params['decode_bodies'] = true;
     $params['decode_headers'] = true;
     $params['input'] = $raw_mail;
     $this->mail =& Mail_mimeDecode::decode($params);
 }

 function updateOrCreateEmail($part = '', $opts, $cm = false)
 {
     // DB_DataObject::debugLevel(1);
     $template_name = preg_replace('/\\.[a-z]+$/i', '', basename($opts['file']));
     if (!file_exists($opts['file'])) {
         $this->jerr("file does not exist : " . $opts['file']);
     }
     if (!empty($opts['master']) && !file_exists($opts['master'])) {
         $this->jerr("master file does not exist : " . $opts['master']);
     }
     if (empty($cm)) {
         $cm = DB_dataObject::factory('core_email');
         $ret = $cm->get('name', $template_name);
         if ($ret && empty($opts['update'])) {
             $this->jerr("use --update 1 to update the template..");
         }
     }
     $mailtext = file_get_contents($opts['file']);
     if (!empty($opts['master'])) {
         $body = $mailtext;
         $mailtext = file_get_contents($opts['master']);
         $mailtext = str_replace('{outputBody():h}', $body, $mailtext);
     }
     require_once 'Mail/mimeDecode.php';
     require_once 'Mail/RFC822.php';
     $decoder = new Mail_mimeDecode($mailtext);
     $parts = $decoder->getSendArray();
     if (is_a($parts, 'PEAR_Error')) {
         echo $parts->toString() . "\n";
         exit;
     }
     $headers = $parts[1];
     $from = new Mail_RFC822();
     $from_str = $from->parseAddressList($headers['From']);
     $from_name = trim($from_str[0]->personal, '"');
     $from_email = $from_str[0]->mailbox . '@' . $from_str[0]->host;
     if ($cm->id) {
         $cc = clone $cm;
         $cm->setFrom(array('bodytext' => $parts[2], 'updated_dt' => date('Y-m-d H:i:s')));
         $cm->update($cc);
     } else {
         $cm->setFrom(array('from_name' => $from_name, 'from_email' => $from_email, 'subject' => $headers['Subject'], 'name' => $template_name, 'bodytext' => $parts[2], 'updated_dt' => date('Y-m-d H:i:s'), 'created_dt' => date('Y-m-d H:i:s')));
         $cm->insert();
     }
     return $cm;
 }

 public function parse($raw)
 {
     $this->raw = $raw;
     // http://pear.php.net/manual/en/package.mail.mail-mimedecode.decode.php
     $decoder = new Mail_mimeDecode($this->raw);
     $this->decoded = $decoder->decode(['decode_headers' => true, 'include_bodies' => true, 'decode_bodies' => true]);
     $this->from = mb_convert_encoding($this->decoded->headers['from'], $this->charset, $this->charset);
     $this->to = mb_convert_encoding($this->decoded->headers['to'], $this->charset, $this->charset);
     $this->subject = mb_convert_encoding($this->decoded->headers['subject'], $this->charset, $this->charset);
     $this->date = mb_convert_encoding($this->decoded->headers['date'], $this->charset, $this->charset);
     $this->from_email = preg_replace('/.*<(.*)>.*/', "\$1", $this->from);
     if (isset($this->decoded->parts) && is_array($this->decoded->parts)) {
         foreach ($this->decoded->parts as $idx => $body_part) {
             $this->decode_part($body_part);
         }
     }
     if (isset($this->decoded->disposition) && $this->decoded->disposition == 'inline') {
         $mime_type = "{$this->decoded->ctype_primary}/{$this->decoded->ctype_secondary}";
         if (isset($this->decoded->d_parameters) && array_key_exists('filename', $this->decoded->d_parameters)) {
             $filename = $this->decoded->d_parameters['filename'];
         } else {
             $filename = 'file';
         }
         if ($this->is_valid_attachment($mime_type)) {
             $this->save_attachment($filename, $this->decoded->body, $mime_type);
         }
         $this->body = "";
     }
     // We might also have uuencoded files. Check for those.
     if (empty($this->body)) {
         $this->body = isset($this->decoded->body) ? $this->decoded->body : "";
     }
     if (preg_match("/begin ([0-7]{3}) (.+)\r?\n(.+)\r?\nend/Us", $this->body) > 0) {
         foreach ($decoder->uudecode($this->body) as $file) {
             // $file = [ 'filename' => $filename, 'fileperm' => $fileperm, 'filedata' => $filedata ]
             $this->save_attachment($file['filename'], $file['filedata']);
         }
         // Strip out all the uuencoded attachments from the body
         while (preg_match("/begin ([0-7]{3}) (.+)\r?\n(.+)\r?\nend/Us", $this->body) > 0) {
             $this->body = preg_replace("/begin ([0-7]{3}) (.+)\r?\n(.+)\r?\nend/Us", "\n", $this->body);
         }
     }
     $this->body = mb_convert_encoding($this->body, $this->charset, $this->charset);
     return $this;
 }

 function MoblogRequest($request)
 {
     $this->Object();
     $this->_message = $request["message"];
     // it is possible to specify a default user id in the POSTed email message via
     // curl, so that the amount of stuff that we need to type in the email is reduced
     // to only the user password. This basically means that email addresses configured to be used
     // by a default user and blog id cannot be used as 'gateways'
     $this->_blogId = $request["blogId"];
     $this->_user = $request["user"];
     MoblogLogger::log("From REQUEST: user = " . $this->_user . " - blogId = " . $this->_blogId);
     // parse the mime message
     $decode = new Mail_mimeDecode($this->_message, "\r\n");
     $structure = $decode->decode(array("include_bodies" => true, "decode_bodies" => true, "decode_headers" => true));
     // get the reply address, it might be in different headers
     if (isset($structure->headers['x-loop'])) {
         $this->_replyAddress = "";
     } else {
         $replyTo1 = $structure->headers['from'];
         $replyTo2 = $structure->headers['return-path'];
         $this->_replyAddress = $replyTo2 != "" ? $replyTo2 : $replyTo1;
     }
     // parse the body
     $this->parseBody($structure->body);
     $this->_inputEncoding = strtoupper($structure->ctype_parameters['charset']);
     MoblogLogger::log("There are " . count($structure->parts) . " MIME parts available to parse");
     $this->parseMimeParts($structure->parts);
     // if there was no subject specified, then let's see if there was something in the
     // 'subject' line...
     if ($this->_topic == "") {
         $this->_topic = $structure->headers['subject'];
         if ($this->_topic == "" || stristr($this->_topic, "pass:")) {
             // if there is still no subject, get the first 50 characters of the body
             $this->_topic = substr(strip_tags($this->_body), 0, 50);
             if ($this->_topic == "") {
                 $this->_topic = "No Topic";
             }
         }
     }
     MoblogLogger::Log("subject is = " . $this->_topic);
 }

 function &_parseMsg(&$msg)
 {
     $arr = array();
     //Parse out attachments/HTML
     $this->_params['input'] = $msg['msg'];
     $structure = Mail_mimeDecode::decode($this->_params);
     $body = $this->_getBody($structure);
     $arr['hash'] = $this->_parseTicketID($structure->headers['subject']);
     $arr['msg'] = $this->_parseBody($body);
     $arr['mime_struct'] = $structure;
     $arr = array_merge($arr, $this->_parseFrom($structure->headers['from']));
     return $arr;
 }

 /**
  * Constructor
  *
  * @param string                                         $content Http response
  * as string
  *
  * @param WindowsAzure\Common\Internal\Http\BatchRequest $request Source batch
  * request object
  */
 public function __construct($content, $request = null)
 {
     $params['include_bodies'] = true;
     $params['input'] = $content;
     $mimeDecoder = new \Mail_mimeDecode($content);
     $structure = $mimeDecoder->decode($params);
     $parts = $structure->parts;
     $this->_contexts = array();
     $requestContexts = null;
     if ($request != null) {
         Validate::isA($request, 'WindowsAzure\\Common\\Internal\\Http\\BatchRequest', 'request');
         $requestContexts = $request->getContexts();
     }
     $i = 0;
     foreach ($parts as $part) {
         if (!empty($part->body)) {
             $headerEndPos = strpos($part->body, "\r\n\r\n");
             $header = substr($part->body, 0, $headerEndPos);
             $body = substr($part->body, $headerEndPos + 4);
             $headerStrings = explode("\r\n", $header);
             $response = new \HTTP_Request2_Response(array_shift($headerStrings));
             foreach ($headerStrings as $headerString) {
                 $response->parseHeaderLine($headerString);
             }
             $response->appendBody($body);
             $this->_contexts[] = $response;
             if (is_array($requestContexts)) {
                 $expectedCodes = $requestContexts[$i]->getStatusCodes();
                 $statusCode = $response->getStatus();
                 if (!in_array($statusCode, $expectedCodes)) {
                     $reason = $response->getReasonPhrase();
                     throw new ServiceException($statusCode, $reason, $body);
                 }
             }
             $i++;
         }
     }
 }

 function SendMail($rfc822, $forward = false, $reply = false, $parent = false)
 {
     debugLog('FileStorage::SendMail(..., ' . $forward . ', ' . $reply . ', ' . $parent . ')');
     $mobj = new Mail_mimeDecode($rfc822);
     $message = $mobj->decode(array('decode_headers' => true, 'decode_bodies' => true, 'include_bodies' => true, 'input' => $rfc822, 'crlf' => "\r\n", 'charset' => 'utf-8'));
     if ($message->ctype_primary != "multipart" || $message->ctype_secondary != "mixed") {
         debugLog('FileStorage::SendMail not multipart/mixed');
         return false;
     }
     if (!isset($message->headers['subject']) || strtolower(substr(trim($message->headers['subject']), 0, 11)) != 'filestorage') {
         debugLog('FileStorage::SendMail subject not filestorage: ' . $message->headers['subject']);
         return false;
     }
     $d = '/' . str_replace('\\', '/', substr(trim($message->headers['subject']), 11)) . '/';
     if (strpos($d, '/../') !== false) {
         return true;
     }
     debugLog('FileStorage::SendMail dir: ' . $d);
     foreach ($message->parts as $part) {
         if ($part->ctype_primary == "text" || $part->ctype_primary == "multipart") {
             continue;
         }
         debugLog('FileStorage::SendMail attachment found');
         if (isset($part->ctype_parameters["name"])) {
             $filename = $part->ctype_parameters["name"];
         } else {
             if (isset($part->d_parameters["name"])) {
                 $filename = $part->d_parameters["filename"];
             } else {
                 return false;
             }
         }
         debugLog('FileStorage::SendMail saving: ' . $filename);
         file_put_contents($this->getPath('root') . $d . $filename, $part->body);
     }
     return true;
 }

 /**
  * Redfined here just to avoid breakage on isStatic test (first line).
  * It's just a copy/paste of parent's method
  */
 function decode($params = null)
 {
     // determine if this method has been called statically
     $isStatic = !(isset($this) && get_class($this) == __CLASS__);
     // Have we been called statically?
     // If so, create an object and pass details to that.
     if ($isStatic and isset($params['input'])) {
         $obj = new Mail_mimeDecode($params['input']);
         $structure = $obj->decode($params);
         // Called statically but no input
     } elseif ($isStatic) {
         return PEAR::raiseError('Called statically and no input given');
         // Called via an object
     } else {
         $this->_include_bodies = isset($params['include_bodies']) ? $params['include_bodies'] : false;
         $this->_decode_bodies = isset($params['decode_bodies']) ? $params['decode_bodies'] : false;
         $this->_decode_headers = isset($params['decode_headers']) ? $params['decode_headers'] : false;
         $structure = $this->_decode($this->_header, $this->_body);
         if ($structure === false) {
             $structure = $this->raiseError($this->_error);
         }
     }
     return $structure;
 }

 /**
  * 標準入力からメールを読み込み、必要な情報を取得する。
  *
  * @return void
  */
 function parse()
 {
     if (@$this->parsed) {
         return;
     }
     require_once DATA_PATH . '/module/Mail/mimeDecode.php';
     $fp = fopen('php://stdin', 'r');
     // From 行を解析する。
     $from_line = rtrim(fgets($fp));
     if (preg_match('/^From\\s+"?([^\\s"@]+)"?@([^\\s@]+)/', $from_line, $matches)) {
         $this->sender = $matches[1] . '@' . $matches[2];
     } else {
         trigger_error("Invalid from line: {$from_line}");
         $this->sender = null;
     }
     // 残りのヘッダーを解析する。
     $data = '';
     while (!feof($fp)) {
         $data .= fgets($fp);
         if (rtrim($data, "\r\n") == '') {
             break;
         }
     }
     $structure = Mail_mimeDecode::decode(array('input' => $data));
     $this->recipient = @$structure->headers['to'];
     // 宛先アドレスから拡張部分を取得する。
     $pos = strpos($this->recipient, MOBILE_KARA_MAIL_ADDRESS_DELIMITER);
     if ($pos !== false) {
         $extension_and_domain = substr($this->recipient, $pos + 1);
         $pos = strpos($extension_and_domain, '@');
         if ($pos !== false) {
             $this->extension = substr($extension_and_domain, 0, $pos);
         } else {
             $this->extension = $extension_and_domain;
         }
     } else {
         trigger_error("Invalid recipient: {$this->recipient}");
         $this->extension = null;
     }
     $this->parsed = true;
 }

/**
 * This function handles the basic mime decoding
 * @param string
 * @return array
 */
function DecodeMIMEMail($email)
{
    $params = array();
    $params['include_bodies'] = true;
    $params['decode_bodies'] = false;
    $params['decode_headers'] = true;
    $params['input'] = $email;
    $md = new Mail_mimeDecode($email);
    $decoded = $md->decode($params);
    if (empty($decoded->parts)) {
        $decoded->parts = array();
    }
    // have an empty array at minimum, so that it is safe for "foreach"
    return $decoded;
}

 /**
  * Parse the given raw message source and return a structure
  * of rcube_message_part objects.
  *
  * It makes use of the PEAR:Mail_mimeDecode library
  *
  * @param string  The message source
  * @return object rcube_message_part The message structure
  */
 public static function parse_message($raw_body)
 {
     $mime = new Mail_mimeDecode($raw_body);
     $struct = $mime->decode(array('include_bodies' => true, 'decode_bodies' => true));
     return self::structure_part($struct);
 }