255 lines
8.2 KiB
C
255 lines
8.2 KiB
C
|
/*
|
||
|
|
* 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef WEBRTC_P2P_STUNPROBER_STUNPROBER_H_
|
||
|
|
#define WEBRTC_P2P_STUNPROBER_STUNPROBER_H_
|
||
|
|
|
||
|
|
#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_INVALID,
|
||
|
|
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<> {
|
||
|
|
public:
|
||
|
|
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 {
|
||
|
|
public:
|
||
|
|
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() *
|
||
|
|
interval_ms_);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
// 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 {
|
||
|
|
public:
|
||
|
|
void set_callback(AsyncCallback callback) { callback_ = callback; }
|
||
|
|
void OnPrepared(StunProber* stunprober, Status status) {
|
||
|
|
if (status == SUCCESS) {
|
||
|
|
stunprober->Start(this);
|
||
|
|
} else {
|
||
|
|
callback_(stunprober, status);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
void OnFinished(StunProber* stunprober, Status status) {
|
||
|
|
callback_(stunprober, status);
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
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()) *
|
||
|
|
requests_per_ip_;
|
||
|
|
}
|
||
|
|
|
||
|
|
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_;
|
||
|
|
|
||
|
|
RTC_DISALLOW_COPY_AND_ASSIGN(StunProber);
|
||
|
|
};
|
||
|
|
|
||
|
|
} // namespace stunprober
|
||
|
|
|
||
|
|
#endif // WEBRTC_P2P_STUNPROBER_STUNPROBER_H_
|