(this,
+ android.R.layout.simple_spinner_item, securityTypes);
+ securityTypesAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+ mSecurityTypeView.setAdapter(securityTypesAdapter);
+
+ /*
+ * Updates the port when the user changes the security type. This allows
+ * us to show a reasonable default which the user can change.
+ */
+ mSecurityTypeView.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
+ public void onItemSelected(AdapterView arg0, View arg1, int arg2, long arg3) {
+ updatePortFromSecurityType();
+ }
+
+ public void onNothingSelected(AdapterView arg0) {
+ }
+ });
+
+ /*
+ * Calls validateFields() which enables or disables the Next button
+ * based on the fields' validity.
+ */
+ TextWatcher validationTextWatcher = new TextWatcher() {
+ public void afterTextChanged(Editable s) {
+ validateFields();
+ }
+
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+ };
+ mUsernameView.addTextChangedListener(validationTextWatcher);
+ mPasswordView.addTextChangedListener(validationTextWatcher);
+ mServerView.addTextChangedListener(validationTextWatcher);
+ mPortView.addTextChangedListener(validationTextWatcher);
+
+ /*
+ * Only allow digits in the port field.
+ */
+ mPortView.setKeyListener(DigitsKeyListener.getInstance("0123456789"));
+
+ mAccount = (Account)getIntent().getSerializableExtra(EXTRA_ACCOUNT);
+ mMakeDefault = (boolean)getIntent().getBooleanExtra(EXTRA_MAKE_DEFAULT, false);
+
+ /*
+ * If we're being reloaded we override the original account with the one
+ * we saved
+ */
+ if (savedInstanceState != null && savedInstanceState.containsKey(EXTRA_ACCOUNT)) {
+ mAccount = (Account)savedInstanceState.getSerializable(EXTRA_ACCOUNT);
+ }
+
+ try {
+ URI uri = new URI(mAccount.getTransportUri());
+ String username = null;
+ String password = null;
+ if (uri.getUserInfo() != null) {
+ String[] userInfoParts = uri.getUserInfo().split(":", 2);
+ username = userInfoParts[0];
+ if (userInfoParts.length > 1) {
+ password = userInfoParts[1];
+ }
+ }
+
+ if (username != null) {
+ mUsernameView.setText(username);
+ mRequireLoginView.setChecked(true);
+ }
+
+ if (password != null) {
+ mPasswordView.setText(password);
+ }
+
+ for (int i = 0; i < smtpSchemes.length; i++) {
+ if (smtpSchemes[i].equals(uri.getScheme())) {
+ SpinnerOption.setSpinnerOptionValue(mSecurityTypeView, i);
+ }
+ }
+
+ if (uri.getHost() != null) {
+ mServerView.setText(uri.getHost());
+ }
+
+ if (uri.getPort() != -1) {
+ mPortView.setText(Integer.toString(uri.getPort()));
+ } else {
+ updatePortFromSecurityType();
+ }
+ } catch (URISyntaxException use) {
+ /*
+ * We should always be able to parse our own settings.
+ */
+ throw new Error(use);
+ }
+
+ validateFields();
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle outState) {
+ super.onSaveInstanceState(outState);
+ outState.putSerializable(EXTRA_ACCOUNT, mAccount);
+ }
+
+ private void validateFields() {
+ mNextButton
+ .setEnabled(
+ Utility.requiredFieldValid(mServerView) &&
+ Utility.requiredFieldValid(mPortView) &&
+ (!mRequireLoginView.isChecked() ||
+ (Utility.requiredFieldValid(mUsernameView) &&
+ Utility.requiredFieldValid(mPasswordView))));
+ Utility.setCompoundDrawablesAlpha(mNextButton, mNextButton.isEnabled() ? 255 : 128);
+ }
+
+ private void updatePortFromSecurityType() {
+ int securityType = (Integer)((SpinnerOption)mSecurityTypeView.getSelectedItem()).value;
+ mPortView.setText(Integer.toString(smtpPorts[securityType]));
+ }
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (resultCode == RESULT_OK) {
+ if (Intent.ACTION_EDIT.equals(getIntent().getAction())) {
+ mAccount.save(Preferences.getPreferences(this));
+ finish();
+ } else {
+ AccountSetupOptions.actionOptions(this, mAccount, mMakeDefault);
+ finish();
+ }
+ }
+ }
+
+ private void onNext() {
+ int securityType = (Integer)((SpinnerOption)mSecurityTypeView.getSelectedItem()).value;
+ URI uri;
+ try {
+ String userInfo = null;
+ if (mRequireLoginView.isChecked()) {
+ userInfo = mUsernameView.getText().toString() + ":"
+ + mPasswordView.getText().toString();
+ }
+ uri = new URI(smtpSchemes[securityType], userInfo, mServerView.getText().toString(),
+ Integer.parseInt(mPortView.getText().toString()), null, null, null);
+ mAccount.setTransportUri(uri.toString());
+ } catch (URISyntaxException use) {
+ /*
+ * It's unrecoverable if we cannot create a URI from components that
+ * we validated to be safe.
+ */
+ throw new Error(use);
+ }
+ AccountSetupCheckSettings.actionCheckSettings(this, mAccount, false, true);
+ }
+
+ public void onClick(View v) {
+ switch (v.getId()) {
+ case R.id.next:
+ onNext();
+ break;
+ }
+ }
+
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ mRequireLoginSettingsView.setVisibility(isChecked ? View.VISIBLE : View.GONE);
+ validateFields();
+ }
+}
diff --git a/src/com/fsck/k9/activity/setup/SpinnerOption.java b/src/com/fsck/k9/activity/setup/SpinnerOption.java
new file mode 100644
index 0000000000000000000000000000000000000000..f97a9524964840178115817cd775db36c021b0c0
--- /dev/null
+++ b/src/com/fsck/k9/activity/setup/SpinnerOption.java
@@ -0,0 +1,33 @@
+/**
+ *
+ */
+
+package com.fsck.k9.activity.setup;
+
+import android.widget.Spinner;
+
+public class SpinnerOption {
+ public Object value;
+
+ public String label;
+
+ public static void setSpinnerOptionValue(Spinner spinner, Object value) {
+ for (int i = 0, count = spinner.getCount(); i < count; i++) {
+ SpinnerOption so = (SpinnerOption)spinner.getItemAtPosition(i);
+ if (so.value.equals(value)) {
+ spinner.setSelection(i, true);
+ return;
+ }
+ }
+ }
+
+ public SpinnerOption(Object value, String label) {
+ this.value = value;
+ this.label = label;
+ }
+
+ @Override
+ public String toString() {
+ return label;
+ }
+}
diff --git a/src/com/fsck/k9/codec/binary/Base64.java b/src/com/fsck/k9/codec/binary/Base64.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba5b0312602c32627fa76dbd5bbf11f47c4fb015
--- /dev/null
+++ b/src/com/fsck/k9/codec/binary/Base64.java
@@ -0,0 +1,788 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.fsck.k9.codec.binary;
+
+import org.apache.commons.codec.BinaryDecoder;
+import org.apache.commons.codec.BinaryEncoder;
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.EncoderException;
+
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+
+/**
+ * Provides Base64 encoding and decoding as defined by RFC 2045.
+ *
+ *
+ * This class implements section 6.8. Base64 Content-Transfer-Encoding from RFC 2045 Multipurpose
+ * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies by Freed and Borenstein.
+ *
+ *
+ * @see RFC 2045
+ * @author Apache Software Foundation
+ * @since 1.0-dev
+ * @version $Id$
+ */
+public class Base64 implements BinaryEncoder, BinaryDecoder {
+ /**
+ * Chunk size per RFC 2045 section 6.8.
+ *
+ *
+ * The {@value} character limit does not count the trailing CRLF, but counts all other characters, including any
+ * equal signs.
+ *
+ *
+ * @see RFC 2045 section 6.8
+ */
+ static final int CHUNK_SIZE = 76;
+
+ /**
+ * Chunk separator per RFC 2045 section 2.1.
+ *
+ * @see RFC 2045 section 2.1
+ */
+ static final byte[] CHUNK_SEPARATOR = {'\r','\n'};
+
+ /**
+ * This array is a lookup table that translates 6-bit positive integer
+ * index values into their "Base64 Alphabet" equivalents as specified
+ * in Table 1 of RFC 2045.
+ *
+ * Thanks to "commons" project in ws.apache.org for this code.
+ * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ */
+ private static final byte[] intToBase64 = {
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+ 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+ 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+ };
+
+ /**
+ * Byte used to pad output.
+ */
+ private static final byte PAD = '=';
+
+ /**
+ * This array is a lookup table that translates unicode characters
+ * drawn from the "Base64 Alphabet" (as specified in Table 1 of RFC 2045)
+ * into their 6-bit positive integer equivalents. Characters that
+ * are not in the Base64 alphabet but fall within the bounds of the
+ * array are translated to -1.
+ *
+ * Thanks to "commons" project in ws.apache.org for this code.
+ * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ */
+ private static final byte[] base64ToInt = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54,
+ 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+ };
+
+ /** Mask used to extract 6 bits, used when encoding */
+ private static final int MASK_6BITS = 0x3f;
+
+ /** Mask used to extract 8 bits, used in decoding base64 bytes */
+ private static final int MASK_8BITS = 0xff;
+
+ // The static final fields above are used for the original static byte[] methods on Base64.
+ // The private member fields below are used with the new streaming approach, which requires
+ // some state be preserved between calls of encode() and decode().
+
+
+ /**
+ * Line length for encoding. Not used when decoding. A value of zero or less implies
+ * no chunking of the base64 encoded data.
+ */
+ private final int lineLength;
+
+ /**
+ * Line separator for encoding. Not used when decoding. Only used if lineLength > 0.
+ */
+ private final byte[] lineSeparator;
+
+ /**
+ * Convenience variable to help us determine when our buffer is going to run out of
+ * room and needs resizing. decodeSize = 3 + lineSeparator.length;
+ */
+ private final int decodeSize;
+
+ /**
+ * Convenience variable to help us determine when our buffer is going to run out of
+ * room and needs resizing. encodeSize = 4 + lineSeparator.length;
+ */
+ private final int encodeSize;
+
+ /**
+ * Buffer for streaming.
+ */
+ private byte[] buf;
+
+ /**
+ * Position where next character should be written in the buffer.
+ */
+ private int pos;
+
+ /**
+ * Position where next character should be read from the buffer.
+ */
+ private int readPos;
+
+ /**
+ * Variable tracks how many characters have been written to the current line.
+ * Only used when encoding. We use it to make sure each encoded line never
+ * goes beyond lineLength (if lineLength > 0).
+ */
+ private int currentLinePos;
+
+ /**
+ * Writes to the buffer only occur after every 3 reads when encoding, an
+ * every 4 reads when decoding. This variable helps track that.
+ */
+ private int modulus;
+
+ /**
+ * Boolean flag to indicate the EOF has been reached. Once EOF has been
+ * reached, this Base64 object becomes useless, and must be thrown away.
+ */
+ private boolean eof;
+
+ /**
+ * Place holder for the 3 bytes we're dealing with for our base64 logic.
+ * Bitwise operations store and extract the base64 encoding or decoding from
+ * this variable.
+ */
+ private int x;
+
+ /**
+ * Default constructor: lineLength is 76, and the lineSeparator is CRLF
+ * when encoding, and all forms can be decoded.
+ */
+ public Base64() {
+ this(CHUNK_SIZE, CHUNK_SEPARATOR);
+ }
+
+ /**
+ *
+ * Consumer can use this constructor to choose a different lineLength
+ * when encoding (lineSeparator is still CRLF). All forms of data can
+ * be decoded.
+ *
+ * Note: lineLengths that aren't multiples of 4 will still essentially
+ * end up being multiples of 4 in the encoded data.
+ *
+ *
+ * @param lineLength each line of encoded data will be at most this long
+ * (rounded up to nearest multiple of 4).
+ * If lineLength <= 0, then the output will not be divided into lines (chunks).
+ * Ignored when decoding.
+ */
+ public Base64(int lineLength) {
+ this(lineLength, CHUNK_SEPARATOR);
+ }
+
+ /**
+ *
+ * Consumer can use this constructor to choose a different lineLength
+ * and lineSeparator when encoding. All forms of data can
+ * be decoded.
+ *
+ * Note: lineLengths that aren't multiples of 4 will still essentially
+ * end up being multiples of 4 in the encoded data.
+ *
+ * @param lineLength Each line of encoded data will be at most this long
+ * (rounded up to nearest multiple of 4). Ignored when decoding.
+ * If <= 0, then output will not be divided into lines (chunks).
+ * @param lineSeparator Each line of encoded data will end with this
+ * sequence of bytes.
+ * If lineLength <= 0, then the lineSeparator is not used.
+ * @throws IllegalArgumentException The provided lineSeparator included
+ * some base64 characters. That's not going to work!
+ */
+ public Base64(int lineLength, byte[] lineSeparator) {
+ this.lineLength = lineLength;
+ this.lineSeparator = new byte[lineSeparator.length];
+ System.arraycopy(lineSeparator, 0, this.lineSeparator, 0, lineSeparator.length);
+ if (lineLength > 0) {
+ this.encodeSize = 4 + lineSeparator.length;
+ } else {
+ this.encodeSize = 4;
+ }
+ this.decodeSize = encodeSize - 1;
+ if (containsBase64Byte(lineSeparator)) {
+ String sep;
+ try {
+ sep = new String(lineSeparator, "UTF-8");
+ } catch (UnsupportedEncodingException uee) {
+ sep = new String(lineSeparator);
+ }
+ throw new IllegalArgumentException("lineSeperator must not contain base64 characters: [" + sep + "]");
+ }
+ }
+
+ /**
+ * Returns true if this Base64 object has buffered data for reading.
+ *
+ * @return true if there is Base64 object still available for reading.
+ */
+ boolean hasData() { return buf != null; }
+
+ /**
+ * Returns the amount of buffered data available for reading.
+ *
+ * @return The amount of buffered data available for reading.
+ */
+ int avail() { return buf != null ? pos - readPos : 0; }
+
+ /** Doubles our buffer. */
+ private void resizeBuf() {
+ if (buf == null) {
+ buf = new byte[8192];
+ pos = 0;
+ readPos = 0;
+ } else {
+ byte[] b = new byte[buf.length * 2];
+ System.arraycopy(buf, 0, b, 0, buf.length);
+ buf = b;
+ }
+ }
+
+ /**
+ * Extracts buffered data into the provided byte[] array, starting
+ * at position bPos, up to a maximum of bAvail bytes. Returns how
+ * many bytes were actually extracted.
+ *
+ * @param b byte[] array to extract the buffered data into.
+ * @param bPos position in byte[] array to start extraction at.
+ * @param bAvail amount of bytes we're allowed to extract. We may extract
+ * fewer (if fewer are available).
+ * @return The number of bytes successfully extracted into the provided
+ * byte[] array.
+ */
+ int readResults(byte[] b, int bPos, int bAvail) {
+ if (buf != null) {
+ int len = Math.min(avail(), bAvail);
+ if (buf != b) {
+ System.arraycopy(buf, readPos, b, bPos, len);
+ readPos += len;
+ if (readPos >= pos) {
+ buf = null;
+ }
+ } else {
+ // Re-using the original consumer's output array is only
+ // allowed for one round.
+ buf = null;
+ }
+ return len;
+ } else {
+ return eof ? -1 : 0;
+ }
+ }
+
+ /**
+ * Small optimization where we try to buffer directly to the consumer's
+ * output array for one round (if consumer calls this method first!) instead
+ * of starting our own buffer.
+ *
+ * @param out byte[] array to buffer directly to.
+ * @param outPos Position to start buffering into.
+ * @param outAvail Amount of bytes available for direct buffering.
+ */
+ void setInitialBuffer(byte[] out, int outPos, int outAvail) {
+ // We can re-use consumer's original output array under
+ // special circumstances, saving on some System.arraycopy().
+ if (out != null && out.length == outAvail) {
+ buf = out;
+ pos = outPos;
+ readPos = outPos;
+ }
+ }
+
+ /**
+ *
+ * Encodes all of the provided data, starting at inPos, for inAvail bytes.
+ * Must be called at least twice: once with the data to encode, and once
+ * with inAvail set to "-1" to alert encoder that EOF has been reached,
+ * so flush last remaining bytes (if not multiple of 3).
+ *
+ * Thanks to "commons" project in ws.apache.org for the bitwise operations,
+ * and general approach.
+ * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ *
+ *
+ * @param in byte[] array of binary data to base64 encode.
+ * @param inPos Position to start reading data from.
+ * @param inAvail Amount of bytes available from input for encoding.
+ */
+ void encode(byte[] in, int inPos, int inAvail) {
+ if (eof) {
+ return;
+ }
+
+ // inAvail < 0 is how we're informed of EOF in the underlying data we're
+ // encoding.
+ if (inAvail < 0) {
+ eof = true;
+ if (buf == null || buf.length - pos < encodeSize) {
+ resizeBuf();
+ }
+ switch (modulus) {
+ case 1:
+ buf[pos++] = intToBase64[(x >> 2) & MASK_6BITS];
+ buf[pos++] = intToBase64[(x << 4) & MASK_6BITS];
+ buf[pos++] = PAD;
+ buf[pos++] = PAD;
+ break;
+
+ case 2:
+ buf[pos++] = intToBase64[(x >> 10) & MASK_6BITS];
+ buf[pos++] = intToBase64[(x >> 4) & MASK_6BITS];
+ buf[pos++] = intToBase64[(x << 2) & MASK_6BITS];
+ buf[pos++] = PAD;
+ break;
+ }
+ if (lineLength > 0) {
+ System.arraycopy(lineSeparator, 0, buf, pos, lineSeparator.length);
+ pos += lineSeparator.length;
+ }
+ } else {
+ for (int i = 0; i < inAvail; i++) {
+ if (buf == null || buf.length - pos < encodeSize) {
+ resizeBuf();
+ }
+ modulus = (++modulus) % 3;
+ int b = in[inPos++];
+ if (b < 0) { b += 256; }
+ x = (x << 8) + b;
+ if (0 == modulus) {
+ buf[pos++] = intToBase64[(x >> 18) & MASK_6BITS];
+ buf[pos++] = intToBase64[(x >> 12) & MASK_6BITS];
+ buf[pos++] = intToBase64[(x >> 6) & MASK_6BITS];
+ buf[pos++] = intToBase64[x & MASK_6BITS];
+ currentLinePos += 4;
+ if (lineLength > 0 && lineLength <= currentLinePos) {
+ System.arraycopy(lineSeparator, 0, buf, pos, lineSeparator.length);
+ pos += lineSeparator.length;
+ currentLinePos = 0;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ *
+ * Decodes all of the provided data, starting at inPos, for inAvail bytes.
+ * Should be called at least twice: once with the data to decode, and once
+ * with inAvail set to "-1" to alert decoder that EOF has been reached.
+ * The "-1" call is not necessary when decoding, but it doesn't hurt, either.
+ *
+ * Ignores all non-base64 characters. This is how chunked (e.g. 76 character)
+ * data is handled, since CR and LF are silently ignored, but has implications
+ * for other bytes, too. This method subscribes to the garbage-in, garbage-out
+ * philosophy: it will not check the provided data for validity.
+ *
+ * Thanks to "commons" project in ws.apache.org for the bitwise operations,
+ * and general approach.
+ * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
+ *
+
+ * @param in byte[] array of ascii data to base64 decode.
+ * @param inPos Position to start reading data from.
+ * @param inAvail Amount of bytes available from input for encoding.
+ */
+ void decode(byte[] in, int inPos, int inAvail) {
+ if (eof) {
+ return;
+ }
+ if (inAvail < 0) {
+ eof = true;
+ }
+ for (int i = 0; i < inAvail; i++) {
+ if (buf == null || buf.length - pos < decodeSize) {
+ resizeBuf();
+ }
+ byte b = in[inPos++];
+ if (b == PAD) {
+ x = x << 6;
+ switch (modulus) {
+ case 2:
+ x = x << 6;
+ buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+ break;
+ case 3:
+ buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+ buf[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+ break;
+ }
+ // WE'RE DONE!!!!
+ eof = true;
+ return;
+ } else {
+ if (b >= 0 && b < base64ToInt.length) {
+ int result = base64ToInt[b];
+ if (result >= 0) {
+ modulus = (++modulus) % 4;
+ x = (x << 6) + result;
+ if (modulus == 0) {
+ buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+ buf[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+ buf[pos++] = (byte) (x & MASK_8BITS);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns whether or not the octet is in the base 64 alphabet.
+ *
+ * @param octet
+ * The value to test
+ * @return true if the value is defined in the the base 64 alphabet, false otherwise.
+ */
+ public static boolean isBase64(byte octet) {
+ return octet == PAD || (octet >= 0 && octet < base64ToInt.length && base64ToInt[octet] != -1);
+ }
+
+ /**
+ * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet.
+ * Currently the method treats whitespace as valid.
+ *
+ * @param arrayOctet
+ * byte array to test
+ * @return true if all bytes are valid characters in the Base64 alphabet or if the byte array is
+ * empty; false, otherwise
+ */
+ public static boolean isArrayByteBase64(byte[] arrayOctet) {
+ for (int i = 0; i < arrayOctet.length; i++) {
+ if (!isBase64(arrayOctet[i]) && !isWhiteSpace(arrayOctet[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /*
+ * Tests a given byte array to see if it contains only valid characters within the Base64 alphabet.
+ *
+ * @param arrayOctet
+ * byte array to test
+ * @return true if any byte is a valid character in the Base64 alphabet; false herwise
+ */
+ private static boolean containsBase64Byte(byte[] arrayOctet) {
+ for (int i = 0; i < arrayOctet.length; i++) {
+ if (isBase64(arrayOctet[i])) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Encodes binary data using the base64 algorithm but does not chunk the output.
+ *
+ * @param binaryData
+ * binary data to encode
+ * @return Base64 characters
+ */
+ public static byte[] encodeBase64(byte[] binaryData) {
+ return encodeBase64(binaryData, false);
+ }
+
+ /**
+ * Encodes binary data using the base64 algorithm and chunks the encoded output into 76 character blocks
+ *
+ * @param binaryData
+ * binary data to encode
+ * @return Base64 characters chunked in 76 character blocks
+ */
+ public static byte[] encodeBase64Chunked(byte[] binaryData) {
+ return encodeBase64(binaryData, true);
+ }
+
+ /**
+ * Decodes an Object using the base64 algorithm. This method is provided in order to satisfy the requirements of the
+ * Decoder interface, and will throw a DecoderException if the supplied object is not of type byte[].
+ *
+ * @param pObject
+ * Object to decode
+ * @return An object (of type byte[]) containing the binary data which corresponds to the byte[] supplied.
+ * @throws DecoderException
+ * if the parameter supplied is not of type byte[]
+ */
+ public Object decode(Object pObject) throws DecoderException {
+ if (!(pObject instanceof byte[])) {
+ throw new DecoderException("Parameter supplied to Base64 decode is not a byte[]");
+ }
+ return decode((byte[]) pObject);
+ }
+
+ /**
+ * Decodes a byte[] containing containing characters in the Base64 alphabet.
+ *
+ * @param pArray
+ * A byte array containing Base64 character data
+ * @return a byte array containing binary data
+ */
+ public byte[] decode(byte[] pArray) {
+ return decodeBase64(pArray);
+ }
+
+ /**
+ * Encodes binary data using the base64 algorithm, optionally chunking the output into 76 character blocks.
+ *
+ * @param binaryData
+ * Array containing binary data to encode.
+ * @param isChunked
+ * if true this encoder will chunk the base64 output into 76 character blocks
+ * @return Base64-encoded data.
+ * @throws IllegalArgumentException
+ * Thrown when the input array needs an output array bigger than {@link Integer#MAX_VALUE}
+ */
+ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
+ if (binaryData == null || binaryData.length == 0) {
+ return binaryData;
+ }
+ Base64 b64 = isChunked ? new Base64() : new Base64(0);
+
+ long len = (binaryData.length * 4) / 3;
+ long mod = len % 4;
+ if (mod != 0) {
+ len += 4 - mod;
+ }
+ if (isChunked) {
+ len += (1 + (len / CHUNK_SIZE)) * CHUNK_SEPARATOR.length;
+ }
+
+ if (len > Integer.MAX_VALUE) {
+ throw new IllegalArgumentException(
+ "Input array too big, output array would be bigger than Integer.MAX_VALUE=" + Integer.MAX_VALUE);
+ }
+ byte[] buf = new byte[(int) len];
+ b64.setInitialBuffer(buf, 0, buf.length);
+ b64.encode(binaryData, 0, binaryData.length);
+ b64.encode(binaryData, 0, -1); // Notify encoder of EOF.
+
+ // Encoder might have resized, even though it was unnecessary.
+ if (b64.buf != buf) {
+ b64.readResults(buf, 0, buf.length);
+ }
+ return buf;
+ }
+
+ /**
+ * Decodes Base64 data into octets
+ *
+ * @param base64Data Byte array containing Base64 data
+ * @return Array containing decoded data.
+ */
+ public static byte[] decodeBase64(byte[] base64Data) {
+ if (base64Data == null || base64Data.length == 0) {
+ return base64Data;
+ }
+ Base64 b64 = new Base64();
+
+ long len = (base64Data.length * 3) / 4;
+ byte[] buf = new byte[(int) len];
+ b64.setInitialBuffer(buf, 0, buf.length);
+ b64.decode(base64Data, 0, base64Data.length);
+ b64.decode(base64Data, 0, -1); // Notify decoder of EOF.
+
+ // We have no idea what the line-length was, so we
+ // cannot know how much of our array wasn't used.
+ byte[] result = new byte[b64.pos];
+ b64.readResults(result, 0, result.length);
+ return result;
+ }
+
+ /**
+ * Discards any whitespace from a base-64 encoded block.
+ *
+ * @param data
+ * The base-64 encoded data to discard the whitespace from.
+ * @return The data, less whitespace (see RFC 2045).
+ * @deprecated This method is no longer needed
+ */
+ static byte[] discardWhitespace(byte[] data) {
+ byte groomedData[] = new byte[data.length];
+ int bytesCopied = 0;
+
+ for (int i = 0; i < data.length; i++) {
+ switch (data[i]) {
+ case ' ' :
+ case '\n' :
+ case '\r' :
+ case '\t' :
+ break;
+ default :
+ groomedData[bytesCopied++] = data[i];
+ }
+ }
+
+ byte packedData[] = new byte[bytesCopied];
+
+ System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
+
+ return packedData;
+ }
+
+
+ /**
+ * Check if a byte value is whitespace or not.
+ *
+ * @param byteToCheck the byte to check
+ * @return true if byte is whitespace, false otherwise
+ */
+ private static boolean isWhiteSpace(byte byteToCheck){
+ switch (byteToCheck) {
+ case ' ' :
+ case '\n' :
+ case '\r' :
+ case '\t' :
+ return true;
+ default :
+ return false;
+ }
+ }
+
+ /**
+ * Discards any characters outside of the base64 alphabet, per the requirements on page 25 of RFC 2045 - "Any
+ * characters outside of the base64 alphabet are to be ignored in base64 encoded data."
+ *
+ * @param data
+ * The base-64 encoded data to groom
+ * @return The data, less non-base64 characters (see RFC 2045).
+ */
+ static byte[] discardNonBase64(byte[] data) {
+ byte groomedData[] = new byte[data.length];
+ int bytesCopied = 0;
+
+ for (int i = 0; i < data.length; i++) {
+ if (isBase64(data[i])) {
+ groomedData[bytesCopied++] = data[i];
+ }
+ }
+
+ byte packedData[] = new byte[bytesCopied];
+
+ System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
+
+ return packedData;
+ }
+
+ // Implementation of the Encoder Interface
+
+ /**
+ * Encodes an Object using the base64 algorithm. This method is provided in order to satisfy the requirements of the
+ * Encoder interface, and will throw an EncoderException if the supplied object is not of type byte[].
+ *
+ * @param pObject
+ * Object to encode
+ * @return An object (of type byte[]) containing the base64 encoded data which corresponds to the byte[] supplied.
+ * @throws EncoderException
+ * if the parameter supplied is not of type byte[]
+ */
+ public Object encode(Object pObject) throws EncoderException {
+ if (!(pObject instanceof byte[])) {
+ throw new EncoderException("Parameter supplied to Base64 encode is not a byte[]");
+ }
+ return encode((byte[]) pObject);
+ }
+
+ /**
+ * Encodes a byte[] containing binary data, into a byte[] containing characters in the Base64 alphabet.
+ *
+ * @param pArray
+ * a byte array containing binary data
+ * @return A byte array containing only Base64 character data
+ */
+ public byte[] encode(byte[] pArray) {
+ return encodeBase64(pArray, false);
+ }
+
+ // Implementation of integer encoding used for crypto
+ /**
+ * Decode a byte64-encoded integer according to crypto
+ * standards such as W3C's XML-Signature
+ *
+ * @param pArray a byte array containing base64 character data
+ * @return A BigInteger
+ */
+ public static BigInteger decodeInteger(byte[] pArray) {
+ return new BigInteger(1, decodeBase64(pArray));
+ }
+
+ /**
+ * Encode to a byte64-encoded integer according to crypto
+ * standards such as W3C's XML-Signature
+ *
+ * @param bigInt a BigInteger
+ * @return A byte array containing base64 character data
+ * @throws NullPointerException if null is passed in
+ */
+ public static byte[] encodeInteger(BigInteger bigInt) {
+ if(bigInt == null) {
+ throw new NullPointerException("encodeInteger called with null parameter");
+ }
+
+ return encodeBase64(toIntegerBytes(bigInt), false);
+ }
+
+ /**
+ * Returns a byte-array representation of a BigInteger
+ * without sign bit.
+ *
+ * @param bigInt BigInteger to be converted
+ * @return a byte array representation of the BigInteger parameter
+ */
+ static byte[] toIntegerBytes(BigInteger bigInt) {
+ int bitlen = bigInt.bitLength();
+ // round bitlen
+ bitlen = ((bitlen + 7) >> 3) << 3;
+ byte[] bigBytes = bigInt.toByteArray();
+
+ if(((bigInt.bitLength() % 8) != 0) &&
+ (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
+ return bigBytes;
+ }
+
+ // set up params for copying everything but sign bit
+ int startSrc = 0;
+ int len = bigBytes.length;
+
+ // if bigInt is exactly byte-aligned, just skip signbit in copy
+ if((bigInt.bitLength() % 8) == 0) {
+ startSrc = 1;
+ len--;
+ }
+
+ int startDst = bitlen / 8 - len; // to pad w/ nulls as per spec
+ byte[] resizedBytes = new byte[bitlen / 8];
+
+ System.arraycopy(bigBytes, startSrc, resizedBytes, startDst, len);
+
+ return resizedBytes;
+ }
+}
diff --git a/src/com/fsck/k9/codec/binary/Base64OutputStream.java b/src/com/fsck/k9/codec/binary/Base64OutputStream.java
new file mode 100644
index 0000000000000000000000000000000000000000..f812cd368a6441b5b387ae9f53b11045c83a4d1a
--- /dev/null
+++ b/src/com/fsck/k9/codec/binary/Base64OutputStream.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.fsck.k9.codec.binary;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Provides Base64 encoding and decoding in a streaming fashion (unlimited size).
+ * When encoding the default lineLength is 76 characters and the default
+ * lineEnding is CRLF, but these can be overridden by using the appropriate
+ * constructor.
+ *
+ * The default behaviour of the Base64OutputStream is to ENCODE, whereas the
+ * default behaviour of the Base64InputStream is to DECODE. But this behaviour
+ * can be overridden by using a different constructor.
+ *
+ * This class implements section 6.8. Base64 Content-Transfer-Encoding from RFC 2045 Multipurpose
+ * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies by Freed and Borenstein.
+ *
+ *
+ * @author Apache Software Foundation
+ * @version $Id $
+ * @see RFC 2045
+ * @since 1.0-dev
+ */
+public class Base64OutputStream extends FilterOutputStream {
+ private final boolean doEncode;
+ private final Base64 base64;
+ private final byte[] singleByte = new byte[1];
+
+ /**
+ * Creates a Base64OutputStream such that all data written is Base64-encoded
+ * to the original provided OutputStream.
+ *
+ * @param out OutputStream to wrap.
+ */
+ public Base64OutputStream(OutputStream out) {
+ this(out, true);
+ }
+
+ /**
+ * Creates a Base64OutputStream such that all data written is either
+ * Base64-encoded or Base64-decoded to the original provided OutputStream.
+ *
+ * @param out OutputStream to wrap.
+ * @param doEncode true if we should encode all data written to us,
+ * false if we should decode.
+ */
+ public Base64OutputStream(OutputStream out, boolean doEncode) {
+ super(out);
+ this.doEncode = doEncode;
+ this.base64 = new Base64();
+ }
+
+ /**
+ * Creates a Base64OutputStream such that all data written is either
+ * Base64-encoded or Base64-decoded to the original provided OutputStream.
+ *
+ * @param out OutputStream to wrap.
+ * @param doEncode true if we should encode all data written to us,
+ * false if we should decode.
+ * @param lineLength If doEncode is true, each line of encoded
+ * data will contain lineLength characters.
+ * If lineLength <=0, the encoded data is not divided into lines.
+ * If doEncode is false, lineLength is ignored.
+ * @param lineSeparator If doEncode is true, each line of encoded
+ * data will be terminated with this byte sequence (e.g. \r\n).
+ * If lineLength <= 0, the lineSeparator is not used.
+ * If doEncode is false lineSeparator is ignored.
+ */
+ public Base64OutputStream(OutputStream out, boolean doEncode, int lineLength, byte[] lineSeparator) {
+ super(out);
+ this.doEncode = doEncode;
+ this.base64 = new Base64(lineLength, lineSeparator);
+ }
+
+ /**
+ * Writes the specified byte to this output stream.
+ */
+ public void write(int i) throws IOException {
+ singleByte[0] = (byte) i;
+ write(singleByte, 0, 1);
+ }
+
+ /**
+ * Writes len bytes from the specified
+ * b array starting at offset to
+ * this output stream.
+ *
+ * @param b source byte array
+ * @param offset where to start reading the bytes
+ * @param len maximum number of bytes to write
+ *
+ * @throws IOException if an I/O error occurs.
+ * @throws NullPointerException if the byte array parameter is null
+ * @throws IndexOutOfBoundsException if offset, len or buffer size are invalid
+ */
+ public void write(byte b[], int offset, int len) throws IOException {
+ if (b == null) {
+ throw new NullPointerException();
+ } else if (offset < 0 || len < 0 || offset + len < 0) {
+ throw new IndexOutOfBoundsException();
+ } else if (offset > b.length || offset + len > b.length) {
+ throw new IndexOutOfBoundsException();
+ } else if (len > 0) {
+ if (doEncode) {
+ base64.encode(b, offset, len);
+ } else {
+ base64.decode(b, offset, len);
+ }
+ flush(false);
+ }
+ }
+
+ /**
+ * Flushes this output stream and forces any buffered output bytes
+ * to be written out to the stream. If propogate is true, the wrapped
+ * stream will also be flushed.
+ *
+ * @param propogate boolean flag to indicate whether the wrapped
+ * OutputStream should also be flushed.
+ * @throws IOException if an I/O error occurs.
+ */
+ private void flush(boolean propogate) throws IOException {
+ int avail = base64.avail();
+ if (avail > 0) {
+ byte[] buf = new byte[avail];
+ int c = base64.readResults(buf, 0, avail);
+ if (c > 0) {
+ out.write(buf, 0, c);
+ }
+ }
+ if (propogate) {
+ out.flush();
+ }
+ }
+
+ /**
+ * Flushes this output stream and forces any buffered output bytes
+ * to be written out to the stream.
+ *
+ * @throws IOException if an I/O error occurs.
+ */
+ public void flush() throws IOException {
+ flush(true);
+ }
+
+ /**
+ * Closes this output stream, flushing any remaining bytes that must be encoded. The
+ * underlying stream is flushed but not closed.
+ */
+ public void close() throws IOException {
+ // Notify encoder of EOF (-1).
+ if (doEncode) {
+ base64.encode(singleByte, 0, -1);
+ } else {
+ base64.decode(singleByte, 0, -1);
+ }
+ flush();
+ }
+
+}
diff --git a/src/com/fsck/k9/k9.java b/src/com/fsck/k9/k9.java
new file mode 100644
index 0000000000000000000000000000000000000000..be80538509a548d22be992a9f82847ff70b98851
--- /dev/null
+++ b/src/com/fsck/k9/k9.java
@@ -0,0 +1,177 @@
+
+package com.fsck.k9;
+
+import java.io.File;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.util.Config;
+import android.util.Log;
+
+import com.fsck.k9.activity.MessageCompose;
+import com.fsck.k9.mail.internet.BinaryTempFileBody;
+import com.fsck.k9.mail.internet.MimeMessage;
+import com.fsck.k9.service.BootReceiver;
+import com.fsck.k9.service.MailService;
+
+public class k9 extends Application {
+ public static Application app = null;
+ public static File tempDirectory;
+ public static final String LOG_TAG = "k9";
+
+ /**
+ * If this is enabled there will be additional logging information sent to
+ * Log.d, including protocol dumps.
+ */
+ public static boolean DEBUG = false;
+
+ /**
+ * If this is enabled than logging that normally hides sensitive information
+ * like passwords will show that information.
+ */
+ public static boolean DEBUG_SENSITIVE = false;
+
+
+ /**
+ * The MIME type(s) of attachments we're willing to send. At the moment it is not possible
+ * to open a chooser with a list of filter types, so the chooser is only opened with the first
+ * item in the list. The entire list will be used to filter down attachments that are added
+ * with Intent.ACTION_SEND.
+ */
+ public static final String[] ACCEPTABLE_ATTACHMENT_SEND_TYPES = new String[] {
+ "*/*",
+ };
+
+ /**
+ * The MIME type(s) of attachments we're willing to view.
+ */
+ public static final String[] ACCEPTABLE_ATTACHMENT_VIEW_TYPES = new String[] {
+ "image/*",
+ "audio/*",
+ "text/*",
+ };
+
+ /**
+ * The MIME type(s) of attachments we're not willing to view.
+ */
+ public static final String[] UNACCEPTABLE_ATTACHMENT_VIEW_TYPES = new String[] {
+ "image/gif",
+ };
+
+ /**
+ * The MIME type(s) of attachments we're willing to download to SD.
+ */
+ public static final String[] ACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES = new String[] {
+ "*/*",
+ };
+
+ /**
+ * The MIME type(s) of attachments we're not willing to download to SD.
+ */
+ public static final String[] UNACCEPTABLE_ATTACHMENT_DOWNLOAD_TYPES = new String[] {
+ "image/gif",
+ };
+
+ /**
+ * The special name "INBOX" is used throughout the application to mean "Whatever folder
+ * the server refers to as the user's Inbox. Placed here to ease use.
+ */
+ public static final String INBOX = "INBOX";
+
+ /**
+ * Specifies how many messages will be shown in a folder by default. This number is set
+ * on each new folder and can be incremented with "Load more messages..." by the
+ * VISIBLE_LIMIT_INCREMENT
+ */
+ public static int DEFAULT_VISIBLE_LIMIT = 25;
+
+ /**
+ * Number of additioanl messages to load when a user selectes "Load more messages..."
+ */
+ public static int VISIBLE_LIMIT_INCREMENT = 25;
+
+ /**
+ * The maximum size of an attachment we're willing to download (either View or Save)
+ * Attachments that are base64 encoded (most) will be about 1.375x their actual size
+ * so we should probably factor that in. A 5MB attachment will generally be around
+ * 6.8MB downloaded but only 5MB saved.
+ */
+ public static final int MAX_ATTACHMENT_DOWNLOAD_SIZE = (5 * 1024 * 1024);
+
+ /**
+ * Called throughout the application when the number of accounts has changed. This method
+ * enables or disables the Compose activity, the boot receiver and the service based on
+ * whether any accounts are configured.
+ */
+ public static void setServicesEnabled(Context context) {
+ setServicesEnabled(context, Preferences.getPreferences(context).getAccounts().length > 0);
+ }
+
+ public static void setServicesEnabled(Context context, boolean enabled) {
+ PackageManager pm = context.getPackageManager();
+ if (!enabled && pm.getComponentEnabledSetting(new ComponentName(context, MailService.class)) ==
+ PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
+ /*
+ * If no accounts now exist but the service is still enabled we're about to disable it
+ * so we'll reschedule to kill off any existing alarms.
+ */
+ MailService.actionReschedule(context);
+ }
+ pm.setComponentEnabledSetting(
+ new ComponentName(context, MessageCompose.class),
+ enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
+ PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+ PackageManager.DONT_KILL_APP);
+ pm.setComponentEnabledSetting(
+ new ComponentName(context, BootReceiver.class),
+ enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
+ PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+ PackageManager.DONT_KILL_APP);
+ pm.setComponentEnabledSetting(
+ new ComponentName(context, MailService.class),
+ enabled ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED :
+ PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+ PackageManager.DONT_KILL_APP);
+ if (enabled && pm.getComponentEnabledSetting(new ComponentName(context, MailService.class)) ==
+ PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
+ /*
+ * And now if accounts do exist then we've just enabled the service and we want to
+ * schedule alarms for the new accounts.
+ */
+ MailService.actionReschedule(context);
+ }
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ app = this;
+ Preferences prefs = Preferences.getPreferences(this);
+ DEBUG = prefs.geteEnableDebugLogging();
+ DEBUG_SENSITIVE = prefs.getEnableSensitiveLogging();
+ MessagingController.getInstance(this).resetVisibleLimits(prefs.getAccounts());
+
+ /*
+ * We have to give MimeMessage a temp directory because File.createTempFile(String, String)
+ * doesn't work in Android and MimeMessage does not have access to a Context.
+ */
+ BinaryTempFileBody.setTempDirectory(getCacheDir());
+
+ /*
+ * Enable background sync of messages
+ */
+
+ setServicesEnabled(this);
+
+ }
+}
+
+
+
+
+
+
+
+
diff --git a/src/com/fsck/k9/mail/Address.java b/src/com/fsck/k9/mail/Address.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b64631d8c114a57eaafe538f3d28d5fd27fe5a5
--- /dev/null
+++ b/src/com/fsck/k9/mail/Address.java
@@ -0,0 +1,215 @@
+
+package com.fsck.k9.mail;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.james.mime4j.field.address.AddressList;
+import org.apache.james.mime4j.field.address.Mailbox;
+import org.apache.james.mime4j.field.address.MailboxList;
+import org.apache.james.mime4j.field.address.NamedMailbox;
+import org.apache.james.mime4j.field.address.parser.ParseException;
+
+import android.util.Config;
+import android.util.Log;
+
+import com.fsck.k9.k9;
+import com.fsck.k9.Utility;
+import com.fsck.k9.mail.internet.MimeUtility;
+
+public class Address {
+ String mAddress;
+
+ String mPersonal;
+
+ public Address(String address, String personal) {
+ this.mAddress = address;
+ this.mPersonal = personal;
+ }
+
+ public Address(String address) {
+ this.mAddress = address;
+ }
+
+ public String getAddress() {
+ return mAddress;
+ }
+
+ public void setAddress(String address) {
+ this.mAddress = address;
+ }
+
+ public String getPersonal() {
+ return mPersonal;
+ }
+
+ public void setPersonal(String personal) {
+ this.mPersonal = personal;
+ }
+
+ /**
+ * Parse a comma separated list of addresses in RFC-822 format and return an
+ * array of Address objects.
+ *
+ * @param addressList
+ * @return An array of 0 or more Addresses.
+ */
+ public static Address[] parse(String addressList) {
+ ArrayList addresses = new ArrayList();
+ if (addressList == null) {
+ return new Address[] {};
+ }
+ try {
+ MailboxList parsedList = AddressList.parse(addressList).flatten();
+ for (int i = 0, count = parsedList.size(); i < count; i++) {
+ org.apache.james.mime4j.field.address.Address address = parsedList.get(i);
+ if (address instanceof NamedMailbox) {
+ NamedMailbox namedMailbox = (NamedMailbox)address;
+ addresses.add(new Address(namedMailbox.getLocalPart() + "@"
+ + namedMailbox.getDomain(), namedMailbox.getName()));
+ } else if (address instanceof Mailbox) {
+ Mailbox mailbox = (Mailbox)address;
+ addresses.add(new Address(mailbox.getLocalPart() + "@" + mailbox.getDomain()));
+ } else {
+ Log.e(k9.LOG_TAG, "Unknown address type from Mime4J: "
+ + address.getClass().toString());
+ }
+
+ }
+ } catch (ParseException pe) {
+ }
+ return addresses.toArray(new Address[] {});
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (o instanceof Address) {
+ return getAddress().equals(((Address) o).getAddress());
+ }
+ return super.equals(o);
+ }
+
+ public String toString() {
+ if (mPersonal != null) {
+ if (mPersonal.matches(".*[\\(\\)<>@,;:\\\\\".\\[\\]].*")) {
+ return Utility.quoteString(mPersonal) + " <" + mAddress + ">";
+ } else {
+ return mPersonal + " <" + mAddress + ">";
+ }
+ } else {
+ return mAddress;
+ }
+ }
+
+ public static String toString(Address[] addresses) {
+ if (addresses == null) {
+ return null;
+ }
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < addresses.length; i++) {
+ sb.append(addresses[i].toString());
+ if (i < addresses.length - 1) {
+ sb.append(',');
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Returns either the personal portion of the Address or the address portion if the personal
+ * is not available.
+ * @return
+ */
+ public String toFriendly() {
+ if (mPersonal != null && mPersonal.length() > 0) {
+ return mPersonal;
+ }
+ else {
+ return mAddress;
+ }
+ }
+
+ public static String toFriendly(Address[] addresses) {
+ if (addresses == null) {
+ return null;
+ }
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; i < addresses.length; i++) {
+ sb.append(addresses[i].toFriendly());
+ if (i < addresses.length - 1) {
+ sb.append(',');
+ }
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Unpacks an address list previously packed with packAddressList()
+ * @param list
+ * @return
+ */
+ public static Address[] unpack(String addressList) {
+ if (addressList == null) {
+ return new Address[] { };
+ }
+ ArrayList addresses = new ArrayList();
+ int length = addressList.length();
+ int pairStartIndex = 0;
+ int pairEndIndex = 0;
+ int addressEndIndex = 0;
+ while (pairStartIndex < length) {
+ pairEndIndex = addressList.indexOf(',', pairStartIndex);
+ if (pairEndIndex == -1) {
+ pairEndIndex = length;
+ }
+ addressEndIndex = addressList.indexOf(';', pairStartIndex);
+ String address = null;
+ String personal = null;
+ if (addressEndIndex == -1 || addressEndIndex > pairEndIndex) {
+ address = Utility.fastUrlDecode(addressList.substring(pairStartIndex, pairEndIndex));
+ }
+ else {
+ address = Utility.fastUrlDecode(addressList.substring(pairStartIndex, addressEndIndex));
+ personal = Utility.fastUrlDecode(addressList.substring(addressEndIndex + 1, pairEndIndex));
+ }
+ addresses.add(new Address(address, personal));
+ pairStartIndex = pairEndIndex + 1;
+ }
+ return addresses.toArray(new Address[] { });
+ }
+
+ /**
+ * Packs an address list into a String that is very quick to read
+ * and parse. Packed lists can be unpacked with unpackAddressList()
+ * The packed list is a comma seperated list of:
+ * URLENCODE(address)[;URLENCODE(personal)]
+ * @param list
+ * @return
+ */
+ public static String pack(Address[] addresses) {
+ if (addresses == null) {
+ return null;
+ }
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0, count = addresses.length; i < count; i++) {
+ Address address = addresses[i];
+ try {
+ sb.append(URLEncoder.encode(address.getAddress(), "UTF-8"));
+ if (address.getPersonal() != null) {
+ sb.append(';');
+ sb.append(URLEncoder.encode(address.getPersonal(), "UTF-8"));
+ }
+ if (i < count - 1) {
+ sb.append(',');
+ }
+ }
+ catch (UnsupportedEncodingException uee) {
+ return null;
+ }
+ }
+ return sb.toString();
+ }
+}
diff --git a/src/com/fsck/k9/mail/AuthenticationFailedException.java b/src/com/fsck/k9/mail/AuthenticationFailedException.java
new file mode 100644
index 0000000000000000000000000000000000000000..006063a145d55f86d7d0415f5de30f8d2d09bca9
--- /dev/null
+++ b/src/com/fsck/k9/mail/AuthenticationFailedException.java
@@ -0,0 +1,14 @@
+
+package com.fsck.k9.mail;
+
+public class AuthenticationFailedException extends MessagingException {
+ public static final long serialVersionUID = -1;
+
+ public AuthenticationFailedException(String message) {
+ super(message);
+ }
+
+ public AuthenticationFailedException(String message, Throwable throwable) {
+ super(message, throwable);
+ }
+}
diff --git a/src/com/fsck/k9/mail/Body.java b/src/com/fsck/k9/mail/Body.java
new file mode 100644
index 0000000000000000000000000000000000000000..7deb2a1eb2f2a175dd7741b686b720f0e258b408
--- /dev/null
+++ b/src/com/fsck/k9/mail/Body.java
@@ -0,0 +1,11 @@
+
+package com.fsck.k9.mail;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public interface Body {
+ public InputStream getInputStream() throws MessagingException;
+ public void writeTo(OutputStream out) throws IOException, MessagingException;
+}
diff --git a/src/com/fsck/k9/mail/BodyPart.java b/src/com/fsck/k9/mail/BodyPart.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5f9375e6e5383e4b026b8cf957fb6136c3c1d30
--- /dev/null
+++ b/src/com/fsck/k9/mail/BodyPart.java
@@ -0,0 +1,10 @@
+
+package com.fsck.k9.mail;
+
+public abstract class BodyPart implements Part {
+ protected Multipart mParent;
+
+ public Multipart getParent() {
+ return mParent;
+ }
+}
diff --git a/src/com/fsck/k9/mail/CertificateValidationException.java b/src/com/fsck/k9/mail/CertificateValidationException.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed35cf8ac1444579032bfd714ca2c967bb2a5656
--- /dev/null
+++ b/src/com/fsck/k9/mail/CertificateValidationException.java
@@ -0,0 +1,14 @@
+
+package com.fsck.k9.mail;
+
+public class CertificateValidationException extends MessagingException {
+ public static final long serialVersionUID = -1;
+
+ public CertificateValidationException(String message) {
+ super(message);
+ }
+
+ public CertificateValidationException(String message, Throwable throwable) {
+ super(message, throwable);
+ }
+}
\ No newline at end of file
diff --git a/src/com/fsck/k9/mail/FetchProfile.java b/src/com/fsck/k9/mail/FetchProfile.java
new file mode 100644
index 0000000000000000000000000000000000000000..95bc447122d34c1badd5110abd78cd465418b745
--- /dev/null
+++ b/src/com/fsck/k9/mail/FetchProfile.java
@@ -0,0 +1,57 @@
+
+package com.fsck.k9.mail;
+
+import java.util.ArrayList;
+
+/**
+ *
+ * A FetchProfile is a list of items that should be downloaded in bulk for a set of messages.
+ * FetchProfile can contain the following objects:
+ * FetchProfile.Item: Described below.
+ * Message: Indicates that the body of the entire message should be fetched.
+ * Synonymous with FetchProfile.Item.BODY.
+ * Part: Indicates that the given Part should be fetched. The provider
+ * is expected have previously created the given BodyPart and stored
+ * any information it needs to download the content.
+ *
+ */
+public class FetchProfile extends ArrayList {
+ /**
+ * Default items available for pre-fetching. It should be expected that any
+ * item fetched by using these items could potentially include all of the
+ * previous items.
+ */
+ public enum Item {
+ /**
+ * Download the flags of the message.
+ */
+ FLAGS,
+
+ /**
+ * Download the envelope of the message. This should include at minimum
+ * the size and the following headers: date, subject, from, content-type, to, cc
+ */
+ ENVELOPE,
+
+ /**
+ * Download the structure of the message. This maps directly to IMAP's BODYSTRUCTURE
+ * and may map to other providers.
+ * The provider should, if possible, fill in a properly formatted MIME structure in
+ * the message without actually downloading any message data. If the provider is not
+ * capable of this operation it should specifically set the body of the message to null
+ * so that upper levels can detect that a full body download is needed.
+ */
+ STRUCTURE,
+
+ /**
+ * A sane portion of the entire message, cut off at a provider determined limit.
+ * This should generaly be around 50kB.
+ */
+ BODY_SANE,
+
+ /**
+ * The entire message.
+ */
+ BODY,
+ }
+}
diff --git a/src/com/fsck/k9/mail/Flag.java b/src/com/fsck/k9/mail/Flag.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec898a700ad414c7b48ad5f0a3632b7f934e63d3
--- /dev/null
+++ b/src/com/fsck/k9/mail/Flag.java
@@ -0,0 +1,48 @@
+
+package com.fsck.k9.mail;
+
+/**
+ * Flags that can be applied to Messages.
+ */
+public enum Flag {
+ DELETED,
+ SEEN,
+ ANSWERED,
+ FLAGGED,
+ DRAFT,
+ RECENT,
+
+ /*
+ * The following flags are for internal library use only.
+ * TODO Eventually we should creates a Flags class that extends ArrayList that allows
+ * these flags and Strings to represent user defined flags. At that point the below
+ * flags should become user defined flags.
+ */
+ /**
+ * Delete and remove from the LocalStore immediately.
+ */
+ X_DESTROYED,
+
+ /**
+ * Sending of an unsent message failed. It will be retried. Used to show status.
+ */
+ X_SEND_FAILED,
+
+ /**
+ * Sending of an unsent message is in progress.
+ */
+ X_SEND_IN_PROGRESS,
+
+ /**
+ * Indicates that a message is fully downloaded from the server and can be viewed normally.
+ * This does not include attachments, which are never downloaded fully.
+ */
+ X_DOWNLOADED_FULL,
+
+ /**
+ * Indicates that a message is partially downloaded from the server and can be viewed but
+ * more content is available on the server.
+ * This does not include attachments, which are never downloaded fully.
+ */
+ X_DOWNLOADED_PARTIAL,
+}
diff --git a/src/com/fsck/k9/mail/Folder.java b/src/com/fsck/k9/mail/Folder.java
new file mode 100644
index 0000000000000000000000000000000000000000..037f1b36f56cd6fd3b9552aca1b277ff4a4f6f85
--- /dev/null
+++ b/src/com/fsck/k9/mail/Folder.java
@@ -0,0 +1,107 @@
+package com.fsck.k9.mail;
+
+
+public abstract class Folder {
+ public enum OpenMode {
+ READ_WRITE, READ_ONLY,
+ }
+
+ public enum FolderType {
+ HOLDS_FOLDERS, HOLDS_MESSAGES,
+ }
+
+ /**
+ * Forces an open of the MailProvider. If the provider is already open this
+ * function returns without doing anything.
+ *
+ * @param mode READ_ONLY or READ_WRITE
+ */
+ public abstract void open(OpenMode mode) throws MessagingException;
+
+ /**
+ * Forces a close of the MailProvider. Any further access will attempt to
+ * reopen the MailProvider.
+ *
+ * @param expunge If true all deleted messages will be expunged.
+ */
+ public abstract void close(boolean expunge) throws MessagingException;
+
+ /**
+ * @return True if further commands are not expected to have to open the
+ * connection.
+ */
+ public abstract boolean isOpen();
+
+ /**
+ * Get the mode the folder was opened with. This may be different than the mode the open
+ * was requested with.
+ * @return
+ */
+ public abstract OpenMode getMode() throws MessagingException;
+
+ public abstract boolean create(FolderType type) throws MessagingException;
+
+ /**
+ * Create a new folder with a specified display limit. Not abstract to allow
+ * remote folders to not override or worry about this call if they don't care to.
+ */
+ public boolean create(FolderType type, int displayLimit) throws MessagingException {
+ return create(type);
+ }
+
+ public abstract boolean exists() throws MessagingException;
+
+ /**
+ * @return A count of the messages in the selected folder.
+ */
+ public abstract int getMessageCount() throws MessagingException;
+
+ public abstract int getUnreadMessageCount() throws MessagingException;
+
+ public abstract Message getMessage(String uid) throws MessagingException;
+
+ public abstract Message[] getMessages(int start, int end, MessageRetrievalListener listener)
+ throws MessagingException;
+
+ /**
+ * Fetches the given list of messages. The specified listener is notified as
+ * each fetch completes. Messages are downloaded as (as) lightweight (as
+ * possible) objects to be filled in with later requests. In most cases this
+ * means that only the UID is downloaded.
+ *
+ * @param uids
+ * @param listener
+ */
+ public abstract Message[] getMessages(MessageRetrievalListener listener)
+ throws MessagingException;
+
+ public abstract Message[] getMessages(String[] uids, MessageRetrievalListener listener)
+ throws MessagingException;
+
+ public abstract void appendMessages(Message[] messages) throws MessagingException;
+
+ public abstract void copyMessages(Message[] msgs, Folder folder) throws MessagingException;
+
+ public abstract void setFlags(Message[] messages, Flag[] flags, boolean value)
+ throws MessagingException;
+
+ public abstract Message[] expunge() throws MessagingException;
+
+ public abstract void fetch(Message[] messages, FetchProfile fp,
+ MessageRetrievalListener listener) throws MessagingException;
+
+ public abstract void delete(boolean recurse) throws MessagingException;
+
+ public abstract String getName();
+
+ public abstract Flag[] getPermanentFlags() throws MessagingException;
+
+ public boolean supportsFetchingFlags() {
+ return true;
+ }//isFlagSupported
+
+ @Override
+ public String toString() {
+ return getName();
+ }
+}
diff --git a/src/com/fsck/k9/mail/Message.java b/src/com/fsck/k9/mail/Message.java
new file mode 100644
index 0000000000000000000000000000000000000000..58f036304f72e5551af86d79369d011897485071
--- /dev/null
+++ b/src/com/fsck/k9/mail/Message.java
@@ -0,0 +1,118 @@
+
+package com.fsck.k9.mail;
+
+import java.util.Date;
+import java.util.HashSet;
+
+public abstract class Message implements Part, Body {
+ public enum RecipientType {
+ TO, CC, BCC,
+ }
+
+ protected String mUid;
+
+ protected HashSet mFlags = new HashSet();
+
+ protected Date mInternalDate;
+
+ protected Folder mFolder;
+
+ public String getUid() {
+ return mUid;
+ }
+
+ public void setUid(String uid) {
+ this.mUid = uid;
+ }
+
+ public Folder getFolder() {
+ return mFolder;
+ }
+
+ public abstract String getSubject() throws MessagingException;
+
+ public abstract void setSubject(String subject) throws MessagingException;
+
+ public Date getInternalDate() {
+ return mInternalDate;
+ }
+
+ public void setInternalDate(Date internalDate) {
+ this.mInternalDate = internalDate;
+ }
+
+ public abstract Date getReceivedDate() throws MessagingException;
+
+ public abstract Date getSentDate() throws MessagingException;
+
+ public abstract void setSentDate(Date sentDate) throws MessagingException;
+
+ public abstract Address[] getRecipients(RecipientType type) throws MessagingException;
+
+ public abstract void setRecipients(RecipientType type, Address[] addresses)
+ throws MessagingException;
+
+ public void setRecipient(RecipientType type, Address address) throws MessagingException {
+ setRecipients(type, new Address[] {
+ address
+ });
+ }
+
+ public abstract Address[] getFrom() throws MessagingException;
+
+ public abstract void setFrom(Address from) throws MessagingException;
+
+ public abstract Address[] getReplyTo() throws MessagingException;
+
+ public abstract void setReplyTo(Address[] from) throws MessagingException;
+
+ public abstract Body getBody() throws MessagingException;
+
+ public abstract String getContentType() throws MessagingException;
+
+ public abstract void addHeader(String name, String value) throws MessagingException;
+
+ public abstract void setHeader(String name, String value) throws MessagingException;
+
+ public abstract String[] getHeader(String name) throws MessagingException;
+
+ public abstract void removeHeader(String name) throws MessagingException;
+
+ public abstract void setBody(Body body) throws MessagingException;
+
+ public boolean isMimeType(String mimeType) throws MessagingException {
+ return getContentType().startsWith(mimeType);
+ }
+
+ /*
+ * TODO Refactor Flags at some point to be able to store user defined flags.
+ */
+ public Flag[] getFlags() {
+ return mFlags.toArray(new Flag[] {});
+ }
+
+ public void setFlag(Flag flag, boolean set) throws MessagingException {
+ if (set) {
+ mFlags.add(flag);
+ } else {
+ mFlags.remove(flag);
+ }
+ }
+
+ /**
+ * This method calls setFlag(Flag, boolean)
+ * @param flags
+ * @param set
+ */
+ public void setFlags(Flag[] flags, boolean set) throws MessagingException {
+ for (Flag flag : flags) {
+ setFlag(flag, set);
+ }
+ }
+
+ public boolean isSet(Flag flag) {
+ return mFlags.contains(flag);
+ }
+
+ public abstract void saveChanges() throws MessagingException;
+}
diff --git a/src/com/fsck/k9/mail/MessageDateComparator.java b/src/com/fsck/k9/mail/MessageDateComparator.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bde7af0b854e4c10fd102e826b721cc792ed8e8
--- /dev/null
+++ b/src/com/fsck/k9/mail/MessageDateComparator.java
@@ -0,0 +1,19 @@
+
+package com.fsck.k9.mail;
+
+import java.util.Comparator;
+
+public class MessageDateComparator implements Comparator
+