Es gibt dutzende gute Mail-Klassen und Libraries da draußen (ezcMail, htmlMimeMail5), ich benutze häufig Zend_Mail. Mit den verschiedenen Zend_Mail_Transport_* Klassen ist es möglich, die Mails über sendmail (sprich über mail()) zu versenden, oder aber beispielsweise mit Hilfe des SMTP-Protokolls an einen SMTP-Server zu übergeben. Seit wenigen Monaten neu ist Zend_Mail_Transport_File, womit die E-Mail nicht versendet wird, sondern “nur” in eine Datei geschrieben wird. Ich habe mir früher einen solchen Adapter selbst geschrieben, nun ist er im Zend Framework enthalten.

Mit diesem Adapter ist es sehr einfach möglich, beispielsweise in der Entwicklungsumgebung keine E-Mails zu versenden, damit nicht aus Versehen beim Testen des Abschickens eines Formulars wirkliche E-Mails versendet werden, sondern nur zu Debuggingzwecken in eine Datei geschrieben wird. Beispielsweise so:

[production]
;    Config we use for production:
resources.mail.transport.type = smtp
resources.mail.transport.host = "smtp.example.com"
resources.mail.transport.auth = login
resources.mail.transport.username = myUsername
resources.mail.transport.password = myPassword

[development]
;    This options for the dev env:
resources.mail.transport.type = file
resources.mail.transport.path = "/tmp/send" 

Mit dem Adapter ist es auch möglich, den Mail-Versand zu testen mittels Unit-Tests, der Inhalt der Datei kann dann einfach gegen die erwartete Ausgabe geprüft werden.

In meinem eigenen Repertoire habe ich noch einen Adapter, mit dem man dieses Schreiben in eine Datei umgehen kann und den generierten E-Mail Quelltext direkt abfragen kann. Auch dieser Adapter kann natürlich gut zu Testzwecken genutzt werden, und man benötigt keinen Speicherplatz/Schreibrechte:

<?
class App_Mail_Transport_Null extends Zend_Mail_Transport_Smtp {
    /**
     * DON'T send an email via the SMTP connection protocol
     *
     * @return void
     */
    public function _sendMail()
    {
    }

    public function getSmtpMailSource()
    {
        if (empty($this->header)) {
            throw new Exception('Mail source could not be returned, you have to call send() first!');
        }

        return $this->header . Zend_Mime::LINEEND . $this->body;
    }
}

$transport = new App_Mail_Transport_Null();
$mail->send($transport);
$messageString = $transport->getSmtpMailSource();

Das Senden von vielen E-Mails wird kompliziert wenn man möglichst schnell möglichst viele E-Mails versenden möchte. Eine der schnellsten Methoden ist es, die generierte E-Mail in eine Datei zu schreiben und dann in das Pick-Up Verzeichnis des Postfix zu schieben. Dazu kann der oben gezeigte File-Adapter genutzt werden. Falls dieser Weg zu umständlich ist (oder kein Zugriff auf dieses Verzeichnis möglich ist), bleibt nur der Versand über SMTP. Aber auch da gibt es einige feine Unterschiede. Normalerweise wird für jede E-Mail eine eigene TCP/IP Verbindung geöffnet und dann für jede E-Mail ein SMTP-Dialog abgespult. Doch es geht auch effizienter, indem man eine Verbindung wiederbenutzt. Hier erstmal das normale Vorgehen:

$tr = new Zend_Mail_Transport_Smtp("mail.example.com")
Zend_Mail::setDefaultTransport($tr);

for ($i = 0; $i < 5; $i++) {
    $mail = new Zend_Mail();
    $mail->setBodyText("This is the text of the mail. $i");
    $mail->setFrom("sender@example.com", "Some Sender $i")
    $mail->addTo("recipient@example.com", "Some Recipient $i");
    $mail->setSubject("Test Subject $i");
    $mail->send();
}

Besser ist es jedoch so:

$tr = new Zend_Mail_Transport_Smtp("mail.example.com");
Zend_Mail::setDefaultTransport($tr);

$mail = new Zend_Mail();
for ($i = 0; $i < 5; $i++) {
    $mail->setBodyText("This is the text of the mail $i.");
    $mail->setFrom("sender@example.com", "Some Sender $i");
    $mail->addTo("recipient@example.com", "Some Recipient $i");
    $mail->setSubject("Test Subject $i");
    $mail->send();
}

Im zweiten Fall bleibt die Verbindung bestehen, und es wird im SMTP-Dialog einfach ein RSET gesendet und dann die nächste E-Mail verschickt.

Bei dieser Methode gilt jedoch zu beachten dass viele SMTP-Server die Anzahl der E-Mails, die innerhalb eines SMTP-Dialogs versendet werden dürfen, beschränken.

Ähnliche Artikel:

1. Inline Grafiken in HTML E-Mails mit Zend_Mail automatisch versenden
2. Linkpool Nummer 6

