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 "ntstatus.h"
  19 #define WIN32_NO_STATUS
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winternl.h"
  25 #include "winnls.h"
  26 #include "lmcons.h"
  27 #include "wtsapi32.h"
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wtsapi);
  32
  33
  34 /************************************************************
  35  *                WTSCloseServer  (WTSAPI32.@)
  36  */
  37 void WINAPI WTSCloseServer(HANDLE hServer)
  38 {
  39     FIXME("Stub %p\n", hServer);
  40 }
  41
  42 /************************************************************
  43  *                WTSConnectSessionA  (WTSAPI32.@)
  44  */
  45 BOOL WINAPI WTSConnectSessionA(ULONG LogonId, ULONG TargetLogonId, PSTR pPassword, BOOL bWait)
  46 {
  47    FIXME("Stub %ld %ld (%s) %d\n", LogonId, TargetLogonId, debugstr_a(pPassword), bWait);
  48    return TRUE;
  49 }
  50
  51 /************************************************************
  52  *                WTSConnectSessionW  (WTSAPI32.@)
  53  */
  54 BOOL WINAPI WTSConnectSessionW(ULONG LogonId, ULONG TargetLogonId, PWSTR pPassword, BOOL bWait)
  55 {
  56    FIXME("Stub %ld %ld (%s) %d\n", LogonId, TargetLogonId, debugstr_w(pPassword), bWait);
  57    return TRUE;
  58 }
  59
  60 /************************************************************
  61  *                WTSDisconnectSession  (WTSAPI32.@)
  62  */
  63 BOOL WINAPI WTSDisconnectSession(HANDLE hServer, DWORD SessionId, BOOL bWait)
  64 {
  65     FIXME("Stub %p 0x%08lx %d\n", hServer, SessionId, bWait);
  66     return TRUE;
  67 }
  68
  69 /************************************************************
  70  *                WTSEnableChildSessions  (WTSAPI32.@)
  71  */
  72 BOOL WINAPI WTSEnableChildSessions(BOOL enable)
  73 {
  74     FIXME("Stub %d\n", enable);
  75     return TRUE;
  76 }
  77
  78
  79 /************************************************************
  80  *                WTSEnumerateProcessesExW  (WTSAPI32.@)
  81  */
  82 BOOL WINAPI WTSEnumerateProcessesExW(HANDLE server, DWORD *level, DWORD session_id,
  83         WCHAR **ret_info, DWORD *ret_count)
  84 {
  85     SYSTEM_PROCESS_INFORMATION *nt_info, *nt_process;
  86     WTS_PROCESS_INFOW *info;
  87     ULONG nt_size = 4096;
  88     DWORD count, size;
  89     NTSTATUS status;
  90     char *p;
  91
  92     TRACE("server %p, level %lu, session_id %#lx, ret_info %p, ret_count %p\n",
  93             server, *level, session_id, ret_info, ret_count);
  94
  95     if (!ret_info || !ret_count)
  96     {
  97         SetLastError(ERROR_INVALID_PARAMETER);
  98         return FALSE;
  99     }
 100
 101     if (session_id != WTS_ANY_SESSION)
 102         FIXME("ignoring session id %#lx\n", session_id);
 103
 104     if (*level)
 105     {
 106         FIXME("unhandled level %lu\n", *level);
 107         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 108         return FALSE;
 109     }
 110
 111     if (!(nt_info = malloc(nt_size)))
 112     {
 113         SetLastError(ERROR_OUTOFMEMORY);
 114         return FALSE;
 115     }
 116
 117     while ((status = NtQuerySystemInformation(SystemProcessInformation, nt_info,
 118             nt_size, NULL)) == STATUS_INFO_LENGTH_MISMATCH)
 119     {
 120         SYSTEM_PROCESS_INFORMATION *new_info;
 121
 122         nt_size *= 2;
 123         if (!(new_info = realloc(nt_info, nt_size)))
 124         {
 125             free(nt_info);
 126             SetLastError(ERROR_OUTOFMEMORY);
 127             return FALSE;
 128         }
 129         nt_info = new_info;
 130     }
 131     if (status)
 132     {
 133         free(nt_info);
 134         SetLastError(RtlNtStatusToDosError(status));
 135         return FALSE;
 136     }
 137
 138     size = 0;
 139     count = 0;
 140     nt_process = nt_info;
 141     for (;;)
 142     {
 143         size += sizeof(WTS_PROCESS_INFOW) + nt_process->ProcessName.Length + sizeof(WCHAR);
 144         size += offsetof(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES]);
 145         ++count;
 146
 147         if (!nt_process->NextEntryOffset)
 148             break;
 149         nt_process = (SYSTEM_PROCESS_INFORMATION *)((char *)nt_process + nt_process->NextEntryOffset);
 150     }
 151
 152     if (!(info = heap_alloc(size)))
 153     {
 154         free(nt_info);
 155         SetLastError(ERROR_OUTOFMEMORY);
 156         return FALSE;
 157     }
 158     p = (char *)(info + count);
 159
 160     count = 0;
 161     nt_process = nt_info;
 162     for (;;)
 163     {
 164         HANDLE process, token;
 165
 166         info[count].SessionId = nt_process->SessionId;
 167         info[count].ProcessId = (DWORD_PTR)nt_process->UniqueProcessId;
 168
 169         info[count].pProcessName = (WCHAR *)p;
 170         memcpy(p, nt_process->ProcessName.Buffer, nt_process->ProcessName.Length);
 171         info[count].pProcessName[nt_process->ProcessName.Length / sizeof(WCHAR)] = 0;
 172         p += nt_process->ProcessName.Length + sizeof(WCHAR);
 173
 174         info[count].pUserSid = NULL;
 175         if ((process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, info[count].ProcessId)))
 176         {
 177             if (OpenProcessToken(process, TOKEN_QUERY, &token))
 178             {
 179                 char buffer[sizeof(TOKEN_USER) + offsetof(SID, SubAuthority[SID_MAX_SUB_AUTHORITIES])];
 180                 TOKEN_USER *user = (TOKEN_USER *)buffer;
 181                 DWORD size;
 182
 183                 GetTokenInformation(token, TokenUser, buffer, sizeof(buffer), &size);
 184                 info[count].pUserSid = p;
 185                 size = GetLengthSid(user->User.Sid);
 186                 memcpy(p, user->User.Sid, size);
 187                 p += size;
 188                 CloseHandle(token);
 189             }
 190             CloseHandle(process);
 191         }
 192
 193         ++count;
 194         if (!nt_process->NextEntryOffset)
 195             break;
 196         nt_process = (SYSTEM_PROCESS_INFORMATION *)((char *)nt_process + nt_process->NextEntryOffset);
 197     }
 198
 199     *ret_info = (WCHAR *)info;
 200     *ret_count = count;
 201     SetLastError(0);
 202     return TRUE;
 203 }
 204
 205 /************************************************************
 206  *                WTSEnumerateProcessesExA  (WTSAPI32.@)
 207  */
 208 BOOL WINAPI WTSEnumerateProcessesExA(HANDLE server, DWORD *level, DWORD session_id, char **info, DWORD *count)
 209 {
 210     FIXME("Stub %p %p %ld %p %p\n", server, level, session_id, info, count);
 211     if (count) *count = 0;
 212     return FALSE;
 213 }
 214
 215 /************************************************************
 216  *                WTSEnumerateProcessesA  (WTSAPI32.@)
 217  */
 218 BOOL WINAPI WTSEnumerateProcessesA(HANDLE hServer, DWORD Reserved, DWORD Version,
 219     PWTS_PROCESS_INFOA* ppProcessInfo, DWORD* pCount)
 220 {
 221     FIXME("Stub %p 0x%08lx 0x%08lx %p %p\n", hServer, Reserved, Version,
 222           ppProcessInfo, pCount);
 223
 224     if (!ppProcessInfo || !pCount) return FALSE;
 225
 226     *pCount = 0;
 227     *ppProcessInfo = NULL;
 228
 229     return TRUE;
 230 }
 231
 232 /************************************************************
 233  *                WTSEnumerateProcessesW  (WTSAPI32.@)
 234  */
 235 BOOL WINAPI WTSEnumerateProcessesW(HANDLE server, DWORD reserved, DWORD version,
 236         WTS_PROCESS_INFOW **info, DWORD *count)
 237 {
 238     DWORD level = 0;
 239
 240     TRACE("server %p, reserved %#lx, version %lu, info %p, count %p\n", server, reserved, version, info, count);
 241
 242     if (reserved || version != 1)
 243     {
 244         SetLastError(ERROR_INVALID_PARAMETER);
 245         return FALSE;
 246     }
 247
 248     return WTSEnumerateProcessesExW(server, &level, WTS_ANY_SESSION, (WCHAR **)info, count);
 249 }
 250
 251 /************************************************************
 252  *                WTSEnumerateServersA  (WTSAPI32.@)
 253  */
 254 BOOL WINAPI WTSEnumerateServersA(LPSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOA *ppServerInfo, DWORD *pCount)
 255 {
 256     FIXME("Stub %s 0x%08lx 0x%08lx %p %p\n", debugstr_a(pDomainName), Reserved, Version, ppServerInfo, pCount);
 257     return FALSE;
 258 }
 259
 260 /************************************************************
 261  *                WTSEnumerateServersW  (WTSAPI32.@)
 262  */
 263 BOOL WINAPI WTSEnumerateServersW(LPWSTR pDomainName, DWORD Reserved, DWORD Version, PWTS_SERVER_INFOW *ppServerInfo, DWORD *pCount)
 264 {
 265     FIXME("Stub %s 0x%08lx 0x%08lx %p %p\n", debugstr_w(pDomainName), Reserved, Version, ppServerInfo, pCount);
 266     return FALSE;
 267 }
 268
 269
 270 /************************************************************
 271  *                WTSEnumerateEnumerateSessionsExW  (WTSAPI32.@)
 272  */
 273 BOOL WINAPI WTSEnumerateSessionsExW(HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1W* info, DWORD *count)
 274 {
 275     FIXME("Stub %p %p %ld %p %p\n", server, level, filter, info, count);
 276     if (count) *count = 0;
 277     return FALSE;
 278 }
 279
 280 /************************************************************
 281  *                WTSEnumerateEnumerateSessionsExA  (WTSAPI32.@)
 282  */
 283 BOOL WINAPI WTSEnumerateSessionsExA(HANDLE server, DWORD *level, DWORD filter, WTS_SESSION_INFO_1A* info, DWORD *count)
 284 {
 285     FIXME("Stub %p %p %ld %p %p\n", server, level, filter, info, count);
 286     if (count) *count = 0;
 287     return FALSE;
 288 }
 289
 290 /************************************************************
 291  *                WTSEnumerateEnumerateSessionsA  (WTSAPI32.@)
 292  */
 293 BOOL WINAPI WTSEnumerateSessionsA(HANDLE hServer, DWORD Reserved, DWORD Version,
 294     PWTS_SESSION_INFOA* ppSessionInfo, DWORD* pCount)
 295 {
 296     static int once;
 297
 298     if (!once++) FIXME("Stub %p 0x%08lx 0x%08lx %p %p\n", hServer, Reserved, Version,
 299           ppSessionInfo, pCount);
 300
 301     if (!ppSessionInfo || !pCount) return FALSE;
 302
 303     *pCount = 0;
 304     *ppSessionInfo = NULL;
 305
 306     return TRUE;
 307 }
 308
 309 /************************************************************
 310  *                WTSEnumerateEnumerateSessionsW  (WTSAPI32.@)
 311  */
 312 BOOL WINAPI WTSEnumerateSessionsW(HANDLE hServer, DWORD Reserved, DWORD Version,
 313     PWTS_SESSION_INFOW* ppSessionInfo, DWORD* pCount)
 314 {
 315     FIXME("Stub %p 0x%08lx 0x%08lx %p %p\n", hServer, Reserved, Version,
 316           ppSessionInfo, pCount);
 317
 318     if (!ppSessionInfo || !pCount) return FALSE;
 319
 320     *pCount = 0;
 321     *ppSessionInfo = NULL;
 322
 323     return TRUE;
 324 }
 325
 326 /************************************************************
 327  *                WTSFreeMemory (WTSAPI32.@)
 328  */
 329 void WINAPI WTSFreeMemory(PVOID pMemory)
 330 {
 331     heap_free(pMemory);
 332 }
 333
 334 /************************************************************
 335  *                WTSFreeMemoryExA (WTSAPI32.@)
 336  */
 337 BOOL WINAPI WTSFreeMemoryExA(WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
 338 {
 339     TRACE("%d %p %ld\n", type, ptr, nmemb);
 340     heap_free(ptr);
 341     return TRUE;
 342 }
 343
 344 /************************************************************
 345  *                WTSFreeMemoryExW (WTSAPI32.@)
 346  */
 347 BOOL WINAPI WTSFreeMemoryExW(WTS_TYPE_CLASS type, void *ptr, ULONG nmemb)
 348 {
 349     TRACE("%d %p %ld\n", type, ptr, nmemb);
 350     heap_free(ptr);
 351     return TRUE;
 352 }
 353
 354
 355 /************************************************************
 356  *                WTSLogoffSession (WTSAPI32.@)
 357  */
 358 BOOL WINAPI WTSLogoffSession(HANDLE hserver, DWORD session_id, BOOL bwait)
 359 {
 360     FIXME("(%p, 0x%lx, %d): stub\n", hserver, session_id, bwait);
 361     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 362     return FALSE;
 363 }
 364
 365
 366 /************************************************************
 367  *                WTSOpenServerExW (WTSAPI32.@)
 368  */
 369 HANDLE WINAPI WTSOpenServerExW(WCHAR *server_name)
 370 {
 371     FIXME("(%s) stub\n", debugstr_w(server_name));
 372     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 373     return NULL;
 374 }
 375
 376 /************************************************************
 377  *                WTSOpenServerExA (WTSAPI32.@)
 378  */
 379 HANDLE WINAPI WTSOpenServerExA(char *server_name)
 380 {
 381     FIXME("(%s) stub\n", debugstr_a(server_name));
 382     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 383     return NULL;
 384 }
 385
 386 /************************************************************
 387  *                WTSOpenServerA (WTSAPI32.@)
 388  */
 389 HANDLE WINAPI WTSOpenServerA(LPSTR pServerName)
 390 {
 391     FIXME("(%s) stub\n", debugstr_a(pServerName));
 392     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 393     return NULL;
 394 }
 395
 396 /************************************************************
 397  *                WTSOpenServerW (WTSAPI32.@)
 398  */
 399 HANDLE WINAPI WTSOpenServerW(LPWSTR pServerName)
 400 {
 401     FIXME("(%s) stub\n", debugstr_w(pServerName));
 402     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 403     return NULL;
 404 }
 405
 406 /************************************************************
 407  *                WTSQuerySessionInformationA  (WTSAPI32.@)
 408  */
 409 BOOL WINAPI WTSQuerySessionInformationA(HANDLE server, DWORD session_id, WTS_INFO_CLASS class, char **buffer, DWORD *count)
 410 {
 411     WCHAR *bufferW = NULL;
 412
 413     TRACE("%p 0x%08lx %d %p %p\n", server, session_id, class, buffer, count);
 414
 415     if (!buffer || !count)
 416     {
 417         SetLastError(ERROR_INVALID_USER_BUFFER);
 418         return FALSE;
 419     }
 420
 421     if (class == WTSClientProtocolType)
 422     {
 423         USHORT *protocol;
 424
 425         if (!(protocol = heap_alloc(sizeof(*protocol)))) return FALSE;
 426         FIXME("returning 0 protocol type\n");
 427         *protocol = 0;
 428         *buffer = (char *)protocol;
 429         *count = sizeof(*protocol);
 430         return TRUE;
 431     }
 432
 433     if (!WTSQuerySessionInformationW(server, session_id, class, &bufferW, count))
 434         return FALSE;
 435
 436     *count = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
 437     if (!*count)
 438     {
 439         WTSFreeMemory(bufferW);
 440         return FALSE;
 441     }
 442
 443     if (!(*buffer = heap_alloc(*count)))
 444     {
 445         WTSFreeMemory(bufferW);
 446         return FALSE;
 447     }
 448
 449     if (!(*count = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, *buffer, *count, NULL, NULL)))
 450     {
 451         WTSFreeMemory(bufferW);
 452         heap_free(*buffer);
 453         return FALSE;
 454     }
 455
 456     WTSFreeMemory(bufferW);
 457     return TRUE;
 458 }
 459
 460 /************************************************************
 461  *                WTSQuerySessionInformationW  (WTSAPI32.@)
 462  */
 463 BOOL WINAPI WTSQuerySessionInformationW(HANDLE server, DWORD session_id, WTS_INFO_CLASS class, WCHAR **buffer, DWORD *count)
 464 {
 465     TRACE("%p 0x%08lx %d %p %p\n", server, session_id, class, buffer, count);
 466
 467     if (!buffer || !count)
 468     {
 469         SetLastError(ERROR_INVALID_USER_BUFFER);
 470         return FALSE;
 471     }
 472
 473     if (class == WTSClientProtocolType)
 474     {
 475         USHORT *protocol;
 476
 477         if (!(protocol = heap_alloc(sizeof(*protocol)))) return FALSE;
 478         FIXME("returning 0 protocol type\n");
 479         *protocol = 0;
 480         *buffer = (WCHAR *)protocol;
 481         *count = sizeof(*protocol);
 482         return TRUE;
 483     }
 484
 485     if (class == WTSUserName)
 486     {
 487         DWORD size = UNLEN + 1;
 488         WCHAR *username;
 489
 490         if (!(username = heap_alloc(size * sizeof(WCHAR)))) return FALSE;
 491         GetUserNameW(username, &size);
 492         *buffer = username;
 493         *count = size * sizeof(WCHAR);
 494         return TRUE;
 495     }
 496
 497     if (class ==  WTSDomainName)
 498     {
 499         DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
 500         WCHAR *computername;
 501
 502         if (!(computername = heap_alloc(size * sizeof(WCHAR)))) return FALSE;
 503         GetComputerNameW(computername, &size);
 504         *buffer = computername;
 505         /* GetComputerNameW() return size doesn't include terminator */
 506         size++;
 507         *count = size * sizeof(WCHAR);
 508         return TRUE;
 509     }
 510
 511     FIXME("Unimplemented class %d\n", class);
 512
 513     *buffer = NULL;
 514     *count = 0;
 515     return FALSE;
 516 }
 517
 518 /************************************************************
 519  *                WTSQueryUserToken (WTSAPI32.@)
 520  */
 521 BOOL WINAPI WTSQueryUserToken(ULONG session_id, PHANDLE token)
 522 {
 523     FIXME("%lu %p semi-stub!\n", session_id, token);
 524
 525     if (!token)
 526     {
 527         SetLastError(ERROR_INVALID_PARAMETER);
 528         return FALSE;
 529     }
 530
 531     return DuplicateHandle(GetCurrentProcess(), GetCurrentProcessToken(),
 532                            GetCurrentProcess(), token,
 533                            0, FALSE, DUPLICATE_SAME_ACCESS);
 534 }
 535
 536 /************************************************************
 537  *                WTSQueryUserConfigA (WTSAPI32.@)
 538  */
 539 BOOL WINAPI WTSQueryUserConfigA(LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR *ppBuffer, DWORD *pBytesReturned)
 540 {
 541    FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,
 542         ppBuffer, pBytesReturned);
 543    return FALSE;
 544 }
 545
 546 /************************************************************
 547  *                WTSQueryUserConfigW (WTSAPI32.@)
 548  */
 549 BOOL WINAPI WTSQueryUserConfigW(LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR *ppBuffer, DWORD *pBytesReturned)
 550 {
 551    FIXME("Stub (%s) (%s) 0x%08x %p %p\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,
 552         ppBuffer, pBytesReturned);
 553    return FALSE;
 554 }
 555
 556
 557 /************************************************************
 558  *                WTSRegisterSessionNotification (WTSAPI32.@)
 559  */
 560 BOOL WINAPI WTSRegisterSessionNotification(HWND hWnd, DWORD dwFlags)
 561 {
 562     FIXME("Stub %p 0x%08lx\n", hWnd, dwFlags);
 563     return TRUE;
 564 }
 565
 566 /************************************************************
 567  *                WTSRegisterSessionNotificationEx (WTSAPI32.@)
 568  */
 569 BOOL WINAPI WTSRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd, DWORD dwFlags)
 570 {
 571     FIXME("Stub %p %p 0x%08lx\n", hServer, hWnd, dwFlags);
 572     return TRUE;
 573 }
 574
 575
 576 /************************************************************
 577  *                WTSSendMessageA (WTSAPI32.@)
 578  */
 579 BOOL WINAPI WTSSendMessageA(HANDLE hServer, DWORD SessionId, LPSTR pTitle, DWORD TitleLength, LPSTR pMessage,
 580    DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
 581 {
 582    FIXME("Stub %p 0x%08lx (%s) %ld (%s) %ld 0x%08lx %ld %p %d\n", hServer, SessionId, debugstr_a(pTitle), TitleLength, debugstr_a(pMessage), MessageLength, Style, Timeout, pResponse, bWait);
 583    return FALSE;
 584 }
 585
 586 /************************************************************
 587  *                WTSSendMessageW (WTSAPI32.@)
 588  */
 589 BOOL WINAPI WTSSendMessageW(HANDLE hServer, DWORD SessionId, LPWSTR pTitle, DWORD TitleLength, LPWSTR pMessage,
 590    DWORD MessageLength, DWORD Style, DWORD Timeout, DWORD *pResponse, BOOL bWait)
 591 {
 592    FIXME("Stub %p 0x%08lx (%s) %ld (%s) %ld 0x%08lx %ld %p %d\n", hServer, SessionId, debugstr_w(pTitle), TitleLength, debugstr_w(pMessage), MessageLength, Style, Timeout, pResponse, bWait);
 593    return FALSE;
 594 }
 595
 596 /************************************************************
 597  *                WTSSetUserConfigA (WTSAPI32.@)
 598  */
 599 BOOL WINAPI WTSSetUserConfigA(LPSTR pServerName, LPSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPSTR pBuffer, DWORD DataLength)
 600 {
 601    FIXME("Stub (%s) (%s) 0x%08x %p %ld\n", debugstr_a(pServerName), debugstr_a(pUserName), WTSConfigClass,pBuffer, DataLength);
 602    return FALSE;
 603 }
 604
 605 /************************************************************
 606  *                WTSSetUserConfigW (WTSAPI32.@)
 607  */
 608 BOOL WINAPI WTSSetUserConfigW(LPWSTR pServerName, LPWSTR pUserName, WTS_CONFIG_CLASS WTSConfigClass, LPWSTR pBuffer, DWORD DataLength)
 609 {
 610    FIXME("Stub (%s) (%s) 0x%08x %p %ld\n", debugstr_w(pServerName), debugstr_w(pUserName), WTSConfigClass,pBuffer, DataLength);
 611    return FALSE;
 612 }
 613
 614 /************************************************************
 615  *                WTSShutdownSystem (WTSAPI32.@)
 616  */
 617 BOOL WINAPI WTSShutdownSystem(HANDLE hServer, DWORD ShutdownFlag)
 618 {
 619    FIXME("Stub %p 0x%08lx\n", hServer,ShutdownFlag);
 620    return FALSE;
 621 }
 622
 623 /************************************************************
 624  *                WTSStartRemoteControlSessionA (WTSAPI32.@)
 625  */
 626 BOOL WINAPI WTSStartRemoteControlSessionA(LPSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
 627 {
 628    FIXME("Stub (%s) %ld %d %d\n", debugstr_a(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
 629    return FALSE;
 630 }
 631
 632 /************************************************************
 633  *                WTSStartRemoteControlSessionW (WTSAPI32.@)
 634  */
 635 BOOL WINAPI WTSStartRemoteControlSessionW(LPWSTR pTargetServerName, ULONG TargetLogonId, BYTE HotkeyVk, USHORT HotkeyModifiers)
 636 {
 637    FIXME("Stub (%s) %ld %d %d\n", debugstr_w(pTargetServerName), TargetLogonId, HotkeyVk, HotkeyModifiers);
 638    return FALSE;
 639 }
 640
 641 /************************************************************
 642  *                WTSStopRemoteControlSession (WTSAPI32.@)
 643  */
 644 BOOL WINAPI WTSStopRemoteControlSession(ULONG LogonId)
 645 {
 646    FIXME("Stub %ld\n",  LogonId);
 647    return FALSE;
 648 }
 649
 650 /************************************************************
 651  *                WTSTerminateProcess (WTSAPI32.@)
 652  */
 653 BOOL WINAPI WTSTerminateProcess(HANDLE hServer, DWORD ProcessId, DWORD ExitCode)
 654 {
 655    FIXME("Stub %p %ld %ld\n", hServer, ProcessId, ExitCode);
 656    return FALSE;
 657 }
 658
 659 /************************************************************
 660  *                WTSUnRegisterSessionNotification (WTSAPI32.@)
 661  */
 662 BOOL WINAPI WTSUnRegisterSessionNotification(HWND hWnd)
 663 {
 664     FIXME("Stub %p\n", hWnd);
 665     return FALSE;
 666 }
 667
 668 /************************************************************
 669  *                WTSUnRegisterSessionNotification (WTSAPI32.@)
 670  */
 671 BOOL WINAPI WTSUnRegisterSessionNotificationEx(HANDLE hServer, HWND hWnd)
 672 {
 673     FIXME("Stub %p %p\n", hServer, hWnd);
 674     return FALSE;
 675 }
 676
 677
 678 /************************************************************
 679  *                WTSVirtualChannelClose (WTSAPI32.@)
 680  */
 681 BOOL WINAPI WTSVirtualChannelClose(HANDLE hChannelHandle)
 682 {
 683    FIXME("Stub %p\n", hChannelHandle);
 684    return FALSE;
 685 }
 686
 687 /************************************************************
 688  *                WTSVirtualChannelOpen (WTSAPI32.@)
 689  */
 690 HANDLE WINAPI WTSVirtualChannelOpen(HANDLE hServer, DWORD SessionId, LPSTR pVirtualName)
 691 {
 692    FIXME("Stub %p %ld (%s)\n", hServer, SessionId, debugstr_a(pVirtualName));
 693    return NULL;
 694 }
 695
 696 /************************************************************
 697  *                WTSVirtualChannelOpen (WTSAPI32.@)
 698  */
 699 HANDLE WINAPI WTSVirtualChannelOpenEx(DWORD SessionId, LPSTR pVirtualName, DWORD flags)
 700 {
 701    FIXME("Stub %ld (%s) %ld\n",  SessionId, debugstr_a(pVirtualName), flags);
 702    return NULL;
 703 }
 704
 705 /************************************************************
 706  *                WTSVirtualChannelPurgeInput (WTSAPI32.@)
 707  */
 708 BOOL WINAPI WTSVirtualChannelPurgeInput(HANDLE hChannelHandle)
 709 {
 710    FIXME("Stub %p\n", hChannelHandle);
 711    return FALSE;
 712 }
 713
 714 /************************************************************
 715  *                WTSVirtualChannelPurgeOutput (WTSAPI32.@)
 716  */
 717 BOOL WINAPI WTSVirtualChannelPurgeOutput(HANDLE hChannelHandle)
 718 {
 719    FIXME("Stub %p\n", hChannelHandle);
 720    return FALSE;
 721 }
 722
 723
 724 /************************************************************
 725  *                WTSVirtualChannelQuery (WTSAPI32.@)
 726  */
 727 BOOL WINAPI WTSVirtualChannelQuery(HANDLE hChannelHandle, WTS_VIRTUAL_CLASS WtsVirtualClass, PVOID *ppBuffer, DWORD *pBytesReturned)
 728 {
 729    FIXME("Stub %p %d %p %p\n", hChannelHandle, WtsVirtualClass, ppBuffer, pBytesReturned);
 730    return FALSE;
 731 }
 732
 733 /************************************************************
 734  *                WTSVirtualChannelRead (WTSAPI32.@)
 735  */
 736 BOOL WINAPI WTSVirtualChannelRead(HANDLE hChannelHandle, ULONG TimeOut, PCHAR Buffer, ULONG BufferSize, PULONG pBytesRead)
 737 {
 738    FIXME("Stub %p %ld %p %ld %p\n", hChannelHandle, TimeOut, Buffer, BufferSize, pBytesRead);
 739    return FALSE;
 740 }
 741
 742 /************************************************************
 743  *                WTSVirtualChannelWrite (WTSAPI32.@)
 744  */
 745 BOOL WINAPI WTSVirtualChannelWrite(HANDLE hChannelHandle, PCHAR Buffer, ULONG Length, PULONG pBytesWritten)
 746 {
 747    FIXME("Stub %p %p %ld %p\n", hChannelHandle, Buffer, Length, pBytesWritten);
 748    return FALSE;
 749 }
 750
 751 /************************************************************
 752  *                WTSWaitSystemEvent (WTSAPI32.@)
 753  */
 754 BOOL WINAPI WTSWaitSystemEvent(HANDLE hServer, DWORD Mask, DWORD* Flags)
 755 {
 756     /* FIXME: Forward request to winsta.dll::WinStationWaitSystemEvent */
 757     FIXME("Stub %p 0x%08lx %p\n", hServer, Mask, Flags);
 758     return FALSE;
 759 }