dlls/taskschd/regtask.c

   1 /*
   2  * Copyright 2014 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 "winreg.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     IRegisteredTask IRegisteredTask_iface;
  38     LONG ref;
  39     WCHAR *path;
  40     ITaskDefinition *taskdef;
  41 } RegisteredTask;
  42
  43 static inline RegisteredTask *impl_from_IRegisteredTask(IRegisteredTask *iface)
  44 {
  45     return CONTAINING_RECORD(iface, RegisteredTask, IRegisteredTask_iface);
  46 }
  47
  48 static ULONG WINAPI regtask_AddRef(IRegisteredTask *iface)
  49 {
  50     RegisteredTask *regtask = impl_from_IRegisteredTask(iface);
  51     return InterlockedIncrement(&regtask->ref);
  52 }
  53
  54 static ULONG WINAPI regtask_Release(IRegisteredTask *iface)
  55 {
  56     RegisteredTask *regtask = impl_from_IRegisteredTask(iface);
  57     LONG ref = InterlockedDecrement(&regtask->ref);
  58
  59     if (!ref)
  60     {
  61         TRACE("destroying %p\n", iface);
  62         ITaskDefinition_Release(regtask->taskdef);
  63         heap_free(regtask->path);
  64         heap_free(regtask);
  65     }
  66
  67     return ref;
  68 }
  69
  70 static HRESULT WINAPI regtask_QueryInterface(IRegisteredTask *iface, REFIID riid, void **obj)
  71 {
  72     if (!riid || !obj) return E_INVALIDARG;
  73
  74     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  75
  76     if (IsEqualGUID(riid, &IID_IRegisteredTask) ||
  77         IsEqualGUID(riid, &IID_IDispatch) ||
  78         IsEqualGUID(riid, &IID_IUnknown))
  79     {
  80         IRegisteredTask_AddRef(iface);
  81         *obj = iface;
  82         return S_OK;
  83     }
  84
  85     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
  86     *obj = NULL;
  87     return E_NOINTERFACE;
  88 }
  89
  90 static HRESULT WINAPI regtask_GetTypeInfoCount(IRegisteredTask *iface, UINT *count)
  91 {
  92     FIXME("%p,%p: stub\n", iface, count);
  93     return E_NOTIMPL;
  94 }
  95
  96 static HRESULT WINAPI regtask_GetTypeInfo(IRegisteredTask *iface, UINT index, LCID lcid, ITypeInfo **info)
  97 {
  98     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
  99     return E_NOTIMPL;
 100 }
 101
 102 static HRESULT WINAPI regtask_GetIDsOfNames(IRegisteredTask *iface, REFIID riid, LPOLESTR *names,
 103                                             UINT count, LCID lcid, DISPID *dispid)
 104 {
 105     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI regtask_Invoke(IRegisteredTask *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 110                                      DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 111 {
 112     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 113           params, result, excepinfo, argerr);
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI regtask_get_Name(IRegisteredTask *iface, BSTR *name)
 118 {
 119     FIXME("%p,%p: stub\n", iface, name);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI regtask_get_Path(IRegisteredTask *iface, BSTR *path)
 124 {
 125     FIXME("%p,%p: stub\n", iface, path);
 126     return E_NOTIMPL;
 127 }
 128
 129 static HRESULT WINAPI regtask_get_State(IRegisteredTask *iface, TASK_STATE *state)
 130 {
 131     FIXME("%p,%p: stub\n", iface, state);
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT WINAPI regtask_get_Enabled(IRegisteredTask *iface, VARIANT_BOOL *enabled)
 136 {
 137     FIXME("%p,%p: stub\n", iface, enabled);
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI regtask_put_Enabled(IRegisteredTask *iface, VARIANT_BOOL enabled)
 142 {
 143     FIXME("%p,%d: stub\n", iface, enabled);
 144     return E_NOTIMPL;
 145 }
 146
 147 static HRESULT WINAPI regtask_Run(IRegisteredTask *iface, VARIANT params, IRunningTask **task)
 148 {
 149     FIXME("%p,%s,%p: stub\n", iface, debugstr_variant(&params), task);
 150     return E_NOTIMPL;
 151 }
 152
 153 static HRESULT WINAPI regtask_RunEx(IRegisteredTask *iface, VARIANT params, LONG flags,
 154                                     LONG session_id, BSTR user, IRunningTask **task)
 155 {
 156     FIXME("%p,%s,%x,%x,%s,%p: stub\n", iface, debugstr_variant(&params), flags, session_id, debugstr_w(user), task);
 157     return E_NOTIMPL;
 158 }
 159
 160 static HRESULT WINAPI regtask_GetInstances(IRegisteredTask *iface, LONG flags, IRunningTaskCollection **tasks)
 161 {
 162     FIXME("%p,%x,%p: stub\n", iface, flags, tasks);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI regtask_get_LastRunTime(IRegisteredTask *iface, DATE *date)
 167 {
 168     FIXME("%p,%p: stub\n", iface, date);
 169     return E_NOTIMPL;
 170 }
 171
 172 static HRESULT WINAPI regtask_get_LastTaskResult(IRegisteredTask *iface, LONG *result)
 173 {
 174     FIXME("%p,%p: stub\n", iface, result);
 175     return E_NOTIMPL;
 176 }
 177
 178 static HRESULT WINAPI regtask_get_NumberOfMissedRuns(IRegisteredTask *iface, LONG *runs)
 179 {
 180     FIXME("%p,%p: stub\n", iface, runs);
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI regtask_get_NextRunTime(IRegisteredTask *iface, DATE *date)
 185 {
 186     FIXME("%p,%p: stub\n", iface, date);
 187     return E_NOTIMPL;
 188 }
 189
 190 static HRESULT WINAPI regtask_get_Definition(IRegisteredTask *iface, ITaskDefinition **task)
 191 {
 192     RegisteredTask *regtask = impl_from_IRegisteredTask(iface);
 193
 194     TRACE("%p,%p\n", iface, task);
 195
 196     if (!task) return E_POINTER;
 197
 198     ITaskDefinition_AddRef(regtask->taskdef);
 199     *task = regtask->taskdef;
 200
 201     return S_OK;
 202 }
 203
 204 static HRESULT WINAPI regtask_get_Xml(IRegisteredTask *iface, BSTR *xml)
 205 {
 206     RegisteredTask *regtask = impl_from_IRegisteredTask(iface);
 207
 208     TRACE("%p,%p\n", iface, xml);
 209
 210     if (!xml) return E_POINTER;
 211
 212     return ITaskDefinition_get_XmlText(regtask->taskdef, xml);
 213 }
 214
 215 static HRESULT WINAPI regtask_GetSecurityDescriptor(IRegisteredTask *iface, LONG info, BSTR *sddl)
 216 {
 217     FIXME("%p,%x,%p: stub\n", iface, info, sddl);
 218     return E_NOTIMPL;
 219 }
 220
 221 static HRESULT WINAPI regtask_SetSecurityDescriptor(IRegisteredTask *iface, BSTR sddl, LONG flags)
 222 {
 223     FIXME("%p,%s,%x: stub\n", iface, debugstr_w(sddl), flags);
 224     return E_NOTIMPL;
 225 }
 226
 227 static HRESULT WINAPI regtask_Stop(IRegisteredTask *iface, LONG flags)
 228 {
 229     FIXME("%p,%x: stub\n", iface, flags);
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI regtask_GetRunTimes(IRegisteredTask *iface, const LPSYSTEMTIME start, const LPSYSTEMTIME end,
 234                                           DWORD *count, LPSYSTEMTIME *time)
 235 {
 236     FIXME("%p,%p.%p,%p,%p: stub\n", iface, start, end, count, time);
 237     return E_NOTIMPL;
 238 }
 239
 240 static const IRegisteredTaskVtbl RegisteredTask_vtbl =
 241 {
 242     regtask_QueryInterface,
 243     regtask_AddRef,
 244     regtask_Release,
 245     regtask_GetTypeInfoCount,
 246     regtask_GetTypeInfo,
 247     regtask_GetIDsOfNames,
 248     regtask_Invoke,
 249     regtask_get_Name,
 250     regtask_get_Path,
 251     regtask_get_State,
 252     regtask_get_Enabled,
 253     regtask_put_Enabled,
 254     regtask_Run,
 255     regtask_RunEx,
 256     regtask_GetInstances,
 257     regtask_get_LastRunTime,
 258     regtask_get_LastTaskResult,
 259     regtask_get_NumberOfMissedRuns,
 260     regtask_get_NextRunTime,
 261     regtask_get_Definition,
 262     regtask_get_Xml,
 263     regtask_GetSecurityDescriptor,
 264     regtask_SetSecurityDescriptor,
 265     regtask_Stop,
 266     regtask_GetRunTimes
 267 };
 268
 269 HRESULT RegisteredTask_create(const WCHAR *path, const WCHAR *name, ITaskDefinition *definition,
 270                               TASK_LOGON_TYPE logon, IRegisteredTask **obj, BOOL create)
 271 {
 272     RegisteredTask *regtask;
 273
 274     regtask = heap_alloc(sizeof(*regtask));
 275     if (!regtask) return E_OUTOFMEMORY;
 276
 277     regtask->IRegisteredTask_iface.lpVtbl = &RegisteredTask_vtbl;
 278     regtask->path = heap_strdupW(path);
 279     regtask->ref = 1;
 280     ITaskDefinition_AddRef(definition);
 281     regtask->taskdef = definition;
 282     *obj = &regtask->IRegisteredTask_iface;
 283
 284     TRACE("created %p\n", *obj);
 285
 286     return S_OK;
 287 }
 288
 289 typedef struct
 290 {
 291     IRegisteredTaskCollection IRegisteredTaskCollection_iface;
 292     LONG ref;
 293     WCHAR *path;
 294 } RegisteredTaskCollection;
 295
 296 static inline RegisteredTaskCollection *impl_from_IRegisteredTaskCollection(IRegisteredTaskCollection *iface)
 297 {
 298     return CONTAINING_RECORD(iface, RegisteredTaskCollection, IRegisteredTaskCollection_iface);
 299 }
 300
 301 static ULONG WINAPI regtasks_AddRef(IRegisteredTaskCollection *iface)
 302 {
 303     RegisteredTaskCollection *regtasks = impl_from_IRegisteredTaskCollection(iface);
 304     return InterlockedIncrement(&regtasks->ref);
 305 }
 306
 307 static ULONG WINAPI regtasks_Release(IRegisteredTaskCollection *iface)
 308 {
 309     RegisteredTaskCollection *regtasks = impl_from_IRegisteredTaskCollection(iface);
 310     LONG ref = InterlockedDecrement(&regtasks->ref);
 311
 312     if (!ref)
 313     {
 314         TRACE("destroying %p\n", iface);
 315         heap_free(regtasks->path);
 316         heap_free(regtasks);
 317     }
 318
 319     return ref;
 320 }
 321
 322 static HRESULT WINAPI regtasks_QueryInterface(IRegisteredTaskCollection *iface, REFIID riid, void **obj)
 323 {
 324     if (!riid || !obj) return E_INVALIDARG;
 325
 326     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 327
 328     if (IsEqualGUID(riid, &IID_IRegisteredTaskCollection) ||
 329         IsEqualGUID(riid, &IID_IDispatch) ||
 330         IsEqualGUID(riid, &IID_IUnknown))
 331     {
 332         IRegisteredTaskCollection_AddRef(iface);
 333         *obj = iface;
 334         return S_OK;
 335     }
 336
 337     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 338     *obj = NULL;
 339     return E_NOINTERFACE;
 340 }
 341
 342 static HRESULT WINAPI regtasks_GetTypeInfoCount(IRegisteredTaskCollection *iface, UINT *count)
 343 {
 344     FIXME("%p,%p: stub\n", iface, count);
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI regtasks_GetTypeInfo(IRegisteredTaskCollection *iface, UINT index, LCID lcid, ITypeInfo **info)
 349 {
 350     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI regtasks_GetIDsOfNames(IRegisteredTaskCollection *iface, REFIID riid, LPOLESTR *names,
 355                                                 UINT count, LCID lcid, DISPID *dispid)
 356 {
 357     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI regtasks_Invoke(IRegisteredTaskCollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 362                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 363 {
 364     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 365           params, result, excepinfo, argerr);
 366     return E_NOTIMPL;
 367 }
 368
 369 static HRESULT WINAPI regtasks_get_Count(IRegisteredTaskCollection *iface, LONG *count)
 370 {
 371     FIXME("%p,%p: stub\n", iface, count);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI regtasks_get_Item(IRegisteredTaskCollection *iface, VARIANT index, IRegisteredTask **regtask)
 376 {
 377     FIXME("%p,%s,%p: stub\n", iface, debugstr_variant(&index), regtask);
 378     return E_NOTIMPL;
 379 }
 380
 381 static HRESULT WINAPI regtasks_get__NewEnum(IRegisteredTaskCollection *iface, IUnknown **penum)
 382 {
 383     FIXME("%p,%p: stub\n", iface, penum);
 384     return E_NOTIMPL;
 385 }
 386
 387 static const IRegisteredTaskCollectionVtbl RegisteredTaskCollection_vtbl =
 388 {
 389     regtasks_QueryInterface,
 390     regtasks_AddRef,
 391     regtasks_Release,
 392     regtasks_GetTypeInfoCount,
 393     regtasks_GetTypeInfo,
 394     regtasks_GetIDsOfNames,
 395     regtasks_Invoke,
 396     regtasks_get_Count,
 397     regtasks_get_Item,
 398     regtasks_get__NewEnum
 399 };
 400
 401 HRESULT RegisteredTaskCollection_create(const WCHAR *path, IRegisteredTaskCollection **obj)
 402 {
 403     RegisteredTaskCollection *regtasks;
 404
 405     regtasks = heap_alloc(sizeof(*regtasks));
 406     if (!regtasks) return E_OUTOFMEMORY;
 407
 408     regtasks->IRegisteredTaskCollection_iface.lpVtbl = &RegisteredTaskCollection_vtbl;
 409     regtasks->ref = 1;
 410     regtasks->path = heap_strdupW(path);
 411     *obj = &regtasks->IRegisteredTaskCollection_iface;
 412
 413     TRACE("created %p\n", *obj);
 414
 415     return S_OK;
 416 }