dlls/taskschd/task.c

   1 /*
   2  * Copyright 2013 Dmitry Timoshkov
   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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "initguid.h"
  26 #include "objbase.h"
  27 #include "xmllite.h"
  28 #include "taskschd.h"
  29 #include "winsvc.h"
  30 #include "schrpc.h"
  31 #include "taskschd_private.h"
  32
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(taskschd);
  37
  38 typedef struct {
  39     IDailyTrigger IDailyTrigger_iface;
  40     LONG ref;
  41     short interval;
  42     WCHAR *start_boundary;
  43     BOOL enabled;
  44 } DailyTrigger;
  45
  46 static inline DailyTrigger *impl_from_IDailyTrigger(IDailyTrigger *iface)
  47 {
  48     return CONTAINING_RECORD(iface, DailyTrigger, IDailyTrigger_iface);
  49 }
  50
  51 static HRESULT WINAPI DailyTrigger_QueryInterface(IDailyTrigger *iface, REFIID riid, void **ppv)
  52 {
  53     DailyTrigger *This = impl_from_IDailyTrigger(iface);
  54
  55     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
  56
  57     if(IsEqualGUID(&IID_IUnknown, riid) ||
  58        IsEqualGUID(&IID_IDispatch, riid) ||
  59        IsEqualGUID(&IID_ITrigger, riid) ||
  60        IsEqualGUID(&IID_IDailyTrigger, riid))
  61     {
  62         *ppv = &This->IDailyTrigger_iface;
  63     }
  64     else
  65     {
  66         FIXME("unsupported riid %s\n", debugstr_guid(riid));
  67         *ppv = NULL;
  68         return E_NOINTERFACE;
  69     }
  70
  71     IUnknown_AddRef((IUnknown*)*ppv);
  72     return S_OK;
  73 }
  74
  75 static ULONG WINAPI DailyTrigger_AddRef(IDailyTrigger *iface)
  76 {
  77     DailyTrigger *This = impl_from_IDailyTrigger(iface);
  78     LONG ref = InterlockedIncrement(&This->ref);
  79
  80     TRACE("(%p) ref=%d\n", This, ref);
  81
  82     return ref;
  83 }
  84
  85 static ULONG WINAPI DailyTrigger_Release(IDailyTrigger *iface)
  86 {
  87     DailyTrigger *This = impl_from_IDailyTrigger(iface);
  88     LONG ref = InterlockedDecrement(&This->ref);
  89
  90     TRACE("(%p) ref=%d\n", This, ref);
  91
  92     if(!ref)
  93     {
  94         TRACE("destroying %p\n", iface);
  95         heap_free(This->start_boundary);
  96         heap_free(This);
  97     }
  98
  99     return ref;
 100 }
 101
 102 static HRESULT WINAPI DailyTrigger_GetTypeInfoCount(IDailyTrigger *iface, UINT *count)
 103 {
 104     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 105     FIXME("(%p)->(%p)\n", This, count);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI DailyTrigger_GetTypeInfo(IDailyTrigger *iface, UINT index, LCID lcid, ITypeInfo **info)
 110 {
 111     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 112     FIXME("(%p)->(%u %u %p)\n", This, index, lcid, info);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI DailyTrigger_GetIDsOfNames(IDailyTrigger *iface, REFIID riid, LPOLESTR *names,
 117                                             UINT count, LCID lcid, DISPID *dispid)
 118 {
 119     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 120     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), names, count, lcid, dispid);
 121     return E_NOTIMPL;
 122 }
 123
 124 static HRESULT WINAPI DailyTrigger_Invoke(IDailyTrigger *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 125                                      DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 126 {
 127     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 128     FIXME("(%p)->(%d %s %x %x %p %p %p %p)\n", This, dispid, debugstr_guid(riid), lcid, flags,
 129           params, result, excepinfo, argerr);
 130     return E_NOTIMPL;
 131 }
 132
 133 static HRESULT WINAPI DailyTrigger_get_Type(IDailyTrigger *iface, TASK_TRIGGER_TYPE2 *type)
 134 {
 135     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 136     FIXME("(%p)->(%p)\n", This, type);
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI DailyTrigger_get_Id(IDailyTrigger *iface, BSTR *id)
 141 {
 142     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 143     FIXME("(%p)->(%p)\n", This, id);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI DailyTrigger_put_Id(IDailyTrigger *iface, BSTR id)
 148 {
 149     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 150     FIXME("(%p)->(%s)\n", This, debugstr_w(id));
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI DailyTrigger_get_Repetition(IDailyTrigger *iface, IRepetitionPattern **repeat)
 155 {
 156     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 157     FIXME("(%p)->(%p)\n", This, repeat);
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI DailyTrigger_put_Repetition(IDailyTrigger *iface, IRepetitionPattern *repeat)
 162 {
 163     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 164     FIXME("(%p)->(%p)\n", This, repeat);
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI DailyTrigger_get_ExecutionTimeLimit(IDailyTrigger *iface, BSTR *limit)
 169 {
 170     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 171     FIXME("(%p)->(%p)\n", This, limit);
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI DailyTrigger_put_ExecutionTimeLimit(IDailyTrigger *iface, BSTR limit)
 176 {
 177     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 178     FIXME("(%p)->(%s)\n", This, debugstr_w(limit));
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI DailyTrigger_get_StartBoundary(IDailyTrigger *iface, BSTR *start)
 183 {
 184     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 185
 186     TRACE("(%p)->(%p)\n", This, start);
 187
 188     if (!start) return E_POINTER;
 189
 190     if (!This->start_boundary) *start = NULL;
 191     else if (!(*start = SysAllocString(This->start_boundary))) return E_OUTOFMEMORY;
 192
 193     return S_OK;
 194 }
 195
 196 static HRESULT WINAPI DailyTrigger_put_StartBoundary(IDailyTrigger *iface, BSTR start)
 197 {
 198     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 199     WCHAR *str = NULL;
 200
 201     TRACE("(%p)->(%s)\n", This, debugstr_w(start));
 202
 203     if (start && !(str = heap_strdupW(start))) return E_OUTOFMEMORY;
 204     heap_free(This->start_boundary);
 205     This->start_boundary = str;
 206
 207     return S_OK;
 208 }
 209
 210 static HRESULT WINAPI DailyTrigger_get_EndBoundary(IDailyTrigger *iface, BSTR *end)
 211 {
 212     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 213     FIXME("(%p)->(%p)\n", This, end);
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI DailyTrigger_put_EndBoundary(IDailyTrigger *iface, BSTR end)
 218 {
 219     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 220     FIXME("(%p)->(%s)\n", This, debugstr_w(end));
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI DailyTrigger_get_Enabled(IDailyTrigger *iface, VARIANT_BOOL *enabled)
 225 {
 226     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 227
 228     TRACE("(%p)->(%p)\n", This, enabled);
 229
 230     if (!enabled) return E_POINTER;
 231
 232     *enabled = This->enabled ? VARIANT_TRUE : VARIANT_FALSE;
 233     return S_OK;
 234 }
 235
 236 static HRESULT WINAPI DailyTrigger_put_Enabled(IDailyTrigger *iface, VARIANT_BOOL enabled)
 237 {
 238     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 239
 240     TRACE("(%p)->(%x)\n", This, enabled);
 241
 242     This->enabled = enabled ? TRUE : FALSE;
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI DailyTrigger_get_DaysInterval(IDailyTrigger *iface, short *days)
 247 {
 248     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 249
 250     TRACE("(%p)->(%p)\n", This, days);
 251
 252     *days = This->interval;
 253     return S_OK;
 254 }
 255
 256 static HRESULT WINAPI DailyTrigger_put_DaysInterval(IDailyTrigger *iface, short days)
 257 {
 258     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 259
 260     TRACE("(%p)->(%d)\n", This, days);
 261
 262     if(days <= 0)
 263         return E_INVALIDARG;
 264
 265     This->interval = days;
 266     return S_OK;
 267 }
 268
 269 static HRESULT WINAPI DailyTrigger_get_RandomDelay(IDailyTrigger *iface, BSTR *pRandomDelay)
 270 {
 271     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 272     FIXME("(%p)->(%p)\n", This, pRandomDelay);
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI DailyTrigger_put_RandomDelay(IDailyTrigger *iface, BSTR randomDelay)
 277 {
 278     DailyTrigger *This = impl_from_IDailyTrigger(iface);
 279     FIXME("(%p)->(%s)\n", This, debugstr_w(randomDelay));
 280     return E_NOTIMPL;
 281 }
 282
 283 static const IDailyTriggerVtbl DailyTrigger_vtbl = {
 284     DailyTrigger_QueryInterface,
 285     DailyTrigger_AddRef,
 286     DailyTrigger_Release,
 287     DailyTrigger_GetTypeInfoCount,
 288     DailyTrigger_GetTypeInfo,
 289     DailyTrigger_GetIDsOfNames,
 290     DailyTrigger_Invoke,
 291     DailyTrigger_get_Type,
 292     DailyTrigger_get_Id,
 293     DailyTrigger_put_Id,
 294     DailyTrigger_get_Repetition,
 295     DailyTrigger_put_Repetition,
 296     DailyTrigger_get_ExecutionTimeLimit,
 297     DailyTrigger_put_ExecutionTimeLimit,
 298     DailyTrigger_get_StartBoundary,
 299     DailyTrigger_put_StartBoundary,
 300     DailyTrigger_get_EndBoundary,
 301     DailyTrigger_put_EndBoundary,
 302     DailyTrigger_get_Enabled,
 303     DailyTrigger_put_Enabled,
 304     DailyTrigger_get_DaysInterval,
 305     DailyTrigger_put_DaysInterval,
 306     DailyTrigger_get_RandomDelay,
 307     DailyTrigger_put_RandomDelay
 308 };
 309
 310 static HRESULT DailyTrigger_create(ITrigger **trigger)
 311 {
 312     DailyTrigger *daily_trigger;
 313
 314     daily_trigger = heap_alloc(sizeof(*daily_trigger));
 315     if (!daily_trigger)
 316         return E_OUTOFMEMORY;
 317
 318     daily_trigger->IDailyTrigger_iface.lpVtbl = &DailyTrigger_vtbl;
 319     daily_trigger->ref = 1;
 320     daily_trigger->interval = 1;
 321     daily_trigger->start_boundary = NULL;
 322     daily_trigger->enabled = TRUE;
 323
 324     *trigger = (ITrigger*)&daily_trigger->IDailyTrigger_iface;
 325     return S_OK;
 326 }
 327
 328 typedef struct
 329 {
 330     ITriggerCollection ITriggerCollection_iface;
 331     LONG ref;
 332 } trigger_collection;
 333
 334 static inline trigger_collection *impl_from_ITriggerCollection(ITriggerCollection *iface)
 335 {
 336     return CONTAINING_RECORD(iface, trigger_collection, ITriggerCollection_iface);
 337 }
 338
 339 static HRESULT WINAPI TriggerCollection_QueryInterface(ITriggerCollection *iface, REFIID riid, void **ppv)
 340 {
 341     trigger_collection *This = impl_from_ITriggerCollection(iface);
 342
 343     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 344
 345     if(IsEqualGUID(&IID_IUnknown, riid) ||
 346        IsEqualGUID(&IID_IDispatch, riid) ||
 347        IsEqualGUID(&IID_ITriggerCollection, riid)) {
 348         *ppv = &This->ITriggerCollection_iface;
 349     }else {
 350         FIXME("unimplemented interface %s\n", debugstr_guid(riid));
 351         *ppv = NULL;
 352         return E_NOINTERFACE;
 353     }
 354
 355     IUnknown_AddRef((IUnknown*)*ppv);
 356     return S_OK;
 357 }
 358
 359 static ULONG WINAPI TriggerCollection_AddRef(ITriggerCollection *iface)
 360 {
 361     trigger_collection *This = impl_from_ITriggerCollection(iface);
 362     LONG ref = InterlockedIncrement(&This->ref);
 363
 364     TRACE("(%p) ref=%d\n", This, ref);
 365
 366     return ref;
 367 }
 368
 369 static ULONG WINAPI TriggerCollection_Release(ITriggerCollection *iface)
 370 {
 371     trigger_collection *This = impl_from_ITriggerCollection(iface);
 372     LONG ref = InterlockedDecrement(&This->ref);
 373
 374     TRACE("(%p) ref=%d\n", This, ref);
 375
 376     if(!ref)
 377         heap_free(This);
 378
 379     return ref;
 380 }
 381
 382 static HRESULT WINAPI TriggerCollection_GetTypeInfoCount(ITriggerCollection *iface, UINT *count)
 383 {
 384     trigger_collection *This = impl_from_ITriggerCollection(iface);
 385     FIXME("(%p)->(%p)\n", This, count);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI TriggerCollection_GetTypeInfo(ITriggerCollection *iface, UINT index, LCID lcid, ITypeInfo **info)
 390 {
 391     trigger_collection *This = impl_from_ITriggerCollection(iface);
 392     FIXME("(%p)->(%u %u %p)\n", This, index, lcid, info);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI TriggerCollection_GetIDsOfNames(ITriggerCollection *iface, REFIID riid, LPOLESTR *names,
 397                                                    UINT count, LCID lcid, DISPID *dispid)
 398 {
 399     trigger_collection *This = impl_from_ITriggerCollection(iface);
 400     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), names, count, lcid, dispid);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI TriggerCollection_Invoke(ITriggerCollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 405                                                DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 406 {
 407     trigger_collection *This = impl_from_ITriggerCollection(iface);
 408     FIXME("(%p)->(%d %s %x %x %p %p %p %p)\n", This, dispid, debugstr_guid(riid), lcid, flags,
 409           params, result, excepinfo, argerr);
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI TriggerCollection_get_Count(ITriggerCollection *iface, LONG *count)
 414 {
 415     trigger_collection *This = impl_from_ITriggerCollection(iface);
 416     FIXME("(%p)->(%p)\n", This, count);
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI TriggerCollection_get_Item(ITriggerCollection *iface, LONG index, ITrigger **trigger)
 421 {
 422     trigger_collection *This = impl_from_ITriggerCollection(iface);
 423     FIXME("(%p)->(%d %p)\n", This, index, trigger);
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI TriggerCollection_get__NewEnum(ITriggerCollection *iface, IUnknown **penum)
 428 {
 429     trigger_collection *This = impl_from_ITriggerCollection(iface);
 430     FIXME("(%p)->(%p)\n", This, penum);
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI TriggerCollection_Create(ITriggerCollection *iface, TASK_TRIGGER_TYPE2 type, ITrigger **trigger)
 435 {
 436     trigger_collection *This = impl_from_ITriggerCollection(iface);
 437
 438     TRACE("(%p)->(%d %p)\n", This, type, trigger);
 439
 440     switch(type) {
 441     case TASK_TRIGGER_DAILY:
 442         return DailyTrigger_create(trigger);
 443     default:
 444         FIXME("Unimplemented type %d\n", type);
 445         return E_NOTIMPL;
 446     }
 447
 448     return S_OK;
 449 }
 450
 451 static HRESULT WINAPI TriggerCollection_Remove(ITriggerCollection *iface, VARIANT index)
 452 {
 453     trigger_collection *This = impl_from_ITriggerCollection(iface);
 454     FIXME("(%p)->(%s)\n", This, debugstr_variant(&index));
 455     return E_NOTIMPL;
 456 }
 457
 458 static HRESULT WINAPI TriggerCollection_Clear(ITriggerCollection *iface)
 459 {
 460     trigger_collection *This = impl_from_ITriggerCollection(iface);
 461     FIXME("(%p)\n", This);
 462     return E_NOTIMPL;
 463 }
 464
 465 static const ITriggerCollectionVtbl TriggerCollection_vtbl = {
 466     TriggerCollection_QueryInterface,
 467     TriggerCollection_AddRef,
 468     TriggerCollection_Release,
 469     TriggerCollection_GetTypeInfoCount,
 470     TriggerCollection_GetTypeInfo,
 471     TriggerCollection_GetIDsOfNames,
 472     TriggerCollection_Invoke,
 473     TriggerCollection_get_Count,
 474     TriggerCollection_get_Item,
 475     TriggerCollection_get__NewEnum,
 476     TriggerCollection_Create,
 477     TriggerCollection_Remove,
 478     TriggerCollection_Clear
 479 };
 480
 481 typedef struct
 482 {
 483     IRegistrationInfo IRegistrationInfo_iface;
 484     LONG ref;
 485     WCHAR *description, *author, *version, *date, *documentation, *uri, *source;
 486 } registration_info;
 487
 488 static inline registration_info *impl_from_IRegistrationInfo(IRegistrationInfo *iface)
 489 {
 490     return CONTAINING_RECORD(iface, registration_info, IRegistrationInfo_iface);
 491 }
 492
 493 static ULONG WINAPI RegistrationInfo_AddRef(IRegistrationInfo *iface)
 494 {
 495     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 496     return InterlockedIncrement(&reginfo->ref);
 497 }
 498
 499 static ULONG WINAPI RegistrationInfo_Release(IRegistrationInfo *iface)
 500 {
 501     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 502     LONG ref = InterlockedDecrement(&reginfo->ref);
 503
 504     if (!ref)
 505     {
 506         TRACE("destroying %p\n", iface);
 507         heap_free(reginfo->description);
 508         heap_free(reginfo->author);
 509         heap_free(reginfo->version);
 510         heap_free(reginfo->date);
 511         heap_free(reginfo->documentation);
 512         heap_free(reginfo->uri);
 513         heap_free(reginfo->source);
 514         heap_free(reginfo);
 515     }
 516
 517     return ref;
 518 }
 519
 520 static HRESULT WINAPI RegistrationInfo_QueryInterface(IRegistrationInfo *iface, REFIID riid, void **obj)
 521 {
 522     if (!riid || !obj) return E_INVALIDARG;
 523
 524     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 525
 526     if (IsEqualGUID(riid, &IID_IRegistrationInfo) ||
 527         IsEqualGUID(riid, &IID_IDispatch) ||
 528         IsEqualGUID(riid, &IID_IUnknown))
 529     {
 530         IRegistrationInfo_AddRef(iface);
 531         *obj = iface;
 532         return S_OK;
 533     }
 534
 535     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 536     *obj = NULL;
 537     return E_NOINTERFACE;
 538 }
 539
 540 static HRESULT WINAPI RegistrationInfo_GetTypeInfoCount(IRegistrationInfo *iface, UINT *count)
 541 {
 542     FIXME("%p,%p: stub\n", iface, count);
 543     return E_NOTIMPL;
 544 }
 545
 546 static HRESULT WINAPI RegistrationInfo_GetTypeInfo(IRegistrationInfo *iface, UINT index, LCID lcid, ITypeInfo **info)
 547 {
 548     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI RegistrationInfo_GetIDsOfNames(IRegistrationInfo *iface, REFIID riid, LPOLESTR *names,
 553                                                    UINT count, LCID lcid, DISPID *dispid)
 554 {
 555     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI RegistrationInfo_Invoke(IRegistrationInfo *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 560                                             DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 561 {
 562     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 563           params, result, excepinfo, argerr);
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI RegistrationInfo_get_Description(IRegistrationInfo *iface, BSTR *description)
 568 {
 569     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 570
 571     TRACE("%p,%p\n", iface, description);
 572
 573     if (!description) return E_POINTER;
 574
 575     if (!reginfo->description) *description = NULL;
 576     else if (!(*description = SysAllocString(reginfo->description))) return E_OUTOFMEMORY;
 577
 578     return S_OK;
 579 }
 580
 581 static HRESULT WINAPI RegistrationInfo_put_Description(IRegistrationInfo *iface, BSTR description)
 582 {
 583     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 584     WCHAR *str = NULL;
 585
 586     TRACE("%p,%s\n", iface, debugstr_w(description));
 587
 588     if (description && !(str = heap_strdupW(description))) return E_OUTOFMEMORY;
 589     heap_free(reginfo->description);
 590     reginfo->description = str;
 591     return S_OK;
 592 }
 593
 594 static HRESULT WINAPI RegistrationInfo_get_Author(IRegistrationInfo *iface, BSTR *author)
 595 {
 596     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 597
 598     TRACE("%p,%p\n", iface, author);
 599
 600     if (!author) return E_POINTER;
 601
 602     if (!reginfo->author) *author = NULL;
 603     else if (!(*author = SysAllocString(reginfo->author))) return E_OUTOFMEMORY;
 604
 605     return S_OK;
 606 }
 607
 608 static HRESULT WINAPI RegistrationInfo_put_Author(IRegistrationInfo *iface, BSTR author)
 609 {
 610     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 611     WCHAR *str = NULL;
 612
 613     TRACE("%p,%s\n", iface, debugstr_w(author));
 614
 615     if (author && !(str = heap_strdupW(author))) return E_OUTOFMEMORY;
 616     heap_free(reginfo->author);
 617     reginfo->author = str;
 618     return S_OK;
 619 }
 620
 621 static HRESULT WINAPI RegistrationInfo_get_Version(IRegistrationInfo *iface, BSTR *version)
 622 {
 623     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 624
 625     TRACE("%p,%p\n", iface, version);
 626
 627     if (!version) return E_POINTER;
 628
 629     if (!reginfo->version) *version = NULL;
 630     else if (!(*version = SysAllocString(reginfo->version))) return E_OUTOFMEMORY;
 631
 632     return S_OK;
 633 }
 634
 635 static HRESULT WINAPI RegistrationInfo_put_Version(IRegistrationInfo *iface, BSTR version)
 636 {
 637     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 638     WCHAR *str = NULL;
 639
 640     TRACE("%p,%s\n", iface, debugstr_w(version));
 641
 642     if (version && !(str = heap_strdupW(version))) return E_OUTOFMEMORY;
 643     heap_free(reginfo->version);
 644     reginfo->version = str;
 645     return S_OK;
 646 }
 647
 648 static HRESULT WINAPI RegistrationInfo_get_Date(IRegistrationInfo *iface, BSTR *date)
 649 {
 650     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 651
 652     TRACE("%p,%p\n", iface, date);
 653
 654     if (!date) return E_POINTER;
 655
 656     if (!reginfo->date) *date = NULL;
 657     else if (!(*date = SysAllocString(reginfo->date))) return E_OUTOFMEMORY;
 658
 659     return S_OK;
 660 }
 661
 662 static HRESULT WINAPI RegistrationInfo_put_Date(IRegistrationInfo *iface, BSTR date)
 663 {
 664     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 665     WCHAR *str = NULL;
 666
 667     TRACE("%p,%s\n", iface, debugstr_w(date));
 668
 669     if (date && !(str = heap_strdupW(date))) return E_OUTOFMEMORY;
 670     heap_free(reginfo->date);
 671     reginfo->date = str;
 672     return S_OK;
 673 }
 674
 675 static HRESULT WINAPI RegistrationInfo_get_Documentation(IRegistrationInfo *iface, BSTR *doc)
 676 {
 677     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 678
 679     TRACE("%p,%p\n", iface, doc);
 680
 681     if (!doc) return E_POINTER;
 682
 683     if (!reginfo->documentation) *doc = NULL;
 684     else if (!(*doc = SysAllocString(reginfo->documentation))) return E_OUTOFMEMORY;
 685
 686     return S_OK;
 687 }
 688
 689 static HRESULT WINAPI RegistrationInfo_put_Documentation(IRegistrationInfo *iface, BSTR doc)
 690 {
 691     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 692     WCHAR *str = NULL;
 693
 694     TRACE("%p,%s\n", iface, debugstr_w(doc));
 695
 696     if (doc && !(str = heap_strdupW(doc))) return E_OUTOFMEMORY;
 697     heap_free(reginfo->documentation);
 698     reginfo->documentation = str;
 699     return S_OK;
 700 }
 701
 702 static HRESULT WINAPI RegistrationInfo_get_XmlText(IRegistrationInfo *iface, BSTR *xml)
 703 {
 704     FIXME("%p,%p: stub\n", iface, xml);
 705     return E_NOTIMPL;
 706 }
 707
 708 static HRESULT WINAPI RegistrationInfo_put_XmlText(IRegistrationInfo *iface, BSTR xml)
 709 {
 710     FIXME("%p,%s: stub\n", iface, debugstr_w(xml));
 711     return E_NOTIMPL;
 712 }
 713
 714 static HRESULT WINAPI RegistrationInfo_get_URI(IRegistrationInfo *iface, BSTR *uri)
 715 {
 716     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 717
 718     TRACE("%p,%p\n", iface, uri);
 719
 720     if (!uri) return E_POINTER;
 721
 722     if (!reginfo->uri) *uri = NULL;
 723     else if (!(*uri = SysAllocString(reginfo->uri))) return E_OUTOFMEMORY;
 724
 725     return S_OK;
 726 }
 727
 728 static HRESULT WINAPI RegistrationInfo_put_URI(IRegistrationInfo *iface, BSTR uri)
 729 {
 730     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 731
 732     TRACE("%p,%s\n", iface, debugstr_w(uri));
 733
 734     if (!uri) return E_INVALIDARG;
 735
 736     heap_free(reginfo->uri);
 737     reginfo->uri = heap_strdupW(uri);
 738     /* FIXME: update XML on the server side */
 739     return reginfo->uri ? S_OK : E_OUTOFMEMORY;
 740 }
 741
 742 static HRESULT WINAPI RegistrationInfo_get_SecurityDescriptor(IRegistrationInfo *iface, VARIANT *sddl)
 743 {
 744     FIXME("%p,%p: stub\n", iface, sddl);
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI RegistrationInfo_put_SecurityDescriptor(IRegistrationInfo *iface, VARIANT sddl)
 749 {
 750     FIXME("%p,%s: stub\n", iface, debugstr_variant(&sddl));
 751     return S_OK;
 752 }
 753
 754 static HRESULT WINAPI RegistrationInfo_get_Source(IRegistrationInfo *iface, BSTR *source)
 755 {
 756     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 757
 758     TRACE("%p,%p\n", iface, source);
 759
 760     if (!source) return E_POINTER;
 761
 762     if (!reginfo->source) *source = NULL;
 763     else if (!(*source = SysAllocString(reginfo->source))) return E_OUTOFMEMORY;
 764
 765     return S_OK;
 766 }
 767
 768 static HRESULT WINAPI RegistrationInfo_put_Source(IRegistrationInfo *iface, BSTR source)
 769 {
 770     registration_info *reginfo = impl_from_IRegistrationInfo(iface);
 771
 772     TRACE("%p,%s\n", iface, debugstr_w(source));
 773
 774     if (!source) return E_INVALIDARG;
 775
 776     heap_free(reginfo->source);
 777     reginfo->source = heap_strdupW(source);
 778     /* FIXME: update XML on the server side */
 779     return reginfo->source ? S_OK : E_OUTOFMEMORY;
 780 }
 781
 782 static const IRegistrationInfoVtbl RegistrationInfo_vtbl =
 783 {
 784     RegistrationInfo_QueryInterface,
 785     RegistrationInfo_AddRef,
 786     RegistrationInfo_Release,
 787     RegistrationInfo_GetTypeInfoCount,
 788     RegistrationInfo_GetTypeInfo,
 789     RegistrationInfo_GetIDsOfNames,
 790     RegistrationInfo_Invoke,
 791     RegistrationInfo_get_Description,
 792     RegistrationInfo_put_Description,
 793     RegistrationInfo_get_Author,
 794     RegistrationInfo_put_Author,
 795     RegistrationInfo_get_Version,
 796     RegistrationInfo_put_Version,
 797     RegistrationInfo_get_Date,
 798     RegistrationInfo_put_Date,
 799     RegistrationInfo_get_Documentation,
 800     RegistrationInfo_put_Documentation,
 801     RegistrationInfo_get_XmlText,
 802     RegistrationInfo_put_XmlText,
 803     RegistrationInfo_get_URI,
 804     RegistrationInfo_put_URI,
 805     RegistrationInfo_get_SecurityDescriptor,
 806     RegistrationInfo_put_SecurityDescriptor,
 807     RegistrationInfo_get_Source,
 808     RegistrationInfo_put_Source
 809 };
 810
 811 static HRESULT RegistrationInfo_create(IRegistrationInfo **obj)
 812 {
 813     registration_info *reginfo;
 814
 815     reginfo = heap_alloc_zero(sizeof(*reginfo));
 816     if (!reginfo) return E_OUTOFMEMORY;
 817
 818     reginfo->IRegistrationInfo_iface.lpVtbl = &RegistrationInfo_vtbl;
 819     reginfo->ref = 1;
 820     *obj = &reginfo->IRegistrationInfo_iface;
 821
 822     TRACE("created %p\n", *obj);
 823
 824     return S_OK;
 825 }
 826
 827 typedef struct
 828 {
 829     ITaskSettings ITaskSettings_iface;
 830     LONG ref;
 831     WCHAR *restart_interval;
 832     WCHAR *execution_time_limit;
 833     WCHAR *delete_expired_task_after;
 834     int restart_count;
 835     int priority;
 836     TASK_INSTANCES_POLICY policy;
 837     TASK_COMPATIBILITY compatibility;
 838     BOOL allow_on_demand_start;
 839     BOOL stop_if_going_on_batteries;
 840     BOOL disallow_start_if_on_batteries;
 841     BOOL allow_hard_terminate;
 842     BOOL start_when_available;
 843     BOOL run_only_if_network_available;
 844     BOOL enabled;
 845     BOOL hidden;
 846     BOOL run_only_if_idle;
 847     BOOL wake_to_run;
 848 } TaskSettings;
 849
 850 static inline TaskSettings *impl_from_ITaskSettings(ITaskSettings *iface)
 851 {
 852     return CONTAINING_RECORD(iface, TaskSettings, ITaskSettings_iface);
 853 }
 854
 855 static ULONG WINAPI TaskSettings_AddRef(ITaskSettings *iface)
 856 {
 857     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 858     return InterlockedIncrement(&taskset->ref);
 859 }
 860
 861 static ULONG WINAPI TaskSettings_Release(ITaskSettings *iface)
 862 {
 863     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 864     LONG ref = InterlockedDecrement(&taskset->ref);
 865
 866     if (!ref)
 867     {
 868         TRACE("destroying %p\n", iface);
 869         heap_free(taskset->restart_interval);
 870         heap_free(taskset->execution_time_limit);
 871         heap_free(taskset->delete_expired_task_after);
 872         heap_free(taskset);
 873     }
 874
 875     return ref;
 876 }
 877
 878 static HRESULT WINAPI TaskSettings_QueryInterface(ITaskSettings *iface, REFIID riid, void **obj)
 879 {
 880     if (!riid || !obj) return E_INVALIDARG;
 881
 882     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 883
 884     if (IsEqualGUID(riid, &IID_ITaskSettings) ||
 885         IsEqualGUID(riid, &IID_IDispatch) ||
 886         IsEqualGUID(riid, &IID_IUnknown))
 887     {
 888         ITaskSettings_AddRef(iface);
 889         *obj = iface;
 890         return S_OK;
 891     }
 892
 893     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 894     *obj = NULL;
 895     return E_NOINTERFACE;
 896 }
 897
 898 static HRESULT WINAPI TaskSettings_GetTypeInfoCount(ITaskSettings *iface, UINT *count)
 899 {
 900     FIXME("%p,%p: stub\n", iface, count);
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI TaskSettings_GetTypeInfo(ITaskSettings *iface, UINT index, LCID lcid, ITypeInfo **info)
 905 {
 906     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT WINAPI TaskSettings_GetIDsOfNames(ITaskSettings *iface, REFIID riid, LPOLESTR *names,
 911                                                  UINT count, LCID lcid, DISPID *dispid)
 912 {
 913     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI TaskSettings_Invoke(ITaskSettings *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 918                                           DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 919 {
 920     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 921           params, result, excepinfo, argerr);
 922     return E_NOTIMPL;
 923 }
 924
 925 static HRESULT WINAPI TaskSettings_get_AllowDemandStart(ITaskSettings *iface, VARIANT_BOOL *allow)
 926 {
 927     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 928
 929     TRACE("%p,%p\n", iface, allow);
 930
 931     if (!allow) return E_POINTER;
 932
 933     *allow = taskset->allow_on_demand_start ? VARIANT_TRUE : VARIANT_FALSE;
 934
 935     return S_OK;
 936 }
 937
 938 static HRESULT WINAPI TaskSettings_put_AllowDemandStart(ITaskSettings *iface, VARIANT_BOOL allow)
 939 {
 940     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 941
 942     TRACE("%p,%d\n", iface, allow);
 943
 944     taskset->allow_on_demand_start = allow ? TRUE : FALSE;
 945
 946     return S_OK;
 947 }
 948
 949 static HRESULT WINAPI TaskSettings_get_RestartInterval(ITaskSettings *iface, BSTR *interval)
 950 {
 951     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 952
 953     TRACE("%p,%p\n", iface, interval);
 954
 955     if (!interval) return E_POINTER;
 956
 957     if (!taskset->restart_interval)
 958     {
 959         *interval = NULL;
 960         return S_OK;
 961     }
 962
 963     if (!taskset->restart_interval) *interval = NULL;
 964     else if (!(*interval = SysAllocString(taskset->restart_interval))) return E_OUTOFMEMORY;
 965
 966     return S_OK;
 967 }
 968
 969 static HRESULT WINAPI TaskSettings_put_RestartInterval(ITaskSettings *iface, BSTR interval)
 970 {
 971     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 972     WCHAR *str = NULL;
 973
 974     TRACE("%p,%s\n", iface, debugstr_w(interval));
 975
 976     if (interval && !(str = heap_strdupW(interval))) return E_OUTOFMEMORY;
 977     heap_free(taskset->restart_interval);
 978     taskset->restart_interval = str;
 979
 980     return S_OK;
 981 }
 982
 983 static HRESULT WINAPI TaskSettings_get_RestartCount(ITaskSettings *iface, INT *count)
 984 {
 985     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 986
 987     TRACE("%p,%p\n", iface, count);
 988
 989     if (!count) return E_POINTER;
 990
 991     *count = taskset->restart_count;
 992
 993     return S_OK;
 994 }
 995
 996 static HRESULT WINAPI TaskSettings_put_RestartCount(ITaskSettings *iface, INT count)
 997 {
 998     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 999
1000     TRACE("%p,%d\n", iface, count);
1001
1002     taskset->restart_count = count;
1003
1004     return S_OK;
1005 }
1006
1007 static HRESULT WINAPI TaskSettings_get_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY *policy)
1008 {
1009     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1010
1011     TRACE("%p,%p\n", iface, policy);
1012
1013     if (!policy) return E_POINTER;
1014
1015     *policy = taskset->policy;
1016
1017     return S_OK;
1018 }
1019
1020 static HRESULT WINAPI TaskSettings_put_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY policy)
1021 {
1022     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1023
1024     TRACE("%p,%d\n", iface, policy);
1025
1026     taskset->policy = policy;
1027
1028     return S_OK;
1029 }
1030
1031 static HRESULT WINAPI TaskSettings_get_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL *stop)
1032 {
1033     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1034
1035     TRACE("%p,%p\n", iface, stop);
1036
1037     if (!stop) return E_POINTER;
1038
1039     *stop = taskset->stop_if_going_on_batteries ? VARIANT_TRUE : VARIANT_FALSE;
1040
1041     return S_OK;
1042 }
1043
1044 static HRESULT WINAPI TaskSettings_put_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL stop)
1045 {
1046     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1047
1048     TRACE("%p,%d\n", iface, stop);
1049
1050     taskset->stop_if_going_on_batteries = stop ? TRUE : FALSE;
1051
1052     return S_OK;
1053 }
1054
1055 static HRESULT WINAPI TaskSettings_get_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL *disallow)
1056 {
1057     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1058
1059     TRACE("%p,%p\n", iface, disallow);
1060
1061     if (!disallow) return E_POINTER;
1062
1063     *disallow = taskset->disallow_start_if_on_batteries ? VARIANT_TRUE : VARIANT_FALSE;
1064
1065     return S_OK;
1066 }
1067
1068 static HRESULT WINAPI TaskSettings_put_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL disallow)
1069 {
1070     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1071
1072     TRACE("%p,%d\n", iface, disallow);
1073
1074     taskset->disallow_start_if_on_batteries = disallow ? TRUE : FALSE;
1075
1076     return S_OK;
1077 }
1078
1079 static HRESULT WINAPI TaskSettings_get_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL *allow)
1080 {
1081     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1082
1083     TRACE("%p,%p\n", iface, allow);
1084
1085     if (!allow) return E_POINTER;
1086
1087     *allow = taskset->allow_hard_terminate ? VARIANT_TRUE : VARIANT_FALSE;
1088
1089     return S_OK;
1090 }
1091
1092 static HRESULT WINAPI TaskSettings_put_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL allow)
1093 {
1094     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1095
1096     TRACE("%p,%d\n", iface, allow);
1097
1098     taskset->allow_hard_terminate = allow ? TRUE : FALSE;
1099
1100     return S_OK;
1101 }
1102
1103 static HRESULT WINAPI TaskSettings_get_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL *start)
1104 {
1105     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1106
1107     TRACE("%p,%p\n", iface, start);
1108
1109     if (!start) return E_POINTER;
1110
1111     *start = taskset->start_when_available ? VARIANT_TRUE : VARIANT_FALSE;
1112
1113     return S_OK;
1114 }
1115
1116 static HRESULT WINAPI TaskSettings_put_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL start)
1117 {
1118     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1119
1120     TRACE("%p,%d\n", iface, start);
1121
1122     taskset->start_when_available = start ? TRUE : FALSE;
1123
1124     return S_OK;
1125 }
1126
1127 static HRESULT WINAPI TaskSettings_get_XmlText(ITaskSettings *iface, BSTR *xml)
1128 {
1129     FIXME("%p,%p: stub\n", iface, xml);
1130     return E_NOTIMPL;
1131 }
1132
1133 static HRESULT WINAPI TaskSettings_put_XmlText(ITaskSettings *iface, BSTR xml)
1134 {
1135     FIXME("%p,%s: stub\n", iface, debugstr_w(xml));
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI TaskSettings_get_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL *run)
1140 {
1141     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1142
1143     TRACE("%p,%p\n", iface, run);
1144
1145     if (!run) return E_POINTER;
1146
1147     *run = taskset->run_only_if_network_available ? VARIANT_TRUE : VARIANT_FALSE;
1148
1149     return S_OK;
1150 }
1151
1152 static HRESULT WINAPI TaskSettings_put_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL run)
1153 {
1154     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1155
1156     TRACE("%p,%d\n", iface, run);
1157
1158     taskset->run_only_if_network_available = run ? TRUE : FALSE;
1159
1160     return S_OK;
1161 }
1162
1163 static HRESULT WINAPI TaskSettings_get_ExecutionTimeLimit(ITaskSettings *iface, BSTR *limit)
1164 {
1165     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1166
1167     TRACE("%p,%p\n", iface, limit);
1168
1169     if (!limit) return E_POINTER;
1170
1171     if (!taskset->execution_time_limit)
1172     {
1173         *limit = NULL;
1174         return S_OK;
1175     }
1176
1177     if (!taskset->execution_time_limit) *limit = NULL;
1178     else if (!(*limit = SysAllocString(taskset->execution_time_limit))) return E_OUTOFMEMORY;
1179
1180     return S_OK;
1181 }
1182
1183 static HRESULT WINAPI TaskSettings_put_ExecutionTimeLimit(ITaskSettings *iface, BSTR limit)
1184 {
1185     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1186     WCHAR *str = NULL;
1187
1188     TRACE("%p,%s\n", iface, debugstr_w(limit));
1189
1190     if (limit && !(str = heap_strdupW(limit))) return E_OUTOFMEMORY;
1191     heap_free(taskset->execution_time_limit);
1192     taskset->execution_time_limit = str;
1193
1194     return S_OK;
1195 }
1196
1197 static HRESULT WINAPI TaskSettings_get_Enabled(ITaskSettings *iface, VARIANT_BOOL *enabled)
1198 {
1199     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1200
1201     TRACE("%p,%p\n", iface, enabled);
1202
1203     if (!enabled) return E_POINTER;
1204
1205     *enabled = taskset->enabled ? VARIANT_TRUE : VARIANT_FALSE;
1206
1207     return S_OK;
1208 }
1209
1210 static HRESULT WINAPI TaskSettings_put_Enabled(ITaskSettings *iface, VARIANT_BOOL enabled)
1211 {
1212     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1213
1214     TRACE("%p,%d\n", iface, enabled);
1215
1216     taskset->enabled = enabled ? TRUE : FALSE;
1217
1218     return S_OK;
1219 }
1220
1221 static HRESULT WINAPI TaskSettings_get_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR *delay)
1222 {
1223     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1224
1225     TRACE("%p,%p\n", iface, delay);
1226
1227     if (!delay) return E_POINTER;
1228
1229     if (!taskset->delete_expired_task_after) *delay = NULL;
1230     else if (!(*delay = SysAllocString(taskset->delete_expired_task_after))) return E_OUTOFMEMORY;
1231
1232     return S_OK;
1233 }
1234
1235 static HRESULT WINAPI TaskSettings_put_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR delay)
1236 {
1237     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1238     WCHAR *str = NULL;
1239
1240     TRACE("%p,%s\n", iface, debugstr_w(delay));
1241
1242     if (delay && !(str = heap_strdupW(delay))) return E_OUTOFMEMORY;
1243     heap_free(taskset->delete_expired_task_after);
1244     taskset->delete_expired_task_after = str;
1245
1246     return S_OK;
1247 }
1248
1249 static HRESULT WINAPI TaskSettings_get_Priority(ITaskSettings *iface, INT *priority)
1250 {
1251     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1252
1253     TRACE("%p,%p\n", iface, priority);
1254
1255     if (!priority) return E_POINTER;
1256
1257     *priority = taskset->priority;
1258
1259     return S_OK;
1260 }
1261
1262 static HRESULT WINAPI TaskSettings_put_Priority(ITaskSettings *iface, INT priority)
1263 {
1264     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1265
1266     TRACE("%p,%d\n", iface, priority);
1267
1268     taskset->priority = priority;
1269
1270     return S_OK;
1271 }
1272
1273 static HRESULT WINAPI TaskSettings_get_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY *level)
1274 {
1275     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1276
1277     TRACE("%p,%p\n", iface, level);
1278
1279     if (!level) return E_POINTER;
1280
1281     *level = taskset->compatibility;
1282
1283     return S_OK;
1284 }
1285
1286 static HRESULT WINAPI TaskSettings_put_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY level)
1287 {
1288     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1289
1290     TRACE("%p,%d\n", iface, level);
1291
1292     taskset->compatibility = level;
1293
1294     return S_OK;
1295 }
1296
1297 static HRESULT WINAPI TaskSettings_get_Hidden(ITaskSettings *iface, VARIANT_BOOL *hidden)
1298 {
1299     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1300
1301     TRACE("%p,%p\n", iface, hidden);
1302
1303     if (!hidden) return E_POINTER;
1304
1305     *hidden = taskset->hidden ? VARIANT_TRUE : VARIANT_FALSE;
1306
1307     return S_OK;
1308 }
1309
1310 static HRESULT WINAPI TaskSettings_put_Hidden(ITaskSettings *iface, VARIANT_BOOL hidden)
1311 {
1312     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1313
1314     TRACE("%p,%d\n", iface, hidden);
1315
1316     taskset->hidden = hidden ? TRUE : FALSE;
1317
1318     return S_OK;
1319 }
1320
1321 static HRESULT WINAPI TaskSettings_get_IdleSettings(ITaskSettings *iface, IIdleSettings **settings)
1322 {
1323     FIXME("%p,%p: stub\n", iface, settings);
1324     return E_NOTIMPL;
1325 }
1326
1327 static HRESULT WINAPI TaskSettings_put_IdleSettings(ITaskSettings *iface, IIdleSettings *settings)
1328 {
1329     FIXME("%p,%p: stub\n", iface, settings);
1330     return E_NOTIMPL;
1331 }
1332
1333 static HRESULT WINAPI TaskSettings_get_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL *run)
1334 {
1335     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1336
1337     TRACE("%p,%p\n", iface, run);
1338
1339     if (!run) return E_POINTER;
1340
1341     *run = taskset->run_only_if_idle ? VARIANT_TRUE : VARIANT_FALSE;
1342
1343     return S_OK;
1344 }
1345
1346 static HRESULT WINAPI TaskSettings_put_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL run)
1347 {
1348     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1349
1350     TRACE("%p,%d\n", iface, run);
1351
1352     taskset->run_only_if_idle = run ? TRUE : FALSE;
1353
1354     return S_OK;
1355 }
1356
1357 static HRESULT WINAPI TaskSettings_get_WakeToRun(ITaskSettings *iface, VARIANT_BOOL *wake)
1358 {
1359     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1360
1361     TRACE("%p,%p\n", iface, wake);
1362
1363     if (!wake) return E_POINTER;
1364
1365     *wake = taskset->wake_to_run ? VARIANT_TRUE : VARIANT_FALSE;
1366
1367     return S_OK;
1368 }
1369
1370 static HRESULT WINAPI TaskSettings_put_WakeToRun(ITaskSettings *iface, VARIANT_BOOL wake)
1371 {
1372     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1373
1374     TRACE("%p,%d\n", iface, wake);
1375
1376     taskset->wake_to_run = wake ? TRUE : FALSE;
1377
1378     return S_OK;
1379 }
1380
1381 static HRESULT WINAPI TaskSettings_get_NetworkSettings(ITaskSettings *iface, INetworkSettings **settings)
1382 {
1383     FIXME("%p,%p: stub\n", iface, settings);
1384     return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI TaskSettings_put_NetworkSettings(ITaskSettings *iface, INetworkSettings *settings)
1388 {
1389     FIXME("%p,%p: stub\n", iface, settings);
1390     return E_NOTIMPL;
1391 }
1392
1393 static const ITaskSettingsVtbl TaskSettings_vtbl =
1394 {
1395     TaskSettings_QueryInterface,
1396     TaskSettings_AddRef,
1397     TaskSettings_Release,
1398     TaskSettings_GetTypeInfoCount,
1399     TaskSettings_GetTypeInfo,
1400     TaskSettings_GetIDsOfNames,
1401     TaskSettings_Invoke,
1402     TaskSettings_get_AllowDemandStart,
1403     TaskSettings_put_AllowDemandStart,
1404     TaskSettings_get_RestartInterval,
1405     TaskSettings_put_RestartInterval,
1406     TaskSettings_get_RestartCount,
1407     TaskSettings_put_RestartCount,
1408     TaskSettings_get_MultipleInstances,
1409     TaskSettings_put_MultipleInstances,
1410     TaskSettings_get_StopIfGoingOnBatteries,
1411     TaskSettings_put_StopIfGoingOnBatteries,
1412     TaskSettings_get_DisallowStartIfOnBatteries,
1413     TaskSettings_put_DisallowStartIfOnBatteries,
1414     TaskSettings_get_AllowHardTerminate,
1415     TaskSettings_put_AllowHardTerminate,
1416     TaskSettings_get_StartWhenAvailable,
1417     TaskSettings_put_StartWhenAvailable,
1418     TaskSettings_get_XmlText,
1419     TaskSettings_put_XmlText,
1420     TaskSettings_get_RunOnlyIfNetworkAvailable,
1421     TaskSettings_put_RunOnlyIfNetworkAvailable,
1422     TaskSettings_get_ExecutionTimeLimit,
1423     TaskSettings_put_ExecutionTimeLimit,
1424     TaskSettings_get_Enabled,
1425     TaskSettings_put_Enabled,
1426     TaskSettings_get_DeleteExpiredTaskAfter,
1427     TaskSettings_put_DeleteExpiredTaskAfter,
1428     TaskSettings_get_Priority,
1429     TaskSettings_put_Priority,
1430     TaskSettings_get_Compatibility,
1431     TaskSettings_put_Compatibility,
1432     TaskSettings_get_Hidden,
1433     TaskSettings_put_Hidden,
1434     TaskSettings_get_IdleSettings,
1435     TaskSettings_put_IdleSettings,
1436     TaskSettings_get_RunOnlyIfIdle,
1437     TaskSettings_put_RunOnlyIfIdle,
1438     TaskSettings_get_WakeToRun,
1439     TaskSettings_put_WakeToRun,
1440     TaskSettings_get_NetworkSettings,
1441     TaskSettings_put_NetworkSettings
1442 };
1443
1444 static HRESULT TaskSettings_create(ITaskSettings **obj)
1445 {
1446     static const WCHAR exec_time_limit[] = { 'P','T','7','2','H',0 };
1447     TaskSettings *taskset;
1448
1449     taskset = heap_alloc(sizeof(*taskset));
1450     if (!taskset) return E_OUTOFMEMORY;
1451
1452     taskset->ITaskSettings_iface.lpVtbl = &TaskSettings_vtbl;
1453     taskset->ref = 1;
1454     /* set the defaults */
1455     taskset->restart_interval = NULL;
1456     taskset->execution_time_limit = heap_strdupW(exec_time_limit);
1457     taskset->delete_expired_task_after = NULL;
1458     taskset->restart_count = 0;
1459     taskset->priority = 7;
1460     taskset->policy = TASK_INSTANCES_IGNORE_NEW;
1461     taskset->compatibility = TASK_COMPATIBILITY_V2;
1462     taskset->allow_on_demand_start = TRUE;
1463     taskset->stop_if_going_on_batteries = TRUE;
1464     taskset->disallow_start_if_on_batteries = TRUE;
1465     taskset->allow_hard_terminate = TRUE;
1466     taskset->start_when_available = FALSE;
1467     taskset->run_only_if_network_available = FALSE;
1468     taskset->enabled = TRUE;
1469     taskset->hidden = FALSE;
1470     taskset->run_only_if_idle = FALSE;
1471     taskset->wake_to_run = FALSE;
1472
1473     *obj = &taskset->ITaskSettings_iface;
1474
1475     TRACE("created %p\n", *obj);
1476
1477     return S_OK;
1478 }
1479
1480 typedef struct
1481 {
1482     IPrincipal IPrincipal_iface;
1483     LONG ref;
1484 } Principal;
1485
1486 static inline Principal *impl_from_IPrincipal(IPrincipal *iface)
1487 {
1488     return CONTAINING_RECORD(iface, Principal, IPrincipal_iface);
1489 }
1490
1491 static ULONG WINAPI Principal_AddRef(IPrincipal *iface)
1492 {
1493     Principal *principal = impl_from_IPrincipal(iface);
1494     return InterlockedIncrement(&principal->ref);
1495 }
1496
1497 static ULONG WINAPI Principal_Release(IPrincipal *iface)
1498 {
1499     Principal *principal = impl_from_IPrincipal(iface);
1500     LONG ref = InterlockedDecrement(&principal->ref);
1501
1502     if (!ref)
1503     {
1504         TRACE("destroying %p\n", iface);
1505         heap_free(principal);
1506     }
1507
1508     return ref;
1509 }
1510
1511 static HRESULT WINAPI Principal_QueryInterface(IPrincipal *iface, REFIID riid, void **obj)
1512 {
1513     if (!riid || !obj) return E_INVALIDARG;
1514
1515     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1516
1517     if (IsEqualGUID(riid, &IID_IPrincipal) ||
1518         IsEqualGUID(riid, &IID_IDispatch) ||
1519         IsEqualGUID(riid, &IID_IUnknown))
1520     {
1521         IPrincipal_AddRef(iface);
1522         *obj = iface;
1523         return S_OK;
1524     }
1525
1526     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
1527     *obj = NULL;
1528     return E_NOINTERFACE;
1529 }
1530
1531 static HRESULT WINAPI Principal_GetTypeInfoCount(IPrincipal *iface, UINT *count)
1532 {
1533     FIXME("%p,%p: stub\n", iface, count);
1534     return E_NOTIMPL;
1535 }
1536
1537 static HRESULT WINAPI Principal_GetTypeInfo(IPrincipal *iface, UINT index, LCID lcid, ITypeInfo **info)
1538 {
1539     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
1540     return E_NOTIMPL;
1541 }
1542
1543 static HRESULT WINAPI Principal_GetIDsOfNames(IPrincipal *iface, REFIID riid, LPOLESTR *names,
1544                                               UINT count, LCID lcid, DISPID *dispid)
1545 {
1546     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
1547     return E_NOTIMPL;
1548 }
1549
1550 static HRESULT WINAPI Principal_Invoke(IPrincipal *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
1551                                        DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
1552 {
1553     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
1554           params, result, excepinfo, argerr);
1555     return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI Principal_get_Id(IPrincipal *iface, BSTR *id)
1559 {
1560     FIXME("%p,%p: stub\n", iface, id);
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI Principal_put_Id(IPrincipal *iface, BSTR id)
1565 {
1566     FIXME("%p,%s: stub\n", iface, debugstr_w(id));
1567     return S_OK;
1568 }
1569
1570 static HRESULT WINAPI Principal_get_DisplayName(IPrincipal *iface, BSTR *name)
1571 {
1572     FIXME("%p,%p: stub\n", iface, name);
1573     return E_NOTIMPL;
1574 }
1575
1576 static HRESULT WINAPI Principal_put_DisplayName(IPrincipal *iface, BSTR name)
1577 {
1578     FIXME("%p,%s: stub\n", iface, debugstr_w(name));
1579     return E_NOTIMPL;
1580 }
1581
1582 static HRESULT WINAPI Principal_get_UserId(IPrincipal *iface, BSTR *user_id)
1583 {
1584     FIXME("%p,%p: stub\n", iface, user_id);
1585     return E_NOTIMPL;
1586 }
1587
1588 static HRESULT WINAPI Principal_put_UserId(IPrincipal *iface, BSTR user_id)
1589 {
1590     FIXME("%p,%s: stub\n", iface, debugstr_w(user_id));
1591     return S_OK;
1592 }
1593
1594 static HRESULT WINAPI Principal_get_LogonType(IPrincipal *iface, TASK_LOGON_TYPE *logon_type)
1595 {
1596     FIXME("%p,%p: stub\n", iface, logon_type);
1597     return E_NOTIMPL;
1598 }
1599
1600 static HRESULT WINAPI Principal_put_LogonType(IPrincipal *iface, TASK_LOGON_TYPE logon_type)
1601 {
1602     FIXME("%p,%u: stub\n", iface, logon_type);
1603     return E_NOTIMPL;
1604 }
1605
1606 static HRESULT WINAPI Principal_get_GroupId(IPrincipal *iface, BSTR *group_id)
1607 {
1608     FIXME("%p,%p: stub\n", iface, group_id);
1609     return E_NOTIMPL;
1610 }
1611
1612 static HRESULT WINAPI Principal_put_GroupId(IPrincipal *iface, BSTR group_id)
1613 {
1614     FIXME("%p,%s: stub\n", iface, debugstr_w(group_id));
1615     return E_NOTIMPL;
1616 }
1617
1618 static HRESULT WINAPI Principal_get_RunLevel(IPrincipal *iface, TASK_RUNLEVEL_TYPE *run_level)
1619 {
1620     FIXME("%p,%p: stub\n", iface, run_level);
1621     return E_NOTIMPL;
1622 }
1623
1624 static HRESULT WINAPI Principal_put_RunLevel(IPrincipal *iface, TASK_RUNLEVEL_TYPE run_level)
1625 {
1626     FIXME("%p,%u: stub\n", iface, run_level);
1627     return E_NOTIMPL;
1628 }
1629
1630 static const IPrincipalVtbl Principal_vtbl =
1631 {
1632     Principal_QueryInterface,
1633     Principal_AddRef,
1634     Principal_Release,
1635     Principal_GetTypeInfoCount,
1636     Principal_GetTypeInfo,
1637     Principal_GetIDsOfNames,
1638     Principal_Invoke,
1639     Principal_get_Id,
1640     Principal_put_Id,
1641     Principal_get_DisplayName,
1642     Principal_put_DisplayName,
1643     Principal_get_UserId,
1644     Principal_put_UserId,
1645     Principal_get_LogonType,
1646     Principal_put_LogonType,
1647     Principal_get_GroupId,
1648     Principal_put_GroupId,
1649     Principal_get_RunLevel,
1650     Principal_put_RunLevel
1651 };
1652
1653 static HRESULT Principal_create(IPrincipal **obj)
1654 {
1655     Principal *principal;
1656
1657     principal = heap_alloc(sizeof(*principal));
1658     if (!principal) return E_OUTOFMEMORY;
1659
1660     principal->IPrincipal_iface.lpVtbl = &Principal_vtbl;
1661     principal->ref = 1;
1662
1663     *obj = &principal->IPrincipal_iface;
1664
1665     TRACE("created %p\n", *obj);
1666
1667     return S_OK;
1668 }
1669
1670 typedef struct
1671 {
1672     IExecAction IExecAction_iface;
1673     LONG ref;
1674     WCHAR *path;
1675     WCHAR *directory;
1676     WCHAR *args;
1677     WCHAR *id;
1678 } ExecAction;
1679
1680 static inline ExecAction *impl_from_IExecAction(IExecAction *iface)
1681 {
1682     return CONTAINING_RECORD(iface, ExecAction, IExecAction_iface);
1683 }
1684
1685 static ULONG WINAPI ExecAction_AddRef(IExecAction *iface)
1686 {
1687     ExecAction *action = impl_from_IExecAction(iface);
1688     return InterlockedIncrement(&action->ref);
1689 }
1690
1691 static ULONG WINAPI ExecAction_Release(IExecAction *iface)
1692 {
1693     ExecAction *action = impl_from_IExecAction(iface);
1694     LONG ref = InterlockedDecrement(&action->ref);
1695
1696     if (!ref)
1697     {
1698         TRACE("destroying %p\n", iface);
1699         heap_free(action->path);
1700         heap_free(action->directory);
1701         heap_free(action->args);
1702         heap_free(action->id);
1703         heap_free(action);
1704     }
1705
1706     return ref;
1707 }
1708
1709 static HRESULT WINAPI ExecAction_QueryInterface(IExecAction *iface, REFIID riid, void **obj)
1710 {
1711     if (!riid || !obj) return E_INVALIDARG;
1712
1713     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1714
1715     if (IsEqualGUID(riid, &IID_IExecAction) ||
1716         IsEqualGUID(riid, &IID_IAction) ||
1717         IsEqualGUID(riid, &IID_IDispatch) ||
1718         IsEqualGUID(riid, &IID_IUnknown))
1719     {
1720         IExecAction_AddRef(iface);
1721         *obj = iface;
1722         return S_OK;
1723     }
1724
1725     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
1726     *obj = NULL;
1727     return E_NOINTERFACE;
1728 }
1729
1730 static HRESULT WINAPI ExecAction_GetTypeInfoCount(IExecAction *iface, UINT *count)
1731 {
1732     FIXME("%p,%p: stub\n", iface, count);
1733     return E_NOTIMPL;
1734 }
1735
1736 static HRESULT WINAPI ExecAction_GetTypeInfo(IExecAction *iface, UINT index, LCID lcid, ITypeInfo **info)
1737 {
1738     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
1739     return E_NOTIMPL;
1740 }
1741
1742 static HRESULT WINAPI ExecAction_GetIDsOfNames(IExecAction *iface, REFIID riid, LPOLESTR *names,
1743                                                UINT count, LCID lcid, DISPID *dispid)
1744 {
1745     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
1746     return E_NOTIMPL;
1747 }
1748
1749 static HRESULT WINAPI ExecAction_Invoke(IExecAction *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
1750                                         DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
1751 {
1752     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
1753           params, result, excepinfo, argerr);
1754     return E_NOTIMPL;
1755 }
1756
1757 static HRESULT WINAPI ExecAction_get_Id(IExecAction *iface, BSTR *id)
1758 {
1759     ExecAction *action = impl_from_IExecAction(iface);
1760
1761     TRACE("%p,%p\n", iface, id);
1762
1763     if (!id) return E_POINTER;
1764
1765     if (!action->id) *id = NULL;
1766     else if (!(*id = SysAllocString(action->id))) return E_OUTOFMEMORY;
1767
1768     return S_OK;
1769 }
1770
1771 static HRESULT WINAPI ExecAction_put_Id(IExecAction *iface, BSTR id)
1772 {
1773     ExecAction *action = impl_from_IExecAction(iface);
1774     WCHAR *str = NULL;
1775
1776     TRACE("%p,%s\n", iface, debugstr_w(id));
1777
1778     if (id && !(str = heap_strdupW((id)))) return E_OUTOFMEMORY;
1779     heap_free(action->id);
1780     action->id = str;
1781
1782     return S_OK;
1783 }
1784
1785 static HRESULT WINAPI ExecAction_get_Type(IExecAction *iface, TASK_ACTION_TYPE *type)
1786 {
1787     TRACE("%p,%p\n", iface, type);
1788
1789     if (!type) return E_POINTER;
1790
1791     *type = TASK_ACTION_EXEC;
1792
1793     return S_OK;
1794 }
1795
1796 static HRESULT WINAPI ExecAction_get_Path(IExecAction *iface, BSTR *path)
1797 {
1798     ExecAction *action = impl_from_IExecAction(iface);
1799
1800     TRACE("%p,%p\n", iface, path);
1801
1802     if (!path) return E_POINTER;
1803
1804     if (!action->path) *path = NULL;
1805     else if (!(*path = SysAllocString(action->path))) return E_OUTOFMEMORY;
1806
1807     return S_OK;
1808 }
1809
1810 static HRESULT WINAPI ExecAction_put_Path(IExecAction *iface, BSTR path)
1811 {
1812     ExecAction *action = impl_from_IExecAction(iface);
1813     WCHAR *str = NULL;
1814
1815     TRACE("%p,%s\n", iface, debugstr_w(path));
1816
1817     if (path && !(str = heap_strdupW((path)))) return E_OUTOFMEMORY;
1818     heap_free(action->path);
1819     action->path = str;
1820
1821     return S_OK;
1822 }
1823
1824 static HRESULT WINAPI ExecAction_get_Arguments(IExecAction *iface, BSTR *arguments)
1825 {
1826     ExecAction *action = impl_from_IExecAction(iface);
1827
1828     TRACE("%p,%p\n", iface, arguments);
1829
1830     if (!arguments) return E_POINTER;
1831
1832     if (!action->args) *arguments = NULL;
1833     else if (!(*arguments = SysAllocString(action->args))) return E_OUTOFMEMORY;
1834
1835     return S_OK;
1836 }
1837
1838 static HRESULT WINAPI ExecAction_put_Arguments(IExecAction *iface, BSTR arguments)
1839 {
1840     ExecAction *action = impl_from_IExecAction(iface);
1841     WCHAR *str = NULL;
1842
1843     TRACE("%p,%s\n", iface, debugstr_w(arguments));
1844
1845     if (arguments && !(str = heap_strdupW((arguments)))) return E_OUTOFMEMORY;
1846     heap_free(action->args);
1847     action->args = str;
1848
1849     return S_OK;
1850 }
1851
1852 static HRESULT WINAPI ExecAction_get_WorkingDirectory(IExecAction *iface, BSTR *directory)
1853 {
1854     ExecAction *action = impl_from_IExecAction(iface);
1855
1856     TRACE("%p,%p\n", iface, directory);
1857
1858     if (!directory) return E_POINTER;
1859
1860     if (!action->directory) *directory = NULL;
1861     else if (!(*directory = SysAllocString(action->directory))) return E_OUTOFMEMORY;
1862
1863     return S_OK;
1864 }
1865
1866 static HRESULT WINAPI ExecAction_put_WorkingDirectory(IExecAction *iface, BSTR directory)
1867 {
1868     ExecAction *action = impl_from_IExecAction(iface);
1869     WCHAR *str = NULL;
1870
1871     TRACE("%p,%s\n", iface, debugstr_w(directory));
1872
1873     if (directory && !(str = heap_strdupW((directory)))) return E_OUTOFMEMORY;
1874     heap_free(action->directory);
1875     action->directory = str;
1876
1877     return S_OK;
1878 }
1879
1880 static const IExecActionVtbl Action_vtbl =
1881 {
1882     ExecAction_QueryInterface,
1883     ExecAction_AddRef,
1884     ExecAction_Release,
1885     ExecAction_GetTypeInfoCount,
1886     ExecAction_GetTypeInfo,
1887     ExecAction_GetIDsOfNames,
1888     ExecAction_Invoke,
1889     ExecAction_get_Id,
1890     ExecAction_put_Id,
1891     ExecAction_get_Type,
1892     ExecAction_get_Path,
1893     ExecAction_put_Path,
1894     ExecAction_get_Arguments,
1895     ExecAction_put_Arguments,
1896     ExecAction_get_WorkingDirectory,
1897     ExecAction_put_WorkingDirectory
1898 };
1899
1900 static HRESULT ExecAction_create(IExecAction **obj)
1901 {
1902     ExecAction *action;
1903
1904     action = heap_alloc(sizeof(*action));
1905     if (!action) return E_OUTOFMEMORY;
1906
1907     action->IExecAction_iface.lpVtbl = &Action_vtbl;
1908     action->ref = 1;
1909     action->path = NULL;
1910     action->directory = NULL;
1911     action->args = NULL;
1912     action->id = NULL;
1913
1914     *obj = &action->IExecAction_iface;
1915
1916     TRACE("created %p\n", *obj);
1917
1918     return S_OK;
1919 }
1920
1921 typedef struct
1922 {
1923     IActionCollection IActionCollection_iface;
1924     LONG ref;
1925 } Actions;
1926
1927 static inline Actions *impl_from_IActionCollection(IActionCollection *iface)
1928 {
1929     return CONTAINING_RECORD(iface, Actions, IActionCollection_iface);
1930 }
1931
1932 static ULONG WINAPI Actions_AddRef(IActionCollection *iface)
1933 {
1934     Actions *actions = impl_from_IActionCollection(iface);
1935     return InterlockedIncrement(&actions->ref);
1936 }
1937
1938 static ULONG WINAPI Actions_Release(IActionCollection *iface)
1939 {
1940     Actions *actions = impl_from_IActionCollection(iface);
1941     LONG ref = InterlockedDecrement(&actions->ref);
1942
1943     if (!ref)
1944     {
1945         TRACE("destroying %p\n", iface);
1946         heap_free(actions);
1947     }
1948
1949     return ref;
1950 }
1951
1952 static HRESULT WINAPI Actions_QueryInterface(IActionCollection *iface, REFIID riid, void **obj)
1953 {
1954     if (!riid || !obj) return E_INVALIDARG;
1955
1956     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1957
1958     if (IsEqualGUID(riid, &IID_IActionCollection) ||
1959         IsEqualGUID(riid, &IID_IDispatch) ||
1960         IsEqualGUID(riid, &IID_IUnknown))
1961     {
1962         IActionCollection_AddRef(iface);
1963         *obj = iface;
1964         return S_OK;
1965     }
1966
1967     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
1968     *obj = NULL;
1969     return E_NOINTERFACE;
1970 }
1971
1972 static HRESULT WINAPI Actions_GetTypeInfoCount(IActionCollection *iface, UINT *count)
1973 {
1974     FIXME("%p,%p: stub\n", iface, count);
1975     return E_NOTIMPL;
1976 }
1977
1978 static HRESULT WINAPI Actions_GetTypeInfo(IActionCollection *iface, UINT index, LCID lcid, ITypeInfo **info)
1979 {
1980     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
1981     return E_NOTIMPL;
1982 }
1983
1984 static HRESULT WINAPI Actions_GetIDsOfNames(IActionCollection *iface, REFIID riid, LPOLESTR *names,
1985                                             UINT count, LCID lcid, DISPID *dispid)
1986 {
1987     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
1988     return E_NOTIMPL;
1989 }
1990
1991 static HRESULT WINAPI Actions_Invoke(IActionCollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
1992                                      DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
1993 {
1994     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
1995           params, result, excepinfo, argerr);
1996     return E_NOTIMPL;
1997 }
1998
1999 static HRESULT WINAPI Actions_get_Count(IActionCollection *iface, LONG *count)
2000 {
2001     FIXME("%p,%p: stub\n", iface, count);
2002     return E_NOTIMPL;
2003 }
2004
2005 static HRESULT WINAPI Actions_get_Item(IActionCollection *iface, LONG index, IAction **action)
2006 {
2007     FIXME("%p,%d,%p: stub\n", iface, index, action);
2008     return E_NOTIMPL;
2009 }
2010
2011 static HRESULT WINAPI Actions_get__NewEnum(IActionCollection *iface, IUnknown **penum)
2012 {
2013     FIXME("%p,%p: stub\n", iface, penum);
2014     return E_NOTIMPL;
2015 }
2016
2017 static HRESULT WINAPI Actions_get_XmlText(IActionCollection *iface, BSTR *xml)
2018 {
2019     FIXME("%p,%p: stub\n", iface, xml);
2020     return E_NOTIMPL;
2021 }
2022
2023 static HRESULT WINAPI Actions_put_XmlText(IActionCollection *iface, BSTR xml)
2024 {
2025     FIXME("%p,%s: stub\n", iface, debugstr_w(xml));
2026     return E_NOTIMPL;
2027 }
2028
2029 static HRESULT WINAPI Actions_Create(IActionCollection *iface, TASK_ACTION_TYPE type, IAction **action)
2030 {
2031     TRACE("%p,%u,%p\n", iface, type, action);
2032
2033     switch (type)
2034     {
2035     case TASK_ACTION_EXEC:
2036         return ExecAction_create((IExecAction **)action);
2037
2038     default:
2039         FIXME("unimplemented type %u\n", type);
2040         return E_NOTIMPL;
2041     }
2042 }
2043
2044 static HRESULT WINAPI Actions_Remove(IActionCollection *iface, VARIANT index)
2045 {
2046     FIXME("%p,%s: stub\n", iface, debugstr_variant(&index));
2047     return E_NOTIMPL;
2048 }
2049
2050 static HRESULT WINAPI Actions_Clear(IActionCollection *iface)
2051 {
2052     FIXME("%p: stub\n", iface);
2053     return E_NOTIMPL;
2054 }
2055
2056 static HRESULT WINAPI Actions_get_Context(IActionCollection *iface, BSTR *ctx)
2057 {
2058     FIXME("%p,%p: stub\n", iface, ctx);
2059     return E_NOTIMPL;
2060 }
2061
2062 static HRESULT WINAPI Actions_put_Context(IActionCollection *iface, BSTR ctx)
2063 {
2064     FIXME("%p,%s: stub\n", iface, debugstr_w(ctx));
2065     return S_OK;
2066 }
2067
2068 static const IActionCollectionVtbl Actions_vtbl =
2069 {
2070     Actions_QueryInterface,
2071     Actions_AddRef,
2072     Actions_Release,
2073     Actions_GetTypeInfoCount,
2074     Actions_GetTypeInfo,
2075     Actions_GetIDsOfNames,
2076     Actions_Invoke,
2077     Actions_get_Count,
2078     Actions_get_Item,
2079     Actions_get__NewEnum,
2080     Actions_get_XmlText,
2081     Actions_put_XmlText,
2082     Actions_Create,
2083     Actions_Remove,
2084     Actions_Clear,
2085     Actions_get_Context,
2086     Actions_put_Context
2087 };
2088
2089 static HRESULT Actions_create(IActionCollection **obj)
2090 {
2091     Actions *actions;
2092
2093     actions = heap_alloc(sizeof(*actions));
2094     if (!actions) return E_OUTOFMEMORY;
2095
2096     actions->IActionCollection_iface.lpVtbl = &Actions_vtbl;
2097     actions->ref = 1;
2098
2099     *obj = &actions->IActionCollection_iface;
2100
2101     TRACE("created %p\n", *obj);
2102
2103     return S_OK;
2104 }
2105
2106 typedef struct
2107 {
2108     ITaskDefinition ITaskDefinition_iface;
2109     LONG ref;
2110     IRegistrationInfo *reginfo;
2111     ITaskSettings *taskset;
2112     ITriggerCollection *triggers;
2113     IPrincipal *principal;
2114     IActionCollection *actions;
2115 } TaskDefinition;
2116
2117 static inline TaskDefinition *impl_from_ITaskDefinition(ITaskDefinition *iface)
2118 {
2119     return CONTAINING_RECORD(iface, TaskDefinition, ITaskDefinition_iface);
2120 }
2121
2122 static ULONG WINAPI TaskDefinition_AddRef(ITaskDefinition *iface)
2123 {
2124     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2125     return InterlockedIncrement(&taskdef->ref);
2126 }
2127
2128 static ULONG WINAPI TaskDefinition_Release(ITaskDefinition *iface)
2129 {
2130     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2131     LONG ref = InterlockedDecrement(&taskdef->ref);
2132
2133     if (!ref)
2134     {
2135         TRACE("destroying %p\n", iface);
2136
2137         if (taskdef->reginfo)
2138             IRegistrationInfo_Release(taskdef->reginfo);
2139         if (taskdef->taskset)
2140             ITaskSettings_Release(taskdef->taskset);
2141         if (taskdef->triggers)
2142             ITriggerCollection_Release(taskdef->triggers);
2143         if (taskdef->principal)
2144             IPrincipal_Release(taskdef->principal);
2145         if (taskdef->actions)
2146             IActionCollection_Release(taskdef->actions);
2147
2148         heap_free(taskdef);
2149     }
2150
2151     return ref;
2152 }
2153
2154 static HRESULT WINAPI TaskDefinition_QueryInterface(ITaskDefinition *iface, REFIID riid, void **obj)
2155 {
2156     if (!riid || !obj) return E_INVALIDARG;
2157
2158     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
2159
2160     if (IsEqualGUID(riid, &IID_ITaskDefinition) ||
2161         IsEqualGUID(riid, &IID_IDispatch) ||
2162         IsEqualGUID(riid, &IID_IUnknown))
2163     {
2164         ITaskDefinition_AddRef(iface);
2165         *obj = iface;
2166         return S_OK;
2167     }
2168
2169     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
2170     *obj = NULL;
2171     return E_NOINTERFACE;
2172 }
2173
2174 static HRESULT WINAPI TaskDefinition_GetTypeInfoCount(ITaskDefinition *iface, UINT *count)
2175 {
2176     FIXME("%p,%p: stub\n", iface, count);
2177     return E_NOTIMPL;
2178 }
2179
2180 static HRESULT WINAPI TaskDefinition_GetTypeInfo(ITaskDefinition *iface, UINT index, LCID lcid, ITypeInfo **info)
2181 {
2182     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
2183     return E_NOTIMPL;
2184 }
2185
2186 static HRESULT WINAPI TaskDefinition_GetIDsOfNames(ITaskDefinition *iface, REFIID riid, LPOLESTR *names,
2187                                                    UINT count, LCID lcid, DISPID *dispid)
2188 {
2189     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
2190     return E_NOTIMPL;
2191 }
2192
2193 static HRESULT WINAPI TaskDefinition_Invoke(ITaskDefinition *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
2194                                             DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
2195 {
2196     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
2197           params, result, excepinfo, argerr);
2198     return E_NOTIMPL;
2199 }
2200
2201 static HRESULT WINAPI TaskDefinition_get_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo **info)
2202 {
2203     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2204     HRESULT hr;
2205
2206     TRACE("%p,%p\n", iface, info);
2207
2208     if (!info) return E_POINTER;
2209
2210     if (!taskdef->reginfo)
2211     {
2212         hr = RegistrationInfo_create(&taskdef->reginfo);
2213         if (hr != S_OK) return hr;
2214     }
2215
2216     IRegistrationInfo_AddRef(taskdef->reginfo);
2217     *info = taskdef->reginfo;
2218
2219     return S_OK;
2220 }
2221
2222 static HRESULT WINAPI TaskDefinition_put_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo *info)
2223 {
2224     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2225
2226     TRACE("%p,%p\n", iface, info);
2227
2228     if (!info) return E_POINTER;
2229
2230     if (taskdef->reginfo)
2231         IRegistrationInfo_Release(taskdef->reginfo);
2232
2233     IRegistrationInfo_AddRef(info);
2234     taskdef->reginfo = info;
2235
2236     return S_OK;
2237 }
2238
2239 static HRESULT WINAPI TaskDefinition_get_Triggers(ITaskDefinition *iface, ITriggerCollection **triggers)
2240 {
2241     TaskDefinition *This = impl_from_ITaskDefinition(iface);
2242
2243     TRACE("%p,%p\n", This, triggers);
2244
2245     if (!This->triggers)
2246     {
2247         trigger_collection *collection;
2248
2249         collection = heap_alloc(sizeof(*collection));
2250         if (!collection) return E_OUTOFMEMORY;
2251
2252         collection->ITriggerCollection_iface.lpVtbl = &TriggerCollection_vtbl;
2253         collection->ref = 1;
2254         This->triggers = &collection->ITriggerCollection_iface;
2255     }
2256
2257     ITriggerCollection_AddRef(*triggers = This->triggers);
2258     return S_OK;
2259 }
2260
2261 static HRESULT WINAPI TaskDefinition_put_Triggers(ITaskDefinition *iface, ITriggerCollection *triggers)
2262 {
2263     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2264
2265     TRACE("%p,%p\n", iface, triggers);
2266
2267     if (!triggers) return E_POINTER;
2268
2269     if (taskdef->triggers)
2270         ITriggerCollection_Release(taskdef->triggers);
2271
2272     ITriggerCollection_AddRef(triggers);
2273     taskdef->triggers = triggers;
2274
2275     return S_OK;
2276 }
2277
2278 static HRESULT WINAPI TaskDefinition_get_Settings(ITaskDefinition *iface, ITaskSettings **settings)
2279 {
2280     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2281     HRESULT hr;
2282
2283     TRACE("%p,%p\n", iface, settings);
2284
2285     if (!settings) return E_POINTER;
2286
2287     if (!taskdef->taskset)
2288     {
2289         hr = TaskSettings_create(&taskdef->taskset);
2290         if (hr != S_OK) return hr;
2291     }
2292
2293     ITaskSettings_AddRef(taskdef->taskset);
2294     *settings = taskdef->taskset;
2295
2296     return S_OK;
2297 }
2298
2299 static HRESULT WINAPI TaskDefinition_put_Settings(ITaskDefinition *iface, ITaskSettings *settings)
2300 {
2301     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2302
2303     TRACE("%p,%p\n", iface, settings);
2304
2305     if (!settings) return E_POINTER;
2306
2307     if (taskdef->taskset)
2308         ITaskSettings_Release(taskdef->taskset);
2309
2310     ITaskSettings_AddRef(settings);
2311     taskdef->taskset = settings;
2312
2313     return S_OK;
2314 }
2315
2316 static HRESULT WINAPI TaskDefinition_get_Data(ITaskDefinition *iface, BSTR *data)
2317 {
2318     FIXME("%p,%p: stub\n", iface, data);
2319     return E_NOTIMPL;
2320 }
2321
2322 static HRESULT WINAPI TaskDefinition_put_Data(ITaskDefinition *iface, BSTR data)
2323 {
2324     FIXME("%p,%p: stub\n", iface, data);
2325     return E_NOTIMPL;
2326 }
2327
2328 static HRESULT WINAPI TaskDefinition_get_Principal(ITaskDefinition *iface, IPrincipal **principal)
2329 {
2330     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2331     HRESULT hr;
2332
2333     TRACE("%p,%p\n", iface, principal);
2334
2335     if (!principal) return E_POINTER;
2336
2337     if (!taskdef->principal)
2338     {
2339         hr = Principal_create(&taskdef->principal);
2340         if (hr != S_OK) return hr;
2341     }
2342
2343     IPrincipal_AddRef(taskdef->principal);
2344     *principal = taskdef->principal;
2345
2346     return S_OK;
2347 }
2348
2349 static HRESULT WINAPI TaskDefinition_put_Principal(ITaskDefinition *iface, IPrincipal *principal)
2350 {
2351     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2352
2353     TRACE("%p,%p\n", iface, principal);
2354
2355     if (!principal) return E_POINTER;
2356
2357     if (taskdef->principal)
2358         IPrincipal_Release(taskdef->principal);
2359
2360     IPrincipal_AddRef(principal);
2361     taskdef->principal = principal;
2362
2363     return S_OK;
2364 }
2365
2366 static HRESULT WINAPI TaskDefinition_get_Actions(ITaskDefinition *iface, IActionCollection **actions)
2367 {
2368     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2369     HRESULT hr;
2370
2371     TRACE("%p,%p\n", iface, actions);
2372
2373     if (!actions) return E_POINTER;
2374
2375     if (!taskdef->actions)
2376     {
2377         hr = Actions_create(&taskdef->actions);
2378         if (hr != S_OK) return hr;
2379     }
2380
2381     IActionCollection_AddRef(taskdef->actions);
2382     *actions = taskdef->actions;
2383
2384     return S_OK;
2385 }
2386
2387 static HRESULT WINAPI TaskDefinition_put_Actions(ITaskDefinition *iface, IActionCollection *actions)
2388 {
2389     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2390
2391     TRACE("%p,%p\n", iface, actions);
2392
2393     if (!actions) return E_POINTER;
2394
2395     if (taskdef->actions)
2396         IActionCollection_Release(taskdef->actions);
2397
2398     IActionCollection_AddRef(actions);
2399     taskdef->actions = actions;
2400
2401     return S_OK;
2402 }
2403
2404 static const WCHAR Task[] = {'T','a','s','k',0};
2405 static const WCHAR version[] = {'v','e','r','s','i','o','n',0};
2406 static const WCHAR v1_0[] = {'1','.','0',0};
2407 static const WCHAR v1_1[] = {'1','.','1',0};
2408 static const WCHAR v1_2[] = {'1','.','2',0};
2409 static const WCHAR v1_3[] = {'1','.','3',0};
2410 static const WCHAR xmlns[] = {'x','m','l','n','s',0};
2411 static const WCHAR task_ns[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','m','i','c','r','o','s','o','f','t','.','c','o','m','/','w','i','n','d','o','w','s','/','2','0','0','4','/','0','2','/','m','i','t','/','t','a','s','k',0};
2412 static const WCHAR RegistrationInfo[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
2413 static const WCHAR Author[] = {'A','u','t','h','o','r',0};
2414 static const WCHAR Description[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
2415 static const WCHAR Source[] = {'S','o','u','r','c','e',0};
2416 static const WCHAR Date[] = {'D','a','t','e',0};
2417 static const WCHAR Version[] = {'V','e','r','s','i','o','n',0};
2418 static const WCHAR Documentation[] = {'D','o','c','u','m','e','n','t','a','t','i','o','n',0};
2419 static const WCHAR URI[] = {'U','R','I',0};
2420 static const WCHAR SecurityDescriptor[] = {'S','e','c','u','r','i','t','y','D','e','s','c','r','i','p','t','o','r',0};
2421 static const WCHAR Settings[] = {'S','e','t','t','i','n','g','s',0};
2422 static const WCHAR Triggers[] = {'T','r','i','g','g','e','r','s',0};
2423 static const WCHAR Principals[] = {'P','r','i','n','c','i','p','a','l','s',0};
2424 static const WCHAR principalW[] = {'P','r','i','n','c','i','p','a','l',0};
2425 static const WCHAR id[] = {'i','d',0};
2426 static const WCHAR UserId[] = {'U','s','e','r','I','d',0};
2427 static const WCHAR LogonType[] = {'L','o','g','o','n','T','y','p','e',0};
2428 static const WCHAR GroupId[] = {'G','r','o','u','p','I','d',0};
2429 static const WCHAR DisplayName[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
2430 static const WCHAR HighestAvailable[] = {'H','i','g','h','e','s','t','A','v','a','i','l','a','b','l','e',0};
2431 static const WCHAR Password[] = {'P','a','s','s','w','o','r','d',0};
2432 static const WCHAR S4U[] = {'S','4','U',0};
2433 static const WCHAR InteractiveToken[] = {'I','n','t','e','r','a','c','t','i','v','e','T','o','k','e','n',0};
2434 static const WCHAR RunLevel[] = {'R','u','n','L','e','v','e','l',0};
2435 static const WCHAR LeastPrivilege[] = {'L','e','a','s','t','P','r','i','v','i','l','e','g','e',0};
2436 static const WCHAR actionsW[] = {'A','c','t','i','o','n','s',0};
2437 static const WCHAR Exec[] = {'E','x','e','c',0};
2438 static const WCHAR MultipleInstancesPolicy[] = {'M','u','l','t','i','p','l','e','I','n','s','t','a','n','c','e','s','P','o','l','i','c','y',0};
2439 static const WCHAR IgnoreNew[] = {'I','g','n','o','r','e','N','e','w',0};
2440 static const WCHAR DisallowStartIfOnBatteries[] = {'D','i','s','a','l','l','o','w','S','t','a','r','t','I','f','O','n','B','a','t','t','e','r','i','e','s',0};
2441 static const WCHAR AllowStartOnDemand[] = {'A','l','l','o','w','S','t','a','r','t','O','n','D','e','m','a','n','d',0};
2442 static const WCHAR StopIfGoingOnBatteries[] = {'S','t','o','p','I','f','G','o','i','n','g','O','n','B','a','t','t','e','r','i','e','s',0};
2443 static const WCHAR AllowHardTerminate[] = {'A','l','l','o','w','H','a','r','d','T','e','r','m','i','n','a','t','e',0};
2444 static const WCHAR StartWhenAvailable[] = {'S','t','a','r','t','W','h','e','n','A','v','a','i','l','a','b','l','e',0};
2445 static const WCHAR RunOnlyIfNetworkAvailable[] = {'R','u','n','O','n','l','y','I','f','N','e','t','w','o','r','k','A','v','a','i','l','a','b','l','e',0};
2446 static const WCHAR Enabled[] = {'E','n','a','b','l','e','d',0};
2447 static const WCHAR Hidden[] = {'H','i','d','d','e','n',0};
2448 static const WCHAR RunOnlyIfIdle[] = {'R','u','n','O','n','l','y','I','f','I','d','l','e',0};
2449 static const WCHAR WakeToRun[] = {'W','a','k','e','T','o','R','u','n',0};
2450 static const WCHAR ExecutionTimeLimit[] = {'E','x','e','c','u','t','i','o','n','T','i','m','e','L','i','m','i','t',0};
2451 static const WCHAR Priority[] = {'P','r','i','o','r','i','t','y',0};
2452 static const WCHAR IdleSettings[] = {'I','d','l','e','S','e','t','t','i','n','g','s',0};
2453
2454 static int xml_indent;
2455
2456 static inline void push_indent(void)
2457 {
2458     xml_indent += 2;
2459 }
2460
2461 static inline void pop_indent(void)
2462 {
2463     xml_indent -= 2;
2464 }
2465
2466 static inline HRESULT write_stringW(IStream *stream, const WCHAR *str)
2467 {
2468     return IStream_Write(stream, str, lstrlenW(str) * sizeof(WCHAR), NULL);
2469 }
2470
2471 static void write_indent(IStream *stream)
2472 {
2473     static const WCHAR spacesW[] = {' ',' ',0};
2474     int i;
2475     for (i = 0; i < xml_indent; i += 2)
2476         write_stringW(stream, spacesW);
2477 }
2478
2479 static const WCHAR start_element[] = {'<',0};
2480 static const WCHAR start_end_element[] = {'<','/',0};
2481 static const WCHAR close_element[] = {'>',0};
2482 static const WCHAR end_empty_element[] = {'/','>',0};
2483 static const WCHAR eol[] = {'\n',0};
2484 static const WCHAR spaceW[] = {' ',0};
2485 static const WCHAR equalW[] = {'=',0};
2486 static const WCHAR quoteW[] = {'"',0};
2487
2488 static inline HRESULT write_empty_element(IStream *stream, const WCHAR *name)
2489 {
2490     write_indent(stream);
2491     write_stringW(stream, start_element);
2492     write_stringW(stream, name);
2493     write_stringW(stream, end_empty_element);
2494     return write_stringW(stream, eol);
2495 }
2496
2497 static inline HRESULT write_element(IStream *stream, const WCHAR *name)
2498 {
2499     write_indent(stream);
2500     write_stringW(stream, start_element);
2501     write_stringW(stream, name);
2502     write_stringW(stream, close_element);
2503     return write_stringW(stream, eol);
2504 }
2505
2506 static inline HRESULT write_element_end(IStream *stream, const WCHAR *name)
2507 {
2508     write_indent(stream);
2509     write_stringW(stream, start_end_element);
2510     write_stringW(stream, name);
2511     write_stringW(stream, close_element);
2512     return write_stringW(stream, eol);
2513 }
2514
2515 static inline HRESULT write_text_value(IStream *stream, const WCHAR *name, const WCHAR *value)
2516 {
2517     write_indent(stream);
2518     write_stringW(stream, start_element);
2519     write_stringW(stream, name);
2520     write_stringW(stream, close_element);
2521     write_stringW(stream, value);
2522     write_stringW(stream, start_end_element);
2523     write_stringW(stream, name);
2524     write_stringW(stream, close_element);
2525     return write_stringW(stream, eol);
2526 }
2527
2528 static HRESULT write_task_attributes(IStream *stream, ITaskDefinition *taskdef)
2529 {
2530     HRESULT hr;
2531     ITaskSettings *taskset;
2532     TASK_COMPATIBILITY level;
2533     const WCHAR *compatibility;
2534
2535     hr = ITaskDefinition_get_Settings(taskdef, &taskset);
2536     if (hr != S_OK) return hr;
2537
2538     hr = ITaskSettings_get_Compatibility(taskset, &level);
2539     if (hr != S_OK) level = TASK_COMPATIBILITY_V2_1;
2540
2541     ITaskSettings_Release(taskset);
2542
2543     switch (level)
2544     {
2545     case TASK_COMPATIBILITY_AT:
2546         compatibility = v1_0;
2547         break;
2548     case TASK_COMPATIBILITY_V1:
2549         compatibility = v1_1;
2550         break;
2551     case TASK_COMPATIBILITY_V2:
2552         compatibility = v1_2;
2553         break;
2554     default:
2555         compatibility = v1_3;
2556         break;
2557     }
2558
2559     write_stringW(stream, start_element);
2560     write_stringW(stream, Task);
2561     write_stringW(stream, spaceW);
2562     write_stringW(stream, version);
2563     write_stringW(stream, equalW);
2564     write_stringW(stream, quoteW);
2565     write_stringW(stream, compatibility);
2566     write_stringW(stream, quoteW);
2567     write_stringW(stream, spaceW);
2568     write_stringW(stream, xmlns);
2569     write_stringW(stream, equalW);
2570     write_stringW(stream, quoteW);
2571     write_stringW(stream, task_ns);
2572     write_stringW(stream, quoteW);
2573     write_stringW(stream, close_element);
2574     return write_stringW(stream, eol);
2575 }
2576
2577 static HRESULT write_registration_info(IStream *stream, IRegistrationInfo *reginfo)
2578 {
2579     HRESULT hr;
2580     BSTR bstr;
2581     VARIANT var;
2582
2583     if (!reginfo)
2584         return write_empty_element(stream, RegistrationInfo);
2585
2586     hr = write_element(stream, RegistrationInfo);
2587     if (hr != S_OK) return hr;
2588
2589     push_indent();
2590
2591     hr = IRegistrationInfo_get_Source(reginfo, &bstr);
2592     if (hr == S_OK && bstr)
2593     {
2594         hr = write_text_value(stream, Source, bstr);
2595         SysFreeString(bstr);
2596         if (hr != S_OK) return hr;
2597     }
2598     hr = IRegistrationInfo_get_Date(reginfo, &bstr);
2599     if (hr == S_OK && bstr)
2600     {
2601         hr = write_text_value(stream, Date, bstr);
2602         SysFreeString(bstr);
2603         if (hr != S_OK) return hr;
2604     }
2605     hr = IRegistrationInfo_get_Author(reginfo, &bstr);
2606     if (hr == S_OK && bstr)
2607     {
2608         hr = write_text_value(stream, Author, bstr);
2609         SysFreeString(bstr);
2610         if (hr != S_OK) return hr;
2611     }
2612     hr = IRegistrationInfo_get_Version(reginfo, &bstr);
2613     if (hr == S_OK && bstr)
2614     {
2615         hr = write_text_value(stream, Version, bstr);
2616         SysFreeString(bstr);
2617         if (hr != S_OK) return hr;
2618     }
2619     hr = IRegistrationInfo_get_Description(reginfo, &bstr);
2620     if (hr == S_OK && bstr)
2621     {
2622         hr = write_text_value(stream, Description, bstr);
2623         SysFreeString(bstr);
2624         if (hr != S_OK) return hr;
2625     }
2626     hr = IRegistrationInfo_get_Documentation(reginfo, &bstr);
2627     if (hr == S_OK && bstr)
2628     {
2629         hr = write_text_value(stream, Documentation, bstr);
2630         SysFreeString(bstr);
2631         if (hr != S_OK) return hr;
2632     }
2633     hr = IRegistrationInfo_get_URI(reginfo, &bstr);
2634     if (hr == S_OK && bstr)
2635     {
2636         hr = write_text_value(stream, URI, bstr);
2637         SysFreeString(bstr);
2638         if (hr != S_OK) return hr;
2639     }
2640     hr = IRegistrationInfo_get_SecurityDescriptor(reginfo, &var);
2641     if (hr == S_OK)
2642     {
2643         if (V_VT(&var) == VT_BSTR)
2644         {
2645             hr = write_text_value(stream, SecurityDescriptor, V_BSTR(&var));
2646             VariantClear(&var);
2647             if (hr != S_OK) return hr;
2648         }
2649         else
2650             FIXME("SecurityInfo variant type %d is not supported\n", V_VT(&var));
2651     }
2652
2653     pop_indent();
2654
2655     return write_element_end(stream, RegistrationInfo);
2656 }
2657
2658 static HRESULT write_principal(IStream *stream, IPrincipal *principal)
2659 {
2660     HRESULT hr;
2661     BSTR bstr;
2662     TASK_LOGON_TYPE logon;
2663     TASK_RUNLEVEL_TYPE level;
2664
2665     if (!principal)
2666         return write_empty_element(stream, Principals);
2667
2668     hr = write_element(stream, Principals);
2669     if (hr != S_OK) return hr;
2670
2671     push_indent();
2672
2673     hr = IPrincipal_get_Id(principal, &bstr);
2674     if (hr == S_OK)
2675     {
2676         write_indent(stream);
2677         write_stringW(stream, start_element);
2678         write_stringW(stream, principalW);
2679         write_stringW(stream, spaceW);
2680         write_stringW(stream, id);
2681         write_stringW(stream, equalW);
2682         write_stringW(stream, quoteW);
2683         write_stringW(stream, bstr);
2684         write_stringW(stream, quoteW);
2685         write_stringW(stream, close_element);
2686         write_stringW(stream, eol);
2687         SysFreeString(bstr);
2688     }
2689     else
2690         write_element(stream, principalW);
2691
2692     push_indent();
2693
2694     hr = IPrincipal_get_GroupId(principal, &bstr);
2695     if (hr == S_OK)
2696     {
2697         hr = write_text_value(stream, GroupId, bstr);
2698         SysFreeString(bstr);
2699         if (hr != S_OK) return hr;
2700     }
2701     hr = IPrincipal_get_DisplayName(principal, &bstr);
2702     if (hr == S_OK)
2703     {
2704         hr = write_text_value(stream, DisplayName, bstr);
2705         SysFreeString(bstr);
2706         if (hr != S_OK) return hr;
2707     }
2708     hr = IPrincipal_get_UserId(principal, &bstr);
2709     if (hr == S_OK && lstrlenW(bstr))
2710     {
2711         hr = write_text_value(stream, UserId, bstr);
2712         SysFreeString(bstr);
2713         if (hr != S_OK) return hr;
2714     }
2715     hr = IPrincipal_get_RunLevel(principal, &level);
2716     if (hr == S_OK)
2717     {
2718         const WCHAR *level_str = NULL;
2719
2720         switch (level)
2721         {
2722         case TASK_RUNLEVEL_HIGHEST:
2723             level_str = HighestAvailable;
2724             break;
2725         case TASK_RUNLEVEL_LUA:
2726             level_str = LeastPrivilege;
2727             break;
2728         default:
2729             FIXME("Principal run level %d\n", level);
2730             break;
2731         }
2732
2733         if (level_str)
2734         {
2735             hr = write_text_value(stream, RunLevel, level_str);
2736             if (hr != S_OK) return hr;
2737         }
2738     }
2739     hr = IPrincipal_get_LogonType(principal, &logon);
2740     if (hr == S_OK)
2741     {
2742         const WCHAR *logon_str = NULL;
2743
2744         switch (logon)
2745         {
2746         case TASK_LOGON_PASSWORD:
2747             logon_str = Password;
2748             break;
2749         case TASK_LOGON_S4U:
2750             logon_str = S4U;
2751             break;
2752         case TASK_LOGON_INTERACTIVE_TOKEN:
2753             logon_str = InteractiveToken;
2754             break;
2755         default:
2756             FIXME("Principal logon type %d\n", logon);
2757             break;
2758         }
2759
2760         if (logon_str)
2761         {
2762             hr = write_text_value(stream, LogonType, logon_str);
2763             if (hr != S_OK) return hr;
2764         }
2765     }
2766
2767     pop_indent();
2768     write_element_end(stream, principalW);
2769
2770     pop_indent();
2771     return write_element_end(stream, Principals);
2772 }
2773
2774 static HRESULT write_settings(IStream *stream, ITaskSettings *settings)
2775 {
2776     if (!settings)
2777         return write_empty_element(stream, Settings);
2778
2779     FIXME("stub\n");
2780     return S_OK;
2781 }
2782
2783 static HRESULT write_triggers(IStream *stream, ITriggerCollection *triggers)
2784 {
2785     if (!triggers)
2786         return write_empty_element(stream, Triggers);
2787
2788     FIXME("stub\n");
2789     return S_OK;
2790 }
2791
2792 static HRESULT write_actions(IStream *stream, IActionCollection *actions)
2793 {
2794     if (!actions)
2795     {
2796         write_element(stream, actionsW);
2797         push_indent();
2798         write_empty_element(stream, Exec);
2799         pop_indent();
2800         return write_element_end(stream, actionsW);
2801     }
2802
2803     FIXME("stub\n");
2804     return S_OK;
2805 }
2806
2807 static HRESULT WINAPI TaskDefinition_get_XmlText(ITaskDefinition *iface, BSTR *xml)
2808 {
2809     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2810     HRESULT hr;
2811     IStream *stream;
2812     HGLOBAL hmem;
2813     void *p;
2814
2815     TRACE("%p,%p\n", iface, xml);
2816
2817     hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 16);
2818     if (!hmem) return E_OUTOFMEMORY;
2819
2820     hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
2821     if (hr != S_OK)
2822     {
2823         GlobalFree(hmem);
2824         return hr;
2825     }
2826
2827     hr = write_task_attributes(stream, &taskdef->ITaskDefinition_iface);
2828     if (hr != S_OK) goto failed;
2829
2830     push_indent();
2831
2832     hr = write_registration_info(stream, taskdef->reginfo);
2833     if (hr != S_OK) goto failed;
2834
2835     hr = write_triggers(stream, taskdef->triggers);
2836     if (hr != S_OK) goto failed;
2837
2838     hr = write_principal(stream, taskdef->principal);
2839     if (hr != S_OK) goto failed;
2840
2841     hr = write_settings(stream, taskdef->taskset);
2842     if (hr != S_OK) goto failed;
2843
2844     hr = write_actions(stream, taskdef->actions);
2845     if (hr != S_OK) goto failed;
2846
2847     pop_indent();
2848
2849     write_element_end(stream, Task);
2850     IStream_Write(stream, "\0\0", 2, NULL);
2851
2852     p = GlobalLock(hmem);
2853     *xml = SysAllocString(p);
2854     GlobalUnlock(hmem);
2855
2856     IStream_Release(stream);
2857
2858     return *xml ? S_OK : E_OUTOFMEMORY;
2859
2860 failed:
2861     IStream_Release(stream);
2862     return hr;
2863 }
2864
2865 static HRESULT read_text_value(IXmlReader *reader, WCHAR **value)
2866 {
2867     HRESULT hr;
2868     XmlNodeType type;
2869
2870     while (IXmlReader_Read(reader, &type) == S_OK)
2871     {
2872         switch (type)
2873         {
2874         case XmlNodeType_Text:
2875             hr = IXmlReader_GetValue(reader, (const WCHAR **)value, NULL);
2876             if (hr != S_OK) return hr;
2877             TRACE("%s\n", debugstr_w(*value));
2878             return S_OK;
2879
2880         case XmlNodeType_Whitespace:
2881         case XmlNodeType_Comment:
2882             break;
2883
2884         default:
2885             FIXME("unexpected node type %d\n", type);
2886             return E_FAIL;
2887         }
2888     }
2889
2890     return E_FAIL;
2891 }
2892
2893 static HRESULT read_variantbool_value(IXmlReader *reader, VARIANT_BOOL *vbool)
2894 {
2895     static const WCHAR trueW[] = {'t','r','u','e',0};
2896     static const WCHAR falseW[] = {'f','a','l','s','e',0};
2897     HRESULT hr;
2898     WCHAR *value;
2899
2900     hr = read_text_value(reader, &value);
2901     if (hr != S_OK) return hr;
2902
2903     if (!lstrcmpW(value, trueW))
2904         *vbool = VARIANT_TRUE;
2905     else if (!lstrcmpW(value, falseW))
2906         *vbool = VARIANT_FALSE;
2907     else
2908     {
2909         WARN("unexpected bool value %s\n", debugstr_w(value));
2910         return SCHED_E_INVALIDVALUE;
2911     }
2912
2913     return S_OK;
2914 }
2915
2916 static HRESULT read_int_value(IXmlReader *reader, int *int_val)
2917 {
2918     HRESULT hr;
2919     WCHAR *value;
2920
2921     hr = read_text_value(reader, &value);
2922     if (hr != S_OK) return hr;
2923
2924     *int_val = strtolW(value, NULL, 10);
2925
2926     return S_OK;
2927 }
2928
2929 static HRESULT read_triggers(IXmlReader *reader, ITaskDefinition *taskdef)
2930 {
2931     FIXME("stub\n");
2932     return S_OK;
2933 }
2934
2935 static HRESULT read_principal_attributes(IXmlReader *reader, IPrincipal *principal)
2936 {
2937     HRESULT hr;
2938     const WCHAR *name;
2939     const WCHAR *value;
2940
2941     hr = IXmlReader_MoveToFirstAttribute(reader);
2942
2943     while (hr == S_OK)
2944     {
2945         hr = IXmlReader_GetLocalName(reader, &name, NULL);
2946         if (hr != S_OK) break;
2947
2948         hr = IXmlReader_GetValue(reader, &value, NULL);
2949         if (hr != S_OK) break;
2950
2951         TRACE("%s=%s\n", debugstr_w(name), debugstr_w(value));
2952
2953         if (!lstrcmpW(name, id))
2954             IPrincipal_put_Id(principal, (BSTR)value);
2955         else
2956             FIXME("unhandled Principal attribute %s\n", debugstr_w(name));
2957
2958         hr = IXmlReader_MoveToNextAttribute(reader);
2959     }
2960
2961     return S_OK;
2962 }
2963
2964 static HRESULT read_principal(IXmlReader *reader, IPrincipal *principal)
2965 {
2966     HRESULT hr;
2967     XmlNodeType type;
2968     const WCHAR *name;
2969     WCHAR *value;
2970
2971     if (IXmlReader_IsEmptyElement(reader))
2972     {
2973         TRACE("Principal is empty\n");
2974         return S_OK;
2975     }
2976
2977     read_principal_attributes(reader, principal);
2978
2979     while (IXmlReader_Read(reader, &type) == S_OK)
2980     {
2981         switch (type)
2982         {
2983         case XmlNodeType_EndElement:
2984             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2985             if (hr != S_OK) return hr;
2986
2987             TRACE("/%s\n", debugstr_w(name));
2988
2989             if (!lstrcmpW(name, principalW))
2990                 return S_OK;
2991
2992             break;
2993
2994         case XmlNodeType_Element:
2995             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2996             if (hr != S_OK) return hr;
2997
2998             TRACE("Element: %s\n", debugstr_w(name));
2999
3000             if (!lstrcmpW(name, UserId))
3001             {
3002                 hr = read_text_value(reader, &value);
3003                 if (hr == S_OK)
3004                     IPrincipal_put_UserId(principal, value);
3005             }
3006             else if (!lstrcmpW(name, LogonType))
3007             {
3008                 hr = read_text_value(reader, &value);
3009                 if (hr == S_OK)
3010                 {
3011                     TASK_LOGON_TYPE logon = TASK_LOGON_NONE;
3012
3013                     if (!lstrcmpW(value, InteractiveToken))
3014                         logon = TASK_LOGON_INTERACTIVE_TOKEN;
3015                     else
3016                         FIXME("unhandled LogonType %s\n", debugstr_w(value));
3017
3018                     IPrincipal_put_LogonType(principal, logon);
3019                 }
3020             }
3021             else if (!lstrcmpW(name, RunLevel))
3022             {
3023                 hr = read_text_value(reader, &value);
3024                 if (hr == S_OK)
3025                 {
3026                     TASK_RUNLEVEL_TYPE level = TASK_RUNLEVEL_LUA;
3027
3028                     if (!lstrcmpW(value, LeastPrivilege))
3029                         level = TASK_RUNLEVEL_LUA;
3030                     else
3031                         FIXME("unhandled RunLevel %s\n", debugstr_w(value));
3032
3033                     IPrincipal_put_RunLevel(principal, level);
3034                 }
3035             }
3036             else
3037                 FIXME("unhandled Principal element %s\n", debugstr_w(name));
3038
3039             break;
3040
3041         case XmlNodeType_Whitespace:
3042         case XmlNodeType_Comment:
3043             break;
3044
3045         default:
3046             FIXME("unhandled Principal node type %d\n", type);
3047             break;
3048         }
3049     }
3050
3051     WARN("Principal was not terminated\n");
3052     return E_FAIL;
3053 }
3054
3055 static HRESULT read_principals(IXmlReader *reader, ITaskDefinition *taskdef)
3056 {
3057     HRESULT hr;
3058     XmlNodeType type;
3059     const WCHAR *name;
3060
3061     if (IXmlReader_IsEmptyElement(reader))
3062     {
3063         TRACE("Principals is empty\n");
3064         return S_OK;
3065     }
3066
3067     while (IXmlReader_Read(reader, &type) == S_OK)
3068     {
3069         switch (type)
3070         {
3071         case XmlNodeType_EndElement:
3072             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3073             if (hr != S_OK) return hr;
3074
3075             TRACE("/%s\n", debugstr_w(name));
3076
3077             if (!lstrcmpW(name, Principals))
3078                 return S_OK;
3079
3080             break;
3081
3082         case XmlNodeType_Element:
3083             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3084             if (hr != S_OK) return hr;
3085
3086             TRACE("Element: %s\n", debugstr_w(name));
3087
3088             if (!lstrcmpW(name, principalW))
3089             {
3090                 IPrincipal *principal;
3091
3092                 hr = ITaskDefinition_get_Principal(taskdef, &principal);
3093                 if (hr != S_OK) return hr;
3094                 hr = read_principal(reader, principal);
3095                 IPrincipal_Release(principal);
3096             }
3097             else
3098                 FIXME("unhandled Principals element %s\n", debugstr_w(name));
3099
3100             break;
3101
3102         case XmlNodeType_Whitespace:
3103         case XmlNodeType_Comment:
3104             break;
3105
3106         default:
3107             FIXME("unhandled Principals node type %d\n", type);
3108             break;
3109         }
3110     }
3111
3112     WARN("Principals was not terminated\n");
3113     return E_FAIL;
3114 }
3115
3116 static HRESULT read_actions(IXmlReader *reader, ITaskDefinition *taskdef)
3117 {
3118     FIXME("stub\n");
3119     return S_OK;
3120 }
3121
3122 static HRESULT read_idle_settings(IXmlReader *reader, ITaskSettings *taskset)
3123 {
3124     FIXME("stub\n");
3125     return S_OK;
3126 }
3127
3128 static HRESULT read_settings(IXmlReader *reader, ITaskSettings *taskset)
3129 {
3130     HRESULT hr;
3131     XmlNodeType type;
3132     const WCHAR *name;
3133     WCHAR *value;
3134     VARIANT_BOOL bool_val;
3135     int int_val;
3136
3137     if (IXmlReader_IsEmptyElement(reader))
3138     {
3139         TRACE("Settings is empty\n");
3140         return S_OK;
3141     }
3142
3143     while (IXmlReader_Read(reader, &type) == S_OK)
3144     {
3145         switch (type)
3146         {
3147         case XmlNodeType_EndElement:
3148             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3149             if (hr != S_OK) return hr;
3150
3151             TRACE("/%s\n", debugstr_w(name));
3152
3153             if (!lstrcmpW(name, Settings))
3154                 return S_OK;
3155
3156             break;
3157
3158         case XmlNodeType_Element:
3159             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3160             if (hr != S_OK) return hr;
3161
3162             TRACE("Element: %s\n", debugstr_w(name));
3163
3164             if (!lstrcmpW(name, MultipleInstancesPolicy))
3165             {
3166                 hr = read_text_value(reader, &value);
3167                 if (hr == S_OK)
3168                 {
3169                     int_val = TASK_INSTANCES_IGNORE_NEW;
3170
3171                     if (!lstrcmpW(value, IgnoreNew))
3172                         int_val = TASK_INSTANCES_IGNORE_NEW;
3173                     else
3174                         FIXME("unhandled MultipleInstancesPolicy %s\n", debugstr_w(value));
3175
3176                     ITaskSettings_put_MultipleInstances(taskset, int_val);
3177                 }
3178             }
3179             else if (!lstrcmpW(name, DisallowStartIfOnBatteries))
3180             {
3181                 hr = read_variantbool_value(reader, &bool_val);
3182                 if (hr != S_OK) return hr;
3183                 ITaskSettings_put_DisallowStartIfOnBatteries(taskset, bool_val);
3184             }
3185             else if (!lstrcmpW(name, AllowStartOnDemand))
3186             {
3187                 hr = read_variantbool_value(reader, &bool_val);
3188                 if (hr != S_OK) return hr;
3189                 ITaskSettings_put_AllowDemandStart(taskset, bool_val);
3190             }
3191             else if (!lstrcmpW(name, StopIfGoingOnBatteries))
3192             {
3193                 hr = read_variantbool_value(reader, &bool_val);
3194                 if (hr != S_OK) return hr;
3195                 ITaskSettings_put_StopIfGoingOnBatteries(taskset, bool_val);
3196             }
3197             else if (!lstrcmpW(name, AllowHardTerminate))
3198             {
3199                 hr = read_variantbool_value(reader, &bool_val);
3200                 if (hr != S_OK) return hr;
3201                 ITaskSettings_put_AllowHardTerminate(taskset, bool_val);
3202             }
3203             else if (!lstrcmpW(name, StartWhenAvailable))
3204             {
3205                 hr = read_variantbool_value(reader, &bool_val);
3206                 if (hr != S_OK) return hr;
3207                 ITaskSettings_put_StartWhenAvailable(taskset, bool_val);
3208             }
3209             else if (!lstrcmpW(name, RunOnlyIfNetworkAvailable))
3210             {
3211                 hr = read_variantbool_value(reader, &bool_val);
3212                 if (hr != S_OK) return hr;
3213                 ITaskSettings_put_RunOnlyIfNetworkAvailable(taskset, bool_val);
3214             }
3215             else if (!lstrcmpW(name, Enabled))
3216             {
3217                 hr = read_variantbool_value(reader, &bool_val);
3218                 if (hr != S_OK) return hr;
3219                 ITaskSettings_put_Enabled(taskset, bool_val);
3220             }
3221             else if (!lstrcmpW(name, Hidden))
3222             {
3223                 hr = read_variantbool_value(reader, &bool_val);
3224                 if (hr != S_OK) return hr;
3225                 ITaskSettings_put_Hidden(taskset, bool_val);
3226             }
3227             else if (!lstrcmpW(name, RunOnlyIfIdle))
3228             {
3229                 hr = read_variantbool_value(reader, &bool_val);
3230                 if (hr != S_OK) return hr;
3231                 ITaskSettings_put_RunOnlyIfIdle(taskset, bool_val);
3232             }
3233             else if (!lstrcmpW(name, WakeToRun))
3234             {
3235                 hr = read_variantbool_value(reader, &bool_val);
3236                 if (hr != S_OK) return hr;
3237                 ITaskSettings_put_WakeToRun(taskset, bool_val);
3238             }
3239             else if (!lstrcmpW(name, ExecutionTimeLimit))
3240             {
3241                 hr = read_text_value(reader, &value);
3242                 if (hr == S_OK)
3243                     ITaskSettings_put_ExecutionTimeLimit(taskset, value);
3244             }
3245             else if (!lstrcmpW(name, Priority))
3246             {
3247                 hr = read_int_value(reader, &int_val);
3248                 if (hr == S_OK)
3249                     ITaskSettings_put_Priority(taskset, int_val);
3250             }
3251             else if (!lstrcmpW(name, IdleSettings))
3252             {
3253                 hr = read_idle_settings(reader, taskset);
3254                 if (hr != S_OK) return hr;
3255             }
3256             else
3257                 FIXME("unhandled Settings element %s\n", debugstr_w(name));
3258
3259             break;
3260
3261         case XmlNodeType_Whitespace:
3262         case XmlNodeType_Comment:
3263             break;
3264
3265         default:
3266             FIXME("unhandled Settings node type %d\n", type);
3267             break;
3268         }
3269     }
3270
3271     WARN("Settings was not terminated\n");
3272     return SCHED_E_MALFORMEDXML;
3273 }
3274
3275 static HRESULT read_registration_info(IXmlReader *reader, IRegistrationInfo *info)
3276 {
3277     HRESULT hr;
3278     XmlNodeType type;
3279     const WCHAR *name;
3280     WCHAR *value;
3281
3282     if (IXmlReader_IsEmptyElement(reader))
3283     {
3284         TRACE("RegistrationInfo is empty\n");
3285         return S_OK;
3286     }
3287
3288     while (IXmlReader_Read(reader, &type) == S_OK)
3289     {
3290         switch (type)
3291         {
3292         case XmlNodeType_EndElement:
3293             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3294             if (hr != S_OK) return hr;
3295
3296             TRACE("/%s\n", debugstr_w(name));
3297
3298             if (!lstrcmpW(name, RegistrationInfo))
3299                 return S_OK;
3300
3301             break;
3302
3303         case XmlNodeType_Element:
3304             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3305             if (hr != S_OK) return hr;
3306
3307             TRACE("Element: %s\n", debugstr_w(name));
3308
3309             if (!lstrcmpW(name, Author))
3310             {
3311                 hr = read_text_value(reader, &value);
3312                 if (hr == S_OK)
3313                     IRegistrationInfo_put_Author(info, value);
3314             }
3315             else if (!lstrcmpW(name, Description))
3316             {
3317                 hr = read_text_value(reader, &value);
3318                 if (hr == S_OK)
3319                     IRegistrationInfo_put_Description(info, value);
3320             }
3321             else if (!lstrcmpW(name, Version))
3322             {
3323                 hr = read_text_value(reader, &value);
3324                 if (hr == S_OK)
3325                     IRegistrationInfo_put_Version(info, value);
3326             }
3327             else if (!lstrcmpW(name, Date))
3328             {
3329                 hr = read_text_value(reader, &value);
3330                 if (hr == S_OK)
3331                     IRegistrationInfo_put_Date(info, value);
3332             }
3333             else if (!lstrcmpW(name, Documentation))
3334             {
3335                 hr = read_text_value(reader, &value);
3336                 if (hr == S_OK)
3337                     IRegistrationInfo_put_Documentation(info, value);
3338             }
3339             else
3340                 FIXME("unhandled RegistrationInfo element %s\n", debugstr_w(name));
3341
3342             break;
3343
3344         case XmlNodeType_Whitespace:
3345         case XmlNodeType_Comment:
3346             break;
3347
3348         default:
3349             FIXME("unhandled RegistrationInfo node type %d\n", type);
3350             break;
3351         }
3352     }
3353
3354     WARN("RegistrationInfo was not terminated\n");
3355     return SCHED_E_MALFORMEDXML;
3356 }
3357
3358 static HRESULT read_task_attributes(IXmlReader *reader, ITaskDefinition *taskdef)
3359 {
3360     HRESULT hr;
3361     ITaskSettings *taskset;
3362     const WCHAR *name;
3363     const WCHAR *value;
3364     BOOL xmlns_ok = FALSE;
3365
3366     TRACE("\n");
3367
3368     hr = ITaskDefinition_get_Settings(taskdef, &taskset);
3369     if (hr != S_OK) return hr;
3370
3371     hr = IXmlReader_MoveToFirstAttribute(reader);
3372
3373     while (hr == S_OK)
3374     {
3375         hr = IXmlReader_GetLocalName(reader, &name, NULL);
3376         if (hr != S_OK) break;
3377
3378         hr = IXmlReader_GetValue(reader, &value, NULL);
3379         if (hr != S_OK) break;
3380
3381         TRACE("%s=%s\n", debugstr_w(name), debugstr_w(value));
3382
3383         if (!lstrcmpW(name, version))
3384         {
3385             TASK_COMPATIBILITY compatibility = TASK_COMPATIBILITY_V2;
3386
3387             if (!lstrcmpW(value, v1_0))
3388                 compatibility = TASK_COMPATIBILITY_AT;
3389             else if (!lstrcmpW(value, v1_1))
3390                 compatibility = TASK_COMPATIBILITY_V1;
3391             else if (!lstrcmpW(value, v1_2))
3392                 compatibility = TASK_COMPATIBILITY_V2;
3393             else if (!lstrcmpW(value, v1_3))
3394                 compatibility = TASK_COMPATIBILITY_V2_1;
3395             else
3396                 FIXME("unknown version %s\n", debugstr_w(value));
3397
3398             ITaskSettings_put_Compatibility(taskset, compatibility);
3399         }
3400         else if (!lstrcmpW(name, xmlns))
3401         {
3402             if (lstrcmpW(value, task_ns))
3403             {
3404                 FIXME("unknown namespace %s\n", debugstr_w(value));
3405                 break;
3406             }
3407             xmlns_ok = TRUE;
3408         }
3409         else
3410             FIXME("unhandled Task attribute %s\n", debugstr_w(name));
3411
3412         hr = IXmlReader_MoveToNextAttribute(reader);
3413     }
3414
3415     ITaskSettings_Release(taskset);
3416     return xmlns_ok ? S_OK : SCHED_E_NAMESPACE;
3417 }
3418
3419 static HRESULT read_task(IXmlReader *reader, ITaskDefinition *taskdef)
3420 {
3421     HRESULT hr;
3422     XmlNodeType type;
3423     const WCHAR *name;
3424
3425     if (IXmlReader_IsEmptyElement(reader))
3426     {
3427         TRACE("Task is empty\n");
3428         return S_OK;
3429     }
3430
3431     while (IXmlReader_Read(reader, &type) == S_OK)
3432     {
3433         switch (type)
3434         {
3435         case XmlNodeType_EndElement:
3436             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3437             if (hr != S_OK) return hr;
3438
3439             TRACE("/%s\n", debugstr_w(name));
3440
3441             if (!lstrcmpW(name, Task))
3442                 return S_OK;
3443
3444             break;
3445
3446         case XmlNodeType_Element:
3447             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3448             if (hr != S_OK) return hr;
3449
3450             TRACE("Element: %s\n", debugstr_w(name));
3451
3452             if (!lstrcmpW(name, RegistrationInfo))
3453             {
3454                 IRegistrationInfo *info;
3455
3456                 hr = ITaskDefinition_get_RegistrationInfo(taskdef, &info);
3457                 if (hr != S_OK) return hr;
3458                 hr = read_registration_info(reader, info);
3459                 IRegistrationInfo_Release(info);
3460             }
3461             else if (!lstrcmpW(name, Settings))
3462             {
3463                 ITaskSettings *taskset;
3464
3465                 hr = ITaskDefinition_get_Settings(taskdef, &taskset);
3466                 if (hr != S_OK) return hr;
3467                 hr = read_settings(reader, taskset);
3468                 ITaskSettings_Release(taskset);
3469             }
3470             else if (!lstrcmpW(name, Triggers))
3471                 hr = read_triggers(reader, taskdef);
3472             else if (!lstrcmpW(name, Principals))
3473                 hr = read_principals(reader, taskdef);
3474             else if (!lstrcmpW(name, actionsW))
3475                 hr = read_actions(reader, taskdef);
3476             else
3477                 FIXME("unhandled Task element %s\n", debugstr_w(name));
3478
3479             if (hr != S_OK) return hr;
3480             break;
3481
3482         case XmlNodeType_Comment:
3483         case XmlNodeType_Whitespace:
3484             break;
3485
3486         default:
3487             FIXME("unhandled Task node type %d\n", type);
3488             break;
3489         }
3490     }
3491
3492     WARN("Task was not terminated\n");
3493     return SCHED_E_MALFORMEDXML;
3494 }
3495
3496 static HRESULT read_xml(IXmlReader *reader, ITaskDefinition *taskdef)
3497 {
3498     HRESULT hr;
3499     XmlNodeType type;
3500     const WCHAR *name;
3501
3502     while (IXmlReader_Read(reader, &type) == S_OK)
3503     {
3504         switch (type)
3505         {
3506         case XmlNodeType_XmlDeclaration:
3507             TRACE("XmlDeclaration\n");
3508             break;
3509
3510         case XmlNodeType_Element:
3511             hr = IXmlReader_GetLocalName(reader, &name, NULL);
3512             if (hr != S_OK) return hr;
3513
3514             TRACE("Element: %s\n", debugstr_w(name));
3515
3516             if (!lstrcmpW(name, Task))
3517             {
3518                 hr = read_task_attributes(reader, taskdef);
3519                 if (hr != S_OK) return hr;
3520
3521                 return read_task(reader, taskdef);
3522             }
3523             else
3524                 FIXME("unhandled XML element %s\n", debugstr_w(name));
3525
3526             break;
3527
3528         case XmlNodeType_Comment:
3529         case XmlNodeType_Whitespace:
3530             break;
3531
3532         default:
3533             FIXME("unhandled XML node type %d\n", type);
3534             break;
3535         }
3536     }
3537
3538     WARN("Task definition was not found\n");
3539     return SCHED_E_MALFORMEDXML;
3540 }
3541
3542 static HRESULT WINAPI TaskDefinition_put_XmlText(ITaskDefinition *iface, BSTR xml)
3543 {
3544     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
3545     HRESULT hr;
3546     IStream *stream;
3547     IXmlReader *reader;
3548     HGLOBAL hmem;
3549     void *buf;
3550
3551     TRACE("%p,%s\n", iface, debugstr_w(xml));
3552
3553     if (!xml) return E_INVALIDARG;
3554
3555     hmem = GlobalAlloc(0, lstrlenW(xml) * sizeof(WCHAR));
3556     if (!hmem) return E_OUTOFMEMORY;
3557
3558     buf = GlobalLock(hmem);
3559     memcpy(buf, xml, lstrlenW(xml) * sizeof(WCHAR));
3560     GlobalUnlock(hmem);
3561
3562     hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
3563     if (hr != S_OK)
3564     {
3565         GlobalFree(hmem);
3566         return hr;
3567     }
3568
3569     hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
3570     if (hr != S_OK)
3571     {
3572         IStream_Release(stream);
3573         return hr;
3574     }
3575
3576     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
3577     if (hr == S_OK)
3578     {
3579         if (taskdef->reginfo)
3580         {
3581             IRegistrationInfo_Release(taskdef->reginfo);
3582             taskdef->reginfo = NULL;
3583         }
3584         if (taskdef->taskset)
3585         {
3586             ITaskSettings_Release(taskdef->taskset);
3587             taskdef->taskset = NULL;
3588         }
3589         if (taskdef->triggers)
3590         {
3591             ITriggerCollection_Release(taskdef->triggers);
3592             taskdef->triggers = NULL;
3593         }
3594         if (taskdef->principal)
3595         {
3596             IPrincipal_Release(taskdef->principal);
3597             taskdef->principal = NULL;
3598         }
3599         if (taskdef->actions)
3600         {
3601             IActionCollection_Release(taskdef->actions);
3602             taskdef->actions = NULL;
3603         }
3604
3605         hr = read_xml(reader, iface);
3606     }
3607
3608     IXmlReader_Release(reader);
3609     IStream_Release(stream);
3610
3611     return hr;
3612 }
3613
3614 static const ITaskDefinitionVtbl TaskDefinition_vtbl =
3615 {
3616     TaskDefinition_QueryInterface,
3617     TaskDefinition_AddRef,
3618     TaskDefinition_Release,
3619     TaskDefinition_GetTypeInfoCount,
3620     TaskDefinition_GetTypeInfo,
3621     TaskDefinition_GetIDsOfNames,
3622     TaskDefinition_Invoke,
3623     TaskDefinition_get_RegistrationInfo,
3624     TaskDefinition_put_RegistrationInfo,
3625     TaskDefinition_get_Triggers,
3626     TaskDefinition_put_Triggers,
3627     TaskDefinition_get_Settings,
3628     TaskDefinition_put_Settings,
3629     TaskDefinition_get_Data,
3630     TaskDefinition_put_Data,
3631     TaskDefinition_get_Principal,
3632     TaskDefinition_put_Principal,
3633     TaskDefinition_get_Actions,
3634     TaskDefinition_put_Actions,
3635     TaskDefinition_get_XmlText,
3636     TaskDefinition_put_XmlText
3637 };
3638
3639 HRESULT TaskDefinition_create(ITaskDefinition **obj)
3640 {
3641     TaskDefinition *taskdef;
3642
3643     taskdef = heap_alloc_zero(sizeof(*taskdef));
3644     if (!taskdef) return E_OUTOFMEMORY;
3645
3646     taskdef->ITaskDefinition_iface.lpVtbl = &TaskDefinition_vtbl;
3647     taskdef->ref = 1;
3648     *obj = &taskdef->ITaskDefinition_iface;
3649
3650     TRACE("created %p\n", *obj);
3651
3652     return S_OK;
3653 }
3654
3655 typedef struct
3656 {
3657     ITaskService ITaskService_iface;
3658     LONG ref;
3659     BOOL connected;
3660     DWORD version;
3661     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
3662 } TaskService;
3663
3664 static inline TaskService *impl_from_ITaskService(ITaskService *iface)
3665 {
3666     return CONTAINING_RECORD(iface, TaskService, ITaskService_iface);
3667 }
3668
3669 static ULONG WINAPI TaskService_AddRef(ITaskService *iface)
3670 {
3671     TaskService *task_svc = impl_from_ITaskService(iface);
3672     return InterlockedIncrement(&task_svc->ref);
3673 }
3674
3675 static ULONG WINAPI TaskService_Release(ITaskService *iface)
3676 {
3677     TaskService *task_svc = impl_from_ITaskService(iface);
3678     LONG ref = InterlockedDecrement(&task_svc->ref);
3679
3680     if (!ref)
3681     {
3682         TRACE("destroying %p\n", iface);
3683         heap_free(task_svc);
3684     }
3685
3686     return ref;
3687 }
3688
3689 static HRESULT WINAPI TaskService_QueryInterface(ITaskService *iface, REFIID riid, void **obj)
3690 {
3691     if (!riid || !obj) return E_INVALIDARG;
3692
3693     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
3694
3695     if (IsEqualGUID(riid, &IID_ITaskService) ||
3696         IsEqualGUID(riid, &IID_IDispatch) ||
3697         IsEqualGUID(riid, &IID_IUnknown))
3698     {
3699         ITaskService_AddRef(iface);
3700         *obj = iface;
3701         return S_OK;
3702     }
3703
3704     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
3705     *obj = NULL;
3706     return E_NOINTERFACE;
3707 }
3708
3709 static HRESULT WINAPI TaskService_GetTypeInfoCount(ITaskService *iface, UINT *count)
3710 {
3711     FIXME("%p,%p: stub\n", iface, count);
3712     return E_NOTIMPL;
3713 }
3714
3715 static HRESULT WINAPI TaskService_GetTypeInfo(ITaskService *iface, UINT index, LCID lcid, ITypeInfo **info)
3716 {
3717     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
3718     return E_NOTIMPL;
3719 }
3720
3721 static HRESULT WINAPI TaskService_GetIDsOfNames(ITaskService *iface, REFIID riid, LPOLESTR *names,
3722                                                 UINT count, LCID lcid, DISPID *dispid)
3723 {
3724     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
3725     return E_NOTIMPL;
3726 }
3727
3728 static HRESULT WINAPI TaskService_Invoke(ITaskService *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
3729                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
3730 {
3731     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
3732           params, result, excepinfo, argerr);
3733     return E_NOTIMPL;
3734 }
3735
3736 static HRESULT WINAPI TaskService_GetFolder(ITaskService *iface, BSTR path, ITaskFolder **folder)
3737 {
3738     TaskService *task_svc = impl_from_ITaskService(iface);
3739
3740     TRACE("%p,%s,%p\n", iface, debugstr_w(path), folder);
3741
3742     if (!folder) return E_POINTER;
3743
3744     if (!task_svc->connected)
3745         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
3746
3747     return TaskFolder_create(path, NULL, folder, FALSE);
3748 }
3749
3750 static HRESULT WINAPI TaskService_GetRunningTasks(ITaskService *iface, LONG flags, IRunningTaskCollection **tasks)
3751 {
3752     FIXME("%p,%x,%p: stub\n", iface, flags, tasks);
3753     return E_NOTIMPL;
3754 }
3755
3756 static HRESULT WINAPI TaskService_NewTask(ITaskService *iface, DWORD flags, ITaskDefinition **definition)
3757 {
3758     TRACE("%p,%x,%p\n", iface, flags, definition);
3759
3760     if (!definition) return E_POINTER;
3761
3762     if (flags)
3763         FIXME("unsupported flags %x\n", flags);
3764
3765     return TaskDefinition_create(definition);
3766 }
3767
3768 static inline BOOL is_variant_null(const VARIANT *var)
3769 {
3770     return V_VT(var) == VT_EMPTY || V_VT(var) == VT_NULL ||
3771           (V_VT(var) == VT_BSTR && (V_BSTR(var) == NULL || !*V_BSTR(var)));
3772 }
3773
3774 static HRESULT start_schedsvc(void)
3775 {
3776     static const WCHAR scheduleW[] = { 'S','c','h','e','d','u','l','e',0 };
3777     SC_HANDLE scm, service;
3778     SERVICE_STATUS_PROCESS status;
3779     ULONGLONG start_time;
3780     HRESULT hr = SCHED_E_SERVICE_NOT_RUNNING;
3781
3782     TRACE("Trying to start %s service\n", debugstr_w(scheduleW));
3783
3784     scm = OpenSCManagerW(NULL, NULL, 0);
3785     if (!scm) return SCHED_E_SERVICE_NOT_INSTALLED;
3786
3787     service = OpenServiceW(scm, scheduleW, SERVICE_START | SERVICE_QUERY_STATUS);
3788     if (service)
3789     {
3790         if (StartServiceW(service, 0, NULL) || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
3791         {
3792             start_time = GetTickCount64();
3793             do
3794             {
3795                 DWORD dummy;
3796
3797                 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(status), &dummy))
3798                 {
3799                     WARN("failed to query scheduler status (%u)\n", GetLastError());
3800                     break;
3801                 }
3802
3803                 if (status.dwCurrentState == SERVICE_RUNNING)
3804                 {
3805                     hr = S_OK;
3806                     break;
3807                 }
3808
3809                 if (GetTickCount64() - start_time > 30000) break;
3810                 Sleep(1000);
3811
3812             } while (status.dwCurrentState == SERVICE_START_PENDING);
3813
3814             if (status.dwCurrentState != SERVICE_RUNNING)
3815                 WARN("scheduler failed to start %u\n", status.dwCurrentState);
3816         }
3817         else
3818             WARN("failed to start scheduler service (%u)\n", GetLastError());
3819
3820         CloseServiceHandle(service);
3821     }
3822     else
3823         WARN("failed to open scheduler service (%u)\n", GetLastError());
3824
3825     CloseServiceHandle(scm);
3826     return hr;
3827 }
3828
3829 static HRESULT WINAPI TaskService_Connect(ITaskService *iface, VARIANT server, VARIANT user, VARIANT domain, VARIANT password)
3830 {
3831     static WCHAR ncalrpc[] = { 'n','c','a','l','r','p','c',0 };
3832     TaskService *task_svc = impl_from_ITaskService(iface);
3833     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
3834     DWORD len;
3835     HRESULT hr;
3836     RPC_WSTR binding_str;
3837     extern handle_t rpc_handle;
3838
3839     TRACE("%p,%s,%s,%s,%s\n", iface, debugstr_variant(&server), debugstr_variant(&user),
3840           debugstr_variant(&domain), debugstr_variant(&password));
3841
3842     if (!is_variant_null(&user) || !is_variant_null(&domain) || !is_variant_null(&password))
3843         FIXME("user/domain/password are ignored\n");
3844
3845     len = sizeof(comp_name)/sizeof(comp_name[0]);
3846     if (!GetComputerNameW(comp_name, &len))
3847         return HRESULT_FROM_WIN32(GetLastError());
3848
3849     if (!is_variant_null(&server))
3850     {
3851         const WCHAR *server_name;
3852
3853         if (V_VT(&server) != VT_BSTR)
3854         {
3855             FIXME("server variant type %d is not supported\n", V_VT(&server));
3856             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
3857         }
3858
3859         /* skip UNC prefix if any */
3860         server_name = V_BSTR(&server);
3861         if (server_name[0] == '\\' && server_name[1] == '\\')
3862             server_name += 2;
3863
3864         if (strcmpiW(server_name, comp_name))
3865         {
3866             FIXME("connection to remote server %s is not supported\n", debugstr_w(V_BSTR(&server)));
3867             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
3868         }
3869     }
3870
3871     hr = start_schedsvc();
3872     if (hr != S_OK) return hr;
3873
3874     hr = RpcStringBindingComposeW(NULL, ncalrpc, NULL, NULL, NULL, &binding_str);
3875     if (hr != RPC_S_OK) return hr;
3876     hr = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
3877     RpcStringFreeW(&binding_str);
3878     if (hr != RPC_S_OK) return hr;
3879
3880     /* Make sure that the connection works */
3881     hr = SchRpcHighestVersion(&task_svc->version);
3882     if (hr != S_OK) return hr;
3883
3884     TRACE("server version %#x\n", task_svc->version);
3885
3886     strcpyW(task_svc->comp_name, comp_name);
3887     task_svc->connected = TRUE;
3888
3889     return S_OK;
3890 }
3891
3892 static HRESULT WINAPI TaskService_get_Connected(ITaskService *iface, VARIANT_BOOL *connected)
3893 {
3894     TaskService *task_svc = impl_from_ITaskService(iface);
3895
3896     TRACE("%p,%p\n", iface, connected);
3897
3898     if (!connected) return E_POINTER;
3899
3900     *connected = task_svc->connected ? VARIANT_TRUE : VARIANT_FALSE;
3901
3902     return S_OK;
3903 }
3904
3905 static HRESULT WINAPI TaskService_get_TargetServer(ITaskService *iface, BSTR *server)
3906 {
3907     TaskService *task_svc = impl_from_ITaskService(iface);
3908
3909     TRACE("%p,%p\n", iface, server);
3910
3911     if (!server) return E_POINTER;
3912
3913     if (!task_svc->connected)
3914         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
3915
3916     *server = SysAllocString(task_svc->comp_name);
3917     if (!*server) return E_OUTOFMEMORY;
3918
3919     return S_OK;
3920 }
3921
3922 static HRESULT WINAPI TaskService_get_ConnectedUser(ITaskService *iface, BSTR *user)
3923 {
3924     FIXME("%p,%p: stub\n", iface, user);
3925     return E_NOTIMPL;
3926 }
3927
3928 static HRESULT WINAPI TaskService_get_ConnectedDomain(ITaskService *iface, BSTR *domain)
3929 {
3930     FIXME("%p,%p: stub\n", iface, domain);
3931     return E_NOTIMPL;
3932 }
3933
3934 static HRESULT WINAPI TaskService_get_HighestVersion(ITaskService *iface, DWORD *version)
3935 {
3936     TaskService *task_svc = impl_from_ITaskService(iface);
3937
3938     TRACE("%p,%p\n", iface, version);
3939
3940     if (!version) return E_POINTER;
3941
3942     if (!task_svc->connected)
3943         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
3944
3945     *version = task_svc->version;
3946
3947     return S_OK;
3948 }
3949
3950 static const ITaskServiceVtbl TaskService_vtbl =
3951 {
3952     TaskService_QueryInterface,
3953     TaskService_AddRef,
3954     TaskService_Release,
3955     TaskService_GetTypeInfoCount,
3956     TaskService_GetTypeInfo,
3957     TaskService_GetIDsOfNames,
3958     TaskService_Invoke,
3959     TaskService_GetFolder,
3960     TaskService_GetRunningTasks,
3961     TaskService_NewTask,
3962     TaskService_Connect,
3963     TaskService_get_Connected,
3964     TaskService_get_TargetServer,
3965     TaskService_get_ConnectedUser,
3966     TaskService_get_ConnectedDomain,
3967     TaskService_get_HighestVersion
3968 };
3969
3970 HRESULT TaskService_create(void **obj)
3971 {
3972     TaskService *task_svc;
3973
3974     task_svc = heap_alloc(sizeof(*task_svc));
3975     if (!task_svc) return E_OUTOFMEMORY;
3976
3977     task_svc->ITaskService_iface.lpVtbl = &TaskService_vtbl;
3978     task_svc->ref = 1;
3979     task_svc->connected = FALSE;
3980     *obj = &task_svc->ITaskService_iface;
3981
3982     TRACE("created %p\n", *obj);
3983
3984     return S_OK;
3985 }
3986
3987 void __RPC_FAR *__RPC_USER MIDL_user_allocate(SIZE_T n)
3988 {
3989     return HeapAlloc(GetProcessHeap(), 0, n);
3990 }
3991
3992 void __RPC_USER MIDL_user_free(void __RPC_FAR *p)
3993 {
3994     HeapFree(GetProcessHeap(), 0, p);
3995 }