1232 lines
34 KiB
C++
1232 lines
34 KiB
C++
//+----------------------------------------------------------------------------
|
|
//
|
|
// Job Scheduler Service
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996.
|
|
//
|
|
// File: sch_main.cxx
|
|
//
|
|
// Contents: job scheduler NT service entry point and thread launcher
|
|
//
|
|
// History: 08-Sep-95 EricB created
|
|
// 03-Mar-01 JBenton - BUG 207402 RESUMESUSPEND and RESUMEAUTOMATIC
|
|
// events arrive out of the expected sequence on some hardware.
|
|
// This caused the internal POWER_RESUME event to be sent twice
|
|
// which sometimes (20%) prevented the scheduled job that
|
|
// triggered the wake-up from running.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "..\..\pch\headers.hxx"
|
|
#pragma hdrstop
|
|
#include <svc_core.hxx>
|
|
#include "..\..\inc\sadat.hxx"
|
|
#include "..\..\inc\resource.h"
|
|
#include "..\..\idletask\inc\idlesrv.h"
|
|
|
|
DECLARE_INFOLEVEL(Sched);
|
|
|
|
// globals
|
|
SERVICE_STATUS_HANDLE g_hStatus = NULL;
|
|
SERVICE_STATUS g_SvcStatus; // BUGBUG guard with critsec, put in class
|
|
ATOM g_aClass = 0;
|
|
HANDLE g_hWindowThread = NULL;
|
|
HWND g_hwndSchedSvc = NULL;
|
|
LONG g_fUserIsLoggedOn = FALSE; // Whether a user is currently logged on
|
|
HANDLE g_WndEvent = NULL;
|
|
UINT g_uTaskbarMessage = 0;
|
|
BOOL g_fShuttingDown;
|
|
|
|
// the following allows the service to be run from the command line as a
|
|
// console app.
|
|
BOOL g_fVisible = FALSE;
|
|
BOOL ConsoleHandler(DWORD dwControl);
|
|
|
|
// local prototypes
|
|
void SchedStart(DWORD, LPWSTR *);
|
|
BOOL RunningAsLocalSystem(VOID);
|
|
HRESULT WindowMsgFcn(LPVOID pVoid);
|
|
LRESULT CALLBACK SchedWndProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
// routine to run on the prefetcher service thread.
|
|
|
|
extern "C" DWORD WINAPI PfSvcMainThread(VOID *Param);
|
|
|
|
#define IDM_EXIT 100
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: main
|
|
//
|
|
// Synopsis: entry point
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void _cdecl
|
|
main(int argc, char ** argv)
|
|
{
|
|
DBG_OUT("Schedule svc starting...");
|
|
|
|
if (argc > 1)
|
|
{
|
|
if (argv[1][0] == '/' || argv[1][0] == '-')
|
|
{
|
|
if (argv[1][1] == '?' || argv[1][1] == 'h' || argv[1][1] == 'H')
|
|
{
|
|
SchError(IDS_NOT_FROM_CMD_LINE);
|
|
#if DBG == 1
|
|
printf("\nJob Scheduler service: "
|
|
"use the /d switch to run from the command line\n");
|
|
#endif
|
|
return;
|
|
}
|
|
#if DBG == 1
|
|
else
|
|
{
|
|
if (argv[1][1] == 'd')
|
|
{
|
|
// debug switch, run from the command line
|
|
g_fVisible = TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//
|
|
// Open the schedule service log file.
|
|
//
|
|
if (FAILED(OpenLogFile()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
LogServiceEvent(IDS_LOG_SERVICE_STARTED);
|
|
|
|
if (!g_fVisible)
|
|
{
|
|
SERVICE_TABLE_ENTRY ScheduleServiceDispatchTable[] = {
|
|
{g_tszSrvcName, SchedStart},
|
|
{NULL, NULL}};
|
|
|
|
if (!StartServiceCtrlDispatcher(ScheduleServiceDispatchTable))
|
|
{
|
|
LogServiceError(IDS_FATAL_ERROR, GetLastError(), 0);
|
|
ERR_OUT("StartServiceCtrlDispatcher", GetLastError());
|
|
SchError(IDS_NOT_FROM_CMD_LINE);
|
|
LogServiceEvent(IDS_LOG_SERVICE_EXITED);
|
|
CloseLogFile();
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SchedStart(0, NULL);
|
|
}
|
|
|
|
LogServiceEvent(IDS_LOG_SERVICE_EXITED);
|
|
|
|
//
|
|
// Close the schedule service log.
|
|
//
|
|
CloseLogFile();
|
|
|
|
DBG_OUT("Schedule svc exiting.\n");
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SchedServiceMain
|
|
//
|
|
// Synopsis: Entry point when running in an SvcHost.exe instance.
|
|
//
|
|
// Arguments: [CArgs] - count of arg strings
|
|
// [ppwszArgs] - array of arg strings
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
VOID
|
|
WINAPI
|
|
SchedServiceMain(DWORD cArgs, LPWSTR * ppwszArgs)
|
|
{
|
|
|
|
//
|
|
// We need to initialize g_hInstance here for OpenLogFile
|
|
// to work.
|
|
//
|
|
|
|
g_hInstance = GetModuleHandle(SCH_SERVICE_DLL_NAME);
|
|
|
|
//
|
|
// Open the schedule service log file.
|
|
//
|
|
if (FAILED(OpenLogFile()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
LogServiceEvent(IDS_LOG_SERVICE_STARTED);
|
|
|
|
SchedStart(cArgs, ppwszArgs);
|
|
|
|
LogServiceEvent(IDS_LOG_SERVICE_EXITED);
|
|
|
|
//
|
|
// Close the schedule service log.
|
|
//
|
|
CloseLogFile();
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SchedStart
|
|
//
|
|
// Synopsis: Primary thread of the NT service
|
|
//
|
|
// Arguments: [CArgs] - count of arg strings
|
|
// [ppwszArgs] - array of arg strings
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
SchedStart(DWORD cArgs, LPWSTR * ppwszArgs)
|
|
{
|
|
HANDLE hPfSvcThread;
|
|
HANDLE hPfSvcStopEvent;
|
|
DWORD ErrorCode;
|
|
BOOLEAN StartedIdleDetectionServer;
|
|
|
|
HRESULT hr;
|
|
|
|
//
|
|
// initialize locals so we know what to cleanup.
|
|
//
|
|
|
|
hPfSvcStopEvent = NULL;
|
|
hPfSvcThread = NULL;
|
|
StartedIdleDetectionServer = FALSE;
|
|
|
|
//
|
|
// Initialize some globals.
|
|
//
|
|
|
|
if (!g_hInstance) {
|
|
g_hInstance = GetModuleHandle(NULL);
|
|
}
|
|
|
|
g_fShuttingDown = FALSE;
|
|
g_hStatus = NULL;
|
|
g_hWindowThread = NULL;
|
|
g_hwndSchedSvc = NULL;
|
|
g_fUserIsLoggedOn = FALSE;
|
|
g_WndEvent = NULL;
|
|
|
|
g_SvcStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
|
|
g_SvcStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
|
|
SERVICE_ACCEPT_PAUSE_CONTINUE |
|
|
SERVICE_ACCEPT_SHUTDOWN |
|
|
SERVICE_ACCEPT_POWEREVENT;
|
|
|
|
g_SvcStatus.dwWaitHint = SCH_WAIT_HINT;
|
|
g_SvcStatus.dwCheckPoint = 1;
|
|
g_SvcStatus.dwWin32ExitCode = NO_ERROR;
|
|
g_SvcStatus.dwServiceSpecificExitCode = 0;
|
|
g_SvcStatus.dwCurrentState = SERVICE_START_PENDING;
|
|
|
|
//
|
|
// Register the control handler.
|
|
//
|
|
if (g_fVisible)
|
|
{ // running in a console window
|
|
SetConsoleCtrlHandler(ConsoleHandler, TRUE);
|
|
}
|
|
else
|
|
{
|
|
g_hStatus = RegisterServiceCtrlHandlerEx(g_tszSrvcName,
|
|
SchSvcHandler,
|
|
NULL);
|
|
|
|
if (g_hStatus == NULL)
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, GetLastError(), 0);
|
|
ERR_OUT("RegisterServiceCtrlHandler", GetLastError());
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Let the service controller know we're making progress.
|
|
//
|
|
UpdateStatus();
|
|
|
|
//
|
|
// Make sure the service is running as LocalSystem
|
|
//
|
|
if (!RunningAsLocalSystem())
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE,
|
|
HRESULT_FROM_WIN32(SCHED_E_SERVICE_NOT_LOCALSYSTEM),
|
|
0);
|
|
|
|
SchStop(HRESULT_FROM_WIN32(SCHED_E_SERVICE_NOT_LOCALSYSTEM), FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Initialize the service.
|
|
//
|
|
hr = SchInit();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr, FALSE);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Let the service controller know we're making progress.
|
|
//
|
|
StartupProgressing();
|
|
|
|
//
|
|
// Get the ID of the logged on user, if there is one.
|
|
//
|
|
GetLoggedOnUser();
|
|
|
|
//
|
|
// Let the service controller know we're making progress.
|
|
//
|
|
StartupProgressing();
|
|
|
|
//
|
|
// Initialize NetSchedule API support code.
|
|
//
|
|
hr = InitializeNetScheduleApi();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Let the service controller know we're making progress.
|
|
//
|
|
StartupProgressing();
|
|
|
|
//
|
|
// Start the RPC server.
|
|
//
|
|
hr = StartRpcServer();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Let the service controller know we're making progress.
|
|
//
|
|
StartupProgressing();
|
|
|
|
//
|
|
// Create the window thread event.
|
|
//
|
|
g_WndEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
|
|
if (g_WndEvent == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
ERR_OUT("CreateEvent", hr);
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Create the window thread.
|
|
//
|
|
DWORD dwThreadID;
|
|
g_hWindowThread = CreateThread(NULL,
|
|
0,
|
|
(LPTHREAD_START_ROUTINE)WindowMsgFcn,
|
|
NULL,
|
|
0,
|
|
&dwThreadID);
|
|
if (!g_hWindowThread)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
ERR_OUT("Creation of Window Thread", hr);
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr);
|
|
|
|
CloseHandle( g_WndEvent );
|
|
g_WndEvent = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Initialize idle detection server. This must be done after we
|
|
// start the other RPC servers that register a dynamic ncalrpc
|
|
// endpoint.
|
|
//
|
|
|
|
ErrorCode = ItSrvInitialize();
|
|
|
|
hr = HRESULT_FROM_WIN32(ErrorCode);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
SchStop(hr);
|
|
return;
|
|
}
|
|
|
|
StartedIdleDetectionServer = TRUE;
|
|
|
|
|
|
//
|
|
// Initialize the event it is going to wait on and kick off the
|
|
// prefetcher maintenance thread.
|
|
//
|
|
|
|
hPfSvcStopEvent = CreateEvent(NULL, // no security attributes
|
|
TRUE, // manual reset event
|
|
FALSE, // not-signalled
|
|
NULL); // no name
|
|
|
|
if (hPfSvcStopEvent) {
|
|
hPfSvcThread = CreateThread(0,0,PfSvcMainThread,&hPfSvcStopEvent,0,0);
|
|
}
|
|
|
|
//
|
|
// We're off and running.
|
|
//
|
|
g_SvcStatus.dwCurrentState = SERVICE_RUNNING;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
UpdateStatus();
|
|
|
|
hr = g_pSched->InitialDirScan();
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// Update the service flag in SA.DAT to running.
|
|
// Also redetermine whether the machine supports wakeup timers. We do
|
|
// this every time the service starts in order to work around problems
|
|
// with IBM Thinkpads and VPOWERD on Windows 98. (BUGBUG Do we need
|
|
// to do this on NT as well?)
|
|
//
|
|
// Note, this function should not fail. If it does, something is
|
|
// seriously wrong with the system.
|
|
//
|
|
|
|
hr = SADatCreate(g_TasksFolderInfo.ptszPath);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
goto Exit;
|
|
}
|
|
|
|
//
|
|
// Call the main function.
|
|
//
|
|
|
|
hr = SchedMain(NULL);
|
|
|
|
//
|
|
// Exit.
|
|
//
|
|
|
|
Exit:
|
|
|
|
//
|
|
// If one exists, signal prefetcher thread's stop event and wait
|
|
// for it to terminate.
|
|
//
|
|
|
|
if (hPfSvcStopEvent && hPfSvcThread) {
|
|
SetEvent(hPfSvcStopEvent);
|
|
WaitForSingleObject(hPfSvcThread, INFINITE);
|
|
}
|
|
|
|
if (hPfSvcStopEvent) {
|
|
CloseHandle(hPfSvcStopEvent);
|
|
}
|
|
|
|
if (hPfSvcThread) {
|
|
CloseHandle(hPfSvcThread);
|
|
}
|
|
|
|
HANDLE rghWaitArray[2] = { g_WndEvent, g_hWindowThread };
|
|
|
|
DBG_OUT("Service exit -- waiting for window thread to finish starting.");
|
|
|
|
if (WaitForMultipleObjects(2, rghWaitArray, FALSE, INFINITE) == WAIT_OBJECT_0)
|
|
{
|
|
//
|
|
// g_WndEvent was signalled -- we can now send a message
|
|
// to the window thread to tell it to shut down
|
|
//
|
|
g_fShuttingDown = TRUE;
|
|
SendMessage(g_hwndSchedSvc, WM_COMMAND, IDM_EXIT, 0);
|
|
|
|
//
|
|
// Wait for window thread to exit before exitting the main thread.
|
|
// This is to ensure that the task bar icon is removed. The wait is
|
|
// probably not needed since the SendMessage exit processing looks
|
|
// like it is completely syncronous.
|
|
//
|
|
|
|
DBG_OUT("Waiting for window thread to exit.");
|
|
WaitForSingleObject(g_hWindowThread, INFINITE);
|
|
DBG_OUT("Window thread exited.");
|
|
}
|
|
else
|
|
{
|
|
DBG_OUT("Window thread exited prematurely -- shutting down.");
|
|
}
|
|
|
|
//
|
|
// Stop idle detection server.
|
|
//
|
|
|
|
if (StartedIdleDetectionServer) {
|
|
ItSrvUninitialize();
|
|
}
|
|
|
|
//
|
|
// Cleanup some globals.
|
|
//
|
|
|
|
if (g_fUserIsLoggedOn) {
|
|
LogonSessionDataCleanup();
|
|
g_fUserIsLoggedOn = FALSE;
|
|
}
|
|
|
|
if (g_hWindowThread) {
|
|
CloseHandle(g_hWindowThread);
|
|
g_hWindowThread = NULL;
|
|
}
|
|
|
|
if (g_WndEvent) {
|
|
CloseHandle(g_WndEvent);
|
|
g_WndEvent = NULL;
|
|
}
|
|
|
|
SchStop(hr);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: RunningAsLocalSystem
|
|
//
|
|
// Synopsis: Detects whether the service was started in the System account.
|
|
//
|
|
// Arguments: None
|
|
//
|
|
// Returns: TRUE if the service is running as LocalSystem
|
|
// FALSE if it is not or if any errors were encountered
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
RunningAsLocalSystem(VOID)
|
|
{
|
|
SID LocalSystemSid = { SID_REVISION,
|
|
1,
|
|
SECURITY_NT_AUTHORITY,
|
|
SECURITY_LOCAL_SYSTEM_RID };
|
|
|
|
BOOL fCheckSucceeded;
|
|
BOOL fIsLocalSystem = FALSE;
|
|
|
|
fCheckSucceeded = CheckTokenMembership(NULL,
|
|
&LocalSystemSid,
|
|
&fIsLocalSystem);
|
|
|
|
if (!fCheckSucceeded)
|
|
{
|
|
ERR_OUT("CheckTokenMembership", GetLastError());
|
|
}
|
|
|
|
return (fCheckSucceeded && fIsLocalSystem);
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: WindowMsgFcn
|
|
//
|
|
// Synopsis: Window message loop thread of the service.
|
|
//
|
|
// Arguments: [pVoid] - currently not used
|
|
//
|
|
// Returns: HRESULTS - the service is not currently detecting if this
|
|
// thread exits prematurely. Thus, the exit code is ignored.
|
|
// Monitoring the thread handle in SchedMain would give more
|
|
// thorough error detection.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT
|
|
WindowMsgFcn(LPVOID pVoid)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Find out the ID of the message that the tray will send us when it
|
|
// starts.
|
|
//
|
|
g_uTaskbarMessage = RegisterWindowMessage(TEXT("TaskbarCreated"));
|
|
|
|
//
|
|
// Register the window class
|
|
//
|
|
WNDCLASS wc;
|
|
|
|
wc.style = CS_HREDRAW | CS_VREDRAW;
|
|
wc.lpfnWndProc = SchedWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = g_hInstance;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = SCHED_CLASS;
|
|
|
|
g_aClass = RegisterClass(&wc);
|
|
if (!g_aClass)
|
|
{
|
|
ULONG ulLastError = GetLastError();
|
|
|
|
LogServiceError(IDS_NON_FATAL_ERROR, ulLastError, 0);
|
|
ERR_OUT("RegisterClass", ulLastError);
|
|
return HRESULT_FROM_WIN32(ulLastError);
|
|
}
|
|
|
|
//
|
|
// Now create the hidden window on the interactive desktop.
|
|
//
|
|
g_hwndSchedSvc = CreateWindow(SCHED_CLASS, SCHED_TITLE, WS_OVERLAPPEDWINDOW,
|
|
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
|
|
CW_USEDEFAULT, (HWND)NULL, (HMENU)NULL,
|
|
g_hInstance, (LPVOID)NULL);
|
|
if (!g_hwndSchedSvc)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
ERR_OUT("CreateWindow", hr);
|
|
return hr;
|
|
}
|
|
|
|
ShowWindow(g_hwndSchedSvc, SW_HIDE);
|
|
UpdateWindow(g_hwndSchedSvc);
|
|
|
|
//
|
|
// Initialize this thread's keep-awake count.
|
|
//
|
|
|
|
InitThreadWakeCount();
|
|
|
|
//
|
|
// Initialize idle detection. This must be done by the window thread
|
|
// (not the state machine thread).
|
|
//
|
|
InitIdleDetection();
|
|
|
|
//
|
|
// Notify the main thread that the window creation is complete.
|
|
//
|
|
if (!SetEvent(g_WndEvent))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
LogServiceError(IDS_INITIALIZATION_FAILURE, (DWORD)hr, 0);
|
|
ERR_OUT("SetEvent(g_WndEvent)", hr);
|
|
return hr;
|
|
}
|
|
|
|
MSG msg;
|
|
while (GetMessage(&msg, (HWND) NULL, 0, 0))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
if (g_aClass != 0)
|
|
{
|
|
DeleteAtom(g_aClass);
|
|
g_aClass = 0;
|
|
|
|
UnregisterClass(SCHED_CLASS, g_hInstance);
|
|
}
|
|
|
|
DBG_OUT("Window exited.");
|
|
return S_OK;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SchedWndProc
|
|
//
|
|
// Synopsis: handle messages
|
|
//
|
|
// Returns: occasionally
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
LRESULT CALLBACK
|
|
SchedWndProc(HWND hwndSched, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT lResult = 0;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_CREATE:
|
|
case WM_SETTEXT:
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDM_EXIT:
|
|
|
|
//
|
|
// Only exit if this message was sent by the
|
|
// Task Scheduler's shutdown code (vs. a user)
|
|
//
|
|
if (g_fShuttingDown)
|
|
{
|
|
DestroyWindow(hwndSched);
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_TIMECHANGE:
|
|
DBG_OUT("WM_TIMECHANGE received");
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_TIME_CHANGED);
|
|
break;
|
|
|
|
case WM_SCHED_SetNextIdleNotification:
|
|
return SetNextIdleNotificationFn((WORD)wParam);
|
|
|
|
case WM_SCHED_SetIdleLossNotification:
|
|
return SetIdleLossNotificationFn();
|
|
|
|
case WM_DESTROY:
|
|
DBG_OUT("Got WM_DESTROY.");
|
|
|
|
//
|
|
// Only exit if this message was sent by the
|
|
// Task Scheduler's shutdown code (vs. a user)
|
|
//
|
|
if (g_fShuttingDown)
|
|
{
|
|
EndIdleDetection();
|
|
PostQuitMessage(0);
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
case WM_QUIT:
|
|
|
|
//
|
|
// If the Task Scheduler isn't shutting down, these
|
|
// are malicious messages, so ignore them. If the
|
|
// Task Scheduler is shutting down, fall through and
|
|
// let DefWindowProc handle these
|
|
//
|
|
if (!g_fShuttingDown)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Fall through
|
|
|
|
default:
|
|
if (uMsg == g_uTaskbarMessage)
|
|
{
|
|
schDebugOut((DEB_ITRACE,
|
|
"Got Taskbar message, calling SchSvcHandler.\n"));
|
|
SchSvcHandler(SERVICE_CONTROL_USER_LOGON, 0, NULL, NULL);
|
|
// CODEWORK: Is a non-zero return code expected from the wndproc?
|
|
}
|
|
else
|
|
{
|
|
return DefWindowProc(hwndSched, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
return lResult;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SchSvcHandler
|
|
//
|
|
// Synopsis: handles service controller callback notifications
|
|
//
|
|
// Arguments: [dwControl] - the control code
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
DWORD WINAPI
|
|
SchSvcHandler(
|
|
DWORD dwControl,
|
|
DWORD dwEventType,
|
|
LPVOID lpEventData,
|
|
LPVOID lpContext
|
|
)
|
|
{
|
|
static BOOL fResumeHandled; // initially FALSE
|
|
|
|
switch (dwControl)
|
|
{
|
|
case SERVICE_CONTROL_PAUSE:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_PAUSE");
|
|
if (g_SvcStatus.dwCurrentState == SERVICE_RUNNING ||
|
|
g_SvcStatus.dwCurrentState == SERVICE_CONTINUE_PENDING)
|
|
{
|
|
g_SvcStatus.dwCurrentState = SERVICE_PAUSE_PENDING;
|
|
g_SvcStatus.dwWaitHint = 0;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
|
|
g_pSched->SubmitControl(0);
|
|
LogServiceEvent(IDS_LOG_SERVICE_PAUSED);
|
|
}
|
|
else
|
|
{
|
|
ERR_OUT("Trying to pause when service not running!", 0);
|
|
}
|
|
break;
|
|
|
|
case SERVICE_CONTROL_CONTINUE:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_CONTINUE");
|
|
if (g_SvcStatus.dwCurrentState == SERVICE_PAUSED ||
|
|
g_SvcStatus.dwCurrentState == SERVICE_PAUSE_PENDING)
|
|
{
|
|
g_SvcStatus.dwCurrentState = SERVICE_CONTINUE_PENDING;
|
|
g_SvcStatus.dwWaitHint = 0;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
|
|
g_pSched->SubmitControl(0);
|
|
LogServiceEvent(IDS_LOG_SERVICE_CONTINUED);
|
|
}
|
|
else
|
|
{
|
|
ERR_OUT("Trying to continue when service not paused!", 0);
|
|
}
|
|
break;
|
|
|
|
case SERVICE_CONTROL_SHUTDOWN:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_SHUTDOWN");
|
|
case SERVICE_CONTROL_STOP:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_STOP");
|
|
g_SvcStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
|
g_SvcStatus.dwWaitHint = SCH_WAIT_HINT;
|
|
g_SvcStatus.dwCheckPoint = 1;
|
|
|
|
UpdateStatus();
|
|
|
|
g_pSched->SubmitControl(0);
|
|
break;
|
|
|
|
case SERVICE_CONTROL_USER_LOGON:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_USER_LOGON");
|
|
//
|
|
// (This could be called by the window-handling thread.)
|
|
// The tray (or mstinit /logon) has notified us that it's started.
|
|
// This usually happens because a user has logged on, but it also
|
|
// happens when the tray crashes and restarts. We must ignore the
|
|
// notification in the latter case.
|
|
//
|
|
if (InterlockedExchange(&g_fUserIsLoggedOn, TRUE))
|
|
{
|
|
//
|
|
// It wasn't really a user logon. Ignore the control.
|
|
//
|
|
DBG_OUT("SchSvcHandler: User is already logged on");
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Signal the main thread loop to run logon jobs.
|
|
//
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_USER_LOGON);
|
|
break;
|
|
|
|
case SERVICE_CONTROL_USER_LOGOFF:
|
|
|
|
schDebugOut((DEB_ITRACE, "User logging off *******************\n"));
|
|
|
|
//
|
|
// Dealloc & set to NULL the global data associated with the
|
|
// user's logon session.
|
|
//
|
|
|
|
LogonSessionDataCleanup();
|
|
|
|
g_fUserIsLoggedOn = FALSE;
|
|
|
|
break;
|
|
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
DBG_OUT("SchSvcHandler: SERVICE_CONTROL_INTERROGATE");
|
|
//
|
|
// The interrogate is satisfied by the UpdateStatus call below.
|
|
//
|
|
break;
|
|
|
|
case SERVICE_CONTROL_POWEREVENT:
|
|
switch (dwEventType)
|
|
{
|
|
case PBT_APMPOWERSTATUSCHANGE:
|
|
SYSTEM_POWER_STATUS PwrStatus;
|
|
if (!GetSystemPowerStatus(&PwrStatus))
|
|
{
|
|
LogServiceError(IDS_NON_FATAL_ERROR, GetLastError(), 0);
|
|
ERR_OUT("GetSystemPowerStatus", GetLastError());
|
|
break;
|
|
}
|
|
if (PwrStatus.ACLineStatus == 0)
|
|
{
|
|
//
|
|
// On battery.
|
|
//
|
|
OnPowerChange(TRUE);
|
|
}
|
|
else
|
|
{
|
|
if (PwrStatus.ACLineStatus == 1)
|
|
{
|
|
//
|
|
// On AC power.
|
|
//
|
|
OnPowerChange(FALSE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PBT_APMQUERYSUSPEND:
|
|
//
|
|
// The computer is preparing for suspended mode.
|
|
// Signal the other thread to stop running jobs.
|
|
//
|
|
DBG_OUT("PBT_APMQUERYSUSPEND received");
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_POWER_SUSPEND);
|
|
break;
|
|
|
|
case PBT_APMQUERYSUSPENDFAILED:
|
|
//
|
|
// Aborted going into suspended mode.
|
|
// Signal the other thread to run the elapsed jobs.
|
|
//
|
|
DBG_OUT("PBT_APMQUERYSUSPENDFAILED received");
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_POWER_SUSPEND_FAILED);
|
|
break;
|
|
|
|
case PBT_APMSUSPEND:
|
|
//
|
|
// The computer is going into the suspended mode.
|
|
// We already prepared for it when we got QUERYSUSPEND.
|
|
// BUGBUG We should wait here for the other thread to finish.
|
|
//
|
|
DBG_OUT("PBT_APMSUSPEND received, ignoring (already handled)");
|
|
fResumeHandled = FALSE;
|
|
break;
|
|
|
|
|
|
//
|
|
// PBT_APMRESUMExxx messages:
|
|
// The computer is coming back from suspended mode.
|
|
// Signal the other thread to run the appropriate jobs.
|
|
//
|
|
|
|
case PBT_APMRESUMESUSPEND:
|
|
DBG_OUT("PBT_APMRESUMESUSPEND received");
|
|
if (fResumeHandled)
|
|
{
|
|
DBG_OUT("IGNORING resumesuspend (sent after resumeautomatic)");
|
|
}
|
|
else
|
|
{
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_POWER_RESUME);
|
|
//
|
|
// On some systems we see the RESUMESUSPEND message before
|
|
// the RESUMEAUTOMATIC message. We don't want to signal the
|
|
// main loop twice. So set a flag telling us to ignore
|
|
// RESUMEAUTOMATIC messages until a SUSPEND message is sent.
|
|
//
|
|
fResumeHandled = TRUE;
|
|
}
|
|
break;
|
|
|
|
case PBT_APMRESUMECRITICAL:
|
|
DBG_OUT("PBT_APMRESUMECRITICAL received");
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_POWER_RESUME);
|
|
break;
|
|
|
|
case PBT_APMRESUMEAUTOMATIC:
|
|
DBG_OUT("PBT_APMRESUMEAUTOMATIC received");
|
|
|
|
if (fResumeHandled)
|
|
{
|
|
DBG_OUT("IGNORING resumeautomatic (sent after resumeresume)");
|
|
}
|
|
else
|
|
{
|
|
g_pSched->SubmitControl(SERVICE_CONTROL_POWER_RESUME);
|
|
//
|
|
// After this RESUMEAUTOMATIC message, the system may also
|
|
// send a RESUMESUSPEND message (if it detects user activity).
|
|
// We don't want to signal the main loop twice. So set a flag
|
|
// telling us to ignore RESUMESUSPEND messages until a SUSPEND
|
|
// message is sent.
|
|
//
|
|
fResumeHandled = TRUE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ERR_OUT("Unrecognized service control code", dwControl);
|
|
return ERROR_CALL_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
UpdateStatus();
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: CSchedWorker::HandleControl
|
|
//
|
|
// Synopsis: Handle NT service controller state changes.
|
|
//
|
|
// Returns: the control or the current/new state
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
DWORD
|
|
CSchedWorker::HandleControl()
|
|
{
|
|
TRACE(CSchedWorker,HandleControl);
|
|
|
|
DWORD dwControl = m_ControlQueue.GetEntry();
|
|
|
|
switch (dwControl)
|
|
{
|
|
case SERVICE_CONTROL_USER_LOGON:
|
|
schDebugOut((DEB_ITRACE, " Event is USER_LOGON\n"));
|
|
break;
|
|
|
|
case SERVICE_CONTROL_POWER_SUSPEND:
|
|
schDebugOut((DEB_ITRACE, " Event is POWER_SUSPEND\n"));
|
|
break;
|
|
|
|
case SERVICE_CONTROL_POWER_SUSPEND_FAILED:
|
|
schDebugOut((DEB_ITRACE, " Event is POWER_SUSPEND_FAILED\n"));
|
|
break;
|
|
|
|
case SERVICE_CONTROL_POWER_RESUME:
|
|
schDebugOut((DEB_ITRACE, " Event is POWER_RESUME\n"));
|
|
break;
|
|
|
|
case SERVICE_CONTROL_TIME_CHANGED:
|
|
schDebugOut((DEB_ITRACE, " Event is TIME_CHANGED\n"));
|
|
break;
|
|
|
|
case 0:
|
|
schDebugOut((DEB_ITRACE, " Service Control is state %#lx\n",
|
|
g_SvcStatus.dwCurrentState));
|
|
|
|
switch (g_SvcStatus.dwCurrentState)
|
|
{
|
|
case SERVICE_STOP_PENDING:
|
|
schDebugOut((DEB_ITRACE,
|
|
" WaitForMultipleObjects signaled for exit\n"));
|
|
break;
|
|
|
|
case SERVICE_PAUSE_PENDING:
|
|
schDebugOut((DEB_ITRACE,
|
|
" WaitForMultipleObjects signaled for pausing\n"));
|
|
g_SvcStatus.dwCurrentState = SERVICE_PAUSED;
|
|
g_SvcStatus.dwWaitHint = 0;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
UpdateStatus();
|
|
break;
|
|
|
|
case SERVICE_CONTINUE_PENDING:
|
|
schDebugOut((DEB_ITRACE,
|
|
" WaitForMultipleObjects signaled for continuing\n"));
|
|
g_SvcStatus.dwCurrentState = SERVICE_RUNNING;
|
|
g_SvcStatus.dwWaitHint = 0;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
UpdateStatus();
|
|
break;
|
|
}
|
|
return g_SvcStatus.dwCurrentState;
|
|
|
|
default:
|
|
schDebugOut((DEB_ITRACE, " ??? UNKNOWN CONTROL %#lx\n", dwControl));
|
|
break;
|
|
}
|
|
|
|
return dwControl;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: GetCurrentServiceState
|
|
//
|
|
// Returns: The schedule service's current state.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
DWORD
|
|
GetCurrentServiceState(void)
|
|
{
|
|
return g_SvcStatus.dwCurrentState;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: UpdateStatus
|
|
//
|
|
// Synopsis: Tell the service controller what the current status is.
|
|
//
|
|
// Returns: Win32 error values
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
DWORD
|
|
UpdateStatus(void)
|
|
{
|
|
if (g_fVisible)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
TRACE_FUNCTION(UpdateStatus);
|
|
|
|
DWORD dwRet = NO_ERROR;
|
|
|
|
if (g_hStatus == NULL)
|
|
{
|
|
ERR_OUT("UpdateStatus called with a null status handle!", 0);
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
if (!SetServiceStatus(g_hStatus, &g_SvcStatus))
|
|
{
|
|
dwRet = GetLastError();
|
|
LogServiceError(IDS_NON_FATAL_ERROR, dwRet, 0);
|
|
ERR_OUT("SetServiceStatus", dwRet);
|
|
}
|
|
return dwRet;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: SchStop
|
|
//
|
|
// Synopsis: Shuts down the schedule service
|
|
//
|
|
// Arguments: [hr] - an error code if terminating abnormally
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
SchStop(HRESULT hr, BOOL fCoreCleanup)
|
|
{
|
|
//
|
|
// Update the service flag in SA.DAT to not running.
|
|
// Check the folder path for NULL in case initialization failed.
|
|
//
|
|
|
|
if (g_TasksFolderInfo.ptszPath != NULL)
|
|
{
|
|
UpdateSADatServiceFlags(g_TasksFolderInfo.ptszPath,
|
|
SA_DAT_SVCFLAG_SVC_RUNNING,
|
|
TRUE);
|
|
}
|
|
|
|
g_SvcStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
|
g_SvcStatus.dwCheckPoint++;
|
|
|
|
UpdateStatus();
|
|
|
|
//
|
|
// do core cleanup
|
|
//
|
|
|
|
if (fCoreCleanup)
|
|
{
|
|
SchCleanup();
|
|
}
|
|
|
|
//
|
|
// tell service controller that we are done cleaning up
|
|
//
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
|
|
{
|
|
g_SvcStatus.dwWin32ExitCode = HRESULT_CODE(hr);
|
|
}
|
|
else
|
|
{
|
|
g_SvcStatus.dwWin32ExitCode = hr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_SvcStatus.dwWin32ExitCode = NO_ERROR;
|
|
}
|
|
|
|
g_SvcStatus.dwServiceSpecificExitCode = 0;
|
|
g_SvcStatus.dwCurrentState = SERVICE_STOPPED;
|
|
g_SvcStatus.dwControlsAccepted = 0;
|
|
g_SvcStatus.dwWaitHint = 0;
|
|
g_SvcStatus.dwCheckPoint = 0;
|
|
|
|
UpdateStatus();
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: ConsoleHandler
|
|
//
|
|
// Synopsis: handles system signals when run as a console app
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
ConsoleHandler(DWORD dwControl)
|
|
{
|
|
TRACE_FUNCTION(ConsoleHandler);
|
|
g_SvcStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
|
g_pSched->SubmitControl(0);
|
|
return TRUE;
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: StartupProgressing
|
|
//
|
|
// Synopsis: Notifies the service controller that startup is still
|
|
// progressing normally.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
void
|
|
StartupProgressing(void)
|
|
{
|
|
g_SvcStatus.dwCheckPoint++;
|
|
UpdateStatus();
|
|
}
|