Exemple #1
4
 /**
  * Method to read email from imap extension and return Zend Mail Message object.
  *
  * This is bridge while migrating to Zend Mail package supporting reading from imap extension functions.
  *
  * @param resource $mbox
  * @param integer $num
  * @param array $info connection information about connection
  * @return ImapMessage
  */
 public static function createFromImap($mbox, $num, $info)
 {
     // check if the current message was already seen
     list($overview) = imap_fetch_overview($mbox, $num);
     $headers = imap_fetchheader($mbox, $num);
     $content = imap_body($mbox, $num);
     // fill with "\Seen", "\Deleted", "\Answered", ... etc
     $knownFlags = array('recent' => Zend\Mail\Storage::FLAG_RECENT, 'flagged' => Zend\Mail\Storage::FLAG_FLAGGED, 'answered' => Zend\Mail\Storage::FLAG_ANSWERED, 'deleted' => Zend\Mail\Storage::FLAG_DELETED, 'seen' => Zend\Mail\Storage::FLAG_SEEN, 'draft' => Zend\Mail\Storage::FLAG_DRAFT);
     $flags = array();
     foreach ($knownFlags as $flag => $value) {
         if ($overview->{$flag}) {
             $flags[] = $value;
         }
     }
     $message = new self(array('root' => true, 'headers' => $headers, 'content' => $content, 'flags' => $flags));
     // set MailDate to $message object, as it's not available in message headers, only in IMAP itself
     // this likely "message received date"
     $imapheaders = imap_headerinfo($mbox, $num);
     $header = new GenericHeader('X-IMAP-UnixDate', $imapheaders->udate);
     $message->getHeaders()->addHeader($header);
     $message->mbox = $mbox;
     $message->num = $num;
     $message->info = $info;
     return $message;
 }
	/**
	 * Recupera o conteúdo de uma mensagem
	 * @param	MailContext $context Contexto da conexão
	 * @param	Message $message
	 * @return	Message A própria mensagem
	 * @throws	MailStateException Caso o estado do objeto não implemente abertura
	 * @throws	MailException Caso não seja possível recuperar o conteúdo da mensagem
	 */
	public function fetch( MailContext $context , Message $message ) {
		$msgNum = imap_msgno( ImapState::$resource , $message->getUID() );

		$structure = imap_fetchstructure( ImapState::$resource , $msgNum );
		$overview = (array) current( imap_fetch_overview( ImapState::$resource , $msgNum ) );

		$message->setHeaders( imap_fetchheader( ImapState::$resource , $msgNum ) );
		$message->setOverview( $overview );

		if ( isset( $structure->parts ) && count( $structure->parts ) ) {
			foreach ( $structure->parts as $key => $part ) {
				$this->fetchContent( $message , $part->subtype , $msgNum , $key + 1 );
			}
		} else {
			$this->fetchContent( $message , $structure->subtype , $msgNum , 1 );
		}
	}
Exemple #3
0
 /**
  * Lista o cabeçalho das 100 primeiras mensagens armazenadas
  *
  * @param string $textSearch
  * @return \ZendT_Mail_Service_HeaderMessage[]
  */
 public function listHeaderMessages($textSearch = 'ALL')
 {
     $itens = array();
     $messages = $this->getMailsInfo($this->searchMailbox($textSearch));
     $limitMessage = 100;
     $iMessage = 0;
     foreach ($messages as $message) {
         if ($iMessage == $limitMessage) {
             break;
         }
         $head = imap_rfc822_parse_headers(imap_fetchheader($this->getImapStream(), $message->uid, FT_UID));
         $item = new ZendT_Mail_HeaderMessage();
         $item->id = $head->message_id;
         $item->dateTime = date('Y-m-d H:i:s', isset($head->date) ? strtotime($head->date) : time());
         $item->subject = $this->decodeMimeStr($head->subject, $this->serverEncoding);
         $item->from = strtolower($head->from[0]->mailbox . '@' . $head->from[0]->host);
         $toStrings = array();
         foreach ($head->to as $to) {
             if (!empty($to->mailbox) && !empty($to->host)) {
                 $toEmail = strtolower($to->mailbox . '@' . $to->host);
                 $toName = isset($to->personal) ? $this->decodeMimeStr($to->personal, $this->serverEncoding) : null;
                 $toStrings[] = $toName ? "{$toName} <{$toEmail}>" : $toEmail;
             }
         }
         $item->to = implode(', ', $toStrings);
         $itens[] = $item;
         $iMessage++;
     }
     return $itens;
 }
function retrieve_message($auth_user, $accountid, $messageid, $fullheaders)
{
    $message = array();
    if (!($auth_user && $messageid && $accountid)) {
        return false;
    }
    $imap = open_mailbox($auth_user, $accountid);
    if (!$imap) {
        return false;
    }
    $header = imap_header($imap, $messageid);
    if (!$header) {
        return false;
    }
    $message['body'] = imap_body($imap, $messageid);
    if (!$message['body']) {
        $message['body'] = "[This message has no body]\n\n\n\n\n\n";
    }
    if ($fullheaders) {
        $message['fullheaders'] = imap_fetchheader($imap, $messageid);
    } else {
        $message['fullheaders'] = '';
    }
    $message['subject'] = $header->subject;
    $message['fromaddress'] = $header->fromaddress;
    $message['toaddress'] = $header->toaddress;
    $message['ccaddress'] = $header->ccaddress;
    $message['date'] = $header->date;
    // note we can get more detailed information by using from and to
    // rather than fromaddress and toaddress, but these are easier
    imap_close($imap);
    return $message;
}
 function get_message($uid)
 {
     $raw_header = imap_fetchheader($this->stream, $uid, FT_UID);
     $raw_body = imap_body($this->stream, $uid, FT_UID);
     $message = new Email_Parser($raw_header . $raw_body);
     return $message;
 }
	function get_message($msg)
	{
		$header = imap_fetchheader($this->_connection, $msg);
		echo "<h1>header {$msg}:</h1><br>".$header;
		$message = imap_body($this->_connection, $msg);
		echo "<h1>message {$msg}:</h1><br>".$message;
		return $header.$message;
	}
 function fetch_raw_mail($stream, $msg_num, $flags = 0)
 {
     $flags |= FT_PREFETCHTEXT;
     // do we force use of msg UID's
     if ($this->force_msg_uids == True && !($flags & FT_UID)) {
         $flags |= FT_UID;
     }
     return imap_fetchheader($stream, $msg_num, $flags);
 }
