dll/win32/mstask/task.c

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