<?php
// $Horde: horde/lib/MIME.php,v 1.63 2001/08/08 21:00:27 chuck Exp $

$mime_types =
array(
      TYPETEXT => ''text'', ''text'' => TYPETEXT,
      TYPEMULTIPART => ''multipart'', ''multipart'' => TYPEMULTIPART,
      TYPEMESSAGE => ''message'', ''message'' => TYPEMESSAGE,
      TYPEAPPLICATION => ''application'', ''application'' => TYPEAPPLICATION,
      TYPEAUDIO => ''audio'', ''audio'' => TYPEAUDIO,
      TYPEIMAGE => ''image'', ''image'' => TYPEIMAGE,
      TYPEVIDEO => ''video'', ''video'' => TYPEVIDEO,
      TYPEOTHER => ''unknown'', ''unknown'' => TYPEOTHER
      );

$mime_encodings =
array(
      ENC7BIT => ''7bit'', ''7bit'' => ENC7BIT,
      ENC8BIT => ''8bit'', ''8bit'' => ENC8BIT,
      ENCBINARY => ''binary'', ''binary'' => ENCBINARY,
      ENCBASE64 => ''base64'', ''base64'' => ENCBASE64,
      ENCQUOTEDPRINTABLE => ''quoted-printable'', ''quoted-printable'' => ENCQUOTEDPRINTABLE,
      ENCOTHER => ''unknown'', ''unknown'' => ENCOTHER
      );


/**
* The MIME:: class provides methods for dealing with MIME standards.
*
* @author  Chuck Hagenbuch <chuck@horde.org>
* @version $Revision: 1.64 $
* @since   Horde 1.3
* @package horde.mime
*/
class MIME {
    
    /**
     * Determine if a string contains 8-bit characters.
     * @access private
     *
     * @param string $string  The string to check.
     * @return boolean        true if it does, false if it doesn''t.
     */
    function is8bit($string)
    {
        if (is_string($string)) {
            for ($i = 0; $i < strlen($string); $i++) {
                if (ord($string[$i]) >> 7)
                    return true;
            }
            return false;
        }
        return false;
    }
    
    /**
     * Encode a string containing non-ascii characters according to RFC 2047.
     *
     * @param string $text    The text to encode.
     * @param string $charset (optional) The character set of the text.
     * @param boolean $outer  Is this the final iteration?
     *
     * @return string The text, encoded only if it contains non-ascii characters.
     */
    function encode($text, $charset = null, $outer = true)
    {
        if (MIME::is8bit($text)) {
            if (((strlen($text) * 3) + strlen($charset) + 7) > 76) {
                $text = MIME::encode(substr($text, 0, (23 - strlen($charset))), $charset) . MIME::encode(substr($text, (23 - strlen($charset))), $charset, false);
            } else {
                $text = "=?$charset?B?" . strtr(trim(base64_encode($text)), '' '', ''_'') . "?=\n\t";
            }
        }
        
        // if this is the final iteration, take off any trailing
        // newline/tab chars.
        if ($outer && (substr($text, -2) == "\n\t"))
            $text = substr($text, 0, -2);
        
        return $text;
    }
    
