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 E_NOTIMPL;
 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 E_NOTIMPL;
 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 E_NOTIMPL;
 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     TRACE("%p,%s\n", iface, debugstr_w(interval));
 928     return E_NOTIMPL;
 929 }
 930
 931 static HRESULT WINAPI TaskSettings_get_RestartCount(ITaskSettings *iface, INT *count)
 932 {
 933     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 934
 935     TRACE("%p,%p\n", iface, count);
 936
 937     if (!count) return E_POINTER;
 938
 939     *count = taskset->restart_count;
 940
 941     return S_OK;
 942 }
 943
 944 static HRESULT WINAPI TaskSettings_put_RestartCount(ITaskSettings *iface, INT count)
 945 {
 946     FIXME("%p,%d: stub\n", iface, count);
 947     return E_NOTIMPL;
 948 }
 949
 950 static HRESULT WINAPI TaskSettings_get_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY *policy)
 951 {
 952     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 953
 954     TRACE("%p,%p\n", iface, policy);
 955
 956     if (!policy) return E_POINTER;
 957
 958     *policy = taskset->policy;
 959
 960     return S_OK;
 961 }
 962
 963 static HRESULT WINAPI TaskSettings_put_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY policy)
 964 {
 965     FIXME("%p,%d: stub\n", iface, policy);
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI TaskSettings_get_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL *stop)
 970 {
 971     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 972
 973     TRACE("%p,%p\n", iface, stop);
 974
 975     if (!stop) return E_POINTER;
 976
 977     *stop = taskset->stop_if_going_on_batteries ? VARIANT_TRUE : VARIANT_FALSE;
 978
 979     return S_OK;
 980 }
 981
 982 static HRESULT WINAPI TaskSettings_put_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL stop)
 983 {
 984     FIXME("%p,%d: stub\n", iface, stop);
 985     return E_NOTIMPL;
 986 }
 987
 988 static HRESULT WINAPI TaskSettings_get_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL *disallow)
 989 {
 990     TaskSettings *taskset = impl_from_ITaskSettings(iface);
 991
 992     TRACE("%p,%p\n", iface, disallow);
 993
 994     if (!disallow) return E_POINTER;
 995
 996     *disallow = taskset->disallow_start_if_on_batteries ? VARIANT_TRUE : VARIANT_FALSE;
 997
 998     return S_OK;
 999 }