Der Code unten zeigt ein komplettes lauffähiges Beispiel. Nach der Konfiguration wird auch gleich ein Zend_Mail Objekt erstellt und der HTML Bereich mit Inhalten bestückt. Über preg_match_all und array_filter werden alle Fundstellen in IMG Tags, im BACKGROUND Attribut sowie im Inline-CSS gefunden. Das Array mit den Ergebnissen wird dann durchlaufen. Abhängig davon, ob es sich um Grafiken auf dem Server oder externe Grafiken handelt, wird dann das entsprechende Attachment erstellt.

Zusätzlich muss im HTML Bereich der E-Mail auch jeweils der alte Verweis auf die Grafik durch den Verweis auf das Attachment ausgetauscht werden. Wichtig ist noch, dass der Typ der E-Mail auf Zend_Mime::MULTIPART_RELATED gesetzt wird. Danach kann der Versand erfolgen.

Ich hoffe, dieses Skript hilft dem einen oder anderen weiter.

<?php
set_include_path(implode(PATH_SEPARATOR, array(
	realpath(dirname(__FILE__) . '/library'),
	get_include_path(),
)));

date_default_timezone_set('Europe/Berlin');

require_once('Zend/Loader/Autoloader.php');
$autoloader = Zend_Loader_Autoloader::getInstance();

$mailSender = 'absender@domain.de';
$nameSender = 'Absender';
$mailRecipient = 'empfaenger@domain.de';
$nameRecipient = 'Empfaenger';
$mailSubject = 'Testmail mit inline img';
$htmlBody = '<b>html</b><br/><img src="sexy-sprite.png"><br/>
			<table background="error_messages.png"><tr><td>Zelle</td></tr></table>
			<br/><img src="http://www.fremdedomain.de/bild2.jpg">';
$textBody = 'text here';

// build mail
$mail = new Zend_Mail('UTF-8');
$mail->setFrom($mailSender, $nameSender);
$mail->addTo($mailRecipient, $nameRecipient);
$mail->setSubject($mailSubject);

// find images
preg_match_all('^url\((.*)\)|src="(.*)"|background="(.*)"^iU', $htmlBody, $imageList);

// combine findings
$imageList = array_filter(array_merge($imageList[1], $imageList[2], $imageList[3]));

// check image list
if (count($imageList) > 0) {
	// loop through image list
	foreach ($imageList as $key => $value) {
		if (substr($value, 0, 4) == 'http') {
			$filePath = 'img/' . basename($value);
			file_put_contents($filePath, file_get_contents($value));
		} else {
			$filePath = 'img/' . $value;
		}
		$fileName = basename($filePath);
		$fileType = getimagesize($filePath);

		// create attachment
		$att = $mail->createAttachment(file_get_contents($filePath));
		$att->type = $fileType['mime'];
		$att->disposition = Zend_Mime::DISPOSITION_INLINE;
		$att->encoding = Zend_Mime::ENCODING_BASE64;
		$att->filename = $fileName;
		$att->id = md5($att->filename);

		// change body
		$htmlBody = str_replace($imageList[$key], 'cid:'.$att->id, $htmlBody);
	}
}

$mail->setType(Zend_Mime::MULTIPART_RELATED);
$mail->setBodyText($textBody);
$mail->setBodyHtml($htmlBody);

$config = array('auth' 	=> 'login',
	'username' 	=> 'absender@domain.de',
	'password' 	=> 'SMTPPASSWORD');
$mail->send(new Zend_Mail_Transport_Smtp('mail.domain.de', $config));

Ähnliche Artikel:

1. Kein Hexenwerk: SMS/MMS mit PHP versenden

In der Vergangenheit habe ich bereits einige Scripte geschrieben die Emails periodisch abholen und bearbeiten. Darunter waren zum Beispiel Backup-Benachrichtigungen von einem Programm das früher nicht in der Lage war, die Ergebnisse in eine Datenbank zu schreiben. Um eine Übersicht über einen Zeitraum zu erhalten muß man die Ergebnisse also per Email in ein Postfach senden lassen und dieses periodisch abrufen und die Emails parsen.

Ein anderes Script hat zum Beispiel ein Postfach nach Anhängen durchsucht. Dieses Postfach wurde dazu benutzt, Dokumente automatisiert verarbeiten zu lassen. Dazu wurden die Emails geparst, die Anhänge gelöst und dann je nach Absender an einen bestimmten Sachbearbeiter gesendet oder an ein automatisiertes System weitergeleitet bzw. auf ein Netzwerklaufwerk abgelegt.

Es gibt noch viele weitere Möglichkeiten, wofür Emails nützlich sein können und warum man sie automatisiert verarbeiten sollte.

Früher habe ich diese Arbeit mit den imap_* Funktionen erledigt. Heutzutage nutze ich dafür natürlich die Zend-Framework Klassen Zend_Mail_Storage_Imap und Zend_Mail_Message. Der Zugriff via IMAP ist der POP3-Möglichkeit vorzuziehen, da wir dann z.B. Flags oder Ordner nutzen können um Mails zu markieren/verschieben die gerade in Progress sind bzw. fertig bearbeitet wurden.

