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