blob: dffabafa7ccee74581564fdc243a1b40cefd35ae [file] [log] [blame]
/*
* Copyright (c) 2018 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 TEST_NETWORK_NETWORK_EMULATION_H_
#define TEST_NETWORK_NETWORK_EMULATION_H_
#include <cstdint>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/numerics/samples_stats_counter.h"
#include "api/sequence_checker.h"
#include "api/test/network_emulation/network_emulation_interfaces.h"
#include "api/test/network_emulation_manager.h"
#include "api/test/simulated_network.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/network.h"
#include "rtc_base/network_constants.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/task_utils/repeating_task.h"
#include "rtc_base/thread_annotations.h"
#include "system_wrappers/include/clock.h"
namespace webrtc {
// All methods of EmulatedNetworkOutgoingStatsBuilder have to be used on a
// single thread. It may be created on another thread.
class EmulatedNetworkOutgoingStatsBuilder {
public:
explicit EmulatedNetworkOutgoingStatsBuilder(
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
void OnPacketSent(Timestamp sent_time, DataSize packet_size);
void AddOutgoingStats(const EmulatedNetworkOutgoingStats& stats);
EmulatedNetworkOutgoingStats Build() const;
private:
const EmulatedNetworkStatsGatheringMode stats_gathering_mode_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
EmulatedNetworkOutgoingStats stats_ RTC_GUARDED_BY(sequence_checker_);
};
// All methods of EmulatedNetworkIncomingStatsBuilder have to be used on a
// single thread. It may be created on another thread.
class EmulatedNetworkIncomingStatsBuilder {
public:
explicit EmulatedNetworkIncomingStatsBuilder(
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
void OnPacketDropped(DataSize packet_size);
void OnPacketReceived(Timestamp received_time, DataSize packet_size);
// Adds stats collected from another endpoints to the builder.
void AddIncomingStats(const EmulatedNetworkIncomingStats& stats);
EmulatedNetworkIncomingStats Build() const;
private:
const EmulatedNetworkStatsGatheringMode stats_gathering_mode_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
EmulatedNetworkIncomingStats stats_ RTC_GUARDED_BY(sequence_checker_);
};
// All methods of EmulatedNetworkStatsBuilder have to be used on a single
// thread. It may be created on another thread.
class EmulatedNetworkStatsBuilder {
public:
explicit EmulatedNetworkStatsBuilder(
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
explicit EmulatedNetworkStatsBuilder(
rtc::IPAddress local_ip,
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
void OnPacketSent(Timestamp queued_time,
Timestamp sent_time,
rtc::IPAddress destination_ip,
DataSize packet_size);
void OnPacketDropped(rtc::IPAddress source_ip, DataSize packet_size);
void OnPacketReceived(Timestamp received_time,
rtc::IPAddress source_ip,
DataSize packet_size);
void AddEmulatedNetworkStats(const EmulatedNetworkStats& stats);
EmulatedNetworkStats Build() const;
private:
const EmulatedNetworkStatsGatheringMode stats_gathering_mode_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
std::vector<rtc::IPAddress> local_addresses_
RTC_GUARDED_BY(sequence_checker_);
SamplesStatsCounter sent_packets_queue_wait_time_us_;
std::map<rtc::IPAddress, std::unique_ptr<EmulatedNetworkOutgoingStatsBuilder>>
outgoing_stats_per_destination_ RTC_GUARDED_BY(sequence_checker_);
std::map<rtc::IPAddress, std::unique_ptr<EmulatedNetworkIncomingStatsBuilder>>
incoming_stats_per_source_ RTC_GUARDED_BY(sequence_checker_);
};
// All methods of EmulatedNetworkNodeStatsBuilder have to be used on a
// single thread. It may be created on another thread.
class EmulatedNetworkNodeStatsBuilder {
public:
explicit EmulatedNetworkNodeStatsBuilder(
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
void AddPacketTransportTime(TimeDelta time, size_t packet_size);
void AddEmulatedNetworkNodeStats(const EmulatedNetworkNodeStats& stats);
EmulatedNetworkNodeStats Build() const;
private:
const EmulatedNetworkStatsGatheringMode stats_gathering_mode_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
EmulatedNetworkNodeStats stats_ RTC_GUARDED_BY(sequence_checker_);
};
class LinkEmulation : public EmulatedNetworkReceiverInterface {
public:
LinkEmulation(Clock* clock,
rtc::TaskQueue* task_queue,
std::unique_ptr<NetworkBehaviorInterface> network_behavior,
EmulatedNetworkReceiverInterface* receiver,
EmulatedNetworkStatsGatheringMode stats_gathering_mode)
: clock_(clock),
task_queue_(task_queue),
network_behavior_(std::move(network_behavior)),
receiver_(receiver),
stats_builder_(stats_gathering_mode) {}
void OnPacketReceived(EmulatedIpPacket packet) override;
EmulatedNetworkNodeStats stats() const;
private:
struct StoredPacket {
uint64_t id;
Timestamp sent_time;
EmulatedIpPacket packet;
bool removed;
};
void Process(Timestamp at_time) RTC_RUN_ON(task_queue_);
Clock* const clock_;
rtc::TaskQueue* const task_queue_;
const std::unique_ptr<NetworkBehaviorInterface> network_behavior_
RTC_GUARDED_BY(task_queue_);
EmulatedNetworkReceiverInterface* const receiver_;
RepeatingTaskHandle process_task_ RTC_GUARDED_BY(task_queue_);
std::deque<StoredPacket> packets_ RTC_GUARDED_BY(task_queue_);
uint64_t next_packet_id_ RTC_GUARDED_BY(task_queue_) = 1;
EmulatedNetworkNodeStatsBuilder stats_builder_ RTC_GUARDED_BY(task_queue_);
};
// Represents a component responsible for routing packets based on their IP
// address. All possible routes have to be set explicitly before packet for
// desired destination will be seen for the first time. If route is unknown
// the packet will be silently dropped.
class NetworkRouterNode : public EmulatedNetworkReceiverInterface {
public:
explicit NetworkRouterNode(rtc::TaskQueue* task_queue);
void OnPacketReceived(EmulatedIpPacket packet) override;
void SetReceiver(const rtc::IPAddress& dest_ip,
EmulatedNetworkReceiverInterface* receiver);
void RemoveReceiver(const rtc::IPAddress& dest_ip);
// Sets a default receive that will be used for all incoming packets for which
// there is no specific receiver binded to their destination port.
void SetDefaultReceiver(EmulatedNetworkReceiverInterface* receiver);
void RemoveDefaultReceiver();
void SetWatcher(std::function<void(const EmulatedIpPacket&)> watcher);
void SetFilter(std::function<bool(const EmulatedIpPacket&)> filter);
private:
rtc::TaskQueue* const task_queue_;
absl::optional<EmulatedNetworkReceiverInterface*> default_receiver_
RTC_GUARDED_BY(task_queue_);
std::map<rtc::IPAddress, EmulatedNetworkReceiverInterface*> routing_
RTC_GUARDED_BY(task_queue_);
std::function<void(const EmulatedIpPacket&)> watcher_
RTC_GUARDED_BY(task_queue_);
std::function<bool(const EmulatedIpPacket&)> filter_
RTC_GUARDED_BY(task_queue_);
};
// Represents node in the emulated network. Nodes can be connected with each
// other to form different networks with different behavior. The behavior of
// the node itself is determined by a concrete implementation of
// NetworkBehaviorInterface that is provided on construction.
class EmulatedNetworkNode : public EmulatedNetworkReceiverInterface {
public:
// Creates node based on `network_behavior`. The specified `packet_overhead`
// is added to the size of each packet in the information provided to
// `network_behavior`.
// `task_queue` is used to process packets and to forward the packets when
// they are ready.
EmulatedNetworkNode(
Clock* clock,
rtc::TaskQueue* task_queue,
std::unique_ptr<NetworkBehaviorInterface> network_behavior,
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
~EmulatedNetworkNode() override;
EmulatedNetworkNode(const EmulatedNetworkNode&) = delete;
EmulatedNetworkNode& operator=(const EmulatedNetworkNode&) = delete;
void OnPacketReceived(EmulatedIpPacket packet) override;
LinkEmulation* link() { return &link_; }
NetworkRouterNode* router() { return &router_; }
EmulatedNetworkNodeStats stats() const;
// Creates a route for the given receiver_ip over all the given nodes to the
// given receiver.
static void CreateRoute(const rtc::IPAddress& receiver_ip,
std::vector<EmulatedNetworkNode*> nodes,
EmulatedNetworkReceiverInterface* receiver);
static void ClearRoute(const rtc::IPAddress& receiver_ip,
std::vector<EmulatedNetworkNode*> nodes);
private:
NetworkRouterNode router_;
LinkEmulation link_;
};
// Represents single network interface on the device.
// It will be used as sender from socket side to send data to the network and
// will act as packet receiver from emulated network side to receive packets
// from other EmulatedNetworkNodes.
class EmulatedEndpointImpl : public EmulatedEndpoint {
public:
struct Options {
Options(uint64_t id,
const rtc::IPAddress& ip,
const EmulatedEndpointConfig& config,
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
// TODO(titovartem) check if we can remove id.
uint64_t id;
// Endpoint local IP address.
rtc::IPAddress ip;
EmulatedNetworkStatsGatheringMode stats_gathering_mode;
rtc::AdapterType type;
// Allow endpoint to send packets specifying source IP address different to
// the current endpoint IP address. If false endpoint will crash if attempt
// to send such packet will be done.
bool allow_send_packet_with_different_source_ip;
// Allow endpoint to receive packet with destination IP address different to
// the current endpoint IP address. If false endpoint will crash if such
// packet will arrive.
bool allow_receive_packets_with_different_dest_ip;
// Name of the endpoint used for logging purposes.
std::string log_name;
};
EmulatedEndpointImpl(const Options& options,
bool is_enabled,
rtc::TaskQueue* task_queue,
Clock* clock);
~EmulatedEndpointImpl() override;
uint64_t GetId() const;
NetworkRouterNode* router() { return &router_; }
void SendPacket(const rtc::SocketAddress& from,
const rtc::SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead = 0) override;
absl::optional<uint16_t> BindReceiver(
uint16_t desired_port,
EmulatedNetworkReceiverInterface* receiver) override;
// Binds a receiver, and automatically removes the binding after first call to
// OnPacketReceived.
absl::optional<uint16_t> BindOneShotReceiver(
uint16_t desired_port,
EmulatedNetworkReceiverInterface* receiver);
void UnbindReceiver(uint16_t port) override;
void BindDefaultReceiver(EmulatedNetworkReceiverInterface* receiver) override;
void UnbindDefaultReceiver() override;
rtc::IPAddress GetPeerLocalAddress() const override;
// Will be called to deliver packet into endpoint from network node.
void OnPacketReceived(EmulatedIpPacket packet) override;
void Enable();
void Disable();
bool Enabled() const;
const rtc::Network& network() const { return *network_.get(); }
EmulatedNetworkStats stats() const;
private:
struct ReceiverBinding {
EmulatedNetworkReceiverInterface* receiver;
bool is_one_shot;
};
absl::optional<uint16_t> BindReceiverInternal(
uint16_t desired_port,
EmulatedNetworkReceiverInterface* receiver,
bool is_one_shot);
static constexpr uint16_t kFirstEphemeralPort = 49152;
uint16_t NextPort() RTC_EXCLUSIVE_LOCKS_REQUIRED(receiver_lock_);
Mutex receiver_lock_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker enabled_state_checker_;
const Options options_;
bool is_enabled_ RTC_GUARDED_BY(enabled_state_checker_);
Clock* const clock_;
rtc::TaskQueue* const task_queue_;
std::unique_ptr<rtc::Network> network_;
NetworkRouterNode router_;
uint16_t next_port_ RTC_GUARDED_BY(receiver_lock_);
absl::optional<EmulatedNetworkReceiverInterface*> default_receiver_
RTC_GUARDED_BY(receiver_lock_);
std::map<uint16_t, ReceiverBinding> port_to_receiver_
RTC_GUARDED_BY(receiver_lock_);
EmulatedNetworkStatsBuilder stats_builder_ RTC_GUARDED_BY(task_queue_);
};
class EmulatedRoute {
public:
EmulatedRoute(EmulatedEndpointImpl* from,
std::vector<EmulatedNetworkNode*> via_nodes,
EmulatedEndpointImpl* to,
bool is_default)
: from(from),
via_nodes(std::move(via_nodes)),
to(to),
active(true),
is_default(is_default) {}
EmulatedEndpointImpl* from;
std::vector<EmulatedNetworkNode*> via_nodes;
EmulatedEndpointImpl* to;
bool active;
bool is_default;
};
// This object is immutable and so thread safe.
class EndpointsContainer {
public:
EndpointsContainer(const std::vector<EmulatedEndpointImpl*>& endpoints,
EmulatedNetworkStatsGatheringMode stats_gathering_mode);
EmulatedEndpointImpl* LookupByLocalAddress(
const rtc::IPAddress& local_ip) const;
bool HasEndpoint(EmulatedEndpointImpl* endpoint) const;
// Returns list of networks for enabled endpoints. Caller takes ownership of
// returned rtc::Network objects.
std::vector<std::unique_ptr<rtc::Network>> GetEnabledNetworks() const;
std::vector<EmulatedEndpoint*> GetEndpoints() const;
EmulatedNetworkStats GetStats() const;
private:
const std::vector<EmulatedEndpointImpl*> endpoints_;
const EmulatedNetworkStatsGatheringMode stats_gathering_mode_;
};
template <typename FakePacketType>
class FakePacketRoute : public EmulatedNetworkReceiverInterface {
public:
FakePacketRoute(EmulatedRoute* route,
std::function<void(FakePacketType, Timestamp)> action)
: route_(route),
action_(std::move(action)),
send_addr_(route_->from->GetPeerLocalAddress(), 0),
recv_addr_(route_->to->GetPeerLocalAddress(),
*route_->to->BindReceiver(0, this)) {}
~FakePacketRoute() { route_->to->UnbindReceiver(recv_addr_.port()); }
void SendPacket(size_t size, FakePacketType packet) {
RTC_CHECK_GE(size, sizeof(int));
sent_.emplace(next_packet_id_, packet);
rtc::CopyOnWriteBuffer buf(size);
reinterpret_cast<int*>(buf.MutableData())[0] = next_packet_id_++;
route_->from->SendPacket(send_addr_, recv_addr_, buf);
}
void OnPacketReceived(EmulatedIpPacket packet) override {
int packet_id = reinterpret_cast<const int*>(packet.data.data())[0];
action_(std::move(sent_[packet_id]), packet.arrival_time);
sent_.erase(packet_id);
}
private:
EmulatedRoute* const route_;
const std::function<void(FakePacketType, Timestamp)> action_;
const rtc::SocketAddress send_addr_;
const rtc::SocketAddress recv_addr_;
int next_packet_id_ = 0;
std::map<int, FakePacketType> sent_;
};
template <typename RequestPacketType, typename ResponsePacketType>
class TwoWayFakeTrafficRoute {
public:
class TrafficHandlerInterface {
public:
virtual void OnRequest(RequestPacketType, Timestamp) = 0;
virtual void OnResponse(ResponsePacketType, Timestamp) = 0;
virtual ~TrafficHandlerInterface() = default;
};
TwoWayFakeTrafficRoute(TrafficHandlerInterface* handler,
EmulatedRoute* send_route,
EmulatedRoute* ret_route)
: handler_(handler),
request_handler_{send_route,
[&](RequestPacketType packet, Timestamp arrival_time) {
handler_->OnRequest(std::move(packet), arrival_time);
}},
response_handler_{
ret_route, [&](ResponsePacketType packet, Timestamp arrival_time) {
handler_->OnResponse(std::move(packet), arrival_time);
}} {}
void SendRequest(size_t size, RequestPacketType packet) {
request_handler_.SendPacket(size, std::move(packet));
}
void SendResponse(size_t size, ResponsePacketType packet) {
response_handler_.SendPacket(size, std::move(packet));
}
private:
TrafficHandlerInterface* handler_;
FakePacketRoute<RequestPacketType> request_handler_;
FakePacketRoute<ResponsePacketType> response_handler_;
};
} // namespace webrtc
#endif // TEST_NETWORK_NETWORK_EMULATION_H_