/*

 * 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.

 */

/*

 * @(#)MimeBodyPart.java      1.52 03/02/12

 */

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

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

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

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

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

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.activation.DataHandler;

import java.io.BufferedInputStream;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.util.List;

import javax.activation.DataSource;

import com.sun.xml.internal.org.jvnet.mimepull.MIMEPart;

/**

 * This class represents a MIME body part.

 * MimeBodyParts are contained in <code>MimeMultipart</code>

 * objects. <p>

 *

 * MimeBodyPart uses the <code>InternetHeaders</code> class to parse

 * and store the headers of that body part. <p>

 *

 * <hr><strong>A note on RFC 822 and MIME headers</strong><p>

 *

 * RFC 822 header fields <strong>must</strong> contain only

 * US-ASCII characters. MIME allows non ASCII characters to be present

 * in certain portions of certain headers, by encoding those characters.

 * RFC 2047 specifies the rules for doing this. The MimeUtility

 * class provided in this package can be used to to achieve this.

 * Callers of the <code>setHeader</code>, <code>addHeader</code>, and

 * <code>addHeaderLine</code> methods are responsible for enforcing

 * the MIME requirements for the specified headers.  In addition, these

 * header fields must be folded (wrapped) before being sent if they

 * exceed the line length limitation for the transport (1000 bytes for

 * SMTP).  Received headers may have been folded.  The application is

 * responsible for folding and unfolding headers as appropriate. <p>

 *

 * @author John Mani

 * @author Bill Shannon

 * @see MimeUtility

 */

public final class MimeBodyPart {

    /**

     * This part should be presented as an attachment.

     * @see #getDisposition

     * @see #setDisposition

     */

    public static final String ATTACHMENT = "attachment";

    /**

     * This part should be presented inline.

     * @see #getDisposition

     * @see #setDisposition

     */

    public static final String INLINE = "inline";

    // Paranoia:

    // allow this last minute change to be disabled if it causes problems

    private static boolean setDefaultTextCharset = true;

    static {

        try {

            String s = System.getProperty("mail.mime.setdefaulttextcharset");

            // default to true

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

        } catch (SecurityException sex) {

            // ignore it

        }

    }

    /*

        Data is represented in one of three forms.

        Either we have a DataHandler, or byte[] as the raw content image, or the contentStream.

        It's OK to have more than one of them, provided that they are identical.

    */

    /**

     * The DataHandler object representing this MimeBodyPart's content.

     */

    private DataHandler dh;

    /**

     * Byte array that holds the bytes of the content of this MimeBodyPart.

     * Used in a pair with {@link #contentLength} to denote a regision of a buffer

     * as a valid data.

     */

    private byte[] content;

    private int contentLength;

    private int start = 0;

    /**

     * If the data for this body part was supplied by an

     * InputStream that implements the SharedInputStream interface,

     * <code>contentStream</code> is another such stream representing

     * the content of this body part.  In this case, <code>content</code>

     * will be null.

     *

     * @since   JavaMail 1.2

     */

    private InputStream contentStream;

    /**

     * The InternetHeaders object that stores all the headers

     * of this body part.

     */

    private final InternetHeaders headers;

    /**

     * The <code>MimeMultipart</code> object containing this <code>MimeBodyPart</code>,

     * if known.

     * @since   JavaMail 1.1

     */

    private MimeMultipart parent;

    private MIMEPart mimePart;

    /**

     * An empty MimeBodyPart object is created.

     * This body part maybe filled in by a client constructing a multipart

     * message.

     */

    public MimeBodyPart() {

        headers = new InternetHeaders();

    }

    /**

     * Constructs a MimeBodyPart by reading and parsing the data from

     * the specified input stream. The parser consumes data till the end

     * of the given input stream.  The input stream must start at the

     * beginning of a valid MIME body part and must terminate at the end

     * of that body part. <p>

     *

     * Note that the "boundary" string that delimits body parts must

     * <strong>not</strong> be included in the input stream. The intention

     * is that the MimeMultipart parser will extract each body part's bytes

     * from a multipart stream and feed them into this constructor, without

     * the delimiter strings.

     *

     * @param   is      the body part Input Stream

     */

    public MimeBodyPart(InputStream is) throws MessagingException {

        if (!(is instanceof ByteArrayInputStream) &&

                !(is instanceof BufferedInputStream) &&

                !(is instanceof SharedInputStream))

            is = new BufferedInputStream(is);

        headers = new InternetHeaders(is);

        if (is instanceof SharedInputStream) {

            SharedInputStream sis = (SharedInputStream) is;

            contentStream = sis.newStream(sis.getPosition(), -1);

        } else {

            try {

                bos.write(is);

                content = bos.getBytes();

                contentLength = bos.getCount();

            } catch (IOException ioex) {

                throw new MessagingException("Error reading input stream", ioex);

            }

        }

    }

