conversations-classic/src/main/java/eu/siacs/conversations/xmpp/jingle/JingleConnection.java

1032 lines
34 KiB
Java
Raw Normal View History

package eu.siacs.conversations.xmpp.jingle;
2015-07-20 12:26:29 +00:00
import android.util.Log;
import android.util.Pair;
2015-07-20 12:26:29 +00:00
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
2014-06-22 19:44:17 +00:00
import java.util.Locale;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
2014-08-31 14:28:21 +00:00
import eu.siacs.conversations.Config;
import eu.siacs.conversations.crypto.axolotl.AxolotlService;
import eu.siacs.conversations.crypto.axolotl.OnMessageCreatedCallback;
import eu.siacs.conversations.crypto.axolotl.XmppAxolotlMessage;
import eu.siacs.conversations.entities.Account;
import eu.siacs.conversations.entities.Conversation;
2014-10-14 10:02:48 +00:00
import eu.siacs.conversations.entities.DownloadableFile;
import eu.siacs.conversations.entities.Message;
2015-07-20 12:26:29 +00:00
import eu.siacs.conversations.entities.Transferable;
import eu.siacs.conversations.entities.TransferablePlaceholder;
import eu.siacs.conversations.persistance.FileBackend;
import eu.siacs.conversations.services.AbstractConnectionManager;
import eu.siacs.conversations.services.XmppConnectionService;
import eu.siacs.conversations.xml.Element;
import eu.siacs.conversations.xmpp.OnIqPacketReceived;
2014-11-06 19:10:03 +00:00
import eu.siacs.conversations.xmpp.jid.Jid;
import eu.siacs.conversations.xmpp.jingle.stanzas.Content;
import eu.siacs.conversations.xmpp.jingle.stanzas.JinglePacket;
import eu.siacs.conversations.xmpp.jingle.stanzas.Reason;
import eu.siacs.conversations.xmpp.stanzas.IqPacket;
2015-07-10 13:11:03 +00:00
public class JingleConnection implements Transferable {
private JingleConnectionManager mJingleConnectionManager;
private XmppConnectionService mXmppConnectionService;
protected static final int JINGLE_STATUS_INITIATED = 0;
protected static final int JINGLE_STATUS_ACCEPTED = 1;
protected static final int JINGLE_STATUS_FINISHED = 4;
protected static final int JINGLE_STATUS_TRANSMITTING = 5;
protected static final int JINGLE_STATUS_FAILED = 99;
2015-07-17 11:06:51 +00:00
private int ibbBlockSize = 8192;
private int mJingleStatus = -1;
2015-07-10 13:11:03 +00:00
private int mStatus = Transferable.STATUS_UNKNOWN;
private Message message;
private String sessionId;
private Account account;
2014-11-06 19:10:03 +00:00
private Jid initiator;
private Jid responder;
private List<JingleCandidate> candidates = new ArrayList<>();
private ConcurrentHashMap<String, JingleSocks5Transport> connections = new ConcurrentHashMap<>();
2014-04-17 12:52:10 +00:00
private String transportId;
private Element fileOffer;
2014-10-13 23:06:45 +00:00
private DownloadableFile file = null;
private String contentName;
private String contentCreator;
2014-11-13 20:04:05 +00:00
private int mProgress = 0;
private boolean receivedCandidate = false;
private boolean sentCandidate = false;
private boolean acceptedAutomatically = false;
private XmppAxolotlMessage mXmppAxolotlMessage;
private JingleTransport transport = null;
private OutputStream mFileOutputStream;
private InputStream mFileInputStream;
private OnIqPacketReceived responseListener = new OnIqPacketReceived() {
@Override
public void onIqPacketReceived(Account account, IqPacket packet) {
if (packet.getType() != IqPacket.TYPE.RESULT) {
2014-11-15 11:37:09 +00:00
fail();
}
}
};
final OnFileTransmissionStatusChanged onFileTransmissionSatusChanged = new OnFileTransmissionStatusChanged() {
@Override
2014-10-13 23:06:45 +00:00
public void onFileTransmitted(DownloadableFile file) {
if (responder.equals(account.getJid())) {
sendSuccess();
mXmppConnectionService.getFileBackend().updateFileParams(message);
mXmppConnectionService.databaseBackend.createMessage(message);
mXmppConnectionService.markMessage(message,Message.STATUS_RECEIVED);
if (acceptedAutomatically) {
message.markUnread();
if (message.getEncryption() == Message.ENCRYPTION_PGP) {
account.getPgpDecryptionService().decrypt(message, true);
} else {
JingleConnection.this.mXmppConnectionService.getNotificationService().push(message);
}
}
} else {
if (message.getEncryption() == Message.ENCRYPTION_PGP) {
account.getPgpDecryptionService().decrypt(message, false);
}
2014-11-14 13:04:34 +00:00
if (message.getEncryption() == Message.ENCRYPTION_PGP || message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
file.delete();
}
}
Log.d(Config.LOGTAG,"successfully transmitted file:" + file.getAbsolutePath()+" ("+file.getSha1Sum()+")");
2014-08-31 14:28:21 +00:00
if (message.getEncryption() != Message.ENCRYPTION_PGP) {
mXmppConnectionService.getFileBackend().updateMediaScanner(file);
}
}
@Override
public void onFileTransferAborted() {
2014-07-03 20:55:20 +00:00
JingleConnection.this.sendCancel();
2014-11-15 11:37:09 +00:00
JingleConnection.this.fail();
}
};
public InputStream getFileInputStream() {
return this.mFileInputStream;
}
public OutputStream getFileOutputStream() {
return this.mFileOutputStream;
}
private OnProxyActivated onProxyActivated = new OnProxyActivated() {
@Override
public void success() {
if (initiator.equals(account.getJid())) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "we were initiating. sending file");
transport.send(file, onFileTransmissionSatusChanged);
} else {
transport.receive(file, onFileTransmissionSatusChanged);
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "we were responding. receiving file");
}
}
@Override
public void failed() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "proxy activation failed");
}
};
public JingleConnection(JingleConnectionManager mJingleConnectionManager) {
this.mJingleConnectionManager = mJingleConnectionManager;
this.mXmppConnectionService = mJingleConnectionManager
.getXmppConnectionService();
}
public String getSessionId() {
return this.sessionId;
}
2014-10-21 17:43:34 +00:00
public Account getAccount() {
return this.account;
}
2014-11-06 19:10:03 +00:00
public Jid getCounterPart() {
return this.message.getCounterpart();
}
public void deliverPacket(JinglePacket packet) {
boolean returnResult = true;
if (packet.isAction("session-terminate")) {
Reason reason = packet.getReason();
if (reason != null) {
if (reason.hasChild("cancel")) {
2014-11-15 11:37:09 +00:00
this.fail();
} else if (reason.hasChild("success")) {
2014-04-23 19:19:56 +00:00
this.receiveSuccess();
} else {
2014-11-15 11:37:09 +00:00
this.fail();
}
} else {
2014-11-15 11:37:09 +00:00
this.fail();
}
} else if (packet.isAction("session-accept")) {
returnResult = receiveAccept(packet);
} else if (packet.isAction("transport-info")) {
returnResult = receiveTransportInfo(packet);
2014-04-22 11:11:53 +00:00
} else if (packet.isAction("transport-replace")) {
if (packet.getJingleContent().hasIbbTransport()) {
returnResult = this.receiveFallbackToIbb(packet);
2014-04-22 11:11:53 +00:00
} else {
returnResult = false;
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "trying to fallback to something unknown"
+ packet.toString());
2014-04-22 11:11:53 +00:00
}
} else if (packet.isAction("transport-accept")) {
returnResult = this.receiveTransportAccept(packet);
} else {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "packet arrived in connection. action was "
+ packet.getAction());
returnResult = false;
}
IqPacket response;
if (returnResult) {
2014-12-30 13:16:25 +00:00
response = packet.generateResponse(IqPacket.TYPE.RESULT);
} else {
2014-12-30 13:16:25 +00:00
response = packet.generateResponse(IqPacket.TYPE.ERROR);
}
mXmppConnectionService.sendIqPacket(account,response,null);
}
public void init(final Message message) {
if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL) {
Conversation conversation = message.getConversation();
conversation.getAccount().getAxolotlService().prepareKeyTransportMessage(conversation, new OnMessageCreatedCallback() {
@Override
public void run(XmppAxolotlMessage xmppAxolotlMessage) {
if (xmppAxolotlMessage != null) {
init(message, xmppAxolotlMessage);
} else {
fail();
}
}
});
} else {
init(message, null);
}
}
private void init(Message message, XmppAxolotlMessage xmppAxolotlMessage) {
this.mXmppAxolotlMessage = xmppAxolotlMessage;
this.contentCreator = "initiator";
this.contentName = this.mJingleConnectionManager.nextRandomId();
this.message = message;
2015-07-10 13:11:03 +00:00
this.message.setTransferable(this);
this.mStatus = Transferable.STATUS_UPLOADING;
this.account = message.getConversation().getAccount();
this.initiator = this.account.getJid();
this.responder = this.message.getCounterpart();
this.sessionId = this.mJingleConnectionManager.nextRandomId();
if (this.candidates.size() > 0) {
this.sendInitRequest();
} else {
this.mJingleConnectionManager.getPrimaryCandidate(account,
new OnPrimaryCandidateFound() {
@Override
public void onPrimaryCandidateFound(boolean success,
final JingleCandidate candidate) {
if (success) {
final JingleSocks5Transport socksConnection = new JingleSocks5Transport(
JingleConnection.this, candidate);
connections.put(candidate.getCid(),
socksConnection);
socksConnection
.connect(new OnTransportConnected() {
@Override
public void failed() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
"connection to our own primary candidete failed");
sendInitRequest();
}
@Override
public void established() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
2016-05-04 08:29:29 +00:00
"successfully connected to our own primary candidate");
mergeCandidate(candidate);
sendInitRequest();
}
});
mergeCandidate(candidate);
} else {
Log.d(Config.LOGTAG, "no primary candidate of our own was found");
sendInitRequest();
}
}
});
}
}
public void init(Account account, JinglePacket packet) {
this.mJingleStatus = JINGLE_STATUS_INITIATED;
Conversation conversation = this.mXmppConnectionService
.findOrCreateConversation(account,
2014-11-06 19:10:03 +00:00
packet.getFrom().toBareJid(), false);
this.message = new Message(conversation, "", Message.ENCRYPTION_NONE);
this.message.setStatus(Message.STATUS_RECEIVED);
2015-07-10 13:11:03 +00:00
this.mStatus = Transferable.STATUS_OFFER;
this.message.setTransferable(this);
2014-11-06 19:10:03 +00:00
final Jid from = packet.getFrom();
this.message.setCounterpart(from);
this.account = account;
this.initiator = packet.getFrom();
this.responder = this.account.getJid();
this.sessionId = packet.getSessionId();
2014-04-17 12:52:10 +00:00
Content content = packet.getJingleContent();
this.contentCreator = content.getAttribute("creator");
this.contentName = content.getAttribute("name");
2014-04-17 12:52:10 +00:00
this.transportId = content.getTransportId();
this.mergeCandidates(JingleCandidate.parse(content.socks5transport().getChildren()));
2014-04-17 12:52:10 +00:00
this.fileOffer = packet.getJingleContent().getFileOffer();
mXmppConnectionService.sendIqPacket(account,packet.generateResponse(IqPacket.TYPE.RESULT),null);
if (fileOffer != null) {
Element encrypted = fileOffer.findChild("encrypted", AxolotlService.PEP_PREFIX);
if (encrypted != null) {
this.mXmppAxolotlMessage = XmppAxolotlMessage.fromElement(encrypted, packet.getFrom().toBareJid());
}
Element fileSize = fileOffer.findChild("size");
2014-04-23 19:19:56 +00:00
Element fileNameElement = fileOffer.findChild("name");
if (fileNameElement != null) {
String[] filename = fileNameElement.getContent()
.toLowerCase(Locale.US).toLowerCase().split("\\.");
2015-01-11 14:19:36 +00:00
String extension = filename[filename.length - 1];
2016-03-04 10:24:53 +00:00
if (VALID_IMAGE_EXTENSIONS.contains(extension)) {
2014-11-13 20:04:05 +00:00
message.setType(Message.TYPE_IMAGE);
2015-01-11 14:19:36 +00:00
message.setRelativeFilePath(message.getUuid()+"."+extension);
2016-03-04 10:24:53 +00:00
} else if (VALID_CRYPTO_EXTENSIONS.contains(
filename[filename.length - 1])) {
2014-04-23 19:19:56 +00:00
if (filename.length == 3) {
2015-01-11 14:19:36 +00:00
extension = filename[filename.length - 2];
2016-03-04 10:24:53 +00:00
if (VALID_IMAGE_EXTENSIONS.contains(extension)) {
2014-11-13 20:04:05 +00:00
message.setType(Message.TYPE_IMAGE);
2015-01-11 14:19:36 +00:00
message.setRelativeFilePath(message.getUuid()+"."+extension);
2014-11-13 20:04:05 +00:00
} else {
message.setType(Message.TYPE_FILE);
2014-04-23 19:19:56 +00:00
}
2014-11-13 20:04:05 +00:00
if (filename[filename.length - 1].equals("otr")) {
message.setEncryption(Message.ENCRYPTION_OTR);
2014-07-03 20:55:20 +00:00
} else {
2014-11-13 20:04:05 +00:00
message.setEncryption(Message.ENCRYPTION_PGP);
2014-07-03 20:55:20 +00:00
}
}
2014-04-23 19:19:56 +00:00
} else {
2014-11-13 20:04:05 +00:00
message.setType(Message.TYPE_FILE);
}
if (message.getType() == Message.TYPE_FILE) {
String suffix = "";
if (!fileNameElement.getContent().isEmpty()) {
String parts[] = fileNameElement.getContent().split("/");
suffix = parts[parts.length - 1];
if (message.getEncryption() == Message.ENCRYPTION_OTR && suffix.endsWith(".otr")) {
suffix = suffix.substring(0,suffix.length() - 4);
2014-11-14 02:27:18 +00:00
} else if (message.getEncryption() == Message.ENCRYPTION_PGP && (suffix.endsWith(".pgp") || suffix.endsWith(".gpg"))) {
suffix = suffix.substring(0,suffix.length() - 4);
}
2014-11-13 20:04:05 +00:00
}
message.setRelativeFilePath(message.getUuid()+"_"+suffix);
}
2014-11-13 20:04:05 +00:00
long size = Long.parseLong(fileSize.getContent());
message.setBody(Long.toString(size));
conversation.add(message);
mXmppConnectionService.updateConversationUi();
if (mJingleConnectionManager.hasStoragePermission()
&& size < this.mJingleConnectionManager.getAutoAcceptFileSize()) {
Log.d(Config.LOGTAG, "auto accepting file from "+ packet.getFrom());
2014-11-13 20:04:05 +00:00
this.acceptedAutomatically = true;
this.sendAccept();
} else {
message.markUnread();
Log.d(Config.LOGTAG,
"not auto accepting new file offer with size: "
+ size
+ " allowed size:"
+ this.mJingleConnectionManager
.getAutoAcceptFileSize());
this.mXmppConnectionService.getNotificationService().push(message);
2014-11-13 20:04:05 +00:00
}
this.file = this.mXmppConnectionService.getFileBackend().getFile(message, false);
if (mXmppAxolotlMessage != null) {
XmppAxolotlMessage.XmppAxolotlKeyTransportMessage transportMessage = account.getAxolotlService().processReceivingKeyTransportMessage(mXmppAxolotlMessage);
if (transportMessage != null) {
message.setEncryption(Message.ENCRYPTION_AXOLOTL);
this.file.setKey(transportMessage.getKey());
this.file.setIv(transportMessage.getIv());
2016-03-31 19:15:49 +00:00
message.setFingerprint(transportMessage.getFingerprint());
} else {
Log.d(Config.LOGTAG,"could not process KeyTransportMessage");
}
} else if (message.getEncryption() == Message.ENCRYPTION_OTR) {
2014-11-13 20:04:05 +00:00
byte[] key = conversation.getSymmetricKey();
if (key == null) {
this.sendCancel();
2014-11-15 11:37:09 +00:00
this.fail();
2014-11-13 20:04:05 +00:00
return;
} else {
this.file.setKeyAndIv(key);
2014-11-13 20:04:05 +00:00
}
}
this.mFileOutputStream = AbstractConnectionManager.createOutputStream(this.file,message.getEncryption() == Message.ENCRYPTION_AXOLOTL);
if (message.getEncryption() == Message.ENCRYPTION_OTR && Config.REPORT_WRONG_FILESIZE_IN_OTR_JINGLE) {
this.file.setExpectedSize((size / 16 + 1) * 16);
} else {
this.file.setExpectedSize(size);
}
Log.d(Config.LOGTAG, "receiving file: expecting size of " + this.file.getExpectedSize());
2014-04-23 19:19:56 +00:00
} else {
2014-07-03 20:55:20 +00:00
this.sendCancel();
2014-11-15 11:37:09 +00:00
this.fail();
}
} else {
2014-07-03 20:55:20 +00:00
this.sendCancel();
2014-11-15 11:37:09 +00:00
this.fail();
}
}
private void sendInitRequest() {
JinglePacket packet = this.bootstrapPacket("session-initiate");
Content content = new Content(this.contentCreator, this.contentName);
2014-11-13 20:04:05 +00:00
if (message.getType() == Message.TYPE_IMAGE || message.getType() == Message.TYPE_FILE) {
content.setTransportId(this.transportId);
this.file = this.mXmppConnectionService.getFileBackend().getFile(message, false);
Pair<InputStream,Integer> pair;
try {
if (message.getEncryption() == Message.ENCRYPTION_OTR) {
Conversation conversation = this.message.getConversation();
if (!this.mXmppConnectionService.renewSymmetricKey(conversation)) {
Log.d(Config.LOGTAG, account.getJid().toBareJid() + ": could not set symmetric key");
cancel();
}
this.file.setKeyAndIv(conversation.getSymmetricKey());
pair = AbstractConnectionManager.createInputStream(this.file, false);
this.file.setExpectedSize(pair.second);
content.setFileOffer(this.file, true);
} else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL) {
this.file.setKey(mXmppAxolotlMessage.getInnerKey());
this.file.setIv(mXmppAxolotlMessage.getIV());
pair = AbstractConnectionManager.createInputStream(this.file, true);
this.file.setExpectedSize(pair.second);
content.setFileOffer(this.file, false).addChild(mXmppAxolotlMessage.toElement());
} else {
pair = AbstractConnectionManager.createInputStream(this.file, false);
this.file.setExpectedSize(pair.second);
content.setFileOffer(this.file, false);
}
} catch (FileNotFoundException e) {
cancel();
return;
}
this.mFileInputStream = pair.first;
2014-04-17 12:52:10 +00:00
this.transportId = this.mJingleConnectionManager.nextRandomId();
2014-04-21 10:03:26 +00:00
content.setTransportId(this.transportId);
content.socks5transport().setChildren(getCandidatesAsElements());
packet.setContent(content);
this.sendJinglePacket(packet,new OnIqPacketReceived() {
@Override
public void onIqPacketReceived(Account account, IqPacket packet) {
if (packet.getType() == IqPacket.TYPE.RESULT) {
Log.d(Config.LOGTAG,account.getJid().toBareJid()+": other party received offer");
mJingleStatus = JINGLE_STATUS_INITIATED;
mXmppConnectionService.markMessage(message, Message.STATUS_OFFERED);
} else {
fail();
}
}
});
}
}
2014-04-17 12:52:10 +00:00
private List<Element> getCandidatesAsElements() {
2014-11-06 19:10:03 +00:00
List<Element> elements = new ArrayList<>();
for (JingleCandidate c : this.candidates) {
if (c.isOurs()) {
elements.add(c.toElement());
}
2014-04-17 12:52:10 +00:00
}
return elements;
}
private void sendAccept() {
mJingleStatus = JINGLE_STATUS_ACCEPTED;
2015-07-10 13:11:03 +00:00
this.mStatus = Transferable.STATUS_DOWNLOADING;
mXmppConnectionService.updateConversationUi();
this.mJingleConnectionManager.getPrimaryCandidate(this.account, new OnPrimaryCandidateFound() {
@Override
public void onPrimaryCandidateFound(boolean success, final JingleCandidate candidate) {
final JinglePacket packet = bootstrapPacket("session-accept");
final Content content = new Content(contentCreator,contentName);
content.setFileOffer(fileOffer);
content.setTransportId(transportId);
if (success && candidate != null && !equalCandidateExists(candidate)) {
final JingleSocks5Transport socksConnection = new JingleSocks5Transport(
JingleConnection.this,
candidate);
connections.put(candidate.getCid(), socksConnection);
socksConnection.connect(new OnTransportConnected() {
@Override
public void failed() {
Log.d(Config.LOGTAG,"connection to our own primary candidate failed");
content.socks5transport().setChildren(getCandidatesAsElements());
packet.setContent(content);
2014-04-18 23:14:30 +00:00
sendJinglePacket(packet);
2014-04-21 18:39:57 +00:00
connectNextCandidate();
}
@Override
public void established() {
Log.d(Config.LOGTAG, "connected to primary candidate");
mergeCandidate(candidate);
content.socks5transport().setChildren(getCandidatesAsElements());
packet.setContent(content);
sendJinglePacket(packet);
connectNextCandidate();
}
});
} else {
Log.d(Config.LOGTAG,"did not find a primary candidate for ourself");
content.socks5transport().setChildren(getCandidatesAsElements());
packet.setContent(content);
sendJinglePacket(packet);
connectNextCandidate();
}
}
});
}
private JinglePacket bootstrapPacket(String action) {
JinglePacket packet = new JinglePacket();
packet.setAction(action);
packet.setFrom(account.getJid());
packet.setTo(this.message.getCounterpart());
packet.setSessionId(this.sessionId);
packet.setInitiator(this.initiator);
return packet;
}
2014-04-18 23:14:30 +00:00
private void sendJinglePacket(JinglePacket packet) {
mXmppConnectionService.sendIqPacket(account,packet,responseListener);
}
private void sendJinglePacket(JinglePacket packet, OnIqPacketReceived callback) {
mXmppConnectionService.sendIqPacket(account,packet,callback);
2014-04-18 23:14:30 +00:00
}
private boolean receiveAccept(JinglePacket packet) {
Content content = packet.getJingleContent();
mergeCandidates(JingleCandidate.parse(content.socks5transport()
.getChildren()));
this.mJingleStatus = JINGLE_STATUS_ACCEPTED;
mXmppConnectionService.markMessage(message, Message.STATUS_UNSEND);
this.connectNextCandidate();
return true;
}
private boolean receiveTransportInfo(JinglePacket packet) {
Content content = packet.getJingleContent();
if (content.hasSocks5Transport()) {
if (content.socks5transport().hasChild("activated")) {
if ((this.transport != null) && (this.transport instanceof JingleSocks5Transport)) {
2014-04-23 19:19:56 +00:00
onProxyActivated.success();
} else {
String cid = content.socks5transport().findChild("activated").getAttribute("cid");
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "received proxy activated (" + cid
+ ")prior to choosing our own transport");
JingleSocks5Transport connection = this.connections.get(cid);
if (connection != null) {
2014-04-23 19:19:56 +00:00
connection.setActivated(true);
} else {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "activated connection not found");
2014-07-03 20:55:20 +00:00
this.sendCancel();
2014-11-15 11:37:09 +00:00
this.fail();
2014-04-23 19:19:56 +00:00
}
}
return true;
} else if (content.socks5transport().hasChild("proxy-error")) {
onProxyActivated.failed();
return true;
} else if (content.socks5transport().hasChild("candidate-error")) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "received candidate error");
this.receivedCandidate = true;
if ((mJingleStatus == JINGLE_STATUS_ACCEPTED)
&& (this.sentCandidate)) {
this.connect();
}
return true;
} else if (content.socks5transport().hasChild("candidate-used")) {
String cid = content.socks5transport()
.findChild("candidate-used").getAttribute("cid");
if (cid != null) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "candidate used by counterpart:" + cid);
JingleCandidate candidate = getCandidate(cid);
candidate.flagAsUsedByCounterpart();
this.receivedCandidate = true;
if ((mJingleStatus == JINGLE_STATUS_ACCEPTED)
&& (this.sentCandidate)) {
this.connect();
} else {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
2016-05-04 08:29:29 +00:00
"ignoring because file is already in transmission or we haven't sent our candidate yet");
}
return true;
} else {
return false;
}
} else {
return false;
}
} else {
return true;
}
}
2014-04-17 12:52:10 +00:00
private void connect() {
2014-04-22 11:11:53 +00:00
final JingleSocks5Transport connection = chooseConnection();
this.transport = connection;
if (connection == null) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "could not find suitable candidate");
2014-11-15 11:37:09 +00:00
this.disconnectSocks5Connections();
if (this.initiator.equals(account.getJid())) {
2014-04-22 11:11:53 +00:00
this.sendFallbackToIbb();
}
2014-04-18 23:14:30 +00:00
} else {
this.mJingleStatus = JINGLE_STATUS_TRANSMITTING;
2014-04-23 19:19:56 +00:00
if (connection.needsActivation()) {
if (connection.getCandidate().isOurs()) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "candidate "
+ connection.getCandidate().getCid()
+ " was our proxy. going to activate");
2014-12-30 13:16:25 +00:00
IqPacket activation = new IqPacket(IqPacket.TYPE.SET);
activation.setTo(connection.getCandidate().getJid());
activation.query("http://jabber.org/protocol/bytestreams")
.setAttribute("sid", this.getSessionId());
activation.query().addChild("activate")
2014-11-06 19:10:03 +00:00
.setContent(this.getCounterPart().toString());
mXmppConnectionService.sendIqPacket(account,activation,
new OnIqPacketReceived() {
@Override
public void onIqPacketReceived(Account account,
IqPacket packet) {
if (packet.getType() != IqPacket.TYPE.RESULT) {
onProxyActivated.failed();
} else {
onProxyActivated.success();
sendProxyActivated(connection.getCandidate().getCid());
}
}
});
} else {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
"candidate "
+ connection.getCandidate().getCid()
+ " was a proxy. waiting for other party to activate");
}
} else {
if (initiator.equals(account.getJid())) {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "we were initiating. sending file");
connection.send(file, onFileTransmissionSatusChanged);
2014-04-18 23:14:30 +00:00
} else {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "we were responding. receiving file");
connection.receive(file, onFileTransmissionSatusChanged);
2014-04-18 23:14:30 +00:00
}
}
}
}
2014-04-22 11:11:53 +00:00
private JingleSocks5Transport chooseConnection() {
JingleSocks5Transport connection = null;
for (Entry<String, JingleSocks5Transport> cursor : connections
.entrySet()) {
JingleSocks5Transport currentConnection = cursor.getValue();
2014-08-31 14:28:21 +00:00
// Log.d(Config.LOGTAG,"comparing candidate: "+currentConnection.getCandidate().toString());
if (currentConnection.isEstablished()
&& (currentConnection.getCandidate().isUsedByCounterpart() || (!currentConnection
.getCandidate().isOurs()))) {
2014-08-31 14:28:21 +00:00
// Log.d(Config.LOGTAG,"is usable");
if (connection == null) {
connection = currentConnection;
} else {
if (connection.getCandidate().getPriority() < currentConnection
.getCandidate().getPriority()) {
connection = currentConnection;
} else if (connection.getCandidate().getPriority() == currentConnection
.getCandidate().getPriority()) {
2014-08-31 14:28:21 +00:00
// Log.d(Config.LOGTAG,"found two candidates with same priority");
if (initiator.equals(account.getJid())) {
if (currentConnection.getCandidate().isOurs()) {
connection = currentConnection;
}
} else {
if (!currentConnection.getCandidate().isOurs()) {
connection = currentConnection;
}
}
}
}
}
}
2014-04-17 12:52:10 +00:00
return connection;
}
private void sendSuccess() {
JinglePacket packet = bootstrapPacket("session-terminate");
Reason reason = new Reason();
reason.addChild("success");
packet.setReason(reason);
2014-04-18 23:14:30 +00:00
this.sendJinglePacket(packet);
2014-11-15 11:37:09 +00:00
this.disconnectSocks5Connections();
this.mJingleStatus = JINGLE_STATUS_FINISHED;
this.message.setStatus(Message.STATUS_RECEIVED);
2015-07-10 13:11:03 +00:00
this.message.setTransferable(null);
this.mXmppConnectionService.updateMessage(message);
this.mJingleConnectionManager.finishConnection(this);
}
2014-04-22 11:11:53 +00:00
private void sendFallbackToIbb() {
Log.d(Config.LOGTAG, "sending fallback to ibb");
2014-04-22 11:11:53 +00:00
JinglePacket packet = this.bootstrapPacket("transport-replace");
Content content = new Content(this.contentCreator, this.contentName);
2014-04-22 11:11:53 +00:00
this.transportId = this.mJingleConnectionManager.nextRandomId();
content.setTransportId(this.transportId);
content.ibbTransport().setAttribute("block-size",
2014-09-01 08:40:45 +00:00
Integer.toString(this.ibbBlockSize));
2014-04-22 11:11:53 +00:00
packet.setContent(content);
this.sendJinglePacket(packet);
}
private boolean receiveFallbackToIbb(JinglePacket packet) {
Log.d(Config.LOGTAG, "receiving fallack to ibb");
String receivedBlockSize = packet.getJingleContent().ibbTransport()
.getAttribute("block-size");
if (receivedBlockSize != null) {
2014-04-22 11:11:53 +00:00
int bs = Integer.parseInt(receivedBlockSize);
if (bs > this.ibbBlockSize) {
2014-04-22 11:11:53 +00:00
this.ibbBlockSize = bs;
}
}
this.transportId = packet.getJingleContent().getTransportId();
2014-11-14 13:04:34 +00:00
this.transport = new JingleInbandTransport(this, this.transportId, this.ibbBlockSize);
this.transport.receive(file, onFileTransmissionSatusChanged);
2014-04-22 11:11:53 +00:00
JinglePacket answer = bootstrapPacket("transport-accept");
Content content = new Content("initiator", "a-file-offer");
content.setTransportId(this.transportId);
2015-10-12 10:36:54 +00:00
content.ibbTransport().setAttribute("block-size",this.ibbBlockSize);
2014-04-22 11:11:53 +00:00
answer.setContent(content);
this.sendJinglePacket(answer);
return true;
2014-04-22 11:11:53 +00:00
}
private boolean receiveTransportAccept(JinglePacket packet) {
2014-04-22 11:11:53 +00:00
if (packet.getJingleContent().hasIbbTransport()) {
String receivedBlockSize = packet.getJingleContent().ibbTransport()
.getAttribute("block-size");
if (receivedBlockSize != null) {
2014-04-22 11:11:53 +00:00
int bs = Integer.parseInt(receivedBlockSize);
if (bs > this.ibbBlockSize) {
2014-04-22 11:11:53 +00:00
this.ibbBlockSize = bs;
}
}
2014-11-14 13:04:34 +00:00
this.transport = new JingleInbandTransport(this, this.transportId, this.ibbBlockSize);
2014-04-22 11:11:53 +00:00
this.transport.connect(new OnTransportConnected() {
2014-04-22 11:11:53 +00:00
@Override
public void failed() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG, "ibb open failed");
2014-04-22 11:11:53 +00:00
}
2014-04-22 11:11:53 +00:00
@Override
public void established() {
JingleConnection.this.transport.send(file,
onFileTransmissionSatusChanged);
2014-04-22 11:11:53 +00:00
}
});
return true;
2014-04-22 11:11:53 +00:00
} else {
return false;
2014-04-22 11:11:53 +00:00
}
}
2014-04-23 19:19:56 +00:00
private void receiveSuccess() {
this.mJingleStatus = JINGLE_STATUS_FINISHED;
this.mXmppConnectionService.markMessage(this.message,Message.STATUS_SEND_RECEIVED);
2014-11-15 11:37:09 +00:00
this.disconnectSocks5Connections();
if (this.transport != null && this.transport instanceof JingleInbandTransport) {
this.transport.disconnect();
}
2015-07-10 13:11:03 +00:00
this.message.setTransferable(null);
this.mJingleConnectionManager.finishConnection(this);
}
2014-07-03 20:55:20 +00:00
public void cancel() {
2014-11-15 11:37:09 +00:00
this.disconnectSocks5Connections();
if (this.transport != null && this.transport instanceof JingleInbandTransport) {
this.transport.disconnect();
}
this.sendCancel();
this.mJingleConnectionManager.finishConnection(this);
if (this.responder.equals(account.getJid())) {
2015-07-10 13:11:03 +00:00
this.message.setTransferable(new TransferablePlaceholder(Transferable.STATUS_FAILED));
if (this.file!=null) {
file.delete();
}
2014-11-15 11:37:09 +00:00
this.mXmppConnectionService.updateConversationUi();
} else {
this.mXmppConnectionService.markMessage(this.message,
Message.STATUS_SEND_FAILED);
2015-07-10 13:11:03 +00:00
this.message.setTransferable(null);
2014-11-15 11:37:09 +00:00
}
}
private void fail() {
this.mJingleStatus = JINGLE_STATUS_FAILED;
this.disconnectSocks5Connections();
if (this.transport != null && this.transport instanceof JingleInbandTransport) {
this.transport.disconnect();
}
FileBackend.close(mFileInputStream);
FileBackend.close(mFileOutputStream);
if (this.message != null) {
if (this.responder.equals(account.getJid())) {
2015-07-10 13:11:03 +00:00
this.message.setTransferable(new TransferablePlaceholder(Transferable.STATUS_FAILED));
if (this.file!=null) {
file.delete();
}
this.mXmppConnectionService.updateConversationUi();
} else {
2014-10-29 10:31:03 +00:00
this.mXmppConnectionService.markMessage(this.message,
Message.STATUS_SEND_FAILED);
2015-07-10 13:11:03 +00:00
this.message.setTransferable(null);
}
}
this.mJingleConnectionManager.finishConnection(this);
}
2014-04-23 19:19:56 +00:00
private void sendCancel() {
JinglePacket packet = bootstrapPacket("session-terminate");
Reason reason = new Reason();
reason.addChild("cancel");
packet.setReason(reason);
this.sendJinglePacket(packet);
}
2014-04-18 23:14:30 +00:00
private void connectNextCandidate() {
for (JingleCandidate candidate : this.candidates) {
if ((!connections.containsKey(candidate.getCid()) && (!candidate
.isOurs()))) {
this.connectWithCandidate(candidate);
2014-04-17 12:52:10 +00:00
return;
}
}
2014-04-17 12:52:10 +00:00
this.sendCandidateError();
}
2014-04-17 12:52:10 +00:00
private void connectWithCandidate(final JingleCandidate candidate) {
final JingleSocks5Transport socksConnection = new JingleSocks5Transport(
this, candidate);
2014-04-17 12:52:10 +00:00
connections.put(candidate.getCid(), socksConnection);
2014-04-22 11:11:53 +00:00
socksConnection.connect(new OnTransportConnected() {
@Override
public void failed() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
"connection failed with " + candidate.getHost() + ":"
+ candidate.getPort());
connectNextCandidate();
}
@Override
public void established() {
2014-08-31 14:28:21 +00:00
Log.d(Config.LOGTAG,
"established connection with " + candidate.getHost()
+ ":" + candidate.getPort());
2014-04-17 12:52:10 +00:00
sendCandidateUsed(candidate.getCid());
}
});
}
2014-11-15 11:37:09 +00:00
private void disconnectSocks5Connections() {
Iterator<Entry<String, JingleSocks5Transport>> it = this.connections
.entrySet().iterator();
while (it.hasNext()) {
Entry<String, JingleSocks5Transport> pairs = it.next();
pairs.getValue().disconnect();
it.remove();
}
}
private void sendProxyActivated(String cid) {
JinglePacket packet = bootstrapPacket("transport-info");
Content content = new Content(this.contentCreator, this.contentName);
content.setTransportId(this.transportId);
content.socks5transport().addChild("activated")
.setAttribute("cid", cid);
packet.setContent(content);
this.sendJinglePacket(packet);
}
private void sendCandidateUsed(final String cid) {
JinglePacket packet = bootstrapPacket("transport-info");
Content content = new Content(this.contentCreator, this.contentName);
content.setTransportId(this.transportId);
content.socks5transport().addChild("candidate-used")
.setAttribute("cid", cid);
packet.setContent(content);
this.sentCandidate = true;
if ((receivedCandidate) && (mJingleStatus == JINGLE_STATUS_ACCEPTED)) {
2014-04-19 09:58:35 +00:00
connect();
}
2014-04-21 18:39:57 +00:00
this.sendJinglePacket(packet);
2014-04-17 12:52:10 +00:00
}
2014-04-17 12:52:10 +00:00
private void sendCandidateError() {
JinglePacket packet = bootstrapPacket("transport-info");
Content content = new Content(this.contentCreator, this.contentName);
content.setTransportId(this.transportId);
2014-04-21 18:39:57 +00:00
content.socks5transport().addChild("candidate-error");
2014-04-17 12:52:10 +00:00
packet.setContent(content);
this.sentCandidate = true;
if ((receivedCandidate) && (mJingleStatus == JINGLE_STATUS_ACCEPTED)) {
2014-04-19 09:58:35 +00:00
connect();
}
2014-04-21 18:39:57 +00:00
this.sendJinglePacket(packet);
}
2014-11-06 19:10:03 +00:00
public Jid getInitiator() {
return this.initiator;
}
2014-11-06 19:10:03 +00:00
public Jid getResponder() {
return this.responder;
}
public int getJingleStatus() {
return this.mJingleStatus;
}
2014-04-17 12:52:10 +00:00
private boolean equalCandidateExists(JingleCandidate candidate) {
for (JingleCandidate c : this.candidates) {
2014-04-17 12:52:10 +00:00
if (c.equalValues(candidate)) {
return true;
}
}
return false;
}
2014-04-17 12:52:10 +00:00
private void mergeCandidate(JingleCandidate candidate) {
for (JingleCandidate c : this.candidates) {
2014-04-17 12:52:10 +00:00
if (c.equals(candidate)) {
return;
}
}
this.candidates.add(candidate);
}
2014-04-17 12:52:10 +00:00
private void mergeCandidates(List<JingleCandidate> candidates) {
for (JingleCandidate c : candidates) {
mergeCandidate(c);
}
}
2014-04-17 12:52:10 +00:00
private JingleCandidate getCandidate(String cid) {
for (JingleCandidate c : this.candidates) {
2014-04-17 12:52:10 +00:00
if (c.getCid().equals(cid)) {
return c;
}
}
return null;
}
2014-11-13 20:04:05 +00:00
public void updateProgress(int i) {
this.mProgress = i;
mXmppConnectionService.updateConversationUi();
2014-11-13 20:04:05 +00:00
}
interface OnProxyActivated {
public void success();
public void failed();
}
2014-04-22 11:11:53 +00:00
public boolean hasTransportId(String sid) {
return sid.equals(this.transportId);
}
2014-04-22 11:11:53 +00:00
public JingleTransport getTransport() {
return this.transport;
}
public boolean start() {
2014-11-15 16:09:02 +00:00
if (account.getStatus() == Account.State.ONLINE) {
if (mJingleStatus == JINGLE_STATUS_INITIATED) {
new Thread(new Runnable() {
@Override
public void run() {
sendAccept();
}
}).start();
}
return true;
} else {
return false;
}
}
@Override
public int getStatus() {
return this.mStatus;
}
@Override
public long getFileSize() {
if (this.file != null) {
return this.file.getExpectedSize();
} else {
return 0;
}
}
2014-11-13 20:04:05 +00:00
@Override
public int getProgress() {
return this.mProgress;
}
public AbstractConnectionManager getConnectionManager() {
return this.mJingleConnectionManager;
}
}