dlls/mstask/task.c

   1 /*
   2  * Copyright (C) 2008 Google (Roy Shea)
   3  * Copyright (C) 2018 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27 #include "taskschd.h"
  28 #include "mstask.h"
  29 #include "mstask_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mstask);
  33
  34 typedef struct
  35 {
  36     ITask ITask_iface;
  37     IPersistFile IPersistFile_iface;
  38     LONG ref;
  39     ITaskDefinition *task;
  40     IExecAction *action;
  41     LPWSTR task_name;
  42     HRESULT status;
  43     WORD idle_minutes, deadline_minutes;
  44     DWORD priority, maxRunTime;
  45     LPWSTR accountName;
  46 } TaskImpl;
  47
  48 static inline TaskImpl *impl_from_ITask(ITask *iface)
  49 {
  50     return CONTAINING_RECORD(iface, TaskImpl, ITask_iface);
  51 }
  52
  53 static inline TaskImpl *impl_from_IPersistFile( IPersistFile *iface )
  54 {
  55     return CONTAINING_RECORD(iface, TaskImpl, IPersistFile_iface);
  56 }
  57
  58 static void TaskDestructor(TaskImpl *This)
  59 {
  60     TRACE("%p\n", This);
  61     if (This->action)
  62         IExecAction_Release(This->action);
  63     ITaskDefinition_Release(This->task);
  64     HeapFree(GetProcessHeap(), 0, This->task_name);
  65     HeapFree(GetProcessHeap(), 0, This->accountName);
  66     HeapFree(GetProcessHeap(), 0, This);
  67     InterlockedDecrement(&dll_ref);
  68 }
  69
  70 static HRESULT WINAPI MSTASK_ITask_QueryInterface(
  71         ITask* iface,
  72         REFIID riid,
  73         void **ppvObject)
  74 {
  75     TaskImpl * This = impl_from_ITask(iface);
  76
  77     TRACE("IID: %s\n", debugstr_guid(riid));
  78     if (ppvObject == NULL)
  79         return E_POINTER;
  80
  81     if (IsEqualGUID(riid, &IID_IUnknown) ||
  82             IsEqualGUID(riid, &IID_ITask))
  83     {
  84         *ppvObject = &This->ITask_iface;
  85         ITask_AddRef(iface);
  86         return S_OK;
  87     }
  88     else if (IsEqualGUID(riid, &IID_IPersistFile))
  89     {
  90         *ppvObject = &This->IPersistFile_iface;
  91         ITask_AddRef(iface);
  92         return S_OK;
  93     }
  94
  95     WARN("Unknown interface: %s\n", debugstr_guid(riid));
  96     *ppvObject = NULL;
  97     return E_NOINTERFACE;
  98 }
  99
 100 static ULONG WINAPI MSTASK_ITask_AddRef(
 101         ITask* iface)
 102 {
 103     TaskImpl *This = impl_from_ITask(iface);
 104     ULONG ref;
 105     TRACE("\n");
 106     ref = InterlockedIncrement(&This->ref);
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI MSTASK_ITask_Release(
 111         ITask* iface)
 112 {
 113     TaskImpl * This = impl_from_ITask(iface);
 114     ULONG ref;
 115     TRACE("\n");
 116     ref = InterlockedDecrement(&This->ref);
 117     if (ref == 0)
 118         TaskDestructor(This);
 119     return ref;
 120 }
 121
 122 static HRESULT WINAPI MSTASK_ITask_CreateTrigger(
 123         ITask* iface,
 124         WORD *piNewTrigger,
 125         ITaskTrigger **ppTrigger)
 126 {
 127     TRACE("(%p, %p, %p)\n", iface, piNewTrigger, ppTrigger);
 128     return TaskTriggerConstructor((LPVOID *)ppTrigger);
 129 }
 130
 131 static HRESULT WINAPI MSTASK_ITask_DeleteTrigger(
 132         ITask* iface,
 133         WORD iTrigger)
 134 {
 135     FIXME("(%p, %d): stub\n", iface, iTrigger);
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI MSTASK_ITask_GetTriggerCount(
 140         ITask* iface,
 141         WORD *plCount)
 142 {
 143     FIXME("(%p, %p): stub\n", iface, plCount);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI MSTASK_ITask_GetTrigger(
 148         ITask* iface,
 149         WORD iTrigger,
 150         ITaskTrigger **ppTrigger)
 151 {
 152     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppTrigger);
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI MSTASK_ITask_GetTriggerString(
 157         ITask* iface,
 158         WORD iTrigger,
 159         LPWSTR *ppwszTrigger)
 160 {
 161     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppwszTrigger);
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI MSTASK_ITask_GetRunTimes(
 166         ITask* iface,
 167         const LPSYSTEMTIME pstBegin,
 168         const LPSYSTEMTIME pstEnd,
 169         WORD *pCount,
 170         LPSYSTEMTIME *rgstTaskTimes)
 171 {
 172     FIXME("(%p, %p, %p, %p, %p): stub\n", iface, pstBegin, pstEnd, pCount,
 173             rgstTaskTimes);
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI MSTASK_ITask_GetNextRunTime(
 178         ITask* iface,
 179         SYSTEMTIME *pstNextRun)
 180 {
 181     FIXME("(%p, %p): stub\n", iface, pstNextRun);
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI MSTASK_ITask_SetIdleWait(
 186         ITask* iface,
 187         WORD wIdleMinutes,
 188         WORD wDeadlineMinutes)
 189 {
 190     FIXME("(%p, %d, %d): stub\n", iface, wIdleMinutes, wDeadlineMinutes);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI MSTASK_ITask_GetIdleWait(ITask *iface, WORD *idle_minutes, WORD *deadline_minutes)
 195 {
 196     TaskImpl *This = impl_from_ITask(iface);
 197
 198     TRACE("(%p, %p, %p): stub\n", iface, idle_minutes, deadline_minutes);
 199
 200     *idle_minutes = This->idle_minutes;
 201     *deadline_minutes = This->deadline_minutes;
 202     return S_OK;
 203 }
 204
 205 static HRESULT WINAPI MSTASK_ITask_Run(
 206         ITask* iface)
 207 {
 208     FIXME("(%p): stub\n", iface);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI MSTASK_ITask_Terminate(
 213         ITask* iface)
 214 {
 215     FIXME("(%p): stub\n", iface);
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI MSTASK_ITask_EditWorkItem(
 220         ITask* iface,
 221         HWND hParent,
 222         DWORD dwReserved)
 223 {
 224     FIXME("(%p, %p, %d): stub\n", iface, hParent, dwReserved);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI MSTASK_ITask_GetMostRecentRunTime(
 229         ITask* iface,
 230         SYSTEMTIME *pstLastRun)
 231 {
 232     FIXME("(%p, %p): stub\n", iface, pstLastRun);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI MSTASK_ITask_GetStatus(ITask *iface, HRESULT *status)
 237 {
 238     TaskImpl *This = impl_from_ITask(iface);
 239
 240     TRACE("(%p, %p)\n", iface, status);
 241
 242     *status = This->status;
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI MSTASK_ITask_GetExitCode(ITask *iface, DWORD *exit_code)
 247 {
 248     FIXME("(%p, %p): stub\n", iface, exit_code);
 249
 250     *exit_code = 0;
 251     return SCHED_S_TASK_HAS_NOT_RUN;
 252 }
 253
 254 static HRESULT WINAPI MSTASK_ITask_SetComment(ITask *iface, LPCWSTR comment)
 255 {
 256     TaskImpl *This = impl_from_ITask(iface);
 257     IRegistrationInfo *info;
 258     HRESULT hr;
 259
 260     TRACE("(%p, %s)\n", iface, debugstr_w(comment));
 261
 262     if (!comment || !comment[0])
 263         comment = NULL;
 264
 265     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 266     if (hr == S_OK)
 267     {
 268         hr = IRegistrationInfo_put_Description(info, (BSTR)comment);
 269         IRegistrationInfo_Release(info);
 270     }
 271     return hr;
 272 }
 273
 274 static HRESULT WINAPI MSTASK_ITask_GetComment(ITask *iface, LPWSTR *comment)
 275 {
 276     TaskImpl *This = impl_from_ITask(iface);
 277     IRegistrationInfo *info;
 278     HRESULT hr;
 279     BSTR description;
 280     DWORD len;
 281
 282     TRACE("(%p, %p)\n", iface, comment);
 283
 284     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 285     if (hr != S_OK) return hr;
 286
 287     hr = IRegistrationInfo_get_Description(info, &description);
 288     if (hr == S_OK)
 289     {
 290         len = description ? lstrlenW(description) + 1 : 1;
 291         *comment = CoTaskMemAlloc(len * sizeof(WCHAR));
 292         if (*comment)
 293         {
 294             if (!description)
 295                 *comment[0] = 0;
 296             else
 297                 lstrcpyW(*comment, description);
 298             hr = S_OK;
 299         }
 300         else
 301             hr =  E_OUTOFMEMORY;
 302
 303         SysFreeString(description);
 304     }
 305
 306     IRegistrationInfo_Release(info);
 307     return hr;
 308 }
 309
 310 static HRESULT WINAPI MSTASK_ITask_SetCreator(ITask *iface, LPCWSTR creator)
 311 {
 312     TaskImpl *This = impl_from_ITask(iface);
 313     IRegistrationInfo *info;
 314     HRESULT hr;
 315
 316     TRACE("(%p, %s)\n", iface, debugstr_w(creator));
 317
 318     if (!creator || !creator[0])
 319         creator = NULL;
 320
 321     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 322     if (hr == S_OK)
 323     {
 324         hr = IRegistrationInfo_put_Author(info, (BSTR)creator);
 325         IRegistrationInfo_Release(info);
 326     }
 327     return hr;
 328 }
 329
 330 static HRESULT WINAPI MSTASK_ITask_GetCreator(ITask *iface, LPWSTR *creator)
 331 {
 332     TaskImpl *This = impl_from_ITask(iface);
 333     IRegistrationInfo *info;
 334     HRESULT hr;
 335     BSTR author;
 336     DWORD len;
 337
 338     TRACE("(%p, %p)\n", iface, creator);
 339
 340     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 341     if (hr != S_OK) return hr;
 342
 343     hr = IRegistrationInfo_get_Author(info, &author);
 344     if (hr == S_OK)
 345     {
 346         len = author ? lstrlenW(author) + 1 : 1;
 347         *creator = CoTaskMemAlloc(len * sizeof(WCHAR));
 348         if (*creator)
 349         {
 350             if (!author)
 351                 *creator[0] = 0;
 352             else
 353                 lstrcpyW(*creator, author);
 354             hr = S_OK;
 355         }
 356         else
 357             hr =  E_OUTOFMEMORY;
 358
 359         SysFreeString(author);
 360     }
 361
 362     IRegistrationInfo_Release(info);
 363     return hr;
 364 }
 365
 366 static HRESULT WINAPI MSTASK_ITask_SetWorkItemData(
 367         ITask* iface,
 368         WORD cBytes,
 369         BYTE rgbData[])
 370 {
 371     FIXME("(%p, %d, %p): stub\n", iface, cBytes, rgbData);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI MSTASK_ITask_GetWorkItemData(
 376         ITask* iface,
 377         WORD *pcBytes,
 378         BYTE **ppBytes)
 379 {
 380     FIXME("(%p, %p, %p): stub\n", iface, pcBytes, ppBytes);
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryCount(
 385         ITask* iface,
 386         WORD wRetryCount)
 387 {
 388     FIXME("(%p, %d): stub\n", iface, wRetryCount);
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryCount(ITask *iface, WORD *count)
 393 {
 394     TRACE("(%p, %p)\n", iface, count);
 395     return E_NOTIMPL;
 396 }
 397
 398 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryInterval(
 399         ITask* iface,
 400         WORD wRetryInterval)
 401 {
 402     FIXME("(%p, %d): stub\n", iface, wRetryInterval);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryInterval(ITask *iface, WORD *interval)
 407 {
 408     TRACE("(%p, %p)\n", iface, interval);
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI MSTASK_ITask_SetFlags(
 413         ITask* iface,
 414         DWORD dwFlags)
 415 {
 416     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI MSTASK_ITask_GetFlags(ITask *iface, DWORD *flags)
 421 {
 422     FIXME("(%p, %p): stub\n", iface, flags);
 423     *flags = 0;
 424     return S_OK;
 425 }
 426
 427 static HRESULT WINAPI MSTASK_ITask_SetAccountInformation(
 428         ITask* iface,
 429         LPCWSTR pwszAccountName,
 430         LPCWSTR pwszPassword)
 431 {
 432     DWORD n;
 433     TaskImpl *This = impl_from_ITask(iface);
 434     LPWSTR tmp_account_name;
 435
 436     TRACE("(%p, %s, %s): partial stub\n", iface, debugstr_w(pwszAccountName),
 437             debugstr_w(pwszPassword));
 438
 439     if (pwszPassword)
 440         FIXME("Partial stub ignores passwords\n");
 441
 442     n = (lstrlenW(pwszAccountName) + 1);
 443     tmp_account_name = HeapAlloc(GetProcessHeap(), 0, n * sizeof(WCHAR));
 444     if (!tmp_account_name)
 445         return E_OUTOFMEMORY;
 446     lstrcpyW(tmp_account_name, pwszAccountName);
 447     HeapFree(GetProcessHeap(), 0, This->accountName);
 448     This->accountName = tmp_account_name;
 449     return S_OK;
 450 }
 451
 452 static HRESULT WINAPI MSTASK_ITask_GetAccountInformation(
 453         ITask* iface,
 454         LPWSTR *ppwszAccountName)
 455 {
 456     DWORD n;
 457     TaskImpl *This = impl_from_ITask(iface);
 458
 459     TRACE("(%p, %p): partial stub\n", iface, ppwszAccountName);
 460
 461     /* This implements the WinXP behavior when accountName has not yet
 462      * set.  Win2K behaves differently, returning SCHED_E_CANNOT_OPEN_TASK */
 463     if (!This->accountName)
 464         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 465
 466     n = (lstrlenW(This->accountName) + 1);
 467     *ppwszAccountName = CoTaskMemAlloc(n * sizeof(WCHAR));
 468     if (!*ppwszAccountName)
 469         return E_OUTOFMEMORY;
 470     lstrcpyW(*ppwszAccountName, This->accountName);
 471     return S_OK;
 472 }
 473
 474 static HRESULT WINAPI MSTASK_ITask_SetApplicationName(ITask *iface, LPCWSTR appname)
 475 {
 476     TaskImpl *This = impl_from_ITask(iface);
 477     DWORD len;
 478
 479     TRACE("(%p, %s)\n", iface, debugstr_w(appname));
 480
 481     /* Empty application name */
 482     if (!appname || !appname[0])
 483         return IExecAction_put_Path(This->action, NULL);
 484
 485     /* Attempt to set pwszApplicationName to a path resolved application name */
 486     len = SearchPathW(NULL, appname, NULL, 0, NULL, NULL);
 487     if (len)
 488     {
 489         LPWSTR tmp_name;
 490         HRESULT hr;
 491
 492         tmp_name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 493         if (!tmp_name)
 494             return E_OUTOFMEMORY;
 495         len = SearchPathW(NULL, appname, NULL, len, tmp_name, NULL);
 496         if (len)
 497             hr = IExecAction_put_Path(This->action, tmp_name);
 498         else
 499             hr = HRESULT_FROM_WIN32(GetLastError());
 500
 501         HeapFree(GetProcessHeap(), 0, tmp_name);
 502         return hr;
 503     }
 504
 505     /* If unable to path resolve name, simply set to appname */
 506     return IExecAction_put_Path(This->action, (BSTR)appname);
 507 }
 508
 509 static HRESULT WINAPI MSTASK_ITask_GetApplicationName(ITask *iface, LPWSTR *appname)
 510 {
 511     TaskImpl *This = impl_from_ITask(iface);
 512     HRESULT hr;
 513     BSTR path;
 514     DWORD len;
 515
 516     TRACE("(%p, %p)\n", iface, appname);
 517
 518     hr = IExecAction_get_Path(This->action, &path);
 519     if (hr != S_OK) return hr;
 520
 521     len = path ? lstrlenW(path) + 1 : 1;
 522     *appname = CoTaskMemAlloc(len * sizeof(WCHAR));
 523     if (*appname)
 524     {
 525         if (!path)
 526             *appname[0] = 0;
 527         else
 528             lstrcpyW(*appname, path);
 529         hr = S_OK;
 530     }
 531     else
 532         hr =  E_OUTOFMEMORY;
 533
 534     SysFreeString(path);
 535     return hr;
 536 }
 537
 538 static HRESULT WINAPI MSTASK_ITask_SetParameters(ITask *iface, LPCWSTR params)
 539 {
 540     TaskImpl *This = impl_from_ITask(iface);
 541
 542     TRACE("(%p, %s)\n", iface, debugstr_w(params));
 543
 544     /* Empty parameter list */
 545     if (!params || !params[0])
 546         params = NULL;
 547
 548     return IExecAction_put_Arguments(This->action, (BSTR)params);
 549 }
 550
 551 static HRESULT WINAPI MSTASK_ITask_GetParameters(ITask *iface, LPWSTR *params)
 552 {
 553     TaskImpl *This = impl_from_ITask(iface);
 554     HRESULT hr;
 555     BSTR args;
 556     DWORD len;
 557
 558     TRACE("(%p, %p)\n", iface, params);
 559
 560     hr = IExecAction_get_Arguments(This->action, &args);
 561     if (hr != S_OK) return hr;
 562
 563     len = args ? lstrlenW(args) + 1 : 1;
 564     *params = CoTaskMemAlloc(len * sizeof(WCHAR));
 565     if (*params)
 566     {
 567         if (!args)
 568             *params[0] = 0;
 569         else
 570             lstrcpyW(*params, args);
 571         hr = S_OK;
 572     }
 573     else
 574         hr =  E_OUTOFMEMORY;
 575
 576     SysFreeString(args);
 577     return hr;
 578 }
 579
 580 static HRESULT WINAPI MSTASK_ITask_SetWorkingDirectory(ITask * iface, LPCWSTR workdir)
 581 {
 582     TaskImpl *This = impl_from_ITask(iface);
 583
 584     TRACE("(%p, %s)\n", iface, debugstr_w(workdir));
 585
 586     if (!workdir || !workdir[0])
 587         workdir = NULL;
 588
 589     return IExecAction_put_WorkingDirectory(This->action, (BSTR)workdir);
 590 }
 591
 592 static HRESULT WINAPI MSTASK_ITask_GetWorkingDirectory(ITask *iface, LPWSTR *workdir)
 593 {
 594     TaskImpl *This = impl_from_ITask(iface);
 595     HRESULT hr;
 596     BSTR dir;
 597     DWORD len;
 598
 599     TRACE("(%p, %p)\n", iface, workdir);
 600
 601     hr = IExecAction_get_WorkingDirectory(This->action, &dir);
 602     if (hr != S_OK) return hr;
 603
 604     len = dir ? lstrlenW(dir) + 1 : 1;
 605     *workdir = CoTaskMemAlloc(len * sizeof(WCHAR));
 606     if (*workdir)
 607     {
 608         if (!dir)
 609             *workdir[0] = 0;
 610         else
 611             lstrcpyW(*workdir, dir);
 612         hr = S_OK;
 613     }
 614     else
 615         hr =  E_OUTOFMEMORY;
 616
 617     SysFreeString(dir);
 618     return hr;
 619 }
 620
 621 static HRESULT WINAPI MSTASK_ITask_SetPriority(
 622         ITask* iface,
 623         DWORD dwPriority)
 624 {
 625     FIXME("(%p, 0x%08x): stub\n", iface, dwPriority);
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI MSTASK_ITask_GetPriority(ITask *iface, DWORD *priority)
 630 {
 631     TaskImpl *This = impl_from_ITask(iface);
 632
 633     TRACE("(%p, %p)\n", iface, priority);
 634
 635     *priority = This->priority;
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI MSTASK_ITask_SetTaskFlags(
 640         ITask* iface,
 641         DWORD dwFlags)
 642 {
 643     FIXME("(%p, 0x%08x): stub\n", iface, dwFlags);
 644     return E_NOTIMPL;
 645 }
 646
 647 static HRESULT WINAPI MSTASK_ITask_GetTaskFlags(ITask *iface, DWORD *flags)
 648 {
 649     FIXME("(%p, %p): stub\n", iface, flags);
 650     *flags = 0;
 651     return S_OK;
 652 }
 653
 654 static HRESULT WINAPI MSTASK_ITask_SetMaxRunTime(
 655         ITask* iface,
 656         DWORD dwMaxRunTime)
 657 {
 658     TaskImpl *This = impl_from_ITask(iface);
 659
 660     TRACE("(%p, %d)\n", iface, dwMaxRunTime);
 661
 662     This->maxRunTime = dwMaxRunTime;
 663     return S_OK;
 664 }
 665
 666 static HRESULT WINAPI MSTASK_ITask_GetMaxRunTime(
 667         ITask* iface,
 668         DWORD *pdwMaxRunTime)
 669 {
 670     TaskImpl *This = impl_from_ITask(iface);
 671
 672     TRACE("(%p, %p)\n", iface, pdwMaxRunTime);
 673
 674     *pdwMaxRunTime = This->maxRunTime;
 675     return S_OK;
 676 }
 677
 678 static HRESULT WINAPI MSTASK_IPersistFile_QueryInterface(
 679         IPersistFile* iface,
 680         REFIID riid,
 681         void **ppvObject)
 682 {
 683     TaskImpl *This = impl_from_IPersistFile(iface);
 684     TRACE("(%p, %s, %p)\n", iface, debugstr_guid(riid), ppvObject);
 685     return ITask_QueryInterface(&This->ITask_iface, riid, ppvObject);
 686 }
 687
 688 static ULONG WINAPI MSTASK_IPersistFile_AddRef(
 689         IPersistFile* iface)
 690 {
 691     TaskImpl *This = impl_from_IPersistFile(iface);
 692     ULONG ref;
 693     TRACE("\n");
 694     ref = InterlockedIncrement(&This->ref);
 695     return ref;
 696 }
 697
 698 static ULONG WINAPI MSTASK_IPersistFile_Release(
 699         IPersistFile* iface)
 700 {
 701     TaskImpl *This = impl_from_IPersistFile(iface);
 702     ULONG ref;
 703     TRACE("\n");
 704     ref = InterlockedDecrement(&This->ref);
 705     if (ref == 0)
 706         TaskDestructor(This);
 707     return ref;
 708 }
 709
 710 static HRESULT WINAPI MSTASK_IPersistFile_GetClassID(IPersistFile *iface, CLSID *clsid)
 711 {
 712     TRACE("(%p, %p)\n", iface, clsid);
 713
 714     *clsid = CLSID_CTask;
 715     return S_OK;
 716 }
 717
 718 static HRESULT WINAPI MSTASK_IPersistFile_IsDirty(
 719         IPersistFile* iface)
 720 {
 721     FIXME("(%p): stub\n", iface);
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT WINAPI MSTASK_IPersistFile_Load(
 726         IPersistFile* iface,
 727         LPCOLESTR pszFileName,
 728         DWORD dwMode)
 729 {
 730     FIXME("(%p, %p, 0x%08x): stub\n", iface, pszFileName, dwMode);
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI MSTASK_IPersistFile_Save(
 735         IPersistFile* iface,
 736         LPCOLESTR pszFileName,
 737         BOOL fRemember)
 738 {
 739     FIXME("(%p, %p, %d): stub\n", iface, pszFileName, fRemember);
 740     WARN("Returning S_OK but not writing to disk: %s %d\n",
 741             debugstr_w(pszFileName), fRemember);
 742     return S_OK;
 743 }
 744
 745 static HRESULT WINAPI MSTASK_IPersistFile_SaveCompleted(
 746         IPersistFile* iface,
 747         LPCOLESTR pszFileName)
 748 {
 749     FIXME("(%p, %p): stub\n", iface, pszFileName);
 750     return E_NOTIMPL;
 751 }
 752
 753 static HRESULT WINAPI MSTASK_IPersistFile_GetCurFile(
 754         IPersistFile* iface,
 755         LPOLESTR *ppszFileName)
 756 {
 757     FIXME("(%p, %p): stub\n", iface, ppszFileName);
 758     return E_NOTIMPL;
 759 }
 760
 761
 762 static const ITaskVtbl MSTASK_ITaskVtbl =
 763 {
 764     MSTASK_ITask_QueryInterface,
 765     MSTASK_ITask_AddRef,
 766     MSTASK_ITask_Release,
 767     MSTASK_ITask_CreateTrigger,
 768     MSTASK_ITask_DeleteTrigger,
 769     MSTASK_ITask_GetTriggerCount,
 770     MSTASK_ITask_GetTrigger,
 771     MSTASK_ITask_GetTriggerString,
 772     MSTASK_ITask_GetRunTimes,
 773     MSTASK_ITask_GetNextRunTime,
 774     MSTASK_ITask_SetIdleWait,
 775     MSTASK_ITask_GetIdleWait,
 776     MSTASK_ITask_Run,
 777     MSTASK_ITask_Terminate,
 778     MSTASK_ITask_EditWorkItem,
 779     MSTASK_ITask_GetMostRecentRunTime,
 780     MSTASK_ITask_GetStatus,
 781     MSTASK_ITask_GetExitCode,
 782     MSTASK_ITask_SetComment,
 783     MSTASK_ITask_GetComment,
 784     MSTASK_ITask_SetCreator,
 785     MSTASK_ITask_GetCreator,
 786     MSTASK_ITask_SetWorkItemData,
 787     MSTASK_ITask_GetWorkItemData,
 788     MSTASK_ITask_SetErrorRetryCount,
 789     MSTASK_ITask_GetErrorRetryCount,
 790     MSTASK_ITask_SetErrorRetryInterval,
 791     MSTASK_ITask_GetErrorRetryInterval,
 792     MSTASK_ITask_SetFlags,
 793     MSTASK_ITask_GetFlags,
 794     MSTASK_ITask_SetAccountInformation,
 795     MSTASK_ITask_GetAccountInformation,
 796     MSTASK_ITask_SetApplicationName,
 797     MSTASK_ITask_GetApplicationName,
 798     MSTASK_ITask_SetParameters,
 799     MSTASK_ITask_GetParameters,
 800     MSTASK_ITask_SetWorkingDirectory,
 801     MSTASK_ITask_GetWorkingDirectory,
 802     MSTASK_ITask_SetPriority,
 803     MSTASK_ITask_GetPriority,
 804     MSTASK_ITask_SetTaskFlags,
 805     MSTASK_ITask_GetTaskFlags,
 806     MSTASK_ITask_SetMaxRunTime,
 807     MSTASK_ITask_GetMaxRunTime
 808 };
 809
 810 static const IPersistFileVtbl MSTASK_IPersistFileVtbl =
 811 {
 812     MSTASK_IPersistFile_QueryInterface,
 813     MSTASK_IPersistFile_AddRef,
 814     MSTASK_IPersistFile_Release,
 815     MSTASK_IPersistFile_GetClassID,
 816     MSTASK_IPersistFile_IsDirty,
 817     MSTASK_IPersistFile_Load,
 818     MSTASK_IPersistFile_Save,
 819     MSTASK_IPersistFile_SaveCompleted,
 820     MSTASK_IPersistFile_GetCurFile
 821 };
 822
 823 HRESULT TaskConstructor(ITaskService *service, const WCHAR *task_name, ITask **task)
 824 {
 825     TaskImpl *This;
 826     ITaskDefinition *taskdef;
 827     IActionCollection *actions;
 828     HRESULT hr;
 829
 830     TRACE("(%s, %p)\n", debugstr_w(task_name), task);
 831
 832     hr = ITaskService_NewTask(service, 0, &taskdef);
 833     if (hr != S_OK) return hr;
 834
 835     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 836     if (!This)
 837     {
 838         ITaskDefinition_Release(taskdef);
 839         return E_OUTOFMEMORY;
 840     }
 841
 842     This->ITask_iface.lpVtbl = &MSTASK_ITaskVtbl;
 843     This->IPersistFile_iface.lpVtbl = &MSTASK_IPersistFileVtbl;
 844     This->ref = 1;
 845     This->task = taskdef;
 846     This->task_name = heap_strdupW(task_name);
 847     This->status = SCHED_S_TASK_NOT_SCHEDULED;
 848     This->idle_minutes = 10;
 849     This->deadline_minutes = 60;
 850     This->priority = NORMAL_PRIORITY_CLASS;
 851     This->accountName = NULL;
 852
 853     /* Default time is 3 days = 259200000 ms */
 854     This->maxRunTime = 259200000;
 855
 856     hr = ITaskDefinition_get_Actions(This->task, &actions);
 857     if (hr == S_OK)
 858     {
 859         hr = IActionCollection_Create(actions, TASK_ACTION_EXEC, (IAction **)&This->action);
 860         IActionCollection_Release(actions);
 861         if (hr == S_OK)
 862         {
 863             *task = &This->ITask_iface;
 864             InterlockedIncrement(&dll_ref);
 865             return S_OK;
 866         }
 867     }
 868
 869     ITaskDefinition_Release(This->task);
 870     ITask_Release(&This->ITask_iface);
 871     return hr;
 872 }