    /**

     * Constructs a MimeBodyPart using the given header and

     * content bytes. <p>

     *

     * Used by providers.

     *

     * @param   headers The header of this part

     * @param   content bytes representing the body of this part.

     */

    public MimeBodyPart(InternetHeaders headers, byte[] content, int len) {

        this.headers = headers;

        this.content = content;

        this.contentLength = len;

    }

    public MimeBodyPart(

        InternetHeaders headers, byte[] content, int start,  int len) {

        this.headers = headers;

        this.content = content;

        this.start = start;

        this.contentLength = len;

    }

    public MimeBodyPart(MIMEPart part) {

       mimePart = part;

       headers = new InternetHeaders();

       List<? extends com.sun.xml.internal.org.jvnet.mimepull.Header> hdrs = mimePart.getAllHeaders();

        for (com.sun.xml.internal.org.jvnet.mimepull.Header hd : hdrs) {

            headers.addHeader(hd.getName(), hd.getValue());

        }

    }

    /**

     * Return the containing <code>MimeMultipart</code> object,

     * or <code>null</code> if not known.

     */

    public MimeMultipart getParent() {

        return parent;

    }

    /**

     * Set the parent of this <code>MimeBodyPart</code> to be the specified

     * <code>MimeMultipart</code>.  Normally called by <code>MimeMultipart</code>'s

     * <code>addBodyPart</code> method.  <code>parent</code> may be

     * <code>null</code> if the <code>MimeBodyPart</code> is being removed

     * from its containing <code>MimeMultipart</code>.

     * @since   JavaMail 1.1

     */

    public void setParent(MimeMultipart parent) {

        this.parent = parent;

    }

    /**

     * Return the size of the content of this body part in bytes.

     * Return -1 if the size cannot be determined. <p>

     *

     * Note that this number may not be an exact measure of the

     * content size and may or may not account for any transfer

     * encoding of the content. <p>

     *

     * This implementation returns the size of the <code>content</code>

     * array (if not null), or, if <code>contentStream</code> is not

     * null, and the <code>available</code> method returns a positive

     * number, it returns that number as the size.  Otherwise, it returns

     * -1.

     *

     * @return size in bytes, or -1 if not known

     */

    public int getSize() {

        if (mimePart != null) {

            try {

                return mimePart.read().available();

            } catch (IOException ex) {

                return -1;

            }

        }

        if (content != null)

            return contentLength;

        if (contentStream != null) {

            try {

                int size = contentStream.available();

                // only believe the size if it's greate than zero, since zero

                // is the default returned by the InputStream class itself

                if (size > 0)

                    return size;

            } catch (IOException ex) {

                // ignore it

            }

        }

        return -1;

    }

    /**

     * Return the number of lines for the content of this MimeBodyPart.

     * Return -1 if this number cannot be determined. <p>

     *

     * Note that this number may not be an exact measure of the

     * content length and may or may not account for any transfer

     * encoding of the content. <p>

     *

     * This implementation returns -1.

     *

     * @return number of lines, or -1 if not known

     */

     public int getLineCount() {

        return -1;

     }

    /**

     * Returns the value of the RFC 822 "Content-Type" header field.

     * This represents the content type of the content of this

     * body part. This value must not be null. If this field is

     * unavailable, "text/plain" should be returned. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     *

     * @return  Content-Type of this body part

     */

    public String getContentType() {

        if (mimePart != null) {

            return mimePart.getContentType();

        }

        String s = getHeader("Content-Type", null);

        if (s == null)

            s = "text/plain";

        return s;

    }

    /**

     * Is this MimeBodyPart of the specified MIME type?  This method

     * compares <strong>only the <code>primaryType</code> and

     * <code>subType</code></strong>.

     * The parameters of the content types are ignored. <p>

     *

     * For example, this method will return <code>true</code> when

     * comparing a MimeBodyPart of content type <strong>"text/plain"</strong>

     * with <strong>"text/plain; charset=foobar"</strong>. <p>

     *

     * If the <code>subType</code> of <code>mimeType</code> is the

     * special character '*', then the subtype is ignored during the

     * comparison.

     */