Exemple #8
0
 /**
  * @param $mailId
  * @return object
  */
 public function getImapHeaderInfo($mailId)
 {
     $imapHeader = imap_fetchheader($this->getImapStream(), $mailId, FT_UID);
     $parsed = array();
     $blocks = preg_split('/\\n\\n/', $imapHeader);
     $matches = array();
     foreach ($blocks as $i => $block) {
         $parsed[$i] = array();
         $lines = preg_split('/\\n(([\\w.-]+)\\: *((.*\\n\\s+.+)+|(.*(?:\\n))|(.*))?)/', $block, -1, PREG_SPLIT_DELIM_CAPTURE);
         foreach ($lines as $line) {
             if (preg_match('/^\\n?([\\w.-]+)\\: *((.*\\n\\s+.+)+|(.*(?:\\n))|(.*))?$/', $line, $matches)) {
                 $parsed[$i][$matches[1]] = preg_replace('/\\n +/', ' ', trim($matches[2]));
             }
         }
     }
     return $parsed;
 }
Exemple #9
0
 /**
  * Cabesera de mensage
  * 
  * @param  int $numMsg 
  * @return array
  */
 public function headerMsg($numMsg, $uid = false)
 {
     //$numMsg es el uid y no el numero de secuencia
     if ($uid) {
         $numMsg = imap_msgno($this->connect, $numMsg);
     }
     $header = explode("\n", imap_fetchheader($this->connect, $numMsg));
     if (is_array($header) && count($header)) {
         $head = array();
         foreach ($header as $line) {
             // separate name and value
             eregi("^([^:]*): (.*)", $line, $arg);
             $head[$arg[1]] = $arg[2];
         }
     }
     return $head;
 }
 static function fetch($options)
 {
     if ($mbox = imap_open(sprintf('{%1$s:%2$s/%3$s}INBOX', $options['server'], $options['port'], implode('/', $options['settings'])), $options['user'], $options['pass'])) {
         $ret = array();
         if (($messages = imap_num_msg($mbox)) > 0) {
             for ($message = 1; $message < $messages + 1; $message++) {
                 $eml = imap_fetchheader($mbox, $message) . imap_body($mbox, $message);
                 $data = array('Task' => array());
                 $email_data = LilTasksParseEmail::__parseEmailHeader($mbox, $message);
                 $data['Task']['title'] = $email_data['subject'];
                 $data['Task']['happened'] = strftime('%Y-%m-%d', strtotime($email_data['date']));
                 list($sender, $domain) = explode('@', $email_data['from']);
                 if ($sender == 'today') {
                     $data['Task']['deadline'] = strftime('%Y-%m-%d');
                 } else {
                     if ($sender == 'tomorrow') {
                         $data['Task']['deadline'] = strftime('%Y-%m-%d', time() + 24 * 60 * 60);
                     } else {
                         if (in_array(strtolower($sender), array('monday', 'tuesday', 'wednesday', 'thursday', 'saturday', 'sunday'))) {
                             $data['Task']['deadline'] = strftime('%Y-%m-%d', strtotime('next ' . ucfirst($sender)));
                         }
                     }
                 }
                 $hash = sha1($data['Task']['happened'] . '_' . $email_data['subject']);
                 $parts = array();
                 $data['Task']['descript'] = LilTasksParseEmail::__parseEmailBody($mbox, $message, $hash, $parts);
                 file_put_contents(TMP . $hash . '.eml', $eml);
                 $data['Attachment'][0] = array('model' => 'Task', 'filename' => array('name' => $hash . '.eml', 'tmp_name' => TMP . $hash . '.eml'), 'title' => 'SOURCE: ' . $data['Task']['title']);
                 App::uses('Sanitize', 'Utility');
                 foreach ($parts as $part) {
                     if (!empty($part['attachment'])) {
                         $data['Attachment'][] = array('model' => 'Task', 'filename' => array('name' => Sanitize::paranoid($part['attachment']['filename']), 'tmp_name' => $part['attachment']['tmp']), 'title' => $part['attachment']['filename']);
                     }
                 }
                 $ret[$message] = $data;
                 imap_delete($mbox, $message);
             }
         }
         return $ret;
         imap_close($mbox, CL_EXPUNGE);
     } else {
         var_dump(imap_errors());
     }
 }
Exemple #11
0
function email_msg_headers($mbox, $uid)
{
    $raw_header = $mbox && $uid ? @imap_fetchheader($mbox, $uid, FT_UID) : '';
    $raw_header = str_replace("\r", '', $raw_header);
    $ret = array();
    $h = split("\n", $raw_header);
    if (count($h)) {
        foreach ($h as $line) {
            if (preg_match("/^[a-zA-Z]/", $line)) {
                $key = substr($line, 0, strpos($line, ':'));
                $value = substr($line, strpos($line, ':') + 1);
                $last_entry = strtolower($key);
                $ret[$last_entry] = trim($value);
            } else {
                $ret[$last_entry] .= ' ' . trim($line);
            }
        }
    }
    return $ret;
}
Exemple #12
0
 function getHeaders($mid)
 {
     if (!$this->marubox) {
         return false;
     }
     $mail_header = @imap_fetchheader($this->marubox, $mid);
     if ($mail_header == false) {
         return false;
     }
     $mail_header = imap_rfc822_parse_headers($mail_header);
     $sender = isset($mail_header->from[0]) ? $mail_header->from[0] : '';
     $sender_replyto = isset($mail_header->reply_to[0]) ? $mail_header->reply_to[0] : '';
     if (strtolower($sender->mailbox) != 'mailer-daemon' && strtolower($sender->mailbox) != 'postmaster') {
         $newvalue['personal'] = $this->email_Decode($sender->personal);
         $newvalue['sender_personal'] = $this->email_Decode($sender_replyto->personal);
         $newvalue['subject'] = $this->email_Decode($mail_header->subject);
         $newvalue['toaddress'] = isset($mail_header->toaddress) ? $this->email_Decode($mail_header->toaddress) : '';
         $mail_header = (array) $mail_header;
         $sender = (array) $sender;
         $mail_details = array('feid' => imap_uid($this->marubox, $mid), 'from' => strtolower($sender['mailbox']) . '@' . $sender['host'], 'from_name' => $newvalue['personal'], 'to_other' => strtolower($sender_replyto->mailbox) . '@' . $sender_replyto->host, 'toname_other' => $newvalue['sender_personal'], 'subjects' => $newvalue['subject'], 'to' => $newvalue['toaddress'], 'time' => strtotime($mail_header['Date']));
     }
     return $mail_details;
 }