Um eine Verbindung zum Mailserver aufzubauen nutzen wir einfach den Konstruktor:

$storage = new Zend_Mail_Storage_Imap(array(
    'host'     => 'imap.firma.de',
    'user'     => 'postfach@firma.de',
    'password' => 'passworthier'));

Eine verschlüsselte SSL oder TLS Verbindung ist natürlich auch möglich (hier SSL):

$storage = new Zend_Mail_Storage_Imap(array(
    'host'     => 'imap.firma.de',
    'user'     => 'postfach@firma.de',
    'password' => 'passworthier',
    'ssl'      => 'SSL'));

Nachdem die Verbindungsparameter spezifiziert wurden kann man nun auf den Server zugreifen. Als erstes möchten wir uns die Gesamtanzahl der Nachrichten im aktuellen Ordner anzeigen lassen:

echo $storage->countMessages() . ' Nachrichten im Ordner';

Mit Hilfe einer foreach-Schleife können wir nun alle Emails durchlaufen. Das ist möglich da das Storage-Object das Iterator-Pattern implementiert:

foreach ($storage as $messageNum => $message) {
    echo 'Email von '.$message->from.': '.$message->subject;
}

Wie man oben sehen kann werden die Header der Email einfach wie ein public Attribut abgefragt. Das wird intern über die magische __get() Funktion ermöglicht. Man kann aber auch die getHeader() Funktion nutzen, die gerade im Fall von “besonderen” Headern wie “Reply-To” einfacher einzusetzen ist ($message->reply-to wäre ungültig).

Um auf den Inhalt der Email zugreifen zu können nutzt man die getContent()-Funktion:

echo $message->getContent();

Da Emails aus mehreren Teilen bestehen können (Textteil, HTML-Teil, Anhänge, Inline-Bilder usw) kann man diese Teile auch untersuchen:

$foundPart = null;
foreach (new RecursiveIteratorIterator($message) as $part) {
    try {
        if (strtok($part->contentType, ';') == 'text/plain') {
            $foundPart = $part;
            break;
        }
    } catch (Zend_Mail_Exception $e) {
        // ignorieren
    }
}
if (!$foundPart) {
    echo 'kein reiner Text-Teil gefunden';
} else {
    echo "Reiner Text-Teil: \n" . $foundPart;
}

Auf IMAP-Servern können wir wie bereits erwähnt Emails mit Flags versehen und abfragen.

if ($message->hasFlag(Zend_Mail_Storage::FLAG_FLAGGED)) {
        continue;
}

Damit würden wie alle Emails überspringen die geflaggt sind. Flags können wie gesagt dafür genutzt werden um bereits bearbeitete Emails zu markieren.

$storage->setFlags($messageNum, array(Zend_Mail_Storage::FLAG_FLAGGED));

Man kann natürlich auch auf einzelne Emails zugreifen:

$message = $storage->getMessage($messageNum);

Dabei sollte man jedoch daran denken dass $messageNum die Sequenznummer ist. Wenn eine Email heute die Sequenznummer 3 hat, kann sie morgen schon die Sequenznummer 2 haben wenn Email 1 oder 2 in der Zwischenzeit gelöscht wurde.

Emails löschen ist auch sehr einfach:

$storage->removeMessage($messageNum);

Wie bereits geschrieben kann es dabei zu Verschiebungen der Sequenznummern kommen, es ist also Vorsicht geboten.

Die Zend-Framework-Klassen sind für die meisten einfachen Aufgaben sehr gut brauchbar. Wenn man allerdings erweiterte Funktionalitäten benötigt muß man die Klasse erweitern. Um einigen Problemen aus dem Weg zu gehen habe ich beispielsweise alle Funktionen erweitert, sodass ich mit UniqueIDs arbeiten kann statt Sequenznummern. Desweiteren sind folgende Funktionen dazugekommen die man des öfteren mal benötigt (für die meisten davon gibt es bereits Issue-Tracker-Einträge, um sie in das Framework aufzunehmen):

sort() Methode: http://framework.zend.com/issues/browse/ZF-9138
search() Methode: http://framework.zend.com/issues/browse/ZF-8858
Kopieren mehrere Emails mit einem IMAP-Befehl (nicht copy() in einer Schleife aufrufen): http://framework.zend.com/issues/browse/ZF-8513
Flags auf mehrere Emails gleichzeitig setzen (anstatt setFlags() in einer Schleife aufrufen zu müssen): http://framework.zend.com/issues/browse/ZF-8488
Mehr Kontrolle über den EXPUNGE Befehl: http://framework.zend.com/issues/browse/ZF-5655

Ähnliche Artikel:

1. PHP 5.3.1 und Zend Framework Bug Hunt Day
2. PHP und das Zend Framework
3. Nicht-HTML-Responses mit dem Zend Framework