Documentation TYPO3 par Ameos

Disponible dans d'autres versions de TYPO3 -> 3.7.0  3.8.1  4.0.0  4.0.1  4.1.0   <- Available in other TYPO3 versions

class.t3lib_htmlmail.php

<?php
/***************************************************************
*  Copyright notice
*
*  (c) 1999-2006 Kasper Skaarhoj (kasperYYYY@typo3.com)
*  All rights reserved
*
*  This script is part of the TYPO3 project. The TYPO3 project is
*  free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  The GNU General Public License can be found at
*  http://www.gnu.org/copyleft/gpl.html.
*  A copy is found in the textfile GPL.txt and important notices to the license
*  from the author is found in LICENSE.txt distributed with these scripts.
*
*
*  This script is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  This copyright notice MUST APPEAR in all copies of the script!
***************************************************************/
class t3lib_htmlmail {
                // Headerinfo:
        var $recipient = "recipient@whatever.com";
        var $recipient_copy = "";               // This recipient (or list of...) will also receive the mail. Regard it as a copy.
        var $subject = "This is the subject";
        var $from_email = "sender@php-mailer.com";
        var $from_name = "Mr. Sender";
        var $replyto_email = "reply@mailer.com";
        var $replyto_name = "Mr. Reply";
        var $organisation = "Your Company";
        var $priority = 3;   // 1 = highest, 5 = lowest, 3 = normal
        var $mailer = "PHP mailer";     // X-mailer
        var $alt_base64=0;
        var $alt_8bit=0;
        var $jumperURL_prefix ="";              // This is a prefix that will be added to all links in the mail. Example: 'http://www.mydomain.com/jump?userid=###FIELD_uid###&url='. if used, anything after url= is urlencoded.
        var $jumperURL_useId=0;                 // If set, then the array-key of the urls are inserted instead of the url itself. Smart in order to reduce link-length
        var $mediaList="";                              // If set, this is a list of the media-files (index-keys to the array) that should be represented in the html-mail
        var $http_password="";
        var $http_username="";
        var $postfix_version1=false;

        // Internal

/*              This is how the $theParts-array is normally looking
        var $theParts = Array(
                "plain" => Array (
                        "content"=> ""
                ),
                "html" => Array (
                        "content"=> "",
                        "path" => "",
                        "media" => Array(),
                        "hrefs" => Array()
                ),
                "attach" => Array ()
        );
*/
        var $theParts = Array();

        var $messageid = "";
        var $returnPath = "";
        var $Xid = "";
        var $dontEncodeHeader = false;          // If set, the header will not be encoded

        var $headers = "";
        var $message = "";
        var $part=0;
        var $image_fullpath_list = "";
        var $href_fullpath_list = "";

        var $plain_text_header = '';
        var $html_text_header = '';
        var $charset = '';
        var $defaultCharset = 'iso-8859-1';








        function t3lib_htmlmail () {
                $this->forceReturnPath = $GLOBALS['TYPO3_CONF_VARS']['SYS']['forceReturnPath'];
        }

        function start ()       {
                global $TYPO3_CONF_VARS;

                        // Sets the message id
                $host = php_uname('n');
                if (strpos('.',$host) === FALSE) {
                        $host = gethostbyaddr(gethostbyname($host));
                }
                if (!$host || $host == '127.0.0.1' || $host == 'localhost') {
                        $host = ($TYPO3_CONF_VARS['SYS']['sitename'] ? preg_replace('/[^A-Za-z0-9_\-]/', '_', $TYPO3_CONF_VARS['SYS']['sitename']) : 'localhost') . '.TYPO3';
                }
                $this->messageid = md5(microtime()) . '@' . $host;

                        // Default line break for Unix systems.
                $this->linebreak = chr(10);
                        // Line break for Windows. This is needed because PHP on Windows systems send mails via SMTP instead of using sendmail, and thus the linebreak needs to be \r\n.
                if (TYPO3_OS=='WIN')    {
                        $this->linebreak = chr(13).chr(10);
                }

                $charset = $this->defaultCharset;
                if (is_object($GLOBALS['TSFE']) && $GLOBALS['TSFE']->config['metaCharset'])     {
                        $charset = $GLOBALS['TSFE']->config['metaCharset'];
                } elseif ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'])    {
                        $charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'];
                }
                $this->charset = $charset;

