reactos/subsystems/win32/win32k/ntuser/message.c

   1 /*
   2 * COPYRIGHT:        See COPYING in the top level directory
   3 * PROJECT:          ReactOS kernel
   4 * PURPOSE:          Messages
   5 * FILE:             subsystems/win32/win32k/ntuser/message.c
   6 * PROGRAMER:        Casper S. Hornstrup (chorns@users.sourceforge.net)
   7 * REVISION HISTORY:
   8 *       06-06-2001  CSH  Created
   9 */
  10
  11 /* INCLUDES ******************************************************************/
  12
  13 #include <win32k.h>
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 BOOLEAN NTAPI PsGetProcessExitProcessCalled(PEPROCESS Process);
  19
  20 #define PM_BADMSGFLAGS ~((QS_RAWINPUT << 16)|PM_QS_SENDMESSAGE|PM_QS_PAINT|PM_QS_POSTMESSAGE|PM_QS_INPUT|PM_NOYIELD|PM_REMOVE)
  21
  22 /* FUNCTIONS *****************************************************************/
  23
  24 NTSTATUS FASTCALL
  25 IntInitMessageImpl(VOID)
  26 {
  27     return STATUS_SUCCESS;
  28 }
  29
  30 NTSTATUS FASTCALL
  31 IntCleanupMessageImpl(VOID)
  32 {
  33     return STATUS_SUCCESS;
  34 }
  35
  36 /* From wine: */
  37 /* flag for messages that contain pointers */
  38 /* 32 messages per entry, messages 0..31 map to bits 0..31 */
  39
  40 #define SET(msg) (1 << ((msg) & 31))
  41
  42 static const unsigned int message_pointer_flags[] =
  43 {
  44     /* 0x00 - 0x1f */
  45     SET(WM_CREATE) | SET(WM_SETTEXT) | SET(WM_GETTEXT) |
  46     SET(WM_WININICHANGE) | SET(WM_DEVMODECHANGE),
  47     /* 0x20 - 0x3f */
  48     SET(WM_GETMINMAXINFO) | SET(WM_DRAWITEM) | SET(WM_MEASUREITEM) | SET(WM_DELETEITEM) |
  49     SET(WM_COMPAREITEM),
  50     /* 0x40 - 0x5f */
  51     SET(WM_WINDOWPOSCHANGING) | SET(WM_WINDOWPOSCHANGED) | SET(WM_COPYDATA) |
  52     SET(WM_COPYGLOBALDATA) | SET(WM_NOTIFY) | SET(WM_HELP),
  53     /* 0x60 - 0x7f */
  54     SET(WM_STYLECHANGING) | SET(WM_STYLECHANGED),
  55     /* 0x80 - 0x9f */
  56     SET(WM_NCCREATE) | SET(WM_NCCALCSIZE) | SET(WM_GETDLGCODE),
  57     /* 0xa0 - 0xbf */
  58     SET(EM_GETSEL) | SET(EM_GETRECT) | SET(EM_SETRECT) | SET(EM_SETRECTNP),
  59     /* 0xc0 - 0xdf */
  60     SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETTABSTOPS),
  61     /* 0xe0 - 0xff */
  62     SET(SBM_GETRANGE) | SET(SBM_SETSCROLLINFO) | SET(SBM_GETSCROLLINFO) | SET(SBM_GETSCROLLBARINFO),
  63     /* 0x100 - 0x11f */
  64     0,
  65     /* 0x120 - 0x13f */
  66     0,
  67     /* 0x140 - 0x15f */
  68     SET(CB_GETEDITSEL) | SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) |
  69     SET(CB_INSERTSTRING) | SET(CB_FINDSTRING) | SET(CB_SELECTSTRING) |
  70     SET(CB_GETDROPPEDCONTROLRECT) | SET(CB_FINDSTRINGEXACT),
  71     /* 0x160 - 0x17f */
  72     0,
  73     /* 0x180 - 0x19f */
  74     SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_SELECTSTRING) |
  75     SET(LB_DIR) | SET(LB_FINDSTRING) |
  76     SET(LB_GETSELITEMS) | SET(LB_SETTABSTOPS) | SET(LB_ADDFILE) | SET(LB_GETITEMRECT),
  77     /* 0x1a0 - 0x1bf */
  78     SET(LB_FINDSTRINGEXACT),
  79     /* 0x1c0 - 0x1df */
  80     0,
  81     /* 0x1e0 - 0x1ff */
  82     0,
  83     /* 0x200 - 0x21f */
  84     SET(WM_NEXTMENU) | SET(WM_SIZING) | SET(WM_MOVING) | SET(WM_DEVICECHANGE),
  85     /* 0x220 - 0x23f */
  86     SET(WM_MDICREATE) | SET(WM_MDIGETACTIVE) | SET(WM_DROPOBJECT) |
  87     SET(WM_QUERYDROPOBJECT) | SET(WM_DRAGLOOP) | SET(WM_DRAGSELECT) | SET(WM_DRAGMOVE),
  88     /* 0x240 - 0x25f */
  89     0,
  90     /* 0x260 - 0x27f */
  91     0,
  92     /* 0x280 - 0x29f */
  93     0,
  94     /* 0x2a0 - 0x2bf */
  95     0,
  96     /* 0x2c0 - 0x2df */
  97     0,
  98     /* 0x2e0 - 0x2ff */
  99     0,
 100     /* 0x300 - 0x31f */
 101     SET(WM_ASKCBFORMATNAME)
 102 };
 103
 104 /* check whether a given message type includes pointers */
 105 static inline int is_pointer_message( UINT message )
 106 {
 107     if (message >= 8*sizeof(message_pointer_flags)) return FALSE;
 108         return (message_pointer_flags[message / 32] & SET(message)) != 0;
 109 }
 110
 111 #define MMS_SIZE_WPARAM      -1
 112 #define MMS_SIZE_WPARAMWCHAR -2
 113 #define MMS_SIZE_LPARAMSZ    -3
 114 #define MMS_SIZE_SPECIAL     -4
 115 #define MMS_FLAG_READ        0x01
 116 #define MMS_FLAG_WRITE       0x02
 117 #define MMS_FLAG_READWRITE   (MMS_FLAG_READ | MMS_FLAG_WRITE)
 118 typedef struct tagMSGMEMORY
 119 {
 120     UINT Message;
 121     UINT Size;
 122     INT Flags;
 123 }
 124 MSGMEMORY, *PMSGMEMORY;
 125
 126 static MSGMEMORY MsgMemory[] =
 127 {
 128     { WM_CREATE, MMS_SIZE_SPECIAL, MMS_FLAG_READWRITE },
 129     { WM_DDE_ACK, sizeof(KMDDELPARAM), MMS_FLAG_READ },
 130     { WM_DDE_EXECUTE, MMS_SIZE_WPARAM, MMS_FLAG_READ },
 131     { WM_GETMINMAXINFO, sizeof(MINMAXINFO), MMS_FLAG_READWRITE },
 132     { WM_GETTEXT, MMS_SIZE_WPARAMWCHAR, MMS_FLAG_WRITE },
 133     { WM_NCCALCSIZE, MMS_SIZE_SPECIAL, MMS_FLAG_READWRITE },
 134     { WM_NCCREATE, MMS_SIZE_SPECIAL, MMS_FLAG_READWRITE },
 135     { WM_SETTEXT, MMS_SIZE_LPARAMSZ, MMS_FLAG_READ },
 136     { WM_STYLECHANGED, sizeof(STYLESTRUCT), MMS_FLAG_READ },
 137     { WM_STYLECHANGING, sizeof(STYLESTRUCT), MMS_FLAG_READWRITE },
 138     { WM_COPYDATA, MMS_SIZE_SPECIAL, MMS_FLAG_READ },
 139     { WM_COPYGLOBALDATA, MMS_SIZE_WPARAM, MMS_FLAG_READ },
 140     { WM_WINDOWPOSCHANGED, sizeof(WINDOWPOS), MMS_FLAG_READ },
 141     { WM_WINDOWPOSCHANGING, sizeof(WINDOWPOS), MMS_FLAG_READWRITE },
 142 };
 143
 144 static PMSGMEMORY FASTCALL
 145 FindMsgMemory(UINT Msg)
 146 {
 147     PMSGMEMORY MsgMemoryEntry;
 148
 149     /* See if this message type is present in the table */
 150     for (MsgMemoryEntry = MsgMemory;
 151     MsgMemoryEntry < MsgMemory + sizeof(MsgMemory) / sizeof(MSGMEMORY);
 152     MsgMemoryEntry++)
 153     {
 154         if (Msg == MsgMemoryEntry->Message)
 155         {
 156             return MsgMemoryEntry;
 157         }
 158     }
 159
 160     return NULL;
 161 }
 162
 163 static UINT FASTCALL
 164 MsgMemorySize(PMSGMEMORY MsgMemoryEntry, WPARAM wParam, LPARAM lParam)
 165 {
 166     CREATESTRUCTW *Cs;
 167     PUNICODE_STRING WindowName;
 168     PUNICODE_STRING ClassName;
 169     UINT Size = 0;
 170
 171     _SEH2_TRY
 172     {
 173         if (MMS_SIZE_WPARAM == MsgMemoryEntry->Size)
 174         {
 175             Size = (UINT)wParam;
 176         }
 177         else if (MMS_SIZE_WPARAMWCHAR == MsgMemoryEntry->Size)
 178         {
 179             Size = (UINT) (wParam * sizeof(WCHAR));
 180         }
 181         else if (MMS_SIZE_LPARAMSZ == MsgMemoryEntry->Size)
 182         {
 183             Size = (UINT) ((wcslen((PWSTR) lParam) + 1) * sizeof(WCHAR));
 184         }
 185         else if (MMS_SIZE_SPECIAL == MsgMemoryEntry->Size)
 186         {
 187             switch(MsgMemoryEntry->Message)
 188             {
 189             case WM_CREATE:
 190             case WM_NCCREATE:
 191                 Cs = (CREATESTRUCTW *) lParam;
 192                 WindowName = (PUNICODE_STRING) Cs->lpszName;
 193                 ClassName = (PUNICODE_STRING) Cs->lpszClass;
 194                 Size = sizeof(CREATESTRUCTW) + WindowName->Length + sizeof(WCHAR);
 195                 if (IS_ATOM(ClassName->Buffer))
 196                 {
 197                     Size += sizeof(WCHAR) + sizeof(ATOM);
 198                 }
 199                 else
 200                 {
 201                     Size += sizeof(WCHAR) + ClassName->Length + sizeof(WCHAR);
 202                 }
 203                 break;
 204
 205             case WM_NCCALCSIZE:
 206                 Size = wParam ? sizeof(NCCALCSIZE_PARAMS) + sizeof(WINDOWPOS) : sizeof(RECT);
 207                 break;
 208
 209             case WM_COPYDATA:
 210                 Size = sizeof(COPYDATASTRUCT) + ((PCOPYDATASTRUCT)lParam)->cbData;
 211                 break;
 212
 213             default:
 214                 ASSERT(FALSE);
 215                 Size = 0;
 216                 break;
 217             }
 218         }
 219         else
 220         {
 221             Size = MsgMemoryEntry->Size;
 222         }
 223     }
 224     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 225     {
 226         DPRINT1("Exception caught in MsgMemorySize()! Status: 0x%x\n", _SEH2_GetExceptionCode());
 227         Size = 0;
 228     }
 229     _SEH2_END;
 230     return Size;
 231 }
 232
 233 static NTSTATUS
 234 PackParam(LPARAM *lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolNeeded)
 235 {
 236     NCCALCSIZE_PARAMS *UnpackedNcCalcsize;
 237     NCCALCSIZE_PARAMS *PackedNcCalcsize;
 238     CREATESTRUCTW *UnpackedCs;
 239     CREATESTRUCTW *PackedCs;
 240     PLARGE_STRING WindowName;
 241     PUNICODE_STRING ClassName;
 242     POOL_TYPE PoolType;
 243     UINT Size;
 244     PCHAR CsData;
 245
 246     *lParamPacked = lParam;
 247
 248     if (NonPagedPoolNeeded)
 249         PoolType = NonPagedPool;
 250     else
 251         PoolType = PagedPool;
 252
 253     if (WM_NCCALCSIZE == Msg && wParam)
 254     {
 255
 256         UnpackedNcCalcsize = (NCCALCSIZE_PARAMS *) lParam;
 257         PackedNcCalcsize = ExAllocatePoolWithTag(PoolType,
 258         sizeof(NCCALCSIZE_PARAMS) + sizeof(WINDOWPOS),
 259         TAG_MSG);
 260
 261         if (NULL == PackedNcCalcsize)
 262         {
 263             DPRINT1("Not enough memory to pack lParam\n");
 264             return STATUS_NO_MEMORY;
 265         }
 266         RtlCopyMemory(PackedNcCalcsize, UnpackedNcCalcsize, sizeof(NCCALCSIZE_PARAMS));
 267         PackedNcCalcsize->lppos = (PWINDOWPOS) (PackedNcCalcsize + 1);
 268         RtlCopyMemory(PackedNcCalcsize->lppos, UnpackedNcCalcsize->lppos, sizeof(WINDOWPOS));
 269         *lParamPacked = (LPARAM) PackedNcCalcsize;
 270     }
 271     else if (WM_CREATE == Msg || WM_NCCREATE == Msg)
 272     {
 273         UnpackedCs = (CREATESTRUCTW *) lParam;
 274         WindowName = (PLARGE_STRING) UnpackedCs->lpszName;
 275         ClassName = (PUNICODE_STRING) UnpackedCs->lpszClass;
 276         Size = sizeof(CREATESTRUCTW) + WindowName->Length + sizeof(WCHAR);
 277         if (IS_ATOM(ClassName->Buffer))
 278         {
 279             Size += sizeof(WCHAR) + sizeof(ATOM);
 280         }
 281         else
 282         {
 283             Size += sizeof(WCHAR) + ClassName->Length + sizeof(WCHAR);
 284         }
 285         PackedCs = ExAllocatePoolWithTag(PoolType, Size, TAG_MSG);
 286         if (NULL == PackedCs)
 287         {
 288             DPRINT1("Not enough memory to pack lParam\n");
 289             return STATUS_NO_MEMORY;
 290         }
 291         RtlCopyMemory(PackedCs, UnpackedCs, sizeof(CREATESTRUCTW));
 292         CsData = (PCHAR) (PackedCs + 1);
 293         PackedCs->lpszName = (LPCWSTR) (CsData - (PCHAR) PackedCs);
 294         RtlCopyMemory(CsData, WindowName->Buffer, WindowName->Length);
 295         CsData += WindowName->Length;
 296         *((WCHAR *) CsData) = L'\0';
 297         CsData += sizeof(WCHAR);
 298         PackedCs->lpszClass = (LPCWSTR) (CsData - (PCHAR) PackedCs);
 299         if (IS_ATOM(ClassName->Buffer))
 300         {
 301             *((WCHAR *) CsData) = L'A';
 302             CsData += sizeof(WCHAR);
 303             *((ATOM *) CsData) = (ATOM)(DWORD_PTR) ClassName->Buffer;
 304             CsData += sizeof(ATOM);
 305         }
 306         else
 307         {
 308             *((WCHAR *) CsData) = L'S';
 309             CsData += sizeof(WCHAR);
 310             RtlCopyMemory(CsData, ClassName->Buffer, ClassName->Length);
 311             CsData += ClassName->Length;
 312             *((WCHAR *) CsData) = L'\0';
 313             CsData += sizeof(WCHAR);
 314         }
 315         ASSERT(CsData == (PCHAR) PackedCs + Size);
 316         *lParamPacked = (LPARAM) PackedCs;
 317     }
 318     else if (PoolType == NonPagedPool)
 319     {
 320         PMSGMEMORY MsgMemoryEntry;
 321         PVOID PackedData;
 322         SIZE_T size;
 323
 324         MsgMemoryEntry = FindMsgMemory(Msg);
 325
 326         if ((!MsgMemoryEntry) || (MsgMemoryEntry->Size < 0))
 327         {
 328             /* Keep previous behavior */
 329             return STATUS_SUCCESS;
 330         }
 331         size = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
 332         if (!size)
 333         {
 334            DPRINT1("No size for lParamPacked\n");
 335            return STATUS_SUCCESS;
 336         }
 337         PackedData = ExAllocatePoolWithTag(NonPagedPool, size, TAG_MSG);
 338         RtlCopyMemory(PackedData, (PVOID)lParam, MsgMemorySize(MsgMemoryEntry, wParam, lParam));
 339         *lParamPacked = (LPARAM)PackedData;
 340     }
 341
 342     return STATUS_SUCCESS;
 343 }
 344
 345 static NTSTATUS
 346 UnpackParam(LPARAM lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolUsed)
 347 {
 348     NCCALCSIZE_PARAMS *UnpackedParams;
 349     NCCALCSIZE_PARAMS *PackedParams;
 350     PWINDOWPOS UnpackedWindowPos;
 351
 352     if (lParamPacked == lParam)
 353     {
 354         return STATUS_SUCCESS;
 355     }
 356
 357     if (WM_NCCALCSIZE == Msg && wParam)
 358     {
 359         PackedParams = (NCCALCSIZE_PARAMS *) lParamPacked;
 360         UnpackedParams = (NCCALCSIZE_PARAMS *) lParam;
 361         UnpackedWindowPos = UnpackedParams->lppos;
 362         RtlCopyMemory(UnpackedParams, PackedParams, sizeof(NCCALCSIZE_PARAMS));
 363         UnpackedParams->lppos = UnpackedWindowPos;
 364         RtlCopyMemory(UnpackedWindowPos, PackedParams + 1, sizeof(WINDOWPOS));
 365         ExFreePool((PVOID) lParamPacked);
 366
 367         return STATUS_SUCCESS;
 368     }
 369     else if (WM_CREATE == Msg || WM_NCCREATE == Msg)
 370     {
 371         ExFreePool((PVOID) lParamPacked);
 372
 373         return STATUS_SUCCESS;
 374     }
 375     else if (NonPagedPoolUsed)
 376     {
 377         PMSGMEMORY MsgMemoryEntry;
 378         MsgMemoryEntry = FindMsgMemory(Msg);
 379         if (MsgMemoryEntry->Size < 0)
 380         {
 381             /* Keep previous behavior */
 382             return STATUS_INVALID_PARAMETER;
 383         }
 384
 385         if (MsgMemory->Flags == MMS_FLAG_READWRITE)
 386         {
 387             //RtlCopyMemory((PVOID)lParam, (PVOID)lParamPacked, MsgMemory->Size);
 388         }
 389         ExFreePool((PVOID) lParamPacked);
 390         return STATUS_SUCCESS;
 391     }
 392
 393     ASSERT(FALSE);
 394
 395     return STATUS_INVALID_PARAMETER;
 396 }
 397
 398 static NTSTATUS FASTCALL
 399 CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEntry)
 400 {
 401     NTSTATUS Status;
 402
 403     PVOID KernelMem;
 404     UINT Size;
 405
 406     *KernelModeMsg = *UserModeMsg;
 407
 408     /* See if this message type is present in the table */
 409     if (NULL == MsgMemoryEntry)
 410     {
 411         /* Not present, no copying needed */
 412         return STATUS_SUCCESS;
 413     }
 414
 415     /* Determine required size */
 416     Size = MsgMemorySize(MsgMemoryEntry, UserModeMsg->wParam, UserModeMsg->lParam);
 417
 418     if (0 != Size)
 419     {
 420         /* Allocate kernel mem */
 421         KernelMem = ExAllocatePoolWithTag(PagedPool, Size, TAG_MSG);
 422         if (NULL == KernelMem)
 423         {
 424             DPRINT1("Not enough memory to copy message to kernel mem\n");
 425             return STATUS_NO_MEMORY;
 426         }
 427         KernelModeMsg->lParam = (LPARAM) KernelMem;
 428
 429         /* Copy data if required */
 430         if (0 != (MsgMemoryEntry->Flags & MMS_FLAG_READ))
 431         {
 432             Status = MmCopyFromCaller(KernelMem, (PVOID) UserModeMsg->lParam, Size);
 433             if (! NT_SUCCESS(Status))
 434             {
 435                 DPRINT1("Failed to copy message to kernel: invalid usermode buffer\n");
 436                 ExFreePoolWithTag(KernelMem, TAG_MSG);
 437                 return Status;
 438             }
 439         }
 440         else
 441         {
 442             /* Make sure we don't pass any secrets to usermode */
 443             RtlZeroMemory(KernelMem, Size);
 444         }
 445     }
 446     else
 447     {
 448         KernelModeMsg->lParam = 0;
 449     }
 450
 451     return STATUS_SUCCESS;
 452 }
 453
 454 static NTSTATUS FASTCALL
 455 CopyMsgToUserMem(MSG *UserModeMsg, MSG *KernelModeMsg)
 456 {
 457     NTSTATUS Status;
 458     PMSGMEMORY MsgMemoryEntry;
 459     UINT Size;
 460
 461     /* See if this message type is present in the table */
 462     MsgMemoryEntry = FindMsgMemory(UserModeMsg->message);
 463     if (NULL == MsgMemoryEntry)
 464     {
 465         /* Not present, no copying needed */
 466         return STATUS_SUCCESS;
 467     }
 468
 469     /* Determine required size */
 470     Size = MsgMemorySize(MsgMemoryEntry, UserModeMsg->wParam, UserModeMsg->lParam);
 471
 472     if (0 != Size)
 473     {
 474         /* Copy data if required */
 475         if (0 != (MsgMemoryEntry->Flags & MMS_FLAG_WRITE))
 476         {
 477             Status = MmCopyToCaller((PVOID) UserModeMsg->lParam, (PVOID) KernelModeMsg->lParam, Size);
 478             if (! NT_SUCCESS(Status))
 479             {
 480                 DPRINT1("Failed to copy message from kernel: invalid usermode buffer\n");
 481                 ExFreePool((PVOID) KernelModeMsg->lParam);
 482                 return Status;
 483             }
 484         }
 485
 486         ExFreePool((PVOID) KernelModeMsg->lParam);
 487     }
 488
 489     return STATUS_SUCCESS;
 490 }
 491
 492 //
 493 // Wakeup any thread/process waiting on idle input.
 494 //
 495 VOID FASTCALL
 496 IdlePing(VOID)
 497 {
 498    PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
 499    PUSER_MESSAGE_QUEUE ForegroundQueue;
 500    PTHREADINFO pti, ptiForeground = NULL;
 501
 502    ForegroundQueue = IntGetFocusMessageQueue();
 503
 504    if (ForegroundQueue)
 505       ptiForeground = ForegroundQueue->Thread->Tcb.Win32Thread;
 506
 507    pti = PsGetCurrentThreadWin32Thread();
 508
 509    if ( pti )
 510    {
 511       pti->pClientInfo->cSpins = 0; // Reset spins.
 512
 513       if ( pti->pDeskInfo && pti == ptiForeground )
 514       {
 515          if ( pti->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) ||
 516               pti->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) )
 517          {
 518             co_HOOK_CallHooks(WH_FOREGROUNDIDLE,HC_ACTION,0,0);
 519          }
 520       }
 521    }
 522
 523    DPRINT("IdlePing ppi 0x%x\n",ppi);
 524    if ( ppi && ppi->InputIdleEvent )
 525    {
 526       DPRINT("InputIdleEvent\n");
 527       KeSetEvent( ppi->InputIdleEvent, IO_NO_INCREMENT, FALSE);
 528    }
 529 }
 530
 531 VOID FASTCALL
 532 IdlePong(VOID)
 533 {
 534    PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
 535
 536    DPRINT("IdlePong ppi 0x%x\n",ppi);
 537    if ( ppi && ppi->InputIdleEvent )
 538    {
 539       KeClearEvent(ppi->InputIdleEvent);
 540    }
 541 }
 542
 543 UINT FASTCALL
 544 GetWakeMask(UINT first, UINT last )
 545 {
 546     UINT mask = QS_POSTMESSAGE | QS_SENDMESSAGE;  /* Always selected */
 547
 548     if (first || last)
 549     {
 550         if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
 551         if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
 552              ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
 553         if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
 554         if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
 555         if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
 556     }
 557     else mask = QS_ALLINPUT;
 558
 559     return mask;
 560 }
 561
 562 static VOID FASTCALL
 563 IntCallWndProc( PWND Window, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 564 {
 565     BOOL SameThread = FALSE;
 566     CWPSTRUCT CWP;
 567
 568     if (Window->head.pti == ((PTHREADINFO)PsGetCurrentThreadWin32Thread()))
 569         SameThread = TRUE;
 570
 571     CWP.hwnd    = hWnd;
 572     CWP.message = Msg;
 573     CWP.wParam  = wParam;
 574     CWP.lParam  = lParam;
 575     co_HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, SameThread, (LPARAM)&CWP );
 576 }
 577
 578 static VOID FASTCALL
 579 IntCallWndProcRet ( PWND Window, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *uResult)
 580 {
 581     BOOL SameThread = FALSE;
 582     CWPRETSTRUCT CWPR;
 583
 584     if (Window->head.pti == ((PTHREADINFO)PsGetCurrentThreadWin32Thread()))
 585         SameThread = TRUE;
 586
 587     CWPR.hwnd    = hWnd;
 588     CWPR.message = Msg;
 589     CWPR.wParam  = wParam;
 590     CWPR.lParam  = lParam;
 591     CWPR.lResult = *uResult;
 592     co_HOOK_CallHooks( WH_CALLWNDPROCRET, HC_ACTION, SameThread, (LPARAM)&CWPR );
 593 }
 594
 595 LRESULT FASTCALL
 596 IntDispatchMessage(PMSG pMsg)
 597 {
 598     LARGE_INTEGER TickCount;
 599     LONG Time;
 600     LRESULT retval = 0;
 601     PTHREADINFO pti;
 602     PWND Window = NULL;
 603
 604     if (pMsg->hwnd)
 605     {
 606         Window = UserGetWindowObject(pMsg->hwnd);
 607         if (!Window) return 0;
 608     }
 609
 610     pti = PsGetCurrentThreadWin32Thread();
 611
 612     if ( Window->head.pti != pti)
 613     {
 614        EngSetLastError( ERROR_MESSAGE_SYNC_ONLY );
 615        return 0;
 616     }
 617
 618     if (((pMsg->message == WM_SYSTIMER) ||
 619          (pMsg->message == WM_TIMER)) &&
 620          (pMsg->lParam) )
 621     {
 622         if (pMsg->message == WM_TIMER)
 623         {
 624             if (ValidateTimerCallback(pti,pMsg->lParam))
 625             {
 626                 KeQueryTickCount(&TickCount);
 627                 Time = MsqCalculateMessageTime(&TickCount);
 628                 retval = co_IntCallWindowProc((WNDPROC)pMsg->lParam,
 629                                               TRUE,
 630                                               pMsg->hwnd,
 631                                               WM_TIMER,
 632                                               pMsg->wParam,
 633                                               (LPARAM)Time,
 634                                               0);
 635             }
 636             return retval;
 637         }
 638         else
 639         {
 640             PTIMER pTimer = FindSystemTimer(pMsg);
 641             if (pTimer && pTimer->pfn)
 642             {
 643                 KeQueryTickCount(&TickCount);
 644                 Time = MsqCalculateMessageTime(&TickCount);
 645                 pTimer->pfn(pMsg->hwnd, WM_SYSTIMER, (UINT)pMsg->wParam, Time);
 646             }
 647             return 0;
 648         }
 649     }
 650     // Need a window!
 651     if ( !Window ) return 0;
 652
 653     /* Since we are doing a callback on the same thread right away, there is
 654        no need to copy the lparam to kernel mode and then back to usermode.
 655        We just pretend it isn't a pointer */
 656
 657     retval = co_IntCallWindowProc( Window->lpfnWndProc,
 658                                    !Window->Unicode,
 659                                    pMsg->hwnd,
 660                                    pMsg->message,
 661                                    pMsg->wParam,
 662                                    pMsg->lParam,
 663                                    0);
 664
 665     if (pMsg->message == WM_PAINT)
 666     {
 667         /* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
 668         HRGN hrgn = IntSysCreateRectRgn( 0, 0, 0, 0 );
 669         co_UserGetUpdateRgn( Window, hrgn, TRUE );
 670         GreDeleteObject(hrgn);
 671     }
 672
 673     return retval;
 674 }
 675
 676 /*
 677  * Internal version of PeekMessage() doing all the work
 678  */
 679 BOOL FASTCALL
 680 co_IntPeekMessage( PMSG Msg,
 681                    PWND Window,
 682                    UINT MsgFilterMin,
 683                    UINT MsgFilterMax,
 684                    UINT RemoveMsg,
 685                    BOOL bGMSG )
 686 {
 687     PTHREADINFO pti;
 688     PCLIENTINFO pci;
 689     LARGE_INTEGER LargeTickCount;
 690     PUSER_MESSAGE_QUEUE ThreadQueue;
 691     BOOL RemoveMessages;
 692     UINT ProcessMask;
 693     BOOL Hit = FALSE;
 694
 695     pti = PsGetCurrentThreadWin32Thread();
 696     ThreadQueue = pti->MessageQueue;
 697     pci = pti->pClientInfo;
 698
 699     RemoveMessages = RemoveMsg & PM_REMOVE;
 700     ProcessMask = HIWORD(RemoveMsg);
 701
 702  /* Hint, "If wMsgFilterMin and wMsgFilterMax are both zero, PeekMessage returns
 703     all available messages (that is, no range filtering is performed)".        */
 704     if (!ProcessMask) ProcessMask = (QS_ALLPOSTMESSAGE|QS_ALLINPUT);
 705
 706     IdlePong();
 707
 708     do
 709     {
 710         KeQueryTickCount(&LargeTickCount);
 711         ThreadQueue->LastMsgRead = LargeTickCount.u.LowPart;
 712         pti->pcti->tickLastMsgChecked = LargeTickCount.u.LowPart;
 713
 714         /* Dispatch sent messages here. */
 715         while ( co_MsqDispatchOneSentMessage(ThreadQueue) )
 716         {
 717            /* if some PM_QS* flags were specified, only handle sent messages from now on */
 718            if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE; // wine does this; ProcessMask = QS_SENDMESSAGE;
 719         }
 720         if (Hit) return FALSE;
 721
 722         /* Clear changed bits so we can wait on them if we don't find a message */
 723         if (ProcessMask & QS_POSTMESSAGE)
 724         {
 725            pti->pcti->fsChangeBits &= ~(QS_POSTMESSAGE | QS_HOTKEY | QS_TIMER);
 726            if (MsgFilterMin == 0 && MsgFilterMax == 0) // wine hack does this; ~0U)
 727            {
 728               pti->pcti->fsChangeBits &= ~QS_ALLPOSTMESSAGE;
 729            }
 730         }
 731
 732         if (ProcessMask & QS_INPUT)
 733         {
 734            pti->pcti->fsChangeBits &= ~QS_INPUT;
 735         }
 736
 737         /* Now check for normal messages. */
 738         if (( (ProcessMask & QS_POSTMESSAGE) ||
 739               (ProcessMask & QS_HOTKEY) ) &&
 740             MsqPeekMessage( ThreadQueue,
 741                             RemoveMessages,
 742                             Window,
 743                             MsgFilterMin,
 744                             MsgFilterMax,
 745                             ProcessMask,
 746                             Msg ))
 747         {
 748                return TRUE;
 749         }
 750
 751         /* Now look for a quit message. */
 752         if (ThreadQueue->QuitPosted)
 753         {
 754             /* According to the PSDK, WM_QUIT messages are always returned, regardless
 755                of the filter specified */
 756             Msg->hwnd = NULL;
 757             Msg->message = WM_QUIT;
 758             Msg->wParam = ThreadQueue->QuitExitCode;
 759             Msg->lParam = 0;
 760             if (RemoveMessages)
 761             {
 762                 ThreadQueue->QuitPosted = FALSE;
 763                 ClearMsgBitsMask(ThreadQueue, QS_POSTMESSAGE);
 764                 pti->pcti->fsWakeBits &= ~QS_ALLPOSTMESSAGE;
 765                 pti->pcti->fsChangeBits &= ~QS_ALLPOSTMESSAGE;
 766             }
 767             return TRUE;
 768         }
 769
 770         /* Check for hardware events. */
 771         if ((ProcessMask & QS_MOUSE) &&
 772             co_MsqPeekMouseMove( ThreadQueue,
 773                                  RemoveMessages,
 774                                  Window,
 775                                  MsgFilterMin,
 776                                  MsgFilterMax,
 777                                  Msg ))
 778         {
 779             return TRUE;
 780         }
 781
 782         if ((ProcessMask & QS_INPUT) &&
 783             co_MsqPeekHardwareMessage( ThreadQueue,
 784                                        RemoveMessages,
 785                                        Window,
 786                                        MsgFilterMin,
 787                                        MsgFilterMax,
 788                                        ProcessMask,
 789                                        Msg))
 790         {
 791             return TRUE;
 792         }
 793
 794         /* Check for sent messages again. */
 795         while ( co_MsqDispatchOneSentMessage(ThreadQueue) )
 796         {
 797            if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE;
 798         }
 799         if (Hit) return FALSE;
 800
 801         /* Check for paint messages. */
 802         if ((ProcessMask & QS_PAINT) &&
 803             pti->cPaintsReady &&
 804             IntGetPaintMessage( Window,
 805                                 MsgFilterMin,
 806                                 MsgFilterMax,
 807                                 pti,
 808                                 Msg,
 809                                 RemoveMessages))
 810         {
 811             return TRUE;
 812         }
 813
 814        /* This is correct, check for the current threads timers waiting to be
 815           posted to this threads message queue. If any we loop again.
 816         */
 817         if ((ProcessMask & QS_TIMER) &&
 818             PostTimerMessages(Window))
 819         {
 820             continue;
 821         }
 822
 823         return FALSE;
 824     }
 825     while (TRUE);
 826
 827     return TRUE;
 828 }
 829
 830 static BOOL FASTCALL
 831 co_IntWaitMessage( PWND Window,
 832                    UINT MsgFilterMin,
 833                    UINT MsgFilterMax )
 834 {
 835     PTHREADINFO pti;
 836     PUSER_MESSAGE_QUEUE ThreadQueue;
 837     NTSTATUS Status = STATUS_SUCCESS;
 838     MSG Msg;
 839
 840     pti = PsGetCurrentThreadWin32Thread();
 841     ThreadQueue = pti->MessageQueue;
 842
 843     do
 844     {
 845         if ( co_IntPeekMessage( &Msg,       // Dont reenter!
 846                                  Window,
 847                                  MsgFilterMin,
 848                                  MsgFilterMax,
 849                                  MAKELONG( PM_NOREMOVE, GetWakeMask( MsgFilterMin, MsgFilterMax)),
 850                                  TRUE ) )   // act like GetMessage.
 851         {
 852             return TRUE;
 853         }
 854
 855         /* Nothing found. Wait for new messages. */
 856         Status = co_MsqWaitForNewMessages( ThreadQueue,
 857                                            Window,
 858                                            MsgFilterMin,
 859                                            MsgFilterMax);
 860         if (!NT_SUCCESS(Status))
 861         {
 862             SetLastNtError(Status);
 863             DPRINT1("Exit co_IntWaitMessage on error!\n");
 864             return FALSE;
 865         }
 866         if (Status == STATUS_USER_APC || Status == STATUS_TIMEOUT)
 867         {
 868            return FALSE;
 869         }
 870     }
 871     while ( TRUE );
 872
 873     return FALSE;
 874 }
 875
 876 BOOL FASTCALL
 877 co_IntGetPeekMessage( PMSG pMsg,
 878                       HWND hWnd,
 879                       UINT MsgFilterMin,
 880                       UINT MsgFilterMax,
 881                       UINT RemoveMsg,
 882                       BOOL bGMSG )
 883 {
 884     PWND Window;
 885     PTHREADINFO pti;
 886     BOOL Present = FALSE;
 887     NTSTATUS Status;
 888
 889     if ( hWnd == HWND_TOPMOST || hWnd == HWND_BROADCAST )
 890         hWnd = HWND_BOTTOM;
 891
 892     /* Validate input */
 893     if (hWnd && hWnd != HWND_BOTTOM)
 894     {
 895         if (!(Window = UserGetWindowObject(hWnd)))
 896         {
 897             if (bGMSG)
 898                 return -1;
 899             else
 900                 return FALSE;
 901         }
 902     }
 903     else
 904     {
 905         Window = (PWND)hWnd;
 906     }
 907
 908     if (MsgFilterMax < MsgFilterMin)
 909     {
 910         MsgFilterMin = 0;
 911         MsgFilterMax = 0;
 912     }
 913
 914     if (bGMSG)
 915     {
 916        RemoveMsg |= ((GetWakeMask( MsgFilterMin, MsgFilterMax ))<< 16);
 917     }
 918
 919     pti = PsGetCurrentThreadWin32Thread();
 920     pti->pClientInfo->cSpins++; // Bump up the spin count.
 921
 922     do
 923     {
 924         Present = co_IntPeekMessage( pMsg,
 925                                      Window,
 926                                      MsgFilterMin,
 927                                      MsgFilterMax,
 928                                      RemoveMsg,
 929                                      bGMSG );
 930         if (Present)
 931         {
 932            /* GetMessage or PostMessage must never get messages that contain pointers */
 933            ASSERT(FindMsgMemory(pMsg->message) == NULL);
 934
 935            if (pMsg->message != WM_PAINT && pMsg->message != WM_QUIT)
 936            {
 937               pti->timeLast = pMsg->time;
 938               pti->ptLast   = pMsg->pt;
 939            }
 940
 941            // The WH_GETMESSAGE hook enables an application to monitor messages about to
 942            // be returned by the GetMessage or PeekMessage function.
 943
 944            co_HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, RemoveMsg & PM_REMOVE, (LPARAM)pMsg);
 945
 946            if ( bGMSG ) break;
 947         }
 948
 949         if ( bGMSG )
 950         {
 951             Status = co_MsqWaitForNewMessages( pti->MessageQueue,
 952                                                Window,
 953                                                MsgFilterMin,
 954                                                MsgFilterMax);
 955            if ( !NT_SUCCESS(Status) ||
 956                 Status == STATUS_USER_APC ||
 957                 Status == STATUS_TIMEOUT )
 958            {
 959               Present = -1;
 960               break;
 961            }
 962         }
 963         else
 964         {
 965            if (!(RemoveMsg & PM_NOYIELD))
 966            {
 967               IdlePing();
 968               // Yield this thread!
 969               UserLeave();
 970               ZwYieldExecution();
 971               UserEnterExclusive();
 972               // Fall through to exit.
 973               IdlePong();
 974            }
 975            break;
 976         }
 977     }
 978     while( bGMSG && !Present );
 979
 980     // Been spinning, time to swap vinyl...
 981     if (pti->pClientInfo->cSpins >= 100)
 982     {
 983        // Clear the spin cycle to fix the mix.
 984        pti->pClientInfo->cSpins = 0;
 985        //if (!(pti->TIF_flags & TIF_SPINNING)) FIXME need to swap vinyl..
 986     }
 987     return Present;
 988 }
 989
 990 BOOL FASTCALL
 991 UserPostThreadMessage( DWORD idThread,
 992                        UINT Msg,
 993                        WPARAM wParam,
 994                        LPARAM lParam )
 995 {
 996     MSG Message;
 997     PETHREAD peThread;
 998     PTHREADINFO pThread;
 999     LARGE_INTEGER LargeTickCount;
1000     NTSTATUS Status;
1001
1002     if (is_pointer_message(Msg))
1003     {
1004         EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
1005         return FALSE;
1006     }
1007
1008     Status = PsLookupThreadByThreadId((HANDLE)idThread,&peThread);
1009
1010     if( Status == STATUS_SUCCESS )
1011     {
1012         pThread = (PTHREADINFO)peThread->Tcb.Win32Thread;
1013         if( !pThread ||
1014             !pThread->MessageQueue ||
1015             (pThread->TIF_flags & TIF_INCLEANUP))
1016         {
1017             ObDereferenceObject( peThread );
1018             return FALSE;
1019         }
1020
1021         Message.hwnd = NULL;
1022         Message.message = Msg;
1023         Message.wParam = wParam;
1024         Message.lParam = lParam;
1025         Message.pt = gpsi->ptCursor;
1026
1027         KeQueryTickCount(&LargeTickCount);
1028         Message.time = MsqCalculateMessageTime(&LargeTickCount);
1029         MsqPostMessage(pThread->MessageQueue, &Message, FALSE, QS_POSTMESSAGE);
1030         ObDereferenceObject( peThread );
1031         return TRUE;
1032     }
1033     else
1034     {
1035         SetLastNtError( Status );
1036     }
1037     return FALSE;
1038 }
1039
1040 BOOL FASTCALL
1041 UserPostMessage( HWND Wnd,
1042                  UINT Msg,
1043                  WPARAM wParam,
1044                  LPARAM lParam )
1045 {
1046     PTHREADINFO pti;
1047     MSG Message, KernelModeMsg;
1048     LARGE_INTEGER LargeTickCount;
1049
1050     Message.hwnd = Wnd;
1051     Message.message = Msg;
1052     Message.wParam = wParam;
1053     Message.lParam = lParam;
1054     Message.pt = gpsi->ptCursor;
1055     KeQueryTickCount(&LargeTickCount);
1056     Message.time = MsqCalculateMessageTime(&LargeTickCount);
1057
1058     if (is_pointer_message(Message.message))
1059     {
1060         EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
1061         return FALSE;
1062     }
1063
1064     if( Msg >= WM_DDE_FIRST && Msg <= WM_DDE_LAST )
1065     {
1066         NTSTATUS Status;
1067         PMSGMEMORY MsgMemoryEntry;
1068
1069         MsgMemoryEntry = FindMsgMemory(Message.message);
1070
1071         Status = CopyMsgToKernelMem(&KernelModeMsg, &Message, MsgMemoryEntry);
1072         if (! NT_SUCCESS(Status))
1073         {
1074             EngSetLastError(ERROR_INVALID_PARAMETER);
1075             return FALSE;
1076         }
1077         co_IntSendMessageNoWait(KernelModeMsg.hwnd,
1078                                 KernelModeMsg.message,
1079                                 KernelModeMsg.wParam,
1080                                 KernelModeMsg.lParam);
1081
1082         if (MsgMemoryEntry && KernelModeMsg.lParam)
1083             ExFreePool((PVOID) KernelModeMsg.lParam);
1084
1085         return TRUE;
1086     }
1087
1088     if (!Wnd)
1089     {
1090         return UserPostThreadMessage( PtrToInt(PsGetCurrentThreadId()),
1091                                       Msg,
1092                                       wParam,
1093                                       lParam);
1094     }
1095     if (Wnd == HWND_BROADCAST)
1096     {
1097         HWND *List;
1098         PWND DesktopWindow;
1099         ULONG i;
1100
1101         DesktopWindow = UserGetWindowObject(IntGetDesktopWindow());
1102         List = IntWinListChildren(DesktopWindow);
1103
1104         if (List != NULL)
1105         {
1106             UserPostMessage(DesktopWindow->head.h, Msg, wParam, lParam);
1107             for (i = 0; List[i]; i++)
1108             {
1109                 UserPostMessage(List[i], Msg, wParam, lParam);
1110             }
1111             ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
1112         }
1113     }
1114     else
1115     {
1116         PWND Window;
1117
1118         Window = UserGetWindowObject(Wnd);
1119         if ( !Window )
1120         {
1121             return FALSE;
1122         }
1123
1124         pti = Window->head.pti;
1125         if ( pti->TIF_flags & TIF_INCLEANUP )
1126         {
1127             DPRINT1("Attempted to post message to window 0x%x when the thread is in cleanup!\n", Wnd);
1128             return FALSE;
1129         }
1130
1131         if ( Window->state & WNDS_DESTROYED )
1132         {
1133             DPRINT1("Attempted to post message to window 0x%x that is being destroyed!\n", Wnd);
1134             /* FIXME - last error code? */
1135             return FALSE;
1136         }
1137
1138         if (WM_QUIT == Msg)
1139         {
1140             MsqPostQuitMessage(Window->head.pti->MessageQueue, wParam);
1141         }
1142         else
1143         {
1144             MsqPostMessage(Window->head.pti->MessageQueue, &Message, FALSE, QS_POSTMESSAGE);
1145         }
1146     }
1147     return TRUE;
1148 }
1149
1150
1151 LRESULT FASTCALL
1152 co_IntSendMessage( HWND hWnd,
1153                    UINT Msg,
1154                    WPARAM wParam,
1155                    LPARAM lParam )
1156 {
1157     ULONG_PTR Result = 0;
1158     if(co_IntSendMessageTimeout(hWnd, Msg, wParam, lParam, SMTO_NORMAL, 0, &Result))
1159     {
1160         return (LRESULT)Result;
1161     }
1162     return 0;
1163 }
1164
1165 static LRESULT FASTCALL
1166 co_IntSendMessageTimeoutSingle( HWND hWnd,
1167                                 UINT Msg,
1168                                 WPARAM wParam,
1169                                 LPARAM lParam,
1170                                 UINT uFlags,
1171                                 UINT uTimeout,
1172                                 ULONG_PTR *uResult )
1173 {
1174     NTSTATUS Status;
1175     PWND Window = NULL;
1176     PMSGMEMORY MsgMemoryEntry;
1177     INT lParamBufferSize;
1178     LPARAM lParamPacked;
1179     PTHREADINFO Win32Thread;
1180     ULONG_PTR Result = 0;
1181     DECLARE_RETURN(LRESULT);
1182     USER_REFERENCE_ENTRY Ref;
1183
1184     if (!(Window = UserGetWindowObject(hWnd)))
1185     {
1186         RETURN( FALSE);
1187     }
1188
1189     UserRefObjectCo(Window, &Ref);
1190
1191     Win32Thread = PsGetCurrentThreadWin32Thread();
1192
1193     IntCallWndProc( Window, hWnd, Msg, wParam, lParam);
1194
1195     if ( NULL != Win32Thread &&
1196          Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
1197     {
1198         if (Win32Thread->TIF_flags & TIF_INCLEANUP)
1199         {
1200             /* Never send messages to exiting threads */
1201             RETURN( FALSE);
1202         }
1203
1204         /* See if this message type is present in the table */
1205         MsgMemoryEntry = FindMsgMemory(Msg);
1206         if (NULL == MsgMemoryEntry)
1207         {
1208             lParamBufferSize = -1;
1209         }
1210         else
1211         {
1212             lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
1213         }
1214
1215         if (! NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, FALSE)))
1216         {
1217             DPRINT1("Failed to pack message parameters\n");
1218             RETURN( FALSE);
1219         }
1220
1221         Result = (ULONG_PTR)co_IntCallWindowProc( Window->lpfnWndProc,
1222                                                   !Window->Unicode,
1223                                                   hWnd,
1224                                                   Msg,
1225                                                   wParam,
1226                                                   lParamPacked,
1227                                                   lParamBufferSize );
1228         if(uResult)
1229         {
1230             *uResult = Result;
1231         }
1232
1233         IntCallWndProcRet( Window, hWnd, Msg, wParam, lParam, (LRESULT *)uResult);
1234
1235         if (! NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
1236         {
1237             DPRINT1("Failed to unpack message parameters\n");
1238             RETURN( TRUE);
1239         }
1240
1241         RETURN( TRUE);
1242     }
1243
1244     if (uFlags & SMTO_ABORTIFHUNG && MsqIsHung(Window->head.pti->MessageQueue))
1245     {
1246         // FIXME - Set window hung and add to a list.
1247         /* FIXME - Set a LastError? */
1248         RETURN( FALSE);
1249     }
1250
1251     if (Window->state & WNDS_DESTROYED)
1252     {
1253         /* FIXME - last error? */
1254         DPRINT1("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
1255         RETURN( FALSE);
1256     }
1257
1258     do
1259     {
1260         Status = co_MsqSendMessage( Window->head.pti->MessageQueue,
1261                                     hWnd,
1262                                     Msg,
1263                                     wParam,
1264                                     lParam,
1265                                     uTimeout,
1266                                     (uFlags & SMTO_BLOCK),
1267                                     MSQ_NORMAL,
1268                                     uResult );
1269     }
1270     while ((STATUS_TIMEOUT == Status) &&
1271            (uFlags & SMTO_NOTIMEOUTIFNOTHUNG) &&
1272            !MsqIsHung(Window->head.pti->MessageQueue)); // FIXME - Set window hung and add to a list.
1273
1274     IntCallWndProcRet( Window, hWnd, Msg, wParam, lParam, (LRESULT *)uResult);
1275
1276     if (STATUS_TIMEOUT == Status)
1277     {
1278 /*
1279     MSDN says:
1280     Microsoft Windows 2000: If GetLastError returns zero, then the function
1281     timed out.
1282     XP+ : If the function fails or times out, the return value is zero.
1283     To get extended error information, call GetLastError. If GetLastError
1284     returns ERROR_TIMEOUT, then the function timed out.
1285 */
1286         EngSetLastError(ERROR_TIMEOUT);
1287         RETURN( FALSE);
1288     }
1289     else if (! NT_SUCCESS(Status))
1290     {
1291         SetLastNtError(Status);
1292         RETURN( FALSE);
1293     }
1294
1295     RETURN( TRUE);
1296
1297 CLEANUP:
1298     if (Window) UserDerefObjectCo(Window);
1299     END_CLEANUP;
1300 }
1301
1302 LRESULT FASTCALL
1303 co_IntSendMessageTimeout( HWND hWnd,
1304                           UINT Msg,
1305                           WPARAM wParam,
1306                           LPARAM lParam,
1307                           UINT uFlags,
1308                           UINT uTimeout,
1309                           ULONG_PTR *uResult )
1310 {
1311     PWND DesktopWindow;
1312     HWND *Children;
1313     HWND *Child;
1314
1315     if (HWND_BROADCAST != hWnd)
1316     {
1317         return co_IntSendMessageTimeoutSingle(hWnd, Msg, wParam, lParam, uFlags, uTimeout, uResult);
1318     }
1319
1320     DesktopWindow = UserGetWindowObject(IntGetDesktopWindow());
1321     if (NULL == DesktopWindow)
1322     {
1323         EngSetLastError(ERROR_INTERNAL_ERROR);
1324         return 0;
1325     }
1326
1327     /* Send message to the desktop window too! */
1328     co_IntSendMessageTimeoutSingle(DesktopWindow->head.h, Msg, wParam, lParam, uFlags, uTimeout, uResult);
1329
1330     Children = IntWinListChildren(DesktopWindow);
1331     if (NULL == Children)
1332     {
1333         return 0;
1334     }
1335
1336     for (Child = Children; NULL != *Child; Child++)
1337     {
1338         co_IntSendMessageTimeoutSingle(*Child, Msg, wParam, lParam, uFlags, uTimeout, uResult);
1339     }
1340
1341     ExFreePool(Children);
1342
1343     return (LRESULT) TRUE;
1344 }
1345
1346 LRESULT FASTCALL
1347 co_IntSendMessageNoWait(HWND hWnd,
1348                         UINT Msg,
1349                         WPARAM wParam,
1350                         LPARAM lParam)
1351 {
1352     ULONG_PTR Result = 0;
1353     co_IntSendMessageWithCallBack(hWnd,
1354                                   Msg,
1355                                   wParam,
1356                                   lParam,
1357                                   NULL,
1358                                   0,
1359                                   &Result);
1360     return Result;
1361 }
1362 /* MSDN:
1363    If you send a message in the range below WM_USER to the asynchronous message
1364    functions (PostMessage, SendNotifyMessage, and SendMessageCallback), its
1365    message parameters cannot include pointers. Otherwise, the operation will fail.
1366    The functions will return before the receiving thread has had a chance to
1367    process the message and the sender will free the memory before it is used.
1368 */
1369 LRESULT FASTCALL
1370 co_IntSendMessageWithCallBack( HWND hWnd,
1371                               UINT Msg,
1372                               WPARAM wParam,
1373                               LPARAM lParam,
1374                               SENDASYNCPROC CompletionCallback,
1375                               ULONG_PTR CompletionCallbackContext,
1376                               ULONG_PTR *uResult)
1377 {
1378     ULONG_PTR Result;
1379     PWND Window = NULL;
1380     PMSGMEMORY MsgMemoryEntry;
1381     INT lParamBufferSize;
1382     LPARAM lParamPacked;
1383     PTHREADINFO Win32Thread;
1384     DECLARE_RETURN(LRESULT);
1385     USER_REFERENCE_ENTRY Ref;
1386     PUSER_SENT_MESSAGE Message;
1387
1388     if (!(Window = UserGetWindowObject(hWnd)))
1389     {
1390         RETURN(FALSE);
1391     }
1392
1393     UserRefObjectCo(Window, &Ref);
1394
1395     if (Window->state & WNDS_DESTROYED)
1396     {
1397         /* FIXME - last error? */
1398         DPRINT1("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
1399         RETURN(FALSE);
1400     }
1401
1402     Win32Thread = PsGetCurrentThreadWin32Thread();
1403
1404     if (Win32Thread == NULL)
1405     {
1406         RETURN(FALSE);
1407     }
1408
1409     /* See if this message type is present in the table */
1410     MsgMemoryEntry = FindMsgMemory(Msg);
1411     if (NULL == MsgMemoryEntry)
1412     {
1413         lParamBufferSize = -1;
1414     }
1415     else
1416     {
1417         lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
1418     }
1419
1420     if (! NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, Window->head.pti->MessageQueue != Win32Thread->MessageQueue)))
1421     {
1422         DPRINT1("Failed to pack message parameters\n");
1423         RETURN( FALSE);
1424     }
1425
1426     /* If it can be sent now, then send it. */
1427     if (Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
1428     {
1429         if (Win32Thread->TIF_flags & TIF_INCLEANUP)
1430         {
1431             UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE);
1432             /* Never send messages to exiting threads */
1433             RETURN(FALSE);
1434         }
1435
1436         IntCallWndProc( Window, hWnd, Msg, wParam, lParam);
1437
1438         Result = (ULONG_PTR)co_IntCallWindowProc( Window->lpfnWndProc,
1439                                                   !Window->Unicode,
1440                                                   hWnd,
1441                                                   Msg,
1442                                                   wParam,
1443                                                   lParamPacked,
1444                                                   lParamBufferSize );
1445         if(uResult)
1446         {
1447             *uResult = Result;
1448         }
1449
1450         IntCallWndProcRet( Window, hWnd, Msg, wParam, lParam, (LRESULT *)uResult);
1451
1452         if (CompletionCallback)
1453         {
1454             co_IntCallSentMessageCallback(CompletionCallback,
1455                                           hWnd,
1456                                           Msg,
1457                                           CompletionCallbackContext,
1458                                           Result);
1459         }
1460     }
1461
1462
1463
1464     if (Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
1465     {
1466         if (! NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
1467         {
1468             DPRINT1("Failed to unpack message parameters\n");
1469         }
1470         RETURN(TRUE);
1471     }
1472
1473     if(!(Message = ExAllocatePoolWithTag(NonPagedPool, sizeof(USER_SENT_MESSAGE), TAG_USRMSG)))
1474     {
1475         DPRINT1("MsqSendMessage(): Not enough memory to allocate a message");
1476         RETURN( FALSE);
1477     }
1478
1479     IntReferenceMessageQueue(Window->head.pti->MessageQueue);
1480     /* Take reference on this MessageQueue if its a callback. It will be released
1481        when message is processed or removed from target hwnd MessageQueue */
1482     if (CompletionCallback)
1483        IntReferenceMessageQueue(Win32Thread->MessageQueue);
1484
1485     Message->Msg.hwnd = hWnd;
1486     Message->Msg.message = Msg;
1487     Message->Msg.wParam = wParam;
1488     Message->Msg.lParam = lParamPacked;
1489     Message->CompletionEvent = NULL;
1490     Message->Result = 0;
1491     Message->lResult = 0;
1492     Message->QS_Flags = 0;
1493     Message->SenderQueue = NULL; // mjmartin, you are right! This is null.
1494     Message->CallBackSenderQueue = Win32Thread->MessageQueue;
1495     Message->DispatchingListEntry.Flink = NULL;
1496     Message->CompletionCallback = CompletionCallback;
1497     Message->CompletionCallbackContext = CompletionCallbackContext;
1498     Message->HookMessage = MSQ_NORMAL;
1499     Message->HasPackedLParam = (lParamBufferSize > 0);
1500     Message->QS_Flags = QS_SENDMESSAGE;
1501
1502     InsertTailList(&Window->head.pti->MessageQueue->SentMessagesListHead, &Message->ListEntry);
1503     MsqWakeQueue(Window->head.pti->MessageQueue, QS_SENDMESSAGE, TRUE);
1504     IntDereferenceMessageQueue(Window->head.pti->MessageQueue);
1505
1506     RETURN(TRUE);
1507
1508 CLEANUP:
1509     if (Window) UserDerefObjectCo(Window);
1510     END_CLEANUP;
1511 }
1512
1513 /* This function posts a message if the destination's message queue belongs to
1514 another thread, otherwise it sends the message. It does not support broadcast
1515 messages! */
1516 LRESULT FASTCALL
1517 co_IntPostOrSendMessage( HWND hWnd,
1518                          UINT Msg,
1519                          WPARAM wParam,
1520                          LPARAM lParam )
1521 {
1522     ULONG_PTR Result;
1523     PTHREADINFO pti;
1524     PWND Window;
1525
1526     if ( hWnd == HWND_BROADCAST )
1527     {
1528         return 0;
1529     }
1530
1531     if(!(Window = UserGetWindowObject(hWnd)))
1532     {
1533         return 0;
1534     }
1535
1536     pti = PsGetCurrentThreadWin32Thread();
1537
1538     if ( Window->head.pti->MessageQueue != pti->MessageQueue &&
1539          FindMsgMemory(Msg) == 0 )
1540     {
1541         Result = UserPostMessage(hWnd, Msg, wParam, lParam);
1542     }
1543     else
1544     {
1545         if ( !co_IntSendMessageTimeoutSingle(hWnd, Msg, wParam, lParam, SMTO_NORMAL, 0, &Result) )
1546         {
1547             Result = 0;
1548         }
1549     }
1550
1551     return (LRESULT)Result;
1552 }
1553
1554 LRESULT FASTCALL
1555 co_IntDoSendMessage( HWND hWnd,
1556                      UINT Msg,
1557                      WPARAM wParam,
1558                      LPARAM lParam,
1559                      PDOSENDMESSAGE dsm)
1560 {
1561     PTHREADINFO pti;
1562     LRESULT Result = TRUE;
1563     NTSTATUS Status;
1564     PWND Window = NULL;
1565     MSG UserModeMsg;
1566     MSG KernelModeMsg;
1567     PMSGMEMORY MsgMemoryEntry;
1568
1569     if (HWND_BROADCAST != hWnd)
1570     {
1571         Window = UserGetWindowObject(hWnd);
1572         if ( !Window )
1573         {
1574             return 0;
1575         }
1576     }
1577
1578     /* Check for an exiting window. */
1579     if (Window && Window->state & WNDS_DESTROYED)
1580     {
1581         DPRINT1("co_IntDoSendMessage Window Exiting!\n");
1582     }
1583
1584     /* See if the current thread can handle the message */
1585     pti = PsGetCurrentThreadWin32Thread();
1586
1587     UserModeMsg.hwnd = hWnd;
1588     UserModeMsg.message = Msg;
1589     UserModeMsg.wParam = wParam;
1590     UserModeMsg.lParam = lParam;
1591     MsgMemoryEntry = FindMsgMemory(UserModeMsg.message);
1592
1593     Status = CopyMsgToKernelMem(&KernelModeMsg, &UserModeMsg, MsgMemoryEntry);
1594     if (! NT_SUCCESS(Status))
1595     {
1596        EngSetLastError(ERROR_INVALID_PARAMETER);
1597        return (dsm ? 0 : -1);
1598     }
1599
1600     if (!dsm)
1601     {
1602        Result = co_IntSendMessage( KernelModeMsg.hwnd,
1603                                    KernelModeMsg.message,
1604                                    KernelModeMsg.wParam,
1605                                    KernelModeMsg.lParam );
1606     }
1607     else
1608     {
1609        Result = co_IntSendMessageTimeout( KernelModeMsg.hwnd,
1610                                           KernelModeMsg.message,
1611                                           KernelModeMsg.wParam,
1612                                           KernelModeMsg.lParam,
1613                                           dsm->uFlags,
1614                                           dsm->uTimeout,
1615                                          &dsm->Result );
1616     }
1617
1618     Status = CopyMsgToUserMem(&UserModeMsg, &KernelModeMsg);
1619     if (! NT_SUCCESS(Status))
1620     {
1621        EngSetLastError(ERROR_INVALID_PARAMETER);
1622        return(dsm ? 0 : -1);
1623     }
1624
1625     return (LRESULT)Result;
1626 }
1627
1628 BOOL FASTCALL
1629 UserSendNotifyMessage( HWND hWnd,
1630                        UINT Msg,
1631                        WPARAM wParam,
1632                        LPARAM lParam )
1633 {
1634     BOOL Ret = TRUE;
1635
1636     if (is_pointer_message(Msg))
1637     {
1638         EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
1639         return FALSE;
1640     }
1641
1642     // Basicly the same as IntPostOrSendMessage
1643     if (hWnd == HWND_BROADCAST) //Handle Broadcast
1644     {
1645         HWND *List;
1646         PWND DesktopWindow;
1647         ULONG i;
1648
1649         DesktopWindow = UserGetWindowObject(IntGetDesktopWindow());
1650         List = IntWinListChildren(DesktopWindow);
1651
1652         if (List != NULL)
1653         {
1654             UserSendNotifyMessage(DesktopWindow->head.h, Msg, wParam, lParam);
1655             for (i = 0; List[i]; i++)
1656             {
1657                 Ret = UserSendNotifyMessage(List[i], Msg, wParam, lParam);
1658             }
1659             ExFreePool(List);
1660         }
1661     }
1662     else
1663     {
1664         ULONG_PTR lResult = 0;
1665         Ret = co_IntSendMessageWithCallBack( hWnd,
1666                                              Msg,
1667                                              wParam,
1668                                              lParam,
1669                                              NULL,
1670                                              0,
1671                                             &lResult);
1672     }
1673     return Ret;
1674 }
1675
1676
1677 DWORD APIENTRY
1678 IntGetQueueStatus(DWORD Changes)
1679 {
1680     PTHREADINFO pti;
1681     PUSER_MESSAGE_QUEUE Queue;
1682     DWORD Result;
1683
1684     pti = PsGetCurrentThreadWin32Thread();
1685     Queue = pti->MessageQueue;
1686 // wine:
1687     Changes &= (QS_ALLINPUT|QS_ALLPOSTMESSAGE|QS_SMRESULT);
1688
1689     /* High word, types of messages currently in the queue.
1690        Low  word, types of messages that have been added to the queue and that
1691                   are still in the queue
1692      */
1693     Result = MAKELONG(pti->pcti->fsChangeBits & Changes, pti->pcti->fsWakeBits & Changes);
1694
1695     pti->pcti->fsChangeBits &= ~Changes;
1696
1697     return Result;
1698 }
1699
1700 BOOL APIENTRY
1701 IntInitMessagePumpHook()
1702 {
1703     PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
1704
1705     if (pti->pcti)
1706     {
1707         pti->pcti->dwcPumpHook++;
1708         return TRUE;
1709     }
1710     return FALSE;
1711 }
1712
1713 BOOL APIENTRY
1714 IntUninitMessagePumpHook()
1715 {
1716     PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
1717
1718     if (pti->pcti)
1719     {
1720         if (pti->pcti->dwcPumpHook <= 0)
1721         {
1722             return FALSE;
1723         }
1724         pti->pcti->dwcPumpHook--;
1725         return TRUE;
1726     }
1727     return FALSE;
1728 }
1729
1730 /** Functions ******************************************************************/
1731
1732 BOOL
1733 APIENTRY
1734 NtUserDragDetect(
1735    HWND hWnd,
1736    POINT pt) // Just like the User call.
1737 {
1738     MSG msg;
1739     RECT rect;
1740     WORD wDragWidth, wDragHeight;
1741     DECLARE_RETURN(BOOL);
1742
1743     DPRINT("Enter NtUserDragDetect(%x)\n", hWnd);
1744     UserEnterExclusive();
1745
1746     wDragWidth = UserGetSystemMetrics(SM_CXDRAG);
1747     wDragHeight= UserGetSystemMetrics(SM_CYDRAG);
1748
1749     rect.left = pt.x - wDragWidth;
1750     rect.right = pt.x + wDragWidth;
1751
1752     rect.top = pt.y - wDragHeight;
1753     rect.bottom = pt.y + wDragHeight;
1754
1755     co_UserSetCapture(hWnd);
1756
1757     for (;;)
1758     {
1759         while (co_IntGetPeekMessage( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE, FALSE ) ||
1760                co_IntGetPeekMessage( &msg, 0, WM_QUEUESYNC,  WM_QUEUESYNC, PM_REMOVE, FALSE ) ||
1761                co_IntGetPeekMessage( &msg, 0, WM_KEYFIRST,   WM_KEYLAST,   PM_REMOVE, FALSE ) )
1762         {
1763             if ( msg.message == WM_LBUTTONUP )
1764             {
1765                 co_UserSetCapture(NULL);
1766                 RETURN( FALSE);
1767             }
1768             if ( msg.message == WM_MOUSEMOVE )
1769             {
1770                 POINT tmp;
1771                 tmp.x = (short)LOWORD(msg.lParam);
1772                 tmp.y = (short)HIWORD(msg.lParam);
1773                 if( !IntPtInRect( &rect, tmp ) )
1774                 {
1775                     co_UserSetCapture(NULL);
1776                     RETURN( TRUE);
1777                 }
1778             }
1779             if ( msg.message == WM_KEYDOWN )
1780             {
1781                 if ( msg.wParam == VK_ESCAPE )
1782                 {
1783                    co_UserSetCapture(NULL);
1784                    RETURN( TRUE);
1785                 }
1786             }
1787             if ( msg.message == WM_QUEUESYNC )
1788             {
1789                 co_HOOK_CallHooks( WH_CBT, HCBT_QS, 0, 0 );
1790             }
1791         }
1792         co_IntWaitMessage(NULL, 0, 0);
1793     }
1794     RETURN( FALSE);
1795
1796 CLEANUP:
1797    DPRINT("Leave NtUserDragDetect, ret=%i\n",_ret_);
1798    UserLeave();
1799    END_CLEANUP;
1800 }
1801
1802 BOOL APIENTRY
1803 NtUserPostMessage(HWND hWnd,
1804                   UINT Msg,
1805                   WPARAM wParam,
1806                   LPARAM lParam)
1807 {
1808     BOOL ret;
1809
1810     UserEnterExclusive();
1811
1812     ret = UserPostMessage(hWnd, Msg, wParam, lParam);
1813
1814     UserLeave();
1815
1816     return ret;
1817 }
1818
1819 BOOL APIENTRY
1820 NtUserPostThreadMessage(DWORD idThread,
1821                         UINT Msg,
1822                         WPARAM wParam,
1823                         LPARAM lParam)
1824 {
1825     BOOL ret;
1826
1827     UserEnterExclusive();
1828
1829     ret = UserPostThreadMessage( idThread, Msg, wParam, lParam);
1830
1831     UserLeave();
1832
1833     return ret;
1834 }
1835
1836 BOOL APIENTRY
1837 NtUserWaitMessage(VOID)
1838 {
1839     BOOL ret;
1840
1841     UserEnterExclusive();
1842     DPRINT("NtUserWaitMessage Enter\n");
1843     ret = co_IntWaitMessage(NULL, 0, 0);
1844     DPRINT("NtUserWaitMessage Leave\n");
1845     UserLeave();
1846
1847     return ret;
1848 }
1849
1850 BOOL APIENTRY
1851 NtUserGetMessage(PMSG pMsg,
1852                   HWND hWnd,
1853                   UINT MsgFilterMin,
1854                   UINT MsgFilterMax )
1855 {
1856     MSG Msg;
1857     BOOL Ret;
1858
1859     if ( (MsgFilterMin|MsgFilterMax) & ~WM_MAXIMUM )
1860     {
1861         EngSetLastError(ERROR_INVALID_PARAMETER);
1862         return FALSE;
1863     }
1864
1865     UserEnterExclusive();
1866
1867     RtlZeroMemory(&Msg, sizeof(MSG));
1868
1869     Ret = co_IntGetPeekMessage(&Msg, hWnd, MsgFilterMin, MsgFilterMax, PM_REMOVE, TRUE);
1870
1871     UserLeave();
1872
1873     if (Ret == TRUE)
1874     {
1875         _SEH2_TRY
1876         {
1877             ProbeForWrite(pMsg, sizeof(MSG), 1);
1878             RtlCopyMemory(pMsg, &Msg, sizeof(MSG));
1879         }
1880         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1881         {
1882             SetLastNtError(_SEH2_GetExceptionCode());
1883             Ret = FALSE;
1884         }
1885         _SEH2_END;
1886     }
1887
1888     if ((INT)Ret != -1)
1889        Ret = Ret ? (WM_QUIT != pMsg->message) : FALSE;
1890
1891     return Ret;
1892 }
1893
1894 BOOL APIENTRY
1895 NtUserPeekMessage( PMSG pMsg,
1896                   HWND hWnd,
1897                   UINT MsgFilterMin,
1898                   UINT MsgFilterMax,
1899                   UINT RemoveMsg)
1900 {
1901     MSG Msg;
1902     BOOL Ret;
1903
1904     if ( RemoveMsg & PM_BADMSGFLAGS )
1905     {
1906         EngSetLastError(ERROR_INVALID_FLAGS);
1907         return FALSE;
1908     }
1909
1910     UserEnterExclusive();
1911
1912     RtlZeroMemory(&Msg, sizeof(MSG));
1913
1914     Ret = co_IntGetPeekMessage(&Msg, hWnd, MsgFilterMin, MsgFilterMax, RemoveMsg, FALSE);
1915
1916     UserLeave();
1917
1918     if (Ret)
1919     {
1920         _SEH2_TRY
1921         {
1922             ProbeForWrite(pMsg, sizeof(MSG), 1);
1923             RtlCopyMemory(pMsg, &Msg, sizeof(MSG));
1924         }
1925         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1926         {
1927             SetLastNtError(_SEH2_GetExceptionCode());
1928             Ret = FALSE;
1929         }
1930         _SEH2_END;
1931     }
1932
1933     return Ret;
1934 }
1935
1936 BOOL APIENTRY
1937 NtUserCallMsgFilter( LPMSG lpmsg, INT code)
1938 {
1939     BOOL Ret = FALSE;
1940     MSG Msg;
1941
1942     _SEH2_TRY
1943     {
1944         ProbeForRead(lpmsg, sizeof(MSG), 1);
1945         RtlCopyMemory( &Msg, lpmsg, sizeof(MSG));
1946     }
1947     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1948     {
1949         _SEH2_YIELD(return FALSE);
1950     }
1951     _SEH2_END;
1952
1953     UserEnterExclusive();
1954
1955     if ( co_HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)&Msg))
1956     {
1957         Ret = TRUE;
1958     }
1959     else
1960     {
1961         Ret = co_HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)&Msg);
1962     }
1963
1964     UserLeave();
1965
1966     _SEH2_TRY
1967     {
1968         ProbeForWrite(lpmsg, sizeof(MSG), 1);
1969         RtlCopyMemory(lpmsg, &Msg, sizeof(MSG));
1970     }
1971     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1972     {
1973         Ret = FALSE;
1974     }
1975     _SEH2_END;
1976
1977     return Ret;
1978 }
1979
1980 LRESULT APIENTRY
1981 NtUserDispatchMessage(PMSG UnsafeMsgInfo)
1982 {
1983     LRESULT Res = 0;
1984     MSG SafeMsg;
1985
1986     _SEH2_TRY
1987     {
1988         ProbeForRead(UnsafeMsgInfo, sizeof(MSG), 1);
1989         RtlCopyMemory(&SafeMsg, UnsafeMsgInfo, sizeof(MSG));
1990     }
1991     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1992     {
1993         SetLastNtError(_SEH2_GetExceptionCode());
1994         _SEH2_YIELD(return FALSE);
1995     }
1996     _SEH2_END;
1997
1998     UserEnterExclusive();
1999
2000     Res = IntDispatchMessage(&SafeMsg);
2001
2002     UserLeave();
2003     return Res;
2004 }
2005
2006
2007 BOOL APIENTRY
2008 NtUserTranslateMessage(LPMSG lpMsg, UINT flags)
2009 {
2010     MSG SafeMsg;
2011     BOOL Ret;
2012
2013     _SEH2_TRY
2014     {
2015         ProbeForRead(lpMsg, sizeof(MSG), 1);
2016         RtlCopyMemory(&SafeMsg, lpMsg, sizeof(MSG));
2017     }
2018     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2019     {
2020         SetLastNtError(_SEH2_GetExceptionCode());
2021         _SEH2_YIELD(return FALSE);
2022     }
2023     _SEH2_END;
2024
2025     UserEnterExclusive();
2026
2027     Ret = IntTranslateKbdMessage(&SafeMsg, flags);
2028
2029     UserLeave();
2030
2031     return Ret;
2032 }
2033
2034 BOOL APIENTRY
2035 NtUserMessageCall( HWND hWnd,
2036                    UINT Msg,
2037                    WPARAM wParam,
2038                    LPARAM lParam,
2039                    ULONG_PTR ResultInfo,
2040                    DWORD dwType, // fnID?
2041                    BOOL Ansi)
2042 {
2043     LRESULT lResult = 0;
2044     BOOL Ret = FALSE;
2045     PWND Window = NULL;
2046     USER_REFERENCE_ENTRY Ref;
2047
2048     UserEnterExclusive();
2049
2050     switch(dwType)
2051     {
2052     case FNID_DEFWINDOWPROC:
2053         /* Validate input */
2054         if (hWnd && (hWnd != INVALID_HANDLE_VALUE))
2055         {
2056            Window = UserGetWindowObject(hWnd);
2057            if (!Window)
2058            {
2059                UserLeave();
2060                return FALSE;
2061            }
2062         }
2063         UserRefObjectCo(Window, &Ref);
2064         lResult = IntDefWindowProc(Window, Msg, wParam, lParam, Ansi);
2065         Ret = TRUE;
2066         UserDerefObjectCo(Window);
2067         break;
2068     case FNID_SENDNOTIFYMESSAGE:
2069         Ret = UserSendNotifyMessage(hWnd, Msg, wParam, lParam);
2070         break;
2071     case FNID_BROADCASTSYSTEMMESSAGE:
2072         {
2073             BROADCASTPARM parm;
2074             DWORD_PTR RetVal = 0;
2075
2076             if (ResultInfo)
2077             {
2078                 _SEH2_TRY
2079                 {
2080                     ProbeForWrite((PVOID)ResultInfo, sizeof(BROADCASTPARM), 1);
2081                     RtlCopyMemory(&parm, (PVOID)ResultInfo, sizeof(BROADCASTPARM));
2082                 }
2083                 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2084                 {
2085                     _SEH2_YIELD(break);
2086                 }
2087                 _SEH2_END;
2088             }
2089             else
2090                 break;
2091
2092             if ( parm.recipients & BSM_ALLDESKTOPS ||
2093                     parm.recipients == BSM_ALLCOMPONENTS )
2094             {
2095             }
2096             else if (parm.recipients & BSM_APPLICATIONS)
2097             {
2098                 if (parm.flags & BSF_QUERY)
2099                 {
2100                     if (parm.flags & BSF_FORCEIFHUNG || parm.flags & BSF_NOHANG)
2101                     {
2102                         co_IntSendMessageTimeout( HWND_BROADCAST,
2103                                                   Msg,
2104                                                   wParam,
2105                                                   lParam,
2106                                                   SMTO_ABORTIFHUNG,
2107                                                   2000,
2108                                                  &RetVal);
2109                     }
2110                     else if (parm.flags & BSF_NOTIMEOUTIFNOTHUNG)
2111                     {
2112                         co_IntSendMessageTimeout( HWND_BROADCAST,
2113                                                   Msg,
2114                                                   wParam,
2115                                                   lParam,
2116                                                   SMTO_NOTIMEOUTIFNOTHUNG,
2117                                                   2000,
2118                                                  &RetVal);
2119                     }
2120                     else
2121                     {
2122                         co_IntSendMessageTimeout( HWND_BROADCAST,
2123                                                   Msg,
2124                                                   wParam,
2125                                                   lParam,
2126                                                   SMTO_NORMAL,
2127                                                   2000,
2128                                                  &RetVal);
2129                     }
2130                     Ret = RetVal;
2131                 }
2132                 else if (parm.flags & BSF_POSTMESSAGE)
2133                 {
2134                     Ret = UserPostMessage(HWND_BROADCAST, Msg, wParam, lParam);
2135                 }
2136                 else //Everything else,,,, if ( parm.flags & BSF_SENDNOTIFYMESSAGE)
2137                 {
2138                     Ret = UserSendNotifyMessage(HWND_BROADCAST, Msg, wParam, lParam);
2139                 }
2140             }
2141         }
2142         break;
2143     case FNID_SENDMESSAGECALLBACK:
2144         {
2145             CALL_BACK_INFO CallBackInfo;
2146             ULONG_PTR uResult;
2147
2148             _SEH2_TRY
2149             {
2150                 ProbeForRead((PVOID)ResultInfo, sizeof(CALL_BACK_INFO), 1);
2151                 RtlCopyMemory(&CallBackInfo, (PVOID)ResultInfo, sizeof(CALL_BACK_INFO));
2152             }
2153             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2154             {
2155                 _SEH2_YIELD(break);
2156             }
2157             _SEH2_END;
2158
2159             if (is_pointer_message(Msg))
2160             {
2161                EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
2162                break;
2163             }
2164
2165             if (!(Ret = co_IntSendMessageWithCallBack(hWnd, Msg, wParam, lParam,
2166                         CallBackInfo.CallBack, CallBackInfo.Context, &uResult)))
2167             {
2168                 DPRINT1("Callback failure!\n");
2169             }
2170         }
2171         break;
2172     case FNID_SENDMESSAGE:
2173         {
2174             Ret = co_IntDoSendMessage(hWnd, Msg, wParam, lParam, 0);
2175
2176             if (ResultInfo)
2177             {
2178                 _SEH2_TRY
2179                 {
2180                     ProbeForWrite((PVOID)ResultInfo, sizeof(ULONG_PTR), 1);
2181                     RtlCopyMemory((PVOID)ResultInfo, &Ret, sizeof(ULONG_PTR));
2182                 }
2183                 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2184                 {
2185                     Ret = FALSE;
2186                     _SEH2_YIELD(break);
2187                 }
2188                 _SEH2_END;
2189             }
2190             break;
2191         }
2192     case FNID_SENDMESSAGETIMEOUT:
2193         {
2194             DOSENDMESSAGE dsm, *pdsm = (PDOSENDMESSAGE)ResultInfo;
2195             if (ResultInfo)
2196             {
2197                 _SEH2_TRY
2198                 {
2199                     ProbeForRead(pdsm, sizeof(DOSENDMESSAGE), 1);
2200                     RtlCopyMemory(&dsm, pdsm, sizeof(DOSENDMESSAGE));
2201                 }
2202                 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2203                 {
2204                     _SEH2_YIELD(break);
2205                 }
2206                 _SEH2_END;
2207             }
2208
2209             Ret = co_IntDoSendMessage( hWnd, Msg, wParam, lParam, &dsm );
2210
2211             if (pdsm)
2212             {
2213                 _SEH2_TRY
2214                 {
2215                     ProbeForWrite(pdsm, sizeof(DOSENDMESSAGE), 1);
2216                     RtlCopyMemory(pdsm, &dsm, sizeof(DOSENDMESSAGE));
2217                 }
2218                 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2219                 {
2220                     Ret = FALSE;
2221                     _SEH2_YIELD(break);
2222                 }
2223                 _SEH2_END;
2224             }
2225             break;
2226         }
2227         // CallNextHook bypass.
2228     case FNID_CALLWNDPROC:
2229     case FNID_CALLWNDPROCRET:
2230         {
2231             PTHREADINFO pti;
2232             PCLIENTINFO ClientInfo;
2233             PHOOK NextObj, Hook;
2234
2235             pti = GetW32ThreadInfo();
2236
2237             Hook = pti->sphkCurrent;
2238
2239             if (!Hook) break;
2240
2241             NextObj = Hook->phkNext;
2242             ClientInfo = pti->pClientInfo;
2243             _SEH2_TRY
2244             {
2245                 ClientInfo->phkCurrent = NextObj;
2246             }
2247             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2248             {
2249                 ClientInfo = NULL;
2250             }
2251             _SEH2_END;
2252
2253             if (!ClientInfo || !NextObj) break;
2254
2255             NextObj->phkNext = IntGetNextHook(NextObj);
2256
2257             if ( Hook->HookId == WH_CALLWNDPROC)
2258             {
2259                 CWPSTRUCT CWP;
2260                 CWP.hwnd    = hWnd;
2261                 CWP.message = Msg;
2262                 CWP.wParam  = wParam;
2263                 CWP.lParam  = lParam;
2264                 DPRINT("WH_CALLWNDPROC: Hook %x NextHook %x\n", Hook, NextObj );
2265
2266                 lResult = co_IntCallHookProc( Hook->HookId,
2267                                               HC_ACTION,
2268                                               ((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
2269                                               (LPARAM)&CWP,
2270                                               Hook->Proc,
2271                                               Hook->Ansi,
2272                                               &Hook->ModuleName);
2273             }
2274             else
2275             {
2276                 CWPRETSTRUCT CWPR;
2277                 CWPR.hwnd    = hWnd;
2278                 CWPR.message = Msg;
2279                 CWPR.wParam  = wParam;
2280                 CWPR.lParam  = lParam;
2281                 CWPR.lResult = ClientInfo->dwHookData;
2282
2283                 lResult = co_IntCallHookProc( Hook->HookId,
2284                                               HC_ACTION,
2285                                               ((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
2286                                               (LPARAM)&CWPR,
2287                                               Hook->Proc,
2288                                               Hook->Ansi,
2289                                               &Hook->ModuleName);
2290             }
2291         }
2292         break;
2293     }
2294
2295     switch(dwType)
2296     {
2297     case FNID_DEFWINDOWPROC:
2298     case FNID_CALLWNDPROC:
2299     case FNID_CALLWNDPROCRET:
2300         if (ResultInfo)
2301         {
2302             _SEH2_TRY
2303             {
2304                 ProbeForWrite((PVOID)ResultInfo, sizeof(LRESULT), 1);
2305                 RtlCopyMemory((PVOID)ResultInfo, &lResult, sizeof(LRESULT));
2306             }
2307             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2308             {
2309                 Ret = FALSE;
2310             }
2311             _SEH2_END;
2312         }
2313         break;
2314     default:
2315         break;
2316     }
2317
2318     UserLeave();
2319
2320     return Ret;
2321 }
2322
2323 #define INFINITE 0xFFFFFFFF
2324 #define WAIT_FAILED ((DWORD)0xFFFFFFFF)
2325
2326 DWORD
2327 APIENTRY
2328 NtUserWaitForInputIdle( IN HANDLE hProcess,
2329                         IN DWORD dwMilliseconds,
2330                         IN BOOL Unknown2)
2331 {
2332     PEPROCESS Process;
2333     PPROCESSINFO W32Process;
2334     PTHREADINFO pti;
2335     NTSTATUS Status;
2336     HANDLE Handles[3];
2337     LARGE_INTEGER Timeout;
2338
2339     UserEnterExclusive();
2340
2341     Status = ObReferenceObjectByHandle(hProcess,
2342                                        PROCESS_QUERY_INFORMATION,
2343                                        PsProcessType,
2344                                        UserMode,
2345                                        (PVOID*)&Process,
2346                                        NULL);
2347
2348     if (!NT_SUCCESS(Status))
2349     {
2350         UserLeave();
2351         SetLastNtError(Status);
2352         return WAIT_FAILED;
2353     }
2354
2355     pti = PsGetCurrentThreadWin32Thread();
2356
2357     W32Process = (PPROCESSINFO)Process->Win32Process;
2358
2359     if ( PsGetProcessExitProcessCalled(Process) ||
2360          !W32Process ||
2361          pti->ppi == W32Process)
2362     {
2363         ObDereferenceObject(Process);
2364         UserLeave();
2365         EngSetLastError(ERROR_INVALID_PARAMETER);
2366         return WAIT_FAILED;
2367     }
2368
2369     Handles[0] = Process;
2370     Handles[1] = W32Process->InputIdleEvent;
2371     Handles[2] = pti->MessageQueue->NewMessages; // pEventQueueServer; IntMsqSetWakeMask returns hEventQueueClient
2372
2373     if (!Handles[1])
2374     {
2375         ObDereferenceObject(Process);
2376         UserLeave();
2377         return STATUS_SUCCESS;  /* no event to wait on */
2378     }
2379
2380     if (dwMilliseconds != INFINITE)
2381        Timeout.QuadPart = (LONGLONG) dwMilliseconds * (LONGLONG) -10000;
2382
2383     W32Process->W32PF_flags |= W32PF_WAITFORINPUTIDLE;
2384     for (pti = W32Process->ptiList; pti; pti = pti->ptiSibling)
2385     {
2386        pti->TIF_flags |= TIF_WAITFORINPUTIDLE;
2387        pti->pClientInfo->dwTIFlags = pti->TIF_flags;
2388     }
2389
2390     DPRINT("WFII: ppi 0x%x\n",W32Process);
2391     DPRINT("WFII: waiting for %p\n", Handles[1] );
2392     do
2393     {
2394         UserLeave();
2395         Status = KeWaitForMultipleObjects( 3,
2396                                            Handles,
2397                                            WaitAny,
2398                                            UserRequest,
2399                                            UserMode,
2400                                            FALSE,
2401                                            dwMilliseconds == INFINITE ? NULL : &Timeout,
2402                                            NULL);
2403         UserEnterExclusive();
2404
2405         if (!NT_SUCCESS(Status))
2406         {
2407             SetLastNtError(Status);
2408             Status = WAIT_FAILED;
2409             goto WaitExit;
2410         }
2411
2412         switch (Status)
2413         {
2414         case STATUS_WAIT_0:
2415             goto WaitExit;
2416
2417         case STATUS_WAIT_2:
2418             {
2419                MSG Msg;
2420                co_IntGetPeekMessage( &Msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE, FALSE);
2421                DPRINT1("WFII: WAIT 2\n");
2422             }
2423             break;
2424
2425         case STATUS_TIMEOUT:
2426             DPRINT1("WFII: timeout\n");
2427         case WAIT_FAILED:
2428             goto WaitExit;
2429
2430         default:
2431             DPRINT1("WFII: finished\n");
2432             Status = STATUS_SUCCESS;
2433             goto WaitExit;
2434         }
2435     }
2436     while (TRUE);
2437
2438 WaitExit:
2439     for (pti = W32Process->ptiList; pti; pti = pti->ptiSibling)
2440     {
2441        pti->TIF_flags &= ~TIF_WAITFORINPUTIDLE;
2442        pti->pClientInfo->dwTIFlags = pti->TIF_flags;
2443     }
2444     W32Process->W32PF_flags &= ~W32PF_WAITFORINPUTIDLE;
2445     ObDereferenceObject(Process);
2446     UserLeave();
2447     return Status;
2448 }
2449
2450 /* EOF */