]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/common/socket.cpp | |
3 | // Purpose: Socket handler classes | |
4 | // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia | |
5 | // Created: April 1997 | |
6 | // Copyright: (C) 1999-1997, Guilhem Lavaux | |
7 | // (C) 1999-2000, Guillermo Rodriguez Garcia | |
8 | // (C) 2008 Vadim Zeitlin | |
9 | // RCS_ID: $Id$ | |
10 | // Licence: wxWindows licence | |
11 | ///////////////////////////////////////////////////////////////////////////// | |
12 | ||
13 | // ========================================================================== | |
14 | // Declarations | |
15 | // ========================================================================== | |
16 | ||
17 | // For compilers that support precompilation, includes "wx.h". | |
18 | #include "wx/wxprec.h" | |
19 | ||
20 | #ifdef __BORLANDC__ | |
21 | #pragma hdrstop | |
22 | #endif | |
23 | ||
24 | #if wxUSE_SOCKETS | |
25 | ||
26 | #include "wx/socket.h" | |
27 | ||
28 | #ifndef WX_PRECOMP | |
29 | #include "wx/object.h" | |
30 | #include "wx/string.h" | |
31 | #include "wx/intl.h" | |
32 | #include "wx/log.h" | |
33 | #include "wx/event.h" | |
34 | #include "wx/app.h" | |
35 | #include "wx/utils.h" | |
36 | #include "wx/timer.h" | |
37 | #include "wx/module.h" | |
38 | #endif | |
39 | ||
40 | #include "wx/apptrait.h" | |
41 | #include "wx/sckaddr.h" | |
42 | #include "wx/stopwatch.h" | |
43 | #include "wx/thread.h" | |
44 | #include "wx/evtloop.h" | |
45 | #include "wx/link.h" | |
46 | ||
47 | #include "wx/private/fd.h" | |
48 | #include "wx/private/socket.h" | |
49 | ||
50 | #ifdef __UNIX__ | |
51 | #include <errno.h> | |
52 | #endif | |
53 | ||
54 | // we use MSG_NOSIGNAL to avoid getting SIGPIPE when sending data to a remote | |
55 | // host which closed the connection if it is available, otherwise we rely on | |
56 | // SO_NOSIGPIPE existency | |
57 | // | |
58 | // this should cover all the current Unix systems (Windows never sends any | |
59 | // signals anyhow) but if we find one that has neither we should explicitly | |
60 | // ignore SIGPIPE for it | |
61 | // OpenVMS has neither MSG_NOSIGNAL nor SO_NOSIGPIPE. However the socket sample | |
62 | // seems to work. Not sure if problems will show up on OpenVMS using sockets. | |
63 | #ifdef MSG_NOSIGNAL | |
64 | #define wxSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL | |
65 | #else // MSG_NOSIGNAL not available (BSD including OS X) | |
66 | // next best possibility is to use SO_NOSIGPIPE socket option, this covers | |
67 | // BSD systems (including OS X) -- but if we don't have it neither (AIX and | |
68 | // old HP-UX do not), we have to fall back to the old way of simply | |
69 | // disabling SIGPIPE temporarily, so define a class to do it in a safe way | |
70 | #if defined(__UNIX__) && !defined(SO_NOSIGPIPE) | |
71 | extern "C" { typedef void (*wxSigHandler_t)(int); } | |
72 | namespace | |
73 | { | |
74 | class IgnoreSignal | |
75 | { | |
76 | public: | |
77 | // ctor disables the given signal | |
78 | IgnoreSignal(int sig) | |
79 | : m_handler(signal(sig, SIG_IGN)), | |
80 | m_sig(sig) | |
81 | { | |
82 | } | |
83 | ||
84 | // dtor restores the old handler | |
85 | ~IgnoreSignal() | |
86 | { | |
87 | signal(m_sig, m_handler); | |
88 | } | |
89 | ||
90 | private: | |
91 | const wxSigHandler_t m_handler; | |
92 | const int m_sig; | |
93 | ||
94 | wxDECLARE_NO_COPY_CLASS(IgnoreSignal); | |
95 | }; | |
96 | } // anonymous namespace | |
97 | ||
98 | #define wxNEEDS_IGNORE_SIGPIPE | |
99 | #endif // Unix without SO_NOSIGPIPE | |
100 | ||
101 | #define wxSOCKET_MSG_NOSIGNAL 0 | |
102 | #endif | |
103 | ||
104 | // DLL options compatibility check: | |
105 | #include "wx/build.h" | |
106 | WX_CHECK_BUILD_OPTIONS("wxNet") | |
107 | ||
108 | // -------------------------------------------------------------------------- | |
109 | // macros and constants | |
110 | // -------------------------------------------------------------------------- | |
111 | ||
112 | // event | |
113 | wxDEFINE_EVENT(wxEVT_SOCKET, wxSocketEvent); | |
114 | ||
115 | // discard buffer | |
116 | #define MAX_DISCARD_SIZE (10 * 1024) | |
117 | ||
118 | #define wxTRACE_Socket wxT("wxSocket") | |
119 | ||
120 | // -------------------------------------------------------------------------- | |
121 | // wxWin macros | |
122 | // -------------------------------------------------------------------------- | |
123 | ||
124 | IMPLEMENT_CLASS(wxSocketBase, wxObject) | |
125 | IMPLEMENT_CLASS(wxSocketServer, wxSocketBase) | |
126 | IMPLEMENT_CLASS(wxSocketClient, wxSocketBase) | |
127 | IMPLEMENT_CLASS(wxDatagramSocket, wxSocketBase) | |
128 | IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent) | |
129 | ||
130 | // ---------------------------------------------------------------------------- | |
131 | // private functions | |
132 | // ---------------------------------------------------------------------------- | |
133 | ||
134 | namespace | |
135 | { | |
136 | ||
137 | void SetTimeValFromMS(timeval& tv, unsigned long ms) | |
138 | { | |
139 | tv.tv_sec = (ms / 1000); | |
140 | tv.tv_usec = (ms % 1000) * 1000; | |
141 | } | |
142 | ||
143 | } // anonymous namespace | |
144 | ||
145 | // -------------------------------------------------------------------------- | |
146 | // private classes | |
147 | // -------------------------------------------------------------------------- | |
148 | ||
149 | class wxSocketState : public wxObject | |
150 | { | |
151 | public: | |
152 | wxSocketFlags m_flags; | |
153 | wxSocketEventFlags m_eventmask; | |
154 | bool m_notify; | |
155 | void *m_clientData; | |
156 | ||
157 | public: | |
158 | wxSocketState() : wxObject() {} | |
159 | ||
160 | wxDECLARE_NO_COPY_CLASS(wxSocketState); | |
161 | }; | |
162 | ||
163 | // wxSocketWaitModeChanger: temporarily change the socket flags affecting its | |
164 | // wait mode | |
165 | class wxSocketWaitModeChanger | |
166 | { | |
167 | public: | |
168 | // temporarily set the flags to include the flag value which may be either | |
169 | // wxSOCKET_NOWAIT or wxSOCKET_WAITALL | |
170 | wxSocketWaitModeChanger(wxSocketBase *socket, int flag) | |
171 | : m_socket(socket), | |
172 | m_oldflags(socket->GetFlags()) | |
173 | ||
174 | { | |
175 | wxASSERT_MSG( flag == wxSOCKET_WAITALL || flag == wxSOCKET_NOWAIT, | |
176 | "not a wait flag" ); | |
177 | ||
178 | // preserve wxSOCKET_BLOCK value when switching to wxSOCKET_WAITALL | |
179 | // mode but not when switching to wxSOCKET_NOWAIT as the latter is | |
180 | // incompatible with wxSOCKET_BLOCK | |
181 | if ( flag != wxSOCKET_NOWAIT ) | |
182 | flag |= m_oldflags & wxSOCKET_BLOCK; | |
183 | ||
184 | socket->SetFlags(flag); | |
185 | } | |
186 | ||
187 | ~wxSocketWaitModeChanger() | |
188 | { | |
189 | m_socket->SetFlags(m_oldflags); | |
190 | } | |
191 | ||
192 | private: | |
193 | wxSocketBase * const m_socket; | |
194 | const int m_oldflags; | |
195 | ||
196 | wxDECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger); | |
197 | }; | |
198 | ||
199 | // wxSocketRead/WriteGuard are instantiated before starting reading | |
200 | // from/writing to the socket | |
201 | class wxSocketReadGuard | |
202 | { | |
203 | public: | |
204 | wxSocketReadGuard(wxSocketBase *socket) | |
205 | : m_socket(socket) | |
206 | { | |
207 | wxASSERT_MSG( !m_socket->m_reading, "read reentrancy?" ); | |
208 | ||
209 | m_socket->m_reading = true; | |
210 | } | |
211 | ||
212 | ~wxSocketReadGuard() | |
213 | { | |
214 | m_socket->m_reading = false; | |
215 | ||
216 | // connection could have been lost while reading, in this case calling | |
217 | // ReenableEvents() would assert and is not necessary anyhow | |
218 | wxSocketImpl * const impl = m_socket->m_impl; | |
219 | if ( impl && impl->m_fd != INVALID_SOCKET ) | |
220 | impl->ReenableEvents(wxSOCKET_INPUT_FLAG); | |
221 | } | |
222 | ||
223 | private: | |
224 | wxSocketBase * const m_socket; | |
225 | ||
226 | wxDECLARE_NO_COPY_CLASS(wxSocketReadGuard); | |
227 | }; | |
228 | ||
229 | class wxSocketWriteGuard | |
230 | { | |
231 | public: | |
232 | wxSocketWriteGuard(wxSocketBase *socket) | |
233 | : m_socket(socket) | |
234 | { | |
235 | wxASSERT_MSG( !m_socket->m_writing, "write reentrancy?" ); | |
236 | ||
237 | m_socket->m_writing = true; | |
238 | } | |
239 | ||
240 | ~wxSocketWriteGuard() | |
241 | { | |
242 | m_socket->m_writing = false; | |
243 | ||
244 | wxSocketImpl * const impl = m_socket->m_impl; | |
245 | if ( impl && impl->m_fd != INVALID_SOCKET ) | |
246 | impl->ReenableEvents(wxSOCKET_OUTPUT_FLAG); | |
247 | } | |
248 | ||
249 | private: | |
250 | wxSocketBase * const m_socket; | |
251 | ||
252 | wxDECLARE_NO_COPY_CLASS(wxSocketWriteGuard); | |
253 | }; | |
254 | ||
255 | // ============================================================================ | |
256 | // wxSocketManager | |
257 | // ============================================================================ | |
258 | ||
259 | wxSocketManager *wxSocketManager::ms_manager = NULL; | |
260 | ||
261 | /* static */ | |
262 | void wxSocketManager::Set(wxSocketManager *manager) | |
263 | { | |
264 | wxASSERT_MSG( !ms_manager, "too late to set manager now" ); | |
265 | ||
266 | ms_manager = manager; | |
267 | } | |
268 | ||
269 | /* static */ | |
270 | void wxSocketManager::Init() | |
271 | { | |
272 | wxASSERT_MSG( !ms_manager, "shouldn't be initialized twice" ); | |
273 | ||
274 | /* | |
275 | Details: Initialize() creates a hidden window as a sink for socket | |
276 | events, such as 'read completed'. wxMSW has only one message loop | |
277 | for the main thread. If Initialize is called in a secondary thread, | |
278 | the socket window will be created for the secondary thread, but | |
279 | since there is no message loop on this thread, it will never | |
280 | receive events and all socket operations will time out. | |
281 | BTW, the main thread must not be stopped using sleep or block | |
282 | on a semaphore (a bad idea in any case) or socket operations | |
283 | will time out. | |
284 | ||
285 | On the Mac side, Initialize() stores a pointer to the CFRunLoop for | |
286 | the main thread. Because secondary threads do not have run loops, | |
287 | adding event notifications to the "Current" loop would have no | |
288 | effect at all, events would never fire. | |
289 | */ | |
290 | wxASSERT_MSG( wxIsMainThread(), | |
291 | "sockets must be initialized from the main thread" ); | |
292 | ||
293 | wxAppConsole * const app = wxAppConsole::GetInstance(); | |
294 | wxCHECK_RET( app, "sockets can't be initialized without wxApp" ); | |
295 | ||
296 | ms_manager = app->GetTraits()->GetSocketManager(); | |
297 | } | |
298 | ||
299 | // ========================================================================== | |
300 | // wxSocketImpl | |
301 | // ========================================================================== | |
302 | ||
303 | wxSocketImpl::wxSocketImpl(wxSocketBase& wxsocket) | |
304 | : m_wxsocket(&wxsocket) | |
305 | { | |
306 | m_fd = INVALID_SOCKET; | |
307 | m_error = wxSOCKET_NOERROR; | |
308 | m_server = false; | |
309 | m_stream = true; | |
310 | ||
311 | SetTimeout(wxsocket.GetTimeout() * 1000); | |
312 | ||
313 | m_establishing = false; | |
314 | m_reusable = false; | |
315 | m_broadcast = false; | |
316 | m_dobind = true; | |
317 | m_initialRecvBufferSize = -1; | |
318 | m_initialSendBufferSize = -1; | |
319 | } | |
320 | ||
321 | wxSocketImpl::~wxSocketImpl() | |
322 | { | |
323 | if ( m_fd != INVALID_SOCKET ) | |
324 | Shutdown(); | |
325 | } | |
326 | ||
327 | bool wxSocketImpl::PreCreateCheck(const wxSockAddressImpl& addr) | |
328 | { | |
329 | if ( m_fd != INVALID_SOCKET ) | |
330 | { | |
331 | m_error = wxSOCKET_INVSOCK; | |
332 | return false; | |
333 | } | |
334 | ||
335 | if ( !addr.IsOk() ) | |
336 | { | |
337 | m_error = wxSOCKET_INVADDR; | |
338 | return false; | |
339 | } | |
340 | ||
341 | return true; | |
342 | } | |
343 | ||
344 | void wxSocketImpl::PostCreation() | |
345 | { | |
346 | // FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option | |
347 | #ifdef SO_NOSIGPIPE | |
348 | EnableSocketOption(SO_NOSIGPIPE); | |
349 | #endif | |
350 | ||
351 | if ( m_reusable ) | |
352 | EnableSocketOption(SO_REUSEADDR); | |
353 | ||
354 | if ( m_broadcast ) | |
355 | { | |
356 | wxASSERT_MSG( !m_stream, "broadcasting is for datagram sockets only" ); | |
357 | ||
358 | EnableSocketOption(SO_BROADCAST); | |
359 | } | |
360 | ||
361 | if ( m_initialRecvBufferSize >= 0 ) | |
362 | SetSocketOption(SO_RCVBUF, m_initialRecvBufferSize); | |
363 | if ( m_initialSendBufferSize >= 0 ) | |
364 | SetSocketOption(SO_SNDBUF, m_initialSendBufferSize); | |
365 | ||
366 | // we always put our sockets in unblocked mode and handle blocking | |
367 | // ourselves in DoRead/Write() if wxSOCKET_WAITALL is specified | |
368 | UnblockAndRegisterWithEventLoop(); | |
369 | } | |
370 | ||
371 | wxSocketError wxSocketImpl::UpdateLocalAddress() | |
372 | { | |
373 | if ( !m_local.IsOk() ) | |
374 | { | |
375 | // ensure that we have a valid object using the correct family: correct | |
376 | // being the same one as our peer uses as we have no other way to | |
377 | // determine it | |
378 | m_local.Create(m_peer.GetFamily()); | |
379 | } | |
380 | ||
381 | WX_SOCKLEN_T lenAddr = m_local.GetLen(); | |
382 | if ( getsockname(m_fd, m_local.GetWritableAddr(), &lenAddr) != 0 ) | |
383 | { | |
384 | Close(); | |
385 | m_error = wxSOCKET_IOERR; | |
386 | return m_error; | |
387 | } | |
388 | ||
389 | return wxSOCKET_NOERROR; | |
390 | } | |
391 | ||
392 | wxSocketError wxSocketImpl::CreateServer() | |
393 | { | |
394 | if ( !PreCreateCheck(m_local) ) | |
395 | return m_error; | |
396 | ||
397 | m_server = true; | |
398 | m_stream = true; | |
399 | ||
400 | // do create the socket | |
401 | m_fd = socket(m_local.GetFamily(), SOCK_STREAM, 0); | |
402 | ||
403 | if ( m_fd == INVALID_SOCKET ) | |
404 | { | |
405 | m_error = wxSOCKET_IOERR; | |
406 | return wxSOCKET_IOERR; | |
407 | } | |
408 | ||
409 | PostCreation(); | |
410 | ||
411 | // and then bind to and listen on it | |
412 | // | |
413 | // FIXME: should we test for m_dobind here? | |
414 | if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 ) | |
415 | m_error = wxSOCKET_IOERR; | |
416 | ||
417 | if ( IsOk() ) | |
418 | { | |
419 | if ( listen(m_fd, 5) != 0 ) | |
420 | m_error = wxSOCKET_IOERR; | |
421 | } | |
422 | ||
423 | if ( !IsOk() ) | |
424 | { | |
425 | Close(); | |
426 | return m_error; | |
427 | } | |
428 | ||
429 | // finally retrieve the address we effectively bound to | |
430 | return UpdateLocalAddress(); | |
431 | } | |
432 | ||
433 | wxSocketError wxSocketImpl::CreateClient(bool wait) | |
434 | { | |
435 | if ( !PreCreateCheck(m_peer) ) | |
436 | return m_error; | |
437 | ||
438 | m_fd = socket(m_peer.GetFamily(), SOCK_STREAM, 0); | |
439 | ||
440 | if ( m_fd == INVALID_SOCKET ) | |
441 | { | |
442 | m_error = wxSOCKET_IOERR; | |
443 | return wxSOCKET_IOERR; | |
444 | } | |
445 | ||
446 | PostCreation(); | |
447 | ||
448 | // If a local address has been set, then bind to it before calling connect | |
449 | if ( m_local.IsOk() ) | |
450 | { | |
451 | if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 ) | |
452 | { | |
453 | Close(); | |
454 | m_error = wxSOCKET_IOERR; | |
455 | return m_error; | |
456 | } | |
457 | } | |
458 | ||
459 | // Do connect now | |
460 | int rc = connect(m_fd, m_peer.GetAddr(), m_peer.GetLen()); | |
461 | if ( rc == SOCKET_ERROR ) | |
462 | { | |
463 | wxSocketError err = GetLastError(); | |
464 | if ( err == wxSOCKET_WOULDBLOCK ) | |
465 | { | |
466 | m_establishing = true; | |
467 | ||
468 | // block waiting for connection if we should (otherwise just return | |
469 | // wxSOCKET_WOULDBLOCK to the caller) | |
470 | if ( wait ) | |
471 | { | |
472 | err = SelectWithTimeout(wxSOCKET_CONNECTION_FLAG) | |
473 | ? wxSOCKET_NOERROR | |
474 | : wxSOCKET_TIMEDOUT; | |
475 | m_establishing = false; | |
476 | } | |
477 | } | |
478 | ||
479 | m_error = err; | |
480 | } | |
481 | else // connected | |
482 | { | |
483 | m_error = wxSOCKET_NOERROR; | |
484 | } | |
485 | ||
486 | return m_error; | |
487 | } | |
488 | ||
489 | ||
490 | wxSocketError wxSocketImpl::CreateUDP() | |
491 | { | |
492 | if ( !PreCreateCheck(m_local) ) | |
493 | return m_error; | |
494 | ||
495 | m_stream = false; | |
496 | m_server = false; | |
497 | ||
498 | m_fd = socket(m_local.GetFamily(), SOCK_DGRAM, 0); | |
499 | ||
500 | if ( m_fd == INVALID_SOCKET ) | |
501 | { | |
502 | m_error = wxSOCKET_IOERR; | |
503 | return wxSOCKET_IOERR; | |
504 | } | |
505 | ||
506 | PostCreation(); | |
507 | ||
508 | if ( m_dobind ) | |
509 | { | |
510 | if ( bind(m_fd, m_local.GetAddr(), m_local.GetLen()) != 0 ) | |
511 | { | |
512 | Close(); | |
513 | m_error = wxSOCKET_IOERR; | |
514 | return m_error; | |
515 | } | |
516 | ||
517 | return UpdateLocalAddress(); | |
518 | } | |
519 | ||
520 | return wxSOCKET_NOERROR; | |
521 | } | |
522 | ||
523 | wxSocketImpl *wxSocketImpl::Accept(wxSocketBase& wxsocket) | |
524 | { | |
525 | wxSockAddressStorage from; | |
526 | WX_SOCKLEN_T fromlen = sizeof(from); | |
527 | const SOCKET fd = accept(m_fd, &from.addr, &fromlen); | |
528 | ||
529 | // accepting is similar to reading in the sense that it resets "ready for | |
530 | // read" flag on the socket | |
531 | ReenableEvents(wxSOCKET_INPUT_FLAG); | |
532 | ||
533 | if ( fd == INVALID_SOCKET ) | |
534 | return NULL; | |
535 | ||
536 | wxSocketManager * const manager = wxSocketManager::Get(); | |
537 | if ( !manager ) | |
538 | return NULL; | |
539 | ||
540 | wxSocketImpl * const sock = manager->CreateSocket(wxsocket); | |
541 | if ( !sock ) | |
542 | return NULL; | |
543 | ||
544 | sock->m_fd = fd; | |
545 | sock->m_peer = wxSockAddressImpl(from.addr, fromlen); | |
546 | ||
547 | sock->UnblockAndRegisterWithEventLoop(); | |
548 | ||
549 | return sock; | |
550 | } | |
551 | ||
552 | ||
553 | void wxSocketImpl::Close() | |
554 | { | |
555 | if ( m_fd != INVALID_SOCKET ) | |
556 | { | |
557 | DoClose(); | |
558 | m_fd = INVALID_SOCKET; | |
559 | } | |
560 | } | |
561 | ||
562 | void wxSocketImpl::Shutdown() | |
563 | { | |
564 | if ( m_fd != INVALID_SOCKET ) | |
565 | { | |
566 | shutdown(m_fd, 1 /* SD_SEND */); | |
567 | Close(); | |
568 | } | |
569 | } | |
570 | ||
571 | /* | |
572 | * Sets the timeout for blocking calls. Time is expressed in | |
573 | * milliseconds. | |
574 | */ | |
575 | void wxSocketImpl::SetTimeout(unsigned long millis) | |
576 | { | |
577 | SetTimeValFromMS(m_timeout, millis); | |
578 | } | |
579 | ||
580 | void wxSocketImpl::NotifyOnStateChange(wxSocketNotify event) | |
581 | { | |
582 | m_wxsocket->OnRequest(event); | |
583 | } | |
584 | ||
585 | /* Address handling */ | |
586 | wxSocketError wxSocketImpl::SetLocal(const wxSockAddressImpl& local) | |
587 | { | |
588 | /* the socket must be initialized, or it must be a server */ | |
589 | if (m_fd != INVALID_SOCKET && !m_server) | |
590 | { | |
591 | m_error = wxSOCKET_INVSOCK; | |
592 | return wxSOCKET_INVSOCK; | |
593 | } | |
594 | ||
595 | if ( !local.IsOk() ) | |
596 | { | |
597 | m_error = wxSOCKET_INVADDR; | |
598 | return wxSOCKET_INVADDR; | |
599 | } | |
600 | ||
601 | m_local = local; | |
602 | ||
603 | return wxSOCKET_NOERROR; | |
604 | } | |
605 | ||
606 | wxSocketError wxSocketImpl::SetPeer(const wxSockAddressImpl& peer) | |
607 | { | |
608 | if ( !peer.IsOk() ) | |
609 | { | |
610 | m_error = wxSOCKET_INVADDR; | |
611 | return wxSOCKET_INVADDR; | |
612 | } | |
613 | ||
614 | m_peer = peer; | |
615 | ||
616 | return wxSOCKET_NOERROR; | |
617 | } | |
618 | ||
619 | const wxSockAddressImpl& wxSocketImpl::GetLocal() | |
620 | { | |
621 | if ( !m_local.IsOk() ) | |
622 | UpdateLocalAddress(); | |
623 | ||
624 | return m_local; | |
625 | } | |
626 | ||
627 | // ---------------------------------------------------------------------------- | |
628 | // wxSocketImpl IO | |
629 | // ---------------------------------------------------------------------------- | |
630 | ||
631 | // this macro wraps the given expression (normally a syscall) in a loop which | |
632 | // ignores any interruptions, i.e. reevaluates it again if it failed and errno | |
633 | // is EINTR | |
634 | #ifdef __UNIX__ | |
635 | #define DO_WHILE_EINTR( rc, syscall ) \ | |
636 | do { \ | |
637 | rc = (syscall); \ | |
638 | } \ | |
639 | while ( rc == -1 && errno == EINTR ) | |
640 | #else | |
641 | #define DO_WHILE_EINTR( rc, syscall ) rc = (syscall) | |
642 | #endif | |
643 | ||
644 | int wxSocketImpl::RecvStream(void *buffer, int size) | |
645 | { | |
646 | int ret; | |
647 | DO_WHILE_EINTR( ret, recv(m_fd, static_cast<char *>(buffer), size, 0) ); | |
648 | ||
649 | if ( !ret ) | |
650 | { | |
651 | // receiving 0 bytes for a TCP socket indicates that the connection was | |
652 | // closed by peer so shut down our end as well (for UDP sockets empty | |
653 | // datagrams are also possible) | |
654 | m_establishing = false; | |
655 | NotifyOnStateChange(wxSOCKET_LOST); | |
656 | ||
657 | Shutdown(); | |
658 | ||
659 | // do not return an error in this case however | |
660 | } | |
661 | ||
662 | return ret; | |
663 | } | |
664 | ||
665 | int wxSocketImpl::SendStream(const void *buffer, int size) | |
666 | { | |
667 | #ifdef wxNEEDS_IGNORE_SIGPIPE | |
668 | IgnoreSignal ignore(SIGPIPE); | |
669 | #endif | |
670 | ||
671 | int ret; | |
672 | DO_WHILE_EINTR( ret, send(m_fd, static_cast<const char *>(buffer), size, | |
673 | wxSOCKET_MSG_NOSIGNAL) ); | |
674 | ||
675 | return ret; | |
676 | } | |
677 | ||
678 | int wxSocketImpl::RecvDgram(void *buffer, int size) | |
679 | { | |
680 | wxSockAddressStorage from; | |
681 | WX_SOCKLEN_T fromlen = sizeof(from); | |
682 | ||
683 | int ret; | |
684 | DO_WHILE_EINTR( ret, recvfrom(m_fd, static_cast<char *>(buffer), size, | |
685 | 0, &from.addr, &fromlen) ); | |
686 | ||
687 | if ( ret == SOCKET_ERROR ) | |
688 | return SOCKET_ERROR; | |
689 | ||
690 | m_peer = wxSockAddressImpl(from.addr, fromlen); | |
691 | if ( !m_peer.IsOk() ) | |
692 | return -1; | |
693 | ||
694 | return ret; | |
695 | } | |
696 | ||
697 | int wxSocketImpl::SendDgram(const void *buffer, int size) | |
698 | { | |
699 | if ( !m_peer.IsOk() ) | |
700 | { | |
701 | m_error = wxSOCKET_INVADDR; | |
702 | return -1; | |
703 | } | |
704 | ||
705 | int ret; | |
706 | DO_WHILE_EINTR( ret, sendto(m_fd, static_cast<const char *>(buffer), size, | |
707 | 0, m_peer.GetAddr(), m_peer.GetLen()) ); | |
708 | ||
709 | return ret; | |
710 | } | |
711 | ||
712 | int wxSocketImpl::Read(void *buffer, int size) | |
713 | { | |
714 | // server sockets can't be used for IO, only to accept new connections | |
715 | if ( m_fd == INVALID_SOCKET || m_server ) | |
716 | { | |
717 | m_error = wxSOCKET_INVSOCK; | |
718 | return -1; | |
719 | } | |
720 | ||
721 | int ret = m_stream ? RecvStream(buffer, size) | |
722 | : RecvDgram(buffer, size); | |
723 | ||
724 | m_error = ret == SOCKET_ERROR ? GetLastError() : wxSOCKET_NOERROR; | |
725 | ||
726 | return ret; | |
727 | } | |
728 | ||
729 | int wxSocketImpl::Write(const void *buffer, int size) | |
730 | { | |
731 | if ( m_fd == INVALID_SOCKET || m_server ) | |
732 | { | |
733 | m_error = wxSOCKET_INVSOCK; | |
734 | return -1; | |
735 | } | |
736 | ||
737 | int ret = m_stream ? SendStream(buffer, size) | |
738 | : SendDgram(buffer, size); | |
739 | ||
740 | m_error = ret == SOCKET_ERROR ? GetLastError() : wxSOCKET_NOERROR; | |
741 | ||
742 | return ret; | |
743 | } | |
744 | ||
745 | // ========================================================================== | |
746 | // wxSocketBase | |
747 | // ========================================================================== | |
748 | ||
749 | // -------------------------------------------------------------------------- | |
750 | // Initialization and shutdown | |
751 | // -------------------------------------------------------------------------- | |
752 | ||
753 | namespace | |
754 | { | |
755 | ||
756 | // counts the number of calls to Initialize() minus the number of calls to | |
757 | // Shutdown(): we don't really need it any more but it was documented that | |
758 | // Shutdown() must be called the same number of times as Initialize() and using | |
759 | // a counter helps us to check it | |
760 | int gs_socketInitCount = 0; | |
761 | ||
762 | } // anonymous namespace | |
763 | ||
764 | bool wxSocketBase::IsInitialized() | |
765 | { | |
766 | wxASSERT_MSG( wxIsMainThread(), "unsafe to call from other threads" ); | |
767 | ||
768 | return gs_socketInitCount != 0; | |
769 | } | |
770 | ||
771 | bool wxSocketBase::Initialize() | |
772 | { | |
773 | wxCHECK_MSG( wxIsMainThread(), false, | |
774 | "must be called from the main thread" ); | |
775 | ||
776 | if ( !gs_socketInitCount ) | |
777 | { | |
778 | wxSocketManager * const manager = wxSocketManager::Get(); | |
779 | if ( !manager || !manager->OnInit() ) | |
780 | return false; | |
781 | } | |
782 | ||
783 | gs_socketInitCount++; | |
784 | ||
785 | return true; | |
786 | } | |
787 | ||
788 | void wxSocketBase::Shutdown() | |
789 | { | |
790 | wxCHECK_RET( wxIsMainThread(), "must be called from the main thread" ); | |
791 | ||
792 | wxCHECK_RET( gs_socketInitCount > 0, "too many calls to Shutdown()" ); | |
793 | ||
794 | if ( !--gs_socketInitCount ) | |
795 | { | |
796 | wxSocketManager * const manager = wxSocketManager::Get(); | |
797 | wxCHECK_RET( manager, "should have a socket manager" ); | |
798 | ||
799 | manager->OnExit(); | |
800 | } | |
801 | } | |
802 | ||
803 | // -------------------------------------------------------------------------- | |
804 | // Ctor and dtor | |
805 | // -------------------------------------------------------------------------- | |
806 | ||
807 | void wxSocketBase::Init() | |
808 | { | |
809 | m_impl = NULL; | |
810 | m_type = wxSOCKET_UNINIT; | |
811 | ||
812 | // state | |
813 | m_flags = 0; | |
814 | m_connected = | |
815 | m_establishing = | |
816 | m_reading = | |
817 | m_writing = | |
818 | m_closed = false; | |
819 | m_lcount = 0; | |
820 | m_timeout = 600; | |
821 | m_beingDeleted = false; | |
822 | ||
823 | // pushback buffer | |
824 | m_unread = NULL; | |
825 | m_unrd_size = 0; | |
826 | m_unrd_cur = 0; | |
827 | ||
828 | // events | |
829 | m_id = wxID_ANY; | |
830 | m_handler = NULL; | |
831 | m_clientData = NULL; | |
832 | m_notify = false; | |
833 | m_eventmask = | |
834 | m_eventsgot = 0; | |
835 | ||
836 | // when we create the first socket in the main thread we initialize the | |
837 | // OS-dependent socket stuff: notice that this means that the user code | |
838 | // needs to call wxSocket::Initialize() itself if the first socket it | |
839 | // creates is not created in the main thread | |
840 | if ( wxIsMainThread() ) | |
841 | { | |
842 | if ( !Initialize() ) | |
843 | { | |
844 | wxLogError(_("Cannot initialize sockets")); | |
845 | } | |
846 | } | |
847 | } | |
848 | ||
849 | wxSocketBase::wxSocketBase() | |
850 | { | |
851 | Init(); | |
852 | } | |
853 | ||
854 | wxSocketBase::wxSocketBase(wxSocketFlags flags, wxSocketType type) | |
855 | { | |
856 | Init(); | |
857 | ||
858 | SetFlags(flags); | |
859 | ||
860 | m_type = type; | |
861 | } | |
862 | ||
863 | wxSocketBase::~wxSocketBase() | |
864 | { | |
865 | // Shutdown and close the socket | |
866 | if (!m_beingDeleted) | |
867 | Close(); | |
868 | ||
869 | // Destroy the implementation object | |
870 | delete m_impl; | |
871 | ||
872 | // Free the pushback buffer | |
873 | free(m_unread); | |
874 | } | |
875 | ||
876 | bool wxSocketBase::Destroy() | |
877 | { | |
878 | // Delayed destruction: the socket will be deleted during the next idle | |
879 | // loop iteration. This ensures that all pending events have been | |
880 | // processed. | |
881 | m_beingDeleted = true; | |
882 | ||
883 | // Shutdown and close the socket | |
884 | Close(); | |
885 | ||
886 | // Suppress events from now on | |
887 | Notify(false); | |
888 | ||
889 | // Schedule this object for deletion instead of destroying it right now if | |
890 | // possible as we may have other events pending for it | |
891 | if ( wxTheApp ) | |
892 | { | |
893 | wxTheApp->ScheduleForDestruction(this); | |
894 | } | |
895 | else // no app | |
896 | { | |
897 | // in wxBase we might have no app object at all, don't leak memory | |
898 | delete this; | |
899 | } | |
900 | ||
901 | return true; | |
902 | } | |
903 | ||
904 | // ---------------------------------------------------------------------------- | |
905 | // simple accessors | |
906 | // ---------------------------------------------------------------------------- | |
907 | ||
908 | void wxSocketBase::SetError(wxSocketError error) | |
909 | { | |
910 | m_impl->m_error = error; | |
911 | } | |
912 | ||
913 | wxSocketError wxSocketBase::LastError() const | |
914 | { | |
915 | return m_impl->GetError(); | |
916 | } | |
917 | ||
918 | // -------------------------------------------------------------------------- | |
919 | // Basic IO calls | |
920 | // -------------------------------------------------------------------------- | |
921 | ||
922 | // The following IO operations update m_lcount: | |
923 | // {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard} | |
924 | bool wxSocketBase::Close() | |
925 | { | |
926 | // Interrupt pending waits | |
927 | InterruptWait(); | |
928 | ||
929 | ShutdownOutput(); | |
930 | ||
931 | m_connected = false; | |
932 | m_establishing = false; | |
933 | return true; | |
934 | } | |
935 | ||
936 | void wxSocketBase::ShutdownOutput() | |
937 | { | |
938 | if ( m_impl ) | |
939 | m_impl->Shutdown(); | |
940 | } | |
941 | ||
942 | wxSocketBase& wxSocketBase::Read(void* buffer, wxUint32 nbytes) | |
943 | { | |
944 | wxSocketReadGuard read(this); | |
945 | ||
946 | m_lcount = DoRead(buffer, nbytes); | |
947 | ||
948 | return *this; | |
949 | } | |
950 | ||
951 | wxUint32 wxSocketBase::DoRead(void* buffer_, wxUint32 nbytes) | |
952 | { | |
953 | wxCHECK_MSG( m_impl, 0, "socket must be valid" ); | |
954 | ||
955 | // We use pointer arithmetic here which doesn't work with void pointers. | |
956 | char *buffer = static_cast<char *>(buffer_); | |
957 | wxCHECK_MSG( buffer, 0, "NULL buffer" ); | |
958 | ||
959 | // Try the push back buffer first, even before checking whether the socket | |
960 | // is valid to allow reading previously pushed back data from an already | |
961 | // closed socket. | |
962 | wxUint32 total = GetPushback(buffer, nbytes, false); | |
963 | nbytes -= total; | |
964 | buffer += total; | |
965 | ||
966 | while ( nbytes ) | |
967 | { | |
968 | // our socket is non-blocking so Read() will return immediately if | |
969 | // there is nothing to read yet and it's more efficient to try it first | |
970 | // before entering DoWait() which is going to start dispatching GUI | |
971 | // events and, even more importantly, we must do this under Windows | |
972 | // where we're not going to get notifications about socket being ready | |
973 | // for reading before we read all the existing data from it | |
974 | const int ret = !m_impl->m_stream || m_connected | |
975 | ? m_impl->Read(buffer, nbytes) | |
976 | : 0; | |
977 | if ( ret == -1 ) | |
978 | { | |
979 | if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) | |
980 | { | |
981 | // if we don't want to wait, just return immediately | |
982 | if ( m_flags & wxSOCKET_NOWAIT ) | |
983 | { | |
984 | // this shouldn't be counted as an error in this case | |
985 | SetError(wxSOCKET_NOERROR); | |
986 | break; | |
987 | } | |
988 | ||
989 | // otherwise wait until the socket becomes ready for reading or | |
990 | // an error occurs on it | |
991 | if ( !DoWaitWithTimeout(wxSOCKET_INPUT_FLAG) ) | |
992 | { | |
993 | // and exit if the timeout elapsed before it did | |
994 | SetError(wxSOCKET_TIMEDOUT); | |
995 | break; | |
996 | } | |
997 | ||
998 | // retry reading | |
999 | continue; | |
1000 | } | |
1001 | else // "real" error | |
1002 | { | |
1003 | SetError(wxSOCKET_IOERR); | |
1004 | break; | |
1005 | } | |
1006 | } | |
1007 | else if ( ret == 0 ) | |
1008 | { | |
1009 | // for connection-oriented (e.g. TCP) sockets we can only read | |
1010 | // 0 bytes if the other end has been closed, and for connectionless | |
1011 | // ones (UDP) this flag doesn't make sense anyhow so we can set it | |
1012 | // to true too without doing any harm | |
1013 | m_closed = true; | |
1014 | ||
1015 | // we're not going to read anything else and so if we haven't read | |
1016 | // anything (or not everything in wxSOCKET_WAITALL case) already, | |
1017 | // signal an error | |
1018 | if ( (m_flags & wxSOCKET_WAITALL) || !total ) | |
1019 | SetError(wxSOCKET_IOERR); | |
1020 | break; | |
1021 | } | |
1022 | ||
1023 | total += ret; | |
1024 | ||
1025 | // if we are happy to read something and not the entire nbytes bytes, | |
1026 | // then we're done | |
1027 | if ( !(m_flags & wxSOCKET_WAITALL) ) | |
1028 | break; | |
1029 | ||
1030 | nbytes -= ret; | |
1031 | buffer += ret; | |
1032 | } | |
1033 | ||
1034 | return total; | |
1035 | } | |
1036 | ||
1037 | wxSocketBase& wxSocketBase::ReadMsg(void* buffer, wxUint32 nbytes) | |
1038 | { | |
1039 | struct | |
1040 | { | |
1041 | unsigned char sig[4]; | |
1042 | unsigned char len[4]; | |
1043 | } msg; | |
1044 | ||
1045 | wxSocketReadGuard read(this); | |
1046 | ||
1047 | wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); | |
1048 | ||
1049 | bool ok = false; | |
1050 | if ( DoRead(&msg, sizeof(msg)) == sizeof(msg) ) | |
1051 | { | |
1052 | wxUint32 sig = (wxUint32)msg.sig[0]; | |
1053 | sig |= (wxUint32)(msg.sig[1] << 8); | |
1054 | sig |= (wxUint32)(msg.sig[2] << 16); | |
1055 | sig |= (wxUint32)(msg.sig[3] << 24); | |
1056 | ||
1057 | if ( sig == 0xfeeddead ) | |
1058 | { | |
1059 | wxUint32 len = (wxUint32)msg.len[0]; | |
1060 | len |= (wxUint32)(msg.len[1] << 8); | |
1061 | len |= (wxUint32)(msg.len[2] << 16); | |
1062 | len |= (wxUint32)(msg.len[3] << 24); | |
1063 | ||
1064 | wxUint32 len2; | |
1065 | if (len > nbytes) | |
1066 | { | |
1067 | len2 = len - nbytes; | |
1068 | len = nbytes; | |
1069 | } | |
1070 | else | |
1071 | len2 = 0; | |
1072 | ||
1073 | // Don't attempt to read if the msg was zero bytes long. | |
1074 | m_lcount = len ? DoRead(buffer, len) : 0; | |
1075 | ||
1076 | if ( len2 ) | |
1077 | { | |
1078 | char discard_buffer[MAX_DISCARD_SIZE]; | |
1079 | long discard_len; | |
1080 | ||
1081 | // NOTE: discarded bytes don't add to m_lcount. | |
1082 | do | |
1083 | { | |
1084 | discard_len = len2 > MAX_DISCARD_SIZE | |
1085 | ? MAX_DISCARD_SIZE | |
1086 | : len2; | |
1087 | discard_len = DoRead(discard_buffer, (wxUint32)discard_len); | |
1088 | len2 -= (wxUint32)discard_len; | |
1089 | } | |
1090 | while ((discard_len > 0) && len2); | |
1091 | } | |
1092 | ||
1093 | if ( !len2 && DoRead(&msg, sizeof(msg)) == sizeof(msg) ) | |
1094 | { | |
1095 | sig = (wxUint32)msg.sig[0]; | |
1096 | sig |= (wxUint32)(msg.sig[1] << 8); | |
1097 | sig |= (wxUint32)(msg.sig[2] << 16); | |
1098 | sig |= (wxUint32)(msg.sig[3] << 24); | |
1099 | ||
1100 | if ( sig == 0xdeadfeed ) | |
1101 | ok = true; | |
1102 | } | |
1103 | } | |
1104 | } | |
1105 | ||
1106 | if ( !ok ) | |
1107 | SetError(wxSOCKET_IOERR); | |
1108 | ||
1109 | return *this; | |
1110 | } | |
1111 | ||
1112 | wxSocketBase& wxSocketBase::Peek(void* buffer, wxUint32 nbytes) | |
1113 | { | |
1114 | wxSocketReadGuard read(this); | |
1115 | ||
1116 | // Peek() should never block | |
1117 | wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT); | |
1118 | ||
1119 | m_lcount = DoRead(buffer, nbytes); | |
1120 | ||
1121 | Pushback(buffer, m_lcount); | |
1122 | ||
1123 | return *this; | |
1124 | } | |
1125 | ||
1126 | wxSocketBase& wxSocketBase::Write(const void *buffer, wxUint32 nbytes) | |
1127 | { | |
1128 | wxSocketWriteGuard write(this); | |
1129 | ||
1130 | m_lcount = DoWrite(buffer, nbytes); | |
1131 | ||
1132 | return *this; | |
1133 | } | |
1134 | ||
1135 | // This function is a mirror image of DoRead() except that it doesn't use the | |
1136 | // push back buffer and doesn't treat 0 return value specially (normally this | |
1137 | // shouldn't happen at all here), so please see comments there for explanations | |
1138 | wxUint32 wxSocketBase::DoWrite(const void *buffer_, wxUint32 nbytes) | |
1139 | { | |
1140 | wxCHECK_MSG( m_impl, 0, "socket must be valid" ); | |
1141 | ||
1142 | const char *buffer = static_cast<const char *>(buffer_); | |
1143 | wxCHECK_MSG( buffer, 0, "NULL buffer" ); | |
1144 | ||
1145 | wxUint32 total = 0; | |
1146 | while ( nbytes ) | |
1147 | { | |
1148 | if ( m_impl->m_stream && !m_connected ) | |
1149 | { | |
1150 | if ( (m_flags & wxSOCKET_WAITALL) || !total ) | |
1151 | SetError(wxSOCKET_IOERR); | |
1152 | break; | |
1153 | } | |
1154 | ||
1155 | const int ret = m_impl->Write(buffer, nbytes); | |
1156 | if ( ret == -1 ) | |
1157 | { | |
1158 | if ( m_impl->GetLastError() == wxSOCKET_WOULDBLOCK ) | |
1159 | { | |
1160 | if ( m_flags & wxSOCKET_NOWAIT ) | |
1161 | break; | |
1162 | ||
1163 | if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG) ) | |
1164 | { | |
1165 | SetError(wxSOCKET_TIMEDOUT); | |
1166 | break; | |
1167 | } | |
1168 | ||
1169 | continue; | |
1170 | } | |
1171 | else // "real" error | |
1172 | { | |
1173 | SetError(wxSOCKET_IOERR); | |
1174 | break; | |
1175 | } | |
1176 | } | |
1177 | ||
1178 | total += ret; | |
1179 | ||
1180 | if ( !(m_flags & wxSOCKET_WAITALL) ) | |
1181 | break; | |
1182 | ||
1183 | nbytes -= ret; | |
1184 | buffer += ret; | |
1185 | } | |
1186 | ||
1187 | return total; | |
1188 | } | |
1189 | ||
1190 | wxSocketBase& wxSocketBase::WriteMsg(const void *buffer, wxUint32 nbytes) | |
1191 | { | |
1192 | struct | |
1193 | { | |
1194 | unsigned char sig[4]; | |
1195 | unsigned char len[4]; | |
1196 | } msg; | |
1197 | ||
1198 | wxSocketWriteGuard write(this); | |
1199 | ||
1200 | wxSocketWaitModeChanger changeFlags(this, wxSOCKET_WAITALL); | |
1201 | ||
1202 | msg.sig[0] = (unsigned char) 0xad; | |
1203 | msg.sig[1] = (unsigned char) 0xde; | |
1204 | msg.sig[2] = (unsigned char) 0xed; | |
1205 | msg.sig[3] = (unsigned char) 0xfe; | |
1206 | ||
1207 | msg.len[0] = (unsigned char) (nbytes & 0xff); | |
1208 | msg.len[1] = (unsigned char) ((nbytes >> 8) & 0xff); | |
1209 | msg.len[2] = (unsigned char) ((nbytes >> 16) & 0xff); | |
1210 | msg.len[3] = (unsigned char) ((nbytes >> 24) & 0xff); | |
1211 | ||
1212 | bool ok = false; | |
1213 | if ( DoWrite(&msg, sizeof(msg)) == sizeof(msg) ) | |
1214 | { | |
1215 | m_lcount = DoWrite(buffer, nbytes); | |
1216 | if ( m_lcount == nbytes ) | |
1217 | { | |
1218 | msg.sig[0] = (unsigned char) 0xed; | |
1219 | msg.sig[1] = (unsigned char) 0xfe; | |
1220 | msg.sig[2] = (unsigned char) 0xad; | |
1221 | msg.sig[3] = (unsigned char) 0xde; | |
1222 | msg.len[0] = | |
1223 | msg.len[1] = | |
1224 | msg.len[2] = | |
1225 | msg.len[3] = (char) 0; | |
1226 | ||
1227 | if ( DoWrite(&msg, sizeof(msg)) == sizeof(msg)) | |
1228 | ok = true; | |
1229 | } | |
1230 | } | |
1231 | ||
1232 | if ( !ok ) | |
1233 | SetError(wxSOCKET_IOERR); | |
1234 | ||
1235 | return *this; | |
1236 | } | |
1237 | ||
1238 | wxSocketBase& wxSocketBase::Unread(const void *buffer, wxUint32 nbytes) | |
1239 | { | |
1240 | if (nbytes != 0) | |
1241 | Pushback(buffer, nbytes); | |
1242 | ||
1243 | SetError(wxSOCKET_NOERROR); | |
1244 | m_lcount = nbytes; | |
1245 | ||
1246 | return *this; | |
1247 | } | |
1248 | ||
1249 | wxSocketBase& wxSocketBase::Discard() | |
1250 | { | |
1251 | char *buffer = new char[MAX_DISCARD_SIZE]; | |
1252 | wxUint32 ret; | |
1253 | wxUint32 total = 0; | |
1254 | ||
1255 | wxSocketReadGuard read(this); | |
1256 | ||
1257 | wxSocketWaitModeChanger changeFlags(this, wxSOCKET_NOWAIT); | |
1258 | ||
1259 | do | |
1260 | { | |
1261 | ret = DoRead(buffer, MAX_DISCARD_SIZE); | |
1262 | total += ret; | |
1263 | } | |
1264 | while (ret == MAX_DISCARD_SIZE); | |
1265 | ||
1266 | delete[] buffer; | |
1267 | m_lcount = total; | |
1268 | SetError(wxSOCKET_NOERROR); | |
1269 | ||
1270 | return *this; | |
1271 | } | |
1272 | ||
1273 | // -------------------------------------------------------------------------- | |
1274 | // Wait functions | |
1275 | // -------------------------------------------------------------------------- | |
1276 | ||
1277 | /* | |
1278 | This function will check for the events specified in the flags parameter, | |
1279 | and it will return a mask indicating which operations can be performed. | |
1280 | */ | |
1281 | wxSocketEventFlags wxSocketImpl::Select(wxSocketEventFlags flags, | |
1282 | const timeval *timeout) | |
1283 | { | |
1284 | if ( m_fd == INVALID_SOCKET ) | |
1285 | return (wxSOCKET_LOST_FLAG & flags); | |
1286 | ||
1287 | struct timeval tv; | |
1288 | if ( timeout ) | |
1289 | tv = *timeout; | |
1290 | else | |
1291 | tv.tv_sec = tv.tv_usec = 0; | |
1292 | ||
1293 | // prepare the FD sets, passing NULL for the one(s) we don't use | |
1294 | fd_set | |
1295 | readfds, *preadfds = NULL, | |
1296 | writefds, *pwritefds = NULL, | |
1297 | exceptfds; // always want to know about errors | |
1298 | ||
1299 | if ( flags & wxSOCKET_INPUT_FLAG ) | |
1300 | { | |
1301 | preadfds = &readfds; | |
1302 | wxFD_ZERO(preadfds); | |
1303 | wxFD_SET(m_fd, preadfds); | |
1304 | } | |
1305 | ||
1306 | // when using non-blocking connect() the socket becomes connected | |
1307 | // (successfully or not) when it becomes writable | |
1308 | if ( flags & (wxSOCKET_OUTPUT_FLAG | wxSOCKET_CONNECTION_FLAG) ) | |
1309 | { | |
1310 | pwritefds = &writefds; | |
1311 | wxFD_ZERO(pwritefds); | |
1312 | wxFD_SET(m_fd, pwritefds); | |
1313 | } | |
1314 | ||
1315 | wxFD_ZERO(&exceptfds); | |
1316 | wxFD_SET(m_fd, &exceptfds); | |
1317 | ||
1318 | const int rc = select(m_fd + 1, preadfds, pwritefds, &exceptfds, &tv); | |
1319 | ||
1320 | // check for errors first | |
1321 | if ( rc == -1 || wxFD_ISSET(m_fd, &exceptfds) ) | |
1322 | { | |
1323 | m_establishing = false; | |
1324 | ||
1325 | return wxSOCKET_LOST_FLAG & flags; | |
1326 | } | |
1327 | ||
1328 | if ( rc == 0 ) | |
1329 | return 0; | |
1330 | ||
1331 | wxASSERT_MSG( rc == 1, "unexpected select() return value" ); | |
1332 | ||
1333 | wxSocketEventFlags detected = 0; | |
1334 | if ( preadfds && wxFD_ISSET(m_fd, preadfds) ) | |
1335 | detected |= wxSOCKET_INPUT_FLAG; | |
1336 | ||
1337 | if ( pwritefds && wxFD_ISSET(m_fd, pwritefds) ) | |
1338 | { | |
1339 | // check for the case of non-blocking connect() | |
1340 | if ( m_establishing && !m_server ) | |
1341 | { | |
1342 | int error; | |
1343 | SOCKOPTLEN_T len = sizeof(error); | |
1344 | m_establishing = false; | |
1345 | getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len); | |
1346 | ||
1347 | if ( error ) | |
1348 | detected = wxSOCKET_LOST_FLAG; | |
1349 | else | |
1350 | detected |= wxSOCKET_CONNECTION_FLAG; | |
1351 | } | |
1352 | else // not called to get non-blocking connect() status | |
1353 | { | |
1354 | detected |= wxSOCKET_OUTPUT_FLAG; | |
1355 | } | |
1356 | } | |
1357 | ||
1358 | return detected & flags; | |
1359 | } | |
1360 | ||
1361 | int | |
1362 | wxSocketBase::DoWait(long seconds, long milliseconds, wxSocketEventFlags flags) | |
1363 | { | |
1364 | // Use either the provided timeout or the default timeout value associated | |
1365 | // with this socket. | |
1366 | // | |
1367 | // TODO: allow waiting forever, see #9443 | |
1368 | const long timeout = seconds == -1 ? m_timeout * 1000 | |
1369 | : seconds * 1000 + milliseconds; | |
1370 | ||
1371 | return DoWait(timeout, flags); | |
1372 | } | |
1373 | ||
1374 | int | |
1375 | wxSocketBase::DoWait(long timeout, wxSocketEventFlags flags) | |
1376 | { | |
1377 | wxCHECK_MSG( m_impl, -1, "can't wait on invalid socket" ); | |
1378 | ||
1379 | // we're never going to become ready in a TCP client if we're not connected | |
1380 | // any more (OTOH a server can call this to precisely wait for a connection | |
1381 | // so do wait for it in this case and UDP client is never "connected") | |
1382 | if ( !m_impl->IsServer() && | |
1383 | m_impl->m_stream && !m_connected && !m_establishing ) | |
1384 | return -1; | |
1385 | ||
1386 | // This can be set to true from Interrupt() to exit this function a.s.a.p. | |
1387 | m_interrupt = false; | |
1388 | ||
1389 | ||
1390 | const wxMilliClock_t timeEnd = wxGetLocalTimeMillis() + timeout; | |
1391 | ||
1392 | // Get the active event loop which we'll use for the message dispatching | |
1393 | // when running in the main thread unless this was explicitly disabled by | |
1394 | // setting wxSOCKET_BLOCK flag | |
1395 | wxEventLoopBase *eventLoop; | |
1396 | if ( !(m_flags & wxSOCKET_BLOCK) && wxIsMainThread() ) | |
1397 | { | |
1398 | eventLoop = wxEventLoop::GetActive(); | |
1399 | } | |
1400 | else // in worker thread | |
1401 | { | |
1402 | // We never dispatch messages from threads other than the main one. | |
1403 | eventLoop = NULL; | |
1404 | } | |
1405 | ||
1406 | // Make sure the events we're interested in are enabled before waiting for | |
1407 | // them: this is really necessary here as otherwise this could happen: | |
1408 | // 1. DoRead(wxSOCKET_WAITALL) is called | |
1409 | // 2. There is nothing to read so DoWait(wxSOCKET_INPUT_FLAG) is called | |
1410 | // 3. Some, but not all data appears, wxSocketImplUnix::OnReadWaiting() | |
1411 | // is called and wxSOCKET_INPUT_FLAG events are disabled in it | |
1412 | // 4. Because of wxSOCKET_WAITALL we call DoWait() again but the events | |
1413 | // are still disabled and we block forever | |
1414 | // | |
1415 | // More elegant solution would be nice but for now simply re-enabling the | |
1416 | // events here will do | |
1417 | m_impl->ReenableEvents(flags & (wxSOCKET_INPUT_FLAG | wxSOCKET_OUTPUT_FLAG)); | |
1418 | ||
1419 | ||
1420 | // Wait until we receive the event we're waiting for or the timeout expires | |
1421 | // (but note that we always execute the loop at least once, even if timeout | |
1422 | // is 0 as this is used for polling) | |
1423 | int rc = 0; | |
1424 | for ( bool firstTime = true; !m_interrupt; firstTime = false ) | |
1425 | { | |
1426 | long timeLeft = wxMilliClockToLong(timeEnd - wxGetLocalTimeMillis()); | |
1427 | if ( timeLeft < 0 ) | |
1428 | { | |
1429 | if ( !firstTime ) | |
1430 | break; // timed out | |
1431 | ||
1432 | timeLeft = 0; | |
1433 | } | |
1434 | ||
1435 | wxSocketEventFlags events; | |
1436 | if ( eventLoop ) | |
1437 | { | |
1438 | // reset them before starting to wait | |
1439 | m_eventsgot = 0; | |
1440 | ||
1441 | eventLoop->DispatchTimeout(timeLeft); | |
1442 | ||
1443 | events = m_eventsgot; | |
1444 | } | |
1445 | else // no event loop or waiting in another thread | |
1446 | { | |
1447 | // as explained below, we should always check for wxSOCKET_LOST_FLAG | |
1448 | timeval tv; | |
1449 | SetTimeValFromMS(tv, timeLeft); | |
1450 | events = m_impl->Select(flags | wxSOCKET_LOST_FLAG, &tv); | |
1451 | } | |
1452 | ||
1453 | // always check for wxSOCKET_LOST_FLAG, even if flags doesn't include | |
1454 | // it, as continuing to wait for anything else after getting it is | |
1455 | // pointless | |
1456 | if ( events & wxSOCKET_LOST_FLAG ) | |
1457 | { | |
1458 | m_connected = false; | |
1459 | m_establishing = false; | |
1460 | rc = -1; | |
1461 | break; | |
1462 | } | |
1463 | ||
1464 | // otherwise mask out the bits we're not interested in | |
1465 | events &= flags; | |
1466 | ||
1467 | // Incoming connection (server) or connection established (client)? | |
1468 | if ( events & wxSOCKET_CONNECTION_FLAG ) | |
1469 | { | |
1470 | m_connected = true; | |
1471 | m_establishing = false; | |
1472 | rc = true; | |
1473 | break; | |
1474 | } | |
1475 | ||
1476 | // Data available or output buffer ready? | |
1477 | if ( (events & wxSOCKET_INPUT_FLAG) || (events & wxSOCKET_OUTPUT_FLAG) ) | |
1478 | { | |
1479 | rc = true; | |
1480 | break; | |
1481 | } | |
1482 | } | |
1483 | ||
1484 | return rc; | |
1485 | } | |
1486 | ||
1487 | bool wxSocketBase::Wait(long seconds, long milliseconds) | |
1488 | { | |
1489 | return DoWait(seconds, milliseconds, | |
1490 | wxSOCKET_INPUT_FLAG | | |
1491 | wxSOCKET_OUTPUT_FLAG | | |
1492 | wxSOCKET_CONNECTION_FLAG) != 0; | |
1493 | } | |
1494 | ||
1495 | bool wxSocketBase::WaitForRead(long seconds, long milliseconds) | |
1496 | { | |
1497 | // Check pushback buffer before entering DoWait | |
1498 | if ( m_unread ) | |
1499 | return true; | |
1500 | ||
1501 | // Check if the socket is not already ready for input, if it is, there is | |
1502 | // no need to start waiting for it (worse, we'll actually never get a | |
1503 | // notification about the socket becoming ready if it is already under | |
1504 | // Windows) | |
1505 | if ( m_impl->Select(wxSOCKET_INPUT_FLAG) ) | |
1506 | return true; | |
1507 | ||
1508 | return DoWait(seconds, milliseconds, wxSOCKET_INPUT_FLAG) != 0; | |
1509 | } | |
1510 | ||
1511 | ||
1512 | bool wxSocketBase::WaitForWrite(long seconds, long milliseconds) | |
1513 | { | |
1514 | if ( m_impl->Select(wxSOCKET_OUTPUT_FLAG) ) | |
1515 | return true; | |
1516 | ||
1517 | return DoWait(seconds, milliseconds, wxSOCKET_OUTPUT_FLAG) != 0; | |
1518 | } | |
1519 | ||
1520 | bool wxSocketBase::WaitForLost(long seconds, long milliseconds) | |
1521 | { | |
1522 | return DoWait(seconds, milliseconds, wxSOCKET_LOST_FLAG) == -1; | |
1523 | } | |
1524 | ||
1525 | // -------------------------------------------------------------------------- | |
1526 | // Miscellaneous | |
1527 | // -------------------------------------------------------------------------- | |
1528 | ||
1529 | // | |
1530 | // Get local or peer address | |
1531 | // | |
1532 | ||
1533 | bool wxSocketBase::GetPeer(wxSockAddress& addr) const | |
1534 | { | |
1535 | wxCHECK_MSG( m_impl, false, "invalid socket" ); | |
1536 | ||
1537 | const wxSockAddressImpl& peer = m_impl->GetPeer(); | |
1538 | if ( !peer.IsOk() ) | |
1539 | return false; | |
1540 | ||
1541 | addr.SetAddress(peer); | |
1542 | ||
1543 | return true; | |
1544 | } | |
1545 | ||
1546 | bool wxSocketBase::GetLocal(wxSockAddress& addr) const | |
1547 | { | |
1548 | wxCHECK_MSG( m_impl, false, "invalid socket" ); | |
1549 | ||
1550 | const wxSockAddressImpl& local = m_impl->GetLocal(); | |
1551 | if ( !local.IsOk() ) | |
1552 | return false; | |
1553 | ||
1554 | addr.SetAddress(local); | |
1555 | ||
1556 | return true; | |
1557 | } | |
1558 | ||
1559 | // | |
1560 | // Save and restore socket state | |
1561 | // | |
1562 | ||
1563 | void wxSocketBase::SaveState() | |
1564 | { | |
1565 | wxSocketState *state; | |
1566 | ||
1567 | state = new wxSocketState(); | |
1568 | ||
1569 | state->m_flags = m_flags; | |
1570 | state->m_notify = m_notify; | |
1571 | state->m_eventmask = m_eventmask; | |
1572 | state->m_clientData = m_clientData; | |
1573 | ||
1574 | m_states.Append(state); | |
1575 | } | |
1576 | ||
1577 | void wxSocketBase::RestoreState() | |
1578 | { | |
1579 | wxList::compatibility_iterator node; | |
1580 | wxSocketState *state; | |
1581 | ||
1582 | node = m_states.GetLast(); | |
1583 | if (!node) | |
1584 | return; | |
1585 | ||
1586 | state = (wxSocketState *)node->GetData(); | |
1587 | ||
1588 | m_flags = state->m_flags; | |
1589 | m_notify = state->m_notify; | |
1590 | m_eventmask = state->m_eventmask; | |
1591 | m_clientData = state->m_clientData; | |
1592 | ||
1593 | m_states.Erase(node); | |
1594 | delete state; | |
1595 | } | |
1596 | ||
1597 | // | |
1598 | // Timeout and flags | |
1599 | // | |
1600 | ||
1601 | void wxSocketBase::SetTimeout(long seconds) | |
1602 | { | |
1603 | m_timeout = seconds; | |
1604 | ||
1605 | if (m_impl) | |
1606 | m_impl->SetTimeout(m_timeout * 1000); | |
1607 | } | |
1608 | ||
1609 | void wxSocketBase::SetFlags(wxSocketFlags flags) | |
1610 | { | |
1611 | // Do some sanity checking on the flags used: not all values can be used | |
1612 | // together. | |
1613 | wxASSERT_MSG( !(flags & wxSOCKET_NOWAIT) || | |
1614 | !(flags & (wxSOCKET_WAITALL | wxSOCKET_BLOCK)), | |
1615 | "Using wxSOCKET_WAITALL or wxSOCKET_BLOCK with " | |
1616 | "wxSOCKET_NOWAIT doesn't make sense" ); | |
1617 | ||
1618 | m_flags = flags; | |
1619 | } | |
1620 | ||
1621 | ||
1622 | // -------------------------------------------------------------------------- | |
1623 | // Event handling | |
1624 | // -------------------------------------------------------------------------- | |
1625 | ||
1626 | void wxSocketBase::OnRequest(wxSocketNotify notification) | |
1627 | { | |
1628 | wxSocketEventFlags flag = 0; | |
1629 | switch ( notification ) | |
1630 | { | |
1631 | case wxSOCKET_INPUT: | |
1632 | flag = wxSOCKET_INPUT_FLAG; | |
1633 | break; | |
1634 | ||
1635 | case wxSOCKET_OUTPUT: | |
1636 | flag = wxSOCKET_OUTPUT_FLAG; | |
1637 | break; | |
1638 | ||
1639 | case wxSOCKET_CONNECTION: | |
1640 | flag = wxSOCKET_CONNECTION_FLAG; | |
1641 | ||
1642 | // we're now successfully connected | |
1643 | m_connected = true; | |
1644 | m_establishing = false; | |
1645 | ||
1646 | // error was previously set to wxSOCKET_WOULDBLOCK, but this is not | |
1647 | // the case any longer | |
1648 | SetError(wxSOCKET_NOERROR); | |
1649 | break; | |
1650 | ||
1651 | case wxSOCKET_LOST: | |
1652 | flag = wxSOCKET_LOST_FLAG; | |
1653 | ||
1654 | // if we lost the connection the socket is now closed and not | |
1655 | // connected any more | |
1656 | m_connected = false; | |
1657 | m_closed = true; | |
1658 | break; | |
1659 | ||
1660 | default: | |
1661 | wxFAIL_MSG( "unknown wxSocket notification" ); | |
1662 | } | |
1663 | ||
1664 | // remember the events which were generated for this socket, we're going to | |
1665 | // use this in DoWait() | |
1666 | m_eventsgot |= flag; | |
1667 | ||
1668 | // send the wx event if enabled and we're interested in it | |
1669 | if ( m_notify && (m_eventmask & flag) && m_handler ) | |
1670 | { | |
1671 | // don't generate the events when we're inside DoWait() called from our | |
1672 | // own code as we are going to consume the data that has just become | |
1673 | // available ourselves and the user code won't see it at all | |
1674 | if ( (notification == wxSOCKET_INPUT && m_reading) || | |
1675 | (notification == wxSOCKET_OUTPUT && m_writing) ) | |
1676 | { | |
1677 | return; | |
1678 | } | |
1679 | ||
1680 | wxSocketEvent event(m_id); | |
1681 | event.m_event = notification; | |
1682 | event.m_clientData = m_clientData; | |
1683 | event.SetEventObject(this); | |
1684 | ||
1685 | m_handler->AddPendingEvent(event); | |
1686 | } | |
1687 | } | |
1688 | ||
1689 | void wxSocketBase::Notify(bool notify) | |
1690 | { | |
1691 | m_notify = notify; | |
1692 | } | |
1693 | ||
1694 | void wxSocketBase::SetNotify(wxSocketEventFlags flags) | |
1695 | { | |
1696 | m_eventmask = flags; | |
1697 | } | |
1698 | ||
1699 | void wxSocketBase::SetEventHandler(wxEvtHandler& handler, int id) | |
1700 | { | |
1701 | m_handler = &handler; | |
1702 | m_id = id; | |
1703 | } | |
1704 | ||
1705 | // -------------------------------------------------------------------------- | |
1706 | // Pushback buffer | |
1707 | // -------------------------------------------------------------------------- | |
1708 | ||
1709 | void wxSocketBase::Pushback(const void *buffer, wxUint32 size) | |
1710 | { | |
1711 | if (!size) return; | |
1712 | ||
1713 | if (m_unread == NULL) | |
1714 | m_unread = malloc(size); | |
1715 | else | |
1716 | { | |
1717 | void *tmp; | |
1718 | ||
1719 | tmp = malloc(m_unrd_size + size); | |
1720 | memcpy((char *)tmp + size, m_unread, m_unrd_size); | |
1721 | free(m_unread); | |
1722 | ||
1723 | m_unread = tmp; | |
1724 | } | |
1725 | ||
1726 | m_unrd_size += size; | |
1727 | ||
1728 | memcpy(m_unread, buffer, size); | |
1729 | } | |
1730 | ||
1731 | wxUint32 wxSocketBase::GetPushback(void *buffer, wxUint32 size, bool peek) | |
1732 | { | |
1733 | wxCHECK_MSG( buffer, 0, "NULL buffer" ); | |
1734 | ||
1735 | if (!m_unrd_size) | |
1736 | return 0; | |
1737 | ||
1738 | if (size > (m_unrd_size-m_unrd_cur)) | |
1739 | size = m_unrd_size-m_unrd_cur; | |
1740 | ||
1741 | memcpy(buffer, (char *)m_unread + m_unrd_cur, size); | |
1742 | ||
1743 | if (!peek) | |
1744 | { | |
1745 | m_unrd_cur += size; | |
1746 | if (m_unrd_size == m_unrd_cur) | |
1747 | { | |
1748 | free(m_unread); | |
1749 | m_unread = NULL; | |
1750 | m_unrd_size = 0; | |
1751 | m_unrd_cur = 0; | |
1752 | } | |
1753 | } | |
1754 | ||
1755 | return size; | |
1756 | } | |
1757 | ||
1758 | ||
1759 | // ========================================================================== | |
1760 | // wxSocketServer | |
1761 | // ========================================================================== | |
1762 | ||
1763 | // -------------------------------------------------------------------------- | |
1764 | // Ctor | |
1765 | // -------------------------------------------------------------------------- | |
1766 | ||
1767 | wxSocketServer::wxSocketServer(const wxSockAddress& addr, | |
1768 | wxSocketFlags flags) | |
1769 | : wxSocketBase(flags, wxSOCKET_SERVER) | |
1770 | { | |
1771 | wxLogTrace( wxTRACE_Socket, wxT("Opening wxSocketServer") ); | |
1772 | ||
1773 | wxSocketManager * const manager = wxSocketManager::Get(); | |
1774 | m_impl = manager ? manager->CreateSocket(*this) : NULL; | |
1775 | ||
1776 | if (!m_impl) | |
1777 | { | |
1778 | wxLogTrace( wxTRACE_Socket, wxT("*** Failed to create m_impl") ); | |
1779 | return; | |
1780 | } | |
1781 | ||
1782 | // Setup the socket as server | |
1783 | m_impl->SetLocal(addr.GetAddress()); | |
1784 | ||
1785 | if (GetFlags() & wxSOCKET_REUSEADDR) { | |
1786 | m_impl->SetReusable(); | |
1787 | } | |
1788 | if (GetFlags() & wxSOCKET_BROADCAST) { | |
1789 | m_impl->SetBroadcast(); | |
1790 | } | |
1791 | if (GetFlags() & wxSOCKET_NOBIND) { | |
1792 | m_impl->DontDoBind(); | |
1793 | } | |
1794 | ||
1795 | if (m_impl->CreateServer() != wxSOCKET_NOERROR) | |
1796 | { | |
1797 | wxDELETE(m_impl); | |
1798 | ||
1799 | wxLogTrace( wxTRACE_Socket, wxT("*** CreateServer() failed") ); | |
1800 | return; | |
1801 | } | |
1802 | ||
1803 | wxLogTrace( wxTRACE_Socket, wxT("wxSocketServer on fd %d"), m_impl->m_fd ); | |
1804 | } | |
1805 | ||
1806 | // -------------------------------------------------------------------------- | |
1807 | // Accept | |
1808 | // -------------------------------------------------------------------------- | |
1809 | ||
1810 | bool wxSocketServer::AcceptWith(wxSocketBase& sock, bool wait) | |
1811 | { | |
1812 | if ( !m_impl || (m_impl->m_fd == INVALID_SOCKET) || !m_impl->IsServer() ) | |
1813 | { | |
1814 | wxFAIL_MSG( "can only be called for a valid server socket" ); | |
1815 | ||
1816 | SetError(wxSOCKET_INVSOCK); | |
1817 | ||
1818 | return false; | |
1819 | } | |
1820 | ||
1821 | if ( wait ) | |
1822 | { | |
1823 | // wait until we get a connection | |
1824 | if ( !m_impl->SelectWithTimeout(wxSOCKET_INPUT_FLAG) ) | |
1825 | { | |
1826 | SetError(wxSOCKET_TIMEDOUT); | |
1827 | ||
1828 | return false; | |
1829 | } | |
1830 | } | |
1831 | ||
1832 | sock.m_impl = m_impl->Accept(sock); | |
1833 | ||
1834 | if ( !sock.m_impl ) | |
1835 | { | |
1836 | SetError(m_impl->GetLastError()); | |
1837 | ||
1838 | return false; | |
1839 | } | |
1840 | ||
1841 | sock.m_type = wxSOCKET_BASE; | |
1842 | sock.m_connected = true; | |
1843 | ||
1844 | return true; | |
1845 | } | |
1846 | ||
1847 | wxSocketBase *wxSocketServer::Accept(bool wait) | |
1848 | { | |
1849 | wxSocketBase* sock = new wxSocketBase(); | |
1850 | ||
1851 | sock->SetFlags(m_flags); | |
1852 | ||
1853 | if (!AcceptWith(*sock, wait)) | |
1854 | { | |
1855 | sock->Destroy(); | |
1856 | sock = NULL; | |
1857 | } | |
1858 | ||
1859 | return sock; | |
1860 | } | |
1861 | ||
1862 | bool wxSocketServer::WaitForAccept(long seconds, long milliseconds) | |
1863 | { | |
1864 | return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG) == 1; | |
1865 | } | |
1866 | ||
1867 | bool wxSocketBase::GetOption(int level, int optname, void *optval, int *optlen) | |
1868 | { | |
1869 | wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); | |
1870 | ||
1871 | SOCKOPTLEN_T lenreal = *optlen; | |
1872 | if ( getsockopt(m_impl->m_fd, level, optname, | |
1873 | static_cast<char *>(optval), &lenreal) != 0 ) | |
1874 | return false; | |
1875 | ||
1876 | *optlen = lenreal; | |
1877 | ||
1878 | return true; | |
1879 | } | |
1880 | ||
1881 | bool | |
1882 | wxSocketBase::SetOption(int level, int optname, const void *optval, int optlen) | |
1883 | { | |
1884 | wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); | |
1885 | ||
1886 | return setsockopt(m_impl->m_fd, level, optname, | |
1887 | static_cast<const char *>(optval), optlen) == 0; | |
1888 | } | |
1889 | ||
1890 | bool wxSocketBase::SetLocal(const wxIPV4address& local) | |
1891 | { | |
1892 | m_localAddress = local; | |
1893 | ||
1894 | return true; | |
1895 | } | |
1896 | ||
1897 | // ========================================================================== | |
1898 | // wxSocketClient | |
1899 | // ========================================================================== | |
1900 | ||
1901 | // -------------------------------------------------------------------------- | |
1902 | // Ctor and dtor | |
1903 | // -------------------------------------------------------------------------- | |
1904 | ||
1905 | wxSocketClient::wxSocketClient(wxSocketFlags flags) | |
1906 | : wxSocketBase(flags, wxSOCKET_CLIENT) | |
1907 | { | |
1908 | m_initialRecvBufferSize = | |
1909 | m_initialSendBufferSize = -1; | |
1910 | } | |
1911 | ||
1912 | // -------------------------------------------------------------------------- | |
1913 | // Connect | |
1914 | // -------------------------------------------------------------------------- | |
1915 | ||
1916 | bool wxSocketClient::DoConnect(const wxSockAddress& remote, | |
1917 | const wxSockAddress* local, | |
1918 | bool wait) | |
1919 | { | |
1920 | if ( m_impl ) | |
1921 | { | |
1922 | // Shutdown and destroy the old socket | |
1923 | Close(); | |
1924 | delete m_impl; | |
1925 | } | |
1926 | ||
1927 | m_connected = false; | |
1928 | m_establishing = false; | |
1929 | ||
1930 | // Create and set up the new one | |
1931 | wxSocketManager * const manager = wxSocketManager::Get(); | |
1932 | m_impl = manager ? manager->CreateSocket(*this) : NULL; | |
1933 | if ( !m_impl ) | |
1934 | return false; | |
1935 | ||
1936 | // Reuse makes sense for clients too, if we are trying to rebind to the same port | |
1937 | if (GetFlags() & wxSOCKET_REUSEADDR) | |
1938 | m_impl->SetReusable(); | |
1939 | if (GetFlags() & wxSOCKET_BROADCAST) | |
1940 | m_impl->SetBroadcast(); | |
1941 | if (GetFlags() & wxSOCKET_NOBIND) | |
1942 | m_impl->DontDoBind(); | |
1943 | ||
1944 | // Bind to the local IP address and port, when provided or if one had been | |
1945 | // set before | |
1946 | if ( !local && m_localAddress.GetAddress().IsOk() ) | |
1947 | local = &m_localAddress; | |
1948 | ||
1949 | if ( local ) | |
1950 | m_impl->SetLocal(local->GetAddress()); | |
1951 | ||
1952 | m_impl->SetInitialSocketBuffers(m_initialRecvBufferSize, m_initialSendBufferSize); | |
1953 | ||
1954 | m_impl->SetPeer(remote.GetAddress()); | |
1955 | ||
1956 | // Finally do create the socket and connect to the peer | |
1957 | const wxSocketError err = m_impl->CreateClient(wait); | |
1958 | ||
1959 | if ( err != wxSOCKET_NOERROR ) | |
1960 | { | |
1961 | if ( err == wxSOCKET_WOULDBLOCK ) | |
1962 | { | |
1963 | wxASSERT_MSG( !wait, "shouldn't get this for blocking connect" ); | |
1964 | ||
1965 | m_establishing = true; | |
1966 | } | |
1967 | ||
1968 | return false; | |
1969 | } | |
1970 | ||
1971 | m_connected = true; | |
1972 | return true; | |
1973 | } | |
1974 | ||
1975 | bool wxSocketClient::Connect(const wxSockAddress& remote, bool wait) | |
1976 | { | |
1977 | return DoConnect(remote, NULL, wait); | |
1978 | } | |
1979 | ||
1980 | bool wxSocketClient::Connect(const wxSockAddress& remote, | |
1981 | const wxSockAddress& local, | |
1982 | bool wait) | |
1983 | { | |
1984 | return DoConnect(remote, &local, wait); | |
1985 | } | |
1986 | ||
1987 | bool wxSocketClient::WaitOnConnect(long seconds, long milliseconds) | |
1988 | { | |
1989 | if ( m_connected ) | |
1990 | { | |
1991 | // this happens if the initial attempt to connect succeeded without | |
1992 | // blocking | |
1993 | return true; | |
1994 | } | |
1995 | ||
1996 | wxCHECK_MSG( m_establishing && m_impl, false, | |
1997 | "No connection establishment attempt in progress" ); | |
1998 | ||
1999 | // notice that we return true even if DoWait() returned -1, i.e. if an | |
2000 | // error occurred and connection was lost: this is intentional as we should | |
2001 | // return false only if timeout expired without anything happening | |
2002 | return DoWait(seconds, milliseconds, wxSOCKET_CONNECTION_FLAG) != 0; | |
2003 | } | |
2004 | ||
2005 | // ========================================================================== | |
2006 | // wxDatagramSocket | |
2007 | // ========================================================================== | |
2008 | ||
2009 | wxDatagramSocket::wxDatagramSocket( const wxSockAddress& addr, | |
2010 | wxSocketFlags flags ) | |
2011 | : wxSocketBase( flags, wxSOCKET_DATAGRAM ) | |
2012 | { | |
2013 | // Create the socket | |
2014 | wxSocketManager * const manager = wxSocketManager::Get(); | |
2015 | m_impl = manager ? manager->CreateSocket(*this) : NULL; | |
2016 | ||
2017 | if (!m_impl) | |
2018 | return; | |
2019 | ||
2020 | // Setup the socket as non connection oriented | |
2021 | m_impl->SetLocal(addr.GetAddress()); | |
2022 | if (flags & wxSOCKET_REUSEADDR) | |
2023 | { | |
2024 | m_impl->SetReusable(); | |
2025 | } | |
2026 | if (GetFlags() & wxSOCKET_BROADCAST) | |
2027 | { | |
2028 | m_impl->SetBroadcast(); | |
2029 | } | |
2030 | if (GetFlags() & wxSOCKET_NOBIND) | |
2031 | { | |
2032 | m_impl->DontDoBind(); | |
2033 | } | |
2034 | ||
2035 | if ( m_impl->CreateUDP() != wxSOCKET_NOERROR ) | |
2036 | { | |
2037 | wxDELETE(m_impl); | |
2038 | return; | |
2039 | } | |
2040 | ||
2041 | // Initialize all stuff | |
2042 | m_connected = false; | |
2043 | m_establishing = false; | |
2044 | } | |
2045 | ||
2046 | wxDatagramSocket& wxDatagramSocket::RecvFrom( wxSockAddress& addr, | |
2047 | void* buf, | |
2048 | wxUint32 nBytes ) | |
2049 | { | |
2050 | Read(buf, nBytes); | |
2051 | GetPeer(addr); | |
2052 | return (*this); | |
2053 | } | |
2054 | ||
2055 | wxDatagramSocket& wxDatagramSocket::SendTo( const wxSockAddress& addr, | |
2056 | const void* buf, | |
2057 | wxUint32 nBytes ) | |
2058 | { | |
2059 | wxASSERT_MSG( m_impl, wxT("Socket not initialised") ); | |
2060 | ||
2061 | m_impl->SetPeer(addr.GetAddress()); | |
2062 | Write(buf, nBytes); | |
2063 | return (*this); | |
2064 | } | |
2065 | ||
2066 | // ========================================================================== | |
2067 | // wxSocketModule | |
2068 | // ========================================================================== | |
2069 | ||
2070 | class wxSocketModule : public wxModule | |
2071 | { | |
2072 | public: | |
2073 | virtual bool OnInit() | |
2074 | { | |
2075 | // wxSocketBase will call Initialize() itself only if sockets are | |
2076 | // really used, don't do it from here | |
2077 | return true; | |
2078 | } | |
2079 | ||
2080 | virtual void OnExit() | |
2081 | { | |
2082 | if ( wxSocketBase::IsInitialized() ) | |
2083 | wxSocketBase::Shutdown(); | |
2084 | } | |
2085 | ||
2086 | private: | |
2087 | DECLARE_DYNAMIC_CLASS(wxSocketModule) | |
2088 | }; | |
2089 | ||
2090 | IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule) | |
2091 | ||
2092 | #if defined(wxUSE_SELECT_DISPATCHER) && wxUSE_SELECT_DISPATCHER | |
2093 | // NOTE: we need to force linking against socketiohandler.cpp otherwise in | |
2094 | // static builds of wxWidgets the ManagerSetter::ManagerSetter ctor | |
2095 | // contained there wouldn't be ever called | |
2096 | wxFORCE_LINK_MODULE( socketiohandler ) | |
2097 | #endif | |
2098 | ||
2099 | // same for ManagerSetter in the MSW file | |
2100 | #ifdef __WXMSW__ | |
2101 | wxFORCE_LINK_MODULE( mswsocket ) | |
2102 | #endif | |
2103 | ||
2104 | // and for OSXManagerSetter in the OS X one | |
2105 | #ifdef __WXOSX__ | |
2106 | wxFORCE_LINK_MODULE( osxsocket ) | |
2107 | #endif | |
2108 | ||
2109 | #endif // wxUSE_SOCKETS |