BOOL
APIENTRY
NtUserGetCaretPos(
LPPOINT lpPoint)
{
PTHREADINFO pti;
PUSER_MESSAGE_QUEUE ThreadQueue;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
TRACE("Enter NtUserGetCaretPos\n");
UserEnterShared();
pti = PsGetCurrentThreadWin32Thread();
ThreadQueue = pti->MessageQueue;
Status = MmCopyToCaller(lpPoint, &(ThreadQueue->CaretInfo->Pos), sizeof(POINT));
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN(FALSE);
}
RETURN(TRUE);
CLEANUP:
TRACE("Leave NtUserGetCaretPos, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
BOOL
APIENTRY
NtUserSBGetParms(
HWND hWnd,
int fnBar,
PSBDATA pSBData,
LPSCROLLINFO lpsi)
{
NTSTATUS Status;
PWND Window;
SCROLLINFO psi;
DWORD sz;
BOOL Ret;
DECLARE_RETURN(BOOL);
USER_REFERENCE_ENTRY Ref;
TRACE("Enter NtUserGetScrollInfo\n");
UserEnterExclusive();
Status = MmCopyFromCaller(&psi.cbSize, &(lpsi->cbSize), sizeof(UINT));
if(!NT_SUCCESS(Status) ||
!((psi.cbSize == sizeof(SCROLLINFO)) || (psi.cbSize == sizeof(SCROLLINFO) - sizeof(psi.nTrackPos))))
{
SetLastNtError(Status);
RETURN(FALSE);
}
sz = psi.cbSize;
Status = MmCopyFromCaller(&psi, lpsi, sz);
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN(FALSE);
}
if(!(Window = UserGetWindowObject(hWnd)))
{
RETURN(FALSE);
}
UserRefObjectCo(Window, &Ref);
Ret = co_IntGetScrollInfo(Window, fnBar, &psi);
UserDerefObjectCo(Window);
Status = MmCopyToCaller(lpsi, &psi, sz);
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN( FALSE);
}
RETURN( Ret);
CLEANUP:
TRACE("Leave NtUserGetScrollInfo, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
BOOL
APIENTRY
NtUserGetScrollBarInfo(HWND hWnd, LONG idObject, PSCROLLBARINFO psbi)
{
NTSTATUS Status;
SCROLLBARINFO sbi;
PWND Window;
BOOL Ret;
DECLARE_RETURN(BOOL);
USER_REFERENCE_ENTRY Ref;
TRACE("Enter NtUserGetScrollBarInfo\n");
UserEnterExclusive();
Status = MmCopyFromCaller(&sbi, psbi, sizeof(SCROLLBARINFO));
if(!NT_SUCCESS(Status) || (sbi.cbSize != sizeof(SCROLLBARINFO)))
{
SetLastNtError(Status);
RETURN(FALSE);
}
if(!(Window = UserGetWindowObject(hWnd)))
{
RETURN(FALSE);
}
UserRefObjectCo(Window, &Ref);
Ret = co_IntGetScrollBarInfo(Window, idObject, &sbi);
UserDerefObjectCo(Window);
Status = MmCopyToCaller(psbi, &sbi, sizeof(SCROLLBARINFO));
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
Ret = FALSE;
}
RETURN( Ret);
CLEANUP:
TRACE("Leave NtUserGetScrollBarInfo, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
BOOL FASTCALL
IntSwitchCaretShowing(PVOID Info)
{
PTHREADINFO pti;
PUSER_MESSAGE_QUEUE ThreadQueue;
pti = PsGetCurrentThreadWin32Thread();
ThreadQueue = pti->MessageQueue;
if(ThreadQueue->CaretInfo->hWnd)
{
ThreadQueue->CaretInfo->Showing = (ThreadQueue->CaretInfo->Showing ? 0 : 1);
MmCopyToCaller(Info, ThreadQueue->CaretInfo, sizeof(THRDCARETINFO));
return TRUE;
}
return FALSE;
}
/*
* @implemented
*/
BOOL
APIENTRY
NtUserGetClipCursor(
RECTL *lpRect)
{
/* FIXME: Check if process has WINSTA_READATTRIBUTES */
PSYSTEM_CURSORINFO CurInfo;
RECTL Rect;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
TRACE("Enter NtUserGetClipCursor\n");
UserEnterExclusive();
if (!lpRect)
RETURN(FALSE);
CurInfo = IntGetSysCursorInfo();
if (CurInfo->bClipped)
{
Rect = CurInfo->rcClip;
}
else
{
Rect.left = 0;
Rect.top = 0;
Rect.right = UserGetSystemMetrics(SM_CXSCREEN);
Rect.bottom = UserGetSystemMetrics(SM_CYSCREEN);
}
Status = MmCopyToCaller(lpRect, &Rect, sizeof(RECT));
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN(FALSE);
}
RETURN(TRUE);
CLEANUP:
TRACE("Leave NtUserGetClipCursor, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
BOOL
APIENTRY
NtUserGetGUIThreadInfo(
DWORD idThread, /* If NULL use foreground thread */
LPGUITHREADINFO lpgui)
{
NTSTATUS Status;
PTHRDCARETINFO CaretInfo;
GUITHREADINFO SafeGui;
PDESKTOP Desktop;
PUSER_MESSAGE_QUEUE MsgQueue;
PTHREADINFO W32Thread;
PETHREAD Thread = NULL;
DECLARE_RETURN(BOOLEAN);
TRACE("Enter NtUserGetGUIThreadInfo\n");
UserEnterShared();
Status = MmCopyFromCaller(&SafeGui, lpgui, sizeof(DWORD));
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN( FALSE);
}
if(SafeGui.cbSize != sizeof(GUITHREADINFO))
{
EngSetLastError(ERROR_INVALID_PARAMETER);
RETURN( FALSE);
}
if (idThread)
{
Status = PsLookupThreadByThreadId((HANDLE)(DWORD_PTR)idThread, &Thread);
if(!NT_SUCCESS(Status))
{
EngSetLastError(ERROR_ACCESS_DENIED);
RETURN( FALSE);
}
W32Thread = (PTHREADINFO)Thread->Tcb.Win32Thread;
Desktop = W32Thread->rpdesk;
if (!Thread || !Desktop )
{
if(Thread)
ObDereferenceObject(Thread);
EngSetLastError(ERROR_ACCESS_DENIED);
RETURN( FALSE);
}
if ( W32Thread->MessageQueue )
MsgQueue = W32Thread->MessageQueue;
else
{
if ( Desktop ) MsgQueue = Desktop->ActiveMessageQueue;
}
}
else
{ /* Get the foreground thread */
/* FIXME: Handle NULL queue properly? */
MsgQueue = IntGetFocusMessageQueue();
if(!MsgQueue)
{
EngSetLastError(ERROR_ACCESS_DENIED);
RETURN( FALSE);
}
}
CaretInfo = &MsgQueue->CaretInfo;
SafeGui.flags = (CaretInfo->Visible ? GUI_CARETBLINKING : 0);
/*
if (W32Thread->pMenuState->pGlobalPopupMenu)
{
SafeGui.flags |= GUI_INMENUMODE;
if (W32Thread->pMenuState->pGlobalPopupMenu->spwndNotify)
SafeGui.hwndMenuOwner = UserHMGetHandle(W32Thread->pMenuState->pGlobalPopupMenu->spwndNotify);
if (W32Thread->pMenuState->pGlobalPopupMenu->fHasMenuBar)
{
if (W32Thread->pMenuState->pGlobalPopupMenu->fIsSysMenu)
{
SafeGui.flags |= GUI_SYSTEMMENUMODE;
}
}
else
{
SafeGui.flags |= GUI_POPUPMENUMODE;
}
}
*/
SafeGui.hwndMenuOwner = MsgQueue->MenuOwner;
if (MsgQueue->MenuOwner)
SafeGui.flags |= GUI_INMENUMODE | MsgQueue->MenuState;
if (MsgQueue->MoveSize)
SafeGui.flags |= GUI_INMOVESIZE;
/* FIXME: Add flag GUI_16BITTASK */
SafeGui.hwndActive = MsgQueue->spwndActive ? UserHMGetHandle(MsgQueue->spwndActive) : 0;
SafeGui.hwndFocus = MsgQueue->spwndFocus ? UserHMGetHandle(MsgQueue->spwndFocus) : 0;
SafeGui.hwndCapture = MsgQueue->spwndCapture ? UserHMGetHandle(MsgQueue->spwndCapture) : 0;
SafeGui.hwndMoveSize = MsgQueue->MoveSize;
SafeGui.hwndCaret = CaretInfo->hWnd;
SafeGui.rcCaret.left = CaretInfo->Pos.x;
SafeGui.rcCaret.top = CaretInfo->Pos.y;
SafeGui.rcCaret.right = SafeGui.rcCaret.left + CaretInfo->Size.cx;
SafeGui.rcCaret.bottom = SafeGui.rcCaret.top + CaretInfo->Size.cy;
if (idThread)
ObDereferenceObject(Thread);
Status = MmCopyToCaller(lpgui, &SafeGui, sizeof(GUITHREADINFO));
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN( FALSE);
}
RETURN( TRUE);
CLEANUP:
TRACE("Leave NtUserGetGUIThreadInfo, ret=%u\n",_ret_);
UserLeave();
END_CLEANUP;
}
NTSTATUS APIENTRY
NtUserBuildPropList(HWND hWnd,
LPVOID Buffer,
DWORD BufferSize,
DWORD *Count)
{
PWND Window;
PPROPERTY Property;
PLIST_ENTRY ListEntry;
PROPLISTITEM listitem, *li;
NTSTATUS Status;
DWORD Cnt = 0;
DECLARE_RETURN(NTSTATUS);
TRACE("Enter NtUserBuildPropList\n");
UserEnterShared();
if (!(Window = UserGetWindowObject(hWnd)))
{
RETURN( STATUS_INVALID_HANDLE);
}
if(Buffer)
{
if(!BufferSize || (BufferSize % sizeof(PROPLISTITEM) != 0))
{
RETURN( STATUS_INVALID_PARAMETER);
}
/* copy list */
li = (PROPLISTITEM *)Buffer;
ListEntry = Window->PropListHead.Flink;
while((BufferSize >= sizeof(PROPLISTITEM)) && (ListEntry != &Window->PropListHead))
{
Property = CONTAINING_RECORD(ListEntry, PROPERTY, PropListEntry);
listitem.Atom = Property->Atom;
listitem.Data = Property->Data;
Status = MmCopyToCaller(li, &listitem, sizeof(PROPLISTITEM));
if(!NT_SUCCESS(Status))
{
RETURN( Status);
}
BufferSize -= sizeof(PROPLISTITEM);
Cnt++;
li++;
ListEntry = ListEntry->Flink;
}
}
else
{
Cnt = Window->PropListItems * sizeof(PROPLISTITEM);
}
if(Count)
{
Status = MmCopyToCaller(Count, &Cnt, sizeof(DWORD));
if(!NT_SUCCESS(Status))
{
RETURN( Status);
}
}
RETURN( STATUS_SUCCESS);
CLEANUP:
TRACE("Leave NtUserBuildPropList, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
/* NtUserGetMonitorInfo
*
* Retrieves information about a given monitor
*
* Arguments
*
* hMonitor
* Handle to a monitor for which to get information
*
* pMonitorInfo
* Pointer to a MONITORINFO struct which is filled with the information.
* The cbSize member must be set to sizeof(MONITORINFO) or
* sizeof(MONITORINFOEX). Even if set to sizeof(MONITORINFOEX) only parts
* from MONITORINFO will be filled.
*
* pDevice
* Pointer to a UNICODE_STRING which will recieve the device's name. The
* length should be CCHDEVICENAME
* Can be NULL
*
* Return value
* TRUE on success; FALSE on failure (calls SetLastNtError())
*
*/
BOOL
APIENTRY
NtUserGetMonitorInfo(
IN HMONITOR hMonitor,
OUT LPMONITORINFO pMonitorInfo)
{
PMONITOR Monitor;
MONITORINFOEXW MonitorInfo;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
TRACE("Enter NtUserGetMonitorInfo\n");
UserEnterShared();
/* get monitor object */
if (!(Monitor = UserGetMonitorObject(hMonitor)))
{
TRACE("Couldnt find monitor 0x%lx\n", hMonitor);
RETURN(FALSE);
}
if(pMonitorInfo == NULL)
{
SetLastNtError(STATUS_INVALID_PARAMETER);
RETURN(FALSE);
}
/* get size of pMonitorInfo */
Status = MmCopyFromCaller(&MonitorInfo.cbSize, &pMonitorInfo->cbSize, sizeof (MonitorInfo.cbSize));
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
RETURN(FALSE);
}
if ((MonitorInfo.cbSize != sizeof (MONITORINFO)) &&
(MonitorInfo.cbSize != sizeof (MONITORINFOEXW)))
{
SetLastNtError(STATUS_INVALID_PARAMETER);
RETURN(FALSE);
}
/* fill monitor info */
MonitorInfo.rcMonitor = Monitor->rcMonitor;
MonitorInfo.rcWork = Monitor->rcWork;
MonitorInfo.dwFlags = 0;
if (Monitor->IsPrimary)
MonitorInfo.dwFlags |= MONITORINFOF_PRIMARY;
/* fill device name */
if (MonitorInfo.cbSize == sizeof (MONITORINFOEXW))
{
RtlStringCbCopyNW(MonitorInfo.szDevice,
sizeof(MonitorInfo.szDevice),
Monitor->DeviceName.Buffer,
Monitor->DeviceName.Length);
}
/* output data */
Status = MmCopyToCaller(pMonitorInfo, &MonitorInfo, MonitorInfo.cbSize);
if (!NT_SUCCESS(Status))
{
TRACE("GetMonitorInfo: MmCopyToCaller failed\n");
SetLastNtError(Status);
RETURN(FALSE);
}
TRACE("GetMonitorInfo: success\n");
RETURN(TRUE);
CLEANUP:
TRACE("Leave NtUserGetMonitorInfo, ret=%i\n",_ret_);
UserLeave();
END_CLEANUP;
}
/* NtUserEnumDisplayMonitors
*
* Enumerates display monitors which intersect the given HDC/cliprect
*
* Arguments
*
* hDC
* Handle to a DC for which to enum intersecting monitors. If this is NULL
* it returns all monitors which are part of the current virtual screen.
*
* pRect
* Clipping rectangle with coordinate system origin at the DCs origin if the
* given HDC is not NULL or in virtual screen coordinated if it is NULL.
* Can be NULL
*
* hMonitorList
* Pointer to an array of HMONITOR which is filled with monitor handles.
* Can be NULL
*
* monitorRectList
* Pointer to an array of RECT which is filled with intersection rectangles.
* Can be NULL
*
* listSize
* Size of the hMonitorList and monitorRectList arguments. If this is zero
* hMonitorList and monitorRectList are ignored.
*
* Returns
* The number of monitors which intersect the specified region or -1 on failure.
*/
INT
APIENTRY
NtUserEnumDisplayMonitors(
OPTIONAL IN HDC hDC,
OPTIONAL IN LPCRECTL pRect,
OPTIONAL OUT HMONITOR *hMonitorList,
OPTIONAL OUT PRECTL monitorRectList,
OPTIONAL IN DWORD listSize)
{
INT numMonitors, i;
HMONITOR *safeHMonitorList = NULL;
PRECTL safeRectList = NULL;
RECTL rect, *myRect;
RECTL dcRect;
NTSTATUS status;
/* get rect */
if (pRect != NULL)
{
status = MmCopyFromCaller(&rect, pRect, sizeof (RECT));
if (!NT_SUCCESS(status))
{
TRACE("MmCopyFromCaller() failed!\n");
SetLastNtError(status);
return -1;
}
}
if (hDC != NULL)
{
PDC dc;
INT regionType;
/* get visible region bounding rect */
dc = DC_LockDc(hDC);
if (dc == NULL)
{
TRACE("DC_LockDc() failed!\n");
/* FIXME: setlasterror? */
return -1;
}
regionType = REGION_GetRgnBox(dc->prgnVis, &dcRect);
DC_UnlockDc(dc);
if (regionType == 0)
{
TRACE("NtGdiGetRgnBox() failed!\n");
return -1;
}
if (regionType == NULLREGION)
return 0;
if (regionType == COMPLEXREGION)
{
/* TODO: warning */
}
/* if hDC and pRect are given the area of interest is pRect with
coordinate origin at the DC position */
if (pRect != NULL)
{
rect.left += dcRect.left;
rect.right += dcRect.left;
rect.top += dcRect.top;
rect.bottom += dcRect.top;
}
/* if hDC is given and pRect is not the area of interest is the
bounding rect of hDC */
else
{
rect = dcRect;
}
}
if (hDC == NULL && pRect == NULL)
myRect = NULL;
else
myRect = ▭
/* find intersecting monitors */
numMonitors = IntGetMonitorsFromRect(myRect, NULL, NULL, 0, 0);
if (numMonitors == 0 || listSize == 0 ||
(hMonitorList == NULL && monitorRectList == NULL))
{
TRACE("numMonitors = %d\n", numMonitors);
return numMonitors;
}
if (hMonitorList != NULL && listSize != 0)
{
safeHMonitorList = ExAllocatePoolWithTag(PagedPool, sizeof (HMONITOR) * listSize, USERTAG_MONITORRECTS);
if (safeHMonitorList == NULL)
{
/* FIXME: EngSetLastError? */
return -1;
}
}
if (monitorRectList != NULL && listSize != 0)
{
safeRectList = ExAllocatePoolWithTag(PagedPool, sizeof (RECT) * listSize, USERTAG_MONITORRECTS);
if (safeRectList == NULL)
{
ExFreePoolWithTag(safeHMonitorList, USERTAG_MONITORRECTS);
/* FIXME: EngSetLastError? */
return -1;
}
}
/* get intersecting monitors */
numMonitors = IntGetMonitorsFromRect(myRect, safeHMonitorList, safeRectList,
listSize, 0 );
if (hDC != NULL && pRect != NULL && safeRectList != NULL)
for (i = 0; i < numMonitors; i++)
{
safeRectList[i].left -= dcRect.left;
safeRectList[i].right -= dcRect.left;
safeRectList[i].top -= dcRect.top;
safeRectList[i].bottom -= dcRect.top;
}
/* output result */
if (hMonitorList != NULL && listSize != 0)
{
status = MmCopyToCaller(hMonitorList, safeHMonitorList, sizeof (HMONITOR) * listSize);
ExFreePool(safeHMonitorList);
if (!NT_SUCCESS(status))
{
ExFreePoolWithTag(safeRectList, USERTAG_MONITORRECTS);
SetLastNtError(status);
return -1;
}
}
if (monitorRectList != NULL && listSize != 0)
{
status = MmCopyToCaller(monitorRectList, safeRectList, sizeof (RECT) * listSize);
ExFreePoolWithTag(safeRectList, USERTAG_MONITORRECTS);
if (!NT_SUCCESS(status))
{
SetLastNtError(status);
return -1;
}
}
return numMonitors;
}
static NTSTATUS FASTCALL
BuildDesktopNameList(
HWINSTA hWindowStation,
ULONG dwSize,
PVOID lpBuffer,
PULONG pRequiredSize)
{
NTSTATUS Status;
PWINSTATION_OBJECT WindowStation;
PLIST_ENTRY DesktopEntry;
PDESKTOP DesktopObject;
DWORD EntryCount;
ULONG ReturnLength;
WCHAR NullWchar;
UNICODE_STRING DesktopName;
Status = IntValidateWindowStationHandle(hWindowStation,
UserMode,
0,
&WindowStation,
0);
if (! NT_SUCCESS(Status))
{
return Status;
}
/*
* Count the required size of buffer.
*/
ReturnLength = sizeof(DWORD);
EntryCount = 0;
for (DesktopEntry = WindowStation->DesktopListHead.Flink;
DesktopEntry != &WindowStation->DesktopListHead;
DesktopEntry = DesktopEntry->Flink)
{
DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
RtlInitUnicodeString(&DesktopName, DesktopObject->pDeskInfo->szDesktopName);
ReturnLength += DesktopName.Length + sizeof(WCHAR);
EntryCount++;
}
TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
if (NULL != pRequiredSize)
{
Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
if (! NT_SUCCESS(Status))
{
ObDereferenceObject(WindowStation);
return STATUS_BUFFER_TOO_SMALL;
}
}
/*
* Check if the supplied buffer is large enough.
*/
if (dwSize < ReturnLength)
{
ObDereferenceObject(WindowStation);
return STATUS_BUFFER_TOO_SMALL;
}
/*
* Generate the resulting buffer contents.
*/
Status = MmCopyToCaller(lpBuffer, &EntryCount, sizeof(DWORD));
if (! NT_SUCCESS(Status))
{
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(DWORD));
NullWchar = L'\0';
for (DesktopEntry = WindowStation->DesktopListHead.Flink;
DesktopEntry != &WindowStation->DesktopListHead;
DesktopEntry = DesktopEntry->Flink)
{
DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
RtlInitUnicodeString(&DesktopName, DesktopObject->pDeskInfo->szDesktopName);
Status = MmCopyToCaller(lpBuffer, DesktopName.Buffer, DesktopName.Length);
if (! NT_SUCCESS(Status))
{
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR)lpBuffer + DesktopName.Length);
Status = MmCopyToCaller(lpBuffer, &NullWchar, sizeof(WCHAR));
if (! NT_SUCCESS(Status))
{
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(WCHAR));
}
/*
* Clean up and return
*/
ObDereferenceObject(WindowStation);
return STATUS_SUCCESS;
}
static NTSTATUS FASTCALL
BuildWindowStationNameList(
ULONG dwSize,
PVOID lpBuffer,
PULONG pRequiredSize)
{
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
HANDLE DirectoryHandle;
char InitialBuffer[256], *Buffer;
ULONG Context, ReturnLength, BufferSize;
DWORD EntryCount;
POBJECT_DIRECTORY_INFORMATION DirEntry;
WCHAR NullWchar;
/*
* Try to open the directory.
*/
InitializeObjectAttributes(&ObjectAttributes,
&gustrWindowStationsDir,
OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL);
Status = ZwOpenDirectoryObject(&DirectoryHandle,
DIRECTORY_QUERY,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
return Status;
}
/* First try to query the directory using a fixed-size buffer */
Context = 0;
Buffer = NULL;
Status = ZwQueryDirectoryObject(DirectoryHandle,
InitialBuffer,
sizeof(InitialBuffer),
FALSE,
TRUE,
&Context,
&ReturnLength);
if (NT_SUCCESS(Status))
{
if (STATUS_NO_MORE_ENTRIES == ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE,
FALSE, &Context, NULL))
{
/* Our fixed-size buffer is large enough */
Buffer = InitialBuffer;
}
}
if (NULL == Buffer)
{
/* Need a larger buffer, check how large exactly */
Status = ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE, TRUE, &Context,
&ReturnLength);
if (!NT_SUCCESS(Status))
{
ERR("ZwQueryDirectoryObject failed\n");
ZwClose(DirectoryHandle);
return Status;
}
BufferSize = ReturnLength;
Buffer = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_WINSTA);
if (NULL == Buffer)
{
ZwClose(DirectoryHandle);
return STATUS_NO_MEMORY;
}
/* We should have a sufficiently large buffer now */
Context = 0;
Status = ZwQueryDirectoryObject(DirectoryHandle, Buffer, BufferSize,
FALSE, TRUE, &Context, &ReturnLength);
if (! NT_SUCCESS(Status) ||
STATUS_NO_MORE_ENTRIES != ZwQueryDirectoryObject(DirectoryHandle, NULL, 0, FALSE,
FALSE, &Context, NULL))
{
/* Something went wrong, maybe someone added a directory entry? Just give up. */
ExFreePoolWithTag(Buffer, TAG_WINSTA);
ZwClose(DirectoryHandle);
return NT_SUCCESS(Status) ? STATUS_INTERNAL_ERROR : Status;
}
}
ZwClose(DirectoryHandle);
/*
* Count the required size of buffer.
*/
ReturnLength = sizeof(DWORD);
EntryCount = 0;
for (DirEntry = (POBJECT_DIRECTORY_INFORMATION) Buffer;
0 != DirEntry->Name.Length;
DirEntry++)
{
ReturnLength += DirEntry->Name.Length + sizeof(WCHAR);
EntryCount++;
}
TRACE("Required size: %lu Entry count: %lu\n", ReturnLength, EntryCount);
if (NULL != pRequiredSize)
{
Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
if (! NT_SUCCESS(Status))
{
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return STATUS_BUFFER_TOO_SMALL;
}
}
/*
* Check if the supplied buffer is large enough.
*/
if (dwSize < ReturnLength)
{
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return STATUS_BUFFER_TOO_SMALL;
}
/*
* Generate the resulting buffer contents.
*/
Status = MmCopyToCaller(lpBuffer, &EntryCount, sizeof(DWORD));
if (! NT_SUCCESS(Status))
{
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(DWORD));
NullWchar = L'\0';
for (DirEntry = (POBJECT_DIRECTORY_INFORMATION) Buffer;
0 != DirEntry->Name.Length;
DirEntry++)
{
Status = MmCopyToCaller(lpBuffer, DirEntry->Name.Buffer, DirEntry->Name.Length);
if (! NT_SUCCESS(Status))
{
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + DirEntry->Name.Length);
Status = MmCopyToCaller(lpBuffer, &NullWchar, sizeof(WCHAR));
if (! NT_SUCCESS(Status))
{
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(WCHAR));
}
/*
* Clean up
*/
if (Buffer != InitialBuffer)
{
ExFreePoolWithTag(Buffer, TAG_WINSTA);
}
return STATUS_SUCCESS;
}
/* NtUserGetMonitorInfo
*
* Retrieves information about a given monitor
*
* Arguments
*
* hMonitor
* Handle to a monitor for which to get information
*
* pMonitorInfoUnsafe
* Pointer to a MONITORINFO struct which is filled with the information.
* The cbSize member must be set to sizeof(MONITORINFO) or
* sizeof(MONITORINFOEX). Even if set to sizeof(MONITORINFOEX) only parts
* from MONITORINFO will be filled.
*
* pDevice
* Pointer to a UNICODE_STRING which will receive the device's name. The
* length should be CCHDEVICENAME
* Can be NULL
*
* Return value
* TRUE on success; FALSE on failure (calls SetLastNtError())
*
*/
BOOL
APIENTRY
NtUserGetMonitorInfo(
IN HMONITOR hMonitor,
OUT LPMONITORINFO pMonitorInfoUnsafe)
{
PMONITOR pMonitor;
MONITORINFOEXW MonitorInfo;
NTSTATUS Status;
BOOL bRet = FALSE;
PWCHAR pwstrDeviceName;
TRACE("Enter NtUserGetMonitorInfo\n");
UserEnterShared();
/* Get monitor object */
pMonitor = UserGetMonitorObject(hMonitor);
if (!pMonitor)
{
TRACE("Couldnt find monitor %p\n", hMonitor);
goto cleanup;
}
/* Check if pMonitorInfoUnsafe is valid */
if(pMonitorInfoUnsafe == NULL)
{
SetLastNtError(STATUS_INVALID_PARAMETER);
goto cleanup;
}
pwstrDeviceName = ((PPDEVOBJ)(pMonitor->hDev))->pGraphicsDevice->szWinDeviceName;
/* Get size of pMonitorInfoUnsafe */
Status = MmCopyFromCaller(&MonitorInfo.cbSize, &pMonitorInfoUnsafe->cbSize, sizeof(MonitorInfo.cbSize));
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
goto cleanup;
}
/* Check if size of struct is valid */
if (MonitorInfo.cbSize != sizeof(MONITORINFO) &&
MonitorInfo.cbSize != sizeof(MONITORINFOEXW))
{
SetLastNtError(STATUS_INVALID_PARAMETER);
goto cleanup;
}
/* Fill monitor info */
MonitorInfo.rcMonitor = pMonitor->rcMonitor;
MonitorInfo.rcWork = pMonitor->rcWork;
MonitorInfo.dwFlags = 0;
if (pMonitor->IsPrimary)
MonitorInfo.dwFlags |= MONITORINFOF_PRIMARY;
/* Fill device name */
if (MonitorInfo.cbSize == sizeof(MONITORINFOEXW))
{
RtlStringCbCopyNExW(MonitorInfo.szDevice,
sizeof(MonitorInfo.szDevice),
pwstrDeviceName,
(wcslen(pwstrDeviceName)+1) * sizeof(WCHAR),
NULL, NULL, STRSAFE_FILL_BEHIND_NULL);
}
/* Output data */
Status = MmCopyToCaller(pMonitorInfoUnsafe, &MonitorInfo, MonitorInfo.cbSize);
if (!NT_SUCCESS(Status))
{
TRACE("GetMonitorInfo: MmCopyToCaller failed\n");
SetLastNtError(Status);
goto cleanup;
}
TRACE("GetMonitorInfo: success\n");
bRet = TRUE;
cleanup:
TRACE("Leave NtUserGetMonitorInfo, ret=%i\n", bRet);
UserLeave();
return bRet;
}
/* NtUserEnumDisplayMonitors
*
* Enumerates display monitors which intersect the given HDC/cliprect
*
* Arguments
*
* hdc
* Handle to a DC for which to enum intersecting monitors. If this is NULL
* it returns all monitors which are part of the current virtual screen.
*
* pUnsafeRect
* Clipping rectangle with coordinate system origin at the DCs origin if the
* given HDC is not NULL or in virtual screen coordinated if it is NULL.
* Can be NULL
*
* phUnsafeMonitorList
* Pointer to an array of HMONITOR which is filled with monitor handles.
* Can be NULL
*
* prcUnsafeMonitorList
* Pointer to an array of RECT which is filled with intersection rectangles.
* Can be NULL
*
* dwListSize
* Size of the hMonitorList and monitorRectList arguments. If this is zero
* hMonitorList and monitorRectList are ignored.
*
* Returns
* The number of monitors which intersect the specified region or -1 on failure.
*/
INT
APIENTRY
NtUserEnumDisplayMonitors(
OPTIONAL IN HDC hdc,
OPTIONAL IN LPCRECTL pUnsafeRect,
OPTIONAL OUT HMONITOR *phUnsafeMonitorList,
OPTIONAL OUT PRECTL prcUnsafeMonitorList,
OPTIONAL IN DWORD dwListSize)
{
INT cMonitors, iRet = -1, i;
HMONITOR *phMonitorList = NULL;
PRECTL prcMonitorList = NULL;
RECTL rc, *pRect;
RECTL DcRect = {0};
NTSTATUS Status;
/* Get rectangle */
if (pUnsafeRect != NULL)
{
Status = MmCopyFromCaller(&rc, pUnsafeRect, sizeof(RECT));
if (!NT_SUCCESS(Status))
{
TRACE("MmCopyFromCaller() failed!\n");
SetLastNtError(Status);
return -1;
}
}
if (hdc != NULL)
{
PDC pDc;
INT iRgnType;
/* Get visible region bounding rect */
pDc = DC_LockDc(hdc);
if (pDc == NULL)
{
TRACE("DC_LockDc() failed!\n");
/* FIXME: setlasterror? */
return -1;
}
iRgnType = REGION_GetRgnBox(pDc->prgnVis, &DcRect);
DC_UnlockDc(pDc);
if (iRgnType == 0)
{
TRACE("NtGdiGetRgnBox() failed!\n");
return -1;
}
if (iRgnType == NULLREGION)
return 0;
if (iRgnType == COMPLEXREGION)
{
/* TODO: Warning */
}
/* If hdc and pRect are given the area of interest is pRect with
coordinate origin at the DC position */
if (pUnsafeRect != NULL)
{
rc.left += DcRect.left;
rc.right += DcRect.left;
rc.top += DcRect.top;
rc.bottom += DcRect.top;
}
/* If hdc is given and pRect is not the area of interest is the
bounding rect of hdc */
else
{
rc = DcRect;
}
}
if (hdc == NULL && pUnsafeRect == NULL)
pRect = NULL;
else
pRect = &rc;
UserEnterShared();
/* Find intersecting monitors */
cMonitors = IntGetMonitorsFromRect(pRect, NULL, NULL, 0, MONITOR_DEFAULTTONULL);
if (cMonitors == 0 || dwListSize == 0 ||
(phUnsafeMonitorList == NULL && prcUnsafeMonitorList == NULL))
{
/* Simple case - just return monitors count */
TRACE("cMonitors = %d\n", cMonitors);
iRet = cMonitors;
goto cleanup;
}
/* Allocate safe buffers */
if (phUnsafeMonitorList != NULL && dwListSize != 0)
{
phMonitorList = ExAllocatePoolWithTag(PagedPool, sizeof (HMONITOR) * dwListSize, USERTAG_MONITORRECTS);
if (phMonitorList == NULL)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto cleanup;
}
}
if (prcUnsafeMonitorList != NULL && dwListSize != 0)
{
prcMonitorList = ExAllocatePoolWithTag(PagedPool, sizeof (RECT) * dwListSize, USERTAG_MONITORRECTS);
if (prcMonitorList == NULL)
{
EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto cleanup;
}
}
/* Get intersecting monitors */
cMonitors = IntGetMonitorsFromRect(pRect, phMonitorList, prcMonitorList,
dwListSize, MONITOR_DEFAULTTONULL);
if (hdc != NULL && pRect != NULL && prcMonitorList != NULL)
for (i = 0; i < cMonitors; i++)
{
prcMonitorList[i].left -= DcRect.left;
prcMonitorList[i].right -= DcRect.left;
prcMonitorList[i].top -= DcRect.top;
prcMonitorList[i].bottom -= DcRect.top;
}
/* Output result */
if (phUnsafeMonitorList != NULL && dwListSize != 0)
{
Status = MmCopyToCaller(phUnsafeMonitorList, phMonitorList, sizeof(HMONITOR) * dwListSize);
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
goto cleanup;
}
}
if (prcUnsafeMonitorList != NULL && dwListSize != 0)
{
Status = MmCopyToCaller(prcUnsafeMonitorList, prcMonitorList, sizeof(RECT) * dwListSize);
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
goto cleanup;
}
}
/* Return monitors count on success */
iRet = cMonitors;
cleanup:
if (phMonitorList)
ExFreePoolWithTag(phMonitorList, USERTAG_MONITORRECTS);
if (prcMonitorList)
ExFreePoolWithTag(prcMonitorList, USERTAG_MONITORRECTS);
UserLeave();
return iRet;
}
BOOL APIENTRY
NtUserGetObjectInformation(
HANDLE hObject,
DWORD nIndex,
PVOID pvInformation,
DWORD nLength,
PDWORD nLengthNeeded)
{
PWINSTATION_OBJECT WinStaObject = NULL;
PDESKTOP DesktopObject = NULL;
NTSTATUS Status;
PVOID pvData = NULL;
DWORD nDataSize = 0;
/* try windowstation */
TRACE("Trying to open window station 0x%x\n", hObject);
Status = ObReferenceObjectByHandle(
hObject,
0,
ExWindowStationObjectType,
UserMode,
(PVOID*)&WinStaObject,
NULL);
if (Status == STATUS_OBJECT_TYPE_MISMATCH)
{
/* try desktop */
TRACE("Trying to open desktop 0x%x\n", hObject);
Status = IntValidateDesktopHandle(
hObject,
UserMode,
0,
&DesktopObject);
}
if (!NT_SUCCESS(Status))
{
ERR("Failed: 0x%x\n", Status);
SetLastNtError(Status);
return FALSE;
}
TRACE("WinSta or Desktop opened!!\n");
/* get data */
switch (nIndex)
{
case UOI_FLAGS:
Status = STATUS_NOT_IMPLEMENTED;
ERR("UOI_FLAGS unimplemented!\n");
break;
case UOI_NAME:
if (WinStaObject != NULL)
{
pvData = WinStaObject->Name.Buffer;
nDataSize = WinStaObject->Name.Length + sizeof(WCHAR);
Status = STATUS_SUCCESS;
}
else if (DesktopObject != NULL)
{
pvData = DesktopObject->pDeskInfo->szDesktopName;
nDataSize = (wcslen(DesktopObject->pDeskInfo->szDesktopName) + 1) * sizeof(WCHAR);
Status = STATUS_SUCCESS;
}
else
Status = STATUS_INVALID_PARAMETER;
break;
case UOI_TYPE:
if (WinStaObject != NULL)
{
pvData = L"WindowStation";
nDataSize = sizeof(L"WindowStation");
Status = STATUS_SUCCESS;
}
else if (DesktopObject != NULL)
{
pvData = L"Desktop";
nDataSize = sizeof(L"Desktop");
Status = STATUS_SUCCESS;
}
else
Status = STATUS_INVALID_PARAMETER;
break;
case UOI_USER_SID:
Status = STATUS_NOT_IMPLEMENTED;
ERR("UOI_USER_SID unimplemented!\n");
break;
default:
Status = STATUS_INVALID_PARAMETER;
break;
}
/* try to copy data to caller */
if (Status == STATUS_SUCCESS)
{
TRACE("Trying to copy data to caller (len = %d, len needed = %d)\n", nLength, nDataSize);
*nLengthNeeded = nDataSize;
if (nLength >= nDataSize)
Status = MmCopyToCaller(pvInformation, pvData, nDataSize);
else
Status = STATUS_BUFFER_TOO_SMALL;
}
/* release objects */
if (WinStaObject != NULL)
ObDereferenceObject(WinStaObject);
if (DesktopObject != NULL)
ObDereferenceObject(DesktopObject);
if (!NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
return TRUE;
}
static NTSTATUS FASTCALL
BuildDesktopNameList(
HWINSTA hWindowStation,
ULONG dwSize,
PVOID lpBuffer,
PULONG pRequiredSize)
{
NTSTATUS Status;
PWINSTATION_OBJECT WindowStation;
KIRQL OldLevel;
PLIST_ENTRY DesktopEntry;
PDESKTOP DesktopObject;
DWORD EntryCount;
ULONG ReturnLength;
WCHAR NullWchar;
PUNICODE_STRING DesktopName;
Status = IntValidateWindowStationHandle(hWindowStation,
KernelMode,
0,
&WindowStation);
if (! NT_SUCCESS(Status))
{
return Status;
}
KeAcquireSpinLock(&WindowStation->Lock, &OldLevel);
/*
* Count the required size of buffer.
*/
ReturnLength = sizeof(DWORD);
EntryCount = 0;
for (DesktopEntry = WindowStation->DesktopListHead.Flink;
DesktopEntry != &WindowStation->DesktopListHead;
DesktopEntry = DesktopEntry->Flink)
{
DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
DesktopName = GET_DESKTOP_NAME(DesktopObject);
if (DesktopName) ReturnLength += DesktopName->Length + sizeof(WCHAR);
EntryCount++;
}
TRACE("Required size: %d Entry count: %d\n", ReturnLength, EntryCount);
if (NULL != pRequiredSize)
{
Status = MmCopyToCaller(pRequiredSize, &ReturnLength, sizeof(ULONG));
if (! NT_SUCCESS(Status))
{
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return STATUS_BUFFER_TOO_SMALL;
}
}
/*
* Check if the supplied buffer is large enough.
*/
if (dwSize < ReturnLength)
{
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return STATUS_BUFFER_TOO_SMALL;
}
/*
* Generate the resulting buffer contents.
*/
Status = MmCopyToCaller(lpBuffer, &EntryCount, sizeof(DWORD));
if (! NT_SUCCESS(Status))
{
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(DWORD));
NullWchar = L'\0';
for (DesktopEntry = WindowStation->DesktopListHead.Flink;
DesktopEntry != &WindowStation->DesktopListHead;
DesktopEntry = DesktopEntry->Flink)
{
DesktopObject = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
_PRAGMA_WARNING_SUPPRESS(__WARNING_DEREF_NULL_PTR)
DesktopName = GET_DESKTOP_NAME(DesktopObject);/// @todo Don't mess around with the object headers!
if (!DesktopName) continue;
Status = MmCopyToCaller(lpBuffer, DesktopName->Buffer, DesktopName->Length);
if (! NT_SUCCESS(Status))
{
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR)lpBuffer + DesktopName->Length);
Status = MmCopyToCaller(lpBuffer, &NullWchar, sizeof(WCHAR));
if (! NT_SUCCESS(Status))
{
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return Status;
}
lpBuffer = (PVOID) ((PCHAR) lpBuffer + sizeof(WCHAR));
}
/*
* Clean up
*/
KeReleaseSpinLock(&WindowStation->Lock, OldLevel);
ObDereferenceObject(WindowStation);
return STATUS_SUCCESS;
}
