wtsapi32.c File Reference

#include <stdarg.h>
#include <stdlib.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "wine/winternl.h"
#include "wtsapi32.h"
#include "wine/debug.h"
#include "wine/heap.h"

Include dependency graph for wtsapi32.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wtsapi)
void WINAPI	WTSCloseServer (HANDLE hServer)
BOOL WINAPI	WTSConnectSessionA (ULONG LogonId, ULONG TargetLogonId, PSTR pPassword, BOOL bWait)
BOOL WINAPI	WTSConnectSessionW (ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword, BOOL bWait)
BOOL WINAPI	WTSDisconnectSession (HANDLE hServer, DWORD SessionId, BOOL bWait)
BOOL WINAPI	WTSEnableChildSessions (BOOL enable)
BOOL WINAPI	WTSEnumerateProcessesExW (HANDLE server, DWORD *level, DWORD session_id, WCHAR **info, DWORD *count)
BOOL WINAPI	WTSEnumerateProcessesExA (HANDLE server, DWORD *level, DWORD session_id, char **info, DWORD *count)
BOOL WINAPI	WTSEnumerateProcessesA (HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_PROCESS_INFOA *ppProcessInfo, DWORD *pCount)
BOOL WINAPI	WTSEnumerateProcessesW (HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_PROCESS_INFOW *ppProcessInfo, DWORD *pCount)
BOOL WINAPI	WTSEnumerateServersA (LPSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOA *ppServerInfo, DWORD *pCount)
BOOL WINAPI	WTSEnumerateServersW (LPWSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOW *ppServerInfo, DWORD *pCount)
BOOL WINAPI	WTSEnumerateSessionsExW (HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1W *info, DWORD *count)
BOOL WINAPI	WTSEnumerateSessionsExA (HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1A *info, DWORD *count)
BOOL WINAPI	WTSEnumerateSessionsA (HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_SESSION_INFOA *ppSessionInfo, DWORD *pCount)
BOOL WINAPI	WTSEnumerateSessionsW (HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_SESSION_INFOW *ppSessionInfo, DWORD *pCount)
void WINAPI	WTSFreeMemory (PVOID pMemory)
BOOL WINAPI	WTSFreeMemoryExA (WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
BOOL WINAPI	WTSFreeMemoryExW (WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
BOOL WINAPI	WTSLogoffSession (HANDLE hserver, DWORD session_id, BOOL bwait)
HANDLE WINAPI	WTSOpenServerExW (WCHAR *server_name)
HANDLE WINAPI	WTSOpenServerExA (char *server_name)
HANDLE WINAPI	WTSOpenServerA (LPSTR pServerName)
HANDLE WINAPI	WTSOpenServerW (LPWSTR pServerName)
BOOL WINAPI	WTSQuerySessionInformationA (HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPSTR *Buffer, DWORD *BytesReturned)
BOOL WINAPI	WTSQuerySessionInformationW (HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPWSTR *Buffer, DWORD *BytesReturned)
BOOL WINAPI	WTSQueryUserToken (ULONG session_id, PHANDLE token)
BOOL WINAPI	WTSQueryUserConfigA (LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR *ppBuffer, DWORD *pBytesReturned)
BOOL WINAPI	WTSQueryUserConfigW (LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR *ppBuffer, DWORD *pBytesReturned)
BOOL WINAPI	WTSRegisterSessionNotification (HWND hWnd, DWORD dwFlags)
BOOL WINAPI	WTSRegisterSessionNotificationEx (HANDLE hServer, HWND hWnd, DWORD dwFlags)
BOOL WINAPI	WTSSendMessageA (HANDLE hServer, DWORD SessionId, LPSTR pTitle, DWORD TitleLength, LPSTR pMessage, DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
BOOL WINAPI	WTSSendMessageW (HANDLE hServer, DWORD SessionId, LPWSTR pTitle, DWORD TitleLength, LPWSTR pMessage, DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
BOOL WINAPI	WTSSetUserConfigA (LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer, DWORD DataLength)
BOOL WINAPI	WTSSetUserConfigW (LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer, DWORD DataLength)
BOOL WINAPI	WTSShutdownSystem (HANDLE hServer, DWORD ShutdownFlag)
BOOL WINAPI	WTSStartRemoteControlSessionA (LPSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
BOOL WINAPI	WTSStartRemoteControlSessionW (LPWSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
BOOL WINAPI	WTSStopRemoteControlSession (ULONG LogonId)
BOOL WINAPI	WTSTerminateProcess (HANDLE hServer, DWORD ProcessId, DWORD ExitCode)
BOOL WINAPI	WTSUnRegisterSessionNotification (HWND hWnd)
BOOL WINAPI	WTSUnRegisterSessionNotificationEx (HANDLE hServer, HWND hWnd)
BOOL WINAPI	WTSVirtualChannelClose (HANDLE hChannelHandle)
HANDLE WINAPI	WTSVirtualChannelOpen (HANDLE hServer, DWORD SessionId, LPSTR pVirtualName)
HANDLE WINAPI	WTSVirtualChannelOpenEx (DWORD SessionId, LPSTR pVirtualName, DWORD flags)
BOOL WINAPI	WTSVirtualChannelPurgeInput (HANDLE hChannelHandle)
BOOL WINAPI	WTSVirtualChannelPurgeOutput (HANDLE hChannelHandle)
BOOL WINAPI	WTSVirtualChannelQuery (HANDLE hChannelHandle, WTS_VIRTUAL_CLASS WtsVirtualClass, PVOID *ppBuffer, DWORD *pBytesReturned)
BOOL WINAPI	WTSVirtualChannelRead (HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer, ULONG BufferSize, PULONG pBytesRead)
BOOL WINAPI	WTSVirtualChannelWrite (HANDLE hChannelHandle, PCHAR Buffer, ULONG Length, PULONG pBytesWritten)
BOOL WINAPI	WTSWaitSystemEvent (HANDLE hServer, DWORD Mask, DWORD *Flags)

Macro Definition Documentation

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 21 of file wtsapi32.c.

Function Documentation

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wtsapi

)

WTSCloseServer()

void WINAPI WTSCloseServer

(

HANDLE

hServer

)

Definition at line 38 of file wtsapi32.c.

{
    FIXME("Stub %p\n", hServer);
}

WTSConnectSessionA()

BOOL WINAPI WTSConnectSessionA	(	ULONG	LogonId,
		ULONG	TargetLogonId,
		PSTR	pPassword,
		BOOL	bWait
	)

Definition at line 46 of file wtsapi32.c.

{
   FIXME("Stub %d %d (%s) %d\n", LogonId, TargetLogonId, debugstr_a(pPassword), bWait);
   return TRUE;
}

WTSConnectSessionW()

BOOL WINAPI WTSConnectSessionW	(	ULONG	LogonId,
		ULONG	TargetLogonId,
		PWSTR	pPassword,
		BOOL	bWait
	)

Definition at line 55 of file wtsapi32.c.

{
   FIXME("Stub %d %d (%s) %d\n", LogonId, TargetLogonId, debugstr_w(pPassword), bWait);
   return TRUE;
}

WTSDisconnectSession()

BOOL WINAPI WTSDisconnectSession	(	HANDLE	hServer,
		DWORD	SessionId,
		BOOL	bWait
	)

Definition at line 64 of file wtsapi32.c.

{
    FIXME("Stub %p 0x%08x %d\n", hServer, SessionId, bWait);
    return TRUE;
}

WTSEnableChildSessions()

BOOL WINAPI WTSEnableChildSessions

(

BOOL

enable

)

Definition at line 73 of file wtsapi32.c.

{
    FIXME("Stub %d\n", enable);
    return TRUE;
}

WTSEnumerateProcessesA()

BOOL WINAPI WTSEnumerateProcessesA	(	HANDLE	hServer,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_PROCESS_INFOA *	ppProcessInfo,
		DWORD *	pCount
	)

Definition at line 103 of file wtsapi32.c.

{
    FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
          ppProcessInfo, pCount);
 
    if (!ppProcessInfo || !pCount) return FALSE;
 
    *pCount = 0;
    *ppProcessInfo = NULL;
 
    return TRUE;
}

WTSEnumerateProcessesExA()

BOOL WINAPI WTSEnumerateProcessesExA	(	HANDLE	server,
		DWORD *	level,
		DWORD	session_id,
		char **	info,
		DWORD *	count
	)

Definition at line 93 of file wtsapi32.c.

{
    FIXME("Stub %p %p %d %p %p\n", server, level, session_id, info, count);
    if (count) *count = 0;
    return FALSE;
}

WTSEnumerateProcessesExW()

BOOL WINAPI WTSEnumerateProcessesExW	(	HANDLE	server,
		DWORD *	level,
		DWORD	session_id,
		WCHAR **	info,
		DWORD *	count
	)

Definition at line 83 of file wtsapi32.c.

{
    FIXME("Stub %p %p %d %p %p\n", server, level, session_id, info, count);
    if (count) *count = 0;
    return FALSE;
}

WTSEnumerateProcessesW()

BOOL WINAPI WTSEnumerateProcessesW	(	HANDLE	hServer,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_PROCESS_INFOW *	ppProcessInfo,
		DWORD *	pCount
	)

Definition at line 120 of file wtsapi32.c.

{
    WTS_PROCESS_INFOW *processInfo;
    SYSTEM_PROCESS_INFORMATION *spi;
    ULONG size = 0x4000;
    void *buf = NULL;
    NTSTATUS status;
    DWORD count;
    WCHAR *name;
 
    if (!ppProcessInfo || !pCount || Reserved != 0 || Version != 1)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (hServer != WTS_CURRENT_SERVER_HANDLE)
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    do
    {
        size *= 2;
        HeapFree(GetProcessHeap(), 0, buf);
        buf = HeapAlloc(GetProcessHeap(), 0, size);
        if (!buf)
        {
            SetLastError(ERROR_OUTOFMEMORY);
            return FALSE;
        }
        status = NtQuerySystemInformation(SystemProcessInformation, buf, size, NULL);
    }
    while (status == STATUS_INFO_LENGTH_MISMATCH);
 
    if (status != STATUS_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, buf);
        SetLastError(RtlNtStatusToDosError(status));
        return FALSE;
    }
 
    spi = buf;
    count = size = 0;
    for (;;)
    {
        size += sizeof(WTS_PROCESS_INFOW) + spi->ProcessName.Length + sizeof(WCHAR);
        count++;
        if (spi->NextEntryOffset == 0) break;
        spi = (SYSTEM_PROCESS_INFORMATION *)(((PCHAR)spi) + spi->NextEntryOffset);
    }
 
    processInfo = HeapAlloc(GetProcessHeap(), 0, size);
    if (!processInfo)
    {
        HeapFree(GetProcessHeap(), 0, buf);
        SetLastError(ERROR_OUTOFMEMORY);
        return FALSE;
    }
    name = (WCHAR *)&processInfo[count];
 
    *ppProcessInfo = processInfo;
    *pCount = count;
 
    spi = buf;
    while (count--)
    {
        processInfo->SessionId = 0;
        processInfo->ProcessId = HandleToUlong(spi->UniqueProcessId);
        processInfo->pProcessName = name;
        processInfo->pUserSid = NULL;
        memcpy( name, spi->ProcessName.Buffer, spi->ProcessName.Length );
        name[ spi->ProcessName.Length/sizeof(WCHAR) ] = 0;
 
        processInfo++;
        name += (spi->ProcessName.Length + sizeof(WCHAR))/sizeof(WCHAR);
        spi = (SYSTEM_PROCESS_INFORMATION *)(((PCHAR)spi) + spi->NextEntryOffset);
    }
 
    HeapFree(GetProcessHeap(), 0, buf);
    return TRUE;
}

Referenced by test_WTSEnumerateProcessesW().

WTSEnumerateServersA()

BOOL WINAPI WTSEnumerateServersA	(	LPSTR	pDomainName,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_SERVER_INFOA *	ppServerInfo,
		DWORD *	pCount
	)

Definition at line 208 of file wtsapi32.c.

{
    FIXME("Stub %s 0x%08x 0x%08x %p %p\n", debugstr_a(pDomainName), Reserved, Version, ppServerInfo, pCount);
    return FALSE;
}

WTSEnumerateServersW()

BOOL WINAPI WTSEnumerateServersW	(	LPWSTR	pDomainName,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_SERVER_INFOW *	ppServerInfo,
		DWORD *	pCount
	)

Definition at line 217 of file wtsapi32.c.

{
    FIXME("Stub %s 0x%08x 0x%08x %p %p\n", debugstr_w(pDomainName), Reserved, Version, ppServerInfo, pCount);
    return FALSE;
}

WTSEnumerateSessionsA()

BOOL WINAPI WTSEnumerateSessionsA	(	HANDLE	hServer,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_SESSION_INFOA *	ppSessionInfo,
		DWORD *	pCount
	)

Definition at line 247 of file wtsapi32.c.

{
    static int once;
 
    if (!once++) FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
          ppSessionInfo, pCount);
 
    if (!ppSessionInfo || !pCount) return FALSE;
 
    *pCount = 0;
    *ppSessionInfo = NULL;
 
    return TRUE;
}

WTSEnumerateSessionsExA()

BOOL WINAPI WTSEnumerateSessionsExA	(	HANDLE	server,
		DWORD *	level,
		DWORD	filter,
		WTS_SESSION_INFO_1A *	info,
		DWORD *	count
	)

Definition at line 237 of file wtsapi32.c.

{
    FIXME("Stub %p %p %d %p %p\n", server, level, filter, info, count);
    if (count) *count = 0;
    return FALSE;
}

WTSEnumerateSessionsExW()

BOOL WINAPI WTSEnumerateSessionsExW	(	HANDLE	server,
		DWORD *	level,
		DWORD	filter,
		WTS_SESSION_INFO_1W *	info,
		DWORD *	count
	)

Definition at line 227 of file wtsapi32.c.

{
    FIXME("Stub %p %p %d %p %p\n", server, level, filter, info, count);
    if (count) *count = 0;
    return FALSE;
}

WTSEnumerateSessionsW()

BOOL WINAPI WTSEnumerateSessionsW	(	HANDLE	hServer,
		DWORD	Reserved,
		DWORD	Version,
		PWTS_SESSION_INFOW *	ppSessionInfo,
		DWORD *	pCount
	)

Definition at line 266 of file wtsapi32.c.

{
    FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
          ppSessionInfo, pCount);
 
    if (!ppSessionInfo || !pCount) return FALSE;
 
    *pCount = 0;
    *ppSessionInfo = NULL;
 
    return TRUE;
}

WTSFreeMemory()

void WINAPI WTSFreeMemory

(

PVOID

pMemory

)

Definition at line 283 of file wtsapi32.c.

{
    heap_free(pMemory);
}

Referenced by test_WTSEnumerateProcessesW(), test_WTSQuerySessionInformationW(), and WTSQuerySessionInformationA().

WTSFreeMemoryExA()

BOOL WINAPI WTSFreeMemoryExA	(	WTS_TYPE_CLASS	type,
		void *	ptr,
		ULONG	nmemb
	)

Definition at line 291 of file wtsapi32.c.

{
    TRACE("%d %p %d\n", type, ptr, nmemb);
    heap_free(ptr);
    return TRUE;
}

WTSFreeMemoryExW()

BOOL WINAPI WTSFreeMemoryExW	(	WTS_TYPE_CLASS	type,
		void *	ptr,
		ULONG	nmemb
	)

Definition at line 301 of file wtsapi32.c.

{
    TRACE("%d %p %d\n", type, ptr, nmemb);
    heap_free(ptr);
    return TRUE;
}

WTSLogoffSession()

BOOL WINAPI WTSLogoffSession	(	HANDLE	hserver,
		DWORD	session_id,
		BOOL	bwait
	)

Definition at line 312 of file wtsapi32.c.

{
    FIXME("(%p, 0x%x, %d): stub\n", hserver, session_id, bwait);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}

WTSOpenServerA()

HANDLE WINAPI WTSOpenServerA

(

LPSTR

pServerName

)

Definition at line 343 of file wtsapi32.c.

{
    FIXME("(%s) stub\n", debugstr_a(pServerName));
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

WTSOpenServerExA()

HANDLE WINAPI WTSOpenServerExA

(

char *

server_name

)

Definition at line 333 of file wtsapi32.c.

{
    FIXME("(%s) stub\n", debugstr_a(server_name));
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

WTSOpenServerExW()

HANDLE WINAPI WTSOpenServerExW

(

WCHAR *

server_name

)

Definition at line 323 of file wtsapi32.c.

{
    FIXME("(%s) stub\n", debugstr_w(server_name));
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

WTSOpenServerW()

HANDLE WINAPI WTSOpenServerW

(

LPWSTR

pServerName

)

Definition at line 353 of file wtsapi32.c.

{
    FIXME("(%s) stub\n", debugstr_w(pServerName));
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return NULL;
}

WTSQuerySessionInformationA()

BOOL WINAPI WTSQuerySessionInformationA	(	HANDLE	hServer,
		DWORD	SessionId,
		WTS_INFO_CLASS	WTSInfoClass,
		LPSTR *	Buffer,
		DWORD *	BytesReturned
	)

Definition at line 363 of file wtsapi32.c.

{
#ifdef __REACTOS__
    const size_t wcsErrorCode = -1;
    LPWSTR buffer = NULL;
    LPSTR ansiBuffer = NULL;
    DWORD bytesReturned = 0;
    BOOL result = FALSE;
    size_t len;
 
    if (!BytesReturned || !Buffer)
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
    if (!WTSQuerySessionInformationW(hServer, SessionId, WTSInfoClass, &buffer, &bytesReturned))
    {
        ansiBuffer = (LPSTR)buffer;
        *Buffer = ansiBuffer;
        *BytesReturned = bytesReturned;
        return FALSE;
    }
 
    switch (WTSInfoClass)
    {
        case WTSInitialProgram:
        case WTSApplicationName:
        case WTSWorkingDirectory:
        case WTSOEMId:
        case WTSUserName:
        case WTSWinStationName:
        case WTSDomainName:
        case WTSClientName:
        case WTSClientDirectory:
        {
            len = wcstombs(NULL, buffer, 0);
            if (len != wcsErrorCode)
            {
                len++;
                ansiBuffer = heap_alloc_zero(len);
                if (ansiBuffer && (wcstombs(ansiBuffer, buffer, len) != wcsErrorCode))
                {
                    result = TRUE;
                    bytesReturned = len;
                }
            }
            WTSFreeMemory(buffer);
            break;
        }
 
        default:
        {
            result = TRUE;
            ansiBuffer = (LPSTR)buffer;
            break;
        }
    }
 
    *Buffer = ansiBuffer;
    *BytesReturned = bytesReturned;
 
    return result;
#else
    /* FIXME: Forward request to winsta.dll::WinStationQueryInformationA */
    FIXME("Stub %p 0x%08x %d %p %p\n", hServer, SessionId, WTSInfoClass,
        Buffer, BytesReturned);
 
    return FALSE;
#endif
}

WTSQuerySessionInformationW()

BOOL WINAPI WTSQuerySessionInformationW	(	HANDLE	hServer,
		DWORD	SessionId,
		WTS_INFO_CLASS	WTSInfoClass,
		LPWSTR *	Buffer,
		DWORD *	BytesReturned
	)

Definition at line 443 of file wtsapi32.c.

{
#ifdef __REACTOS__
    if (!BytesReturned || !Buffer)
    {
        SetLastError(ERROR_INVALID_USER_BUFFER);
        return FALSE;
    }
 
#if (NTDDI_VERSION >= NTDDI_WS08)
    if (WTSInfoClass > WTSIsRemoteSession)
#else
    if (WTSInfoClass > WTSClientProtocolType)
#endif
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    switch (WTSInfoClass)
    {
        case WTSSessionId:
        {
            const DWORD size = sizeof(ULONG);
            ULONG* output = heap_alloc_zero(size);
            if (!output)
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return FALSE;
            }
 
            *output = NtCurrentTeb()->Peb->SessionId;
            *Buffer = (LPWSTR)output;
            *BytesReturned = size;
            return TRUE;
        }
 
        case WTSUserName:
        {
            WCHAR* username;
            DWORD count = 0;
 
            GetUserNameW(NULL, &count);
            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
                return FALSE;
            username = heap_alloc(count * sizeof(WCHAR));
            if (!username)
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return FALSE;
            }
 
            GetUserNameW(username, &count);
            *Buffer = username;
            *BytesReturned = count * sizeof(WCHAR);
            return TRUE;
        }
 
        case WTSConnectState:
        {
            const DWORD size = sizeof(DWORD);
            WCHAR* output = heap_alloc_zero(size);
            if (!output)
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return FALSE;
            }
 
            *Buffer = output;
            *BytesReturned = size;
            return TRUE;
        }
 
        case WTSClientProtocolType:
        {
            const DWORD size = sizeof(WORD);
            WCHAR* output = heap_alloc_zero(size);
            if (!output)
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return FALSE;
            }
 
            *Buffer = output;
            *BytesReturned = size;
            return TRUE;
        }
 
#if (NTDDI_VERSION >= NTDDI_WS08)
        case WTSIdleTime:
        case WTSLogonTime:
        case WTSIncomingBytes:
        case WTSOutgoingBytes:
        case WTSIncomingFrames:
        case WTSOutgoingFrames:
        {
            SetLastError(ERROR_NOT_SUPPORTED);
            return FALSE;
        }
#endif /* (NTDDI_VERSION >= NTDDI_WS08) */
 
        default:
        {
            if (BytesReturned)
                *BytesReturned = 0;
 
            break;
        }
    }
 
    /* FIXME: Forward request to winsta.dll::WinStationQueryInformationW */
    FIXME("Stub %p 0x%08x %d %p %p\n", hServer, SessionId, WTSInfoClass,
        Buffer, BytesReturned);
 
    return FALSE;
#else
    /* FIXME: Forward request to winsta.dll::WinStationQueryInformationW */
    FIXME("Stub %p 0x%08x %d %p %p\n", hServer, SessionId, WTSInfoClass,
        Buffer, BytesReturned);
 
    if (WTSInfoClass == WTSUserName)
    {
        WCHAR *username;
        DWORD count = 0;
 
        GetUserNameW(NULL, &count);
        if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
        if (!(username = heap_alloc(count * sizeof(WCHAR)))) return FALSE;
        GetUserNameW(username, &count);
        *Buffer = username;
        *BytesReturned = count * sizeof(WCHAR);
        return TRUE;
    }
    return FALSE;
#endif
}

