src/msw/gsockmsw.cpp

/* -------------------------------------------------------------------------
 * Project: GSocket (Generic Socket)
 * Name:    gsockmsw.cpp
 * Author:  Guillermo Rodriguez Garcia <guille@iies.es>
 * Purpose: GSocket GUI-specific MSW code
 * CVSID:   $Id$
 * -------------------------------------------------------------------------
 */

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

/*
 * DONE: for WinCE we need to replace WSAAsyncSelect
 * (Windows message-based notification of network events for a socket)
 * with another mechanism.
 * As WSAAsyncSelect is not present on WinCE, it now uses
 * WSACreateEvent, WSAEventSelect, WSAWaitForMultipleEvents and WSAEnumNetworkEvents.
 * When enabling eventhandling for a socket a new thread it created that keeps track of the events
 * and posts a messageto the hidden window to use the standard message loop.
 */

/* including rasasync.h (included from windows.h itself included from
 * wx/setup.h and/or winsock.h results in this warning for
 * RPCNOTIFICATION_ROUTINE
 */
#ifdef _MSC_VER
#   pragma warning(disable:4115) /* named type definition in parentheses */
#endif

/* This needs to be before the wx/defs/h inclusion
 * for some reason
 */

#ifdef __WXWINCE__
    /* windows.h results in tons of warnings at max warning level */
#   ifdef _MSC_VER
#       pragma warning(push, 1)
#   endif
#   include <windows.h>
#   ifdef _MSC_VER
#       pragma warning(pop)
#       pragma warning(disable:4514)
#   endif
#endif

#ifndef __GSOCKET_STANDALONE__
#   include "wx/platform.h"
#   include "wx/setup.h"
#endif

#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)

#ifndef __GSOCKET_STANDALONE__

#include "wx/msw/gsockmsw.h"
#include "wx/gsocket.h"

extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
#define INSTANCE wxGetInstance()

#else /* __GSOCKET_STANDALONE__ */

#include "gsockmsw.h"
#include "gsocket.h"

/* If not using wxWidgets, a global var called hInst must
 * be available and it must contain the app's instance
 * handle.
 */
extern HINSTANCE hInst;
#define INSTANCE hInst

#endif /* !__GSOCKET_STANDALONE__/__GSOCKET_STANDALONE__ */

#ifndef __WXWINCE__
#include <assert.h>
#else
#define assert(x)
#include <winsock.h>
#include "wx/msw/wince/net.h"
#include <wx/hashmap.h>
WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash);
#endif

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <ctype.h>

#include <winsock.h>

#ifdef _MSC_VER
#  pragma warning(default:4115) /* named type definition in parentheses */
#endif

#define CLASSNAME  TEXT("_GSocket_Internal_Window_Class")

/* implemented in utils.cpp */
extern "C" WXDLLIMPEXP_BASE HWND
wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);

/* 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!"
#endif

#ifndef __WXWINCE__
typedef int (PASCAL *WSAAsyncSelectFunc)(SOCKET,HWND,u_int,long);
#else
/* Typedef the needed function prototypes and the WSANETWORKEVENTS structure
*/
typedef struct _WSANETWORKEVENTS {
       long lNetworkEvents;
       int iErrorCode[10];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
typedef HANDLE (PASCAL *WSACreateEventFunc)(void);
typedef int (PASCAL *WSAEventSelectFunc)(SOCKET,HANDLE,long);
typedef int (PASCAL *WSAWaitForMultipleEventsFunc)(long,HANDLE,BOOL,long,BOOL);
typedef int (PASCAL *WSAEnumNetworkEventsFunc)(SOCKET,HANDLE,LPWSANETWORKEVENTS);
#endif //__WXWINCE__

LRESULT CALLBACK _GSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM);

/* Global variables */

static HWND hWin;
static CRITICAL_SECTION critical;
static GSocket* socketList[MAXSOCKETS];
static int firstAvailable;

