blob: 043d15a0826a887b3d2af6f8e7a42ff058a2afa5 [file] [log] [blame]
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001/*
2 * Copyright 2004 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Steve Anton10542f22019-01-11 09:11:00 -080011#include "rtc_base/virtual_socket_server.h"
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000012
13#include <errno.h>
14#include <math.h>
15
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000016#include <map>
jbauch555604a2016-04-26 03:13:22 -070017#include <memory>
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000018#include <vector>
19
Steve Anton2acd1632019-03-25 13:48:30 -070020#include "absl/algorithm/container.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020021#include "rtc_base/checks.h"
Markus Handell3cb525b2020-07-16 16:16:09 +020022#include "rtc_base/deprecated/recursive_critical_section.h"
Steve Anton10542f22019-01-11 09:11:00 -080023#include "rtc_base/fake_clock.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020024#include "rtc_base/logging.h"
Steve Anton10542f22019-01-11 09:11:00 -080025#include "rtc_base/physical_socket_server.h"
26#include "rtc_base/socket_address_pair.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020027#include "rtc_base/thread.h"
Steve Anton10542f22019-01-11 09:11:00 -080028#include "rtc_base/time_utils.h"
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000029
30namespace rtc {
31#if defined(WEBRTC_WIN)
Yves Gerey665174f2018-06-19 15:03:05 +020032const in_addr kInitialNextIPv4 = {{{0x01, 0, 0, 0}}};
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000033#else
34// This value is entirely arbitrary, hence the lack of concern about endianness.
Yves Gerey665174f2018-06-19 15:03:05 +020035const in_addr kInitialNextIPv4 = {0x01000000};
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000036#endif
37// Starts at ::2 so as to not cause confusion with ::1.
Yves Gerey665174f2018-06-19 15:03:05 +020038const in6_addr kInitialNextIPv6 = {
39 {{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}}};
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000040
Peter Boström0c4e06b2015-10-07 12:23:21 +020041const uint16_t kFirstEphemeralPort = 49152;
42const uint16_t kLastEphemeralPort = 65535;
43const uint16_t kEphemeralPortCount =
44 kLastEphemeralPort - kFirstEphemeralPort + 1;
45const uint32_t kDefaultNetworkCapacity = 64 * 1024;
46const uint32_t kDefaultTcpBufferSize = 32 * 1024;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000047
Peter Boström0c4e06b2015-10-07 12:23:21 +020048const uint32_t UDP_HEADER_SIZE = 28; // IP + UDP headers
49const uint32_t TCP_HEADER_SIZE = 40; // IP + TCP headers
50const uint32_t TCP_MSS = 1400; // Maximum segment size
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000051
52// Note: The current algorithm doesn't work for sample sizes smaller than this.
53const int NUM_SAMPLES = 1000;
54
55enum {
56 MSG_ID_PACKET,
57 MSG_ID_CONNECT,
58 MSG_ID_DISCONNECT,
deadbeefed3b9862017-06-02 10:33:16 -070059 MSG_ID_SIGNALREADEVENT,
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000060};
61
62// Packets are passed between sockets as messages. We copy the data just like
63// the kernel does.
64class Packet : public MessageData {
65 public:
66 Packet(const char* data, size_t size, const SocketAddress& from)
Yves Gerey665174f2018-06-19 15:03:05 +020067 : size_(size), consumed_(0), from_(from) {
deadbeef37f5ecf2017-02-27 14:06:41 -080068 RTC_DCHECK(nullptr != data);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000069 data_ = new char[size_];
70 memcpy(data_, data, size_);
71 }
72
Yves Gerey665174f2018-06-19 15:03:05 +020073 ~Packet() override { delete[] data_; }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000074
75 const char* data() const { return data_ + consumed_; }
76 size_t size() const { return size_ - consumed_; }
77 const SocketAddress& from() const { return from_; }
78
79 // Remove the first size bytes from the data.
80 void Consume(size_t size) {
Taylor Brandstettere7536412016-09-09 13:16:15 -070081 RTC_DCHECK(size + consumed_ < size_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000082 consumed_ += size;
83 }
84
85 private:
86 char* data_;
87 size_t size_, consumed_;
88 SocketAddress from_;
89};
90
91struct MessageAddress : public MessageData {
Yves Gerey665174f2018-06-19 15:03:05 +020092 explicit MessageAddress(const SocketAddress& a) : addr(a) {}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000093 SocketAddress addr;
94};
95
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +000096VirtualSocket::VirtualSocket(VirtualSocketServer* server,
97 int family,
98 int type,
99 bool async)
100 : server_(server),
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000101 type_(type),
102 async_(async),
103 state_(CS_CLOSED),
104 error_(0),
deadbeef37f5ecf2017-02-27 14:06:41 -0800105 listen_queue_(nullptr),
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000106 network_size_(0),
107 recv_buffer_size_(0),
108 bound_(false),
109 was_any_(false) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700110 RTC_DCHECK((type_ == SOCK_DGRAM) || (type_ == SOCK_STREAM));
111 RTC_DCHECK(async_ ||
112 (type_ != SOCK_STREAM)); // We only support async streams
113 server->SignalReadyToSend.connect(this,
114 &VirtualSocket::OnSocketServerReadyToSend);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000115}
116
117VirtualSocket::~VirtualSocket() {
118 Close();
119
120 for (RecvBuffer::iterator it = recv_buffer_.begin(); it != recv_buffer_.end();
121 ++it) {
122 delete *it;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000123 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000124}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000125
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000126SocketAddress VirtualSocket::GetLocalAddress() const {
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000127 return local_addr_;
128}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000129
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000130SocketAddress VirtualSocket::GetRemoteAddress() const {
131 return remote_addr_;
132}
133
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000134void VirtualSocket::SetLocalAddress(const SocketAddress& addr) {
135 local_addr_ = addr;
136}
137
138int VirtualSocket::Bind(const SocketAddress& addr) {
139 if (!local_addr_.IsNil()) {
140 error_ = EINVAL;
141 return -1;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000142 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000143 local_addr_ = addr;
144 int result = server_->Bind(this, &local_addr_);
145 if (result != 0) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000146 local_addr_.Clear();
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000147 error_ = EADDRINUSE;
148 } else {
149 bound_ = true;
150 was_any_ = addr.IsAnyIP();
151 }
152 return result;
153}
154
155int VirtualSocket::Connect(const SocketAddress& addr) {
156 return InitiateConnect(addr, true);
157}
158
159int VirtualSocket::Close() {
160 if (!local_addr_.IsNil() && bound_) {
161 // Remove from the binding table.
162 server_->Unbind(local_addr_, this);
163 bound_ = false;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000164 }
165
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000166 if (SOCK_STREAM == type_) {
167 // Cancel pending sockets
168 if (listen_queue_) {
169 while (!listen_queue_->empty()) {
170 SocketAddress addr = listen_queue_->front();
171
172 // Disconnect listening socket.
Niels Möllerc79bd432021-02-16 09:25:52 +0100173 server_->Disconnect(addr);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000174 listen_queue_->pop_front();
175 }
176 delete listen_queue_;
deadbeef37f5ecf2017-02-27 14:06:41 -0800177 listen_queue_ = nullptr;
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000178 }
179 // Disconnect stream sockets
180 if (CS_CONNECTED == state_) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100181 server_->Disconnect(local_addr_, remote_addr_);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000182 }
183 // Cancel potential connects
Niels Möllerc79bd432021-02-16 09:25:52 +0100184 server_->CancelConnects(this);
Tomas Gunnarssond9663472020-11-21 16:20:23 +0100185 }
186
187 // Clear incoming packets and disconnect messages
Niels Möllerc79bd432021-02-16 09:25:52 +0100188 server_->Clear(this);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000189
190 state_ = CS_CLOSED;
191 local_addr_.Clear();
192 remote_addr_.Clear();
193 return 0;
194}
195
196int VirtualSocket::Send(const void* pv, size_t cb) {
Yves Gerey665174f2018-06-19 15:03:05 +0200197 if (CS_CONNECTED != state_) {
198 error_ = ENOTCONN;
199 return -1;
200 }
201 if (SOCK_DGRAM == type_) {
202 return SendUdp(pv, cb, remote_addr_);
203 } else {
204 return SendTcp(pv, cb);
205 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000206}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000207
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000208int VirtualSocket::SendTo(const void* pv,
209 size_t cb,
210 const SocketAddress& addr) {
211 if (SOCK_DGRAM == type_) {
212 return SendUdp(pv, cb, addr);
213 } else {
214 if (CS_CONNECTED != state_) {
215 error_ = ENOTCONN;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000216 return -1;
217 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000218 return SendTcp(pv, cb);
219 }
220}
221
Stefan Holmer9131efd2016-05-23 18:19:26 +0200222int VirtualSocket::Recv(void* pv, size_t cb, int64_t* timestamp) {
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000223 SocketAddress addr;
Stefan Holmer9131efd2016-05-23 18:19:26 +0200224 return RecvFrom(pv, cb, &addr, timestamp);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000225}
226
Stefan Holmer9131efd2016-05-23 18:19:26 +0200227int VirtualSocket::RecvFrom(void* pv,
228 size_t cb,
229 SocketAddress* paddr,
230 int64_t* timestamp) {
231 if (timestamp) {
232 *timestamp = -1;
233 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000234 // If we don't have a packet, then either error or wait for one to arrive.
235 if (recv_buffer_.empty()) {
236 if (async_) {
237 error_ = EAGAIN;
238 return -1;
239 }
240 while (recv_buffer_.empty()) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100241 server_->ProcessOneMessage();
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000242 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000243 }
244
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000245 // Return the packet at the front of the queue.
246 Packet* packet = recv_buffer_.front();
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000247 size_t data_read = std::min(cb, packet->size());
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000248 memcpy(pv, packet->data(), data_read);
249 *paddr = packet->from();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000250
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000251 if (data_read < packet->size()) {
252 packet->Consume(data_read);
253 } else {
254 recv_buffer_.pop_front();
255 delete packet;
256 }
257
deadbeefed3b9862017-06-02 10:33:16 -0700258 // To behave like a real socket, SignalReadEvent should fire in the next
259 // message loop pass if there's still data buffered.
260 if (!recv_buffer_.empty()) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100261 server_->PostSignalReadEvent(this);
deadbeefed3b9862017-06-02 10:33:16 -0700262 }
263
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000264 if (SOCK_STREAM == type_) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100265 bool was_full = (recv_buffer_size_ == server_->recv_buffer_capacity());
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000266 recv_buffer_size_ -= data_read;
267 if (was_full) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100268 server_->SendTcp(remote_addr_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000269 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000270 }
271
272 return static_cast<int>(data_read);
273}
274
275int VirtualSocket::Listen(int backlog) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700276 RTC_DCHECK(SOCK_STREAM == type_);
277 RTC_DCHECK(CS_CLOSED == state_);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000278 if (local_addr_.IsNil()) {
279 error_ = EINVAL;
280 return -1;
281 }
deadbeef37f5ecf2017-02-27 14:06:41 -0800282 RTC_DCHECK(nullptr == listen_queue_);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000283 listen_queue_ = new ListenQueue;
284 state_ = CS_CONNECTING;
285 return 0;
286}
287
288VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800289 if (nullptr == listen_queue_) {
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000290 error_ = EINVAL;
deadbeef37f5ecf2017-02-27 14:06:41 -0800291 return nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000292 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000293 while (!listen_queue_->empty()) {
294 VirtualSocket* socket = new VirtualSocket(server_, AF_INET, type_, async_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000295
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000296 // Set the new local address to the same as this server socket.
297 socket->SetLocalAddress(local_addr_);
298 // Sockets made from a socket that 'was Any' need to inherit that.
299 socket->set_was_any(was_any_);
300 SocketAddress remote_addr(listen_queue_->front());
301 int result = socket->InitiateConnect(remote_addr, false);
302 listen_queue_->pop_front();
303 if (result != 0) {
304 delete socket;
305 continue;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000306 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000307 socket->CompleteConnect(remote_addr, false);
308 if (paddr) {
309 *paddr = remote_addr;
310 }
311 return socket;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000312 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000313 error_ = EWOULDBLOCK;
deadbeef37f5ecf2017-02-27 14:06:41 -0800314 return nullptr;
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000315}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000316
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000317int VirtualSocket::GetError() const {
318 return error_;
319}
320
321void VirtualSocket::SetError(int error) {
322 error_ = error;
323}
324
325Socket::ConnState VirtualSocket::GetState() const {
326 return state_;
327}
328
329int VirtualSocket::GetOption(Option opt, int* value) {
330 OptionsMap::const_iterator it = options_map_.find(opt);
331 if (it == options_map_.end()) {
332 return -1;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000333 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000334 *value = it->second;
335 return 0; // 0 is success to emulate getsockopt()
336}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000337
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000338int VirtualSocket::SetOption(Option opt, int value) {
339 options_map_[opt] = value;
340 return 0; // 0 is success to emulate setsockopt()
341}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000342
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000343void VirtualSocket::OnMessage(Message* pmsg) {
344 if (pmsg->message_id == MSG_ID_PACKET) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800345 RTC_DCHECK(nullptr != pmsg->pdata);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000346 Packet* packet = static_cast<Packet*>(pmsg->pdata);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000347
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000348 recv_buffer_.push_back(packet);
349
350 if (async_) {
351 SignalReadEvent(this);
352 }
353 } else if (pmsg->message_id == MSG_ID_CONNECT) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800354 RTC_DCHECK(nullptr != pmsg->pdata);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000355 MessageAddress* data = static_cast<MessageAddress*>(pmsg->pdata);
deadbeef37f5ecf2017-02-27 14:06:41 -0800356 if (listen_queue_ != nullptr) {
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000357 listen_queue_->push_back(data->addr);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000358 if (async_) {
359 SignalReadEvent(this);
360 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000361 } else if ((SOCK_STREAM == type_) && (CS_CONNECTING == state_)) {
362 CompleteConnect(data->addr, true);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000363 } else {
Jonas Olssonabbe8412018-04-03 13:40:05 +0200364 RTC_LOG(LS_VERBOSE) << "Socket at " << local_addr_.ToString()
365 << " is not listening";
Niels Möllerc79bd432021-02-16 09:25:52 +0100366 server_->Disconnect(data->addr);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000367 }
368 delete data;
369 } else if (pmsg->message_id == MSG_ID_DISCONNECT) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700370 RTC_DCHECK(SOCK_STREAM == type_);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000371 if (CS_CLOSED != state_) {
372 int error = (CS_CONNECTING == state_) ? ECONNREFUSED : 0;
373 state_ = CS_CLOSED;
374 remote_addr_.Clear();
375 if (async_) {
376 SignalCloseEvent(this, error);
377 }
378 }
deadbeefed3b9862017-06-02 10:33:16 -0700379 } else if (pmsg->message_id == MSG_ID_SIGNALREADEVENT) {
380 if (!recv_buffer_.empty()) {
381 SignalReadEvent(this);
382 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000383 } else {
nisseeb4ca4e2017-01-12 02:24:27 -0800384 RTC_NOTREACHED();
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000385 }
386}
387
388int VirtualSocket::InitiateConnect(const SocketAddress& addr, bool use_delay) {
389 if (!remote_addr_.IsNil()) {
390 error_ = (CS_CONNECTED == state_) ? EISCONN : EINPROGRESS;
391 return -1;
392 }
393 if (local_addr_.IsNil()) {
394 // If there's no local address set, grab a random one in the correct AF.
395 int result = 0;
396 if (addr.ipaddr().family() == AF_INET) {
397 result = Bind(SocketAddress("0.0.0.0", 0));
398 } else if (addr.ipaddr().family() == AF_INET6) {
399 result = Bind(SocketAddress("::", 0));
400 }
401 if (result != 0) {
402 return result;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000403 }
404 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000405 if (type_ == SOCK_DGRAM) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000406 remote_addr_ = addr;
407 state_ = CS_CONNECTED;
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000408 } else {
409 int result = server_->Connect(this, addr, use_delay);
410 if (result != 0) {
411 error_ = EHOSTUNREACH;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000412 return -1;
413 }
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000414 state_ = CS_CONNECTING;
415 }
416 return 0;
417}
418
419void VirtualSocket::CompleteConnect(const SocketAddress& addr, bool notify) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700420 RTC_DCHECK(CS_CONNECTING == state_);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000421 remote_addr_ = addr;
422 state_ = CS_CONNECTED;
423 server_->AddConnection(remote_addr_, local_addr_, this);
424 if (async_ && notify) {
425 SignalConnectEvent(this);
426 }
427}
428
429int VirtualSocket::SendUdp(const void* pv,
430 size_t cb,
431 const SocketAddress& addr) {
432 // If we have not been assigned a local port, then get one.
433 if (local_addr_.IsNil()) {
434 local_addr_ = EmptySocketAddressWithFamily(addr.ipaddr().family());
435 int result = server_->Bind(this, &local_addr_);
436 if (result != 0) {
437 local_addr_.Clear();
438 error_ = EADDRINUSE;
439 return result;
440 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000441 }
442
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000443 // Send the data in a message to the appropriate socket.
444 return server_->SendUdp(this, static_cast<const char*>(pv), cb, addr);
445}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000446
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000447int VirtualSocket::SendTcp(const void* pv, size_t cb) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100448 size_t capacity = server_->send_buffer_capacity() - send_buffer_.size();
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000449 if (0 == capacity) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700450 ready_to_send_ = false;
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000451 error_ = EWOULDBLOCK;
452 return -1;
453 }
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000454 size_t consumed = std::min(cb, capacity);
guoweis@webrtc.org0eb6eec2014-12-17 22:03:33 +0000455 const char* cpv = static_cast<const char*>(pv);
456 send_buffer_.insert(send_buffer_.end(), cpv, cpv + consumed);
457 server_->SendTcp(this);
458 return static_cast<int>(consumed);
459}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000460
Taylor Brandstettere7536412016-09-09 13:16:15 -0700461void VirtualSocket::OnSocketServerReadyToSend() {
462 if (ready_to_send_) {
463 // This socket didn't encounter EWOULDBLOCK, so there's nothing to do.
464 return;
465 }
466 if (type_ == SOCK_DGRAM) {
467 ready_to_send_ = true;
468 SignalWriteEvent(this);
469 } else {
470 RTC_DCHECK(type_ == SOCK_STREAM);
471 // This will attempt to empty the full send buffer, and will fire
472 // SignalWriteEvent if successful.
473 server_->SendTcp(this);
474 }
475}
476
Niels Möllerc79bd432021-02-16 09:25:52 +0100477void VirtualSocket::SetToBlocked() {
478 CritScope cs(&crit_);
479 ready_to_send_ = false;
480 error_ = EWOULDBLOCK;
481}
482
483void VirtualSocket::UpdateRecv(size_t data_size) {
484 recv_buffer_size_ += data_size;
485}
486
487void VirtualSocket::UpdateSend(size_t data_size) {
488 size_t new_buffer_size = send_buffer_.size() - data_size;
489 // Avoid undefined access beyond the last element of the vector.
490 // This only happens when new_buffer_size is 0.
491 if (data_size < send_buffer_.size()) {
492 // memmove is required for potentially overlapping source/destination.
493 memmove(&send_buffer_[0], &send_buffer_[data_size], new_buffer_size);
494 }
495 send_buffer_.resize(new_buffer_size);
496}
497
498void VirtualSocket::MaybeSignalWriteEvent(size_t capacity) {
499 if (!ready_to_send_ && (send_buffer_.size() < capacity)) {
500 ready_to_send_ = true;
501 SignalWriteEvent(this);
502 }
503}
504
505uint32_t VirtualSocket::AddPacket(int64_t cur_time, size_t packet_size) {
506 network_size_ += packet_size;
507 uint32_t send_delay =
508 server_->SendDelay(static_cast<uint32_t>(network_size_));
509
510 NetworkEntry entry;
511 entry.size = packet_size;
512 entry.done_time = cur_time + send_delay;
513 network_.push_back(entry);
514
515 return send_delay;
516}
517
518int64_t VirtualSocket::UpdateOrderedDelivery(int64_t ts) {
519 // Ensure that new packets arrive after previous ones
520 ts = std::max(ts, last_delivery_time_);
521 // A socket should not have both ordered and unordered delivery, so its last
522 // delivery time only needs to be updated when it has ordered delivery.
523 last_delivery_time_ = ts;
524 return ts;
525}
526
527size_t VirtualSocket::PurgeNetworkPackets(int64_t cur_time) {
528 CritScope cs(&crit_);
529
530 while (!network_.empty() && (network_.front().done_time <= cur_time)) {
531 RTC_DCHECK(network_size_ >= network_.front().size);
532 network_size_ -= network_.front().size;
533 network_.pop_front();
534 }
535 return network_size_;
536}
537
deadbeef22e08142017-06-12 14:30:28 -0700538VirtualSocketServer::VirtualSocketServer() : VirtualSocketServer(nullptr) {}
539
Sebastian Janssond624c392019-04-17 10:36:03 +0200540VirtualSocketServer::VirtualSocketServer(ThreadProcessingFakeClock* fake_clock)
deadbeef22e08142017-06-12 14:30:28 -0700541 : fake_clock_(fake_clock),
deadbeef37f5ecf2017-02-27 14:06:41 -0800542 msg_queue_(nullptr),
Honghai Zhang82d78622016-05-06 11:29:15 -0700543 stop_on_idle_(false),
Honghai Zhang82d78622016-05-06 11:29:15 -0700544 next_ipv4_(kInitialNextIPv4),
545 next_ipv6_(kInitialNextIPv6),
546 next_port_(kFirstEphemeralPort),
547 bindings_(new AddressMap()),
548 connections_(new ConnectionMap()),
549 bandwidth_(0),
550 network_capacity_(kDefaultNetworkCapacity),
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000551 send_buffer_capacity_(kDefaultTcpBufferSize),
552 recv_buffer_capacity_(kDefaultTcpBufferSize),
Honghai Zhang82d78622016-05-06 11:29:15 -0700553 delay_mean_(0),
554 delay_stddev_(0),
555 delay_samples_(NUM_SAMPLES),
Honghai Zhang82d78622016-05-06 11:29:15 -0700556 drop_prob_(0.0) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000557 UpdateDelayDistribution();
558}
559
560VirtualSocketServer::~VirtualSocketServer() {
561 delete bindings_;
562 delete connections_;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000563}
564
565IPAddress VirtualSocketServer::GetNextIP(int family) {
566 if (family == AF_INET) {
567 IPAddress next_ip(next_ipv4_);
Yves Gerey665174f2018-06-19 15:03:05 +0200568 next_ipv4_.s_addr = HostToNetwork32(NetworkToHost32(next_ipv4_.s_addr) + 1);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000569 return next_ip;
570 } else if (family == AF_INET6) {
571 IPAddress next_ip(next_ipv6_);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200572 uint32_t* as_ints = reinterpret_cast<uint32_t*>(&next_ipv6_.s6_addr);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000573 as_ints[3] += 1;
574 return next_ip;
575 }
576 return IPAddress();
577}
578
Peter Boström0c4e06b2015-10-07 12:23:21 +0200579uint16_t VirtualSocketServer::GetNextPort() {
580 uint16_t port = next_port_;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000581 if (next_port_ < kLastEphemeralPort) {
582 ++next_port_;
583 } else {
584 next_port_ = kFirstEphemeralPort;
585 }
586 return port;
587}
588
Taylor Brandstettere7536412016-09-09 13:16:15 -0700589void VirtualSocketServer::SetSendingBlocked(bool blocked) {
590 if (blocked == sending_blocked_) {
591 // Unchanged; nothing to do.
592 return;
593 }
594 sending_blocked_ = blocked;
595 if (!sending_blocked_) {
596 // Sending was blocked, but is now unblocked. This signal gives sockets a
597 // chance to fire SignalWriteEvent, and for TCP, send buffered data.
598 SignalReadyToSend();
599 }
600}
601
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000602Socket* VirtualSocketServer::CreateSocket(int family, int type) {
603 return CreateSocketInternal(family, type);
604}
605
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000606AsyncSocket* VirtualSocketServer::CreateAsyncSocket(int family, int type) {
607 return CreateSocketInternal(family, type);
608}
609
610VirtualSocket* VirtualSocketServer::CreateSocketInternal(int family, int type) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100611 return new VirtualSocket(this, family, type, true);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000612}
613
Sebastian Jansson290de822020-01-09 14:20:23 +0100614void VirtualSocketServer::SetMessageQueue(Thread* msg_queue) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000615 msg_queue_ = msg_queue;
616 if (msg_queue_) {
Yves Gerey665174f2018-06-19 15:03:05 +0200617 msg_queue_->SignalQueueDestroyed.connect(
618 this, &VirtualSocketServer::OnMessageQueueDestroyed);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000619 }
620}
621
622bool VirtualSocketServer::Wait(int cmsWait, bool process_io) {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700623 RTC_DCHECK(msg_queue_ == Thread::Current());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000624 if (stop_on_idle_ && Thread::Current()->empty()) {
625 return false;
626 }
deadbeef98e186c2017-05-16 18:00:06 -0700627 // Note: we don't need to do anything with |process_io| since we don't have
628 // any real I/O. Received packets come in the form of queued messages, so
Sebastian Jansson290de822020-01-09 14:20:23 +0100629 // Thread will ensure WakeUp is called if another thread sends a
deadbeef98e186c2017-05-16 18:00:06 -0700630 // packet.
631 wakeup_.Wait(cmsWait);
632 return true;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000633}
634
635void VirtualSocketServer::WakeUp() {
deadbeef98e186c2017-05-16 18:00:06 -0700636 wakeup_.Set();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000637}
638
deadbeef5c3c1042017-08-04 15:01:57 -0700639void VirtualSocketServer::SetAlternativeLocalAddress(
640 const rtc::IPAddress& address,
641 const rtc::IPAddress& alternative) {
642 alternative_address_mapping_[address] = alternative;
643}
644
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000645bool VirtualSocketServer::ProcessMessagesUntilIdle() {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700646 RTC_DCHECK(msg_queue_ == Thread::Current());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000647 stop_on_idle_ = true;
648 while (!msg_queue_->empty()) {
deadbeef22e08142017-06-12 14:30:28 -0700649 if (fake_clock_) {
650 // If using a fake clock, advance it in millisecond increments until the
Bjorn Mellem6eb03b82017-06-13 15:07:41 -0700651 // queue is empty.
Danil Chapovalov0c626af2020-02-10 11:16:00 +0100652 fake_clock_->AdvanceTime(webrtc::TimeDelta::Millis(1));
deadbeef22e08142017-06-12 14:30:28 -0700653 } else {
654 // Otherwise, run a normal message loop.
655 Message msg;
656 if (msg_queue_->Get(&msg, Thread::kForever)) {
657 msg_queue_->Dispatch(&msg);
658 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000659 }
660 }
661 stop_on_idle_ = false;
662 return !msg_queue_->IsQuitting();
663}
664
Peter Boström0c4e06b2015-10-07 12:23:21 +0200665void VirtualSocketServer::SetNextPortForTesting(uint16_t port) {
jiayl@webrtc.org22406fc2014-09-09 15:44:05 +0000666 next_port_ = port;
667}
668
Guo-wei Shiehbe508a12015-04-06 12:48:47 -0700669bool VirtualSocketServer::CloseTcpConnections(
670 const SocketAddress& addr_local,
671 const SocketAddress& addr_remote) {
672 VirtualSocket* socket = LookupConnection(addr_local, addr_remote);
673 if (!socket) {
674 return false;
675 }
676 // Signal the close event on the local connection first.
677 socket->SignalCloseEvent(socket, 0);
678
679 // Trigger the remote connection's close event.
680 socket->Close();
681
682 return true;
683}
684
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000685int VirtualSocketServer::Bind(VirtualSocket* socket,
686 const SocketAddress& addr) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800687 RTC_DCHECK(nullptr != socket);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000688 // Address must be completely specified at this point
Taylor Brandstettere7536412016-09-09 13:16:15 -0700689 RTC_DCHECK(!IPIsUnspec(addr.ipaddr()));
690 RTC_DCHECK(addr.port() != 0);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000691
692 // Normalize the address (turns v6-mapped addresses into v4-addresses).
693 SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
694
695 AddressMap::value_type entry(normalized, socket);
Niels Möllerd44532a2021-02-18 14:38:14 +0100696 return bindings_->insert(entry).second ? 0 : -1;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000697}
698
699int VirtualSocketServer::Bind(VirtualSocket* socket, SocketAddress* addr) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800700 RTC_DCHECK(nullptr != socket);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000701
deadbeef5c3c1042017-08-04 15:01:57 -0700702 // Normalize the IP.
guoweis@webrtc.orgd3b453b2015-02-14 00:43:41 +0000703 if (!IPIsUnspec(addr->ipaddr())) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000704 addr->SetIP(addr->ipaddr().Normalized());
705 } else {
nisseeb4ca4e2017-01-12 02:24:27 -0800706 RTC_NOTREACHED();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000707 }
708
deadbeef5c3c1042017-08-04 15:01:57 -0700709 // If the IP appears in |alternative_address_mapping_|, meaning the test has
710 // configured sockets bound to this IP to actually use another IP, replace
711 // the IP here.
712 auto alternative = alternative_address_mapping_.find(addr->ipaddr());
713 if (alternative != alternative_address_mapping_.end()) {
714 addr->SetIP(alternative->second);
715 }
716
717 // Assign a port if not assigned.
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000718 if (addr->port() == 0) {
719 for (int i = 0; i < kEphemeralPortCount; ++i) {
720 addr->SetPort(GetNextPort());
721 if (bindings_->find(*addr) == bindings_->end()) {
722 break;
723 }
724 }
725 }
726
727 return Bind(socket, *addr);
728}
729
730VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
Yves Gerey665174f2018-06-19 15:03:05 +0200731 SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000732 AddressMap::iterator it = bindings_->find(normalized);
Guo-wei Shieh38f88932015-08-13 22:24:02 -0700733 if (it != bindings_->end()) {
734 return it->second;
735 }
736
737 IPAddress default_ip = GetDefaultRoute(addr.ipaddr().family());
738 if (!IPIsUnspec(default_ip) && addr.ipaddr() == default_ip) {
739 // If we can't find a binding for the packet which is sent to the interface
740 // corresponding to the default route, it should match a binding with the
741 // correct port to the any address.
742 SocketAddress sock_addr =
743 EmptySocketAddressWithFamily(addr.ipaddr().family());
744 sock_addr.SetPort(addr.port());
745 return LookupBinding(sock_addr);
746 }
747
748 return nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000749}
750
751int VirtualSocketServer::Unbind(const SocketAddress& addr,
752 VirtualSocket* socket) {
Yves Gerey665174f2018-06-19 15:03:05 +0200753 SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
Taylor Brandstettere7536412016-09-09 13:16:15 -0700754 RTC_DCHECK((*bindings_)[normalized] == socket);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000755 bindings_->erase(bindings_->find(normalized));
756 return 0;
757}
758
759void VirtualSocketServer::AddConnection(const SocketAddress& local,
760 const SocketAddress& remote,
761 VirtualSocket* remote_socket) {
762 // Add this socket pair to our routing table. This will allow
763 // multiple clients to connect to the same server address.
Yves Gerey665174f2018-06-19 15:03:05 +0200764 SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
765 SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000766 SocketAddressPair address_pair(local_normalized, remote_normalized);
Yves Gerey665174f2018-06-19 15:03:05 +0200767 connections_->insert(std::pair<SocketAddressPair, VirtualSocket*>(
768 address_pair, remote_socket));
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000769}
770
771VirtualSocket* VirtualSocketServer::LookupConnection(
772 const SocketAddress& local,
773 const SocketAddress& remote) {
Yves Gerey665174f2018-06-19 15:03:05 +0200774 SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
775 SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000776 SocketAddressPair address_pair(local_normalized, remote_normalized);
777 ConnectionMap::iterator it = connections_->find(address_pair);
deadbeef37f5ecf2017-02-27 14:06:41 -0800778 return (connections_->end() != it) ? it->second : nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000779}
780
781void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
782 const SocketAddress& remote) {
Yves Gerey665174f2018-06-19 15:03:05 +0200783 SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
784 SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000785 SocketAddressPair address_pair(local_normalized, remote_normalized);
786 connections_->erase(address_pair);
787}
788
789static double Random() {
790 return static_cast<double>(rand()) / RAND_MAX;
791}
792
793int VirtualSocketServer::Connect(VirtualSocket* socket,
794 const SocketAddress& remote_addr,
795 bool use_delay) {
Honghai Zhangc67e0f52016-09-19 16:57:37 -0700796 uint32_t delay = use_delay ? GetTransitDelay(socket) : 0;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000797 VirtualSocket* remote = LookupBinding(remote_addr);
798 if (!CanInteractWith(socket, remote)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100799 RTC_LOG(LS_INFO) << "Address family mismatch between "
Jonas Olssonabbe8412018-04-03 13:40:05 +0200800 << socket->GetLocalAddress().ToString() << " and "
801 << remote_addr.ToString();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000802 return -1;
803 }
deadbeef37f5ecf2017-02-27 14:06:41 -0800804 if (remote != nullptr) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000805 SocketAddress addr = socket->GetLocalAddress();
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700806 msg_queue_->PostDelayed(RTC_FROM_HERE, delay, remote, MSG_ID_CONNECT,
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000807 new MessageAddress(addr));
808 } else {
Jonas Olssonabbe8412018-04-03 13:40:05 +0200809 RTC_LOG(LS_INFO) << "No one listening at " << remote_addr.ToString();
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700810 msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000811 }
812 return 0;
813}
814
815bool VirtualSocketServer::Disconnect(VirtualSocket* socket) {
816 if (socket) {
Taylor Brandstetter716d07a2016-06-27 14:07:41 -0700817 // If we simulate packets being delayed, we should simulate the
818 // equivalent of a FIN being delayed as well.
Honghai Zhangc67e0f52016-09-19 16:57:37 -0700819 uint32_t delay = GetTransitDelay(socket);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000820 // Remove the mapping.
Taylor Brandstetter716d07a2016-06-27 14:07:41 -0700821 msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000822 return true;
823 }
824 return false;
825}
826
Niels Möllerc79bd432021-02-16 09:25:52 +0100827bool VirtualSocketServer::Disconnect(const SocketAddress& addr) {
828 return Disconnect(LookupBinding(addr));
829}
830
831bool VirtualSocketServer::Disconnect(const SocketAddress& local_addr,
832 const SocketAddress& remote_addr) {
833 // Disconnect remote socket, check if it is a child of a server socket.
834 VirtualSocket* socket = LookupConnection(local_addr, remote_addr);
835 if (!socket) {
836 // Not a server socket child, then see if it is bound.
837 // TODO(tbd): If this is indeed a server socket that has no
838 // children this will cause the server socket to be
839 // closed. This might lead to unexpected results, how to fix this?
840 socket = LookupBinding(remote_addr);
841 }
842 Disconnect(socket);
843
844 // Remove mapping for both directions.
845 RemoveConnection(remote_addr, local_addr);
846 RemoveConnection(local_addr, remote_addr);
847 return socket != nullptr;
848}
849
850void VirtualSocketServer::CancelConnects(VirtualSocket* socket) {
851 MessageList msgs;
852 if (msg_queue_) {
853 msg_queue_->Clear(socket, MSG_ID_CONNECT, &msgs);
854 }
855 for (MessageList::iterator it = msgs.begin(); it != msgs.end(); ++it) {
856 RTC_DCHECK(nullptr != it->pdata);
857 MessageAddress* data = static_cast<MessageAddress*>(it->pdata);
858 SocketAddress local_addr = socket->GetLocalAddress();
859 // Lookup remote side.
860 VirtualSocket* socket = LookupConnection(local_addr, data->addr);
861 if (socket) {
862 // Server socket, remote side is a socket retreived by
863 // accept. Accepted sockets are not bound so we will not
864 // find it by looking in the bindings table.
865 Disconnect(socket);
866 RemoveConnection(local_addr, data->addr);
867 } else {
868 Disconnect(data->addr);
869 }
870 delete data;
871 }
872}
873
874void VirtualSocketServer::Clear(VirtualSocket* socket) {
875 // Clear incoming packets and disconnect messages
876 if (msg_queue_) {
877 msg_queue_->Clear(socket);
878 }
879}
880
881void VirtualSocketServer::ProcessOneMessage() {
882 Message msg;
883 msg_queue_->Get(&msg);
884 msg_queue_->Dispatch(&msg);
885}
886
887void VirtualSocketServer::PostSignalReadEvent(VirtualSocket* socket) {
888 // Clear the message so it doesn't end up posted multiple times.
889 msg_queue_->Clear(socket, MSG_ID_SIGNALREADEVENT);
890 msg_queue_->Post(RTC_FROM_HERE, socket, MSG_ID_SIGNALREADEVENT);
891}
892
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000893int VirtualSocketServer::SendUdp(VirtualSocket* socket,
Yves Gerey665174f2018-06-19 15:03:05 +0200894 const char* data,
895 size_t data_size,
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000896 const SocketAddress& remote_addr) {
Taylor Brandstetter389a97c2018-01-03 16:26:06 -0800897 ++sent_packets_;
Taylor Brandstettere7536412016-09-09 13:16:15 -0700898 if (sending_blocked_) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100899 socket->SetToBlocked();
Taylor Brandstettere7536412016-09-09 13:16:15 -0700900 return -1;
901 }
902
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000903 // See if we want to drop this packet.
904 if (Random() < drop_prob_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100905 RTC_LOG(LS_VERBOSE) << "Dropping packet: bad luck";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000906 return static_cast<int>(data_size);
907 }
908
909 VirtualSocket* recipient = LookupBinding(remote_addr);
910 if (!recipient) {
911 // Make a fake recipient for address family checking.
jbauch555604a2016-04-26 03:13:22 -0700912 std::unique_ptr<VirtualSocket> dummy_socket(
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000913 CreateSocketInternal(AF_INET, SOCK_DGRAM));
914 dummy_socket->SetLocalAddress(remote_addr);
915 if (!CanInteractWith(socket, dummy_socket.get())) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100916 RTC_LOG(LS_VERBOSE) << "Incompatible address families: "
Jonas Olssonabbe8412018-04-03 13:40:05 +0200917 << socket->GetLocalAddress().ToString() << " and "
918 << remote_addr.ToString();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000919 return -1;
920 }
Jonas Olssonabbe8412018-04-03 13:40:05 +0200921 RTC_LOG(LS_VERBOSE) << "No one listening at " << remote_addr.ToString();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000922 return static_cast<int>(data_size);
923 }
924
925 if (!CanInteractWith(socket, recipient)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100926 RTC_LOG(LS_VERBOSE) << "Incompatible address families: "
Jonas Olssonabbe8412018-04-03 13:40:05 +0200927 << socket->GetLocalAddress().ToString() << " and "
928 << remote_addr.ToString();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000929 return -1;
930 }
931
Taylor Brandstettere7536412016-09-09 13:16:15 -0700932 {
Taylor Brandstettere7536412016-09-09 13:16:15 -0700933 int64_t cur_time = TimeMillis();
Niels Möllerc79bd432021-02-16 09:25:52 +0100934 size_t network_size = socket->PurgeNetworkPackets(cur_time);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000935
Taylor Brandstettere7536412016-09-09 13:16:15 -0700936 // Determine whether we have enough bandwidth to accept this packet. To do
937 // this, we need to update the send queue. Once we know it's current size,
938 // we know whether we can fit this packet.
939 //
940 // NOTE: There are better algorithms for maintaining such a queue (such as
941 // "Derivative Random Drop"); however, this algorithm is a more accurate
942 // simulation of what a normal network would do.
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000943
Taylor Brandstettere7536412016-09-09 13:16:15 -0700944 size_t packet_size = data_size + UDP_HEADER_SIZE;
Niels Möllerc79bd432021-02-16 09:25:52 +0100945 if (network_size + packet_size > network_capacity_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100946 RTC_LOG(LS_VERBOSE) << "Dropping packet: network capacity exceeded";
Taylor Brandstettere7536412016-09-09 13:16:15 -0700947 return static_cast<int>(data_size);
948 }
949
950 AddPacketToNetwork(socket, recipient, cur_time, data, data_size,
951 UDP_HEADER_SIZE, false);
952
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000953 return static_cast<int>(data_size);
954 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000955}
956
957void VirtualSocketServer::SendTcp(VirtualSocket* socket) {
Taylor Brandstetter389a97c2018-01-03 16:26:06 -0800958 ++sent_packets_;
Taylor Brandstettere7536412016-09-09 13:16:15 -0700959 if (sending_blocked_) {
960 // Eventually the socket's buffer will fill and VirtualSocket::SendTcp will
961 // set EWOULDBLOCK.
962 return;
963 }
964
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000965 // TCP can't send more data than will fill up the receiver's buffer.
966 // We track the data that is in the buffer plus data in flight using the
967 // recipient's recv_buffer_size_. Anything beyond that must be stored in the
968 // sender's buffer. We will trigger the buffered data to be sent when data
969 // is read from the recv_buffer.
970
971 // Lookup the local/remote pair in the connections table.
Yves Gerey665174f2018-06-19 15:03:05 +0200972 VirtualSocket* recipient =
Niels Möllerc79bd432021-02-16 09:25:52 +0100973 LookupConnection(socket->GetLocalAddress(), socket->GetRemoteAddress());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000974 if (!recipient) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100975 RTC_LOG(LS_VERBOSE) << "Sending data to no one.";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000976 return;
977 }
978
Honghai Zhang82d78622016-05-06 11:29:15 -0700979 int64_t cur_time = TimeMillis();
Niels Möllerc79bd432021-02-16 09:25:52 +0100980 socket->PurgeNetworkPackets(cur_time);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000981
982 while (true) {
Niels Möllerc79bd432021-02-16 09:25:52 +0100983 size_t available = recv_buffer_capacity_ - recipient->recv_buffer_size();
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000984 size_t max_data_size =
985 std::min<size_t>(available, TCP_MSS - TCP_HEADER_SIZE);
Niels Möllerc79bd432021-02-16 09:25:52 +0100986 size_t data_size = std::min(socket->send_buffer_size(), max_data_size);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000987 if (0 == data_size)
988 break;
989
Niels Möllerc79bd432021-02-16 09:25:52 +0100990 AddPacketToNetwork(socket, recipient, cur_time, socket->send_buffer_data(),
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000991 data_size, TCP_HEADER_SIZE, true);
Niels Möllerc79bd432021-02-16 09:25:52 +0100992 recipient->UpdateRecv(data_size);
993 socket->UpdateSend(data_size);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000994 }
995
Niels Möllerc79bd432021-02-16 09:25:52 +0100996 socket->MaybeSignalWriteEvent(send_buffer_capacity_);
997}
998
999void VirtualSocketServer::SendTcp(const SocketAddress& addr) {
1000 VirtualSocket* sender = LookupBinding(addr);
1001 RTC_DCHECK(nullptr != sender);
1002 SendTcp(sender);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001003}
1004
1005void VirtualSocketServer::AddPacketToNetwork(VirtualSocket* sender,
1006 VirtualSocket* recipient,
Honghai Zhang82d78622016-05-06 11:29:15 -07001007 int64_t cur_time,
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001008 const char* data,
1009 size_t data_size,
1010 size_t header_size,
1011 bool ordered) {
Niels Möllerc79bd432021-02-16 09:25:52 +01001012 uint32_t send_delay = sender->AddPacket(cur_time, data_size + header_size);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001013
1014 // Find the delay for crossing the many virtual hops of the network.
Honghai Zhangc67e0f52016-09-19 16:57:37 -07001015 uint32_t transit_delay = GetTransitDelay(sender);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001016
Guo-wei Shieh38f88932015-08-13 22:24:02 -07001017 // When the incoming packet is from a binding of the any address, translate it
1018 // to the default route here such that the recipient will see the default
1019 // route.
Niels Möllerc79bd432021-02-16 09:25:52 +01001020 SocketAddress sender_addr = sender->GetLocalAddress();
Guo-wei Shieh38f88932015-08-13 22:24:02 -07001021 IPAddress default_ip = GetDefaultRoute(sender_addr.ipaddr().family());
1022 if (sender_addr.IsAnyIP() && !IPIsUnspec(default_ip)) {
1023 sender_addr.SetIP(default_ip);
1024 }
1025
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001026 // Post the packet as a message to be delivered (on our own thread)
Guo-wei Shieh38f88932015-08-13 22:24:02 -07001027 Packet* p = new Packet(data, data_size, sender_addr);
1028
Honghai Zhang82d78622016-05-06 11:29:15 -07001029 int64_t ts = TimeAfter(send_delay + transit_delay);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001030 if (ordered) {
Niels Möllerc79bd432021-02-16 09:25:52 +01001031 ts = sender->UpdateOrderedDelivery(ts);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001032 }
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001033 msg_queue_->PostAt(RTC_FROM_HERE, ts, recipient, MSG_ID_PACKET, p);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001034}
1035
Peter Boström0c4e06b2015-10-07 12:23:21 +02001036uint32_t VirtualSocketServer::SendDelay(uint32_t size) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001037 if (bandwidth_ == 0)
1038 return 0;
1039 else
1040 return 1000 * size / bandwidth_;
1041}
1042
1043#if 0
1044void PrintFunction(std::vector<std::pair<double, double> >* f) {
1045 return;
1046 double sum = 0;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001047 for (uint32_t i = 0; i < f->size(); ++i) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001048 std::cout << (*f)[i].first << '\t' << (*f)[i].second << std::endl;
1049 sum += (*f)[i].second;
1050 }
1051 if (!f->empty()) {
1052 const double mean = sum / f->size();
1053 double sum_sq_dev = 0;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001054 for (uint32_t i = 0; i < f->size(); ++i) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001055 double dev = (*f)[i].second - mean;
1056 sum_sq_dev += dev * dev;
1057 }
1058 std::cout << "Mean = " << mean << " StdDev = "
1059 << sqrt(sum_sq_dev / f->size()) << std::endl;
1060 }
1061}
1062#endif // <unused>
1063
1064void VirtualSocketServer::UpdateDelayDistribution() {
Niels Möller983627c2021-02-09 15:12:28 +01001065 delay_dist_ = CreateDistribution(delay_mean_, delay_stddev_, delay_samples_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001066}
1067
1068static double PI = 4 * atan(1.0);
1069
1070static double Normal(double x, double mean, double stddev) {
1071 double a = (x - mean) * (x - mean) / (2 * stddev * stddev);
1072 return exp(-a) / (stddev * sqrt(2 * PI));
1073}
1074
1075#if 0 // static unused gives a warning
1076static double Pareto(double x, double min, double k) {
1077 if (x < min)
1078 return 0;
1079 else
1080 return k * std::pow(min, k) / std::pow(x, k+1);
1081}
1082#endif
1083
Niels Möller983627c2021-02-09 15:12:28 +01001084std::unique_ptr<VirtualSocketServer::Function>
1085VirtualSocketServer::CreateDistribution(uint32_t mean,
1086 uint32_t stddev,
1087 uint32_t samples) {
1088 auto f = std::make_unique<Function>();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001089
1090 if (0 == stddev) {
1091 f->push_back(Point(mean, 1.0));
1092 } else {
1093 double start = 0;
1094 if (mean >= 4 * static_cast<double>(stddev))
1095 start = mean - 4 * static_cast<double>(stddev);
1096 double end = mean + 4 * static_cast<double>(stddev);
1097
Peter Boström0c4e06b2015-10-07 12:23:21 +02001098 for (uint32_t i = 0; i < samples; i++) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001099 double x = start + (end - start) * i / (samples - 1);
1100 double y = Normal(x, mean, stddev);
1101 f->push_back(Point(x, y));
1102 }
1103 }
Niels Möller983627c2021-02-09 15:12:28 +01001104 return Resample(Invert(Accumulate(std::move(f))), 0, 1, samples);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001105}
1106
Honghai Zhangc67e0f52016-09-19 16:57:37 -07001107uint32_t VirtualSocketServer::GetTransitDelay(Socket* socket) {
1108 // Use the delay based on the address if it is set.
1109 auto iter = delay_by_ip_.find(socket->GetLocalAddress().ipaddr());
1110 if (iter != delay_by_ip_.end()) {
1111 return static_cast<uint32_t>(iter->second);
1112 }
1113 // Otherwise, use the delay from the distribution distribution.
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001114 size_t index = rand() % delay_dist_->size();
1115 double delay = (*delay_dist_)[index].second;
Mirko Bonadei675513b2017-11-09 11:09:25 +01001116 // RTC_LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001117 return static_cast<uint32_t>(delay);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001118}
1119
1120struct FunctionDomainCmp {
1121 bool operator()(const VirtualSocketServer::Point& p1,
Yves Gerey665174f2018-06-19 15:03:05 +02001122 const VirtualSocketServer::Point& p2) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001123 return p1.first < p2.first;
1124 }
1125 bool operator()(double v1, const VirtualSocketServer::Point& p2) {
1126 return v1 < p2.first;
1127 }
1128 bool operator()(const VirtualSocketServer::Point& p1, double v2) {
1129 return p1.first < v2;
1130 }
1131};
1132
Niels Möller983627c2021-02-09 15:12:28 +01001133std::unique_ptr<VirtualSocketServer::Function> VirtualSocketServer::Accumulate(
1134 std::unique_ptr<Function> f) {
Taylor Brandstettere7536412016-09-09 13:16:15 -07001135 RTC_DCHECK(f->size() >= 1);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001136 double v = 0;
1137 for (Function::size_type i = 0; i < f->size() - 1; ++i) {
1138 double dx = (*f)[i + 1].first - (*f)[i].first;
1139 double avgy = ((*f)[i + 1].second + (*f)[i].second) / 2;
1140 (*f)[i].second = v;
1141 v = v + dx * avgy;
1142 }
Yves Gerey665174f2018-06-19 15:03:05 +02001143 (*f)[f->size() - 1].second = v;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001144 return f;
1145}
1146
Niels Möller983627c2021-02-09 15:12:28 +01001147std::unique_ptr<VirtualSocketServer::Function> VirtualSocketServer::Invert(
1148 std::unique_ptr<Function> f) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001149 for (Function::size_type i = 0; i < f->size(); ++i)
1150 std::swap((*f)[i].first, (*f)[i].second);
1151
Steve Anton2acd1632019-03-25 13:48:30 -07001152 absl::c_sort(*f, FunctionDomainCmp());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001153 return f;
1154}
1155
Niels Möller983627c2021-02-09 15:12:28 +01001156std::unique_ptr<VirtualSocketServer::Function> VirtualSocketServer::Resample(
1157 std::unique_ptr<Function> f,
1158 double x1,
1159 double x2,
1160 uint32_t samples) {
1161 auto g = std::make_unique<Function>();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001162
1163 for (size_t i = 0; i < samples; i++) {
1164 double x = x1 + (x2 - x1) * i / (samples - 1);
Niels Möller983627c2021-02-09 15:12:28 +01001165 double y = Evaluate(f.get(), x);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001166 g->push_back(Point(x, y));
1167 }
1168
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001169 return g;
1170}
1171
Niels Möller983627c2021-02-09 15:12:28 +01001172double VirtualSocketServer::Evaluate(const Function* f, double x) {
1173 Function::const_iterator iter =
1174 absl::c_lower_bound(*f, x, FunctionDomainCmp());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001175 if (iter == f->begin()) {
1176 return (*f)[0].second;
1177 } else if (iter == f->end()) {
Taylor Brandstettere7536412016-09-09 13:16:15 -07001178 RTC_DCHECK(f->size() >= 1);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001179 return (*f)[f->size() - 1].second;
1180 } else if (iter->first == x) {
1181 return iter->second;
1182 } else {
1183 double x1 = (iter - 1)->first;
1184 double y1 = (iter - 1)->second;
1185 double x2 = iter->first;
1186 double y2 = iter->second;
1187 return y1 + (y2 - y1) * (x - x1) / (x2 - x1);
1188 }
1189}
1190
1191bool VirtualSocketServer::CanInteractWith(VirtualSocket* local,
1192 VirtualSocket* remote) {
1193 if (!local || !remote) {
1194 return false;
1195 }
1196 IPAddress local_ip = local->GetLocalAddress().ipaddr();
1197 IPAddress remote_ip = remote->GetLocalAddress().ipaddr();
1198 IPAddress local_normalized = local_ip.Normalized();
1199 IPAddress remote_normalized = remote_ip.Normalized();
1200 // Check if the addresses are the same family after Normalization (turns
1201 // mapped IPv6 address into IPv4 addresses).
1202 // This will stop unmapped V6 addresses from talking to mapped V6 addresses.
1203 if (local_normalized.family() == remote_normalized.family()) {
1204 return true;
1205 }
1206
1207 // If ip1 is IPv4 and ip2 is :: and ip2 is not IPV6_V6ONLY.
1208 int remote_v6_only = 0;
1209 remote->GetOption(Socket::OPT_IPV6_V6ONLY, &remote_v6_only);
1210 if (local_ip.family() == AF_INET && !remote_v6_only && IPIsAny(remote_ip)) {
1211 return true;
1212 }
1213 // Same check, backwards.
1214 int local_v6_only = 0;
1215 local->GetOption(Socket::OPT_IPV6_V6ONLY, &local_v6_only);
1216 if (remote_ip.family() == AF_INET && !local_v6_only && IPIsAny(local_ip)) {
1217 return true;
1218 }
1219
1220 // Check to see if either socket was explicitly bound to IPv6-any.
1221 // These sockets can talk with anyone.
1222 if (local_ip.family() == AF_INET6 && local->was_any()) {
1223 return true;
1224 }
1225 if (remote_ip.family() == AF_INET6 && remote->was_any()) {
1226 return true;
1227 }
1228
1229 return false;
1230}
1231
Guo-wei Shieh38f88932015-08-13 22:24:02 -07001232IPAddress VirtualSocketServer::GetDefaultRoute(int family) {
1233 if (family == AF_INET) {
1234 return default_route_v4_;
1235 }
1236 if (family == AF_INET6) {
1237 return default_route_v6_;
1238 }
1239 return IPAddress();
1240}
1241void VirtualSocketServer::SetDefaultRoute(const IPAddress& from_addr) {
henrikg91d6ede2015-09-17 00:24:34 -07001242 RTC_DCHECK(!IPIsAny(from_addr));
Guo-wei Shieh38f88932015-08-13 22:24:02 -07001243 if (from_addr.family() == AF_INET) {
1244 default_route_v4_ = from_addr;
1245 } else if (from_addr.family() == AF_INET6) {
1246 default_route_v6_ = from_addr;
1247 }
1248}
1249
henrike@webrtc.orgf0488722014-05-13 18:00:26 +00001250} // namespace rtc