3
* Copyright 2004--2005, Google Inc.
5
* Redistribution and use in source and binary forms, with or without
6
* modification, are permitted provided that the following conditions are met:
8
* 1. Redistributions of source code must retain the above copyright notice,
9
* this list of conditions and the following disclaimer.
10
* 2. Redistributions in binary form must reproduce the above copyright notice,
11
* this list of conditions and the following disclaimer in the documentation
12
* and/or other materials provided with the distribution.
13
* 3. The name of the author may not be used to endorse or promote products
14
* derived from this software without specific prior written permission.
16
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
#ifndef TALK_BASE_VIRTUALSOCKETSERVER_H_
29
#define TALK_BASE_VIRTUALSOCKETSERVER_H_
35
#include "talk/base/messagequeue.h"
36
#include "talk/base/socketserver.h"
41
class SocketAddressPair;
43
// Simulates a network in the same manner as a loopback interface. The
44
// interface can create as many addresses as you want. All of the sockets
45
// created by this network will be able to communicate with one another, unless
46
// they are bound to addresses from incompatible families.
47
class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {
49
// TODO: Add "owned" parameter.
50
// If "owned" is set, the supplied socketserver will be deleted later.
51
explicit VirtualSocketServer(SocketServer* ss);
52
virtual ~VirtualSocketServer();
54
SocketServer* socketserver() { return server_; }
56
// Limits the network bandwidth (maximum bytes per second). Zero means that
57
// all sends occur instantly. Defaults to 0.
58
uint32 bandwidth() const { return bandwidth_; }
59
void set_bandwidth(uint32 bandwidth) { bandwidth_ = bandwidth; }
61
// Limits the amount of data which can be in flight on the network without
62
// packet loss (on a per sender basis). Defaults to 64 KB.
63
uint32 network_capacity() const { return network_capacity_; }
64
void set_network_capacity(uint32 capacity) {
65
network_capacity_ = capacity;
68
// The amount of data which can be buffered by tcp on the sender's side
69
uint32 send_buffer_capacity() const { return send_buffer_capacity_; }
70
void set_send_buffer_capacity(uint32 capacity) {
71
send_buffer_capacity_ = capacity;
74
// The amount of data which can be buffered by tcp on the receiver's side
75
uint32 recv_buffer_capacity() const { return recv_buffer_capacity_; }
76
void set_recv_buffer_capacity(uint32 capacity) {
77
recv_buffer_capacity_ = capacity;
80
// Controls the (transit) delay for packets sent in the network. This does
81
// not inclue the time required to sit in the send queue. Both of these
82
// values are measured in milliseconds. Defaults to no delay.
83
uint32 delay_mean() const { return delay_mean_; }
84
uint32 delay_stddev() const { return delay_stddev_; }
85
uint32 delay_samples() const { return delay_samples_; }
86
void set_delay_mean(uint32 delay_mean) { delay_mean_ = delay_mean; }
87
void set_delay_stddev(uint32 delay_stddev) {
88
delay_stddev_ = delay_stddev;
90
void set_delay_samples(uint32 delay_samples) {
91
delay_samples_ = delay_samples;
94
// If the (transit) delay parameters are modified, this method should be
95
// called to recompute the new distribution.
96
void UpdateDelayDistribution();
98
// Controls the (uniform) probability that any sent packet is dropped. This
99
// is separate from calculations to drop based on queue size.
100
double drop_probability() { return drop_prob_; }
101
void set_drop_probability(double drop_prob) {
102
assert((0 <= drop_prob) && (drop_prob <= 1));
103
drop_prob_ = drop_prob;
107
virtual Socket* CreateSocket(int type);
108
virtual Socket* CreateSocket(int family, int type);
110
virtual AsyncSocket* CreateAsyncSocket(int type);
111
virtual AsyncSocket* CreateAsyncSocket(int family, int type);
114
virtual void SetMessageQueue(MessageQueue* queue);
115
virtual bool Wait(int cms, bool process_io);
116
virtual void WakeUp();
118
typedef std::pair<double, double> Point;
119
typedef std::vector<Point> Function;
121
static Function* CreateDistribution(uint32 mean, uint32 stddev,
124
// Similar to Thread::ProcessMessages, but it only processes messages until
125
// there are no immediate messages or pending network traffic. Returns false
126
// if Thread::Stop() was called.
127
bool ProcessMessagesUntilIdle();
130
// Returns a new IP not used before in this network.
131
IPAddress GetNextIP(int family);
132
uint16 GetNextPort();
134
VirtualSocket* CreateSocketInternal(int family, int type);
136
// Binds the given socket to addr, assigning and IP and Port if necessary
137
int Bind(VirtualSocket* socket, SocketAddress* addr);
139
// Binds the given socket to the given (fully-defined) address.
140
int Bind(VirtualSocket* socket, const SocketAddress& addr);
142
// Find the socket bound to the given address
143
VirtualSocket* LookupBinding(const SocketAddress& addr);
145
int Unbind(const SocketAddress& addr, VirtualSocket* socket);
147
// Adds a mapping between this socket pair and the socket.
148
void AddConnection(const SocketAddress& client,
149
const SocketAddress& server,
150
VirtualSocket* socket);
152
// Find the socket pair corresponding to this server address.
153
VirtualSocket* LookupConnection(const SocketAddress& client,
154
const SocketAddress& server);
156
void RemoveConnection(const SocketAddress& client,
157
const SocketAddress& server);
159
// Connects the given socket to the socket at the given address
160
int Connect(VirtualSocket* socket, const SocketAddress& remote_addr,
163
// Sends a disconnect message to the socket at the given address
164
bool Disconnect(VirtualSocket* socket);
166
// Sends the given packet to the socket at the given address (if one exists).
167
int SendUdp(VirtualSocket* socket, const char* data, size_t data_size,
168
const SocketAddress& remote_addr);
170
// Moves as much data as possible from the sender's buffer to the network
171
void SendTcp(VirtualSocket* socket);
173
// Places a packet on the network.
174
void AddPacketToNetwork(VirtualSocket* socket, VirtualSocket* recipient,
175
uint32 cur_time, const char* data, size_t data_size,
176
size_t header_size, bool ordered);
178
// Removes stale packets from the network
179
void PurgeNetworkPackets(VirtualSocket* socket, uint32 cur_time);
181
// Computes the number of milliseconds required to send a packet of this size.
182
uint32 SendDelay(uint32 size);
184
// Returns a random transit delay chosen from the appropriate distribution.
185
uint32 GetRandomTransitDelay();
187
// Basic operations on functions. Those that return a function also take
188
// ownership of the function given (and hence, may modify or delete it).
189
static Function* Accumulate(Function* f);
190
static Function* Invert(Function* f);
191
static Function* Resample(Function* f, double x1, double x2, uint32 samples);
192
static double Evaluate(Function* f, double x);
194
// NULL out our message queue if it goes away. Necessary in the case where
195
// our lifetime is greater than that of the thread we are using, since we
196
// try to send Close messages for all connected sockets when we shutdown.
197
void OnMessageQueueDestroyed() { msg_queue_ = NULL; }
199
// Determine if two sockets should be able to communicate.
200
// We don't (currently) specify an address family for sockets; instead,
201
// the currently bound address is used to infer the address family.
202
// Any socket that is not explicitly bound to an IPv4 address is assumed to be
203
// dual-stack capable.
204
// This function tests if two addresses can communicate, as well as the
205
// sockets to which they may be bound (the addresses may or may not yet be
206
// bound to the sockets).
207
// First the addresses are tested (after normalization):
208
// If both have the same family, then communication is OK.
209
// If only one is IPv4 then false, unless the other is bound to ::.
210
// This applies even if the IPv4 address is 0.0.0.0.
211
// The socket arguments are optional; the sockets are checked to see if they
212
// were explicitly bound to IPv6-any ('::'), and if so communication is
214
// NB: This scheme doesn't permit non-dualstack IPv6 sockets.
215
static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
218
friend class VirtualSocket;
220
typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
221
typedef std::map<SocketAddressPair, VirtualSocket*> ConnectionMap;
223
SocketServer* server_;
225
MessageQueue* msg_queue_;
227
uint32 network_delay_;
231
AddressMap* bindings_;
232
ConnectionMap* connections_;
235
uint32 network_capacity_;
236
uint32 send_buffer_capacity_;
237
uint32 recv_buffer_capacity_;
239
uint32 delay_stddev_;
240
uint32 delay_samples_;
241
Function* delay_dist_;
242
CriticalSection delay_crit_;
245
DISALLOW_EVIL_CONSTRUCTORS(VirtualSocketServer);
248
} // namespace talk_base
250
#endif // TALK_BASE_VIRTUALSOCKETSERVER_H_
added
removed
protocols/jabber/libjingle/talk/base/virtualsocketserver.h
