74fb27171f6646c32118242cf46ca73aa076dd35
[reactos.git] / reactos / win32ss / user / ntuser / callback.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Callback to usermode support
5 * FILE: subsystems/win32/win32k/ntuser/callback.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Thomas Weidenmueller (w3seek@users.sourceforge.net)
8 * NOTES: Please use the Callback Memory Management functions for
9 * callbacks to make sure, the memory is freed on thread
10 * termination!
11 */
12
13 #include <win32k.h>
14 DBG_DEFAULT_CHANNEL(UserCallback);
15
16
17 /* CALLBACK MEMORY MANAGEMENT ************************************************/
18
19 typedef struct _INT_CALLBACK_HEADER
20 {
21 /* List entry in the THREADINFO structure */
22 LIST_ENTRY ListEntry;
23 }
24 INT_CALLBACK_HEADER, *PINT_CALLBACK_HEADER;
25
26 PVOID FASTCALL
27 IntCbAllocateMemory(ULONG Size)
28 {
29 PINT_CALLBACK_HEADER Mem;
30 PTHREADINFO W32Thread;
31
32 if(!(Mem = ExAllocatePoolWithTag(PagedPool, Size + sizeof(INT_CALLBACK_HEADER),
33 USERTAG_CALLBACK)))
34 {
35 return NULL;
36 }
37
38 W32Thread = PsGetCurrentThreadWin32Thread();
39 ASSERT(W32Thread);
40
41 /* Insert the callback memory into the thread's callback list */
42
43 InsertTailList(&W32Thread->W32CallbackListHead, &Mem->ListEntry);
44
45 return (Mem + 1);
46 }
47
48 VOID FASTCALL
49 IntCbFreeMemory(PVOID Data)
50 {
51 PINT_CALLBACK_HEADER Mem;
52 PTHREADINFO W32Thread;
53
54 ASSERT(Data);
55
56 Mem = ((PINT_CALLBACK_HEADER)Data - 1);
57
58 W32Thread = PsGetCurrentThreadWin32Thread();
59 ASSERT(W32Thread);
60
61 /* Remove the memory block from the thread's callback list */
62 RemoveEntryList(&Mem->ListEntry);
63
64 /* Free memory */
65 ExFreePoolWithTag(Mem, USERTAG_CALLBACK);
66 }
67
68 VOID FASTCALL
69 IntCleanupThreadCallbacks(PTHREADINFO W32Thread)
70 {
71 PLIST_ENTRY CurrentEntry;
72 PINT_CALLBACK_HEADER Mem;
73
74 while (!IsListEmpty(&W32Thread->W32CallbackListHead))
75 {
76 CurrentEntry = RemoveHeadList(&W32Thread->W32CallbackListHead);
77 Mem = CONTAINING_RECORD(CurrentEntry, INT_CALLBACK_HEADER,
78 ListEntry);
79
80 /* Free memory */
81 ExFreePoolWithTag(Mem, USERTAG_CALLBACK);
82 }
83 }
84
85 //
86 // Pass the Current Window handle and pointer to the Client Callback.
87 // This will help user space programs speed up read access with the window object.
88 //
89 static VOID
90 IntSetTebWndCallback (HWND * hWnd, PWND * pWnd, PVOID * pActCtx)
91 {
92 HWND hWndS = *hWnd;
93 PWND Window = UserGetWindowObject(*hWnd);
94 PCLIENTINFO ClientInfo = GetWin32ClientInfo();
95
96 *hWnd = ClientInfo->CallbackWnd.hWnd;
97 *pWnd = ClientInfo->CallbackWnd.pWnd;
98 *pActCtx = ClientInfo->CallbackWnd.pActCtx;
99
100 ClientInfo->CallbackWnd.hWnd = hWndS;
101 ClientInfo->CallbackWnd.pWnd = DesktopHeapAddressToUser(Window);
102 ClientInfo->CallbackWnd.pActCtx = Window->pActCtx;
103 }
104
105 static VOID
106 IntRestoreTebWndCallback (HWND hWnd, PWND pWnd, PVOID pActCtx)
107 {
108 PCLIENTINFO ClientInfo = GetWin32ClientInfo();
109
110 ClientInfo->CallbackWnd.hWnd = hWnd;
111 ClientInfo->CallbackWnd.pWnd = pWnd;
112 ClientInfo->CallbackWnd.pActCtx = pActCtx;
113 }
114
115 /* FUNCTIONS *****************************************************************/
116
117 /* Calls ClientLoadLibrary in user32 */
118 BOOL
119 NTAPI
120 co_IntClientLoadLibrary(PUNICODE_STRING pstrLibName,
121 PUNICODE_STRING pstrInitFunc,
122 BOOL Unload,
123 BOOL ApiHook)
124 {
125 PVOID ResultPointer;
126 ULONG ResultLength;
127 ULONG ArgumentLength;
128 PCLIENT_LOAD_LIBRARY_ARGUMENTS pArguments;
129 NTSTATUS Status;
130 BOOL bResult;
131 ULONG_PTR pLibNameBuffer = 0, pInitFuncBuffer = 0;
132
133 /* Do not allow the desktop thread to do callback to user mode */
134 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
135
136 TRACE("co_IntClientLoadLibrary: %S, %S, %d, %d\n", pstrLibName->Buffer, pstrLibName->Buffer, Unload, ApiHook);
137
138 /* Calculate the size of the argument */
139 ArgumentLength = sizeof(CLIENT_LOAD_LIBRARY_ARGUMENTS);
140 if(pstrLibName)
141 {
142 pLibNameBuffer = ArgumentLength;
143 ArgumentLength += pstrLibName->Length + sizeof(WCHAR);
144 }
145 if(pstrInitFunc)
146 {
147 pInitFuncBuffer = ArgumentLength;
148 ArgumentLength += pstrInitFunc->Length + sizeof(WCHAR);
149 }
150
151 /* Allocate the argument */
152 pArguments = IntCbAllocateMemory(ArgumentLength);
153 if(pArguments == NULL)
154 {
155 return FALSE;
156 }
157
158 /* Fill the argument */
159 pArguments->Unload = Unload;
160 pArguments->ApiHook = ApiHook;
161 if(pstrLibName)
162 {
163 /* Copy the string to the callback memory */
164 pLibNameBuffer += (ULONG_PTR)pArguments;
165 pArguments->strLibraryName.Buffer = (PWCHAR)pLibNameBuffer;
166 pArguments->strLibraryName.MaximumLength = pstrLibName->Length + sizeof(WCHAR);
167 RtlCopyUnicodeString(&pArguments->strLibraryName, pstrLibName);
168
169 /* Fix argument pointer to be relative to the argument */
170 pLibNameBuffer -= (ULONG_PTR)pArguments;
171 pArguments->strLibraryName.Buffer = (PWCHAR)(pLibNameBuffer);
172 }
173 else
174 {
175 RtlZeroMemory(&pArguments->strLibraryName, sizeof(UNICODE_STRING));
176 }
177
178 if(pstrInitFunc)
179 {
180 /* Copy the strings to the callback memory */
181 pInitFuncBuffer += (ULONG_PTR)pArguments;
182 pArguments->strInitFuncName.Buffer = (PWCHAR)pInitFuncBuffer;
183 pArguments->strInitFuncName.MaximumLength = pstrInitFunc->Length + sizeof(WCHAR);
184 RtlCopyUnicodeString(&pArguments->strInitFuncName, pstrInitFunc);
185
186 /* Fix argument pointers to be relative to the argument */
187 pInitFuncBuffer -= (ULONG_PTR)pArguments;
188 pArguments->strInitFuncName.Buffer = (PWCHAR)(pInitFuncBuffer);
189 }
190 else
191 {
192 RtlZeroMemory(&pArguments->strInitFuncName, sizeof(UNICODE_STRING));
193 }
194
195 /* Do the callback */
196 UserLeaveCo();
197
198 Status = KeUserModeCallback(USER32_CALLBACK_CLIENTLOADLIBRARY,
199 pArguments,
200 ArgumentLength,
201 &ResultPointer,
202 &ResultLength);
203
204 UserEnterCo();
205
206 /* Free the argument */
207 IntCbFreeMemory(pArguments);
208
209 if(!NT_SUCCESS(Status))
210 {
211 return FALSE;
212 }
213
214 _SEH2_TRY
215 {
216 /* Probe and copy the usermode result data */
217 ProbeForRead(ResultPointer, sizeof(HMODULE), 1);
218 bResult = *(BOOL*)ResultPointer;
219 }
220 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
221 {
222 bResult = FALSE;
223 }
224 _SEH2_END;
225
226 return bResult;
227 }
228
229 VOID APIENTRY
230 co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback,
231 HWND hWnd,
232 UINT Msg,
233 ULONG_PTR CompletionCallbackContext,
234 LRESULT Result)
235 {
236 SENDASYNCPROC_CALLBACK_ARGUMENTS Arguments;
237 PVOID ResultPointer, pActCtx;
238 PWND pWnd;
239 ULONG ResultLength;
240 NTSTATUS Status;
241
242 /* Do not allow the desktop thread to do callback to user mode */
243 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
244
245 Arguments.Callback = CompletionCallback;
246 Arguments.Wnd = hWnd;
247 Arguments.Msg = Msg;
248 Arguments.Context = CompletionCallbackContext;
249 Arguments.Result = Result;
250
251 IntSetTebWndCallback (&hWnd, &pWnd, &pActCtx);
252
253 UserLeaveCo();
254
255 Status = KeUserModeCallback(USER32_CALLBACK_SENDASYNCPROC,
256 &Arguments,
257 sizeof(SENDASYNCPROC_CALLBACK_ARGUMENTS),
258 &ResultPointer,
259 &ResultLength);
260
261 UserEnterCo();
262
263 IntRestoreTebWndCallback (hWnd, pWnd, pActCtx);
264
265 if (!NT_SUCCESS(Status))
266 {
267 return;
268 }
269 return;
270 }
271
272 LRESULT APIENTRY
273 co_IntCallWindowProc(WNDPROC Proc,
274 BOOLEAN IsAnsiProc,
275 HWND Wnd,
276 UINT Message,
277 WPARAM wParam,
278 LPARAM lParam,
279 INT lParamBufferSize)
280 {
281 WINDOWPROC_CALLBACK_ARGUMENTS StackArguments;
282 PWINDOWPROC_CALLBACK_ARGUMENTS Arguments;
283 NTSTATUS Status;
284 PVOID ResultPointer, pActCtx;
285 PWND pWnd;
286 ULONG ResultLength;
287 ULONG ArgumentLength;
288 LRESULT Result;
289
290 /* Do not allow the desktop thread to do callback to user mode */
291 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
292
293 if (lParamBufferSize != -1)
294 {
295 ArgumentLength = sizeof(WINDOWPROC_CALLBACK_ARGUMENTS) + lParamBufferSize;
296 Arguments = IntCbAllocateMemory(ArgumentLength);
297 if (NULL == Arguments)
298 {
299 ERR("Unable to allocate buffer for window proc callback\n");
300 return -1;
301 }
302 RtlMoveMemory((PVOID) ((char *) Arguments + sizeof(WINDOWPROC_CALLBACK_ARGUMENTS)),
303 (PVOID) lParam, lParamBufferSize);
304 }
305 else
306 {
307 Arguments = &StackArguments;
308 ArgumentLength = sizeof(WINDOWPROC_CALLBACK_ARGUMENTS);
309 }
310 Arguments->Proc = Proc;
311 Arguments->IsAnsiProc = IsAnsiProc;
312 Arguments->Wnd = Wnd;
313 Arguments->Msg = Message;
314 Arguments->wParam = wParam;
315 Arguments->lParam = lParam;
316 Arguments->lParamBufferSize = lParamBufferSize;
317 ResultPointer = NULL;
318 ResultLength = ArgumentLength;
319
320 IntSetTebWndCallback (&Wnd, &pWnd, &pActCtx);
321
322 UserLeaveCo();
323
324 Status = KeUserModeCallback(USER32_CALLBACK_WINDOWPROC,
325 Arguments,
326 ArgumentLength,
327 &ResultPointer,
328 &ResultLength);
329
330 _SEH2_TRY
331 {
332 /* Simulate old behaviour: copy into our local buffer */
333 RtlMoveMemory(Arguments, ResultPointer, ArgumentLength);
334 }
335 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
336 {
337 ERR("Failed to copy result from user mode, Message %d lParam size %d!\n", Message, lParamBufferSize);
338 Status = _SEH2_GetExceptionCode();
339 }
340 _SEH2_END;
341
342 UserEnterCo();
343
344 IntRestoreTebWndCallback (Wnd, pWnd, pActCtx);
345
346 if (!NT_SUCCESS(Status))
347 {
348 ERR("Call to user mode failed!\n");
349 if (lParamBufferSize != -1)
350 {
351 IntCbFreeMemory(Arguments);
352 }
353 return -1;
354 }
355 Result = Arguments->Result;
356
357 if (lParamBufferSize != -1)
358 {
359 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
360 // Is this message being processed from inside kernel space?
361 BOOL InSendMessage = (pti->pcti->CTI_flags & CTI_INSENDMESSAGE);
362
363 TRACE("Copy lParam Message %d lParam %d!\n", Message, lParam);
364 switch (Message)
365 {
366 default:
367 TRACE("Don't copy lParam, Message %d Size %d lParam %d!\n", Message, lParamBufferSize, lParam);
368 break;
369 // Write back to user/kernel space. Also see g_MsgMemory.
370 case WM_CREATE:
371 case WM_GETMINMAXINFO:
372 case WM_GETTEXT:
373 case WM_NCCALCSIZE:
374 case WM_NCCREATE:
375 case WM_STYLECHANGING:
376 case WM_WINDOWPOSCHANGING:
377 case WM_SIZING:
378 case WM_MOVING:
379 TRACE("Copy lParam, Message %d Size %d lParam %d!\n", Message, lParamBufferSize, lParam);
380 if (InSendMessage)
381 // Copy into kernel space.
382 RtlMoveMemory((PVOID) lParam,
383 (PVOID) ((char *) Arguments + sizeof(WINDOWPROC_CALLBACK_ARGUMENTS)),
384 lParamBufferSize);
385 else
386 {
387 _SEH2_TRY
388 { // Copy into user space.
389 RtlMoveMemory((PVOID) lParam,
390 (PVOID) ((char *) Arguments + sizeof(WINDOWPROC_CALLBACK_ARGUMENTS)),
391 lParamBufferSize);
392 }
393 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
394 {
395 ERR("Failed to copy lParam to user space, Message %d!\n", Message);
396 }
397 _SEH2_END;
398 }
399 break;
400 }
401 IntCbFreeMemory(Arguments);
402 }
403
404 return Result;
405 }
406
407 HMENU APIENTRY
408 co_IntLoadSysMenuTemplate()
409 {
410 LRESULT Result = 0;
411 NTSTATUS Status;
412 PVOID ResultPointer;
413 ULONG ResultLength;
414
415 /* Do not allow the desktop thread to do callback to user mode */
416 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
417
418 ResultPointer = NULL;
419 ResultLength = sizeof(LRESULT);
420
421 UserLeaveCo();
422
423 Status = KeUserModeCallback(USER32_CALLBACK_LOADSYSMENUTEMPLATE,
424 &ResultPointer,
425 0,
426 &ResultPointer,
427 &ResultLength);
428 if (NT_SUCCESS(Status))
429 {
430 /* Simulate old behaviour: copy into our local buffer */
431 _SEH2_TRY
432 {
433 ProbeForRead(ResultPointer, sizeof(LRESULT), 1);
434 Result = *(LRESULT*)ResultPointer;
435 }
436 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
437 {
438 Result = 0;
439 }
440 _SEH2_END;
441 }
442
443 UserEnterCo();
444
445 return (HMENU)Result;
446 }
447
448 extern HCURSOR gDesktopCursor;
449
450 BOOL APIENTRY
451 co_IntLoadDefaultCursors(VOID)
452 {
453 NTSTATUS Status;
454 PVOID ResultPointer;
455 ULONG ResultLength;
456 BOOL DefaultCursor = TRUE;
457
458 /* Do not allow the desktop thread to do callback to user mode */
459 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
460
461 ResultPointer = NULL;
462 ResultLength = sizeof(HCURSOR);
463
464 UserLeaveCo();
465
466 Status = KeUserModeCallback(USER32_CALLBACK_LOADDEFAULTCURSORS,
467 &DefaultCursor,
468 sizeof(BOOL),
469 &ResultPointer,
470 &ResultLength);
471
472 UserEnterCo();
473
474 /* HACK: The desktop class doen't have a proper cursor yet, so set it here */
475 gDesktopCursor = *((HCURSOR*)ResultPointer);
476
477 if (!NT_SUCCESS(Status))
478 {
479 return FALSE;
480 }
481 return TRUE;
482 }
483
484 LRESULT APIENTRY
485 co_IntCallHookProc(INT HookId,
486 INT Code,
487 WPARAM wParam,
488 LPARAM lParam,
489 HOOKPROC Proc,
490 INT Mod,
491 ULONG_PTR offPfn,
492 BOOLEAN Ansi,
493 PUNICODE_STRING ModuleName)
494 {
495 ULONG ArgumentLength;
496 PVOID Argument = NULL;
497 LRESULT Result = 0;
498 NTSTATUS Status;
499 PVOID ResultPointer;
500 ULONG ResultLength;
501 PHOOKPROC_CALLBACK_ARGUMENTS Common;
502 CBT_CREATEWNDW *CbtCreateWnd = NULL;
503 PCHAR Extra;
504 PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS CbtCreatewndExtra = NULL;
505 PTHREADINFO pti;
506 PWND pWnd;
507 PMSG pMsg = NULL;
508 BOOL Hit = FALSE;
509 UINT lParamSize = 0;
510
511 ASSERT(Proc);
512 /* Do not allow the desktop thread to do callback to user mode */
513 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
514
515 pti = PsGetCurrentThreadWin32Thread();
516 if (pti->TIF_flags & TIF_INCLEANUP)
517 {
518 ERR("Thread is in cleanup and trying to call hook %d\n", Code);
519 return 0;
520 }
521
522 ArgumentLength = sizeof(HOOKPROC_CALLBACK_ARGUMENTS);
523
524 switch(HookId)
525 {
526 case WH_CBT:
527 TRACE("WH_CBT: Code %d\n", Code);
528 switch(Code)
529 {
530 case HCBT_CREATEWND:
531 pWnd = UserGetWindowObject((HWND) wParam);
532 if (!pWnd)
533 {
534 ERR("WH_CBT HCBT_CREATEWND wParam bad hWnd!\n");
535 goto Fault_Exit;
536 }
537 TRACE("HCBT_CREATEWND AnsiCreator %s, AnsiHook %s\n", pWnd->state & WNDS_ANSICREATOR ? "True" : "False", Ansi ? "True" : "False");
538 // Due to KsStudio.exe, just pass the callers original pointers
539 // except class which point to kernel space if not an atom.
540 // Found by, Olaf Siejka
541 CbtCreateWnd = (CBT_CREATEWNDW *) lParam;
542 ArgumentLength += sizeof(HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS);
543 break;
544
545 case HCBT_MOVESIZE:
546 ArgumentLength += sizeof(RECTL);
547 break;
548 case HCBT_ACTIVATE:
549 ArgumentLength += sizeof(CBTACTIVATESTRUCT);
550 break;
551 case HCBT_CLICKSKIPPED:
552 ArgumentLength += sizeof(MOUSEHOOKSTRUCT);
553 break;
554 /* ATM pass on */
555 case HCBT_KEYSKIPPED:
556 case HCBT_MINMAX:
557 case HCBT_SETFOCUS:
558 case HCBT_SYSCOMMAND:
559 /* These types pass through. */
560 case HCBT_DESTROYWND:
561 case HCBT_QS:
562 break;
563 default:
564 ERR("Trying to call unsupported CBT hook %d\n", Code);
565 goto Fault_Exit;
566 }
567 break;
568 case WH_KEYBOARD_LL:
569 ArgumentLength += sizeof(KBDLLHOOKSTRUCT);
570 break;
571 case WH_MOUSE_LL:
572 ArgumentLength += sizeof(MSLLHOOKSTRUCT);
573 break;
574 case WH_MOUSE:
575 ArgumentLength += sizeof(MOUSEHOOKSTRUCT);
576 break;
577 case WH_CALLWNDPROC:
578 {
579 CWPSTRUCT* pCWP = (CWPSTRUCT*) lParam;
580 ArgumentLength += sizeof(CWPSTRUCT);
581 lParamSize = lParamMemorySize(pCWP->message, pCWP->wParam, pCWP->lParam);
582 ArgumentLength += lParamSize;
583 break;
584 }
585 case WH_CALLWNDPROCRET:
586 {
587 CWPRETSTRUCT* pCWPR = (CWPRETSTRUCT*) lParam;
588 ArgumentLength += sizeof(CWPRETSTRUCT);
589 lParamSize = lParamMemorySize(pCWPR->message, pCWPR->wParam, pCWPR->lParam);
590 ArgumentLength += lParamSize;
591 break;
592 }
593 case WH_MSGFILTER:
594 case WH_SYSMSGFILTER:
595 case WH_GETMESSAGE:
596 ArgumentLength += sizeof(MSG);
597 break;
598 case WH_FOREGROUNDIDLE:
599 case WH_KEYBOARD:
600 case WH_SHELL:
601 break;
602 default:
603 ERR("Trying to call unsupported window hook %d\n", HookId);
604 goto Fault_Exit;
605 }
606
607 Argument = IntCbAllocateMemory(ArgumentLength);
608 if (NULL == Argument)
609 {
610 ERR("HookProc callback failed: out of memory\n");
611 goto Fault_Exit;
612 }
613 Common = (PHOOKPROC_CALLBACK_ARGUMENTS) Argument;
614 Common->HookId = HookId;
615 Common->Code = Code;
616 Common->wParam = wParam;
617 Common->lParam = lParam;
618 Common->Proc = Proc;
619 Common->Mod = Mod;
620 Common->offPfn = offPfn;
621 Common->Ansi = Ansi;
622 RtlZeroMemory(&Common->ModuleName, sizeof(Common->ModuleName));
623 RtlCopyMemory(&Common->ModuleName, ModuleName->Buffer, ModuleName->Length);
624 Extra = (PCHAR) Common + sizeof(HOOKPROC_CALLBACK_ARGUMENTS);
625
626 switch(HookId)
627 {
628 case WH_CBT:
629 switch(Code)
630 { // Need to remember this is not the first time through! Call Next Hook?
631 case HCBT_CREATEWND:
632 CbtCreatewndExtra = (PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS) Extra;
633 RtlCopyMemory( &CbtCreatewndExtra->Cs, CbtCreateWnd->lpcs, sizeof(CREATESTRUCTW) );
634 CbtCreatewndExtra->WndInsertAfter = CbtCreateWnd->hwndInsertAfter;
635 CbtCreatewndExtra->Cs.lpszClass = CbtCreateWnd->lpcs->lpszClass;
636 CbtCreatewndExtra->Cs.lpszName = CbtCreateWnd->lpcs->lpszName;
637 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
638 break;
639 case HCBT_CLICKSKIPPED:
640 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(MOUSEHOOKSTRUCT));
641 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
642 break;
643 case HCBT_MOVESIZE:
644 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(RECTL));
645 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
646 break;
647 case HCBT_ACTIVATE:
648 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(CBTACTIVATESTRUCT));
649 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
650 break;
651 }
652 break;
653 case WH_KEYBOARD_LL:
654 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(KBDLLHOOKSTRUCT));
655 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
656 break;
657 case WH_MOUSE_LL:
658 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(MSLLHOOKSTRUCT));
659 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
660 break;
661 case WH_MOUSE:
662 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(MOUSEHOOKSTRUCT));
663 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
664 break;
665 case WH_CALLWNDPROC:
666 /* For CALLWNDPROC and CALLWNDPROCRET, we must be wary of the fact that
667 * lParam could be a pointer to a buffer. This buffer must be exported
668 * to user space too */
669 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(CWPSTRUCT));
670 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
671 if(lParamSize)
672 {
673 RtlCopyMemory(Extra + sizeof(CWPSTRUCT), (PVOID)((CWPSTRUCT*)lParam)->lParam, lParamSize);
674 ((CWPSTRUCT*)Extra)->lParam = (LPARAM)lParamSize;
675 }
676 break;
677 case WH_CALLWNDPROCRET:
678 RtlCopyMemory(Extra, (PVOID) lParam, sizeof(CWPRETSTRUCT));
679 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
680 if(lParamSize)
681 {
682 RtlCopyMemory(Extra + sizeof(CWPRETSTRUCT), (PVOID)((CWPRETSTRUCT*)lParam)->lParam, lParamSize);
683 ((CWPRETSTRUCT*)Extra)->lParam = (LPARAM)lParamSize;
684 }
685 break;
686 case WH_MSGFILTER:
687 case WH_SYSMSGFILTER:
688 case WH_GETMESSAGE:
689 pMsg = (PMSG)lParam;
690 RtlCopyMemory(Extra, (PVOID) pMsg, sizeof(MSG));
691 Common->lParam = (LPARAM) (Extra - (PCHAR) Common);
692 break;
693 case WH_FOREGROUNDIDLE:
694 case WH_KEYBOARD:
695 case WH_SHELL:
696 break;
697 }
698
699 ResultPointer = NULL;
700 ResultLength = ArgumentLength;
701
702 UserLeaveCo();
703
704 Status = KeUserModeCallback(USER32_CALLBACK_HOOKPROC,
705 Argument,
706 ArgumentLength,
707 &ResultPointer,
708 &ResultLength);
709
710 UserEnterCo();
711
712 if (ResultPointer)
713 {
714 _SEH2_TRY
715 {
716 /* Simulate old behaviour: copy into our local buffer */
717 RtlMoveMemory(Argument, ResultPointer, ArgumentLength);
718 Result = Common->Result;
719 }
720 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
721 {
722 Result = 0;
723 Hit = TRUE;
724 }
725 _SEH2_END;
726 }
727 else
728 {
729 ERR("ERROR: Hook %d Code %d ResultPointer 0x%p ResultLength %u\n",HookId,Code,ResultPointer,ResultLength);
730 }
731
732 if (!NT_SUCCESS(Status))
733 {
734 ERR("Failure to make Callback! Status 0x%x",Status);
735 goto Fault_Exit;
736 }
737 /* Support write backs... SEH is in UserCallNextHookEx. */
738 switch (HookId)
739 {
740 case WH_CBT:
741 {
742 switch (Code)
743 {
744 case HCBT_CREATEWND:
745 if (CbtCreatewndExtra)
746 {/*
747 The parameters could have been changed, include the coordinates
748 and dimensions of the window. We copy it back.
749 */
750 CbtCreateWnd->hwndInsertAfter = CbtCreatewndExtra->WndInsertAfter;
751 CbtCreateWnd->lpcs->x = CbtCreatewndExtra->Cs.x;
752 CbtCreateWnd->lpcs->y = CbtCreatewndExtra->Cs.y;
753 CbtCreateWnd->lpcs->cx = CbtCreatewndExtra->Cs.cx;
754 CbtCreateWnd->lpcs->cy = CbtCreatewndExtra->Cs.cy;
755 }
756 break;
757 case HCBT_MOVESIZE:
758 if (Extra && lParam)
759 {
760 RtlCopyMemory((PVOID) lParam, Extra, sizeof(RECTL));
761 }
762 break;
763 }
764 }
765 // "The GetMsgProc hook procedure can examine or modify the message."
766 case WH_GETMESSAGE:
767 if (pMsg)
768 {
769 RtlCopyMemory((PVOID) pMsg, Extra, sizeof(MSG));
770 }
771 break;
772 }
773
774 Fault_Exit:
775 if (Hit)
776 {
777 ERR("Exception CallHookProc HookId %d Code %d\n",HookId,Code);
778 }
779 if (Argument) IntCbFreeMemory(Argument);
780
781 return Result;
782 }
783
784 //
785 // Events are notifications w/o results.
786 //
787 LRESULT
788 APIENTRY
789 co_IntCallEventProc(HWINEVENTHOOK hook,
790 DWORD event,
791 HWND hWnd,
792 LONG idObject,
793 LONG idChild,
794 DWORD dwEventThread,
795 DWORD dwmsEventTime,
796 WINEVENTPROC Proc)
797 {
798 LRESULT Result = 0;
799 NTSTATUS Status;
800 PEVENTPROC_CALLBACK_ARGUMENTS Common;
801 ULONG ArgumentLength, ResultLength;
802 PVOID Argument, ResultPointer;
803
804 ArgumentLength = sizeof(EVENTPROC_CALLBACK_ARGUMENTS);
805
806 Argument = IntCbAllocateMemory(ArgumentLength);
807 if (NULL == Argument)
808 {
809 ERR("EventProc callback failed: out of memory\n");
810 return 0;
811 }
812 Common = (PEVENTPROC_CALLBACK_ARGUMENTS) Argument;
813 Common->hook = hook;
814 Common->event = event;
815 Common->hwnd = hWnd;
816 Common->idObject = idObject;
817 Common->idChild = idChild;
818 Common->dwEventThread = dwEventThread;
819 Common->dwmsEventTime = dwmsEventTime;
820 Common->Proc = Proc;
821
822 ResultPointer = NULL;
823 ResultLength = sizeof(LRESULT);
824
825 UserLeaveCo();
826
827 Status = KeUserModeCallback(USER32_CALLBACK_EVENTPROC,
828 Argument,
829 ArgumentLength,
830 &ResultPointer,
831 &ResultLength);
832
833 UserEnterCo();
834
835 IntCbFreeMemory(Argument);
836
837 if (!NT_SUCCESS(Status))
838 {
839 return 0;
840 }
841
842 return Result;
843 }
844
845 //
846 // Callback Load Menu and results.
847 //
848 HMENU
849 APIENTRY
850 co_IntCallLoadMenu( HINSTANCE hModule,
851 PUNICODE_STRING pMenuName )
852 {
853 LRESULT Result = 0;
854 NTSTATUS Status;
855 PLOADMENU_CALLBACK_ARGUMENTS Common;
856 ULONG ArgumentLength, ResultLength;
857 PVOID Argument, ResultPointer;
858
859 ArgumentLength = sizeof(LOADMENU_CALLBACK_ARGUMENTS);
860
861 ArgumentLength += pMenuName->Length + sizeof(WCHAR);
862
863 Argument = IntCbAllocateMemory(ArgumentLength);
864 if (NULL == Argument)
865 {
866 ERR("LoadMenu callback failed: out of memory\n");
867 return 0;
868 }
869 Common = (PLOADMENU_CALLBACK_ARGUMENTS) Argument;
870
871 // Help Intersource check and MenuName is now 4 bytes + so zero it.
872 RtlZeroMemory(Common, ArgumentLength);
873
874 Common->hModule = hModule;
875 if (pMenuName->Length)
876 RtlCopyMemory(&Common->MenuName, pMenuName->Buffer, pMenuName->Length);
877 else
878 RtlCopyMemory(&Common->MenuName, &pMenuName->Buffer, sizeof(WCHAR));
879
880 ResultPointer = NULL;
881 ResultLength = sizeof(LRESULT);
882
883 UserLeaveCo();
884
885 Status = KeUserModeCallback(USER32_CALLBACK_LOADMENU,
886 Argument,
887 ArgumentLength,
888 &ResultPointer,
889 &ResultLength);
890
891 UserEnterCo();
892
893 Result = *(LRESULT*)ResultPointer;
894
895 IntCbFreeMemory(Argument);
896
897 if (!NT_SUCCESS(Status))
898 {
899 return 0;
900 }
901
902 return (HMENU)Result;
903 }
904
905 NTSTATUS
906 APIENTRY
907 co_IntClientThreadSetup(VOID)
908 {
909 NTSTATUS Status;
910 ULONG ArgumentLength, ResultLength;
911 PVOID Argument, ResultPointer;
912
913 /* Do not allow the desktop thread to do callback to user mode */
914 ASSERT(PsGetCurrentThreadWin32Thread() != gptiDesktopThread);
915
916 ArgumentLength = ResultLength = 0;
917 Argument = ResultPointer = NULL;
918
919 UserLeaveCo();
920
921 Status = KeUserModeCallback(USER32_CALLBACK_CLIENTTHREADSTARTUP,
922 Argument,
923 ArgumentLength,
924 &ResultPointer,
925 &ResultLength);
926
927 UserEnterCo();
928
929 return Status;
930 }
931
932 HANDLE FASTCALL
933 co_IntCopyImage(HANDLE hnd, UINT type, INT desiredx, INT desiredy, UINT flags)
934 {
935 HANDLE Handle;
936 NTSTATUS Status;
937 ULONG ArgumentLength, ResultLength;
938 PVOID Argument, ResultPointer;
939 PCOPYIMAGE_CALLBACK_ARGUMENTS Common;
940
941 ArgumentLength = ResultLength = 0;
942 Argument = ResultPointer = NULL;
943
944 ArgumentLength = sizeof(COPYIMAGE_CALLBACK_ARGUMENTS);
945
946 Argument = IntCbAllocateMemory(ArgumentLength);
947 if (NULL == Argument)
948 {
949 ERR("CopyImage callback failed: out of memory\n");
950 return 0;
951 }
952 Common = (PCOPYIMAGE_CALLBACK_ARGUMENTS) Argument;
953
954 Common->hImage = hnd;
955 Common->uType = type;
956 Common->cxDesired = desiredx;
957 Common->cyDesired = desiredy;
958 Common->fuFlags = flags;
959
960 UserLeaveCo();
961
962 Status = KeUserModeCallback(USER32_CALLBACK_COPYIMAGE,
963 Argument,
964 ArgumentLength,
965 &ResultPointer,
966 &ResultLength);
967
968
969 UserEnterCo();
970
971 Handle = *(HANDLE*)ResultPointer;
972
973 IntCbFreeMemory(Argument);
974
975 if (!NT_SUCCESS(Status))
976 {
977 ERR("CopyImage callback failed!\n");
978 return 0;
979 }
980
981 return Handle;
982 }
983
984 BOOL
985 APIENTRY
986 co_IntGetCharsetInfo(LCID Locale, PCHARSETINFO pCs)
987 {
988 NTSTATUS Status;
989 ULONG ArgumentLength, ResultLength;
990 PVOID Argument, ResultPointer;
991 PGET_CHARSET_INFO Common;
992
993 ArgumentLength = sizeof(GET_CHARSET_INFO);
994
995 Argument = IntCbAllocateMemory(ArgumentLength);
996 if (NULL == Argument)
997 {
998 ERR("GetCharsetInfo callback failed: out of memory\n");
999 return 0;
1000 }
1001 Common = (PGET_CHARSET_INFO) Argument;
1002
1003 Common->Locale = Locale;
1004
1005 ResultPointer = NULL;
1006 ResultLength = ArgumentLength;
1007
1008 UserLeaveCo();
1009
1010 Status = KeUserModeCallback(USER32_CALLBACK_GETCHARSETINFO,
1011 Argument,
1012 ArgumentLength,
1013 &ResultPointer,
1014 &ResultLength);
1015
1016 _SEH2_TRY
1017 {
1018 /* Need to copy into our local buffer */
1019 RtlMoveMemory(Argument, ResultPointer, ArgumentLength);
1020 }
1021 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1022 {
1023 ERR("Failed to copy result from user mode!\n");
1024 Status = _SEH2_GetExceptionCode();
1025 }
1026 _SEH2_END;
1027
1028 UserEnterCo();
1029
1030 RtlCopyMemory(pCs, &Common->Cs, sizeof(CHARSETINFO));
1031
1032 IntCbFreeMemory(Argument);
1033
1034 if (!NT_SUCCESS(Status))
1035 {
1036 ERR("GetCharsetInfo Failed!!\n");
1037 return FALSE;
1038 }
1039
1040 return TRUE;
1041 }
1042
1043 BOOL FASTCALL
1044 co_IntSetWndIcons(VOID)
1045 {
1046 NTSTATUS Status;
1047 ULONG ArgumentLength, ResultLength;
1048 PVOID Argument, ResultPointer;
1049 PSETWNDICONS_CALLBACK_ARGUMENTS Common;
1050
1051 ResultPointer = NULL;
1052 ResultLength = ArgumentLength = sizeof(SETWNDICONS_CALLBACK_ARGUMENTS);
1053
1054 Argument = IntCbAllocateMemory(ArgumentLength);
1055 if (NULL == Argument)
1056 {
1057 ERR("Set Window Icons callback failed: out of memory\n");
1058 return FALSE;
1059 }
1060 Common = (PSETWNDICONS_CALLBACK_ARGUMENTS) Argument;
1061
1062 UserLeaveCo();
1063
1064 Status = KeUserModeCallback(USER32_CALLBACK_SETWNDICONS,
1065 Argument,
1066 ArgumentLength,
1067 &ResultPointer,
1068 &ResultLength);
1069
1070
1071 UserEnterCo();
1072
1073 /* FIXME: Need to setup Registry System Cursor & Icons via Callbacks at init time! */
1074 RtlMoveMemory(Common, ResultPointer, ArgumentLength);
1075 gpsi->hIconSmWindows = Common->hIconSmWindows;
1076 gpsi->hIconWindows = Common->hIconWindows;
1077
1078 ERR("hIconSmWindows %p hIconWindows %p \n",gpsi->hIconSmWindows,gpsi->hIconWindows);
1079
1080 IntCbFreeMemory(Argument);
1081
1082 if (!NT_SUCCESS(Status))
1083 {
1084 ERR("Set Window Icons callback failed!\n");
1085 return FALSE;
1086 }
1087
1088 return TRUE;
1089 }
1090
1091 /* EOF */