dlls/taskschd/task.c

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