* PLEASE don't put C++ comments here - this is a C source file.
*/
+#ifdef _MSC_VER
+ /* RPCNOTIFICATION_ROUTINE in rasasync.h (included from winsock.h),
+ * warning: conditional expression is constant.
+ */
+# pragma warning(disable:4115)
+ /* FD_SET,
+ * warning: named type definition in parentheses.
+ */
+# pragma warning(disable:4127)
+ /* GAddress_UNIX_GetPath,
+ * warning: unreferenced formal parameter.
+ */
+# pragma warning(disable:4100)
+#endif /* _MSC_VER */
+
+
#ifndef __GSOCKET_STANDALONE__
-#include "wx/setup.h"
+# include "wx/defs.h"
+# include "wx/setup.h"
#endif
#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
#ifndef __GSOCKET_STANDALONE__
-
-#include "wx/msw/gsockmsw.h"
-#include "wx/gsocket.h"
-
-#define INSTANCE wxGetInstance()
-
+# include "wx/msw/gsockmsw.h"
+# include "wx/gsocket.h"
#else
-
-#include "gsockmsw.h"
-#include "gsocket.h"
-
-/* If not using wxWindows, a global var called hInst must
- * be available and it must containt the app's instance
- * handle.
- */
-#define INSTANCE hInst
-
+# include "gsockmsw.h"
+# include "gsocket.h"
#endif /* __GSOCKET_STANDALONE__ */
+/* Redefine some GUI-only functions to do nothing in console mode */
+#if defined(wxUSE_GUI) && !wxUSE_GUI
+# define _GSocket_GUI_Init(socket) (1)
+# define _GSocket_GUI_Destroy(socket)
+# define _GSocket_Enable_Events(socket)
+# define _GSocket_Disable_Events(socket)
+#endif /* wxUSE_GUI */
+
#include <assert.h>
#include <string.h>
#include <stdlib.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
-#endif
-
-#define CLASSNAME "_GSocket_Internal_Window_Class"
-#define WINDOWNAME "_GSocket_Internal_Window_Name"
-
-/* Maximum number of different GSocket objects at a given time.
- * This value can be modified at will, but it CANNOT be greater
- * than (0x7FFF - WM_USER + 1)
- */
-#define MAXSOCKETS 1024
-
-#if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
-#error "MAXSOCKETS is too big!"
+# define SOCKLEN_T int
#endif
-/* Global variables */
-
-extern HINSTANCE INSTANCE;
-static HWND hWin;
-static CRITICAL_SECTION critical;
-static GSocket* socketList[MAXSOCKETS];
-static int firstAvailable;
-
-/* Global initializers */
-
-bool GSocket_Init()
-{
- WSADATA wsaData;
- WNDCLASS winClass;
- int i;
-
- /* Create internal window for event notifications */
- winClass.style = 0;
- winClass.lpfnWndProc = _GSocket_Internal_WinProc;
- winClass.cbClsExtra = 0;
- winClass.cbWndExtra = 0;
- winClass.hInstance = INSTANCE;
- winClass.hIcon = (HICON) NULL;
- winClass.hCursor = (HCURSOR) NULL;
- winClass.hbrBackground = (HBRUSH) NULL;
- winClass.lpszMenuName = (LPCTSTR) NULL;
- winClass.lpszClassName = CLASSNAME;
-
- RegisterClass(&winClass);
- hWin = CreateWindow(CLASSNAME,
- WINDOWNAME,
- 0, 0, 0, 0, 0,
- (HWND) NULL, (HMENU) NULL, INSTANCE, (LPVOID) NULL);
-
- if (!hWin) return FALSE;
-
- /* Initialize socket list */
- InitializeCriticalSection(&critical);
-
- for (i = 0; i < MAXSOCKETS; i++)
- {
- socketList[i] = NULL;
- }
- firstAvailable = 0;
-
- /* Initialize WinSocket */
- return (WSAStartup((1 << 8) | 1, &wsaData) == 0);
-}
-
-void GSocket_Cleanup()
-{
- /* Destroy internal window */
- DestroyWindow(hWin);
- UnregisterClass(CLASSNAME, INSTANCE);
-
- /* Delete critical section */
- DeleteCriticalSection(&critical);
-
- /* Cleanup WinSocket */
- WSACleanup();
-}
-
/* Constructors / Destructors for GSocket */
-GSocket *GSocket_new()
+GSocket *GSocket_new(void)
{
- int i;
+ int i, success;
GSocket *socket;
if ((socket = (GSocket *) malloc(sizeof(GSocket))) == NULL)
{
socket->m_cbacks[i] = NULL;
}
- socket->m_local = NULL;
- socket->m_peer = NULL;
+ socket->m_detected = 0;
+ 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 */
socket->m_timeout.tv_usec = 0;
- socket->m_detected = 0;
-
- /* Allocate a new message number for this socket */
- EnterCriticalSection(&critical);
+ socket->m_establishing = FALSE;
- i = firstAvailable;
- while (socketList[i] != NULL)
+ /* Per-socket GUI-specific initialization */
+ success = _GSocket_GUI_Init(socket);
+ if (!success)
{
- i = (i + 1) % MAXSOCKETS;
-
- if (i == firstAvailable) /* abort! */
- {
- free(socket);
- LeaveCriticalSection(&critical);
- return NULL;
- }
+ free(socket);
+ socket = NULL;
}
- socketList[i] = socket;
- firstAvailable = (i + 1) % MAXSOCKETS;
- socket->m_msgnumber = (i + WM_USER);
-
- LeaveCriticalSection(&critical);
return socket;
}
{
assert(socket != NULL);
- /* Remove the socket from the list */
- EnterCriticalSection(&critical);
- socketList[(socket->m_msgnumber - WM_USER)] = NULL;
- LeaveCriticalSection(&critical);
+ /* Per-socket GUI-specific cleanup */
+ _GSocket_GUI_Destroy(socket);
/* Check that the socket is really shutdowned */
if (socket->m_fd != INVALID_SOCKET)
for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
socket->m_cbacks[evt] = NULL;
- socket->m_detected = 0;
+ socket->m_detected = GSOCK_LOST_FLAG;
_GSocket_Disable_Events(socket);
}
* 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)
{
if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
(getsockname(sck->m_fd,
sck->m_local->m_addr,
- &sck->m_local->m_len) != 0) ||
+ (SOCKLEN_T *)&sck->m_local->m_len) != 0) ||
(listen(sck->m_fd, 5) != 0))
{
closesocket(sck->m_fd);
* 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)
{
sck->m_stream = (stream == GSOCK_STREAMED);
sck->m_oriented = TRUE;
sck->m_server = FALSE;
+ sck->m_establishing = FALSE;
/* Create the socket */
sck->m_fd = socket(sck->m_peer->m_realfamily,
*/
if ((err == WSAEWOULDBLOCK) && (sck->m_non_blocking))
{
+ sck->m_establishing = TRUE;
sck->m_error = GSOCK_WOULDBLOCK;
return GSOCK_WOULDBLOCK;
}
* 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)
{
if ((bind(sck->m_fd, sck->m_local->m_addr, sck->m_local->m_len) != 0) ||
(getsockname(sck->m_fd,
sck->m_local->m_addr,
- &sck->m_local->m_len) != 0))
+ (SOCKLEN_T *)&sck->m_local->m_len) != 0))
{
closesocket(sck->m_fd);
sck->m_fd = INVALID_SOCKET;
return GSOCK_NOERROR;
}
-
/* Generic IO */
/* Like recv(), send(), ... */
*/
GSocketEventFlags GSocket_Select(GSocket *socket, GSocketEventFlags flags)
{
+#if defined(wxUSE_GUI) && !wxUSE_GUI
+
+ GSocketEventFlags result = 0;
+ fd_set readfds;
+ fd_set writefds;
+ fd_set exceptfds;
+ static const struct timeval tv = { 0, 0 };
+
assert(socket != NULL);
+ FD_ZERO(&readfds);
+ FD_ZERO(&writefds);
+ FD_ZERO(&exceptfds);
+ FD_SET(socket->m_fd, &readfds);
+ 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);
+
+ /* Try select now */
+ if (select(socket->m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
+ return result;
+
+ /* 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);
+ else
+ result |= (GSOCK_INPUT_FLAG & flags);
+ }
+
+ /* Check for writability */
+ if (FD_ISSET(socket->m_fd, &writefds))
+ {
+ if (socket->m_establishing && !socket->m_server)
+ {
+ result |= (GSOCK_CONNECTION_FLAG & flags);
+ socket->m_establishing = FALSE;
+ socket->m_detected |= GSOCK_CONNECTION_FLAG;
+ }
+ else
+ result |= (GSOCK_OUTPUT_FLAG & flags);
+ }
+
+ /* Check for exceptions and errors */
+ if (FD_ISSET(socket->m_fd, &exceptfds))
+ {
+ result |= (GSOCK_LOST_FLAG & flags);
+ socket->m_establishing = FALSE;
+ socket->m_detected = GSOCK_LOST_FLAG;
+ }
+
+ return result;
+
+#else
+
+ assert(socket != NULL);
return flags & socket->m_detected;
+
+#endif /* !wxUSE_GUI */
}
/* Attributes */
* Sets the socket to non-blocking mode. All IO calls will return
* immediately.
*/
-void GSocket_SetNonBlocking(GSocket *socket, bool non_block)
+void GSocket_SetNonBlocking(GSocket *socket, int non_block)
{
assert(socket != NULL);
return socket->m_error;
}
-
/* Callbacks */
/* GSOCK_INPUT:
* 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
}
}
-
-/* Internals */
-
-/* _GSocket_Enable_Events:
- * Enable all event notifications; we need to be notified of all
- * events for internal processing, but we will only notify users
- * when an appropiate callback function has been installed.
- */
-void _GSocket_Enable_Events(GSocket *socket)
-{
- assert (socket != NULL);
-
- if (socket->m_fd != INVALID_SOCKET)
- {
- WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber,
- FD_READ | FD_WRITE | FD_ACCEPT | FD_CONNECT | FD_CLOSE);
- }
-}
-
-/* _GSocket_Disable_Events:
- * Disable event notifications (when shutdowning the socket)
- */
-void _GSocket_Disable_Events(GSocket *socket)
-{
- assert (socket != NULL);
-
- if (socket->m_fd != INVALID_SOCKET)
- {
- WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
- }
-}
-
-
-LRESULT CALLBACK _GSocket_Internal_WinProc(HWND hWnd,
- UINT uMsg,
- WPARAM wParam,
- LPARAM lParam)
-{
- GSocket *socket;
- GSocketEvent event;
- GSocketCallback cback;
- char *data;
-
- if (uMsg >= WM_USER && uMsg <= (WM_USER + MAXSOCKETS - 1))
- {
- EnterCriticalSection(&critical);
- socket = socketList[(uMsg - WM_USER)];
- event = -1;
- cback = NULL;
- data = NULL;
-
- /* Check that the socket still exists (it has not been
- * destroyed) and for safety, check that the m_fd field
- * is what we expect it to be.
- */
- if ((socket != NULL) && (socket->m_fd == wParam))
- {
- switch WSAGETSELECTEVENT(lParam)
- {
- case FD_READ: event = GSOCK_INPUT; break;
- case FD_WRITE: event = GSOCK_OUTPUT; break;
- case FD_ACCEPT: event = GSOCK_CONNECTION; break;
- case FD_CONNECT:
- {
- if (WSAGETSELECTERROR(lParam) != 0)
- event = GSOCK_LOST;
- else
- event = GSOCK_CONNECTION;
- break;
- }
- case FD_CLOSE: event = GSOCK_LOST; break;
- }
-
- if (event != -1)
- {
- cback = socket->m_cbacks[event];
- data = socket->m_data[event];
-
- if (event == GSOCK_LOST)
- socket->m_detected = GSOCK_LOST_FLAG;
- else
- socket->m_detected |= (1 << event);
- }
- }
-
- /* OK, we can now leave the critical section because we have
- * already obtained the callback address (we make no further
- * accesses to socket->whatever). However, the app should
- * be prepared to handle events from a socket that has just
- * been closed!
- */
- LeaveCriticalSection(&critical);
-
- if (cback != NULL)
- (cback)(socket, event, data);
-
- return (LRESULT) 0;
- }
- else
- return DefWindowProc(hWnd, uMsg, wParam, lParam);
-}
-
+/* Internals (IO) */
/* _GSocket_Input_Timeout:
* For blocking sockets, wait until data is available or
* -------------------------------------------------------------------------
*/
-/* CHECK_ADDRESS verifies that the current family is either GSOCK_NOFAMILY
- * or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it initalizes address
- * to be a GSOCK_*family*. In other cases, it returns GSOCK_INVADDR.
+/* CHECK_ADDRESS verifies that the current address family is either
+ * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
+ * initalizes it to be a GSOCK_*family*. In other cases, it returns
+ * an appropiate error code.
+ *
+ * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
*/
-#define CHECK_ADDRESS(address, family, retval) \
+#define CHECK_ADDRESS(address, family) \
{ \
if (address->m_family == GSOCK_NOFAMILY) \
if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
return address->m_error; \
if (address->m_family != GSOCK_##family) \
+ { \
+ address->m_error = GSOCK_INVADDR; \
+ return GSOCK_INVADDR; \
+ } \
+}
+
+#define CHECK_ADDRESS_RETVAL(address, family, retval) \
+{ \
+ if (address->m_family == GSOCK_NOFAMILY) \
+ if (_GAddress_Init_##family(address) != GSOCK_NOERROR) \
+ return retval; \
+ if (address->m_family != GSOCK_##family) \
{ \
address->m_error = GSOCK_INVADDR; \
return retval; \
} \
}
-GAddress *GAddress_new()
+
+GAddress *GAddress_new(void)
{
GAddress *address;
{
assert(address != NULL);
+ if (address->m_addr)
+ free(address->m_addr);
+
free(address);
}
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
addr->s_addr = hostaddr;
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
if (!port)
{
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = (struct sockaddr_in *)address->m_addr;
addr->sin_port = htons(port);
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, GSOCK_INVADDR);
+ CHECK_ADDRESS(address, INET);
addr = (struct sockaddr_in *)address->m_addr;
addr_buf = (char *)&(addr->sin_addr);
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, 0);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
addr = (struct sockaddr_in *)address->m_addr;
struct sockaddr_in *addr;
assert(address != NULL);
- CHECK_ADDRESS(address, INET, 0);
+ CHECK_ADDRESS_RETVAL(address, INET, 0);
addr = (struct sockaddr_in *)address->m_addr;
return ntohs(addr->sin_port);
#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