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