Referenced by test_WTSQuerySessionInformationW(), and WTSQuerySessionInformationA().

WTSQueryUserConfigA()

BOOL WINAPI WTSQueryUserConfigA	(	LPSTR	pServerName,
		LPSTR	pUserName,
		WTS_CONFIG_CLASS	WTSConfigClass,
		LPSTR *	ppBuffer,
		DWORD *	pBytesReturned
	)

Definition at line 606 of file wtsapi32.c.

{
   FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,
        ppBuffer, pBytesReturned);
   return FALSE;
}

WTSQueryUserConfigW()

BOOL WINAPI WTSQueryUserConfigW	(	LPWSTR	pServerName,
		LPWSTR	pUserName,
		WTS_CONFIG_CLASS	WTSConfigClass,
		LPWSTR *	ppBuffer,
		DWORD *	pBytesReturned
	)

Definition at line 616 of file wtsapi32.c.

{
   FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,
        ppBuffer, pBytesReturned);
   return FALSE;
}

WTSQueryUserToken()

BOOL WINAPI WTSQueryUserToken	(	ULONG	session_id,
		PHANDLE	token
	)

Definition at line 588 of file wtsapi32.c.

{
    FIXME("%u %p semi-stub!\n", session_id, token);
 
    if (!token)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return DuplicateHandle(GetCurrentProcess(), GetCurrentProcessToken(),
                           GetCurrentProcess(), token,
                           0, FALSE, DUPLICATE_SAME_ACCESS);
}