#ifndef __WXWINCE__
static WSAAsyncSelectFunc gs_WSAAsyncSelect = NULL;
#else
static SocketHash socketHash;
static unsigned int currSocket;
HANDLE hThread[MAXSOCKETS];
static WSACreateEventFunc gs_WSACreateEvent = NULL;
static WSAEventSelectFunc gs_WSAEventSelect = NULL;
static WSAWaitForMultipleEventsFunc gs_WSAWaitForMultipleEvents = NULL;
static WSAEnumNetworkEventsFunc gs_WSAEnumNetworkEvents = NULL;
/* This structure will be used to pass data on to the thread that handles socket events.
*/
typedef struct thread_data{
	HWND hEvtWin;
	unsigned long msgnumber;
	unsigned long fd;
	unsigned long lEvent;
}thread_data;
#endif

static HMODULE gs_wsock32dll = 0;


#ifdef __WXWINCE__
/* This thread handles socket events on WinCE using WSAEventSelect() as WSAAsyncSelect is not supported.
*  When an event occures for the socket, it is checked what kind of event happend and the correct message gets posted
*  so that the hidden window can handle it as it would in other MSW builds.
*/
DWORD WINAPI SocketThread(LPVOID data)
{
	WSANETWORKEVENTS NetworkEvents;
	thread_data* d = (thread_data *)data;

	HANDLE	NetworkEvent = gs_WSACreateEvent();
	gs_WSAEventSelect(d->fd, NetworkEvent, d->lEvent);

	while(socketHash[d->fd] == true)
	{
		if ((gs_WSAWaitForMultipleEvents(1, &NetworkEvent, FALSE,INFINITE, FALSE)) == WAIT_FAILED)
		{
			 printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
      		 return 0;
		}
		if (gs_WSAEnumNetworkEvents(d->fd ,NetworkEvent, &NetworkEvents) == SOCKET_ERROR)
		{
			 printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
  			 return 0;
		}

		long flags = NetworkEvents.lNetworkEvents;
		if (flags & FD_READ)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_READ);
		if (flags & FD_WRITE)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_WRITE);
		if (flags & FD_OOB)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_OOB);
		if (flags & FD_ACCEPT)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_ACCEPT);
		if (flags & FD_CONNECT)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CONNECT);
		if (flags & FD_CLOSE)
			::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CLOSE);

	}
	gs_WSAEventSelect(d->fd, NetworkEvent, 0);
	ExitThread(0);
	return 0;
}
#endif


bool GSocketGUIFunctionsTableConcrete::CanUseEventLoop()
{
    return true;
}

/* Global initializers */

bool GSocketGUIFunctionsTableConcrete::OnInit()
{
  static LPCTSTR pclassname = NULL;
  int i;

  /* Create internal window for event notifications */
  hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, _GSocket_Internal_WinProc);
  if (!hWin)
      return false;

  /* Initialize socket list */
  InitializeCriticalSection(&critical);

  for (i = 0; i < MAXSOCKETS; i++)
  {
    socketList[i] = NULL;
  }
  firstAvailable = 0;

  /* Load WSAAsyncSelect from wsock32.dll (we don't link against it
     statically to avoid dependency on wsock32.dll for apps that don't use
     sockets): */
#ifndef __WXWINCE__
  gs_wsock32dll = LoadLibrary(wxT("wsock32.dll"));
  if (!gs_wsock32dll)
      return false;
  gs_WSAAsyncSelect =(WSAAsyncSelectFunc)GetProcAddress(gs_wsock32dll,
                                                        "WSAAsyncSelect");
  if (!gs_WSAAsyncSelect)
      return false;
#else
/*  On WinCE we load ws2.dll which will provide the needed functions.
*/
	gs_wsock32dll = LoadLibrary(wxT("ws2.dll"));
  if (!gs_wsock32dll)
      return false;
  gs_WSAEventSelect =(WSAEventSelectFunc)GetProcAddress(gs_wsock32dll,
                                                        wxT("WSAEventSelect"));
  if (!gs_WSAEventSelect)
      return false;

  gs_WSACreateEvent =(WSACreateEventFunc)GetProcAddress(gs_wsock32dll,
														wxT("WSACreateEvent"));
  if (!gs_WSACreateEvent)
      return false;

  gs_WSAWaitForMultipleEvents =(WSAWaitForMultipleEventsFunc)GetProcAddress(gs_wsock32dll,
														wxT("WSAWaitForMultipleEvents"));
  if (!gs_WSAWaitForMultipleEvents)
      return false;

  gs_WSAEnumNetworkEvents =(WSAEnumNetworkEventsFunc)GetProcAddress(gs_wsock32dll,
														wxT("WSAEnumNetworkEvents"));
  if (!gs_WSAEnumNetworkEvents)
      return false;

  currSocket = 0;
