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