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