/* * 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. */ #ifndef WEBRTC_BASE_VIRTUALSOCKETSERVER_H_ #define WEBRTC_BASE_VIRTUALSOCKETSERVER_H_ #include #include #include #include "webrtc/base/constructormagic.h" #include "webrtc/base/messagequeue.h" #include "webrtc/base/socketserver.h" namespace rtc { class Packet; class VirtualSocket; class SocketAddressPair; // Simulates a network in the same manner as a loopback interface. The // interface can create as many addresses as you want. All of the sockets // created by this network will be able to communicate with one another, unless // they are bound to addresses from incompatible families. class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> { public: // TODO: Add "owned" parameter. // If "owned" is set, the supplied socketserver will be deleted later. explicit VirtualSocketServer(SocketServer* ss); ~VirtualSocketServer() override; SocketServer* socketserver() { return server_; } // The default route indicates which local address to use when a socket is // bound to the 'any' address, e.g. 0.0.0.0. IPAddress GetDefaultRoute(int family); void SetDefaultRoute(const IPAddress& from_addr); // Limits the network bandwidth (maximum bytes per second). Zero means that // all sends occur instantly. Defaults to 0. uint32_t bandwidth() const { return bandwidth_; } void set_bandwidth(uint32_t bandwidth) { bandwidth_ = bandwidth; } // Limits the amount of data which can be in flight on the network without // packet loss (on a per sender basis). Defaults to 64 KB. uint32_t network_capacity() const { return network_capacity_; } void set_network_capacity(uint32_t capacity) { network_capacity_ = capacity; } // The amount of data which can be buffered by tcp on the sender's side uint32_t send_buffer_capacity() const { return send_buffer_capacity_; } void set_send_buffer_capacity(uint32_t capacity) { send_buffer_capacity_ = capacity; } // The amount of data which can be buffered by tcp on the receiver's side uint32_t recv_buffer_capacity() const { return recv_buffer_capacity_; } void set_recv_buffer_capacity(uint32_t capacity) { recv_buffer_capacity_ = capacity; } // Controls the (transit) delay for packets sent in the network. This does // not inclue the time required to sit in the send queue. Both of these // values are measured in milliseconds. Defaults to no delay. uint32_t delay_mean() const { return delay_mean_; } uint32_t delay_stddev() const { return delay_stddev_; } uint32_t delay_samples() const { return delay_samples_; } void set_delay_mean(uint32_t delay_mean) { delay_mean_ = delay_mean; } void set_delay_stddev(uint32_t delay_stddev) { delay_stddev_ = delay_stddev; } void set_delay_samples(uint32_t delay_samples) { delay_samples_ = delay_samples; } // If the (transit) delay parameters are modified, this method should be // called to recompute the new distribution. void UpdateDelayDistribution(); // Controls the (uniform) probability that any sent packet is dropped. This // is separate from calculations to drop based on queue size. double drop_probability() { return drop_prob_; } void set_drop_probability(double drop_prob) { assert((0 <= drop_prob) && (drop_prob <= 1)); drop_prob_ = drop_prob; } // SocketFactory: Socket* CreateSocket(int type) override; Socket* CreateSocket(int family, int type) override; AsyncSocket* CreateAsyncSocket(int type) override; AsyncSocket* CreateAsyncSocket(int family, int type) override; // SocketServer: void SetMessageQueue(MessageQueue* queue) override; bool Wait(int cms, bool process_io) override; void WakeUp() override; typedef std::pair Point; typedef std::vector Function; static Function* CreateDistribution(uint32_t mean, uint32_t stddev, uint32_t samples); // Similar to Thread::ProcessMessages, but it only processes messages until // there are no immediate messages or pending network traffic. Returns false // if Thread::Stop() was called. bool ProcessMessagesUntilIdle(); // Sets the next port number to use for testing. void SetNextPortForTesting(uint16_t port); // Close a pair of Tcp connections by addresses. Both connections will have // its own OnClose invoked. bool CloseTcpConnections(const SocketAddress& addr_local, const SocketAddress& addr_remote); // For testing purpose only. Fired when a client socket is created. sigslot::signal1 SignalSocketCreated; protected: // Returns a new IP not used before in this network. IPAddress GetNextIP(int family); uint16_t GetNextPort(); VirtualSocket* CreateSocketInternal(int family, int type); // Binds the given socket to addr, assigning and IP and Port if necessary int Bind(VirtualSocket* socket, SocketAddress* addr); // Binds the given socket to the given (fully-defined) address. int Bind(VirtualSocket* socket, const SocketAddress& addr); // Find the socket bound to the given address VirtualSocket* LookupBinding(const SocketAddress& addr); int Unbind(const SocketAddress& addr, VirtualSocket* socket); // Adds a mapping between this socket pair and the socket. void AddConnection(const SocketAddress& client, const SocketAddress& server, VirtualSocket* socket); // Find the socket pair corresponding to this server address. VirtualSocket* LookupConnection(const SocketAddress& client, const SocketAddress& server); void RemoveConnection(const SocketAddress& client, const SocketAddress& server); // Connects the given socket to the socket at the given address int Connect(VirtualSocket* socket, const SocketAddress& remote_addr, bool use_delay); // Sends a disconnect message to the socket at the given address bool Disconnect(VirtualSocket* socket); // Sends the given packet to the socket at the given address (if one exists). int SendUdp(VirtualSocket* socket, const char* data, size_t data_size, const SocketAddress& remote_addr); // Moves as much data as possible from the sender's buffer to the network void SendTcp(VirtualSocket* socket); // Places a packet on the network. void AddPacketToNetwork(VirtualSocket* socket, VirtualSocket* recipient, int64_t cur_time, const char* data, size_t data_size, size_t header_size, bool ordered); // Removes stale packets from the network void PurgeNetworkPackets(VirtualSocket* socket, int64_t cur_time); // Computes the number of milliseconds required to send a packet of this size. uint32_t SendDelay(uint32_t size); // Returns a random transit delay chosen from the appropriate distribution. uint32_t GetRandomTransitDelay(); // Basic operations on functions. Those that return a function also take // ownership of the function given (and hence, may modify or delete it). static Function* Accumulate(Function* f); static Function* Invert(Function* f); static Function* Resample(Function* f, double x1, double x2, uint32_t samples); static double Evaluate(Function* f, double x); // NULL out our message queue if it goes away. Necessary in the case where // our lifetime is greater than that of the thread we are using, since we // try to send Close messages for all connected sockets when we shutdown. void OnMessageQueueDestroyed() { msg_queue_ = NULL; } // Determine if two sockets should be able to communicate. // We don't (currently) specify an address family for sockets; instead, // the currently bound address is used to infer the address family. // Any socket that is not explicitly bound to an IPv4 address is assumed to be // dual-stack capable. // This function tests if two addresses can communicate, as well as the // sockets to which they may be bound (the addresses may or may not yet be // bound to the sockets). // First the addresses are tested (after normalization): // If both have the same family, then communication is OK. // If only one is IPv4 then false, unless the other is bound to ::. // This applies even if the IPv4 address is 0.0.0.0. // The socket arguments are optional; the sockets are checked to see if they // were explicitly bound to IPv6-any ('::'), and if so communication is // permitted. // NB: This scheme doesn't permit non-dualstack IPv6 sockets. static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote); private: friend class VirtualSocket; typedef std::map AddressMap; typedef std::map ConnectionMap; SocketServer* server_; bool server_owned_; MessageQueue* msg_queue_; bool stop_on_idle_; int64_t network_delay_; in_addr next_ipv4_; in6_addr next_ipv6_; uint16_t next_port_; AddressMap* bindings_; ConnectionMap* connections_; IPAddress default_route_v4_; IPAddress default_route_v6_; uint32_t bandwidth_; uint32_t network_capacity_; uint32_t send_buffer_capacity_; uint32_t recv_buffer_capacity_; uint32_t delay_mean_; uint32_t delay_stddev_; uint32_t delay_samples_; Function* delay_dist_; CriticalSection delay_crit_; double drop_prob_; RTC_DISALLOW_COPY_AND_ASSIGN(VirtualSocketServer); }; // Implements the socket interface using the virtual network. Packets are // passed as messages using the message queue of the socket server. class VirtualSocket : public AsyncSocket, public MessageHandler { public: VirtualSocket(VirtualSocketServer* server, int family, int type, bool async); ~VirtualSocket() override; SocketAddress GetLocalAddress() const override; SocketAddress GetRemoteAddress() const override; // Used by TurnPortTest to mimic a case where proxy returns local host address // instead of the original one TurnPort was bound against. Please see WebRTC // issue 3927 for more detail. void SetAlternativeLocalAddress(const SocketAddress& addr); int Bind(const SocketAddress& addr) override; int Connect(const SocketAddress& addr) override; int Close() override; int Send(const void* pv, size_t cb) override; int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override; int Recv(void* pv, size_t cb, int64_t* timestamp) override; int RecvFrom(void* pv, size_t cb, SocketAddress* paddr, int64_t* timestamp) override; int Listen(int backlog) override; VirtualSocket* Accept(SocketAddress* paddr) override; int GetError() const override; void SetError(int error) override; ConnState GetState() const override; int GetOption(Option opt, int* value) override; int SetOption(Option opt, int value) override; int EstimateMTU(uint16_t* mtu) override; void OnMessage(Message* pmsg) override; bool was_any() { return was_any_; } void set_was_any(bool was_any) { was_any_ = was_any; } // For testing purpose only. Fired when client socket is bound to an address. sigslot::signal2 SignalAddressReady; private: struct NetworkEntry { size_t size; int64_t done_time; }; typedef std::deque ListenQueue; typedef std::deque NetworkQueue; typedef std::vector SendBuffer; typedef std::list RecvBuffer; typedef std::map OptionsMap; int InitiateConnect(const SocketAddress& addr, bool use_delay); void CompleteConnect(const SocketAddress& addr, bool notify); int SendUdp(const void* pv, size_t cb, const SocketAddress& addr); int SendTcp(const void* pv, size_t cb); // Used by server sockets to set the local address without binding. void SetLocalAddress(const SocketAddress& addr); VirtualSocketServer* server_; int type_; bool async_; ConnState state_; int error_; SocketAddress local_addr_; SocketAddress alternative_local_addr_; SocketAddress remote_addr_; // Pending sockets which can be Accepted ListenQueue* listen_queue_; // Data which tcp has buffered for sending SendBuffer send_buffer_; bool write_enabled_; // Critical section to protect the recv_buffer and queue_ CriticalSection crit_; // Network model that enforces bandwidth and capacity constraints NetworkQueue network_; size_t network_size_; // Data which has been received from the network RecvBuffer recv_buffer_; // The amount of data which is in flight or in recv_buffer_ size_t recv_buffer_size_; // Is this socket bound? bool bound_; // When we bind a socket to Any, VSS's Bind gives it another address. For // dual-stack sockets, we want to distinguish between sockets that were // explicitly given a particular address and sockets that had one picked // for them by VSS. bool was_any_; // Store the options that are set OptionsMap options_map_; friend class VirtualSocketServer; }; } // namespace rtc #endif // WEBRTC_BASE_VIRTUALSOCKETSERVER_H_