git.oblomov.eu Git - wine/blob - windows/queue.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <string.h>
   8 #include <signal.h>
   9 #include <assert.h>
  10 #include "windef.h"
  11 #include "wingdi.h"
  12 #include "winerror.h"
  13 #include "wine/winbase16.h"
  14 #include "wine/winuser16.h"
  15 #include "queue.h"
  16 #include "win.h"
  17 #include "user.h"
  18 #include "hook.h"
  19 #include "thread.h"
  20 #include "debugtools.h"
  21 #include "wine/server.h"
  22 #include "spy.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(msg);
  25
  26
  27 static HQUEUE16 hExitingQueue = 0;
  28 static PERQUEUEDATA *pQDataWin16 = NULL;  /* Global perQData for Win16 tasks */
  29
  30 HQUEUE16 hActiveQueue = 0;
  31
  32
  33 /***********************************************************************
  34  *           PERQDATA_Addref
  35  *
  36  * Increment reference count for the PERQUEUEDATA instance
  37  * Returns reference count for debugging purposes
  38  */
  39 static void PERQDATA_Addref( PERQUEUEDATA *pQData )
  40 {
  41     assert(pQData != 0 );
  42     TRACE_(msg)("(): current refcount %lu ...\n", pQData->ulRefCount);
  43
  44     InterlockedIncrement( &pQData->ulRefCount );
  45 }
  46
  47
  48 /***********************************************************************
  49  *           PERQDATA_Release
  50  *
  51  * Release a reference to a PERQUEUEDATA instance.
  52  * Destroy the instance if no more references exist
  53  * Returns reference count for debugging purposes
  54  */
  55 static void PERQDATA_Release( PERQUEUEDATA *pQData )
  56 {
  57     assert(pQData != 0 );
  58     TRACE_(msg)("(): current refcount %lu ...\n",
  59           (LONG)pQData->ulRefCount );
  60
  61     if (!InterlockedDecrement( &pQData->ulRefCount ))
  62     {
  63         DeleteCriticalSection( &pQData->cSection );
  64
  65         TRACE_(msg)("(): deleting PERQUEUEDATA instance ...\n" );
  66
  67         /* Deleting our global 16 bit perQData? */
  68         if ( pQData == pQDataWin16 ) pQDataWin16 = 0;
  69
  70         /* Free the PERQUEUEDATA instance */
  71         HeapFree( GetProcessHeap(), 0, pQData );
  72     }
  73 }
  74
  75
  76 /***********************************************************************
  77  *           PERQDATA_CreateInstance
  78  *
  79  * Creates an instance of a reference counted PERQUEUEDATA element
  80  * for the message queue. perQData is stored globally for 16 bit tasks.
  81  *
  82  * Note: We don't implement perQdata exactly the same way Windows does.
  83  * Each perQData element is reference counted since it may be potentially
  84  * shared by multiple message Queues (via AttachThreadInput).
  85  * We only store the current values for Active, Capture and focus windows
  86  * currently.
  87  */
  88 static PERQUEUEDATA * PERQDATA_CreateInstance(void)
  89 {
  90     PERQUEUEDATA *pQData;
  91
  92     BOOL16 bIsWin16 = 0;
  93
  94     TRACE_(msg)("()\n");
  95
  96     /* Share a single instance of perQData for all 16 bit tasks */
  97     if ( ( bIsWin16 = !(NtCurrentTeb()->tibflags & TEBF_WIN32) ) )
  98     {
  99         /* If previously allocated, just bump up ref count */
 100         if ( pQDataWin16 )
 101         {
 102             PERQDATA_Addref( pQDataWin16 );
 103             return pQDataWin16;
 104         }
 105     }
 106
 107     /* Allocate PERQUEUEDATA from the system heap */
 108     if (!( pQData = (PERQUEUEDATA *) HeapAlloc( GetProcessHeap(), 0,
 109                                                     sizeof(PERQUEUEDATA) ) ))
 110         return 0;
 111
 112     /* Initialize */
 113     pQData->hWndCapture = pQData->hWndFocus = pQData->hWndActive = 0;
 114     pQData->ulRefCount = 1;
 115     pQData->nCaptureHT = HTCLIENT;
 116
 117     /* Note: We have an independent critical section for the per queue data
 118      * since this may be shared by different threads. see AttachThreadInput()
 119      */
 120     InitializeCriticalSection( &pQData->cSection );
 121     /* FIXME: not all per queue data critical sections should be global */
 122     MakeCriticalSectionGlobal( &pQData->cSection );
 123
 124     /* Save perQData globally for 16 bit tasks */
 125     if ( bIsWin16 )
 126         pQDataWin16 = pQData;
 127
 128     return pQData;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           PERQDATA_GetFocusWnd
 134  *
 135  * Get the focus hwnd member in a threadsafe manner
 136  */
 137 HWND PERQDATA_GetFocusWnd( PERQUEUEDATA *pQData )
 138 {
 139     HWND hWndFocus;
 140     assert(pQData != 0 );
 141
 142     EnterCriticalSection( &pQData->cSection );
 143     hWndFocus = pQData->hWndFocus;
 144     LeaveCriticalSection( &pQData->cSection );
 145
 146     return hWndFocus;
 147 }
 148
 149
 150 /***********************************************************************
 151  *           PERQDATA_SetFocusWnd
 152  *
 153  * Set the focus hwnd member in a threadsafe manner
 154  */
 155 HWND PERQDATA_SetFocusWnd( PERQUEUEDATA *pQData, HWND hWndFocus )
 156 {
 157     HWND hWndFocusPrv;
 158     assert(pQData != 0 );
 159
 160     EnterCriticalSection( &pQData->cSection );
 161     hWndFocusPrv = pQData->hWndFocus;
 162     pQData->hWndFocus = hWndFocus;
 163     LeaveCriticalSection( &pQData->cSection );
 164
 165     return hWndFocusPrv;
 166 }
 167
 168
 169 /***********************************************************************
 170  *           PERQDATA_GetActiveWnd
 171  *
 172  * Get the active hwnd member in a threadsafe manner
 173  */
 174 HWND PERQDATA_GetActiveWnd( PERQUEUEDATA *pQData )
 175 {
 176     HWND hWndActive;
 177     assert(pQData != 0 );
 178
 179     EnterCriticalSection( &pQData->cSection );
 180     hWndActive = pQData->hWndActive;
 181     LeaveCriticalSection( &pQData->cSection );
 182
 183     return hWndActive;
 184 }
 185
 186
 187 /***********************************************************************
 188  *           PERQDATA_SetActiveWnd
 189  *
 190  * Set the active focus hwnd member in a threadsafe manner
 191  */
 192 HWND PERQDATA_SetActiveWnd( PERQUEUEDATA *pQData, HWND hWndActive )
 193 {
 194     HWND hWndActivePrv;
 195     assert(pQData != 0 );
 196
 197     EnterCriticalSection( &pQData->cSection );
 198     hWndActivePrv = pQData->hWndActive;
 199     pQData->hWndActive = hWndActive;
 200     LeaveCriticalSection( &pQData->cSection );
 201
 202     return hWndActivePrv;
 203 }
 204
 205
 206 /***********************************************************************
 207  *           PERQDATA_GetCaptureWnd
 208  *
 209  * Get the capture hwnd member in a threadsafe manner
 210  */
 211 HWND PERQDATA_GetCaptureWnd( INT *hittest )
 212 {
 213     MESSAGEQUEUE *queue;
 214     PERQUEUEDATA *pQData;
 215     HWND hWndCapture;
 216
 217     if (!(queue = QUEUE_Current())) return 0;
 218     pQData = queue->pQData;
 219
 220     EnterCriticalSection( &pQData->cSection );
 221     hWndCapture = pQData->hWndCapture;
 222     *hittest = pQData->nCaptureHT;
 223     LeaveCriticalSection( &pQData->cSection );
 224     return hWndCapture;
 225 }
 226
 227
 228 /***********************************************************************
 229  *           PERQDATA_SetCaptureWnd
 230  *
 231  * Set the capture hwnd member in a threadsafe manner
 232  */
 233 HWND PERQDATA_SetCaptureWnd( HWND hWndCapture, INT hittest )
 234 {
 235     MESSAGEQUEUE *queue;
 236     PERQUEUEDATA *pQData;
 237     HWND hWndCapturePrv;
 238
 239     if (!(queue = QUEUE_Current())) return 0;
 240     pQData = queue->pQData;
 241
 242     EnterCriticalSection( &pQData->cSection );
 243     hWndCapturePrv = pQData->hWndCapture;
 244     pQData->hWndCapture = hWndCapture;
 245     pQData->nCaptureHT = hittest;
 246     LeaveCriticalSection( &pQData->cSection );
 247     return hWndCapturePrv;
 248 }
 249
 250
 251
 252 /***********************************************************************
 253  *           QUEUE_Lock
 254  *
 255  * Function for getting a 32 bit pointer on queue structure. For thread
 256  * safeness programmers should use this function instead of GlobalLock to
 257  * retrieve a pointer on the structure. QUEUE_Unlock should also be called
 258  * when access to the queue structure is not required anymore.
 259  */
 260 MESSAGEQUEUE *QUEUE_Lock( HQUEUE16 hQueue )
 261 {
 262     MESSAGEQUEUE *queue;
 263
 264     HeapLock( GetProcessHeap() );  /* FIXME: a bit overkill */
 265     queue = GlobalLock16( hQueue );
 266     if ( !queue || (queue->magic != QUEUE_MAGIC) )
 267     {
 268         HeapUnlock( GetProcessHeap() );
 269         return NULL;
 270     }
 271
 272     queue->lockCount++;
 273     HeapUnlock( GetProcessHeap() );
 274     return queue;
 275 }
 276
 277
 278 /***********************************************************************
 279  *           QUEUE_Current
 280  *
 281  * Get the current thread queue, creating it if required.
 282  * QUEUE_Unlock is not needed since the queue can only be deleted by
 283  * the current thread anyway.
 284  */
 285 MESSAGEQUEUE *QUEUE_Current(void)
 286 {
 287     MESSAGEQUEUE *queue;
 288     HQUEUE16 hQueue;
 289
 290     if (!(hQueue = GetThreadQueue16(0)))
 291     {
 292         if (!(hQueue = InitThreadInput16( 0, 0 ))) return NULL;
 293     }
 294
 295     if ((queue = GlobalLock16( hQueue )))
 296     {
 297         if (queue->magic != QUEUE_MAGIC) queue = NULL;
 298     }
 299     return queue;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           QUEUE_Unlock
 305  *
 306  * Use with QUEUE_Lock to get a thread safe access to message queue
 307  * structure
 308  */
 309 void QUEUE_Unlock( MESSAGEQUEUE *queue )
 310 {
 311     if (queue)
 312     {
 313         HeapLock( GetProcessHeap() );  /* FIXME: a bit overkill */
 314
 315         if ( --queue->lockCount == 0 )
 316         {
 317             if (queue->server_queue)
 318                 CloseHandle( queue->server_queue );
 319             GlobalFree16( queue->self );
 320         }
 321
 322         HeapUnlock( GetProcessHeap() );
 323     }
 324 }
 325
 326
 327 /***********************************************************************
 328  *           QUEUE_IsExitingQueue
 329  */
 330 BOOL QUEUE_IsExitingQueue( HQUEUE16 hQueue )
 331 {
 332     return (hExitingQueue && (hQueue == hExitingQueue));
 333 }
 334
 335
 336 /***********************************************************************
 337  *           QUEUE_SetExitingQueue
 338  */
 339 void QUEUE_SetExitingQueue( HQUEUE16 hQueue )
 340 {
 341     hExitingQueue = hQueue;
 342 }
 343
 344
 345 /***********************************************************************
 346  *           QUEUE_CreateMsgQueue
 347  *
 348  * Creates a message queue. Doesn't link it into queue list!
 349  */
 350 static HQUEUE16 QUEUE_CreateMsgQueue( BOOL16 bCreatePerQData )
 351 {
 352     HQUEUE16 hQueue;
 353     HANDLE handle;
 354     MESSAGEQUEUE * msgQueue;
 355
 356     TRACE_(msg)("(): Creating message queue...\n");
 357
 358     if (!(hQueue = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT,
 359                                   sizeof(MESSAGEQUEUE) )))
 360         return 0;
 361
 362     msgQueue = (MESSAGEQUEUE *) GlobalLock16( hQueue );
 363     if ( !msgQueue )
 364         return 0;
 365
 366     if (bCreatePerQData)
 367     {
 368         SERVER_START_REQ( get_msg_queue )
 369         {
 370             SERVER_CALL_ERR();
 371             handle = req->handle;
 372         }
 373         SERVER_END_REQ;
 374         if (!handle)
 375         {
 376             ERR_(msg)("Cannot get thread queue");
 377             GlobalFree16( hQueue );
 378             return 0;
 379         }
 380         msgQueue->server_queue = handle;
 381     }
 382
 383     msgQueue->self = hQueue;
 384     msgQueue->lockCount = 1;
 385     msgQueue->magic = QUEUE_MAGIC;
 386
 387     /* Create and initialize our per queue data */
 388     msgQueue->pQData = bCreatePerQData ? PERQDATA_CreateInstance() : NULL;
 389
 390     return hQueue;
 391 }
 392
 393
 394 /***********************************************************************
 395  *           QUEUE_DeleteMsgQueue
 396  *
 397  * Unlinks and deletes a message queue.
 398  *
 399  * Note: We need to mask asynchronous events to make sure PostMessage works
 400  * even in the signal handler.
 401  */
 402 void QUEUE_DeleteMsgQueue(void)
 403 {
 404     HQUEUE16 hQueue = GetThreadQueue16(0);
 405     MESSAGEQUEUE * msgQueue;
 406
 407     if (!hQueue) return;  /* thread doesn't have a queue */
 408
 409     TRACE("(): Deleting message queue %04x\n", hQueue);
 410
 411     if (!(msgQueue = QUEUE_Lock(hQueue)))
 412     {
 413         ERR("invalid thread queue\n");
 414         return;
 415     }
 416
 417     msgQueue->magic = 0;
 418
 419     if( hActiveQueue == hQueue ) hActiveQueue = 0;
 420     if (hExitingQueue == hQueue) hExitingQueue = 0;
 421
 422     HeapLock( GetProcessHeap() );  /* FIXME: a bit overkill */
 423
 424     /* Release per queue data if present */
 425     if ( msgQueue->pQData )
 426     {
 427         PERQDATA_Release( msgQueue->pQData );
 428         msgQueue->pQData = 0;
 429     }
 430
 431     msgQueue->self = 0;
 432
 433     HeapUnlock( GetProcessHeap() );
 434     SetThreadQueue16( 0, 0 );
 435
 436     /* free up resource used by MESSAGEQUEUE structure */
 437     msgQueue->lockCount--;
 438     QUEUE_Unlock( msgQueue );
 439 }
 440
 441
 442 /***********************************************************************
 443  *           QUEUE_CleanupWindow
 444  *
 445  * Cleanup the queue to account for a window being deleted.
 446  */
 447 void QUEUE_CleanupWindow( HWND hwnd )
 448 {
 449     SERVER_START_REQ( cleanup_window_queue )
 450     {
 451         req->win = hwnd;
 452         SERVER_CALL();
 453     }
 454     SERVER_END_REQ;
 455 }
 456
 457
 458 /***********************************************************************
 459  *              GetWindowTask (USER.224)
 460  */
 461 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
 462 {
 463     HTASK16 retvalue;
 464     MESSAGEQUEUE *queue;
 465
 466     WND *wndPtr = WIN_FindWndPtr( hwnd );
 467     if (!wndPtr) return 0;
 468
 469     queue = QUEUE_Lock( wndPtr->hmemTaskQ );
 470     WIN_ReleaseWndPtr(wndPtr);
 471
 472     if (!queue) return 0;
 473
 474     retvalue = queue->teb->htask16;
 475     QUEUE_Unlock( queue );
 476
 477     return retvalue;
 478 }
 479
 480 /***********************************************************************
 481  *              GetWindowThreadProcessId (USER32.@)
 482  */
 483 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
 484 {
 485     DWORD retvalue;
 486     MESSAGEQUEUE *queue;
 487
 488     WND *wndPtr = WIN_FindWndPtr( hwnd );
 489     if (!wndPtr) return 0;
 490
 491     queue = QUEUE_Lock( wndPtr->hmemTaskQ );
 492     WIN_ReleaseWndPtr(wndPtr);
 493
 494     if (!queue) return 0;
 495
 496     if ( process ) *process = (DWORD)queue->teb->pid;
 497     retvalue = (DWORD)queue->teb->tid;
 498
 499     QUEUE_Unlock( queue );
 500     return retvalue;
 501 }
 502
 503
 504 /***********************************************************************
 505  *              InitThreadInput (USER.409)
 506  */
 507 HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
 508 {
 509     MESSAGEQUEUE *queuePtr;
 510     HQUEUE16 hQueue = NtCurrentTeb()->queue;
 511
 512     if ( !hQueue )
 513     {
 514         /* Create thread message queue */
 515         if( !(hQueue = QUEUE_CreateMsgQueue( TRUE )))
 516         {
 517             ERR_(msg)("failed!\n");
 518             return FALSE;
 519         }
 520
 521         /* Link new queue into list */
 522         queuePtr = QUEUE_Lock( hQueue );
 523         queuePtr->teb = NtCurrentTeb();
 524
 525         HeapLock( GetProcessHeap() );  /* FIXME: a bit overkill */
 526         SetThreadQueue16( 0, hQueue );
 527         NtCurrentTeb()->queue = hQueue;
 528         HeapUnlock( GetProcessHeap() );
 529
 530         QUEUE_Unlock( queuePtr );
 531     }
 532
 533     return hQueue;
 534 }
 535
 536 /***********************************************************************
 537  *              GetQueueStatus (USER32.@)
 538  */
 539 DWORD WINAPI GetQueueStatus( UINT flags )
 540 {
 541     DWORD ret = 0;
 542
 543     SERVER_START_REQ( get_queue_status )
 544     {
 545         req->clear = 1;
 546         SERVER_CALL();
 547         ret = MAKELONG( req->changed_bits & flags, req->wake_bits & flags );
 548     }
 549     SERVER_END_REQ;
 550     return ret;
 551 }
 552
 553
 554 /***********************************************************************
 555  *              GetInputState   (USER32.@)
 556  */
 557 BOOL WINAPI GetInputState(void)
 558 {
 559     DWORD ret = 0;
 560
 561     SERVER_START_REQ( get_queue_status )
 562     {
 563         req->clear = 0;
 564         SERVER_CALL();
 565         ret = req->wake_bits & (QS_KEY | QS_MOUSEBUTTON);
 566     }
 567     SERVER_END_REQ;
 568     return ret;
 569 }
 570
 571 /***********************************************************************
 572  *              GetMessagePos (USER.119)
 573  *              GetMessagePos (USER32.@)
 574  *
 575  * The GetMessagePos() function returns a long value representing a
 576  * cursor position, in screen coordinates, when the last message
 577  * retrieved by the GetMessage() function occurs. The x-coordinate is
 578  * in the low-order word of the return value, the y-coordinate is in
 579  * the high-order word. The application can use the MAKEPOINT()
 580  * macro to obtain a POINT structure from the return value.
 581  *
 582  * For the current cursor position, use GetCursorPos().
 583  *
 584  * RETURNS
 585  *
 586  * Cursor position of last message on success, zero on failure.
 587  *
 588  * CONFORMANCE
 589  *
 590  * ECMA-234, Win32
 591  *
 592  */
 593 DWORD WINAPI GetMessagePos(void)
 594 {
 595     MESSAGEQUEUE *queue;
 596
 597     if (!(queue = QUEUE_Current())) return 0;
 598     return queue->GetMessagePosVal;
 599 }
 600
 601
 602 /***********************************************************************
 603  *              GetMessageTime (USER.120)
 604  *              GetMessageTime (USER32.@)
 605  *
 606  * GetMessageTime() returns the message time for the last message
 607  * retrieved by the function. The time is measured in milliseconds with
 608  * the same offset as GetTickCount().
 609  *
 610  * Since the tick count wraps, this is only useful for moderately short
 611  * relative time comparisons.
 612  *
 613  * RETURNS
 614  *
 615  * Time of last message on success, zero on failure.
 616  *
 617  * CONFORMANCE
 618  *
 619  * ECMA-234, Win32
 620  *
 621  */
 622 LONG WINAPI GetMessageTime(void)
 623 {
 624     MESSAGEQUEUE *queue;
 625
 626     if (!(queue = QUEUE_Current())) return 0;
 627     return queue->GetMessageTimeVal;
 628 }
 629
 630
 631 /***********************************************************************
 632  *              GetMessageExtraInfo (USER.288)
 633  *              GetMessageExtraInfo (USER32.@)
 634  */
 635 LONG WINAPI GetMessageExtraInfo(void)
 636 {
 637     MESSAGEQUEUE *queue;
 638
 639     if (!(queue = QUEUE_Current())) return 0;
 640     return queue->GetMessageExtraInfoVal;
 641 }
 642
 643
 644 /**********************************************************************
 645  *              AttachThreadInput (USER32.@) Attaches input of 1 thread to other
 646  *
 647  * Attaches the input processing mechanism of one thread to that of
 648  * another thread.
 649  *
 650  * RETURNS
 651  *    Success: TRUE
 652  *    Failure: FALSE
 653  *
 654  * TODO:
 655  *    1. Reset the Key State (currenly per thread key state is not maintained)
 656  */
 657 BOOL WINAPI AttachThreadInput(
 658     DWORD idAttach,   /* [in] Thread to attach */
 659     DWORD idAttachTo, /* [in] Thread to attach to */
 660     BOOL fAttach)   /* [in] Attach or detach */
 661 {
 662     MESSAGEQUEUE *pSrcMsgQ = 0, *pTgtMsgQ = 0;
 663     BOOL16 bRet = 0;
 664
 665     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 666
 667     /* A thread cannot attach to itself */
 668     if ( idAttach == idAttachTo )
 669         goto CLEANUP;
 670
 671     /* According to the docs this method should fail if a
 672      * "Journal record" hook is installed. (attaches all input queues together)
 673      */
 674     if ( HOOK_IsHooked( WH_JOURNALRECORD ) )
 675         goto CLEANUP;
 676
 677     /* Retrieve message queues corresponding to the thread id's */
 678     pTgtMsgQ = QUEUE_Lock( GetThreadQueue16( idAttach ) );
 679     pSrcMsgQ = QUEUE_Lock( GetThreadQueue16( idAttachTo ) );
 680
 681     /* Ensure we have message queues and that Src and Tgt threads
 682      * are not system threads.
 683      */
 684     if ( !pSrcMsgQ || !pTgtMsgQ || !pSrcMsgQ->pQData || !pTgtMsgQ->pQData )
 685         goto CLEANUP;
 686
 687     if (fAttach)   /* Attach threads */
 688     {
 689         /* Only attach if currently detached  */
 690         if ( pTgtMsgQ->pQData != pSrcMsgQ->pQData )
 691         {
 692             /* First release the target threads perQData */
 693             PERQDATA_Release( pTgtMsgQ->pQData );
 694
 695             /* Share a reference to the source threads perQDATA */
 696             PERQDATA_Addref( pSrcMsgQ->pQData );
 697             pTgtMsgQ->pQData = pSrcMsgQ->pQData;
 698         }
 699     }
 700     else    /* Detach threads */
 701     {
 702         /* Only detach if currently attached */
 703         if ( pTgtMsgQ->pQData == pSrcMsgQ->pQData )
 704         {
 705             /* First release the target threads perQData */
 706             PERQDATA_Release( pTgtMsgQ->pQData );
 707
 708             /* Give the target thread its own private perQDATA once more */
 709             pTgtMsgQ->pQData = PERQDATA_CreateInstance();
 710         }
 711     }
 712
 713     /* TODO: Reset the Key State */
 714
 715     bRet = 1;      /* Success */
 716
 717 CLEANUP:
 718
 719     /* Unlock the queues before returning */
 720     if ( pSrcMsgQ )
 721         QUEUE_Unlock( pSrcMsgQ );
 722     if ( pTgtMsgQ )
 723         QUEUE_Unlock( pTgtMsgQ );
 724
 725     return bRet;
 726 }