dlls/taskschd/folder_collection.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 "objbase.h"
  26 #include "taskschd.h"
  27 #include "taskschd_private.h"
  28
  29 #include "wine/unicode.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(taskschd);
  33
  34 static const char root[] = "Software\\Microsoft\\Windows NT\\CurrentVersion\\Schedule\\TaskCache\\Tree";
  35
  36 typedef struct
  37 {
  38     ITaskFolderCollection ITaskFolderCollection_iface;
  39     LONG ref;
  40     WCHAR *path;
  41     LPWSTR *list;
  42     LONG count;
  43 } TaskFolderCollection;
  44
  45 static HRESULT NewEnum_create(TaskFolderCollection *folders, IUnknown **obj);
  46
  47 static inline TaskFolderCollection *impl_from_ITaskFolderCollection(ITaskFolderCollection *iface)
  48 {
  49     return CONTAINING_RECORD(iface, TaskFolderCollection, ITaskFolderCollection_iface);
  50 }
  51
  52 static ULONG WINAPI folders_AddRef(ITaskFolderCollection *iface)
  53 {
  54     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
  55     return InterlockedIncrement(&folders->ref);
  56 }
  57
  58 static void free_list(LPWSTR *list, LONG count)
  59 {
  60     LONG i;
  61
  62     for (i = 0; i < count; i++)
  63         heap_free(list[i]);
  64
  65     heap_free(list);
  66 }
  67
  68 static ULONG WINAPI folders_Release(ITaskFolderCollection *iface)
  69 {
  70     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
  71     LONG ref = InterlockedDecrement(&folders->ref);
  72
  73     if (!ref)
  74     {
  75         TRACE("destroying %p\n", iface);
  76         free_list(folders->list, folders->count);
  77         heap_free(folders->path);
  78         heap_free(folders);
  79     }
  80
  81     return ref;
  82 }
  83
  84 static HRESULT WINAPI folders_QueryInterface(ITaskFolderCollection *iface, REFIID riid, void **obj)
  85 {
  86     if (!riid || !obj) return E_INVALIDARG;
  87
  88     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  89
  90     if (IsEqualGUID(riid, &IID_ITaskFolderCollection) ||
  91         IsEqualGUID(riid, &IID_IDispatch) ||
  92         IsEqualGUID(riid, &IID_IUnknown))
  93     {
  94         ITaskFolderCollection_AddRef(iface);
  95         *obj = iface;
  96         return S_OK;
  97     }
  98
  99     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 100     *obj = NULL;
 101     return E_NOINTERFACE;
 102 }
 103
 104 static HRESULT WINAPI folders_GetTypeInfoCount(ITaskFolderCollection *iface, UINT *count)
 105 {
 106     FIXME("%p,%p: stub\n", iface, count);
 107     return E_NOTIMPL;
 108 }
 109
 110 static HRESULT WINAPI folders_GetTypeInfo(ITaskFolderCollection *iface, UINT index, LCID lcid, ITypeInfo **info)
 111 {
 112     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI folders_GetIDsOfNames(ITaskFolderCollection *iface, REFIID riid, LPOLESTR *names,
 117                                                 UINT count, LCID lcid, DISPID *dispid)
 118 {
 119     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI folders_Invoke(ITaskFolderCollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 124                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 125 {
 126     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 127           params, result, excepinfo, argerr);
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI folders_get_Count(ITaskFolderCollection *iface, LONG *count)
 132 {
 133     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 134
 135     TRACE("%p,%p\n", iface, count);
 136
 137     if (!count) return E_POINTER;
 138
 139     *count = folders->count;
 140
 141     return S_OK;
 142 }
 143
 144 static LONG get_var_int(const VARIANT *var)
 145 {
 146     switch(V_VT(var))
 147     {
 148     case VT_I1:
 149     case VT_UI1:
 150         return V_UI1(var);
 151
 152     case VT_I2:
 153     case VT_UI2:
 154         return V_UI2(var);
 155
 156     case VT_I4:
 157     case VT_UI4:
 158         return V_UI4(var);
 159
 160     case VT_I8:
 161     case VT_UI8:
 162         return V_UI8(var);
 163
 164     case VT_INT:
 165     case VT_UINT:
 166         return V_UINT(var);
 167
 168     default:
 169         FIXME("unsupported variant type %d\n", V_VT(var));
 170         return 0;
 171     }
 172 }
 173
 174 static HRESULT WINAPI folders_get_Item(ITaskFolderCollection *iface, VARIANT index, ITaskFolder **folder)
 175 {
 176     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 177     LONG idx;
 178
 179     TRACE("%p,%s,%p\n", iface, debugstr_variant(&index), folder);
 180
 181     if (!folder) return E_POINTER;
 182
 183     if (V_VT(&index) == VT_BSTR)
 184         return TaskFolder_create(folders->path, V_BSTR(&index), folder, FALSE);
 185
 186     idx = get_var_int(&index);
 187     /* collections are 1 based */
 188     if (idx < 1 || idx > folders->count)
 189         return E_INVALIDARG;
 190
 191     return TaskFolder_create(folders->path, folders->list[idx - 1], folder, FALSE);
 192 }
 193
 194 static HRESULT WINAPI folders_get__NewEnum(ITaskFolderCollection *iface, IUnknown **penum)
 195 {
 196     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 197
 198     TRACE("%p,%p\n", iface, penum);
 199
 200     if (!penum) return E_POINTER;
 201
 202     return NewEnum_create(folders, penum);
 203 }
 204
 205 static const ITaskFolderCollectionVtbl TaskFolderCollection_vtbl =
 206 {
 207     folders_QueryInterface,
 208     folders_AddRef,
 209     folders_Release,
 210     folders_GetTypeInfoCount,
 211     folders_GetTypeInfo,
 212     folders_GetIDsOfNames,
 213     folders_Invoke,
 214     folders_get_Count,
 215     folders_get_Item,
 216     folders_get__NewEnum
 217 };
 218
 219 static HRESULT reg_open_folder(const WCHAR *path, HKEY *hfolder)
 220 {
 221     HKEY hroot;
 222     DWORD ret;
 223
 224     ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, root, &hroot);
 225     if (ret) return HRESULT_FROM_WIN32(ret);
 226
 227     while (*path == '\\') path++;
 228     ret = RegOpenKeyExW(hroot, path, 0, KEY_ALL_ACCESS, hfolder);
 229     if (ret == ERROR_FILE_NOT_FOUND)
 230         ret = ERROR_PATH_NOT_FOUND;
 231
 232     RegCloseKey(hroot);
 233
 234     return HRESULT_FROM_WIN32(ret);
 235 }
 236
 237 static inline void reg_close_folder(HKEY hfolder)
 238 {
 239     RegCloseKey(hfolder);
 240 }
 241
 242 static HRESULT create_folders_list(const WCHAR *path, LPWSTR **folders_list, LONG *folders_count)
 243 {
 244     HRESULT hr;
 245     HKEY hfolder;
 246     WCHAR name[MAX_PATH];
 247     LONG ret, idx, allocated, count;
 248     LPWSTR *list;
 249
 250     *folders_list = NULL;
 251     *folders_count = 0;
 252
 253     hr = reg_open_folder(path, &hfolder);
 254     if (hr) return hr;
 255
 256     allocated = 64;
 257     list = heap_alloc(allocated * sizeof(LPWSTR));
 258     if (!list)
 259     {
 260         reg_close_folder(hfolder);
 261         return E_OUTOFMEMORY;
 262     }
 263
 264     idx = count = 0;
 265
 266     while (!(ret = RegEnumKeyW(hfolder, idx++, name, MAX_PATH)))
 267     {
 268         /* FIXME: differentiate between folders and tasks */
 269         if (count >= allocated)
 270         {
 271             LPWSTR *new_list;
 272             allocated *= 2;
 273             new_list = heap_realloc(list, allocated * sizeof(LPWSTR));
 274             if (!new_list)
 275             {
 276                 reg_close_folder(hfolder);
 277                 free_list(list, count);
 278                 return E_OUTOFMEMORY;
 279             }
 280             list = new_list;
 281         }
 282
 283         list[count] = heap_strdupW(name);
 284         if (!list[count])
 285         {
 286             reg_close_folder(hfolder);
 287             free_list(list, count);
 288             return E_OUTOFMEMORY;
 289         }
 290
 291         count++;
 292     }
 293
 294     reg_close_folder(hfolder);
 295
 296     *folders_list = list;
 297     *folders_count = count;
 298
 299     return S_OK;
 300 }
 301
 302 HRESULT TaskFolderCollection_create(const WCHAR *path, ITaskFolderCollection **obj)
 303 {
 304     TaskFolderCollection *folders;
 305     HRESULT hr;
 306     LPWSTR *list;
 307     LONG count;
 308
 309     hr = create_folders_list(path, &list, &count);
 310     if (hr) return hr;
 311
 312     folders = heap_alloc(sizeof(*folders));
 313     if (!folders)
 314     {
 315         free_list(list, count);
 316         return E_OUTOFMEMORY;
 317     }
 318
 319     folders->ITaskFolderCollection_iface.lpVtbl = &TaskFolderCollection_vtbl;
 320     folders->ref = 1;
 321     folders->path = heap_strdupW(path);
 322     folders->count = count;
 323     folders->list = list;
 324     *obj = &folders->ITaskFolderCollection_iface;
 325
 326     TRACE("created %p\n", *obj);
 327
 328     return S_OK;
 329 }
 330
 331 typedef struct
 332 {
 333     IEnumVARIANT IEnumVARIANT_iface;
 334     LONG ref, pos;
 335     TaskFolderCollection *folders;
 336 } EnumVARIANT;
 337
 338 static inline EnumVARIANT *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
 339 {
 340     return CONTAINING_RECORD(iface, EnumVARIANT, IEnumVARIANT_iface);
 341 }
 342
 343 static HRESULT WINAPI enumvar_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
 344 {
 345     if (!riid || !obj) return E_INVALIDARG;
 346
 347     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 348
 349     if (IsEqualGUID(riid, &IID_IEnumVARIANT) ||
 350         IsEqualGUID(riid, &IID_IUnknown))
 351     {
 352         IEnumVARIANT_AddRef(iface);
 353         *obj = iface;
 354         return S_OK;
 355     }
 356
 357     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 358     *obj = NULL;
 359     return E_NOINTERFACE;
 360 }
 361
 362 static ULONG WINAPI enumvar_AddRef(IEnumVARIANT *iface)
 363 {
 364     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 365     return InterlockedIncrement(&enumvar->ref);
 366 }
 367
 368 static ULONG WINAPI enumvar_Release(IEnumVARIANT *iface)
 369 {
 370     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 371     LONG ref = InterlockedDecrement(&enumvar->ref);
 372
 373     if (!ref)
 374     {
 375         TRACE("destroying %p\n", iface);
 376         ITaskFolderCollection_Release(&enumvar->folders->ITaskFolderCollection_iface);
 377         heap_free(enumvar);
 378     }
 379
 380     return ref;
 381 }
 382
 383 static HRESULT WINAPI enumvar_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
 384 {
 385     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 386     LONG i;
 387
 388     TRACE("%p,%u,%p,%p\n", iface, celt, var, fetched);
 389
 390     for (i = 0; i < celt && enumvar->pos < enumvar->folders->count; i++)
 391     {
 392         ITaskFolder *folder;
 393         HRESULT hr;
 394
 395         hr = TaskFolder_create(enumvar->folders->path, enumvar->folders->list[enumvar->pos++], &folder, FALSE);
 396         if (hr) return hr;
 397
 398         if (!var)
 399         {
 400             ITaskFolder_Release(folder);
 401             return E_POINTER;
 402         }
 403
 404         V_VT(&var[i]) = VT_DISPATCH;
 405         V_DISPATCH(&var[i]) = (IDispatch *)folder;
 406     }
 407
 408     if (fetched) *fetched = i;
 409
 410     return i == celt ? S_OK : S_FALSE;
 411 }
 412
 413 static HRESULT WINAPI enumvar_Skip(IEnumVARIANT *iface, ULONG celt)
 414 {
 415     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 416
 417     TRACE("%p,%u\n", iface, celt);
 418
 419     enumvar->pos += celt;
 420
 421     if (enumvar->pos > enumvar->folders->count)
 422     {
 423         enumvar->pos = enumvar->folders->count;
 424         return S_FALSE;
 425     }
 426
 427     return S_OK;
 428 }
 429
 430 static HRESULT WINAPI enumvar_Reset(IEnumVARIANT *iface)
 431 {
 432     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 433
 434     TRACE("%p\n", iface);
 435
 436     enumvar->pos = 0;
 437
 438     return S_OK;
 439 }
 440
 441 static HRESULT WINAPI enumvar_Clone(IEnumVARIANT *iface, IEnumVARIANT **penum)
 442 {
 443     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 444
 445     TRACE("%p,%p\n", iface, penum);
 446
 447     return NewEnum_create(enumvar->folders, (IUnknown **)penum);
 448 }
 449
 450 static const struct IEnumVARIANTVtbl EnumVARIANT_vtbl =
 451 {
 452     enumvar_QueryInterface,
 453     enumvar_AddRef,
 454     enumvar_Release,
 455     enumvar_Next,
 456     enumvar_Skip,
 457     enumvar_Reset,
 458     enumvar_Clone
 459 };
 460
 461 static HRESULT NewEnum_create(TaskFolderCollection *folders, IUnknown **obj)
 462 {
 463     EnumVARIANT *enumvar;
 464
 465     enumvar = heap_alloc(sizeof(*enumvar));
 466     if (!enumvar) return E_OUTOFMEMORY;
 467
 468     enumvar->IEnumVARIANT_iface.lpVtbl = &EnumVARIANT_vtbl;
 469     enumvar->ref = 1;
 470     enumvar->pos = 0;
 471     enumvar->folders = folders;
 472     ITaskFolderCollection_AddRef(&folders->ITaskFolderCollection_iface);
 473
 474     *obj = (IUnknown *)&enumvar->IEnumVARIANT_iface;
 475
 476     TRACE("created %p\n", *obj);
 477
 478     return S_OK;
 479 }