HostAddressPort BoostConnectionServer::getAddressPort() const {
if (acceptor_) {
return HostAddressPort(acceptor_->local_endpoint());
}
else {
return HostAddressPort();
}
}
void LocalJingleTransportCandidateGenerator::emitOnLocalTransportCandidatesGenerated() {
std::vector<JingleS5BTransportPayload::Candidate> candidates;
if (options_.isDirectAllowed()) {
// get direct candidates
std::vector<HostAddressPort> directCandidates = s5bServerManager->getHostAddressPorts();
for(auto&& addressPort : directCandidates) {
if (addressPort.getAddress().getRawAddress().is_v6() &&
addressPort.getAddress().getRawAddress().to_v6().is_link_local()) {
continue;
}
JingleS5BTransportPayload::Candidate candidate;
candidate.type = JingleS5BTransportPayload::Candidate::DirectType;
candidate.jid = ownJID;
candidate.hostPort = addressPort;
candidate.priority = 65536 * 126 + LOCAL_PREFERENCE;
candidate.cid = idGenerator->generateID();
candidates.push_back(candidate);
}
}
if (options_.isAssistedAllowed()) {
// get assissted candidates
std::vector<HostAddressPort> assisstedCandidates = s5bServerManager->getAssistedHostAddressPorts();
for (auto&& addressPort : assisstedCandidates) {
JingleS5BTransportPayload::Candidate candidate;
candidate.type = JingleS5BTransportPayload::Candidate::AssistedType;
candidate.jid = ownJID;
candidate.hostPort = addressPort;
candidate.priority = 65536 * 120 + LOCAL_PREFERENCE;
candidate.cid = idGenerator->generateID();
candidates.push_back(candidate);
}
}
if (options_.isProxiedAllowed() && s5bProxy->getOrDiscoverS5BProxies().is_initialized()) {
for (auto&& proxy : s5bProxy->getOrDiscoverS5BProxies().get()) {
if (proxy->getStreamHost()) { // FIXME: Added this test, because there were cases where this wasn't initialized. Investigate this. (Remko)
JingleS5BTransportPayload::Candidate candidate;
candidate.type = JingleS5BTransportPayload::Candidate::ProxyType;
candidate.jid = (*proxy->getStreamHost()).jid;
auto address = HostAddress::fromString((*proxy->getStreamHost()).host);
if (address) {
candidate.hostPort = HostAddressPort(address.get(), (*proxy->getStreamHost()).port);
candidate.priority = 65536 * 10 + LOCAL_PREFERENCE;
candidate.cid = idGenerator->generateID();
candidates.push_back(candidate);
}
}
}
}
onLocalTransportCandidatesGenerated(candidates);
}
void LinkLocalConnector::handleHostnameResolved(const boost::optional<HostAddress>& address) {
resolveQuery->finish();
resolveQueryHostNameResolvedConnection.disconnect();
resolveQuery.reset();
if (address) {
connectionConnectFinishedConnection = connection->onConnectFinished.connect(
boost::bind(&LinkLocalConnector::handleConnected, shared_from_this(), _1));
connection->connect(HostAddressPort(*address, service.getPort()));
}
else {
onConnectFinished(true);
}
}
HostAddressPort UnixProxyProvider::getHTTPConnectProxy() const {
HostAddressPort proxy;
#if defined(HAVE_GCONF)
proxy = gconfProxyProvider->getHTTPConnectProxy();
if(proxy.isValid()) {
return proxy;
}
#endif
proxy = environmentProxyProvider.getHTTPConnectProxy();
if(proxy.isValid()) {
return proxy;
}
return HostAddressPort(HostAddress(), 0);
}
void JingleS5BTransportMethodPayloadParser::handleStartElement(const std::string& element, const std::string&, const AttributeMap& attributes) {
if (level == 0) {
getPayloadInternal()->setSessionID(attributes.getAttributeValue("sid").get_value_or(""));
std::string mode = attributes.getAttributeValue("mode").get_value_or("tcp");
if (mode == "tcp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
} else if(mode == "udp") {
getPayloadInternal()->setMode(JingleS5BTransportPayload::UDPMode);
} else {
SWIFT_LOG(warning) << "Unknown S5B mode; falling back to defaul!";
getPayloadInternal()->setMode(JingleS5BTransportPayload::TCPMode);
}
getPayloadInternal()->setDstAddr(attributes.getAttributeValue("dstaddr").get_value_or(""));
} else if (level == 1) {
if (element == "candidate") {
JingleS5BTransportPayload::Candidate candidate;
candidate.cid = attributes.getAttributeValue("cid").get_value_or("");
int port = -1;
try {
port = boost::lexical_cast<int>(attributes.getAttributeValue("port").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.hostPort = HostAddressPort(HostAddress(attributes.getAttributeValue("host").get_value_or("")), port);
candidate.jid = JID(attributes.getAttributeValue("jid").get_value_or(""));
int priority = -1;
try {
priority = boost::lexical_cast<int>(attributes.getAttributeValue("priority").get_value_or("-1"));
} catch(boost::bad_lexical_cast &) { }
candidate.priority = priority;
candidate.type = stringToType(attributes.getAttributeValue("type").get_value_or("direct"));
getPayloadInternal()->addCandidate(candidate);
} else if (element == "candidate-used") {
getPayloadInternal()->setCandidateUsed(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "candidate-error") {
getPayloadInternal()->setCandidateError(true);
} else if (element == "activated") {
getPayloadInternal()->setActivated(attributes.getAttributeValue("cid").get_value_or(""));
} else if (element == "proxy-error") {
getPayloadInternal()->setProxyError(true);
}
}
++level;
}
void Connector::tryNextAddress() {
if (addressQueryResults.empty()) {
SWIFT_LOG(debug) << "Done trying addresses. Moving on." << std::endl;
// Done trying all addresses. Move on to the next host.
if (!serviceQueryResults.empty()) {
serviceQueryResults.pop_front();
}
tryNextServiceOrFallback();
}
else {
SWIFT_LOG(debug) << "Trying next address" << std::endl;
HostAddress address = addressQueryResults.front();
addressQueryResults.pop_front();
int connectPort = (port == -1 ? 5222 : port);
if (!serviceQueryResults.empty()) {
connectPort = serviceQueryResults.front().port;
}
tryConnect(HostAddressPort(address, connectPort));
}
}
HostAddressPort BoostConnection::getLocalAddress() const {
return HostAddressPort(socket_.local_endpoint());
}
