dlls/wtsapi32/wtsapi32.c

   1 /* Copyright 2005 Ulrich Czekalla
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  16  */
  17
  18 #include <stdarg.h>
  19 #include <stdlib.h>
  20 #include "windef.h"
  21 #include "winbase.h"
  22 #include "winnls.h"
  23 #include "lmcons.h"
  24 #include "wtsapi32.h"
  25 #include "wine/debug.h"
  26 #include "wine/heap.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(wtsapi);
  29
  30
  31 /************************************************************
  32  *                WTSCloseServer  (WTSAPI32.@)
  33  */
  34 void WINAPI WTSCloseServer(HANDLE hServer)
  35 {
  36     FIXME("Stub %p\n", hServer);
  37 }
  38
  39 /************************************************************
  40  *                WTSConnectSessionA  (WTSAPI32.@)
  41  */
  42 BOOL WINAPI WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId, PSTR pPassword, BOOL bWait)
  43 {
  44    FIXME("Stub %d %d (%s) %d\n", LogonId, TargetLogonId, debugstr_a(pPassword), bWait);
  45    return TRUE;
  46 }
  47
  48 /************************************************************
  49  *                WTSConnectSessionW  (WTSAPI32.@)
  50  */
  51 BOOL WINAPI WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword, BOOL bWait)
  52 {
  53    FIXME("Stub %d %d (%s) %d\n", LogonId, TargetLogonId, debugstr_w(pPassword), bWait);
  54    return TRUE;
  55 }
  56
  57 /************************************************************
  58  *                WTSDisconnectSession  (WTSAPI32.@)
  59  */
  60 BOOL WINAPI WTSDisconnectSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
  61 {
  62     FIXME("Stub %p 0x%08x %d\n", hServer, SessionId, bWait);
  63     return TRUE;
  64 }
  65
  66 /************************************************************
  67  *                WTSEnableChildSessions  (WTSAPI32.@)
  68  */
  69 BOOL WINAPI WTSEnableChildSessions(BOOL enable)
  70 {
  71     FIXME("Stub %d\n", enable);
  72     return TRUE;
  73 }
  74
  75
  76 /************************************************************
  77  *                WTSEnumerateProcessesExW  (WTSAPI32.@)
  78  */
  79 BOOL WINAPI WTSEnumerateProcessesExW(HANDLE server, DWORD *level, DWORD session_id, WCHAR **info, DWORD *count)
  80 {
  81     FIXME("Stub %p %p %d %p %p\n", server, level, session_id, info, count);
  82     if (count) *count = 0;
  83     return FALSE;
  84 }
  85
  86 /************************************************************
  87  *                WTSEnumerateProcessesExA  (WTSAPI32.@)
  88  */
  89 BOOL WINAPI WTSEnumerateProcessesExA(HANDLE server, DWORD *level, DWORD session_id, char **info, DWORD *count)
  90 {
  91     FIXME("Stub %p %p %d %p %p\n", server, level, session_id, info, count);
  92     if (count) *count = 0;
  93     return FALSE;
  94 }
  95
  96 /************************************************************
  97  *                WTSEnumerateProcessesA  (WTSAPI32.@)
  98  */
  99 BOOL WINAPI WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved, DWORD Version,
 100     PWTS_PROCESS_INFOA* ppProcessInfo, DWORD* pCount)
 101 {
 102     FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
 103           ppProcessInfo, pCount);
 104
 105     if (!ppProcessInfo || !pCount) return FALSE;
 106
 107     *pCount = 0;
 108     *ppProcessInfo = NULL;
 109
 110     return TRUE;
 111 }
 112
 113 /************************************************************
 114  *                WTSEnumerateProcessesW  (WTSAPI32.@)
 115  */
 116 BOOL WINAPI WTSEnumerateProcessesW(HANDLE hServer, DWORD Reserved, DWORD Version,
 117     PWTS_PROCESS_INFOW* ppProcessInfo, DWORD* pCount)
 118 {
 119     FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
 120           ppProcessInfo, pCount);
 121
 122     if (!ppProcessInfo || !pCount || Reserved != 0 || Version != 1)
 123     {
 124         SetLastError(ERROR_INVALID_PARAMETER);
 125         return FALSE;
 126     }
 127
 128     *pCount = 0;
 129     *ppProcessInfo = NULL;
 130
 131     return TRUE;
 132 }
 133
 134 /************************************************************
 135  *                WTSEnumerateServersA  (WTSAPI32.@)
 136  */
 137 BOOL WINAPI WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOA *ppServerInfo, DWORD *pCount)
 138 {
 139     FIXME("Stub %s 0x%08x 0x%08x %p %p\n", debugstr_a(pDomainName), Reserved, Version, ppServerInfo, pCount);
 140     return FALSE;
 141 }
 142
 143 /************************************************************
 144  *                WTSEnumerateServersW  (WTSAPI32.@)
 145  */
 146 BOOL WINAPI WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOW *ppServerInfo, DWORD *pCount)
 147 {
 148     FIXME("Stub %s 0x%08x 0x%08x %p %p\n", debugstr_w(pDomainName), Reserved, Version, ppServerInfo, pCount);
 149     return FALSE;
 150 }
 151
 152
 153 /************************************************************
 154  *                WTSEnumerateEnumerateSessionsExW  (WTSAPI32.@)
 155  */
 156 BOOL WINAPI WTSEnumerateSessionsExW(HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1W* info, DWORD *count)
 157 {
 158     FIXME("Stub %p %p %d %p %p\n", server, level, filter, info, count);
 159     if (count) *count = 0;
 160     return FALSE;
 161 }
 162
 163 /************************************************************
 164  *                WTSEnumerateEnumerateSessionsExA  (WTSAPI32.@)
 165  */
 166 BOOL WINAPI WTSEnumerateSessionsExA(HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1A* info, DWORD *count)
 167 {
 168     FIXME("Stub %p %p %d %p %p\n", server, level, filter, info, count);
 169     if (count) *count = 0;
 170     return FALSE;
 171 }
 172
 173 /************************************************************
 174  *                WTSEnumerateEnumerateSessionsA  (WTSAPI32.@)
 175  */
 176 BOOL WINAPI WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved, DWORD Version,
 177     PWTS_SESSION_INFOA* ppSessionInfo, DWORD* pCount)
 178 {
 179     static int once;
 180
 181     if (!once++) FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
 182           ppSessionInfo, pCount);
 183
 184     if (!ppSessionInfo || !pCount) return FALSE;
 185
 186     *pCount = 0;
 187     *ppSessionInfo = NULL;
 188
 189     return TRUE;
 190 }
 191
 192 /************************************************************
 193  *                WTSEnumerateEnumerateSessionsW  (WTSAPI32.@)
 194  */
 195 BOOL WINAPI WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved, DWORD Version,
 196     PWTS_SESSION_INFOW* ppSessionInfo, DWORD* pCount)
 197 {
 198     FIXME("Stub %p 0x%08x 0x%08x %p %p\n", hServer, Reserved, Version,
 199           ppSessionInfo, pCount);
 200
 201     if (!ppSessionInfo || !pCount) return FALSE;
 202
 203     *pCount = 0;
 204     *ppSessionInfo = NULL;
 205
 206     return TRUE;
 207 }
 208
 209 /************************************************************
 210  *                WTSFreeMemory (WTSAPI32.@)
 211  */
 212 void WINAPI WTSFreeMemory(PVOID pMemory)
 213 {
 214     heap_free(pMemory);
 215 }
 216
 217 /************************************************************
 218  *                WTSFreeMemoryExA (WTSAPI32.@)
 219  */
 220 BOOL WINAPI WTSFreeMemoryExA(WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
 221 {
 222     TRACE("%d %p %d\n", type, ptr, nmemb);
 223     heap_free(ptr);
 224     return TRUE;
 225 }
 226
 227 /************************************************************
 228  *                WTSFreeMemoryExW (WTSAPI32.@)
 229  */
 230 BOOL WINAPI WTSFreeMemoryExW(WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
 231 {
 232     TRACE("%d %p %d\n", type, ptr, nmemb);
 233     heap_free(ptr);
 234     return TRUE;
 235 }
 236
 237
 238 /************************************************************
 239  *                WTSLogoffSession (WTSAPI32.@)
 240  */
 241 BOOL WINAPI WTSLogoffSession(HANDLE hserver, DWORD session_id, BOOL bwait)
 242 {
 243     FIXME("(%p, 0x%x, %d): stub\n", hserver, session_id, bwait);
 244     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 245     return FALSE;
 246 }
 247
 248
 249 /************************************************************
 250  *                WTSOpenServerExW (WTSAPI32.@)
 251  */
 252 HANDLE WINAPI WTSOpenServerExW(WCHAR *server_name)
 253 {
 254     FIXME("(%s) stub\n", debugstr_w(server_name));
 255     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 256     return NULL;
 257 }
 258
 259 /************************************************************
 260  *                WTSOpenServerExA (WTSAPI32.@)
 261  */
 262 HANDLE WINAPI WTSOpenServerExA(char *server_name)
 263 {
 264     FIXME("(%s) stub\n", debugstr_a(server_name));
 265     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 266     return NULL;
 267 }
 268
 269 /************************************************************
 270  *                WTSOpenServerA (WTSAPI32.@)
 271  */
 272 HANDLE WINAPI WTSOpenServerA(LPSTR pServerName)
 273 {
 274     FIXME("(%s) stub\n", debugstr_a(pServerName));
 275     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 276     return NULL;
 277 }
 278
 279 /************************************************************
 280  *                WTSOpenServerW (WTSAPI32.@)
 281  */
 282 HANDLE WINAPI WTSOpenServerW(LPWSTR pServerName)
 283 {
 284     FIXME("(%s) stub\n", debugstr_w(pServerName));
 285     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 286     return NULL;
 287 }
 288
 289 /************************************************************
 290  *                WTSQuerySessionInformationA  (WTSAPI32.@)
 291  */
 292 BOOL WINAPI WTSQuerySessionInformationA(HANDLE server, DWORD session_id, WTS_INFO_CLASS class, char **buffer, DWORD *count)
 293 {
 294     WCHAR *bufferW = NULL;
 295
 296     TRACE("%p 0x%08x %d %p %p\n", server, session_id, class, buffer, count);
 297
 298     if (!buffer || !count)
 299     {
 300         SetLastError(ERROR_INVALID_USER_BUFFER);
 301         return FALSE;
 302     }
 303
 304     if (!WTSQuerySessionInformationW(server, session_id, class, &bufferW, count))
 305         return FALSE;
 306
 307     *count = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
 308     if (!*count)
 309     {
 310         WTSFreeMemory(bufferW);
 311         return FALSE;
 312     }
 313
 314     if (!(*buffer = heap_alloc(*count)))
 315     {
 316         WTSFreeMemory(bufferW);
 317         return FALSE;
 318     }
 319
 320     if (!(*count = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, *buffer, *count, NULL, NULL)))
 321     {
 322         WTSFreeMemory(bufferW);
 323         heap_free(*buffer);
 324         return FALSE;
 325     }
 326
 327     WTSFreeMemory(bufferW);
 328     return TRUE;
 329 }
 330
 331 /************************************************************
 332  *                WTSQuerySessionInformationW  (WTSAPI32.@)
 333  */
 334 BOOL WINAPI WTSQuerySessionInformationW(HANDLE server, DWORD session_id, WTS_INFO_CLASS class, WCHAR **buffer, DWORD *count)
 335 {
 336     TRACE("%p 0x%08x %d %p %p\n", server, session_id, class, buffer, count);
 337
 338     if (!buffer || !count)
 339     {
 340         SetLastError(ERROR_INVALID_USER_BUFFER);
 341         return FALSE;
 342     }
 343
 344     if (class == WTSUserName)
 345     {
 346         DWORD size = UNLEN + 1;
 347         WCHAR *username;
 348
 349         if (!(username = heap_alloc(size * sizeof(WCHAR)))) return FALSE;
 350         GetUserNameW(username, &size);
 351         *buffer = username;
 352         *count = size * sizeof(WCHAR);
 353         return TRUE;
 354     }
 355
 356     if (class ==  WTSDomainName)
 357     {
 358         DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
 359         WCHAR *computername;
 360
 361         if (!(computername = heap_alloc(size * sizeof(WCHAR)))) return FALSE;
 362         GetComputerNameW(computername, &size);
 363         *buffer = computername;
 364         /* GetComputerNameW() return size doesn't include terminator */
 365         size++;
 366         *count = size * sizeof(WCHAR);
 367         return TRUE;
 368     }
 369
 370     FIXME("Unimplemented class %d\n", class);
 371
 372     *buffer = NULL;
 373     *count = 0;
 374     return FALSE;
 375 }
 376
 377 /************************************************************
 378  *                WTSQueryUserToken (WTSAPI32.@)
 379  */
 380 BOOL WINAPI WTSQueryUserToken(ULONG session_id, PHANDLE token)
 381 {
 382     FIXME("%u %p semi-stub!\n", session_id, token);
 383
 384     if (!token)
 385     {
 386         SetLastError(ERROR_INVALID_PARAMETER);
 387         return FALSE;
 388     }
 389
 390     return DuplicateHandle(GetCurrentProcess(), GetCurrentProcessToken(),
 391                            GetCurrentProcess(), token,
 392                            0, FALSE, DUPLICATE_SAME_ACCESS);
 393 }
 394
 395 /************************************************************
 396  *                WTSQueryUserConfigA (WTSAPI32.@)
 397  */
 398 BOOL WINAPI WTSQueryUserConfigA(LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR *ppBuffer, DWORD *pBytesReturned)
 399 {
 400    FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,
 401         ppBuffer, pBytesReturned);
 402    return FALSE;
 403 }
 404
 405 /************************************************************
 406  *                WTSQueryUserConfigW (WTSAPI32.@)
 407  */
 408 BOOL WINAPI WTSQueryUserConfigW(LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR *ppBuffer, DWORD *pBytesReturned)
 409 {
 410    FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,
 411         ppBuffer, pBytesReturned);
 412    return FALSE;
 413 }
 414
 415
 416 /************************************************************
 417  *                WTSRegisterSessionNotification (WTSAPI32.@)
 418  */
 419 BOOL WINAPI WTSRegisterSessionNotification(HWND hWnd, DWORD dwFlags)
 420 {
 421     FIXME("Stub %p 0x%08x\n", hWnd, dwFlags);
 422     return TRUE;
 423 }
 424
 425 /************************************************************
 426  *                WTSRegisterSessionNotificationEx (WTSAPI32.@)
 427  */
 428 BOOL WINAPI WTSRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd, DWORD dwFlags)
 429 {
 430     FIXME("Stub %p %p 0x%08x\n", hServer, hWnd, dwFlags);
 431     return TRUE;
 432 }
 433
 434
 435 /************************************************************
 436  *                WTSSendMessageA (WTSAPI32.@)
 437  */
 438 BOOL WINAPI WTSSendMessageA(HANDLE hServer, DWORD SessionId, LPSTR pTitle, DWORD TitleLength, LPSTR pMessage,
 439    DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
 440 {
 441    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);
 442    return FALSE;
 443 }
 444
 445 /************************************************************
 446  *                WTSSendMessageW (WTSAPI32.@)
 447  */
 448 BOOL WINAPI WTSSendMessageW(HANDLE hServer, DWORD SessionId, LPWSTR pTitle, DWORD TitleLength, LPWSTR pMessage,
 449    DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
 450 {
 451    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);
 452    return FALSE;
 453 }
 454
 455 /************************************************************
 456  *                WTSSetUserConfigA (WTSAPI32.@)
 457  */
 458 BOOL WINAPI WTSSetUserConfigA(LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer, DWORD DataLength)
 459 {
 460    FIXME("Stub (%s) (%s) 0x%08x %p %d\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,pBuffer, DataLength);
 461    return FALSE;
 462 }
 463
 464 /************************************************************
 465  *                WTSSetUserConfigW (WTSAPI32.@)
 466  */
 467 BOOL WINAPI WTSSetUserConfigW(LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer, DWORD DataLength)
 468 {
 469    FIXME("Stub (%s) (%s) 0x%08x %p %d\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,pBuffer, DataLength);
 470    return FALSE;
 471 }
 472
 473 /************************************************************
 474  *                WTSShutdownSystem (WTSAPI32.@)
 475  */
 476 BOOL WINAPI WTSShutdownSystem(HANDLE hServer, DWORD ShutdownFlag)
 477 {
 478    FIXME("Stub %p 0x%08x\n", hServer,ShutdownFlag);
 479    return FALSE;
 480 }
 481
 482 /************************************************************
 483  *                WTSStartRemoteControlSessionA (WTSAPI32.@)
 484  */
 485 BOOL WINAPI WTSStartRemoteControlSessionA(LPSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
 486 {
 487    FIXME("Stub (%s) %d %d %d\n", debugstr_a(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
 488    return FALSE;
 489 }
 490
 491 /************************************************************
 492  *                WTSStartRemoteControlSessionW (WTSAPI32.@)
 493  */
 494 BOOL WINAPI WTSStartRemoteControlSessionW(LPWSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
 495 {
 496    FIXME("Stub (%s) %d %d %d\n", debugstr_w(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
 497    return FALSE;
 498 }
 499
 500 /************************************************************
 501  *                WTSStopRemoteControlSession (WTSAPI32.@)
 502  */
 503 BOOL WINAPI WTSStopRemoteControlSession(ULONG LogonId)
 504 {
 505    FIXME("Stub %d\n",  LogonId);
 506    return FALSE;
 507 }
 508
 509 /************************************************************
 510  *                WTSTerminateProcess (WTSAPI32.@)
 511  */
 512 BOOL WINAPI WTSTerminateProcess(HANDLE hServer, DWORD ProcessId, DWORD ExitCode)
 513 {
 514    FIXME("Stub %p %d %d\n", hServer, ProcessId, ExitCode);
 515    return FALSE;
 516 }
 517
 518 /************************************************************
 519  *                WTSUnRegisterSessionNotification (WTSAPI32.@)
 520  */
 521 BOOL WINAPI WTSUnRegisterSessionNotification(HWND hWnd)
 522 {
 523     FIXME("Stub %p\n", hWnd);
 524     return FALSE;
 525 }
 526
 527 /************************************************************
 528  *                WTSUnRegisterSessionNotification (WTSAPI32.@)
 529  */
 530 BOOL WINAPI WTSUnRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd)
 531 {
 532     FIXME("Stub %p %p\n", hServer, hWnd);
 533     return FALSE;
 534 }
 535
 536
 537 /************************************************************
 538  *                WTSVirtualChannelClose (WTSAPI32.@)
 539  */
 540 BOOL WINAPI WTSVirtualChannelClose(HANDLE hChannelHandle)
 541 {
 542    FIXME("Stub %p\n", hChannelHandle);
 543    return FALSE;
 544 }
 545
 546 /************************************************************
 547  *                WTSVirtualChannelOpen (WTSAPI32.@)
 548  */
 549 HANDLE WINAPI WTSVirtualChannelOpen(HANDLE hServer, DWORD SessionId, LPSTR pVirtualName)
 550 {
 551    FIXME("Stub %p %d (%s)\n", hServer, SessionId, debugstr_a(pVirtualName));
 552    return NULL;
 553 }
 554
 555 /************************************************************
 556  *                WTSVirtualChannelOpen (WTSAPI32.@)
 557  */
 558 HANDLE WINAPI WTSVirtualChannelOpenEx(DWORD SessionId, LPSTR pVirtualName, DWORD flags)
 559 {
 560    FIXME("Stub %d (%s) %d\n",  SessionId, debugstr_a(pVirtualName), flags);
 561    return NULL;
 562 }
 563
 564 /************************************************************
 565  *                WTSVirtualChannelPurgeInput (WTSAPI32.@)
 566  */
 567 BOOL WINAPI WTSVirtualChannelPurgeInput(HANDLE hChannelHandle)
 568 {
 569    FIXME("Stub %p\n", hChannelHandle);
 570    return FALSE;
 571 }
 572
 573 /************************************************************
 574  *                WTSVirtualChannelPurgeOutput (WTSAPI32.@)
 575  */
 576 BOOL WINAPI WTSVirtualChannelPurgeOutput(HANDLE hChannelHandle)
 577 {
 578    FIXME("Stub %p\n", hChannelHandle);
 579    return FALSE;
 580 }
 581
 582
 583 /************************************************************
 584  *                WTSVirtualChannelQuery (WTSAPI32.@)
 585  */
 586 BOOL WINAPI WTSVirtualChannelQuery(HANDLE hChannelHandle, WTS_VIRTUAL_CLASS WtsVirtualClass, PVOID *ppBuffer, DWORD *pBytesReturned)
 587 {
 588    FIXME("Stub %p %d %p %p\n", hChannelHandle, WtsVirtualClass, ppBuffer, pBytesReturned);
 589    return FALSE;
 590 }
 591
 592 /************************************************************
 593  *                WTSVirtualChannelRead (WTSAPI32.@)
 594  */
 595 BOOL WINAPI WTSVirtualChannelRead(HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer, ULONG BufferSize, PULONG pBytesRead)
 596 {
 597    FIXME("Stub %p %d %p %d %p\n", hChannelHandle, TimeOut, Buffer, BufferSize, pBytesRead);
 598    return FALSE;
 599 }
 600
 601 /************************************************************
 602  *                WTSVirtualChannelWrite (WTSAPI32.@)
 603  */
 604 BOOL WINAPI WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length, PULONG pBytesWritten)
 605 {
 606    FIXME("Stub %p %p %d %p\n", hChannelHandle, Buffer, Length, pBytesWritten);
 607    return FALSE;
 608 }
 609
 610 /************************************************************
 611  *                WTSWaitSystemEvent (WTSAPI32.@)
 612  */
 613 BOOL WINAPI WTSWaitSystemEvent(HANDLE hServer, DWORD Mask, DWORD* Flags)
 614 {
 615     /* FIXME: Forward request to winsta.dll::WinStationWaitSystemEvent */
 616     FIXME("Stub %p 0x%08x %p\n", hServer, Mask, Flags);
 617     return FALSE;
 618 }