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