// We populate Message using the ImapList parsed by BODYSTRUCTURE returned from server.
private static void parseBodyStructure(ImapList bs, Part part, String id)
throws MessagingException {
if (bs.getElementOrNone(0).isList()) {
/*
* This is a multipart/*
*/
MimeMultipart mp = new MimeMultipart();
for (int i = 0, count = bs.size(); i < count; i++) {
ImapElement e = bs.getElementOrNone(i);
if (e.isList()) {
/*
* For each part in the message we're going to add a new BodyPart and parse
* into it.
*/
MimeBodyPart bp = new MimeBodyPart();
if (id.equals(ImapConstants.TEXT)) {
parseBodyStructure(bs.getListOrEmpty(i), bp, Integer.toString(i + 1));
} else {
parseBodyStructure(bs.getListOrEmpty(i), bp, id + "." + (i + 1));
}
mp.addBodyPart(bp);
} else {
if (e.isString()) {
mp.setSubType(bs.getStringOrEmpty(i).getString().toLowerCase());
}
break; // Ignore the rest of the list.
}
}
part.setBody(mp);
} else {
/*
* This is a body. We need to add as much information as we can find out about
* it to the Part.
*/
/*
body type
body subtype
body parameter parenthesized list
body id
body description
body encoding
body size
*/
final ImapString type = bs.getStringOrEmpty(0);
final ImapString subType = bs.getStringOrEmpty(1);
final String mimeType = (type.getString() + "/" + subType.getString()).toLowerCase();
final ImapList bodyParams = bs.getListOrEmpty(2);
final ImapString cid = bs.getStringOrEmpty(3);
final ImapString encoding = bs.getStringOrEmpty(5);
final int size = bs.getStringOrEmpty(6).getNumberOrZero();
if (MimeUtility.mimeTypeMatches(mimeType, MimeUtility.MIME_TYPE_RFC822)) {
// A body type of type MESSAGE and subtype RFC822
// contains, immediately after the basic fields, the
// envelope structure, body structure, and size in
// text lines of the encapsulated message.
// [MESSAGE, RFC822, [NAME, filename.eml], NIL, NIL, 7BIT, 5974, NIL,
// [INLINE, [FILENAME*0, Fwd: Xxx..., FILENAME*1, filename.eml]], NIL]
/*
* This will be caught by fetch and handled appropriately.
*/
// throw new MessagingException("BODYSTRUCTURE " +
// MimeUtility.MIME_TYPE_RFC822
// + " not yet supported.");
Logging.w("BODYSTRUCTURE " + MimeUtility.MIME_TYPE_RFC822 + " not yet supported.");
return;
}
/*
* Set the content type with as much information as we know right now.
*/
final StringBuilder contentType = new StringBuilder(mimeType);
/*
* If there are body params we might be able to get some more information out
* of them.
*/
for (int i = 1, count = bodyParams.size(); i < count; i += 2) {
// TODO We need to convert " into %22, but
// because MimeUtility.getHeaderParameter doesn't recognize it,
// we can't fix it for now.
contentType.append(
String.format(
";\n %s=\"%s\"",
bodyParams.getStringOrEmpty(i - 1).getString(),
bodyParams.getStringOrEmpty(i).getString()));
}
part.setHeader(MimeHeader.HEADER_CONTENT_TYPE, contentType.toString());
// Extension items
final ImapList bodyDisposition;
if (type.is(ImapConstants.TEXT) && bs.getElementOrNone(9).isList()) {
// If media-type is TEXT, 9th element might be: [body-fld-lines] := number
// So, if it's not a list, use 10th element.
// (Couldn't find evidence in the RFC if it's ALWAYS 10th element.)
bodyDisposition = bs.getListOrEmpty(9);
} else {
bodyDisposition = bs.getListOrEmpty(8);
}
final StringBuilder contentDisposition = new StringBuilder();
if (bodyDisposition.size() > 0) {
final String bodyDisposition0Str =
bodyDisposition.getStringOrEmpty(0).getString().toLowerCase();
if (!TextUtils.isEmpty(bodyDisposition0Str)) {
contentDisposition.append(bodyDisposition0Str);
}
final ImapList bodyDispositionParams = bodyDisposition.getListOrEmpty(1);
if (!bodyDispositionParams.isEmpty()) {
/*
* If there is body disposition information we can pull some more
* information about the attachment out.
*/
for (int i = 1, count = bodyDispositionParams.size(); i < count; i += 2) {
// TODO We need to convert " into %22. See above.
contentDisposition.append(
String.format(
";\n %s=\"%s\"",
bodyDispositionParams.getStringOrEmpty(i - 1).getString().toLowerCase(),
bodyDispositionParams.getStringOrEmpty(i).getString()));
}
}
}
if ((size > 0)
&& (MimeUtility.getHeaderParameter(contentDisposition.toString(), "size") == null)) {
// If the encoding is base64 and no Content-Disposition size fetched, then recounting the
// actual size: the encoded size multiplied by a fixed ratio
if (ENC_BASE64.equals(encoding.getString())) {
contentDisposition.append(String.format(";\n size=%d", (int) (size * BASE64_RATIO)));
} else {
contentDisposition.append(String.format(";\n size=%d", size));
}
}
if (contentDisposition.length() > 0) {
/*
* Set the content disposition containing at least the size. Attachment
* handling code will use this down the road.
*/
part.setHeader(MimeHeader.HEADER_CONTENT_DISPOSITION, contentDisposition.toString());
}
/*
* Set the Content-Transfer-Encoding header. Attachment code will use this
* to parse the body.
*/
if (!encoding.isEmpty()) {
part.setHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING, encoding.getString());
}
/*
* Set the Content-ID header.
*/
if (!cid.isEmpty()) {
part.setHeader(MimeHeader.HEADER_CONTENT_ID, cid.getString());
}
if (size > 0) {
if (part instanceof ImapMessage) {
((ImapMessage) part).setSize(size);
} else if (part instanceof MimeBodyPart) {
((MimeBodyPart) part).setSize(size);
} else {
throw new MessagingException("Unknown part type " + part.toString());
}
}
part.setHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA, id);
}
}
/**
* Appends the given messages to the selected folder. This implementation also determines the new
* UID of the given message on the IMAP server and sets the Message's UID to the new server UID.
*/
@Override
public void appendMessages(Message[] messages) throws MessagingException {
checkOpen();
try {
for (Message message : messages) {
// Create output count
CountingOutputStream out = new CountingOutputStream();
EOLConvertingOutputStream eolOut = new EOLConvertingOutputStream(out);
message.writeTo(eolOut);
eolOut.flush();
// Create flag list (most often this will be "\SEEN")
String flagList = "";
Flag[] flags = message.getFlags();
if (flags.length > 0) {
StringBuilder sb = new StringBuilder();
for (int i = 0, count = flags.length; i < count; i++) {
Flag flag = flags[i];
if (flag == Flag.SEEN) {
sb.append(" " + ImapConstants.FLAG_SEEN);
} else if (flag == Flag.FLAGGED) {
sb.append(" " + ImapConstants.FLAG_FLAGGED);
}
}
if (sb.length() > 0) {
flagList = sb.substring(1);
}
}
mConnection.sendCommand(
String.format(
ImapConstants.APPEND + " \"%s\" (%s) {%d}",
ImapStore.encodeFolderName(mName, mStore.mPathPrefix),
flagList,
out.getCount()),
false);
ImapResponse response;
do {
response = mConnection.readResponse();
if (response.isContinuationRequest()) {
eolOut = new EOLConvertingOutputStream(mConnection.mTransport.getOutputStream());
message.writeTo(eolOut);
eolOut.write('\r');
eolOut.write('\n');
eolOut.flush();
} else if (!response.isTagged()) {
handleUntaggedResponse(response);
}
} while (!response.isTagged());
// TODO Why not check the response?
/*
* Try to recover the UID of the message from an APPENDUID response.
* e.g. 11 OK [APPENDUID 2 238268] APPEND completed
*/
final ImapList appendList = response.getListOrEmpty(1);
if ((appendList.size() >= 3) && appendList.is(0, ImapConstants.APPENDUID)) {
String serverUid = appendList.getStringOrEmpty(2).getString();
if (!TextUtils.isEmpty(serverUid)) {
message.setUid(serverUid);
continue;
}
}
/*
* Try to find the UID of the message we just appended using the
* Message-ID header. If there are more than one response, take the
* last one, as it's most likely the newest (the one we just uploaded).
*/
String messageId = message.getMessageId();
if (messageId == null || messageId.length() == 0) {
continue;
}
// Most servers don't care about parenthesis in the search query [and, some
// fail to work if they are used]
String[] uids = searchForUids(String.format("HEADER MESSAGE-ID %s", messageId));
if (uids.length > 0) {
message.setUid(uids[0]);
}
// However, there's at least one server [AOL] that fails to work unless there
// are parenthesis, so, try this as a last resort
uids = searchForUids(String.format("(HEADER MESSAGE-ID %s)", messageId));
if (uids.length > 0) {
message.setUid(uids[0]);
}
}
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
} finally {
destroyResponses();
}
}
public void fetchInternal(Message[] messages, FetchProfile fp, MessageRetrievalListener listener)
throws MessagingException {
if (messages.length == 0) {
return;
}
checkOpen();
HashMap<String, Message> messageMap = new HashMap<String, Message>();
for (Message m : messages) {
messageMap.put(m.getUid(), m);
}
/*
* Figure out what command we are going to run:
* FLAGS - UID FETCH (FLAGS)
* ENVELOPE - UID FETCH (INTERNALDATE UID RFC822.SIZE FLAGS BODY.PEEK[
* HEADER.FIELDS (date subject from content-type to cc)])
* STRUCTURE - UID FETCH (BODYSTRUCTURE)
* BODY_SANE - UID FETCH (BODY.PEEK[]<0.N>) where N = max bytes returned
* BODY - UID FETCH (BODY.PEEK[])
* Part - UID FETCH (BODY.PEEK[ID]) where ID = mime part ID
*/
final LinkedHashSet<String> fetchFields = new LinkedHashSet<String>();
fetchFields.add(ImapConstants.UID);
if (fp.contains(FetchProfile.Item.FLAGS)) {
fetchFields.add(ImapConstants.FLAGS);
}
if (fp.contains(FetchProfile.Item.ENVELOPE)) {
fetchFields.add(ImapConstants.INTERNALDATE);
fetchFields.add(ImapConstants.RFC822_SIZE);
fetchFields.add(ImapConstants.FETCH_FIELD_HEADERS);
}
if (fp.contains(FetchProfile.Item.STRUCTURE)) {
fetchFields.add(ImapConstants.BODYSTRUCTURE);
}
if (fp.contains(FetchProfile.Item.BODY_SANE)) {
fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK_SANE);
}
if (fp.contains(FetchProfile.Item.BODY)) {
fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK);
}
final Part fetchPart = fp.getFirstPart();
if (fetchPart != null) {
String[] partIds = fetchPart.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
if (partIds != null) {
fetchFields.add(
ImapConstants.FETCH_FIELD_BODY_PEEK_BARE
+ "["
+ partIds[0]
+ "]"
+ (mFetchSize > 0 ? String.format("<0.%d>", mFetchSize) : ""));
}
}
try {
mConnection.sendCommand(
String.format(
ImapConstants.UID_FETCH + " %s (%s)",
ImapStore.joinMessageUids(messages),
Utility.combine(fetchFields.toArray(new String[fetchFields.size()]), ' ')),
false);
ImapResponse response;
int messageNumber = 0;
do {
response = null;
try {
response = mConnection.readResponse(listener);
if (!response.isDataResponse(1, ImapConstants.FETCH)) {
continue; // Ignore
}
final ImapList fetchList = response.getListOrEmpty(2);
final String uid = fetchList.getKeyedStringOrEmpty(ImapConstants.UID).getString();
if (TextUtils.isEmpty(uid)) continue;
ImapMessage message = (ImapMessage) messageMap.get(uid);
if (message == null) continue;
if (fp.contains(FetchProfile.Item.FLAGS)) {
final ImapList flags = fetchList.getKeyedListOrEmpty(ImapConstants.FLAGS);
for (int i = 0, count = flags.size(); i < count; i++) {
final ImapString flag = flags.getStringOrEmpty(i);
if (flag.is(ImapConstants.FLAG_DELETED)) {
message.setFlagInternal(Flag.DELETED, true);
} else if (flag.is(ImapConstants.FLAG_ANSWERED)) {
message.setFlagInternal(Flag.ANSWERED, true);
} else if (flag.is(ImapConstants.FLAG_SEEN)) {
message.setFlagInternal(Flag.SEEN, true);
} else if (flag.is(ImapConstants.FLAG_FLAGGED)) {
message.setFlagInternal(Flag.FLAGGED, true);
}
}
}
if (fp.contains(FetchProfile.Item.ENVELOPE)) {
final Date internalDate =
fetchList.getKeyedStringOrEmpty(ImapConstants.INTERNALDATE).getDateOrNull();
final int size =
fetchList.getKeyedStringOrEmpty(ImapConstants.RFC822_SIZE).getNumberOrZero();
final InputStream header =
fetchList
.getKeyedStringOrEmpty(ImapConstants.BODY_BRACKET_HEADER, true)
.getAsStream();
message.setInternalDate(internalDate);
message.setSize(size);
message.parse(header);
}
if (fp.contains(FetchProfile.Item.STRUCTURE)) {
ImapList bs = fetchList.getKeyedListOrEmpty(ImapConstants.BODYSTRUCTURE);
if (!bs.isEmpty()) {
try {
parseBodyStructure(bs, message, ImapConstants.TEXT);
} catch (MessagingException e) {
if (Logging.LOGD) {
Log.v(Logging.LOG_TAG, "Error handling message", e);
}
message.setBody(null);
}
}
}
if (fp.contains(FetchProfile.Item.BODY) || fp.contains(FetchProfile.Item.BODY_SANE)) {
// Body is keyed by "BODY[]...".
// Previously used "BODY[..." but this can be confused with "BODY[HEADER..."
// TODO Should we accept "RFC822" as well??
ImapString body = fetchList.getKeyedStringOrEmpty("BODY[]", true);
String bodyText = body.getString();
InputStream bodyStream = body.getAsStream();
message.parse(bodyStream);
}
if (fetchPart != null && fetchPart.getSize() > 0) {
InputStream bodyStream = fetchList.getKeyedStringOrEmpty("BODY[", true).getAsStream();
String contentType = fetchPart.getContentType();
String[] encodingHeader =
fetchPart.getHeader(MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING);
String contentTransferEncoding = null;
if (encodingHeader != null) {
contentTransferEncoding = encodingHeader[0];
}
// TODO Don't create 2 temp files.
// decodeBody creates BinaryTempFileBody, but we could avoid this
// if we implement ImapStringBody.
// (We'll need to share a temp file. Protect it with a ref-count.)
fetchPart.setBody(
decodeBody(bodyStream, contentTransferEncoding, fetchPart.getSize(), listener));
}
if (listener != null) {
listener.messageRetrieved(message);
}
} finally {
destroyResponses();
}
} while (!response.isTagged());
} catch (IOException ioe) {
throw ioExceptionHandler(mConnection, ioe);
}
}