1744 lines
71 KiB
Java
1744 lines
71 KiB
Java
/*
|
|
* Copyright (C) 2011 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.email.mail.store;
|
|
|
|
import android.content.Context;
|
|
import android.text.TextUtils;
|
|
import android.util.Base64DataException;
|
|
|
|
import com.android.email.DebugUtils;
|
|
import com.android.email.mail.store.ImapStore.ImapException;
|
|
import com.android.email.mail.store.ImapStore.ImapMessage;
|
|
import com.android.email.mail.store.imap.ImapConstants;
|
|
import com.android.email.mail.store.imap.ImapElement;
|
|
import com.android.email.mail.store.imap.ImapList;
|
|
import com.android.email.mail.store.imap.ImapResponse;
|
|
import com.android.email.mail.store.imap.ImapString;
|
|
import com.android.email.mail.store.imap.ImapUtility;
|
|
import com.android.email.service.ImapService;
|
|
import com.android.emailcommon.Logging;
|
|
import com.android.emailcommon.internet.BinaryTempFileBody;
|
|
import com.android.emailcommon.internet.MimeBodyPart;
|
|
import com.android.emailcommon.internet.MimeHeader;
|
|
import com.android.emailcommon.internet.MimeMultipart;
|
|
import com.android.emailcommon.internet.MimeUtility;
|
|
import com.android.emailcommon.mail.AuthenticationFailedException;
|
|
import com.android.emailcommon.mail.Body;
|
|
import com.android.emailcommon.mail.FetchProfile;
|
|
import com.android.emailcommon.mail.Flag;
|
|
import com.android.emailcommon.mail.Folder;
|
|
import com.android.emailcommon.mail.Message;
|
|
import com.android.emailcommon.mail.MessagingException;
|
|
import com.android.emailcommon.mail.Part;
|
|
import com.android.emailcommon.provider.Mailbox;
|
|
import com.android.emailcommon.service.SearchParams;
|
|
import com.android.emailcommon.utility.CountingOutputStream;
|
|
import com.android.emailcommon.utility.EOLConvertingOutputStream;
|
|
import com.android.emailcommon.utility.Utility;
|
|
import com.android.mail.utils.LogUtils;
|
|
import com.google.common.annotations.VisibleForTesting;
|
|
|
|
import static com.android.emailcommon.Logging.LOG_TAG;
|
|
|
|
import org.apache.commons.io.IOUtils;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.net.SocketTimeoutException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedHashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.TimeZone;
|
|
|
|
public class ImapFolder extends Folder {
|
|
private final static Flag[] PERMANENT_FLAGS =
|
|
{ Flag.DELETED, Flag.SEEN, Flag.FLAGGED, Flag.ANSWERED };
|
|
private static final int COPY_BUFFER_SIZE = 16*1024;
|
|
|
|
public interface IdleCallback {
|
|
/**
|
|
* Invoked when the connection enters idle mode
|
|
*/
|
|
public void onIdled();
|
|
/**
|
|
* Invoked when idle state is left
|
|
*/
|
|
public void onIdlingDone();
|
|
/**
|
|
* Invoked when a new change is communicated by the server.
|
|
*
|
|
* @param needSync whether a sync is required
|
|
* @param fetchMessages list of message UIDs to update
|
|
*/
|
|
public void onNewServerChange(boolean needSync, List<String> fetchMessages);
|
|
/**
|
|
* Connection to socket timed out. The idle connection needs
|
|
* to be considered broken when this is called.
|
|
*/
|
|
public void onTimeout();
|
|
/**
|
|
* Something went wrong while waiting for push data.
|
|
*
|
|
* @param ex the exception detected
|
|
*/
|
|
public void onException(MessagingException ex);
|
|
}
|
|
|
|
private final ImapStore mStore;
|
|
private final String mName;
|
|
private int mMessageCount = -1;
|
|
private ImapConnection mConnection;
|
|
private OpenMode mMode;
|
|
private boolean mExists;
|
|
/** The local mailbox associated with this remote folder */
|
|
Mailbox mMailbox;
|
|
/** A set of hashes that can be used to track dirtiness */
|
|
Object mHash[];
|
|
|
|
private final Object mIdleSync = new Object();
|
|
private boolean mIdling;
|
|
private boolean mIdlingCancelled;
|
|
private boolean mDiscardIdlingConnection;
|
|
private Thread mIdleReader;
|
|
|
|
private static final String[] IDLE_STATUSES = {
|
|
ImapConstants.UIDVALIDITY, ImapConstants.UIDNEXT
|
|
};
|
|
private Map<String, String> mIdleStatuses = new HashMap<>();
|
|
|
|
private static class ImapIdleChanges {
|
|
public boolean mRequiredSync = false;
|
|
public ArrayList<String> mMessageToFetch = new ArrayList<>();
|
|
}
|
|
|
|
/*package*/ ImapFolder(ImapStore store, String name) {
|
|
mStore = store;
|
|
mName = name;
|
|
}
|
|
|
|
private void destroyResponses() {
|
|
if (mConnection != null) {
|
|
mConnection.destroyResponses();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void open(OpenMode mode)
|
|
throws MessagingException {
|
|
try {
|
|
if (isOpen()) {
|
|
if (mMode == mode) {
|
|
// Make sure the connection is valid.
|
|
// If it's not we'll close it down and continue on to get a new one.
|
|
try {
|
|
mConnection.executeSimpleCommand(ImapConstants.NOOP);
|
|
return;
|
|
|
|
} catch (IOException ioe) {
|
|
ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
} else {
|
|
// Return the connection to the pool, if exists.
|
|
close(false);
|
|
}
|
|
}
|
|
synchronized (this) {
|
|
mConnection = mStore.getConnection();
|
|
}
|
|
// * FLAGS (\Answered \Flagged \Deleted \Seen \Draft NonJunk
|
|
// $MDNSent)
|
|
// * OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft
|
|
// NonJunk $MDNSent \*)] Flags permitted.
|
|
// * 23 EXISTS
|
|
// * 0 RECENT
|
|
// * OK [UIDVALIDITY 1125022061] UIDs valid
|
|
// * OK [UIDNEXT 57576] Predicted next UID
|
|
// 2 OK [READ-WRITE] Select completed.
|
|
try {
|
|
mConnection.setTransportTag(mName + "-" + hashCode());
|
|
doSelect();
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
} catch (AuthenticationFailedException e) {
|
|
// Don't cache this connection, so we're forced to try connecting/login again
|
|
mConnection = null;
|
|
close(false);
|
|
throw e;
|
|
} catch (MessagingException e) {
|
|
mExists = false;
|
|
close(false);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@VisibleForTesting
|
|
public boolean isOpen() {
|
|
return mExists && mConnection != null;
|
|
}
|
|
|
|
@Override
|
|
public OpenMode getMode() {
|
|
return mMode;
|
|
}
|
|
|
|
@Override
|
|
public void close(boolean expunge) {
|
|
// TODO implement expunge
|
|
mMessageCount = -1;
|
|
synchronized (this) {
|
|
mStore.poolConnection(mConnection);
|
|
mConnection = null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getName() {
|
|
return mName;
|
|
}
|
|
|
|
public void startIdling(final IdleCallback callback) throws MessagingException {
|
|
LogUtils.d(LOG_TAG, "startIdling on folder " + mName);
|
|
checkOpen();
|
|
synchronized (mIdleSync) {
|
|
if (mIdling) {
|
|
throw new MessagingException("Folder " + mName + " is in IDLE state already.");
|
|
}
|
|
mIdling = true;
|
|
mIdlingCancelled = false;
|
|
mDiscardIdlingConnection = false;
|
|
}
|
|
|
|
final ImapConnection connection;
|
|
synchronized (this) {
|
|
connection = mConnection;
|
|
}
|
|
|
|
// Run idle in background
|
|
mIdleReader = new Thread() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
// Get some info before start idling
|
|
mIdleStatuses = getStatuses(IDLE_STATUSES);
|
|
|
|
// We setup the max time specified in RFC 2177 to re-issue
|
|
// an idle request to the server
|
|
connection.setReadTimeout(ImapConnection.PING_IDLE_TIMEOUT);
|
|
connection.destroyResponses();
|
|
|
|
// Enter now in idle status (we hold a connection with
|
|
// the server to listen for new changes)
|
|
synchronized (mIdleSync) {
|
|
if (mIdlingCancelled) {
|
|
mIdling = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (callback != null) {
|
|
callback.onIdled();
|
|
}
|
|
List<ImapResponse> responses = connection.executeIdleCommand();
|
|
|
|
// Check whether IDLE was successful (first response is an idling response)
|
|
if (responses.isEmpty() || (mIdling && !responses.get(0).isIdling())) {
|
|
if (callback != null) {
|
|
callback.onException(new MessagingException(
|
|
MessagingException.SERVER_ERROR, "Cannot idle"));
|
|
}
|
|
synchronized (mIdleSync) {
|
|
mIdling = false;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Exit idle if we are still in that state
|
|
boolean cancelled = false;
|
|
boolean discardConnection = false;
|
|
synchronized (mIdleSync) {
|
|
if (!mIdlingCancelled) {
|
|
try {
|
|
connection.setReadTimeout(ImapConnection.DONE_TIMEOUT);
|
|
connection.executeSimpleCommand(ImapConstants.DONE);
|
|
} catch (MessagingException me) {
|
|
// Ignore this exception caused by messages in the queue
|
|
}
|
|
}
|
|
|
|
cancelled = mIdlingCancelled;
|
|
discardConnection = mDiscardIdlingConnection;
|
|
}
|
|
|
|
if (!cancelled && callback != null) {
|
|
// Notify that new changes exists in the server. Remove
|
|
// the idling status response since is only relevant for the protocol
|
|
// We have to enter in idle
|
|
ImapIdleChanges changes = extractImapChanges(
|
|
new ArrayList<Object>(responses.subList(1, responses.size())));
|
|
callback.onNewServerChange(changes.mRequiredSync, changes.mMessageToFetch);
|
|
}
|
|
|
|
if (discardConnection) {
|
|
// Return the connection to the pool
|
|
cleanupConnection(connection, false);
|
|
}
|
|
|
|
synchronized (mIdleSync) {
|
|
mIdling = false;
|
|
}
|
|
|
|
if (callback != null) {
|
|
callback.onIdlingDone();
|
|
}
|
|
} catch (MessagingException me) {
|
|
cleanupConnection(connection, false);
|
|
synchronized (mIdleSync) {
|
|
mIdling = false;
|
|
}
|
|
if (callback != null) {
|
|
callback.onException(me);
|
|
}
|
|
|
|
} catch (SocketTimeoutException ste) {
|
|
cleanupConnection(connection, false);
|
|
synchronized (mIdleSync) {
|
|
mIdling = false;
|
|
}
|
|
if (callback != null) {
|
|
callback.onTimeout();
|
|
}
|
|
|
|
} catch (IOException ioe) {
|
|
synchronized (mIdleSync) {
|
|
mIdling = false;
|
|
}
|
|
if (callback != null) {
|
|
callback.onException(ioExceptionHandler(connection, ioe));
|
|
} else {
|
|
cleanupConnection(connection, false);
|
|
}
|
|
|
|
}
|
|
}
|
|
};
|
|
mIdleReader.setName("IdleReader " + mStore.getAccount().mId + ":" + mName);
|
|
mIdleReader.start();
|
|
}
|
|
|
|
public void stopIdling(boolean discardConnection) throws MessagingException {
|
|
LogUtils.d(LOG_TAG, "stopIdling on folder " + mName);
|
|
if (!isOpen()) {
|
|
throw new MessagingException("Folder " + mName + " is not open.");
|
|
}
|
|
|
|
final ImapConnection connection;
|
|
synchronized (this) {
|
|
connection = mConnection;
|
|
}
|
|
|
|
synchronized (mIdleSync) {
|
|
if (!mIdling) {
|
|
throw new MessagingException("Folder " + mName + " isn't in IDLE state.");
|
|
}
|
|
try {
|
|
mIdlingCancelled = true;
|
|
mDiscardIdlingConnection = discardConnection;
|
|
// Send the DONE command to make the idle reader thread exit. Shorten
|
|
// the read timeout for doing that in order to not wait indefinitely,
|
|
// the server should respond to the DONE command quickly anyway
|
|
connection.sendCommand(ImapConstants.DONE, false);
|
|
|
|
} catch (MessagingException me) {
|
|
// Treat IOERROR messaging exception as IOException
|
|
if (me.getExceptionType() == MessagingException.IOERROR) {
|
|
cleanupConnection(connection, false);
|
|
throw me;
|
|
}
|
|
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
|
|
}
|
|
}
|
|
|
|
// Try to join the thread, but make sure to not wait indefinitely. This should
|
|
// be the normal case (server sends the response to DONE quickly)
|
|
try {
|
|
mIdleReader.join(1000, 0);
|
|
} catch (InterruptedException e) {
|
|
// ignore
|
|
}
|
|
// In case the server didn't respond quickly, the connection is likely broken;
|
|
// close it (which definitely will cause the thread to return) and finally join the thread
|
|
if (mIdleReader.isAlive()) {
|
|
cleanupConnection(connection, true);
|
|
try {
|
|
mIdleReader.join();
|
|
} catch (InterruptedException e) {
|
|
// ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean isIdling() {
|
|
synchronized (mIdleSync) {
|
|
return mIdling;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean exists() throws MessagingException {
|
|
if (mExists) {
|
|
return true;
|
|
}
|
|
/*
|
|
* This method needs to operate in the unselected mode as well as the selected mode
|
|
* so we must get the connection ourselves if it's not there. We are specifically
|
|
* not calling checkOpen() since we don't care if the folder is open.
|
|
*/
|
|
ImapConnection connection = null;
|
|
synchronized(this) {
|
|
if (mConnection == null) {
|
|
connection = mStore.getConnection();
|
|
} else {
|
|
connection = mConnection;
|
|
}
|
|
}
|
|
try {
|
|
connection.executeSimpleCommand(String.format(Locale.US,
|
|
ImapConstants.STATUS + " \"%s\" (" + ImapConstants.UIDVALIDITY + ")",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
|
|
mExists = true;
|
|
return true;
|
|
|
|
} catch (MessagingException me) {
|
|
// Treat IOERROR messaging exception as IOException
|
|
if (me.getExceptionType() == MessagingException.IOERROR) {
|
|
throw me;
|
|
}
|
|
return false;
|
|
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(connection, ioe);
|
|
|
|
} finally {
|
|
connection.destroyResponses();
|
|
if (mConnection == null) {
|
|
mStore.poolConnection(connection);
|
|
}
|
|
}
|
|
}
|
|
|
|
// IMAP supports folder creation
|
|
@Override
|
|
public boolean canCreate(FolderType type) {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean create(FolderType type) throws MessagingException {
|
|
/*
|
|
* This method needs to operate in the unselected mode as well as the selected mode
|
|
* so we must get the connection ourselves if it's not there. We are specifically
|
|
* not calling checkOpen() since we don't care if the folder is open.
|
|
*/
|
|
ImapConnection connection = null;
|
|
synchronized(this) {
|
|
if (mConnection == null) {
|
|
connection = mStore.getConnection();
|
|
} else {
|
|
connection = mConnection;
|
|
}
|
|
}
|
|
try {
|
|
connection.executeSimpleCommand(String.format(Locale.US,
|
|
ImapConstants.CREATE + " \"%s\"",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
|
|
return true;
|
|
|
|
} catch (MessagingException me) {
|
|
return false;
|
|
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(connection, ioe);
|
|
|
|
} finally {
|
|
connection.destroyResponses();
|
|
if (mConnection == null) {
|
|
mStore.poolConnection(connection);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void copyMessages(Message[] messages, Folder folder,
|
|
MessageUpdateCallbacks callbacks) throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
List<ImapResponse> responseList = mConnection.executeSimpleCommand(
|
|
String.format(Locale.US, ImapConstants.UID_COPY + " %s \"%s\"",
|
|
ImapStore.joinMessageUids(messages),
|
|
ImapStore.encodeFolderName(folder.getName(), mStore.mPathPrefix)));
|
|
// Build a message map for faster UID matching
|
|
HashMap<String, Message> messageMap = new HashMap<String, Message>();
|
|
boolean handledUidPlus = false;
|
|
for (Message m : messages) {
|
|
messageMap.put(m.getUid(), m);
|
|
}
|
|
// Process response to get the new UIDs
|
|
for (ImapResponse response : responseList) {
|
|
// All "BAD" responses are bad. Only "NO", tagged responses are bad.
|
|
if (response.isBad() || (response.isNo() && response.isTagged())) {
|
|
String responseText = response.getStatusResponseTextOrEmpty().getString();
|
|
throw new MessagingException(responseText);
|
|
}
|
|
// Skip untagged responses; they're just status
|
|
if (!response.isTagged()) {
|
|
continue;
|
|
}
|
|
// No callback provided to report of UID changes; nothing more to do here
|
|
// NOTE: We check this here to catch any server errors
|
|
if (callbacks == null) {
|
|
continue;
|
|
}
|
|
ImapList copyResponse = response.getListOrEmpty(1);
|
|
String responseCode = copyResponse.getStringOrEmpty(0).getString();
|
|
if (ImapConstants.COPYUID.equals(responseCode)) {
|
|
handledUidPlus = true;
|
|
String origIdSet = copyResponse.getStringOrEmpty(2).getString();
|
|
String newIdSet = copyResponse.getStringOrEmpty(3).getString();
|
|
String[] origIdArray = ImapUtility.getImapSequenceValues(origIdSet);
|
|
String[] newIdArray = ImapUtility.getImapSequenceValues(newIdSet);
|
|
// There has to be a 1:1 mapping between old and new IDs
|
|
if (origIdArray.length != newIdArray.length) {
|
|
throw new MessagingException("Set length mis-match; orig IDs \"" +
|
|
origIdSet + "\" new IDs \"" + newIdSet + "\"");
|
|
}
|
|
for (int i = 0; i < origIdArray.length; i++) {
|
|
final String id = origIdArray[i];
|
|
final Message m = messageMap.get(id);
|
|
if (m != null) {
|
|
callbacks.onMessageUidChange(m, newIdArray[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If the server doesn't support UIDPLUS, try a different way to get the new UID(s)
|
|
if (callbacks != null && !handledUidPlus) {
|
|
final ImapFolder newFolder = (ImapFolder)folder;
|
|
try {
|
|
// Temporarily select the destination folder
|
|
newFolder.open(OpenMode.READ_WRITE);
|
|
// Do the search(es) ...
|
|
for (Message m : messages) {
|
|
final String searchString =
|
|
"HEADER Message-Id \"" + m.getMessageId() + "\"";
|
|
final String[] newIdArray = newFolder.searchForUids(searchString);
|
|
if (newIdArray.length == 1) {
|
|
callbacks.onMessageUidChange(m, newIdArray[0]);
|
|
}
|
|
}
|
|
} catch (MessagingException e) {
|
|
// Log, but, don't abort; failures here don't need to be propagated
|
|
LogUtils.d(Logging.LOG_TAG, "Failed to find message", e);
|
|
} finally {
|
|
newFolder.close(false);
|
|
}
|
|
// Re-select the original folder
|
|
doSelect();
|
|
}
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getMessageCount() {
|
|
synchronized (this) {
|
|
return mMessageCount;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int getUnreadMessageCount() throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
int unreadMessageCount = 0;
|
|
final List<ImapResponse> responses = mConnection.executeSimpleCommand(
|
|
String.format(Locale.US,
|
|
ImapConstants.STATUS + " \"%s\" (" + ImapConstants.UNSEEN + ")",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
|
|
// S: * STATUS mboxname (MESSAGES 231 UIDNEXT 44292)
|
|
for (ImapResponse response : responses) {
|
|
if (response.isDataResponse(0, ImapConstants.STATUS)) {
|
|
unreadMessageCount = response.getListOrEmpty(2)
|
|
.getKeyedStringOrEmpty(ImapConstants.UNSEEN).getNumberOrZero();
|
|
}
|
|
}
|
|
return unreadMessageCount;
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
public Map<String, String> getStatuses(String[] statuses) throws MessagingException {
|
|
checkOpen();
|
|
Map<String, String> allReturnStatuses = new HashMap<>();
|
|
try {
|
|
String flags = TextUtils.join(" ", statuses);
|
|
final List<ImapResponse> responses = mConnection.executeSimpleCommand(
|
|
String.format(Locale.US,
|
|
ImapConstants.STATUS + " \"%s\" (%s)",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix), flags));
|
|
// S: * STATUS mboxname (MESSAGES 231 UIDNEXT 44292)
|
|
for (ImapResponse response : responses) {
|
|
if (response.isDataResponse(0, ImapConstants.STATUS)) {
|
|
ImapList list = response.getListOrEmpty(2);
|
|
int count = list.size();
|
|
for (int i = 0; i < count; i += 2) {
|
|
String key = list.getStringOrEmpty(i).getString();
|
|
String value = list.getStringOrEmpty(i + 1).getString();
|
|
allReturnStatuses.put(key, value);
|
|
}
|
|
}
|
|
}
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
return allReturnStatuses;
|
|
}
|
|
|
|
private void cleanupConnection(ImapConnection connection, boolean close) {
|
|
if (close) {
|
|
connection.close();
|
|
}
|
|
synchronized (this) {
|
|
if (connection == mConnection) {
|
|
if (close) {
|
|
// To prevent close() from returning the connection to the pool
|
|
mConnection = null;
|
|
}
|
|
close(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<String> getNewMessagesFromUid(String uid) throws MessagingException {
|
|
checkOpen();
|
|
List<String> nextMSNs = new ArrayList<>();
|
|
try {
|
|
final List<ImapResponse> responses = mConnection.executeSimpleCommand(
|
|
ImapConstants.SEARCH + " " + ImapConstants.UID + " " + uid + ":*");
|
|
// S: * SEARCH 1 2 3
|
|
for (ImapResponse response : responses) {
|
|
if (response.isDataResponse(0, ImapConstants.SEARCH)) {
|
|
int count = response.size();
|
|
for (int i = 1; i < count; i++) {
|
|
nextMSNs.add(response.getStringOrEmpty(i).getString());
|
|
}
|
|
}
|
|
}
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
return nextMSNs;
|
|
}
|
|
|
|
@Override
|
|
public void delete(boolean recurse) {
|
|
throw new Error("ImapStore.delete() not yet implemented");
|
|
}
|
|
|
|
String[] getSearchUids(List<ImapResponse> responses) {
|
|
// S: * SEARCH 2 3 6
|
|
final ArrayList<String> uids = new ArrayList<String>();
|
|
for (ImapResponse response : responses) {
|
|
if (!response.isDataResponse(0, ImapConstants.SEARCH)) {
|
|
continue;
|
|
}
|
|
// Found SEARCH response data
|
|
for (int i = 1; i < response.size(); i++) {
|
|
ImapString s = response.getStringOrEmpty(i);
|
|
if (s.isString()) {
|
|
uids.add(s.getString());
|
|
}
|
|
}
|
|
}
|
|
return uids.toArray(Utility.EMPTY_STRINGS);
|
|
}
|
|
|
|
String[] searchForUids(String searchCriteria) throws MessagingException {
|
|
return searchForUids(searchCriteria, true);
|
|
}
|
|
|
|
/**
|
|
* I'm not a fan of having a parameter that determines whether to throw exceptions or
|
|
* consume them, but getMessage() for a date range needs to differentiate between
|
|
* a failure and just a legitimate empty result.
|
|
* See b/11183568.
|
|
* TODO:
|
|
* Either figure out how to make getMessage() with a date range work without this
|
|
* exception information, or make all users of searchForUids() handle the ImapException.
|
|
* It's too late in the release cycle to add this risk right now.
|
|
*/
|
|
@VisibleForTesting
|
|
String[] searchForUids(String searchCriteria, boolean swallowException)
|
|
throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
try {
|
|
final String command = ImapConstants.UID_SEARCH + " " + searchCriteria;
|
|
final String[] result = getSearchUids(mConnection.executeSimpleCommand(command));
|
|
LogUtils.d(Logging.LOG_TAG, "searchForUids '" + searchCriteria + "' results: " +
|
|
result.length);
|
|
return result;
|
|
} catch (ImapException me) {
|
|
LogUtils.d(Logging.LOG_TAG, me, "ImapException in search: " + searchCriteria);
|
|
if (swallowException) {
|
|
return Utility.EMPTY_STRINGS; // Not found
|
|
} else {
|
|
throw me;
|
|
}
|
|
} catch (IOException ioe) {
|
|
LogUtils.d(Logging.LOG_TAG, ioe, "IOException in search: " + searchCriteria);
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
}
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@VisibleForTesting
|
|
public Message getMessage(String uid) throws MessagingException {
|
|
checkOpen();
|
|
|
|
final String[] uids = searchForUids(ImapConstants.UID + " " + uid);
|
|
for (int i = 0; i < uids.length; i++) {
|
|
if (uids[i].equals(uid)) {
|
|
return new ImapMessage(uid, this);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
protected static boolean isAsciiString(String str) {
|
|
int len = str.length();
|
|
for (int i = 0; i < len; i++) {
|
|
char c = str.charAt(i);
|
|
if (c >= 128) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Retrieve messages based on search parameters. We search FROM, TO, CC, SUBJECT, and BODY
|
|
* We send: SEARCH OR FROM "foo" (OR TO "foo" (OR CC "foo" (OR SUBJECT "foo" BODY "foo"))), but
|
|
* with the additional CHARSET argument and sending "foo" as a literal (e.g. {3}<CRLF>foo}
|
|
*/
|
|
@Override
|
|
@VisibleForTesting
|
|
public Message[] getMessages(SearchParams params, MessageRetrievalListener listener)
|
|
throws MessagingException {
|
|
List<String> commands = new ArrayList<String>();
|
|
final String filter = params.mFilter;
|
|
// All servers MUST accept US-ASCII, so we'll send this as the CHARSET unless we're really
|
|
// dealing with a string that contains non-ascii characters
|
|
String charset = "US-ASCII";
|
|
if (!isAsciiString(filter)) {
|
|
charset = "UTF-8";
|
|
}
|
|
// This is the length of the string in octets (bytes), formatted as a string literal {n}
|
|
final String octetLength = "{" + filter.getBytes().length + "}";
|
|
// Break the command up into pieces ending with the string literal length
|
|
commands.add(ImapConstants.UID_SEARCH + " CHARSET " + charset + " OR FROM " + octetLength);
|
|
commands.add(filter + " (OR TO " + octetLength);
|
|
commands.add(filter + " (OR CC " + octetLength);
|
|
commands.add(filter + " (OR SUBJECT " + octetLength);
|
|
commands.add(filter + " BODY " + octetLength);
|
|
commands.add(filter + ")))");
|
|
return getMessagesInternal(complexSearchForUids(commands), listener);
|
|
}
|
|
|
|
/* package */ String[] complexSearchForUids(List<String> commands) throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
try {
|
|
return getSearchUids(mConnection.executeComplexCommand(commands, false));
|
|
} catch (ImapException e) {
|
|
return Utility.EMPTY_STRINGS; // not found;
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
}
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@VisibleForTesting
|
|
public Message[] getMessages(int start, int end, MessageRetrievalListener listener)
|
|
throws MessagingException {
|
|
if (start < 1 || end < 1 || end < start) {
|
|
throw new MessagingException(String.format("Invalid range: %d %d", start, end));
|
|
}
|
|
LogUtils.d(Logging.LOG_TAG, "getMessages number " + start + " - " + end);
|
|
return getMessagesInternal(
|
|
searchForUids(String.format(Locale.US, "%d:%d NOT DELETED", start, end)), listener);
|
|
}
|
|
|
|
private String generateDateRangeCommand(final long startDate, final long endDate,
|
|
boolean useQuotes)
|
|
throws MessagingException {
|
|
// Dates must be formatted like: 7-Feb-1994. Time info within a date is not
|
|
// universally supported.
|
|
// XXX can I limit the maximum number of results?
|
|
final SimpleDateFormat formatter = new SimpleDateFormat("dd-LLL-yyyy", Locale.US);
|
|
formatter.setTimeZone(TimeZone.getTimeZone("UTC"));
|
|
final String sinceDateStr = formatter.format(endDate);
|
|
|
|
StringBuilder queryParam = new StringBuilder();
|
|
queryParam.append( "1:* ");
|
|
// If the caller requests a startDate of zero, then ignore the BEFORE parameter.
|
|
// This makes sure that we can always query for the newest messages, even if our
|
|
// time is different from the imap server's time.
|
|
if (startDate != 0) {
|
|
final String beforeDateStr = formatter.format(startDate);
|
|
if (startDate < endDate) {
|
|
throw new MessagingException(String.format("Invalid date range: %s - %s",
|
|
sinceDateStr, beforeDateStr));
|
|
}
|
|
queryParam.append("BEFORE ");
|
|
if (useQuotes) queryParam.append('\"');
|
|
queryParam.append(beforeDateStr);
|
|
if (useQuotes) queryParam.append('\"');
|
|
queryParam.append(" ");
|
|
}
|
|
queryParam.append("SINCE ");
|
|
if (useQuotes) queryParam.append('\"');
|
|
queryParam.append(sinceDateStr);
|
|
if (useQuotes) queryParam.append('\"');
|
|
|
|
return queryParam.toString();
|
|
}
|
|
|
|
@Override
|
|
@VisibleForTesting
|
|
public Message[] getMessages(long startDate, long endDate, MessageRetrievalListener listener)
|
|
throws MessagingException {
|
|
String [] uids = null;
|
|
String command = generateDateRangeCommand(startDate, endDate, false)
|
|
+ " NOT DELETED";
|
|
LogUtils.d(Logging.LOG_TAG, "getMessages dateRange " + command.toString());
|
|
|
|
try {
|
|
uids = searchForUids(command.toString(), false);
|
|
} catch (ImapException e) {
|
|
// TODO: This is a last minute hack to make certain servers work. Some servers
|
|
// demand that the date in the date range be surrounded by double quotes, other
|
|
// servers won't accept that. So if we can an ImapException using one method,
|
|
// try the other.
|
|
// See b/11183568
|
|
LogUtils.d(Logging.LOG_TAG, e, "query failed %s, trying alternate",
|
|
command.toString());
|
|
command = generateDateRangeCommand(startDate, endDate, true)
|
|
+ " NOT DELETED";
|
|
try {
|
|
uids = searchForUids(command, true);
|
|
} catch (ImapException e2) {
|
|
LogUtils.w(Logging.LOG_TAG, e2, "query failed %s, fatal", command);
|
|
uids = null;
|
|
}
|
|
}
|
|
return getMessagesInternal(uids, listener);
|
|
}
|
|
|
|
@Override
|
|
@VisibleForTesting
|
|
public Message[] getMessages(String[] uids, MessageRetrievalListener listener)
|
|
throws MessagingException {
|
|
if (uids == null) {
|
|
uids = searchForUids("1:* NOT DELETED");
|
|
}
|
|
return getMessagesInternal(uids, listener);
|
|
}
|
|
|
|
public Message[] getMessagesInternal(String[] uids, MessageRetrievalListener listener) {
|
|
final ArrayList<Message> messages = new ArrayList<Message>(uids.length);
|
|
for (int i = 0; i < uids.length; i++) {
|
|
final String uid = uids[i];
|
|
final ImapMessage message = new ImapMessage(uid, this);
|
|
messages.add(message);
|
|
if (listener != null) {
|
|
listener.messageRetrieved(message);
|
|
}
|
|
}
|
|
return messages.toArray(Message.EMPTY_ARRAY);
|
|
}
|
|
|
|
@Override
|
|
public void fetch(Message[] messages, FetchProfile fp, MessageRetrievalListener listener)
|
|
throws MessagingException {
|
|
try {
|
|
fetchInternal(messages, fp, listener);
|
|
} catch (RuntimeException e) { // Probably a parser error.
|
|
LogUtils.w(Logging.LOG_TAG, "Exception detected: " + e.getMessage());
|
|
if (mConnection != null) {
|
|
mConnection.logLastDiscourse();
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
// TODO Why are we only fetching the first part given?
|
|
final Part fetchPart = fp.getFirstPart();
|
|
if (fetchPart != null) {
|
|
final String[] partIds =
|
|
fetchPart.getHeader(MimeHeader.HEADER_ANDROID_ATTACHMENT_STORE_DATA);
|
|
// TODO Why can a single part have more than one Id? And why should we only fetch
|
|
// the first id if there are more than one?
|
|
if (partIds != null) {
|
|
fetchFields.add(ImapConstants.FETCH_FIELD_BODY_PEEK_BARE
|
|
+ "[" + partIds[0] + "]");
|
|
}
|
|
}
|
|
|
|
try {
|
|
mConnection.sendCommand(String.format(Locale.US,
|
|
ImapConstants.UID_FETCH + " %s (%s)", ImapStore.joinMessageUids(messages),
|
|
Utility.combine(fetchFields.toArray(new String[fetchFields.size()]), ' ')
|
|
), false);
|
|
ImapResponse response;
|
|
do {
|
|
response = null;
|
|
try {
|
|
response = mConnection.readResponse();
|
|
|
|
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 String header = fetchList.getKeyedStringOrEmpty(
|
|
ImapConstants.BODY_BRACKET_HEADER, true).getString();
|
|
|
|
message.setInternalDate(internalDate);
|
|
message.setSize(size);
|
|
message.parse(Utility.streamFromAsciiString(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) {
|
|
LogUtils.v(Logging.LOG_TAG, e, "Error handling message");
|
|
}
|
|
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);
|
|
InputStream bodyStream = body.getAsStream();
|
|
message.parse(bodyStream);
|
|
}
|
|
if (fetchPart != null) {
|
|
InputStream bodyStream =
|
|
fetchList.getKeyedStringOrEmpty("BODY[", true).getAsStream();
|
|
String encodings[] = fetchPart.getHeader(
|
|
MimeHeader.HEADER_CONTENT_TRANSFER_ENCODING);
|
|
|
|
String contentTransferEncoding = null;
|
|
if (encodings != null && encodings.length > 0) {
|
|
contentTransferEncoding = encodings[0];
|
|
} else {
|
|
// According to http://tools.ietf.org/html/rfc2045#section-6.1
|
|
// "7bit" is the default.
|
|
contentTransferEncoding = "7bit";
|
|
}
|
|
|
|
try {
|
|
// 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));
|
|
} catch(Exception e) {
|
|
// TODO: Figure out what kinds of exceptions might actually be thrown
|
|
// from here. This blanket catch-all is because we're not sure what to
|
|
// do if we don't have a contentTransferEncoding, and we don't have
|
|
// time to figure out what exceptions might be thrown.
|
|
LogUtils.e(Logging.LOG_TAG, "Error fetching body %s", e);
|
|
}
|
|
}
|
|
|
|
if (listener != null) {
|
|
listener.messageRetrieved(message);
|
|
}
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
} while (!response.isTagged());
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes any content transfer encoding from the stream and returns a Body.
|
|
* This code is taken/condensed from MimeUtility.decodeBody
|
|
*/
|
|
private static Body decodeBody(InputStream in, String contentTransferEncoding, int size,
|
|
MessageRetrievalListener listener) throws IOException {
|
|
// Get a properly wrapped input stream
|
|
in = MimeUtility.getInputStreamForContentTransferEncoding(in, contentTransferEncoding);
|
|
BinaryTempFileBody tempBody = new BinaryTempFileBody();
|
|
OutputStream out = tempBody.getOutputStream();
|
|
try {
|
|
byte[] buffer = new byte[COPY_BUFFER_SIZE];
|
|
int n = 0;
|
|
int count = 0;
|
|
while (-1 != (n = in.read(buffer))) {
|
|
out.write(buffer, 0, n);
|
|
count += n;
|
|
if (listener != null) {
|
|
if (size == 0) {
|
|
// We don't know how big the file is, so just fake it.
|
|
listener.loadAttachmentProgress((int)Math.ceil(100 * (1-1.0/count)));
|
|
} else {
|
|
listener.loadAttachmentProgress(count * 100 / size);
|
|
}
|
|
}
|
|
}
|
|
} catch (Base64DataException bde) {
|
|
String warning = "\n\n" + ImapService.getMessageDecodeErrorString();
|
|
out.write(warning.getBytes());
|
|
} finally {
|
|
out.close();
|
|
}
|
|
return tempBody;
|
|
}
|
|
|
|
@Override
|
|
public Flag[] getPermanentFlags() {
|
|
return PERMANENT_FLAGS;
|
|
}
|
|
|
|
/**
|
|
* Handle any untagged responses that the caller doesn't care to handle themselves.
|
|
* @param responses
|
|
*/
|
|
private void handleUntaggedResponses(List<ImapResponse> responses) {
|
|
for (ImapResponse response : responses) {
|
|
handleUntaggedResponse(response);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle an untagged response that the caller doesn't care to handle themselves.
|
|
* @param response
|
|
*/
|
|
private void handleUntaggedResponse(ImapResponse response) {
|
|
if (response.isDataResponse(1, ImapConstants.EXISTS)) {
|
|
synchronized (this) {
|
|
mMessageCount = response.getStringOrEmpty(0).getNumberOrZero();
|
|
}
|
|
}
|
|
}
|
|
|
|
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(Locale.US));
|
|
}
|
|
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(Locale.US);
|
|
|
|
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.");
|
|
}
|
|
|
|
/*
|
|
* 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(Locale.US);
|
|
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(Locale.US, ";\n %s=\"%s\"",
|
|
bodyDispositionParams.getStringOrEmpty(i - 1)
|
|
.getString().toLowerCase(Locale.US),
|
|
bodyDispositionParams.getStringOrEmpty(i).getString()));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((size > 0)
|
|
&& (MimeUtility.getHeaderParameter(contentDisposition.toString(), "size")
|
|
== null)) {
|
|
contentDisposition.append(String.format(Locale.US, ";\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.
|
|
* @param message Message
|
|
* @param noTimeout Set to true on manual syncs, disables the timeout after sending the message
|
|
* content to the server
|
|
*/
|
|
@Override
|
|
public void appendMessage(final Context context, final Message message, final boolean noTimeout)
|
|
throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
// Create temp file
|
|
/**
|
|
* We need to know the encoded message size before we upload it, and encoding
|
|
* attachments as Base64, possibly reading from a slow provider, is a non-trivial
|
|
* operation. So we write the contents to a temp file while measuring the size,
|
|
* and then use that temp file and size to do the actual upsync.
|
|
* For context, most classic email clients would store the message in RFC822 format
|
|
* internally, and so would not need to do this on-the-fly.
|
|
*/
|
|
final File tempDir = context.getExternalCacheDir();
|
|
final File tempFile = File.createTempFile("IMAPupsync", ".eml", tempDir);
|
|
// Delete here so we don't leave the file lingering. We've got a handle to it so we
|
|
// can still use it.
|
|
final boolean deleteSuccessful = tempFile.delete();
|
|
if (!deleteSuccessful) {
|
|
LogUtils.w(LogUtils.TAG, "Could not delete temp file %s",
|
|
tempFile.getAbsolutePath());
|
|
}
|
|
final OutputStream tempOut = new FileOutputStream(tempFile);
|
|
// Create output count while writing temp file
|
|
final CountingOutputStream out = new CountingOutputStream(tempOut);
|
|
final 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 (final Flag flag : flags) {
|
|
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(Locale.US, ImapConstants.APPEND + " \"%s\" (%s) {%d}",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix),
|
|
flagList,
|
|
out.getCount()), false);
|
|
ImapResponse response;
|
|
do {
|
|
final int socketTimeout = mConnection.mTransport.getSoTimeout();
|
|
try {
|
|
// Need to set the timeout to unlimited since we might be upsyncing a pretty
|
|
// big attachment so who knows how long it'll take. It would sure be nice
|
|
// if this only timed out after the send buffer drained but welp.
|
|
if (noTimeout) {
|
|
// For now, only unset the timeout if we're doing a manual sync
|
|
mConnection.mTransport.setSoTimeout(0);
|
|
}
|
|
response = mConnection.readResponse();
|
|
if (response.isContinuationRequest()) {
|
|
final OutputStream transportOutputStream =
|
|
mConnection.mTransport.getOutputStream();
|
|
IOUtils.copyLarge(new FileInputStream(tempFile), transportOutputStream);
|
|
transportOutputStream.write('\r');
|
|
transportOutputStream.write('\n');
|
|
transportOutputStream.flush();
|
|
} else if (!response.isTagged()) {
|
|
handleUntaggedResponse(response);
|
|
}
|
|
} finally {
|
|
mConnection.mTransport.setSoTimeout(socketTimeout);
|
|
}
|
|
} 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);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
final String messageId = message.getMessageId();
|
|
if (messageId == null || messageId.length() == 0) {
|
|
return;
|
|
}
|
|
// 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(Locale.US, "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(Locale.US, "(HEADER MESSAGE-ID %s)", messageId));
|
|
if (uids.length > 0) {
|
|
message.setUid(uids[0]);
|
|
}
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public Message[] expunge() throws MessagingException {
|
|
checkOpen();
|
|
try {
|
|
handleUntaggedResponses(mConnection.executeSimpleCommand(ImapConstants.EXPUNGE));
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void setFlags(Message[] messages, Flag[] flags, boolean value)
|
|
throws MessagingException {
|
|
checkOpen();
|
|
|
|
String allFlags = "";
|
|
if (flags.length > 0) {
|
|
StringBuilder flagList = new StringBuilder();
|
|
for (int i = 0, count = flags.length; i < count; i++) {
|
|
Flag flag = flags[i];
|
|
if (flag == Flag.SEEN) {
|
|
flagList.append(" " + ImapConstants.FLAG_SEEN);
|
|
} else if (flag == Flag.DELETED) {
|
|
flagList.append(" " + ImapConstants.FLAG_DELETED);
|
|
} else if (flag == Flag.FLAGGED) {
|
|
flagList.append(" " + ImapConstants.FLAG_FLAGGED);
|
|
} else if (flag == Flag.ANSWERED) {
|
|
flagList.append(" " + ImapConstants.FLAG_ANSWERED);
|
|
}
|
|
}
|
|
allFlags = flagList.substring(1);
|
|
}
|
|
try {
|
|
mConnection.executeSimpleCommand(String.format(Locale.US,
|
|
ImapConstants.UID_STORE + " %s %s" + ImapConstants.FLAGS_SILENT + " (%s)",
|
|
ImapStore.joinMessageUids(messages),
|
|
value ? "+" : "-",
|
|
allFlags));
|
|
|
|
} catch (IOException ioe) {
|
|
throw ioExceptionHandler(mConnection, ioe);
|
|
} finally {
|
|
destroyResponses();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Persists this folder. We will always perform the proper database operation (e.g.
|
|
* 'save' or 'update'). As an optimization, if a folder has not been modified, no
|
|
* database operations are performed.
|
|
*/
|
|
void save(Context context) {
|
|
final Mailbox mailbox = mMailbox;
|
|
if (!mailbox.isSaved()) {
|
|
mailbox.save(context);
|
|
mHash = mailbox.getHashes();
|
|
} else {
|
|
Object[] hash = mailbox.getHashes();
|
|
if (!Arrays.equals(mHash, hash)) {
|
|
mailbox.update(context, mailbox.toContentValues());
|
|
mHash = hash; // Save updated hash
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Selects the folder for use. Before performing any operations on this folder, it
|
|
* must be selected.
|
|
*/
|
|
private void doSelect() throws IOException, MessagingException {
|
|
final List<ImapResponse> responses = mConnection.executeSimpleCommand(
|
|
String.format(Locale.US, ImapConstants.SELECT + " \"%s\"",
|
|
ImapStore.encodeFolderName(mName, mStore.mPathPrefix)));
|
|
|
|
// Assume the folder is opened read-write; unless we are notified otherwise
|
|
mMode = OpenMode.READ_WRITE;
|
|
int messageCount = -1;
|
|
for (ImapResponse response : responses) {
|
|
if (response.isDataResponse(1, ImapConstants.EXISTS)) {
|
|
messageCount = response.getStringOrEmpty(0).getNumberOrZero();
|
|
} else if (response.isOk()) {
|
|
final ImapString responseCode = response.getResponseCodeOrEmpty();
|
|
if (responseCode.is(ImapConstants.READ_ONLY)) {
|
|
mMode = OpenMode.READ_ONLY;
|
|
} else if (responseCode.is(ImapConstants.READ_WRITE)) {
|
|
mMode = OpenMode.READ_WRITE;
|
|
}
|
|
} else if (response.isTagged()) { // Not OK
|
|
throw new MessagingException("Can't open mailbox: "
|
|
+ response.getStatusResponseTextOrEmpty());
|
|
}
|
|
}
|
|
if (messageCount == -1) {
|
|
throw new MessagingException("Did not find message count during select");
|
|
}
|
|
mMessageCount = messageCount;
|
|
mExists = true;
|
|
}
|
|
|
|
private void checkOpen() throws MessagingException {
|
|
if (!isOpen()) {
|
|
throw new MessagingException("Folder " + mName + " is not open.");
|
|
}
|
|
}
|
|
|
|
private MessagingException ioExceptionHandler(ImapConnection connection, IOException ioe) {
|
|
if (DebugUtils.DEBUG) {
|
|
LogUtils.d(Logging.LOG_TAG, ioe, "IO Exception detected: ");
|
|
}
|
|
if (connection != null) {
|
|
cleanupConnection(connection, true);
|
|
}
|
|
return new MessagingException(MessagingException.IOERROR, "IO Error", ioe);
|
|
}
|
|
|
|
private ImapIdleChanges extractImapChanges(List<Object> changes) throws MessagingException {
|
|
// Process the changes and fill the idle changes structure.
|
|
// Basically we should look for the next commands in this method:
|
|
//
|
|
// OK DONE
|
|
// No more changes
|
|
// n EXISTS
|
|
// Indicates the number of messages in the mailbox => handle like
|
|
// RECENT if the number increased
|
|
// n EXPUNGE
|
|
// Indicates a message was completely deleted => a full sync is required
|
|
// n RECENT
|
|
// New messages waiting in the server => use UIDNEXT to search for the new messages.
|
|
// If isn't possible to retrieve the new UID messages, then a full sync is required
|
|
// n FETCH (UID X FLAGS (...))
|
|
// a message has changed and requires to fetch only X message
|
|
// (something change on that item). If UID is not present, a conversion
|
|
// from MSN to UID is required
|
|
|
|
final ImapIdleChanges imapIdleChanges = new ImapIdleChanges();
|
|
|
|
int count = changes.size();
|
|
if (Logging.LOGD) {
|
|
for (int i = 0; i < count; i++) {
|
|
ImapResponse change = (ImapResponse) changes.get(i);
|
|
if (Logging.LOGD) {
|
|
LogUtils.d(Logging.LOG_TAG, "Received: " + change.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
// We can't ask to the server, because the responses will be destroyed. We need
|
|
// to compute and fetch any related after we have all the responses processed
|
|
boolean hasNewMessages = false;
|
|
List<String> msns = new ArrayList<>();
|
|
for (int i = 0; i < count; i++) {
|
|
ImapResponse change = (ImapResponse) changes.get(i);
|
|
if (change.isOk() || change.isNo() || change.isBad()) {
|
|
// No more processing. DONE included
|
|
break;
|
|
}
|
|
try {
|
|
ImapElement element = change.getElementOrNone(1);
|
|
if (element.equals(ImapElement.NONE)) {
|
|
continue;
|
|
}
|
|
if (!element.isString()) {
|
|
continue;
|
|
}
|
|
|
|
ImapString op = (ImapString) element;
|
|
if (op.is(ImapConstants.DONE)) {
|
|
break;
|
|
} else if (op.is(ImapConstants.EXISTS)) {
|
|
int newMessageCount = change.getStringOrEmpty(0).getNumberOrZero();
|
|
int oldMessageCount;
|
|
synchronized (this) {
|
|
oldMessageCount = mMessageCount;
|
|
mMessageCount = newMessageCount;
|
|
}
|
|
if (Logging.LOGD) {
|
|
LogUtils.d(LOG_TAG, "Got EXISTS idle response, message count now "
|
|
+ newMessageCount + ", was " + oldMessageCount);
|
|
}
|
|
if (newMessageCount > oldMessageCount) {
|
|
hasNewMessages = true;
|
|
}
|
|
} else if (op.is(ImapConstants.EXPUNGE)) {
|
|
imapIdleChanges.mRequiredSync = true;
|
|
synchronized (this) {
|
|
mMessageCount--;
|
|
}
|
|
} else if (op.is(ImapConstants.RECENT)) {
|
|
hasNewMessages = true;
|
|
} else if (op.is(ImapConstants.FETCH)
|
|
&& change.getElementOrNone(2).isList()) {
|
|
ImapList messageFlags = (ImapList) change.getElementOrNone(2);
|
|
String uid = ((ImapString) messageFlags.getKeyedStringOrEmpty(
|
|
ImapConstants.UID, true)).getString();
|
|
if (!TextUtils.isEmpty(uid) &&
|
|
!imapIdleChanges.mMessageToFetch.contains(uid)) {
|
|
imapIdleChanges.mMessageToFetch.add(uid);
|
|
} else {
|
|
msns.add(change.getStringOrEmpty(0).getString());
|
|
}
|
|
} else {
|
|
if (Logging.LOGD) {
|
|
LogUtils.w(LOG_TAG, "Unrecognized imap change (" + change
|
|
+ ") for mailbox " + mName);
|
|
}
|
|
}
|
|
|
|
} catch (Exception ex) {
|
|
if (Logging.LOGD) {
|
|
LogUtils.e(LOG_TAG, ex, "Failure processing imap change (" + change
|
|
+ ") for mailbox " + mName);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check whether UIDVALIDITY changed - if yes, a full sync request is required
|
|
// NOTE: This needs to happen after parsing all responses; otherwise
|
|
// getStatuses will destroy the response
|
|
Map<String, String> statuses = getStatuses(new String[] { ImapConstants.UIDVALIDITY });
|
|
String oldUidValidity = mIdleStatuses.get(ImapConstants.UIDVALIDITY);
|
|
String newUidValidity = statuses.get(ImapConstants.UIDVALIDITY);
|
|
if (!TextUtils.equals(oldUidValidity, newUidValidity)) {
|
|
imapIdleChanges.mMessageToFetch.clear();
|
|
imapIdleChanges.mRequiredSync = true;
|
|
return imapIdleChanges;
|
|
}
|
|
|
|
// Recover the UIDs of new messages in case we don't do a full sync anyway
|
|
if (!imapIdleChanges.mRequiredSync) {
|
|
try {
|
|
// Retrieve new message UIDs
|
|
String uidNext = mIdleStatuses.get(ImapConstants.UIDNEXT);
|
|
if (hasNewMessages && !TextUtils.isEmpty(uidNext)) {
|
|
msns.addAll(getNewMessagesFromUid(uidNext));
|
|
}
|
|
|
|
// Transform MSNs to UIDs
|
|
for (String msn : msns) {
|
|
String[] uids = searchForUids(String.format(Locale.US, "%s:%s", msn, msn));
|
|
if (uids.length > 0) {
|
|
imapIdleChanges.mMessageToFetch.add(uids[0]);
|
|
} else {
|
|
throw new MessagingException("Server could not resolve MSN " + msn);
|
|
}
|
|
}
|
|
} catch (MessagingException ex) {
|
|
// Server doesn't support UID. We have to do a full sync (since
|
|
// we don't know what message changed)
|
|
imapIdleChanges.mMessageToFetch.clear();
|
|
imapIdleChanges.mRequiredSync = true;
|
|
}
|
|
}
|
|
|
|
return imapIdleChanges;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (o instanceof ImapFolder) {
|
|
return ((ImapFolder)o).mName.equals(mName);
|
|
}
|
|
return super.equals(o);
|
|
}
|
|
|
|
@Override
|
|
public Message createMessage(String uid) {
|
|
return new ImapMessage(uid, this);
|
|
}
|
|
}
|