# pragma warning(disable:4100)
#endif /* _MSC_VER */
+#include <winsock.h>
#ifndef __GSOCKET_STANDALONE__
+# include "wx/defs.h"
# include "wx/setup.h"
#endif
# define _GSocket_Disable_Events(socket)
#endif /* wxUSE_GUI */
-
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stddef.h>
#include <ctype.h>
-#include <winsock.h>
-
-
/* if we use configure for MSW SOCKLEN_T will be already defined */
#ifndef SOCKLEN_T
# define SOCKLEN_T int
socket->m_cbacks[i] = NULL;
}
socket->m_detected = 0;
- socket->m_local = NULL;
- socket->m_peer = NULL;
+ socket->m_local = NULL;
+ socket->m_peer = NULL;
socket->m_error = GSOCK_NOERROR;
- socket->m_server = FALSE;
+ socket->m_server = FALSE;
socket->m_stream = TRUE;
socket->m_non_blocking = FALSE;
socket->m_timeout.tv_sec = 10 * 60; /* 10 minutes */
return socket;
}
+void GSocket_close(GSocket *socket)
+{
+ _GSocket_Disable_Events(socket);
+ closesocket(socket->m_fd);
+ socket->m_fd = INVALID_SOCKET;
+}
+
void GSocket_destroy(GSocket *socket)
{
assert(socket != NULL);
if (socket->m_fd != INVALID_SOCKET)
{
shutdown(socket->m_fd, 2);
- closesocket(socket->m_fd);
- socket->m_fd = INVALID_SOCKET;
+ GSocket_close(socket);
}
/* Disable GUI callbacks */
socket->m_cbacks[evt] = NULL;
socket->m_detected = GSOCK_LOST_FLAG;
- _GSocket_Disable_Events(socket);
}
/* Address handling */
* Sets up this socket as a server. The local address must have been
* set with GSocket_SetLocal() before GSocket_SetServer() is called.
* Returns GSOCK_NOERROR on success, one of the following otherwise:
- *
+ *
* Error codes:
* GSOCK_INVSOCK - the socket is in use.
* GSOCK_INVADDR - the local address has not been set.
- * GSOCK_IOERR - low-level error.
+ * GSOCK_IOERR - low-level error.
*/
GSocketError GSocket_SetServer(GSocket *sck)
{
(SOCKLEN_T *)&sck->m_local->m_len) != 0) ||
(listen(sck->m_fd, 5) != 0))
{
- closesocket(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
* GSOCK_TIMEDOUT - timeout, no incoming connections.
* GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
* GSOCK_MEMERR - couldn't allocate memory.
- * GSOCK_IOERR - low-level error.
+ * GSOCK_IOERR - low-level error.
*/
GSocket *GSocket_WaitConnection(GSocket *sck)
{
* GSOCK_TIMEDOUT - timeout, the connection failed.
* GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
* GSOCK_MEMERR - couldn't allocate memory.
- * GSOCK_IOERR - low-level error.
+ * GSOCK_IOERR - low-level error.
*/
GSocketError GSocket_Connect(GSocket *sck, GSocketStream stream)
{
if (err != GSOCK_NOERROR)
{
- closesocket(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
/* sck->m_error is set in _GSocket_Connect_Timeout */
}
- return err;
+ return (GSocketError) err;
}
/* If connect failed with EWOULDBLOCK and the GSocket object
/* If connect failed with an error other than EWOULDBLOCK,
* then the call to GSocket_Connect() has failed.
*/
- closesocket(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
* Error codes:
* GSOCK_INVSOCK - the socket is in use.
* GSOCK_INVADDR - the local address has not been set.
- * GSOCK_IOERR - low-level error.
+ * GSOCK_IOERR - low-level error.
*/
GSocketError GSocket_SetNonOriented(GSocket *sck)
{
sck->m_local->m_addr,
(SOCKLEN_T *)&sck->m_local->m_len) != 0))
{
- closesocket(sck->m_fd);
- sck->m_fd = INVALID_SOCKET;
+ GSocket_close(sck);
sck->m_error = GSOCK_IOERR;
return GSOCK_IOERR;
}
FD_SET(socket->m_fd, &writefds);
FD_SET(socket->m_fd, &exceptfds);
- /* Check known state first */
- result |= (GSOCK_CONNECTION_FLAG & socket->m_detected & flags);
- result |= (GSOCK_LOST_FLAG & socket->m_detected & flags);
+ /* Check 'sticky' CONNECTION flag first */
+ result |= (GSOCK_CONNECTION_FLAG & socket->m_detected);
+
+ /* If we have already detected a LOST event, then don't try
+ * to do any further processing.
+ */
+ if ((socket->m_detected & GSOCK_LOST_FLAG) != 0)
+ {
+ socket->m_establishing = FALSE;
+
+ return (GSOCK_LOST_FLAG & flags);
+ }
/* Try select now */
if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
- return result;
+ {
+ /* What to do here? */
+ return (result & flags);
+ }
/* Check for readability */
if (FD_ISSET(socket->m_fd, &readfds))
{
- /* Assume that closure of the socket is always reported via exceptfds */
- if (socket->m_server && socket->m_stream)
- result |= (GSOCK_CONNECTION_FLAG & flags);
+ char c;
+
+ if (recv(socket->m_fd, &c, 1, MSG_PEEK) > 0)
+ {
+ result |= GSOCK_INPUT_FLAG;
+ }
else
- result |= (GSOCK_INPUT_FLAG & flags);
+ {
+ if (socket->m_server && socket->m_stream)
+ {
+ result |= GSOCK_CONNECTION_FLAG;
+ socket->m_detected |= GSOCK_CONNECTION_FLAG;
+ }
+ else
+ {
+ socket->m_detected = GSOCK_LOST_FLAG;
+ socket->m_establishing = FALSE;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
+ }
+ }
}
/* Check for writability */
{
if (socket->m_establishing && !socket->m_server)
{
- result |= (GSOCK_CONNECTION_FLAG & flags);
+ int error;
+ SOCKLEN_T len = sizeof(error);
+
socket->m_establishing = FALSE;
- socket->m_detected |= GSOCK_CONNECTION_FLAG;
+
+ getsockopt(socket->m_fd, SOL_SOCKET, SO_ERROR, (void*)&error, &len);
+
+ if (error)
+ {
+ socket->m_detected = GSOCK_LOST_FLAG;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
+ }
+ else
+ {
+ result |= GSOCK_CONNECTION_FLAG;
+ socket->m_detected |= GSOCK_CONNECTION_FLAG;
+ }
}
else
- result |= (GSOCK_OUTPUT_FLAG & flags);
+ {
+ result |= GSOCK_OUTPUT_FLAG;
+ }
}
- /* Check for exceptions and errors */
+ /* Check for exceptions and errors (is this useful in Unices?) */
if (FD_ISSET(socket->m_fd, &exceptfds))
{
- result |= (GSOCK_LOST_FLAG & flags);
socket->m_establishing = FALSE;
socket->m_detected = GSOCK_LOST_FLAG;
+
+ /* LOST event: Abort any further processing */
+ return (GSOCK_LOST_FLAG & flags);
}
- return result;
+ return (result & flags);
-#else
+#else
assert(socket != NULL);
return flags & socket->m_detected;
* operation, there is still data available, the callback function will
* be called again.
* GSOCK_OUTPUT:
- * The socket is available for writing. That is, the next write call
+ * The socket is available for writing. That is, the next write call
* won't block. This event is generated only once, when the connection is
* first established, and then only if a call failed with GSOCK_WOULDBLOCK,
* when the output buffer empties again. This means that the app should
#else /* !wxUSE_SOCKETS */
-/*
+/*
* Translation unit shouldn't be empty, so include this typedef to make the
* compiler (VC++ 6.0, for example) happy
*/
-typedef (*wxDummy)();
+typedef void (*wxDummy)();
#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
+
projects / wxWidgets.git / blobdiff