    /**
     * Encode a string containing email addresses according to RFC 2047.
     *
     * This differs from MIME::encode() because it keeps email
     * addresses legal, only encoding the personal information.
     *
     * @param string $text      The email addresses to encode.
     * @param string $charset   (optional) The character set of the text.
     * @param string $defserver (optional) The default domain to append to mailboxes.
     *
     * @return string The text, encoded only if it contains non-ascii characters.
     */
    function encodeAddress($text, $charset = null, $defserver = null)
    {
        include_once ''Mail/RFC822.php'';
        
        $addr_arr = Mail_RFC822::parseAddressList($text, $defserver, false, false);
        $text = '''';
        if (is_array($addr_arr)) {
            foreach ($addr_arr as $addr) {
                if (empty($addr->personal)) {
                    $personal = '''';
                } else {
                    if ((substr($addr->personal, 0, 1) == ''"'') &&
                        (substr($addr->personal, -1) == ''"'')) {
                        $addr->personal = substr($addr->personal, 1, -1);
                    }
                    $personal = MIME::encode($addr->personal, $charset);
                }
                if (strlen($text) != 0) $text .= '', '';
                // FIXME: dependency on imap module
                $text .= MIME::trimEmailAddress(imap_rfc822_write_address($addr->mailbox, $addr->host, $personal));
            }
        }
        return $text;
    }
    
    /**
     * Decode an RFC 2047-encoded string.
     *
     * @param string $string The text to decode.
     * @return string        The decoded text, or the original string if it was not encoded.
     */
    function decode($string)
    {
        $pos = strpos($string, ''=?'');
        if ($pos === false) {
            return $string;
        }
        
        // take out any spaces between multiple encoded words
        $string = preg_replace(''|\?=\s=\?|'', ''?==?'', $string);
        
        $preceding = substr($string, 0, $pos); // save any preceding text
        
        $search = substr($string, $pos + 2, 75); // the mime header spec says this is the longest a single encoded word can be
        $d1 = strpos($search, ''?'');
        if (!is_int($d1)) {
            return $string;
        }
        
        $charset = substr($string, $pos + 2, $d1);
        $search = substr($search, $d1 + 1);
        
        $d2 = strpos($search, ''?'');
        if (!is_int($d2)) {
            return $string;
        }
        
        $encoding = substr($search, 0, $d2);
        $search = substr($search, $d2+1);
        
        $end = strpos($search, ''?='');
        if (!is_int($end)) {
            return $string;
        }
        
        $encoded_text = substr($search, 0, $end);
        $rest = substr($string, (strlen($preceding . $charset . $encoding . $encoded_text) + 6));
        
        switch ($encoding) {
        case ''Q'':
        case ''q'':
            $encoded_text = str_replace(''_'', ''%20'', $encoded_text);
            $encoded_text = str_replace(''='', ''%'', $encoded_text);
            $decoded = urldecode($encoded_text);

            /* Convert Cyrillic character sets. */
            if (stristr($GLOBALS[''registry'']->getCharset(), ''windows-1251'')) {
                if (stristr($charset, ''koi8-r'')) {
                    $decoded = convert_cyr_string($decoded, ''k'', ''w'');
                }
            }
            if (stristr($GLOBALS[''registry'']->getCharset(), ''koi8-r'')) {
                if (stristr($charset, ''windows-1251'')) {
                    $decoded = convert_cyr_string($decoded, ''w'', ''k'');
                }
            }
            
            break;
            
        case ''B'':
        case ''b'':
            $decoded = urldecode(base64_decode($encoded_text));
            if (stristr($GLOBALS[''registry'']->getCharset(), ''windows-1251'')) {
                if (stristr($charset, ''koi8-r'')) {
                    $decoded = convert_cyr_string($decoded, ''k'', ''w'');
                }
            }
            if (stristr($GLOBALS[''registry'']->getCharset(), ''koi8-r'')) {
                if (stristr($charset, ''windows-1251'')) {
                    $decoded = convert_cyr_string($decoded, ''w'', ''k'');
                }
            }
            break;
            
        default:
            $decoded = ''=?'' . $charset . ''?'' . $encoding . ''?'' . $encoded_text . ''?='';
            break;
        }
        
        return $preceding . $decoded . MIME::decode($rest);
    }
    
    /**
     * If an email address has no personal information, get rid of any
     * angle brackets (<>) around it.
     *
     * @param string $address   The address to trim.
     * @return string           The trimmed address.
     */
    function trimEmailAddress($address)
    {
        $address = trim($address);
        if ((substr($address, 0, 1) == ''<'') && (substr($address, -1) == ''>'')) {
            $address = substr($address, 1, -1);
        }
        return $address;
    }
    
}
?>