keejef
/
session-android
mirror of https://github.com/oxen-io/session-android
1
0
Fork 0
Code Issues 1 Projects Releases Wiki Activity

Change MMS network request pattern.

Browse Source 
Currently we're flipping the radio in "MMS" mode, and connecting through
any proxies specified in the APN.  This always work, or at least doesn't
seem to work on Sprint, since the configured mms proxy rejects proxy
requests.

Instead we try the following in this order:

1) Connect over normal data connection directly to MMSC.
2) Connect over MMS radio connection to MMSC.
3) Connect over MMS radio connection with any configured proxy to MMSC.

Hopefully this doesn't fuck up shit on other unknown networks.
pull/1/head
Moxie Marlinspike 12 years ago
parent df05508a6f
commit f73adfc8f5
6 changed files with 303 additions and 162 deletions
Show Stats Download Patch File Download Diff File

5
res/values/strings.xml
Unescape Escape View File

@ -103,6 +103,11 @@
<!-- KeyScanningActivity --> <!-- KeyScanningActivity -->
<string name="KeyScanningActivity_no_scanned_key_found_exclamation">No scanned key found!</string> <string name="KeyScanningActivity_no_scanned_key_found_exclamation">No scanned key found!</string>
<!-- MmsDownloader -->
<string name="MmsDownloader_no_connectivity_available_for_mms_download_try_again_later">No connectivity available for MMS download, try again later...</string>
<string name="MmsDownloader_error_storing_mms">Error storing MMS!</string>
<string name="MmsDownloader_error_connecting_to_mms_provider">Error connecting to MMS provider...</string>
<!-- PassphraseChangeActivity --> <!-- PassphraseChangeActivity -->
<string name="PassphraseChangeActivity_passphrases_dont_match_exclamation">Passphrases Don\'t Match!</string> <string name="PassphraseChangeActivity_passphrases_dont_match_exclamation">Passphrases Don\'t Match!</string>

36
src/org/thoughtcrime/securesms/mms/MmsCommunication.java
Unescape Escape View File

