[WTSAPI32][PSDK] Addendum to 27ed609a: Some of the WTS_INFO_CLASS values are NT6...
[reactos.git] / dll / win32 / 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 "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 }