1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/socket.cpp
3 // Purpose: Socket handler classes
4 // Authors: Guilhem Lavaux, Guillermo Rodriguez Garcia
6 // Copyright: (C) 1999-1997, Guilhem Lavaux
7 // (C) 1999-2000, Guillermo Rodriguez Garcia
8 // (C) 2008 Vadim Zeitlin
10 // License: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
13 // ==========================================================================
15 // ==========================================================================
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
26 #include "wx/socket.h"
29 #include "wx/object.h"
30 #include "wx/string.h"
37 #include "wx/module.h"
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"
47 #include "wx/private/fd.h"
48 #include "wx/private/socket.h"
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
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.
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, we have
68 // to fall back to the old way of simply disabling SIGPIPE temporarily, so
69 // define a class to do it in a simple way
70 #if defined(__UNIX__) && !defined(SO_NOSIGPIPE)
76 // ctor disables the given signal
78 : m_handler(signal(sig
, SIG_IGN
)),
83 // dtor restores the old handler
86 signal(m_sig
, m_handler
);
90 const sighandler_t m_handler
;
93 wxDECLARE_NO_COPY_CLASS(IgnoreSignal
);
95 } // anonymous namespace
98 #define wxSOCKET_MSG_NOSIGNAL 0
101 // DLL options compatibility check:
102 #include "wx/build.h"
103 WX_CHECK_BUILD_OPTIONS("wxNet")
105 // --------------------------------------------------------------------------
106 // macros and constants
107 // --------------------------------------------------------------------------
110 wxDEFINE_EVENT(wxEVT_SOCKET
, wxSocketEvent
);
113 #define MAX_DISCARD_SIZE (10 * 1024)
115 #define wxTRACE_Socket _T("wxSocket")
117 // --------------------------------------------------------------------------
119 // --------------------------------------------------------------------------
121 IMPLEMENT_CLASS(wxSocketBase
, wxObject
)
122 IMPLEMENT_CLASS(wxSocketServer
, wxSocketBase
)
123 IMPLEMENT_CLASS(wxSocketClient
, wxSocketBase
)
124 IMPLEMENT_CLASS(wxDatagramSocket
, wxSocketBase
)
125 IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent
, wxEvent
)
127 // ----------------------------------------------------------------------------
129 // ----------------------------------------------------------------------------
134 void SetTimeValFromMS(timeval
& tv
, unsigned long ms
)
136 tv
.tv_sec
= (ms
/ 1000);
137 tv
.tv_usec
= (ms
% 1000) * 1000;
140 } // anonymous namespace
142 // --------------------------------------------------------------------------
144 // --------------------------------------------------------------------------
146 class wxSocketState
: public wxObject
149 wxSocketFlags m_flags
;
150 wxSocketEventFlags m_eventmask
;
155 wxSocketState() : wxObject() {}
157 wxDECLARE_NO_COPY_CLASS(wxSocketState
);
160 // wxSocketWaitModeChanger: temporarily change the socket flags affecting its
162 class wxSocketWaitModeChanger
165 // temporarily set the flags to include the flag value which may be either
166 // wxSOCKET_NOWAIT or wxSOCKET_WAITALL
167 wxSocketWaitModeChanger(wxSocketBase
*socket
, int flag
)
169 m_oldflags(socket
->GetFlags())
172 wxASSERT_MSG( flag
== wxSOCKET_WAITALL
|| flag
== wxSOCKET_NOWAIT
,
175 // preserve wxSOCKET_BLOCK value when switching to wxSOCKET_WAITALL
176 // mode but not when switching to wxSOCKET_NOWAIT as the latter is
177 // incompatible with wxSOCKET_BLOCK
178 if ( flag
!= wxSOCKET_NOWAIT
)
179 flag
|= m_oldflags
& wxSOCKET_BLOCK
;
181 socket
->SetFlags(flag
);
184 ~wxSocketWaitModeChanger()
186 m_socket
->SetFlags(m_oldflags
);
190 wxSocketBase
* const m_socket
;
191 const int m_oldflags
;
193 wxDECLARE_NO_COPY_CLASS(wxSocketWaitModeChanger
);
196 // wxSocketRead/WriteGuard are instantiated before starting reading
197 // from/writing to the socket
198 class wxSocketReadGuard
201 wxSocketReadGuard(wxSocketBase
*socket
)
204 wxASSERT_MSG( !m_socket
->m_reading
, "read reentrancy?" );
206 m_socket
->m_reading
= true;
211 m_socket
->m_reading
= false;
213 m_socket
->m_impl
->ReenableEvents(wxSOCKET_INPUT_FLAG
);
217 wxSocketBase
* const m_socket
;
219 wxDECLARE_NO_COPY_CLASS(wxSocketReadGuard
);
222 class wxSocketWriteGuard
225 wxSocketWriteGuard(wxSocketBase
*socket
)
228 wxASSERT_MSG( !m_socket
->m_writing
, "write reentrancy?" );
230 m_socket
->m_writing
= true;
232 m_socket
->m_impl
->ReenableEvents(wxSOCKET_OUTPUT_FLAG
);
235 ~wxSocketWriteGuard()
237 m_socket
->m_writing
= false;
241 wxSocketBase
* const m_socket
;
243 wxDECLARE_NO_COPY_CLASS(wxSocketWriteGuard
);
246 // ============================================================================
248 // ============================================================================
250 wxSocketManager
*wxSocketManager::ms_manager
= NULL
;
253 void wxSocketManager::Set(wxSocketManager
*manager
)
255 wxASSERT_MSG( !ms_manager
, "too late to set manager now" );
257 ms_manager
= manager
;
261 void wxSocketManager::Init()
263 wxASSERT_MSG( !ms_manager
, "shouldn't be initialized twice" );
266 Details: Initialize() creates a hidden window as a sink for socket
267 events, such as 'read completed'. wxMSW has only one message loop
268 for the main thread. If Initialize is called in a secondary thread,
269 the socket window will be created for the secondary thread, but
270 since there is no message loop on this thread, it will never
271 receive events and all socket operations will time out.
272 BTW, the main thread must not be stopped using sleep or block
273 on a semaphore (a bad idea in any case) or socket operations
276 On the Mac side, Initialize() stores a pointer to the CFRunLoop for
277 the main thread. Because secondary threads do not have run loops,
278 adding event notifications to the "Current" loop would have no
279 effect at all, events would never fire.
281 wxASSERT_MSG( wxIsMainThread(),
282 "sockets must be initialized from the main thread" );
284 wxAppConsole
* const app
= wxAppConsole::GetInstance();
285 wxCHECK_RET( app
, "sockets can't be initialized without wxApp" );
287 ms_manager
= app
->GetTraits()->GetSocketManager();
290 // ==========================================================================
292 // ==========================================================================
294 wxSocketImpl::wxSocketImpl(wxSocketBase
& wxsocket
)
295 : m_wxsocket(&wxsocket
)
297 m_fd
= INVALID_SOCKET
;
298 m_error
= wxSOCKET_NOERROR
;
302 SetTimeout(wxsocket
.GetTimeout() * 1000);
304 m_establishing
= false;
308 m_initialRecvBufferSize
= -1;
309 m_initialSendBufferSize
= -1;
312 wxSocketImpl::~wxSocketImpl()
314 if ( m_fd
!= INVALID_SOCKET
)
318 bool wxSocketImpl::PreCreateCheck(const wxSockAddressImpl
& addr
)
320 if ( m_fd
!= INVALID_SOCKET
)
322 m_error
= wxSOCKET_INVSOCK
;
328 m_error
= wxSOCKET_INVADDR
;
335 void wxSocketImpl::PostCreation()
337 // FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option
339 EnableSocketOption(SO_NOSIGPIPE
);
343 EnableSocketOption(SO_REUSEADDR
);
347 wxASSERT_MSG( !m_stream
, "broadcasting is for datagram sockets only" );
349 EnableSocketOption(SO_BROADCAST
);
352 if ( m_initialRecvBufferSize
>= 0 )
353 SetSocketOption(SO_RCVBUF
, m_initialRecvBufferSize
);
354 if ( m_initialSendBufferSize
>= 0 )
355 SetSocketOption(SO_SNDBUF
, m_initialSendBufferSize
);
357 // we always put our sockets in unblocked mode and handle blocking
358 // ourselves in DoRead/Write() if wxSOCKET_WAITALL is specified
359 UnblockAndRegisterWithEventLoop();
362 wxSocketError
wxSocketImpl::UpdateLocalAddress()
364 WX_SOCKLEN_T lenAddr
= m_local
.GetLen();
365 if ( getsockname(m_fd
, m_local
.GetWritableAddr(), &lenAddr
) != 0 )
368 m_error
= wxSOCKET_IOERR
;
372 return wxSOCKET_NOERROR
;
375 wxSocketError
wxSocketImpl::CreateServer()
377 if ( !PreCreateCheck(m_local
) )
383 // do create the socket
384 m_fd
= socket(m_local
.GetFamily(), SOCK_STREAM
, 0);
386 if ( m_fd
== INVALID_SOCKET
)
388 m_error
= wxSOCKET_IOERR
;
389 return wxSOCKET_IOERR
;
394 // and then bind to and listen on it
396 // FIXME: should we test for m_dobind here?
397 if ( bind(m_fd
, m_local
.GetAddr(), m_local
.GetLen()) != 0 )
398 m_error
= wxSOCKET_IOERR
;
402 if ( listen(m_fd
, 5) != 0 )
403 m_error
= wxSOCKET_IOERR
;
412 // finally retrieve the address we effectively bound to
413 return UpdateLocalAddress();
416 wxSocketError
wxSocketImpl::CreateClient(bool wait
)
418 if ( !PreCreateCheck(m_peer
) )
421 m_fd
= socket(m_peer
.GetFamily(), SOCK_STREAM
, 0);
423 if ( m_fd
== INVALID_SOCKET
)
425 m_error
= wxSOCKET_IOERR
;
426 return wxSOCKET_IOERR
;
431 // If a local address has been set, then bind to it before calling connect
432 if ( m_local
.IsOk() )
434 if ( bind(m_fd
, m_local
.GetAddr(), m_local
.GetLen()) != 0 )
437 m_error
= wxSOCKET_IOERR
;
443 int rc
= connect(m_fd
, m_peer
.GetAddr(), m_peer
.GetLen());
444 if ( rc
== SOCKET_ERROR
)
446 wxSocketError err
= GetLastError();
447 if ( err
== wxSOCKET_WOULDBLOCK
)
449 m_establishing
= true;
451 // block waiting for connection if we should (otherwise just return
452 // wxSOCKET_WOULDBLOCK to the caller)
455 err
= SelectWithTimeout(wxSOCKET_CONNECTION_FLAG
)
458 m_establishing
= false;
466 m_error
= wxSOCKET_NOERROR
;
473 wxSocketError
wxSocketImpl::CreateUDP()
475 if ( !PreCreateCheck(m_local
) )
481 m_fd
= socket(m_local
.GetFamily(), SOCK_DGRAM
, 0);
483 if ( m_fd
== INVALID_SOCKET
)
485 m_error
= wxSOCKET_IOERR
;
486 return wxSOCKET_IOERR
;
493 if ( bind(m_fd
, m_local
.GetAddr(), m_local
.GetLen()) != 0 )
496 m_error
= wxSOCKET_IOERR
;
500 return UpdateLocalAddress();
503 return wxSOCKET_NOERROR
;
506 wxSocketImpl
*wxSocketImpl::Accept(wxSocketBase
& wxsocket
)
508 wxSockAddressStorage from
;
509 WX_SOCKLEN_T fromlen
= sizeof(from
);
510 const SOCKET fd
= accept(m_fd
, &from
.addr
, &fromlen
);
512 // accepting is similar to reading in the sense that it resets "ready for
513 // read" flag on the socket
514 ReenableEvents(wxSOCKET_INPUT_FLAG
);
516 if ( fd
== INVALID_SOCKET
)
519 wxSocketImpl
* const sock
= Create(wxsocket
);
521 sock
->m_peer
= wxSockAddressImpl(from
.addr
, fromlen
);
523 sock
->UnblockAndRegisterWithEventLoop();
529 void wxSocketImpl::Close()
531 if ( m_fd
!= INVALID_SOCKET
)
534 m_fd
= INVALID_SOCKET
;
538 void wxSocketImpl::Shutdown()
540 if ( m_fd
!= INVALID_SOCKET
)
542 shutdown(m_fd
, 1 /* SD_SEND */);
548 * Sets the timeout for blocking calls. Time is expressed in
551 void wxSocketImpl::SetTimeout(unsigned long millis
)
553 SetTimeValFromMS(m_timeout
, millis
);
556 void wxSocketImpl::NotifyOnStateChange(wxSocketNotify event
)
558 m_wxsocket
->OnRequest(event
);
561 /* Address handling */
562 wxSocketError
wxSocketImpl::SetLocal(const wxSockAddressImpl
& local
)
564 /* the socket must be initialized, or it must be a server */
565 if (m_fd
!= INVALID_SOCKET
&& !m_server
)
567 m_error
= wxSOCKET_INVSOCK
;
568 return wxSOCKET_INVSOCK
;
573 m_error
= wxSOCKET_INVADDR
;
574 return wxSOCKET_INVADDR
;
579 return wxSOCKET_NOERROR
;
582 wxSocketError
wxSocketImpl::SetPeer(const wxSockAddressImpl
& peer
)
586 m_error
= wxSOCKET_INVADDR
;
587 return wxSOCKET_INVADDR
;
592 return wxSOCKET_NOERROR
;
595 const wxSockAddressImpl
& wxSocketImpl::GetLocal()
597 if ( !m_local
.IsOk() )
598 UpdateLocalAddress();
603 // ----------------------------------------------------------------------------
605 // ----------------------------------------------------------------------------
607 // this macro wraps the given expression (normally a syscall) in a loop which
608 // ignores any interruptions, i.e. reevaluates it again if it failed and errno
611 #define DO_WHILE_EINTR( rc, syscall ) \
615 while ( rc == -1 && errno == EINTR )
617 #define DO_WHILE_EINTR( rc, syscall ) rc = (syscall)
620 int wxSocketImpl::RecvStream(void *buffer
, int size
)
623 DO_WHILE_EINTR( ret
, recv(m_fd
, static_cast<char *>(buffer
), size
, 0) );
627 // receiving 0 bytes for a TCP socket indicates that the connection was
628 // closed by peer so shut down our end as well (for UDP sockets empty
629 // datagrams are also possible)
630 m_establishing
= false;
631 NotifyOnStateChange(wxSOCKET_LOST
);
635 // do not return an error in this case however
641 int wxSocketImpl::SendStream(const void *buffer
, int size
)
643 #if !defined(MSG_NOSIGNAL) && !defined(SO_NOSIGPIPE)
644 IgnoreSignal
ignore(SIGPIPE
);
648 DO_WHILE_EINTR( ret
, send(m_fd
, static_cast<const char *>(buffer
), size
,
649 wxSOCKET_MSG_NOSIGNAL
) );
654 int wxSocketImpl::RecvDgram(void *buffer
, int size
)
656 wxSockAddressStorage from
;
657 WX_SOCKLEN_T fromlen
= sizeof(from
);
660 DO_WHILE_EINTR( ret
, recvfrom(m_fd
, static_cast<char *>(buffer
), size
,
661 0, &from
.addr
, &fromlen
) );
663 if ( ret
== SOCKET_ERROR
)
666 m_peer
= wxSockAddressImpl(from
.addr
, fromlen
);
667 if ( !m_peer
.IsOk() )
673 int wxSocketImpl::SendDgram(const void *buffer
, int size
)
675 if ( !m_peer
.IsOk() )
677 m_error
= wxSOCKET_INVADDR
;
682 DO_WHILE_EINTR( ret
, sendto(m_fd
, static_cast<const char *>(buffer
), size
,
683 0, m_peer
.GetAddr(), m_peer
.GetLen()) );
688 int wxSocketImpl::Read(void *buffer
, int size
)
690 // server sockets can't be used for IO, only to accept new connections
691 if ( m_fd
== INVALID_SOCKET
|| m_server
)
693 m_error
= wxSOCKET_INVSOCK
;
697 int ret
= m_stream
? RecvStream(buffer
, size
)
698 : RecvDgram(buffer
, size
);
700 m_error
= ret
== SOCKET_ERROR
? GetLastError() : wxSOCKET_NOERROR
;
705 int wxSocketImpl::Write(const void *buffer
, int size
)
707 if ( m_fd
== INVALID_SOCKET
|| m_server
)
709 m_error
= wxSOCKET_INVSOCK
;
713 int ret
= m_stream
? SendStream(buffer
, size
)
714 : SendDgram(buffer
, size
);
716 m_error
= ret
== SOCKET_ERROR
? GetLastError() : wxSOCKET_NOERROR
;
721 // ==========================================================================
723 // ==========================================================================
725 // --------------------------------------------------------------------------
726 // Initialization and shutdown
727 // --------------------------------------------------------------------------
729 // FIXME-MT: all this is MT-unsafe, of course, we should protect all accesses
730 // to m_countInit with a crit section
731 size_t wxSocketBase::m_countInit
= 0;
733 bool wxSocketBase::IsInitialized()
735 return m_countInit
> 0;
738 bool wxSocketBase::Initialize()
740 if ( !m_countInit
++ )
742 wxSocketManager
* const manager
= wxSocketManager::Get();
743 if ( !manager
|| !manager
->OnInit() )
754 void wxSocketBase::Shutdown()
756 // we should be initialized
757 wxASSERT_MSG( m_countInit
> 0, _T("extra call to Shutdown()") );
758 if ( --m_countInit
== 0 )
760 wxSocketManager
* const manager
= wxSocketManager::Get();
761 wxCHECK_RET( manager
, "should have a socket manager" );
767 // --------------------------------------------------------------------------
769 // --------------------------------------------------------------------------
771 void wxSocketBase::Init()
774 m_type
= wxSOCKET_UNINIT
;
785 m_beingDeleted
= false;
800 if ( !IsInitialized() )
802 // this Initialize() will be undone by wxSocketModule::OnExit(), all
803 // the other calls to it should be matched by a call to Shutdown()
805 wxLogError("Cannot initialize wxSocketBase");
809 wxSocketBase::wxSocketBase()
814 wxSocketBase::wxSocketBase(wxSocketFlags flags
, wxSocketType type
)
823 wxSocketBase::~wxSocketBase()
825 // Just in case the app called Destroy() *and* then deleted the socket
826 // immediately: don't leave dangling pointers.
827 wxAppTraits
*traits
= wxTheApp
? wxTheApp
->GetTraits() : NULL
;
829 traits
->RemoveFromPendingDelete(this);
831 // Shutdown and close the socket
835 // Destroy the implementation object
838 // Free the pushback buffer
843 bool wxSocketBase::Destroy()
845 // Delayed destruction: the socket will be deleted during the next idle
846 // loop iteration. This ensures that all pending events have been
848 m_beingDeleted
= true;
850 // Shutdown and close the socket
853 // Suppress events from now on
856 // schedule this object for deletion
857 wxAppTraits
*traits
= wxTheApp
? wxTheApp
->GetTraits() : NULL
;
860 // let the traits object decide what to do with us
861 traits
->ScheduleForDestroy(this);
863 else // no app or no traits
865 // in wxBase we might have no app object at all, don't leak memory
872 // ----------------------------------------------------------------------------
874 // ----------------------------------------------------------------------------
876 void wxSocketBase::SetError(wxSocketError error
)
878 m_impl
->m_error
= error
;
881 wxSocketError
wxSocketBase::LastError() const
883 return m_impl
->GetError();
886 // --------------------------------------------------------------------------
888 // --------------------------------------------------------------------------
890 // The following IO operations update m_lcount:
891 // {Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard}
892 bool wxSocketBase::Close()
894 // Interrupt pending waits
900 m_establishing
= false;
904 void wxSocketBase::ShutdownOutput()
910 wxSocketBase
& wxSocketBase::Read(void* buffer
, wxUint32 nbytes
)
912 wxSocketReadGuard
read(this);
914 m_lcount
= DoRead(buffer
, nbytes
);
919 wxUint32
wxSocketBase::DoRead(void* buffer_
, wxUint32 nbytes
)
921 wxCHECK_MSG( m_impl
, 0, "socket must be valid" );
923 // We use pointer arithmetic here which doesn't work with void pointers.
924 char *buffer
= static_cast<char *>(buffer_
);
925 wxCHECK_MSG( buffer
, 0, "NULL buffer" );
927 // Try the push back buffer first, even before checking whether the socket
928 // is valid to allow reading previously pushed back data from an already
930 wxUint32 total
= GetPushback(buffer
, nbytes
, false);
936 // our socket is non-blocking so Read() will return immediately if
937 // there is nothing to read yet and it's more efficient to try it first
938 // before entering DoWait() which is going to start dispatching GUI
939 // events and, even more importantly, we must do this under Windows
940 // where we're not going to get notifications about socket being ready
941 // for reading before we read all the existing data from it
942 const int ret
= m_connected
? m_impl
->Read(buffer
, nbytes
) : 0;
945 if ( m_impl
->GetLastError() == wxSOCKET_WOULDBLOCK
)
947 // if we don't want to wait, just return immediately
948 if ( m_flags
& wxSOCKET_NOWAIT
)
951 // otherwise wait until the socket becomes ready for reading or
952 // an error occurs on it
953 if ( !DoWaitWithTimeout(wxSOCKET_INPUT_FLAG
) )
955 // and exit if the timeout elapsed before it did
956 SetError(wxSOCKET_TIMEDOUT
);
965 SetError(wxSOCKET_IOERR
);
971 // for connection-oriented (e.g. TCP) sockets we can only read
972 // 0 bytes if the other end has been closed, and for connectionless
973 // ones (UDP) this flag doesn't make sense anyhow so we can set it
974 // to true too without doing any harm
977 // we're not going to read anything else and so if we haven't read
978 // anything (or not everything in wxSOCKET_WAITALL case) already,
980 if ( (m_flags
& wxSOCKET_WAITALL
) || !total
)
981 SetError(wxSOCKET_IOERR
);
987 // if we are happy to read something and not the entire nbytes bytes,
989 if ( !(m_flags
& wxSOCKET_WAITALL
) )
999 wxSocketBase
& wxSocketBase::ReadMsg(void* buffer
, wxUint32 nbytes
)
1003 unsigned char sig
[4];
1004 unsigned char len
[4];
1007 wxSocketReadGuard
read(this);
1009 wxSocketWaitModeChanger
changeFlags(this, wxSOCKET_WAITALL
);
1012 if ( DoRead(&msg
, sizeof(msg
)) == sizeof(msg
) )
1014 wxUint32 sig
= (wxUint32
)msg
.sig
[0];
1015 sig
|= (wxUint32
)(msg
.sig
[1] << 8);
1016 sig
|= (wxUint32
)(msg
.sig
[2] << 16);
1017 sig
|= (wxUint32
)(msg
.sig
[3] << 24);
1019 if ( sig
== 0xfeeddead )
1021 wxUint32 len
= (wxUint32
)msg
.len
[0];
1022 len
|= (wxUint32
)(msg
.len
[1] << 8);
1023 len
|= (wxUint32
)(msg
.len
[2] << 16);
1024 len
|= (wxUint32
)(msg
.len
[3] << 24);
1029 len2
= len
- nbytes
;
1035 // Don't attempt to read if the msg was zero bytes long.
1036 m_lcount
= len
? DoRead(buffer
, len
) : 0;
1040 char discard_buffer
[MAX_DISCARD_SIZE
];
1043 // NOTE: discarded bytes don't add to m_lcount.
1046 discard_len
= len2
> MAX_DISCARD_SIZE
1049 discard_len
= DoRead(discard_buffer
, (wxUint32
)discard_len
);
1050 len2
-= (wxUint32
)discard_len
;
1052 while ((discard_len
> 0) && len2
);
1055 if ( !len2
&& DoRead(&msg
, sizeof(msg
)) == sizeof(msg
) )
1057 sig
= (wxUint32
)msg
.sig
[0];
1058 sig
|= (wxUint32
)(msg
.sig
[1] << 8);
1059 sig
|= (wxUint32
)(msg
.sig
[2] << 16);
1060 sig
|= (wxUint32
)(msg
.sig
[3] << 24);
1062 if ( sig
== 0xdeadfeed )
1069 SetError(wxSOCKET_IOERR
);
1074 wxSocketBase
& wxSocketBase::Peek(void* buffer
, wxUint32 nbytes
)
1076 wxSocketReadGuard
read(this);
1078 m_lcount
= DoRead(buffer
, nbytes
);
1080 Pushback(buffer
, m_lcount
);
1085 wxSocketBase
& wxSocketBase::Write(const void *buffer
, wxUint32 nbytes
)
1087 wxSocketWriteGuard
write(this);
1089 m_lcount
= DoWrite(buffer
, nbytes
);
1094 // This function is a mirror image of DoRead() except that it doesn't use the
1095 // push back buffer and doesn't treat 0 return value specially (normally this
1096 // shouldn't happen at all here), so please see comments there for explanations
1097 wxUint32
wxSocketBase::DoWrite(const void *buffer_
, wxUint32 nbytes
)
1099 wxCHECK_MSG( m_impl
, 0, "socket must be valid" );
1101 const char *buffer
= static_cast<const char *>(buffer_
);
1102 wxCHECK_MSG( buffer
, 0, "NULL buffer" );
1109 if ( (m_flags
& wxSOCKET_WAITALL
) || !total
)
1110 SetError(wxSOCKET_IOERR
);
1114 const int ret
= m_impl
->Write(buffer
, nbytes
);
1117 if ( m_impl
->GetLastError() == wxSOCKET_WOULDBLOCK
)
1119 if ( m_flags
& wxSOCKET_NOWAIT
)
1122 if ( !DoWaitWithTimeout(wxSOCKET_OUTPUT_FLAG
) )
1124 SetError(wxSOCKET_TIMEDOUT
);
1130 else // "real" error
1132 SetError(wxSOCKET_IOERR
);
1139 if ( !(m_flags
& wxSOCKET_WAITALL
) )
1149 wxSocketBase
& wxSocketBase::WriteMsg(const void *buffer
, wxUint32 nbytes
)
1153 unsigned char sig
[4];
1154 unsigned char len
[4];
1157 wxSocketWriteGuard
write(this);
1159 wxSocketWaitModeChanger
changeFlags(this, wxSOCKET_WAITALL
);
1161 msg
.sig
[0] = (unsigned char) 0xad;
1162 msg
.sig
[1] = (unsigned char) 0xde;
1163 msg
.sig
[2] = (unsigned char) 0xed;
1164 msg
.sig
[3] = (unsigned char) 0xfe;
1166 msg
.len
[0] = (unsigned char) (nbytes
& 0xff);
1167 msg
.len
[1] = (unsigned char) ((nbytes
>> 8) & 0xff);
1168 msg
.len
[2] = (unsigned char) ((nbytes
>> 16) & 0xff);
1169 msg
.len
[3] = (unsigned char) ((nbytes
>> 24) & 0xff);
1172 if ( DoWrite(&msg
, sizeof(msg
)) == sizeof(msg
) )
1174 m_lcount
= DoWrite(buffer
, nbytes
);
1175 if ( m_lcount
== nbytes
)
1177 msg
.sig
[0] = (unsigned char) 0xed;
1178 msg
.sig
[1] = (unsigned char) 0xfe;
1179 msg
.sig
[2] = (unsigned char) 0xad;
1180 msg
.sig
[3] = (unsigned char) 0xde;
1184 msg
.len
[3] = (char) 0;
1186 if ( DoWrite(&msg
, sizeof(msg
)) == sizeof(msg
))
1192 SetError(wxSOCKET_IOERR
);
1197 wxSocketBase
& wxSocketBase::Unread(const void *buffer
, wxUint32 nbytes
)
1200 Pushback(buffer
, nbytes
);
1202 SetError(wxSOCKET_NOERROR
);
1208 wxSocketBase
& wxSocketBase::Discard()
1210 char *buffer
= new char[MAX_DISCARD_SIZE
];
1214 wxSocketReadGuard
read(this);
1216 wxSocketWaitModeChanger
changeFlags(this, wxSOCKET_NOWAIT
);
1220 ret
= DoRead(buffer
, MAX_DISCARD_SIZE
);
1223 while (ret
== MAX_DISCARD_SIZE
);
1227 SetError(wxSOCKET_NOERROR
);
1232 // --------------------------------------------------------------------------
1234 // --------------------------------------------------------------------------
1237 This function will check for the events specified in the flags parameter,
1238 and it will return a mask indicating which operations can be performed.
1240 wxSocketEventFlags
wxSocketImpl::Select(wxSocketEventFlags flags
,
1241 const timeval
*timeout
)
1243 if ( m_fd
== INVALID_SOCKET
)
1244 return (wxSOCKET_LOST_FLAG
& flags
);
1250 tv
.tv_sec
= tv
.tv_usec
= 0;
1252 // prepare the FD sets, passing NULL for the one(s) we don't use
1254 readfds
, *preadfds
= NULL
,
1255 writefds
, *pwritefds
= NULL
,
1256 exceptfds
; // always want to know about errors
1258 if ( flags
& wxSOCKET_INPUT_FLAG
)
1260 preadfds
= &readfds
;
1261 wxFD_ZERO(preadfds
);
1262 wxFD_SET(m_fd
, preadfds
);
1265 // when using non-blocking connect() the socket becomes connected
1266 // (successfully or not) when it becomes writable
1267 if ( flags
& (wxSOCKET_OUTPUT_FLAG
| wxSOCKET_CONNECTION_FLAG
) )
1269 pwritefds
= &writefds
;
1270 wxFD_ZERO(pwritefds
);
1271 wxFD_SET(m_fd
, pwritefds
);
1274 wxFD_ZERO(&exceptfds
);
1275 wxFD_SET(m_fd
, &exceptfds
);
1277 const int rc
= select(m_fd
+ 1, preadfds
, pwritefds
, &exceptfds
, &tv
);
1279 // check for errors first
1280 if ( rc
== -1 || wxFD_ISSET(m_fd
, &exceptfds
) )
1282 m_establishing
= false;
1284 return wxSOCKET_LOST_FLAG
& flags
;
1290 wxASSERT_MSG( rc
== 1, "unexpected select() return value" );
1292 wxSocketEventFlags detected
= 0;
1293 if ( preadfds
&& wxFD_ISSET(m_fd
, preadfds
) )
1294 detected
|= wxSOCKET_INPUT_FLAG
;
1296 if ( pwritefds
&& wxFD_ISSET(m_fd
, pwritefds
) )
1298 // check for the case of non-blocking connect()
1299 if ( m_establishing
&& !m_server
)
1302 SOCKOPTLEN_T len
= sizeof(error
);
1303 m_establishing
= false;
1304 getsockopt(m_fd
, SOL_SOCKET
, SO_ERROR
, (char*)&error
, &len
);
1307 detected
= wxSOCKET_LOST_FLAG
;
1309 detected
|= wxSOCKET_CONNECTION_FLAG
;
1311 else // not called to get non-blocking connect() status
1313 detected
|= wxSOCKET_OUTPUT_FLAG
;
1317 return detected
& flags
;
1321 wxSocketBase::DoWait(long seconds
, long milliseconds
, wxSocketEventFlags flags
)
1323 // Use either the provided timeout or the default timeout value associated
1324 // with this socket.
1326 // TODO: allow waiting forever, see #9443
1327 const long timeout
= seconds
== -1 ? m_timeout
* 1000
1328 : seconds
* 1000 + milliseconds
;
1330 return DoWait(timeout
, flags
);
1334 wxSocketBase::DoWait(long timeout
, wxSocketEventFlags flags
)
1336 wxCHECK_MSG( m_impl
, -1, "can't wait on invalid socket" );
1338 // we're never going to become ready if we're not connected (any more)
1339 if ( !m_connected
&& !m_establishing
)
1342 // This can be set to true from Interrupt() to exit this function a.s.a.p.
1343 m_interrupt
= false;
1346 const wxMilliClock_t timeEnd
= wxGetLocalTimeMillis() + timeout
;
1348 // Get the active event loop which we'll use for the message dispatching
1349 // when running in the main thread unless this was explicitly disabled by
1350 // setting wxSOCKET_BLOCK flag
1351 wxEventLoopBase
*eventLoop
;
1352 if ( !(m_flags
& wxSOCKET_BLOCK
) && wxIsMainThread() )
1354 eventLoop
= wxEventLoop::GetActive();
1356 else // in worker thread
1358 // We never dispatch messages from threads other than the main one.
1362 // Make sure the events we're interested in are enabled before waiting for
1363 // them: this is really necessary here as otherwise this could happen:
1364 // 1. DoRead(wxSOCKET_WAITALL) is called
1365 // 2. There is nothing to read so DoWait(wxSOCKET_INPUT_FLAG) is called
1366 // 3. Some, but not all data appears, wxSocketImplUnix::OnReadWaiting()
1367 // is called and wxSOCKET_INPUT_FLAG events are disabled in it
1368 // 4. Because of wxSOCKET_WAITALL we call DoWait() again but the events
1369 // are still disabled and we block forever
1371 // More elegant solution would be nice but for now simply re-enabling the
1372 // events here will do
1373 m_impl
->ReenableEvents(flags
& (wxSOCKET_INPUT_FLAG
| wxSOCKET_OUTPUT_FLAG
));
1376 // Wait until we receive the event we're waiting for or the timeout expires
1377 // (but note that we always execute the loop at least once, even if timeout
1378 // is 0 as this is used for polling)
1380 for ( bool firstTime
= true; !m_interrupt
; firstTime
= false )
1382 long timeLeft
= wxMilliClockToLong(timeEnd
- wxGetLocalTimeMillis());
1391 wxSocketEventFlags events
;
1394 // reset them before starting to wait
1397 eventLoop
->DispatchTimeout(timeLeft
);
1399 events
= m_eventsgot
;
1401 else // no event loop or waiting in another thread
1403 // as explained below, we should always check for wxSOCKET_LOST_FLAG
1405 SetTimeValFromMS(tv
, timeLeft
);
1406 events
= m_impl
->Select(flags
| wxSOCKET_LOST_FLAG
, &tv
);
1409 // always check for wxSOCKET_LOST_FLAG, even if flags doesn't include
1410 // it, as continuing to wait for anything else after getting it is
1412 if ( events
& wxSOCKET_LOST_FLAG
)
1414 m_connected
= false;
1415 m_establishing
= false;
1420 // otherwise mask out the bits we're not interested in
1423 // Incoming connection (server) or connection established (client)?
1424 if ( events
& wxSOCKET_CONNECTION_FLAG
)
1427 m_establishing
= false;
1432 // Data available or output buffer ready?
1433 if ( (events
& wxSOCKET_INPUT_FLAG
) || (events
& wxSOCKET_OUTPUT_FLAG
) )
1443 bool wxSocketBase::Wait(long seconds
, long milliseconds
)
1445 return DoWait(seconds
, milliseconds
,
1446 wxSOCKET_INPUT_FLAG
|
1447 wxSOCKET_OUTPUT_FLAG
|
1448 wxSOCKET_CONNECTION_FLAG
) != 0;
1451 bool wxSocketBase::WaitForRead(long seconds
, long milliseconds
)
1453 // Check pushback buffer before entering DoWait
1457 // Check if the socket is not already ready for input, if it is, there is
1458 // no need to start waiting for it (worse, we'll actually never get a
1459 // notification about the socket becoming ready if it is already under
1461 if ( m_impl
->Select(wxSOCKET_INPUT_FLAG
) )
1464 return DoWait(seconds
, milliseconds
, wxSOCKET_INPUT_FLAG
) != 0;
1468 bool wxSocketBase::WaitForWrite(long seconds
, long milliseconds
)
1470 if ( m_impl
->Select(wxSOCKET_OUTPUT_FLAG
) )
1473 return DoWait(seconds
, milliseconds
, wxSOCKET_OUTPUT_FLAG
) != 0;
1476 bool wxSocketBase::WaitForLost(long seconds
, long milliseconds
)
1478 return DoWait(seconds
, milliseconds
, wxSOCKET_LOST_FLAG
) == -1;
1481 // --------------------------------------------------------------------------
1483 // --------------------------------------------------------------------------
1486 // Get local or peer address
1489 bool wxSocketBase::GetPeer(wxSockAddress
& addr
) const
1491 wxCHECK_MSG( m_impl
, false, "invalid socket" );
1493 const wxSockAddressImpl
& peer
= m_impl
->GetPeer();
1497 addr
.SetAddress(peer
);
1502 bool wxSocketBase::GetLocal(wxSockAddress
& addr
) const
1504 wxCHECK_MSG( m_impl
, false, "invalid socket" );
1506 const wxSockAddressImpl
& local
= m_impl
->GetLocal();
1507 if ( !local
.IsOk() )
1510 addr
.SetAddress(local
);
1516 // Save and restore socket state
1519 void wxSocketBase::SaveState()
1521 wxSocketState
*state
;
1523 state
= new wxSocketState();
1525 state
->m_flags
= m_flags
;
1526 state
->m_notify
= m_notify
;
1527 state
->m_eventmask
= m_eventmask
;
1528 state
->m_clientData
= m_clientData
;
1530 m_states
.Append(state
);
1533 void wxSocketBase::RestoreState()
1535 wxList::compatibility_iterator node
;
1536 wxSocketState
*state
;
1538 node
= m_states
.GetLast();
1542 state
= (wxSocketState
*)node
->GetData();
1544 m_flags
= state
->m_flags
;
1545 m_notify
= state
->m_notify
;
1546 m_eventmask
= state
->m_eventmask
;
1547 m_clientData
= state
->m_clientData
;
1549 m_states
.Erase(node
);
1554 // Timeout and flags
1557 void wxSocketBase::SetTimeout(long seconds
)
1559 m_timeout
= seconds
;
1562 m_impl
->SetTimeout(m_timeout
* 1000);
1565 void wxSocketBase::SetFlags(wxSocketFlags flags
)
1567 // Do some sanity checking on the flags used: not all values can be used
1569 wxASSERT_MSG( !(flags
& wxSOCKET_NOWAIT
) ||
1570 !(flags
& (wxSOCKET_WAITALL
| wxSOCKET_BLOCK
)),
1571 "Using wxSOCKET_WAITALL or wxSOCKET_BLOCK with "
1572 "wxSOCKET_NOWAIT doesn't make sense" );
1578 // --------------------------------------------------------------------------
1580 // --------------------------------------------------------------------------
1582 void wxSocketBase::OnRequest(wxSocketNotify notification
)
1584 wxSocketEventFlags flag
= 0;
1585 switch ( notification
)
1587 case wxSOCKET_INPUT
:
1588 flag
= wxSOCKET_INPUT_FLAG
;
1591 case wxSOCKET_OUTPUT
:
1592 flag
= wxSOCKET_OUTPUT_FLAG
;
1595 case wxSOCKET_CONNECTION
:
1596 flag
= wxSOCKET_CONNECTION_FLAG
;
1600 flag
= wxSOCKET_LOST_FLAG
;
1604 wxFAIL_MSG( "unknown wxSocket notification" );
1607 // if we lost the connection the socket is now closed
1608 if ( notification
== wxSOCKET_LOST
)
1611 // remember the events which were generated for this socket, we're going to
1612 // use this in DoWait()
1613 m_eventsgot
|= flag
;
1615 // send the wx event if enabled and we're interested in it
1616 if ( m_notify
&& (m_eventmask
& flag
) && m_handler
)
1618 // don't generate the events when we're inside DoWait() called from our
1619 // own code as we are going to consume the data that has just become
1620 // available ourselves and the user code won't see it at all
1621 if ( (notification
== wxSOCKET_INPUT
&& m_reading
) ||
1622 (notification
== wxSOCKET_OUTPUT
&& m_writing
) )
1627 wxSocketEvent
event(m_id
);
1628 event
.m_event
= notification
;
1629 event
.m_clientData
= m_clientData
;
1630 event
.SetEventObject(this);
1632 m_handler
->AddPendingEvent(event
);
1636 void wxSocketBase::Notify(bool notify
)
1641 void wxSocketBase::SetNotify(wxSocketEventFlags flags
)
1643 m_eventmask
= flags
;
1646 void wxSocketBase::SetEventHandler(wxEvtHandler
& handler
, int id
)
1648 m_handler
= &handler
;
1652 // --------------------------------------------------------------------------
1654 // --------------------------------------------------------------------------
1656 void wxSocketBase::Pushback(const void *buffer
, wxUint32 size
)
1660 if (m_unread
== NULL
)
1661 m_unread
= malloc(size
);
1666 tmp
= malloc(m_unrd_size
+ size
);
1667 memcpy((char *)tmp
+ size
, m_unread
, m_unrd_size
);
1673 m_unrd_size
+= size
;
1675 memcpy(m_unread
, buffer
, size
);
1678 wxUint32
wxSocketBase::GetPushback(void *buffer
, wxUint32 size
, bool peek
)
1680 wxCHECK_MSG( buffer
, 0, "NULL buffer" );
1685 if (size
> (m_unrd_size
-m_unrd_cur
))
1686 size
= m_unrd_size
-m_unrd_cur
;
1688 memcpy(buffer
, (char *)m_unread
+ m_unrd_cur
, size
);
1693 if (m_unrd_size
== m_unrd_cur
)
1706 // ==========================================================================
1708 // ==========================================================================
1710 // --------------------------------------------------------------------------
1712 // --------------------------------------------------------------------------
1714 wxSocketServer::wxSocketServer(const wxSockAddress
& addr
,
1715 wxSocketFlags flags
)
1716 : wxSocketBase(flags
, wxSOCKET_SERVER
)
1718 wxLogTrace( wxTRACE_Socket
, _T("Opening wxSocketServer") );
1720 m_impl
= wxSocketImpl::Create(*this);
1724 wxLogTrace( wxTRACE_Socket
, _T("*** Failed to create m_impl") );
1728 // Setup the socket as server
1729 m_impl
->SetLocal(addr
.GetAddress());
1731 if (GetFlags() & wxSOCKET_REUSEADDR
) {
1732 m_impl
->SetReusable();
1734 if (GetFlags() & wxSOCKET_BROADCAST
) {
1735 m_impl
->SetBroadcast();
1737 if (GetFlags() & wxSOCKET_NOBIND
) {
1738 m_impl
->DontDoBind();
1741 if (m_impl
->CreateServer() != wxSOCKET_NOERROR
)
1746 wxLogTrace( wxTRACE_Socket
, _T("*** CreateServer() failed") );
1750 wxLogTrace( wxTRACE_Socket
, _T("wxSocketServer on fd %d"), m_impl
->m_fd
);
1753 // --------------------------------------------------------------------------
1755 // --------------------------------------------------------------------------
1757 bool wxSocketServer::AcceptWith(wxSocketBase
& sock
, bool wait
)
1759 if ( !m_impl
|| (m_impl
->m_fd
== INVALID_SOCKET
) || !m_impl
->IsServer() )
1761 wxFAIL_MSG( "can only be called for a valid server socket" );
1763 SetError(wxSOCKET_INVSOCK
);
1770 // wait until we get a connection
1771 if ( !m_impl
->SelectWithTimeout(wxSOCKET_INPUT_FLAG
) )
1773 SetError(wxSOCKET_TIMEDOUT
);
1779 sock
.m_impl
= m_impl
->Accept(sock
);
1783 SetError(m_impl
->GetLastError());
1788 sock
.m_type
= wxSOCKET_BASE
;
1789 sock
.m_connected
= true;
1794 wxSocketBase
*wxSocketServer::Accept(bool wait
)
1796 wxSocketBase
* sock
= new wxSocketBase();
1798 sock
->SetFlags(m_flags
);
1800 if (!AcceptWith(*sock
, wait
))
1809 bool wxSocketServer::WaitForAccept(long seconds
, long milliseconds
)
1811 return DoWait(seconds
, milliseconds
, wxSOCKET_CONNECTION_FLAG
) == 1;
1814 bool wxSocketBase::GetOption(int level
, int optname
, void *optval
, int *optlen
)
1816 wxASSERT_MSG( m_impl
, _T("Socket not initialised") );
1818 SOCKOPTLEN_T lenreal
= *optlen
;
1819 if ( getsockopt(m_impl
->m_fd
, level
, optname
,
1820 static_cast<char *>(optval
), &lenreal
) != 0 )
1829 wxSocketBase::SetOption(int level
, int optname
, const void *optval
, int optlen
)
1831 wxASSERT_MSG( m_impl
, _T("Socket not initialised") );
1833 return setsockopt(m_impl
->m_fd
, level
, optname
,
1834 static_cast<const char *>(optval
), optlen
) == 0;
1837 bool wxSocketBase::SetLocal(const wxIPV4address
& local
)
1839 m_localAddress
= local
;
1844 // ==========================================================================
1846 // ==========================================================================
1848 // --------------------------------------------------------------------------
1850 // --------------------------------------------------------------------------
1852 wxSocketClient::wxSocketClient(wxSocketFlags flags
)
1853 : wxSocketBase(flags
, wxSOCKET_CLIENT
)
1855 m_initialRecvBufferSize
=
1856 m_initialSendBufferSize
= -1;
1859 // --------------------------------------------------------------------------
1861 // --------------------------------------------------------------------------
1863 bool wxSocketClient::DoConnect(const wxSockAddress
& remote
,
1864 const wxSockAddress
* local
,
1869 // Shutdown and destroy the old socket
1874 m_connected
= false;
1875 m_establishing
= false;
1877 // Create and set up the new one
1878 m_impl
= wxSocketImpl::Create(*this);
1882 // Reuse makes sense for clients too, if we are trying to rebind to the same port
1883 if (GetFlags() & wxSOCKET_REUSEADDR
)
1884 m_impl
->SetReusable();
1885 if (GetFlags() & wxSOCKET_BROADCAST
)
1886 m_impl
->SetBroadcast();
1887 if (GetFlags() & wxSOCKET_NOBIND
)
1888 m_impl
->DontDoBind();
1890 // Bind to the local IP address and port, when provided or if one had been
1892 if ( !local
&& m_localAddress
.GetAddress().IsOk() )
1893 local
= &m_localAddress
;
1896 m_impl
->SetLocal(local
->GetAddress());
1898 m_impl
->SetInitialSocketBuffers(m_initialRecvBufferSize
, m_initialSendBufferSize
);
1900 m_impl
->SetPeer(remote
.GetAddress());
1902 // Finally do create the socket and connect to the peer
1903 const wxSocketError err
= m_impl
->CreateClient(wait
);
1905 if ( err
!= wxSOCKET_NOERROR
)
1907 if ( err
== wxSOCKET_WOULDBLOCK
)
1909 wxASSERT_MSG( !wait
, "shouldn't get this for blocking connect" );
1911 m_establishing
= true;
1921 bool wxSocketClient::Connect(const wxSockAddress
& remote
, bool wait
)
1923 return DoConnect(remote
, NULL
, wait
);
1926 bool wxSocketClient::Connect(const wxSockAddress
& remote
,
1927 const wxSockAddress
& local
,
1930 return DoConnect(remote
, &local
, wait
);
1933 bool wxSocketClient::WaitOnConnect(long seconds
, long milliseconds
)
1937 // this happens if the initial attempt to connect succeeded without
1942 wxCHECK_MSG( m_establishing
&& m_impl
, false,
1943 "No connection establishment attempt in progress" );
1945 // notice that we return true even if DoWait() returned -1, i.e. if an
1946 // error occurred and connection was lost: this is intentional as we should
1947 // return false only if timeout expired without anything happening
1948 return DoWait(seconds
, milliseconds
, wxSOCKET_CONNECTION_FLAG
) != 0;
1951 // ==========================================================================
1953 // ==========================================================================
1955 wxDatagramSocket::wxDatagramSocket( const wxSockAddress
& addr
,
1956 wxSocketFlags flags
)
1957 : wxSocketBase( flags
, wxSOCKET_DATAGRAM
)
1959 // Create the socket
1960 m_impl
= wxSocketImpl::Create(*this);
1965 // Setup the socket as non connection oriented
1966 m_impl
->SetLocal(addr
.GetAddress());
1967 if (flags
& wxSOCKET_REUSEADDR
)
1969 m_impl
->SetReusable();
1971 if (GetFlags() & wxSOCKET_BROADCAST
)
1973 m_impl
->SetBroadcast();
1975 if (GetFlags() & wxSOCKET_NOBIND
)
1977 m_impl
->DontDoBind();
1980 if ( m_impl
->CreateUDP() != wxSOCKET_NOERROR
)
1987 // Initialize all stuff
1988 m_connected
= false;
1989 m_establishing
= false;
1992 wxDatagramSocket
& wxDatagramSocket::RecvFrom( wxSockAddress
& addr
,
2001 wxDatagramSocket
& wxDatagramSocket::SendTo( const wxSockAddress
& addr
,
2005 wxASSERT_MSG( m_impl
, _T("Socket not initialised") );
2007 m_impl
->SetPeer(addr
.GetAddress());
2012 // ==========================================================================
2014 // ==========================================================================
2016 class wxSocketModule
: public wxModule
2019 virtual bool OnInit()
2021 // wxSocketBase will call Initialize() itself only if sockets are
2022 // really used, don't do it from here
2026 virtual void OnExit()
2028 if ( wxSocketBase::IsInitialized() )
2029 wxSocketBase::Shutdown();
2033 DECLARE_DYNAMIC_CLASS(wxSocketModule
)
2036 IMPLEMENT_DYNAMIC_CLASS(wxSocketModule
, wxModule
)
2038 #if defined(wxUSE_SELECT_DISPATCHER) && wxUSE_SELECT_DISPATCHER
2039 // NOTE: we need to force linking against socketiohandler.cpp otherwise in
2040 // static builds of wxWidgets the ManagerSetter::ManagerSetter ctor
2041 // contained there wouldn't be ever called
2042 wxFORCE_LINK_MODULE( socketiohandler
)
2045 #endif // wxUSE_SOCKETS