dlls/schedsvc/svc_main.c

   1 /*
   2  * Task Scheduler Service
   3  *
   4  * Copyright 2014 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winsvc.h"
  26 #include "rpc.h"
  27 #include "atsvc.h"
  28 #include "schrpc.h"
  29 #include "wine/debug.h"
  30
  31 #include "schedsvc_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(schedsvc);
  34
  35 static const WCHAR scheduleW[] = {'S','c','h','e','d','u','l','e',0};
  36 static SERVICE_STATUS_HANDLE schedsvc_handle;
  37 static HANDLE done_event, hjob_queue;
  38
  39 void add_process_to_queue(HANDLE process)
  40 {
  41     if (!AssignProcessToJobObject(hjob_queue, process))
  42         ERR("AssignProcessToJobObject failed\n");
  43 }
  44
  45 static DWORD WINAPI tasks_monitor_thread(void *arg)
  46 {
  47     static const WCHAR tasksW[] = { '\\','T','a','s','k','s','\\',0 };
  48     WCHAR path[MAX_PATH];
  49     HANDLE htasks, hport, htimer;
  50     JOBOBJECT_ASSOCIATE_COMPLETION_PORT info;
  51     OVERLAPPED ov;
  52     LARGE_INTEGER period;
  53
  54     TRACE("Starting...\n");
  55
  56     load_at_tasks();
  57     check_missed_task_time();
  58
  59     htimer = CreateWaitableTimerW(NULL, FALSE, NULL);
  60     if (htimer == NULL)
  61     {
  62         ERR("CreateWaitableTimer failed\n");
  63         return -1;
  64     }
  65
  66     GetWindowsDirectoryW(path, MAX_PATH);
  67     lstrcatW(path, tasksW);
  68
  69     htasks = CreateFileW(path, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
  70                          NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
  71     if (htasks == INVALID_HANDLE_VALUE)
  72     {
  73         ERR("Couldn't start monitoring %s for tasks, error %u\n", debugstr_w(path), GetLastError());
  74         /* Probably this is an old prefix with disabled updates */
  75         if (GetLastError() == ERROR_PATH_NOT_FOUND || GetLastError() == ERROR_FILE_NOT_FOUND)
  76             ERR("Please create the directory manually\n");
  77         return -1;
  78     }
  79
  80     hjob_queue = CreateJobObjectW(NULL, NULL);
  81     if (!hjob_queue)
  82     {
  83         ERR("CreateJobObject failed\n");
  84         return -1;
  85     }
  86
  87     hport = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
  88     if (!hport)
  89     {
  90         ERR("CreateIoCompletionPort failed\n");
  91         return -1;
  92     }
  93
  94     info.CompletionKey = hjob_queue;
  95     info.CompletionPort = hport;
  96     if (!SetInformationJobObject(hjob_queue, JobObjectAssociateCompletionPortInformation, &info, sizeof(info)))
  97     {
  98         ERR("SetInformationJobObject failed\n");
  99         return -1;
 100     }
 101
 102     memset(&ov, 0, sizeof(ov));
 103     ov.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 104
 105     for (;;)
 106     {
 107         struct
 108         {
 109             FILE_NOTIFY_INFORMATION data;
 110             WCHAR name_buffer[MAX_PATH];
 111         } info;
 112         HANDLE events[4];
 113         DWORD ret;
 114
 115         /* the buffer must be DWORD aligned */
 116         C_ASSERT(!(sizeof(info) & 3));
 117
 118         memset(&info, 0, sizeof(info));
 119
 120         ret = ReadDirectoryChangesW(htasks, &info, sizeof(info), FALSE,
 121                                     FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE,
 122                                     NULL, &ov, NULL);
 123         if (!ret) break;
 124
 125         if (info.data.NextEntryOffset)
 126             FIXME("got multiple entries\n");
 127
 128         events[0] = done_event;
 129         events[1] = htimer;
 130         events[2] = hport;
 131         events[3] = ov.hEvent;
 132
 133         ret = WaitForMultipleObjects(4, events, FALSE, INFINITE);
 134         /* Done event */
 135         if (ret == WAIT_OBJECT_0) break;
 136
 137         /* Next runtime timer */
 138         if (ret == WAIT_OBJECT_0 + 1)
 139         {
 140             check_task_time();
 141             continue;
 142         }
 143
 144         /* Job queue */
 145         if (ret == WAIT_OBJECT_0 + 2)
 146         {
 147             DWORD msg;
 148             ULONG_PTR dummy, pid;
 149
 150             if (GetQueuedCompletionStatus(hport, &msg, &dummy, (OVERLAPPED **)&pid, 0))
 151             {
 152                 if (msg == JOB_OBJECT_MSG_EXIT_PROCESS)
 153                 {
 154                     TRACE("got message: process %#lx has terminated\n", pid);
 155                     update_process_status(pid);
 156                 }
 157                 else
 158                     FIXME("got message %#x from the job\n", msg);
 159             }
 160             continue;
 161         }
 162
 163         /* Directory change notification */
 164         info.data.FileName[info.data.FileNameLength/sizeof(WCHAR)] = 0;
 165
 166         switch (info.data.Action)
 167         {
 168         case FILE_ACTION_ADDED:
 169             TRACE("FILE_ACTION_ADDED %s\n", debugstr_w(info.data.FileName));
 170
 171             GetWindowsDirectoryW(path, MAX_PATH);
 172             lstrcatW(path, tasksW);
 173             lstrcatW(path, info.data.FileName);
 174             add_job(path);
 175             break;
 176
 177         case FILE_ACTION_REMOVED:
 178             TRACE("FILE_ACTION_REMOVED %s\n", debugstr_w(info.data.FileName));
 179             GetWindowsDirectoryW(path, MAX_PATH);
 180             lstrcatW(path, tasksW);
 181             lstrcatW(path, info.data.FileName);
 182             remove_job(path);
 183             break;
 184
 185         case FILE_ACTION_MODIFIED:
 186             TRACE("FILE_ACTION_MODIFIED %s\n", debugstr_w(info.data.FileName));
 187
 188             GetWindowsDirectoryW(path, MAX_PATH);
 189             lstrcatW(path, tasksW);
 190             lstrcatW(path, info.data.FileName);
 191             remove_job(path);
 192             add_job(path);
 193             break;
 194
 195         default:
 196             FIXME("%s: action %#x not handled\n", debugstr_w(info.data.FileName), info.data.Action);
 197             break;
 198         }
 199
 200         check_task_state();
 201
 202         if (get_next_runtime(&period))
 203         {
 204             if (!SetWaitableTimer(htimer, &period, 0, NULL, NULL, FALSE))
 205                 ERR("SetWaitableTimer failed\n");
 206         }
 207     }
 208
 209     CancelWaitableTimer(htimer);
 210     CloseHandle(htimer);
 211     CloseHandle(ov.hEvent);
 212     CloseHandle(hport);
 213     CloseHandle(hjob_queue);
 214     CloseHandle(htasks);
 215
 216     TRACE("Finished.\n");
 217
 218     return 0;
 219 }
 220
 221 void schedsvc_auto_start(void)
 222 {
 223     static DWORD start_type;
 224     SC_HANDLE scm, service;
 225     QUERY_SERVICE_CONFIGW *cfg;
 226     DWORD cfg_size;
 227
 228     if (start_type == SERVICE_AUTO_START) return;
 229
 230     TRACE("changing service start type to SERVICE_AUTO_START\n");
 231
 232     scm = OpenSCManagerW(NULL, NULL, 0);
 233     if (!scm)
 234     {
 235         WARN("failed to open SCM (%u)\n", GetLastError());
 236         return;
 237     }
 238
 239     service = OpenServiceW(scm, scheduleW, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG);
 240     if (service)
 241     {
 242         if (!QueryServiceConfigW(service, NULL, 0, &cfg_size) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 243         {
 244             cfg = HeapAlloc(GetProcessHeap(), 0, cfg_size);
 245             if (cfg)
 246             {
 247                 if (QueryServiceConfigW(service, cfg, cfg_size, &cfg_size))
 248                 {
 249                     start_type = cfg->dwStartType;
 250                     if (start_type != SERVICE_AUTO_START)
 251                     {
 252                         if (ChangeServiceConfigW(service, SERVICE_NO_CHANGE, SERVICE_AUTO_START, SERVICE_NO_CHANGE,
 253                                                  NULL, NULL, NULL, NULL, NULL, NULL, NULL))
 254                             start_type = SERVICE_AUTO_START;
 255                     }
 256                 }
 257                 HeapFree(GetProcessHeap(), 0, cfg);
 258             }
 259         }
 260         else
 261             WARN("failed to query service config (%u)\n", GetLastError());
 262
 263         CloseServiceHandle(service);
 264     }
 265     else
 266         WARN("failed to open service (%u)\n", GetLastError());
 267
 268     CloseServiceHandle(scm);
 269 }
 270
 271 static void schedsvc_update_status(DWORD state)
 272 {
 273     SERVICE_STATUS status;
 274
 275     status.dwServiceType = SERVICE_WIN32;
 276     status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
 277     status.dwWin32ExitCode = 0;
 278     status.dwServiceSpecificExitCode = 0;
 279     status.dwCheckPoint = 0;
 280     status.dwWaitHint = 0;
 281     status.dwControlsAccepted = 0;
 282     status.dwCurrentState = state;
 283
 284     SetServiceStatus(schedsvc_handle, &status);
 285 }
 286
 287 static void WINAPI schedsvc_handler(DWORD control)
 288 {
 289     TRACE("%#x\n", control);
 290
 291     switch (control)
 292     {
 293     case SERVICE_CONTROL_STOP:
 294     case SERVICE_CONTROL_SHUTDOWN:
 295         schedsvc_update_status(SERVICE_STOP_PENDING);
 296         SetEvent(done_event);
 297         break;
 298
 299     default:
 300         schedsvc_update_status(SERVICE_RUNNING);
 301         break;
 302     }
 303 }
 304
 305 static RPC_BINDING_VECTOR *sched_bindings;
 306
 307 static RPC_STATUS RPC_init(void)
 308 {
 309     static WCHAR ncacn_npW[] = { 'n','c','a','c','n','_','n','p',0 };
 310     static WCHAR endpoint_npW[] = { '\\','p','i','p','e','\\','a','t','s','v','c',0 };
 311     static WCHAR ncalrpcW[] = { 'n','c','a','l','r','p','c',0 };
 312     static WCHAR endpoint_lrpcW[] = { 'a','t','s','v','c',0 };
 313     RPC_STATUS status;
 314
 315     status = RpcServerRegisterIf(ITaskSchedulerService_v1_0_s_ifspec, NULL, NULL);
 316     if (status != RPC_S_OK)
 317     {
 318         ERR("RpcServerRegisterIf error %#x\n", status);
 319         return status;
 320     }
 321
 322     status = RpcServerRegisterIf(atsvc_v1_0_s_ifspec, NULL, NULL);
 323     if (status != RPC_S_OK)
 324     {
 325         ERR("RpcServerRegisterIf error %#x\n", status);
 326         RpcServerUnregisterIf(ITaskSchedulerService_v1_0_s_ifspec, NULL, FALSE);
 327         return status;
 328     }
 329
 330     status = RpcServerUseProtseqEpW(ncacn_npW, RPC_C_PROTSEQ_MAX_REQS_DEFAULT, endpoint_npW, NULL);
 331     if (status != RPC_S_OK)
 332     {
 333         ERR("RpcServerUseProtseqEp error %#x\n", status);
 334         return status;
 335     }
 336
 337     status = RpcServerUseProtseqEpW(ncalrpcW, RPC_C_PROTSEQ_MAX_REQS_DEFAULT, endpoint_lrpcW, NULL);
 338     if (status != RPC_S_OK)
 339     {
 340         ERR("RpcServerUseProtseqEp error %#x\n", status);
 341         return status;
 342     }
 343
 344     status = RpcServerInqBindings(&sched_bindings);
 345     if (status != RPC_S_OK)
 346     {
 347         ERR("RpcServerInqBindings error %#x\n", status);
 348         return status;
 349     }
 350
 351     status = RpcEpRegisterW(ITaskSchedulerService_v1_0_s_ifspec, sched_bindings, NULL, NULL);
 352     if (status != RPC_S_OK)
 353     {
 354         ERR("RpcEpRegister error %#x\n", status);
 355         return status;
 356     }
 357
 358     status = RpcEpRegisterW(atsvc_v1_0_s_ifspec, sched_bindings, NULL, NULL);
 359     if (status != RPC_S_OK)
 360     {
 361         ERR("RpcEpRegister error %#x\n", status);
 362         return status;
 363     }
 364
 365     status = RpcServerListen(1, RPC_C_LISTEN_MAX_CALLS_DEFAULT, TRUE);
 366     if (status != RPC_S_OK)
 367     {
 368         ERR("RpcServerListen error %#x\n", status);
 369         return status;
 370     }
 371     return RPC_S_OK;
 372 }
 373
 374 static void RPC_finish(void)
 375 {
 376     RpcMgmtStopServerListening(NULL);
 377     RpcEpUnregister(ITaskSchedulerService_v1_0_s_ifspec, sched_bindings, NULL);
 378     RpcEpUnregister(atsvc_v1_0_s_ifspec, sched_bindings, NULL);
 379     RpcBindingVectorFree(&sched_bindings);
 380     RpcServerUnregisterIf(ITaskSchedulerService_v1_0_s_ifspec, NULL, FALSE);
 381     RpcServerUnregisterIf(atsvc_v1_0_s_ifspec, NULL, FALSE);
 382 }
 383
 384 void WINAPI ServiceMain(DWORD argc, LPWSTR *argv)
 385 {
 386     HANDLE thread;
 387     DWORD tid;
 388
 389     TRACE("starting Task Scheduler Service\n");
 390
 391     schedsvc_handle = RegisterServiceCtrlHandlerW(scheduleW, schedsvc_handler);
 392     if (!schedsvc_handle)
 393     {
 394         ERR("RegisterServiceCtrlHandler error %d\n", GetLastError());
 395         return;
 396     }
 397
 398     schedsvc_update_status(SERVICE_START_PENDING);
 399
 400     done_event = CreateEventW(NULL, TRUE, FALSE, NULL);
 401     thread = CreateThread(NULL, 0, tasks_monitor_thread, NULL, 0, &tid);
 402
 403     if (thread && RPC_init() == RPC_S_OK)
 404     {
 405         schedsvc_update_status(SERVICE_RUNNING);
 406         WaitForSingleObject(thread, INFINITE);
 407         CloseHandle(thread);
 408         RPC_finish();
 409     }
 410
 411     schedsvc_update_status(SERVICE_STOPPED);
 412
 413     TRACE("exiting Task Scheduler Service\n");
 414 }
 415
 416 void  __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
 417 {
 418     return heap_alloc(len);
 419 }
 420
 421 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
 422 {
 423     heap_free(ptr);
 424 }