Referenced by test_WTSQueryUserToken().

WTSRegisterSessionNotification()

BOOL WINAPI WTSRegisterSessionNotification	(	HWND	hWnd,
		DWORD	dwFlags
	)

Definition at line 627 of file wtsapi32.c.

{
    FIXME("Stub %p 0x%08x\n", hWnd, dwFlags);
    return TRUE;
}

WTSRegisterSessionNotificationEx()

BOOL WINAPI WTSRegisterSessionNotificationEx	(	HANDLE	hServer,
		HWND	hWnd,
		DWORD	dwFlags
	)

Definition at line 636 of file wtsapi32.c.

{
    FIXME("Stub %p %p 0x%08x\n", hServer, hWnd, dwFlags);
    return FALSE;
}

WTSSendMessageA()

BOOL WINAPI WTSSendMessageA	(	HANDLE	hServer,
		DWORD	SessionId,
		LPSTR	pTitle,
		DWORD	TitleLength,
		LPSTR	pMessage,
		DWORD	MessageLength,
		DWORD	Style,
		DWORD	Timeout,
		DWORD *	pResponse,
		BOOL	bWait
	)

Definition at line 646 of file wtsapi32.c.

{
   FIXME("Stub %p 0x%08x (%s) %d (%s) %d 0x%08x %d %p %d\n", hServer, SessionId, debugstr_a(pTitle), TitleLength, debugstr_a(pMessage), MessageLength, Style, Timeout, pResponse, bWait);
   return FALSE;
}

