src/msw/gsockmsw.cpp

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