@ -63,7 +63,8 @@ public class MmsCommunication {
throw new ApnUnavailableException("No locally configured parameters available"); throw new ApnUnavailableException("No locally configured parameters available");
} }
protected static MmsConnectionParameters getMmsConnectionParameters(Context context, String apn) protected static MmsConnectionParameters getMmsConnectionParameters(Context context, String apn,
boolean proxyIfPossible)
throws ApnUnavailableException throws ApnUnavailableException
{ {
Cursor cursor = null; Cursor cursor = null;
@ -76,8 +77,13 @@ public class MmsCommunication {
do { do {
String mmsc = cursor.getString(cursor.getColumnIndexOrThrow("mmsc")); String mmsc = cursor.getString(cursor.getColumnIndexOrThrow("mmsc"));
String proxy = cursor.getString(cursor.getColumnIndexOrThrow("mmsproxy")); String proxy = null;
String port = cursor.getString(cursor.getColumnIndexOrThrow("mmsport")); String port = null;
if (proxyIfPossible) {
proxy = cursor.getString(cursor.getColumnIndexOrThrow("mmsproxy"));
port = cursor.getString(cursor.getColumnIndexOrThrow("mmsport"));
}
if (mmsc != null && !mmsc.equals("")) if (mmsc != null && !mmsc.equals(""))
return new MmsConnectionParameters(mmsc, proxy, port); return new MmsConnectionParameters(mmsc, proxy, port);
@ -97,15 +103,29 @@ public class MmsCommunication {
} }
} }
protected static void checkRouteToHost(Context context, MmsConnectionParameters parameters, String url) throws IOException { protected static void checkRouteToHost(Context context, MmsConnectionParameters parameters,
String url, boolean usingMmsRadio)
throws IOException
{
if (parameters == null || !parameters.hasProxy()) if (parameters == null || !parameters.hasProxy())
checkRouteToHost(context, Uri.parse(url).getHost()); checkRouteToHost(context, Uri.parse(url).getHost(), usingMmsRadio);
else else
checkRouteToHost(context, parameters.getProxy()); checkRouteToHost(context, parameters.getProxy(), usingMmsRadio);
} }
private static void checkRouteToHost(Context context, String host) throws IOException { private static void checkRouteToHost(Context context, String host, boolean usingMmsRadio)
InetAddress inetAddress = InetAddress.getByName(host); throws IOException
{
InetAddress inetAddress = InetAddress.getByName(host);
if (!usingMmsRadio) {
if (inetAddress.isSiteLocalAddress()) {
throw new IOException("RFC1918 address in non-MMS radio situation!");
}
return;
}
byte[] ipAddressBytes = inetAddress.getAddress(); byte[] ipAddressBytes = inetAddress.getAddress();
int ipAddress = Conversions.byteArrayToIntLittleEndian(ipAddressBytes, 0); int ipAddress = Conversions.byteArrayToIntLittleEndian(ipAddressBytes, 0);
ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE); ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

32
src/org/thoughtcrime/securesms/mms/MmsDownloadHelper.java
Unescape Escape View File

@ -26,6 +26,9 @@ import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException; import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpGet;
import ws.com.google.android.mms.pdu.PduParser;
import ws.com.google.android.mms.pdu.RetrieveConf;
import java.io.IOException; import java.io.IOException;
import java.net.URI; import java.net.URI;
import java.net.URISyntaxException; import java.net.URISyntaxException;
@ -46,15 +49,6 @@ public class MmsDownloadHelper extends MmsCommunication {
request.setParams(client.getParams()); request.setParams(client.getParams());
request.addHeader("Accept", "*/*, application/vnd.wap.mms-message, application/vnd.wap.sic"); request.addHeader("Accept", "*/*, application/vnd.wap.mms-message, application/vnd.wap.sic");
// java.util.logging.Logger.getLogger("org.apache.http.wire").setLevel(java.util.logging.Level.FINEST);
// java.util.logging.Logger.getLogger("org.apache.http.headers").setLevel(java.util.logging.Level.FINEST);
//
// System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
// System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true");
// System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire", "debug");
// System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "debug");
// System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http.headers", "debug");
HttpResponse response = client.execute(target, request); HttpResponse response = client.execute(target, request);
StatusLine status = response.getStatusLine(); StatusLine status = response.getStatusLine();
@ -71,17 +65,29 @@ public class MmsDownloadHelper extends MmsCommunication {
} }
} }
public static byte[] retrieveMms(Context context, String url, String apn) throws IOException { public static RetrieveConf retrieveMms(Context context, String url, String apn,
boolean usingMmsRadio, boolean proxyIfPossible)
throws IOException
{
MmsConnectionParameters connectionParameters; MmsConnectionParameters connectionParameters;
try { try {
connectionParameters = getMmsConnectionParameters(context, apn); connectionParameters = getMmsConnectionParameters(context, apn, proxyIfPossible);
} catch (ApnUnavailableException aue) { } catch (ApnUnavailableException aue) {
Log.w("MmsDownloadHelper", aue); Log.w("MmsDownloadHelper", aue);
connectionParameters = new MmsConnectionParameters(null, null, null); connectionParameters = new MmsConnectionParameters(null, null, null);
} }
checkRouteToHost(context, connectionParameters, url); checkRouteToHost(context, connectionParameters, url, usingMmsRadio);
return makeRequest(context, connectionParameters, url);
byte[] pdu = makeRequest(context, connectionParameters, url);
RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse();
if (retrieved == null) {
throw new IOException("Bad retrieved PDU");
}
return retrieved;
} }
} }

15
src/org/thoughtcrime/securesms/mms/MmsSendHelper.java
Unescape Escape View File

