blob: dbb67c61674ebbb22f93d4cb65e93095823c58d7 [file] [log] [blame]
* Copyright 2015 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 <set>
#include <string>
#include <vector>
#include "webrtc/base/asyncinvoker.h"
#include "webrtc/base/basictypes.h"
#include "webrtc/base/bytebuffer.h"
#include "webrtc/base/callback.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/ipaddress.h"
#include "webrtc/base/network.h"
#include "webrtc/base/socketaddress.h"
#include "webrtc/base/thread.h"
#include "webrtc/base/thread_checker.h"
#include "webrtc/typedefs.h"
namespace rtc {
class AsyncPacketSocket;
class PacketSocketFactory;
class Thread;
class NetworkManager;
class AsyncResolverInterface;
} // namespace rtc
namespace stunprober {
class StunProber;
static const int kMaxUdpBufferSize = 1200;
typedef rtc::Callback2<void, StunProber*, int> AsyncCallback;
enum NatType {
NATTYPE_NONE, // Not behind a NAT.
NATTYPE_UNKNOWN, // Behind a NAT but type can't be determine.
NATTYPE_SYMMETRIC, // Behind a symmetric NAT.
NATTYPE_NON_SYMMETRIC // Behind a non-symmetric NAT.
class StunProber : public sigslot::has_slots<> {
enum Status { // Used in UMA_HISTOGRAM_ENUMERATION.
SUCCESS, // Successfully received bytes from the server.
GENERIC_FAILURE, // Generic failure.
RESOLVE_FAILED, // Host resolution failed.
WRITE_FAILED, // Sending a message to the server failed.
READ_FAILED, // Reading the reply from the server failed.
class Observer {
virtual ~Observer() = default;
virtual void OnPrepared(StunProber* prober, StunProber::Status status) = 0;
virtual void OnFinished(StunProber* prober, StunProber::Status status) = 0;
struct Stats {
Stats() {}
// |raw_num_request_sent| is the total number of requests
// sent. |num_request_sent| is the count of requests against a server where
// we see at least one response. |num_request_sent| is designed to protect
// against DNS resolution failure or the STUN server is not responsive
// which could skew the result.
int raw_num_request_sent = 0;
int num_request_sent = 0;
int num_response_received = 0;
NatType nat_type = NATTYPE_INVALID;
int average_rtt_ms = -1;
int success_percent = 0;
int target_request_interval_ns = 0;
int actual_request_interval_ns = 0;
// Also report whether this trial can't be considered truly as shared
// mode. Share mode only makes sense when we have multiple IP resolved and
// successfully probed.
bool shared_socket_mode = false;
std::string host_ip;
// If the srflx_addrs has more than 1 element, the NAT is symmetric.
std::set<std::string> srflx_addrs;
StunProber(rtc::PacketSocketFactory* socket_factory,
rtc::Thread* thread,
const rtc::NetworkManager::NetworkList& networks);
virtual ~StunProber();
// Begin performing the probe test against the |servers|. If
// |shared_socket_mode| is false, each request will be done with a new socket.
// Otherwise, a unique socket will be used for a single round of requests
// against all resolved IPs. No single socket will be used against a given IP
// more than once. The interval of requests will be as close to the requested
// inter-probe interval |stun_ta_interval_ms| as possible. After sending out
// the last scheduled request, the probe will wait |timeout_ms| for request
// responses and then call |finish_callback|. |requests_per_ip| indicates how
// many requests should be tried for each resolved IP address. In shared mode,
// (the number of sockets to be created) equals to |requests_per_ip|. In
// non-shared mode, (the number of sockets) equals to requests_per_ip * (the
// number of resolved IP addresses). TODO(guoweis): Remove this once
// everything moved to Prepare() and Run().
bool Start(const std::vector<rtc::SocketAddress>& servers,
bool shared_socket_mode,
int stun_ta_interval_ms,
int requests_per_ip,
int timeout_ms,
const AsyncCallback finish_callback);
// TODO(guoweis): The combination of Prepare() and Run() are equivalent to the
// Start() above. Remove Start() once everything is migrated.
bool Prepare(const std::vector<rtc::SocketAddress>& servers,
bool shared_socket_mode,
int stun_ta_interval_ms,
int requests_per_ip,
int timeout_ms,
StunProber::Observer* observer);
// Start to send out the STUN probes.
bool Start(StunProber::Observer* observer);
// Method to retrieve the Stats once |finish_callback| is invoked. Returning
// false when the result is inconclusive, for example, whether it's behind a
// NAT or not.
bool GetStats(Stats* stats) const;
int estimated_execution_time() {
return static_cast<int>(requests_per_ip_ * all_servers_addrs_.size() *
// A requester tracks the requests and responses from a single socket to many
// STUN servers.
class Requester;
// TODO(guoweis): Remove this once all dependencies move away from
// AsyncCallback.
class ObserverAdapter : public Observer {
void set_callback(AsyncCallback callback) { callback_ = callback; }
void OnPrepared(StunProber* stunprober, Status status) {
if (status == SUCCESS) {
} else {
callback_(stunprober, status);
void OnFinished(StunProber* stunprober, Status status) {
callback_(stunprober, status);
AsyncCallback callback_;
bool ResolveServerName(const rtc::SocketAddress& addr);
void OnServerResolved(rtc::AsyncResolverInterface* resolver);
void OnSocketReady(rtc::AsyncPacketSocket* socket,
const rtc::SocketAddress& addr);
bool Done() {
return num_request_sent_ >= requests_per_ip_ * all_servers_addrs_.size();
size_t total_socket_required() {
return (shared_socket_mode_ ? 1 : all_servers_addrs_.size()) *
bool should_send_next_request(int64_t now);
int get_wake_up_interval_ms();
bool SendNextRequest();
// Will be invoked in 1ms intervals and schedule the next request from the
// |current_requester_| if the time has passed for another request.
void MaybeScheduleStunRequests();
void ReportOnPrepared(StunProber::Status status);
void ReportOnFinished(StunProber::Status status);
Requester* CreateRequester();
Requester* current_requester_ = nullptr;
// The time when the next request should go out.
int64_t next_request_time_ms_ = 0;
// Total requests sent so far.
uint32_t num_request_sent_ = 0;
bool shared_socket_mode_ = false;
// How many requests should be done against each resolved IP.
uint32_t requests_per_ip_ = 0;
// Milliseconds to pause between each STUN request.
int interval_ms_;
// Timeout period after the last request is sent.
int timeout_ms_;
// STUN server name to be resolved.
std::vector<rtc::SocketAddress> servers_;
// Weak references.
rtc::PacketSocketFactory* socket_factory_;
rtc::Thread* thread_;
// Accumulate all resolved addresses.
std::vector<rtc::SocketAddress> all_servers_addrs_;
// The set of STUN probe sockets and their state.
std::vector<Requester*> requesters_;
rtc::ThreadChecker thread_checker_;
// Temporary storage for created sockets.
std::vector<rtc::AsyncPacketSocket*> sockets_;
// This tracks how many of the sockets are ready.
size_t total_ready_sockets_ = 0;
rtc::AsyncInvoker invoker_;
Observer* observer_ = nullptr;
// TODO(guoweis): Remove this once all dependencies move away from
// AsyncCallback.
ObserverAdapter observer_adapter_;
rtc::NetworkManager::NetworkList networks_;
} // namespace stunprober