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"
#   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: 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	# include "wx/setup.h"
	56	#endif
	57
	58	#if wxUSE_SOCKETS \|\| defined(__GSOCKET_STANDALONE__)
	59
	60	#ifndef __GSOCKET_STANDALONE__
	61
	62	#include "wx/msw/gsockmsw.h"
	63	#include "wx/gsocket.h"
	64
	65	extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
	66	#define INSTANCE wxGetInstance()
	67
	68	#else /* __GSOCKET_STANDALONE__ */
	69
	70	#include "gsockmsw.h"
	71	#include "gsocket.h"
	72
	73	/* If not using wxWidgets, a global var called hInst must
	74	* be available and it must contain the app's instance
	75	* handle.
	76	*/
	77	extern HINSTANCE hInst;
	78	#define INSTANCE hInst
	79
	80	#endif /* !__GSOCKET_STANDALONE__/__GSOCKET_STANDALONE__ */
	81
	82	#ifndef __WXWINCE__
	83	#include <assert.h>
	84	#else
	85	#define assert(x)
	86	#include <winsock.h>
	87	#include "wx/msw/wince/net.h"
	88	#include "wx/hashmap.h"
	89	WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash);
	90	#endif
	91
	92	#include <string.h>
	93	#include <stdio.h>
	94	#include <stdlib.h>
	95	#include <stddef.h>
	96	#include <ctype.h>
	97
	98	#include <winsock.h>
	99
	100	#ifdef _MSC_VER
	101	# pragma warning(default:4115) /* named type definition in parentheses */
	102	#endif
	103
	104	#define CLASSNAME TEXT("_GSocket_Internal_Window_Class")
	105
	106	/* implemented in utils.cpp */
	107	extern "C" WXDLLIMPEXP_BASE HWND
	108	wxCreateHiddenWindow(LPCTSTR *pclassname, LPCTSTR classname, WNDPROC wndproc);
	109
	110	/* Maximum number of different GSocket objects at a given time.
	111	* This value can be modified at will, but it CANNOT be greater
	112	* than (0x7FFF - WM_USER + 1)
	113	*/
	114	#define MAXSOCKETS 1024
	115
	116	#if (MAXSOCKETS > (0x7FFF - WM_USER + 1))
	117	#error "MAXSOCKETS is too big!"
	118	#endif
	119
	120	#ifndef __WXWINCE__
	121	typedef int (PASCAL *WSAAsyncSelectFunc)(SOCKET,HWND,u_int,long);
	122	#else
	123	/* Typedef the needed function prototypes and the WSANETWORKEVENTS structure
	124	*/
	125	typedef struct _WSANETWORKEVENTS {
	126	long lNetworkEvents;
	127	int iErrorCode[10];
	128	} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;
	129	typedef HANDLE (PASCAL *WSACreateEventFunc)(void);
	130	typedef int (PASCAL *WSAEventSelectFunc)(SOCKET,HANDLE,long);
	131	typedef int (PASCAL *WSAWaitForMultipleEventsFunc)(long,HANDLE,BOOL,long,BOOL);
	132	typedef int (PASCAL *WSAEnumNetworkEventsFunc)(SOCKET,HANDLE,LPWSANETWORKEVENTS);
	133	#endif //__WXWINCE__
	134
	135	LRESULT CALLBACK _GSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM);
	136
	137	/* Global variables */
	138
	139	static HWND hWin;
	140	static CRITICAL_SECTION critical;
	141	static GSocket* socketList[MAXSOCKETS];
	142	static int firstAvailable;
	143
	144	#ifndef __WXWINCE__
	145	static WSAAsyncSelectFunc gs_WSAAsyncSelect = NULL;
	146	#else
	147	static SocketHash socketHash;
	148	static unsigned int currSocket;
	149	HANDLE hThread[MAXSOCKETS];
	150	static WSACreateEventFunc gs_WSACreateEvent = NULL;
	151	static WSAEventSelectFunc gs_WSAEventSelect = NULL;
	152	static WSAWaitForMultipleEventsFunc gs_WSAWaitForMultipleEvents = NULL;
	153	static WSAEnumNetworkEventsFunc gs_WSAEnumNetworkEvents = NULL;
	154	/* This structure will be used to pass data on to the thread that handles socket events.
	155	*/
	156	typedef struct thread_data{
	157	HWND hEvtWin;
	158	unsigned long msgnumber;
	159	unsigned long fd;
	160	unsigned long lEvent;
	161	}thread_data;
	162	#endif
	163
	164	static HMODULE gs_wsock32dll = 0;
	165
	166
	167	#ifdef __WXWINCE__
	168	/* This thread handles socket events on WinCE using WSAEventSelect() as WSAAsyncSelect is not supported.
	169	* When an event occures for the socket, it is checked what kind of event happend and the correct message gets posted
	170	* so that the hidden window can handle it as it would in other MSW builds.
	171	*/
	172	DWORD WINAPI SocketThread(LPVOID data)
	173	{
	174	WSANETWORKEVENTS NetworkEvents;
	175	thread_data* d = (thread_data *)data;
	176
	177	HANDLE NetworkEvent = gs_WSACreateEvent();
	178	gs_WSAEventSelect(d->fd, NetworkEvent, d->lEvent);
	179
	180	while(socketHash[d->fd] == true)
	181	{
	182	if ((gs_WSAWaitForMultipleEvents(1, &NetworkEvent, FALSE,INFINITE, FALSE)) == WAIT_FAILED)
	183	{
	184	printf("WSAWaitForMultipleEvents failed with error %d\n", WSAGetLastError());
	185	return 0;
	186	}
	187	if (gs_WSAEnumNetworkEvents(d->fd ,NetworkEvent, &NetworkEvents) == SOCKET_ERROR)
	188	{
	189	printf("WSAEnumNetworkEvents failed with error %d\n", WSAGetLastError());
	190	return 0;
	191	}
	192
	193	long flags = NetworkEvents.lNetworkEvents;
	194	if (flags & FD_READ)
	195	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_READ);
	196	if (flags & FD_WRITE)
	197	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_WRITE);
	198	if (flags & FD_OOB)
	199	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_OOB);
	200	if (flags & FD_ACCEPT)
	201	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_ACCEPT);
	202	if (flags & FD_CONNECT)
	203	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CONNECT);
	204	if (flags & FD_CLOSE)
	205	::PostMessage(d->hEvtWin, d->msgnumber,d->fd, FD_CLOSE);
	206
	207	}
	208	gs_WSAEventSelect(d->fd, NetworkEvent, 0);
	209	ExitThread(0);
	210	return 0;
	211	}
	212	#endif
	213
	214
	215	bool GSocketGUIFunctionsTableConcrete::CanUseEventLoop()
	216	{
	217	return true;
	218	}
	219
	220	/* Global initializers */
	221
	222	bool GSocketGUIFunctionsTableConcrete::OnInit()
	223	{
	224	static LPCTSTR pclassname = NULL;
	225	int i;
	226
	227	/* Create internal window for event notifications */
	228	hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, _GSocket_Internal_WinProc);
	229	if (!hWin)
	230	return false;
	231
	232	/* Initialize socket list */
	233	InitializeCriticalSection(&critical);
	234
	235	for (i = 0; i < MAXSOCKETS; i++)
	236	{
	237	socketList[i] = NULL;
	238	}
	239	firstAvailable = 0;
	240
	241	/* Load WSAAsyncSelect from wsock32.dll (we don't link against it
	242	statically to avoid dependency on wsock32.dll for apps that don't use
	243	sockets): */
	244	#ifndef __WXWINCE__
	245	gs_wsock32dll = LoadLibrary(wxT("wsock32.dll"));
	246	if (!gs_wsock32dll)
	247	return false;
	248	gs_WSAAsyncSelect =(WSAAsyncSelectFunc)GetProcAddress(gs_wsock32dll,
	249	"WSAAsyncSelect");
	250	if (!gs_WSAAsyncSelect)
	251	return false;
	252	#else
	253	/* On WinCE we load ws2.dll which will provide the needed functions.
	254	*/
	255	gs_wsock32dll = LoadLibrary(wxT("ws2.dll"));
	256	if (!gs_wsock32dll)
	257	return false;
	258	gs_WSAEventSelect =(WSAEventSelectFunc)GetProcAddress(gs_wsock32dll,
	259	wxT("WSAEventSelect"));
	260	if (!gs_WSAEventSelect)
	261	return false;
	262
	263	gs_WSACreateEvent =(WSACreateEventFunc)GetProcAddress(gs_wsock32dll,
	264	wxT("WSACreateEvent"));
	265	if (!gs_WSACreateEvent)
	266	return false;
	267
	268	gs_WSAWaitForMultipleEvents =(WSAWaitForMultipleEventsFunc)GetProcAddress(gs_wsock32dll,
	269	wxT("WSAWaitForMultipleEvents"));
	270	if (!gs_WSAWaitForMultipleEvents)
	271	return false;
	272
	273	gs_WSAEnumNetworkEvents =(WSAEnumNetworkEventsFunc)GetProcAddress(gs_wsock32dll,
	274	wxT("WSAEnumNetworkEvents"));
	275	if (!gs_WSAEnumNetworkEvents)
	276	return false;
	277
	278	currSocket = 0;
	279	#endif
	280
	281	return true;
	282	}
	283
	284	void GSocketGUIFunctionsTableConcrete::OnExit()
	285	{
	286	#ifdef __WXWINCE__
	287	/* Delete the threads here */
	288	for(unsigned int i=0; i < currSocket; i++)
	289	CloseHandle(hThread[i]);
	290	#endif
	291	/* Destroy internal window */
	292	DestroyWindow(hWin);
	293	UnregisterClass(CLASSNAME, INSTANCE);
	294
	295	/* Unlock wsock32.dll */
	296	if (gs_wsock32dll)
	297	{
	298	FreeLibrary(gs_wsock32dll);
	299	gs_wsock32dll = 0;
	300	}
	301
	302	/* Delete critical section */
	303	DeleteCriticalSection(&critical);
	304	}
	305
	306	/* Per-socket GUI initialization / cleanup */
	307
	308	bool GSocketGUIFunctionsTableConcrete::Init_Socket(GSocket *socket)
	309	{
	310	int i;
	311
	312	/* Allocate a new message number for this socket */
	313	EnterCriticalSection(&critical);
	314
	315	i = firstAvailable;
	316	while (socketList[i] != NULL)
	317	{
	318	i = (i + 1) % MAXSOCKETS;
	319
	320	if (i == firstAvailable) /* abort! */
	321	{
	322	LeaveCriticalSection(&critical);
	323	return false;
	324	}
	325	}
	326	socketList[i] = socket;
	327	firstAvailable = (i + 1) % MAXSOCKETS;
	328	socket->m_msgnumber = (i + WM_USER);
	329
	330	LeaveCriticalSection(&critical);
	331
	332	return true;
	333	}
	334
	335	void GSocketGUIFunctionsTableConcrete::Destroy_Socket(GSocket *socket)
	336	{
	337	/* Remove the socket from the list */
	338	EnterCriticalSection(&critical);
	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__) */