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 / mimePart.php < prev    next >
Encoding:
PHP Script  |  2001-11-13  |  10.9 KB  |  325 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: Richard Heyes <richard@phpguru.org>                         |
  17. // +----------------------------------------------------------------------+
  18.  
  19.     require_once('PEAR.php');
  20.  
  21. /**
  22. *
  23. *  Raw mime encoding class
  24. *
  25. * What is it?
  26. *   This class enables you to manipulate and build
  27. *   a mime email from the ground up.
  28. *
  29. * Why use this instead of mime.php?
  30. *   mime.php is a userfriendly api to this class for
  31. *   people who aren't interested in the internals of
  32. *   mime mail. This class however allows full control
  33. *   over the email.
  34. *
  35. * Eg.
  36. *
  37. * // Since multipart/mixed has no real body, (the body is
  38. * // the subpart), we set the body argument to blank.
  39. *
  40. * $params['content_type'] = 'multipart/mixed';
  41. * $email = new Mail_mimePart('', $params);
  42. *
  43. * // Here we add a text part to the multipart we have
  44. * // already. Assume $body contains plain text.
  45. *
  46. * $params['content_type'] = 'text/plain';
  47. * $params['encoding']     = '7bit';
  48. * $text = $email->addSubPart($body, $params);
  49. *
  50. * // Now add an attachment. Assume $attach is
  51. * the contents of the attachment
  52. *
  53. * $params['content_type'] = 'application/zip';
  54. * $params['encoding']     = 'base64';
  55. * $params['disposition']  = 'attachment';
  56. * $params['dfilename']    = 'example.zip';
  57. * $attach =& $email->addSubPart($body, $params);
  58. *
  59. * // Now build the email. Note that the encode
  60. * // function returns an associative array containing two
  61. * // elements, body and headers. You will need to add extra
  62. * // headers, (eg. Mime-Version) before sending.
  63. *
  64. * $email = $message->encode();
  65. * $email['headers'][] = 'Mime-Version: 1.0';
  66. *
  67. * 
  68. * Further examples are available at http://www.phpguru.org
  69. *
  70. * TODO:
  71. *  - Set encode() to return the $obj->encoded if encode()
  72. *    has already been run. Unless a flag is passed to specifically
  73. *    re-build the message.
  74. *
  75. * @author  Richard Heyes <richard@phpguru.org>
  76. * @version $Revision: 1.4.2.1 $
  77. * @package Mail
  78. */
  79.  
  80. class Mail_mimePart extends PEAR{
  81.  
  82.    /**
  83.     * The encoding type of this part
  84.     * @var string
  85.     */
  86.     var $_encoding;
  87.  
  88.    /**
  89.     * An array of subparts
  90.     * @var array
  91.     */
  92.     var $_subparts;
  93.  
  94.    /**
  95.     * The output of this part after being built
  96.     * @var string
  97.     */
  98.     var $_encoded;
  99.  
  100.    /**
  101.     * Headers for this part
  102.     * @var array
  103.     */
  104.     var $_headers;
  105.  
  106.    /**
  107.     * The body of this part (not encoded)
  108.     * @var string
  109.     */
  110.     var $_body;
  111.  
  112.     /**
  113.      * Constructor.
  114.      * 
  115.      * Sets up the object.
  116.      *
  117.      * @param $body   - The body of the mime part if any.
  118.      * @param $params - An associative array of parameters:
  119.      *                  content_type - The content type for this part eg multipart/mixed
  120.      *                  encoding     - The encoding to use, 7bit, base64, or quoted-printable
  121.      *                  cid          - Content ID to apply
  122.      *                  disposition  - Content disposition, inline or attachment
  123.      *                  dfilename    - Optional filename parameter for content disposition
  124.      *                  description  - Content description
  125.      * @access public
  126.      */
  127.     function Mail_mimePart($body, $params = array())
  128.     {
  129.         if (!defined('MAIL_MIMEPART_CRLF')) {
  130.             define('MAIL_MIMEPART_CRLF', "\r\n", TRUE);
  131.         }
  132.  
  133.         foreach ($params as $key => $value) {
  134.             switch ($key) {
  135.                 case 'content_type':
  136.                     $headers['Content-Type'] = $value . (isset($charset) ? '; charset="' . $charset . '"' : '');
  137.                     break;
  138.  
  139.                 case 'encoding':
  140.                     $this->_encoding = $value;
  141.                     $headers['Content-Transfer-Encoding'] = $value;
  142.                     break;
  143.  
  144.                 case 'cid':
  145.                     $headers['Content-ID'] = '<' . $value . '>';
  146.                     break;
  147.  
  148.                 case 'disposition':
  149.                     $headers['Content-Disposition'] = $value . (isset($dfilename) ? '; filename="' . $dfilename . '"' : '');
  150.                     break;
  151.  
  152.                 case 'dfilename':
  153.                     if (isset($headers['Content-Disposition'])) {
  154.                         $headers['Content-Disposition'] .= '; filename="' . $value . '"';
  155.                     } else {
  156.                         $dfilename = $value;
  157.                     }
  158.                     break;
  159.  
  160.                 case 'description':
  161.                     $headers['Content-Description'] = $value;
  162.                     break;
  163.  
  164.                 case 'charset':
  165.                     if (isset($headers['Content-Type'])) {
  166.                         $headers['Content-Type'] .= '; charset="' . $value . '"';
  167.                     } else {
  168.                         $charset = $value;
  169.                     }
  170.                     break;
  171.             }
  172.         }
  173.  
  174.         // Default content-type
  175.         if (!isset($_headers['Content-Type'])) {
  176.             $_headers['Content-Type'] = 'text/plain';
  177.         }
  178.  
  179.         // Assign stuff to member variables
  180.         $this->_encoded  =  array();
  181.         $this->_headers  =& $headers;
  182.         $this->_body     =  $body;
  183.     }
  184.  
  185.     /**
  186.      * encode()
  187.      * 
  188.      * Encodes and returns the email. Also stores
  189.      * it in the encoded member variable
  190.      *
  191.      * @return An associative array containing two elements,
  192.      *         body and headers. The headers element is itself
  193.      *         an indexed array.
  194.      * @access public
  195.      */
  196.     function encode()
  197.     {
  198.         $encoded =& $this->_encoded;
  199.  
  200.         if (!empty($this->_subparts)) {
  201.             srand((double)microtime()*1000000);
  202.             $boundary = '=_' . md5(uniqid(rand()) . microtime());
  203.             $this->_headers['Content-Type'] .= '; ' . 'boundary="' . $boundary . '"';
  204.  
  205.             // Add body parts to $subparts
  206.             for ($i = 0; $i < count($this->_subparts); $i++) {
  207.                 $headers = array();
  208.                 $tmp = $this->_subparts[$i]->encode();
  209.                 foreach ($tmp['headers'] as $key => $value) {
  210.                     $headers[] = $key . ': ' . $value;
  211.                 }
  212.                 $subparts[] = implode(MAIL_MIMEPART_CRLF, $headers) . MAIL_MIMEPART_CRLF . MAIL_MIMEPART_CRLF . $tmp['body'];
  213.             }
  214.  
  215.             $encoded['body'] = '--' . $boundary . MAIL_MIMEPART_CRLF .
  216.                                implode('--' . $boundary . MAIL_MIMEPART_CRLF, $subparts) .
  217.                                '--' . $boundary.'--' . MAIL_MIMEPART_CRLF;
  218.  
  219.         } else {
  220.             $encoded['body'] = $this->_getEncodedData($this->_body, $this->_encoding) . MAIL_MIMEPART_CRLF;
  221.         }
  222.  
  223.         // Add headers to $encoded
  224.         $encoded['headers'] =& $this->_headers;
  225.  
  226.         return $encoded;
  227.     }
  228.  
  229.     /**
  230.      * &addSubPart()
  231.      * 
  232.      * Adds a subpart to current mime part and returns
  233.      * a reference to it
  234.      *
  235.      * @param $body   The body of the subpart, if any.
  236.      * @param $params The parameters for the subpart, same
  237.      *                as the $params argument for constructor.
  238.      * @return A reference to the part you just added. It is
  239.      *         crucial if using multipart/* in your subparts that
  240.      *         you use =& in your script when calling this function,
  241.      *         otherwise you will not be able to add further subparts.
  242.      * @access public
  243.      */
  244.     function &addSubPart($body, $params)
  245.     {
  246.         $this->_subparts[] = new Mail_mimePart($body, $params);
  247.         return $this->_subparts[count($this->_subparts) - 1];
  248.     }
  249.  
  250.     /**
  251.      * _getEncodedData()
  252.      * 
  253.      * Returns encoded data based upon encoding passed to it
  254.      *
  255.      * @param $data     The data to encode.
  256.      * @param $encoding The encoding type to use, 7bit, base64,
  257.      *                  or quoted-printable.
  258.      * @access private
  259.      */
  260.     function _getEncodedData($data, $encoding)
  261.     {
  262.         switch ($encoding) {
  263.             case '7bit':
  264.                 return $data;
  265.                 break;
  266.  
  267.             case 'quoted-printable':
  268.                 return $this->_quotedPrintableEncode($data);
  269.                 break;
  270.  
  271.             case 'base64':
  272.                 return rtrim(chunk_split(base64_encode($data), 76, MAIL_MIMEPART_CRLF));
  273.                 break;
  274.         }
  275.     }
  276.  
  277.     /**
  278.      * quoteadPrintableEncode()
  279.      * 
  280.      * Encodes data to quoted-printable standard.
  281.      *
  282.      * @param $input    The data to encode
  283.      * @param $line_max Optional max line length. Should 
  284.      *                  not be more than 76 chars
  285.      *
  286.      * @access private
  287.      */
  288.     function _quotedPrintableEncode($input , $line_max = 76)
  289.     {
  290.         $lines    = preg_split("/\r\n|\r|\n/", $input);
  291.         $eol    = MAIL_MIMEPART_CRLF;
  292.         $escape    = '=';
  293.         $output    = '';
  294.         
  295.         while(list(, $line) = each($lines)){
  296.  
  297.             $linlen     = strlen($line);
  298.             $newline = '';
  299.  
  300.             for ($i = 0; $i < $linlen; $i++) {
  301.                 $char = substr($line, $i, 1);
  302.                 $dec  = ord($char);
  303.  
  304.                 if (($dec == 32) AND ($i == ($linlen - 1))){    // convert space at eol only
  305.                     $char = '=20';
  306.  
  307.                 } elseif($dec == 9) {
  308.                     ; // Do nothing if a tab.
  309.                 } elseif(($dec == 61) OR ($dec < 32 ) OR ($dec > 126)) {
  310.                     $char = $escape . strtoupper(sprintf('%02s', dechex($dec)));
  311.                 }
  312.     
  313.                 if ((strlen($newline) + strlen($char)) >= $line_max) {        // MAIL_MIMEPART_CRLF is not counted
  314.                     $output  .= $newline . $escape . $eol;                    // soft line break; " =\r\n" is okay
  315.                     $newline  = '';
  316.                 }
  317.                 $newline .= $char;
  318.             } // end of for
  319.             $output .= $newline . $eol;
  320.         }
  321.         $output = substr($output, 0, -1 * strlen($eol)); // Don't want last crlf
  322.         return $output;
  323.     }
  324. } // End of class
  325. ?>