                        // Use quoted-printable headers by default
                $this->useQuotedPrintable();
        }

        function useQuotedPrintable()   {
                $this->plain_text_header = 'Content-Type: text/plain; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: quoted-printable';
                $this->html_text_header = 'Content-Type: text/html; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: quoted-printable';
        }

        function useBase64()    {
                $this->plain_text_header = 'Content-Type: text/plain; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: base64';
                $this->html_text_header = 'Content-Type: text/html; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: base64';
                $this->alt_base64=1;
        }

        function use8Bit()      {
                $this->plain_text_header = 'Content-Type: text/plain; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: 8bit';
                $this->html_text_header = 'Content-Type: text/html; charset='.$this->charset.$this->linebreak.'Content-Transfer-Encoding: 8bit';
                $this->alt_8bit=1;
        }

        function encodeMsg($content)    {
                return $this->alt_base64 ? $this->makeBase64($content) : ($this->alt_8bit ? $content : t3lib_div::quoted_printable($content));
        }

        function addPlain ($content)    {
                        // Adds plain-text and qp-encodes it
                $content=$this->substHTTPurlsInPlainText($content);
                $this->setPlain($this->encodeMsg($content));
        }

        function addAttachment($file)   {
                        // Adds an attachment to the mail
                $theArr = $this->getExtendedURL($file);         // We fetch the content and the mime-type
                if ($theArr)    {
                        if (!$theArr["content_type"]){$theArr["content_type"]="application/octet-stream";}
                        $temp = $this->split_fileref($file);
                        $theArr["filename"]= (($temp["file"])?$temp["file"]:(strpos(" ".$theArr["content_type"],"htm")?"index.html":"unknown"));
                        $this->theParts["attach"][]=$theArr;
                        return true;
                } else { return false;}
        }

        function addHTML ($file)        {
                        // Adds HTML and media, encodes it from a URL or file
                $status = $this->fetchHTML($file);
//              debug(md5($status));
                if (!$status)   {return false;}
                if ($this->extractFramesInfo()) {
                        return "Document was a frameset. Stopped";
                }
                $this->extractMediaLinks();
                $this->extractHyperLinks();
                $this->fetchHTMLMedia();
                $this->substMediaNamesInHTML(0);        // 0 = relative
                $this->substHREFsInHTML();
                $this->setHTML($this->encodeMsg($this->theParts["html"]["content"]));
        }

        function extractHtmlInit($html,$url)    {
                $this->theParts["html"]["content"]=$html;
                $this->theParts["html"]["path"]=$url;
        }

        function send($recipient)       {
                        // This function sends the mail to one $recipient
                if ($recipient) {$this->recipient = $recipient;}
                $this->setHeaders();
                $this->setContent();
                $this->sendTheMail();
        }













        /*****************************************
         *
         * Main functions
         *
         *****************************************/

        function setHeaders()   {
                        // Clears the header-string and sets the headers based on object-vars.
                $this->headers = "";
                        // Message_id
                $this->add_header("Message-ID: <".$this->messageid.">");
                        // Return path
                if ($this->returnPath)  {
                        $this->add_header("Return-Path: ".$this->returnPath);
                        $this->add_header("Errors-To: ".$this->returnPath);
                }
                        // X-id
                if ($this->Xid) {
                        $this->add_header("X-Typo3MID: ".$this->Xid);
                }

                        // From
                if ($this->from_email)  {
                        if ($this->from_name)   {
                                $this->add_header('From: '.$this->from_name.' <'.$this->from_email.'>');
                        } else {
                                $this->add_header('From: '.$this->from_email);
                        }
                }
                        // Reply
                if ($this->replyto_email)       {
                        if ($this->replyto_name)        {
                                $this->add_header('Reply-To: '.$this->replyto_name.' <'.$this->replyto_email.'>');
                        } else {
                                $this->add_header('Reply-To: '.$this->replyto_email);
                        }
                }
                        // Organisation
                if ($this->organisation)        {
                        $this->add_header('Organisation: '.$this->organisation);
                }
                        // mailer
                if ($this->mailer)      {
                        $this->add_header("X-Mailer: $this->mailer");
                }
                        // priority
                if ($this->priority)    {
                        $this->add_header("X-Priority: $this->priority");
                }
                $this->add_header("Mime-Version: 1.0");

                if (!$this->dontEncodeHeader)   {
                        $enc = $this->alt_base64 ? 'base64' : 'quoted_printable';       // Header must be ASCII, therefore only base64 or quoted_printable are allowed!
                                // Quote recipient and subject
                        $this->recipient = t3lib_div::encodeHeader($this->recipient,$enc,$this->charset);
                        $this->subject = t3lib_div::encodeHeader($this->subject,$enc,$this->charset);
                }
        }

        function setRecipient ($recip)  {
                // Sets the recipient(s). If you supply a string, you set one recipient. If you supply an array, every value is added as a recipient.
                if (is_array($recip))   {
                        $this->recipient = "";
                        while (list($key,) = each($recip)) {
                                $this->recipient .= $recip[$key].",";
                        }
                        $this->recipient = ereg_replace(",$","",$this->recipient);
                } else {
                        $this->recipient = $recip;
                }
        }

        function getHTMLContentType()   {
                return count($this->theParts["html"]["media"]) ? 'multipart/related;' : 'multipart/alternative;';
        }

        function setContent()   {
                        // Begins building the message-body
                $this->message = "";
                $boundary = $this->getBoundary();
                // Setting up headers
                if (count($this->theParts["attach"]))   {
                        $this->add_header('Content-Type: multipart/mixed;');
                        $this->add_header(' boundary="'.$boundary.'"');
                        $this->add_message("This is a multi-part message in MIME format.\n");
                        $this->constructMixed($boundary);       // Generate (plain/HTML) / attachments
                } elseif ($this->theParts["html"]["content"]) {
                        $this->add_header('Content-Type: '.$this->getHTMLContentType());
                        $this->add_header(' boundary="'.$boundary.'"');
                        $this->add_message("This is a multi-part message in MIME format.\n");
                        $this->constructHTML($boundary);                // Generate plain/HTML mail
                } else {
                        $this->add_header($this->plain_text_header);
                        $this->add_message($this->getContent("plain")); // Generate plain only
                }
        }

        function constructMixed ($boundary)     {
                        // Here (plain/HTML) is combined with the attachments
                $this->add_message("--".$boundary);
                        // (plain/HTML) is added
                if ($this->theParts["html"]["content"]) {
                                // HTML and plain
                        $newBoundary = $this->getBoundary();
                        $this->add_message("Content-Type: ".$this->getHTMLContentType());
                        $this->add_message(' boundary="'.$newBoundary.'"');
                        $this->add_message('');
                        $this->constructHTML($newBoundary);
                } else {        // Purely plain
                        $this->add_message($this->plain_text_header);
                        $this->add_message('');
                        $this->add_message($this->getContent("plain"));
                }
                        // attachments are added
                if (is_array($this->theParts["attach"]))        {
                        reset($this->theParts["attach"]);
                        while(list(,$media)=each($this->theParts["attach"]))    {
                                $this->add_message("--".$boundary);
                                $this->add_message("Content-Type: ".$media["content_type"]);
                                $this->add_message(' name="'.$media["filename"].'"');
                                $this->add_message("Content-Transfer-Encoding: base64");
                                $this->add_message("Content-Disposition: attachment;");
                                $this->add_message(' filename="'.$media["filename"].'"');
                                $this->add_message('');
                                $this->add_message($this->makeBase64($media["content"]));
                        }
                }
                $this->add_message("--".$boundary."--\n");
        }

        function constructHTML ($boundary)      {
                if (count($this->theParts["html"]["media"]))    {       // If media, then we know, the multipart/related content-type has been set before this function call...
                        $this->add_message("--".$boundary);
                                // HTML has media
                        $newBoundary = $this->getBoundary();
                        $this->add_message("Content-Type: multipart/alternative;");
                        $this->add_message(' boundary="'.$newBoundary.'"');
                        $this->add_message('Content-Transfer-Encoding: 7bit');
                        $this->add_message('');

                        $this->constructAlternative($newBoundary);      // Adding the plaintext/html mix

                        $this->constructHTML_media($boundary);
                } else {
                        $this->constructAlternative($boundary); // Adding the plaintext/html mix, and if no media, then use $boundary instead of $newBoundary
                }
        }

        function constructAlternative($boundary)        {
                        // Here plain is combined with HTML
                $this->add_message("--".$boundary);
                        // plain is added
                $this->add_message($this->plain_text_header);
                $this->add_message('');
                $this->add_message($this->getContent("plain"));
                $this->add_message("--".$boundary);
                        // html is added
                $this->add_message($this->html_text_header);
                $this->add_message('');
                $this->add_message($this->getContent("html"));
                $this->add_message("--".$boundary."--\n");
        }

        function constructHTML_media ($boundary)        {
/*                      // Constructs the HTML-part of message if the HTML contains media
                $this->add_message("--".$boundary);
                        // htmlcode is added
                $this->add_message($this->html_text_header);
                $this->add_message('');
                $this->add_message($this->getContent("html"));

                OLD stuf...

                */
                        // media is added
                if (is_array($this->theParts["html"]["media"])) {
                        reset($this->theParts["html"]["media"]);
                        while(list($key,$media)=each($this->theParts["html"]["media"])) {
                                if (!$this->mediaList || t3lib_div::inList($this->mediaList,$key))      {
                                        $this->add_message("--".$boundary);
                                        $this->add_message("Content-Type: ".$media["ctype"]);
                                        $this->add_message("Content-ID: <part".$key.".".$this->messageid.">");
                                        $this->add_message("Content-Transfer-Encoding: base64");
                                        $this->add_message('');
                                        $this->add_message($this->makeBase64($media["content"]));
                                }
                        }
                }
                $this->add_message("--".$boundary."--\n");
        }

        function sendTheMail () {
#debug(array($this->recipient,$this->subject,$this->message,$this->headers));
                        // Sends the mail, requires the recipient, message and headers to be set.
                if (trim($this->recipient) && trim($this->message))     {       //  && trim($this->headers)
                        $returnPath = (strlen($this->returnPath)>0)?"-f".$this->returnPath:'';
                                //On windows the -f flag is not used (specific for Sendmail and Postfix), but instead the php.ini parameter sendmail_from is used.
                        if($this->returnPath) {
                                ini_set(sendmail_from, $this->returnPath);
                        }
                                //If safe mode is on, the fifth parameter to mail is not allowed, so the fix wont work on unix with safe_mode=On
                        if(!ini_get('safe_mode') && $this->forceReturnPath) {
                                mail($this->recipient,
                                          $this->subject,
                                          $this->message,
                                          $this->headers,
                                          $returnPath);
                        } else {
                                mail($this->recipient,
                                          $this->subject,
                                          $this->message,
                                          $this->headers);
                        }
                                // Sending copy:
                        if ($this->recipient_copy)      {
                                if(!ini_get('safe_mode') && $this->forceReturnPath) {
                                        mail(   $this->recipient_copy,
                                                                $this->subject,
                                                                $this->message,
                                                                $this->headers,
                                                                $returnPath);
                                } else {
                                        mail(   $this->recipient_copy,
                                                                $this->subject,
                                                                $this->message,
                                                                $this->headers  );
                                }
                        }
                                // Auto response
                        if ($this->auto_respond_msg)    {
                                $theParts = explode('/',$this->auto_respond_msg,2);
                                $theParts[1] = str_replace("/",chr(10),$theParts[1]);
                                if(!ini_get('safe_mode') && $this->forceReturnPath) {
                                        mail(   $this->from_email,
                                                                $theParts[0],
                                                                $theParts[1],
                                                                "From: ".$this->recipient,
                                                                $returnPath);
                                } else {
                                        mail(   $this->from_email,
                                                                $theParts[0],
                                                                $theParts[1],
                                                                "From: ".$this->recipient);
                                }
                        }
                        if($this->returnPath) {
                                ini_restore(sendmail_from);
                        }
                        return true;
                } else {return false;}
        }

        function getBoundary()  {
                        // Returns boundaries
                $this->part++;
                return  "----------".uniqid("part_".$this->part."_");
        }

        function setPlain ($content)    {
                        // Sets the plain-text part. No processing done.
                $this->theParts["plain"]["content"] = $content;
        }

        function setHtml ($content)     {
                        // Sets the HTML-part. No processing done.
                $this->theParts["html"]["content"] = $content;
        }

        function add_header($header)    {
                if (!$this->dontEncodeHeader && !stristr($header,'Content-Type') && !stristr($header,'Content-Transfer-Encoding'))      {
                                // Mail headers must be ASCII, therefore we convert the whole header to either base64 or quoted_printable
                        $parts = explode(': ',$header,2);       // Field tags must not be encoded
                        if (count($parts)==2)   {
                                $enc = $this->alt_base64 ? 'base64' : 'quoted_printable';
                                $parts[1] = t3lib_div::encodeHeader($parts[1],$enc,$this->charset);
                                $header = implode(': ',$parts);
                        }
                }

                        // Adds a header to the mail. Use this AFTER the setHeaders()-function
                $this->headers.=$header."\n";
        }

        function add_message($string)   {
                        // Adds a line of text to the mail-body. Is normally use internally
                $this->message.=$string."\n";
        }

        function getContent($type)      {
                return $this->theParts[$type]["content"];
        }

        function preview()      {
                echo nl2br(HTMLSpecialChars($this->headers));
                echo "<BR>";
                echo nl2br(HTMLSpecialChars($this->message));
        }













        /****************************************************
         *
         * Functions for acquiring attachments, HTML, analyzing and so on  **
         *
         ***************************************************/

        function fetchHTML($file)       {
                        // Fetches the HTML-content from either url og local serverfile
                $this->theParts["html"]["content"] = $this->getURL($file);      // Fetches the content of the page
                if ($this->theParts["html"]["content"]) {
                        $addr = $this->extParseUrl($file);
                        $path = ($addr['scheme']) ? $addr['scheme'].'://'.$addr['host'].(($addr['port'])?':'.$addr['port']:'').(($addr['filepath'])?$addr['filepath']:'/') : $addr['filepath'];
                        $this->theParts["html"]["path"] = $path;
                        return true;
                } else {
                        return false;
                }
        }

        function fetchHTMLMedia()       {
                        // Fetches the mediafiles which are found by extractMediaLinks()
                if (is_array($this->theParts["html"]["media"])) {
                        reset ($this->theParts["html"]["media"]);
                        if (count($this->theParts["html"]["media"]) > 0)        {
                                while (list($key,$media) = each ($this->theParts["html"]["media"]))     {
                                        $picdata = $this->getExtendedURL($this->theParts["html"]["media"][$key]["absRef"]);             // We fetch the content and the mime-type
                                        if (is_array($picdata)) {
                                                $this->theParts["html"]["media"][$key]["content"] = $picdata["content"];
                                                $this->theParts["html"]["media"][$key]["ctype"] = $picdata["content_type"];
                                        }
                                }
                        }
                }
        }

        function extractMediaLinks()    {
                        // extracts all media-links from $this->theParts["html"]["content"]
                $html_code = $this->theParts["html"]["content"];
                $attribRegex = $this->tag_regex(Array("img","table","td","tr","body","iframe","script","input","embed"));
                $codepieces = split($attribRegex, $html_code);  // Splits the document by the beginning of the above tags
                $len=strlen($codepieces[0]);
                $pieces = count($codepieces);
                $reg = array();
                for($i=1; $i < $pieces; $i++)   {
                        $tag = strtolower(strtok(substr($html_code,$len+1,10)," "));
                        $len+=strlen($tag)+strlen($codepieces[$i])+2;
                        $dummy = eregi("[^>]*", $codepieces[$i], $reg);
                        $attributes = $this->get_tag_attributes($reg[0]);       // Fetches the attributes for the tag
                        $imageData=array();
                        $imageData["ref"]=($attributes["src"]) ? $attributes["src"] : $attributes["background"];        // Finds the src or background attribute
                        if ($imageData["ref"])  {
                                $imageData["quotes"]=(substr($codepieces[$i],strpos($codepieces[$i], $imageData["ref"])-1,1)=='"')?'"':'';              // Finds out if the value had quotes around it
                                $imageData["subst_str"] = $imageData["quotes"].$imageData["ref"].$imageData["quotes"];  // subst_str is the string to look for, when substituting lateron
                                if ($imageData["ref"] && !strstr($this->image_fullpath_list,"|".$imageData["subst_str"]."|"))   {
                                        $this->image_fullpath_list.="|".$imageData["subst_str"]."|";
                                        $imageData["absRef"] = $this->absRef($imageData["ref"]);
                                        $imageData["tag"]=$tag;
                                        $imageData["use_jumpurl"]=$attributes["dmailerping"]?1:0;
                                        $this->theParts["html"]["media"][]=$imageData;
                                }
                        }
                }
                        // Extracts stylesheets
                $attribRegex = $this->tag_regex(Array("link"));
                $codepieces = split($attribRegex, $html_code);  // Splits the document by the beginning of the above tags
                $pieces = count($codepieces);
                for($i=1; $i < $pieces; $i++)   {
                        $dummy = eregi("[^>]*", $codepieces[$i], $reg);
                        $attributes = $this->get_tag_attributes($reg[0]);       // Fetches the attributes for the tag
                        $imageData=array();
                        if (strtolower($attributes["rel"])=="stylesheet" && $attributes["href"])        {
                                $imageData["ref"]=$attributes["href"];  // Finds the src or background attribute
                                $imageData["quotes"]=(substr($codepieces[$i],strpos($codepieces[$i], $imageData["ref"])-1,1)=='"')?'"':'';              // Finds out if the value had quotes around it
                                $imageData["subst_str"] = $imageData["quotes"].$imageData["ref"].$imageData["quotes"];  // subst_str is the string to look for, when substituting lateron
                                if ($imageData["ref"] && !strstr($this->image_fullpath_list,"|".$imageData["subst_str"]."|"))   {
                                        $this->image_fullpath_list.="|".$imageData["subst_str"]."|";
                                        $imageData["absRef"] = $this->absRef($imageData["ref"]);
                                        $this->theParts["html"]["media"][]=$imageData;
                                }
                        }
                }
                        // fixes javascript rollovers
                $codepieces = split(quotemeta(".src"), $html_code);
                $pieces = count($codepieces);
                $expr = "^[^".quotemeta("\"").quotemeta("'")."]*";
                for($i=1; $i < $pieces; $i++)   {
                        $temp = $codepieces[$i];
                        $temp = trim(ereg_replace("=","",trim($temp)));
                        ereg ($expr,substr($temp,1,strlen($temp)),$reg);
                        $imageData["ref"] = $reg[0];
                        $imageData["quotes"] = substr($temp,0,1);
                        $imageData["subst_str"] = $imageData["quotes"].$imageData["ref"].$imageData["quotes"];  // subst_str is the string to look for, when substituting lateron
                        $theInfo = $this->split_fileref($imageData["ref"]);
                        switch ($theInfo["fileext"])    {
                                case "gif":
                                case "jpeg":
                                case "jpg":
                                        if ($imageData["ref"] && !strstr($this->image_fullpath_list,"|".$imageData["subst_str"]."|"))   {
                                                $this->image_fullpath_list.="|".$imageData["subst_str"]."|";
                                                $imageData["absRef"] = $this->absRef($imageData["ref"]);
                                                $this->theParts["html"]["media"][]=$imageData;
                                        }
                                break;
                        }
                }
        }

        function extractHyperLinks()    {
                        // extracts all hyper-links from $this->theParts["html"]["content"]
                $html_code = $this->theParts["html"]["content"];
                $attribRegex = $this->tag_regex(Array("a","form","area"));
                $codepieces = split($attribRegex, $html_code);  // Splits the document by the beginning of the above tags
                $len=strlen($codepieces[0]);
                $pieces = count($codepieces);
                for($i=1; $i < $pieces; $i++)   {
                        $tag = strtolower(strtok(substr($html_code,$len+1,10)," "));
                        $len+=strlen($tag)+strlen($codepieces[$i])+2;

                        $dummy = eregi("[^>]*", $codepieces[$i], $reg);
                        $attributes = $this->get_tag_attributes($reg[0]);       // Fetches the attributes for the tag
                        $hrefData="";
                        if ($attributes["href"]) {$hrefData["ref"]=$attributes["href"];} else {$hrefData["ref"]=$attributes["action"];}
                        if ($hrefData["ref"])   {
                                $hrefData["quotes"]=(substr($codepieces[$i],strpos($codepieces[$i], $hrefData["ref"])-1,1)=='"')?'"':'';                // Finds out if the value had quotes around it
                                $hrefData["subst_str"] = $hrefData["quotes"].$hrefData["ref"].$hrefData["quotes"];      // subst_str is the string to look for, when substituting lateron
                                if ($hrefData["ref"] && substr(trim($hrefData["ref"]),0,1)!="#" && !strstr($this->href_fullpath_list,"|".$hrefData["subst_str"]."|"))   {
                                        $this->href_fullpath_list.="|".$hrefData["subst_str"]."|";
                                        $hrefData["absRef"] = $this->absRef($hrefData["ref"]);
                                        $hrefData["tag"]=$tag;
                                        $this->theParts["html"]["hrefs"][]=$hrefData;
                                }
                        }
                }
                        // Extracts TYPO3 specific links made by the openPic() JS function
                $codepieces = explode("onClick=\"openPic('", $html_code);
                $pieces = count($codepieces);
                for($i=1; $i < $pieces; $i++)   {
                        $showpic_linkArr = explode("'",$codepieces[$i]);
                        $hrefData["ref"]=$showpic_linkArr[0];
                        if ($hrefData["ref"])   {
                                $hrefData["quotes"]="'";                // Finds out if the value had quotes around it
                                $hrefData["subst_str"] = $hrefData["quotes"].$hrefData["ref"].$hrefData["quotes"];      // subst_str is the string to look for, when substituting lateron
                                if ($hrefData["ref"] && !strstr($this->href_fullpath_list,"|".$hrefData["subst_str"]."|"))      {
                                        $this->href_fullpath_list.="|".$hrefData["subst_str"]."|";
                                        $hrefData["absRef"] = $this->absRef($hrefData["ref"]);
                                        $this->theParts["html"]["hrefs"][]=$hrefData;
                                }
                        }
                }
        }

        function extractFramesInfo()    {
                        // extracts all media-links from $this->theParts["html"]["content"]
                $html_code = $this->theParts["html"]["content"];
                if (strpos(" ".$html_code,"<frame "))   {
                        $attribRegex = $this->tag_regex("frame");
                        $codepieces = split($attribRegex, $html_code, 1000000 );        // Splits the document by the beginning of the above tags
                        $pieces = count($codepieces);
                        for($i=1; $i < $pieces; $i++)   {
                                $dummy = eregi("[^>]*", $codepieces[$i], $reg);
                                $attributes = $this->get_tag_attributes($reg[0]);       // Fetches the attributes for the tag
                                $frame="";
                                $frame["src"]=$attributes["src"];
                                $frame["name"]=$attributes["name"];
                                $frame["absRef"] = $this->absRef($frame["src"]);
                                $theInfo[] = $frame;
                        }
                        return $theInfo;
                }
        }

        function substMediaNamesInHTML($absolute)       {
                        // This substitutes the media-references in $this->theParts["html"]["content"]
                        // If $absolute is true, then the refs are substituted with http:// ref's indstead of Content-ID's (cid).
                if (is_array($this->theParts["html"]["media"])) {
                        reset ($this->theParts["html"]["media"]);
                        while (list($key,$val) = each ($this->theParts["html"]["media"]))       {
                                if ($val["use_jumpurl"] && $this->jumperURL_prefix)     {
                                        $theSubstVal = $this->jumperURL_prefix.t3lib_div::rawUrlEncodeFP($val['absRef']);
                                } else {
                                        $theSubstVal = ($absolute) ? $val["absRef"] : "cid:part".$key.".".$this->messageid;
                                }
                                $this->theParts["html"]["content"] = str_replace(
                                                $val["subst_str"],
                                                $val["quotes"].$theSubstVal.$val["quotes"],
                                                $this->theParts["html"]["content"]      );
                        }
                }
                if (!$absolute) {
                        $this->fixRollOvers();
                }
        }

        function substHREFsInHTML()     {
                        // This substitutes the hrefs in $this->theParts["html"]["content"]
                if (is_array($this->theParts["html"]["hrefs"])) {
                        reset ($this->theParts["html"]["hrefs"]);
                        while (list($key,$val) = each ($this->theParts["html"]["hrefs"]))       {
                                if ($this->jumperURL_prefix && $val["tag"]!="form")     {       // Form elements cannot use jumpurl!
                                        if ($this->jumperURL_useId)     {
                                                $theSubstVal = $this->jumperURL_prefix.$key;
                                        } else {
                                                $theSubstVal = $this->jumperURL_prefix.t3lib_div::rawUrlEncodeFP($val['absRef']);
                                        }
                                } else {
                                        $theSubstVal = $val["absRef"];
                                }
                                $this->theParts["html"]["content"] = str_replace(
                                                $val["subst_str"],
                                                $val["quotes"].$theSubstVal.$val["quotes"],
                                                $this->theParts["html"]["content"]      );
                        }
                }
        }

        function substHTTPurlsInPlainText($content)     {
                        // This substitutes the http:// urls in plain text with links
                if ($this->jumperURL_prefix)    {
                        $textpieces = explode("http://", $content);
                        $pieces = count($textpieces);
                        $textstr = $textpieces[0];
                        for($i=1; $i<$pieces; $i++)     {
                                $len=strcspn($textpieces[$i],chr(32).chr(9).chr(13).chr(10));
                                if (trim(substr($textstr,-1))=="" && $len)      {
                                        $lastChar=substr($textpieces[$i],$len-1,1);
                                        if (!ereg("[A-Za-z0-9\/#]",$lastChar)) {$len--;}                // Included "\/" 3/12

                                        $parts[0]="http://".substr($textpieces[$i],0,$len);
                                        $parts[1]=substr($textpieces[$i],$len);

                                        if ($this->jumperURL_useId)     {
                                                $this->theParts["plain"]["link_ids"][$i]=$parts[0];
                                                $parts[0] = $this->jumperURL_prefix."-".$i;
                                        } else {
                                                $parts[0] = $this->jumperURL_prefix.t3lib_div::rawUrlEncodeFP($parts[0]);
                                        }
                                        $textstr.=$parts[0].$parts[1];
                                } else {
                                        $textstr.='http://'.$textpieces[$i];
                                }
                        }
                        $content = $textstr;
                }
                return $content;
        }

        function fixRollOvers() {
                        // JavaScript rollOvers cannot support graphics inside of mail. If these exists we must let them refer to the absolute url. By the way: Roll-overs seems to work only on some mail-readers and so far I've seen it work on Netscape 4 message-center (but not 4.5!!)
                $theNewContent = "";
                $theSplit = explode(".src",$this->theParts["html"]["content"]);
                if (count($theSplit)>1) {
                        while(list($key,$part)=each($theSplit)) {
                                $sub = substr($part,0,200);
                                if (ereg("cid:part[^ \"']*",$sub,$reg)) {
                                        $thePos = strpos($part,$reg[0]);        // The position of the string
                                        ereg("cid:part([^\.]*).*",$sub,$reg2);          // Finds the id of the media...
                                        $theSubStr = $this->theParts["html"]["media"][intval($reg2[1])]["absRef"];
                                        if ($thePos && $theSubStr)      {               // ... and substitutes the javaScript rollover image with this instead
                                                if (!strpos(" ".$theSubStr,"http://")) {$theSubStr = "http://";}                // If the path is NOT and url, the reference is set to nothing
                                                $part = substr($part,0,$thePos).$theSubStr.substr($part,$thePos+strlen($reg[0]),strlen($part));
                                        }
                                }
                                $theNewContent.= $part.((($key+1)!=count($theSplit))? ".src" : ""  );
                        }
                        $this->theParts["html"]["content"]=$theNewContent;
                }
        }
















        /*******************************************
         *
         * File and URL-functions
         *
         *******************************************/

        function makeBase64($inputstr)  {
                        // Returns base64-encoded content, which is broken every 76 character
                return chunk_split(base64_encode($inputstr));
        }

        function getExtendedURL($url)   {
                        // reads the URL or file and determines the Content-type by either guessing or opening a connection to the host
                $res["content"] = $this->getURL($url);
                if (!$res["content"])   {return false;}
                $pathInfo = parse_url($url);
                $fileInfo = $this->split_fileref($pathInfo["path"]);
                if ($fileInfo["fileext"] == "gif")      {$res["content_type"] = "image/gif";}
                if ($fileInfo["fileext"] == "jpg" || $fileInfo["fileext"] == "jpeg")    {$res["content_type"] = "image/jpeg";}
                if ($fileInfo['fileext'] == 'png') {$res['content_type'] = 'image/png';}
                if ($fileInfo["fileext"] == "html" || $fileInfo["fileext"] == "htm")    {$res["content_type"] = "text/html";}
                if ($fileInfo['fileext'] == 'css') {$res['content_type'] = 'text/css';}
                if ($fileInfo["fileext"] == "swf")      {$res["content_type"] = "application/x-shockwave-flash";}
                if (!$res["content_type"])      {$res["content_type"] = $this->getMimeType($url);}
                return $res;
        }

        function addUserPass($url)      {
                $user=$this->http_username;
                $pass=$this->http_password;
                $matches = array();
                if ($user && $pass && preg_match('/^(https?:\/\/)/', $url, $matches)) {
                        $url = $matches[1].$user.':'.$pass.'@'.substr($url,strlen($matches[1]));
                }
                return $url;
        }

        function getURL($url)   {
                $url = $this->addUserPass($url);
                        // reads a url or file
                return t3lib_div::getURL($url);
        }

        function getStrippedURL($url)   {
                        // reads a url or file and strips the HTML-tags AND removes all empty lines. This is used to read plain-text out of a HTML-page
                if($fd = fopen($url,"rb"))      {
                        $content = "";
                        while (!feof($fd))      {
                                $line = fgetss($fd, 5000);
                                if (trim($line))        {
                                        $content.=trim($line)."\n";
                                }
                        }
                        fclose( $fd );
                        return $content;
                }
        }

        function getMimeType($url)      {
                        // Opens a connection to the server and returns the mime-type of the file
                        // takes url only
                $pathInfo = parse_url($url);
                if (!$pathInfo["scheme"])       {return false;}
                $getAdr = ($pathInfo["query"])?$pathInfo["path"]."?".$pathInfo["query"]:$pathInfo["path"];
                $fp = fsockopen($pathInfo['host'], ($pathInfo['port']?$pathInfo['port']:80), $errno, $errstr);
                if(!$fp) {
                        return false;
                } else {
                        fputs($fp,'HEAD '.$getAdr.' HTTP/1.0\r\nHost: '.$pathInfo['host'].'\r\n\r\n');
                        while(!feof($fp)) {
                                $thePortion= fgets($fp,128);
                                if (eregi("(^Content-Type: )(.*)",trim($thePortion), $reg))     {
                                        $res = trim($reg[2]);
                                        break;
                                }
                        }
                        fclose($fp);
                }
                return $res;
        }

        function absRef($ref)   {
                        // Returns the absolute address of a link. This is based on $this->theParts["html"]["path"] being the root-address
                $ref = trim($ref);
                $urlINFO = parse_url($ref);
                if ($urlINFO["scheme"]) {
                        return $ref;
                } elseif (eregi("^/",$ref)){
                        $addr = parse_url($this->theParts["html"]["path"]);
                        return  $addr['scheme'].'://'.$addr['host'].($addr['port']?':'.$addr['port']:'').$ref;
                } else {
                        return $this->theParts["html"]["path"].$ref;    // If the reference is relative, the path is added, in order for us to fetch the content
                }
        }

        function split_fileref($fileref)        {
                        // Returns an array with path, filename, filebody, fileext.
                if (    ereg("(.*/)(.*)$",$fileref,$reg)        )       {
                        $info["path"] = $reg[1];
                        $info["file"] = $reg[2];
                } else {
                        $info["path"] = "";
                        $info["file"] = $fileref;
                }
                $reg="";
                if (    ereg("(.*)\.([^\.]*$)",$info["file"],$reg)      )       {
                        $info["filebody"] = $reg[1];
                        $info["fileext"] = strtolower($reg[2]);
                        $info["realFileext"] = $reg[2];
                } else {
                        $info["filebody"] = $info["file"];
                        $info["fileext"] = "";
                }
                return $info;
        }

        function extParseUrl($path)     {
                        // Returns an array with file or url-information
                $res = parse_url($path);
                ereg("(.*/)([^/]*)$",$res["path"],$reg);
                $res["filepath"]=$reg[1];
                $res["filename"]=$reg[2];
                return $res;
        }

        function tag_regex($tagArray)   {
                if (!is_array($tagArray))       {
                        $tagArray=Array($tagArray);
                }
                $theRegex = "";
                $c=count($tagArray);
                while(list(,$tag)=each($tagArray))      {
                        $c--;
                        $theRegex.="<".sql_regcase($tag)."[[:space:]]".(($c)?"|":"");
                }
                return $theRegex;
        }

        function get_tag_attributes($tag)       {
                $attributes = Array();
                $tag = ltrim(eregi_replace ("^<[^ ]*","",trim($tag)));
                $tagLen = strlen($tag);
                $safetyCounter = 100;
                        // Find attribute
                while ($tag)    {
                        $value = "";
                        $reg = split("[[:space:]=>]",$tag,2);
                        $attrib = $reg[0];

                        $tag = ltrim(substr($tag,strlen($attrib),$tagLen));
                        if (substr($tag,0,1)=="=")      {
                                $tag = ltrim(substr($tag,1,$tagLen));
                                if (substr($tag,0,1)=='"')      {       // Quotes around the value
                                        $reg = explode('"',substr($tag,1,$tagLen),2);
                                        $tag = ltrim($reg[1]);
                                        $value = $reg[0];
                                } else {        // No qoutes around value
                                        ereg("^([^[:space:]>]*)(.*)",$tag,$reg);
                                        $value = trim($reg[1]);
                                        $tag = ltrim($reg[2]);
                                        if (substr($tag,0,1)==">")      {
                                                $tag ="";
                                        }
                                }
                        }
                        $attributes[strtolower($attrib)]=$value;
                        $safetyCounter--;
                        if ($safetyCounter<0)   {break;}
                }
                return $attributes;
        }

        function quoted_printable($string)      {
                return t3lib_div::quoted_printable($string, 76);
        }

        function convertName($name)     {
                return $name;
        }
}

if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_htmlmail.php'])  {
        include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_htmlmail.php']);
}
?>

---