| /* |
| * 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); |
| } |
| } |
