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

#if wxUSE_SOCKETS

/*
 * 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

#include "wx/gsocket.h"
#include "wx/apptrait.h"
#include "wx/link.h"

wxFORCE_LINK_THIS_MODULE(gsockmsw)

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

#ifdef __WXWINCE__
#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)();
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

// ----------------------------------------------------------------------------
// MSW implementation of GSocketManager
// ----------------------------------------------------------------------------

class GSocketMSWManager : public GSocketManager
{
public:
    virtual bool OnInit();
    virtual void OnExit();

    virtual bool Init_Socket(GSocket *socket);
    virtual void Destroy_Socket(GSocket *socket);

    virtual void Install_Callback(GSocket *socket, GSocketEvent event);
    virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event);

    virtual void Enable_Events(GSocket *socket);
    virtual void Disable_Events(GSocket *socket);
};

/* Global initializers */

bool GSocketMSWManager::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 GSocketMSWManager::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 GSocketMSWManager::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 GSocketMSWManager::Destroy_Socket(GSocket *socket)
{
  /* Remove the socket from the list */
  EnterCriticalSection(&critical);
  if ( socket->IsOk() )
  {
      const int msgnum = socket->m_msgnumber;

      // we need to remove any pending messages for this socket to avoid having
      // them sent to a new socket which could reuse the same message number as
      // soon as we destroy this one
      MSG msg;
      while ( ::PeekMessage(&msg, hWin, msgnum, msgnum, PM_REMOVE) )
          ;

      socketList[msgnum - WM_USER] = NULL;
  }

  LeaveCriticalSection(&critical);
}

void GSocketMSWManager::Install_Callback(GSocket * WXUNUSED(socket),
                                         GSocketEvent WXUNUSED(event))
{
    wxFAIL_MSG( _T("not used under MSW") );
}

void GSocketMSWManager::Uninstall_Callback(GSocket * WXUNUSED(socket),
                                           GSocketEvent WXUNUSED(event))
{
    wxFAIL_MSG( _T("not used under MSW") );
}

/* 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 GSocketMSWManager::Enable_Events(GSocket *socket)
{
  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 GSocketMSWManager::Disable_Events(GSocket *socket)
{
  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
  }
}

// set the wxBase variable to point to our GSocketManager implementation
//
// see comments in wx/msw/apptbase.h for the explanation of why do we do it
// like this
static struct ManagerSetter
{
    ManagerSetter()
    {
        static GSocketMSWManager s_manager;
        wxAppTraits::SetDefaultSocketManager(&s_manager);
    }
} gs_managerSetter;

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