* -------------------------------------------------------------------------
*/
-#if defined(__WATCOMC__)
#include "wx/wxprec.h"
-#include <errno.h>
-#include <nerrno.h>
-#endif
-#ifndef __GSOCKET_STANDALONE__
-#include "wx/defs.h"
+#if wxUSE_SOCKETS
+
+#include "wx/private/gsocket.h"
+
+#include "wx/private/fd.h"
+#include "wx/private/socket.h"
#include "wx/private/gsocketiohandler.h"
-#endif
#if defined(__VISAGECPP__)
#define BSD_SELECT /* use Berkeley Sockets select */
#endif
-#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
-
-#include "wx/private/socket.h"
+#if defined(__WATCOMC__)
+#include <errno.h>
+#include <nerrno.h>
+#endif
#include <assert.h>
#include <sys/types.h>
# define GSOCKET_MSG_NOSIGNAL 0
#endif /* MSG_NOSIGNAL */
-#ifndef __GSOCKET_STANDALONE__
-# include "wx/unix/gsockunx.h"
-# include "wx/unix/private.h"
-# include "wx/gsocket.h"
#if wxUSE_THREADS && (defined(HAVE_GETHOSTBYNAME) || defined(HAVE_GETSERVBYNAME))
# include "wx/thread.h"
#endif
-#else
-# include "gsockunx.h"
-# include "gsocket.h"
-# ifndef WXUNUSED
-# define WXUNUSED(x)
-# endif
-#endif /* __GSOCKET_STANDALONE__ */
#if defined(HAVE_GETHOSTBYNAME)
static struct hostent * deepCopyHostent(struct hostent *h,
/* Constructors / Destructors for GSocket */
GSocket::GSocket(wxSocketBase& wxsocket)
- : GSocketBase(wxsocket)
+ : GSocketBase(wxsocket)
{
m_handler = NULL;
m_use_events = false;
}
-void GSocket::Close()
-{
- if (m_use_events)
- DisableEvents();
-
- /* When running on OS X, the gsockosx implementation of GSocketGUIFunctionsTable
- will close the socket during Disable_Events. However, it will only do this
- if it is being used. That is, it won't do it in a console program. To
- ensure we get the right behavior, we have gsockosx set m_fd = INVALID_SOCKET
- if it has closed the socket which indicates to us (at runtime, instead of
- at compile time as this had been before) that the socket has already
- been closed.
- */
- if(m_fd != INVALID_SOCKET)
- close(m_fd);
- m_fd = INVALID_SOCKET;
-}
-
GSocket::~GSocket()
{
delete m_handler;
void GSocket::Shutdown()
{
/* Don't allow events to fire after socket has been closed */
- if (m_use_events)
- DisableEvents();
+ DisableEvents();
GSocketBase::Shutdown();
}
#endif
ioctl(m_fd, FIONBIO, &arg);
- if (m_use_events)
- EnableEvents();
+ EnableEvents();
/* allow a socket to re-bind if the socket is in the TIME_WAIT
state after being previously closed.
connection->m_fd = accept(m_fd, (sockaddr*)&from, (WX_SOCKLEN_T *) &fromlen);
/* Reenable CONNECTION events */
- Enable(GSOCK_CONNECTION);
+ EnableEvent(GSOCK_CONNECTION);
if (connection->m_fd == INVALID_SOCKET)
{
if (flag == m_use_events)
return;
m_use_events = flag;
- EnableEvents(flag);
+ DoEnableEvents(flag);
}
-void GSocket::EnableEvents(bool flag)
+void GSocket::DoEnableEvents(bool flag)
{
- if (flag)
- GSocketManager::Get()->Enable_Events(this);
- else
- GSocketManager::Get()->Disable_Events(this);
+ GSocketManager * const manager = GSocketManager::Get();
+ if ( flag )
+ {
+ manager->Install_Callback(this, GSOCK_INPUT);
+ manager->Install_Callback(this, GSOCK_OUTPUT);
+ }
+ else // off
+ {
+ manager->Uninstall_Callback(this, GSOCK_INPUT);
+ manager->Uninstall_Callback(this, GSOCK_OUTPUT);
+ }
}
bool GSocket::SetReusable()
assert(this);
/* Enable CONNECTION events (needed for nonblocking connections) */
- Enable(GSOCK_CONNECTION);
+ EnableEvent(GSOCK_CONNECTION);
if (m_fd != INVALID_SOCKET)
{
/* Connect it to the peer address, with a timeout (see below) */
ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
- /* We only call Enable_Events if we know we aren't shutting down the socket.
- * NB: Enable_Events needs to be called whether the socket is blocking or
+ /* We only call EnableEvents() if we know we aren't shutting down the socket.
+ * NB: EnableEvents() needs to be called whether the socket is blocking or
* non-blocking, it just shouldn't be called prior to knowing there is a
* connection _if_ blocking sockets are being used.
* If connect above returns 0, we are already connected and need to make the
- * call to Enable_Events now.
+ * call to EnableEvents() now.
*/
-
- if (m_use_events && (m_non_blocking || ret == 0))
+ if ( m_non_blocking || (ret == 0) )
EnableEvents();
if (ret == -1)
SOCKOPTLEN_T len = sizeof(error);
getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
- if (m_use_events)
- EnableEvents();
+ EnableEvents();
if (!error)
return GSOCK_NOERROR;
#else
ioctl(m_fd, FIONBIO, &arg);
#endif
- if (m_use_events)
- EnableEvents();
+ EnableEvents();
if (m_reusable)
{
}
/* Disable events during query of socket status */
- Disable(GSOCK_INPUT);
+ DisableEvent(GSOCK_INPUT);
/* If the socket is blocking, wait for data (with a timeout) */
if (Input_Timeout() == GSOCK_TIMEDOUT) {
}
/* Enable events again now that we are done processing */
- Enable(GSOCK_INPUT);
+ EnableEvent(GSOCK_INPUT);
return ret;
}
* that the socket is writable until a read operation fails. Only then
* will further OUTPUT events be posted.
*/
- Enable(GSOCK_OUTPUT);
+ EnableEvent(GSOCK_OUTPUT);
return -1;
}
return GSOCK_OPTERR;
}
-void GSocket::Enable(GSocketEvent event)
+void GSocket::EnableEvent(GSocketEvent event)
{
if (m_use_events)
{
}
}
-void GSocket::Disable(GSocketEvent event)
+void GSocket::DisableEvent(GSocketEvent event)
{
if (m_use_events)
{
*/
GSocketError GSocket::Input_Timeout()
{
- struct timeval tv;
fd_set readfds;
int ret;
- /* Linux select() will overwrite the struct on return */
- tv.tv_sec = (m_timeout / 1000);
- tv.tv_usec = (m_timeout % 1000) * 1000;
+ // Linux select() will overwrite the struct on return so make a copy
+ struct timeval tv = m_timeout;
if (!m_non_blocking)
{
*/
GSocketError GSocket::Output_Timeout()
{
- struct timeval tv;
fd_set writefds;
int ret;
- /* Linux select() will overwrite the struct on return */
- tv.tv_sec = (m_timeout / 1000);
- tv.tv_usec = (m_timeout % 1000) * 1000;
+ // Linux select() will overwrite the struct on return so make a copy
+ struct timeval tv = m_timeout;
GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
void GSocket::OnStateChange(GSocketEvent event)
{
- Disable(event);
+ DisableEvent(event);
NotifyOnStateChange(event);
if ( event == GSOCK_LOST )
return GSOCK_NOERROR;
}
#endif /* !defined(__VISAGECPP__) */
-#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
+#endif /* wxUSE_SOCKETS */
projects / wxWidgets.git / blobdiff