Mercurial > jdk8-mips64-public > jaxws / file revision

 /*

  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.

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

                 ByteOutputStream bos = new ByteOutputStream();

                 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);

         FinalArrayList v = new FinalArrayList();

         HeaderTokenizer.Token tk;

         int tkType;

         while (true) {

             tk = h.next(); // get a language-tag

             tkType = tk.getType();

             if (tkType == HeaderTokenizer.Token.EOF)

             break; // done

             else if (tkType == HeaderTokenizer.Token.ATOM) v.add(tk.getValue());

             else // invalid token, skip it.

             continue;

         }

         if (v.size() == 0)

             return null;

         return (String[])v.toArray(new String[v.size()]);

     }

     /**

      * Set the Content-Language header of this MimeBodyPart. The

      * Content-Language header is defined by RFC 1766.

      *

      * @param languages         array of language tags

      */

     public void setContentLanguage(String[] languages) {

         StringBuffer sb = new StringBuffer(languages[0]);

         for (int i = 1; i < languages.length; i++)

             sb.append(',').append(languages[i]);

         setHeader("Content-Language", sb.toString());

     }

     /**

      * Returns the "Content-Description" header field of this body part.

      * This typically associates some descriptive information with

      * this part. Returns null if this field is unavailable or its

      * value is absent. <p>

      *

      * If the Content-Description field is encoded as per RFC 2047,

      * it is decoded and converted into Unicode. If the decoding or

      * conversion fails, the raw data is returned as is. <p>

      *

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

      * to obtain the requisite header field.

      *

      * @return  content description

      */

     public String getDescription() {

         String rawvalue = getHeader("Content-Description", null);

         if (rawvalue == null)

             return null;

         try {

             return MimeUtility.decodeText(MimeUtility.unfold(rawvalue));

         } catch (UnsupportedEncodingException ex) {

             return rawvalue;

         }

     }

     /**

      * Set the "Content-Description" header field for this body part.

      * If the description parameter is <code>null</code>, then any

      * existing "Content-Description" fields are removed. <p>

      *

      * If the description contains non US-ASCII characters, it will

      * be encoded using the platform's default charset. If the

      * description contains only US-ASCII characters, no encoding

      * is done and it is used as is. <p>

      *

      * Note that if the charset encoding process fails, a

      * MessagingException is thrown, and an UnsupportedEncodingException

      * is included in the chain of nested exceptions within the

      * MessagingException.

      *

      * @param description content description

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      * @exception       MessagingException An

      *                  UnsupportedEncodingException may be included

      *                  in the exception chain if the charset

      *                  conversion fails.

      */

     public void setDescription(String description) throws MessagingException {

         setDescription(description, null);

     }

     /**

      * Set the "Content-Description" header field for this body part.

      * If the description parameter is <code>null</code>, then any

      * existing "Content-Description" fields are removed. <p>

      *

      * If the description contains non US-ASCII characters, it will

      * be encoded using the specified charset. If the description

      * contains only US-ASCII characters, no encoding  is done and

      * it is used as is. <p>

      *

      * Note that if the charset encoding process fails, a

      * MessagingException is thrown, and an UnsupportedEncodingException

      * is included in the chain of nested exceptions within the

      * MessagingException.

      *

      * @param   description     Description

      * @param   charset         Charset for encoding

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      * @exception       MessagingException An

      *                  UnsupportedEncodingException may be included

      *                  in the exception chain if the charset

      *                  conversion fails.

      */

     public void setDescription(String description, String charset)

                 throws MessagingException {

         if (description == null) {

             removeHeader("Content-Description");

             return;

         }

         try {

             setHeader("Content-Description", MimeUtility.fold(21,

             MimeUtility.encodeText(description, charset, null)));

         } catch (UnsupportedEncodingException uex) {

             throw new MessagingException("Encoding error", uex);

         }

     }

     /**

      * Get the filename associated with this body part. <p>

      *

      * Returns the value of the "filename" parameter from the

      * "Content-Disposition" header field of this body part. If its

      * not available, returns the value of the "name" parameter from

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

      * Returns <code>null</code> if both are absent.

      *

      * @return  filename

      */

     public String getFileName() throws MessagingException {

         String filename = null;

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

         if (s != null) {

             // Parse the header ..

             ContentDisposition cd = new ContentDisposition(s);

             filename = cd.getParameter("filename");

         }

         if (filename == null) {

             // Still no filename ? Try the "name" ContentType parameter

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

             if (s != null) {

             try {

                 ContentType ct = new ContentType(s);

                 filename = ct.getParameter("name");

             } catch (ParseException pex) { }    // ignore it

             }

         }

         return filename;

     }

     /**

      * Set the filename associated with this body part, if possible. <p>

      *

      * Sets the "filename" parameter of the "Content-Disposition"

      * header field of this body part.

      *

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      */

     public void setFileName(String filename) throws MessagingException {

         // Set the Content-Disposition "filename" parameter

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

         ContentDisposition cd =

             new ContentDisposition(s == null ? ATTACHMENT : s);

         cd.setParameter("filename", filename);

         setHeader("Content-Disposition", cd.toString());

         /* Also attempt to set the Content-Type "name" parameter,

          * to satisfy ancient MUAs.

          * XXX: This is not RFC compliant, and hence should really

          * be conditional based on some property. Fix this once we

          * figure out how to get at Properties from here !

          */

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

         if (s != null) {

             try {

             ContentType cType = new ContentType(s);

             cType.setParameter("name", filename);

             setHeader("Content-Type", cType.toString());

             } catch (ParseException pex) { }    // ignore it

         }

     }

     /**

      * Return a decoded input stream for this body part's "content". <p>

      *

      * This implementation obtains the input stream from the DataHandler.

      * That is, it invokes getDataHandler().getInputStream();

      *

      * @return          an InputStream

      * @exception       IOException this is typically thrown by the

      *                  DataHandler. Refer to the documentation for

      *                  javax.activation.DataHandler for more details.

      *

      * @see     #getContentStream

      * @see     DataHandler#getInputStream

      */

     public InputStream getInputStream()

                 throws IOException {

         return getDataHandler().getInputStream();

     }

    /**

      * Produce the raw bytes of the content. This method is used

      * when creating a DataHandler object for the content. Subclasses

      * that can provide a separate input stream for just the MimeBodyPart

      * content might want to override this method. <p>

      *

      * @see #content

      */

     /*package*/ InputStream getContentStream() throws MessagingException {

         if (mimePart != null) {

             return mimePart.read();

         }

         if (contentStream != null)

             return ((SharedInputStream)contentStream).newStream(0, -1);

         if (content != null)

             return new ByteArrayInputStream(content,start,contentLength);

         throw new MessagingException("No content");

     }

     /**

      * Return an InputStream to the raw data with any Content-Transfer-Encoding

      * intact.  This method is useful if the "Content-Transfer-Encoding"

      * header is incorrect or corrupt, which would prevent the

      * <code>getInputStream</code> method or <code>getContent</code> method

      * from returning the correct data.  In such a case the application may

      * use this method and attempt to decode the raw data itself. <p>

      *

      * This implementation simply calls the <code>getContentStream</code>

      * method.

      *

      * @see     #getInputStream

      * @see     #getContentStream

      * @since   JavaMail 1.2

      */

     public InputStream getRawInputStream() throws MessagingException {

         return getContentStream();

     }

     /**

      * Return a DataHandler for this body part's content. <p>

      *

      * The implementation provided here works just like the

      * the implementation in MimeMessage.

      */

     public DataHandler getDataHandler() {

         if (mimePart != null) {

             //return an inputstream

             return new DataHandler(new DataSource() {

                 public InputStream getInputStream() throws IOException {

                     return mimePart.read();

                 }

                 public OutputStream getOutputStream() throws IOException {

                     throw new UnsupportedOperationException("getOutputStream cannot be supported : You have enabled LazyAttachments Option");

                 }

                 public String getContentType() {

                     return mimePart.getContentType();

                 }

                 public String getName() {

                     return "MIMEPart Wrapped DataSource";

                 }

             });

         }

         if (dh == null)

             dh = new DataHandler(new MimePartDataSource(this));

         return dh;

     }

     /**

      * Return the content as a java object. The type of the object

      * returned is of course dependent on the content itself. For

      * example, the native format of a text/plain content is usually

      * a String object. The native format for a "multipart"

      * content is always a MimeMultipart subclass. For content types that are

      * unknown to the DataHandler system, an input stream is returned

      * as the content. <p>

      *

      * This implementation obtains the content from the DataHandler.

      * That is, it invokes getDataHandler().getContent();

      *

      * @return          Object

      * @exception       IOException this is typically thrown by the

      *                  DataHandler. Refer to the documentation for

      *                  javax.activation.DataHandler for more details.

      */

     public Object getContent() throws IOException {

         return getDataHandler().getContent();

     }

     /**

      * This method provides the mechanism to set this body part's content.

      * The given DataHandler object should wrap the actual content.

      *

      * @param   dh      The DataHandler for the content

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      */

     public void setDataHandler(DataHandler dh) {

         if (mimePart != null) {

             mimePart = null;

         }

         this.dh = dh;

         this.content = null;

         this.contentStream = null;

         removeHeader("Content-Type");

         removeHeader("Content-Transfer-Encoding");

     }

     /**

      * A convenience method for setting this body part's content. <p>

      *

      * The content is wrapped in a DataHandler object. Note that a

      * DataContentHandler class for the specified type should be

      * available to the JavaMail implementation for this to work right.

      * That is, to do <code>setContent(foobar, "application/x-foobar")</code>,

      * a DataContentHandler for "application/x-foobar" should be installed.

      * Refer to the Java Activation Framework for more information.

      *

      * @param   o       the content object

      * @param   type    Mime type of the object

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      */

     public void setContent(Object o, String type) {

         if (mimePart != null) {

             mimePart = null;

         }

         if (o instanceof MimeMultipart) {

             setContent((MimeMultipart)o);

         } else {

             setDataHandler(new DataHandler(o, type));

         }

     }

     /**

      * Convenience method that sets the given String as this

      * part's content, with a MIME type of "text/plain". If the

      * string contains non US-ASCII characters, it will be encoded

      * using the platform's default charset. The charset is also

      * used to set the "charset" parameter. <p>

      *

      * Note that there may be a performance penalty if

      * <code>text</code> is large, since this method may have

      * to scan all the characters to determine what charset to

      * use. <p>

      * If the charset is already known, use the

      * setText() version that takes the charset parameter.

      *

      * @see     #setText(String text, String charset)

      */

     public void setText(String text) {

         setText(text, null);

     }

     /**

      * Convenience method that sets the given String as this part's

      * content, with a MIME type of "text/plain" and the specified

      * charset. The given Unicode string will be charset-encoded

      * using the specified charset. The charset is also used to set

      * the "charset" parameter.

      */

     public void setText(String text, String charset) {

         if (charset == null) {

             if (MimeUtility.checkAscii(text) != MimeUtility.ALL_ASCII)

                 charset = MimeUtility.getDefaultMIMECharset();

             else

                 charset = "us-ascii";

         }

         setContent(text, "text/plain; charset=" +

                 MimeUtility.quote(charset, HeaderTokenizer.MIME));

     }

     /**

      * This method sets the body part's content to a MimeMultipart object.

      *

      * @param  mp       The multipart object that is the Message's content

      * @exception       IllegalStateException if this body part is

      *                  obtained from a READ_ONLY folder.

      */

     public void setContent(MimeMultipart mp) {

         if (mimePart != null) {

             mimePart = null;

         }

         setDataHandler(new DataHandler(mp, mp.getContentType().toString()));

         mp.setParent(this);

     }

     /**

      * Output the body part as an RFC 822 format stream.

      *

      * @exception MessagingException

      * @exception IOException   if an error occurs writing to the

      *                          stream or if an error is generated

      *                          by the javax.activation layer.

      * @see DataHandler#writeTo

      */

     public void writeTo(OutputStream os)

                                 throws IOException, MessagingException {

         // First, write out the header

         List hdrLines = headers.getAllHeaderLines();

         int sz = hdrLines.size();

         for( int i=0; i<sz; i++ )

             OutputUtil.writeln((String)hdrLines.get(i),os);

         // The CRLF separator between header and content

         OutputUtil.writeln(os);

         // Finally, the content.

         // XXX: May need to account for ESMTP ?

         if (contentStream != null) {

             ((SharedInputStream)contentStream).writeTo(0,-1,os);

         } else

         if (content != null) {

             os.write(content,start,contentLength);

         } else

         if (dh!=null) {

             // this is the slowest route, so try it as the last resort

             OutputStream wos = MimeUtility.encode(os, getEncoding());

             getDataHandler().writeTo(wos);

             if(os!=wos)

                 wos.flush(); // Needed to complete encoding

         } else if (mimePart != null) {

             OutputStream wos = MimeUtility.encode(os, getEncoding());

             getDataHandler().writeTo(wos);

             if(os!=wos)

                 wos.flush(); // Needed to complete encoding

         }else {

             throw new MessagingException("no content");

         }

     }

     /**

      * Get all the headers for this header_name. Note that certain

      * headers may be encoded as per RFC 2047 if they contain

      * non US-ASCII characters and these should be decoded.

      *

      * @param   name    name of header

      * @return  array of headers

      * @see     MimeUtility

      */

     public String[] getHeader(String name) {

         return headers.getHeader(name);

     }

     /**

      * Get all the headers for this header name, returned as a single

      * String, with headers separated by the delimiter. If the

      * delimiter is <code>null</code>, only the first header is

      * returned.

      *

      * @param name              the name of this header

      * @param delimiter         delimiter between fields in returned string

      * @return                  the value fields for all headers with

      *                          this name

      */

     public String getHeader(String name, String delimiter) {

         return headers.getHeader(name, delimiter);

     }

     /**

      * Set the value for this header_name. Replaces all existing

      * header values with this new value. Note that RFC 822 headers

      * must contain only US-ASCII characters, so a header that

      * contains non US-ASCII characters must be encoded as per the

      * rules of RFC 2047.

      *

      * @param   name    header name

      * @param   value   header value

      * @see     MimeUtility

      */

     public void setHeader(String name, String value) {

         headers.setHeader(name, value);

     }

     /**

      * Add this value to the existing values for this header_name.

      * Note that RFC 822 headers must contain only US-ASCII

      * characters, so a header that contains non US-ASCII characters

      * must be encoded as per the rules of RFC 2047.

      *

      * @param   name    header name

      * @param   value   header value

      * @see     MimeUtility

      */

     public void addHeader(String name, String value) {

         headers.addHeader(name, value);

     }

     /**

      * Remove all headers with this name.

      */

     public void removeHeader(String name) {

         headers.removeHeader(name);

     }

     /**

      * Return all the headers from this Message as an Enumeration of

      * Header objects.

      */

     public FinalArrayList getAllHeaders() {

         return headers.getAllHeaders();

     }

     /**

      * Add a header line to this body part

      */

     public void addHeaderLine(String line) {

         headers.addHeaderLine(line);

     }

     /**

      * Examine the content of this body part and update the appropriate

      * MIME headers.  Typical headers that get set here are

      * <code>Content-Type</code> and <code>Content-Transfer-Encoding</code>.

      * Headers might need to be updated in two cases:

      *

      * <br>

      * - A message being crafted by a mail application will certainly

      * need to activate this method at some point to fill up its internal

      * headers.

      *

      * <br>

      * - A message read in from a Store will have obtained

      * all its headers from the store, and so doesn't need this.

      * However, if this message is editable and if any edits have

      * been made to either the content or message structure, we might

      * need to resync our headers.

      *

      * <br>

      * In both cases this method is typically called by the

      * <code>Message.saveChanges</code> method.

      */

     protected void updateHeaders() throws MessagingException {

         DataHandler dh = getDataHandler();

         if (dh == null) // Huh ?

             return;

         try {

             String type = dh.getContentType();

             boolean composite = false;

             boolean needCTHeader = getHeader("Content-Type") == null;

             ContentType cType = new ContentType(type);

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

                 // If multipart, recurse

                 composite = true;

                 Object o = dh.getContent();

                 ((MimeMultipart) o).updateHeaders();

             } else if (cType.match("message/rfc822")) {

                 composite = true;

             }

             // Content-Transfer-Encoding, but only if we don't

             // already have one

             if (!composite) {   // not allowed on composite parts

                 if (getHeader("Content-Transfer-Encoding") == null)

                     setEncoding(MimeUtility.getEncoding(dh));

                 if (needCTHeader && setDefaultTextCharset &&

                         cType.match("text/*") &&

                         cType.getParameter("charset") == null) {

                     /*

                      * Set a default charset for text parts.

                      * We really should examine the data to determine

                      * whether or not it's all ASCII, but that's too

                      * expensive so we make an assumption:  If we

                      * chose 7bit encoding for this data, it's probably

                      * ASCII.  (MimeUtility.getEncoding will choose

                      * 7bit only in this case, but someone might've

                      * set the Content-Transfer-Encoding header manually.)

                      */

                     String charset;

                     String enc = getEncoding();

                     if (enc != null && enc.equalsIgnoreCase("7bit"))

                         charset = "us-ascii";

                     else

                         charset = MimeUtility.getDefaultMIMECharset();

                     cType.setParameter("charset", charset);

                     type = cType.toString();

                 }

             }

             // Now, let's update our own headers ...

             // Content-type, but only if we don't already have one

             if (needCTHeader) {

                 /*

                  * Pull out "filename" from Content-Disposition, and

                  * use that to set the "name" parameter. This is to

                  * satisfy older MUAs (DtMail, Roam and probably

                  * a bunch of others).

                  */

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

                 if (s != null) {

                     // Parse the header ..

                     ContentDisposition cd = new ContentDisposition(s);

                     String filename = cd.getParameter("filename");

                     if (filename != null) {

                         cType.setParameter("name", filename);

                         type = cType.toString();

                     }

                 }

                 setHeader("Content-Type", type);

             }

         } catch (IOException ex) {

             throw new MessagingException("IOException updating headers", ex);

         }

     }

     private void setEncoding(String encoding) {

             setHeader("Content-Transfer-Encoding", encoding);

     }

 }