dlls/taskschd/task.c

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