1000
1001 static HRESULT WINAPI TaskSettings_put_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL disallow)
1002 {
1003     FIXME("%p,%d: stub\n", iface, disallow);
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI TaskSettings_get_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL *allow)
1008 {
1009     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1010
1011     TRACE("%p,%p\n", iface, allow);
1012
1013     if (!allow) return E_POINTER;
1014
1015     *allow = taskset->allow_hard_terminate ? VARIANT_TRUE : VARIANT_FALSE;
1016
1017     return S_OK;
1018 }
1019
1020 static HRESULT WINAPI TaskSettings_put_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL allow)
1021 {
1022     FIXME("%p,%d: stub\n", iface, allow);
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI TaskSettings_get_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL *start)
1027 {
1028     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1029
1030     TRACE("%p,%p\n", iface, start);
1031
1032     if (!start) return E_POINTER;
1033
1034     *start = taskset->start_when_available ? VARIANT_TRUE : VARIANT_FALSE;
1035
1036     return S_OK;
1037 }
1038
1039 static HRESULT WINAPI TaskSettings_put_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL start)
1040 {
1041     FIXME("%p,%d: stub\n", iface, start);
1042     return E_NOTIMPL;
1043 }
1044
1045 static HRESULT WINAPI TaskSettings_get_XmlText(ITaskSettings *iface, BSTR *xml)
1046 {
1047     FIXME("%p,%p: stub\n", iface, xml);
1048     return E_NOTIMPL;
1049 }
1050
1051 static HRESULT WINAPI TaskSettings_put_XmlText(ITaskSettings *iface, BSTR xml)
1052 {
1053     FIXME("%p,%s: stub\n", iface, debugstr_w(xml));
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI TaskSettings_get_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL *run)
1058 {
1059     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1060
1061     TRACE("%p,%p\n", iface, run);
1062
1063     if (!run) return E_POINTER;
1064
1065     *run = taskset->run_only_if_network_available ? VARIANT_TRUE : VARIANT_FALSE;
1066
1067     return S_OK;
1068 }
1069
1070 static HRESULT WINAPI TaskSettings_put_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL run)
1071 {
1072     FIXME("%p,%d: stub\n", iface, run);
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI TaskSettings_get_ExecutionTimeLimit(ITaskSettings *iface, BSTR *limit)
1077 {
1078     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1079
1080     TRACE("%p,%p\n", iface, limit);
1081
1082     if (!limit) return E_POINTER;
1083
1084     if (!taskset->execution_time_limit)
1085     {
1086         *limit = NULL;
1087         return S_OK;
1088     }
1089
1090     *limit = SysAllocString(taskset->execution_time_limit);
1091     if (!*limit) return E_OUTOFMEMORY;
1092
1093     return S_OK;
1094 }
1095
1096 static HRESULT WINAPI TaskSettings_put_ExecutionTimeLimit(ITaskSettings *iface, BSTR limit)
1097 {
1098     TRACE("%p,%s\n", iface, debugstr_w(limit));
1099     return E_NOTIMPL;
1100 }
1101
1102 static HRESULT WINAPI TaskSettings_get_Enabled(ITaskSettings *iface, VARIANT_BOOL *enabled)
1103 {
1104     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1105
1106     TRACE("%p,%p\n", iface, enabled);
1107
1108     if (!enabled) return E_POINTER;
1109
1110     *enabled = taskset->enabled ? VARIANT_TRUE : VARIANT_FALSE;
1111
1112     return S_OK;
1113 }
1114
1115 static HRESULT WINAPI TaskSettings_put_Enabled(ITaskSettings *iface, VARIANT_BOOL enabled)
1116 {
1117     FIXME("%p,%d: stub\n", iface, enabled);
1118     return E_NOTIMPL;
1119 }
1120
1121 static HRESULT WINAPI TaskSettings_get_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR *delay)
1122 {
1123     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1124
1125     TRACE("%p,%p\n", iface, delay);
1126
1127     if (!delay) return E_POINTER;
1128
1129     if (!taskset->delete_expired_task_after)
1130     {
1131         *delay = NULL;
1132         return S_OK;
1133     }
1134
1135     *delay = SysAllocString(taskset->delete_expired_task_after);
1136     if (!*delay) return E_OUTOFMEMORY;
1137
1138     return S_OK;
1139 }
1140
1141 static HRESULT WINAPI TaskSettings_put_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR delay)
1142 {
1143     TRACE("%p,%s\n", iface, debugstr_w(delay));
1144     return E_NOTIMPL;
1145 }
1146
1147 static HRESULT WINAPI TaskSettings_get_Priority(ITaskSettings *iface, INT *priority)
1148 {
1149     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1150
1151     TRACE("%p,%p\n", iface, priority);
1152
1153     if (!priority) return E_POINTER;
1154
1155     *priority = taskset->priority;
1156
1157     return S_OK;
1158 }
1159
1160 static HRESULT WINAPI TaskSettings_put_Priority(ITaskSettings *iface, INT priority)
1161 {
1162     FIXME("%p,%d: stub\n", iface, priority);
1163     return E_NOTIMPL;
1164 }
1165
1166 static HRESULT WINAPI TaskSettings_get_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY *level)
1167 {
1168     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1169
1170     TRACE("%p,%p\n", iface, level);
1171
1172     if (!level) return E_POINTER;
1173
1174     *level = taskset->compatibility;
1175
1176     return S_OK;
1177 }
1178
1179 static HRESULT WINAPI TaskSettings_put_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY level)
1180 {
1181     FIXME("%p,%d: stub\n", iface, level);
1182     return E_NOTIMPL;
1183 }
1184
1185 static HRESULT WINAPI TaskSettings_get_Hidden(ITaskSettings *iface, VARIANT_BOOL *hidden)
1186 {
1187     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1188
1189     TRACE("%p,%p\n", iface, hidden);
1190
1191     if (!hidden) return E_POINTER;
1192
1193     *hidden = taskset->hidden ? VARIANT_TRUE : VARIANT_FALSE;
1194
1195     return S_OK;
1196 }
1197
1198 static HRESULT WINAPI TaskSettings_put_Hidden(ITaskSettings *iface, VARIANT_BOOL hidden)
1199 {
1200     FIXME("%p,%d: stub\n", iface, hidden);
1201     return E_NOTIMPL;
1202 }
1203
1204 static HRESULT WINAPI TaskSettings_get_IdleSettings(ITaskSettings *iface, IIdleSettings **settings)
1205 {
1206     FIXME("%p,%p: stub\n", iface, settings);
1207     return E_NOTIMPL;
1208 }
1209
1210 static HRESULT WINAPI TaskSettings_put_IdleSettings(ITaskSettings *iface, IIdleSettings *settings)
1211 {
1212     FIXME("%p,%p: stub\n", iface, settings);
1213     return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI TaskSettings_get_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL *run)
1217 {
1218     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1219
1220     TRACE("%p,%p\n", iface, run);
1221
1222     if (!run) return E_POINTER;
1223
1224     *run = taskset->run_only_if_idle ? VARIANT_TRUE : VARIANT_FALSE;
1225
1226     return S_OK;
1227 }
1228
1229 static HRESULT WINAPI TaskSettings_put_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL run)
1230 {
1231     FIXME("%p,%d: stub\n", iface, run);
1232     return E_NOTIMPL;
1233 }
1234
1235 static HRESULT WINAPI TaskSettings_get_WakeToRun(ITaskSettings *iface, VARIANT_BOOL *wake)
1236 {
1237     TaskSettings *taskset = impl_from_ITaskSettings(iface);
1238
1239     TRACE("%p,%p\n", iface, wake);
1240
1241     if (!wake) return E_POINTER;
1242
1243     *wake = taskset->wake_to_run ? VARIANT_TRUE : VARIANT_FALSE;
1244
1245     return S_OK;
1246 }
1247
1248 static HRESULT WINAPI TaskSettings_put_WakeToRun(ITaskSettings *iface, VARIANT_BOOL wake)
1249 {
1250     FIXME("%p,%d: stub\n", iface, wake);
1251     return E_NOTIMPL;
1252 }
1253
1254 static HRESULT WINAPI TaskSettings_get_NetworkSettings(ITaskSettings *iface, INetworkSettings **settings)
1255 {
1256     FIXME("%p,%p: stub\n", iface, settings);
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT WINAPI TaskSettings_put_NetworkSettings(ITaskSettings *iface, INetworkSettings *settings)
1261 {
1262     FIXME("%p,%p: stub\n", iface, settings);
1263     return E_NOTIMPL;
1264 }
1265
1266 static const ITaskSettingsVtbl TaskSettings_vtbl =
1267 {
1268     TaskSettings_QueryInterface,
1269     TaskSettings_AddRef,
1270     TaskSettings_Release,
1271     TaskSettings_GetTypeInfoCount,
1272     TaskSettings_GetTypeInfo,
1273     TaskSettings_GetIDsOfNames,
1274     TaskSettings_Invoke,
1275     TaskSettings_get_AllowDemandStart,
1276     TaskSettings_put_AllowDemandStart,
1277     TaskSettings_get_RestartInterval,
1278     TaskSettings_put_RestartInterval,
1279     TaskSettings_get_RestartCount,
1280     TaskSettings_put_RestartCount,
1281     TaskSettings_get_MultipleInstances,
1282     TaskSettings_put_MultipleInstances,
1283     TaskSettings_get_StopIfGoingOnBatteries,
1284     TaskSettings_put_StopIfGoingOnBatteries,
1285     TaskSettings_get_DisallowStartIfOnBatteries,
1286     TaskSettings_put_DisallowStartIfOnBatteries,
1287     TaskSettings_get_AllowHardTerminate,
1288     TaskSettings_put_AllowHardTerminate,
1289     TaskSettings_get_StartWhenAvailable,
1290     TaskSettings_put_StartWhenAvailable,
1291     TaskSettings_get_XmlText,
1292     TaskSettings_put_XmlText,
1293     TaskSettings_get_RunOnlyIfNetworkAvailable,
1294     TaskSettings_put_RunOnlyIfNetworkAvailable,
1295     TaskSettings_get_ExecutionTimeLimit,
1296     TaskSettings_put_ExecutionTimeLimit,
1297     TaskSettings_get_Enabled,
1298     TaskSettings_put_Enabled,
1299     TaskSettings_get_DeleteExpiredTaskAfter,
1300     TaskSettings_put_DeleteExpiredTaskAfter,
1301     TaskSettings_get_Priority,
1302     TaskSettings_put_Priority,
1303     TaskSettings_get_Compatibility,
1304     TaskSettings_put_Compatibility,
1305     TaskSettings_get_Hidden,
1306     TaskSettings_put_Hidden,
1307     TaskSettings_get_IdleSettings,
1308     TaskSettings_put_IdleSettings,
1309     TaskSettings_get_RunOnlyIfIdle,
1310     TaskSettings_put_RunOnlyIfIdle,
1311     TaskSettings_get_WakeToRun,
1312     TaskSettings_put_WakeToRun,
1313     TaskSettings_get_NetworkSettings,
1314     TaskSettings_put_NetworkSettings
1315 };
1316
1317 static HRESULT TaskSettings_create(ITaskSettings **obj)
1318 {
1319     static const WCHAR exec_time_limit[] = { 'P','T','7','2','H',0 };
1320     TaskSettings *taskset;
1321
1322     taskset = heap_alloc(sizeof(*taskset));
1323     if (!taskset) return E_OUTOFMEMORY;
1324
1325     taskset->ITaskSettings_iface.lpVtbl = &TaskSettings_vtbl;
1326     taskset->ref = 1;
1327     /* set the defaults */
1328     taskset->restart_interval = NULL;
1329     taskset->execution_time_limit = heap_strdupW(exec_time_limit);
1330     taskset->delete_expired_task_after = NULL;
1331     taskset->restart_count = 0;
1332     taskset->priority = 7;
1333     taskset->policy = TASK_INSTANCES_IGNORE_NEW;
1334     taskset->compatibility = TASK_COMPATIBILITY_V2;
1335     taskset->allow_on_demand_start = TRUE;
1336     taskset->stop_if_going_on_batteries = TRUE;
1337     taskset->disallow_start_if_on_batteries = TRUE;
1338     taskset->allow_hard_terminate = TRUE;
1339     taskset->start_when_available = FALSE;
1340     taskset->run_only_if_network_available = FALSE;
1341     taskset->enabled = TRUE;
1342     taskset->hidden = FALSE;
1343     taskset->run_only_if_idle = FALSE;
1344     taskset->wake_to_run = FALSE;
1345
1346     *obj = &taskset->ITaskSettings_iface;
1347
1348     TRACE("created %p\n", *obj);
1349
1350     return S_OK;
1351 }
1352
1353 typedef struct
1354 {
1355     ITaskDefinition ITaskDefinition_iface;
1356     LONG ref;
1357     IRegistrationInfo *reginfo;
1358     ITaskSettings *taskset;
1359     ITriggerCollection *triggers;
1360     IPrincipal *principal;
1361     IActionCollection *actions;
1362 } TaskDefinition;
1363
1364 static inline TaskDefinition *impl_from_ITaskDefinition(ITaskDefinition *iface)
1365 {
1366     return CONTAINING_RECORD(iface, TaskDefinition, ITaskDefinition_iface);
1367 }
1368
1369 static ULONG WINAPI TaskDefinition_AddRef(ITaskDefinition *iface)
1370 {
1371     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1372     return InterlockedIncrement(&taskdef->ref);
1373 }
1374
1375 static ULONG WINAPI TaskDefinition_Release(ITaskDefinition *iface)
1376 {
1377     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1378     LONG ref = InterlockedDecrement(&taskdef->ref);
1379
1380     if (!ref)
1381     {
1382         TRACE("destroying %p\n", iface);
1383
1384         if (taskdef->reginfo)
1385             IRegistrationInfo_Release(taskdef->reginfo);
1386         if (taskdef->taskset)
1387             ITaskSettings_Release(taskdef->taskset);
1388         if (taskdef->triggers)
1389             ITriggerCollection_Release(taskdef->triggers);
1390         if (taskdef->principal)
1391             IPrincipal_Release(taskdef->principal);
1392         if (taskdef->actions)
1393             IActionCollection_Release(taskdef->actions);
1394
1395         heap_free(taskdef);
1396     }
1397
1398     return ref;
1399 }
1400
1401 static HRESULT WINAPI TaskDefinition_QueryInterface(ITaskDefinition *iface, REFIID riid, void **obj)
1402 {
1403     if (!riid || !obj) return E_INVALIDARG;
1404
1405     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
1406
1407     if (IsEqualGUID(riid, &IID_ITaskDefinition) ||
1408         IsEqualGUID(riid, &IID_IDispatch) ||
1409         IsEqualGUID(riid, &IID_IUnknown))
1410     {
1411         ITaskDefinition_AddRef(iface);
1412         *obj = iface;
1413         return S_OK;
1414     }
1415
1416     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
1417     *obj = NULL;
1418     return E_NOINTERFACE;
1419 }
1420
1421 static HRESULT WINAPI TaskDefinition_GetTypeInfoCount(ITaskDefinition *iface, UINT *count)
1422 {
1423     FIXME("%p,%p: stub\n", iface, count);
1424     return E_NOTIMPL;
1425 }
1426
1427 static HRESULT WINAPI TaskDefinition_GetTypeInfo(ITaskDefinition *iface, UINT index, LCID lcid, ITypeInfo **info)
1428 {
1429     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI TaskDefinition_GetIDsOfNames(ITaskDefinition *iface, REFIID riid, LPOLESTR *names,
1434                                                    UINT count, LCID lcid, DISPID *dispid)
1435 {
1436     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI TaskDefinition_Invoke(ITaskDefinition *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
1441                                             DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
1442 {
1443     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
1444           params, result, excepinfo, argerr);
1445     return E_NOTIMPL;
1446 }
1447
1448 static HRESULT WINAPI TaskDefinition_get_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo **info)
1449 {
1450     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1451     HRESULT hr;
1452
1453     TRACE("%p,%p\n", iface, info);
1454
1455     if (!info) return E_POINTER;
1456
1457     if (!taskdef->reginfo)
1458     {
1459         hr = RegistrationInfo_create(&taskdef->reginfo);
1460         if (hr != S_OK) return hr;
1461     }
1462
1463     IRegistrationInfo_AddRef(taskdef->reginfo);
1464     *info = taskdef->reginfo;
1465
1466     return S_OK;
1467 }
1468
1469 static HRESULT WINAPI TaskDefinition_put_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo *info)
1470 {
1471     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1472
1473     TRACE("%p,%p\n", iface, info);
1474
1475     if (!info) return E_POINTER;
1476
1477     if (taskdef->reginfo)
1478         IRegistrationInfo_Release(taskdef->reginfo);
1479
1480     IRegistrationInfo_AddRef(info);
1481     taskdef->reginfo = info;
1482
1483     return S_OK;
1484 }
1485
1486 static HRESULT WINAPI TaskDefinition_get_Triggers(ITaskDefinition *iface, ITriggerCollection **triggers)
1487 {
1488     TaskDefinition *This = impl_from_ITaskDefinition(iface);
1489
1490     TRACE("%p,%p\n", This, triggers);
1491
1492     if (!This->triggers)
1493     {
1494         trigger_collection *collection;
1495
1496         collection = heap_alloc(sizeof(*collection));
1497         if (!collection) return E_OUTOFMEMORY;
1498
1499         collection->ITriggerCollection_iface.lpVtbl = &TriggerCollection_vtbl;
1500         collection->ref = 1;
1501         This->triggers = &collection->ITriggerCollection_iface;
1502     }
1503
1504     ITriggerCollection_AddRef(*triggers = This->triggers);
1505     return S_OK;
1506 }
1507
1508 static HRESULT WINAPI TaskDefinition_put_Triggers(ITaskDefinition *iface, ITriggerCollection *triggers)
1509 {
1510     FIXME("%p,%p: stub\n", iface, triggers);
1511     return E_NOTIMPL;
1512 }
1513
1514 static HRESULT WINAPI TaskDefinition_get_Settings(ITaskDefinition *iface, ITaskSettings **settings)
1515 {
1516     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1517     HRESULT hr;
1518
1519     TRACE("%p,%p\n", iface, settings);
1520
1521     if (!settings) return E_POINTER;
1522
1523     if (!taskdef->taskset)
1524     {
1525         hr = TaskSettings_create(&taskdef->taskset);
1526         if (hr != S_OK) return hr;
1527     }
1528
1529     ITaskSettings_AddRef(taskdef->taskset);
1530     *settings = taskdef->taskset;
1531
1532     return S_OK;
1533 }
1534
1535 static HRESULT WINAPI TaskDefinition_put_Settings(ITaskDefinition *iface, ITaskSettings *settings)
1536 {
1537     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1538
1539     TRACE("%p,%p\n", iface, settings);
1540
1541     if (!settings) return E_POINTER;
1542
1543     if (taskdef->taskset)
1544         ITaskSettings_Release(taskdef->taskset);
1545
1546     ITaskSettings_AddRef(settings);
1547     taskdef->taskset = settings;
1548
1549     return S_OK;
1550 }
1551
1552 static HRESULT WINAPI TaskDefinition_get_Data(ITaskDefinition *iface, BSTR *data)
1553 {
1554     FIXME("%p,%p: stub\n", iface, data);
1555     return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI TaskDefinition_put_Data(ITaskDefinition *iface, BSTR data)
1559 {
1560     FIXME("%p,%p: stub\n", iface, data);
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI TaskDefinition_get_Principal(ITaskDefinition *iface, IPrincipal **principal)
1565 {
1566     FIXME("%p,%p: stub\n", iface, principal);
1567     return E_NOTIMPL;
1568 }
1569
1570 static HRESULT WINAPI TaskDefinition_put_Principal(ITaskDefinition *iface, IPrincipal *principal)
1571 {
1572     FIXME("%p,%p: stub\n", iface, principal);
1573     return E_NOTIMPL;
1574 }
1575
1576 static HRESULT WINAPI TaskDefinition_get_Actions(ITaskDefinition *iface, IActionCollection **actions)
1577 {
1578     FIXME("%p,%p: stub\n", iface, actions);
1579     return E_NOTIMPL;
1580 }
1581
1582 static HRESULT WINAPI TaskDefinition_put_Actions(ITaskDefinition *iface, IActionCollection *actions)
1583 {
1584     FIXME("%p,%p: stub\n", iface, actions);
1585     return E_NOTIMPL;
1586 }
1587
1588 static const WCHAR Task[] = {'T','a','s','k',0};
1589 static const WCHAR version[] = {'v','e','r','s','i','o','n',0};
1590 static const WCHAR v1_0[] = {'1','.','0',0};
1591 static const WCHAR v1_1[] = {'1','.','1',0};
1592 static const WCHAR v1_2[] = {'1','.','2',0};
1593 static const WCHAR v1_3[] = {'1','.','3',0};
1594 static const WCHAR xmlns[] = {'x','m','l','n','s',0};
1595 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};
1596 static const WCHAR RegistrationInfo[] = {'R','e','g','i','s','t','r','a','t','i','o','n','I','n','f','o',0};
1597 static const WCHAR Author[] = {'A','u','t','h','o','r',0};
1598 static const WCHAR Description[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
1599 static const WCHAR Source[] = {'S','o','u','r','c','e',0};
1600 static const WCHAR Date[] = {'D','a','t','e',0};
1601 static const WCHAR Version[] = {'V','e','r','s','i','o','n',0};
1602 static const WCHAR Documentation[] = {'D','o','c','u','m','e','n','t','a','t','i','o','n',0};
1603 static const WCHAR URI[] = {'U','R','I',0};
1604 static const WCHAR SecurityDescriptor[] = {'S','e','c','u','r','i','t','y','D','e','s','c','r','i','p','t','o','r',0};
1605 static const WCHAR Settings[] = {'S','e','t','t','i','n','g','s',0};
1606 static const WCHAR Triggers[] = {'T','r','i','g','g','e','r','s',0};
1607 static const WCHAR Principals[] = {'P','r','i','n','c','i','p','a','l','s',0};
1608 static const WCHAR Principal[] = {'P','r','i','n','c','i','p','a','l',0};
1609 static const WCHAR id[] = {'i','d',0};
1610 static const WCHAR UserId[] = {'U','s','e','r','I','d',0};
1611 static const WCHAR LogonType[] = {'L','o','g','o','n','T','y','p','e',0};
1612 static const WCHAR GroupId[] = {'G','r','o','u','p','I','d',0};
1613 static const WCHAR DisplayName[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
1614 static const WCHAR HighestAvailable[] = {'H','i','g','h','e','s','t','A','v','a','i','l','a','b','l','e',0};
1615 static const WCHAR Password[] = {'P','a','s','s','w','o','r','d',0};
1616 static const WCHAR S4U[] = {'S','4','U',0};
1617 static const WCHAR InteractiveToken[] = {'I','n','t','e','r','a','c','t','i','v','e','T','o','k','e','n',0};
1618 static const WCHAR RunLevel[] = {'R','u','n','L','e','v','e','l',0};
1619 static const WCHAR LeastPrivilege[] = {'L','e','a','s','t','P','r','i','v','i','l','e','g','e',0};
1620 static const WCHAR Actions[] = {'A','c','t','i','o','n','s',0};
1621 static const WCHAR Exec[] = {'E','x','e','c',0};
1622 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};
1623 static const WCHAR IgnoreNew[] = {'I','g','n','o','r','e','N','e','w',0};
1624 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};
1625 static const WCHAR AllowStartOnDemand[] = {'A','l','l','o','w','S','t','a','r','t','O','n','D','e','m','a','n','d',0};
1626 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};
1627 static const WCHAR AllowHardTerminate[] = {'A','l','l','o','w','H','a','r','d','T','e','r','m','i','n','a','t','e',0};
1628 static const WCHAR StartWhenAvailable[] = {'S','t','a','r','t','W','h','e','n','A','v','a','i','l','a','b','l','e',0};
1629 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};
1630 static const WCHAR Enabled[] = {'E','n','a','b','l','e','d',0};
1631 static const WCHAR Hidden[] = {'H','i','d','d','e','n',0};
1632 static const WCHAR RunOnlyIfIdle[] = {'R','u','n','O','n','l','y','I','f','I','d','l','e',0};
1633 static const WCHAR WakeToRun[] = {'W','a','k','e','T','o','R','u','n',0};
1634 static const WCHAR ExecutionTimeLimit[] = {'E','x','e','c','u','t','i','o','n','T','i','m','e','L','i','m','i','t',0};
1635 static const WCHAR Priority[] = {'P','r','i','o','r','i','t','y',0};
1636 static const WCHAR IdleSettings[] = {'I','d','l','e','S','e','t','t','i','n','g','s',0};
1637
1638 static int xml_indent;
1639
1640 static inline void push_indent(void)
1641 {
1642     xml_indent += 2;
1643 }
1644
1645 static inline void pop_indent(void)
1646 {
1647     xml_indent -= 2;
1648 }
1649
1650 static inline HRESULT write_stringW(IStream *stream, const WCHAR *str)
1651 {
1652     return IStream_Write(stream, str, lstrlenW(str) * sizeof(WCHAR), NULL);
1653 }
1654
1655 static void write_indent(IStream *stream)
1656 {
1657     static const WCHAR spacesW[] = {' ',' ',0};
1658     int i;
1659     for (i = 0; i < xml_indent; i += 2)
1660         write_stringW(stream, spacesW);
1661 }
1662
1663 static const WCHAR start_element[] = {'<',0};
1664 static const WCHAR start_end_element[] = {'<','/',0};
1665 static const WCHAR close_element[] = {'>',0};
1666 static const WCHAR end_empty_element[] = {'/','>',0};
1667 static const WCHAR eol[] = {'\n',0};
1668 static const WCHAR spaceW[] = {' ',0};
1669 static const WCHAR equalW[] = {'=',0};
1670 static const WCHAR quoteW[] = {'"',0};
1671
1672 static inline HRESULT write_empty_element(IStream *stream, const WCHAR *name)
1673 {
1674     write_indent(stream);
1675     write_stringW(stream, start_element);
1676     write_stringW(stream, name);
1677     write_stringW(stream, end_empty_element);
1678     return write_stringW(stream, eol);
1679 }
1680
1681 static inline HRESULT write_element(IStream *stream, const WCHAR *name)
1682 {
1683     write_indent(stream);
1684     write_stringW(stream, start_element);
1685     write_stringW(stream, name);
1686     write_stringW(stream, close_element);
1687     return write_stringW(stream, eol);
1688 }
1689
1690 static inline HRESULT write_element_end(IStream *stream, const WCHAR *name)
1691 {
1692     write_indent(stream);
1693     write_stringW(stream, start_end_element);
1694     write_stringW(stream, name);
1695     write_stringW(stream, close_element);
1696     return write_stringW(stream, eol);
1697 }
1698
1699 static inline HRESULT write_text_value(IStream *stream, const WCHAR *name, const WCHAR *value)
1700 {
1701     write_indent(stream);
1702     write_stringW(stream, start_element);
1703     write_stringW(stream, name);
1704     write_stringW(stream, close_element);
1705     write_stringW(stream, value);
1706     write_stringW(stream, start_end_element);
1707     write_stringW(stream, name);
1708     write_stringW(stream, close_element);
1709     return write_stringW(stream, eol);
1710 }
1711
1712 static HRESULT write_task_attributes(IStream *stream, ITaskDefinition *taskdef)
1713 {
1714     HRESULT hr;
1715     ITaskSettings *taskset;
1716     TASK_COMPATIBILITY level;
1717     const WCHAR *compatibility;
1718
1719     hr = ITaskDefinition_get_Settings(taskdef, &taskset);
1720     if (hr != S_OK) return hr;
1721
1722     hr = ITaskSettings_get_Compatibility(taskset, &level);
1723     if (hr != S_OK) level = TASK_COMPATIBILITY_V2_1;
1724
1725     ITaskSettings_Release(taskset);
1726
1727     switch (level)
1728     {
1729     case TASK_COMPATIBILITY_AT:
1730         compatibility = v1_0;
1731         break;
1732     case TASK_COMPATIBILITY_V1:
1733         compatibility = v1_1;
1734         break;
1735     case TASK_COMPATIBILITY_V2:
1736         compatibility = v1_2;
1737         break;
1738     default:
1739         compatibility = v1_3;
1740         break;
1741     }
1742
1743     write_stringW(stream, start_element);
1744     write_stringW(stream, Task);
1745     write_stringW(stream, spaceW);
1746     write_stringW(stream, version);
1747     write_stringW(stream, equalW);
1748     write_stringW(stream, quoteW);
1749     write_stringW(stream, compatibility);
1750     write_stringW(stream, quoteW);
1751     write_stringW(stream, spaceW);
1752     write_stringW(stream, xmlns);
1753     write_stringW(stream, equalW);
1754     write_stringW(stream, quoteW);
1755     write_stringW(stream, task_ns);
1756     write_stringW(stream, quoteW);
1757     write_stringW(stream, close_element);
1758     return write_stringW(stream, eol);
1759 }
1760
1761 static HRESULT write_registration_info(IStream *stream, IRegistrationInfo *reginfo)
1762 {
1763     HRESULT hr;
1764     BSTR bstr;
1765     VARIANT var;
1766
1767     if (!reginfo)
1768         return write_empty_element(stream, RegistrationInfo);
1769
1770     hr = write_element(stream, RegistrationInfo);
1771     if (hr != S_OK) return hr;
1772
1773     push_indent();
1774
1775     hr = IRegistrationInfo_get_Source(reginfo, &bstr);
1776     if (hr == S_OK && bstr)
1777     {
1778         hr = write_text_value(stream, Source, bstr);
1779         SysFreeString(bstr);
1780         if (hr != S_OK) return hr;
1781     }
1782     hr = IRegistrationInfo_get_Date(reginfo, &bstr);
1783     if (hr == S_OK && bstr)
1784     {
1785         hr = write_text_value(stream, Date, bstr);
1786         SysFreeString(bstr);
1787         if (hr != S_OK) return hr;
1788     }
1789     hr = IRegistrationInfo_get_Author(reginfo, &bstr);
1790     if (hr == S_OK && bstr)
1791     {
1792         hr = write_text_value(stream, Author, bstr);
1793         SysFreeString(bstr);
1794         if (hr != S_OK) return hr;
1795     }
1796     hr = IRegistrationInfo_get_Version(reginfo, &bstr);
1797     if (hr == S_OK && bstr)
1798     {
1799         hr = write_text_value(stream, Version, bstr);
1800         SysFreeString(bstr);
1801         if (hr != S_OK) return hr;
1802     }
1803     hr = IRegistrationInfo_get_Description(reginfo, &bstr);
1804     if (hr == S_OK && bstr)
1805     {
1806         hr = write_text_value(stream, Description, bstr);
1807         SysFreeString(bstr);
1808         if (hr != S_OK) return hr;
1809     }
1810     hr = IRegistrationInfo_get_Documentation(reginfo, &bstr);
1811     if (hr == S_OK && bstr)
1812     {
1813         hr = write_text_value(stream, Documentation, bstr);
1814         SysFreeString(bstr);
1815         if (hr != S_OK) return hr;
1816     }
1817     hr = IRegistrationInfo_get_URI(reginfo, &bstr);
1818     if (hr == S_OK && bstr)
1819     {
1820         hr = write_text_value(stream, URI, bstr);
1821         SysFreeString(bstr);
1822         if (hr != S_OK) return hr;
1823     }
1824     hr = IRegistrationInfo_get_SecurityDescriptor(reginfo, &var);
1825     if (hr == S_OK)
1826     {
1827         if (V_VT(&var) == VT_BSTR)
1828         {
1829             hr = write_text_value(stream, SecurityDescriptor, V_BSTR(&var));
1830             VariantClear(&var);
1831             if (hr != S_OK) return hr;
1832         }
1833         else
1834             FIXME("SecurityInfo variant type %d is not supported\n", V_VT(&var));
1835     }
1836
1837     pop_indent();
1838
1839     return write_element_end(stream, RegistrationInfo);
1840 }
1841
1842 static HRESULT write_principal(IStream *stream, IPrincipal *principal)
1843 {
1844     HRESULT hr;
1845     BSTR bstr;
1846     TASK_LOGON_TYPE logon;
1847     TASK_RUNLEVEL_TYPE level;
1848
1849     if (!principal)
1850         return write_empty_element(stream, Principals);
1851
1852     hr = write_element(stream, Principals);
1853     if (hr != S_OK) return hr;
1854
1855     push_indent();
1856
1857     hr = IPrincipal_get_Id(principal, &bstr);
1858     if (hr == S_OK)
1859     {
1860         write_indent(stream);
1861         write_stringW(stream, start_element);
1862         write_stringW(stream, Principal);
1863         write_stringW(stream, spaceW);
1864         write_stringW(stream, id);
1865         write_stringW(stream, equalW);
1866         write_stringW(stream, quoteW);
1867         write_stringW(stream, bstr);
1868         write_stringW(stream, quoteW);
1869         write_stringW(stream, close_element);
1870         write_stringW(stream, eol);
1871         SysFreeString(bstr);
1872     }
1873     else
1874         write_element(stream, Principal);
1875
1876     push_indent();
1877
1878     hr = IPrincipal_get_GroupId(principal, &bstr);
1879     if (hr == S_OK)
1880     {
1881         hr = write_text_value(stream, GroupId, bstr);
1882         SysFreeString(bstr);
1883         if (hr != S_OK) return hr;
1884     }
1885     hr = IPrincipal_get_DisplayName(principal, &bstr);
1886     if (hr == S_OK)
1887     {
1888         hr = write_text_value(stream, DisplayName, bstr);
1889         SysFreeString(bstr);
1890         if (hr != S_OK) return hr;
1891     }
1892     hr = IPrincipal_get_UserId(principal, &bstr);
1893     if (hr == S_OK && lstrlenW(bstr))
1894     {
1895         hr = write_text_value(stream, UserId, bstr);
1896         SysFreeString(bstr);
1897         if (hr != S_OK) return hr;
1898     }
1899     hr = IPrincipal_get_RunLevel(principal, &level);
1900     if (hr == S_OK)
1901     {
1902         const WCHAR *level_str = NULL;
1903
1904         switch (level)
1905         {
1906         case TASK_RUNLEVEL_HIGHEST:
1907             level_str = HighestAvailable;
1908             break;
1909         case TASK_RUNLEVEL_LUA:
1910             level_str = LeastPrivilege;
1911             break;
1912         default:
1913             FIXME("Principal run level %d\n", level);
1914             break;
1915         }
1916
1917         if (level_str)
1918         {
1919             hr = write_text_value(stream, RunLevel, level_str);
1920             if (hr != S_OK) return hr;
1921         }
1922     }
1923     hr = IPrincipal_get_LogonType(principal, &logon);
1924     if (hr == S_OK)
1925     {
1926         const WCHAR *logon_str = NULL;
1927
1928         switch (logon)
1929         {
1930         case TASK_LOGON_PASSWORD:
1931             logon_str = Password;
1932             break;
1933         case TASK_LOGON_S4U:
1934             logon_str = S4U;
1935             break;
1936         case TASK_LOGON_INTERACTIVE_TOKEN:
1937             logon_str = InteractiveToken;
1938             break;
1939         default:
1940             FIXME("Principal logon type %d\n", logon);
1941             break;
1942         }
1943
1944         if (logon_str)
1945         {
1946             hr = write_text_value(stream, LogonType, logon_str);
1947             if (hr != S_OK) return hr;
1948         }
1949     }
1950
1951     pop_indent();
1952     write_element_end(stream, Principal);
1953
1954     pop_indent();
1955     return write_element_end(stream, Principals);
1956 }
1957
1958 static HRESULT write_settings(IStream *stream, ITaskSettings *settings)
1959 {
1960     if (!settings)
1961         return write_empty_element(stream, Settings);
1962
1963     FIXME("stub\n");
1964     return S_OK;
1965 }
1966
1967 static HRESULT write_triggers(IStream *stream, ITriggerCollection *triggers)
1968 {
1969     if (!triggers)
1970         return write_empty_element(stream, Triggers);
1971
1972     FIXME("stub\n");
1973     return S_OK;
1974 }
1975
1976 static HRESULT write_actions(IStream *stream, IActionCollection *actions)
1977 {
1978     if (!actions)
1979     {
1980         write_element(stream, Actions);
1981         push_indent();
1982         write_empty_element(stream, Exec);
1983         pop_indent();
1984         return write_element_end(stream, Actions);
1985     }
1986
1987     FIXME("stub\n");
1988     return S_OK;
1989 }
1990
1991 static HRESULT WINAPI TaskDefinition_get_XmlText(ITaskDefinition *iface, BSTR *xml)
1992 {
1993     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
1994     HRESULT hr;
1995     IStream *stream;
1996     HGLOBAL hmem;
1997     void *p;
1998
1999     TRACE("%p,%p\n", iface, xml);
2000
2001     hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD, 16);
2002     if (!hmem) return E_OUTOFMEMORY;
2003
2004     hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
2005     if (hr != S_OK)
2006     {
2007         GlobalFree(hmem);
2008         return hr;
2009     }
2010
2011     hr = write_task_attributes(stream, &taskdef->ITaskDefinition_iface);
2012     if (hr != S_OK) goto failed;
2013
2014     push_indent();
2015
2016     hr = write_registration_info(stream, taskdef->reginfo);
2017     if (hr != S_OK) goto failed;
2018
2019     hr = write_triggers(stream, taskdef->triggers);
2020     if (hr != S_OK) goto failed;
2021
2022     hr = write_principal(stream, taskdef->principal);
2023     if (hr != S_OK) goto failed;
2024
2025     hr = write_settings(stream, taskdef->taskset);
2026     if (hr != S_OK) goto failed;
2027
2028     hr = write_actions(stream, taskdef->actions);
2029     if (hr != S_OK) goto failed;
2030
2031     pop_indent();
2032
2033     write_element_end(stream, Task);
2034     IStream_Write(stream, "\0\0", 2, NULL);
2035
2036     p = GlobalLock(hmem);
2037     *xml = SysAllocString(p);
2038     GlobalUnlock(hmem);
2039
2040     IStream_Release(stream);
2041
2042     return *xml ? S_OK : E_OUTOFMEMORY;
2043
2044 failed:
2045     IStream_Release(stream);
2046     return hr;
2047 }
2048
2049 static HRESULT read_text_value(IXmlReader *reader, WCHAR **value)
2050 {
2051     HRESULT hr;
2052     XmlNodeType type;
2053
2054     while (IXmlReader_Read(reader, &type) == S_OK)
2055     {
2056         switch (type)
2057         {
2058         case XmlNodeType_Text:
2059             hr = IXmlReader_GetValue(reader, (const WCHAR **)value, NULL);
2060             if (hr != S_OK) return hr;
2061             TRACE("%s\n", debugstr_w(*value));
2062             return S_OK;
2063
2064         case XmlNodeType_Whitespace:
2065         case XmlNodeType_Comment:
2066             break;
2067
2068         default:
2069             FIXME("unexpected node type %d\n", type);
2070             return E_FAIL;
2071         }
2072     }
2073
2074     return E_FAIL;
2075 }
2076
2077 static HRESULT read_variantbool_value(IXmlReader *reader, VARIANT_BOOL *vbool)
2078 {
2079     static const WCHAR trueW[] = {'t','r','u','e',0};
2080     static const WCHAR falseW[] = {'f','a','l','s','e',0};
2081     HRESULT hr;
2082     WCHAR *value;
2083
2084     hr = read_text_value(reader, &value);
2085     if (hr != S_OK) return hr;
2086
2087     if (!lstrcmpW(value, trueW))
2088         *vbool = VARIANT_TRUE;
2089     else if (!lstrcmpW(value, falseW))
2090         *vbool = VARIANT_FALSE;
2091     else
2092     {
2093         WARN("unexpected bool value %s\n", debugstr_w(value));
2094         return SCHED_E_INVALIDVALUE;
2095     }
2096
2097     return S_OK;
2098 }
2099
2100 static HRESULT read_int_value(IXmlReader *reader, int *int_val)
2101 {
2102     HRESULT hr;
2103     WCHAR *value;
2104
2105     hr = read_text_value(reader, &value);
2106     if (hr != S_OK) return hr;
2107
2108     *int_val = strtolW(value, NULL, 10);
2109
2110     return S_OK;
2111 }
2112
2113 static HRESULT read_triggers(IXmlReader *reader, ITaskDefinition *taskdef)
2114 {
2115     FIXME("stub\n");
2116     return S_OK;
2117 }
2118
2119 static HRESULT read_principal_attributes(IXmlReader *reader, IPrincipal *principal)
2120 {
2121     HRESULT hr;
2122     const WCHAR *name;
2123     const WCHAR *value;
2124
2125     hr = IXmlReader_MoveToFirstAttribute(reader);
2126
2127     while (hr == S_OK)
2128     {
2129         hr = IXmlReader_GetLocalName(reader, &name, NULL);
2130         if (hr != S_OK) break;
2131
2132         hr = IXmlReader_GetValue(reader, &value, NULL);
2133         if (hr != S_OK) break;
2134
2135         TRACE("%s=%s\n", debugstr_w(name), debugstr_w(value));
2136
2137         if (!lstrcmpW(name, id))
2138             IPrincipal_put_Id(principal, (BSTR)value);
2139         else
2140             FIXME("unhandled Principal attribute %s\n", debugstr_w(name));
2141
2142         hr = IXmlReader_MoveToNextAttribute(reader);
2143     }
2144
2145     return S_OK;
2146 }
2147
2148 static HRESULT read_principal(IXmlReader *reader, IPrincipal *principal)
2149 {
2150     HRESULT hr;
2151     XmlNodeType type;
2152     const WCHAR *name;
2153     WCHAR *value;
2154
2155     if (IXmlReader_IsEmptyElement(reader))
2156     {
2157         TRACE("Principal is empty\n");
2158         return S_OK;
2159     }
2160
2161     read_principal_attributes(reader, principal);
2162
2163     while (IXmlReader_Read(reader, &type) == S_OK)
2164     {
2165         switch (type)
2166         {
2167         case XmlNodeType_EndElement:
2168             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2169             if (hr != S_OK) return hr;
2170
2171             TRACE("/%s\n", debugstr_w(name));
2172
2173             if (!lstrcmpW(name, Principal))
2174                 return S_OK;
2175
2176             break;
2177
2178         case XmlNodeType_Element:
2179             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2180             if (hr != S_OK) return hr;
2181
2182             TRACE("Element: %s\n", debugstr_w(name));
2183
2184             if (!lstrcmpW(name, UserId))
2185             {
2186                 hr = read_text_value(reader, &value);
2187                 if (hr == S_OK)
2188                     IPrincipal_put_UserId(principal, value);
2189             }
2190             else if (!lstrcmpW(name, LogonType))
2191             {
2192                 hr = read_text_value(reader, &value);
2193                 if (hr == S_OK)
2194                 {
2195                     TASK_LOGON_TYPE logon = TASK_LOGON_NONE;
2196
2197                     if (!lstrcmpW(value, InteractiveToken))
2198                         logon = TASK_LOGON_INTERACTIVE_TOKEN;
2199                     else
2200                         FIXME("unhandled LogonType %s\n", debugstr_w(value));
2201
2202                     IPrincipal_put_LogonType(principal, logon);
2203                 }
2204             }
2205             else if (!lstrcmpW(name, RunLevel))
2206             {
2207                 hr = read_text_value(reader, &value);
2208                 if (hr == S_OK)
2209                 {
2210                     TASK_RUNLEVEL_TYPE level = TASK_RUNLEVEL_LUA;
2211
2212                     if (!lstrcmpW(value, LeastPrivilege))
2213                         level = TASK_RUNLEVEL_LUA;
2214                     else
2215                         FIXME("unhandled RunLevel %s\n", debugstr_w(value));
2216
2217                     IPrincipal_put_RunLevel(principal, level);
2218                 }
2219             }
2220             else
2221                 FIXME("unhandled Principal element %s\n", debugstr_w(name));
2222
2223             break;
2224
2225         case XmlNodeType_Whitespace:
2226         case XmlNodeType_Comment:
2227             break;
2228
2229         default:
2230             FIXME("unhandled Principal node type %d\n", type);
2231             break;
2232         }
2233     }
2234
2235     WARN("Principal was not terminated\n");
2236     return E_FAIL;
2237 }
2238
2239 static HRESULT read_principals(IXmlReader *reader, ITaskDefinition *taskdef)
2240 {
2241     HRESULT hr;
2242     XmlNodeType type;
2243     const WCHAR *name;
2244
2245     if (IXmlReader_IsEmptyElement(reader))
2246     {
2247         TRACE("Principals is empty\n");
2248         return S_OK;
2249     }
2250
2251     while (IXmlReader_Read(reader, &type) == S_OK)
2252     {
2253         switch (type)
2254         {
2255         case XmlNodeType_EndElement:
2256             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2257             if (hr != S_OK) return hr;
2258
2259             TRACE("/%s\n", debugstr_w(name));
2260
2261             if (!lstrcmpW(name, Principals))
2262                 return S_OK;
2263
2264             break;
2265
2266         case XmlNodeType_Element:
2267             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2268             if (hr != S_OK) return hr;
2269
2270             TRACE("Element: %s\n", debugstr_w(name));
2271
2272             if (!lstrcmpW(name, Principal))
2273             {
2274                 IPrincipal *principal;
2275
2276                 hr = ITaskDefinition_get_Principal(taskdef, &principal);
2277                 if (hr != S_OK) return hr;
2278                 hr = read_principal(reader, principal);
2279                 IPrincipal_Release(principal);
2280             }
2281             else
2282                 FIXME("unhandled Principals element %s\n", debugstr_w(name));
2283
2284             break;
2285
2286         case XmlNodeType_Whitespace:
2287         case XmlNodeType_Comment:
2288             break;
2289
2290         default:
2291             FIXME("unhandled Principals node type %d\n", type);
2292             break;
2293         }
2294     }
2295
2296     WARN("Principals was not terminated\n");
2297     return E_FAIL;
2298 }
2299
2300 static HRESULT read_actions(IXmlReader *reader, ITaskDefinition *taskdef)
2301 {
2302     FIXME("stub\n");
2303     return S_OK;
2304 }
2305
2306 static HRESULT read_idle_settings(IXmlReader *reader, ITaskSettings *taskset)
2307 {
2308     FIXME("stub\n");
2309     return S_OK;
2310 }
2311
2312 static HRESULT read_settings(IXmlReader *reader, ITaskSettings *taskset)
2313 {
2314     HRESULT hr;
2315     XmlNodeType type;
2316     const WCHAR *name;
2317     WCHAR *value;
2318     VARIANT_BOOL bool_val;
2319     int int_val;
2320
2321     if (IXmlReader_IsEmptyElement(reader))
2322     {
2323         TRACE("Settings is empty\n");
2324         return S_OK;
2325     }
2326
2327     while (IXmlReader_Read(reader, &type) == S_OK)
2328     {
2329         switch (type)
2330         {
2331         case XmlNodeType_EndElement:
2332             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2333             if (hr != S_OK) return hr;
2334
2335             TRACE("/%s\n", debugstr_w(name));
2336
2337             if (!lstrcmpW(name, Settings))
2338                 return S_OK;
2339
2340             break;
2341
2342         case XmlNodeType_Element:
2343             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2344             if (hr != S_OK) return hr;
2345
2346             TRACE("Element: %s\n", debugstr_w(name));
2347
2348             if (!lstrcmpW(name, MultipleInstancesPolicy))
2349             {
2350                 hr = read_text_value(reader, &value);
2351                 if (hr == S_OK)
2352                 {
2353                     int_val = TASK_INSTANCES_IGNORE_NEW;
2354
2355                     if (!lstrcmpW(value, IgnoreNew))
2356                         int_val = TASK_INSTANCES_IGNORE_NEW;
2357                     else
2358                         FIXME("unhandled MultipleInstancesPolicy %s\n", debugstr_w(value));
2359
2360                     ITaskSettings_put_MultipleInstances(taskset, int_val);
2361                 }
2362             }
2363             else if (!lstrcmpW(name, DisallowStartIfOnBatteries))
2364             {
2365                 hr = read_variantbool_value(reader, &bool_val);
2366                 if (hr != S_OK) return hr;
2367                 ITaskSettings_put_DisallowStartIfOnBatteries(taskset, bool_val);
2368             }
2369             else if (!lstrcmpW(name, AllowStartOnDemand))
2370             {
2371                 hr = read_variantbool_value(reader, &bool_val);
2372                 if (hr != S_OK) return hr;
2373                 ITaskSettings_put_AllowDemandStart(taskset, bool_val);
2374             }
2375             else if (!lstrcmpW(name, StopIfGoingOnBatteries))
2376             {
2377                 hr = read_variantbool_value(reader, &bool_val);
2378                 if (hr != S_OK) return hr;
2379                 ITaskSettings_put_StopIfGoingOnBatteries(taskset, bool_val);
2380             }
2381             else if (!lstrcmpW(name, AllowHardTerminate))
2382             {
2383                 hr = read_variantbool_value(reader, &bool_val);
2384                 if (hr != S_OK) return hr;
2385                 ITaskSettings_put_AllowHardTerminate(taskset, bool_val);
2386             }
2387             else if (!lstrcmpW(name, StartWhenAvailable))
2388             {
2389                 hr = read_variantbool_value(reader, &bool_val);
2390                 if (hr != S_OK) return hr;
2391                 ITaskSettings_put_StartWhenAvailable(taskset, bool_val);
2392             }
2393             else if (!lstrcmpW(name, RunOnlyIfNetworkAvailable))
2394             {
2395                 hr = read_variantbool_value(reader, &bool_val);
2396                 if (hr != S_OK) return hr;
2397                 ITaskSettings_put_RunOnlyIfNetworkAvailable(taskset, bool_val);
2398             }
2399             else if (!lstrcmpW(name, Enabled))
2400             {
2401                 hr = read_variantbool_value(reader, &bool_val);
2402                 if (hr != S_OK) return hr;
2403                 ITaskSettings_put_Enabled(taskset, bool_val);
2404             }
2405             else if (!lstrcmpW(name, Hidden))
2406             {
2407                 hr = read_variantbool_value(reader, &bool_val);
2408                 if (hr != S_OK) return hr;
2409                 ITaskSettings_put_Hidden(taskset, bool_val);
2410             }
2411             else if (!lstrcmpW(name, RunOnlyIfIdle))
2412             {
2413                 hr = read_variantbool_value(reader, &bool_val);
2414                 if (hr != S_OK) return hr;
2415                 ITaskSettings_put_RunOnlyIfIdle(taskset, bool_val);
2416             }
2417             else if (!lstrcmpW(name, WakeToRun))
2418             {
2419                 hr = read_variantbool_value(reader, &bool_val);
2420                 if (hr != S_OK) return hr;
2421                 ITaskSettings_put_WakeToRun(taskset, bool_val);
2422             }
2423             else if (!lstrcmpW(name, ExecutionTimeLimit))
2424             {
2425                 hr = read_text_value(reader, &value);
2426                 if (hr == S_OK)
2427                     ITaskSettings_put_ExecutionTimeLimit(taskset, value);
2428             }
2429             else if (!lstrcmpW(name, Priority))
2430             {
2431                 hr = read_int_value(reader, &int_val);
2432                 if (hr == S_OK)
2433                     ITaskSettings_put_Priority(taskset, int_val);
2434             }
2435             else if (!lstrcmpW(name, IdleSettings))
2436             {
2437                 hr = read_idle_settings(reader, taskset);
2438                 if (hr != S_OK) return hr;
2439             }
2440             else
2441                 FIXME("unhandled Settings element %s\n", debugstr_w(name));
2442
2443             break;
2444
2445         case XmlNodeType_Whitespace:
2446         case XmlNodeType_Comment:
2447             break;
2448
2449         default:
2450             FIXME("unhandled Settings node type %d\n", type);
2451             break;
2452         }
2453     }
2454
2455     WARN("Settings was not terminated\n");
2456     return SCHED_E_MALFORMEDXML;
2457 }
2458
2459 static HRESULT read_registration_info(IXmlReader *reader, IRegistrationInfo *info)
2460 {
2461     HRESULT hr;
2462     XmlNodeType type;
2463     const WCHAR *name;
2464     WCHAR *value;
2465
2466     if (IXmlReader_IsEmptyElement(reader))
2467     {
2468         TRACE("RegistrationInfo is empty\n");
2469         return S_OK;
2470     }
2471
2472     while (IXmlReader_Read(reader, &type) == S_OK)
2473     {
2474         switch (type)
2475         {
2476         case XmlNodeType_EndElement:
2477             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2478             if (hr != S_OK) return hr;
2479
2480             TRACE("/%s\n", debugstr_w(name));
2481
2482             if (!lstrcmpW(name, RegistrationInfo))
2483                 return S_OK;
2484
2485             break;
2486
2487         case XmlNodeType_Element:
2488             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2489             if (hr != S_OK) return hr;
2490
2491             TRACE("Element: %s\n", debugstr_w(name));
2492
2493             if (!lstrcmpW(name, Author))
2494             {
2495                 hr = read_text_value(reader, &value);
2496                 if (hr == S_OK)
2497                     IRegistrationInfo_put_Author(info, value);
2498             }
2499             else if (!lstrcmpW(name, Description))
2500             {
2501                 hr = read_text_value(reader, &value);
2502                 if (hr == S_OK)
2503                     IRegistrationInfo_put_Description(info, value);
2504             }
2505             else
2506                 FIXME("unhandled RegistrationInfo element %s\n", debugstr_w(name));
2507
2508             break;
2509
2510         case XmlNodeType_Whitespace:
2511         case XmlNodeType_Comment:
2512             break;
2513
2514         default:
2515             FIXME("unhandled RegistrationInfo node type %d\n", type);
2516             break;
2517         }
2518     }
2519
2520     WARN("RegistrationInfo was not terminated\n");
2521     return SCHED_E_MALFORMEDXML;
2522 }
2523
2524 static HRESULT read_task_attributes(IXmlReader *reader, ITaskDefinition *taskdef)
2525 {
2526     HRESULT hr;
2527     ITaskSettings *taskset;
2528     const WCHAR *name;
2529     const WCHAR *value;
2530     BOOL xmlns_ok = FALSE;
2531
2532     TRACE("\n");
2533
2534     hr = ITaskDefinition_get_Settings(taskdef, &taskset);
2535     if (hr != S_OK) return hr;
2536
2537     hr = IXmlReader_MoveToFirstAttribute(reader);
2538
2539     while (hr == S_OK)
2540     {
2541         hr = IXmlReader_GetLocalName(reader, &name, NULL);
2542         if (hr != S_OK) break;
2543
2544         hr = IXmlReader_GetValue(reader, &value, NULL);
2545         if (hr != S_OK) break;
2546
2547         TRACE("%s=%s\n", debugstr_w(name), debugstr_w(value));
2548
2549         if (!lstrcmpW(name, version))
2550         {
2551             TASK_COMPATIBILITY compatibility = TASK_COMPATIBILITY_V2;
2552
2553             if (!lstrcmpW(value, v1_0))
2554                 compatibility = TASK_COMPATIBILITY_AT;
2555             else if (!lstrcmpW(value, v1_1))
2556                 compatibility = TASK_COMPATIBILITY_V1;
2557             else if (!lstrcmpW(value, v1_2))
2558                 compatibility = TASK_COMPATIBILITY_V2;
2559             else if (!lstrcmpW(value, v1_3))
2560                 compatibility = TASK_COMPATIBILITY_V2_1;
2561             else
2562                 FIXME("unknown version %s\n", debugstr_w(value));
2563
2564             ITaskSettings_put_Compatibility(taskset, compatibility);
2565         }
2566         else if (!lstrcmpW(name, xmlns))
2567         {
2568             if (lstrcmpW(value, task_ns))
2569             {
2570                 FIXME("unknown namespace %s\n", debugstr_w(value));
2571                 break;
2572             }
2573             xmlns_ok = TRUE;
2574         }
2575         else
2576             FIXME("unhandled Task attribute %s\n", debugstr_w(name));
2577
2578         hr = IXmlReader_MoveToNextAttribute(reader);
2579     }
2580
2581     ITaskSettings_Release(taskset);
2582     return xmlns_ok ? S_OK : SCHED_E_NAMESPACE;
2583 }
2584
2585 static HRESULT read_task(IXmlReader *reader, ITaskDefinition *taskdef)
2586 {
2587     HRESULT hr;
2588     XmlNodeType type;
2589     const WCHAR *name;
2590
2591     if (IXmlReader_IsEmptyElement(reader))
2592     {
2593         TRACE("Task is empty\n");
2594         return S_OK;
2595     }
2596
2597     while (IXmlReader_Read(reader, &type) == S_OK)
2598     {
2599         switch (type)
2600         {
2601         case XmlNodeType_EndElement:
2602             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2603             if (hr != S_OK) return hr;
2604
2605             TRACE("/%s\n", debugstr_w(name));
2606
2607             if (!lstrcmpW(name, Task))
2608                 return S_OK;
2609
2610             break;
2611
2612         case XmlNodeType_Element:
2613             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2614             if (hr != S_OK) return hr;
2615
2616             TRACE("Element: %s\n", debugstr_w(name));
2617
2618             if (!lstrcmpW(name, RegistrationInfo))
2619             {
2620                 IRegistrationInfo *info;
2621
2622                 hr = ITaskDefinition_get_RegistrationInfo(taskdef, &info);
2623                 if (hr != S_OK) return hr;
2624                 hr = read_registration_info(reader, info);
2625                 IRegistrationInfo_Release(info);
2626             }
2627             else if (!lstrcmpW(name, Settings))
2628             {
2629                 ITaskSettings *taskset;
2630
2631                 hr = ITaskDefinition_get_Settings(taskdef, &taskset);
2632                 if (hr != S_OK) return hr;
2633                 hr = read_settings(reader, taskset);
2634                 ITaskSettings_Release(taskset);
2635             }
2636             else if (!lstrcmpW(name, Triggers))
2637                 hr = read_triggers(reader, taskdef);
2638             else if (!lstrcmpW(name, Principals))
2639                 hr = read_principals(reader, taskdef);
2640             else if (!lstrcmpW(name, Actions))
2641                 hr = read_actions(reader, taskdef);
2642             else
2643                 FIXME("unhandled Task element %s\n", debugstr_w(name));
2644
2645             if (hr != S_OK) return hr;
2646             break;
2647
2648         case XmlNodeType_Comment:
2649         case XmlNodeType_Whitespace:
2650             break;
2651
2652         default:
2653             FIXME("unhandled Task node type %d\n", type);
2654             break;
2655         }
2656     }
2657
2658     WARN("Task was not terminated\n");
2659     return SCHED_E_MALFORMEDXML;
2660 }
2661
2662 static HRESULT read_xml(IXmlReader *reader, ITaskDefinition *taskdef)
2663 {
2664     HRESULT hr;
2665     XmlNodeType type;
2666     const WCHAR *name;
2667
2668     while (IXmlReader_Read(reader, &type) == S_OK)
2669     {
2670         switch (type)
2671         {
2672         case XmlNodeType_XmlDeclaration:
2673             TRACE("XmlDeclaration\n");
2674             break;
2675
2676         case XmlNodeType_Element:
2677             hr = IXmlReader_GetLocalName(reader, &name, NULL);
2678             if (hr != S_OK) return hr;
2679
2680             TRACE("Element: %s\n", debugstr_w(name));
2681
2682             if (!lstrcmpW(name, Task))
2683             {
2684                 hr = read_task_attributes(reader, taskdef);
2685                 if (hr != S_OK) return hr;
2686
2687                 return read_task(reader, taskdef);
2688             }
2689             else
2690                 FIXME("unhandled XML element %s\n", debugstr_w(name));
2691
2692             break;
2693
2694         case XmlNodeType_Comment:
2695         case XmlNodeType_Whitespace:
2696             break;
2697
2698         default:
2699             FIXME("unhandled XML node type %d\n", type);
2700             break;
2701         }
2702     }
2703
2704     WARN("Task definition was not found\n");
2705     return SCHED_E_MALFORMEDXML;
2706 }
2707
2708 static HRESULT WINAPI TaskDefinition_put_XmlText(ITaskDefinition *iface, BSTR xml)
2709 {
2710     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
2711     HRESULT hr;
2712     IStream *stream;
2713     IXmlReader *reader;
2714     HGLOBAL hmem;
2715     void *buf;
2716
2717     TRACE("%p,%s\n", iface, debugstr_w(xml));
2718
2719     if (!xml) return E_INVALIDARG;
2720
2721     hmem = GlobalAlloc(0, lstrlenW(xml) * sizeof(WCHAR));
2722     if (!hmem) return E_OUTOFMEMORY;
2723
2724     buf = GlobalLock(hmem);
2725     memcpy(buf, xml, lstrlenW(xml) * sizeof(WCHAR));
2726     GlobalUnlock(hmem);
2727
2728     hr = CreateStreamOnHGlobal(hmem, TRUE, &stream);
2729     if (hr != S_OK)
2730     {
2731         GlobalFree(hmem);
2732         return hr;
2733     }
2734
2735     hr = CreateXmlReader(&IID_IXmlReader, (void **)&reader, NULL);
2736     if (hr != S_OK)
2737     {
2738         IStream_Release(stream);
2739         return hr;
2740     }
2741
2742     hr = IXmlReader_SetInput(reader, (IUnknown *)stream);
2743     if (hr == S_OK)
2744     {
2745         if (taskdef->reginfo)
2746         {
2747             IRegistrationInfo_Release(taskdef->reginfo);
2748             taskdef->reginfo = NULL;
2749         }
2750         if (taskdef->taskset)
2751         {
2752             ITaskSettings_Release(taskdef->taskset);
2753             taskdef->taskset = NULL;
2754         }
2755         if (taskdef->triggers)
2756         {
2757             ITriggerCollection_Release(taskdef->triggers);
2758             taskdef->triggers = NULL;
2759         }
2760         if (taskdef->principal)
2761         {
2762             IPrincipal_Release(taskdef->principal);
2763             taskdef->principal = NULL;
2764         }
2765         if (taskdef->actions)
2766         {
2767             IActionCollection_Release(taskdef->actions);
2768             taskdef->actions = NULL;
2769         }
2770
2771         hr = read_xml(reader, iface);
2772     }
2773
2774     IXmlReader_Release(reader);
2775     IStream_Release(stream);
2776
2777     return hr;
2778 }
2779
2780 static const ITaskDefinitionVtbl TaskDefinition_vtbl =
2781 {
2782     TaskDefinition_QueryInterface,
2783     TaskDefinition_AddRef,
2784     TaskDefinition_Release,
2785     TaskDefinition_GetTypeInfoCount,
2786     TaskDefinition_GetTypeInfo,
2787     TaskDefinition_GetIDsOfNames,
2788     TaskDefinition_Invoke,
2789     TaskDefinition_get_RegistrationInfo,
2790     TaskDefinition_put_RegistrationInfo,
2791     TaskDefinition_get_Triggers,
2792     TaskDefinition_put_Triggers,
2793     TaskDefinition_get_Settings,
2794     TaskDefinition_put_Settings,
2795     TaskDefinition_get_Data,
2796     TaskDefinition_put_Data,
2797     TaskDefinition_get_Principal,
2798     TaskDefinition_put_Principal,
2799     TaskDefinition_get_Actions,
2800     TaskDefinition_put_Actions,
2801     TaskDefinition_get_XmlText,
2802     TaskDefinition_put_XmlText
2803 };
2804
2805 HRESULT TaskDefinition_create(ITaskDefinition **obj)
2806 {
2807     TaskDefinition *taskdef;
2808
2809     taskdef = heap_alloc_zero(sizeof(*taskdef));
2810     if (!taskdef) return E_OUTOFMEMORY;
2811
2812     taskdef->ITaskDefinition_iface.lpVtbl = &TaskDefinition_vtbl;
2813     taskdef->ref = 1;
2814     *obj = &taskdef->ITaskDefinition_iface;
2815
2816     TRACE("created %p\n", *obj);
2817
2818     return S_OK;
2819 }
2820
2821 typedef struct
2822 {
2823     ITaskService ITaskService_iface;
2824     LONG ref;
2825     BOOL connected;
2826     DWORD version;
2827     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
2828 } TaskService;
2829
2830 static inline TaskService *impl_from_ITaskService(ITaskService *iface)
2831 {
2832     return CONTAINING_RECORD(iface, TaskService, ITaskService_iface);
2833 }
2834
2835 static ULONG WINAPI TaskService_AddRef(ITaskService *iface)
2836 {
2837     TaskService *task_svc = impl_from_ITaskService(iface);
2838     return InterlockedIncrement(&task_svc->ref);
2839 }
2840
2841 static ULONG WINAPI TaskService_Release(ITaskService *iface)
2842 {
2843     TaskService *task_svc = impl_from_ITaskService(iface);
2844     LONG ref = InterlockedDecrement(&task_svc->ref);
2845
2846     if (!ref)
2847     {
2848         TRACE("destroying %p\n", iface);
2849         heap_free(task_svc);
2850     }
2851
2852     return ref;
2853 }
2854
2855 static HRESULT WINAPI TaskService_QueryInterface(ITaskService *iface, REFIID riid, void **obj)
2856 {
2857     if (!riid || !obj) return E_INVALIDARG;
2858
2859     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
2860
2861     if (IsEqualGUID(riid, &IID_ITaskService) ||
2862         IsEqualGUID(riid, &IID_IDispatch) ||
2863         IsEqualGUID(riid, &IID_IUnknown))
2864     {
2865         ITaskService_AddRef(iface);
2866         *obj = iface;
2867         return S_OK;
2868     }
2869
2870     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
2871     *obj = NULL;
2872     return E_NOINTERFACE;
2873 }
2874
2875 static HRESULT WINAPI TaskService_GetTypeInfoCount(ITaskService *iface, UINT *count)
2876 {
2877     FIXME("%p,%p: stub\n", iface, count);
2878     return E_NOTIMPL;
2879 }
2880
2881 static HRESULT WINAPI TaskService_GetTypeInfo(ITaskService *iface, UINT index, LCID lcid, ITypeInfo **info)
2882 {
2883     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
2884     return E_NOTIMPL;
2885 }
2886
2887 static HRESULT WINAPI TaskService_GetIDsOfNames(ITaskService *iface, REFIID riid, LPOLESTR *names,
2888                                                 UINT count, LCID lcid, DISPID *dispid)
2889 {
2890     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
2891     return E_NOTIMPL;
2892 }
2893
2894 static HRESULT WINAPI TaskService_Invoke(ITaskService *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
2895                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
2896 {
2897     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
2898           params, result, excepinfo, argerr);
2899     return E_NOTIMPL;
2900 }
2901
2902 static HRESULT WINAPI TaskService_GetFolder(ITaskService *iface, BSTR path, ITaskFolder **folder)
2903 {
2904     TaskService *task_svc = impl_from_ITaskService(iface);
2905
2906     TRACE("%p,%s,%p\n", iface, debugstr_w(path), folder);
2907
2908     if (!folder) return E_POINTER;
2909
2910     if (!task_svc->connected)
2911         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
2912
2913     return TaskFolder_create(path, NULL, folder, FALSE);
2914 }
2915
2916 static HRESULT WINAPI TaskService_GetRunningTasks(ITaskService *iface, LONG flags, IRunningTaskCollection **tasks)
2917 {
2918     FIXME("%p,%x,%p: stub\n", iface, flags, tasks);
2919     return E_NOTIMPL;
2920 }
2921
2922 static HRESULT WINAPI TaskService_NewTask(ITaskService *iface, DWORD flags, ITaskDefinition **definition)
2923 {
2924     TRACE("%p,%x,%p\n", iface, flags, definition);
2925
2926     if (!definition) return E_POINTER;
2927
2928     if (flags)
2929         FIXME("unsupported flags %x\n", flags);
2930
2931     return TaskDefinition_create(definition);
2932 }
2933
2934 static inline BOOL is_variant_null(const VARIANT *var)
2935 {
2936     return V_VT(var) == VT_EMPTY || V_VT(var) == VT_NULL ||
2937           (V_VT(var) == VT_BSTR && (V_BSTR(var) == NULL || !*V_BSTR(var)));
2938 }
2939
2940 static HRESULT start_schedsvc(void)
2941 {
2942     static const WCHAR scheduleW[] = { 'S','c','h','e','d','u','l','e',0 };
2943     SC_HANDLE scm, service;
2944     SERVICE_STATUS_PROCESS status;
2945     ULONGLONG start_time;
2946     HRESULT hr = SCHED_E_SERVICE_NOT_RUNNING;
2947
2948     TRACE("Trying to start %s service\n", debugstr_w(scheduleW));
2949
2950     scm = OpenSCManagerW(NULL, NULL, 0);
2951     if (!scm) return SCHED_E_SERVICE_NOT_INSTALLED;
2952
2953     service = OpenServiceW(scm, scheduleW, SERVICE_START | SERVICE_QUERY_STATUS);
2954     if (service)
2955     {
2956         if (StartServiceW(service, 0, NULL) || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
2957         {
2958             start_time = GetTickCount64();
2959             do
2960             {
2961                 DWORD dummy;
2962
2963                 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(status), &dummy))
2964                 {
2965                     WARN("failed to query scheduler status (%u)\n", GetLastError());
2966                     break;
2967                 }
2968
2969                 if (status.dwCurrentState == SERVICE_RUNNING)
2970                 {
2971                     hr = S_OK;
2972                     break;
2973                 }
2974
2975                 if (GetTickCount64() - start_time > 30000) break;
2976                 Sleep(1000);
2977
2978             } while (status.dwCurrentState == SERVICE_START_PENDING);
2979
2980             if (status.dwCurrentState != SERVICE_RUNNING)
2981                 WARN("scheduler failed to start %u\n", status.dwCurrentState);
2982         }
2983         else
2984             WARN("failed to start scheduler service (%u)\n", GetLastError());
2985
2986         CloseServiceHandle(service);
2987     }
2988     else
2989         WARN("failed to open scheduler service (%u)\n", GetLastError());
2990
2991     CloseServiceHandle(scm);
2992     return hr;
2993 }
2994
2995 static HRESULT WINAPI TaskService_Connect(ITaskService *iface, VARIANT server, VARIANT user, VARIANT domain, VARIANT password)
2996 {
2997     static WCHAR ncalrpc[] = { 'n','c','a','l','r','p','c',0 };
2998     TaskService *task_svc = impl_from_ITaskService(iface);
2999     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
3000     DWORD len;
3001     HRESULT hr;
3002     RPC_WSTR binding_str;
3003     extern handle_t rpc_handle;
3004
3005     TRACE("%p,%s,%s,%s,%s\n", iface, debugstr_variant(&server), debugstr_variant(&user),
3006           debugstr_variant(&domain), debugstr_variant(&password));
3007
3008     if (!is_variant_null(&user) || !is_variant_null(&domain) || !is_variant_null(&password))
3009         FIXME("user/domain/password are ignored\n");
3010
3011     len = sizeof(comp_name)/sizeof(comp_name[0]);
3012     if (!GetComputerNameW(comp_name, &len))
3013         return HRESULT_FROM_WIN32(GetLastError());
3014
3015     if (!is_variant_null(&server))
3016     {
3017         const WCHAR *server_name;
3018
3019         if (V_VT(&server) != VT_BSTR)
3020         {
3021             FIXME("server variant type %d is not supported\n", V_VT(&server));
3022             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
3023         }
3024
3025         /* skip UNC prefix if any */
3026         server_name = V_BSTR(&server);
3027         if (server_name[0] == '\\' && server_name[1] == '\\')
3028             server_name += 2;
3029
3030         if (strcmpiW(server_name, comp_name))
3031         {
3032             FIXME("connection to remote server %s is not supported\n", debugstr_w(V_BSTR(&server)));
3033             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
3034         }
3035     }
3036
3037     hr = start_schedsvc();
3038     if (hr != S_OK) return hr;
3039
3040     hr = RpcStringBindingComposeW(NULL, ncalrpc, NULL, NULL, NULL, &binding_str);
3041     if (hr != RPC_S_OK) return hr;
3042     hr = RpcBindingFromStringBindingW(binding_str, &rpc_handle);
3043     RpcStringFreeW(&binding_str);
3044     if (hr != RPC_S_OK) return hr;
3045
3046     /* Make sure that the connection works */
3047     hr = SchRpcHighestVersion(&task_svc->version);
3048     if (hr != S_OK) return hr;
3049
3050     TRACE("server version %#x\n", task_svc->version);
3051
3052     strcpyW(task_svc->comp_name, comp_name);
3053     task_svc->connected = TRUE;
3054
3055     return S_OK;
3056 }
3057
3058 static HRESULT WINAPI TaskService_get_Connected(ITaskService *iface, VARIANT_BOOL *connected)
3059 {
3060     TaskService *task_svc = impl_from_ITaskService(iface);
3061
3062     TRACE("%p,%p\n", iface, connected);
3063
3064     if (!connected) return E_POINTER;
3065
3066     *connected = task_svc->connected ? VARIANT_TRUE : VARIANT_FALSE;
3067
3068     return S_OK;
3069 }
3070
3071 static HRESULT WINAPI TaskService_get_TargetServer(ITaskService *iface, BSTR *server)
3072 {
3073     TaskService *task_svc = impl_from_ITaskService(iface);
3074
3075     TRACE("%p,%p\n", iface, server);
3076
3077     if (!server) return E_POINTER;
3078
3079     if (!task_svc->connected)
3080         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
3081
3082     *server = SysAllocString(task_svc->comp_name);
3083     if (!*server) return E_OUTOFMEMORY;
3084
3085     return S_OK;
3086 }
3087
3088 static HRESULT WINAPI TaskService_get_ConnectedUser(ITaskService *iface, BSTR *user)
3089 {
3090     FIXME("%p,%p: stub\n", iface, user);
3091     return E_NOTIMPL;
3092 }
3093
3094 static HRESULT WINAPI TaskService_get_ConnectedDomain(ITaskService *iface, BSTR *domain)
3095 {
3096     FIXME("%p,%p: stub\n", iface, domain);
3097     return E_NOTIMPL;
3098 }
3099
3100 static HRESULT WINAPI TaskService_get_HighestVersion(ITaskService *iface, DWORD *version)
3101 {
3102     TaskService *task_svc = impl_from_ITaskService(iface);
3103
3104     TRACE("%p,%p\n", iface, version);
3105
3106     if (!version) return E_POINTER;
3107
3108     if (!task_svc->connected)
3109         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
3110
3111     *version = task_svc->version;
3112
3113     return S_OK;
3114 }
3115
3116 static const ITaskServiceVtbl TaskService_vtbl =
3117 {
3118     TaskService_QueryInterface,
3119     TaskService_AddRef,
3120     TaskService_Release,
3121     TaskService_GetTypeInfoCount,
3122     TaskService_GetTypeInfo,
3123     TaskService_GetIDsOfNames,
3124     TaskService_Invoke,
3125     TaskService_GetFolder,
3126     TaskService_GetRunningTasks,
3127     TaskService_NewTask,
3128     TaskService_Connect,
3129     TaskService_get_Connected,
3130     TaskService_get_TargetServer,
3131     TaskService_get_ConnectedUser,
3132     TaskService_get_ConnectedDomain,
3133     TaskService_get_HighestVersion
3134 };
3135
3136 HRESULT TaskService_create(void **obj)
3137 {
3138     TaskService *task_svc;
3139
3140     task_svc = heap_alloc(sizeof(*task_svc));
3141     if (!task_svc) return E_OUTOFMEMORY;
3142
3143     task_svc->ITaskService_iface.lpVtbl = &TaskService_vtbl;
3144     task_svc->ref = 1;
3145     task_svc->connected = FALSE;
3146     *obj = &task_svc->ITaskService_iface;
3147
3148     TRACE("created %p\n", *obj);
3149
3150     return S_OK;
3151 }
3152
3153 void __RPC_FAR *__RPC_USER MIDL_user_allocate(SIZE_T n)
3154 {
3155     return HeapAlloc(GetProcessHeap(), 0, n);
3156 }
3157
3158 void __RPC_USER MIDL_user_free(void __RPC_FAR *p)
3159 {
3160     HeapFree(GetProcessHeap(), 0, p);
3161 }