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