Source for file class.mimePart.php

Documentation is available at class.mimePart.php

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

Documentation generated on Sat, 24 Mar 2007 09:59:39 +0100 by phpDocumentor 1.3.1