#endif

  return true;
}

void GSocketGUIFunctionsTableConcrete::OnExit()
{
#ifdef __WXWINCE__
/* Delete the threads here */
	for(unsigned int i=0; i < currSocket; i++)
		CloseHandle(hThread[i]);
#endif
  /* Destroy internal window */
  DestroyWindow(hWin);
  UnregisterClass(CLASSNAME, INSTANCE);

  /* Unlock wsock32.dll */
  if (gs_wsock32dll)
  {
      FreeLibrary(gs_wsock32dll);
      gs_wsock32dll = 0;
  }

  /* Delete critical section */
  DeleteCriticalSection(&critical);
}

/* Per-socket GUI initialization / cleanup */

bool GSocketGUIFunctionsTableConcrete::Init_Socket(GSocket *socket)
{
  int i;

  /* Allocate a new message number for this socket */
  EnterCriticalSection(&critical);

  i = firstAvailable;
  while (socketList[i] != NULL)
  {
    i = (i + 1) % MAXSOCKETS;

    if (i == firstAvailable)    /* abort! */
    {
      LeaveCriticalSection(&critical);
      return false;
    }
  }
  socketList[i] = socket;
  firstAvailable = (i + 1) % MAXSOCKETS;
  socket->m_msgnumber = (i + WM_USER);

  LeaveCriticalSection(&critical);

  return true;
}

void GSocketGUIFunctionsTableConcrete::Destroy_Socket(GSocket *socket)
{
  /* Remove the socket from the list */
  EnterCriticalSection(&critical);
  socketList[(socket->m_msgnumber - WM_USER)] = NULL;
  LeaveCriticalSection(&critical);
}

/* Windows proc for asynchronous event handling */

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 = (GSocketEvent) -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);
}

/* _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 GSocketGUIFunctionsTableConcrete::Enable_Events(GSocket *socket)
{
  assert (socket != NULL);

  if (socket->m_fd != INVALID_SOCKET)
  {
    /* We could probably just subscribe to all events regardless
     * of the socket type, but MS recommends to do it this way.
     */
    long lEvent = socket->m_server?
                  FD_ACCEPT : (FD_READ | FD_WRITE | FD_CONNECT | FD_CLOSE);
#ifndef __WXWINCE__
    gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, lEvent);
#else
/*
*  WinCE creates a thread for socket event handling.
*  All needed parameters get passed through the thread_data structure.
*/

	thread_data* d = new thread_data;
	d->lEvent = lEvent;
	d->hEvtWin = hWin;
	d->msgnumber = socket->m_msgnumber;
	d->fd = socket->m_fd;
	socketHash[socket->m_fd] = true;
	hThread[currSocket++] = CreateThread(NULL, 0, &SocketThread,(LPVOID)d, 0, NULL);
#endif
  }
}

/* _GSocket_Disable_Events:
 *  Disable event notifications (when shutdowning the socket)
 */
void GSocketGUIFunctionsTableConcrete::Disable_Events(GSocket *socket)
{
  assert (socket != NULL);

  if (socket->m_fd != INVALID_SOCKET)
  {
#ifndef __WXWINCE__
    gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
#else
	//Destroy the thread
	socketHash[socket->m_fd] = false;
#endif
  }
}

#else /* !wxUSE_SOCKETS */

/*
 * Translation unit shouldn't be empty, so include this typedef to make the
 * compiler (VC++ 6.0, for example) happy
 */
typedef void (*wxDummy)();

#endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
Commit	Line	Data
	1	/* -------------------------------------------------------------------------
	2	* Project: GSocket (Generic Socket)
	3	* Name: gsockmsw.cpp
	4	* Author: Guillermo Rodriguez Garcia <guille@iies.es>
	5	* Purpose: GSocket GUI-specific MSW code
	6	* CVSID: $Id$
	7	* -------------------------------------------------------------------------
	8	*/
	9
	10	// For compilers that support precompilation, includes "wx.h".
	11	#include "wx/wxprec.h"
	12
	13	#ifdef __BORLANDC__
	14	#pragma hdrstop
	15	#endif
	16
	17	/*
	18	* DONE: for WinCE we need to replace WSAAsyncSelect
	19	* (Windows message-based notification of network events for a socket)
	20	* with another mechanism.
	21	* As WSAAsyncSelect is not present on WinCE, it now uses
	22	* WSACreateEvent, WSAEventSelect, WSAWaitForMultipleEvents and WSAEnumNetworkEvents.
	23	* When enabling eventhandling for a socket a new thread it created that keeps track of the events
	24	* and posts a messageto the hidden window to use the standard message loop.
	25	*/
	26
	27	/* including rasasync.h (included from windows.h itself included from
	28	* wx/setup.h and/or winsock.h results in this warning for
	29	* RPCNOTIFICATION_ROUTINE
	30	*/
	31	#ifdef _MSC_VER
	32	# pragma warning(disable:4115) /* named type definition in parentheses */
	33	#endif
	34
	35	/* This needs to be before the wx/defs/h inclusion
	36	* for some reason
	37	*/
	38
	39	#ifdef __WXWINCE__
	40	/* windows.h results in tons of warnings at max warning level */
	41	# ifdef _MSC_VER
	42	# pragma warning(push, 1)
	43	# endif
	44	# include <windows.h>
	45	# ifdef _MSC_VER
	46	# pragma warning(pop)
	47	# pragma warning(disable:4514)
	48	# endif
	49	#endif
	50
	51	#ifndef __GSOCKET_STANDALONE__
	52	# include "wx/platform.h"
	53	# include "wx/setup.h"
	54	#endif
	55
	56	#if wxUSE_SOCKETS \|\| defined(__GSOCKET_STANDALONE__)
	57
	58	#ifndef __GSOCKET_STANDALONE__
	59
	60	#include "wx/msw/gsockmsw.h"
	61	#include "wx/gsocket.h"
	62
	63	extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
	64	#define INSTANCE wxGetInstance()
	65
	66	#else /* __GSOCKET_STANDALONE__ */
	67
	68	#include "gsockmsw.h"
	69	#include "gsocket.h"
	70
	71	/* If not using wxWidgets, a global var called hInst must
	72	* be available and it must contain the app's instance
	73	* handle.
	74	*/
	75	extern HINSTANCE hInst;
	76	#define INSTANCE hInst
	77
	78	#endif /* !__GSOCKET_STANDALONE__/__GSOCKET_STANDALONE__ */
	79
	80	#ifndef __WXWINCE__
	81	#include <assert.h>
	82	#else
	83	#define assert(x)
	84	#include <winsock.h>
	85	#include "wx/msw/wince/net.h"
	86	#include <wx/hashmap.h>
	87	WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash);
	88	#endif
	89
	90	#include <string.h>
	91	#include <stdio.h>
	92	#include <stdlib.h>
	93	#include <stddef.h>
	94	#include <ctype.h>
	95
	96	#include <winsock.h>
	97
	98	#ifdef _MSC_VER
	99	# pragma warning(default:4115) /* named type definition in parentheses */
	100	#endif
	101
	102	#define CLASSNAME TEXT("_GSocket_Internal_Window_Class")
	103
	104	/* implemented in utils.cpp */
	105	extern "C" WXDLLIMPEXP_BASE HWND
	106	wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
	107
	108	/* Maximum number of different GSocket objects at a given time.
	109	* This value can be modified at will, but it CANNOT be greater
	110	* than (0x7FFF - WM_USER + 1)
	111	*/
	112	#define MAXSOCKETS 1024
	113
	114	#if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
	115	#error "MAXSOCKETS is too big!"
	116	#endif
	117
	118	#ifndef __WXWINCE__
	119	typedef int (PASCAL *WSAAsyncSelectFunc)(SOCKET,HWND,u_int,long);
	120	#else
	121	/* Typedef the needed function prototypes and the WSANETWORKEVENTS structure
	122	*/
	123	typedef struct _WSANETWORKEVENTS {
	124	long lNetworkEvents;
	125	int iErrorCode[10];
	126	} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
	127	typedef HANDLE (PASCAL *WSACreateEventFunc)(void);
	128	typedef int (PASCAL *WSAEventSelectFunc)(SOCKET,HANDLE,long);
	129	typedef int (PASCAL *WSAWaitForMultipleEventsFunc)(long,HANDLE,BOOL,long,BOOL);
	130	typedef int (PASCAL *WSAEnumNetworkEventsFunc)(SOCKET,HANDLE,LPWSANETWORKEVENTS);
	131	#endif //__WXWINCE__
	132
	133	LRESULT CALLBACK _GSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM);
	134
	135	/* Global variables */
	136
	137	static HWND hWin;
	138	static CRITICAL_SECTION critical;
	139	static GSocket* socketList[MAXSOCKETS];
	140	static int firstAvailable;
	141
	142	#ifndef __WXWINCE__
	143	static WSAAsyncSelectFunc gs_WSAAsyncSelect = NULL;
	144	#else
	145	static SocketHash socketHash;
	146	static unsigned int currSocket;
	147	HANDLE hThread[MAXSOCKETS];
	148	static WSACreateEventFunc gs_WSACreateEvent = NULL;
	149	static WSAEventSelectFunc gs_WSAEventSelect = NULL;
	150	static WSAWaitForMultipleEventsFunc gs_WSAWaitForMultipleEvents = NULL;
	151	static WSAEnumNetworkEventsFunc gs_WSAEnumNetworkEvents = NULL;
	152	/* This structure will be used to pass data on to the thread that handles socket events.
	153	*/
	154	typedef struct thread_data{
	155	HWND hEvtWin;
	156	unsigned long msgnumber;
	157	unsigned long fd;
	158	unsigned long lEvent;
	159	}thread_data;
	160	#endif
	161
	162	static HMODULE gs_wsock32dll = 0;
	163
	164
	165	#ifdef __WXWINCE__
	166	/* This thread handles socket events on WinCE using WSAEventSelect() as WSAAsyncSelect is not supported.
	167	* When an event occures for the socket, it is checked what kind of event happend and the correct message gets posted
	168	* so that the hidden window can handle it as it would in other MSW builds.
	169	*/
	170	DWORD WINAPI SocketThread(LPVOID data)
	171	{
	172	WSANETWORKEVENTS NetworkEvents;
	173	thread_data* d = (thread_data *)data;
	174
	175	HANDLE NetworkEvent = gs_WSACreateEvent();
	176	gs_WSAEventSelect(d->fd, NetworkEvent, d->lEvent);
	177
	178	while(socketHash[d->fd] == true)
	179	{
	180	if ((gs_WSAWaitForMultipleEvents(1, &NetworkEvent, FALSE,INFINITE, FALSE)) == WAIT_FAILED)
	181	{
	182	printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
	183	return 0;
	184	}
	185	if (gs_WSAEnumNetworkEvents(d->fd ,NetworkEvent, &NetworkEvents) == SOCKET_ERROR)
	186	{
	187	printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
	188	return 0;
	189	}
	190
	191	long flags = NetworkEvents.lNetworkEvents;
	192	if (flags & FD_READ)
	193	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_READ);
	194	if (flags & FD_WRITE)
	195	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_WRITE);
	196	if (flags & FD_OOB)
	197	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_OOB);
	198	if (flags & FD_ACCEPT)
	199	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_ACCEPT);
	200	if (flags & FD_CONNECT)
	201	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CONNECT);
	202	if (flags & FD_CLOSE)
	203	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CLOSE);
	204
	205	}
	206	gs_WSAEventSelect(d->fd, NetworkEvent, 0);
	207	ExitThread(0);
	208	return 0;
	209	}
	210	#endif
	211
	212
	213	bool GSocketGUIFunctionsTableConcrete::CanUseEventLoop()
	214	{
	215	return true;
	216	}
	217
	218	/* Global initializers */
	219
	220	bool GSocketGUIFunctionsTableConcrete::OnInit()
	221	{
	222	static LPCTSTR pclassname = NULL;
	223	int i;
	224
	225	/* Create internal window for event notifications */
	226	hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, _GSocket_Internal_WinProc);
	227	if (!hWin)
	228	return false;
	229
	230	/* Initialize socket list */
	231	InitializeCriticalSection(&critical);
	232
	233	for (i = 0; i < MAXSOCKETS; i++)
	234	{
	235	socketList[i] = NULL;
	236	}
	237	firstAvailable = 0;
	238
	239	/* Load WSAAsyncSelect from wsock32.dll (we don't link against it
	240	statically to avoid dependency on wsock32.dll for apps that don't use
	241	sockets): */
	242	#ifndef __WXWINCE__
	243	gs_wsock32dll = LoadLibrary(wxT("wsock32.dll"));
	244	if (!gs_wsock32dll)
	245	return false;
	246	gs_WSAAsyncSelect =(WSAAsyncSelectFunc)GetProcAddress(gs_wsock32dll,
	247	"WSAAsyncSelect");
	248	if (!gs_WSAAsyncSelect)
	249	return false;
	250	#else
	251	/* On WinCE we load ws2.dll which will provide the needed functions.
	252	*/
	253	gs_wsock32dll = LoadLibrary(wxT("ws2.dll"));
	254	if (!gs_wsock32dll)
	255	return false;
	256	gs_WSAEventSelect =(WSAEventSelectFunc)GetProcAddress(gs_wsock32dll,
	257	wxT("WSAEventSelect"));
	258	if (!gs_WSAEventSelect)
	259	return false;
	260
	261	gs_WSACreateEvent =(WSACreateEventFunc)GetProcAddress(gs_wsock32dll,
	262	wxT("WSACreateEvent"));
	263	if (!gs_WSACreateEvent)
	264	return false;
	265
	266	gs_WSAWaitForMultipleEvents =(WSAWaitForMultipleEventsFunc)GetProcAddress(gs_wsock32dll,
	267	wxT("WSAWaitForMultipleEvents"));
	268	if (!gs_WSAWaitForMultipleEvents)
	269	return false;
	270
	271	gs_WSAEnumNetworkEvents =(WSAEnumNetworkEventsFunc)GetProcAddress(gs_wsock32dll,
	272	wxT("WSAEnumNetworkEvents"));
	273	if (!gs_WSAEnumNetworkEvents)
	274	return false;
	275
	276	currSocket = 0;
	277	#endif
	278
	279	return true;
	280	}
	281
	282	void GSocketGUIFunctionsTableConcrete::OnExit()
	283	{
	284	#ifdef __WXWINCE__
	285	/* Delete the threads here */
	286	for(unsigned int i=0; i < currSocket; i++)
	287	CloseHandle(hThread[i]);
	288	#endif
	289	/* Destroy internal window */
	290	DestroyWindow(hWin);
	291	UnregisterClass(CLASSNAME, INSTANCE);
	292
	293	/* Unlock wsock32.dll */
	294	if (gs_wsock32dll)
	295	{
	296	FreeLibrary(gs_wsock32dll);
	297	gs_wsock32dll = 0;
	298	}
	299
	300	/* Delete critical section */
	301	DeleteCriticalSection(&critical);
	302	}
	303
	304	/* Per-socket GUI initialization / cleanup */
	305
	306	bool GSocketGUIFunctionsTableConcrete::Init_Socket(GSocket *socket)
	307	{
	308	int i;
	309
	310	/* Allocate a new message number for this socket */
	311	EnterCriticalSection(&critical);
	312
	313	i = firstAvailable;
	314	while (socketList[i] != NULL)
	315	{
	316	i = (i + 1) % MAXSOCKETS;
	317
	318	if (i == firstAvailable) /* abort! */
	319	{
	320	LeaveCriticalSection(&critical);
	321	return false;
	322	}
	323	}
	324	socketList[i] = socket;
	325	firstAvailable = (i + 1) % MAXSOCKETS;
	326	socket->m_msgnumber = (i + WM_USER);
	327
	328	LeaveCriticalSection(&critical);
	329
	330	return true;
	331	}
	332
	333	void GSocketGUIFunctionsTableConcrete::Destroy_Socket(GSocket *socket)
	334	{
	335	/* Remove the socket from the list */
	336	EnterCriticalSection(&critical);
	337	socketList[(socket->m_msgnumber - WM_USER)] = NULL;
	338	LeaveCriticalSection(&critical);
	339	}
	340
	341	/* Windows proc for asynchronous event handling */
	342
	343	LRESULT CALLBACK _GSocket_Internal_WinProc(HWND hWnd,
	344	UINT uMsg,
	345	WPARAM wParam,
	346	LPARAM lParam)
	347	{
	348	GSocket *socket;
	349	GSocketEvent event;
	350	GSocketCallback cback;
	351	char *data;
	352
	353	if (uMsg >= WM_USER && uMsg <= (WM_USER + MAXSOCKETS - 1))
	354	{
	355	EnterCriticalSection(&critical);
	356	socket = socketList[(uMsg - WM_USER)];
	357	event = (GSocketEvent) -1;
	358	cback = NULL;
	359	data = NULL;
	360
	361	/* Check that the socket still exists (it has not been
	362	* destroyed) and for safety, check that the m_fd field
	363	* is what we expect it to be.
	364	*/
	365	if ((socket != NULL) && (socket->m_fd == wParam))
	366	{
	367	switch WSAGETSELECTEVENT(lParam)
	368	{
	369	case FD_READ: event = GSOCK_INPUT; break;
	370	case FD_WRITE: event = GSOCK_OUTPUT; break;
	371	case FD_ACCEPT: event = GSOCK_CONNECTION; break;
	372	case FD_CONNECT:
	373	{
	374	if (WSAGETSELECTERROR(lParam) != 0)
	375	event = GSOCK_LOST;
	376	else
	377	event = GSOCK_CONNECTION;
	378	break;
	379	}
	380	case FD_CLOSE: event = GSOCK_LOST; break;
	381	}
	382
	383	if (event != -1)
	384	{
	385	cback = socket->m_cbacks[event];
	386	data = socket->m_data[event];
	387
	388	if (event == GSOCK_LOST)
	389	socket->m_detected = GSOCK_LOST_FLAG;
	390	else
	391	socket->m_detected \|= (1 << event);
	392	}
	393	}
	394
	395	/* OK, we can now leave the critical section because we have
	396	* already obtained the callback address (we make no further
	397	* accesses to socket->whatever). However, the app should
	398	* be prepared to handle events from a socket that has just
	399	* been closed!
	400	*/
	401	LeaveCriticalSection(&critical);
	402
	403	if (cback != NULL)
	404	(cback)(socket, event, data);
	405
	406	return (LRESULT) 0;
	407	}
	408	else
	409	return DefWindowProc(hWnd, uMsg, wParam, lParam);
	410	}
	411
	412	/* _GSocket_Enable_Events:
	413	* Enable all event notifications; we need to be notified of all
	414	* events for internal processing, but we will only notify users
	415	* when an appropiate callback function has been installed.
	416	*/
	417	void GSocketGUIFunctionsTableConcrete::Enable_Events(GSocket *socket)
	418	{
	419	assert (socket != NULL);
	420
	421	if (socket->m_fd != INVALID_SOCKET)
	422	{
	423	/* We could probably just subscribe to all events regardless
	424	* of the socket type, but MS recommends to do it this way.
	425	*/
	426	long lEvent = socket->m_server?
	427	FD_ACCEPT : (FD_READ \| FD_WRITE \| FD_CONNECT \| FD_CLOSE);
	428	#ifndef __WXWINCE__
	429	gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, lEvent);
	430	#else
	431	/*
	432	* WinCE creates a thread for socket event handling.
	433	* All needed parameters get passed through the thread_data structure.
	434	*/
	435
	436	thread_data* d = new thread_data;
	437	d->lEvent = lEvent;
	438	d->hEvtWin = hWin;
	439	d->msgnumber = socket->m_msgnumber;
	440	d->fd = socket->m_fd;
	441	socketHash[socket->m_fd] = true;
	442	hThread[currSocket++] = CreateThread(NULL, 0, &SocketThread,(LPVOID)d, 0, NULL);
	443	#endif
	444	}
	445	}
	446
	447	/* _GSocket_Disable_Events:
	448	* Disable event notifications (when shutdowning the socket)
	449	*/
	450	void GSocketGUIFunctionsTableConcrete::Disable_Events(GSocket *socket)
	451	{
	452	assert (socket != NULL);
	453
	454	if (socket->m_fd != INVALID_SOCKET)
	455	{
	456	#ifndef __WXWINCE__
	457	gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0);
	458	#else
	459	//Destroy the thread
	460	socketHash[socket->m_fd] = false;
	461	#endif
	462	}
	463	}
	464
	465	#else /* !wxUSE_SOCKETS */
	466
	467	/*
	468	* Translation unit shouldn't be empty, so include this typedef to make the
	469	* compiler (VC++ 6.0, for example) happy
	470	*/
	471	typedef void (*wxDummy)();
	472
	473	#endif /* wxUSE_SOCKETS \|\| defined(__GSOCKET_STANDALONE__) */