t3lib/class.t3lib_htmlmail.php

   1 <?php
   2 /***************************************************************
   3  *  Copyright notice
   4  *
   5  *  (c) 1999-2010 Kasper Skårhøj (kasperYYYY@typo3.com)
   6  *  All rights reserved
   7  *
   8  *  This script is part of the TYPO3 project. The TYPO3 project is
   9  *  free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  The GNU General Public License can be found at
  15  *  http://www.gnu.org/copyleft/gpl.html.
  16  *  A copy is found in the textfile GPL.txt and important notices to the license
  17  *  from the author is found in LICENSE.txt distributed with these scripts.
  18  *
  19  *
  20  *  This script is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *  GNU General Public License for more details.
  24  *
  25  *  This copyright notice MUST APPEAR in all copies of the script!
  26  ***************************************************************/
  27 /**
  28  * HTML mail class
  29  *
  30  * $Id$
  31  *
  32  * @author      Kasper Skårhøj <kasperYYYY@typo3.com>
  33  */
  34 /**
  35  * [CLASS/FUNCTION INDEX of SCRIPT]
  36  *
  37  *
  38  *
  39  *  193: class t3lib_htmlmail
  40  *  261:         function t3lib_htmlmail ()
  41  *  268:         function start ()
  42  *  305:         function useQuotedPrintable()
  43  *  315:         function useBase64()
  44  *  326:         function use8Bit()
  45  *  338:         function encodeMsg($content)
  46  *  348:         function addPlain ($content)
  47  *  360:         function addAttachment($file)
  48  *  378:         function addHTML ($file)
  49  *  401:         function extractHtmlInit($html,$url)
  50  *  412:         function send($recipient)
  51  *
  52  *                        SECTION: Main functions
  53  *  441:         function setHeaders()
  54  *  500:         function setRecipient ($recip)
  55  *  518:         function getHTMLContentType()
  56  *  527:         function setContent()
  57  *  554:         function constructMixed ($boundary)
  58  *  593:         function constructHTML ($boundary)
  59  *  617:         function constructAlternative($boundary)
  60  *  638:         function constructHTML_media ($boundary)
  61  *  691:         function sendTheMail ()
  62  *  757:         function getBoundary()
  63  *  769:         function setPlain ($content)
  64  *  780:         function setHtml ($content)
  65  *  791:         function add_header($header)
  66  *  812:         function add_message($string)
  67  *  823:         function getContent($type)
  68  *  832:         function preview()
  69  *
  70  *                        SECTION: Functions for acquiring attachments, HTML, analyzing and so on  **
  71  *  860:         function fetchHTML($file)
  72  *  878:         function fetchHTMLMedia()
  73  *  899:         function extractMediaLinks()
  74  *  976:         function extractHyperLinks()
  75  * 1025:         function extractFramesInfo()
  76  * 1051:         function substMediaNamesInHTML($absolute)
  77  * 1078:         function substHREFsInHTML()
  78  * 1106:         function substHTTPurlsInPlainText($content)
  79  * 1142:         function fixRollOvers()
  80  *
  81  *                        SECTION: File and URL-functions
  82  * 1189:         function makeBase64($inputstr)
  83  * 1200:         function getExtendedURL($url)
  84  * 1222:         function addUserPass($url)
  85  * 1238:         function getURL($url)
  86  * 1250:         function getStrippedURL($url)
  87  * 1271:         function getMimeType($url)
  88  * 1300:         function absRef($ref)
  89  * 1320:         function split_fileref($fileref)
  90  * 1347:         function extParseUrl($path)
  91  * 1362:         function tag_regex($tagArray)
  92  * 1384:         function get_tag_attributes($tag)
  93  * 1426:         function quoted_printable($string)
  94  * 1437:         function convertName($name)
  95  *
  96  * TOTAL FUNCTIONS: 49
  97  * (This index is automatically created/updated by the extension "extdeveval")
  98  *
  99  */
 100 /**
 101  * NOTES on MIME mail structures:
 102  *
 103  * Plain + HTML
 104  *       multipart/alternative  (text, html)
 105  *       multipart/alternative  (text, html)
 106  *
 107  * Plain + HTML + image
 108  *       multipart/related (m/a, cids)
 109  *               multipart/alternative (text, html)
 110  *
 111  *       multipart/related  (m/a, cids)
 112  *               multipart/alternative  (text, html)
 113  *
 114  * plain + attachment
 115  *       multipart/mixed
 116  *
 117  * HTML + Attachment:
 118  *       multipart/mixed                (text/html , attachments)
 119  *
 120  * Plain + HTML + Attachments:
 121  *       multipart/mixed                (m/a, attachments)
 122  *               multipart/alternative  (text, html)
 123  *
 124  * Plain + HTML + image + attachment
 125  *
 126  *               Outlook expr.
 127  *       multipart/mixed (m/r, attachments)
 128  *               multipart/related  (m/a, cids)
 129  *                       multipart/alternative  (text, html)
 130  *
 131  *
 132  *
 133  * FROM RFC 1521:
 134  *
 135  * 5.1 Quoted-Printable Content-Transfer-Encoding
 136  * The Quoted-Printable encoding is intended to represent data that largely consists of octets that correspond to printable characters in the ASCII character set. It encodes the data in such a way that the resulting octets are unlikely to be modified by mail transport. If the data being encoded are mostly ASCII text, the encoded form of the data remains largely recognizable by humans. A body which is entirely ASCII may also be encoded in Quoted-Printable to ensure the integrity of the data should the message pass through a character- translating, and/or line-wrapping gateway.
 137  *
 138  * In this encoding, octets are to be represented as determined by the following rules:
 139  * Rule #1: (General 8-bit representation) Any octet, except those indicating a line break according to the newline convention of the canonical (standard) form of the data being encoded, may be represented by an "=" followed by a two digit hexadecimal representation of the octet's value. The digits of the hexadecimal alphabet, for this purpose, are "0123456789ABCDEF". Uppercase letters must be used when sending hexadecimal data, though a robust implementation may choose to recognize lowercase letters on receipt. Thus, for example, the value 12 (ASCII form feed) can be represented by "=0C", and the value 61 (ASCII EQUAL SIGN) can be represented by "=3D". Except when the following rules allow an alternative encoding, this rule is mandatory.
 140  * Rule #2: (Literal representation) Octets with decimal values of 33 through 60 inclusive, and 62 through 126, inclusive, MAY be represented as the ASCII characters which correspond to those octets (EXCLAMATION POINT through LESS THAN, and GREATER THAN through TILDE, respectively).
 141  * Rule #3: (White Space): Octets with values of 9 and 32 MAY be represented as ASCII TAB (HT) and SPACE characters, respectively, but MUST NOT be so represented at the end of an encoded line. Any TAB (HT) or SPACE characters on an encoded line MUST thus be followed on that line by a printable character. In particular, an
 142  * "=" at the end of an encoded line, indicating a soft line break (see rule #5) may follow one or more TAB (HT) or SPACE characters. It follows that an octet with value 9 or 32 appearing at the end of an encoded line must be represented according to Rule #1. This rule is necessary because some MTAs (Message Transport Agents, programs which transport messages from one user to another, or perform a part of such transfers) are known to pad lines of text with SPACEs, and others are known to remove "white space" characters from the end of a line. Therefore, when decoding a Quoted-Printable body, any trailing white space on a line must be deleted, as it will necessarily have been added by intermediate transport agents.
 143  * Rule #4 (Line Breaks): A line break in a text body, independent of what its representation is following the canonical representation of the data being encoded, must be represented by a (RFC 822) line break, which is a CRLF sequence, in the Quoted-Printable encoding. Since the canonical representation of types other than text do not generally include the representation of line breaks, no hard line breaks (i.e. line breaks that are intended to be meaningful and to be displayed to the user) should occur in the quoted-printable encoding of such types. Of course, occurrences of "=0D", "=0A", "0A=0D" and "=0D=0A" will eventually be encountered. In general, however, base64 is preferred over quoted-printable for binary data.
 144  * Note that many implementations may elect to encode the local representation of various content types directly, as described in Appendix G. In particular, this may apply to plain text material on systems that use newline conventions other than CRLF delimiters. Such an implementation is permissible, but the generation of line breaks must be generalized to account for the case where alternate representations of newline sequences are used.
 145  * Rule #5 (Soft Line Breaks): The Quoted-Printable encoding REQUIRES that encoded lines be no more than 76 characters long. If longer lines are to be encoded with the Quoted-Printable encoding, 'soft' line breaks must be used. An equal sign as the last character on a encoded line indicates such a non-significant ('soft') line break in the encoded text. Thus if the "raw" form of the line is a single unencoded line that says:
 146  * Now's the time for all folk to come to the aid of their country.
 147  *
 148  * This can be represented, in the Quoted-Printable encoding, as
 149  *
 150  * Now's the time =
 151  * for all folk to come=
 152  * to the aid of their country.
 153  *
 154  * This provides a mechanism with which long lines are encoded in such a way as to be restored by the user agent. The 76 character limit does not count the trailing CRLF, but counts all other characters, including any equal signs.
 155  * Since the hyphen character ("-") is represented as itself in the Quoted-Printable encoding, care must be taken, when encapsulating a quoted-printable encoded body in a multipart entity, to ensure that the encapsulation boundary does not appear anywhere in the encoded body. (A good strategy is to choose a boundary that includes a character sequence such as "=_" which can never appear in a quoted- printable body. See the definition of multipart messages later in this document.)
 156  * NOTE: The quoted-printable encoding represents something of a compromise between readability and reliability in transport. Bodies encoded with the quoted-printable encoding will work reliably over most mail gateways, but may not work perfectly over a few gateways, notably those involving translation into EBCDIC. (In theory, an EBCDIC gateway could decode a quoted-printable body and re-encode it using base64, but such gateways do not yet exist.) A higher level of confidence is offered by the base64 Content-Transfer-Encoding. A way to get reasonably reliable transport through EBCDIC gateways is to also quote the ASCII characters
 157  * !"#$@[\]^`{|}~
 158  * according to rule #1. See Appendix B for more information.
 159  * Because quoted-printable data is generally assumed to be line- oriented, it is to be expected that the representation of the breaks between the lines of quoted printable data may be altered in transport, in the same manner that plain text mail has always been altered in Internet mail when passing between systems with differing newline conventions. If such alterations are likely to constitute a corruption of the data, it is probably more sensible to use the base64 encoding rather than the quoted-printable encoding.
 160  * WARNING TO IMPLEMENTORS: If binary data are encoded in quoted- printable, care must be taken to encode CR and LF characters as "=0D" and "=0A", respectively. In particular, a CRLF sequence in binary data should be encoded as "=0D=0A". Otherwise, if CRLF were represented as a hard line break, it might be incorrectly decoded on
 161  * platforms with different line break conventions.
 162  * For formalists, the syntax of quoted-printable data is described by the following grammar:
 163  *
 164  *      quoted-printable := ([*(ptext / SPACE / TAB) ptext] ["="] CRLF)
 165  *               ; Maximum line length of 76 characters excluding CRLF
 166  *
 167  *      ptext := octet /<any ASCII character except "=", SPACE, or TAB>
 168  *               ; characters not listed as "mail-safe" in Appendix B
 169  *               ; are also not recommended.
 170  *
 171  *      octet := "=" 2(DIGIT / "A" / "B" / "C" / "D" / "E" / "F")
 172  *               ; octet must be used for characters > 127, =, SPACE, or TAB,
 173  *               ; and is recommended for any characters not listed in
 174  *               ; Appendix B as "mail-safe".
 175  */
 176 /**
 177  * HTML mail class
 178  *
 179  * @author      Kasper Skårhøj <kasperYYYY@typo3.com>
 180  * @package     TYPO3
 181  * @subpackage  t3lib
 182  */
 183 class t3lib_htmlmail {
 184                 // Headerinfo:
 185         var $recipient = '';
 186         var $recipient_copy = ''; // This recipient (or list of...) will also receive the mail. Regard it as a copy.
 187         var $recipient_blindcopy = ''; // This recipient (or list of...) will also receive the mail as a blind copy. Regard it as a copy.
 188         var $subject = '';
 189         var $from_email = '';
 190         var $from_name = '';
 191         var $replyto_email = '';
 192         var $replyto_name = '';
 193         var $organisation = '';
 194         var $priority = 3; // 1 = highest, 5 = lowest, 3 = normal
 195         var $mailer = ''; // X-mailer, set to TYPO3 Major.Minor in constructor
 196         var $alt_base64 = 0;
 197         var $alt_8bit = 0;
 198         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.
 199         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
 200         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
 201         var $http_password = '';
 202         var $http_username = '';
 203         var $postfix_version1 = FALSE;
 204
 205                 // Internal
 206         /*
 207         This is how the $theParts-array is normally looking
 208         var $theParts = array(
 209                 'plain' => array(
 210                         'content' => ''
 211                 ),
 212                 'html' => array(
 213                         'content' => '',
 214                         'path' => '',
 215                         'media' => array(),
 216                         'hrefs' => array()
 217                 ),
 218                 'attach' => array()
 219         );
 220         */
 221         var $theParts = array();
 222
 223         var $messageid = '';
 224         var $returnPath = '';
 225         var $Xid = '';
 226         var $dontEncodeHeader = FALSE; // If set, the header will not be encoded
 227
 228         var $headers = '';
 229         var $message = '';
 230         var $part = 0;
 231         var $image_fullpath_list = '';
 232         var $href_fullpath_list = '';
 233
 234         var $plain_text_header = '';
 235         var $html_text_header = '';
 236         var $charset = '';
 237         var $defaultCharset = 'iso-8859-1';
 238
 239
 240         /**
 241          * Constructor. If the configuration variable forceReturnPath is set,
 242          * calls to mail will be called with a 5th parameter.
 243          * See function sendTheMail for more info
 244          *
 245          * @return      void
 246          */
 247         public function t3lib_htmlmail() {
 248                 $this->forceReturnPath = $GLOBALS['TYPO3_CONF_VARS']['SYS']['forceReturnPath'];
 249
 250                 $this->mailer = 'TYPO3';
 251         }
 252
 253
 254         /**
 255          * start action that sets the message ID and the charset
 256          *
 257          * @return      void
 258          */
 259         public function start() {
 260                 global $TYPO3_CONF_VARS;
 261
 262                         // Sets the message id
 263                 $host = t3lib_div::getHostname();
 264                 if (!$host || $host == '127.0.0.1' || $host == 'localhost' || $host == 'localhost.localdomain') {
 265                         $host = ($TYPO3_CONF_VARS['SYS']['sitename'] ? preg_replace('/[^A-Za-z0-9_\-]/', '_', $TYPO3_CONF_VARS['SYS']['sitename']) : 'localhost') . '.TYPO3';
 266                 }
 267                 $this->messageid = md5(microtime()) . '@' . $host;
 268
 269
 270                         // Default line break for Unix systems.
 271                 $this->linebreak = LF;
 272                         // Line break for Windows. This is needed because PHP on Windows systems
 273                         // send mails via SMTP instead of using sendmail, and thus the linebreak needs to be \r\n.
 274                 if (TYPO3_OS == 'WIN') {
 275                         $this->linebreak = CRLF;
 276                 }
 277
 278                         // Sets the Charset
 279                 if (!$this->charset) {
 280                         if (is_object($GLOBALS['TSFE']) && $GLOBALS['TSFE']->renderCharset) {
 281                                 $this->charset = $GLOBALS['TSFE']->renderCharset;
 282                         } elseif (is_object($GLOBALS['LANG']) && $GLOBALS['LANG']->charSet) {
 283                                 $this->charset = $GLOBALS['LANG']->charSet;
 284                         } elseif ($GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset']) {
 285                                 $this->charset = $GLOBALS['TYPO3_CONF_VARS']['BE']['forceCharset'];
 286                         } else {
 287                                 $this->charset = $this->defaultCharset;
 288                         }
 289                 }
 290
 291                         // Use quoted-printable headers by default
 292                 $this->useQuotedPrintable();
 293         }
 294
 295
 296         /**
 297          * sets the header of both Plain Text and HTML mails to quoted printable
 298          *
 299          * @return      void
 300          */
 301         public function useQuotedPrintable() {
 302                 $this->plain_text_header = 'Content-Type: text/plain; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: quoted-printable';
 303                 $this->html_text_header = 'Content-Type: text/html; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: quoted-printable';
 304         }
 305
 306         /**
 307          * sets the encoding headers to base64 for both the Plain Text and HTML mail
 308          *
 309          * @return      void
 310          */
 311         public function useBase64() {
 312                 $this->plain_text_header = 'Content-Type: text/plain; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: base64';
 313                 $this->html_text_header = 'Content-Type: text/html; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: base64';
 314                 $this->alt_base64 = 1;
 315         }
 316
 317
 318         /**
 319          * sets the encoding to 8bit and the current charset of both the Plain Text and the HTML mail
 320          *
 321          * @return      void
 322          */
 323         public function use8Bit() {
 324                 $this->plain_text_header = 'Content-Type: text/plain; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: 8bit';
 325                 $this->html_text_header = 'Content-Type: text/html; charset=' . $this->charset . $this->linebreak . 'Content-Transfer-Encoding: 8bit';
 326                 $this->alt_8bit = 1;
 327         }
 328
 329
 330         /**
 331          * Encodes the message content according to the options "alt_base64" and "alt_8bit" (no need to encode here)
 332          * or to "quoted_printable" if no option is set.
 333          *
 334          * @param       string          $content the content that will be encoded
 335          * @return      string          the encoded content
 336          */
 337         public function encodeMsg($content) {
 338                 if ($this->alt_base64) {
 339                         return $this->makeBase64($content);
 340                 } elseif ($this->alt_8bit) {
 341                         return $content;
 342                 } else {
 343                         return t3lib_div::quoted_printable($content);
 344                 }
 345         }
 346
 347
 348         /**
 349          * Adds plain-text, replaces the HTTP urls in the plain text and then encodes it
 350          *
 351          * @param       string          $content that will be added
 352          * @return      void
 353          */
 354         public function addPlain($content) {
 355                 $content = $this->substHTTPurlsInPlainText($content);
 356                 $this->setPlain($this->encodeMsg($content));
 357         }
 358
 359
 360         /**
 361          * Adds an attachment to the mail
 362          *
 363          * @param       string          $file: the filename to add
 364          * @return      boolean         whether the attachment was added or not
 365          */
 366         public function addAttachment($file) {
 367                         // Fetching the content and the mime-type
 368                 $fileInfo = $this->getExtendedURL($file);
 369                 if ($fileInfo) {
 370                         if (!$fileInfo['content_type']) {
 371                                 $fileInfo['content_type'] = 'application/octet-stream';
 372                         }
 373                         $temp = $this->split_fileref($file);
 374                         if ($temp['file']) {
 375                                 $fileInfo['filename'] = $temp['file'];
 376                         } elseif (strpos(' ' . $fileInfo['content_type'], 'htm')) {
 377                                 $fileInfo['filename'] = 'index.html';
 378                         } else {
 379                                 $fileInfo['filename'] = 'unknown';
 380                         }
 381                         $this->theParts['attach'][] = $fileInfo;
 382                         return TRUE;
 383                 }
 384                 return FALSE;
 385         }
 386
 387
 388         /**
 389          * Adds HTML and media, encodes it from a URL or file
 390          *
 391          * @param       string          $file: the filename to add
 392          * @return      boolean         whether the attachment was added or not
 393          */
 394         public function addHTML($file) {
 395                 $status = $this->fetchHTML($file);
 396                 if (!$status) {
 397                         return FALSE;
 398                 }
 399                 if ($this->extractFramesInfo()) {
 400                         return 'Document was a frameset. Stopped';
 401                 }
 402                 $this->extractMediaLinks();
 403                 $this->extractHyperLinks();
 404                 $this->fetchHTMLMedia();
 405                 $this->substMediaNamesInHTML(0); // 0 = relative
 406                 $this->substHREFsInHTML();
 407                 $this->setHtml($this->encodeMsg($this->theParts['html']['content']));
 408         }
 409
 410
 411         /**
 412          * Extract HTML-parts, used externally
 413          *
 414          * @param       string          $html: will be added to the html "content" part
 415          * @param       string          $url: will be added to the html "path" part
 416          * @return      void
 417          */
 418         public function extractHtmlInit($html, $url) {
 419                 $this->theParts['html']['content'] = $html;
 420                 $this->theParts['html']['path'] = $url;
 421         }
 422
 423
 424         /**
 425          * Assembles the message by headers and content and finally send it to the provided recipient.
 426          *
 427          * @param       string          $recipient: The recipient the message should be delivered to (if blank, $this->recipient will be used instead)
 428          * @return      boolean         Returns whether the mail was sent (successfully accepted for delivery)
 429          */
 430         public function send($recipient) {
 431                 if ($recipient) {
 432                         $this->recipient = $recipient;
 433                 }
 434                 $this->setHeaders();
 435                 $this->setContent();
 436                 $mailWasSent = $this->sendTheMail();
 437                 return $mailWasSent;
 438         }
 439
 440
 441         /*****************************************
 442          *
 443          * Main functions
 444          *
 445          *****************************************/
 446
 447         /**
 448          * Clears the header-string and sets the headers based on object-vars.
 449          *
 450          * @return      void
 451          */
 452         public function setHeaders() {
 453                 $this->headers = '';
 454                         // Message_id
 455                 $this->add_header('Message-ID: <' . $this->messageid . '>');
 456                         // Return path
 457                 if ($this->returnPath) {
 458                         $this->add_header('Return-Path: ' . $this->returnPath);
 459                         $this->add_header('Errors-To: ' . $this->returnPath);
 460                 }
 461                         // X-id
 462                 if ($this->Xid) {
 463                         $this->add_header('X-Typo3MID: ' . $this->Xid);
 464                 }
 465
 466                         // From
 467                 if ($this->from_email) {
 468                         if ($this->from_name && !t3lib_div::isBrokenEmailEnvironment()) {
 469                                 $this->add_header('From: ' . $this->from_name . ' <' . $this->from_email . '>');
 470                         } else {
 471                                 $this->add_header('From: ' . $this->from_email);
 472                         }
 473                 }
 474
 475                         // Cc
 476                 if ($this->recipient_copy) {
 477                         $this->add_header('Cc: ' . $this->recipient_copy);
 478                 }
 479
 480                         // Bcc
 481                 if ($this->recipient_blindcopy) {
 482                         $this->add_header('Bcc: ' . $this->recipient_blindcopy);
 483                 }
 484
 485                         // Reply
 486                 if ($this->replyto_email) {
 487                         if ($this->replyto_name) {
 488                                 $this->add_header('Reply-To: ' . $this->replyto_name . ' <' . $this->replyto_email . '>');
 489                         } else {
 490                                 $this->add_header('Reply-To: ' . $this->replyto_email);
 491                         }
 492                 }
 493                         // Organization, using american english spelling (organization / organisation) as defined in RFC 1036 / 2076
 494                 if ($this->organisation) {
 495                         $this->add_header('Organization: ' . $this->organisation);
 496                 }
 497                         // mailer
 498                 if ($this->mailer) {
 499                         $this->add_header('X-Mailer: ' . $this->mailer);
 500                 }
 501                         // priority
 502                 if ($this->priority) {
 503                         $this->add_header('X-Priority: ' . $this->priority);
 504                 }
 505                 $this->add_header('Mime-Version: 1.0');
 506
 507                 if (!$this->dontEncodeHeader) {
 508                         $enc = $this->alt_base64 ? 'base64' : 'quoted_printable'; // Header must be ASCII, therefore only base64 or quoted_printable are allowed!
 509                                 // Quote recipient and subject
 510                         $this->recipient = t3lib_div::encodeHeader($this->recipient, $enc, $this->charset);
 511                         $this->subject = t3lib_div::encodeHeader($this->subject, $enc, $this->charset);
 512                 }
 513         }
 514
 515
 516         /**
 517          * Sets the recipient(s). If you supply a string, you set one recipient.
 518          * If you supply an array, every value is added as a recipient.
 519          *
 520          * @param       mixed           $recipient: the recipient(s) to set
 521          * @return      void
 522          */
 523         public function setRecipient($recipient) {
 524                 $this->recipient = (is_array($recipient) ? implode(',', $recipient) : $recipient);
 525         }
 526
 527
 528         /**
 529          * Returns the content type based on whether the mail has media / attachments or no
 530          *
 531          * @return      string          the content type
 532          */
 533         public function getHTMLContentType() {
 534                 return (count($this->theParts['html']['media']) ? 'multipart/related' : 'multipart/alternative');
 535         }
 536
 537
 538         /**
 539          * Begins building the message-body
 540          *
 541          * @return      void
 542          */
 543         public function setContent() {
 544                 $this->message = '';
 545                 $boundary = $this->getBoundary();
 546
 547                         // Setting up headers
 548                 if (count($this->theParts['attach'])) {
 549                                 // Generate (plain/HTML) / attachments
 550                         $this->add_header('Content-Type: multipart/mixed;');
 551                         $this->add_header(' boundary="' . $boundary . '"');
 552                         $this->add_message('This is a multi-part message in MIME format.' . LF);
 553                         $this->constructMixed($boundary);
 554                 } elseif ($this->theParts['html']['content']) {
 555                                 // Generate plain/HTML mail
 556                         $this->add_header('Content-Type: ' . $this->getHTMLContentType() . ';');
 557                         $this->add_header(' boundary="' . $boundary . '"');
 558                         $this->add_message('This is a multi-part message in MIME format.' . LF);
 559                         $this->constructHTML($boundary);
 560                 } else {
 561                                 // Generate plain only
 562                         $this->add_header($this->plain_text_header);
 563                         $this->add_message($this->getContent('plain'));
 564                 }
 565         }
 566
 567
 568         /**
 569          * This functions combines the plain / HTML content with the attachments
 570          *
 571          * @param       string          $boundary: the mail boundary
 572          * @return      void
 573          */
 574         public function constructMixed($boundary) {
 575                 $this->add_message('--' . $boundary);
 576
 577                 if ($this->theParts['html']['content']) {
 578                                 // HTML and plain is added
 579                         $newBoundary = $this->getBoundary();
 580                         $this->add_message('Content-Type: ' . $this->getHTMLContentType() . ';');
 581                         $this->add_message(' boundary="' . $newBoundary . '"');
 582                         $this->add_message('');
 583                         $this->constructHTML($newBoundary);
 584                 } else {
 585                                 // Purely plain
 586                         $this->add_message($this->plain_text_header);
 587                         $this->add_message('');
 588                         $this->add_message($this->getContent('plain'));
 589                 }
 590                         // attachments are added
 591                 if (is_array($this->theParts['attach'])) {
 592                         foreach ($this->theParts['attach'] as $media) {
 593                                 $this->add_message('--' . $boundary);
 594                                 $this->add_message('Content-Type: ' . $media['content_type'] . ';');
 595                                 $this->add_message(' name="' . $media['filename'] . '"');
 596                                 $this->add_message('Content-Transfer-Encoding: base64');
 597                                 $this->add_message('Content-Disposition: attachment;');
 598                                 $this->add_message(' filename="' . $media['filename'] . '"');
 599                                 $this->add_message('');
 600                                 $this->add_message($this->makeBase64($media['content']));
 601                         }
 602                 }
 603                 $this->add_message('--' . $boundary . '--' . LF);
 604         }
 605
 606
 607         /**
 608          * this function creates the HTML part of the mail
 609          *
 610          * @param       string          $boundary: the boundary to use
 611          * @return      void
 612          */
 613         public function constructHTML($boundary) {
 614                         // If media, then we know, the multipart/related content-type has been set before this function call
 615                 if (count($this->theParts['html']['media'])) {
 616                         $this->add_message('--' . $boundary);
 617                                 // HTML has media
 618                         $newBoundary = $this->getBoundary();
 619                         $this->add_message('Content-Type: multipart/alternative;');
 620                         $this->add_message(' boundary="' . $newBoundary . '"');
 621                         $this->add_message('Content-Transfer-Encoding: 7bit');
 622                         $this->add_message('');
 623
 624                                 // Adding the plaintext/html mix, and use $newBoundary
 625                         $this->constructAlternative($newBoundary);
 626                         $this->constructHTML_media($boundary);
 627                 } else {
 628                                 // if no media, just use the $boundary for adding plaintext/html mix
 629                         $this->constructAlternative($boundary);
 630                 }
 631         }
 632
 633
 634         /**
 635          * Here plain is combined with HTML
 636          *
 637          * @param       string          $boundary: the boundary to use
 638          * @return      void
 639          */
 640         public function constructAlternative($boundary) {
 641                 $this->add_message('--' . $boundary);
 642
 643                         // plain is added
 644                 $this->add_message($this->plain_text_header);
 645                 $this->add_message('');
 646                 $this->add_message($this->getContent('plain'));
 647                 $this->add_message('--' . $boundary);
 648
 649                         // html is added
 650                 $this->add_message($this->html_text_header);
 651                 $this->add_message('');
 652                 $this->add_message($this->getContent('html'));
 653                 $this->add_message('--' . $boundary . '--' . LF);
 654         }
 655
 656
 657         /**
 658          * Constructs the HTML-part of message if the HTML contains media
 659          *
 660          * @param       string          $boundary: the boundary to use
 661          * @return      void
 662          */
 663         public function constructHTML_media($boundary) {
 664                         // media is added
 665                 if (is_array($this->theParts['html']['media'])) {
 666                         foreach ($this->theParts['html']['media'] as $key => $media) {
 667                                 if (!$this->mediaList || t3lib_div::inList($this->mediaList, $key)) {
 668                                         $this->add_message('--' . $boundary);
 669                                         $this->add_message('Content-Type: ' . $media['ctype']);
 670                                         $this->add_message('Content-ID: <part' . $key . '.' . $this->messageid . '>');
 671                                         $this->add_message('Content-Transfer-Encoding: base64');
 672                                         $this->add_message('');
 673                                         $this->add_message($this->makeBase64($media['content']));
 674                                 }
 675                         }
 676                 }
 677                 $this->add_message('--' . $boundary . '--' . LF);
 678         }
 679
 680
 681         /**
 682          * Sends the mail by calling the mail() function in php. On Linux systems this will invoke the MTA
 683          * defined in php.ini (sendmail -t -i by default), on Windows a SMTP must be specified in the sys.ini.
 684          * Most common MTA's on Linux has a Sendmail interface, including Postfix and Exim.
 685          * For setting the return-path correctly, the parameter -f has to be added to the system call to sendmail.
 686          * This obviously does not have any effect on Windows, but on Sendmail compliant systems this works. If safe mode
 687          * is enabled, then extra parameters is not allowed, so a safe mode check is made before the mail() command is
 688          * invoked. When using the -f parameter, some MTA's will put an X-AUTHENTICATION-WARNING saying that
 689          * the return path was modified manually with the -f flag. To disable this warning make sure that the user running
 690          * Apache is in the /etc/mail/trusted-users table.
 691          *
 692          * POSTFIX: With postfix version below 2.0 there is a problem that the -f parameter can not be used in conjunction
 693          * with -t. Postfix will give an error in the maillog:
 694          *
 695          *  cannot handle command-line recipients with -t
 696          *
 697          * The -f parameter is only enabled if the parameter forceReturnPath is enabled in the install tool.
 698          *
 699          * This whole problem of return-path turns out to be quite tricky. If you have a solution that works better, on all
 700          * standard MTA's then we are very open for suggestions.
 701          *
 702          * With time this function should be made such that several ways of sending the mail is possible (local MTA, smtp other).
 703          *
 704          * @return      boolean         Returns whether the mail was sent (successfully accepted for delivery)
 705          */
 706         public function sendTheMail() {
 707                 $mailWasSent = FALSE;
 708
 709                         // Sending the mail requires the recipient and message to be set.
 710                 if (!trim($this->recipient) || !trim($this->message)) {
 711                         return FALSE;
 712                 }
 713
 714                         // On windows the -f flag is not used (specific for Sendmail and Postfix),
 715                         // but instead the php.ini parameter sendmail_from is used.
 716                 $returnPath = ($this->forceReturnPath && strlen($this->returnPath) > 0) ? '-f ' . escapeshellarg($this->returnPath) : '';
 717                 if (TYPO3_OS == 'WIN' && $this->returnPath) {
 718                         @ini_set('sendmail_from', t3lib_div::normalizeMailAddress($this->returnPath));
 719                 }
 720                 $recipient = t3lib_div::normalizeMailAddress($this->recipient);
 721
 722                         // If safe mode is on, the fifth parameter to mail is not allowed, so the fix wont work on unix with safe_mode=On
 723                 $returnPathPossible = (!t3lib_utility_PhpOptions::isSafeModeEnabled() && $this->forceReturnPath);
 724                 if ($returnPathPossible) {
 725                         $mailWasSent = t3lib_utility_Mail::mail($recipient,
 726                                                                                                         $this->subject,
 727                                                                                                         $this->message,
 728                                                                                                         $this->headers,
 729                                                                                                         $returnPath);
 730                 } else {
 731                         $mailWasSent = t3lib_utility_Mail::mail($recipient,
 732                                                                                                         $this->subject,
 733                                                                                                         $this->message,
 734                                                                                                         $this->headers);
 735                 }
 736
 737                         // Auto response
 738                 if ($this->auto_respond_msg) {
 739                         $theParts = explode('/', $this->auto_respond_msg, 2);
 740                         $theParts[0] = str_replace('###SUBJECT###', $this->subject, $theParts[0]);
 741                         $theParts[1] = str_replace("/", LF, $theParts[1]);
 742                         $theParts[1] = str_replace("###MESSAGE###", $this->getContent('plain'), $theParts[1]);
 743                         if ($returnPathPossible) {
 744                                 $mailWasSent = t3lib_utility_Mail::mail($this->from_email,
 745                                                                                                                 $theParts[0],
 746                                                                                                                 $theParts[1],
 747                                                                                                                 'From: ' . $recipient,
 748                                                                                                                 $returnPath);
 749                         } else {
 750                                 $mailWasSent = t3lib_utility_Mail::mail($this->from_email,
 751                                                                                                                 $theParts[0],
 752                                                                                                                 $theParts[1],
 753                                                                                                                 'From: ' . $recipient);
 754                         }
 755                 }
 756                 if ($this->returnPath) {
 757                         ini_restore('sendmail_from');
 758                 }
 759                 return $mailWasSent;
 760         }
 761
 762
 763         /**
 764          * Returns boundaries
 765          *
 766          * @return      string  the boundary
 767          */
 768         public function getBoundary() {
 769                 $this->part++;
 770                 return "----------" . uniqid("part_" . $this->part . "_");
 771         }
 772
 773
 774         /**
 775          * Sets the plain-text part. No processing done.
 776          *
 777          * @param       string          $content: the plain content
 778          * @return      void
 779          */
 780         public function setPlain($content) {
 781                 $this->theParts['plain']['content'] = $content;
 782         }
 783
 784
 785         /**
 786          * Sets the HTML-part. No processing done.
 787          *
 788          * @param       string          $content: the HTML content
 789          * @return      void
 790          */
 791         public function setHtml($content) {
 792                 $this->theParts['html']['content'] = $content;
 793         }
 794
 795
 796         /**
 797          * Adds a header to the mail. Use this AFTER the setHeaders()-function
 798          *
 799          * @param       string          $header: the header in form of "key: value"
 800          * @return      void
 801          */
 802         public function add_header($header) {
 803                         // Mail headers must be ASCII, therefore we convert the whole header to either base64 or quoted_printable
 804                 if (!$this->dontEncodeHeader && !stristr($header, 'Content-Type') && !stristr($header, 'Content-Transfer-Encoding')) {
 805                                 // Field tags must not be encoded
 806                         $parts = explode(': ', $header, 2);
 807                         if (count($parts) == 2) {
 808                                 $enc = $this->alt_base64 ? 'base64' : 'quoted_printable';
 809                                 $parts[1] = t3lib_div::encodeHeader($parts[1], $enc, $this->charset);
 810                                 $header = implode(': ', $parts);
 811                         }
 812                 }
 813
 814                 $this->headers .= $header . LF;
 815         }
 816
 817
 818         /**
 819          * Adds a line of text to the mail-body. Is normally used internally
 820          *
 821          * @param       string          $msg: the message to add
 822          * @return      void
 823          */
 824         public function add_message($msg) {
 825                 $this->message .= $msg . LF;
 826         }
 827
 828
 829         /**
 830          * returns the content specified by the type (plain, html etc.)
 831          *
 832          * @param       string          $type: the content type, can either plain or html
 833          * @return      void
 834          */
 835         public function getContent($type) {
 836                 return $this->theParts[$type]['content'];
 837         }
 838
 839
 840         /**
 841          * shows a preview of the email of the headers and the message
 842          *
 843          * @return      void
 844          */
 845         public function preview() {
 846                 echo nl2br(htmlspecialchars($this->headers));
 847                 echo "<BR>";
 848                 echo nl2br(htmlspecialchars($this->message));
 849         }
 850
 851
 852         /****************************************************
 853          *
 854          * Functions for acquiring attachments, HTML, analyzing and so on  **
 855          *
 856          ***************************************************/
 857
 858         /**
 859          * Fetches the HTML-content from either url og local serverfile
 860          *
 861          * @param       string          $file: the file to load
 862          * @return      boolean         whether the data was fetched or not
 863          */
 864         public function fetchHTML($file) {
 865                         // Fetches the content of the page
 866                 $this->theParts['html']['content'] = $this->getURL($file);
 867                 if ($this->theParts['html']['content']) {
 868                         $addr = $this->extParseUrl($file);
 869                         $path = ($addr['scheme']) ? $addr['scheme'] . '://' . $addr['host'] . (($addr['port']) ? ':' . $addr['port'] : '') . (($addr['filepath']) ? $addr['filepath'] : '/') : $addr['filepath'];
 870                         $this->theParts['html']['path'] = $path;
 871                         return TRUE;
 872                 } else {
 873                         return FALSE;
 874                 }
 875         }
 876
 877
 878         /**
 879          * Fetches the mediafiles which are found by extractMediaLinks()
 880          *
 881          * @return      void
 882          */
 883         public function fetchHTMLMedia() {
 884                 if (!is_array($this->theParts['html']['media']) || !count($this->theParts['html']['media'])) {
 885                         return;
 886                 }
 887                 foreach ($this->theParts['html']['media'] as $key => $media) {
 888                                 // fetching the content and the mime-type
 889                         $picdata = $this->getExtendedURL($this->theParts['html']['media'][$key]['absRef']);
 890                         if (is_array($picdata)) {
 891                                 $this->theParts['html']['media'][$key]['content'] = $picdata['content'];
 892                                 $this->theParts['html']['media'][$key]['ctype'] = $picdata['content_type'];
 893                         }
 894                 }
 895         }
 896
 897
 898         /**
 899          * extracts all media-links from $this->theParts['html']['content']
 900          *
 901          * @return      void
 902          */
 903         public function extractMediaLinks() {
 904                 $html_code = $this->theParts['html']['content'];
 905                 $attribRegex = $this->tag_regex(array('img', 'table', 'td', 'tr', 'body', 'iframe', 'script', 'input', 'embed'));
 906
 907                         // split the document by the beginning of the above tags
 908                 $codepieces = preg_split($attribRegex, $html_code);
 909                 $len = strlen($codepieces[0]);
 910                 $pieces = count($codepieces);
 911                 $reg = array();
 912                 for ($i = 1; $i < $pieces; $i++) {
 913                         $tag = strtolower(strtok(substr($html_code, $len + 1, 10), ' '));
 914                         $len += strlen($tag) + strlen($codepieces[$i]) + 2;
 915                         $dummy = preg_match('/[^>]*/', $codepieces[$i], $reg);
 916                         $attributes = $this->get_tag_attributes($reg[0]); // Fetches the attributes for the tag
 917                         $imageData = array();
 918
 919                                 // Finds the src or background attribute
 920                         $imageData['ref'] = ($attributes['src'] ? $attributes['src'] : $attributes['background']);
 921                         if ($imageData['ref']) {
 922                                         // find out if the value had quotes around it
 923                                 $imageData['quotes'] = (substr($codepieces[$i], strpos($codepieces[$i], $imageData['ref']) - 1, 1) == '"') ? '"' : '';
 924                                         // subst_str is the string to look for, when substituting lateron
 925                                 $imageData['subst_str'] = $imageData['quotes'] . $imageData['ref'] . $imageData['quotes'];
 926                                 if ($imageData['ref'] && !strstr($this->image_fullpath_list, "|" . $imageData["subst_str"] . "|")) {
 927                                         $this->image_fullpath_list .= "|" . $imageData['subst_str'] . "|";
 928                                         $imageData['absRef'] = $this->absRef($imageData['ref']);
 929                                         $imageData['tag'] = $tag;
 930                                         $imageData['use_jumpurl'] = $attributes['dmailerping'] ? 1 : 0;
 931                                         $this->theParts['html']['media'][] = $imageData;
 932                                 }
 933                         }
 934                 }
 935
 936                         // Extracting stylesheets
 937                 $attribRegex = $this->tag_regex(array('link'));
 938                         // Split the document by the beginning of the above tags
 939                 $codepieces = preg_split($attribRegex, $html_code);
 940                 $pieces = count($codepieces);
 941                 for ($i = 1; $i < $pieces; $i++) {
 942                         $dummy = preg_match('/[^>]*/', $codepieces[$i], $reg);
 943                                 // fetches the attributes for the tag
 944                         $attributes = $this->get_tag_attributes($reg[0]);
 945                         $imageData = array();
 946                         if (strtolower($attributes['rel']) == 'stylesheet' && $attributes['href']) {
 947                                         // Finds the src or background attribute
 948                                 $imageData['ref'] = $attributes['href'];
 949                                         // Finds out if the value had quotes around it
 950                                 $imageData['quotes'] = (substr($codepieces[$i], strpos($codepieces[$i], $imageData['ref']) - 1, 1) == '"') ? '"' : '';
 951                                         // subst_str is the string to look for, when substituting lateron
 952                                 $imageData['subst_str'] = $imageData['quotes'] . $imageData['ref'] . $imageData['quotes'];
 953                                 if ($imageData['ref'] && !strstr($this->image_fullpath_list, "|" . $imageData["subst_str"] . "|")) {
 954                                         $this->image_fullpath_list .= "|" . $imageData["subst_str"] . "|";
 955                                         $imageData['absRef'] = $this->absRef($imageData["ref"]);
 956                                         $this->theParts['html']['media'][] = $imageData;
 957                                 }
 958                         }
 959                 }
 960
 961                         // fixes javascript rollovers
 962                 $codepieces = explode('.src', $html_code);
 963                 $pieces = count($codepieces);
 964                 $expr = '/^[^' . quotemeta('"') . quotemeta("'") . ']*/';
 965                 for ($i = 1; $i < $pieces; $i++) {
 966                         $temp = $codepieces[$i];
 967                         $temp = trim(str_replace('=', '', trim($temp)));
 968                         preg_match($expr, substr($temp, 1, strlen($temp)), $reg);
 969                         $imageData['ref'] = $reg[0];
 970                         $imageData['quotes'] = substr($temp, 0, 1);
 971                                 // subst_str is the string to look for, when substituting lateron
 972                         $imageData['subst_str'] = $imageData['quotes'] . $imageData['ref'] . $imageData['quotes'];
 973                         $theInfo = $this->split_fileref($imageData['ref']);
 974
 975                         switch ($theInfo['fileext']) {
 976                                 case 'gif':
 977                                 case 'jpeg':
 978                                 case 'jpg':
 979                                         if ($imageData['ref'] && !strstr($this->image_fullpath_list, "|" . $imageData["subst_str"] . "|")) {
 980                                                 $this->image_fullpath_list .= "|" . $imageData['subst_str'] . "|";
 981                                                 $imageData['absRef'] = $this->absRef($imageData['ref']);
 982                                                 $this->theParts['html']['media'][] = $imageData;
 983                                         }
 984                                         break;
 985                         }
 986                 }
 987         }
 988
 989
 990         /**
 991          * extracts all hyper-links from $this->theParts["html"]["content"]
 992          *
 993          * @return      void
 994          */
 995         public function extractHyperLinks() {
 996                 $html_code = $this->theParts['html']['content'];
 997                 $attribRegex = $this->tag_regex(array('a', 'form', 'area'));
 998                 $codepieces = preg_split($attribRegex, $html_code); // Splits the document by the beginning of the above tags
 999                 $len = strlen($codepieces[0]);
1000                 $pieces = count($codepieces);
1001                 for ($i = 1; $i < $pieces; $i++) {
1002                         $tag = strtolower(strtok(substr($html_code, $len + 1, 10), " "));
1003                         $len += strlen($tag) + strlen($codepieces[$i]) + 2;
1004
1005                         $dummy = preg_match('/[^>]*/', $codepieces[$i], $reg);
1006                                 // Fetches the attributes for the tag
1007                         $attributes = $this->get_tag_attributes($reg[0]);
1008                         $hrefData = array();
1009                         $hrefData['ref'] = ($attributes['href'] ? $attributes['href'] : $hrefData['ref'] = $attributes['action']);
1010                         if ($hrefData['ref']) {
1011                                         // Finds out if the value had quotes around it
1012                                 $hrefData['quotes'] = (substr($codepieces[$i], strpos($codepieces[$i], $hrefData["ref"]) - 1, 1) == '"') ? '"' : '';
1013                                         // subst_str is the string to look for, when substituting lateron
1014                                 $hrefData['subst_str'] = $hrefData['quotes'] . $hrefData['ref'] . $hrefData['quotes'];
1015                                 if ($hrefData['ref'] && substr(trim($hrefData['ref']), 0, 1) != "#" && !strstr($this->href_fullpath_list, "|" . $hrefData['subst_str'] . "|")) {
1016                                         $this->href_fullpath_list .= "|" . $hrefData['subst_str'] . "|";
1017                                         $hrefData['absRef'] = $this->absRef($hrefData['ref']);
1018                                         $hrefData['tag'] = $tag;
1019                                         $this->theParts['html']['hrefs'][] = $hrefData;
1020                                 }
1021                         }
1022                 }
1023                         // Extracts TYPO3 specific links made by the openPic() JS function
1024                 $codepieces = explode("onClick=\"openPic('", $html_code);
1025                 $pieces = count($codepieces);
1026                 for ($i = 1; $i < $pieces; $i++) {
1027                         $showpic_linkArr = explode("'", $codepieces[$i]);
1028                         $hrefData['ref'] = $showpic_linkArr[0];
1029                         if ($hrefData['ref']) {
1030                                 $hrefData['quotes'] = "'";
1031                                         // subst_str is the string to look for, when substituting lateron
1032                                 $hrefData['subst_str'] = $hrefData['quotes'] . $hrefData['ref'] . $hrefData['quotes'];
1033                                 if ($hrefData['ref'] && !strstr($this->href_fullpath_list, "|" . $hrefData['subst_str'] . "|")) {
1034                                         $this->href_fullpath_list .= "|" . $hrefData['subst_str'] . "|";
1035                                         $hrefData['absRef'] = $this->absRef($hrefData['ref']);
1036                                         $this->theParts['html']['hrefs'][] = $hrefData;
1037                                 }
1038                         }
1039                 }
1040         }
1041
1042
1043         /**
1044          * extracts all media-links from $this->theParts["html"]["content"]
1045          *
1046          * @return      array   two-dimensional array with information about each frame
1047          */
1048         public function extractFramesInfo() {
1049                 $htmlCode = $this->theParts['html']['content'];
1050                 $info = array();
1051                 if (strpos(' ' . $htmlCode, '<frame ')) {
1052                         $attribRegex = $this->tag_regex('frame');
1053                                 // Splits the document by the beginning of the above tags
1054                         $codepieces = preg_split($attribRegex, $htmlCode, 1000000);
1055                         $pieces = count($codepieces);
1056                         for ($i = 1; $i < $pieces; $i++) {
1057                                 $dummy = preg_match('/[^>]*/', $codepieces[$i], $reg);
1058                                         // Fetches the attributes for the tag
1059                                 $attributes = $this->get_tag_attributes($reg[0]);
1060                                 $frame = array();
1061                                 $frame['src'] = $attributes['src'];
1062                                 $frame['name'] = $attributes['name'];
1063                                 $frame['absRef'] = $this->absRef($frame['src']);
1064                                 $info[] = $frame;
1065                         }
1066                         return $info;
1067                 }
1068         }
1069
1070
1071         /**
1072          * This function substitutes the media-references in $this->theParts["html"]["content"]
1073          *
1074          * @param       boolean         $absolute: If true, then the refs are substituted with http:// ref's indstead of Content-ID's (cid).
1075          * @return      void
1076          */
1077         public function substMediaNamesInHTML($absolute) {
1078                 if (is_array($this->theParts['html']['media'])) {
1079                         foreach ($this->theParts['html']['media'] as $key => $val) {
1080                                 if ($val['use_jumpurl'] && $this->jumperURL_prefix) {
1081                                         $subst = $this->jumperURL_prefix . t3lib_div::rawUrlEncodeFP($val['absRef']);
1082                                 } else {
1083                                         $subst = ($absolute) ? $val['absRef'] : 'cid:part' . $key . '.' . $this->messageid;
1084                                 }
1085                                 $this->theParts['html']['content'] = str_replace(
1086                                         $val['subst_str'],
1087                                         $val['quotes'] . $subst . $val['quotes'],
1088                                         $this->theParts['html']['content']);
1089                         }
1090                 }
1091                 if (!$absolute) {
1092                         $this->fixRollOvers();
1093                 }
1094         }
1095
1096
1097         /**
1098          * This function substitutes the hrefs in $this->theParts["html"]["content"]
1099          *
1100          * @return      void
1101          */
1102         public function substHREFsInHTML() {
1103                 if (!is_array($this->theParts['html']['hrefs'])) {
1104                         return;
1105                 }
1106                 foreach ($this->theParts['html']['hrefs'] as $key => $val) {
1107                                 // Form elements cannot use jumpurl!
1108                         if ($this->jumperURL_prefix && $val['tag'] != 'form') {
1109                                 if ($this->jumperURL_useId) {
1110                                         $substVal = $this->jumperURL_prefix . $key;
1111                                 } else {
1112                                         $substVal = $this->jumperURL_prefix . t3lib_div::rawUrlEncodeFP($val['absRef']);
1113                                 }
1114                         } else {
1115                                 $substVal = $val['absRef'];
1116                         }
1117                         $this->theParts['html']['content'] = str_replace(
1118                                 $val['subst_str'],
1119                                 $val['quotes'] . $substVal . $val['quotes'],
1120                                 $this->theParts['html']['content']);
1121                 }
1122         }
1123
1124
1125         /**
1126          *  This substitutes the http:// urls in plain text with links
1127          *
1128          * @param       string          $content: the content to use to substitute
1129          * @return      string          the changed content
1130          */
1131         public function substHTTPurlsInPlainText($content) {
1132                 if (!$this->jumperURL_prefix) {
1133                         return $content;
1134                 }
1135
1136                 $textpieces = explode("http://", $content);
1137                 $pieces = count($textpieces);
1138                 $textstr = $textpieces[0];
1139                 for ($i = 1; $i < $pieces; $i++) {
1140                         $len = strcspn($textpieces[$i], chr(32) . TAB . CRLF);
1141                         if (trim(substr($textstr, -1)) == '' && $len) {
1142                                 $lastChar = substr($textpieces[$i], $len - 1, 1);
1143                                 if (!preg_match('/[A-Za-z0-9\/#]/', $lastChar)) {
1144                                         $len--;
1145                                 }
1146
1147                                 $parts = array();
1148                                 $parts[0] = "http://" . substr($textpieces[$i], 0, $len);
1149                                 $parts[1] = substr($textpieces[$i], $len);
1150
1151                                 if ($this->jumperURL_useId) {
1152                                         $this->theParts['plain']['link_ids'][$i] = $parts[0];
1153                                         $parts[0] = $this->jumperURL_prefix . '-' . $i;
1154                                 } else {
1155                                         $parts[0] = $this->jumperURL_prefix . t3lib_div::rawUrlEncodeFP($parts[0]);
1156                                 }
1157                                 $textstr .= $parts[0] . $parts[1];
1158                         } else {
1159                                 $textstr .= 'http://' . $textpieces[$i];
1160                         }
1161                 }
1162                 return $textstr;
1163         }
1164
1165
1166         /**
1167          * JavaScript rollOvers cannot support graphics inside of mail.
1168          * If these exists we must let them refer to the absolute url. By the way:
1169          * Roll-overs seems to work only on some mail-readers and so far I've seen it
1170          * work on Netscape 4 message-center (but not 4.5!!)
1171          *
1172          * @return      void
1173          */
1174         public function fixRollOvers() {
1175                 $newContent = '';
1176                 $items = explode('.src', $this->theParts['html']['content']);
1177                 if (count($items) <= 1) {
1178                         return;
1179                 }
1180
1181                 foreach ($items as $key => $part) {
1182                         $sub = substr($part, 0, 200);
1183                         if (preg_match('/cid:part[^ "\']*/', $sub, $reg)) {
1184                                         // The position of the string
1185                                 $thePos = strpos($part, $reg[0]);
1186                                         // Finds the id of the media...
1187                                 preg_match('/cid:part([^\.]*).*/', $sub, $reg2);
1188                                 $theSubStr = $this->theParts['html']['media'][intval($reg2[1])]['absRef'];
1189                                 if ($thePos && $theSubStr) {
1190                                                 // ... and substitutes the javaScript rollover image with this instead
1191                                                 // If the path is NOT and url, the reference is set to nothing
1192                                         if (!strpos(' ' . $theSubStr, 'http://')) {
1193                                                 $theSubStr = 'http://';
1194                                         }
1195                                         $part = substr($part, 0, $thePos) . $theSubStr . substr($part, $thePos + strlen($reg[0]), strlen($part));
1196                                 }
1197                         }
1198                         $newContent .= $part . ((($key + 1) != count($items)) ? '.src' : '');
1199                 }
1200                 $this->theParts['html']['content'] = $newContent;
1201         }
1202
1203
1204         /*******************************************
1205          *
1206          * File and URL-functions
1207          *
1208          *******************************************/
1209
1210         /**
1211          * Returns base64-encoded content, which is broken every 76 character
1212          *
1213          * @param       string          $inputstr: the string to encode
1214          * @return      string          the encoded string
1215          */
1216         public function makeBase64($inputstr) {
1217                 return chunk_split(base64_encode($inputstr));
1218         }
1219
1220
1221         /**
1222          * reads the URL or file and determines the Content-type by either guessing or opening a connection to the host
1223          *
1224          * @param       string          $url: the URL to get information of
1225          * @return      mixed           either false or the array with information
1226          */
1227         public function getExtendedURL($url) {
1228                 $res = array();
1229                 $res['content'] = $this->getURL($url);
1230                 if (!$res['content']) {
1231                         return FALSE;
1232                 }
1233                 $pathInfo = parse_url($url);
1234                 $fileInfo = $this->split_fileref($pathInfo['path']);
1235                 switch ($fileInfo['fileext']) {
1236                         case 'gif':
1237                         case 'png':
1238                                 $res['content_type'] = 'image/' . $fileInfo['fileext'];
1239                                 break;
1240                         case 'jpg':
1241                         case 'jpeg':
1242                                 $res['content_type'] = 'image/jpeg';
1243                                 break;
1244                         case 'html':
1245                         case 'htm':
1246                                 $res['content_type'] = 'text/html';
1247                                 break;
1248                         case 'css':
1249                                 $res['content_type'] = 'text/css';
1250                                 break;
1251                         case 'swf':
1252                                 $res['content_type'] = 'application/x-shockwave-flash';
1253                                 break;
1254                         default:
1255                                 $res['content_type'] = $this->getMimeType($url);
1256                 }
1257                 return $res;
1258         }
1259
1260
1261         /**
1262          * Adds HTTP user and password (from $this->http_username) to a URL
1263          *
1264          * @param       string          $url: the URL
1265          * @return      string          the URL with the added values
1266          */
1267         public function addUserPass($url) {
1268                 $user = $this->http_username;
1269                 $pass = $this->http_password;
1270                 $matches = array();
1271                 if ($user && $pass && preg_match('/^(https?:\/\/)/', $url, $matches)) {
1272                         return $matches[1] . $user . ':' . $pass . '@' . substr($url, strlen($matches[1]));
1273                 }
1274                 return $url;
1275         }
1276
1277
1278         /**
1279          * reads a url or file
1280          *
1281          * @param       string          $url: the URL to fetch
1282          * @return      string          the content of the URL
1283          */
1284         public function getURL($url) {
1285                 $url = $this->addUserPass($url);
1286                 return t3lib_div::getURL($url);
1287         }
1288
1289
1290         /**
1291          * reads a url or file and strips the HTML-tags AND removes all
1292          * empty lines. This is used to read plain-text out of a HTML-page
1293          *
1294          * @param       string          $url: the URL to load
1295          * @return      the content
1296          */
1297         public function getStrippedURL($url) {
1298                 $content = '';
1299                 if ($fd = fopen($url, "rb")) {
1300                         while (!feof($fd)) {
1301                                 $line = fgetss($fd, 5000);
1302                                 if (trim($line)) {
1303                                         $content .= trim($line) . LF;
1304                                 }
1305                         }
1306                         fclose($fd);
1307                 }
1308                 return $content;
1309         }
1310
1311
1312         /**
1313          * This function returns the mime type of the file specified by the url
1314          *
1315          * @param       string          $url: the url
1316          * @return      string          $mimeType: the mime type found in the header
1317          */
1318         public function getMimeType($url) {
1319                 $mimeType = '';
1320                 $headers = trim(t3lib_div::getURL($url, 2));
1321                 if ($headers) {
1322                         $matches = array();
1323                         if (preg_match('/(Content-Type:[\s]*)([a-zA-Z_0-9\/\-\.\+]*)([\s]|$)/', $headers, $matches)) {
1324                                 $mimeType = trim($matches[2]);
1325                         }
1326                 }
1327                 return $mimeType;
1328         }
1329
1330
1331         /**
1332          * Returns the absolute address of a link. This is based on
1333          * $this->theParts["html"]["path"] being the root-address
1334          *
1335          * @param       string          $ref: address to use
1336          * @return      string          the absolute address
1337          */
1338         public function absRef($ref) {
1339                 $ref = trim($ref);
1340                 $info = parse_url($ref);
1341                 if ($info['scheme']) {
1342                         return $ref;
1343                 } elseif (preg_match('/^\//', $ref)) {
1344                         $addr = parse_url($this->theParts['html']['path']);
1345                         return $addr['scheme'] . '://' . $addr['host'] . ($addr['port'] ? ':' . $addr['port'] : '') . $ref;
1346                 } else {
1347                                 // If the reference is relative, the path is added, in order for us to fetch the content
1348                         return $this->theParts['html']['path'] . $ref;
1349                 }
1350         }
1351
1352
1353         /**
1354          * Returns information about a file reference
1355          *
1356          * @param       string          $fileref: the file to use
1357          * @return      array           path, filename, filebody, fileext
1358          */
1359         public function split_fileref($fileref) {
1360                 $info = array();
1361                 if (preg_match('/(.*\/)(.*)$/', $fileref, $reg)) {
1362                         $info['path'] = $reg[1];
1363                         $info['file'] = $reg[2];
1364                 } else {
1365                         $info['path'] = '';
1366                         $info['file'] = $fileref;
1367                 }
1368                 $reg = '';
1369                 if (preg_match('/(.*)\.([^\.]*$)/', $info['file'], $reg)) {
1370                         $info['filebody'] = $reg[1];
1371                         $info['fileext'] = strtolower($reg[2]);
1372                         $info['realFileext'] = $reg[2];
1373                 } else {
1374                         $info['filebody'] = $info['file'];
1375                         $info['fileext'] = '';
1376                 }
1377                 return $info;
1378         }
1379
1380
1381         /**
1382          * Returns an array with file or url-information
1383          *
1384          * @param       string          $path: url to check
1385          * @return      array           information about the path / URL
1386          */
1387         public function extParseUrl($path) {
1388                 $res = parse_url($path);
1389                 preg_match('/(.*\/)([^\/]*)$/', $res['path'], $reg);
1390                 $res['filepath'] = $reg[1];
1391                 $res['filename'] = $reg[2];
1392                 return $res;
1393         }
1394
1395
1396         /**
1397          * Creates a regular expression out of a list of tags
1398          *
1399          * @param       mixed           $tagArray: the list of tags (either as array or string if it is one tag)
1400          * @return      string          the regular expression
1401          */
1402         public function tag_regex($tags) {
1403                 $tags = (!is_array($tags) ? array($tags) : $tags);
1404                 $regexp = '/';
1405                 $c = count($tags);
1406                 foreach ($tags as $tag) {
1407                         $c--;
1408                         $regexp .= '<' . $tag . '[[:space:]]' . (($c) ? '|' : '');
1409                 }
1410                 return $regexp . '/i';
1411         }
1412
1413
1414         /**
1415          * This function analyzes a HTML tag
1416          * If an attribute is empty (like OPTION) the value of that key is just empty. Check it with is_set();
1417          *
1418          * @param       string          $tag: is either like this "<TAG OPTION ATTRIB=VALUE>" or
1419          *                               this " OPTION ATTRIB=VALUE>" which means you can omit the tag-name
1420          * @return      array           array with attributes as keys in lower-case
1421          */
1422         public function get_tag_attributes($tag) {
1423                 $attributes = array();
1424                 $tag = ltrim(preg_replace('/^<[^ ]*/', '', trim($tag)));
1425                 $tagLen = strlen($tag);
1426                 $safetyCounter = 100;
1427                         // Find attribute
1428                 while ($tag) {
1429                         $value = '';
1430                         $reg = preg_split('/[[:space:]=>]/', $tag, 2);
1431                         $attrib = $reg[0];
1432
1433                         $tag = ltrim(substr($tag, strlen($attrib), $tagLen));
1434                         if (substr($tag, 0, 1) == '=') {
1435                                 $tag = ltrim(substr($tag, 1, $tagLen));
1436                                 if (substr($tag, 0, 1) == '"') {
1437                                                 // Quotes around the value
1438                                         $reg = explode('"', substr($tag, 1, $tagLen), 2);
1439                                         $tag = ltrim($reg[1]);
1440                                         $value = $reg[0];
1441                                 } else {
1442                                                 // No quotes around value
1443                                         preg_match('/^([^[:space:]>]*)(.*)/', $tag, $reg);
1444                                         $value = trim($reg[1]);
1445                                         $tag = ltrim($reg[2]);
1446                                         if (substr($tag, 0, 1) == '>') {
1447                                                 $tag = '';
1448                                         }
1449                                 }
1450                         }
1451                         $attributes[strtolower($attrib)] = $value;
1452                         $safetyCounter--;
1453                         if ($safetyCounter < 0) {
1454                                 break;
1455                         }
1456                 }
1457                 return $attributes;
1458         }
1459
1460
1461         /**
1462          * Implementation of quoted-printable encode.
1463          * This function was a duplicate of t3lib_div::quoted_printable, thus it's going to be removed.
1464          * Deprecated since TYPO3 4.0
1465          *
1466          * @param       string          Content to encode
1467          * @return      string          The QP encoded string
1468          * @deprecated since TYPO3 4.0, will be removed in TYPO3 4.6
1469          */
1470         public function quoted_printable($string) {
1471                 t3lib_div::logDeprecatedFunction();
1472
1473                 return t3lib_div::quoted_printable($string, 76);
1474         }
1475
1476
1477         /**
1478          * Converts a name field
1479          * Deprecated since TYPO3 4.0
1480          *
1481          * @param       string          $name: the name
1482          * @return      string          the name
1483          * @deprecated since TYPO3 4.0, will be removed in TYPO3 4.6
1484          */
1485         public function convertName($name) {
1486                 t3lib_div::logDeprecatedFunction();
1487
1488                 return $name;
1489         }
1490 }
1491
1492 if (defined('TYPO3_MODE') && $TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_htmlmail.php']) {
1493         include_once($TYPO3_CONF_VARS[TYPO3_MODE]['XCLASS']['t3lib/class.t3lib_htmlmail.php']);
1494 }
1495
1496 ?>