/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @(#)MimeUtility.java       1.45 03/03/10

 */

package com.sun.xml.internal.messaging.saaj.packaging.mime.internet;

import java.io.*;

import java.util.*;

import javax.activation.DataHandler;

import javax.activation.DataSource;

import com.sun.xml.internal.messaging.saaj.packaging.mime.MessagingException;

import com.sun.xml.internal.messaging.saaj.packaging.mime.util.*;

import com.sun.xml.internal.messaging.saaj.util.SAAJUtil;

/**

 * This is a utility class that provides various MIME related

 * functionality. <p>

 *

 * There are a set of methods to encode and decode MIME headers as

 * per RFC 2047. A brief description on handling such headers is

 * given below: <p>

 *

 * RFC 822 mail headers <strong>must</strong> contain only US-ASCII

 * characters. Headers that contain non US-ASCII characters must be

 * encoded so that they contain only US-ASCII characters. Basically,

 * this process involves using either BASE64 or QP to encode certain

 * characters. RFC 2047 describes this in detail. <p>

 *

 * In Java, Strings contain (16 bit) Unicode characters. ASCII is a

 * subset of Unicode (and occupies the range 0 - 127). A String

 * that contains only ASCII characters is already mail-safe. If the

 * String contains non US-ASCII characters, it must be encoded. An

 * additional complexity in this step is that since Unicode is not

 * yet a widely used charset, one might want to first charset-encode

 * the String into another charset and then do the transfer-encoding.

 * <p>

 * Note that to get the actual bytes of a mail-safe String (say,

 * for sending over SMTP), one must do

 * <p><blockquote><pre>

 *

 *      byte[] bytes = string.getBytes("iso-8859-1");

 *

 * </pre></blockquote><p>

 *

 * The <code>setHeader</code> and <code>addHeader</code> methods

 * on MimeMessage and MimeBodyPart assume that the given header values

 * are Unicode strings that contain only US-ASCII characters. Hence

 * the callers of those methods must insure that the values they pass

 * do not contain non US-ASCII characters. The methods in this class

 * help do this. <p>

 *

 * The <code>getHeader</code> family of methods on MimeMessage and

 * MimeBodyPart return the raw header value. These might be encoded

 * as per RFC 2047, and if so, must be decoded into Unicode Strings.

 * The methods in this class help to do this. <p>

 *

 * Several System properties control strict conformance to the MIME

 * spec.  Note that these are not session properties but must be set

 * globally as System properties. <p>

 *

 * The <code>mail.mime.decodetext.strict</code> property controls

 * decoding of MIME encoded words.  The MIME spec requires that encoded

 * words start at the beginning of a whitespace separated word.  Some

 * mailers incorrectly include encoded words in the middle of a word.

 * If the <code>mail.mime.decodetext.strict</code> System property is

 * set to <code>"false"</code>, an attempt will be made to decode these

 * illegal encoded words. The default is true. <p>

 *

 * The <code>mail.mime.encodeeol.strict</code> property controls the

 * choice of Content-Transfer-Encoding for MIME parts that are not of

 * type "text".  Often such parts will contain textual data for which

 * an encoding that allows normal end of line conventions is appropriate.

 * In rare cases, such a part will appear to contain entirely textual

 * data, but will require an encoding that preserves CR and LF characters

 * without change.  If the <code>mail.mime.decodetext.strict</code>

 * System property is set to <code>"true"</code>, such an encoding will

 * be used when necessary.  The default is false. <p>

 *

 * In addition, the <code>mail.mime.charset</code> System property can

 * be used to specify the default MIME charset to use for encoded words

 * and text parts that don't otherwise specify a charset.  Normally, the

 * default MIME charset is derived from the default Java charset, as

 * specified in the <code>file.encoding</code> System property.  Most

 * applications will have no need to explicitly set the default MIME

 * charset.  In cases where the default MIME charset to be used for

 * mail messages is different than the charset used for files stored on

 * the system, this property should be set.

 *

 * @version 1.45, 03/03/10

 * @author  John Mani

 * @author  Bill Shannon

 */

public class MimeUtility {

    // This class cannot be instantiated

    private MimeUtility() { }

    public static final int ALL = -1;

    private static final int BUFFER_SIZE = 1024;

    private static boolean decodeStrict = true;

    private static boolean encodeEolStrict = false;

    private static boolean foldEncodedWords = false;

    private static boolean foldText = true;

    static {

        try {

            String s = SAAJUtil.getSystemProperty("mail.mime.decodetext.strict");

            // default to true

            decodeStrict = s == null || !s.equalsIgnoreCase("false");

            s = SAAJUtil.getSystemProperty("mail.mime.encodeeol.strict");

            // default to false

            encodeEolStrict = s != null && s.equalsIgnoreCase("true");

            s = SAAJUtil.getSystemProperty("mail.mime.foldencodedwords");

            // default to false

            foldEncodedWords = s != null && s.equalsIgnoreCase("true");

            s = SAAJUtil.getSystemProperty("mail.mime.foldtext");

            // default to true

            foldText = s == null || !s.equalsIgnoreCase("false");

        } catch (SecurityException sex) {

            // ignore it

        }

    }

    /**

     * Get the content-transfer-encoding that should be applied

     * to the input stream of this datasource, to make it mailsafe. <p>

     *

     * The algorithm used here is: <br>

     * <ul>

     * <li>

     * If the primary type of this datasource is "text" and if all

     * the bytes in its input stream are US-ASCII, then the encoding

     * is "7bit". If more than half of the bytes are non-US-ASCII, then

     * the encoding is "base64". If less than half of the bytes are

     * non-US-ASCII, then the encoding is "quoted-printable".

     * <li>

     * If the primary type of this datasource is not "text", then if

     * all the bytes of its input stream are US-ASCII, the encoding

     * is "7bit". If there is even one non-US-ASCII character, the

     * encoding is "base64".

     * </ul>

     *

     * @param   ds      DataSource

     * @return          the encoding. This is either "7bit",

     *                  "quoted-printable" or "base64"

     */

    public static String getEncoding(DataSource ds) {

        ContentType cType = null;

        InputStream is = null;

        String encoding = null;

        try {

            cType = new ContentType(ds.getContentType());

            is = ds.getInputStream();

        } catch (Exception ex) {

            return "base64"; // what else ?!

        }

        boolean isText = cType.match("text/*");

        // if not text, stop processing when we see non-ASCII

        int i = checkAscii(is, ALL, !isText);

        switch (i) {

        case ALL_ASCII:

            encoding = "7bit"; // all ascii

            break;

        case MOSTLY_ASCII:

            encoding = "quoted-printable"; // mostly ascii

            break;

        default:

            encoding = "base64"; // mostly binary

            break;

        }

        // Close the input stream

        try {

            is.close();

        } catch (IOException ioex) { }

        return encoding;

    }

    /**

     * Same as <code>getEncoding(DataSource)</code> except that instead

     * of reading the data from an <code>InputStream</code> it uses the

     * <code>writeTo</code> method to examine the data.  This is more

     * efficient in the common case of a <code>DataHandler</code>

     * created with an object and a MIME type (for example, a

     * "text/plain" String) because all the I/O is done in this

     * thread.  In the case requiring an <code>InputStream</code> the

     * <code>DataHandler</code> uses a thread, a pair of pipe streams,

     * and the <code>writeTo</code> method to produce the data. <p>

     *

     * @since   JavaMail 1.2

     */

    public static String getEncoding(DataHandler dh) {

        ContentType cType = null;

        String encoding = null;

        /*

         * Try to pick the most efficient means of determining the

         * encoding.  If this DataHandler was created using a DataSource,

         * the getEncoding(DataSource) method is typically faster.  If

         * the DataHandler was created with an object, this method is

         * much faster.  To distinguish the two cases, we use a heuristic.

         * A DataHandler created with an object will always have a null name.

         * A DataHandler created with a DataSource will usually have a

         * non-null name.

         *

         * XXX - This is actually quite a disgusting hack, but it makes

         *       a common case run over twice as fast.

         */

        if (dh.getName() != null)

            return getEncoding(dh.getDataSource());

        try {

            cType = new ContentType(dh.getContentType());

        } catch (Exception ex) {

            return "base64"; // what else ?!

        }

        if (cType.match("text/*")) {

            // Check all of the available bytes

            AsciiOutputStream aos = new AsciiOutputStream(false, false);

            try {

                dh.writeTo(aos);

            } catch (IOException ex) { }        // ignore it

            switch (aos.getAscii()) {

            case ALL_ASCII:

                encoding = "7bit"; // all ascii

                break;

            case MOSTLY_ASCII:

                encoding = "quoted-printable"; // mostly ascii

                break;

            default:

                encoding = "base64"; // mostly binary

                break;

            }

        } else { // not "text"

            // Check all of available bytes, break out if we find

            // at least one non-US-ASCII character

            AsciiOutputStream aos =

                        new AsciiOutputStream(true, encodeEolStrict);

            try {

                dh.writeTo(aos);

            } catch (IOException ex) { }        // ignore it

            if (aos.getAscii() == ALL_ASCII) // all ascii

                encoding = "7bit";

            else // found atleast one non-ascii character, use b64

                encoding = "base64";

        }

        return encoding;

    }

    /**

     * Decode the given input stream. The Input stream returned is

     * the decoded input stream. All the encodings defined in RFC 2045

     * are supported here. They include "base64", "quoted-printable",

     * "7bit", "8bit", and "binary". In addition, "uuencode" is also

     * supported.

     *

     * @param   is              input stream

     * @param   encoding        the encoding of the stream.

     * @return                  decoded input stream.

     */

    public static InputStream decode(InputStream is, String encoding)

                throws MessagingException {

        if (encoding.equalsIgnoreCase("base64"))

            return new BASE64DecoderStream(is);

        else if (encoding.equalsIgnoreCase("quoted-printable"))

            return new QPDecoderStream(is);

        else if (encoding.equalsIgnoreCase("uuencode") ||

                 encoding.equalsIgnoreCase("x-uuencode") ||

                 encoding.equalsIgnoreCase("x-uue"))

            return new UUDecoderStream(is);

        else if (encoding.equalsIgnoreCase("binary") ||

                 encoding.equalsIgnoreCase("7bit") ||

                 encoding.equalsIgnoreCase("8bit"))

            return is;

        else

            throw new MessagingException("Unknown encoding: " + encoding);

    }

    /**

     * Wrap an encoder around the given output stream.

     * All the encodings defined in RFC 2045 are supported here.

     * They include "base64", "quoted-printable", "7bit", "8bit" and

     * "binary". In addition, "uuencode" is also supported.

     *

     * @param   os              output stream

     * @param   encoding        the encoding of the stream.

     * @return                  output stream that applies the

     *                          specified encoding.

     */

    public static OutputStream encode(OutputStream os, String encoding)

                throws MessagingException {

        if (encoding == null)

            return os;

        else if (encoding.equalsIgnoreCase("base64"))

            return new BASE64EncoderStream(os);

        else if (encoding.equalsIgnoreCase("quoted-printable"))

            return new QPEncoderStream(os);

        else if (encoding.equalsIgnoreCase("uuencode") ||

                 encoding.equalsIgnoreCase("x-uuencode") ||

                 encoding.equalsIgnoreCase("x-uue"))

            return new UUEncoderStream(os);

        else if (encoding.equalsIgnoreCase("binary") ||

                 encoding.equalsIgnoreCase("7bit") ||

                 encoding.equalsIgnoreCase("8bit"))

            return os;

        else

            throw new MessagingException("Unknown encoding: " +encoding);

    }

    /**

     * Wrap an encoder around the given output stream.

     * All the encodings defined in RFC 2045 are supported here.

     * They include "base64", "quoted-printable", "7bit", "8bit" and

     * "binary". In addition, "uuencode" is also supported.

     * The <code>filename</code> parameter is used with the "uuencode"

     * encoding and is included in the encoded output.

     *

     * @param   os              output stream

     * @param   encoding        the encoding of the stream.

     * @param   filename        name for the file being encoded (only used

     *                          with uuencode)

     * @return                  output stream that applies the

     *                          specified encoding.

     * @since                   JavaMail 1.2

     */

    public static OutputStream encode(OutputStream os, String encoding,

                                      String filename)

                throws MessagingException {

        if (encoding == null)

            return os;

        else if (encoding.equalsIgnoreCase("base64"))

            return new BASE64EncoderStream(os);

        else if (encoding.equalsIgnoreCase("quoted-printable"))

            return new QPEncoderStream(os);

        else if (encoding.equalsIgnoreCase("uuencode") ||

                 encoding.equalsIgnoreCase("x-uuencode") ||

                 encoding.equalsIgnoreCase("x-uue"))

            return new UUEncoderStream(os, filename);

        else if (encoding.equalsIgnoreCase("binary") ||

                 encoding.equalsIgnoreCase("7bit") ||

                 encoding.equalsIgnoreCase("8bit"))

            return os;

        else

            throw new MessagingException("Unknown encoding: " +encoding);

    }

    /**

     * Encode a RFC 822 "text" token into mail-safe form as per

     * RFC 2047. <p>

     *

     * The given Unicode string is examined for non US-ASCII

     * characters. If the string contains only US-ASCII characters,

     * it is returned as-is.  If the string contains non US-ASCII

     * characters, it is first character-encoded using the platform's

     * default charset, then transfer-encoded using either the B or

     * Q encoding. The resulting bytes are then returned as a Unicode

     * string containing only ASCII  characters. <p>

     *

     * Note that this method should be used to encode only

     * "unstructured" RFC 822 headers. <p>

     *

     * Example of usage:

     * <p><blockquote><pre>

     *

     *  MimeBodyPart part = ...

     *  String rawvalue = "FooBar Mailer, Japanese version 1.1"

     *  try {

     *    // If we know for sure that rawvalue contains only US-ASCII

     *    // characters, we can skip the encoding part

     *    part.setHeader("X-mailer", MimeUtility.encodeText(rawvalue));

     *  } catch (UnsupportedEncodingException e) {

     *    // encoding failure

     *  } catch (MessagingException me) {

     *   // setHeader() failure

     *  }

     *

     * </pre></blockquote><p>

     *

     * @param   text    unicode string

     * @return  Unicode string containing only US-ASCII characters

     * @exception UnsupportedEncodingException if the encoding fails

     */

    public static String encodeText(String text)

                        throws UnsupportedEncodingException {

        return encodeText(text, null, null);

    }

    /**

     * Encode a RFC 822 "text" token into mail-safe form as per

     * RFC 2047. <p>

     *

     * The given Unicode string is examined for non US-ASCII

     * characters. If the string contains only US-ASCII characters,

     * it is returned as-is.  If the string contains non US-ASCII

     * characters, it is first character-encoded using the specified

     * charset, then transfer-encoded using either the B or Q encoding.

     * The resulting bytes are then returned as a Unicode string

     * containing only ASCII characters. <p>

     *

     * Note that this method should be used to encode only

     * "unstructured" RFC 822 headers.

     *

     * @param   text    the header value

     * @param   charset the charset. If this parameter is null, the

     *          platform's default chatset is used.

     * @param   encoding the encoding to be used. Currently supported

     *          values are "B" and "Q". If this parameter is null, then

     *          the "Q" encoding is used if most of characters to be

     *          encoded are in the ASCII charset, otherwise "B" encoding

     *          is used.

     * @return  Unicode string containing only US-ASCII characters

     */

    public static String encodeText(String text, String charset,

                                    String encoding)

                        throws UnsupportedEncodingException {

        return encodeWord(text, charset, encoding, false);

    }

    /**

     * Decode "unstructured" headers, that is, headers that are defined

     * as '*text' as per RFC 822. <p>

     *

     * The string is decoded using the algorithm specified in

     * RFC 2047, Section 6.1.1. If the charset-conversion fails

     * for any sequence, an UnsupportedEncodingException is thrown.

     * If the String is not an RFC 2047 style encoded header, it is

     * returned as-is <p>

     *

     * Example of usage:

     * <p><blockquote><pre>

     *

     *  MimeBodyPart part = ...

     *  String rawvalue = null;

     *  String  value = null;

     *  try {

     *    if ((rawvalue = part.getHeader("X-mailer")[0]) != null)

     *      value = MimeUtility.decodeText(rawvalue);

     *  } catch (UnsupportedEncodingException e) {

     *      // Don't care

     *      value = rawvalue;

     *  } catch (MessagingException me) { }

     *

     *  return value;

     *

     * </pre></blockquote><p>

     *

     * @param   etext   the possibly encoded value

     * @exception       UnsupportedEncodingException if the charset

     *                  conversion failed.

     */

    public static String decodeText(String etext)

                throws UnsupportedEncodingException {

        /*

         * We look for sequences separated by "linear-white-space".

         * (as per RFC 2047, Section 6.1.1)

         * RFC 822 defines "linear-white-space" as SPACE | HT | CR | NL.

         */

        String lwsp = " \t\n\r";

        StringTokenizer st;

        /*

         * First, lets do a quick run thru the string and check

         * whether the sequence "=?"  exists at all. If none exists,

         * we know there are no encoded-words in here and we can just

         * return the string as-is, without suffering thru the later

         * decoding logic.

         * This handles the most common case of unencoded headers

         * efficiently.

         */

        if (etext.indexOf("=?") == -1)

            return etext;

        // Encoded words found. Start decoding ...

        st = new StringTokenizer(etext, lwsp, true);

        StringBuffer sb = new StringBuffer();  // decode buffer

        StringBuffer wsb = new StringBuffer(); // white space buffer

        boolean prevWasEncoded = false;

        while (st.hasMoreTokens()) {

            char c;

            String s = st.nextToken();

            // If whitespace, append it to the whitespace buffer

            if (((c = s.charAt(0)) == ' ') || (c == '\t') ||

                (c == '\r') || (c == '\n'))

                wsb.append(c);

            else {

                // Check if token is an 'encoded-word' ..

                String word;

                try {

                    word = decodeWord(s);