home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 March / PCWorld_2003-03_cd.bin / Software / Vyzkuste / phptriad / phptriad2-2-1.exe / php / pear / Mail / mime.php < prev    next >
Encoding:
PHP Script  |  2001-11-13  |  18.4 KB  |  522 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Tomas V.V.Cox <cox@idecnet.com>                             |
  17. // |          Richard Heyes <richard@phpguru.org>                         |
  18. // |                                                                      |
  19. // +----------------------------------------------------------------------+
  20. //
  21. // $Id: mime.php,v 1.2.2.2 2001/11/13 01:26:46 ssb Exp $
  22.  
  23. require_once 'PEAR.php';
  24. require_once 'Mail/mimePart.php';
  25.  
  26. /*
  27. * Mime mail composer class. Can handle: text and html bodies, embedded html
  28. * images and attachments.
  29. * Documentation and example of this class is avaible here:
  30. * http://vulcanonet.com/soft/mime/
  31. *
  32. * @notes This class is based on HTML Mime Mail class from
  33. *   Richard Heyes <richard.heyes@heyes-computing.net> which was based also
  34. *   in the mime_mail.class by Tobias Ratschiller <tobias@dnet.it> and
  35. *   Sascha Schumann <sascha@schumann.cx>.
  36. *
  37. * @author Tomas V.V.Cox <cox@idecnet.com>
  38. * @author Richard Heyes <richard.heyes@heyes-computing.net>
  39. * @package Mail
  40. * @access public
  41. */
  42. class Mail_mime extends Mail
  43. {
  44.     /**
  45.     * Contains the plain text part of the email
  46.     * @var string
  47.     */
  48.     var $_txtbody;
  49.     /**
  50.     * Contains the html part of the email
  51.     * @var string
  52.     */
  53.     var $_htmlbody;
  54.     /**
  55.     * contains the mime encoded text
  56.     * @var string
  57.     */
  58.     var $_mime;
  59.     /**
  60.     * contains the multipart content
  61.     * @var string
  62.     */
  63.     var $_multipart;
  64.     /**
  65.     * list of the attached images
  66.     * @var array
  67.     */
  68.     var $_html_images = array();
  69.     /**
  70.     * list of the attachements
  71.     * @var array
  72.     */
  73.     var $_parts = array();
  74.     /**
  75.     * Build parameters
  76.     * @var array
  77.     */
  78.     var $_build_params = array();
  79.     /**
  80.     * Headers for the mail
  81.     * @var array
  82.     */
  83.     var $_headers = array();
  84.  
  85.  
  86.     /*
  87.     * Constructor function
  88.     *
  89.     * @access public
  90.     */
  91.     function Mail_mime($crlf = "\r\n")
  92.     {
  93.         if (!defined('MAIL_MIME_CRLF')) {
  94.             define('MAIL_MIME_CRLF', $crlf, true);
  95.         }
  96.  
  97.         $this->_boundary = '=_' . md5(uniqid(time()));
  98.  
  99.         $this->_build_params = array(
  100.                                      'text_encoding' => '7bit',
  101.                                      'html_encoding' => 'quoted-printable',
  102.                                      '7bit_wrap'     => 998,
  103.                                      'html_charset'  => 'iso-8859-1',
  104.                                      'text_charset'  => 'iso-8859-1'
  105.                                     );
  106.     }
  107.  
  108.     /*
  109.     * Accessor function to set the body text. Body text is used if
  110.     * it's not an html mail being sent or else is used to fill the
  111.     * text/plain part that emails clients who don't support
  112.     * html should show.
  113.     *
  114.     * @param string $data Either a string or the file name with the
  115.     *        contents
  116.     * @param bool $isfile If true the first param should be trated
  117.     *        as a file name, else as a string (default)
  118.     * @return mixed true on success or PEAR_Error object
  119.     * @access public
  120.     */
  121.     function setTXTBody($data, $isfile = false)
  122.     {
  123.         if (!$isfile) {
  124.             $this->_txtbody = $data;
  125.         } else {
  126.             $cont = $this->_file2str($data);
  127.             if (PEAR::isError($cont)) {
  128.                 return $cont;
  129.             }
  130.             $this->_txtbody = $cont;
  131.         }
  132.         return true;
  133.     }
  134.  
  135.     /*
  136.     * Adds a html part to the mail
  137.     *
  138.     * @param string $data Either a string or the file name with the
  139.     *        contents
  140.     * @param bool $isfile If true the first param should be trated
  141.     *        as a file name, else as a string (default)
  142.     * @return mixed true on success or PEAR_Error object
  143.     * @access public
  144.     */
  145.     function setHTMLBody($data, $isfile = false)
  146.     {
  147.         if (!$isfile) {
  148.             $this->_htmlbody = $data;
  149.         } else {
  150.             $cont = $this->_file2str($data);
  151.             if (PEAR::isError($cont)) {
  152.                 return $cont;
  153.             }
  154.             $this->_htmlbody = $cont;
  155.         }
  156.  
  157.         return true;
  158.     }
  159.  
  160.     /*
  161.     * Adds an image to the list of embedded images.
  162.     *
  163.     * @param string $file The image file name OR image data itself
  164.     * @param string $c_type The content type
  165.     * @param string $name The filename of the image. Only use if $file is the image data
  166.     * @param bool $isfilename Whether $file is a filename or not. Defaults to true
  167.     * @return mixed true on success or PEAR_Error object
  168.     * @access public
  169.     */
  170.     function addHTMLImage($file, $c_type='application/octet-stream', $name = '', $isfilename = true)
  171.     {
  172.         $filedata = ($isfilename === true) ? $this->_file2str($file) : $file;
  173.         $filename = ($isfilename === true) ? basename($file) : basename($name);
  174.         if (PEAR::isError($filedata)) {
  175.             return $filedata;
  176.         }
  177.         $this->_html_images[] = array(
  178.                                       'body'   => $filedata,
  179.                                       'name'   => $filename,
  180.                                       'c_type' => $c_type,
  181.                                       'cid'    => md5(uniqid(time()))
  182.                                      );
  183.         return true;
  184.     }
  185.  
  186.     /*
  187.     * Adds a file to the list of attachments.
  188.     *
  189.     * @param string $file The file name of the file to attach OR the file data itself
  190.     * @param string $c_type The content type
  191.     * @param string $name The filename of the attachment. Only use if $file is the file data
  192.     * @param bool $isFilename Whether $file is a filename or not. Defaults to true
  193.     * @return mixed true on success or PEAR_Error object
  194.     * @access public
  195.     */
  196.     function addAttachment($file, $c_type='application/octet-stream', $name = '', $isfilename = true, $encoding = 'base64')
  197.     {
  198.         $filedata = ($isfilename === true) ? $this->_file2str($file) : $file;
  199.         $filename = ($isfilename === true) ? basename($file) : basename($name);
  200.         if (PEAR::isError($filedata)) {
  201.             return $filedata;
  202.         }
  203.  
  204.         $this->_parts[] = array(
  205.                                 'body'     => $filedata,
  206.                                 'name'     => $filename,
  207.                                 'c_type'   => $c_type,
  208.                                 'encoding' => $encoding
  209.                                );
  210.         return true;
  211.     }
  212.  
  213.     /*
  214.     * Returns the contents of the given file name as string
  215.     * @param string $file_name
  216.     * @return string
  217.     * @acces private
  218.     */
  219.     function & _file2str($file_name)
  220.     {
  221.         if (!is_readable($file_name)) {
  222.             return $this->raiseError('File is not readable ' . $file_name);
  223.         }
  224.         if (!$fd = fopen($file_name, 'rb')) {
  225.             return $this->raiseError('Could not open ' . $file_name);
  226.         }
  227.         $cont = fread($fd, filesize($file_name));
  228.         fclose($fd);
  229.         return $cont;
  230.     }
  231.  
  232.     /*
  233.     * Adds a text subpart to the mimePart object and 
  234.     * returns it during the build process.
  235.     *
  236.     * @param mixed    The object to add the part to, or
  237.     *                 null if a new object is to be created.
  238.     * @param string   The text to add.
  239.     * @return object  The text mimePart object
  240.     * @access private
  241.     */
  242.     function &_addTextPart(&$obj, $text){
  243.  
  244.         $params['content_type'] = 'text/plain';
  245.         $params['encoding']     = $this->_build_params['text_encoding'];
  246.         $params['charset']      = $this->_build_params['text_charset'];
  247.         if (is_object($obj)) {
  248.             return $obj->addSubpart($text, $params);
  249.         } else {
  250.             return new Mail_mimePart($text, $params);
  251.         }
  252.     }
  253.  
  254.     /*
  255.     * Adds a html subpart to the mimePart object and
  256.     * returns it during the build process.
  257.     *
  258.     * @param mixed    The object to add the part to, or
  259.     *                 null if a new object is to be created.
  260.     * @return object  The html mimePart object
  261.     * @access private
  262.     */
  263.     function &_addHtmlPart(&$obj){
  264.  
  265.         $params['content_type'] = 'text/html';
  266.         $params['encoding']     = $this->_build_params['html_encoding'];
  267.         $params['charset']      = $this->_build_params['html_charset'];
  268.         if (is_object($obj)) {
  269.             return $obj->addSubpart($this->_htmlbody, $params);
  270.         } else {
  271.             return new Mail_mimePart($this->_htmlbody, $params);
  272.         }
  273.     }
  274.  
  275.     /*
  276.     * Creates a new mimePart object, using multipart/mixed as
  277.     * the initial content-type and returns it during the
  278.     * build process.
  279.     *
  280.     * @return object  The multipart/mixed mimePart object
  281.     * @access private
  282.     */
  283.     function &_addMixedPart(){
  284.  
  285.         $params['content_type'] = 'multipart/mixed';
  286.         return new Mail_mimePart('', $params);
  287.     }
  288.  
  289.     /*
  290.     * Adds a multipart/alternative part to a mimePart
  291.     * object, (or creates one), and returns it  during
  292.     * the build process.
  293.     *
  294.     * @param mixed    The object to add the part to, or
  295.     *                 null if a new object is to be created.
  296.     * @return object  The multipart/mixed mimePart object
  297.     * @access private
  298.     */
  299.     function &_addAlternativePart(&$obj){
  300.  
  301.         $params['content_type'] = 'multipart/alternative';
  302.         if (is_object($obj)) {
  303.             return $obj->addSubpart('', $params);
  304.         } else {
  305.             return new Mail_mimePart('', $params);
  306.         }
  307.     }
  308.  
  309.     /*
  310.     * Adds a multipart/related part to a mimePart
  311.     * object, (or creates one), and returns it  during
  312.     * the build process.
  313.     *
  314.     * @param mixed    The object to add the part to, or
  315.     *                 null if a new object is to be created.
  316.     * @return object  The multipart/mixed mimePart object
  317.     * @access private
  318.     */
  319.     function &_addRelatedPart(&$obj){
  320.  
  321.         $params['content_type'] = 'multipart/related';
  322.         if (is_object($obj)) {
  323.             return $obj->addSubpart('', $params);
  324.         } else {
  325.             return new Mail_mimePart('', $params);
  326.         }
  327.     }
  328.  
  329.     /*
  330.     * Adds an html image subpart to a mimePart object
  331.     * and returns it during the build process.
  332.     *
  333.     * @param  object  The mimePart to add the image to
  334.     * @param  array   The image information
  335.     * @return object  The image mimePart object
  336.     * @access private
  337.     */
  338.     function &_addHtmlImagePart(&$obj, $value){
  339.  
  340.         $params['content_type'] = $value['c_type'];
  341.         $params['encoding']     = 'base64';
  342.         $params['disposition']  = 'inline';
  343.         $params['dfilename']    = $value['name'];
  344.         $params['cid']          = $value['cid'];
  345.         $obj->addSubpart($value['body'], $params);
  346.     }
  347.  
  348.     /*
  349.     * Adds an attachment subpart to a mimePart object
  350.     * and returns it during the build process.
  351.     *
  352.     * @param  object  The mimePart to add the image to
  353.     * @param  array   The attachment information
  354.     * @return object  The image mimePart object
  355.     * @access private
  356.     */
  357.     function &_addAttachmentPart(&$obj, $value){
  358.  
  359.         $params['content_type'] = $value['c_type'];
  360.         $params['encoding']     = $value['encoding'];
  361.         $params['disposition']  = 'attachment';
  362.         $params['dfilename']    = $value['name'];
  363.         $obj->addSubpart($value['body'], $params);
  364.     }
  365.  
  366.     /*
  367.     * Builds the multipart message from the list ($this->_parts) and
  368.     * returns the mime content.
  369.     *
  370.     * @param  array  Build parameters that change the way the email
  371.     *                is built. Should be associative. Can contain:
  372.     *                text_encoding  -  What encoding to use for plain text
  373.     *                                  Default is 7bit
  374.     *                html_encoding  -  What encoding to use for html
  375.     *                                  Default is quoted-printable
  376.     *                7bit_wrap      -  Number of characters before text is
  377.     *                                  wrapped in 7bit encoding
  378.     *                                  Default is 998
  379.     *                html_charset   -  The character set to use for html.
  380.     *                                  Default is iso-8859-1
  381.     *                text_charset   -  The character set to use for text.
  382.     *                                  Default is iso-8859-1
  383.     * @return string The mime content
  384.     * @access public
  385.     */
  386.     function &get($params = null)
  387.     {
  388.         if (isset($build_params)) {
  389.             while (list($key, $value) = each($build_params)) {
  390.                 $this->_build_params[$key] = $value;
  391.             }
  392.         }
  393.  
  394.         if (!empty($this->_html_images) AND isset($this->_htmlbody)) {
  395.             foreach ($this->_html_images as $value) {
  396.                 $this->_htmlbody = str_replace($value['name'], 'cid:'.$value['cid'], $this->_htmlbody);
  397.             }
  398.         }
  399.  
  400.         $null        = null;
  401.         $attachments = !empty($this->_parts)                ? TRUE : FALSE;
  402.         $html_images = !empty($this->_html_images)          ? TRUE : FALSE;
  403.         $html        = !empty($this->_htmlbody)             ? TRUE : FALSE;
  404.         $text        = (!$html AND !empty($this->_txtbody)) ? TRUE : FALSE;
  405.  
  406.         switch (TRUE) {
  407.             case $text AND !$attachments:
  408.                 $message =& $this->_addTextPart($null, $this->text);
  409.                 break;
  410.  
  411.             case !$text AND !$html AND $attachments:
  412.                 $message =& $this->_addMixedPart();
  413.  
  414.                 for ($i = 0; $i < count($this->_parts); $i++) {
  415.                     $this->_addAttachmentPart($message, $this->_parts[$i]);
  416.                 }
  417.                 break;
  418.  
  419.             case $text AND $attachments:
  420.                 $message =& $this->_addMixedPart();
  421.                 $this->_addTextPart($message, $this->_txtbody);
  422.  
  423.                 for ($i = 0; $i < count($this->_parts); $i++) {
  424.                     $this->_addAttachmentPart($message, $this->_parts[$i]);
  425.                 }
  426.                 break;
  427.  
  428.             case $html AND !$attachments AND !$html_images:
  429.                 if (isset($this->_txtbody)) {
  430.                     $message =& $this->_addAlternativePart($null);
  431.                        $this->_addTextPart($message, $this->_txtbody);
  432.                     $this->_addHtmlPart($message);
  433.                     
  434.                 } else {
  435.                     $message =& $this->_addHtmlPart($null);
  436.                 }
  437.                 break;
  438.  
  439.             case $html AND !$attachments AND $html_images:
  440.                 if (isset($this->_txtbody)) {
  441.                     $message =& $this->_addAlternativePart($null);
  442.                     $this->_addTextPart($message, $this->_txtbody);
  443.                     $related =& $this->_addRelatedPart($message);
  444.                 } else {
  445.                     $message =& $this->_addRelatedPart($null);
  446.                     $related =& $message;
  447.                 }
  448.                 $this->_addHtmlPart($related);
  449.                 for ($i = 0; $i < count($this->_html_images); $i++) {
  450.                     $this->_addHtmlImagePart($related, $this->_html_images[$i]);
  451.                 }
  452.                 break;
  453.  
  454.             case $html AND $attachments AND !$html_images:
  455.                 $message =& $this->_addMixedPart();
  456.                 if (isset($this->_txtbody)) {
  457.                     $alt =& $this->_addAlternativePart($message);
  458.                     $this->_addTextPart($alt, $this->_txtbody);
  459.                     $this->_addHtmlPart($alt);
  460.                 } else {
  461.                     $this->_addHtmlPart($message);
  462.                 }
  463.                 for ($i = 0; $i < count($this->_parts); $i++) {
  464.                     $this->_addAttachmentPart($message, $this->_parts[$i]);
  465.                 }
  466.                 break;
  467.  
  468.             case $html AND $attachments AND $html_images:
  469.                 $message =& $this->_addMixedPart();
  470.                 if (isset($this->_txtbody)) {
  471.                     $alt =& $this->_addAlternativePart($message);
  472.                     $this->_addTextPart($alt, $this->_txtbody);
  473.                     $rel =& $this->_addRelatedPart($alt);
  474.                 } else {
  475.                     $rel =& $this->_addRelatedPart($message);
  476.                 }
  477.                 $this->_addHtmlPart($rel);
  478.                 for ($i = 0; $i < count($this->_html_images); $i++) {
  479.                     $this->_addHtmlImagePart($rel, $this->_html_images[$i]);
  480.                 }
  481.                 for ($i = 0; $i < count($this->_parts); $i++) {
  482.                     $this->_addAttachmentPart($message, $this->_parts[$i]);
  483.                 }
  484.                 break;
  485.  
  486.         }
  487.  
  488.         if (isset($message)) {
  489.             $output = $message->encode();
  490.             $this->_headers = $output['headers'];
  491.  
  492.             return $output['body'];
  493.  
  494.         } else {
  495.             return FALSE;
  496.         }
  497.     }
  498.  
  499.  
  500.     /*
  501.     * Returns an array with the headers needed to prepend to the email
  502.     * (MIME-Version and Content-Type). Format of argument is:
  503.     * $array['header-name'] = 'header-value';
  504.     *
  505.     * @param  array Assoc array with any extra headers. Optional.
  506.     * @return array Assoc array with the mime headers
  507.     * @access public
  508.     */
  509.     function & headers($xtra_headers = null)
  510.     {
  511.         // Content-Type header should already be present, 
  512.         // So just add mime version header
  513.         $headers['MIME-Version'] = '1.0';
  514.         if (isset($xtra_headers)) {
  515.             $headers = array_merge($headers, $xtra_headers);
  516.         }
  517.         $this->_headers = array_merge($headers, $this->_headers);
  518.  
  519.         return $this->_headers;
  520.     }
  521. }
  522. ?>