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 = '******';
$password = '******';
$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);
}
/**
* Load structure and save every part of message to common array EmbeddedMessage::$structure
*/
private function loadStructure()
{
$this->rawMimeHeader = imap_fetchmime($this->stream, $this->messageNumber, $this->partNumber, FT_UID);
$this->parsedHeader = imap_rfc822_parse_headers($this->getContent());
if (!count((array) $this->parsedHeader)) {
$this->parsedHeader = imap_rfc822_parse_headers($this->rawMimeHeader);
}
//Message ID
$this->id = $this->parsedHeader->message_id;
//Email from
$emailFrom = $this->parsedHeader->from[0];
$emailFrom->personal = isset($emailFrom->personal) ? $emailFrom->personal : null;
$this->from = new EmailAddress($emailFrom->mailbox, $emailFrom->host, imap_utf8($emailFrom->personal));
//EmailsTo
$emailsTo = [];
$parsedEmails = $this->parsedHeader->to;
foreach ($parsedEmails as $email) {
$email->personal = isset($email->personal) ? $email->personal : null;
$emailsTo[] = new EmailAddress($email->mailbox, $email->host, imap_utf8($email->personal));
}
$this->to = $emailsTo;
//EmailsCC
$emailsCc = [];
$parsedEmails = isset($this->parsedHeader->cc) ? $this->parsedHeader->cc : [];
foreach ($parsedEmails as $email) {
$email->personal = isset($email->personal) ? $email->personal : null;
$emailsCc[] = new EmailAddress($email->mailbox, $email->host, imap_utf8($email->personal));
}
$this->cc = $emailsCc;
//Date
$this->date = new \DateTime($this->parsedHeader->date);
//Subject
if (preg_match('/=\\?(.*?)\\?(.*?)\\?/', $this->parsedHeader->subject, $matchSubject)) {
$subjectEncoding = strtolower($matchSubject[1]);
switch ($subjectEncoding) {
case "utf-8":
$this->subject = mb_decode_mimeheader($this->parsedHeader->subject);
break;
default:
$this->subject = quoted_printable_decode(imap_utf8($this->parsedHeader->subject));
break;
}
} else {
$this->subject = imap_utf8($this->parsedHeader->subject);
}
$this->structure = $this->parseStructure();
//extract attachments from common structure
$this->attachments = $this->parseAttachments();
}
/**
*
* Convert $message->subject from any mime encoded to UTF8
* @param EmailMessage $message
*/
public static function resolveSanitizeFromImapToUtf8(EmailMessage $message)
{
$message->subject = imap_utf8($message->subject);
}
}
}
} else {
$email['message'] = trim($email['message']);
if ($email['content_type'] == 'text/html') {
$email['message'] = str_replace("\n", "", $email['message']);
$email['message'] = preg_replace('/<br(.*?)>/i', "\n", $email['message']);
$email['message'] = trim(strip_tags($email['message']));
}
}
// Finally, Sanitize
$email['from'] = $trellis->sanitize_data(imap_utf8($email['from']));
$email['nickname'] = $trellis->sanitize_data(imap_utf8($email['nickname']));
$email['to'] = $trellis->sanitize_data(imap_utf8($email['to']));
$email['subject'] = $trellis->sanitize_data(imap_utf8($email['subject']));
$email['message'] = $trellis->sanitize_data(utf8_encode(decode_ISO88591(imap_utf8($email['message']))));
if (!$email['nickname']) {
$email['nickname'] = $email['from'];
}
if (!$email['from'] || !$email['to'] || !$email['subject'] || !$email['message']) {
exit;
}
if (!$trellis->validate_email($email['from'])) {
exit;
}
#=============================
# Find Department
#=============================
$trellis->core->db->construct(array('select' => 'all', 'from' => 'departments', 'where' => array(array('email_pipe', '=', 1), array('incoming_email', '=', $email['to'], 'and')), 'limit' => array(0, 1)));
$trellis->core->db->execute();
if (!$trellis->core->db->get_num_rows()) {
protected function _init_mail_part($mail, $part_structure, $part_num)
{
$data = $part_num ? imap_fetchbody($this->get_imap_stream(), $mail->id, $part_num, FT_UID) : imap_body($this->get_imap_stream(), $mail->id, FT_UID);
if ($part_structure->encoding == 1) {
$data = imap_utf8($data);
} elseif ($part_structure->encoding == 2) {
$data = imap_binary($data);
} elseif ($part_structure->encoding == 3) {
$data = imap_base64($data);
} elseif ($part_structure->encoding == 4) {
$data = imap_qprint($data);
}
$params = array();
if (!empty($part_structure->parameters)) {
foreach ($part_structure->parameters as $param) {
$params[strtolower($param->attribute)] = $param->value;
}
}
if (!empty($part_structure->dparameters)) {
foreach ($part_structure->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'])) {
// php-imap fix #46
//$data = iconv(strtoupper($params['charset']), $this->imap_server_encoding . '//IGNORE', $data);
$data = mb_convert_encoding($data, $this->imap_server_encoding, $params['charset']);
}
// attachments
$attachment_id = $part_structure->ifid ? trim($part_structure->id, " <>") : (isset($params['filename']) || isset($params['name']) ? mt_rand() . mt_rand() : null);
if ($attachment_id) {
if (empty($params['filename']) && empty($params['name'])) {
$file_name = $attachment_id . '.' . strtolower($part_structure->subtype);
} else {
$file_name = !empty($params['filename']) ? $params['filename'] : $params['name'];
$file_name = $this->decode_mime_str($file_name, $this->imap_server_encoding);
$file_name = $this->decode_rfc2231($file_name, $this->imap_server_encoding);
}
$CI =& get_instance();
$CI->load->library('Incoming_Mail_Attachment');
$mailattachment = new $CI->incoming_mail_attachment();
$mailattachment->id = $attachment_id;
$mailattachment->name = $file_name;
if ($this->imap_attachemnt_dir) {
$replace = array('/\\s/' => '_', '/[^0-9a-zA-Z_\\.]/' => '', '/_+/' => '_', '/(^_)|(_$)/' => '');
$file_sys_name = preg_replace('~[\\\\/]~', '', $mail->id . '_' . $attachment_id . '_' . preg_replace(array_keys($replace), $replace, $file_name));
$mailattachment->uploadfileName = $file_sys_name;
$mailattachment->filePath = $this->imap_attachemnt_dir . DIRECTORY_SEPARATOR . $file_sys_name;
file_put_contents($mailattachment->filePath, $data);
}
$mail->add_attachment($mailattachment);
unset($mailattachment);
} elseif ($part_structure->type == 0 && $data) {
if (strtolower($part_structure->subtype) == 'plain') {
$mail->text_plain .= $data;
} else {
$mail->text_html .= $data;
}
} elseif ($part_structure->type == 2 && $data) {
$mail->text_plain .= trim($data);
}
if (!empty($part_structure->parts)) {
foreach ($part_structure->parts as $sub_part_num => $sub_part_structure) {
if ($part_structure->type == 2 && $part_structure->subtype == 'RFC822') {
$this->_init_mail_part($mail, $sub_part_structure, $part_num);
} else {
$this->_init_mail_part($mail, $sub_part_structure, $part_num . '.' . ($sub_part_num + 1));
}
}
}
}
/**
* ISO Clean
*
* @param string
* @return string
*/
function iso_clean($str)
{
if (stristr($str, '=?') === FALSE) {
return $str;
}
// -------------------------------------------------
// There exists two functions that do this for us
// but they are not available on all servers and some
// seem to work better than others I have found. The
// base64_decode() method works for many encodings
// but I am not sure how well it handles non Latin
// characters.
//
// The mb_decode_mimeheader() function seems to trim
// any line breaks off the end of the str, so we put
// those back because we need it for the Header
// matching stuff. I added it on for the imap_utf8()
// function just in case.
// -------------------------------------------------
if (function_exists('imap_utf8') && strtoupper($this->EE->config->item('charset')) == 'UTF-8') {
return rtrim(imap_utf8($str)) . "\r\n";
}
if (function_exists('mb_decode_mimeheader')) {
// mb_decode_mimeheader() doesn't replace underscores
return str_replace('_', ' ', rtrim(mb_decode_mimeheader($str))) . "\r\n";
}
if (function_exists('iconv_mime_decode')) {
return rtrim(iconv_mime_decode($str)) . "\r\n";
}
if (substr(trim($str), -2) != '?=') {
$str = trim($str) . '?=';
}
if (preg_match("|\\=\\?iso\\-(.*?)\\?[A-Z]{1}\\?(.*?)\\?\\=|i", trim($str), $mime)) {
if ($mime['1'] == '8859-1') {
$charHex = array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
for ($z = 0, $sz = count($charHex); $z < $sz; ++$z) {
for ($i = 0, $si = count($charHex); $i < $si; ++$i) {
$mime['2'] = str_replace('=' . $charHex[$z] . $charHex[$i], chr(hexdec($charHex[$z] . $charHex[$i])), $mime['2']);
}
}
$str = str_replace($mime['0'], $mime['2'], $str);
} else {
$str = str_replace($mime['0'], base64_decode($mime['2']), $str);
}
$str = str_replace('_', ' ', $str);
}
return ltrim($str);
}
public function _imap_utf8($text)
{
if (preg_match('/=\\?([a-zA-z0-9\\-]+)\\?(.*)\\?=/i', $text, $match)) {
$text = imap_utf8($text);
if (strtolower(substr($match[1], 0, 2)) == 'gb') {
$text = iconv('gbk', 'utf-8', $text);
}
return $text;
}
return $this->_iconv_utf8($text);
}
/**
* Get Filename
*
* @return bool|string
*/
public function getFilename()
{
$filename = imap_utf8($this->filename);
if (!$filename && $this->name) {
$filename = imap_utf8($this->name);
}
return $filename;
}
}
@set_time_limit(0);
$rec = Utils_RecordBrowserCommon::get_record('rc_accounts', $_POST['acc_id']);
if ($rec['epesi_user'] !== Acl::get_user()) {
die('invalid account id');
}
$port = $rec['security'] == 'ssl' ? 993 : 143;
$server_str = '{' . $rec['server'] . '/imap/readonly/novalidate-cert' . ($rec['security'] ? '/' . $rec['security'] : '') . ':' . $port . '}';
$mailbox = @imap_open(imap_utf7_encode($server_str), imap_utf7_encode($rec['login']), imap_utf7_encode($rec['password']), OP_READONLY || OP_SILENT);
$err = imap_errors();
if (!$mailbox || $err) {
die(Utils_TooltipCommon::create(__('Connection error'), $err, false));
}
$uns = @imap_search($mailbox, 'UNSEEN ALL');
$unseen = array();
if ($uns) {
$l = @imap_fetch_overview($mailbox, implode(',', $uns), 0);
$err = imap_errors();
if (!$l || $err) {
die('error reading messages overview');
}
foreach ($l as $msg) {
$from = isset($msg->from) ? $msg->from : '<unknown>';
$subject = isset($msg->subject) ? $msg->subject : '<no subject>';
$unseen[] = htmlspecialchars(imap_utf8($from)) . ': <i>' . htmlspecialchars(imap_utf8($subject)) . '</i>';
}
}
print Utils_TooltipCommon::create(count($unseen), implode('<br />', $unseen));
$err = imap_errors();
print_r('<span style="display:none;">' . $err . '</span>');
imap_close($mailbox);
/**
* takes a breadcrumb and returns the encoding at that level
* @param string bc the breadcrumb string in format (1.1.1)
* @param array parts the root level parts array
* @return int retInt Int key to transfer encoding (see handleTranserEncoding())
*/
function getEncodingFromBreadCrumb($bc, $parts)
{
if (strstr($bc, '.')) {
$exBc = explode('.', $bc);
} else {
$exBc[0] = $bc;
}
$depth = count($exBc);
for ($i = 0; $i < $depth; $i++) {
$tempObj[$i] = $parts[$exBc[$i] - 1];
$retInt = imap_utf8($tempObj[$i]->encoding);
if (!empty($tempObj[$i]->parts)) {
$parts = $tempObj[$i]->parts;
}
}
return $retInt;
}
$structure = imap_fetchstructure($inbox, $email_number);
if (isset($structure->parts) && is_array($structure->parts) && isset($structure->parts[1])) {
$part = $structure->parts[1];
if ($part->encoding == 3) {
$message = imap_base64($message);
} else {
if ($part->encoding == 1) {
$message = imap_8bit($message);
} else {
$message = imap_qprint($message);
}
}
}
$output = "<div class='message-text'>";
$output .= "<span><strong>From: </strong>" . imap_utf8($overview->fromaddress) . "</span><br />";
$output .= "<span><strong>Subject: </strong>" . imap_utf8($overview->subject) . "</span><br />";
$output .= "<span><strong>Date: </strong>" . $overview->date . "</span><br />";
$output .= "<span><strong>Message: </strong>" . $message . "</span><br />";
$output .= "</div>";
echo $output;
}
}
?>
</div>
</div>
<script type="text/javascript" src="js/jquery-1.11.3.min.js"></script>
<script type="text/javascript" src="js/jquery.tablesorter.min.js"></script>
<script type="text/javascript" src="js/script.js"></script>
<script type="text/javascript" src="bootstrap/js/bootstrap.min.js"></script>
</body>
</html>
