1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS User API Server DLL
4 * FILE: win32ss/user/winsrv/usersrv/shutdown.c
5 * PURPOSE: Logout/shutdown
6 * PROGRAMMERS:
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include "usersrv.h"
12
13 #include <commctrl.h>
14 #include <psapi.h>
15
16 #include "resource.h"
17
18 #define NDEBUG
19 #include <debug.h>
20
21 /* GLOBALS ********************************************************************/
22
23 // Those flags (that are used for CsrProcess->ShutdownFlags) are named
24 // in accordance to the only public one: SHUTDOWN_NORETRY used for the
25 // SetProcessShutdownParameters API.
26 #if !defined(SHUTDOWN_SYSTEMCONTEXT) && !defined(SHUTDOWN_OTHERCONTEXT)
27 #define SHUTDOWN_SYSTEMCONTEXT CsrShutdownSystem
28 #define SHUTDOWN_OTHERCONTEXT CsrShutdownOther
29 #endif
30
31 // The DPRINTs that need to really be removed as soon as everything works.
32 #define MY_DPRINT DPRINT1
33 #define MY_DPRINT2 DPRINT
34
35 typedef struct tagNOTIFY_CONTEXT
36 {
37 UINT Msg;
38 WPARAM wParam;
39 LPARAM lParam;
40 // HDESK Desktop;
41 // HDESK OldDesktop;
42 DWORD StartTime;
43 DWORD QueryResult;
44 HWND Dlg;
45 DWORD EndNowResult;
46 BOOL ShowUI;
47 HANDLE UIThread;
48 HWND WndClient;
49 PSHUTDOWN_SETTINGS ShutdownSettings;
50 } NOTIFY_CONTEXT, *PNOTIFY_CONTEXT;
51
52 #define QUERY_RESULT_ABORT 0
53 #define QUERY_RESULT_CONTINUE 1
54 #define QUERY_RESULT_TIMEOUT 2
55 #define QUERY_RESULT_ERROR 3
56 #define QUERY_RESULT_FORCE 4
57
58 typedef void (WINAPI *INITCOMMONCONTROLS_PROC)(void);
59
60 typedef struct tagMESSAGE_CONTEXT
61 {
62 HWND Wnd;
63 UINT Msg;
64 WPARAM wParam;
65 LPARAM lParam;
66 DWORD Timeout;
67 } MESSAGE_CONTEXT, *PMESSAGE_CONTEXT;
68
69
70 /* FUNCTIONS ******************************************************************/
71
72 static HMODULE hComCtl32Lib = NULL;
73
74 static VOID
CallInitCommonControls(VOID)75 CallInitCommonControls(VOID)
76 {
77 static BOOL Initialized = FALSE;
78 INITCOMMONCONTROLS_PROC InitProc;
79
80 if (Initialized) return;
81
82 hComCtl32Lib = LoadLibraryW(L"COMCTL32.DLL");
83 if (hComCtl32Lib == NULL) return;
84
85 InitProc = (INITCOMMONCONTROLS_PROC)GetProcAddress(hComCtl32Lib, "InitCommonControls");
86 if (InitProc == NULL) return;
87
88 (*InitProc)();
89
90 Initialized = TRUE;
91 }
92
93 static VOID FASTCALL
UpdateProgressBar(HWND ProgressBar,PNOTIFY_CONTEXT NotifyContext)94 UpdateProgressBar(HWND ProgressBar, PNOTIFY_CONTEXT NotifyContext)
95 {
96 DWORD Passed;
97
98 Passed = GetTickCount() - NotifyContext->StartTime;
99 Passed -= NotifyContext->ShutdownSettings->HungAppTimeout;
100 if (NotifyContext->ShutdownSettings->WaitToKillAppTimeout < Passed)
101 {
102 Passed = NotifyContext->ShutdownSettings->WaitToKillAppTimeout;
103 }
104 SendMessageW(ProgressBar, PBM_SETPOS, Passed / 2, 0);
105 }
106
107 static INT_PTR CALLBACK
EndNowDlgProc(HWND Dlg,UINT Msg,WPARAM wParam,LPARAM lParam)108 EndNowDlgProc(HWND Dlg, UINT Msg, WPARAM wParam, LPARAM lParam)
109 {
110 INT_PTR Result;
111 PNOTIFY_CONTEXT NotifyContext;
112 HWND ProgressBar;
113 DWORD TitleLength;
114 int Len;
115 LPWSTR Title;
116
117 switch(Msg)
118 {
119 case WM_INITDIALOG:
120 NotifyContext = (PNOTIFY_CONTEXT)lParam;
121 NotifyContext->EndNowResult = QUERY_RESULT_ABORT;
122 SetWindowLongPtrW(Dlg, DWLP_USER, (LONG_PTR)lParam);
123 TitleLength = SendMessageW(NotifyContext->WndClient, WM_GETTEXTLENGTH,
124 0, 0) +
125 GetWindowTextLengthW(Dlg);
126 Title = HeapAlloc(UserServerHeap, 0, (TitleLength + 1) * sizeof(WCHAR));
127 if (Title)
128 {
129 Len = GetWindowTextW(Dlg, Title, TitleLength + 1);
130 SendMessageW(NotifyContext->WndClient, WM_GETTEXT,
131 TitleLength + 1 - Len, (LPARAM)(Title + Len));
132 SetWindowTextW(Dlg, Title);
133 HeapFree(UserServerHeap, 0, Title);
134 }
135 ProgressBar = GetDlgItem(Dlg, IDC_PROGRESS);
136 SendMessageW(ProgressBar, PBM_SETRANGE32, 0,
137 NotifyContext->ShutdownSettings->WaitToKillAppTimeout / 2);
138 UpdateProgressBar(ProgressBar, NotifyContext);
139 SetTimer(Dlg, 0, 200, NULL);
140 Result = FALSE;
141 break;
142
143 case WM_TIMER:
144 NotifyContext = (PNOTIFY_CONTEXT)GetWindowLongPtrW(Dlg, DWLP_USER);
145 ProgressBar = GetDlgItem(Dlg, IDC_PROGRESS);
146 UpdateProgressBar(ProgressBar, NotifyContext);
147 Result = TRUE;
148 break;
149
150 case WM_COMMAND:
151 if (BN_CLICKED == HIWORD(wParam) && IDC_END_NOW == LOWORD(wParam))
152 {
153 NotifyContext = (PNOTIFY_CONTEXT)GetWindowLongPtrW(Dlg, DWLP_USER);
154 NotifyContext->EndNowResult = QUERY_RESULT_FORCE;
155 MY_DPRINT("Closing progress dlg by hand\n");
156 SendMessageW(Dlg, WM_CLOSE, 0, 0);
157 Result = TRUE;
158 }
159 else
160 {
161 Result = FALSE;
162 }
163 break;
164
165 case WM_CLOSE:
166 MY_DPRINT("WM_CLOSE\n");
167 DestroyWindow(Dlg);
168 Result = TRUE;
169 break;
170
171 case WM_DESTROY:
172 MY_DPRINT("WM_DESTROY\n");
173 NotifyContext = (PNOTIFY_CONTEXT)GetWindowLongPtrW(Dlg, DWLP_USER);
174 NotifyContext->Dlg = NULL;
175 KillTimer(Dlg, 0);
176 PostQuitMessage(NotifyContext->EndNowResult);
177 Result = TRUE;
178 break;
179
180 default:
181 Result = FALSE;
182 break;
183 }
184
185 return Result;
186 }
187
188 static DWORD WINAPI
EndNowThreadProc(LPVOID Parameter)189 EndNowThreadProc(LPVOID Parameter)
190 {
191 PNOTIFY_CONTEXT NotifyContext = (PNOTIFY_CONTEXT)Parameter;
192 MSG Msg;
193
194 #if 0
195 SetThreadDesktop(NotifyContext->Desktop);
196 SwitchDesktop(NotifyContext->Desktop);
197 #else
198 /* For now show the end task dialog in the active desktop */
199 NtUserSetInformationThread(NtCurrentThread(),
200 UserThreadUseActiveDesktop,
201 NULL,
202 0);
203 #endif
204
205 CallInitCommonControls();
206 NotifyContext->Dlg = CreateDialogParam(UserServerDllInstance,
207 MAKEINTRESOURCE(IDD_END_NOW), NULL,
208 EndNowDlgProc, (LPARAM)NotifyContext);
209 if (NotifyContext->Dlg == NULL)
210 return 0;
211
212 ShowWindow(NotifyContext->Dlg, SW_SHOWNORMAL);
213
214 while (GetMessageW(&Msg, NULL, 0, 0))
215 {
216 if (!IsDialogMessage(NotifyContext->Dlg, &Msg))
217 {
218 TranslateMessage(&Msg);
219 DispatchMessageW(&Msg);
220 }
221 }
222
223 return Msg.wParam;
224 }
225
226 static DWORD WINAPI
SendClientShutdown(LPVOID Parameter)227 SendClientShutdown(LPVOID Parameter)
228 {
229 PMESSAGE_CONTEXT Context = (PMESSAGE_CONTEXT)Parameter;
230 DWORD_PTR Result;
231
232 /* If the shutdown is aborted, just notify the process, there is no need to wait */
233 if ((Context->wParam & (MCS_QUERYENDSESSION | MCS_ENDSESSION)) == 0)
234 {
235 DPRINT("Called WM_CLIENTSHUTDOWN with wParam == 0 ...\n");
236 SendNotifyMessageW(Context->Wnd, WM_CLIENTSHUTDOWN,
237 Context->wParam, Context->lParam);
238 return QUERY_RESULT_CONTINUE;
239 }
240
241 if (SendMessageTimeoutW(Context->Wnd, WM_CLIENTSHUTDOWN,
242 Context->wParam, Context->lParam,
243 SMTO_NORMAL, Context->Timeout, &Result))
244 {
245 DWORD Ret;
246
247 if (Context->wParam & MCS_QUERYENDSESSION)
248 {
249 /* WM_QUERYENDSESSION case */
250 switch (Result)
251 {
252 case MCSR_DONOTSHUTDOWN:
253 Ret = QUERY_RESULT_ABORT;
254 break;
255
256 case MCSR_GOODFORSHUTDOWN:
257 case MCSR_SHUTDOWNFINISHED:
258 default:
259 Ret = QUERY_RESULT_CONTINUE;
260 }
261 }
262 else
263 {
264 /* WM_ENDSESSION case */
265 Ret = QUERY_RESULT_CONTINUE;
266 }
267
268 DPRINT("SendClientShutdown -- Return == %s\n",
269 Ret == QUERY_RESULT_CONTINUE ? "Continue" : "Abort");
270 return Ret;
271 }
272
273 DPRINT1("SendClientShutdown -- Error == %s\n",
274 GetLastError() == 0 ? "Timeout" : "error");
275
276 return (GetLastError() == 0 ? QUERY_RESULT_TIMEOUT : QUERY_RESULT_ERROR);
277 }
278
279 static BOOL
NotifyTopLevelWindow(HWND Wnd,PNOTIFY_CONTEXT NotifyContext)280 NotifyTopLevelWindow(HWND Wnd, PNOTIFY_CONTEXT NotifyContext)
281 {
282 MESSAGE_CONTEXT MessageContext;
283 DWORD Now, Passed;
284 DWORD Timeout, WaitStatus;
285 HANDLE MessageThread;
286 HANDLE Threads[2];
287
288 SetForegroundWindow(Wnd);
289
290 Now = GetTickCount();
291 if (NotifyContext->StartTime == 0)
292 NotifyContext->StartTime = Now;
293
294 /*
295 * Note: Passed is computed correctly even when GetTickCount()
296 * wraps due to unsigned arithmetic.
297 */
298 Passed = Now - NotifyContext->StartTime;
299 MessageContext.Wnd = Wnd;
300 MessageContext.Msg = NotifyContext->Msg;
301 MessageContext.wParam = NotifyContext->wParam;
302 MessageContext.lParam = NotifyContext->lParam;
303 MessageContext.Timeout = NotifyContext->ShutdownSettings->HungAppTimeout;
304 if (!NotifyContext->ShutdownSettings->AutoEndTasks)
305 {
306 MessageContext.Timeout += NotifyContext->ShutdownSettings->WaitToKillAppTimeout;
307 }
308 if (Passed < MessageContext.Timeout)
309 {
310 MessageContext.Timeout -= Passed;
311 MessageThread = CreateThread(NULL, 0, SendClientShutdown,
312 (LPVOID)&MessageContext, 0, NULL);
313 if (MessageThread == NULL)
314 {
315 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
316 return FALSE;
317 }
318 Timeout = NotifyContext->ShutdownSettings->HungAppTimeout;
319 if (Passed < Timeout)
320 {
321 Timeout -= Passed;
322 WaitStatus = WaitForSingleObjectEx(MessageThread, Timeout, FALSE);
323 }
324 else
325 {
326 WaitStatus = WAIT_TIMEOUT;
327 }
328 if (WAIT_TIMEOUT == WaitStatus)
329 {
330 NotifyContext->WndClient = Wnd;
331 if (NotifyContext->UIThread == NULL && NotifyContext->ShowUI)
332 {
333 NotifyContext->UIThread = CreateThread(NULL, 0,
334 EndNowThreadProc,
335 (LPVOID)NotifyContext,
336 0, NULL);
337 }
338 Threads[0] = MessageThread;
339 Threads[1] = NotifyContext->UIThread;
340 WaitStatus = WaitForMultipleObjectsEx(NotifyContext->UIThread == NULL ?
341 1 : 2,
342 Threads, FALSE, INFINITE,
343 FALSE);
344 if (WaitStatus == WAIT_OBJECT_0)
345 {
346 if (!GetExitCodeThread(MessageThread, &NotifyContext->QueryResult))
347 {
348 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
349 }
350 }
351 else if (WaitStatus == WAIT_OBJECT_0 + 1)
352 {
353 if (!GetExitCodeThread(NotifyContext->UIThread,
354 &NotifyContext->QueryResult))
355 {
356 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
357 }
358 }
359 else
360 {
361 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
362 }
363 if (WaitStatus != WAIT_OBJECT_0)
364 {
365 TerminateThread(MessageThread, QUERY_RESULT_TIMEOUT);
366 }
367 }
368 else if (WaitStatus == WAIT_OBJECT_0)
369 {
370 if (!GetExitCodeThread(MessageThread,
371 &NotifyContext->QueryResult))
372 {
373 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
374 }
375 }
376 else
377 {
378 NotifyContext->QueryResult = QUERY_RESULT_ERROR;
379 }
380 CloseHandle(MessageThread);
381 }
382 else
383 {
384 NotifyContext->QueryResult = QUERY_RESULT_TIMEOUT;
385 }
386
387 DPRINT("NotifyContext->QueryResult == %d\n", NotifyContext->QueryResult);
388 return (NotifyContext->QueryResult == QUERY_RESULT_CONTINUE);
389 }
390
391 static BOOLEAN
IsConsoleMode(VOID)392 IsConsoleMode(VOID)
393 {
394 return (BOOLEAN)NtUserCallNoParam(NOPARAM_ROUTINE_ISCONSOLEMODE);
395 }
396
397 /************************************************/
398
399
400 static BOOL
ThreadShutdownNotify(IN PCSR_THREAD CsrThread,IN ULONG Flags,IN ULONG Flags2,IN PNOTIFY_CONTEXT Context)401 ThreadShutdownNotify(IN PCSR_THREAD CsrThread,
402 IN ULONG Flags,
403 IN ULONG Flags2,
404 IN PNOTIFY_CONTEXT Context)
405 {
406 HWND TopWnd = NULL;
407
408 EnumThreadWindows(HandleToUlong(CsrThread->ClientId.UniqueThread),
409 FindTopLevelWnd, (LPARAM)&TopWnd);
410 if (TopWnd)
411 {
412 HWND hWndOwner;
413
414 /*** FOR TESTING PURPOSES ONLY!! ***/
415 HWND tmpWnd;
416 tmpWnd = TopWnd;
417 /***********************************/
418
419 while ((hWndOwner = GetWindow(TopWnd, GW_OWNER)) != NULL)
420 {
421 MY_DPRINT("GetWindow(TopWnd, GW_OWNER) not returned NULL...\n");
422 TopWnd = hWndOwner;
423 }
424 if (TopWnd != tmpWnd) MY_DPRINT("(TopWnd = %x) != (tmpWnd = %x)\n", TopWnd, tmpWnd);
425 }
426 else
427 {
428 return FALSE;
429 }
430
431 Context->wParam = Flags2;
432 Context->lParam = (0 != (Flags & EWX_CALLER_WINLOGON_LOGOFF) ?
433 ENDSESSION_LOGOFF : 0);
434
435 Context->StartTime = 0;
436 Context->UIThread = NULL;
437 Context->ShowUI = !IsConsoleMode() && (Flags2 & (MCS_QUERYENDSESSION | MCS_ENDSESSION));
438 Context->Dlg = NULL;
439
440 #if 0 // Obviously, switching desktops like that from within WINSRV doesn't work...
441 {
442 BOOL Success;
443 Context->OldDesktop = GetThreadDesktop(GetCurrentThreadId());
444 // Context->Desktop = GetThreadDesktop(HandleToUlong(CsrThread->ClientId.UniqueThread));
445 Context->Desktop = GetThreadDesktop(GetWindowThreadProcessId(TopWnd, NULL));
446 MY_DPRINT("Last error = %d\n", GetLastError());
447 MY_DPRINT("Before switching to desktop 0x%x\n", Context->Desktop);
448 Success = SwitchDesktop(Context->Desktop);
449 MY_DPRINT("After switching to desktop (Success = %s ; last error = %d); going to notify top-level...\n",
450 Success ? "TRUE" : "FALSE", GetLastError());
451 }
452 #endif
453
454 NotifyTopLevelWindow(TopWnd, Context);
455
456 /******************************************************************************/
457 #if 1
458 if (Context->UIThread)
459 {
460 MY_DPRINT("Context->UIThread != NULL\n");
461 if (Context->Dlg)
462 {
463 MY_DPRINT("Sending WM_CLOSE because Dlg is != NULL\n");
464 SendMessageW(Context->Dlg, WM_CLOSE, 0, 0);
465 }
466 else
467 {
468 MY_DPRINT("Terminating UIThread thread with QUERY_RESULT_ERROR\n");
469 TerminateThread(Context->UIThread, QUERY_RESULT_ERROR);
470 }
471 CloseHandle(Context->UIThread);
472 /**/Context->UIThread = NULL;/**/
473 /**/Context->Dlg = NULL;/**/
474 }
475 #endif
476 /******************************************************************************/
477
478 #if 0
479 MY_DPRINT("Switch back to old desktop 0x%x\n", Context->OldDesktop);
480 SwitchDesktop(Context->OldDesktop);
481 MY_DPRINT("Switched back ok\n");
482 #endif
483
484 return TRUE;
485 }
486
487 static ULONG
NotifyUserProcessForShutdown(PCSR_PROCESS CsrProcess,PSHUTDOWN_SETTINGS ShutdownSettings,UINT Flags)488 NotifyUserProcessForShutdown(PCSR_PROCESS CsrProcess,
489 PSHUTDOWN_SETTINGS ShutdownSettings,
490 UINT Flags)
491 {
492 DWORD QueryResult = QUERY_RESULT_CONTINUE;
493 PCSR_PROCESS Process;
494 PCSR_THREAD Thread;
495 PLIST_ENTRY NextEntry;
496 NOTIFY_CONTEXT Context;
497 BOOL FoundWindows = FALSE;
498
499 /* In case we make a forced shutdown, just kill the process */
500 if (Flags & EWX_FORCE)
501 return CsrShutdownCsrProcess;
502
503 Context.ShutdownSettings = ShutdownSettings;
504 Context.QueryResult = QUERY_RESULT_CONTINUE; // We continue shutdown by default.
505
506 /* Lock the process */
507 CsrLockProcessByClientId(CsrProcess->ClientId.UniqueProcess, &Process);
508
509 /* Send first the QUERYENDSESSION messages to all the threads of the process */
510 MY_DPRINT2("Sending the QUERYENDSESSION messages...\n");
511
512 NextEntry = CsrProcess->ThreadList.Flink;
513 while (NextEntry != &CsrProcess->ThreadList)
514 {
515 /* Get the current thread entry */
516 Thread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
517
518 /* Move to the next entry */
519 NextEntry = NextEntry->Flink;
520
521 /* If the thread is being terminated, just skip it */
522 if (Thread->Flags & CsrThreadTerminated) continue;
523
524 /* Reference the thread and temporarily unlock the process */
525 CsrReferenceThread(Thread);
526 CsrUnlockProcess(Process);
527
528 Context.QueryResult = QUERY_RESULT_CONTINUE;
529 if (ThreadShutdownNotify(Thread, Flags, MCS_QUERYENDSESSION, &Context))
530 {
531 FoundWindows = TRUE;
532 }
533
534 /* Lock the process again and dereference the thread */
535 CsrLockProcessByClientId(CsrProcess->ClientId.UniqueProcess, &Process);
536 CsrDereferenceThread(Thread);
537
538 // FIXME: Analyze Context.QueryResult !!
539 /**/if (Context.QueryResult == QUERY_RESULT_ABORT) goto Quit;/**/
540 }
541
542 if (!FoundWindows)
543 {
544 /* We looped all threads but no top level window was found so we didn't send any message */
545 /* Let the console server run the generic process shutdown handler */
546 CsrUnlockProcess(Process);
547 return CsrShutdownNonCsrProcess;
548 }
549
550 QueryResult = Context.QueryResult;
551 MY_DPRINT2("QueryResult = %s\n",
552 QueryResult == QUERY_RESULT_ABORT ? "Abort" : "Continue");
553
554 /* Now send the ENDSESSION messages to the threads */
555 MY_DPRINT2("Now sending the ENDSESSION messages...\n");
556
557 NextEntry = CsrProcess->ThreadList.Flink;
558 while (NextEntry != &CsrProcess->ThreadList)
559 {
560 /* Get the current thread entry */
561 Thread = CONTAINING_RECORD(NextEntry, CSR_THREAD, Link);
562
563 /* Move to the next entry */
564 NextEntry = NextEntry->Flink;
565
566 /* If the thread is being terminated, just skip it */
567 if (Thread->Flags & CsrThreadTerminated) continue;
568
569 /* Reference the thread and temporarily unlock the process */
570 CsrReferenceThread(Thread);
571 CsrUnlockProcess(Process);
572
573 Context.QueryResult = QUERY_RESULT_CONTINUE;
574 ThreadShutdownNotify(Thread, Flags,
575 (QUERY_RESULT_ABORT != QueryResult) ? MCS_ENDSESSION : 0,
576 &Context);
577
578 /* Lock the process again and dereference the thread */
579 CsrLockProcessByClientId(CsrProcess->ClientId.UniqueProcess, &Process);
580 CsrDereferenceThread(Thread);
581 }
582
583 Quit:
584 /* Unlock the process */
585 CsrUnlockProcess(Process);
586
587 #if 0
588 if (Context.UIThread)
589 {
590 if (Context.Dlg)
591 {
592 SendMessageW(Context.Dlg, WM_CLOSE, 0, 0);
593 }
594 else
595 {
596 TerminateThread(Context.UIThread, QUERY_RESULT_ERROR);
597 }
598 CloseHandle(Context.UIThread);
599 }
600 #endif
601
602 /* Kill the process unless we abort shutdown */
603 if (QueryResult == QUERY_RESULT_ABORT)
604 return CsrShutdownCancelled;
605
606 return CsrShutdownCsrProcess;
607 }
608
609 static NTSTATUS FASTCALL
UserExitReactOS(PCSR_THREAD CsrThread,UINT Flags)610 UserExitReactOS(PCSR_THREAD CsrThread, UINT Flags)
611 {
612 NTSTATUS Status;
613 LUID CallerLuid;
614
615 DWORD ProcessId = HandleToUlong(CsrThread->ClientId.UniqueProcess);
616 DWORD ThreadId = HandleToUlong(CsrThread->ClientId.UniqueThread);
617
618 DPRINT1("SrvExitWindowsEx(ClientId: %lx.%lx, Flags: 0x%x)\n",
619 ProcessId, ThreadId, Flags);
620
621 /*
622 * Check for flags validity
623 */
624
625 if (Flags & EWX_CALLER_WINLOGON)
626 {
627 /* Only Winlogon can call this */
628 if (ProcessId != LogonProcessId)
629 {
630 DPRINT1("SrvExitWindowsEx call not from Winlogon\n");
631 return STATUS_ACCESS_DENIED;
632 }
633 }
634
635 /* Implicitely add the shutdown flag when we poweroff or reboot */
636 if (Flags & (EWX_POWEROFF | EWX_REBOOT))
637 Flags |= EWX_SHUTDOWN;
638
639 /*
640 * Impersonate and retrieve the caller's LUID so that
641 * we can only shutdown processes in its context.
642 */
643 if (!CsrImpersonateClient(NULL))
644 return STATUS_BAD_IMPERSONATION_LEVEL;
645
646 Status = CsrGetProcessLuid(NULL, &CallerLuid);
647 if (!NT_SUCCESS(Status))
648 {
649 DPRINT1("Unable to get caller LUID, Status = 0x%08x\n", Status);
650 goto Quit;
651 }
652
653 DPRINT("Caller LUID is: %lx.%lx\n", CallerLuid.HighPart, CallerLuid.LowPart);
654
655 /* Shutdown loop */
656 while (TRUE)
657 {
658 /* Notify Win32k and potentially Winlogon of the shutdown */
659 Status = NtUserSetInformationThread(CsrThread->ThreadHandle,
660 UserThreadInitiateShutdown,
661 &Flags, sizeof(Flags));
662 DPRINT("Win32k says: %lx\n", Status);
663 switch (Status)
664 {
665 /* We cannot wait here, the caller should start a new thread */
666 case STATUS_CANT_WAIT:
667 DPRINT1("NtUserSetInformationThread returned STATUS_CANT_WAIT\n");
668 goto Quit;
669
670 /* Shutdown is in progress */
671 case STATUS_PENDING:
672 DPRINT1("NtUserSetInformationThread returned STATUS_PENDING\n");
673 goto Quit;
674
675 /* Abort */
676 case STATUS_RETRY:
677 {
678 DPRINT1("NtUserSetInformationThread returned STATUS_RETRY\n");
679 UNIMPLEMENTED;
680 continue;
681 }
682
683 default:
684 {
685 if (!NT_SUCCESS(Status))
686 {
687 // FIXME: Use some UserSetLastNTError or SetLastNtError
688 // that we have defined for user32 or win32k usage only...
689 SetLastError(RtlNtStatusToDosError(Status));
690 goto Quit;
691 }
692 }
693 }
694
695 /* All good */
696 break;
697 }
698
699 /*
700 * OK we can continue. Now magic happens:
701 *
702 * Terminate all Win32 processes, stop if we find one kicking
703 * and screaming it doesn't want to die.
704 *
705 * This function calls the ShutdownProcessCallback callback of
706 * each CSR server for each Win32 process.
707 */
708 Status = CsrShutdownProcesses(&CallerLuid, Flags);
709 if (!NT_SUCCESS(Status))
710 {
711 DPRINT1("Failed to shutdown processes, Status = 0x%08x\n", Status);
712 }
713
714 // FIXME: If Status == STATUS_CANCELLED, call RecordShutdownReason
715
716 /* Tell Win32k and potentially Winlogon that we're done */
717 NtUserSetInformationThread(CsrThread->ThreadHandle,
718 UserThreadEndShutdown,
719 &Status, sizeof(Status));
720
721 DPRINT("SrvExitWindowsEx returned 0x%08x\n", Status);
722
723 Quit:
724 /* We are done */
725 CsrRevertToSelf();
726 return Status;
727 }
728
729
730 ULONG
731 NTAPI
UserClientShutdown(IN PCSR_PROCESS CsrProcess,IN ULONG Flags,IN BOOLEAN FirstPhase)732 UserClientShutdown(IN PCSR_PROCESS CsrProcess,
733 IN ULONG Flags,
734 IN BOOLEAN FirstPhase)
735 {
736 ULONG result;
737
738 DPRINT("UserClientShutdown(0x%p, 0x%x, %s) - [0x%x, 0x%x], ShutdownFlags: %lu\n",
739 CsrProcess, Flags, FirstPhase ? "FirstPhase" : "LastPhase",
740 CsrProcess->ClientId.UniqueProcess, CsrProcess->ClientId.UniqueThread,
741 CsrProcess->ShutdownFlags);
742
743 /*
744 * Check for process validity
745 */
746
747 /* Do not kill system processes when a user is logging off */
748 if ((Flags & EWX_SHUTDOWN) == EWX_LOGOFF &&
749 (CsrProcess->ShutdownFlags & (SHUTDOWN_OTHERCONTEXT | SHUTDOWN_SYSTEMCONTEXT)))
750 {
751 DPRINT("Do not kill a system process in a logoff request!\n");
752 return CsrShutdownNonCsrProcess;
753 }
754
755 /* Do not kill Winlogon */
756 if (CsrProcess->ClientId.UniqueProcess == UlongToHandle(LogonProcessId))
757 {
758 DPRINT("Not killing Winlogon; CsrProcess->ShutdownFlags = %lu\n",
759 CsrProcess->ShutdownFlags);
760
761 /* Returning CsrShutdownCsrProcess means that we handled this process by doing nothing */
762 /* This will mark winlogon as processed so consrv won't be notified again for it */
763 CsrDereferenceProcess(CsrProcess);
764 return CsrShutdownCsrProcess;
765 }
766
767 /* Notify the process for shutdown if needed */
768 result = NotifyUserProcessForShutdown(CsrProcess, &ShutdownSettings, Flags);
769 if (result == CsrShutdownCancelled || result == CsrShutdownNonCsrProcess)
770 {
771 if (result == CsrShutdownCancelled)
772 DPRINT1("Process 0x%x aborted shutdown\n", CsrProcess->ClientId.UniqueProcess);
773 return result;
774 }
775
776 /* Terminate this process */
777 #if DBG
778 {
779 WCHAR buffer[MAX_PATH];
780 if (!GetProcessImageFileNameW(CsrProcess->ProcessHandle, buffer, ARRAYSIZE(buffer)))
781 {
782 DPRINT1("Terminating process %x\n", CsrProcess->ClientId.UniqueProcess);
783 }
784 else
785 {
786 DPRINT1("Terminating process %x (%S)\n", CsrProcess->ClientId.UniqueProcess, buffer);
787 }
788 }
789 #endif
790 NtTerminateProcess(CsrProcess->ProcessHandle, 0);
791 WaitForSingleObject(CsrProcess->ProcessHandle, ShutdownSettings.ProcessTerminateTimeout);
792
793 /* We are done */
794 CsrDereferenceProcess(CsrProcess);
795 return CsrShutdownCsrProcess;
796 }
797
798
799 /* PUBLIC SERVER APIS *********************************************************/
800
801 /* API_NUMBER: UserpExitWindowsEx */
CSR_API(SrvExitWindowsEx)802 CSR_API(SrvExitWindowsEx)
803 {
804 NTSTATUS Status;
805 PUSER_EXIT_REACTOS ExitReactOSRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.ExitReactOSRequest;
806
807 Status = NtUserSetInformationThread(NtCurrentThread(),
808 UserThreadUseActiveDesktop,
809 NULL,
810 0);
811 if (!NT_SUCCESS(Status))
812 {
813 DPRINT1("Failed to set thread desktop!\n");
814 return Status;
815 }
816
817 Status = UserExitReactOS(CsrGetClientThread(), ExitReactOSRequest->Flags);
818 ExitReactOSRequest->Success = NT_SUCCESS(Status);
819 ExitReactOSRequest->LastError = GetLastError();
820
821 NtUserSetInformationThread(NtCurrentThread(), UserThreadRestoreDesktop, NULL, 0);
822
823 return Status;
824 }
825
826 /* API_NUMBER: UserpEndTask */
CSR_API(SrvEndTask)827 CSR_API(SrvEndTask)
828 {
829 PUSER_END_TASK EndTaskRequest = &((PUSER_API_MESSAGE)ApiMessage)->Data.EndTaskRequest;
830 NTSTATUS Status;
831
832 // FIXME: This is HACK-plemented!!
833 DPRINT1("SrvEndTask is HACKPLEMENTED!!\n");
834
835 Status = NtUserSetInformationThread(NtCurrentThread(),
836 UserThreadUseActiveDesktop,
837 NULL,
838 0);
839 if (!NT_SUCCESS(Status))
840 {
841 DPRINT1("Failed to set thread desktop!\n");
842 return Status;
843 }
844
845 SendMessageW(EndTaskRequest->WndHandle, WM_CLOSE, 0, 0);
846 // PostMessageW(EndTaskRequest->WndHandle, WM_CLOSE, 0, 0);
847
848 if (IsWindow(EndTaskRequest->WndHandle))
849 {
850 if (EndTaskRequest->Force)
851 {
852 EndTaskRequest->Success = DestroyWindow(EndTaskRequest->WndHandle);
853 EndTaskRequest->LastError = GetLastError();
854 }
855 else
856 {
857 EndTaskRequest->Success = FALSE;
858 }
859 }
860 else
861 {
862 EndTaskRequest->Success = TRUE;
863 EndTaskRequest->LastError = ERROR_SUCCESS;
864 }
865
866 NtUserSetInformationThread(NtCurrentThread(), UserThreadRestoreDesktop, NULL, 0);
867
868 return STATUS_SUCCESS;
869 }
870
871 /* API_NUMBER: UserpRecordShutdownReason */
CSR_API(SrvRecordShutdownReason)872 CSR_API(SrvRecordShutdownReason)
873 {
874 DPRINT1("%s not yet implemented\n", __FUNCTION__);
875 return STATUS_NOT_IMPLEMENTED;
876 }
877
878 /* EOF */
879