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 "schrpc.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     ITaskFolderCollection ITaskFolderCollection_iface;
  38     LONG ref;
  39     WCHAR *path;
  40     TASK_NAMES list;
  41     DWORD count;
  42 } TaskFolderCollection;
  43
  44 static HRESULT NewEnum_create(TaskFolderCollection *folders, IUnknown **obj);
  45
  46 static inline TaskFolderCollection *impl_from_ITaskFolderCollection(ITaskFolderCollection *iface)
  47 {
  48     return CONTAINING_RECORD(iface, TaskFolderCollection, ITaskFolderCollection_iface);
  49 }
  50
  51 static ULONG WINAPI folders_AddRef(ITaskFolderCollection *iface)
  52 {
  53     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
  54     return InterlockedIncrement(&folders->ref);
  55 }
  56
  57 static void free_list(LPWSTR *list, DWORD count)
  58 {
  59     LONG i;
  60
  61     for (i = 0; i < count; i++)
  62         MIDL_user_free(list[i]);
  63
  64     MIDL_user_free(list);
  65 }
  66
  67 static ULONG WINAPI folders_Release(ITaskFolderCollection *iface)
  68 {
  69     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
  70     LONG ref = InterlockedDecrement(&folders->ref);
  71
  72     if (!ref)
  73     {
  74         TRACE("destroying %p\n", iface);
  75         free_list(folders->list, folders->count);
  76         heap_free(folders->path);
  77         heap_free(folders);
  78     }
  79
  80     return ref;
  81 }
  82
  83 static HRESULT WINAPI folders_QueryInterface(ITaskFolderCollection *iface, REFIID riid, void **obj)
  84 {
  85     if (!riid || !obj) return E_INVALIDARG;
  86
  87     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  88
  89     if (IsEqualGUID(riid, &IID_ITaskFolderCollection) ||
  90         IsEqualGUID(riid, &IID_IDispatch) ||
  91         IsEqualGUID(riid, &IID_IUnknown))
  92     {
  93         ITaskFolderCollection_AddRef(iface);
  94         *obj = iface;
  95         return S_OK;
  96     }
  97
  98     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
  99     *obj = NULL;
 100     return E_NOINTERFACE;
 101 }
 102
 103 static HRESULT WINAPI folders_GetTypeInfoCount(ITaskFolderCollection *iface, UINT *count)
 104 {
 105     FIXME("%p,%p: stub\n", iface, count);
 106     return E_NOTIMPL;
 107 }
 108
 109 static HRESULT WINAPI folders_GetTypeInfo(ITaskFolderCollection *iface, UINT index, LCID lcid, ITypeInfo **info)
 110 {
 111     FIXME("%p,%u,%u,%p: stub\n", iface, index, lcid, info);
 112     return E_NOTIMPL;
 113 }
 114
 115 static HRESULT WINAPI folders_GetIDsOfNames(ITaskFolderCollection *iface, REFIID riid, LPOLESTR *names,
 116                                                 UINT count, LCID lcid, DISPID *dispid)
 117 {
 118     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 119     return E_NOTIMPL;
 120 }
 121
 122 static HRESULT WINAPI folders_Invoke(ITaskFolderCollection *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 123                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 124 {
 125     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 126           params, result, excepinfo, argerr);
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI folders_get_Count(ITaskFolderCollection *iface, LONG *count)
 131 {
 132     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 133
 134     TRACE("%p,%p\n", iface, count);
 135
 136     if (!count) return E_POINTER;
 137
 138     *count = folders->count;
 139
 140     return S_OK;
 141 }
 142
 143 static LONG get_var_int(const VARIANT *var)
 144 {
 145     switch(V_VT(var))
 146     {
 147     case VT_I1:
 148     case VT_UI1:
 149         return V_UI1(var);
 150
 151     case VT_I2:
 152     case VT_UI2:
 153         return V_UI2(var);
 154
 155     case VT_I4:
 156     case VT_UI4:
 157         return V_UI4(var);
 158
 159     case VT_I8:
 160     case VT_UI8:
 161         return V_UI8(var);
 162
 163     case VT_INT:
 164     case VT_UINT:
 165         return V_UINT(var);
 166
 167     default:
 168         FIXME("unsupported variant type %d\n", V_VT(var));
 169         return 0;
 170     }
 171 }
 172
 173 static HRESULT WINAPI folders_get_Item(ITaskFolderCollection *iface, VARIANT index, ITaskFolder **folder)
 174 {
 175     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 176     LONG idx;
 177
 178     TRACE("%p,%s,%p\n", iface, debugstr_variant(&index), folder);
 179
 180     if (!folder) return E_POINTER;
 181
 182     if (V_VT(&index) == VT_BSTR)
 183         return TaskFolder_create(folders->path, V_BSTR(&index), folder, FALSE);
 184
 185     idx = get_var_int(&index);
 186     /* collections are 1 based */
 187     if (idx < 1 || idx > folders->count)
 188         return E_INVALIDARG;
 189
 190     return TaskFolder_create(folders->path, folders->list[idx - 1], folder, FALSE);
 191 }
 192
 193 static HRESULT WINAPI folders_get__NewEnum(ITaskFolderCollection *iface, IUnknown **penum)
 194 {
 195     TaskFolderCollection *folders = impl_from_ITaskFolderCollection(iface);
 196
 197     TRACE("%p,%p\n", iface, penum);
 198
 199     if (!penum) return E_POINTER;
 200
 201     return NewEnum_create(folders, penum);
 202 }
 203
 204 static const ITaskFolderCollectionVtbl TaskFolderCollection_vtbl =
 205 {
 206     folders_QueryInterface,
 207     folders_AddRef,
 208     folders_Release,
 209     folders_GetTypeInfoCount,
 210     folders_GetTypeInfo,
 211     folders_GetIDsOfNames,
 212     folders_Invoke,
 213     folders_get_Count,
 214     folders_get_Item,
 215     folders_get__NewEnum
 216 };
 217
 218 HRESULT TaskFolderCollection_create(const WCHAR *path, ITaskFolderCollection **obj)
 219 {
 220     TaskFolderCollection *folders;
 221     HRESULT hr;
 222     TASK_NAMES list;
 223     DWORD start_index, count;
 224
 225     start_index = 0;
 226     list = NULL;
 227     hr = SchRpcEnumFolders(path, 0, &start_index, 0, &count, &list);
 228     if (hr != S_OK) return hr;
 229
 230     folders = heap_alloc(sizeof(*folders));
 231     if (!folders)
 232     {
 233         free_list(list, count);
 234         return E_OUTOFMEMORY;
 235     }
 236
 237     folders->ITaskFolderCollection_iface.lpVtbl = &TaskFolderCollection_vtbl;
 238     folders->ref = 1;
 239     if (!(folders->path = heap_strdupW(path)))
 240     {
 241         heap_free(folders);
 242         free_list(list, count);
 243         return E_OUTOFMEMORY;
 244     }
 245     folders->count = count;
 246     folders->list = list;
 247     *obj = &folders->ITaskFolderCollection_iface;
 248
 249     TRACE("created %p\n", *obj);
 250
 251     return S_OK;
 252 }
 253
 254 typedef struct
 255 {
 256     IEnumVARIANT IEnumVARIANT_iface;
 257     LONG ref, pos;
 258     TaskFolderCollection *folders;
 259 } EnumVARIANT;
 260
 261 static inline EnumVARIANT *impl_from_IEnumVARIANT(IEnumVARIANT *iface)
 262 {
 263     return CONTAINING_RECORD(iface, EnumVARIANT, IEnumVARIANT_iface);
 264 }
 265
 266 static HRESULT WINAPI enumvar_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **obj)
 267 {
 268     if (!riid || !obj) return E_INVALIDARG;
 269
 270     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 271
 272     if (IsEqualGUID(riid, &IID_IEnumVARIANT) ||
 273         IsEqualGUID(riid, &IID_IUnknown))
 274     {
 275         IEnumVARIANT_AddRef(iface);
 276         *obj = iface;
 277         return S_OK;
 278     }
 279
 280     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 281     *obj = NULL;
 282     return E_NOINTERFACE;
 283 }
 284
 285 static ULONG WINAPI enumvar_AddRef(IEnumVARIANT *iface)
 286 {
 287     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 288     return InterlockedIncrement(&enumvar->ref);
 289 }
 290
 291 static ULONG WINAPI enumvar_Release(IEnumVARIANT *iface)
 292 {
 293     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 294     LONG ref = InterlockedDecrement(&enumvar->ref);
 295
 296     if (!ref)
 297     {
 298         TRACE("destroying %p\n", iface);
 299         ITaskFolderCollection_Release(&enumvar->folders->ITaskFolderCollection_iface);
 300         heap_free(enumvar);
 301     }
 302
 303     return ref;
 304 }
 305
 306 static HRESULT WINAPI enumvar_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched)
 307 {
 308     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 309     LONG i;
 310
 311     TRACE("%p,%u,%p,%p\n", iface, celt, var, fetched);
 312
 313     for (i = 0; i < celt && enumvar->pos < enumvar->folders->count; i++)
 314     {
 315         ITaskFolder *folder;
 316         HRESULT hr;
 317
 318         hr = TaskFolder_create(enumvar->folders->path, enumvar->folders->list[enumvar->pos++], &folder, FALSE);
 319         if (hr) return hr;
 320
 321         if (!var)
 322         {
 323             ITaskFolder_Release(folder);
 324             return E_POINTER;
 325         }
 326
 327         V_VT(&var[i]) = VT_DISPATCH;
 328         V_DISPATCH(&var[i]) = (IDispatch *)folder;
 329     }
 330
 331     if (fetched) *fetched = i;
 332
 333     return i == celt ? S_OK : S_FALSE;
 334 }
 335
 336 static HRESULT WINAPI enumvar_Skip(IEnumVARIANT *iface, ULONG celt)
 337 {
 338     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 339
 340     TRACE("%p,%u\n", iface, celt);
 341
 342     enumvar->pos += celt;
 343
 344     if (enumvar->pos > enumvar->folders->count)
 345     {
 346         enumvar->pos = enumvar->folders->count;
 347         return S_FALSE;
 348     }
 349
 350     return S_OK;
 351 }
 352
 353 static HRESULT WINAPI enumvar_Reset(IEnumVARIANT *iface)
 354 {
 355     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 356
 357     TRACE("%p\n", iface);
 358
 359     enumvar->pos = 0;
 360
 361     return S_OK;
 362 }
 363
 364 static HRESULT WINAPI enumvar_Clone(IEnumVARIANT *iface, IEnumVARIANT **penum)
 365 {
 366     EnumVARIANT *enumvar = impl_from_IEnumVARIANT(iface);
 367
 368     TRACE("%p,%p\n", iface, penum);
 369
 370     return NewEnum_create(enumvar->folders, (IUnknown **)penum);
 371 }
 372
 373 static const struct IEnumVARIANTVtbl EnumVARIANT_vtbl =
 374 {
 375     enumvar_QueryInterface,
 376     enumvar_AddRef,
 377     enumvar_Release,
 378     enumvar_Next,
 379     enumvar_Skip,
 380     enumvar_Reset,
 381     enumvar_Clone
 382 };
 383
 384 static HRESULT NewEnum_create(TaskFolderCollection *folders, IUnknown **obj)
 385 {
 386     EnumVARIANT *enumvar;
 387
 388     enumvar = heap_alloc(sizeof(*enumvar));
 389     if (!enumvar) return E_OUTOFMEMORY;
 390
 391     enumvar->IEnumVARIANT_iface.lpVtbl = &EnumVARIANT_vtbl;
 392     enumvar->ref = 1;
 393     enumvar->pos = 0;
 394     enumvar->folders = folders;
 395     ITaskFolderCollection_AddRef(&folders->ITaskFolderCollection_iface);
 396
 397     *obj = (IUnknown *)&enumvar->IEnumVARIANT_iface;
 398
 399     TRACE("created %p\n", *obj);
 400
 401     return S_OK;
 402 }