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 "winternl.h"
  27 #include "objbase.h"
  28 #include "taskschd.h"
  29 #include "mstask.h"
  30 #include "mstask_private.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(mstask);
  34
  35 typedef struct
  36 {
  37     USHORT product_version;
  38     USHORT file_version;
  39     UUID uuid;
  40     USHORT name_size_offset;
  41     USHORT trigger_offset;
  42     USHORT error_retry_count;
  43     USHORT error_retry_interval;
  44     USHORT idle_deadline;
  45     USHORT idle_wait;
  46     UINT priority;
  47     UINT maximum_runtime;
  48     UINT exit_code;
  49     HRESULT status;
  50     UINT flags;
  51     SYSTEMTIME last_runtime;
  52 } FIXDLEN_DATA;
  53
  54 typedef struct
  55 {
  56     ITask ITask_iface;
  57     IPersistFile IPersistFile_iface;
  58     LONG ref;
  59     ITaskDefinition *task;
  60     IExecAction *action;
  61     BYTE *data;
  62     WORD data_count;
  63     UUID uuid;
  64     LPWSTR task_name;
  65     HRESULT status;
  66     WORD idle_minutes, deadline_minutes;
  67     DWORD flags, priority, maxRunTime, exit_code;
  68     SYSTEMTIME last_runtime;
  69     LPWSTR accountName;
  70     DWORD trigger_count;
  71     TASK_TRIGGER *trigger;
  72     BOOL is_dirty;
  73     USHORT instance_count;
  74 } TaskImpl;
  75
  76 static inline TaskImpl *impl_from_ITask(ITask *iface)
  77 {
  78     return CONTAINING_RECORD(iface, TaskImpl, ITask_iface);
  79 }
  80
  81 static inline TaskImpl *impl_from_IPersistFile( IPersistFile *iface )
  82 {
  83     return CONTAINING_RECORD(iface, TaskImpl, IPersistFile_iface);
  84 }
  85
  86 static void TaskDestructor(TaskImpl *This)
  87 {
  88     TRACE("%p\n", This);
  89     if (This->action)
  90         IExecAction_Release(This->action);
  91     ITaskDefinition_Release(This->task);
  92     free(This->data);
  93     free(This->task_name);
  94     free(This->accountName);
  95     free(This->trigger);
  96     free(This);
  97     InterlockedDecrement(&dll_ref);
  98 }
  99
 100 static HRESULT WINAPI MSTASK_ITask_QueryInterface(
 101         ITask* iface,
 102         REFIID riid,
 103         void **ppvObject)
 104 {
 105     TaskImpl * This = impl_from_ITask(iface);
 106
 107     TRACE("IID: %s\n", debugstr_guid(riid));
 108     if (ppvObject == NULL)
 109         return E_POINTER;
 110
 111     if (IsEqualGUID(riid, &IID_IUnknown) ||
 112             IsEqualGUID(riid, &IID_ITask))
 113     {
 114         *ppvObject = &This->ITask_iface;
 115         ITask_AddRef(iface);
 116         return S_OK;
 117     }
 118     else if (IsEqualGUID(riid, &IID_IPersistFile))
 119     {
 120         *ppvObject = &This->IPersistFile_iface;
 121         ITask_AddRef(iface);
 122         return S_OK;
 123     }
 124
 125     WARN("Unknown interface: %s\n", debugstr_guid(riid));
 126     *ppvObject = NULL;
 127     return E_NOINTERFACE;
 128 }
 129
 130 static ULONG WINAPI MSTASK_ITask_AddRef(
 131         ITask* iface)
 132 {
 133     TaskImpl *This = impl_from_ITask(iface);
 134     ULONG ref;
 135     TRACE("\n");
 136     ref = InterlockedIncrement(&This->ref);
 137     return ref;
 138 }
 139
 140 static ULONG WINAPI MSTASK_ITask_Release(
 141         ITask* iface)
 142 {
 143     TaskImpl * This = impl_from_ITask(iface);
 144     ULONG ref;
 145     TRACE("\n");
 146     ref = InterlockedDecrement(&This->ref);
 147     if (ref == 0)
 148         TaskDestructor(This);
 149     return ref;
 150 }
 151
 152 HRESULT task_set_trigger(ITask *task, WORD idx, const TASK_TRIGGER *src)
 153 {
 154     TaskImpl *This = impl_from_ITask(task);
 155     TIME_FIELDS field_time;
 156     LARGE_INTEGER sys_time;
 157     TASK_TRIGGER dst;
 158
 159     TRACE("(%p, %u, %p)\n", task, idx, src);
 160
 161     if (idx >= This->trigger_count)
 162         return E_FAIL;
 163
 164     /* Verify valid structure size */
 165     if (src->cbTriggerSize != sizeof(*src))
 166         return E_INVALIDARG;
 167     dst.cbTriggerSize = src->cbTriggerSize;
 168
 169     /* Reserved field must be zero */
 170     dst.Reserved1 = 0;
 171
 172     /* Verify and set valid start date and time */
 173     memset(&field_time, 0, sizeof(field_time));
 174     field_time.Year = src->wBeginYear;
 175     field_time.Month = src->wBeginMonth;
 176     field_time.Day = src->wBeginDay;
 177     field_time.Hour = src->wStartHour;
 178     field_time.Minute = src->wStartMinute;
 179     if (!RtlTimeFieldsToTime(&field_time, &sys_time))
 180         return E_INVALIDARG;
 181     dst.wBeginYear = src->wBeginYear;
 182     dst.wBeginMonth = src->wBeginMonth;
 183     dst.wBeginDay = src->wBeginDay;
 184     dst.wStartHour = src->wStartHour;
 185     dst.wStartMinute = src->wStartMinute;
 186
 187     /* Verify valid end date if TASK_TRIGGER_FLAG_HAS_END_DATE flag is set */
 188     if (src->rgFlags & TASK_TRIGGER_FLAG_HAS_END_DATE)
 189     {
 190         memset(&field_time, 0, sizeof(field_time));
 191         field_time.Year = src->wEndYear;
 192         field_time.Month = src->wEndMonth;
 193         field_time.Day = src->wEndDay;
 194         if (!RtlTimeFieldsToTime(&field_time, &sys_time))
 195             return E_INVALIDARG;
 196     }
 197
 198     /* Set valid end date independent of TASK_TRIGGER_FLAG_HAS_END_DATE flag */
 199     dst.wEndYear = src->wEndYear;
 200     dst.wEndMonth = src->wEndMonth;
 201     dst.wEndDay = src->wEndDay;
 202
 203     /* Verify duration and interval pair */
 204     if (src->MinutesDuration <= src->MinutesInterval && src->MinutesInterval > 0)
 205         return E_INVALIDARG;
 206     dst.MinutesDuration = src->MinutesDuration;
 207     dst.MinutesInterval = src->MinutesInterval;
 208
 209     /* Copy over flags */
 210     dst.rgFlags = src->rgFlags;
 211
 212     /* Set TriggerType dependent fields of Type union */
 213     dst.TriggerType = src->TriggerType;
 214     switch (src->TriggerType)
 215     {
 216         case TASK_TIME_TRIGGER_DAILY:
 217             dst.Type.Daily.DaysInterval = src->Type.Daily.DaysInterval;
 218             break;
 219         case TASK_TIME_TRIGGER_WEEKLY:
 220             dst.Type.Weekly.WeeksInterval = src->Type.Weekly.WeeksInterval;
 221             dst.Type.Weekly.rgfDaysOfTheWeek = src->Type.Weekly.rgfDaysOfTheWeek;
 222             break;
 223         case TASK_TIME_TRIGGER_MONTHLYDATE:
 224             dst.Type.MonthlyDate.rgfDays = src->Type.MonthlyDate.rgfDays;
 225             dst.Type.MonthlyDate.rgfMonths = src->Type.MonthlyDate.rgfMonths;
 226             break;
 227         case TASK_TIME_TRIGGER_MONTHLYDOW:
 228             dst.Type.MonthlyDOW.wWhichWeek = src->Type.MonthlyDOW.wWhichWeek;
 229             dst.Type.MonthlyDOW.rgfDaysOfTheWeek = src->Type.MonthlyDOW.rgfDaysOfTheWeek;
 230             dst.Type.MonthlyDOW.rgfMonths = src->Type.MonthlyDOW.rgfMonths;
 231             break;
 232         case TASK_TIME_TRIGGER_ONCE:
 233         case TASK_EVENT_TRIGGER_ON_IDLE:
 234         case TASK_EVENT_TRIGGER_AT_SYSTEMSTART:
 235         case TASK_EVENT_TRIGGER_AT_LOGON:
 236         default:
 237             dst.Type = src->Type;
 238             break;
 239     }
 240
 241     /* Reserved field must be zero */
 242     dst.Reserved2 = 0;
 243
 244     /* wRandomMinutesInterval not currently used and is initialized to zero */
 245     dst.wRandomMinutesInterval = 0;
 246
 247     This->trigger[idx] = dst;
 248
 249     return S_OK;
 250 }
 251
 252 HRESULT task_get_trigger(ITask *task, WORD idx, TASK_TRIGGER *dst)
 253 {
 254     TaskImpl *This = impl_from_ITask(task);
 255     TASK_TRIGGER *src;
 256
 257     TRACE("(%p, %u, %p)\n", task, idx, dst);
 258
 259     if (idx >= This->trigger_count)
 260         return SCHED_E_TRIGGER_NOT_FOUND;
 261
 262     src = &This->trigger[idx];
 263
 264     /* Native implementation doesn't verify equivalent cbTriggerSize fields */
 265
 266     /* Copy relevant fields of the structure */
 267     dst->cbTriggerSize = src->cbTriggerSize;
 268     dst->Reserved1 = 0;
 269     dst->wBeginYear = src->wBeginYear;
 270     dst->wBeginMonth = src->wBeginMonth;
 271     dst->wBeginDay = src->wBeginDay;
 272     dst->wEndYear = src->wEndYear;
 273     dst->wEndMonth = src->wEndMonth;
 274     dst->wEndDay = src->wEndDay;
 275     dst->wStartHour = src->wStartHour;
 276     dst->wStartMinute = src->wStartMinute;
 277     dst->MinutesDuration = src->MinutesDuration;
 278     dst->MinutesInterval = src->MinutesInterval;
 279     dst->rgFlags = src->rgFlags;
 280     dst->TriggerType = src->TriggerType;
 281     switch (src->TriggerType)
 282     {
 283         case TASK_TIME_TRIGGER_DAILY:
 284             dst->Type.Daily.DaysInterval = src->Type.Daily.DaysInterval;
 285             break;
 286         case TASK_TIME_TRIGGER_WEEKLY:
 287             dst->Type.Weekly.WeeksInterval = src->Type.Weekly.WeeksInterval;
 288             dst->Type.Weekly.rgfDaysOfTheWeek = src->Type.Weekly.rgfDaysOfTheWeek;
 289             break;
 290         case TASK_TIME_TRIGGER_MONTHLYDATE:
 291             dst->Type.MonthlyDate.rgfDays = src->Type.MonthlyDate.rgfDays;
 292             dst->Type.MonthlyDate.rgfMonths = src->Type.MonthlyDate.rgfMonths;
 293             break;
 294         case TASK_TIME_TRIGGER_MONTHLYDOW:
 295             dst->Type.MonthlyDOW.wWhichWeek = src->Type.MonthlyDOW.wWhichWeek;
 296             dst->Type.MonthlyDOW.rgfDaysOfTheWeek = src->Type.MonthlyDOW.rgfDaysOfTheWeek;
 297             dst->Type.MonthlyDOW.rgfMonths = src->Type.MonthlyDOW.rgfMonths;
 298             break;
 299         case TASK_TIME_TRIGGER_ONCE:
 300         case TASK_EVENT_TRIGGER_ON_IDLE:
 301         case TASK_EVENT_TRIGGER_AT_SYSTEMSTART:
 302         case TASK_EVENT_TRIGGER_AT_LOGON:
 303         default:
 304             break;
 305     }
 306     dst->Reserved2 = 0;
 307     dst->wRandomMinutesInterval = 0;
 308
 309     return S_OK;
 310 }
 311
 312 static HRESULT WINAPI MSTASK_ITask_CreateTrigger(ITask *iface, WORD *idx, ITaskTrigger **task_trigger)
 313 {
 314     TaskImpl *This = impl_from_ITask(iface);
 315     TASK_TRIGGER *new_trigger;
 316     SYSTEMTIME time;
 317     HRESULT hr;
 318
 319     TRACE("(%p, %p, %p)\n", iface, idx, task_trigger);
 320
 321     hr = TaskTriggerConstructor(iface, This->trigger_count, task_trigger);
 322     if (hr != S_OK) return hr;
 323
 324     if (This->trigger)
 325         new_trigger = realloc(This->trigger, sizeof(This->trigger[0]) * (This->trigger_count + 1));
 326     else
 327         new_trigger = malloc(sizeof(This->trigger[0]));
 328     if (!new_trigger)
 329     {
 330         ITaskTrigger_Release(*task_trigger);
 331         return E_OUTOFMEMORY;
 332     }
 333
 334     This->trigger = new_trigger;
 335
 336     new_trigger = &This->trigger[This->trigger_count];
 337
 338     /* Most fields default to zero. Initialize other fields to default values. */
 339     memset(new_trigger, 0, sizeof(*new_trigger));
 340     GetLocalTime(&time);
 341     new_trigger->cbTriggerSize = sizeof(*new_trigger);
 342     new_trigger->wBeginYear = time.wYear;
 343     new_trigger->wBeginMonth = time.wMonth;
 344     new_trigger->wBeginDay = time.wDay;
 345     new_trigger->wStartHour = time.wHour;
 346     new_trigger->wStartMinute = time.wMinute;
 347     new_trigger->rgFlags = TASK_TRIGGER_FLAG_DISABLED;
 348     new_trigger->TriggerType = TASK_TIME_TRIGGER_DAILY;
 349     new_trigger->Type.Daily.DaysInterval = 1;
 350
 351     *idx = This->trigger_count++;
 352
 353     return hr;
 354 }
 355
 356 static HRESULT WINAPI MSTASK_ITask_DeleteTrigger(ITask *iface, WORD idx)
 357 {
 358     TaskImpl *This = impl_from_ITask(iface);
 359
 360     TRACE("(%p, %u)\n", iface, idx);
 361
 362     if (idx >= This->trigger_count)
 363         return SCHED_E_TRIGGER_NOT_FOUND;
 364
 365     This->trigger_count--;
 366     memmove(&This->trigger[idx], &This->trigger[idx + 1], (This->trigger_count - idx) * sizeof(This->trigger[0]));
 367     /* this shouldn't fail in practice since we're shrinking the memory block */
 368     This->trigger = realloc(This->trigger, sizeof(This->trigger[0]) * This->trigger_count);
 369
 370     return S_OK;
 371 }
 372
 373 static HRESULT WINAPI MSTASK_ITask_GetTriggerCount(ITask *iface, WORD *count)
 374 {
 375     TaskImpl *This = impl_from_ITask(iface);
 376
 377     TRACE("(%p, %p)\n", iface, count);
 378
 379     *count = This->trigger_count;
 380     return S_OK;
 381 }
 382
 383 static HRESULT WINAPI MSTASK_ITask_GetTrigger(ITask *iface, WORD idx, ITaskTrigger **trigger)
 384 {
 385     TaskImpl *This = impl_from_ITask(iface);
 386
 387     TRACE("(%p, %u, %p)\n", iface, idx, trigger);
 388
 389     if (idx >= This->trigger_count)
 390         return SCHED_E_TRIGGER_NOT_FOUND;
 391
 392     return TaskTriggerConstructor(iface, idx, trigger);
 393 }
 394
 395 static HRESULT WINAPI MSTASK_ITask_GetTriggerString(
 396         ITask* iface,
 397         WORD iTrigger,
 398         LPWSTR *ppwszTrigger)
 399 {
 400     FIXME("(%p, %d, %p): stub\n", iface, iTrigger, ppwszTrigger);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI MSTASK_ITask_GetRunTimes(
 405         ITask* iface,
 406         const LPSYSTEMTIME pstBegin,
 407         const LPSYSTEMTIME pstEnd,
 408         WORD *pCount,
 409         LPSYSTEMTIME *rgstTaskTimes)
 410 {
 411     FIXME("(%p, %p, %p, %p, %p): stub\n", iface, pstBegin, pstEnd, pCount,
 412             rgstTaskTimes);
 413     return E_NOTIMPL;
 414 }
 415
 416 static void get_begin_time(const TASK_TRIGGER *trigger, FILETIME *ft)
 417 {
 418     SYSTEMTIME st;
 419
 420     st.wYear = trigger->wBeginYear;
 421     st.wMonth = trigger->wBeginMonth;
 422     st.wDay = trigger->wBeginDay;
 423     st.wDayOfWeek = 0;
 424     st.wHour = 0;
 425     st.wMinute = 0;
 426     st.wSecond = 0;
 427     st.wMilliseconds = 0;
 428     SystemTimeToFileTime(&st, ft);
 429 }
 430
 431 static void get_end_time(const TASK_TRIGGER *trigger, FILETIME *ft)
 432 {
 433     SYSTEMTIME st;
 434
 435     if (!(trigger->rgFlags & TASK_TRIGGER_FLAG_HAS_END_DATE))
 436     {
 437         ft->dwHighDateTime = ~0u;
 438         ft->dwLowDateTime = ~0u;
 439         return;
 440     }
 441
 442     st.wYear = trigger->wEndYear;
 443     st.wMonth = trigger->wEndMonth;
 444     st.wDay = trigger->wEndDay;
 445     st.wDayOfWeek = 0;
 446     st.wHour = 0;
 447     st.wMinute = 0;
 448     st.wSecond = 0;
 449     st.wMilliseconds = 0;
 450     SystemTimeToFileTime(&st, ft);
 451 }
 452
 453 static void filetime_add_ms(FILETIME *ft, ULONGLONG ms)
 454 {
 455     union u_ftll
 456     {
 457         FILETIME ft;
 458         ULONGLONG ll;
 459     } *ftll = (union u_ftll *)ft;
 460
 461     ftll->ll += ms * (ULONGLONG)10000;
 462 }
 463
 464 static void filetime_add_hours(FILETIME *ft, ULONG hours)
 465 {
 466     filetime_add_ms(ft, (ULONGLONG)hours * 60 * 60 * 1000);
 467 }
 468
 469 static void filetime_add_days(FILETIME *ft, ULONG days)
 470 {
 471     filetime_add_hours(ft, (ULONGLONG)days * 24);
 472 }
 473
 474 static void filetime_add_weeks(FILETIME *ft, ULONG weeks)
 475 {
 476     filetime_add_days(ft, (ULONGLONG)weeks * 7);
 477 }
 478
 479 static HRESULT WINAPI MSTASK_ITask_GetNextRunTime(ITask *iface, SYSTEMTIME *rt)
 480 {
 481     TaskImpl *This = impl_from_ITask(iface);
 482     HRESULT hr = SCHED_S_TASK_NO_VALID_TRIGGERS;
 483     SYSTEMTIME st, current_st;
 484     FILETIME current_ft, trigger_ft, begin_ft, end_ft, best_ft;
 485     BOOL have_best_time = FALSE;
 486     DWORD i;
 487
 488     TRACE("(%p, %p)\n", iface, rt);
 489
 490     if (This->flags & TASK_FLAG_DISABLED)
 491     {
 492         memset(rt, 0, sizeof(*rt));
 493         return SCHED_S_TASK_DISABLED;
 494     }
 495
 496     GetLocalTime(&current_st);
 497     SystemTimeToFileTime(&current_st, &current_ft);
 498
 499     for (i = 0; i < This->trigger_count; i++)
 500     {
 501         if (!(This->trigger[i].rgFlags & TASK_TRIGGER_FLAG_DISABLED))
 502         {
 503             get_begin_time(&This->trigger[i], &begin_ft);
 504             if (CompareFileTime(&begin_ft, &current_ft) < 0)
 505                 begin_ft = current_ft;
 506
 507             get_end_time(&This->trigger[i], &end_ft);
 508
 509             switch (This->trigger[i].TriggerType)
 510             {
 511             case TASK_EVENT_TRIGGER_ON_IDLE:
 512             case TASK_EVENT_TRIGGER_AT_SYSTEMSTART:
 513             case TASK_EVENT_TRIGGER_AT_LOGON:
 514                 hr = SCHED_S_EVENT_TRIGGER;
 515                 break;
 516
 517             case TASK_TIME_TRIGGER_ONCE:
 518                 st = current_st;
 519                 st.wYear = This->trigger[i].wBeginYear;
 520                 st.wMonth = This->trigger[i].wBeginMonth;
 521                 st.wDay = This->trigger[i].wBeginDay;
 522                 st.wHour = This->trigger[i].wStartHour;
 523                 st.wMinute = This->trigger[i].wStartMinute;
 524                 st.wSecond = 0;
 525                 st.wMilliseconds = 0;
 526                 SystemTimeToFileTime(&st, &trigger_ft);
 527                 if (CompareFileTime(&begin_ft, &trigger_ft) <= 0 && CompareFileTime(&trigger_ft, &end_ft) < 0)
 528                 {
 529                     if (!have_best_time || CompareFileTime(&trigger_ft, &best_ft) < 0)
 530                     {
 531                         best_ft = trigger_ft;
 532                         have_best_time = TRUE;
 533                     }
 534                 }
 535                 break;
 536
 537             case TASK_TIME_TRIGGER_DAILY:
 538                 if (!This->trigger[i].Type.Daily.DaysInterval)
 539                     break; /* avoid infinite loop */
 540
 541                 st = current_st;
 542                 st.wHour = This->trigger[i].wStartHour;
 543                 st.wMinute = This->trigger[i].wStartMinute;
 544                 st.wSecond = 0;
 545                 st.wMilliseconds = 0;
 546                 SystemTimeToFileTime(&st, &trigger_ft);
 547                 while (CompareFileTime(&trigger_ft, &end_ft) < 0)
 548                 {
 549                     if (CompareFileTime(&trigger_ft, &begin_ft) >= 0)
 550                     {
 551                         if (!have_best_time || CompareFileTime(&trigger_ft, &best_ft) < 0)
 552                         {
 553                             best_ft = trigger_ft;
 554                             have_best_time = TRUE;
 555                         }
 556                         break;
 557                     }
 558
 559                     filetime_add_days(&trigger_ft, This->trigger[i].Type.Daily.DaysInterval);
 560                 }
 561                 break;
 562
 563             case TASK_TIME_TRIGGER_WEEKLY:
 564                 if (!This->trigger[i].Type.Weekly.rgfDaysOfTheWeek)
 565                     break; /* avoid infinite loop */
 566
 567                 st = current_st;
 568                 st.wHour = This->trigger[i].wStartHour;
 569                 st.wMinute = This->trigger[i].wStartMinute;
 570                 st.wSecond = 0;
 571                 st.wMilliseconds = 0;
 572                 SystemTimeToFileTime(&st, &trigger_ft);
 573                 while (CompareFileTime(&trigger_ft, &end_ft) < 0)
 574                 {
 575                     FileTimeToSystemTime(&trigger_ft, &st);
 576
 577                     if (CompareFileTime(&trigger_ft, &begin_ft) >= 0)
 578                     {
 579                         if (This->trigger[i].Type.Weekly.rgfDaysOfTheWeek & (1 << st.wDayOfWeek))
 580                         {
 581                             if (!have_best_time || CompareFileTime(&trigger_ft, &best_ft) < 0)
 582                             {
 583                                 best_ft = trigger_ft;
 584                                 have_best_time = TRUE;
 585                             }
 586                             break;
 587                         }
 588                     }
 589
 590                     if (st.wDayOfWeek == 0 && This->trigger[i].Type.Weekly.WeeksInterval > 1) /* Sunday, goto next week */
 591                         filetime_add_weeks(&trigger_ft, This->trigger[i].Type.Weekly.WeeksInterval - 1);
 592                     else /* check next weekday */
 593                         filetime_add_days(&trigger_ft, 1);
 594                 }
 595                 break;
 596
 597             default:
 598                 FIXME("trigger type %u is not handled\n", This->trigger[i].TriggerType);
 599                 break;
 600             }
 601         }
 602     }
 603
 604     if (have_best_time)
 605     {
 606         FileTimeToSystemTime(&best_ft, rt);
 607         return S_OK;
 608     }
 609
 610     memset(rt, 0, sizeof(*rt));
 611     return hr;
 612 }
 613
 614 static HRESULT WINAPI MSTASK_ITask_SetIdleWait(
 615         ITask* iface,
 616         WORD wIdleMinutes,
 617         WORD wDeadlineMinutes)
 618 {
 619     FIXME("(%p, %d, %d): stub\n", iface, wIdleMinutes, wDeadlineMinutes);
 620     return E_NOTIMPL;
 621 }
 622
 623 static HRESULT WINAPI MSTASK_ITask_GetIdleWait(ITask *iface, WORD *idle_minutes, WORD *deadline_minutes)
 624 {
 625     TaskImpl *This = impl_from_ITask(iface);
 626
 627     TRACE("(%p, %p, %p): stub\n", iface, idle_minutes, deadline_minutes);
 628
 629     *idle_minutes = This->idle_minutes;
 630     *deadline_minutes = This->deadline_minutes;
 631     return S_OK;
 632 }
 633
 634 static HRESULT WINAPI MSTASK_ITask_Run(ITask *iface)
 635 {
 636     TaskImpl *This = impl_from_ITask(iface);
 637
 638     TRACE("(%p)\n", iface);
 639
 640     if (This->status == SCHED_S_TASK_NOT_SCHEDULED)
 641         return SCHED_E_TASK_NOT_READY;
 642
 643     This->flags |= 0x04000000;
 644     return IPersistFile_Save(&This->IPersistFile_iface, NULL, FALSE);
 645 }
 646
 647 static HRESULT WINAPI MSTASK_ITask_Terminate(ITask *iface)
 648 {
 649     TaskImpl *This = impl_from_ITask(iface);
 650
 651     TRACE("(%p)\n", iface);
 652
 653     if (!This->instance_count)
 654         return SCHED_E_TASK_NOT_RUNNING;
 655
 656     This->flags |= 0x08000000;
 657     return IPersistFile_Save(&This->IPersistFile_iface, NULL, FALSE);
 658 }
 659
 660 static HRESULT WINAPI MSTASK_ITask_EditWorkItem(
 661         ITask* iface,
 662         HWND hParent,
 663         DWORD dwReserved)
 664 {
 665     FIXME("(%p, %p, %ld): stub\n", iface, hParent, dwReserved);
 666     return E_NOTIMPL;
 667 }
 668
 669 static HRESULT WINAPI MSTASK_ITask_GetMostRecentRunTime(ITask *iface, SYSTEMTIME *st)
 670 {
 671     TaskImpl *This = impl_from_ITask(iface);
 672
 673     TRACE("(%p, %p)\n", iface, st);
 674
 675     if (This->status == SCHED_S_TASK_NOT_SCHEDULED)
 676     {
 677         memset(st, 0, sizeof(*st));
 678         return SCHED_S_TASK_HAS_NOT_RUN;
 679     }
 680
 681     *st = This->last_runtime;
 682     return S_OK;
 683 }
 684
 685 static HRESULT WINAPI MSTASK_ITask_GetStatus(ITask *iface, HRESULT *status)
 686 {
 687     TaskImpl *This = impl_from_ITask(iface);
 688
 689     TRACE("(%p, %p)\n", iface, status);
 690
 691     *status = This->instance_count ? SCHED_S_TASK_RUNNING : This->status;
 692     return S_OK;
 693 }
 694
 695 static HRESULT WINAPI MSTASK_ITask_GetExitCode(ITask *iface, DWORD *exit_code)
 696 {
 697     TaskImpl *This = impl_from_ITask(iface);
 698
 699     TRACE("(%p, %p)\n", iface, exit_code);
 700
 701     if (This->status == SCHED_S_TASK_NOT_SCHEDULED)
 702     {
 703         *exit_code = 0;
 704         return SCHED_S_TASK_HAS_NOT_RUN;
 705     }
 706
 707     *exit_code = This->exit_code;
 708     return S_OK;
 709 }
 710
 711 static HRESULT WINAPI MSTASK_ITask_SetComment(ITask *iface, LPCWSTR comment)
 712 {
 713     TaskImpl *This = impl_from_ITask(iface);
 714     IRegistrationInfo *info;
 715     HRESULT hr;
 716
 717     TRACE("(%p, %s)\n", iface, debugstr_w(comment));
 718
 719     if (!comment || !comment[0])
 720         comment = NULL;
 721
 722     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 723     if (hr == S_OK)
 724     {
 725         hr = IRegistrationInfo_put_Description(info, (BSTR)comment);
 726         IRegistrationInfo_Release(info);
 727         This->is_dirty = TRUE;
 728     }
 729     return hr;
 730 }
 731
 732 static HRESULT WINAPI MSTASK_ITask_GetComment(ITask *iface, LPWSTR *comment)
 733 {
 734     TaskImpl *This = impl_from_ITask(iface);
 735     IRegistrationInfo *info;
 736     HRESULT hr;
 737     BSTR description;
 738     DWORD len;
 739
 740     TRACE("(%p, %p)\n", iface, comment);
 741
 742     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 743     if (hr != S_OK) return hr;
 744
 745     hr = IRegistrationInfo_get_Description(info, &description);
 746     if (hr == S_OK)
 747     {
 748         len = description ? lstrlenW(description) + 1 : 1;
 749         *comment = CoTaskMemAlloc(len * sizeof(WCHAR));
 750         if (*comment)
 751         {
 752             if (!description)
 753                 *comment[0] = 0;
 754             else
 755                 lstrcpyW(*comment, description);
 756             hr = S_OK;
 757         }
 758         else
 759             hr =  E_OUTOFMEMORY;
 760
 761         SysFreeString(description);
 762     }
 763
 764     IRegistrationInfo_Release(info);
 765     return hr;
 766 }
 767
 768 static HRESULT WINAPI MSTASK_ITask_SetCreator(ITask *iface, LPCWSTR creator)
 769 {
 770     TaskImpl *This = impl_from_ITask(iface);
 771     IRegistrationInfo *info;
 772     HRESULT hr;
 773
 774     TRACE("(%p, %s)\n", iface, debugstr_w(creator));
 775
 776     if (!creator || !creator[0])
 777         creator = NULL;
 778
 779     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 780     if (hr == S_OK)
 781     {
 782         hr = IRegistrationInfo_put_Author(info, (BSTR)creator);
 783         IRegistrationInfo_Release(info);
 784         This->is_dirty = TRUE;
 785     }
 786     return hr;
 787 }
 788
 789 static HRESULT WINAPI MSTASK_ITask_GetCreator(ITask *iface, LPWSTR *creator)
 790 {
 791     TaskImpl *This = impl_from_ITask(iface);
 792     IRegistrationInfo *info;
 793     HRESULT hr;
 794     BSTR author;
 795     DWORD len;
 796
 797     TRACE("(%p, %p)\n", iface, creator);
 798
 799     hr = ITaskDefinition_get_RegistrationInfo(This->task, &info);
 800     if (hr != S_OK) return hr;
 801
 802     hr = IRegistrationInfo_get_Author(info, &author);
 803     if (hr == S_OK)
 804     {
 805         len = author ? lstrlenW(author) + 1 : 1;
 806         *creator = CoTaskMemAlloc(len * sizeof(WCHAR));
 807         if (*creator)
 808         {
 809             if (!author)
 810                 *creator[0] = 0;
 811             else
 812                 lstrcpyW(*creator, author);
 813             hr = S_OK;
 814         }
 815         else
 816             hr =  E_OUTOFMEMORY;
 817
 818         SysFreeString(author);
 819     }
 820
 821     IRegistrationInfo_Release(info);
 822     return hr;
 823 }
 824
 825 static HRESULT WINAPI MSTASK_ITask_SetWorkItemData(ITask *iface, WORD count, BYTE data[])
 826 {
 827     TaskImpl *This = impl_from_ITask(iface);
 828
 829     TRACE("(%p, %u, %p)\n", iface, count, data);
 830
 831     if (count)
 832     {
 833         if (!data) return E_INVALIDARG;
 834
 835         free(This->data);
 836         This->data = malloc(count);
 837         if (!This->data) return E_OUTOFMEMORY;
 838         memcpy(This->data, data, count);
 839         This->data_count = count;
 840     }
 841     else
 842     {
 843         if (data) return E_INVALIDARG;
 844
 845         free(This->data);
 846         This->data = NULL;
 847         This->data_count = 0;
 848     }
 849
 850     return S_OK;
 851 }
 852
 853 static HRESULT WINAPI MSTASK_ITask_GetWorkItemData(ITask *iface, WORD *count, BYTE **data)
 854 {
 855     TaskImpl *This = impl_from_ITask(iface);
 856
 857     TRACE("(%p, %p, %p)\n", iface, count, data);
 858
 859     if (!This->data)
 860     {
 861         *count = 0;
 862         *data = NULL;
 863     }
 864     else
 865     {
 866         *data = CoTaskMemAlloc(This->data_count);
 867         if (!*data) return E_OUTOFMEMORY;
 868         memcpy(*data, This->data, This->data_count);
 869         *count = This->data_count;
 870     }
 871
 872     return S_OK;
 873 }
 874
 875 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryCount(
 876         ITask* iface,
 877         WORD wRetryCount)
 878 {
 879     FIXME("(%p, %d): stub\n", iface, wRetryCount);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryCount(ITask *iface, WORD *count)
 884 {
 885     TRACE("(%p, %p)\n", iface, count);
 886     return E_NOTIMPL;
 887 }
 888
 889 static HRESULT WINAPI MSTASK_ITask_SetErrorRetryInterval(
 890         ITask* iface,
 891         WORD wRetryInterval)
 892 {
 893     FIXME("(%p, %d): stub\n", iface, wRetryInterval);
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI MSTASK_ITask_GetErrorRetryInterval(ITask *iface, WORD *interval)
 898 {
 899     TRACE("(%p, %p)\n", iface, interval);
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI MSTASK_ITask_SetFlags(ITask *iface, DWORD flags)
 904 {
 905     TaskImpl *This = impl_from_ITask(iface);
 906
 907     TRACE("(%p, 0x%08lx)\n", iface, flags);
 908     This->flags &= 0xffff8000;
 909     This->flags |= flags & 0x7fff;
 910     This->is_dirty = TRUE;
 911     return S_OK;
 912 }
 913
 914 static HRESULT WINAPI MSTASK_ITask_GetFlags(ITask *iface, DWORD *flags)
 915 {
 916     TaskImpl *This = impl_from_ITask(iface);
 917
 918     TRACE("(%p, %p)\n", iface, flags);
 919     *flags = LOWORD(This->flags);
 920     return S_OK;
 921 }
 922
 923 static HRESULT WINAPI MSTASK_ITask_SetAccountInformation(
 924         ITask* iface,
 925         LPCWSTR pwszAccountName,
 926         LPCWSTR pwszPassword)
 927 {
 928     DWORD n;
 929     TaskImpl *This = impl_from_ITask(iface);
 930     LPWSTR tmp_account_name;
 931
 932     TRACE("(%p, %s, %s): partial stub\n", iface, debugstr_w(pwszAccountName),
 933             debugstr_w(pwszPassword));
 934
 935     if (pwszPassword)
 936         FIXME("Partial stub ignores passwords\n");
 937
 938     n = (lstrlenW(pwszAccountName) + 1);
 939     tmp_account_name = malloc(n * sizeof(WCHAR));
 940     if (!tmp_account_name)
 941         return E_OUTOFMEMORY;
 942     lstrcpyW(tmp_account_name, pwszAccountName);
 943     free(This->accountName);
 944     This->accountName = tmp_account_name;
 945     This->is_dirty = TRUE;
 946     return S_OK;
 947 }
 948
 949 static HRESULT WINAPI MSTASK_ITask_GetAccountInformation(
 950         ITask* iface,
 951         LPWSTR *ppwszAccountName)
 952 {
 953     DWORD n;
 954     TaskImpl *This = impl_from_ITask(iface);
 955
 956     TRACE("(%p, %p): partial stub\n", iface, ppwszAccountName);
 957
 958     /* This implements the WinXP behavior when accountName has not yet
 959      * set.  Win2K behaves differently, returning SCHED_E_CANNOT_OPEN_TASK */
 960     if (!This->accountName)
 961         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 962
 963     n = (lstrlenW(This->accountName) + 1);
 964     *ppwszAccountName = CoTaskMemAlloc(n * sizeof(WCHAR));
 965     if (!*ppwszAccountName)
 966         return E_OUTOFMEMORY;
 967     lstrcpyW(*ppwszAccountName, This->accountName);
 968     return S_OK;
 969 }
 970
 971 static HRESULT WINAPI MSTASK_ITask_SetApplicationName(ITask *iface, LPCWSTR appname)
 972 {
 973     TaskImpl *This = impl_from_ITask(iface);
 974     DWORD len;
 975     HRESULT hr;
 976
 977     TRACE("(%p, %s)\n", iface, debugstr_w(appname));
 978
 979     /* Empty application name */
 980     if (!appname || !appname[0])
 981         return IExecAction_put_Path(This->action, NULL);
 982
 983     /* Attempt to set pwszApplicationName to a path resolved application name */
 984     len = SearchPathW(NULL, appname, NULL, 0, NULL, NULL);
 985     if (len)
 986     {
 987         LPWSTR tmp_name;
 988
 989         tmp_name = malloc(len * sizeof(WCHAR));
 990         if (!tmp_name)
 991             return E_OUTOFMEMORY;
 992         len = SearchPathW(NULL, appname, NULL, len, tmp_name, NULL);
 993         if (len)
 994         {
 995             hr = IExecAction_put_Path(This->action, tmp_name);
 996             if (hr == S_OK) This->is_dirty = TRUE;
 997         }
 998         else
 999             hr = HRESULT_FROM_WIN32(GetLastError());
1000
1001         free(tmp_name);
1002         return hr;
1003     }
1004
1005     /* If unable to path resolve name, simply set to appname */
1006     hr = IExecAction_put_Path(This->action, (BSTR)appname);
1007     if (hr == S_OK) This->is_dirty = TRUE;
1008     return hr;
1009 }
1010
1011 static HRESULT WINAPI MSTASK_ITask_GetApplicationName(ITask *iface, LPWSTR *appname)
1012 {
1013     TaskImpl *This = impl_from_ITask(iface);
1014     HRESULT hr;
1015     BSTR path;
1016     DWORD len;
1017
1018     TRACE("(%p, %p)\n", iface, appname);
1019
1020     hr = IExecAction_get_Path(This->action, &path);
1021     if (hr != S_OK) return hr;
1022
1023     len = path ? lstrlenW(path) + 1 : 1;
1024     *appname = CoTaskMemAlloc(len * sizeof(WCHAR));
1025     if (*appname)
1026     {
1027         if (!path)
1028             *appname[0] = 0;
1029         else
1030             lstrcpyW(*appname, path);
1031         hr = S_OK;
1032     }
1033     else
1034         hr =  E_OUTOFMEMORY;
1035
1036     SysFreeString(path);
1037     return hr;
1038 }
1039
1040 static HRESULT WINAPI MSTASK_ITask_SetParameters(ITask *iface, LPCWSTR params)
1041 {
1042     TaskImpl *This = impl_from_ITask(iface);
1043     HRESULT hr;
1044
1045     TRACE("(%p, %s)\n", iface, debugstr_w(params));
1046
1047     /* Empty parameter list */
1048     if (!params || !params[0])
1049         params = NULL;
1050
1051     hr = IExecAction_put_Arguments(This->action, (BSTR)params);
1052     if (hr == S_OK) This->is_dirty = TRUE;
1053     return hr;
1054 }
1055
1056 static HRESULT WINAPI MSTASK_ITask_GetParameters(ITask *iface, LPWSTR *params)
1057 {
1058     TaskImpl *This = impl_from_ITask(iface);
1059     HRESULT hr;
1060     BSTR args;
1061     DWORD len;
1062
1063     TRACE("(%p, %p)\n", iface, params);
1064
1065     hr = IExecAction_get_Arguments(This->action, &args);
1066     if (hr != S_OK) return hr;
1067
1068     len = args ? lstrlenW(args) + 1 : 1;
1069     *params = CoTaskMemAlloc(len * sizeof(WCHAR));
1070     if (*params)
1071     {
1072         if (!args)
1073             *params[0] = 0;
1074         else
1075             lstrcpyW(*params, args);
1076         hr = S_OK;
1077     }
1078     else
1079         hr =  E_OUTOFMEMORY;
1080
1081     SysFreeString(args);
1082     return hr;
1083 }
1084
1085 static HRESULT WINAPI MSTASK_ITask_SetWorkingDirectory(ITask * iface, LPCWSTR workdir)
1086 {
1087     TaskImpl *This = impl_from_ITask(iface);
1088     HRESULT hr;
1089
1090     TRACE("(%p, %s)\n", iface, debugstr_w(workdir));
1091
1092     if (!workdir || !workdir[0])
1093         workdir = NULL;
1094
1095     hr = IExecAction_put_WorkingDirectory(This->action, (BSTR)workdir);
1096     if (hr == S_OK) This->is_dirty = TRUE;
1097     return hr;
1098 }
1099
1100 static HRESULT WINAPI MSTASK_ITask_GetWorkingDirectory(ITask *iface, LPWSTR *workdir)
1101 {
1102     TaskImpl *This = impl_from_ITask(iface);
1103     HRESULT hr;
1104     BSTR dir;
1105     DWORD len;
1106
1107     TRACE("(%p, %p)\n", iface, workdir);
1108
1109     hr = IExecAction_get_WorkingDirectory(This->action, &dir);
1110     if (hr != S_OK) return hr;
1111
1112     len = dir ? lstrlenW(dir) + 1 : 1;
1113     *workdir = CoTaskMemAlloc(len * sizeof(WCHAR));
1114     if (*workdir)
1115     {
1116         if (!dir)
1117             *workdir[0] = 0;
1118         else
1119             lstrcpyW(*workdir, dir);
1120         hr = S_OK;
1121     }
1122     else
1123         hr =  E_OUTOFMEMORY;
1124
1125     SysFreeString(dir);
1126     return hr;
1127 }
1128
1129 static HRESULT WINAPI MSTASK_ITask_SetPriority(
1130         ITask* iface,
1131         DWORD dwPriority)
1132 {
1133     FIXME("(%p, 0x%08lx): stub\n", iface, dwPriority);
1134     return E_NOTIMPL;
1135 }
1136
1137 static HRESULT WINAPI MSTASK_ITask_GetPriority(ITask *iface, DWORD *priority)
1138 {
1139     TaskImpl *This = impl_from_ITask(iface);
1140
1141     TRACE("(%p, %p)\n", iface, priority);
1142
1143     *priority = This->priority;
1144     return S_OK;
1145 }
1146
1147 static HRESULT WINAPI MSTASK_ITask_SetTaskFlags(
1148         ITask* iface,
1149         DWORD dwFlags)
1150 {
1151     FIXME("(%p, 0x%08lx): stub\n", iface, dwFlags);
1152     return E_NOTIMPL;
1153 }
1154
1155 static HRESULT WINAPI MSTASK_ITask_GetTaskFlags(ITask *iface, DWORD *flags)
1156 {
1157     FIXME("(%p, %p): stub\n", iface, flags);
1158     *flags = 0;
1159     return S_OK;
1160 }
1161
1162 static HRESULT WINAPI MSTASK_ITask_SetMaxRunTime(
1163         ITask* iface,
1164         DWORD dwMaxRunTime)
1165 {
1166     TaskImpl *This = impl_from_ITask(iface);
1167
1168     TRACE("(%p, %ld)\n", iface, dwMaxRunTime);
1169
1170     This->maxRunTime = dwMaxRunTime;
1171     This->is_dirty = TRUE;
1172     return S_OK;
1173 }
1174
1175 static HRESULT WINAPI MSTASK_ITask_GetMaxRunTime(
1176         ITask* iface,
1177         DWORD *pdwMaxRunTime)
1178 {
1179     TaskImpl *This = impl_from_ITask(iface);
1180
1181     TRACE("(%p, %p)\n", iface, pdwMaxRunTime);
1182
1183     *pdwMaxRunTime = This->maxRunTime;
1184     return S_OK;
1185 }
1186
1187 static HRESULT WINAPI MSTASK_IPersistFile_QueryInterface(
1188         IPersistFile* iface,
1189         REFIID riid,
1190         void **ppvObject)
1191 {
1192     TaskImpl *This = impl_from_IPersistFile(iface);
1193     TRACE("(%p, %s, %p)\n", iface, debugstr_guid(riid), ppvObject);
1194     return ITask_QueryInterface(&This->ITask_iface, riid, ppvObject);
1195 }
1196
1197 static ULONG WINAPI MSTASK_IPersistFile_AddRef(
1198         IPersistFile* iface)
1199 {
1200     TaskImpl *This = impl_from_IPersistFile(iface);
1201     return ITask_AddRef(&This->ITask_iface);
1202 }
1203
1204 static ULONG WINAPI MSTASK_IPersistFile_Release(
1205         IPersistFile* iface)
1206 {
1207     TaskImpl *This = impl_from_IPersistFile(iface);
1208     return ITask_Release(&This->ITask_iface);
1209 }
1210
1211 static HRESULT WINAPI MSTASK_IPersistFile_GetClassID(IPersistFile *iface, CLSID *clsid)
1212 {
1213     TRACE("(%p, %p)\n", iface, clsid);
1214
1215     *clsid = CLSID_CTask;
1216     return S_OK;
1217 }
1218
1219 static HRESULT WINAPI MSTASK_IPersistFile_IsDirty(IPersistFile *iface)
1220 {
1221     TaskImpl *This = impl_from_IPersistFile(iface);
1222     TRACE("(%p)\n", iface);
1223     return This->is_dirty ? S_OK : S_FALSE;
1224 }
1225
1226 static DWORD load_unicode_strings(ITask *task, BYTE *data, DWORD limit)
1227 {
1228     DWORD i, data_size = 0;
1229     USHORT len;
1230
1231     for (i = 0; i < 5; i++)
1232     {
1233         if (limit < sizeof(USHORT))
1234         {
1235             TRACE("invalid string %lu offset\n", i);
1236             break;
1237         }
1238
1239         len = *(USHORT *)data;
1240         data += sizeof(USHORT);
1241         data_size += sizeof(USHORT);
1242         limit -= sizeof(USHORT);
1243         if (limit < len * sizeof(WCHAR))
1244         {
1245             TRACE("invalid string %lu size\n", i);
1246             break;
1247         }
1248
1249         TRACE("string %lu: %s\n", i, wine_dbgstr_wn((const WCHAR *)data, len));
1250
1251         switch (i)
1252         {
1253         case 0:
1254             ITask_SetApplicationName(task, (const WCHAR *)data);
1255             break;
1256         case 1:
1257             ITask_SetParameters(task, (const WCHAR *)data);
1258             break;
1259         case 2:
1260             ITask_SetWorkingDirectory(task, (const WCHAR *)data);
1261             break;
1262         case 3:
1263             ITask_SetCreator(task, (const WCHAR *)data);
1264             break;
1265         case 4:
1266             ITask_SetComment(task, (const WCHAR *)data);
1267             break;
1268         default:
1269             break;
1270         }
1271
1272         data += len * sizeof(WCHAR);
1273         data_size += len * sizeof(WCHAR);
1274     }
1275
1276     return data_size;
1277 }
1278
1279 static HRESULT load_job_data(TaskImpl *This, BYTE *data, DWORD size)
1280 {
1281     ITask *task = &This->ITask_iface;
1282     HRESULT hr;
1283     const FIXDLEN_DATA *fixed;
1284     const SYSTEMTIME *st;
1285     DWORD unicode_strings_size, data_size, triggers_size;
1286     USHORT trigger_count, i;
1287     const USHORT *signature;
1288     TASK_TRIGGER *task_trigger;
1289
1290     if (size < sizeof(*fixed))
1291     {
1292         TRACE("no space for FIXDLEN_DATA\n");
1293         return SCHED_E_INVALID_TASK;
1294     }
1295
1296     fixed = (const FIXDLEN_DATA *)data;
1297
1298     TRACE("product_version %04x\n", fixed->product_version);
1299     TRACE("file_version %04x\n", fixed->file_version);
1300     TRACE("uuid %s\n", wine_dbgstr_guid(&fixed->uuid));
1301
1302     if (fixed->file_version != 0x0001)
1303         return SCHED_E_INVALID_TASK;
1304
1305     This->uuid = fixed->uuid;
1306
1307     TRACE("name_size_offset %04x\n", fixed->name_size_offset);
1308     TRACE("trigger_offset %04x\n", fixed->trigger_offset);
1309     TRACE("error_retry_count %u\n", fixed->error_retry_count);
1310     TRACE("error_retry_interval %u\n", fixed->error_retry_interval);
1311     TRACE("idle_deadline %u\n", fixed->idle_deadline);
1312     This->deadline_minutes = fixed->idle_deadline;
1313     TRACE("idle_wait %u\n", fixed->idle_wait);
1314     This->idle_minutes = fixed->idle_wait;
1315     TRACE("priority %08x\n", fixed->priority);
1316     This->priority = fixed->priority;
1317     TRACE("maximum_runtime %u\n", fixed->maximum_runtime);
1318     This->maxRunTime = fixed->maximum_runtime;
1319     TRACE("exit_code %#x\n", fixed->exit_code);
1320     This->exit_code = fixed->exit_code;
1321     TRACE("status %08lx\n", fixed->status);
1322     This->status = fixed->status;
1323     TRACE("flags %08x\n", fixed->flags);
1324     This->flags = fixed->flags;
1325     This->last_runtime = fixed->last_runtime;
1326     st = &fixed->last_runtime;
1327     TRACE("last_runtime %u/%u/%u wday %u %u:%02u:%02u.%03u\n",
1328             st->wDay, st->wMonth, st->wYear, st->wDayOfWeek,
1329             st->wHour, st->wMinute, st->wSecond, st->wMilliseconds);
1330
1331     /* Instance Count */
1332     if (size < sizeof(*fixed) + sizeof(USHORT))
1333     {
1334         TRACE("no space for instance count\n");
1335         return SCHED_E_INVALID_TASK;
1336     }
1337
1338     This->instance_count = *(const USHORT *)(data + sizeof(*fixed));
1339     TRACE("instance count %u\n", This->instance_count);
1340
1341     if (fixed->name_size_offset + sizeof(USHORT) < size)
1342         unicode_strings_size = load_unicode_strings(task, data + fixed->name_size_offset, size - fixed->name_size_offset);
1343     else
1344     {
1345         TRACE("invalid name_size_offset\n");
1346         return SCHED_E_INVALID_TASK;
1347     }
1348     TRACE("unicode strings end at %#lx\n", fixed->name_size_offset + unicode_strings_size);
1349
1350     if (size < fixed->trigger_offset + sizeof(USHORT))
1351     {
1352         TRACE("no space for triggers count\n");
1353         return SCHED_E_INVALID_TASK;
1354     }
1355     trigger_count = *(const USHORT *)(data + fixed->trigger_offset);
1356     TRACE("trigger_count %u\n", trigger_count);
1357     triggers_size = size - fixed->trigger_offset - sizeof(USHORT);
1358     TRACE("triggers_size %lu\n", triggers_size);
1359     task_trigger = (TASK_TRIGGER *)(data + fixed->trigger_offset + sizeof(USHORT));
1360
1361     data += fixed->name_size_offset + unicode_strings_size;
1362     size -= fixed->name_size_offset + unicode_strings_size;
1363
1364     /* User Data */
1365     if (size < sizeof(USHORT))
1366     {
1367         TRACE("no space for user data size\n");
1368         return SCHED_E_INVALID_TASK;
1369     }
1370
1371     data_size = *(const USHORT *)data;
1372     if (size < sizeof(USHORT) + data_size)
1373     {
1374         TRACE("no space for user data\n");
1375         return SCHED_E_INVALID_TASK;
1376     }
1377     TRACE("User Data size %#lx\n", data_size);
1378     ITask_SetWorkItemData(task, data_size, data + sizeof(USHORT));
1379
1380     size -= sizeof(USHORT) + data_size;
1381     data += sizeof(USHORT) + data_size;
1382
1383     /* Reserved Data */
1384     if (size < sizeof(USHORT))
1385     {
1386         TRACE("no space for reserved data size\n");
1387         return SCHED_E_INVALID_TASK;
1388     }
1389
1390     data_size = *(const USHORT *)data;
1391     if (size < sizeof(USHORT) + data_size)
1392     {
1393         TRACE("no space for reserved data\n");
1394         return SCHED_E_INVALID_TASK;
1395     }
1396     TRACE("Reserved Data size %#lx\n", data_size);
1397
1398     size -= sizeof(USHORT) + data_size;
1399     data += sizeof(USHORT) + data_size;
1400
1401     /* Trigger Data */
1402     TRACE("trigger_offset %04x, triggers end at %04Ix\n", fixed->trigger_offset,
1403           fixed->trigger_offset + sizeof(USHORT) + trigger_count * sizeof(TASK_TRIGGER));
1404
1405     task_trigger = (TASK_TRIGGER *)(data + sizeof(USHORT));
1406
1407     if (trigger_count * sizeof(TASK_TRIGGER) > triggers_size)
1408     {
1409         TRACE("no space for triggers data\n");
1410         return SCHED_E_INVALID_TASK;
1411     }
1412
1413     This->trigger_count = 0;
1414
1415     for (i = 0; i < trigger_count; i++)
1416     {
1417         ITaskTrigger *trigger;
1418         WORD idx;
1419
1420         hr = ITask_CreateTrigger(task, &idx, &trigger);
1421         if (hr != S_OK) return hr;
1422
1423         hr = ITaskTrigger_SetTrigger(trigger, &task_trigger[i]);
1424         ITaskTrigger_Release(trigger);
1425         if (hr != S_OK)
1426         {
1427             ITask_DeleteTrigger(task, idx);
1428             return hr;
1429         }
1430     }
1431
1432     size -= sizeof(USHORT) + trigger_count * sizeof(TASK_TRIGGER);
1433     data += sizeof(USHORT) + trigger_count * sizeof(TASK_TRIGGER);
1434
1435     if (size < 2 * sizeof(USHORT) + 64)
1436     {
1437         TRACE("no space for signature\n");
1438         return S_OK; /* signature is optional */
1439     }
1440
1441     signature = (const USHORT *)data;
1442     TRACE("signature version %04x, client version %04x\n", signature[0], signature[1]);
1443
1444     return S_OK;
1445 }
1446
1447 static HRESULT WINAPI MSTASK_IPersistFile_Load(IPersistFile *iface, LPCOLESTR file_name, DWORD mode)
1448 {
1449     TaskImpl *This = impl_from_IPersistFile(iface);
1450     HRESULT hr;
1451     HANDLE file, mapping;
1452     DWORD access, sharing, size, try;
1453     void *data;
1454
1455     TRACE("(%p, %s, 0x%08lx)\n", iface, debugstr_w(file_name), mode);
1456
1457     switch (mode & 0x000f)
1458     {
1459     default:
1460     case STGM_READ:
1461         access = GENERIC_READ;
1462         break;
1463     case STGM_WRITE:
1464     case STGM_READWRITE:
1465         access = GENERIC_READ | GENERIC_WRITE;
1466         break;
1467     }
1468
1469     switch (mode & 0x00f0)
1470     {
1471     default:
1472     case STGM_SHARE_DENY_NONE:
1473         sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1474         break;
1475     case STGM_SHARE_DENY_READ:
1476         sharing = FILE_SHARE_WRITE;
1477         break;
1478     case STGM_SHARE_DENY_WRITE:
1479         sharing = FILE_SHARE_READ;
1480         break;
1481     case STGM_SHARE_EXCLUSIVE:
1482         sharing = 0;
1483         break;
1484     }
1485
1486     try = 1;
1487     for (;;)
1488     {
1489         file = CreateFileW(file_name, access, sharing, NULL, OPEN_EXISTING, 0, 0);
1490         if (file != INVALID_HANDLE_VALUE) break;
1491
1492         if (GetLastError() != ERROR_SHARING_VIOLATION || try++ >= 3)
1493         {
1494             TRACE("Failed to open %s, error %lu\n", debugstr_w(file_name), GetLastError());
1495             return HRESULT_FROM_WIN32(GetLastError());
1496         }
1497         Sleep(100);
1498     }
1499
1500     size = GetFileSize(file, NULL);
1501
1502     mapping = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, 0);
1503     if (!mapping)
1504     {
1505         TRACE("Failed to create file mapping %s, error %lu\n", debugstr_w(file_name), GetLastError());
1506         CloseHandle(file);
1507         return HRESULT_FROM_WIN32(GetLastError());
1508     }
1509
1510     data = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
1511     if (data)
1512     {
1513         hr = load_job_data(This, data, size);
1514         if (hr == S_OK) This->is_dirty = FALSE;
1515         UnmapViewOfFile(data);
1516     }
1517     else
1518         hr = HRESULT_FROM_WIN32(GetLastError());
1519
1520     CloseHandle(mapping);
1521     CloseHandle(file);
1522
1523     return hr;
1524 }
1525
1526 static BOOL write_signature(HANDLE hfile)
1527 {
1528     struct
1529     {
1530         USHORT SignatureVersion;
1531         USHORT ClientVersion;
1532         BYTE md5[64];
1533     } signature;
1534     DWORD size;
1535
1536     signature.SignatureVersion = 0x0001;
1537     signature.ClientVersion = 0x0001;
1538     memset(&signature.md5, 0, sizeof(signature.md5));
1539
1540     return WriteFile(hfile, &signature, sizeof(signature), &size, NULL);
1541 }
1542
1543 static BOOL write_reserved_data(HANDLE hfile)
1544 {
1545     static const struct
1546     {
1547         USHORT size;
1548         BYTE data[8];
1549     } user = { 8, { 0xff,0x0f,0x1d,0,0,0,0,0 } };
1550     DWORD size;
1551
1552     return WriteFile(hfile, &user, sizeof(user), &size, NULL);
1553 }
1554
1555 static BOOL write_user_data(HANDLE hfile, BYTE *data, WORD data_size)
1556 {
1557     DWORD size;
1558
1559     if (!WriteFile(hfile, &data_size, sizeof(data_size), &size, NULL))
1560         return FALSE;
1561
1562     if (!data_size) return TRUE;
1563
1564     return WriteFile(hfile, data, data_size, &size, NULL);
1565 }
1566
1567 static HRESULT write_triggers(TaskImpl *This, HANDLE hfile)
1568 {
1569     WORD count, i, idx = 0xffff;
1570     DWORD size;
1571     HRESULT hr = S_OK;
1572     ITaskTrigger *trigger;
1573
1574     count = This->trigger_count;
1575
1576     /* Windows saves a .job with at least 1 trigger */
1577     if (!count)
1578     {
1579         hr = ITask_CreateTrigger(&This->ITask_iface, &idx, &trigger);
1580         if (hr != S_OK) return hr;
1581         ITaskTrigger_Release(trigger);
1582
1583         count = 1;
1584     }
1585
1586     if (WriteFile(hfile, &count, sizeof(count), &size, NULL))
1587     {
1588         for (i = 0; i < count; i++)
1589         {
1590             if (!WriteFile(hfile, &This->trigger[i], sizeof(This->trigger[0]), &size, NULL))
1591             {
1592                 hr = HRESULT_FROM_WIN32(GetLastError());
1593                 break;
1594             }
1595         }
1596     }
1597     else
1598         hr = HRESULT_FROM_WIN32(GetLastError());
1599
1600     if (idx != 0xffff)
1601         ITask_DeleteTrigger(&This->ITask_iface, idx);
1602
1603     return hr;
1604 }
1605
1606 static BOOL write_unicode_string(HANDLE hfile, const WCHAR *str)
1607 {
1608     USHORT count;
1609     DWORD size;
1610
1611     count = str ? (lstrlenW(str) + 1) : 0;
1612     if (!WriteFile(hfile, &count, sizeof(count), &size, NULL))
1613         return FALSE;
1614
1615     if (!str) return TRUE;
1616
1617     count *= sizeof(WCHAR);
1618     return WriteFile(hfile, str, count, &size, NULL);
1619 }
1620
1621 static HRESULT WINAPI MSTASK_IPersistFile_Save(IPersistFile *iface, LPCOLESTR task_name, BOOL remember)
1622 {
1623     static WCHAR authorW[] = L"Wine";
1624     static WCHAR commentW[] = L"Created by Wine";
1625     FIXDLEN_DATA fixed;
1626     WORD word, user_data_size = 0;
1627     HANDLE hfile;
1628     DWORD size, ver, disposition, try;
1629     TaskImpl *This = impl_from_IPersistFile(iface);
1630     ITask *task = &This->ITask_iface;
1631     LPWSTR appname = NULL, params = NULL, workdir = NULL, creator = NULL, comment = NULL;
1632     BYTE *user_data = NULL;
1633     HRESULT hr;
1634
1635     TRACE("(%p, %s, %d)\n", iface, debugstr_w(task_name), remember);
1636
1637     disposition = task_name ? CREATE_NEW : OPEN_ALWAYS;
1638
1639     if (!task_name)
1640     {
1641         task_name = This->task_name;
1642         remember = FALSE;
1643     }
1644
1645     ITask_GetComment(task, &comment);
1646     if (!comment) comment = commentW;
1647     ITask_GetCreator(task, &creator);
1648     if (!creator) creator = authorW;
1649     ITask_GetApplicationName(task, &appname);
1650     ITask_GetParameters(task, &params);
1651     ITask_GetWorkingDirectory(task, &workdir);
1652     ITask_GetWorkItemData(task, &user_data_size, &user_data);
1653
1654     ver = GetVersion();
1655     fixed.product_version = MAKEWORD(ver >> 8, ver);
1656     fixed.file_version = 0x0001;
1657     fixed.name_size_offset = sizeof(fixed) + sizeof(USHORT); /* FIXDLEN_DATA + Instance Count */
1658     fixed.trigger_offset = sizeof(fixed) + sizeof(USHORT); /* FIXDLEN_DATA + Instance Count */
1659     fixed.trigger_offset += sizeof(USHORT); /* Application Name */
1660     if (appname)
1661         fixed.trigger_offset += (lstrlenW(appname) + 1) * sizeof(WCHAR);
1662     fixed.trigger_offset += sizeof(USHORT); /* Parameters */
1663     if (params)
1664         fixed.trigger_offset += (lstrlenW(params) + 1) * sizeof(WCHAR);
1665     fixed.trigger_offset += sizeof(USHORT); /* Working Directory */
1666     if (workdir)
1667         fixed.trigger_offset += (lstrlenW(workdir) + 1) * sizeof(WCHAR);
1668     fixed.trigger_offset += sizeof(USHORT); /* Author */
1669     if (creator)
1670         fixed.trigger_offset += (lstrlenW(creator) + 1) * sizeof(WCHAR);
1671     fixed.trigger_offset += sizeof(USHORT); /* Comment */
1672     if (comment)
1673         fixed.trigger_offset += (lstrlenW(comment) + 1) * sizeof(WCHAR);
1674     fixed.trigger_offset += sizeof(USHORT) + user_data_size; /* User Data */
1675     fixed.trigger_offset += 10; /* Reserved Data */
1676
1677     fixed.error_retry_count = 0;
1678     fixed.error_retry_interval = 0;
1679     fixed.idle_wait = This->idle_minutes;
1680     fixed.idle_deadline = This->deadline_minutes;
1681     fixed.priority = This->priority;
1682     fixed.maximum_runtime = This->maxRunTime;
1683     fixed.exit_code = This->exit_code;
1684     if (This->status == SCHED_S_TASK_NOT_SCHEDULED && This->trigger_count)
1685         This->status = SCHED_S_TASK_HAS_NOT_RUN;
1686     fixed.status = This->status;
1687     fixed.flags = This->flags;
1688     fixed.last_runtime = This->last_runtime;
1689
1690     try = 1;
1691     for (;;)
1692     {
1693         hfile = CreateFileW(task_name, GENERIC_READ | GENERIC_WRITE, 0, NULL, disposition, 0, 0);
1694         if (hfile != INVALID_HANDLE_VALUE) break;
1695
1696         if (try++ >= 3)
1697         {
1698             hr = HRESULT_FROM_WIN32(GetLastError());
1699             goto failed;
1700         }
1701         Sleep(100);
1702     }
1703
1704     if (GetLastError() == ERROR_ALREADY_EXISTS)
1705         fixed.uuid = This->uuid;
1706     else
1707         CoCreateGuid(&fixed.uuid);
1708
1709     if (!WriteFile(hfile, &fixed, sizeof(fixed), &size, NULL))
1710     {
1711         hr = HRESULT_FROM_WIN32(GetLastError());
1712         goto failed;
1713     }
1714
1715     /* Instance Count: don't touch it in the client */
1716     if (SetFilePointer(hfile, sizeof(word), NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER)
1717     {
1718         hr = HRESULT_FROM_WIN32(GetLastError());
1719         goto failed;
1720     }
1721     /* Application Name */
1722     if (!write_unicode_string(hfile, appname))
1723     {
1724         hr = HRESULT_FROM_WIN32(GetLastError());
1725         goto failed;
1726     }
1727     /* Parameters */
1728     if (!write_unicode_string(hfile, params))
1729     {
1730         hr = HRESULT_FROM_WIN32(GetLastError());
1731         goto failed;
1732     }
1733     /* Working Directory */
1734     if (!write_unicode_string(hfile, workdir))
1735     {
1736         hr = HRESULT_FROM_WIN32(GetLastError());
1737         goto failed;
1738     }
1739     /* Author */
1740     if (!write_unicode_string(hfile, creator))
1741     {
1742         hr = HRESULT_FROM_WIN32(GetLastError());
1743         goto failed;
1744     }
1745     /* Comment */
1746     if (!write_unicode_string(hfile, comment))
1747     {
1748         hr = HRESULT_FROM_WIN32(GetLastError());
1749         goto failed;
1750     }
1751
1752     /* User Data */
1753     if (!write_user_data(hfile, user_data, user_data_size))
1754     {
1755         hr = HRESULT_FROM_WIN32(GetLastError());
1756         goto failed;
1757     }
1758
1759     /* Reserved Data */
1760     if (!write_reserved_data(hfile))
1761     {
1762         hr = HRESULT_FROM_WIN32(GetLastError());
1763         goto failed;
1764     }
1765
1766     /* Triggers */
1767     hr = write_triggers(This, hfile);
1768     if (hr != S_OK)
1769         goto failed;
1770
1771     /* Signature */
1772     if (!write_signature(hfile))
1773     {
1774         hr = HRESULT_FROM_WIN32(GetLastError());
1775         goto failed;
1776     }
1777
1778     hr = S_OK;
1779     This->is_dirty = FALSE;
1780
1781 failed:
1782     CoTaskMemFree(appname);
1783     CoTaskMemFree(params);
1784     CoTaskMemFree(workdir);
1785     if (creator != authorW)
1786         CoTaskMemFree(creator);
1787     if (comment != commentW)
1788         CoTaskMemFree(comment);
1789     CoTaskMemFree(user_data);
1790
1791     if (hfile != INVALID_HANDLE_VALUE)
1792     {
1793         CloseHandle(hfile);
1794         if (hr != S_OK)
1795             DeleteFileW(task_name);
1796         else if (remember)
1797         {
1798             free(This->task_name);
1799             This->task_name = wcsdup(task_name);
1800         }
1801     }
1802     return hr;
1803 }
1804
1805 static HRESULT WINAPI MSTASK_IPersistFile_SaveCompleted(
1806         IPersistFile* iface,
1807         LPCOLESTR pszFileName)
1808 {
1809     FIXME("(%p, %p): stub\n", iface, pszFileName);
1810     return E_NOTIMPL;
1811 }
1812
1813 static HRESULT WINAPI MSTASK_IPersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *file_name)
1814 {
1815     TaskImpl *This = impl_from_IPersistFile(iface);
1816
1817     TRACE("(%p, %p)\n", iface, file_name);
1818
1819     *file_name = CoTaskMemAlloc((lstrlenW(This->task_name) + 1) * sizeof(WCHAR));
1820     if (!*file_name) return E_OUTOFMEMORY;
1821
1822     lstrcpyW(*file_name, This->task_name);
1823     return S_OK;
1824 }
1825
1826 static const ITaskVtbl MSTASK_ITaskVtbl =
1827 {
1828     MSTASK_ITask_QueryInterface,
1829     MSTASK_ITask_AddRef,
1830     MSTASK_ITask_Release,
1831     MSTASK_ITask_CreateTrigger,
1832     MSTASK_ITask_DeleteTrigger,
1833     MSTASK_ITask_GetTriggerCount,
1834     MSTASK_ITask_GetTrigger,
1835     MSTASK_ITask_GetTriggerString,
1836     MSTASK_ITask_GetRunTimes,
1837     MSTASK_ITask_GetNextRunTime,
1838     MSTASK_ITask_SetIdleWait,
1839     MSTASK_ITask_GetIdleWait,
1840     MSTASK_ITask_Run,
1841     MSTASK_ITask_Terminate,
1842     MSTASK_ITask_EditWorkItem,
1843     MSTASK_ITask_GetMostRecentRunTime,
1844     MSTASK_ITask_GetStatus,
1845     MSTASK_ITask_GetExitCode,
1846     MSTASK_ITask_SetComment,
1847     MSTASK_ITask_GetComment,
1848     MSTASK_ITask_SetCreator,
1849     MSTASK_ITask_GetCreator,
1850     MSTASK_ITask_SetWorkItemData,
1851     MSTASK_ITask_GetWorkItemData,
1852     MSTASK_ITask_SetErrorRetryCount,
1853     MSTASK_ITask_GetErrorRetryCount,
1854     MSTASK_ITask_SetErrorRetryInterval,
1855     MSTASK_ITask_GetErrorRetryInterval,
1856     MSTASK_ITask_SetFlags,
1857     MSTASK_ITask_GetFlags,
1858     MSTASK_ITask_SetAccountInformation,
1859     MSTASK_ITask_GetAccountInformation,
1860     MSTASK_ITask_SetApplicationName,
1861     MSTASK_ITask_GetApplicationName,
1862     MSTASK_ITask_SetParameters,
1863     MSTASK_ITask_GetParameters,
1864     MSTASK_ITask_SetWorkingDirectory,
1865     MSTASK_ITask_GetWorkingDirectory,
1866     MSTASK_ITask_SetPriority,
1867     MSTASK_ITask_GetPriority,
1868     MSTASK_ITask_SetTaskFlags,
1869     MSTASK_ITask_GetTaskFlags,
1870     MSTASK_ITask_SetMaxRunTime,
1871     MSTASK_ITask_GetMaxRunTime
1872 };
1873
1874 static const IPersistFileVtbl MSTASK_IPersistFileVtbl =
1875 {
1876     MSTASK_IPersistFile_QueryInterface,
1877     MSTASK_IPersistFile_AddRef,
1878     MSTASK_IPersistFile_Release,
1879     MSTASK_IPersistFile_GetClassID,
1880     MSTASK_IPersistFile_IsDirty,
1881     MSTASK_IPersistFile_Load,
1882     MSTASK_IPersistFile_Save,
1883     MSTASK_IPersistFile_SaveCompleted,
1884     MSTASK_IPersistFile_GetCurFile
1885 };
1886
1887 HRESULT TaskConstructor(ITaskService *service, const WCHAR *name, ITask **task)
1888 {
1889     TaskImpl *This;
1890     WCHAR task_name[MAX_PATH];
1891     ITaskDefinition *taskdef;
1892     IActionCollection *actions;
1893     HRESULT hr;
1894
1895     TRACE("(%s, %p)\n", debugstr_w(name), task);
1896
1897     if (wcschr(name, '.')) return E_INVALIDARG;
1898
1899     GetWindowsDirectoryW(task_name, MAX_PATH);
1900     lstrcatW(task_name, L"\\Tasks\\");
1901     lstrcatW(task_name, name);
1902     lstrcatW(task_name, L".job");
1903
1904     hr = ITaskService_NewTask(service, 0, &taskdef);
1905     if (hr != S_OK) return hr;
1906
1907     This = malloc(sizeof(*This));
1908     if (!This)
1909     {
1910         ITaskDefinition_Release(taskdef);
1911         return E_OUTOFMEMORY;
1912     }
1913
1914     This->ITask_iface.lpVtbl = &MSTASK_ITaskVtbl;
1915     This->IPersistFile_iface.lpVtbl = &MSTASK_IPersistFileVtbl;
1916     This->ref = 1;
1917     This->task = taskdef;
1918     This->data = NULL;
1919     This->data_count = 0;
1920     This->task_name = wcsdup(task_name);
1921     This->flags = 0;
1922     This->status = SCHED_S_TASK_NOT_SCHEDULED;
1923     This->exit_code = 0;
1924     This->idle_minutes = 10;
1925     This->deadline_minutes = 60;
1926     This->priority = NORMAL_PRIORITY_CLASS;
1927     This->accountName = NULL;
1928     This->trigger_count = 0;
1929     This->trigger = NULL;
1930     This->is_dirty = FALSE;
1931     This->instance_count = 0;
1932
1933     memset(&This->last_runtime, 0, sizeof(This->last_runtime));
1934     CoCreateGuid(&This->uuid);
1935
1936     /* Default time is 3 days = 259200000 ms */
1937     This->maxRunTime = 259200000;
1938
1939     hr = ITaskDefinition_get_Actions(This->task, &actions);
1940     if (hr == S_OK)
1941     {
1942         hr = IActionCollection_Create(actions, TASK_ACTION_EXEC, (IAction **)&This->action);
1943         IActionCollection_Release(actions);
1944         if (hr == S_OK)
1945         {
1946             *task = &This->ITask_iface;
1947             InterlockedIncrement(&dll_ref);
1948             return S_OK;
1949         }
1950     }
1951
1952     ITaskDefinition_Release(This->task);
1953     ITask_Release(&This->ITask_iface);
1954     return hr;
1955 }