    public boolean isMimeType(String mimeType) {

        boolean result;

        // XXX - lots of room for optimization here!

        try {

            ContentType ct = new ContentType(getContentType());

            result = ct.match(mimeType);

        } catch (ParseException ex) {

            result = getContentType().equalsIgnoreCase(mimeType);

        }

        return result;

    }

    /**

     * Returns the value of the "Content-Disposition" header field.

     * This represents the disposition of this part. The disposition

     * describes how the part should be presented to the user. <p>

     *

     * If the Content-Disposition field is unavailable,

     * null is returned. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     *

     * @see #headers

     */

    public String getDisposition() throws MessagingException {

        String s = getHeader("Content-Disposition", null);

        if (s == null)

            return null;

        ContentDisposition cd = new ContentDisposition(s);

        return cd.getDisposition();

    }

    /**

     * Set the "Content-Disposition" header field of this body part.

     * If the disposition is null, any existing "Content-Disposition"

     * header field is removed.

     *

     * @exception       IllegalStateException if this body part is

     *                  obtained from a READ_ONLY folder.

     */

    public void setDisposition(String disposition) throws MessagingException {

        if (disposition == null)

            removeHeader("Content-Disposition");

        else {

            String s = getHeader("Content-Disposition", null);

            if (s != null) {

                /* A Content-Disposition header already exists ..

                 *

                 * Override disposition, but attempt to retain

                 * existing disposition parameters

                 */

                ContentDisposition cd = new ContentDisposition(s);

                cd.setDisposition(disposition);

                disposition = cd.toString();

            }

            setHeader("Content-Disposition", disposition);

        }

    }

    /**

     * Returns the content transfer encoding from the

     * "Content-Transfer-Encoding" header

     * field. Returns <code>null</code> if the header is unavailable

     * or its value is absent. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     *

     * @see #headers

     */

    public String getEncoding() throws MessagingException {

        String s = getHeader("Content-Transfer-Encoding", null);

        if (s == null)

            return null;

        s = s.trim();   // get rid of trailing spaces

        // quick check for known values to avoid unnecessary use

        // of tokenizer.

        if (s.equalsIgnoreCase("7bit") || s.equalsIgnoreCase("8bit") ||

            s.equalsIgnoreCase("quoted-printable") ||

            s.equalsIgnoreCase("base64"))

            return s;

        // Tokenize the header to obtain the encoding (skip comments)

        HeaderTokenizer h = new HeaderTokenizer(s, HeaderTokenizer.MIME);

        HeaderTokenizer.Token tk;

        int tkType;

        for (;;) {

            tk = h.next(); // get a token

            tkType = tk.getType();

            if (tkType == HeaderTokenizer.Token.EOF)

            break; // done

            else if (tkType == HeaderTokenizer.Token.ATOM)

            return tk.getValue();

            else // invalid token, skip it.

            continue;

        }

        return s;

    }

    /**

     * Returns the value of the "Content-ID" header field. Returns

     * <code>null</code> if the field is unavailable or its value is

     * absent. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     */

    public String getContentID() {

        return getHeader("Content-ID", null);

    }

    /**

     * Set the "Content-ID" header field of this body part.

     * If the <code>cid</code> parameter is null, any existing

     * "Content-ID" is removed.

     *

     * @exception       IllegalStateException if this body part is

     *                  obtained from a READ_ONLY folder.

     * @since           JavaMail 1.3

     */

    public void setContentID(String cid) {

        if (cid == null)

            removeHeader("Content-ID");

        else

            setHeader("Content-ID", cid);

    }

    /**

     * Return the value of the "Content-MD5" header field. Returns

     * <code>null</code> if this field is unavailable or its value

     * is absent. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     */

    public String getContentMD5() {

        return getHeader("Content-MD5", null);

    }

    /**

     * Set the "Content-MD5" header field of this body part.

     *

     * @exception       IllegalStateException if this body part is

     *                  obtained from a READ_ONLY folder.

     */

    public void setContentMD5(String md5) {

        setHeader("Content-MD5", md5);

    }

    /**

     * Get the languages specified in the Content-Language header

     * of this MimeBodyPart. The Content-Language header is defined by

     * RFC 1766. Returns <code>null</code> if this header is not

     * available or its value is absent. <p>

     *

     * This implementation uses <code>getHeader(name)</code>

     * to obtain the requisite header field.

     */

    public String[] getContentLanguage() throws MessagingException {

        String s = getHeader("Content-Language", null);

        if (s == null)

            return null;

        // Tokenize the header to obtain the Language-tags (skip comments)

        HeaderTokenizer h = new HeaderTokenizer(s, HeaderTokenizer.MIME);