blob: 7be7ffe2c9f6f422b1733e18038982988322b707 [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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "rtc_base/win32socketserver.h"
andresp@webrtc.orgff689be2015-02-12 11:54:26 +000012
13#include <algorithm>
14#include <ws2tcpip.h> // NOLINT
15
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020016#include "rtc_base/byteorder.h"
17#include "rtc_base/checks.h"
18#include "rtc_base/logging.h"
19#include "rtc_base/win32window.h"
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000020
21namespace rtc {
22
23///////////////////////////////////////////////////////////////////////////////
24// Win32Socket
25///////////////////////////////////////////////////////////////////////////////
26
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000027// TODO: Enable for production builds also? Use FormatMessage?
tfarinaa41ab932015-10-30 16:08:48 -070028#if !defined(NDEBUG)
henrike@webrtc.orgf0488722014-05-13 18:00:26 +000029LPCSTR WSAErrorToString(int error, LPCSTR *description_result) {
30 LPCSTR string = "Unspecified";
31 LPCSTR description = "Unspecified description";
32 switch (error) {
33 case ERROR_SUCCESS:
34 string = "SUCCESS";
35 description = "Operation succeeded";
36 break;
37 case WSAEWOULDBLOCK:
38 string = "WSAEWOULDBLOCK";
39 description = "Using a non-blocking socket, will notify later";
40 break;
41 case WSAEACCES:
42 string = "WSAEACCES";
43 description = "Access denied, or sharing violation";
44 break;
45 case WSAEADDRNOTAVAIL:
46 string = "WSAEADDRNOTAVAIL";
47 description = "Address is not valid in this context";
48 break;
49 case WSAENETDOWN:
50 string = "WSAENETDOWN";
51 description = "Network is down";
52 break;
53 case WSAENETUNREACH:
54 string = "WSAENETUNREACH";
55 description = "Network is up, but unreachable";
56 break;
57 case WSAENETRESET:
58 string = "WSANETRESET";
59 description = "Connection has been reset due to keep-alive activity";
60 break;
61 case WSAECONNABORTED:
62 string = "WSAECONNABORTED";
63 description = "Aborted by host";
64 break;
65 case WSAECONNRESET:
66 string = "WSAECONNRESET";
67 description = "Connection reset by host";
68 break;
69 case WSAETIMEDOUT:
70 string = "WSAETIMEDOUT";
71 description = "Timed out, host failed to respond";
72 break;
73 case WSAECONNREFUSED:
74 string = "WSAECONNREFUSED";
75 description = "Host actively refused connection";
76 break;
77 case WSAEHOSTDOWN:
78 string = "WSAEHOSTDOWN";
79 description = "Host is down";
80 break;
81 case WSAEHOSTUNREACH:
82 string = "WSAEHOSTUNREACH";
83 description = "Host is unreachable";
84 break;
85 case WSAHOST_NOT_FOUND:
86 string = "WSAHOST_NOT_FOUND";
87 description = "No such host is known";
88 break;
89 }
90 if (description_result) {
91 *description_result = description;
92 }
93 return string;
94}
95
96void ReportWSAError(LPCSTR context, int error, const SocketAddress& address) {
97 LPCSTR description_string;
98 LPCSTR error_string = WSAErrorToString(error, &description_string);
Mirko Bonadei675513b2017-11-09 11:09:25 +010099 RTC_LOG(LS_INFO) << context << " = " << error << " (" << error_string << ":"
100 << description_string << ") [" << address.ToString() << "]";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000101}
102#else
103void ReportWSAError(LPCSTR context, int error, const SocketAddress& address) {}
104#endif
105
106/////////////////////////////////////////////////////////////////////////////
107// Win32Socket::EventSink
108/////////////////////////////////////////////////////////////////////////////
109
110#define WM_SOCKETNOTIFY (WM_USER + 50)
111#define WM_DNSNOTIFY (WM_USER + 51)
112
113struct Win32Socket::DnsLookup {
114 HANDLE handle;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200115 uint16_t port;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000116 char buffer[MAXGETHOSTSTRUCT];
117};
118
119class Win32Socket::EventSink : public Win32Window {
120 public:
121 explicit EventSink(Win32Socket * parent) : parent_(parent) { }
122
123 void Dispose();
124
Steve Anton9de3aac2017-10-24 10:08:26 -0700125 bool OnMessage(UINT uMsg,
126 WPARAM wParam,
127 LPARAM lParam,
128 LRESULT& result) override;
129 void OnNcDestroy() override;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000130
131 private:
132 bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
133 bool OnDnsNotify(WPARAM wParam, LPARAM lParam, LRESULT& result);
134
135 Win32Socket * parent_;
136};
137
138void Win32Socket::EventSink::Dispose() {
deadbeef37f5ecf2017-02-27 14:06:41 -0800139 parent_ = nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000140 if (::IsWindow(handle())) {
141 ::DestroyWindow(handle());
142 } else {
143 delete this;
144 }
145}
146
147bool Win32Socket::EventSink::OnMessage(UINT uMsg, WPARAM wParam,
148 LPARAM lParam, LRESULT& result) {
149 switch (uMsg) {
150 case WM_SOCKETNOTIFY:
151 case WM_TIMER:
152 return OnSocketNotify(uMsg, wParam, lParam, result);
153 case WM_DNSNOTIFY:
154 return OnDnsNotify(wParam, lParam, result);
155 }
156 return false;
157}
158
159bool Win32Socket::EventSink::OnSocketNotify(UINT uMsg, WPARAM wParam,
160 LPARAM lParam, LRESULT& result) {
161 result = 0;
162
163 int wsa_event = WSAGETSELECTEVENT(lParam);
164 int wsa_error = WSAGETSELECTERROR(lParam);
165
166 // Treat connect timeouts as close notifications
167 if (uMsg == WM_TIMER) {
168 wsa_event = FD_CLOSE;
169 wsa_error = WSAETIMEDOUT;
170 }
171
172 if (parent_)
173 parent_->OnSocketNotify(static_cast<SOCKET>(wParam), wsa_event, wsa_error);
174 return true;
175}
176
177bool Win32Socket::EventSink::OnDnsNotify(WPARAM wParam, LPARAM lParam,
178 LRESULT& result) {
179 result = 0;
180
181 int error = WSAGETASYNCERROR(lParam);
182 if (parent_)
183 parent_->OnDnsNotify(reinterpret_cast<HANDLE>(wParam), error);
184 return true;
185}
186
187void Win32Socket::EventSink::OnNcDestroy() {
188 if (parent_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100189 RTC_LOG(LS_ERROR) << "EventSink hwnd is being destroyed, but the event sink"
190 " hasn't yet been disposed.";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000191 } else {
192 delete this;
193 }
194}
195
196/////////////////////////////////////////////////////////////////////////////
197// Win32Socket
198/////////////////////////////////////////////////////////////////////////////
199
200Win32Socket::Win32Socket()
deadbeef37f5ecf2017-02-27 14:06:41 -0800201 : socket_(INVALID_SOCKET),
202 error_(0),
203 state_(CS_CLOSED),
204 connect_time_(0),
205 closing_(false),
206 close_error_(0),
207 sink_(nullptr),
208 dns_(nullptr) {}
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000209
210Win32Socket::~Win32Socket() {
211 Close();
212}
213
214bool Win32Socket::CreateT(int family, int type) {
215 Close();
216 int proto = (SOCK_DGRAM == type) ? IPPROTO_UDP : IPPROTO_TCP;
deadbeef37f5ecf2017-02-27 14:06:41 -0800217 socket_ = ::WSASocket(family, type, proto, nullptr, 0, 0);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000218 if (socket_ == INVALID_SOCKET) {
219 UpdateLastError();
220 return false;
221 }
222 if ((SOCK_DGRAM == type) && !SetAsync(FD_READ | FD_WRITE)) {
223 return false;
224 }
225 return true;
226}
227
228int Win32Socket::Attach(SOCKET s) {
nisseede5da42017-01-12 05:15:36 -0800229 RTC_DCHECK(socket_ == INVALID_SOCKET);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000230 if (socket_ != INVALID_SOCKET)
231 return SOCKET_ERROR;
232
nisseede5da42017-01-12 05:15:36 -0800233 RTC_DCHECK(s != INVALID_SOCKET);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000234 if (s == INVALID_SOCKET)
235 return SOCKET_ERROR;
236
237 socket_ = s;
238 state_ = CS_CONNECTED;
239
240 if (!SetAsync(FD_READ | FD_WRITE | FD_CLOSE))
241 return SOCKET_ERROR;
242
243 return 0;
244}
245
246void Win32Socket::SetTimeout(int ms) {
247 if (sink_)
248 ::SetTimer(sink_->handle(), 1, ms, 0);
249}
250
251SocketAddress Win32Socket::GetLocalAddress() const {
252 sockaddr_storage addr = {0};
253 socklen_t addrlen = sizeof(addr);
254 int result = ::getsockname(socket_, reinterpret_cast<sockaddr*>(&addr),
255 &addrlen);
256 SocketAddress address;
257 if (result >= 0) {
258 SocketAddressFromSockAddrStorage(addr, &address);
259 } else {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100260 RTC_LOG(LS_WARNING) << "GetLocalAddress: unable to get local addr, socket="
261 << socket_;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000262 }
263 return address;
264}
265
266SocketAddress Win32Socket::GetRemoteAddress() const {
267 sockaddr_storage addr = {0};
268 socklen_t addrlen = sizeof(addr);
269 int result = ::getpeername(socket_, reinterpret_cast<sockaddr*>(&addr),
270 &addrlen);
271 SocketAddress address;
272 if (result >= 0) {
273 SocketAddressFromSockAddrStorage(addr, &address);
274 } else {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100275 RTC_LOG(LS_WARNING)
276 << "GetRemoteAddress: unable to get remote addr, socket=" << socket_;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000277 }
278 return address;
279}
280
281int Win32Socket::Bind(const SocketAddress& addr) {
nisseede5da42017-01-12 05:15:36 -0800282 RTC_DCHECK(socket_ != INVALID_SOCKET);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000283 if (socket_ == INVALID_SOCKET)
284 return SOCKET_ERROR;
285
286 sockaddr_storage saddr;
287 size_t len = addr.ToSockAddrStorage(&saddr);
288 int err = ::bind(socket_,
289 reinterpret_cast<sockaddr*>(&saddr),
290 static_cast<int>(len));
291 UpdateLastError();
292 return err;
293}
294
295int Win32Socket::Connect(const SocketAddress& addr) {
296 if (state_ != CS_CLOSED) {
297 SetError(EALREADY);
298 return SOCKET_ERROR;
299 }
300
301 if (!addr.IsUnresolvedIP()) {
302 return DoConnect(addr);
303 }
304
Mirko Bonadei675513b2017-11-09 11:09:25 +0100305 RTC_LOG_F(LS_INFO) << "async dns lookup (" << addr.hostname() << ")";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000306 DnsLookup * dns = new DnsLookup;
307 if (!sink_) {
308 // Explicitly create the sink ourselves here; we can't rely on SetAsync
309 // because we don't have a socket_ yet.
310 CreateSink();
311 }
312 // TODO: Replace with IPv6 compatible lookup.
313 dns->handle = WSAAsyncGetHostByName(sink_->handle(), WM_DNSNOTIFY,
314 addr.hostname().c_str(), dns->buffer,
315 sizeof(dns->buffer));
316
317 if (!dns->handle) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100318 RTC_LOG_F(LS_ERROR) << "WSAAsyncGetHostByName error: " << WSAGetLastError();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000319 delete dns;
320 UpdateLastError();
321 Close();
322 return SOCKET_ERROR;
323 }
324
325 dns->port = addr.port();
326 dns_ = dns;
327 state_ = CS_CONNECTING;
328 return 0;
329}
330
331int Win32Socket::DoConnect(const SocketAddress& addr) {
332 if ((socket_ == INVALID_SOCKET) && !CreateT(addr.family(), SOCK_STREAM)) {
333 return SOCKET_ERROR;
334 }
335 if (!SetAsync(FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE)) {
336 return SOCKET_ERROR;
337 }
338
339 sockaddr_storage saddr = {0};
340 size_t len = addr.ToSockAddrStorage(&saddr);
341 connect_time_ = Time();
342 int result = connect(socket_,
343 reinterpret_cast<SOCKADDR*>(&saddr),
344 static_cast<int>(len));
345 if (result != SOCKET_ERROR) {
346 state_ = CS_CONNECTED;
347 } else {
348 int code = WSAGetLastError();
349 if (code == WSAEWOULDBLOCK) {
350 state_ = CS_CONNECTING;
351 } else {
352 ReportWSAError("WSAAsync:connect", code, addr);
353 error_ = code;
354 Close();
355 return SOCKET_ERROR;
356 }
357 }
358 addr_ = addr;
359
360 return 0;
361}
362
363int Win32Socket::GetError() const {
364 return error_;
365}
366
367void Win32Socket::SetError(int error) {
368 error_ = error;
369}
370
371Socket::ConnState Win32Socket::GetState() const {
372 return state_;
373}
374
375int Win32Socket::GetOption(Option opt, int* value) {
376 int slevel;
377 int sopt;
378 if (TranslateOption(opt, &slevel, &sopt) == -1)
379 return -1;
380
381 char* p = reinterpret_cast<char*>(value);
382 int optlen = sizeof(value);
383 return ::getsockopt(socket_, slevel, sopt, p, &optlen);
384}
385
386int Win32Socket::SetOption(Option opt, int value) {
387 int slevel;
388 int sopt;
389 if (TranslateOption(opt, &slevel, &sopt) == -1)
390 return -1;
391
392 const char* p = reinterpret_cast<const char*>(&value);
393 return ::setsockopt(socket_, slevel, sopt, p, sizeof(value));
394}
395
396int Win32Socket::Send(const void* buffer, size_t length) {
397 int sent = ::send(socket_,
398 reinterpret_cast<const char*>(buffer),
399 static_cast<int>(length),
400 0);
401 UpdateLastError();
402 return sent;
403}
404
405int Win32Socket::SendTo(const void* buffer, size_t length,
406 const SocketAddress& addr) {
407 sockaddr_storage saddr;
408 size_t addr_len = addr.ToSockAddrStorage(&saddr);
409 int sent = ::sendto(socket_, reinterpret_cast<const char*>(buffer),
410 static_cast<int>(length), 0,
411 reinterpret_cast<sockaddr*>(&saddr),
412 static_cast<int>(addr_len));
413 UpdateLastError();
414 return sent;
415}
416
Stefan Holmer9131efd2016-05-23 18:19:26 +0200417int Win32Socket::Recv(void* buffer, size_t length, int64_t* timestamp) {
418 if (timestamp) {
419 *timestamp = -1;
420 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000421 int received = ::recv(socket_, static_cast<char*>(buffer),
422 static_cast<int>(length), 0);
423 UpdateLastError();
424 if (closing_ && received <= static_cast<int>(length))
425 PostClosed();
426 return received;
427}
428
Stefan Holmer9131efd2016-05-23 18:19:26 +0200429int Win32Socket::RecvFrom(void* buffer,
430 size_t length,
431 SocketAddress* out_addr,
432 int64_t* timestamp) {
433 if (timestamp) {
434 *timestamp = -1;
435 }
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000436 sockaddr_storage saddr;
437 socklen_t addr_len = sizeof(saddr);
438 int received = ::recvfrom(socket_, static_cast<char*>(buffer),
439 static_cast<int>(length), 0,
440 reinterpret_cast<sockaddr*>(&saddr), &addr_len);
441 UpdateLastError();
442 if (received != SOCKET_ERROR)
443 SocketAddressFromSockAddrStorage(saddr, out_addr);
444 if (closing_ && received <= static_cast<int>(length))
445 PostClosed();
446 return received;
447}
448
449int Win32Socket::Listen(int backlog) {
450 int err = ::listen(socket_, backlog);
451 if (!SetAsync(FD_ACCEPT))
452 return SOCKET_ERROR;
453
454 UpdateLastError();
455 if (err == 0)
456 state_ = CS_CONNECTING;
457 return err;
458}
459
460Win32Socket* Win32Socket::Accept(SocketAddress* out_addr) {
461 sockaddr_storage saddr;
462 socklen_t addr_len = sizeof(saddr);
463 SOCKET s = ::accept(socket_, reinterpret_cast<sockaddr*>(&saddr), &addr_len);
464 UpdateLastError();
465 if (s == INVALID_SOCKET)
deadbeef37f5ecf2017-02-27 14:06:41 -0800466 return nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000467 if (out_addr)
468 SocketAddressFromSockAddrStorage(saddr, out_addr);
469 Win32Socket* socket = new Win32Socket;
470 if (0 == socket->Attach(s))
471 return socket;
472 delete socket;
deadbeef37f5ecf2017-02-27 14:06:41 -0800473 return nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000474}
475
476int Win32Socket::Close() {
477 int err = 0;
478 if (socket_ != INVALID_SOCKET) {
479 err = ::closesocket(socket_);
480 socket_ = INVALID_SOCKET;
481 closing_ = false;
482 close_error_ = 0;
483 UpdateLastError();
484 }
485 if (dns_) {
486 WSACancelAsyncRequest(dns_->handle);
487 delete dns_;
deadbeef37f5ecf2017-02-27 14:06:41 -0800488 dns_ = nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000489 }
490 if (sink_) {
491 sink_->Dispose();
deadbeef37f5ecf2017-02-27 14:06:41 -0800492 sink_ = nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000493 }
494 addr_.Clear();
495 state_ = CS_CLOSED;
496 return err;
497}
498
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000499void Win32Socket::CreateSink() {
deadbeef37f5ecf2017-02-27 14:06:41 -0800500 RTC_DCHECK(nullptr == sink_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000501
502 // Create window
503 sink_ = new EventSink(this);
deadbeef37f5ecf2017-02-27 14:06:41 -0800504 sink_->Create(nullptr, L"EventSink", 0, 0, 0, 0, 10, 10);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000505}
506
507bool Win32Socket::SetAsync(int events) {
deadbeef37f5ecf2017-02-27 14:06:41 -0800508 if (nullptr == sink_) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000509 CreateSink();
deadbeef37f5ecf2017-02-27 14:06:41 -0800510 RTC_DCHECK(nullptr != sink_);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000511 }
512
513 // start the async select
514 if (WSAAsyncSelect(socket_, sink_->handle(), WM_SOCKETNOTIFY, events)
515 == SOCKET_ERROR) {
516 UpdateLastError();
517 Close();
518 return false;
519 }
520
521 return true;
522}
523
524bool Win32Socket::HandleClosed(int close_error) {
525 // WM_CLOSE will be received before all data has been read, so we need to
526 // hold on to it until the read buffer has been drained.
527 char ch;
528 closing_ = true;
529 close_error_ = close_error;
530 return (::recv(socket_, &ch, 1, MSG_PEEK) <= 0);
531}
532
533void Win32Socket::PostClosed() {
534 // If we see that the buffer is indeed drained, then send the close.
535 closing_ = false;
536 ::PostMessage(sink_->handle(), WM_SOCKETNOTIFY,
537 socket_, WSAMAKESELECTREPLY(FD_CLOSE, close_error_));
538}
539
540void Win32Socket::UpdateLastError() {
541 error_ = WSAGetLastError();
542}
543
544int Win32Socket::TranslateOption(Option opt, int* slevel, int* sopt) {
545 switch (opt) {
546 case OPT_DONTFRAGMENT:
547 *slevel = IPPROTO_IP;
548 *sopt = IP_DONTFRAGMENT;
549 break;
550 case OPT_RCVBUF:
551 *slevel = SOL_SOCKET;
552 *sopt = SO_RCVBUF;
553 break;
554 case OPT_SNDBUF:
555 *slevel = SOL_SOCKET;
556 *sopt = SO_SNDBUF;
557 break;
558 case OPT_NODELAY:
559 *slevel = IPPROTO_TCP;
560 *sopt = TCP_NODELAY;
561 break;
562 case OPT_DSCP:
Mirko Bonadei675513b2017-11-09 11:09:25 +0100563 RTC_LOG(LS_WARNING) << "Socket::OPT_DSCP not supported.";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000564 return -1;
565 default:
nissec80e7412017-01-11 05:56:46 -0800566 RTC_NOTREACHED();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000567 return -1;
568 }
569 return 0;
570}
571
572void Win32Socket::OnSocketNotify(SOCKET socket, int event, int error) {
573 // Ignore events if we're already closed.
574 if (socket != socket_)
575 return;
576
577 error_ = error;
578 switch (event) {
579 case FD_CONNECT:
580 if (error != ERROR_SUCCESS) {
581 ReportWSAError("WSAAsync:connect notify", error, addr_);
tfarinaa41ab932015-10-30 16:08:48 -0700582#if !defined(NDEBUG)
Honghai Zhang82d78622016-05-06 11:29:15 -0700583 int64_t duration = TimeSince(connect_time_);
Mirko Bonadei675513b2017-11-09 11:09:25 +0100584 RTC_LOG(LS_INFO) << "WSAAsync:connect error (" << duration
585 << " ms), faking close";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000586#endif
587 state_ = CS_CLOSED;
588 // If you get an error connecting, close doesn't really do anything
589 // and it certainly doesn't send back any close notification, but
590 // we really only maintain a few states, so it is easiest to get
591 // back into a known state by pretending that a close happened, even
592 // though the connect event never did occur.
593 SignalCloseEvent(this, error);
594 } else {
tfarinaa41ab932015-10-30 16:08:48 -0700595#if !defined(NDEBUG)
Honghai Zhang82d78622016-05-06 11:29:15 -0700596 int64_t duration = TimeSince(connect_time_);
Mirko Bonadei675513b2017-11-09 11:09:25 +0100597 RTC_LOG(LS_INFO) << "WSAAsync:connect (" << duration << " ms)";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000598#endif
599 state_ = CS_CONNECTED;
600 SignalConnectEvent(this);
601 }
602 break;
603
604 case FD_ACCEPT:
605 case FD_READ:
606 if (error != ERROR_SUCCESS) {
607 ReportWSAError("WSAAsync:read notify", error, addr_);
608 } else {
609 SignalReadEvent(this);
610 }
611 break;
612
613 case FD_WRITE:
614 if (error != ERROR_SUCCESS) {
615 ReportWSAError("WSAAsync:write notify", error, addr_);
616 } else {
617 SignalWriteEvent(this);
618 }
619 break;
620
621 case FD_CLOSE:
622 if (HandleClosed(error)) {
623 ReportWSAError("WSAAsync:close notify", error, addr_);
624 state_ = CS_CLOSED;
625 SignalCloseEvent(this, error);
626 }
627 break;
628 }
629}
630
631void Win32Socket::OnDnsNotify(HANDLE task, int error) {
632 if (!dns_ || dns_->handle != task)
633 return;
634
Peter Boström0c4e06b2015-10-07 12:23:21 +0200635 uint32_t ip = 0;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000636 if (error == 0) {
637 hostent* pHost = reinterpret_cast<hostent*>(dns_->buffer);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200638 uint32_t net_ip = *reinterpret_cast<uint32_t*>(pHost->h_addr_list[0]);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000639 ip = NetworkToHost32(net_ip);
640 }
641
Mirko Bonadei675513b2017-11-09 11:09:25 +0100642 RTC_LOG_F(LS_INFO) << "(" << IPAddress(ip).ToSensitiveString() << ", "
643 << error << ")";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000644
645 if (error == 0) {
646 SocketAddress address(ip, dns_->port);
647 error = DoConnect(address);
648 } else {
649 Close();
650 }
651
652 if (error) {
653 error_ = error;
654 SignalCloseEvent(this, error_);
655 } else {
656 delete dns_;
deadbeef37f5ecf2017-02-27 14:06:41 -0800657 dns_ = nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000658 }
659}
660
661///////////////////////////////////////////////////////////////////////////////
662// Win32SocketServer
663// Provides cricket base services on top of a win32 gui thread
664///////////////////////////////////////////////////////////////////////////////
665
666static UINT s_wm_wakeup_id = 0;
667const TCHAR Win32SocketServer::kWindowName[] = L"libjingle Message Window";
668
nisse7eaa4ea2017-05-08 05:25:41 -0700669Win32SocketServer::Win32SocketServer()
670 : wnd_(this),
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000671 posted_(false),
deadbeef37f5ecf2017-02-27 14:06:41 -0800672 hdlg_(nullptr) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000673 if (s_wm_wakeup_id == 0)
674 s_wm_wakeup_id = RegisterWindowMessage(L"WM_WAKEUP");
deadbeef37f5ecf2017-02-27 14:06:41 -0800675 if (!wnd_.Create(nullptr, kWindowName, 0, 0, 0, 0, 0, 0)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100676 RTC_LOG_GLE(LS_ERROR) << "Failed to create message window.";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000677 }
678}
679
680Win32SocketServer::~Win32SocketServer() {
deadbeef37f5ecf2017-02-27 14:06:41 -0800681 if (wnd_.handle() != nullptr) {
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000682 KillTimer(wnd_.handle(), 1);
683 wnd_.Destroy();
684 }
685}
686
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000687Socket* Win32SocketServer::CreateSocket(int family, int type) {
688 return CreateAsyncSocket(family, type);
689}
690
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000691AsyncSocket* Win32SocketServer::CreateAsyncSocket(int family, int type) {
692 Win32Socket* socket = new Win32Socket;
693 if (socket->CreateT(family, type)) {
694 return socket;
695 }
696 delete socket;
deadbeef37f5ecf2017-02-27 14:06:41 -0800697 return nullptr;
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000698}
699
700void Win32SocketServer::SetMessageQueue(MessageQueue* queue) {
701 message_queue_ = queue;
702}
703
704bool Win32SocketServer::Wait(int cms, bool process_io) {
705 BOOL b;
706 if (process_io) {
707 // Spin the Win32 message pump at least once, and as long as requested.
708 // This is the Thread::ProcessMessages case.
Peter Boström0c4e06b2015-10-07 12:23:21 +0200709 uint32_t start = Time();
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000710 do {
711 MSG msg;
deadbeef37f5ecf2017-02-27 14:06:41 -0800712 SetTimer(wnd_.handle(), 0, cms, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000713 // Get the next available message. If we have a modeless dialog, give
714 // give the message to IsDialogMessage, which will return true if it
715 // was a message for the dialog that it handled internally.
716 // Otherwise, dispatch as usual via Translate/DispatchMessage.
deadbeef37f5ecf2017-02-27 14:06:41 -0800717 b = GetMessage(&msg, nullptr, 0, 0);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000718 if (b == -1) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100719 RTC_LOG_GLE(LS_ERROR) << "GetMessage failed.";
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000720 return false;
721 } else if(b) {
722 if (!hdlg_ || !IsDialogMessage(hdlg_, &msg)) {
723 TranslateMessage(&msg);
724 DispatchMessage(&msg);
725 }
726 }
727 KillTimer(wnd_.handle(), 0);
728 } while (b && TimeSince(start) < cms);
729 } else if (cms != 0) {
730 // Sit and wait forever for a WakeUp. This is the Thread::Send case.
nisseede5da42017-01-12 05:15:36 -0800731 RTC_DCHECK(cms == -1);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000732 MSG msg;
deadbeef37f5ecf2017-02-27 14:06:41 -0800733 b = GetMessage(&msg, nullptr, s_wm_wakeup_id, s_wm_wakeup_id);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000734 {
735 CritScope scope(&cs_);
736 posted_ = false;
737 }
738 } else {
739 // No-op (cms == 0 && !process_io). This is the Pump case.
740 b = TRUE;
741 }
742 return (b != FALSE);
743}
744
745void Win32SocketServer::WakeUp() {
746 if (wnd_.handle()) {
747 // Set the "message pending" flag, if not already set.
748 {
749 CritScope scope(&cs_);
750 if (posted_)
751 return;
752 posted_ = true;
753 }
754
755 PostMessage(wnd_.handle(), s_wm_wakeup_id, 0, 0);
756 }
757}
758
759void Win32SocketServer::Pump() {
760 // Clear the "message pending" flag.
761 {
762 CritScope scope(&cs_);
763 posted_ = false;
764 }
765
766 // Dispatch all the messages that are currently in our queue. If new messages
767 // are posted during the dispatch, they will be handled in the next Pump.
768 // We use max(1, ...) to make sure we try to dispatch at least once, since
769 // this allow us to process "sent" messages, not included in the size() count.
770 Message msg;
andresp@webrtc.orgff689be2015-02-12 11:54:26 +0000771 for (size_t max_messages_to_process =
772 std::max<size_t>(1, message_queue_->size());
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000773 max_messages_to_process > 0 && message_queue_->Get(&msg, 0, false);
774 --max_messages_to_process) {
775 message_queue_->Dispatch(&msg);
776 }
777
778 // Anything remaining?
779 int delay = message_queue_->GetDelay();
780 if (delay == -1) {
781 KillTimer(wnd_.handle(), 1);
782 } else {
deadbeef37f5ecf2017-02-27 14:06:41 -0800783 SetTimer(wnd_.handle(), 1, delay, nullptr);
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000784 }
785}
786
787bool Win32SocketServer::MessageWindow::OnMessage(UINT wm, WPARAM wp,
788 LPARAM lp, LRESULT& lr) {
789 bool handled = false;
790 if (wm == s_wm_wakeup_id || (wm == WM_TIMER && wp == 1)) {
791 ss_->Pump();
792 lr = 0;
793 handled = true;
794 }
795 return handled;
796}
797
Steve Anton9de3aac2017-10-24 10:08:26 -0700798Win32Thread::Win32Thread(SocketServer* ss) : Thread(ss), id_(0) {}
799
800Win32Thread::~Win32Thread() {
801 Stop();
802}
803
804void Win32Thread::Run() {
805 id_ = GetCurrentThreadId();
806 Thread::Run();
807 id_ = 0;
808}
809
810void Win32Thread::Quit() {
811 PostThreadMessage(id_, WM_QUIT, 0, 0);
812}
813
henrike@webrtc.orgf0488722014-05-13 18:00:26 +0000814} // namespace rtc