1 /*****************************************************************
2 |
3 | Neptune - Sockets :: WinRT Implementation
4 |
5 | (c) 2001-2012 Gilles Boccon-Gibod
6 | Author: Gilles Boccon-Gibod (bok@bok.net)
7 |
8 ****************************************************************/
9
10 /*----------------------------------------------------------------------
11 | includes
12 +---------------------------------------------------------------------*/
13 #include "NptWinRtPch.h"
14
15 using namespace Platform;
16 using namespace Windows::Foundation;
17 using namespace Windows::Foundation::Collections;
18 using namespace Windows::Networking;
19 using namespace Windows::Networking::Sockets;
20 using namespace Windows::Storage::Streams;
21 using namespace Concurrency;
22
23 /*----------------------------------------------------------------------
24 | logging
25 +---------------------------------------------------------------------*/
26 NPT_SET_LOCAL_LOGGER("neptune.sockets.winrt")
27
28 /*----------------------------------------------------------------------
29 | constants
30 +---------------------------------------------------------------------*/
31 const DWORD NPT_WINRT_SOCKET_DEFAULT_READ_TIMEOUT = 30000;
32 const DWORD NPT_WINRT_SOCKET_DEFAULT_WRITE_TIMEOUT = 30000;
33
34 /*----------------------------------------------------------------------
35 | NPT_WinRtTcpClientSocket
36 +---------------------------------------------------------------------*/
37 class NPT_WinRtTcpClientSocket : public NPT_SocketInterface
38 {
39 public:
40 // constructors and destructor
41 NPT_WinRtTcpClientSocket();
42 virtual ~NPT_WinRtTcpClientSocket();
43
44 // NPT_SocketInterface methods
45 NPT_Result Bind(const NPT_SocketAddress& address, bool reuse_address = true);
46 NPT_Result Connect(const NPT_SocketAddress& address, NPT_Timeout timeout);
47 NPT_Result GetInputStream(NPT_InputStreamReference& stream);
48 NPT_Result GetOutputStream(NPT_OutputStreamReference& stream);
49 NPT_Result GetInfo(NPT_SocketInfo& info);
50 NPT_Result SetReadTimeout(NPT_Timeout timeout);
51 NPT_Result SetWriteTimeout(NPT_Timeout timeout);
52 NPT_Result Cancel(bool shutdown);
53
54 protected:
55 StreamSocket^ m_Socket;
56 HostName^ m_RemoteHostName;
57 HANDLE m_WaitEvent;
58 NPT_Timeout m_ReadTimeout;
59 NPT_Timeout m_WriteTimeout;
60 };
61
62 /*----------------------------------------------------------------------
63 | NPT_WinRtSocketInputStream
64 +---------------------------------------------------------------------*/
65 class NPT_WinRtSocketInputStream : public NPT_InputStream
66 {
67 public:
68 // constructors and destructor
69 NPT_WinRtSocketInputStream(StreamSocket^ socket, NPT_Timeout timeout);
70 virtual ~NPT_WinRtSocketInputStream();
71
72 // NPT_InputStream methods
73 NPT_Result Read(void* buffer,
74 NPT_Size bytes_to_read,
75 NPT_Size* bytes_read);
76 NPT_Result Seek(NPT_Position offset);
77 NPT_Result Tell(NPT_Position& where);
78 NPT_Result GetSize(NPT_LargeSize& size);
79 NPT_Result GetAvailable(NPT_LargeSize& available);
80
81 private:
82 StreamSocket^ m_Socket;
83 IInputStream^ m_InputStream;
84 DataReader^ m_Reader;
85 HANDLE m_WaitEvent;
86 NPT_Timeout m_Timeout;
87 };
88
89 /*----------------------------------------------------------------------
90 | NPT_WinRtSocketOutputStream
91 +---------------------------------------------------------------------*/
92 class NPT_WinRtSocketOutputStream : public NPT_OutputStream
93 {
94 public:
95 // constructors and destructor
96 NPT_WinRtSocketOutputStream(StreamSocket^ socket, NPT_Timeout timeout);
97 virtual ~NPT_WinRtSocketOutputStream();
98
99 // NPT_OutputStream methods
100 NPT_Result Write(const void* buffer,
101 NPT_Size bytes_to_write,
102 NPT_Size* bytes_written);
103 NPT_Result Seek(NPT_Position offset);
104 NPT_Result Tell(NPT_Position& where);
105 NPT_Result Flush();
106
107 private:
108 StreamSocket^ m_Socket;
109 IOutputStream^ m_OutputStream;
110 DataWriter^ m_Writer;
111 HANDLE m_WaitEvent;
112 NPT_Timeout m_Timeout;
113 };
114
115 /*----------------------------------------------------------------------
116 | StringFromUTF8
117 +---------------------------------------------------------------------*/
118 static String^
119 StringFromUTF8(const char* utf)
120 {
121 unsigned int utf_len = NPT_StringLength(utf);
122 unsigned int wide_len = utf_len;
123 wchar_t* wide = new wchar_t[wide_len+1];
124 int result = MultiByteToWideChar(CP_UTF8,
125 0,
126 utf,
127 utf_len+1,
128 wide,
129 wide_len+1);
130 String^ str;
131 if (result) {
132 str = ref new String(wide);
133 } else {
134 str = ref new String();
135 }
136 delete[] wide;
137 return str;
138 }
139
140 /*----------------------------------------------------------------------
141 | TranslateHResult
142 +---------------------------------------------------------------------*/
143 static NPT_Result
TranslateHResult(HResult result)144 TranslateHResult(HResult result)
145 {
146 switch (HRESULT_FACILITY(result.Value)) {
147 case FACILITY_WIN32:
148 switch (HRESULT_CODE(result.Value)) {
149 case WSAHOST_NOT_FOUND:
150 return NPT_ERROR_HOST_UNKNOWN;
151
152 case WSAETIMEDOUT:
153 return NPT_ERROR_TIMEOUT;
154
155 case WSAECONNREFUSED:
156 return NPT_ERROR_CONNECTION_REFUSED;
157
158 case WSAEWOULDBLOCK:
159 return NPT_ERROR_WOULD_BLOCK;
160
161 case WSAECONNABORTED:
162 return NPT_ERROR_CONNECTION_ABORTED;
163
164 case WSAECONNRESET:
165 case WSAENETRESET:
166 return NPT_ERROR_CONNECTION_RESET;
167
168 case WSAEADDRINUSE:
169 return NPT_ERROR_ADDRESS_IN_USE;
170
171 case WSAENETDOWN:
172 return NPT_ERROR_NETWORK_DOWN;
173
174 case WSAENETUNREACH:
175 return NPT_ERROR_NETWORK_UNREACHABLE;
176
177 case WSAEINTR:
178 return NPT_ERROR_INTERRUPTED;
179
180 case WSAENOTCONN:
181 return NPT_ERROR_NOT_CONNECTED;
182
183 default:
184 return NPT_FAILURE;
185 }
186 break;
187
188 /* TODO: map error codes */
189 default:
190 return NPT_FAILURE;
191 }
192 }
193
194 /*----------------------------------------------------------------------
195 | WaitForAsyncAction
196 +---------------------------------------------------------------------*/
197 static NPT_Result
198 WaitForAsyncAction(IAsyncAction^ action,
199 HANDLE wait_event,
200 DWORD timeout = INFINITE)
201 {
202 NPT_Result result = NPT_ERROR_INTERNAL;
203
204 NPT_LOG_FINEST("waiting for async action...");
205 ResetEvent(wait_event);
206
207 action->Completed = ref new AsyncActionCompletedHandler
__anonb5d451e30102(IAsyncAction^ action_, AsyncStatus status) 208 ([&](IAsyncAction^ action_, AsyncStatus status) {
209 switch (status) {
210 case AsyncStatus::Canceled:
211 result = NPT_ERROR_TIMEOUT;
212 break;
213
214 case AsyncStatus::Completed:
215 result = NPT_SUCCESS;
216 break;
217
218 case AsyncStatus::Error:
219 NPT_LOG_FINE_1("AsyncAction error %x", action_->ErrorCode.Value);
220 result = TranslateHResult(action_->ErrorCode);
221 break;
222
223 default:
224 result = NPT_ERROR_INTERNAL;
225 break;
226 }
227 SetEvent(wait_event);
228 });
229
230 DWORD wait_result = WaitForSingleObjectEx(wait_event, timeout, FALSE);
231 if (wait_result != WAIT_OBJECT_0) {
232 NPT_LOG_FINE("action timed out, canceling...");
233 action->Cancel();
234 WaitForSingleObjectEx(wait_event, INFINITE, FALSE);
235 }
236 NPT_LOG_FINEST("done waiting for async action");
237
238 return result;
239 }
240
241 /*----------------------------------------------------------------------
242 | WaitForAsyncOperation
243 +---------------------------------------------------------------------*/
244 static NPT_Result
245 WaitForAsyncOperation(IAsyncOperation<unsigned int>^ operation,
246 HANDLE wait_event,
247 unsigned int& return_value,
248 DWORD timeout = INFINITE)
249 {
250 NPT_Result result = NPT_ERROR_INTERNAL;
251
252 NPT_LOG_FINEST("waiting for async operation...");
253 return_value = 0;
254 ResetEvent(wait_event);
255
256 operation->Completed = ref new AsyncOperationCompletedHandler<unsigned int>
__anonb5d451e30202(IAsyncOperation<unsigned int>^ operation_, AsyncStatus status) 257 ([&](IAsyncOperation<unsigned int>^ operation_, AsyncStatus status) {
258 switch (status) {
259 case AsyncStatus::Canceled:
260 result = NPT_ERROR_TIMEOUT;
261 break;
262
263 case AsyncStatus::Completed:
264 return_value = operation_->GetResults();
265 result = NPT_SUCCESS;
266 break;
267
268 case AsyncStatus::Error:
269 NPT_LOG_FINE_1("AsyncOperation error %x", operation_->ErrorCode.Value);
270 result = TranslateHResult(operation_->ErrorCode);
271 break;
272
273 default:
274 result = NPT_ERROR_INTERNAL;
275 break;
276 }
277 operation_->Close();
278 SetEvent(wait_event);
279 });
280
281 DWORD wait_result = WaitForSingleObjectEx(wait_event, timeout, FALSE);
282 if (wait_result != WAIT_OBJECT_0) {
283 NPT_LOG_FINE("operation timed out, canceling...");
284 operation->Cancel();
285 WaitForSingleObjectEx(wait_event, INFINITE, FALSE);
286 }
287 NPT_LOG_FINEST("done waiting for async operation");
288
289 return result;
290 }
291
292 /*----------------------------------------------------------------------
293 | NPT_WinRtSocketInputStream::NPT_WinRtSocketInputStream
294 +---------------------------------------------------------------------*/
295 NPT_WinRtSocketInputStream::NPT_WinRtSocketInputStream(StreamSocket^ socket,
296 NPT_Timeout timeout) :
297 m_Socket(socket),
298 m_Timeout(timeout)
299 {
300 m_InputStream = socket->InputStream;
301 m_Reader = ref new DataReader(m_InputStream);
302 m_Reader->InputStreamOptions = InputStreamOptions::Partial;
303 m_WaitEvent = CreateEventExW(NULL, L"", 0, EVENT_ALL_ACCESS);
304 }
305
306 /*----------------------------------------------------------------------
307 | NPT_WinRtSocketInputStream::~NPT_WinRtSocketInputStream
308 +---------------------------------------------------------------------*/
~NPT_WinRtSocketInputStream()309 NPT_WinRtSocketInputStream::~NPT_WinRtSocketInputStream()
310 {
311 m_Reader->DetachStream();
312 CloseHandle(m_WaitEvent);
313 }
314
315 /*----------------------------------------------------------------------
316 | NPT_WinRtSocketInputStream::Read
317 +---------------------------------------------------------------------*/
318 NPT_Result
Read(void * buffer,NPT_Size bytes_to_read,NPT_Size * bytes_read)319 NPT_WinRtSocketInputStream::Read(void* buffer,
320 NPT_Size bytes_to_read,
321 NPT_Size* bytes_read)
322 {
323 // init and shortcut
324 if (bytes_read) *bytes_read = 0;
325 if (bytes_to_read == 0) return NPT_SUCCESS;
326
327 NPT_LOG_FINER_1("reading %d bytes", bytes_to_read);
328 auto operation = m_Reader->LoadAsync(bytes_to_read);
329
330 unsigned int return_value = 0;
331 NPT_Result result = WaitForAsyncOperation(operation, m_WaitEvent, return_value, m_Timeout);
332
333 if (NPT_SUCCEEDED(result)) {
334 if (return_value) {
335 unsigned int bytes_available = m_Reader->UnconsumedBufferLength;
336 Array<unsigned char>^ bytes = ref new Array<unsigned char>(bytes_available);
337 m_Reader->ReadBytes(bytes);
338 NPT_CopyMemory(buffer, bytes->Data, bytes_available);
339 if (bytes_read) *bytes_read = bytes_available;
340 return NPT_SUCCESS;
341 } else {
342 return NPT_ERROR_EOS;
343 }
344 }
345
346 return result;
347 }
348
349 /*----------------------------------------------------------------------
350 | NPT_WinRtSocketInputStream::Seek
351 +---------------------------------------------------------------------*/
352 NPT_Result
Seek(NPT_Position offset)353 NPT_WinRtSocketInputStream::Seek(NPT_Position offset)
354 {
355 return NPT_ERROR_NOT_SUPPORTED;
356 }
357
358 /*----------------------------------------------------------------------
359 | NPT_WinRtSocketInputStream::Tell
360 +---------------------------------------------------------------------*/
361 NPT_Result
Tell(NPT_Position & where)362 NPT_WinRtSocketInputStream::Tell(NPT_Position& where)
363 {
364 where = 0;
365 return NPT_ERROR_NOT_SUPPORTED;
366 }
367
368 /*----------------------------------------------------------------------
369 | NPT_WinRtSocketInputStream::GetSize
370 +---------------------------------------------------------------------*/
371 NPT_Result
GetSize(NPT_LargeSize & size)372 NPT_WinRtSocketInputStream::GetSize(NPT_LargeSize& size)
373 {
374 size = 0;
375 return NPT_ERROR_NOT_SUPPORTED;
376 }
377
378 /*----------------------------------------------------------------------
379 | NPT_WinRtSocketInputStream::GetAvailable
380 +---------------------------------------------------------------------*/
381 NPT_Result
GetAvailable(NPT_LargeSize & available)382 NPT_WinRtSocketInputStream::GetAvailable(NPT_LargeSize& available)
383 {
384 available = 0;
385 return NPT_SUCCESS;
386 }
387
388 /*----------------------------------------------------------------------
389 | NPT_WinRtSocketOutputStream::NPT_WinRtSocketOutputStream
390 +---------------------------------------------------------------------*/
391 NPT_WinRtSocketOutputStream::NPT_WinRtSocketOutputStream(StreamSocket^ socket,
392 NPT_Timeout timeout) :
393 m_Socket(socket),
394 m_Timeout(timeout)
395 {
396 m_OutputStream = socket->OutputStream;
397 m_Writer = ref new DataWriter(m_OutputStream);
398 m_WaitEvent = CreateEventExW(NULL, L"", 0, EVENT_ALL_ACCESS);
399 }
400
401 /*----------------------------------------------------------------------
402 | NPT_WinRtSocketOutputStream::~NPT_WinRtSocketOutputStream
403 +---------------------------------------------------------------------*/
~NPT_WinRtSocketOutputStream()404 NPT_WinRtSocketOutputStream::~NPT_WinRtSocketOutputStream()
405 {
406 m_Writer->DetachStream();
407 CloseHandle(m_WaitEvent);
408 }
409
410 /*----------------------------------------------------------------------
411 | NPT_WinRtSocketOutputStream::Write
412 +---------------------------------------------------------------------*/
413 NPT_Result
Write(const void * buffer,NPT_Size bytes_to_write,NPT_Size * bytes_written)414 NPT_WinRtSocketOutputStream::Write(const void* buffer,
415 NPT_Size bytes_to_write,
416 NPT_Size* bytes_written)
417 {
418 NPT_LOG_FINER_1("writing %d bytes", bytes_to_write);
419
420 Array<unsigned char>^ bytes = ref new Array<unsigned char>(bytes_to_write);
421 NPT_CopyMemory(bytes->Data, buffer, bytes_to_write);
422 m_Writer->WriteBytes(bytes);
423 auto operation = m_Writer->StoreAsync();
424 unsigned int return_value = 0;
425
426 NPT_Result result = WaitForAsyncOperation(operation, m_WaitEvent, return_value, m_Timeout);
427 if (bytes_written) *bytes_written = return_value;
428
429 return NPT_SUCCESS;
430 }
431
432 /*----------------------------------------------------------------------
433 | NPT_WinRtSocketOutputStream::Seek
434 +---------------------------------------------------------------------*/
435 NPT_Result
Seek(NPT_Position offset)436 NPT_WinRtSocketOutputStream::Seek(NPT_Position offset)
437 {
438 return NPT_ERROR_NOT_SUPPORTED;
439 }
440
441 /*----------------------------------------------------------------------
442 | NPT_WinRtSocketOutputStream::Tell
443 +---------------------------------------------------------------------*/
444 NPT_Result
Tell(NPT_Position & where)445 NPT_WinRtSocketOutputStream::Tell(NPT_Position& where)
446 {
447 where = 0;
448 return NPT_ERROR_NOT_SUPPORTED;
449 }
450
451 /*----------------------------------------------------------------------
452 | NPT_WinRtSocketOutputStream
453 +---------------------------------------------------------------------*/
454 NPT_Result
Flush()455 NPT_WinRtSocketOutputStream::Flush()
456 {
457 return NPT_SUCCESS;
458 }
459
460 /*----------------------------------------------------------------------
461 | NPT_WinRtTcpClientSocket::NPT_WinRtTcpClientSocket
462 +---------------------------------------------------------------------*/
NPT_WinRtTcpClientSocket()463 NPT_WinRtTcpClientSocket::NPT_WinRtTcpClientSocket() :
464 m_ReadTimeout(NPT_WINRT_SOCKET_DEFAULT_READ_TIMEOUT),
465 m_WriteTimeout(NPT_WINRT_SOCKET_DEFAULT_WRITE_TIMEOUT)
466 {
467 m_Socket = ref new StreamSocket();
468 m_WaitEvent = CreateEventExW(NULL, L"", 0, EVENT_ALL_ACCESS);
469 }
470
471 /*----------------------------------------------------------------------
472 | NPT_WinRtTcpClientSocket::NPT_WinRtTcpClientSocket
473 +---------------------------------------------------------------------*/
~NPT_WinRtTcpClientSocket()474 NPT_WinRtTcpClientSocket::~NPT_WinRtTcpClientSocket()
475 {
476 CloseHandle(m_WaitEvent);
477 }
478
479 /*----------------------------------------------------------------------
480 | NPT_WinRtTcpClientSocket::Bind
481 +---------------------------------------------------------------------*/
482 NPT_Result
Bind(const NPT_SocketAddress & address,bool reuse_address)483 NPT_WinRtTcpClientSocket::Bind(const NPT_SocketAddress& address, bool reuse_address)
484 {
485 return NPT_ERROR_NOT_IMPLEMENTED;
486 }
487
488 /*----------------------------------------------------------------------
489 | NPT_WinRtTcpClientSocket::Connect
490 +---------------------------------------------------------------------*/
491 NPT_Result
Connect(const NPT_SocketAddress & address,NPT_Timeout timeout)492 NPT_WinRtTcpClientSocket::Connect(const NPT_SocketAddress& address, NPT_Timeout timeout)
493 {
494 try {
495 NPT_LOG_FINE_1("connecting to %s", address.GetIpAddress().m_HostName.GetChars());
496
497 m_RemoteHostName = ref new HostName(StringFromUTF8(address.GetIpAddress().m_HostName.GetChars()));
498 String^ remote_service = ref new String();
499 NPT_String port = NPT_String::FromIntegerU(address.GetPort());
500 IAsyncAction^ connection = m_Socket->ConnectAsync(m_RemoteHostName, StringFromUTF8(port.GetChars()));
501
502 // wait for the connection to be established
503 NPT_Result result = WaitForAsyncAction(connection, m_WaitEvent, timeout);
504 if (NPT_FAILED(result)) {
505 NPT_LOG_FINE_1("connection failed (%d)", result);
506 } else {
507 NPT_LOG_FINE("connected");
508 }
509 return result;
510 } catch (Exception^ e) {
511 NPT_LOG_FINE("exception caught");
512 return NPT_FAILURE;
513 }
514 }
515
516 /*----------------------------------------------------------------------
517 | NPT_WinRtTcpClientSocket::GetInputStream
518 +---------------------------------------------------------------------*/
519 NPT_Result
GetInputStream(NPT_InputStreamReference & stream)520 NPT_WinRtTcpClientSocket::GetInputStream(NPT_InputStreamReference& stream)
521 {
522 stream = new NPT_WinRtSocketInputStream(m_Socket, m_ReadTimeout);
523 return NPT_SUCCESS;
524 }
525
526 /*----------------------------------------------------------------------
527 | NPT_WinRtTcpClientSocket::GetOutputStream
528 +---------------------------------------------------------------------*/
529 NPT_Result
GetOutputStream(NPT_OutputStreamReference & stream)530 NPT_WinRtTcpClientSocket::GetOutputStream(NPT_OutputStreamReference& stream)
531 {
532 stream = new NPT_WinRtSocketOutputStream(m_Socket, m_WriteTimeout);
533 return NPT_SUCCESS;
534 }
535
536 /*----------------------------------------------------------------------
537 | NPT_WinRtTcpClientSocket::GetInfo
538 +---------------------------------------------------------------------*/
539 NPT_Result
GetInfo(NPT_SocketInfo & info)540 NPT_WinRtTcpClientSocket::GetInfo(NPT_SocketInfo& info)
541 {
542 return NPT_SUCCESS;
543 }
544
545 /*----------------------------------------------------------------------
546 | NPT_WinRtTcpClientSocket::SetReadTimeout
547 +---------------------------------------------------------------------*/
548 NPT_Result
SetReadTimeout(NPT_Timeout timeout)549 NPT_WinRtTcpClientSocket::SetReadTimeout(NPT_Timeout timeout)
550 {
551 m_ReadTimeout = timeout;
552 return NPT_SUCCESS;
553 }
554
555 /*----------------------------------------------------------------------
556 | NPT_WinRtTcpClientSocket::SetWriteTimeout
557 +---------------------------------------------------------------------*/
558 NPT_Result
SetWriteTimeout(NPT_Timeout timeout)559 NPT_WinRtTcpClientSocket::SetWriteTimeout(NPT_Timeout timeout)
560 {
561 m_WriteTimeout = timeout;
562 return NPT_SUCCESS;
563 }
564
565 /*----------------------------------------------------------------------
566 | NPT_WinRtTcpClientSocket::Cancel
567 +---------------------------------------------------------------------*/
568 NPT_Result
Cancel(bool shutdown)569 NPT_WinRtTcpClientSocket::Cancel(bool shutdown)
570 {
571 return NPT_SUCCESS;
572 }
573
574 /*----------------------------------------------------------------------
575 | NPT_Socket::~NPT_Socket
576 +---------------------------------------------------------------------*/
~NPT_Socket()577 NPT_Socket::~NPT_Socket()
578 {
579 delete m_SocketDelegate;
580 }
581
582 /*----------------------------------------------------------------------
583 | NPT_UdpSocket::NPT_UdpSocket
584 +---------------------------------------------------------------------*/
NPT_UdpSocket(NPT_Flags flags)585 NPT_UdpSocket::NPT_UdpSocket(NPT_Flags flags)
586 {
587 m_SocketDelegate = NULL;
588 m_UdpSocketDelegate = NULL;
589 }
590
591 /*----------------------------------------------------------------------
592 | NPT_UdpSocket::NPT_UdpSocket
593 +---------------------------------------------------------------------*/
NPT_UdpSocket(NPT_UdpSocketInterface * delegate)594 NPT_UdpSocket::NPT_UdpSocket(NPT_UdpSocketInterface* delegate) :
595 m_UdpSocketDelegate(delegate)
596 {
597 }
598
599 /*----------------------------------------------------------------------
600 | NPT_UdpSocket::~NPT_UdpSocket
601 +---------------------------------------------------------------------*/
~NPT_UdpSocket()602 NPT_UdpSocket::~NPT_UdpSocket()
603 {
604 m_UdpSocketDelegate = NULL;
605 m_SocketDelegate = NULL;
606 }
607
608 /*----------------------------------------------------------------------
609 | NPT_UdpMulticastSocket::NPT_UdpMulticastSocket
610 +---------------------------------------------------------------------*/
NPT_UdpMulticastSocket(NPT_Flags flags)611 NPT_UdpMulticastSocket::NPT_UdpMulticastSocket(NPT_Flags flags) :
612 NPT_UdpSocket((NPT_UdpSocketInterface*)0)
613 {
614 m_SocketDelegate = NULL;
615 m_UdpSocketDelegate = NULL;
616 m_UdpMulticastSocketDelegate = NULL;
617 }
618
619 /*----------------------------------------------------------------------
620 | NPT_UdpMulticastSocket::~NPT_UdpMulticastSocket
621 +---------------------------------------------------------------------*/
~NPT_UdpMulticastSocket()622 NPT_UdpMulticastSocket::~NPT_UdpMulticastSocket()
623 {
624 m_SocketDelegate = NULL;
625 m_UdpSocketDelegate = NULL;
626 m_UdpMulticastSocketDelegate = NULL;
627 }
628
629 /*----------------------------------------------------------------------
630 | NPT_TcpClientSocket::NPT_TcpClientSocket
631 +---------------------------------------------------------------------*/
NPT_TcpClientSocket(NPT_Flags flags)632 NPT_TcpClientSocket::NPT_TcpClientSocket(NPT_Flags flags) :
633 NPT_Socket(NULL)
634 {
635 m_SocketDelegate = new NPT_WinRtTcpClientSocket();
636 }
637
638 /*----------------------------------------------------------------------
639 | NPT_TcpClientSocket::NPT_TcpClientSocket
640 +---------------------------------------------------------------------*/
~NPT_TcpClientSocket()641 NPT_TcpClientSocket::~NPT_TcpClientSocket()
642 {
643 delete m_SocketDelegate;
644
645 m_SocketDelegate = NULL;
646 }
647
648 /*----------------------------------------------------------------------
649 | NPT_TcpServerSocket::NPT_TcpServerSocket
650 +---------------------------------------------------------------------*/
NPT_TcpServerSocket(NPT_Flags flags)651 NPT_TcpServerSocket::NPT_TcpServerSocket(NPT_Flags flags)
652 {
653 m_SocketDelegate = NULL;
654 m_TcpServerSocketDelegate = NULL;
655 }
656
657 /*----------------------------------------------------------------------
658 | NPT_TcpServerSocket::NPT_TcpServerSocket
659 +---------------------------------------------------------------------*/
~NPT_TcpServerSocket()660 NPT_TcpServerSocket::~NPT_TcpServerSocket()
661 {
662 m_SocketDelegate = NULL;
663 m_TcpServerSocketDelegate = NULL;
664 }
665