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