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