Commit | Line | Data |
---|---|---|
b7ceceb1 | 1 | /* ------------------------------------------------------------------------- |
99d80019 | 2 | * Project: GSocket (Generic Socket) |
7ec69821 | 3 | * Name: src/msw/gsockmsw.cpp |
99d80019 JS |
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$ | |
b7ceceb1 DE |
9 | * ------------------------------------------------------------------------- |
10 | */ | |
11 | ||
86afa786 VS |
12 | // For compilers that support precompilation, includes "wx.h". |
13 | #include "wx/wxprec.h" | |
14 | ||
15 | #ifdef __BORLANDC__ | |
16 | #pragma hdrstop | |
17 | #endif | |
18 | ||
b7ceceb1 | 19 | /* |
dbfb61b3 | 20 | * DONE: for WinCE we need to replace WSAAsyncSelect |
b7ceceb1 DE |
21 | * (Windows message-based notification of network events for a socket) |
22 | * with another mechanism. | |
dbfb61b3 JS |
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. | |
b7ceceb1 DE |
27 | */ |
28 | ||
b7ceceb1 DE |
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 | |
1c8681b4 | 34 | # pragma warning(disable:4115) /* named type definition in parentheses */ |
b7ceceb1 DE |
35 | #endif |
36 | ||
37 | /* This needs to be before the wx/defs/h inclusion | |
38 | * for some reason | |
39 | */ | |
40 | ||
41 | #ifdef __WXWINCE__ | |
1c8681b4 DE |
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 | |
b7ceceb1 DE |
51 | #endif |
52 | ||
53 | #ifndef __GSOCKET_STANDALONE__ | |
54 | # include "wx/platform.h" | |
b7ceceb1 DE |
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 | ||
ebb97a41 | 64 | extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void); |
b7ceceb1 DE |
65 | #define INSTANCE wxGetInstance() |
66 | ||
854bac91 | 67 | #else /* __GSOCKET_STANDALONE__ */ |
b7ceceb1 DE |
68 | |
69 | #include "gsockmsw.h" | |
70 | #include "gsocket.h" | |
71 | ||
77ffb593 | 72 | /* If not using wxWidgets, a global var called hInst must |
b7ceceb1 DE |
73 | * be available and it must contain the app's instance |
74 | * handle. | |
75 | */ | |
854bac91 | 76 | extern HINSTANCE hInst; |
b7ceceb1 DE |
77 | #define INSTANCE hInst |
78 | ||
854bac91 | 79 | #endif /* !__GSOCKET_STANDALONE__/__GSOCKET_STANDALONE__ */ |
b7ceceb1 DE |
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" | |
7ec69821 | 87 | #include "wx/hashmap.h" |
84aa68c4 | 88 | WX_DECLARE_HASH_MAP(int,bool,wxIntegerHash,wxIntegerEqual,SocketHash); |
b7ceceb1 DE |
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 */ | |
32524c8f | 106 | extern "C" WXDLLIMPEXP_BASE HWND |
b7ceceb1 DE |
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 | ||
dbfb61b3 | 119 | #ifndef __WXWINCE__ |
1c8681b4 | 120 | typedef int (PASCAL *WSAAsyncSelectFunc)(SOCKET,HWND,u_int,long); |
dbfb61b3 JS |
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__ | |
b7ceceb1 | 133 | |
c90cc42e DE |
134 | LRESULT CALLBACK _GSocket_Internal_WinProc(HWND, UINT, WPARAM, LPARAM); |
135 | ||
b7ceceb1 DE |
136 | /* Global variables */ |
137 | ||
b7ceceb1 DE |
138 | static HWND hWin; |
139 | static CRITICAL_SECTION critical; | |
140 | static GSocket* socketList[MAXSOCKETS]; | |
141 | static int firstAvailable; | |
dbfb61b3 JS |
142 | |
143 | #ifndef __WXWINCE__ | |
1c8681b4 | 144 | static WSAAsyncSelectFunc gs_WSAAsyncSelect = NULL; |
dbfb61b3 | 145 | #else |
84aa68c4 | 146 | static SocketHash socketHash; |
dbfb61b3 JS |
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{ | |
7ec69821 WS |
156 | HWND hEvtWin; |
157 | unsigned long msgnumber; | |
158 | unsigned long fd; | |
159 | unsigned long lEvent; | |
dbfb61b3 JS |
160 | }thread_data; |
161 | #endif | |
162 | ||
1c8681b4 | 163 | static HMODULE gs_wsock32dll = 0; |
b7ceceb1 | 164 | |
dbfb61b3 JS |
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 | { | |
7ec69821 WS |
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; | |
dbfb61b3 JS |
210 | } |
211 | #endif | |
212 | ||
213 | ||
c90cc42e | 214 | bool GSocketGUIFunctionsTableConcrete::CanUseEventLoop() |
1c6dd11c WS |
215 | { |
216 | return true; | |
217 | } | |
c90cc42e | 218 | |
b7ceceb1 DE |
219 | /* Global initializers */ |
220 | ||
c90cc42e | 221 | bool GSocketGUIFunctionsTableConcrete::OnInit() |
b7ceceb1 | 222 | { |
84aa68c4 JS |
223 | static LPCTSTR pclassname = NULL; |
224 | int i; | |
b7ceceb1 | 225 | |
84aa68c4 JS |
226 | /* Create internal window for event notifications */ |
227 | hWin = wxCreateHiddenWindow(&pclassname, CLASSNAME, _GSocket_Internal_WinProc); | |
228 | if (!hWin) | |
229 | return false; | |
b7ceceb1 | 230 | |
84aa68c4 JS |
231 | /* Initialize socket list */ |
232 | InitializeCriticalSection(&critical); | |
b7ceceb1 | 233 | |
84aa68c4 JS |
234 | for (i = 0; i < MAXSOCKETS; i++) |
235 | { | |
236 | socketList[i] = NULL; | |
237 | } | |
238 | firstAvailable = 0; | |
b7ceceb1 | 239 | |
84aa68c4 JS |
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): */ | |
dbfb61b3 | 243 | #ifndef __WXWINCE__ |
84aa68c4 JS |
244 | gs_wsock32dll = LoadLibrary(wxT("wsock32.dll")); |
245 | if (!gs_wsock32dll) | |
246 | return false; | |
247 | gs_WSAAsyncSelect =(WSAAsyncSelectFunc)GetProcAddress(gs_wsock32dll, | |
e9729fc7 | 248 | "WSAAsyncSelect"); |
84aa68c4 JS |
249 | if (!gs_WSAAsyncSelect) |
250 | return false; | |
dbfb61b3 JS |
251 | #else |
252 | /* On WinCE we load ws2.dll which will provide the needed functions. | |
253 | */ | |
7ec69821 | 254 | gs_wsock32dll = LoadLibrary(wxT("ws2.dll")); |
84aa68c4 JS |
255 | if (!gs_wsock32dll) |
256 | return false; | |
257 | gs_WSAEventSelect =(WSAEventSelectFunc)GetProcAddress(gs_wsock32dll, | |
258 | wxT("WSAEventSelect")); | |
259 | if (!gs_WSAEventSelect) | |
260 | return false; | |
1c6dd11c | 261 | |
84aa68c4 | 262 | gs_WSACreateEvent =(WSACreateEventFunc)GetProcAddress(gs_wsock32dll, |
7ec69821 | 263 | wxT("WSACreateEvent")); |
84aa68c4 JS |
264 | if (!gs_WSACreateEvent) |
265 | return false; | |
266 | ||
267 | gs_WSAWaitForMultipleEvents =(WSAWaitForMultipleEventsFunc)GetProcAddress(gs_wsock32dll, | |
7ec69821 | 268 | wxT("WSAWaitForMultipleEvents")); |
84aa68c4 JS |
269 | if (!gs_WSAWaitForMultipleEvents) |
270 | return false; | |
271 | ||
272 | gs_WSAEnumNetworkEvents =(WSAEnumNetworkEventsFunc)GetProcAddress(gs_wsock32dll, | |
7ec69821 | 273 | wxT("WSAEnumNetworkEvents")); |
84aa68c4 JS |
274 | if (!gs_WSAEnumNetworkEvents) |
275 | return false; | |
276 | ||
277 | currSocket = 0; | |
278 | #endif | |
7ec69821 | 279 | |
84aa68c4 | 280 | return true; |
b7ceceb1 DE |
281 | } |
282 | ||
c90cc42e | 283 | void GSocketGUIFunctionsTableConcrete::OnExit() |
b7ceceb1 | 284 | { |
dbfb61b3 | 285 | #ifdef __WXWINCE__ |
1c6dd11c | 286 | /* Delete the threads here */ |
7ec69821 WS |
287 | for(unsigned int i=0; i < currSocket; i++) |
288 | CloseHandle(hThread[i]); | |
dbfb61b3 | 289 | #endif |
b7ceceb1 DE |
290 | /* Destroy internal window */ |
291 | DestroyWindow(hWin); | |
292 | UnregisterClass(CLASSNAME, INSTANCE); | |
293 | ||
1c8681b4 DE |
294 | /* Unlock wsock32.dll */ |
295 | if (gs_wsock32dll) | |
296 | { | |
297 | FreeLibrary(gs_wsock32dll); | |
298 | gs_wsock32dll = 0; | |
299 | } | |
300 | ||
b7ceceb1 DE |
301 | /* Delete critical section */ |
302 | DeleteCriticalSection(&critical); | |
303 | } | |
304 | ||
305 | /* Per-socket GUI initialization / cleanup */ | |
306 | ||
c90cc42e | 307 | bool GSocketGUIFunctionsTableConcrete::Init_Socket(GSocket *socket) |
b7ceceb1 DE |
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); | |
c90cc42e | 322 | return false; |
b7ceceb1 DE |
323 | } |
324 | } | |
325 | socketList[i] = socket; | |
326 | firstAvailable = (i + 1) % MAXSOCKETS; | |
327 | socket->m_msgnumber = (i + WM_USER); | |
328 | ||
329 | LeaveCriticalSection(&critical); | |
330 | ||
c90cc42e | 331 | return true; |
b7ceceb1 DE |
332 | } |
333 | ||
c90cc42e | 334 | void GSocketGUIFunctionsTableConcrete::Destroy_Socket(GSocket *socket) |
b7ceceb1 DE |
335 | { |
336 | /* Remove the socket from the list */ | |
337 | EnterCriticalSection(&critical); | |
b5b0a35d VZ |
338 | if ( socket->IsOk() ) |
339 | socketList[(socket->m_msgnumber - WM_USER)] = NULL; | |
b7ceceb1 DE |
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 | */ | |
c90cc42e | 419 | void GSocketGUIFunctionsTableConcrete::Enable_Events(GSocket *socket) |
b7ceceb1 DE |
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); | |
dbfb61b3 | 430 | #ifndef __WXWINCE__ |
1c8681b4 | 431 | gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, lEvent); |
dbfb61b3 JS |
432 | #else |
433 | /* | |
434 | * WinCE creates a thread for socket event handling. | |
1c6dd11c | 435 | * All needed parameters get passed through the thread_data structure. |
dbfb61b3 | 436 | */ |
84aa68c4 | 437 | |
7ec69821 WS |
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); | |
dbfb61b3 | 445 | #endif |
b7ceceb1 DE |
446 | } |
447 | } | |
448 | ||
449 | /* _GSocket_Disable_Events: | |
450 | * Disable event notifications (when shutdowning the socket) | |
451 | */ | |
c90cc42e | 452 | void GSocketGUIFunctionsTableConcrete::Disable_Events(GSocket *socket) |
b7ceceb1 DE |
453 | { |
454 | assert (socket != NULL); | |
455 | ||
456 | if (socket->m_fd != INVALID_SOCKET) | |
457 | { | |
dbfb61b3 | 458 | #ifndef __WXWINCE__ |
1c8681b4 | 459 | gs_WSAAsyncSelect(socket->m_fd, hWin, socket->m_msgnumber, 0); |
dbfb61b3 | 460 | #else |
7ec69821 WS |
461 | //Destroy the thread |
462 | socketHash[socket->m_fd] = false; | |
dbfb61b3 | 463 | #endif |
b7ceceb1 DE |
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__) */ |