362 lines
16 KiB
Java
362 lines
16 KiB
Java
/**
|
|
*
|
|
* Copyright 2017 Paul Schaub
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.jivesoftware.smackx.jingle.transports.jingle_s5b;
|
|
|
|
import java.io.IOException;
|
|
import java.net.InetAddress;
|
|
import java.net.Socket;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.concurrent.TimeoutException;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.jivesoftware.smack.SmackException;
|
|
import org.jivesoftware.smack.XMPPException;
|
|
import org.jivesoftware.smack.packet.IQ;
|
|
|
|
import org.jivesoftware.smackx.bytestreams.socks5.Socks5BytestreamSession;
|
|
import org.jivesoftware.smackx.bytestreams.socks5.Socks5Client;
|
|
import org.jivesoftware.smackx.bytestreams.socks5.Socks5ClientForInitiator;
|
|
import org.jivesoftware.smackx.bytestreams.socks5.Socks5Proxy;
|
|
import org.jivesoftware.smackx.bytestreams.socks5.Socks5Utils;
|
|
import org.jivesoftware.smackx.bytestreams.socks5.packet.Bytestream;
|
|
import org.jivesoftware.smackx.jingle.JingleManager;
|
|
import org.jivesoftware.smackx.jingle.JingleSession;
|
|
import org.jivesoftware.smackx.jingle.element.Jingle;
|
|
import org.jivesoftware.smackx.jingle.element.JingleContent;
|
|
import org.jivesoftware.smackx.jingle.element.JingleContentTransport;
|
|
import org.jivesoftware.smackx.jingle.element.JingleContentTransportCandidate;
|
|
import org.jivesoftware.smackx.jingle.transports.JingleTransportInitiationCallback;
|
|
import org.jivesoftware.smackx.jingle.transports.JingleTransportSession;
|
|
import org.jivesoftware.smackx.jingle.transports.jingle_s5b.elements.JingleS5BTransport;
|
|
import org.jivesoftware.smackx.jingle.transports.jingle_s5b.elements.JingleS5BTransportCandidate;
|
|
import org.jivesoftware.smackx.jingle.transports.jingle_s5b.elements.JingleS5BTransportInfo;
|
|
|
|
/**
|
|
* Handler that handles Jingle Socks5Bytestream transports (XEP-0260).
|
|
*/
|
|
public class JingleS5BTransportSession extends JingleTransportSession<JingleS5BTransport> {
|
|
private static final Logger LOGGER = Logger.getLogger(JingleS5BTransportSession.class.getName());
|
|
|
|
private JingleTransportInitiationCallback callback;
|
|
|
|
public JingleS5BTransportSession(JingleSession jingleSession) {
|
|
super(jingleSession);
|
|
}
|
|
|
|
private UsedCandidate ourChoice, theirChoice;
|
|
|
|
@Override
|
|
public JingleS5BTransport createTransport() {
|
|
if (ourProposal == null) {
|
|
ourProposal = createTransport(JingleManager.randomId(), Bytestream.Mode.tcp);
|
|
}
|
|
return ourProposal;
|
|
}
|
|
|
|
@Override
|
|
public void setTheirProposal(JingleContentTransport transport) {
|
|
theirProposal = (JingleS5BTransport) transport;
|
|
}
|
|
|
|
public JingleS5BTransport createTransport(String sid, Bytestream.Mode mode) {
|
|
JingleS5BTransport.Builder jb = JingleS5BTransport.getBuilder()
|
|
.setStreamId(sid).setMode(mode).setDestinationAddress(
|
|
Socks5Utils.createDigest(sid, jingleSession.getLocal(), jingleSession.getRemote()));
|
|
|
|
// Local host
|
|
if (JingleS5BTransportManager.isUseLocalCandidates()) {
|
|
for (Bytestream.StreamHost host : transportManager().getLocalStreamHosts()) {
|
|
jb.addTransportCandidate(new JingleS5BTransportCandidate(host, 100, JingleS5BTransportCandidate.Type.direct));
|
|
}
|
|
}
|
|
|
|
List<Bytestream.StreamHost> remoteHosts = Collections.emptyList();
|
|
if (JingleS5BTransportManager.isUseExternalCandidates()) {
|
|
try {
|
|
remoteHosts = transportManager().getAvailableStreamHosts();
|
|
} catch (InterruptedException | XMPPException.XMPPErrorException | SmackException.NotConnectedException | SmackException.NoResponseException e) {
|
|
LOGGER.log(Level.WARNING, "Could not determine available StreamHosts.", e);
|
|
}
|
|
}
|
|
|
|
for (Bytestream.StreamHost host : remoteHosts) {
|
|
jb.addTransportCandidate(new JingleS5BTransportCandidate(host, 0, JingleS5BTransportCandidate.Type.proxy));
|
|
}
|
|
|
|
return jb.build();
|
|
}
|
|
|
|
public void setTheirTransport(JingleContentTransport transport) {
|
|
theirProposal = (JingleS5BTransport) transport;
|
|
}
|
|
|
|
@Override
|
|
public void initiateOutgoingSession(JingleTransportInitiationCallback callback) {
|
|
this.callback = callback;
|
|
initiateSession();
|
|
}
|
|
|
|
@Override
|
|
public void initiateIncomingSession(JingleTransportInitiationCallback callback) {
|
|
this.callback = callback;
|
|
initiateSession();
|
|
}
|
|
|
|
private void initiateSession() {
|
|
Socks5Proxy.getSocks5Proxy().addTransfer(createTransport().getDestinationAddress());
|
|
JingleContent content = jingleSession.getContents().get(0);
|
|
UsedCandidate usedCandidate = chooseFromProposedCandidates(theirProposal);
|
|
if (usedCandidate == null) {
|
|
ourChoice = CANDIDATE_FAILURE;
|
|
Jingle candidateError = transportManager().createCandidateError(
|
|
jingleSession.getRemote(), jingleSession.getInitiator(), jingleSession.getSessionId(),
|
|
content.getSenders(), content.getCreator(), content.getName(), theirProposal.getStreamId());
|
|
try {
|
|
jingleSession.getConnection().sendStanza(candidateError);
|
|
} catch (SmackException.NotConnectedException | InterruptedException e) {
|
|
LOGGER.log(Level.WARNING, "Could not send candidate-error.", e);
|
|
}
|
|
} else {
|
|
ourChoice = usedCandidate;
|
|
Jingle jingle = transportManager().createCandidateUsed(jingleSession.getRemote(), jingleSession.getInitiator(), jingleSession.getSessionId(),
|
|
content.getSenders(), content.getCreator(), content.getName(), theirProposal.getStreamId(), ourChoice.candidate.getCandidateId());
|
|
try {
|
|
jingleSession.getConnection().sendIqRequestAndWaitForResponse(jingle);
|
|
} catch (InterruptedException | XMPPException.XMPPErrorException | SmackException.NotConnectedException | SmackException.NoResponseException e) {
|
|
LOGGER.log(Level.WARNING, "Could not send candidate-used.", e);
|
|
}
|
|
}
|
|
connectIfReady();
|
|
}
|
|
|
|
private UsedCandidate chooseFromProposedCandidates(JingleS5BTransport proposal) {
|
|
for (JingleContentTransportCandidate c : proposal.getCandidates()) {
|
|
JingleS5BTransportCandidate candidate = (JingleS5BTransportCandidate) c;
|
|
|
|
try {
|
|
return connectToTheirCandidate(candidate);
|
|
} catch (InterruptedException | TimeoutException | XMPPException | SmackException | IOException e) {
|
|
LOGGER.log(Level.WARNING, "Could not connect to " + candidate.getHost(), e);
|
|
}
|
|
}
|
|
LOGGER.log(Level.WARNING, "Failed to connect to any candidate.");
|
|
return null;
|
|
}
|
|
|
|
private UsedCandidate connectToTheirCandidate(JingleS5BTransportCandidate candidate)
|
|
throws InterruptedException, TimeoutException, SmackException, XMPPException, IOException {
|
|
Bytestream.StreamHost streamHost = candidate.getStreamHost();
|
|
InetAddress address = streamHost.getAddress().asInetAddress();
|
|
Socks5Client socks5Client = new Socks5Client(streamHost, theirProposal.getDestinationAddress());
|
|
Socket socket = socks5Client.getSocket(10 * 1000);
|
|
LOGGER.log(Level.INFO, "Connected to their StreamHost " + address + " using dstAddr "
|
|
+ theirProposal.getDestinationAddress());
|
|
return new UsedCandidate(theirProposal, candidate, socket);
|
|
}
|
|
|
|
private UsedCandidate connectToOurCandidate(JingleS5BTransportCandidate candidate)
|
|
throws InterruptedException, TimeoutException, SmackException, XMPPException, IOException {
|
|
Bytestream.StreamHost streamHost = candidate.getStreamHost();
|
|
InetAddress address = streamHost.getAddress().asInetAddress();
|
|
Socks5ClientForInitiator socks5Client = new Socks5ClientForInitiator(
|
|
streamHost, ourProposal.getDestinationAddress(), jingleSession.getConnection(),
|
|
ourProposal.getStreamId(), jingleSession.getRemote());
|
|
Socket socket = socks5Client.getSocket(10 * 1000);
|
|
LOGGER.log(Level.INFO, "Connected to our StreamHost " + address + " using dstAddr "
|
|
+ ourProposal.getDestinationAddress());
|
|
return new UsedCandidate(ourProposal, candidate, socket);
|
|
}
|
|
|
|
@Override
|
|
public String getNamespace() {
|
|
return JingleS5BTransport.NAMESPACE_V1;
|
|
}
|
|
|
|
@Override
|
|
public IQ handleTransportInfo(Jingle transportInfo) {
|
|
JingleS5BTransportInfo info = (JingleS5BTransportInfo) transportInfo.getContents().get(0).getTransport().getInfo();
|
|
|
|
switch (info.getElementName()) {
|
|
case JingleS5BTransportInfo.CandidateUsed.ELEMENT:
|
|
return handleCandidateUsed(transportInfo);
|
|
|
|
case JingleS5BTransportInfo.CandidateActivated.ELEMENT:
|
|
return handleCandidateActivate(transportInfo);
|
|
|
|
case JingleS5BTransportInfo.CandidateError.ELEMENT:
|
|
return handleCandidateError(transportInfo);
|
|
|
|
case JingleS5BTransportInfo.ProxyError.ELEMENT:
|
|
return handleProxyError(transportInfo);
|
|
}
|
|
// We should never go here, but lets be gracious...
|
|
return IQ.createResultIQ(transportInfo);
|
|
}
|
|
|
|
public IQ handleCandidateUsed(Jingle jingle) {
|
|
JingleS5BTransportInfo info = (JingleS5BTransportInfo) jingle.getContents().get(0).getTransport().getInfo();
|
|
String candidateId = ((JingleS5BTransportInfo.CandidateUsed) info).getCandidateId();
|
|
theirChoice = new UsedCandidate(ourProposal, ourProposal.getCandidate(candidateId), null);
|
|
|
|
if (theirChoice.candidate == null) {
|
|
/*
|
|
TODO: Booooooh illegal candidateId!! Go home!!!!11elf
|
|
*/
|
|
}
|
|
|
|
connectIfReady();
|
|
|
|
return IQ.createResultIQ(jingle);
|
|
}
|
|
|
|
public IQ handleCandidateActivate(Jingle jingle) {
|
|
LOGGER.log(Level.INFO, "handleCandidateActivate");
|
|
Socks5BytestreamSession bs = new Socks5BytestreamSession(ourChoice.socket,
|
|
ourChoice.candidate.getJid().asBareJid().equals(jingleSession.getRemote().asBareJid()));
|
|
callback.onSessionInitiated(bs);
|
|
return IQ.createResultIQ(jingle);
|
|
}
|
|
|
|
public IQ handleCandidateError(Jingle jingle) {
|
|
theirChoice = CANDIDATE_FAILURE;
|
|
connectIfReady();
|
|
return IQ.createResultIQ(jingle);
|
|
}
|
|
|
|
public IQ handleProxyError(Jingle jingle) {
|
|
// TODO
|
|
return IQ.createResultIQ(jingle);
|
|
}
|
|
|
|
/**
|
|
* Determine, which candidate (ours/theirs) is the nominated one.
|
|
* Connect to this candidate. If it is a proxy and it is ours, activate it and connect.
|
|
* If its a proxy and it is theirs, wait for activation.
|
|
* If it is not a proxy, just connect.
|
|
*/
|
|
private void connectIfReady() {
|
|
JingleContent content = jingleSession.getContents().get(0);
|
|
if (ourChoice == null || theirChoice == null) {
|
|
// Not yet ready.
|
|
LOGGER.log(Level.INFO, "Not ready.");
|
|
return;
|
|
}
|
|
|
|
if (ourChoice == CANDIDATE_FAILURE && theirChoice == CANDIDATE_FAILURE) {
|
|
LOGGER.log(Level.INFO, "Failure.");
|
|
jingleSession.onTransportMethodFailed(getNamespace());
|
|
return;
|
|
}
|
|
|
|
LOGGER.log(Level.INFO, "Ready.");
|
|
|
|
// Determine nominated candidate.
|
|
UsedCandidate nominated;
|
|
if (ourChoice != CANDIDATE_FAILURE && theirChoice != CANDIDATE_FAILURE) {
|
|
if (ourChoice.candidate.getPriority() > theirChoice.candidate.getPriority()) {
|
|
nominated = ourChoice;
|
|
} else if (ourChoice.candidate.getPriority() < theirChoice.candidate.getPriority()) {
|
|
nominated = theirChoice;
|
|
} else {
|
|
nominated = jingleSession.isInitiator() ? ourChoice : theirChoice;
|
|
}
|
|
} else if (ourChoice != CANDIDATE_FAILURE) {
|
|
nominated = ourChoice;
|
|
} else {
|
|
nominated = theirChoice;
|
|
}
|
|
|
|
if (nominated == theirChoice) {
|
|
LOGGER.log(Level.INFO, "Their choice, so our proposed candidate is used.");
|
|
boolean isProxy = nominated.candidate.getType() == JingleS5BTransportCandidate.Type.proxy;
|
|
try {
|
|
nominated = connectToOurCandidate(nominated.candidate);
|
|
} catch (InterruptedException | IOException | XMPPException | SmackException | TimeoutException e) {
|
|
LOGGER.log(Level.INFO, "Could not connect to our candidate.", e);
|
|
// TODO: Proxy-Error
|
|
return;
|
|
}
|
|
|
|
if (isProxy) {
|
|
LOGGER.log(Level.INFO, "Is external proxy. Activate it.");
|
|
Bytestream activate = new Bytestream(ourProposal.getStreamId());
|
|
activate.setMode(null);
|
|
activate.setType(IQ.Type.set);
|
|
activate.setTo(nominated.candidate.getJid());
|
|
activate.setToActivate(jingleSession.getRemote());
|
|
activate.setFrom(jingleSession.getLocal());
|
|
try {
|
|
jingleSession.getConnection().sendIqRequestAndWaitForResponse(activate);
|
|
} catch (InterruptedException | XMPPException.XMPPErrorException | SmackException.NotConnectedException | SmackException.NoResponseException e) {
|
|
LOGGER.log(Level.WARNING, "Could not activate proxy.", e);
|
|
return;
|
|
}
|
|
|
|
LOGGER.log(Level.INFO, "Send candidate-activate.");
|
|
Jingle candidateActivate = transportManager().createCandidateActivated(
|
|
jingleSession.getRemote(), jingleSession.getInitiator(), jingleSession.getSessionId(),
|
|
content.getSenders(), content.getCreator(), content.getName(), nominated.transport.getStreamId(),
|
|
nominated.candidate.getCandidateId());
|
|
try {
|
|
jingleSession.getConnection().sendIqRequestAndWaitForResponse(candidateActivate);
|
|
} catch (InterruptedException | XMPPException.XMPPErrorException | SmackException.NotConnectedException | SmackException.NoResponseException e) {
|
|
LOGGER.log(Level.WARNING, "Could not send candidate-activated", e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
LOGGER.log(Level.INFO, "Start transmission.");
|
|
Socks5BytestreamSession bs = new Socks5BytestreamSession(nominated.socket, !isProxy);
|
|
callback.onSessionInitiated(bs);
|
|
|
|
}
|
|
// Our choice
|
|
else {
|
|
LOGGER.log(Level.INFO, "Our choice, so their candidate was used.");
|
|
boolean isProxy = nominated.candidate.getType() == JingleS5BTransportCandidate.Type.proxy;
|
|
if (!isProxy) {
|
|
LOGGER.log(Level.INFO, "Direct connection.");
|
|
Socks5BytestreamSession bs = new Socks5BytestreamSession(nominated.socket, true);
|
|
callback.onSessionInitiated(bs);
|
|
} else {
|
|
LOGGER.log(Level.INFO, "Our choice was their external proxy. wait for candidate-activate.");
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public JingleS5BTransportManager transportManager() {
|
|
return JingleS5BTransportManager.getInstanceFor(jingleSession.getConnection());
|
|
}
|
|
|
|
private static final class UsedCandidate {
|
|
private final Socket socket;
|
|
private final JingleS5BTransport transport;
|
|
private final JingleS5BTransportCandidate candidate;
|
|
|
|
private UsedCandidate(JingleS5BTransport transport, JingleS5BTransportCandidate candidate, Socket socket) {
|
|
this.socket = socket;
|
|
this.transport = transport;
|
|
this.candidate = candidate;
|
|
}
|
|
}
|
|
|
|
private static final UsedCandidate CANDIDATE_FAILURE = new UsedCandidate(null, null, null);
|
|
}
|