223 lines
7.2 KiB
C++
223 lines
7.2 KiB
C++
/*
|
|
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "webrtc/p2p/client/httpportallocator.h"
|
|
|
|
#include <algorithm>
|
|
#include <map>
|
|
|
|
#include "webrtc/base/common.h"
|
|
#include "webrtc/base/helpers.h"
|
|
#include "webrtc/base/httpcommon.h"
|
|
#include "webrtc/base/logging.h"
|
|
#include "webrtc/base/nethelpers.h"
|
|
#include "webrtc/base/signalthread.h"
|
|
#include "webrtc/base/stringencode.h"
|
|
|
|
namespace {
|
|
|
|
// Helper routine to remove whitespace from the ends of a string.
|
|
void Trim(std::string& str) {
|
|
size_t first = str.find_first_not_of(" \t\r\n");
|
|
if (first == std::string::npos) {
|
|
str.clear();
|
|
return;
|
|
}
|
|
|
|
ASSERT(str.find_last_not_of(" \t\r\n") != std::string::npos);
|
|
}
|
|
|
|
// Parses the lines in the result of the HTTP request that are of the form
|
|
// 'a=b' and returns them in a map.
|
|
typedef std::map<std::string, std::string> StringMap;
|
|
void ParseMap(const std::string& string, StringMap& map) {
|
|
size_t start_of_line = 0;
|
|
size_t end_of_line = 0;
|
|
|
|
for (;;) { // for each line
|
|
start_of_line = string.find_first_not_of("\r\n", end_of_line);
|
|
if (start_of_line == std::string::npos)
|
|
break;
|
|
|
|
end_of_line = string.find_first_of("\r\n", start_of_line);
|
|
if (end_of_line == std::string::npos) {
|
|
end_of_line = string.length();
|
|
}
|
|
|
|
size_t equals = string.find('=', start_of_line);
|
|
if ((equals >= end_of_line) || (equals == std::string::npos))
|
|
continue;
|
|
|
|
std::string key(string, start_of_line, equals - start_of_line);
|
|
std::string value(string, equals + 1, end_of_line - equals - 1);
|
|
|
|
Trim(key);
|
|
Trim(value);
|
|
|
|
if ((key.size() > 0) && (value.size() > 0))
|
|
map[key] = value;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace cricket {
|
|
|
|
// HttpPortAllocatorBase
|
|
|
|
const int HttpPortAllocatorBase::kNumRetries = 5;
|
|
|
|
const char HttpPortAllocatorBase::kCreateSessionURL[] = "/create_session";
|
|
|
|
HttpPortAllocatorBase::HttpPortAllocatorBase(
|
|
rtc::NetworkManager* network_manager,
|
|
rtc::PacketSocketFactory* socket_factory,
|
|
const std::string &user_agent)
|
|
: BasicPortAllocator(network_manager, socket_factory), agent_(user_agent) {
|
|
relay_hosts_.push_back("relay.google.com");
|
|
stun_hosts_.push_back(
|
|
rtc::SocketAddress("stun.l.google.com", 19302));
|
|
}
|
|
|
|
HttpPortAllocatorBase::HttpPortAllocatorBase(
|
|
rtc::NetworkManager* network_manager,
|
|
const std::string &user_agent)
|
|
: BasicPortAllocator(network_manager), agent_(user_agent) {
|
|
relay_hosts_.push_back("relay.google.com");
|
|
stun_hosts_.push_back(
|
|
rtc::SocketAddress("stun.l.google.com", 19302));
|
|
}
|
|
|
|
HttpPortAllocatorBase::~HttpPortAllocatorBase() {
|
|
}
|
|
|
|
// HttpPortAllocatorSessionBase
|
|
|
|
HttpPortAllocatorSessionBase::HttpPortAllocatorSessionBase(
|
|
HttpPortAllocatorBase* allocator,
|
|
const std::string& content_name,
|
|
int component,
|
|
const std::string& ice_ufrag,
|
|
const std::string& ice_pwd,
|
|
const std::vector<rtc::SocketAddress>& stun_hosts,
|
|
const std::vector<std::string>& relay_hosts,
|
|
const std::string& relay_token,
|
|
const std::string& user_agent)
|
|
: BasicPortAllocatorSession(allocator, content_name, component,
|
|
ice_ufrag, ice_pwd),
|
|
relay_hosts_(relay_hosts), stun_hosts_(stun_hosts),
|
|
relay_token_(relay_token), agent_(user_agent), attempts_(0) {
|
|
}
|
|
|
|
HttpPortAllocatorSessionBase::~HttpPortAllocatorSessionBase() {}
|
|
|
|
void HttpPortAllocatorSessionBase::GetPortConfigurations() {
|
|
// Creating relay sessions can take time and is done asynchronously.
|
|
// Creating stun sessions could also take time and could be done aysnc also,
|
|
// but for now is done here and added to the initial config. Note any later
|
|
// configs will have unresolved stun ips and will be discarded by the
|
|
// AllocationSequence.
|
|
ServerAddresses hosts;
|
|
for (std::vector<rtc::SocketAddress>::iterator it = stun_hosts_.begin();
|
|
it != stun_hosts_.end(); ++it) {
|
|
hosts.insert(*it);
|
|
}
|
|
|
|
PortConfiguration* config = new PortConfiguration(hosts,
|
|
username(),
|
|
password());
|
|
ConfigReady(config);
|
|
TryCreateRelaySession();
|
|
}
|
|
|
|
void HttpPortAllocatorSessionBase::TryCreateRelaySession() {
|
|
if (allocator()->flags() & PORTALLOCATOR_DISABLE_RELAY) {
|
|
LOG(LS_VERBOSE) << "HttpPortAllocator: Relay ports disabled, skipping.";
|
|
return;
|
|
}
|
|
|
|
if (attempts_ == HttpPortAllocatorBase::kNumRetries) {
|
|
LOG(LS_ERROR) << "HttpPortAllocator: maximum number of requests reached; "
|
|
<< "giving up on relay.";
|
|
return;
|
|
}
|
|
|
|
if (relay_hosts_.size() == 0) {
|
|
LOG(LS_ERROR) << "HttpPortAllocator: no relay hosts configured.";
|
|
return;
|
|
}
|
|
|
|
// Choose the next host to try.
|
|
std::string host = relay_hosts_[attempts_ % relay_hosts_.size()];
|
|
attempts_++;
|
|
LOG(LS_INFO) << "HTTPPortAllocator: sending to relay host " << host;
|
|
if (relay_token_.empty()) {
|
|
LOG(LS_WARNING) << "No relay auth token found.";
|
|
}
|
|
|
|
SendSessionRequest(host, rtc::HTTP_SECURE_PORT);
|
|
}
|
|
|
|
std::string HttpPortAllocatorSessionBase::GetSessionRequestUrl() {
|
|
std::string url = std::string(HttpPortAllocatorBase::kCreateSessionURL);
|
|
ASSERT(!username().empty());
|
|
ASSERT(!password().empty());
|
|
url = url + "?username=" + rtc::s_url_encode(username()) +
|
|
"&password=" + rtc::s_url_encode(password());
|
|
return url;
|
|
}
|
|
|
|
void HttpPortAllocatorSessionBase::ReceiveSessionResponse(
|
|
const std::string& response) {
|
|
|
|
StringMap map;
|
|
ParseMap(response, map);
|
|
|
|
if (!username().empty() && map["username"] != username()) {
|
|
LOG(LS_WARNING) << "Received unexpected username value from relay server.";
|
|
}
|
|
if (!password().empty() && map["password"] != password()) {
|
|
LOG(LS_WARNING) << "Received unexpected password value from relay server.";
|
|
}
|
|
|
|
std::string relay_ip = map["relay.ip"];
|
|
std::string relay_udp_port = map["relay.udp_port"];
|
|
std::string relay_tcp_port = map["relay.tcp_port"];
|
|
std::string relay_ssltcp_port = map["relay.ssltcp_port"];
|
|
|
|
ServerAddresses hosts;
|
|
for (std::vector<rtc::SocketAddress>::iterator it = stun_hosts_.begin();
|
|
it != stun_hosts_.end(); ++it) {
|
|
hosts.insert(*it);
|
|
}
|
|
|
|
PortConfiguration* config = new PortConfiguration(hosts,
|
|
map["username"],
|
|
map["password"]);
|
|
|
|
RelayServerConfig relay_config(RELAY_GTURN);
|
|
if (!relay_udp_port.empty()) {
|
|
rtc::SocketAddress address(relay_ip, atoi(relay_udp_port.c_str()));
|
|
relay_config.ports.push_back(ProtocolAddress(address, PROTO_UDP));
|
|
}
|
|
if (!relay_tcp_port.empty()) {
|
|
rtc::SocketAddress address(relay_ip, atoi(relay_tcp_port.c_str()));
|
|
relay_config.ports.push_back(ProtocolAddress(address, PROTO_TCP));
|
|
}
|
|
if (!relay_ssltcp_port.empty()) {
|
|
rtc::SocketAddress address(relay_ip, atoi(relay_ssltcp_port.c_str()));
|
|
relay_config.ports.push_back(ProtocolAddress(address, PROTO_SSLTCP));
|
|
}
|
|
config->AddRelay(relay_config);
|
|
ConfigReady(config);
|
|
}
|
|
|
|
} // namespace cricket
|