@ -27,6 +27,9 @@ import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ByteArrayEntity; import org.apache.http.entity.ByteArrayEntity;
import ws.com.google.android.mms.pdu.PduParser;
import ws.com.google.android.mms.pdu.SendConf;
import java.io.IOException; import java.io.IOException;
import java.net.URI; import java.net.URI;
import java.net.URISyntaxException; import java.net.URISyntaxException;
@ -66,12 +69,16 @@ public class MmsSendHelper extends MmsCommunication {
} }
} }
public static byte[] sendMms(Context context, byte[] mms, String apn) throws IOException { public static SendConf sendMms(Context context, byte[] mms, String apn,
boolean usingMmsRadio, boolean useProxyIfAvailable)
throws IOException
{
Log.w("MmsSender", "Sending MMS of length: " + mms.length); Log.w("MmsSender", "Sending MMS of length: " + mms.length);
try { try {
MmsConnectionParameters parameters = getMmsConnectionParameters(context, apn); MmsConnectionParameters parameters = getMmsConnectionParameters(context, apn, useProxyIfAvailable);
checkRouteToHost(context, parameters, parameters.getMmsc()); checkRouteToHost(context, parameters, parameters.getMmsc(), usingMmsRadio);
return makePost(context, parameters, mms); byte[] response = makePost(context, parameters, mms);
return (SendConf) new PduParser(response).parse();
} catch (ApnUnavailableException aue) { } catch (ApnUnavailableException aue) {
Log.w("MmsSender", aue); Log.w("MmsSender", aue);
throw new IOException("Failed to get MMSC information..."); throw new IOException("Failed to get MMSC information...");

156
src/org/thoughtcrime/securesms/service/MmsDownloader.java
Unescape Escape View File

@ -20,6 +20,7 @@ import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.util.Log; import android.util.Log;
import org.thoughtcrime.securesms.R;
import org.thoughtcrime.securesms.crypto.DecryptingQueue; import org.thoughtcrime.securesms.crypto.DecryptingQueue;
import org.thoughtcrime.securesms.crypto.MasterSecret; import org.thoughtcrime.securesms.crypto.MasterSecret;
import org.thoughtcrime.securesms.database.DatabaseFactory; import org.thoughtcrime.securesms.database.DatabaseFactory;
@ -28,7 +29,6 @@ import org.thoughtcrime.securesms.mms.MmsDownloadHelper;
import org.thoughtcrime.securesms.protocol.WirePrefix; import org.thoughtcrime.securesms.protocol.WirePrefix;
import ws.com.google.android.mms.MmsException; import ws.com.google.android.mms.MmsException;
import ws.com.google.android.mms.pdu.PduParser;
import ws.com.google.android.mms.pdu.RetrieveConf; import ws.com.google.android.mms.pdu.RetrieveConf;
import java.io.IOException; import java.io.IOException;
@ -44,73 +44,105 @@ public class MmsDownloader extends MmscProcessor {
this.toastHandler = toastHandler; this.toastHandler = toastHandler;
} }
private void handleDownloadMms(DownloadItem item) { public void process(MasterSecret masterSecret, Intent intent) {
if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_ACTION)) {
DownloadItem item = new DownloadItem(masterSecret, false, false,
intent.getLongExtra("message_id", -1),
intent.getLongExtra("thread_id", -1),
intent.getStringExtra("content_location"),
intent.getByteArrayExtra("transaction_id"));
handleDownloadMmsAction(item);
} else if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_CONNECTIVITY_ACTION)) {
handleConnectivityChange();
}
}
private void handleDownloadMmsAction(DownloadItem item) {
if (!isConnectivityPossible()) { if (!isConnectivityPossible()) {
Log.w("MmsDownloader", "No MMS connectivity available!");
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY); DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY);
toastHandler.makeToast("No connectivity available for MMS download, try again later..."); toastHandler.makeToast(context.getString(R.string.MmsDownloader_no_connectivity_available_for_mms_download_try_again_later));
Log.w("MmsDownloadService", "Unable to download MMS, please try again later."); return;
} else {
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_CONNECTING);
pendingMessages.add(item);
issueConnectivityRequest();
} }
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_CONNECTING);
if (item.useMmsRadioMode()) downloadMmsWithRadioChange(item);
else downloadMms(item);
}
private void downloadMmsWithRadioChange(DownloadItem item) {
Log.w("MmsDownloader", "Handling MMS download with radio change...");
pendingMessages.add(item);
issueConnectivityRequest();
} }
private void handleDownloadMmsContinued(DownloadItem item) { private void downloadMms(DownloadItem item) {
Log.w("MmsDownloadService", "Handling MMS download continuation..."); Log.w("MmsDownloadService", "Handling actual MMS download...");
MmsDatabase mmsDatabase; MmsDatabase mmsDatabase;
if (item.getMasterSecret() == null) if (item.getMasterSecret() == null) {
mmsDatabase = DatabaseFactory.getMmsDatabase(context); mmsDatabase = DatabaseFactory.getMmsDatabase(context);
else } else {
mmsDatabase = DatabaseFactory.getEncryptingMmsDatabase(context, item.getMasterSecret()); mmsDatabase = DatabaseFactory.getEncryptingMmsDatabase(context, item.getMasterSecret());
}
try { try {
byte[] pdu = MmsDownloadHelper.retrieveMms(context, item.getContentLocation(), RetrieveConf retrieved = MmsDownloadHelper.retrieveMms(context, item.getContentLocation(),
getApnInformation()); getApnInformation(),
RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse(); item.useMmsRadioMode(),
item.proxyRequestIfPossible());
if (retrieved == null)
throw new IOException("Bad retrieved PDU");
for (int i=0;i<retrieved.getBody().getPartsNum();i++) { for (int i=0;i<retrieved.getBody().getPartsNum();i++) {
Log.w("MmsDownloader", "Sent MMS part of content-type: " + Log.w("MmsDownloader", "Got MMS part of content-type: " +
new String(retrieved.getBody().getPart(i).getContentType())); new String(retrieved.getBody().getPart(i).getContentType()));
} }
if (retrieved.getSubject() != null && WirePrefix.isEncryptedMmsSubject(retrieved.getSubject().getString())) { storeRetrievedMms(mmsDatabase, item, retrieved);
long messageId = mmsDatabase.insertSecureMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
if (item.getMasterSecret() != null)
DecryptingQueue.scheduleDecryption(context, item.getMasterSecret(), messageId, item.getThreadId(), retrieved);
} else {
mmsDatabase.insertMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
}
mmsDatabase.delete(item.getMessageId());
// NotifyRespInd notifyResponse = new NotifyRespInd(PduHeaders.CURRENT_MMS_VERSION, item.getTransactionId(), PduHeaders.STATUS_RETRIEVED); // NotifyRespInd notifyResponse = new NotifyRespInd(PduHeaders.CURRENT_MMS_VERSION, item.getTransactionId(), PduHeaders.STATUS_RETRIEVED);
// MmsSendHelper.sendMms(context, new PduComposer(context, notifyResponse).make()); // MmsSendHelper.sendMms(context, new PduComposer(context, notifyResponse).make());
if (this.pendingMessages.isEmpty())
finishConnectivity();
} catch (IOException e) { } catch (IOException e) {
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_SOFT_FAILURE);
toastHandler.makeToast("Error connecting to MMS provider...");
Log.w("MmsDownloader", e); Log.w("MmsDownloader", e);
if (!item.useMmsRadioMode() && !item.proxyRequestIfPossible()) {
scheduleDownloadWithRadioMode(item);
} else if (!item.proxyRequestIfPossible()) {
scheduleDownloadWithRadioModeAndProxy(item);
} else {
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_SOFT_FAILURE);
toastHandler.makeToast(context.getString(R.string.MmsDownloader_error_connecting_to_mms_provider));
}
} catch (MmsException e) { } catch (MmsException e) {
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_HARD_FAILURE);
toastHandler.makeToast("Error downloading MMS!");
Log.w("MmsDownloader", e); Log.w("MmsDownloader", e);
DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_HARD_FAILURE);
toastHandler.makeToast(context.getString(R.string.MmsDownloader_error_storing_mms));
} }
} }
private void storeRetrievedMms(MmsDatabase mmsDatabase, DownloadItem item, RetrieveConf retrieved)
throws MmsException
{
if (retrieved.getSubject() != null && WirePrefix.isEncryptedMmsSubject(retrieved.getSubject().getString())) {
long messageId = mmsDatabase.insertSecureMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
if (item.getMasterSecret() != null)
DecryptingQueue.scheduleDecryption(context, item.getMasterSecret(), messageId, item.getThreadId(), retrieved);
} else {
mmsDatabase.insertMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
}
mmsDatabase.delete(item.getMessageId());
}
protected void handleConnectivityChange() { protected void handleConnectivityChange() {
if (!isConnected()) { if (!isConnected()) {
if (!isConnectivityPossible() && !pendingMessages.isEmpty()) { if (!isConnectivityPossible() && !pendingMessages.isEmpty()) {
DatabaseFactory.getMmsDatabase(context).markDownloadState(pendingMessages.remove().getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY); DatabaseFactory.getMmsDatabase(context).markDownloadState(pendingMessages.remove().getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY);
toastHandler.makeToast("No connectivity available for MMS download, try again later..."); toastHandler.makeToast(context
.getString(R.string.MmsDownloader_no_connectivity_available_for_mms_download_try_again_later));
Log.w("MmsDownloadService", "Unable to download MMS, please try again later."); Log.w("MmsDownloadService", "Unable to download MMS, please try again later.");
finishConnectivity(); finishConnectivity();
} }
@ -118,37 +150,45 @@ public class MmsDownloader extends MmscProcessor {
return; return;
} }
if (!pendingMessages.isEmpty()) handleDownloadMmsContinued(pendingMessages.remove()); for (DownloadItem item : pendingMessages) {
else finishConnectivity(); downloadMms(item);
}
pendingMessages.clear();
finishConnectivity();
} }
public void process(MasterSecret masterSecret, Intent intent) {
if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_ACTION)) {
DownloadItem item = new DownloadItem(intent.getLongExtra("message_id", -1),
intent.getLongExtra("thread_id", -1),
intent.getStringExtra("content_location"),
intent.getByteArrayExtra("transaction_id"),
masterSecret);
handleDownloadMms(item); private void scheduleDownloadWithRadioMode(DownloadItem item) {
} else if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_CONNECTIVITY_ACTION)) { item.mmsRadioMode = true;
handleConnectivityChange(); handleDownloadMmsAction(item);
} }
private void scheduleDownloadWithRadioModeAndProxy(DownloadItem item) {
item.mmsRadioMode = true;
item.proxyIfPossible = true;
handleDownloadMmsAction(item);
} }
private static class DownloadItem {
private final MasterSecret masterSecret;
private boolean mmsRadioMode;
private boolean proxyIfPossible;
private class DownloadItem {
private long threadId; private long threadId;
private long messageId; private long messageId;
private byte[] transactionId; private byte[] transactionId;
private String contentLocation; private String contentLocation;
private MasterSecret masterSecret;
public DownloadItem(long messageId, long threadId, String contentLocation, byte[] transactionId, MasterSecret masterSecret) { public DownloadItem(MasterSecret masterSecret, boolean mmsRadioMode, boolean proxyIfPossible,
long messageId, long threadId, String contentLocation, byte[] transactionId)
{
this.masterSecret = masterSecret;
this.mmsRadioMode = mmsRadioMode;
this.proxyIfPossible = proxyIfPossible;
this.threadId = threadId; this.threadId = threadId;
this.messageId = messageId; this.messageId = messageId;
this.contentLocation = contentLocation; this.contentLocation = contentLocation;
this.masterSecret = masterSecret;
this.transactionId = transactionId; this.transactionId = transactionId;
} }
@ -171,6 +211,14 @@ public class MmsDownloader extends MmscProcessor {
public MasterSecret getMasterSecret() { public MasterSecret getMasterSecret() {
return masterSecret; return masterSecret;
} }
public boolean proxyRequestIfPossible() {
return proxyIfPossible;
}
public boolean useMmsRadioMode() {
return mmsRadioMode;
}
} }
@Override @Override

221
src/org/thoughtcrime/securesms/service/MmsSender.java
Unescape Escape View File

@ -18,7 +18,6 @@ package org.thoughtcrime.securesms.service;
import android.content.Context; import android.content.Context;
import android.content.Intent; import android.content.Intent;
import android.os.Handler;
import android.telephony.TelephonyManager; import android.telephony.TelephonyManager;
import android.util.Log; import android.util.Log;
@ -33,6 +32,7 @@ import org.thoughtcrime.securesms.notifications.MessageNotifier;
import org.thoughtcrime.securesms.protocol.WirePrefix; import org.thoughtcrime.securesms.protocol.WirePrefix;
import org.thoughtcrime.securesms.recipients.Recipient; import org.thoughtcrime.securesms.recipients.Recipient;
import org.thoughtcrime.securesms.recipients.Recipients; import org.thoughtcrime.securesms.recipients.Recipients;
import org.thoughtcrime.securesms.service.SendReceiveService.ToastHandler;
import org.thoughtcrime.securesms.util.Hex; import org.thoughtcrime.securesms.util.Hex;
import ws.com.google.android.mms.ContentType; import ws.com.google.android.mms.ContentType;
@ -41,21 +41,22 @@ import ws.com.google.android.mms.pdu.EncodedStringValue;
import ws.com.google.android.mms.pdu.PduBody; import ws.com.google.android.mms.pdu.PduBody;
import ws.com.google.android.mms.pdu.PduComposer; import ws.com.google.android.mms.pdu.PduComposer;
import ws.com.google.android.mms.pdu.PduHeaders; import ws.com.google.android.mms.pdu.PduHeaders;
import ws.com.google.android.mms.pdu.PduParser;
import ws.com.google.android.mms.pdu.PduPart; import ws.com.google.android.mms.pdu.PduPart;
import ws.com.google.android.mms.pdu.SendConf; import ws.com.google.android.mms.pdu.SendConf;
import ws.com.google.android.mms.pdu.SendReq; import ws.com.google.android.mms.pdu.SendReq;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List;
public class MmsSender extends MmscProcessor { public class MmsSender extends MmscProcessor {
private final LinkedList<SendReq[]> pendingMessages = new LinkedList<SendReq[]>(); private final LinkedList<SendItem> pendingMessages = new LinkedList<SendItem>();
private final Handler toastHandler; private final ToastHandler toastHandler;
public MmsSender(Context context, Handler toastHandler) { public MmsSender(Context context, ToastHandler toastHandler) {
super(context); super(context);
this.toastHandler = toastHandler; this.toastHandler = toastHandler;
} }
@ -66,95 +67,66 @@ public class MmsSender extends MmscProcessor {
MmsDatabase database = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret); MmsDatabase database = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret);
try { try {
SendReq[] sendRequests; List<SendReq> sendRequests = getOutgoingMessages(masterSecret, messageId);
if (messageId == -1) { for (SendReq sendRequest : sendRequests) {
sendRequests = database.getOutgoingMessages(); handleSendMmsAction(new SendItem(masterSecret, sendRequest, messageId != -1, false, false));
} else {
sendRequests = new SendReq[1];
sendRequests[0] = database.getSendRequest(messageId);
} }
if (sendRequests != null && sendRequests.length > 0)
handleSendMms(sendRequests, messageId != -1);
} catch (MmsException me) { } catch (MmsException me) {
Log.w("MmsSender", me); Log.w("MmsSender", me);
if (messageId != -1) if (messageId != -1)
database.markAsSentFailed(messageId); database.markAsSentFailed(messageId);
} }
} else if (intent.getAction().equals(SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION)) { } else if (intent.getAction().equals(SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION)) {
handleConnectivityChange(masterSecret); handleConnectivityChange();
} }
} }
protected void handleConnectivityChange(MasterSecret masterSecret) { private void handleSendMmsAction(SendItem item) {
if (!isConnected())
return;
if (!pendingMessages.isEmpty()) handleSendMmsContinued(masterSecret, pendingMessages.remove());
else finishConnectivity();
}
private void handleSendMms(SendReq[] sendRequests, boolean targeted) {
if (!isConnectivityPossible()) { if (!isConnectivityPossible()) {
if (targeted) { if (item.targeted) {
toastHandler toastHandler
.obtainMessage(0, context.getString(R.string.MmsSender_currently_unable_to_send_your_mms_message)) .obtainMessage(0, context.getString(R.string.MmsSender_currently_unable_to_send_your_mms_message))
.sendToTarget(); .sendToTarget();
} }
// for (int i=0;i<sendRequests.length;i++)
// DatabaseFactory.getMmsDatabase(context).markAsSentFailed(sendRequests[i].getDatabaseMessageId()); return;
} else {
pendingMessages.add(sendRequests);
issueConnectivityRequest();
} }
}
private boolean isInconsistentResponse(SendReq send, SendConf response) { if (item.useMmsRadio) sendMmsMessageWithRadioChange(item);
Log.w("MmsSenderService", "Comparing: " + Hex.toString(send.getTransactionId())); else sendMmsMessage(item);
Log.w("MmsSenderService", "With: " + Hex.toString(response.getTransactionId()));
return !Arrays.equals(send.getTransactionId(), response.getTransactionId());
} }
private byte[] getEncryptedPdu(MasterSecret masterSecret, String recipient, byte[] pduBytes) { private void sendMmsMessageWithRadioChange(SendItem item) {
synchronized (SessionCipher.CIPHER_LOCK) { Log.w("MmsSender", "Sending MMS with radio change..");
SessionCipher cipher = new SessionCipher(context, masterSecret, new Recipient(null, recipient, null, null), new TextTransport()); pendingMessages.add(item);
return cipher.encryptMessage(pduBytes); issueConnectivityRequest();
}
} }
private SendReq getEncryptedMms(MasterSecret masterSecret, SendReq pdu, long messageId) { private void sendMmsMessage(SendItem item) {
Log.w("MmsSender", "Sending Secure MMS."); Log.w("MmsSender", "Sending MMS SendItem...");
EncodedStringValue[] encodedRecipient = pdu.getTo(); MmsDatabase db = DatabaseFactory.getEncryptingMmsDatabase(context, item.masterSecret);
String recipient = encodedRecipient[0].getString(); String number = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number();
byte[] pduBytes = new PduComposer(context, pdu).make(); long messageId = item.request.getDatabaseMessageId();
byte[] encryptedPdu = getEncryptedPdu(masterSecret, recipient, pduBytes); long messageBox = item.request.getDatabaseMessageBox();
Log.w("MmsSendeR", "Got encrypted bytes: " + encryptedPdu.length); SendReq request = item.request;
PduBody body = new PduBody();
PduPart part = new PduPart();
part.setContentId((System.currentTimeMillis()+"").getBytes());
part.setContentType(ContentType.TEXT_PLAIN.getBytes());
part.setName((System.currentTimeMillis()+"").getBytes());
part.setData(encryptedPdu);
body.addPart(part);
pdu.setSubject(new EncodedStringValue(WirePrefix.calculateEncryptedMmsSubject()));
pdu.setBody(body);
return pdu; if (MmsDatabase.Types.isSecureMmsBox(messageBox)) {
} request = getEncryptedMms(item.masterSecret, request, messageId);
}
private void sendMms(MmsDatabase db, SendReq pdu, String number, long messageId, boolean secure) { if (number != null && number.trim().length() != 0) {
try { request.setFrom(new EncodedStringValue(number));
if (number != null && number.trim().length() != 0) }
pdu.setFrom(new EncodedStringValue(number));
byte[] response = MmsSendHelper.sendMms(context, new PduComposer(context, pdu).make(), getApnInformation()); try {
SendConf conf = (SendConf) new PduParser(response).parse(); SendConf conf = MmsSendHelper.sendMms(context, new PduComposer(context, request).make(),
getApnInformation(), item.useMmsRadio, item.useProxyIfAvailable);
for (int i=0;i<pdu.getBody().getPartsNum();i++) { for (int i=0;i<request.getBody().getPartsNum();i++) {
Log.w("MmsSender", "Sent MMS part of content-type: " + new String(pdu.getBody().getPart(i).getContentType())); Log.w("MmsSender", "Sent MMS part of content-type: " + new String(request.getBody().getPart(i).getContentType()));
} }
long threadId = DatabaseFactory.getMmsDatabase(context).getThreadIdForMessage(messageId); long threadId = DatabaseFactory.getMmsDatabase(context).getThreadIdForMessage(messageId);
@ -171,43 +143,106 @@ public class MmsSender extends MmscProcessor {
db.markAsSentFailed(messageId); db.markAsSentFailed(messageId);
MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId); MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
return; return;
} else if (isInconsistentResponse(pdu, conf)) { } else if (isInconsistentResponse(request, conf)) {
db.markAsSentFailed(messageId); db.markAsSentFailed(messageId);
MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId); MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
Log.w("MmsSender", "Got a response for the wrong transaction?"); Log.w("MmsSender", "Got a response for the wrong transaction?");
return; return;
} else { } else {
Log.w("MmsSender", "Successful send! " + messageId); Log.w("MmsSender", "Successful send! " + messageId);
if (!secure) if (!MmsDatabase.Types.isSecureMmsBox(messageBox)) {
db.markAsSent(messageId, conf.getMessageId(), conf.getResponseStatus()); db.markAsSent(messageId, conf.getMessageId(), conf.getResponseStatus());
else } else {
db.markAsSecureSent(messageId, conf.getMessageId(), conf.getResponseStatus()); db.markAsSecureSent(messageId, conf.getMessageId(), conf.getResponseStatus());
} }
}
} catch (IOException ioe) { } catch (IOException ioe) {
Log.w("MmsSender", ioe); Log.w("MmsSender", ioe);
db.markAsSentFailed(messageId); if (!item.useMmsRadio) scheduleSendWithMmsRadio(item);
else if (!item.useProxyIfAvailable) scheduleSendWithMmsRadioAndProxy(item);
else db.markAsSentFailed(messageId);
} }
} }
private void handleSendMmsContinued(MasterSecret masterSecret, SendReq[] requests) { private List<SendReq> getOutgoingMessages(MasterSecret masterSecret, long messageId)
Log.w("MmsSenderService", "Handling MMS send continuation..."); throws MmsException
{
MmsDatabase database = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret);
List<SendReq> sendRequests;
MmsDatabase db = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret); if (messageId == -1) {
String number = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number(); sendRequests = Arrays.asList(database.getOutgoingMessages());
} else {
sendRequests = new ArrayList<SendReq>(1);
sendRequests.add(database.getSendRequest(messageId));
}
for (int i=0;i<requests.length;i++) { return sendRequests;
SendReq request = requests[i]; }
long messageId = request.getDatabaseMessageId();
long messageBox = request.getDatabaseMessageBox();
if (MmsDatabase.Types.isSecureMmsBox(messageBox)) protected void handleConnectivityChange() {
request = getEncryptedMms(masterSecret, request, messageId); if (!isConnected()) {
if (!isConnectivityPossible() && !pendingMessages.isEmpty()) {
DatabaseFactory.getMmsDatabase(context).markAsSentFailed(pendingMessages.remove().request.getDatabaseMessageId());
toastHandler.makeToast(context.getString(R.string.MmsSender_currently_unable_to_send_your_mms_message));
Log.w("MmsSender", "Unable to send MMS.");
finishConnectivity();
}
return;
}
sendMms(db, request, number, messageId, MmsDatabase.Types.isSecureMmsBox(messageBox)); for (SendItem item : pendingMessages) {
sendMmsMessage(item);
} }
if (this.pendingMessages.isEmpty()) pendingMessages.clear();
finishConnectivity(); finishConnectivity();
}
private boolean isInconsistentResponse(SendReq send, SendConf response) {
Log.w("MmsSenderService", "Comparing: " + Hex.toString(send.getTransactionId()));
Log.w("MmsSenderService", "With: " + Hex.toString(response.getTransactionId()));
return !Arrays.equals(send.getTransactionId(), response.getTransactionId());
}
private byte[] getEncryptedPdu(MasterSecret masterSecret, String recipient, byte[] pduBytes) {
synchronized (SessionCipher.CIPHER_LOCK) {
SessionCipher cipher = new SessionCipher(context, masterSecret, new Recipient(null, recipient, null, null), new TextTransport());
return cipher.encryptMessage(pduBytes);
}
}
private SendReq getEncryptedMms(MasterSecret masterSecret, SendReq pdu, long messageId) {
Log.w("MmsSender", "Sending Secure MMS.");
EncodedStringValue[] encodedRecipient = pdu.getTo();
String recipient = encodedRecipient[0].getString();
byte[] pduBytes = new PduComposer(context, pdu).make();
byte[] encryptedPdu = getEncryptedPdu(masterSecret, recipient, pduBytes);
Log.w("MmsSendeR", "Got encrypted bytes: " + encryptedPdu.length);
PduBody body = new PduBody();
PduPart part = new PduPart();
part.setContentId((System.currentTimeMillis()+"").getBytes());
part.setContentType(ContentType.TEXT_PLAIN.getBytes());
part.setName((System.currentTimeMillis()+"").getBytes());
part.setData(encryptedPdu);
body.addPart(part);
pdu.setSubject(new EncodedStringValue(WirePrefix.calculateEncryptedMmsSubject()));
pdu.setBody(body);
return pdu;
}
private void scheduleSendWithMmsRadioAndProxy(SendItem item) {
item.useMmsRadio = true;
handleSendMmsAction(item);
}
private void scheduleSendWithMmsRadio(SendItem item) {
item.useMmsRadio = true;
item.useProxyIfAvailable = true;
handleSendMmsAction(item);
} }
@Override @Override
@ -215,4 +250,24 @@ public class MmsSender extends MmscProcessor {
return SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION; return SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION;
} }
private static class SendItem {
private final MasterSecret masterSecret;
private boolean useMmsRadio;
private boolean useProxyIfAvailable;
private SendReq request;
private boolean targeted;
public SendItem(MasterSecret masterSecret, SendReq request,
boolean targeted, boolean useMmsRadio,
boolean useProxyIfAvailable)
{
this.masterSecret = masterSecret;
this.request = request;
this.targeted = targeted;
this.useMmsRadio = useMmsRadio;
this.useProxyIfAvailable = useProxyIfAvailable;
}
}
} }

Write Preview
Loading…
Cancel
Save