win32ss/user/ntuser/misc.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS Win32k subsystem
   4  * PURPOSE:          Miscellaneous User functions
   5  * FILE:             win32ss/user/ntuser/misc.c
   6  * PROGRAMER:        Ge van Geldorp (ge@gse.nl)
   7  */
   8
   9 #include <win32k.h>
  10 DBG_DEFAULT_CHANNEL(UserMisc);
  11
  12
  13 /*
  14  * NOTE: _scwprintf() is NOT exported by ntoskrnl.exe,
  15  * only _vscwprintf() is, so we need to implement it here.
  16  * Code comes from sdk/lib/crt/printf/_scwprintf.c .
  17  * See also win32ss/user/winsrv/usersrv/harderror.c .
  18  */
  19 int
  20 __cdecl
  21 _scwprintf(
  22     const wchar_t *format,
  23     ...)
  24 {
  25     int len;
  26     va_list args;
  27
  28     va_start(args, format);
  29     len = _vscwprintf(format, args);
  30     va_end(args);
  31
  32     return len;
  33 }
  34
  35
  36 /*
  37  * Test the Thread to verify and validate it. Hard to the core tests are required.
  38  */
  39 PTHREADINFO
  40 FASTCALL
  41 IntTID2PTI(HANDLE id)
  42 {
  43    NTSTATUS Status;
  44    PETHREAD Thread;
  45    PTHREADINFO pti;
  46    Status = PsLookupThreadByThreadId(id, &Thread);
  47    if (!NT_SUCCESS(Status))
  48    {
  49       return NULL;
  50    }
  51    if (PsIsThreadTerminating(Thread))
  52    {
  53       ObDereferenceObject(Thread);
  54       return NULL;
  55    }
  56    pti = PsGetThreadWin32Thread(Thread);
  57    if (!pti)
  58    {
  59       ObDereferenceObject(Thread);
  60       return NULL;
  61    }
  62    // Validate and verify!
  63    _SEH2_TRY
  64    {
  65       if (pti->TIF_flags & TIF_INCLEANUP) pti = NULL;
  66       if (pti && !(pti->TIF_flags & TIF_GUITHREADINITIALIZED)) pti = NULL;
  67       if (PsGetThreadId(Thread) != id) pti = NULL;
  68    }
  69    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
  70    {
  71       pti = NULL;
  72    }
  73    _SEH2_END
  74    ObDereferenceObject(Thread);
  75    return pti;
  76 }
  77
  78 DWORD
  79 FASTCALL
  80 UserGetLanguageToggle(VOID)
  81 {
  82     NTSTATUS Status;
  83     DWORD dwValue = 0;
  84
  85     Status = RegReadUserSetting(L"Keyboard Layout\\Toggle", L"Layout Hotkey", REG_SZ, &dwValue, sizeof(dwValue));
  86     if (NT_SUCCESS(Status))
  87     {
  88         dwValue = atoi((char *)&dwValue);
  89         TRACE("Layout Hotkey %d\n",dwValue);
  90     }
  91     return dwValue;
  92 }
  93
  94 SHORT
  95 FASTCALL
  96 UserGetLanguageID(VOID)
  97 {
  98   HANDLE KeyHandle;
  99   OBJECT_ATTRIBUTES ObAttr;
 100 //  http://support.microsoft.com/kb/324097
 101   ULONG Ret = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 102   PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
 103   ULONG Size = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + MAX_PATH*sizeof(WCHAR);
 104   UNICODE_STRING Language;
 105
 106   RtlInitUnicodeString( &Language,
 107     L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Nls\\Language");
 108
 109   InitializeObjectAttributes( &ObAttr,
 110                               &Language,
 111                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 112                               NULL,
 113                               NULL);
 114
 115   if ( NT_SUCCESS(ZwOpenKey(&KeyHandle, KEY_READ, &ObAttr)))
 116   {
 117      pKeyInfo = ExAllocatePoolWithTag(PagedPool, Size, TAG_STRING);
 118      if ( pKeyInfo )
 119      {
 120         RtlInitUnicodeString(&Language, L"Default");
 121
 122         if ( NT_SUCCESS(ZwQueryValueKey( KeyHandle,
 123                                          &Language,
 124                         KeyValuePartialInformation,
 125                                           pKeyInfo,
 126                                               Size,
 127                                              &Size)) )
 128       {
 129         RtlInitUnicodeString(&Language, (PWSTR)pKeyInfo->Data);
 130         if (!NT_SUCCESS(RtlUnicodeStringToInteger(&Language, 16, &Ret)))
 131         {
 132             Ret = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 133         }
 134       }
 135       ExFreePoolWithTag(pKeyInfo, TAG_STRING);
 136     }
 137     ZwClose(KeyHandle);
 138   }
 139   TRACE("Language ID = %x\n",Ret);
 140   return (SHORT) Ret;
 141 }
 142
 143 HBRUSH
 144 FASTCALL
 145 GetControlColor(
 146    PWND pwndParent,
 147    PWND pwnd,
 148    HDC hdc,
 149    UINT CtlMsg)
 150 {
 151     HBRUSH hBrush;
 152
 153     if (!pwndParent) pwndParent = pwnd;
 154
 155     if ( pwndParent->head.pti->ppi != PsGetCurrentProcessWin32Process())
 156     {
 157        return (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
 158     }
 159
 160     hBrush = (HBRUSH)co_IntSendMessage( UserHMGetHandle(pwndParent), CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd));
 161
 162     if (!hBrush || !GreIsHandleValid(hBrush))
 163     {
 164        hBrush = (HBRUSH)IntDefWindowProc( pwndParent, CtlMsg, (WPARAM)hdc, (LPARAM)UserHMGetHandle(pwnd), FALSE);
 165     }
 166     return hBrush;
 167 }
 168
 169 HBRUSH
 170 FASTCALL
 171 GetControlBrush(
 172    PWND pwnd,
 173    HDC  hdc,
 174    UINT ctlType)
 175 {
 176     PWND pwndParent = IntGetParent(pwnd);
 177     return GetControlColor( pwndParent, pwnd, hdc, ctlType);
 178 }
 179
 180 HBRUSH
 181 APIENTRY
 182 NtUserGetControlBrush(
 183    HWND hwnd,
 184    HDC  hdc,
 185    UINT ctlType)
 186 {
 187    PWND pwnd;
 188    HBRUSH hBrush = NULL;
 189
 190    UserEnterExclusive();
 191    if ( (pwnd = UserGetWindowObject(hwnd)) &&
 192        ((ctlType - WM_CTLCOLORMSGBOX) < CTLCOLOR_MAX) &&
 193         hdc )
 194    {
 195       hBrush = GetControlBrush(pwnd, hdc, ctlType);
 196    }
 197    UserLeave();
 198    return hBrush;
 199 }
 200
 201 /*
 202  * Called from PaintRect, works almost like wine PaintRect16 but returns hBrush.
 203  */
 204 HBRUSH
 205 APIENTRY
 206 NtUserGetControlColor(
 207    HWND hwndParent,
 208    HWND hwnd,
 209    HDC hdc,
 210    UINT CtlMsg) // Wine PaintRect: WM_CTLCOLORMSGBOX + hbrush
 211 {
 212    PWND pwnd, pwndParent = NULL;
 213    HBRUSH hBrush = NULL;
 214
 215    UserEnterExclusive();
 216    if ( (pwnd = UserGetWindowObject(hwnd)) &&
 217        ((CtlMsg - WM_CTLCOLORMSGBOX) < CTLCOLOR_MAX) &&
 218         hdc )
 219    {
 220       if (hwndParent) pwndParent = UserGetWindowObject(hwndParent);
 221       hBrush = GetControlColor( pwndParent, pwnd, hdc, CtlMsg);
 222    }
 223    UserLeave();
 224    return hBrush;
 225 }
 226
 227 /*
 228  * @unimplemented
 229  */
 230 DWORD_PTR APIENTRY
 231 NtUserGetThreadState(
 232    DWORD Routine)
 233 {
 234    DWORD_PTR ret = 0;
 235
 236    TRACE("Enter NtUserGetThreadState\n");
 237    if (Routine != THREADSTATE_GETTHREADINFO)
 238    {
 239        UserEnterShared();
 240    }
 241    else
 242    {
 243        UserEnterExclusive();
 244    }
 245
 246    switch (Routine)
 247    {
 248       case THREADSTATE_GETTHREADINFO:
 249          GetW32ThreadInfo();
 250          break;
 251       case THREADSTATE_FOCUSWINDOW:
 252          ret = (DWORD_PTR)IntGetThreadFocusWindow();
 253          break;
 254       case THREADSTATE_CAPTUREWINDOW:
 255          /* FIXME: Should use UserEnterShared */
 256          ret = (DWORD_PTR)IntGetCapture();
 257          break;
 258       case THREADSTATE_PROGMANWINDOW:
 259          ret = (DWORD_PTR)GetW32ThreadInfo()->pDeskInfo->hProgmanWindow;
 260          break;
 261       case THREADSTATE_TASKMANWINDOW:
 262          ret = (DWORD_PTR)GetW32ThreadInfo()->pDeskInfo->hTaskManWindow;
 263          break;
 264       case THREADSTATE_ACTIVEWINDOW:
 265          ret = (DWORD_PTR)UserGetActiveWindow();
 266          break;
 267       case THREADSTATE_INSENDMESSAGE:
 268          {
 269            PUSER_SENT_MESSAGE Message =
 270                 ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->pusmCurrent;
 271            TRACE("THREADSTATE_INSENDMESSAGE\n");
 272
 273            ret = ISMEX_NOSEND;
 274            if (Message)
 275            {
 276              if (Message->ptiSender)
 277                 ret = ISMEX_SEND;
 278              else
 279              {
 280                 if (Message->CompletionCallback)
 281                    ret = ISMEX_CALLBACK;
 282                 else
 283                    ret = ISMEX_NOTIFY;
 284              }
 285              /* If ReplyMessage */
 286              if (Message->QS_Flags & QS_SMRESULT) ret |= ISMEX_REPLIED;
 287            }
 288
 289            break;
 290          }
 291       case THREADSTATE_GETMESSAGETIME:
 292          ret = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->timeLast;
 293          break;
 294
 295       case THREADSTATE_UPTIMELASTREAD:
 296          {
 297            PTHREADINFO pti;
 298            LARGE_INTEGER LargeTickCount;
 299            pti = PsGetCurrentThreadWin32Thread();
 300            KeQueryTickCount(&LargeTickCount);
 301            pti->timeLast = LargeTickCount.u.LowPart;
 302            pti->pcti->tickLastMsgChecked = LargeTickCount.u.LowPart;
 303          }
 304          break;
 305
 306       case THREADSTATE_GETINPUTSTATE:
 307          ret = LOWORD(IntGetQueueStatus(QS_POSTMESSAGE|QS_TIMER|QS_PAINT|QS_SENDMESSAGE|QS_INPUT)) & (QS_KEY | QS_MOUSEBUTTON);
 308          break;
 309
 310       case THREADSTATE_FOREGROUNDTHREAD:
 311          ret = (gpqForeground == GetW32ThreadInfo()->MessageQueue);
 312          break;
 313       case THREADSTATE_GETCURSOR:
 314          ret = (DWORD_PTR) (GetW32ThreadInfo()->MessageQueue->CursorObject ?
 315                             UserHMGetHandle(GetW32ThreadInfo()->MessageQueue->CursorObject) : 0);
 316          break;
 317       case THREADSTATE_GETMESSAGEEXTRAINFO:
 318          ret = (DWORD_PTR)MsqGetMessageExtraInfo();
 319         break;
 320    }
 321
 322    TRACE("Leave NtUserGetThreadState, ret=%lu\n", ret);
 323    UserLeave();
 324
 325    return ret;
 326 }
 327
 328 DWORD
 329 APIENTRY
 330 NtUserSetThreadState(
 331    DWORD Set,
 332    DWORD Flags)
 333 {
 334    PTHREADINFO pti;
 335    DWORD Ret = 0;
 336    // Test the only flags user can change.
 337    if (Set & ~(QF_FF10STATUS|QF_DIALOGACTIVE|QF_TABSWITCHING|QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) return 0;
 338    if (Flags & ~(QF_FF10STATUS|QF_DIALOGACTIVE|QF_TABSWITCHING|QF_FMENUSTATUS|QF_FMENUSTATUSBREAK)) return 0;
 339    UserEnterExclusive();
 340    pti = PsGetCurrentThreadWin32Thread();
 341    if (pti->MessageQueue)
 342    {
 343       Ret = pti->MessageQueue->QF_flags;    // Get the queue flags.
 344       if (Set)
 345          pti->MessageQueue->QF_flags |= (Set&Flags); // Set the queue flags.
 346       else
 347       {
 348          if (Flags) pti->MessageQueue->QF_flags &= ~Flags; // Clr the queue flags.
 349       }
 350    }
 351    UserLeave();
 352    return Ret;
 353 }
 354
 355 UINT
 356 APIENTRY
 357 NtUserGetDoubleClickTime(VOID)
 358 {
 359    UINT Result;
 360
 361    TRACE("Enter NtUserGetDoubleClickTime\n");
 362    UserEnterShared();
 363
 364    // FIXME: Check if this works on non-interactive winsta
 365    Result = gspv.iDblClickTime;
 366
 367    TRACE("Leave NtUserGetDoubleClickTime, ret=%u\n", Result);
 368    UserLeave();
 369    return Result;
 370 }
 371
 372 BOOL
 373 APIENTRY
 374 NtUserGetGUIThreadInfo(
 375    DWORD idThread, /* If NULL use foreground thread */
 376    LPGUITHREADINFO lpgui)
 377 {
 378    NTSTATUS Status;
 379    PTHRDCARETINFO CaretInfo;
 380    GUITHREADINFO SafeGui;
 381    PDESKTOP Desktop;
 382    PUSER_MESSAGE_QUEUE MsgQueue;
 383    PTHREADINFO W32Thread;
 384    PETHREAD Thread = NULL;
 385
 386    DECLARE_RETURN(BOOLEAN);
 387
 388    TRACE("Enter NtUserGetGUIThreadInfo\n");
 389    UserEnterShared();
 390
 391    Status = MmCopyFromCaller(&SafeGui, lpgui, sizeof(DWORD));
 392    if(!NT_SUCCESS(Status))
 393    {
 394       SetLastNtError(Status);
 395       RETURN( FALSE);
 396    }
 397
 398    if(SafeGui.cbSize != sizeof(GUITHREADINFO))
 399    {
 400       EngSetLastError(ERROR_INVALID_PARAMETER);
 401       RETURN( FALSE);
 402    }
 403
 404    if (idThread)
 405    {
 406       Status = PsLookupThreadByThreadId((HANDLE)(DWORD_PTR)idThread, &Thread);
 407       if(!NT_SUCCESS(Status))
 408       {
 409          EngSetLastError(ERROR_ACCESS_DENIED);
 410          RETURN( FALSE);
 411       }
 412       W32Thread = (PTHREADINFO)Thread->Tcb.Win32Thread;
 413       Desktop = W32Thread->rpdesk;
 414
 415       if (!Thread || !Desktop )
 416       {
 417         if(Thread)
 418            ObDereferenceObject(Thread);
 419         EngSetLastError(ERROR_ACCESS_DENIED);
 420         RETURN( FALSE);
 421       }
 422
 423       if ( W32Thread->MessageQueue )
 424         MsgQueue = W32Thread->MessageQueue;
 425       else
 426       {
 427         if ( Desktop ) MsgQueue = Desktop->ActiveMessageQueue;
 428       }
 429    }
 430    else
 431    {  /* Get the foreground thread */
 432       /* FIXME: Handle NULL queue properly? */
 433       MsgQueue = IntGetFocusMessageQueue();
 434       if(!MsgQueue)
 435       {
 436         EngSetLastError(ERROR_ACCESS_DENIED);
 437         RETURN( FALSE);
 438       }
 439    }
 440
 441    CaretInfo = &MsgQueue->CaretInfo;
 442
 443    SafeGui.flags = (CaretInfo->Visible ? GUI_CARETBLINKING : 0);
 444 /*
 445    if (W32Thread->pMenuState->pGlobalPopupMenu)
 446    {
 447        SafeGui.flags |= GUI_INMENUMODE;
 448
 449        if (W32Thread->pMenuState->pGlobalPopupMenu->spwndNotify)
 450           SafeGui.hwndMenuOwner = UserHMGetHandle(W32Thread->pMenuState->pGlobalPopupMenu->spwndNotify);
 451
 452        if (W32Thread->pMenuState->pGlobalPopupMenu->fHasMenuBar)
 453        {
 454           if (W32Thread->pMenuState->pGlobalPopupMenu->fIsSysMenu)
 455           {
 456              SafeGui.flags |= GUI_SYSTEMMENUMODE;
 457           }
 458        }
 459        else
 460        {
 461           SafeGui.flags |= GUI_POPUPMENUMODE;
 462        }
 463    }
 464  */
 465    SafeGui.hwndMenuOwner = MsgQueue->MenuOwner;
 466
 467    if (MsgQueue->MenuOwner)
 468       SafeGui.flags |= GUI_INMENUMODE | MsgQueue->MenuState;
 469
 470    if (MsgQueue->MoveSize)
 471       SafeGui.flags |= GUI_INMOVESIZE;
 472
 473    /* FIXME: Add flag GUI_16BITTASK */
 474
 475    SafeGui.hwndActive = MsgQueue->spwndActive ? UserHMGetHandle(MsgQueue->spwndActive) : 0;
 476    SafeGui.hwndFocus = MsgQueue->spwndFocus ? UserHMGetHandle(MsgQueue->spwndFocus) : 0;
 477    SafeGui.hwndCapture = MsgQueue->spwndCapture ? UserHMGetHandle(MsgQueue->spwndCapture) : 0;
 478    SafeGui.hwndMoveSize = MsgQueue->MoveSize;
 479    SafeGui.hwndCaret = CaretInfo->hWnd;
 480
 481    SafeGui.rcCaret.left = CaretInfo->Pos.x;
 482    SafeGui.rcCaret.top = CaretInfo->Pos.y;
 483    SafeGui.rcCaret.right = SafeGui.rcCaret.left + CaretInfo->Size.cx;
 484    SafeGui.rcCaret.bottom = SafeGui.rcCaret.top + CaretInfo->Size.cy;
 485
 486    if (idThread)
 487       ObDereferenceObject(Thread);
 488
 489    Status = MmCopyToCaller(lpgui, &SafeGui, sizeof(GUITHREADINFO));
 490    if(!NT_SUCCESS(Status))
 491    {
 492       SetLastNtError(Status);
 493       RETURN( FALSE);
 494    }
 495
 496    RETURN( TRUE);
 497
 498 CLEANUP:
 499    TRACE("Leave NtUserGetGUIThreadInfo, ret=%u\n",_ret_);
 500    UserLeave();
 501    END_CLEANUP;
 502 }
 503
 504
 505 DWORD
 506 APIENTRY
 507 NtUserGetGuiResources(
 508    HANDLE hProcess,
 509    DWORD uiFlags)
 510 {
 511    PEPROCESS Process;
 512    PPROCESSINFO W32Process;
 513    NTSTATUS Status;
 514    DWORD Ret = 0;
 515    DECLARE_RETURN(DWORD);
 516
 517    TRACE("Enter NtUserGetGuiResources\n");
 518    UserEnterShared();
 519
 520    Status = ObReferenceObjectByHandle(hProcess,
 521                                       PROCESS_QUERY_INFORMATION,
 522                                       *PsProcessType,
 523                                       ExGetPreviousMode(),
 524                                       (PVOID*)&Process,
 525                                       NULL);
 526
 527    if(!NT_SUCCESS(Status))
 528    {
 529       SetLastNtError(Status);
 530       RETURN( 0);
 531    }
 532
 533    W32Process = (PPROCESSINFO)Process->Win32Process;
 534    if(!W32Process)
 535    {
 536       ObDereferenceObject(Process);
 537       EngSetLastError(ERROR_INVALID_PARAMETER);
 538       RETURN( 0);
 539    }
 540
 541    switch(uiFlags)
 542    {
 543       case GR_GDIOBJECTS:
 544          {
 545             Ret = (DWORD)W32Process->GDIHandleCount;
 546             break;
 547          }
 548       case GR_USEROBJECTS:
 549          {
 550             Ret = (DWORD)W32Process->UserHandleCount;
 551             break;
 552          }
 553       default:
 554          {
 555             EngSetLastError(ERROR_INVALID_PARAMETER);
 556             break;
 557          }
 558    }
 559
 560    ObDereferenceObject(Process);
 561
 562    RETURN( Ret);
 563
 564 CLEANUP:
 565    TRACE("Leave NtUserGetGuiResources, ret=%lu\n",_ret_);
 566    UserLeave();
 567    END_CLEANUP;
 568 }
 569
 570 VOID FASTCALL
 571 IntSetWindowState(PWND pWnd, UINT Flag)
 572 {
 573    UINT bit;
 574    if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
 575    bit = 1 << LOWORD(Flag);
 576    TRACE("SWS %x\n",bit);
 577    switch(HIWORD(Flag))
 578    {
 579       case 0:
 580           pWnd->state |= bit;
 581           break;
 582       case 1:
 583           pWnd->state2 |= bit;
 584           break;
 585       case 2:
 586           pWnd->ExStyle2 |= bit;
 587           break;
 588    }
 589 }
 590
 591 VOID FASTCALL
 592 IntClearWindowState(PWND pWnd, UINT Flag)
 593 {
 594    UINT bit;
 595    if (gptiCurrent->ppi != pWnd->head.pti->ppi) return;
 596    bit = 1 << LOWORD(Flag);
 597    TRACE("CWS %x\n",bit);
 598    switch(HIWORD(Flag))
 599    {
 600       case 0:
 601           pWnd->state &= ~bit;
 602           break;
 603       case 1:
 604           pWnd->state2 &= ~bit;
 605           break;
 606       case 2:
 607           pWnd->ExStyle2 &= ~bit;
 608           break;
 609    }
 610 }
 611
 612 NTSTATUS FASTCALL
 613 IntSafeCopyUnicodeString(PUNICODE_STRING Dest,
 614                          PUNICODE_STRING Source)
 615 {
 616    NTSTATUS Status;
 617    PWSTR Src;
 618
 619    Status = MmCopyFromCaller(Dest, Source, sizeof(UNICODE_STRING));
 620    if(!NT_SUCCESS(Status))
 621    {
 622       return Status;
 623    }
 624
 625    if(Dest->Length > 0x4000)
 626    {
 627       return STATUS_UNSUCCESSFUL;
 628    }
 629
 630    Src = Dest->Buffer;
 631    Dest->Buffer = NULL;
 632    Dest->MaximumLength = Dest->Length;
 633
 634    if(Dest->Length > 0 && Src)
 635    {
 636       Dest->Buffer = ExAllocatePoolWithTag(PagedPool, Dest->MaximumLength, TAG_STRING);
 637       if(!Dest->Buffer)
 638       {
 639          return STATUS_NO_MEMORY;
 640       }
 641
 642       Status = MmCopyFromCaller(Dest->Buffer, Src, Dest->Length);
 643       if(!NT_SUCCESS(Status))
 644       {
 645          ExFreePoolWithTag(Dest->Buffer, TAG_STRING);
 646          Dest->Buffer = NULL;
 647          return Status;
 648       }
 649
 650
 651       return STATUS_SUCCESS;
 652    }
 653
 654    /* String is empty */
 655    return STATUS_SUCCESS;
 656 }
 657
 658 NTSTATUS FASTCALL
 659 IntSafeCopyUnicodeStringTerminateNULL(PUNICODE_STRING Dest,
 660                                       PUNICODE_STRING Source)
 661 {
 662    NTSTATUS Status;
 663    PWSTR Src;
 664
 665    Status = MmCopyFromCaller(Dest, Source, sizeof(UNICODE_STRING));
 666    if(!NT_SUCCESS(Status))
 667    {
 668       return Status;
 669    }
 670
 671    if(Dest->Length > 0x4000)
 672    {
 673       return STATUS_UNSUCCESSFUL;
 674    }
 675
 676    Src = Dest->Buffer;
 677    Dest->Buffer = NULL;
 678    Dest->MaximumLength = 0;
 679
 680    if(Dest->Length > 0 && Src)
 681    {
 682       Dest->MaximumLength = Dest->Length + sizeof(WCHAR);
 683       Dest->Buffer = ExAllocatePoolWithTag(PagedPool, Dest->MaximumLength, TAG_STRING);
 684       if(!Dest->Buffer)
 685       {
 686          return STATUS_NO_MEMORY;
 687       }
 688
 689       Status = MmCopyFromCaller(Dest->Buffer, Src, Dest->Length);
 690       if(!NT_SUCCESS(Status))
 691       {
 692          ExFreePoolWithTag(Dest->Buffer, TAG_STRING);
 693          Dest->Buffer = NULL;
 694          return Status;
 695       }
 696
 697       /* Make sure the string is null-terminated */
 698       Src = (PWSTR)((PBYTE)Dest->Buffer + Dest->Length);
 699       *Src = L'\0';
 700
 701       return STATUS_SUCCESS;
 702    }
 703
 704    /* String is empty */
 705    return STATUS_SUCCESS;
 706 }
 707
 708 void UserDbgAssertThreadInfo(BOOL showCaller)
 709 {
 710     PTEB Teb;
 711     PPROCESSINFO ppi;
 712     PCLIENTINFO pci;
 713     PTHREADINFO pti;
 714
 715     ppi = PsGetCurrentProcessWin32Process();
 716     pti = PsGetCurrentThreadWin32Thread();
 717     Teb = NtCurrentTeb();
 718     pci = GetWin32ClientInfo();
 719
 720     ASSERT(Teb);
 721     ASSERT(pti);
 722     ASSERT(pti->ppi == ppi);
 723     ASSERT(pti->pClientInfo == pci);
 724     ASSERT(Teb->Win32ThreadInfo == pti);
 725     ASSERT(pci->ppi == ppi);
 726     ASSERT(pci->fsHooks == pti->fsHooks);
 727     ASSERT(pci->ulClientDelta == DesktopHeapGetUserDelta());
 728     if (pti->pcti && pci->pDeskInfo)
 729         ASSERT(pci->pClientThreadInfo == (PVOID)((ULONG_PTR)pti->pcti - pci->ulClientDelta));
 730     if (pti->pcti && IsListEmpty(&pti->SentMessagesListHead))
 731         ASSERT((pti->pcti->fsChangeBits & QS_SENDMESSAGE) == 0);
 732     if (pti->KeyboardLayout)
 733         ASSERT(pci->hKL == pti->KeyboardLayout->hkl);
 734     if(pti->rpdesk != NULL)
 735         ASSERT(pti->pDeskInfo == pti->rpdesk->pDeskInfo);
 736
 737     /*too bad we still get this assertion*/
 738
 739     // Why? Not all flags are passed to the user and doing so could crash the system........
 740
 741     /* ASSERT(pci->dwTIFlags == pti->TIF_flags); */
 742 /*    if(pci->dwTIFlags != pti->TIF_flags)
 743     {
 744         ERR("pci->dwTIFlags(0x%x) doesn't match pti->TIF_flags(0x%x)\n", pci->dwTIFlags, pti->TIF_flags);
 745         if(showCaller)
 746         {
 747             DbgPrint("Caller:\n");
 748             KeRosDumpStackFrames(NULL, 10);
 749         }
 750         pci->dwTIFlags = pti->TIF_flags;
 751     }
 752 */
 753 }
 754
 755 void
 756 NTAPI
 757 UserDbgPreServiceHook(ULONG ulSyscallId, PULONG_PTR pulArguments)
 758 {
 759     UserDbgAssertThreadInfo(FALSE);
 760 }
 761
 762 ULONG_PTR
 763 NTAPI
 764 UserDbgPostServiceHook(ULONG ulSyscallId, ULONG_PTR ulResult)
 765 {
 766     /* Make sure that the first syscall is NtUserInitialize */
 767     /* too bad this fails */
 768     // ASSERT(gpepCSRSS);
 769
 770     UserDbgAssertThreadInfo(TRUE);
 771
 772     return ulResult;
 773 }
 774
 775
 776 PPROCESSINFO
 777 GetW32ProcessInfo(VOID)
 778 {
 779     return (PPROCESSINFO)PsGetCurrentProcessWin32Process();
 780 }
 781
 782 PTHREADINFO
 783 GetW32ThreadInfo(VOID)
 784 {
 785     UserDbgAssertThreadInfo(TRUE);
 786     return (PTHREADINFO)PsGetCurrentThreadWin32Thread();
 787 }
 788
 789
 790 NTSTATUS
 791 GetProcessLuid(
 792     IN PETHREAD Thread OPTIONAL,
 793     IN PEPROCESS Process OPTIONAL,
 794     OUT PLUID Luid)
 795 {
 796     NTSTATUS Status;
 797     PACCESS_TOKEN Token = NULL;
 798     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
 799     BOOLEAN CopyOnOpen, EffectiveOnly;
 800
 801     if (Thread && Process)
 802         return STATUS_INVALID_PARAMETER;
 803
 804     /* If nothing has been specified, use the current thread */
 805     if (!Thread && !Process)
 806         Thread = PsGetCurrentThread();
 807
 808     if (Thread)
 809     {
 810         /* Use a thread token */
 811         ASSERT(!Process);
 812         Token = PsReferenceImpersonationToken(Thread,
 813                                               &CopyOnOpen,
 814                                               &EffectiveOnly,
 815                                               &ImpersonationLevel);
 816
 817         /* If we don't have a thread token, use a process token */
 818         if (!Token)
 819             Process = PsGetThreadProcess(Thread);
 820     }
 821     if (!Token && Process)
 822     {
 823         /* Use a process token */
 824         Token = PsReferencePrimaryToken(Process);
 825
 826         /* If we don't have a token, fail */
 827         if (!Token)
 828             return STATUS_NO_TOKEN;
 829     }
 830     ASSERT(Token);
 831
 832     /* Query the LUID */
 833     Status = SeQueryAuthenticationIdToken(Token, Luid);
 834
 835     /* Get rid of the token and return */
 836     ObDereferenceObject(Token);
 837     return Status;
 838 }
 839
 840 /* EOF */