477 lines
19 KiB
Java
477 lines
19 KiB
Java
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.emailcommon.internet;
|
|
|
|
import android.util.Base64;
|
|
import android.util.Base64DataException;
|
|
import android.util.Base64InputStream;
|
|
import android.util.Log;
|
|
|
|
import com.android.emailcommon.Logging;
|
|
import com.android.emailcommon.mail.Body;
|
|
import com.android.emailcommon.mail.BodyPart;
|
|
import com.android.emailcommon.mail.Message;
|
|
import com.android.emailcommon.mail.MessagingException;
|
|
import com.android.emailcommon.mail.Multipart;
|
|
import com.android.emailcommon.mail.Part;
|
|
|
|
import org.apache.commons.io.IOUtils;
|
|
import org.apache.james.mime4j.codec.EncoderUtil;
|
|
import org.apache.james.mime4j.decoder.DecoderUtil;
|
|
import org.apache.james.mime4j.decoder.QuotedPrintableInputStream;
|
|
import org.apache.james.mime4j.util.CharsetUtil;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
public class MimeUtility {
|
|
|
|
public static final String MIME_TYPE_RFC822 = "message/rfc822";
|
|
private final static Pattern PATTERN_CR_OR_LF = Pattern.compile("\r|\n");
|
|
|
|
/**
|
|
* Replace sequences of CRLF+WSP with WSP. Tries to preserve original string
|
|
* object whenever possible.
|
|
*/
|
|
public static String unfold(String s) {
|
|
if (s == null) {
|
|
return null;
|
|
}
|
|
Matcher patternMatcher = PATTERN_CR_OR_LF.matcher(s);
|
|
if (patternMatcher.find()) {
|
|
patternMatcher.reset();
|
|
s = patternMatcher.replaceAll("");
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public static String decode(String s) {
|
|
if (s == null) {
|
|
return null;
|
|
}
|
|
return DecoderUtil.decodeEncodedWords(s);
|
|
}
|
|
|
|
public static String unfoldAndDecode(String s) {
|
|
return decode(unfold(s));
|
|
}
|
|
|
|
// TODO implement proper foldAndEncode
|
|
// NOTE: When this really works, we *must* remove all calls to foldAndEncode2() to prevent
|
|
// duplication of encoding.
|
|
public static String foldAndEncode(String s) {
|
|
return s;
|
|
}
|
|
|
|
/**
|
|
* INTERIM version of foldAndEncode that will be used only by Subject: headers.
|
|
* This is safer than implementing foldAndEncode() (see above) and risking unknown damage
|
|
* to other headers.
|
|
*
|
|
* TODO: Copy this code to foldAndEncode(), get rid of this function, confirm all working OK.
|
|
*
|
|
* @param s original string to encode and fold
|
|
* @param usedCharacters number of characters already used up by header name
|
|
|
|
* @return the String ready to be transmitted
|
|
*/
|
|
public static String foldAndEncode2(String s, int usedCharacters) {
|
|
// james.mime4j.codec.EncoderUtil.java
|
|
// encode: encodeIfNecessary(text, usage, numUsedInHeaderName)
|
|
// Usage.TEXT_TOKENlooks like the right thing for subjects
|
|
// use WORD_ENTITY for address/names
|
|
|
|
String encoded = EncoderUtil.encodeIfNecessary(s, EncoderUtil.Usage.TEXT_TOKEN,
|
|
usedCharacters);
|
|
|
|
return fold(encoded, usedCharacters);
|
|
}
|
|
|
|
/**
|
|
* INTERIM: From newer version of org.apache.james (but we don't want to import
|
|
* the entire MimeUtil class).
|
|
*
|
|
* Splits the specified string into a multiple-line representation with
|
|
* lines no longer than 76 characters (because the line might contain
|
|
* encoded words; see <a href='http://www.faqs.org/rfcs/rfc2047.html'>RFC
|
|
* 2047</a> section 2). If the string contains non-whitespace sequences
|
|
* longer than 76 characters a line break is inserted at the whitespace
|
|
* character following the sequence resulting in a line longer than 76
|
|
* characters.
|
|
*
|
|
* @param s
|
|
* string to split.
|
|
* @param usedCharacters
|
|
* number of characters already used up. Usually the number of
|
|
* characters for header field name plus colon and one space.
|
|
* @return a multiple-line representation of the given string.
|
|
*/
|
|
public static String fold(String s, int usedCharacters) {
|
|
final int maxCharacters = 76;
|
|
|
|
final int length = s.length();
|
|
if (usedCharacters + length <= maxCharacters)
|
|
return s;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
int lastLineBreak = -usedCharacters;
|
|
int wspIdx = indexOfWsp(s, 0);
|
|
while (true) {
|
|
if (wspIdx == length) {
|
|
sb.append(s.substring(Math.max(0, lastLineBreak)));
|
|
return sb.toString();
|
|
}
|
|
|
|
int nextWspIdx = indexOfWsp(s, wspIdx + 1);
|
|
|
|
if (nextWspIdx - lastLineBreak > maxCharacters) {
|
|
sb.append(s.substring(Math.max(0, lastLineBreak), wspIdx));
|
|
sb.append("\r\n");
|
|
lastLineBreak = wspIdx;
|
|
}
|
|
|
|
wspIdx = nextWspIdx;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* INTERIM: From newer version of org.apache.james (but we don't want to import
|
|
* the entire MimeUtil class).
|
|
*
|
|
* Search for whitespace.
|
|
*/
|
|
private static int indexOfWsp(String s, int fromIndex) {
|
|
final int len = s.length();
|
|
for (int index = fromIndex; index < len; index++) {
|
|
char c = s.charAt(index);
|
|
if (c == ' ' || c == '\t')
|
|
return index;
|
|
}
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* Returns the named parameter of a header field. If name is null the first
|
|
* parameter is returned, or if there are no additional parameters in the
|
|
* field the entire field is returned. Otherwise the named parameter is
|
|
* searched for in a case insensitive fashion and returned. If the parameter
|
|
* cannot be found the method returns null.
|
|
*
|
|
* TODO: quite inefficient with the inner trimming & splitting.
|
|
* TODO: Also has a latent bug: uses "startsWith" to match the name, which can false-positive.
|
|
* TODO: The doc says that for a null name you get the first param, but you get the header.
|
|
* Should probably just fix the doc, but if other code assumes that behavior, fix the code.
|
|
* TODO: Need to decode %-escaped strings, as in: filename="ab%22d".
|
|
* ('+' -> ' ' conversion too? check RFC)
|
|
*
|
|
* @param header
|
|
* @param name
|
|
* @return the entire header (if name=null), the found parameter, or null
|
|
*/
|
|
public static String getHeaderParameter(String header, String name) {
|
|
if (header == null) {
|
|
return null;
|
|
}
|
|
String[] parts = unfold(header).split(";");
|
|
if (name == null) {
|
|
return parts[0].trim();
|
|
}
|
|
String lowerCaseName = name.toLowerCase();
|
|
for (String part : parts) {
|
|
if (part.trim().toLowerCase().startsWith(lowerCaseName)) {
|
|
String[] parameterParts = part.split("=", 2);
|
|
if (parameterParts.length < 2) {
|
|
return null;
|
|
}
|
|
String parameter = parameterParts[1].trim();
|
|
if (parameter.startsWith("\"") && parameter.endsWith("\"")) {
|
|
return parameter.substring(1, parameter.length() - 1);
|
|
} else {
|
|
return parameter;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static Part findFirstPartByMimeType(Part part, String mimeType)
|
|
throws MessagingException {
|
|
if (part.getBody() instanceof Multipart) {
|
|
Multipart multipart = (Multipart)part.getBody();
|
|
for (int i = 0, count = multipart.getCount(); i < count; i++) {
|
|
BodyPart bodyPart = multipart.getBodyPart(i);
|
|
Part ret = findFirstPartByMimeType(bodyPart, mimeType);
|
|
if (ret != null) {
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
else if (part.getMimeType().equalsIgnoreCase(mimeType)) {
|
|
return part;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static Part findPartByContentId(Part part, String contentId) throws Exception {
|
|
if (part.getBody() instanceof Multipart) {
|
|
Multipart multipart = (Multipart)part.getBody();
|
|
for (int i = 0, count = multipart.getCount(); i < count; i++) {
|
|
BodyPart bodyPart = multipart.getBodyPart(i);
|
|
Part ret = findPartByContentId(bodyPart, contentId);
|
|
if (ret != null) {
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
String cid = part.getContentId();
|
|
if (contentId.equals(cid)) {
|
|
return part;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Reads the Part's body and returns a String based on any charset conversion that needed
|
|
* to be done.
|
|
* @param part The part containing a body
|
|
* @return a String containing the converted text in the body, or null if there was no text
|
|
* or an error during conversion.
|
|
*/
|
|
public static String getTextFromPart(Part part) {
|
|
try {
|
|
if (part != null && part.getBody() != null) {
|
|
InputStream in = part.getBody().getInputStream();
|
|
String mimeType = part.getMimeType();
|
|
if (mimeType != null && MimeUtility.mimeTypeMatches(mimeType, "text/*")) {
|
|
/*
|
|
* Now we read the part into a buffer for further processing. Because
|
|
* the stream is now wrapped we'll remove any transfer encoding at this point.
|
|
*/
|
|
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
|
IOUtils.copy(in, out);
|
|
in.close();
|
|
in = null; // we want all of our memory back, and close might not release
|
|
|
|
/*
|
|
* We've got a text part, so let's see if it needs to be processed further.
|
|
*/
|
|
String charset = getHeaderParameter(part.getContentType(), "charset");
|
|
if (charset != null) {
|
|
/*
|
|
* See if there is conversion from the MIME charset to the Java one.
|
|
*/
|
|
charset = CharsetUtil.toJavaCharset(charset);
|
|
}
|
|
/*
|
|
* No encoding, so use us-ascii, which is the standard.
|
|
*/
|
|
if (charset == null) {
|
|
charset = "ASCII";
|
|
}
|
|
/*
|
|
* Convert and return as new String
|
|
*/
|
|
String result = out.toString(charset);
|
|
out.close();
|
|
return result;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (OutOfMemoryError oom) {
|
|
/*
|
|
* If we are not able to process the body there's nothing we can do about it. Return
|
|
* null and let the upper layers handle the missing content.
|
|
*/
|
|
Log.e(Logging.LOG_TAG, "Unable to getTextFromPart " + oom.toString());
|
|
}
|
|
catch (Exception e) {
|
|
/*
|
|
* If we are not able to process the body there's nothing we can do about it. Return
|
|
* null and let the upper layers handle the missing content.
|
|
*/
|
|
Log.e(Logging.LOG_TAG, "Unable to getTextFromPart " + e.toString());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given mimeType matches the matchAgainst specification. The comparison
|
|
* ignores case and the matchAgainst string may include "*" for a wildcard (e.g. "image/*").
|
|
*
|
|
* @param mimeType A MIME type to check.
|
|
* @param matchAgainst A MIME type to check against. May include wildcards.
|
|
* @return true if the mimeType matches
|
|
*/
|
|
public static boolean mimeTypeMatches(String mimeType, String matchAgainst) {
|
|
Pattern p = Pattern.compile(matchAgainst.replaceAll("\\*", "\\.\\*"),
|
|
Pattern.CASE_INSENSITIVE);
|
|
return p.matcher(mimeType).matches();
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given mimeType matches any of the matchAgainst specifications. The
|
|
* comparison ignores case and the matchAgainst strings may include "*" for a wildcard
|
|
* (e.g. "image/*").
|
|
*
|
|
* @param mimeType A MIME type to check.
|
|
* @param matchAgainst An array of MIME types to check against. May include wildcards.
|
|
* @return true if the mimeType matches any of the matchAgainst strings
|
|
*/
|
|
public static boolean mimeTypeMatches(String mimeType, String[] matchAgainst) {
|
|
for (String matchType : matchAgainst) {
|
|
if (mimeTypeMatches(mimeType, matchType)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Given an input stream and a transfer encoding, return a wrapped input stream for that
|
|
* encoding (or the original if none is required)
|
|
* @param in the input stream
|
|
* @param contentTransferEncoding the content transfer encoding
|
|
* @return a properly wrapped stream
|
|
*/
|
|
public static InputStream getInputStreamForContentTransferEncoding(InputStream in,
|
|
String contentTransferEncoding) {
|
|
if (contentTransferEncoding != null) {
|
|
contentTransferEncoding =
|
|
MimeUtility.getHeaderParameter(contentTransferEncoding, null);
|
|
if ("quoted-printable".equalsIgnoreCase(contentTransferEncoding)) {
|
|
in = new QuotedPrintableInputStream(in);
|
|
}
|
|
else if ("base64".equalsIgnoreCase(contentTransferEncoding)) {
|
|
in = new Base64InputStream(in, Base64.DEFAULT);
|
|
}
|
|
}
|
|
return in;
|
|
}
|
|
|
|
/**
|
|
* Removes any content transfer encoding from the stream and returns a Body.
|
|
*/
|
|
public static Body decodeBody(InputStream in, String contentTransferEncoding)
|
|
throws IOException {
|
|
/*
|
|
* We'll remove any transfer encoding by wrapping the stream.
|
|
*/
|
|
in = getInputStreamForContentTransferEncoding(in, contentTransferEncoding);
|
|
BinaryTempFileBody tempBody = new BinaryTempFileBody();
|
|
OutputStream out = tempBody.getOutputStream();
|
|
try {
|
|
IOUtils.copy(in, out);
|
|
} catch (Base64DataException bde) {
|
|
// TODO Need to fix this somehow
|
|
//String warning = "\n\n" + Email.getMessageDecodeErrorString();
|
|
//out.write(warning.getBytes());
|
|
} finally {
|
|
out.close();
|
|
}
|
|
return tempBody;
|
|
}
|
|
|
|
/**
|
|
* Recursively scan a Part (usually a Message) and sort out which of its children will be
|
|
* "viewable" and which will be attachments.
|
|
*
|
|
* @param part The part to be broken down
|
|
* @param viewables This arraylist will be populated with all parts that appear to be
|
|
* the "message" (e.g. text/plain & text/html)
|
|
* @param attachments This arraylist will be populated with all parts that appear to be
|
|
* attachments (including inlines)
|
|
* @throws MessagingException
|
|
*/
|
|
public static void collectParts(Part part, ArrayList<Part> viewables,
|
|
ArrayList<Part> attachments) throws MessagingException {
|
|
String disposition = part.getDisposition();
|
|
String dispositionType = null;
|
|
String dispositionFilename = null;
|
|
if (disposition != null) {
|
|
dispositionType = MimeUtility.getHeaderParameter(disposition, null);
|
|
dispositionFilename = MimeUtility.getHeaderParameter(disposition, "filename");
|
|
}
|
|
// An attachment filename can be defined in either the Content-Disposition header
|
|
// or the Content-Type header. Content-Disposition is preferred, so we only try
|
|
// the Content-Type header as a last resort.
|
|
if (dispositionFilename == null) {
|
|
String contentType = part.getContentType();
|
|
dispositionFilename = MimeUtility.getHeaderParameter(contentType, "name");
|
|
}
|
|
boolean attachmentDisposition = "attachment".equalsIgnoreCase(dispositionType);
|
|
// If a disposition is not specified, default to "inline"
|
|
boolean inlineDisposition = dispositionType == null
|
|
|| "inline".equalsIgnoreCase(dispositionType);
|
|
|
|
// A guess that this part is intended to be an attachment
|
|
boolean attachment = attachmentDisposition
|
|
|| (dispositionFilename != null && !inlineDisposition);
|
|
|
|
// A guess that this part is intended to be an inline.
|
|
boolean inline = inlineDisposition && (dispositionFilename != null);
|
|
|
|
// One or the other
|
|
boolean attachmentOrInline = attachment || inline;
|
|
|
|
if (part.getBody() instanceof Multipart) {
|
|
// If the part is Multipart but not alternative it's either mixed or
|
|
// something we don't know about, which means we treat it as mixed
|
|
// per the spec. We just process its pieces recursively.
|
|
MimeMultipart mp = (MimeMultipart)part.getBody();
|
|
boolean foundHtml = false;
|
|
if (mp.getSubTypeForTest().equals("alternative")) {
|
|
for (int i = 0; i < mp.getCount(); i++) {
|
|
if (mp.getBodyPart(i).isMimeType("text/html")) {
|
|
foundHtml = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < mp.getCount(); i++) {
|
|
// See if we have text and html
|
|
BodyPart bp = mp.getBodyPart(i);
|
|
// If there's html, don't bother loading text
|
|
if (foundHtml && bp.isMimeType("text/plain")) {
|
|
continue;
|
|
}
|
|
collectParts(bp, viewables, attachments);
|
|
}
|
|
} else if (part.getBody() instanceof Message) {
|
|
// If the part is an embedded message we just continue to process
|
|
// it, pulling any viewables or attachments into the running list.
|
|
Message message = (Message)part.getBody();
|
|
collectParts(message, viewables, attachments);
|
|
} else if ((!attachmentOrInline) && ("text/html".equalsIgnoreCase(part.getMimeType()))) {
|
|
// If the part is HTML and we got this far, it's a viewable part of a mixed
|
|
viewables.add(part);
|
|
} else if ((!attachmentOrInline) && ("text/plain".equalsIgnoreCase(part.getMimeType()))) {
|
|
// If the part is text and we got this far, it's a viewable part of a mixed
|
|
viewables.add(part);
|
|
} else if (attachmentOrInline) {
|
|
// Finally, if it's an attachment or an inline we will include it as an attachment.
|
|
attachments.add(part);
|
|
}
|
|
}
|
|
}
|