Exemple #13
0
function imap_get_url($u)
{
    if (!($c = imap_open_url($u))) {
        return FALSE;
    }
    extract(parse_url($u));
    extract(imap_parse_path($path));
    if ($mailbox) {
        if ($uid) {
            $msgno = imap_msgno($c, $uid);
            $o = imap_fetchstructure($c, $msgno);
        } else {
            $o = array();
            $n = imap_num_msg($c);
            while ($i++ < $n) {
                $o[] = imap_fetchheader($c, $i);
            }
        }
    } else {
        $o = imap_list($c, '{}', '*');
    }
    return $o;
}
Exemple #14
0
 private function parseHeader()
 {
     $header = imap_fetchheader($this->client->connection, $this->uid, FT_UID);
     if ($header) {
         $header = imap_rfc822_parse_headers($header);
     }
     if (property_exists($header, 'subject')) {
         $this->subject = imap_utf8($header->subject);
     }
     if (property_exists($header, 'date')) {
         $this->date = Carbon::parse($header->date);
     }
     if (property_exists($header, 'from')) {
         $this->from = $this->parseAddresses($header->from);
     }
     if (property_exists($header, 'to')) {
         $this->to = $this->parseAddresses($header->to);
     }
     if (property_exists($header, 'cc')) {
         $this->cc = $this->parseAddresses($header->cc);
     }
     if (property_exists($header, 'bcc')) {
         $this->bcc = $this->parseAddresses($header->bcc);
     }
     if (property_exists($header, 'reply_to')) {
         $this->reply_to = $this->parseAddresses($header->reply_to);
     }
     if (property_exists($header, 'sender')) {
         $this->sender = $this->parseAddresses($header->sender);
     }
     if (property_exists($header, 'message_id')) {
         $this->message_id = str_replace(['<', '>'], '', $header->message_id);
     }
     if (property_exists($header, 'Msgno')) {
         $this->message_no = trim($header->Msgno);
     }
 }
