dlls/taskschd/task.c

   1 /*
   2  * Copyright 2013 Dmitry Timoshkov
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "initguid.h"
  26 #include "objbase.h"
  27 #include "taskschd.h"
  28 #include "taskschd_private.h"
  29
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(taskschd);
  34
  35 typedef struct
  36 {
  37     ITaskSettings ITaskSettings_iface;
  38     LONG ref;
  39 } TaskSettings;
  40
  41 static inline TaskSettings *impl_from_ITaskSettings(ITaskSettings *iface)
  42 {
  43     return CONTAINING_RECORD(iface, TaskSettings, ITaskSettings_iface);
  44 }
  45
  46 static ULONG WINAPI TaskSettings_AddRef(ITaskSettings *iface)
  47 {
  48     TaskSettings *taskset = impl_from_ITaskSettings(iface);
  49     return InterlockedIncrement(&taskset->ref);
  50 }
  51
  52 static ULONG WINAPI TaskSettings_Release(ITaskSettings *iface)
  53 {
  54     TaskSettings *taskset = impl_from_ITaskSettings(iface);
  55     LONG ref = InterlockedDecrement(&taskset->ref);
  56
  57     if (!ref)
  58     {
  59         TRACE("destroying %p\n", iface);
  60         heap_free(taskset);
  61     }
  62
  63     return ref;
  64 }
  65
  66 static HRESULT WINAPI TaskSettings_QueryInterface(ITaskSettings *iface, REFIID riid, void **obj)
  67 {
  68     if (!riid || !obj) return E_INVALIDARG;
  69
  70     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  71
  72     if (IsEqualGUID(riid, &IID_ITaskSettings) ||
  73         IsEqualGUID(riid, &IID_IDispatch) ||
  74         IsEqualGUID(riid, &IID_IUnknown))
  75     {
  76         ITaskSettings_AddRef(iface);
  77         *obj = iface;
  78         return S_OK;
  79     }
  80
  81     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
  82     *obj = NULL;
  83     return E_NOINTERFACE;
  84 }
  85
  86 static HRESULT WINAPI TaskSettings_GetTypeInfoCount(ITaskSettings *iface, UINT *count)
  87 {
  88     FIXME("%p,%p: stub\n", iface, count);
  89     return E_NOTIMPL;
  90 }
  91
  92 static HRESULT WINAPI TaskSettings_GetTypeInfo(ITaskSettings *iface, UINT index, LCID lcid, ITypeInfo **info)
  93 {
  94     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT WINAPI TaskSettings_GetIDsOfNames(ITaskSettings *iface, REFIID riid, LPOLESTR *names,
  99                                                  UINT count, LCID lcid, DISPID *dispid)
 100 {
 101     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI TaskSettings_Invoke(ITaskSettings *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 106                                           DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 107 {
 108     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 109           params, result, excepinfo, argerr);
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI TaskSettings_get_AllowDemandStart(ITaskSettings *iface, VARIANT_BOOL *allow)
 114 {
 115     FIXME("%p,%p: stub\n", iface, allow);
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT WINAPI TaskSettings_put_AllowDemandStart(ITaskSettings *iface, VARIANT_BOOL allow)
 120 {
 121     FIXME("%p,%d: stub\n", iface, allow);
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI TaskSettings_get_RestartInterval(ITaskSettings *iface, BSTR *interval)
 126 {
 127     FIXME("%p,%p: stub\n", iface, interval);
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI TaskSettings_put_RestartInterval(ITaskSettings *iface, BSTR interval)
 132 {
 133     TRACE("%p,%s\n", iface, debugstr_w(interval));
 134     return E_NOTIMPL;
 135 }
 136
 137 static HRESULT WINAPI TaskSettings_get_RestartCount(ITaskSettings *iface, INT *count)
 138 {
 139     FIXME("%p,%p: stub\n", iface, count);
 140     return E_NOTIMPL;
 141 }
 142
 143 static HRESULT WINAPI TaskSettings_put_RestartCount(ITaskSettings *iface, INT count)
 144 {
 145     FIXME("%p,%d: stub\n", iface, count);
 146     return E_NOTIMPL;
 147 }
 148
 149 static HRESULT WINAPI TaskSettings_get_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY *policy)
 150 {
 151     FIXME("%p,%p: stub\n", iface, policy);
 152     return E_NOTIMPL;
 153 }
 154
 155 static HRESULT WINAPI TaskSettings_put_MultipleInstances(ITaskSettings *iface, TASK_INSTANCES_POLICY policy)
 156 {
 157     FIXME("%p,%d: stub\n", iface, policy);
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI TaskSettings_get_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL *stop)
 162 {
 163     FIXME("%p,%p: stub\n", iface, stop);
 164     return E_NOTIMPL;
 165 }
 166
 167 static HRESULT WINAPI TaskSettings_put_StopIfGoingOnBatteries(ITaskSettings *iface, VARIANT_BOOL stop)
 168 {
 169     FIXME("%p,%d: stub\n", iface, stop);
 170     return E_NOTIMPL;
 171 }
 172
 173 static HRESULT WINAPI TaskSettings_get_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL *disallow)
 174 {
 175     FIXME("%p,%p: stub\n", iface, disallow);
 176     return E_NOTIMPL;
 177 }
 178
 179 static HRESULT WINAPI TaskSettings_put_DisallowStartIfOnBatteries(ITaskSettings *iface, VARIANT_BOOL disallow)
 180 {
 181     FIXME("%p,%d: stub\n", iface, disallow);
 182     return E_NOTIMPL;
 183 }
 184
 185 static HRESULT WINAPI TaskSettings_get_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL *allow)
 186 {
 187     FIXME("%p,%p: stub\n", iface, allow);
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI TaskSettings_put_AllowHardTerminate(ITaskSettings *iface, VARIANT_BOOL allow)
 192 {
 193     FIXME("%p,%d: stub\n", iface, allow);
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI TaskSettings_get_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL *start)
 198 {
 199     FIXME("%p,%p: stub\n", iface, start);
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI TaskSettings_put_StartWhenAvailable(ITaskSettings *iface, VARIANT_BOOL start)
 204 {
 205     FIXME("%p,%d: stub\n", iface, start);
 206     return E_NOTIMPL;
 207 }
 208
 209 static HRESULT WINAPI TaskSettings_get_XmlText(ITaskSettings *iface, BSTR *xml)
 210 {
 211     FIXME("%p,%p: stub\n", iface, xml);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI TaskSettings_put_XmlText(ITaskSettings *iface, BSTR xml)
 216 {
 217     TRACE("%p,%s\n", iface, debugstr_w(xml));
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI TaskSettings_get_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL *run)
 222 {
 223     FIXME("%p,%p: stub\n", iface, run);
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI TaskSettings_put_RunOnlyIfNetworkAvailable(ITaskSettings *iface, VARIANT_BOOL run)
 228 {
 229     FIXME("%p,%d: stub\n", iface, run);
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI TaskSettings_get_ExecutionTimeLimit(ITaskSettings *iface, BSTR *limit)
 234 {
 235     FIXME("%p,%p: stub\n", iface, limit);
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI TaskSettings_put_ExecutionTimeLimit(ITaskSettings *iface, BSTR limit)
 240 {
 241     TRACE("%p,%s\n", iface, debugstr_w(limit));
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI TaskSettings_get_Enabled(ITaskSettings *iface, VARIANT_BOOL *enabled)
 246 {
 247     FIXME("%p,%p: stub\n", iface, enabled);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI TaskSettings_put_Enabled(ITaskSettings *iface, VARIANT_BOOL enabled)
 252 {
 253     FIXME("%p,%d: stub\n", iface, enabled);
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI TaskSettings_get_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR *delay)
 258 {
 259     FIXME("%p,%p: stub\n", iface, delay);
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI TaskSettings_put_DeleteExpiredTaskAfter(ITaskSettings *iface, BSTR delay)
 264 {
 265     TRACE("%p,%s\n", iface, debugstr_w(delay));
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI TaskSettings_get_Priority(ITaskSettings *iface, INT *priority)
 270 {
 271     FIXME("%p,%p: stub\n", iface, priority);
 272     return E_NOTIMPL;
 273 }
 274
 275 static HRESULT WINAPI TaskSettings_put_Priority(ITaskSettings *iface, INT priority)
 276 {
 277     FIXME("%p,%d: stub\n", iface, priority);
 278     return E_NOTIMPL;
 279 }
 280
 281 static HRESULT WINAPI TaskSettings_get_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY *level)
 282 {
 283     FIXME("%p,%p: stub\n", iface, level);
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI TaskSettings_put_Compatibility(ITaskSettings *iface, TASK_COMPATIBILITY level)
 288 {
 289     FIXME("%p,%d: stub\n", iface, level);
 290     return E_NOTIMPL;
 291 }
 292
 293 static HRESULT WINAPI TaskSettings_get_Hidden(ITaskSettings *iface, VARIANT_BOOL *hidden)
 294 {
 295     FIXME("%p,%p: stub\n", iface, hidden);
 296     return E_NOTIMPL;
 297 }
 298
 299 static HRESULT WINAPI TaskSettings_put_Hidden(ITaskSettings *iface, VARIANT_BOOL hidden)
 300 {
 301     FIXME("%p,%d: stub\n", iface, hidden);
 302     return E_NOTIMPL;
 303 }
 304
 305 static HRESULT WINAPI TaskSettings_get_IdleSettings(ITaskSettings *iface, IIdleSettings **settings)
 306 {
 307     FIXME("%p,%p: stub\n", iface, settings);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI TaskSettings_put_IdleSettings(ITaskSettings *iface, IIdleSettings *settings)
 312 {
 313     FIXME("%p,%p: stub\n", iface, settings);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI TaskSettings_get_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL *run)
 318 {
 319     FIXME("%p,%p: stub\n", iface, run);
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI TaskSettings_put_RunOnlyIfIdle(ITaskSettings *iface, VARIANT_BOOL run)
 324 {
 325     FIXME("%p,%d: stub\n", iface, run);
 326     return E_NOTIMPL;
 327 }
 328
 329 static HRESULT WINAPI TaskSettings_get_WakeToRun(ITaskSettings *iface, VARIANT_BOOL *wake)
 330 {
 331     FIXME("%p,%p: stub\n", iface, wake);
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI TaskSettings_put_WakeToRun(ITaskSettings *iface, VARIANT_BOOL wake)
 336 {
 337     FIXME("%p,%d: stub\n", iface, wake);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI TaskSettings_get_NetworkSettings(ITaskSettings *iface, INetworkSettings **settings)
 342 {
 343     FIXME("%p,%p: stub\n", iface, settings);
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI TaskSettings_put_NetworkSettings(ITaskSettings *iface, INetworkSettings *settings)
 348 {
 349     FIXME("%p,%p: stub\n", iface, settings);
 350     return E_NOTIMPL;
 351 }
 352
 353 static const ITaskSettingsVtbl TaskSettings_vtbl =
 354 {
 355     TaskSettings_QueryInterface,
 356     TaskSettings_AddRef,
 357     TaskSettings_Release,
 358     TaskSettings_GetTypeInfoCount,
 359     TaskSettings_GetTypeInfo,
 360     TaskSettings_GetIDsOfNames,
 361     TaskSettings_Invoke,
 362     TaskSettings_get_AllowDemandStart,
 363     TaskSettings_put_AllowDemandStart,
 364     TaskSettings_get_RestartInterval,
 365     TaskSettings_put_RestartInterval,
 366     TaskSettings_get_RestartCount,
 367     TaskSettings_put_RestartCount,
 368     TaskSettings_get_MultipleInstances,
 369     TaskSettings_put_MultipleInstances,
 370     TaskSettings_get_StopIfGoingOnBatteries,
 371     TaskSettings_put_StopIfGoingOnBatteries,
 372     TaskSettings_get_DisallowStartIfOnBatteries,
 373     TaskSettings_put_DisallowStartIfOnBatteries,
 374     TaskSettings_get_AllowHardTerminate,
 375     TaskSettings_put_AllowHardTerminate,
 376     TaskSettings_get_StartWhenAvailable,
 377     TaskSettings_put_StartWhenAvailable,
 378     TaskSettings_get_XmlText,
 379     TaskSettings_put_XmlText,
 380     TaskSettings_get_RunOnlyIfNetworkAvailable,
 381     TaskSettings_put_RunOnlyIfNetworkAvailable,
 382     TaskSettings_get_ExecutionTimeLimit,
 383     TaskSettings_put_ExecutionTimeLimit,
 384     TaskSettings_get_Enabled,
 385     TaskSettings_put_Enabled,
 386     TaskSettings_get_DeleteExpiredTaskAfter,
 387     TaskSettings_put_DeleteExpiredTaskAfter,
 388     TaskSettings_get_Priority,
 389     TaskSettings_put_Priority,
 390     TaskSettings_get_Compatibility,
 391     TaskSettings_put_Compatibility,
 392     TaskSettings_get_Hidden,
 393     TaskSettings_put_Hidden,
 394     TaskSettings_get_IdleSettings,
 395     TaskSettings_put_IdleSettings,
 396     TaskSettings_get_RunOnlyIfIdle,
 397     TaskSettings_put_RunOnlyIfIdle,
 398     TaskSettings_get_WakeToRun,
 399     TaskSettings_put_WakeToRun,
 400     TaskSettings_get_NetworkSettings,
 401     TaskSettings_put_NetworkSettings
 402 };
 403
 404 static HRESULT TaskSettings_create(ITaskSettings **obj)
 405 {
 406     TaskSettings *taskset;
 407
 408     taskset = heap_alloc(sizeof(*taskset));
 409     if (!taskset) return E_OUTOFMEMORY;
 410
 411     taskset->ITaskSettings_iface.lpVtbl = &TaskSettings_vtbl;
 412     taskset->ref = 1;
 413     *obj = &taskset->ITaskSettings_iface;
 414
 415     TRACE("created %p\n", *obj);
 416
 417     return S_OK;
 418 }
 419
 420 typedef struct
 421 {
 422     ITaskDefinition ITaskDefinition_iface;
 423     LONG ref;
 424 } TaskDefinition;
 425
 426 static inline TaskDefinition *impl_from_ITaskDefinition(ITaskDefinition *iface)
 427 {
 428     return CONTAINING_RECORD(iface, TaskDefinition, ITaskDefinition_iface);
 429 }
 430
 431 static ULONG WINAPI TaskDefinition_AddRef(ITaskDefinition *iface)
 432 {
 433     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
 434     return InterlockedIncrement(&taskdef->ref);
 435 }
 436
 437 static ULONG WINAPI TaskDefinition_Release(ITaskDefinition *iface)
 438 {
 439     TaskDefinition *taskdef = impl_from_ITaskDefinition(iface);
 440     LONG ref = InterlockedDecrement(&taskdef->ref);
 441
 442     if (!ref)
 443     {
 444         TRACE("destroying %p\n", iface);
 445         heap_free(taskdef);
 446     }
 447
 448     return ref;
 449 }
 450
 451 static HRESULT WINAPI TaskDefinition_QueryInterface(ITaskDefinition *iface, REFIID riid, void **obj)
 452 {
 453     if (!riid || !obj) return E_INVALIDARG;
 454
 455     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 456
 457     if (IsEqualGUID(riid, &IID_ITaskDefinition) ||
 458         IsEqualGUID(riid, &IID_IDispatch) ||
 459         IsEqualGUID(riid, &IID_IUnknown))
 460     {
 461         ITaskDefinition_AddRef(iface);
 462         *obj = iface;
 463         return S_OK;
 464     }
 465
 466     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 467     *obj = NULL;
 468     return E_NOINTERFACE;
 469 }
 470
 471 static HRESULT WINAPI TaskDefinition_GetTypeInfoCount(ITaskDefinition *iface, UINT *count)
 472 {
 473     FIXME("%p,%p: stub\n", iface, count);
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI TaskDefinition_GetTypeInfo(ITaskDefinition *iface, UINT index, LCID lcid, ITypeInfo **info)
 478 {
 479     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI TaskDefinition_GetIDsOfNames(ITaskDefinition *iface, REFIID riid, LPOLESTR *names,
 484                                                    UINT count, LCID lcid, DISPID *dispid)
 485 {
 486     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI TaskDefinition_Invoke(ITaskDefinition *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 491                                             DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 492 {
 493     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 494           params, result, excepinfo, argerr);
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT WINAPI TaskDefinition_get_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo **info)
 499 {
 500     FIXME("%p,%p: stub\n", iface, info);
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI TaskDefinition_put_RegistrationInfo(ITaskDefinition *iface, IRegistrationInfo *info)
 505 {
 506     FIXME("%p,%p: stub\n", iface, info);
 507     return E_NOTIMPL;
 508 }
 509
 510 static HRESULT WINAPI TaskDefinition_get_Triggers(ITaskDefinition *iface, ITriggerCollection **triggers)
 511 {
 512     FIXME("%p,%p: stub\n", iface, triggers);
 513     return E_NOTIMPL;
 514 }
 515
 516 static HRESULT WINAPI TaskDefinition_put_Triggers(ITaskDefinition *iface, ITriggerCollection *triggers)
 517 {
 518     FIXME("%p,%p: stub\n", iface, triggers);
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI TaskDefinition_get_Settings(ITaskDefinition *iface, ITaskSettings **settings)
 523 {
 524     TRACE("%p,%p\n", iface, settings);
 525
 526     if (!settings) return E_POINTER;
 527
 528     return TaskSettings_create(settings);
 529 }
 530
 531 static HRESULT WINAPI TaskDefinition_put_Settings(ITaskDefinition *iface, ITaskSettings *settings)
 532 {
 533     FIXME("%p,%p: stub\n", iface, settings);
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI TaskDefinition_get_Data(ITaskDefinition *iface, BSTR *data)
 538 {
 539     FIXME("%p,%p: stub\n", iface, data);
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI TaskDefinition_put_Data(ITaskDefinition *iface, BSTR data)
 544 {
 545     FIXME("%p,%p: stub\n", iface, data);
 546     return E_NOTIMPL;
 547 }
 548
 549 static HRESULT WINAPI TaskDefinition_get_Principal(ITaskDefinition *iface, IPrincipal **principal)
 550 {
 551     FIXME("%p,%p: stub\n", iface, principal);
 552     return E_NOTIMPL;
 553 }
 554
 555 static HRESULT WINAPI TaskDefinition_put_Principal(ITaskDefinition *iface, IPrincipal *principal)
 556 {
 557     FIXME("%p,%p: stub\n", iface, principal);
 558     return E_NOTIMPL;
 559 }
 560
 561 static HRESULT WINAPI TaskDefinition_get_Actions(ITaskDefinition *iface, IActionCollection **actions)
 562 {
 563     FIXME("%p,%p: stub\n", iface, actions);
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI TaskDefinition_put_Actions(ITaskDefinition *iface, IActionCollection *actions)
 568 {
 569     FIXME("%p,%p: stub\n", iface, actions);
 570     return E_NOTIMPL;
 571 }
 572
 573 static HRESULT WINAPI TaskDefinition_get_XmlText(ITaskDefinition *iface, BSTR *xml)
 574 {
 575     FIXME("%p,%p: stub\n", iface, xml);
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI TaskDefinition_put_XmlText(ITaskDefinition *iface, BSTR xml)
 580 {
 581     FIXME("%p,%p: stub\n", iface, xml);
 582     return E_NOTIMPL;
 583 }
 584
 585 static const ITaskDefinitionVtbl TaskDefinition_vtbl =
 586 {
 587     TaskDefinition_QueryInterface,
 588     TaskDefinition_AddRef,
 589     TaskDefinition_Release,
 590     TaskDefinition_GetTypeInfoCount,
 591     TaskDefinition_GetTypeInfo,
 592     TaskDefinition_GetIDsOfNames,
 593     TaskDefinition_Invoke,
 594     TaskDefinition_get_RegistrationInfo,
 595     TaskDefinition_put_RegistrationInfo,
 596     TaskDefinition_get_Triggers,
 597     TaskDefinition_put_Triggers,
 598     TaskDefinition_get_Settings,
 599     TaskDefinition_put_Settings,
 600     TaskDefinition_get_Data,
 601     TaskDefinition_put_Data,
 602     TaskDefinition_get_Principal,
 603     TaskDefinition_put_Principal,
 604     TaskDefinition_get_Actions,
 605     TaskDefinition_put_Actions,
 606     TaskDefinition_get_XmlText,
 607     TaskDefinition_put_XmlText
 608 };
 609
 610 static HRESULT TaskDefinition_create(ITaskDefinition **obj)
 611 {
 612     TaskDefinition *taskdef;
 613
 614     taskdef = heap_alloc(sizeof(*taskdef));
 615     if (!taskdef) return E_OUTOFMEMORY;
 616
 617     taskdef->ITaskDefinition_iface.lpVtbl = &TaskDefinition_vtbl;
 618     taskdef->ref = 1;
 619     *obj = &taskdef->ITaskDefinition_iface;
 620
 621     TRACE("created %p\n", *obj);
 622
 623     return S_OK;
 624 }
 625
 626 typedef struct
 627 {
 628     ITaskService ITaskService_iface;
 629     LONG ref;
 630     BOOL connected;
 631     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
 632 } TaskService;
 633
 634 static inline TaskService *impl_from_ITaskService(ITaskService *iface)
 635 {
 636     return CONTAINING_RECORD(iface, TaskService, ITaskService_iface);
 637 }
 638
 639 static ULONG WINAPI TaskService_AddRef(ITaskService *iface)
 640 {
 641     TaskService *task_svc = impl_from_ITaskService(iface);
 642     return InterlockedIncrement(&task_svc->ref);
 643 }
 644
 645 static ULONG WINAPI TaskService_Release(ITaskService *iface)
 646 {
 647     TaskService *task_svc = impl_from_ITaskService(iface);
 648     LONG ref = InterlockedDecrement(&task_svc->ref);
 649
 650     if (!ref)
 651     {
 652         TRACE("destroying %p\n", iface);
 653         heap_free(task_svc);
 654     }
 655
 656     return ref;
 657 }
 658
 659 static HRESULT WINAPI TaskService_QueryInterface(ITaskService *iface, REFIID riid, void **obj)
 660 {
 661     if (!riid || !obj) return E_INVALIDARG;
 662
 663     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 664
 665     if (IsEqualGUID(riid, &IID_ITaskService) ||
 666         IsEqualGUID(riid, &IID_IDispatch) ||
 667         IsEqualGUID(riid, &IID_IUnknown))
 668     {
 669         ITaskService_AddRef(iface);
 670         *obj = iface;
 671         return S_OK;
 672     }
 673
 674     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 675     *obj = NULL;
 676     return E_NOINTERFACE;
 677 }
 678
 679 static HRESULT WINAPI TaskService_GetTypeInfoCount(ITaskService *iface, UINT *count)
 680 {
 681     FIXME("%p,%p: stub\n", iface, count);
 682     return E_NOTIMPL;
 683 }
 684
 685 static HRESULT WINAPI TaskService_GetTypeInfo(ITaskService *iface, UINT index, LCID lcid, ITypeInfo **info)
 686 {
 687     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 688     return E_NOTIMPL;
 689 }
 690
 691 static HRESULT WINAPI TaskService_GetIDsOfNames(ITaskService *iface, REFIID riid, LPOLESTR *names,
 692                                                 UINT count, LCID lcid, DISPID *dispid)
 693 {
 694     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 695     return E_NOTIMPL;
 696 }
 697
 698 static HRESULT WINAPI TaskService_Invoke(ITaskService *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 699                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 700 {
 701     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 702           params, result, excepinfo, argerr);
 703     return E_NOTIMPL;
 704 }
 705
 706 static HRESULT WINAPI TaskService_GetFolder(ITaskService *iface, BSTR path, ITaskFolder **folder)
 707 {
 708     TaskService *task_svc = impl_from_ITaskService(iface);
 709
 710     TRACE("%p,%s,%p\n", iface, debugstr_w(path), folder);
 711
 712     if (!folder) return E_POINTER;
 713
 714     if (!task_svc->connected)
 715         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
 716
 717     return TaskFolder_create(path, NULL, folder, FALSE);
 718 }
 719
 720 static HRESULT WINAPI TaskService_GetRunningTasks(ITaskService *iface, LONG flags, IRunningTaskCollection **tasks)
 721 {
 722     FIXME("%p,%x,%p: stub\n", iface, flags, tasks);
 723     return E_NOTIMPL;
 724 }
 725
 726 static HRESULT WINAPI TaskService_NewTask(ITaskService *iface, DWORD flags, ITaskDefinition **definition)
 727 {
 728     TaskService *task_svc = impl_from_ITaskService(iface);
 729
 730     TRACE("%p,%x,%p\n", iface, flags, definition);
 731
 732     if (!definition) return E_POINTER;
 733
 734     if (!task_svc->connected)
 735         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
 736
 737     if (flags)
 738         FIXME("unsupported flags %x\n", flags);
 739
 740     return TaskDefinition_create(definition);
 741 }
 742
 743 static inline BOOL is_variant_null(const VARIANT *var)
 744 {
 745     return V_VT(var) == VT_EMPTY || V_VT(var) == VT_NULL ||
 746           (V_VT(var) == VT_BSTR && (V_BSTR(var) == NULL || !*V_BSTR(var)));
 747 }
 748
 749 static HRESULT WINAPI TaskService_Connect(ITaskService *iface, VARIANT server, VARIANT user, VARIANT domain, VARIANT password)
 750 {
 751     TaskService *task_svc = impl_from_ITaskService(iface);
 752     WCHAR comp_name[MAX_COMPUTERNAME_LENGTH + 1];
 753     DWORD len;
 754
 755     TRACE("%p,%s,%s,%s,%s\n", iface, debugstr_variant(&server), debugstr_variant(&user),
 756           debugstr_variant(&domain), debugstr_variant(&password));
 757
 758     if (!is_variant_null(&user) || !is_variant_null(&domain) || !is_variant_null(&password))
 759         FIXME("user/domain/password are ignored\n");
 760
 761     len = sizeof(comp_name)/sizeof(comp_name[0]);
 762     if (!GetComputerNameW(comp_name, &len))
 763         return HRESULT_FROM_WIN32(GetLastError());
 764
 765     if (!is_variant_null(&server))
 766     {
 767         const WCHAR *server_name;
 768
 769         if (V_VT(&server) != VT_BSTR)
 770         {
 771             FIXME("server variant type %d is not supported\n", V_VT(&server));
 772             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
 773         }
 774
 775         /* skip UNC prefix if any */
 776         server_name = V_BSTR(&server);
 777         if (server_name[0] == '\\' && server_name[1] == '\\')
 778             server_name += 2;
 779
 780         if (strcmpiW(server_name, comp_name))
 781         {
 782             FIXME("connection to remote server %s is not supported\n", debugstr_w(V_BSTR(&server)));
 783             return HRESULT_FROM_WIN32(ERROR_BAD_NETPATH);
 784         }
 785     }
 786
 787     strcpyW(task_svc->comp_name, comp_name);
 788     task_svc->connected = TRUE;
 789
 790     return S_OK;
 791 }
 792
 793 static HRESULT WINAPI TaskService_get_Connected(ITaskService *iface, VARIANT_BOOL *connected)
 794 {
 795     TaskService *task_svc = impl_from_ITaskService(iface);
 796
 797     TRACE("%p,%p\n", iface, connected);
 798
 799     if (!connected) return E_POINTER;
 800
 801     *connected = task_svc->connected ? VARIANT_TRUE : VARIANT_FALSE;
 802
 803     return S_OK;
 804 }
 805
 806 static HRESULT WINAPI TaskService_get_TargetServer(ITaskService *iface, BSTR *server)
 807 {
 808     TaskService *task_svc = impl_from_ITaskService(iface);
 809
 810     TRACE("%p,%p\n", iface, server);
 811
 812     if (!server) return E_POINTER;
 813
 814     if (!task_svc->connected)
 815         return HRESULT_FROM_WIN32(ERROR_ONLY_IF_CONNECTED);
 816
 817     *server = SysAllocString(task_svc->comp_name);
 818     if (!*server) return E_OUTOFMEMORY;
 819
 820     return S_OK;
 821 }
 822
 823 static HRESULT WINAPI TaskService_get_ConnectedUser(ITaskService *iface, BSTR *user)
 824 {
 825     FIXME("%p,%p: stub\n", iface, user);
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI TaskService_get_ConnectedDomain(ITaskService *iface, BSTR *domain)
 830 {
 831     FIXME("%p,%p: stub\n", iface, domain);
 832     return E_NOTIMPL;
 833 }
 834
 835 static HRESULT WINAPI TaskService_get_HighestVersion(ITaskService *iface, DWORD *version)
 836 {
 837     FIXME("%p,%p: stub\n", iface, version);
 838     return E_NOTIMPL;
 839 }
 840
 841 static const ITaskServiceVtbl TaskService_vtbl =
 842 {
 843     TaskService_QueryInterface,
 844     TaskService_AddRef,
 845     TaskService_Release,
 846     TaskService_GetTypeInfoCount,
 847     TaskService_GetTypeInfo,
 848     TaskService_GetIDsOfNames,
 849     TaskService_Invoke,
 850     TaskService_GetFolder,
 851     TaskService_GetRunningTasks,
 852     TaskService_NewTask,
 853     TaskService_Connect,
 854     TaskService_get_Connected,
 855     TaskService_get_TargetServer,
 856     TaskService_get_ConnectedUser,
 857     TaskService_get_ConnectedDomain,
 858     TaskService_get_HighestVersion
 859 };
 860
 861 HRESULT TaskService_create(void **obj)
 862 {
 863     TaskService *task_svc;
 864
 865     task_svc = heap_alloc(sizeof(*task_svc));
 866     if (!task_svc) return E_OUTOFMEMORY;
 867
 868     task_svc->ITaskService_iface.lpVtbl = &TaskService_vtbl;
 869     task_svc->ref = 1;
 870     task_svc->connected = FALSE;
 871     *obj = &task_svc->ITaskService_iface;
 872
 873     TRACE("created %p\n", *obj);
 874
 875     return S_OK;
 876 }