Swift/Message/Encoder.php

<?php

/**
 * Swift Mailer Message Encoder
 * Please read the LICENSE file
 * @copyright Chris Corbyn <chris@w3style.co.uk>
 * @author Chris Corbyn <chris@w3style.co.uk>
 * @package Swift_Message
 * @license GNU Lesser General Public License
 */

require_once dirname(__FILE__) . "/../ClassLoader.php";
Swift_ClassLoader::load("Swift_File");

/**
 * Encodes strings in a variety of formats and detects some encoding formats
 * @package Swift_Message
 * @author Chris Corbyn <chris@w3style.co.uk>
 */
class Swift_Message_Encoder
{
  /**
   * A regular expression which matches valid e-mail addresses (including some unlikely ones)
   */
  const CHEAP_ADDRESS_RE = '(?#Start of dot-atom
    )[-!#\$%&\'\*\+\/=\?\^_`{}\|~0-9A-Za-z]+(?:\.[-!#\$%&\'\*\+\/=\?\^_`{}\|~0-9A-Za-z]+)*(?#
    End of dot-atom)(?:@(?#Start of domain)[-0-9A-Za-z]+(?:\.[-0-9A-Za-z]+)*(?#End of domain))?';
  /**
   * A singleton of this class
   * @var Swift_Message_Encoder
   */
  protected static $instance = null;
  /**
   * Retreive an instance of the encoder as a singleton.
   * New instances are never ever needed since it's monostatic.
   * @return Message_Encoder
   */
  public static function instance()
  {
    if (self::$instance === null)
    {
      self::$instance = new Swift_Message_Encoder();
    }
    return self::$instance;
  }
  /**
   * Break a string apart at every occurence of <add@ress> and return an array
   * This method does NOT remove any characters like a preg_split() would do.
   * Elements matching an address start with "a" followed by the numeric index
   * @param string The input string to separate
   * @return array
   */
  public function addressChunk($input)
  {
    $elements = 0;
    while (preg_match('/^(.*?)(<' . self::CHEAP_ADDRESS_RE . '>)/s', $input, $matches))
    {
      if (!empty($matches[1])) $ret[($elements++)] = $matches[1];
      $ret[('a' . ($elements++))] = $matches[2];
      $input = substr($input, strlen($matches[0]));
    }
    if ($input != "") $ret[($elements++)] = $input; //Whatever is left over

    return $ret;
  }
  /**
   * Break a string apart at every occurence of <xxxyyy> and return an array
   * This method does NOT remove any characters like a preg_split() would do.
   * Elements matching a quoted string start with "a" followed by the numeric index
   * @param string The input string to separate
   * @return array
   */
  public function quoteChunk($input)
  {
    $elements = 0;
    while (preg_match('/^(.*?)(<[\x20-\x3A\x3C-\x7E]*>)/s', $input, $matches))
    {
      if (!empty($matches[1])) $ret[($elements++)] = $matches[1];
      $ret[('a' . ($elements++))] = $matches[2];
      $input = substr($input, strlen($matches[0]));
    }
    if ($input != "") $ret[($elements++)] = $input; //Whatever is left over

    return $ret;
  }
  /**
   * Return the base64 encoded version of the string
   * @param string The input string to encode
   * @param int The maximum length of each line of output (inc CRLF)
   * @param int The maximum length of the first line in the output (for headers)
   * @param boolean Whether email addresses between < and > chars should be preserved or not
   * @param string The line ending
   * @return string
   */
  public function base64Encode($data, $chunk=76, $init_chunk=0, $headers=false, $le="\r\n")
  {
    $ret = "";
    $chunk -= 2;
    $chunk = $this->getHcf($chunk, 4);

    if ($init_chunk >= 2)
    {
      $init_chunk -= 2;
      $init_chunk = $this->getHcf($init_chunk, 4);
    }

    if ($headers) $data = $this->quoteChunk($data);
    else $data = array($data);

    foreach ($data as $key => $string)
    {
      $key = (string) $key;
      if ($key{0} == 'a') //This is an address
      {
        if ($init_chunk && $init_chunk < (strlen($string)+2)) $ret .= $le;
        $ret .= $le . $string;
      }
      else
      {
        $string = $this->rawBase64Encode($string);
        if ($init_chunk > 2)
        {
          $ret .= substr($string, 0, $init_chunk) . $le;
          $string = substr($string, $init_chunk);
        }
        elseif ($init_chunk) $ret .= $le;

        $ret .= trim(chunk_split($string, $chunk, $le)) . $le;
      }
      $init_chunk = 0;
    }

    return trim($ret);
  }
  /**
   * Return the base64 encoded version of a string with no breaks
   * @param The input string to encode
   * @return string
   */
  public function rawBase64Encode($string)
  {
    return $string = base64_encode($string);
  }
  /**
   * Return the base64 encoded version of a file
   * @param Swift_File The file input stream
   * @param int Max line length
   * @param string The line ending
   * @return Swift_Cache_OutputStream
   * @throws Swift_FileException If the file cannot be read
   */
  public function base64EncodeFile(Swift_File $file, $chunk=76, $le="\r\n")
  {
    Swift_ClassLoader::load("Swift_CacheFactory");
    $cache = Swift_CacheFactory::getCache();
    $chunk -= 2;
    $chunk = $this->getHcf($chunk, 4);
    $loop = false;
    //We have to read in multiples of 3 bytes but avoid doing such small chunks that it takes too long
    while (false !== $bytes = $file->read(8190))
    {
      if ($loop) $cache->write("b64", $le);
      $loop = true;
      $next = chunk_split($this->rawBase64Encode($bytes), $chunk, $le);
      $next = trim($next);
      $cache->write("b64", $next);
    }
    $file->reset();
    return $cache->getOutputStream("b64");
  }
  /**
   * Return the quoted printable version of the input string
   * @param string The input string to encode
   * @param int The maximum length of each line of output (inc CRLF)
   * @param int The maximum length of the first line in the output (for headers)
   * @param boolean Whether email addresses between < and > chars should be preserved or not
   * @param string The line ending
   * @return string
   */
  public function QPEncode($data, $chunk=76, $init_chunk=0, $headers=false, $le="\r\n")
  {
    $ret = "";
    if ($headers) $data = $this->quoteChunk($data);
    else $data = array($data);

    $trailing_spaces = chr(9) . chr(32);
    foreach ($data as $key => $string)
    {
      $key = (string) $key;
      if ($key{0} == 'a') //An address
      {
        if ($init_chunk && $init_chunk < (strlen($string)+3)) $ret .= "=";
        $ret .= $le . $string;
      }
      else
      {
        $lines = explode($le, $string);
        foreach ($lines as $n => $line)
          $lines[$n] = $this->rawQPEncode(rtrim($line, $trailing_spaces));
        $string = implode($le, $lines);
        if ($init_chunk > 3)
        {
          if (preg_match('/^.{1,'.($init_chunk-5).'}[^=]{2}(?!=[A-F0-9]{2})/', $string, $matches)
            || preg_match('/^.{1,'.($init_chunk-6).'}([^=]{0,3})?/', $string, $matches))
          {
            $ret .= $this->fixLE($matches[0] . "=", $le); //fixLE added 24/08/07
            $string = substr($string, strlen($matches[0]));
          }
        }
        elseif ($init_chunk) $ret .= "=";

        while (preg_match('/^.{1,'.($init_chunk-5).'}[^=]{2}(?!=[A-F0-9]{2})/', $string, $matches)
          || preg_match('/^.{1,'.($chunk-6).'}([^=]{0,3})?/', $string, $matches)
          || (strlen($string) > 0 && $matches = array($string)))
        {
          $ret .= $this->fixLE($le . $matches[0] . "=", $le); //fixLE added 24/08/07
          $string = substr($string, strlen($matches[0]));
        }
      }
      $init_chunk = 0;
    }

    if (substr($ret, -1) == "=") return trim(substr($ret, 0, -1));
    else return trim($ret);
  }
  /**
   * Return the QP encoded version of a string with no breaks
   * @param string The input to encode
   * @param boolean True if the data we're encoding is binary
   * @return string
   */
  public function rawQPEncode($string, $bin=false)
  {
    $ret = "";
    if (!$bin)
    {
      $string = str_replace(array("\r\n", "\r"), "\n", $string);
      $string = str_replace("\n", "\r\n", $string);
    }
    $len = strlen($string);
    for ($i = 0; $i < $len; $i++)
    {
      $val = ord($string{$i});
      //9, 32 = HT, SP; 10, 13 = CR, LF; 33-60 & 62-126 are ok
      // 63 = '?'; 95 = '_' and need encoding to go in the headers
      if ((!$bin && ($val == 32 || $val == 9 || $val == 10 || $val == 13))
        || ($val >= 33 && $val <= 60) || ($val >= 62 && $val <= 126)
        && $val != 63)
      {
        $ret .= $string{$i};
      }
      else
      {
        $ret .= sprintf("=%02X", $val);
      }
    }
    return $ret;
  }
  /**
   * Return a file as a quoted printable encoded string
   * @param Swift_File The file to encode
   * @param int Max line length
   * @param string The line ending
   * @return Swift_Cache_OutputStream
   * @throws Swift_FileException If the file cannot be read
   */
  public function QPEncodeFile(Swift_File $file, $chunk=76, $le="\r\n")
  {
    Swift_ClassLoader::load("Swift_CacheFactory");
    $cache = Swift_CacheFactory::getCache();
    while (false !== $bytes = $file->readln())
    {
      $next = $this->rawQPEncode($bytes, true);
      preg_match_all('/.{1,'.($chunk-6).'}([^=]{0,3})?/', $next, $next);
      if (count($next[0])) $cache->write("qp", $this->fixLE(implode("=" . $le, $next[0]), $le));
    }
    return $cache->getOutputStream("qp");
  }
  /**
   * Encode a string as 7bit ascii
   * @param string Input data to encode
   * @param int Max line length
   * @param string The line ending
   * @return string
   */
  public function encode7Bit($data, $chunk=76, $le="\r\n")
  {
    return $this->fixLE(wordwrap($data, $chunk-2, $le, 1), $le);
  }
  /**
   * Return a 7bit string from a file
   * @param Swift_File The file stream to read from
   * @param int The max line length
   * @param string The line ending
   * @return Swift_Cache_OutputStream
   * @throws Swift_FileException If the file cannot be read
   */
  public function encode7BitFile(Swift_File $file, $chunk=76, $le="\r\n")
  {
    Swift_ClassLoader::load("Swift_CacheFactory");
    $cache = Swift_CacheFactory::getCache();
    $ret = "";
    while (false !== $bytes = $file->read(8192)) $ret .= $bytes;
    $cache->write("7b", $this->fixLE(wordwrap($ret, $chunk-2, $le, 1), $le));
    return $cache->getOutputStream("7b");
  }
  /**
   * Return the 8bit encoded form of a string (unchanged there-abouts)
   * @param string Input data to encode
   * @param int Maximum line length
   * @param string The line ending
   * @return string
   */
  public function encode8Bit($data, $chunk=76, $le="\r\n")
  {
    return $this->fixLE(wordwrap($data, $chunk-2, $le, 1), $le);
  }
  /**
   * Return a 8bit string from a file
   * @param Swift_File The file stream to read from
   * @param int Max line length (including CRLF)
   * @param string The line ending
   * @return Swift_Cache_OutputStream
   * @throws Swift_FileException If the file cannot be read
   */
  public function encode8BitFile(Swift_File $file, $chunk=76, $le="\r\n")
  {
    Swift_ClassLoader::load("Swift_CacheFactory");
    $cache = Swift_CacheFactory::getCache();
    $ret = "";
    while (false !== $bytes = $file->read(8192)) $ret .= $bytes;
    $cache->write("8b", $this->fixLE(wordwrap($ret, $chunk-2, $le, 1), $le));
    return $cache->getOutputStream("8b");
  }
  /**
   * Keeps lines longer than 76 characters trimmed down to size
   * This currently does not convert other string encodings into 7bit
   * @param string The data to make safe for headers (defaults to RFC 2822 standards)
   * @param int maximum length of lines returned
   * @param int The maximum length of the first line
   * @param string The Line ending
   * @return string
   */
  public function header7BitEncode($data, $chunk=76, $init_chunk=0, $le="\r\n")
  {
    $data = $this->encode7BitPrintable($data);
    $ret = "";
    if ($init_chunk > 2)
    {
      $data_wrapped = wordwrap($data, $init_chunk, $le);
      $lines = explode($le, $data_wrapped);
      $first_line = array_shift($lines);
      $ret .= $first_line . $le;
      $data = preg_replace("~^[ \t]~D", "", substr($data, strlen($first_line)));
    }
    elseif ($init_chunk) $ret .= $le;
    $ret .= wordwrap($data, $chunk-2, $le);
    return trim($ret);
  }
  /**
   * Strip out any characters which are not in the ASCII 7bit printable range
   * @param string The string to clean
   * @return string
   */
  public function encode7BitPrintable($data)
  {
    return preg_replace('/[^\x20-\x7E]/', '', $data);
  }
  /**
   * Detect if a string contains multi-byte non-ascii chars that fall in the UTF-8 ranges
   * @param string Data to detect UTF-8 sequences in
   * @return boolean
   */
  public function isUTF8($data)
  {
    return preg_match('%(?:
    [\xC2-\xDF][\x80-\xBF]				# non-overlong 2-byte
    |\xE0[\xA0-\xBF][\x80-\xBF]			# excluding overlongs
    |[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}	# straight 3-byte
    |\xED[\x80-\x9F][\x80-\xBF]			# excluding surrogates
    |\xF0[\x90-\xBF][\x80-\xBF]{2}		# planes 1-3
    |[\xF1-\xF3][\x80-\xBF]{3}			# planes 4-15
    |\xF4[\x80-\x8F][\x80-\xBF]{2}		# plane 16
    )+%xs', $data);
  }
  /**
   * This function checks for 7bit *printable* characters
   * which excludes \r \n \t etc and so, is safe for use in mail headers
   * Actual permitted chars [\ !"#\$%&'\(\)\*\+,-\.\/0123456789:;<=>\?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\[\\\]\^_`abcdefghijklmnopqrstuvwxyz{\|}~]
   * Ranges \x00-\x1F are printer control sequences
   * \x7F is the ascii delete character
   * @param string Data to check against
   * @return boolean
   */
  public function is7BitPrintable($data)
  {
    return (!preg_match('/[^\x20-\x7E]/', $data));
  }
  /**
   * Check that a string does not contain any evil characters for headers.
   * @param string The string to check
   * @return boolean
   */
  public function isHeaderSafe($data)
  {
    return ($this->is7BitPrintable($data) && strpos($data, ";") === false);
  }
  /**
   * If the characters fall exclusively in the 7bit ascii range, return true
   * @param string Input to check
   * @return boolean
   */
  public function is7BitAscii($data)
  {
    return (!preg_match('/[^\x01-\x7F]/', $data));
  }
  /**
   * Encode a string for RFC 2047 compatability (url-encode)
   * @param string The input for encoding
   * @param string The charset used
   * @param string The language used
   * @param int The maximum line length
   * @param int The maximum length of the first line
   * @param string The line ending
   * @return string
   */
  public function rfc2047Encode($str, $charset="iso-8859-1", $language="en-us", $chunk=76, $le="\r\n")
  {
    $lang_spec = "";
    if (!$this->is7BitPrintable($str))
    {
      $lang_spec = $charset . "'" . $language . "'";
      $str = $lang_spec . str_replace("+", "%20", urlencode($str));
    }
    preg_match_all('~.{1,'.($chunk-6).'}([^%]{0,3})~', $str, $matches);
    if (count($matches[0])) return implode($le, $matches[0]);
  }
  /**
   * Fixes line endings to be whatever is specified by the user
   * SMTP requires the CRLF be used, but using sendmail in -t mode uses LF
   * This method also escapes dots on a start of line to avoid injection
   * @param string The data to fix
   * @return string
   */
  protected function fixLE($data, $le)
  {
    $data = str_replace(array("\r\n", "\r"), "\n", $data);
    if ($le != "\n") $data = str_replace("\n", $le, $data);
    return $data = str_replace($le . ".", $le . "..", $data);
  }
  protected function getHcf($value, $factor)
  {
    return ($value - ($value % $factor));
  }
}