Exemple #15
0
 ob_start();
 $mbox = @imap_open($_email['server'], $_email['username'], $_email['password']);
 if (!$mbox) {
     ob_end_clean();
     sleep(10);
     continue;
 }
 $processed = 0;
 $msgs = @imap_search($mbox, 'UNSEEN');
 if ($msgs) {
     foreach ($msgs as $msgid) {
         // Crap out here if we've run out of time
         if (time() >= $endtime) {
             break;
         }
         $imap_headers = @imap_fetchheader($mbox, $msgid);
         if (!$imap_headers) {
             break;
         }
         $headers = array();
         foreach (explode("\n", trim($imap_headers)) as $header) {
             if (strlen(trim($header)) == 0 or $header[0] == ' ' or $header[0] == "\t") {
                 continue;
             }
             list($key, $val) = explode(':', trim($header));
             $key = strtolower($key);
             $val = trim($val);
             switch ($key) {
                 case 'x-twitterrecipientscreenname':
                     if ($val != $_twitter['username']) {
                         // Skip to the next message - this one is not for us!
Exemple #16
0
    <body>
        <?php 
mysql_connect('localhost', 'kamas3_emailsc', 'bingo45');
mysql_select_db('kamas3_emailsc');
$user = '******';
$pass = '******';
$imap_server = "{192.254.214.105:143/imap/notls}INBOX";
// Connect to the pop3 email inbox belonging to $user
// If you need SSL remove the novalidate-cert section
$mbox = imap_open($imap_server, $user, $pass);
$MC = imap_check($mbox);
$sorted_mbox = imap_sort($mbox, SORTDATE, 1);
$totalrows = imap_num_msg($mbox);
$startvalue = 0;
while ($startvalue < $totalrows && $startvalue < 100) {
    $headers = imap_fetchheader($mbox, $sorted_mbox[$startvalue]);
    // echo $headers;
    // echo htmlentities($headers->message_id);
    $subject = array();
    preg_match_all('/^Subject: (.*)/m', $headers, $subject);
    // print $subject[1][0] . "<br />";
    $subject = isset($subject[1][0]) ? $subject[1][0] : (isset($subject[0][0]) ? $subject[0][0] : '');
    if (strpos(strtolower($subject), 'enquiry for you at') !== FALSE) {
        $msg = imap_fetchbody($mbox, $sorted_mbox[$startvalue], 2);
        // echo $msg.'</br>';
        $msg_array = explode('<tr', $msg);
        echo count($msg_array) . " ";
        if (count($msg_array) < 5) {
            $msg_array = explode('<TR', $msg);
            //echo count($msg_array)." ";
        }
 /**
  * get the basic details like sender and reciver with flags like attatchments etc
  *
  * @param int $uid the number of the message
  * @return array empty on error/nothing or array of formatted details
  */
 protected function _getFormattedMail($Model, $uid, $fetchAttachments = false)
 {
     // Translate uid to msg_no. Has no decent fail
     $msg_number = imap_msgno($this->Stream, $uid);
     // A hack to detect if imap_msgno failed, and we're in fact looking at the wrong mail
     if ($uid != ($mailuid = imap_uid($this->Stream, $msg_number))) {
         pr(compact('Mail'));
         return $this->err($Model, 'Mail id mismatch. parameter id: %s vs mail id: %s', $uid, $mailuid);
     }
     // Get Mail with a property: 'date' or fail
     if (!($Mail = imap_headerinfo($this->Stream, $msg_number)) || !property_exists($Mail, 'date')) {
         pr(compact('Mail'));
         return $this->err($Model, 'Unable to find mail date property in Mail corresponding with uid: %s. Something must be wrong', $uid);
     }
     // Get Mail with a property: 'type' or fail
     if (!($flatStructure = $this->_flatStructure($Model, $uid))) {
         return $this->err($Model, 'Unable to find structure type property in Mail corresponding with uid: %s. Something must be wrong', $uid);
     }
     $plain = $this->_fetchFirstByMime($flatStructure, 'text/plain');
     $html = $this->_fetchFirstByMime($flatStructure, 'text/html');
     $return[$Model->alias] = array('id' => $this->_toId($uid), 'message_id' => $Mail->message_id, 'email_number' => $Mail->Msgno, 'to' => $this->_personId($Mail, 'to', 'address'), 'to_name' => $this->_personId($Mail, 'to', 'name'), 'from' => $this->_personId($Mail, 'from', 'address'), 'from_name' => $this->_personId($Mail, 'from', 'name'), 'reply_to' => $this->_personId($Mail, 'reply_to', 'address'), 'reply_to_name' => $this->_personId($Mail, 'reply_to', 'name'), 'sender' => $this->_personId($Mail, 'sender', 'address'), 'sender_name' => $this->_personId($Mail, 'sender', 'name'), 'subject' => htmlspecialchars(@$Mail->subject), 'slug' => Inflector::slug(@$Mail->subject, '-'), 'header' => @imap_fetchheader($this->Stream, $uid, FT_UID), 'body' => $html, 'plainmsg' => $plain ? $plain : $html, 'size' => @$Mail->Size, 'recent' => @$Mail->Recent === 'R' ? 1 : 0, 'seen' => @$Mail->Unseen === 'U' ? 0 : 1, 'flagged' => @$Mail->Flagged === 'F' ? 1 : 0, 'answered' => @$Mail->Answered === 'A' ? 1 : 0, 'draft' => @$Mail->Draft === 'X' ? 1 : 0, 'deleted' => @$Mail->Deleted === 'D' ? 1 : 0, 'thread_count' => $this->_getThreadCount($Mail), 'in_reply_to' => @$Mail->in_reply_to, 'reference' => @$Mail->references, 'new' => (int) @$Mail->in_reply_to, 'created' => date('Y-m-d H:i:s', strtotime($Mail->date)));
     if ($fetchAttachments) {
         $return['Attachment'] = $this->_fetchAttachments($flatStructure, $Model);
     }
     // Auto mark after read
     if (!empty($this->config['auto_mark_as'])) {
         $marks = '\\' . join(' \\', $this->config['auto_mark_as']);
         if (!imap_setflag_full($this->Stream, $uid, $marks, ST_UID)) {
             $this->err($Model, 'Unable to mark email %s as %s', $uid, $marks);
         }
     }
     return $return;
 }
 public function fetchHeader()
 {
     return imap_fetchheader($this->connection, $this->message_id);
 }
Exemple #19
0
 protected function check_mailbox()
 {
     imap_ping($this->conn);
     $count = imap_num_msg($this->conn);
     common_log(LOG_INFO, "Found {$count} messages");
     if ($count > 0) {
         $handler = new IMAPMailHandler();
         for ($i = 1; $i <= $count; $i++) {
             $rawmessage = imap_fetchheader($this->conn, $count, FT_PREFETCHTEXT) . imap_body($this->conn, $i);
             $handler->handle_message($rawmessage);
             imap_delete($this->conn, $i);
         }
         imap_expunge($this->conn);
         common_log(LOG_INFO, "Finished processing messages");
     }
     return $count;
 }
 /**
  * Get mail data
  *
  * @param $mailId
  * @param bool $markAsSeen
  * @return IncomingMail
  */
 public function getMail($mailId, $markAsSeen = true)
 {
     $head = imap_rfc822_parse_headers(imap_fetchheader($this->getImapStream(), $mailId, FT_UID));
     $mail = new IncomingMail();
     $mail->id = $mailId;
     $mail->date = date('Y-m-d H:i:s', isset($head->date) ? strtotime(preg_replace('/\\(.*?\\)/', '', $head->date)) : time());
     $mail->subject = isset($head->subject) ? $this->decodeMimeStr($head->subject, $this->serverEncoding) : null;
     $mail->fromName = isset($head->from[0]->personal) ? $this->decodeMimeStr($head->from[0]->personal, $this->serverEncoding) : null;
     $mail->fromAddress = strtolower($head->from[0]->mailbox . '@' . $head->from[0]->host);
     if (isset($head->to)) {
         $toStrings = array();
         foreach ($head->to as $to) {
             if (!empty($to->mailbox) && !empty($to->host)) {
                 $toEmail = strtolower($to->mailbox . '@' . $to->host);
                 $toName = isset($to->personal) ? $this->decodeMimeStr($to->personal, $this->serverEncoding) : null;
                 $toStrings[] = $toName ? "{$toName} <{$toEmail}>" : $toEmail;
                 $mail->to[$toEmail] = $toName;
             }
         }
         $mail->toString = implode(', ', $toStrings);
     }
     if (isset($head->cc)) {
         foreach ($head->cc as $cc) {
             $mail->cc[strtolower($cc->mailbox . '@' . $cc->host)] = isset($cc->personal) ? $this->decodeMimeStr($cc->personal, $this->serverEncoding) : null;
         }
     }
     if (isset($head->reply_to)) {
         foreach ($head->reply_to as $replyTo) {
             $mail->replyTo[strtolower($replyTo->mailbox . '@' . $replyTo->host)] = isset($replyTo->personal) ? $this->decodeMimeStr($replyTo->personal, $this->serverEncoding) : null;
         }
     }
     if (isset($head->message_id)) {
         $mail->messageId = $head->message_id;
     }
     $mailStructure = imap_fetchstructure($this->getImapStream(), $mailId, FT_UID);
     if (empty($mailStructure->parts)) {
         $this->initMailPart($mail, $mailStructure, 0, $markAsSeen);
     } else {
         foreach ($mailStructure->parts as $partNum => $partStructure) {
             $this->initMailPart($mail, $partStructure, $partNum + 1, $markAsSeen);
         }
     }
     return $mail;
 }
Exemple #21
0
 public function getMessage($message)
 {
     return imap_fetchheader($this->conn, $message, FT_PREFETCHTEXT);
 }
 function getHeader($mid)
 {
     return imap_fetchheader($this->mbox, $mid, FT_PREFETCHTEXT);
 }
Exemple #23
0
 $imap = imap_open($mailboxRoot . $boxName, $mailUsername, $mailPassword) or die("Can't open {$boxName} box! " . imap_last_error());
 $added = 0;
 $num_msg = imap_num_msg($imap);
 //if ($num_msg > 40) $num_msg = 40;
 // go through each message
 for ($i = 1; $i <= $num_msg; $i++) {
     $thisUID = imap_uid($imap, $i);
     $result = mysql_query("SELECT * FROM winamp_emails WHERE uid = '{$thisUID}'");
     if (mysql_num_rows($result) == 0) {
         $header = imap_headerinfo($imap, $i);
         $thisTo = addslashes($header->toaddress);
         $thisCC = addslashes($header->ccaddress);
         $thisFrom = addslashes($header->fromaddress);
         $thisSubject = addslashes($header->subject);
         $thisDate = strtotime($header->date);
         $thisHeader = addslashes(imap_fetchheader($imap, $i));
         mysql_query("INSERT INTO winamp_emails (uid, mailbox, fromaddress, toaddress, ccaddress, subject, date, headers) \n\t\t\t\t\t\t\t\t\t\t\tVALUES ('{$thisUID}', '{$boxName}', '{$thisFrom}', '{$thisTo}', '{$thisCC}', '{$thisSubject}', FROM_UNIXTIME({$thisDate}), '{$thisHeader}')");
         if (mysql_error()) {
             die(mysql_error());
         }
         $email_id = mysql_insert_id();
         $added++;
         $total_added++;
         //$thisBody = imap_body($imap, $i, FT_PEEK);
         $thisStructure = imap_fetchstructure($imap, $i);
         $thisType = $thisStructure->type;
         $thisSubType = $thisStructure->subtype;
         insertBodyPart($imap, $i, $thisStructure, $email_id);
     }
 }
 $netTime = time() - $startTime;
Exemple #24
0
 /**
  * This function returns an object containing the headers of the message. This is done by taking the raw headers
  * and running them through the imap_rfc822_parse_headers function. The results are only retrieved from the server
  * once unless passed true as a parameter.
  *
  * @param  bool     $forceReload
  * @return stdClass
  */
 public function getHeaders($forceReload = false)
 {
     if ($forceReload || !isset($this->headers)) {
         // raw headers (since imap_headerinfo doesn't use the unique id)
         $rawHeaders = imap_fetchheader($this->imapStream, $this->uid, FT_UID);
         // convert raw header string into a usable object
         $headerObject = imap_rfc822_parse_headers($rawHeaders);
         // to keep this object as close as possible to the original header object we add the udate property
         $headerObject->udate = strtotime($headerObject->date);
         $this->headers = $headerObject;
     }
     return $this->headers;
 }
Exemple #25
0
 function run()
 {
     $logger = DevblocksPlatform::getConsoleLog();
     $logger->info("[POP3] Starting POP3 Task");
     if (!extension_loaded("imap")) {
         die("IMAP Extension not loaded!");
     }
     @set_time_limit(0);
     // Unlimited (if possible)
     @ini_set('memory_limit', '64M');
     $accounts = DAO_Mail::getPop3Accounts();
     /* @var $accounts CerberusPop3Account[] */
     $timeout = ini_get('max_execution_time');
     // Allow runtime overloads (by host, etc.)
     @($gpc_pop3_max = DevblocksPlatform::importGPC($_REQUEST['pop3_max'], 'integer'));
     $max_downloads = !empty($gpc_pop3_max) ? $gpc_pop3_max : $this->getParam('max_messages', $timeout ? 20 : 50);
     // [JAS]: Make sure our output directory is writeable
     if (!is_writable(APP_MAIL_PATH . 'new' . DIRECTORY_SEPARATOR)) {
         $logger->err("[POP3] The mail storage directory is not writeable.  Skipping POP3 download.");
         return;
     }
     foreach ($accounts as $account) {
         /* @var $account CerberusPop3Account */
         if (!$account->enabled) {
             continue;
         }
         $logger->info('[POP3] Account being parsed is ' . $account->nickname);
         switch ($account->protocol) {
             default:
             case 'pop3':
                 // 110
                 $connect = sprintf("{%s:%d/pop3/notls}INBOX", $account->host, $account->port);
                 break;
             case 'pop3-ssl':
                 // 995
                 $connect = sprintf("{%s:%d/pop3/ssl/novalidate-cert}INBOX", $account->host, $account->port);
                 break;
             case 'imap':
                 // 143
                 $connect = sprintf("{%s:%d/notls}INBOX", $account->host, $account->port);
                 break;
             case 'imap-ssl':
                 // 993
                 $connect = sprintf("{%s:%d/imap/ssl/novalidate-cert}INBOX", $account->host, $account->port);
                 break;
         }
         $runtime = microtime(true);
         if (false === ($mailbox = @imap_open($connect, !empty($account->username) ? $account->username : "", !empty($account->password) ? $account->password : ""))) {
             $logger->err("[POP3] Failed with error: " . imap_last_error());
             continue;
         }
         $messages = array();
         $check = imap_check($mailbox);
         // [TODO] Make this an account setting?
         $total = min($max_downloads, $check->Nmsgs);
         $logger->info('[POP3] Init time: ' . (microtime(true) - $runtime) * 1000, " ms");
         $runtime = microtime(true);
         for ($i = 1; $i <= $total; $i++) {
             /*
              * [TODO] Logic for max message size (>1MB, etc.) handling.  If over a
              * threshold then use the attachment parser (imap_fetchstructure) to toss
              * non-plaintext until the message fits.
              */
             $msgno = $i;
             $time = microtime(true);
             $headers = imap_fetchheader($mailbox, $msgno);
             $body = imap_body($mailbox, $msgno);
             do {
                 $unique = sprintf("%s.%04d", time(), mt_rand(0, 9999));
                 $filename = APP_MAIL_PATH . 'new' . DIRECTORY_SEPARATOR . $unique;
             } while (file_exists($filename));
             $fp = fopen($filename, 'w');
             if ($fp) {
                 fwrite($fp, $headers, strlen($headers));
                 fwrite($fp, "\r\n\r\n");
                 fwrite($fp, $body, strlen($body));
                 @fclose($fp);
             }
             /*
              * [JAS]: We don't add the .msg extension until we're done with the file,
              * since this will safely be ignored by the parser until we're ready
              * for it.
              */
             rename($filename, dirname($filename) . DIRECTORY_SEPARATOR . basename($filename) . '.msg');
             unset($headers);
             unset($body);
             $time = microtime(true) - $time;
             $logger->info("[POP3] Downloaded message " . $msgno . " (" . sprintf("%d", $time * 1000) . " ms)");
             imap_delete($mailbox, $msgno);
             continue;
         }
         imap_expunge($mailbox);
         imap_close($mailbox);
         imap_errors();
         $logger->info("[POP3] Total Runtime: " . (microtime(true) - $runtime) * 1000 . " ms");
     }
 }
 /**
  * @param $mid
  **/
 function getAdditionnalHeaders($mid)
 {
     $head = array();
     $header = explode("\n", imap_fetchheader($this->marubox, $mid));
     if (is_array($header) && count($header)) {
         foreach ($header as $line) {
             // is line with additional header?
             if (preg_match("/^X-/i", $line) || preg_match("/^Auto-Submitted/i", $line) || preg_match("/^Received/i", $line)) {
                 // separate name and value
                 if (preg_match("/^([^:]*): (.*)/i", $line, $arg)) {
                     $key = Toolbox::strtolower($arg[1]);
                     if (!isset($head[$key])) {
                         $head[$key] = '';
                     } else {
                         $head[$key] .= "\n";
                     }
                     $head[$key] .= trim($arg[2]);
                 }
             }
         }
     }
     return $head;
 }
 public static function get_mail_detail($mbox, $id, $msgno = false)
 {
     $return = array();
     if (!$msgno) {
         $msgno = imap_msgno($mbox, $id);
     }
     if (!$id) {
         $id = imap_uid($mbox, $msgno);
     }
     if (!$msgno) {
         return false;
     }
     $header = imap_header($mbox, $msgno);
     $structure = self::_get_body_attach($mbox, $id, $msgno);
     $return['id'] = $id;
     $return['Msgno'] = $header->Msgno;
     $return['message_id'] = $header->message_id;
     $return['toaddress'] = self::get_only_email($header->to);
     $return['fromaddress'] = self::get_only_email($header->from);
     $return['reply_toaddress'] = self::get_only_email($header->reply_to);
     $return['ccaddress'] = self::get_only_email($header->cc);
     $return['bccaddress'] = self::get_only_email($header->bcc);
     $return['senderaddress'] = self::get_only_email($header->sender);
     $return['subject'] = self::_decode_text($header->subject);
     $return['MailDate'] = $header->MailDate;
     $return['date'] = $header->date;
     $return['udate'] = $header->udate;
     $return['udate_formated'] = date("Y-m-d H:i:s", $header->udate);
     $return['Recent'] = $header->Recent;
     $return['Unseen'] = $header->Unseen;
     $return['Flagged'] = $header->Flagged;
     $return['Answered'] = $header->Answered;
     $return['Deleted'] = $header->Deleted;
     $return['Draft'] = $header->Draft;
     $return['Size'] = $header->Size;
     $return['body'] = $structure['body'];
     $return['attachments'] = $structure['attachment'];
     $return['clean'] = '';
     $msgs = imap_fetch_overview($mbox, $msgno);
     foreach ($msgs as $msg) {
         $return['clean'] .= imap_fetchheader($mbox, $msg->msgno);
     }
     return $return;
 }
Exemple #28
0
 /** Parse messages sitting in mailbox */
 function parse_messages()
 {
     if ($this->num_msgs > 0) {
         for ($x = 1; $x < $this->num_msgs + 1; $x++) {
             # Retrieve raw mail body
             $rawdata = imap_fetchheader($this->conn, $x) . imap_body($this->conn, $x);
             # Retrieve mail structure
             $struct = imap_fetchstructure($this->conn, $x);
             # Retrieve mail headers
             $headers = imap_headerinfo($this->conn, $x);
             # Build array of addresses mail was sent to
             $to = array();
             foreach ($headers->to as $item) {
                 array_push($to, $item->mailbox . "@" . $item->host);
             }
             # Get the address message is from
             $from = $headers->from[0]->mailbox . "@" . $headers->from[0]->host;
             # FIXME - attachment handling:
             # Use of dparameters seems to be wrong - the correct key is 'filename' I guess.
             # More info http://php.net/manual/en/function.imap-fetchstructure.php
             # Anyway, I have removed the attachment code since it doesn't work AND
             # the code in the parser script already handle the attachments.
             # Check if this is a multipart message. (can not use type since
             # it is 0 for text (.txt) attachments.)
             // if ($struct->type == 1) {
             if ($struct->parts) {
                 foreach ($struct->parts as $key => $part) {
                     // Skipping HTML
                     if ($part->ifsubtype == 1 and $part->subtype == "HTML") {
                         continue;
                     }
                     // Ignoring all attachements
                     if (strtolower($part->disposition) != "attachment") {
                         # Retrieve mail body
                         $body = imap_fetchbody($this->conn, $x, $key + 1);
                         # Check for base64 or quoted printable encoding
                         if ($part->encoding == 3) {
                             $body = imap_base64($body);
                         } else {
                             if ($part->encoding == 4) {
                                 $body = imap_qprint($body);
                             }
                         }
                     }
                 }
             } else {
                 # Retrieve mail body (for this single part message).
                 $body = imap_body($this->conn, $x);
                 # Check for base64 or quoted printable encoding
                 if ($struct->encoding == 3) {
                     $body = imap_base64($body);
                 } else {
                     if ($struct->encoding == 4) {
                         $body = imap_qprint($body);
                     }
                 }
             }
             # Add message to array
             $this->messages[] = array('msgno' => $x, 'from' => $from, 'to' => $to, 'message_id' => $headers->message_id, 'subject' => $headers->subject, 'body' => $body, 'rawdata' => $rawdata);
         }
     }
 }
Exemple #29
-12
 /**
  * Gets the raw email message from the server
  * @return string
  */
 function fetchEmail($index)
 {
     $header_info = imap_headerinfo($this->_connection, $index);
     if (IsDebugMode() || $header_info->Recent == 'N' || $header_info->Unseen == 'U') {
         $email = imap_fetchheader($this->_connection, $index);
         $email .= imap_body($this->_connection, $index);
         return $email;
     } else {
         return 'already read';
     }
 }
 /**
  * shiny new importOneEmail() method
  * @param int msgNo
  * @param bool forDisplay
  * @param clean_email boolean, default true,
  */
 function importOneEmail($msgNo, $uid, $forDisplay = false, $clean_email = true)
 {
     $GLOBALS['log']->debug("InboundEmail processing 1 email {$msgNo}-----------------------------------------------------------------------------------------");
     global $timedate;
     global $app_strings;
     global $app_list_strings;
     global $sugar_config;
     global $current_user;
     // Bug # 45477
     // So, on older versions of PHP (PHP VERSION < 5.3),
     // calling imap_headerinfo and imap_fetchheader can cause a buffer overflow for exteremly large headers,
     // This leads to the remaining messages not being read because Sugar crashes everytime it tries to read the headers.
     // The workaround is to mark a message as read before making trying to read the header of the msg in question
     // This forces this message not be read again, and we can continue processing remaining msgs.
     // UNCOMMENT THIS IF YOU HAVE THIS PROBLEM!  See notes on Bug # 45477
     // $this->markEmails($uid, "read");
     $header = imap_headerinfo($this->conn, $msgNo);
     $fullHeader = imap_fetchheader($this->conn, $msgNo);
     // raw headers
     // reset inline images cache
     $this->inlineImages = array();
     // handle messages deleted on server
     if (empty($header)) {
         if (!isset($this->email) || empty($this->email)) {
             $this->email = new Email();
         }
         $q = "";
         if ($this->isPop3Protocol()) {
             $this->email->name = $app_strings['LBL_EMAIL_ERROR_MESSAGE_DELETED'];
             $q = "DELETE FROM email_cache WHERE message_id = '{$uid}' AND ie_id = '{$this->id}' AND mbox = '{$this->mailbox}'";
         } else {
             $this->email->name = $app_strings['LBL_EMAIL_ERROR_IMAP_MESSAGE_DELETED'];
             $q = "DELETE FROM email_cache WHERE imap_uid = {$uid} AND ie_id = '{$this->id}' AND mbox = '{$this->mailbox}'";
         }
         // else
         // delete local cache
         $r = $this->db->query($q);
         $this->email->date_sent = $timedate->nowDb();
         return false;
         //return "Message deleted from server.";
     }
     ///////////////////////////////////////////////////////////////////////
     ////	DUPLICATE CHECK
     $dupeCheckResult = $this->importDupeCheck($header->message_id, $header, $fullHeader);
     if ($forDisplay || $dupeCheckResult) {
         $GLOBALS['log']->debug('*********** NO duplicate found, continuing with processing.');
         $structure = imap_fetchstructure($this->conn, $msgNo);
         // map of email
         ///////////////////////////////////////////////////////////////////
         ////	CREATE SEED EMAIL OBJECT
         $email = new Email();
         $email->isDuplicate = $dupeCheckResult ? false : true;
         $email->mailbox_id = $this->id;
         $message = array();
         $email->id = create_guid();
         $email->new_with_id = true;
         //forcing a GUID here to prevent double saves.
         ////	END CREATE SEED EMAIL
         ///////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////
         ////	PREP SYSTEM USER
         if (empty($current_user)) {
             // I-E runs as admin, get admin prefs
             $current_user = new User();
             $current_user->getSystemUser();
         }
         $tPref = $current_user->getUserDateTimePreferences();
         ////	END USER PREP
         ///////////////////////////////////////////////////////////////////
         if (!empty($header->date)) {
             $unixHeaderDate = $timedate->fromString($header->date);
         }
         ///////////////////////////////////////////////////////////////////
         ////	HANDLE EMAIL ATTACHEMENTS OR HTML TEXT
         ////	Inline images require that I-E handle attachments before body text
         // parts defines attachments - be mindful of .html being interpreted as an attachment
         if ($structure->type == 1 && !empty($structure->parts)) {
             $GLOBALS['log']->debug('InboundEmail found multipart email - saving attachments if found.');
             $this->saveAttachments($msgNo, $structure->parts, $email->id, 0, $forDisplay);
         } elseif ($structure->type == 0) {
             $uuemail = $this->isUuencode($email->description) ? true : false;
             /*
              * UUEncoded attachments - legacy, but still have to deal with it
              * format:
              * begin 777 filename.txt
              * UUENCODE
              *
              * end
              */
             // set body to the filtered one
             if ($uuemail) {
                 $email->description = $this->handleUUEncodedEmailBody($email->description, $email->id);
                 $email->retrieve($email->id);
                 $email->save();
             }
         } else {
             if ($this->port != 110) {
                 $GLOBALS['log']->debug('InboundEmail found a multi-part email (id:' . $msgNo . ') with no child parts to parse.');
             }
         }
         ////	END HANDLE EMAIL ATTACHEMENTS OR HTML TEXT
         ///////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////
         ////	ASSIGN APPROPRIATE ATTRIBUTES TO NEW EMAIL OBJECT
         // handle UTF-8/charset encoding in the ***headers***
         global $db;
         $email->name = $this->handleMimeHeaderDecode($header->subject);
         $email->date_start = !empty($unixHeaderDate) ? $timedate->asUserDate($unixHeaderDate) : "";
         $email->time_start = !empty($unixHeaderDate) ? $timedate->asUserTime($unixHeaderDate) : "";
         $email->type = 'inbound';
         $email->date_created = !empty($unixHeaderDate) ? $timedate->asUser($unixHeaderDate) : "";
         $email->status = 'unread';
         // this is used in Contacts' Emails SubPanel
         if (!empty($header->toaddress)) {
             $email->to_name = $this->handleMimeHeaderDecode($header->toaddress);
             $email->to_addrs_names = $email->to_name;
         }
         if (!empty($header->to)) {
             $email->to_addrs = $this->convertImapToSugarEmailAddress($header->to);
         }
         $email->from_name = $this->handleMimeHeaderDecode($header->fromaddress);
         $email->from_addr_name = $email->from_name;
         $email->from_addr = $this->convertImapToSugarEmailAddress($header->from);
         if (!empty($header->cc)) {
             $email->cc_addrs = $this->convertImapToSugarEmailAddress($header->cc);
         }
         if (!empty($header->ccaddress)) {
             $email->cc_addrs_names = $this->handleMimeHeaderDecode($header->ccaddress);
         }
         // if
         $email->reply_to_name = $this->handleMimeHeaderDecode($header->reply_toaddress);
         $email->reply_to_email = $this->convertImapToSugarEmailAddress($header->reply_to);
         if (!empty($email->reply_to_email)) {
             $email->reply_to_addr = $email->reply_to_name;
         }
         $email->intent = $this->mailbox_type;
         $email->message_id = $this->compoundMessageId;
         // filled by importDupeCheck();
         $oldPrefix = $this->imagePrefix;
         if (!$forDisplay) {
             // Store CIDs in imported messages, convert on display
             $this->imagePrefix = "cid:";
         }
         // handle multi-part email bodies
         $email->description_html = $this->getMessageText($msgNo, 'HTML', $structure, $fullHeader, $clean_email);
         // runs through handleTranserEncoding() already
         $email->description = $this->getMessageText($msgNo, 'PLAIN', $structure, $fullHeader, $clean_email);
         // runs through handleTranserEncoding() already
         $this->imagePrefix = $oldPrefix;
         // empty() check for body content
         if (empty($email->description)) {
             $GLOBALS['log']->debug('InboundEmail Message (id:' . $email->message_id . ') has no body');
         }
         // assign_to group
         if (!empty($_REQUEST['user_id'])) {
             $email->assigned_user_id = $_REQUEST['user_id'];
         } else {
             // Samir Gandhi : Commented out this code as its not needed
             //$email->assigned_user_id = $this->group_id;
         }
         //Assign Parent Values if set
         if (!empty($_REQUEST['parent_id']) && !empty($_REQUEST['parent_type'])) {
             $email->parent_id = $_REQUEST['parent_id'];
             $email->parent_type = $_REQUEST['parent_type'];
             $mod = strtolower($email->parent_type);
             $rel = array_key_exists($mod, $email->field_defs) ? $mod : $mod . "_activities_emails";
             //Custom modules rel name
             if (!$email->load_relationship($rel)) {
                 return FALSE;
             }
             $email->{$rel}->add($email->parent_id);
         }
         // override $forDisplay w/user pref
         if ($forDisplay) {
             if ($this->isAutoImport()) {
                 $forDisplay = false;
                 // triggers save of imported email
             }
         }
         if (!$forDisplay) {
             $email->save();
             $email->new_with_id = false;
             // to allow future saves by UPDATE, instead of INSERT
             ////	ASSIGN APPROPRIATE ATTRIBUTES TO NEW EMAIL OBJECT
             ///////////////////////////////////////////////////////////////////
             ///////////////////////////////////////////////////////////////////
             ////	LINK APPROPRIATE BEANS TO NEWLY SAVED EMAIL
             //$contactAddr = $this->handleLinking($email);
             ////	END LINK APPROPRIATE BEANS TO NEWLY SAVED EMAIL
             ///////////////////////////////////////////////////////////////////
             ///////////////////////////////////////////////////////////////////
             ////	MAILBOX TYPE HANDLING
             $this->handleMailboxType($email, $header);
             ////	END MAILBOX TYPE HANDLING
             ///////////////////////////////////////////////////////////////////
             ///////////////////////////////////////////////////////////////////
             ////	SEND AUTORESPONSE
             if (!empty($email->reply_to_email)) {
                 $contactAddr = $email->reply_to_email;
             } else {
                 $contactAddr = $email->from_addr;
             }
             if (!$this->isMailBoxTypeCreateCase()) {
                 $this->handleAutoresponse($email, $contactAddr);
             }
             ////	END SEND AUTORESPONSE
             ///////////////////////////////////////////////////////////////////
             ////	END IMPORT ONE EMAIL
             ///////////////////////////////////////////////////////////////////
         }
     } else {
         // only log if not POP3; pop3 iterates through ALL mail
         if ($this->protocol != 'pop3') {
             $GLOBALS['log']->info("InboundEmail found a duplicate email: " . $header->message_id);
             //echo "This email has already been imported";
         }
         return false;
     }
     ////	END DUPLICATE CHECK
     ///////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////
     ////	DEAL WITH THE MAILBOX
     if (!$forDisplay) {
         imap_setflag_full($this->conn, $msgNo, '\\SEEN');
         // if delete_seen, mark msg as deleted
         if ($this->delete_seen == 1 && !$forDisplay) {
             $GLOBALS['log']->info("INBOUNDEMAIL: delete_seen == 1 - deleting email");
             imap_setflag_full($this->conn, $msgNo, '\\DELETED');
         }
     } else {
         // for display - don't touch server files?
         //imap_setflag_full($this->conn, $msgNo, '\\UNSEEN');
     }
     $GLOBALS['log']->debug('********************************* InboundEmail finished import of 1 email: ' . $email->name);
     ////	END DEAL WITH THE MAILBOX
     ///////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////
     ////	TO SUPPORT EMAIL 2.0
     $this->email = $email;
     if (empty($this->email->et)) {
         $this->email->email2init();
     }
     return true;
 }