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