1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/*
* libjingle
* Copyright 2004--2005, Google Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TALK_BASE_VIRTUALSOCKETSERVER_H__
#define TALK_BASE_VIRTUALSOCKETSERVER_H__
#include <cassert>
#include <deque>
#include <map>
#include "talk/base/messagequeue.h"
#include "talk/base/socketserver.h"
namespace talk_base {
class VirtualSocket;
// 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.
class VirtualSocketServer : public SocketServer, public MessageHandler {
public:
VirtualSocketServer();
virtual ~VirtualSocketServer();
// Returns a new IP not used before in this network.
uint32 GetNextIP();
// Limits the network bandwidth (maximum bytes per second). Zero means that
// all sends occur instantly.
uint32 bandwidth() { return bandwidth_; }
void set_bandwidth(uint32 bandwidth) { bandwidth_ = bandwidth; }
// Limits the total size of packets that will be kept in the send queue,
// waiting for their turn to be written to the network Defaults to 64 KB.
uint32 queue_capacity() { return queue_capacity_; }
void set_queue_capacity(uint32 queue_capacity) {
queue_capacity_ = queue_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.
uint32 delay_mean() { return delay_mean_; }
uint32 delay_stddev() { return delay_stddev_; }
void set_delay_mean(uint32 delay_mean) { delay_mean_ = delay_mean; }
void set_delay_stddev(uint32 delay_stddev) {
delay_stddev_ = delay_stddev;
}
// 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:
virtual Socket* CreateSocket(int type);
virtual AsyncSocket* CreateAsyncSocket(int type);
// SocketServer:
virtual bool Wait(int cms, bool process_io);
virtual void WakeUp();
// Used to send internal wake-up messages.
virtual void OnMessage(Message* msg);
typedef std::pair<double,double> Point;
typedef std::vector<Point> Function;
private:
friend class VirtualSocket;
typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
MessageQueue* msg_queue_;
bool fWait_;
uint32 wait_version_;
uint32 next_ip_;
uint16 next_port_;
AddressMap* bindings_;
uint32 bandwidth_;
uint32 queue_capacity_;
uint32 delay_mean_;
uint32 delay_stddev_;
Function* delay_dist_;
CriticalSection delay_crit_;
double drop_prob_;
VirtualSocket* CreateSocketInternal(int type);
// Attempts to bind the given socket to the given (non-zero) address.
int Bind(const SocketAddress& addr, VirtualSocket* socket);
// Binds the given socket to the given (non-zero) IP on an unused port.
int Bind(VirtualSocket* socket, SocketAddress* addr);
// Removes the binding for the given socket.
int Unbind(const SocketAddress& addr, VirtualSocket* socket);
// Sends the given packet to the socket at the given address (if one exists).
int Send(VirtualSocket* socket, const void *pv, size_t cb,
const SocketAddress& local_addr, const SocketAddress& remote_addr);
// Computes the number of milliseconds required to send a packet of this size.
uint32 SendDelay(uint32 size);
// Returns the probability density function for the transit delay.
Function* GetDelayDistribution();
// Returns a random transit delay chosen from the appropriate distribution.
uint32 GetRandomTransitDelay();
// Basic operations on functions. Those that return a function also take
// ownership of the function given (and hence, may modify or delete it).
Function* Accumulate(Function* f);
Function* Invert(Function* f);
Function* Resample(Function* f, double x1, double x2);
double Evaluate(Function* f, double x);
};
} // namespace talk_base
#endif // TALK_BASE_VIRTUALSOCKETSERVER_H__
|