WTSSendMessageW()

BOOL WINAPI WTSSendMessageW	(	HANDLE	hServer,
		DWORD	SessionId,
		LPWSTR	pTitle,
		DWORD	TitleLength,
		LPWSTR	pMessage,
		DWORD	MessageLength,
		DWORD	Style,
		DWORD	Timeout,
		DWORD *	pResponse,
		BOOL	bWait
	)

Definition at line 656 of file wtsapi32.c.

{
   FIXME("Stub %p 0x%08x (%s) %d (%s) %d 0x%08x %d %p %d\n", hServer, SessionId, debugstr_w(pTitle), TitleLength, debugstr_w(pMessage), MessageLength, Style, Timeout, pResponse, bWait);
   return FALSE;
}

WTSSetUserConfigA()

BOOL WINAPI WTSSetUserConfigA	(	LPSTR	pServerName,
		LPSTR	pUserName,
		WTS_CONFIG_CLASS	WTSConfigClass,
		LPSTR	pBuffer,
		DWORD	DataLength
	)

Definition at line 666 of file wtsapi32.c.

{
   FIXME("Stub (%s) (%s) 0x%08x %p %d\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,pBuffer, DataLength);
   return FALSE;
}

WTSSetUserConfigW()

BOOL WINAPI WTSSetUserConfigW	(	LPWSTR	pServerName,
		LPWSTR	pUserName,
		WTS_CONFIG_CLASS	WTSConfigClass,
		LPWSTR	pBuffer,
		DWORD	DataLength
	)

Definition at line 675 of file wtsapi32.c.

{
   FIXME("Stub (%s) (%s) 0x%08x %p %d\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,pBuffer, DataLength);
   return FALSE;
}

WTSShutdownSystem()

BOOL WINAPI WTSShutdownSystem	(	HANDLE	hServer,
		DWORD	ShutdownFlag
	)

Definition at line 684 of file wtsapi32.c.

{
   FIXME("Stub %p 0x%08x\n", hServer,ShutdownFlag);
   return FALSE;
}

WTSStartRemoteControlSessionA()

BOOL WINAPI WTSStartRemoteControlSessionA	(	LPSTR	pTargetServerName,
		ULONG	TargetLogonId,
		BYTE	HotkeyVk,
		USHORT	HotkeyModifiers
	)

Definition at line 693 of file wtsapi32.c.

{
   FIXME("Stub (%s) %d %d %d\n", debugstr_a(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
   return FALSE;
}

WTSStartRemoteControlSessionW()

BOOL WINAPI WTSStartRemoteControlSessionW	(	LPWSTR	pTargetServerName,
		ULONG	TargetLogonId,
		BYTE	HotkeyVk,
		USHORT	HotkeyModifiers
	)

Definition at line 702 of file wtsapi32.c.

{
   FIXME("Stub (%s) %d %d %d\n", debugstr_w(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
   return FALSE;
}

WTSStopRemoteControlSession()

BOOL WINAPI WTSStopRemoteControlSession

(

ULONG

LogonId

)

Definition at line 711 of file wtsapi32.c.

{
   FIXME("Stub %d\n",  LogonId);
   return FALSE;
}

WTSTerminateProcess()

BOOL WINAPI WTSTerminateProcess	(	HANDLE	hServer,
		DWORD	ProcessId,
		DWORD	ExitCode
	)

Definition at line 720 of file wtsapi32.c.

{
   FIXME("Stub %p %d %d\n", hServer, ProcessId, ExitCode);
   return FALSE;
}

WTSUnRegisterSessionNotification()

BOOL WINAPI WTSUnRegisterSessionNotification

(

HWND

hWnd

)

Definition at line 729 of file wtsapi32.c.

{
    FIXME("Stub %p\n", hWnd);
    return FALSE;
}

WTSUnRegisterSessionNotificationEx()

BOOL WINAPI WTSUnRegisterSessionNotificationEx	(	HANDLE	hServer,
		HWND	hWnd
	)

Definition at line 738 of file wtsapi32.c.

{
    FIXME("Stub %p %p\n", hServer, hWnd);
    return FALSE;
}

WTSVirtualChannelClose()

BOOL WINAPI WTSVirtualChannelClose

(

HANDLE

hChannelHandle

)

Definition at line 748 of file wtsapi32.c.

{
   FIXME("Stub %p\n", hChannelHandle);
   return FALSE;
}

WTSVirtualChannelOpen()

HANDLE WINAPI WTSVirtualChannelOpen	(	HANDLE	hServer,
		DWORD	SessionId,
		LPSTR	pVirtualName
	)

Definition at line 757 of file wtsapi32.c.

{
   FIXME("Stub %p %d (%s)\n", hServer, SessionId, debugstr_a(pVirtualName));
   return NULL;
}

WTSVirtualChannelOpenEx()

HANDLE WINAPI WTSVirtualChannelOpenEx	(	DWORD	SessionId,
		LPSTR	pVirtualName,
		DWORD	flags
	)

Definition at line 766 of file wtsapi32.c.

{
   FIXME("Stub %d (%s) %d\n",  SessionId, debugstr_a(pVirtualName), flags);
   return NULL;
}

WTSVirtualChannelPurgeInput()

BOOL WINAPI WTSVirtualChannelPurgeInput

(

HANDLE

hChannelHandle

)

Definition at line 775 of file wtsapi32.c.

{
   FIXME("Stub %p\n", hChannelHandle);
   return FALSE;
}

WTSVirtualChannelPurgeOutput()

BOOL WINAPI WTSVirtualChannelPurgeOutput

(

HANDLE

hChannelHandle

)

Definition at line 784 of file wtsapi32.c.

{
   FIXME("Stub %p\n", hChannelHandle);
   return FALSE;
}

WTSVirtualChannelQuery()

BOOL WINAPI WTSVirtualChannelQuery	(	HANDLE	hChannelHandle,
		WTS_VIRTUAL_CLASS	WtsVirtualClass,
		PVOID *	ppBuffer,
		DWORD *	pBytesReturned
	)

Definition at line 794 of file wtsapi32.c.

{
   FIXME("Stub %p %d %p %p\n", hChannelHandle, WtsVirtualClass, ppBuffer, pBytesReturned);
   return FALSE;
}

WTSVirtualChannelRead()

BOOL WINAPI WTSVirtualChannelRead	(	HANDLE	hChannelHandle,
		ULONG	TimeOut,
		PCHAR	Buffer,
		ULONG	BufferSize,
		PULONG	pBytesRead
	)

Definition at line 803 of file wtsapi32.c.

{
   FIXME("Stub %p %d %p %d %p\n", hChannelHandle, TimeOut, Buffer, BufferSize, pBytesRead);
   return FALSE;
}

WTSVirtualChannelWrite()

BOOL WINAPI WTSVirtualChannelWrite	(	HANDLE	hChannelHandle,
		PCHAR	Buffer,
		ULONG	Length,
		PULONG	pBytesWritten
	)

Definition at line 812 of file wtsapi32.c.

{
   FIXME("Stub %p %p %d %p\n", hChannelHandle, Buffer, Length, pBytesWritten);
   return FALSE;
}

WTSWaitSystemEvent()

BOOL WINAPI WTSWaitSystemEvent	(	HANDLE	hServer,
		DWORD	Mask,
		DWORD *	Flags
	)

Definition at line 821 of file wtsapi32.c.

{
    /* FIXME: Forward request to winsta.dll::WinStationWaitSystemEvent */
    FIXME("Stub %p 0x%08x %p\n", hServer, Mask, Flags);
    return FALSE;
}