dlls/activeds/pathname.c

   1 /*
   2  * Copyright 2020 Dmitry Timoshkov
   3  *
   4  * This file contains only stubs to get the printui.dll up and running
   5  * activeds.dll is much much more than this
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "iads.h"
  29
  30 #include "wine/heap.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(activeds);
  34
  35 #include "initguid.h"
  36 DEFINE_GUID(CLSID_Pathname,0x080d0d78,0xf421,0x11d0,0xa3,0x6e,0x00,0xc0,0x4f,0xb9,0x50,0xdc);
  37
  38 typedef struct
  39 {
  40     IADsPathname IADsPathname_iface;
  41     LONG ref;
  42     BSTR adspath;
  43 } Pathname;
  44
  45 static inline Pathname *impl_from_IADsPathname(IADsPathname *iface)
  46 {
  47     return CONTAINING_RECORD(iface, Pathname, IADsPathname_iface);
  48 }
  49
  50 static HRESULT WINAPI path_QueryInterface(IADsPathname *iface, REFIID riid, void **obj)
  51 {
  52     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
  53
  54     if (!riid || !obj) return E_INVALIDARG;
  55
  56     if (IsEqualGUID(riid, &IID_IUnknown) ||
  57         IsEqualGUID(riid, &IID_IDispatch) ||
  58         IsEqualGUID(riid, &IID_IADsPathname))
  59     {
  60         IADsPathname_AddRef(iface);
  61         *obj = iface;
  62         return S_OK;
  63     }
  64
  65     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
  66     return E_NOINTERFACE;
  67 }
  68
  69 static ULONG WINAPI path_AddRef(IADsPathname *iface)
  70 {
  71     Pathname *path = impl_from_IADsPathname(iface);
  72     return InterlockedIncrement(&path->ref);
  73 }
  74
  75 static ULONG WINAPI path_Release(IADsPathname *iface)
  76 {
  77     Pathname *path = impl_from_IADsPathname(iface);
  78     LONG ref = InterlockedDecrement(&path->ref);
  79
  80     if (!ref)
  81     {
  82         TRACE("destroying %p\n", iface);
  83         heap_free(path);
  84     }
  85
  86     return ref;
  87 }
  88
  89 static HRESULT WINAPI path_GetTypeInfoCount(IADsPathname *iface, UINT *count)
  90 {
  91     FIXME("%p,%p: stub\n", iface, count);
  92     return E_NOTIMPL;
  93 }
  94
  95 static HRESULT WINAPI path_GetTypeInfo(IADsPathname *iface, UINT index, LCID lcid, ITypeInfo **info)
  96 {
  97     FIXME("%p,%u,%#x,%p: stub\n", iface, index, lcid, info);
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI path_GetIDsOfNames(IADsPathname *iface, REFIID riid, LPOLESTR *names,
 102                                          UINT count, LCID lcid, DISPID *dispid)
 103 {
 104     FIXME("%p,%s,%p,%u,%u,%p: stub\n", iface, debugstr_guid(riid), names, count, lcid, dispid);
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI path_Invoke(IADsPathname *iface, DISPID dispid, REFIID riid, LCID lcid, WORD flags,
 109                                   DISPPARAMS *params, VARIANT *result, EXCEPINFO *excepinfo, UINT *argerr)
 110 {
 111     FIXME("%p,%d,%s,%04x,%04x,%p,%p,%p,%p: stub\n", iface, dispid, debugstr_guid(riid), lcid, flags,
 112           params, result, excepinfo, argerr);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI path_Set(IADsPathname *iface, BSTR adspath, LONG type)
 117 {
 118     Pathname *path = impl_from_IADsPathname(iface);
 119
 120     FIXME("%p,%s,%d: stub\n", iface, debugstr_w(adspath), type);
 121
 122     if (!adspath) return E_INVALIDARG;
 123
 124     path->adspath = SysAllocString(adspath);
 125     return path->adspath ? S_OK : E_OUTOFMEMORY;
 126 }
 127
 128 static HRESULT WINAPI path_SetDisplayType(IADsPathname *iface, LONG type)
 129 {
 130     FIXME("%p,%d: stub\n", iface, type);
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI path_Retrieve(IADsPathname *iface, LONG type, BSTR *adspath)
 135 {
 136     Pathname *path = impl_from_IADsPathname(iface);
 137
 138     FIXME("%p,%d,%p: stub\n", iface, type, adspath);
 139
 140     if (!adspath) return E_INVALIDARG;
 141
 142     *adspath = SysAllocString(path->adspath);
 143     return *adspath ? S_OK : E_OUTOFMEMORY;
 144 }
 145
 146 static HRESULT WINAPI path_GetNumElements(IADsPathname *iface, LONG *count)
 147 {
 148     FIXME("%p,%p: stub\n", iface, count);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI path_GetElement(IADsPathname *iface, LONG index, BSTR *element)
 153 {
 154     FIXME("%p,%d,%p: stub\n", iface, index, element);
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI path_AddLeafElement(IADsPathname *iface, BSTR element)
 159 {
 160     FIXME("%p,%s: stub\n", iface, debugstr_w(element));
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI path_RemoveLeafElement(IADsPathname *iface)
 165 {
 166     FIXME("%p: stub\n", iface);
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI path_CopyPath(IADsPathname *iface, IDispatch **path)
 171 {
 172     FIXME("%p,%p: stub\n", iface, path);
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI path_GetEscapedElement(IADsPathname *iface, LONG reserved, BSTR element, BSTR *str)
 177 {
 178     FIXME("%p,%d,%s,%p: stub\n", iface, reserved, debugstr_w(element), str);
 179     return E_NOTIMPL;
 180 }
 181
 182 static HRESULT WINAPI path_get_EscapedMode(IADsPathname *iface, LONG *mode)
 183 {
 184     FIXME("%p,%p: stub\n", iface, mode);
 185     return E_NOTIMPL;
 186 }
 187
 188 static HRESULT WINAPI path_put_EscapedMode(IADsPathname *iface, LONG mode)
 189 {
 190     FIXME("%p,%d: stub\n", iface, mode);
 191     return E_NOTIMPL;
 192 }
 193
 194 static const IADsPathnameVtbl IADsPathname_vtbl =
 195 {
 196     path_QueryInterface,
 197     path_AddRef,
 198     path_Release,
 199     path_GetTypeInfoCount,
 200     path_GetTypeInfo,
 201     path_GetIDsOfNames,
 202     path_Invoke,
 203     path_Set,
 204     path_SetDisplayType,
 205     path_Retrieve,
 206     path_GetNumElements,
 207     path_GetElement,
 208     path_AddLeafElement,
 209     path_RemoveLeafElement,
 210     path_CopyPath,
 211     path_GetEscapedElement,
 212     path_get_EscapedMode,
 213     path_put_EscapedMode
 214 };
 215
 216 static HRESULT Pathname_create(REFIID riid, void **obj)
 217 {
 218     Pathname *path;
 219     HRESULT hr;
 220
 221     path = heap_alloc(sizeof(*path));
 222     if (!path) return E_OUTOFMEMORY;
 223
 224     path->IADsPathname_iface.lpVtbl = &IADsPathname_vtbl;
 225     path->ref = 1;
 226     path->adspath = NULL;
 227
 228     hr = IADsPathname_QueryInterface(&path->IADsPathname_iface, riid, obj);
 229     IADsPathname_Release(&path->IADsPathname_iface);
 230
 231     return hr;
 232 }
 233
 234 static const struct class_info
 235 {
 236     const CLSID *clsid;
 237     HRESULT (*constructor)(REFIID, void **);
 238 } class_info[] =
 239 {
 240     { &CLSID_Pathname, Pathname_create }
 241 };
 242
 243 typedef struct
 244 {
 245     IClassFactory IClassFactory_iface;
 246     LONG ref;
 247     const struct class_info *info;
 248 } class_factory;
 249
 250 static inline class_factory *impl_from_IClassFactory(IClassFactory *iface)
 251 {
 252     return CONTAINING_RECORD(iface, class_factory, IClassFactory_iface);
 253 }
 254
 255 static HRESULT WINAPI factory_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *obj)
 256 {
 257     TRACE("%p,%s,%p\n", iface, debugstr_guid(riid), obj);
 258
 259     if (!riid || !obj) return E_INVALIDARG;
 260
 261     if (IsEqualIID(riid, &IID_IUnknown) ||
 262         IsEqualIID(riid, &IID_IClassFactory))
 263     {
 264         IClassFactory_AddRef(iface);
 265         *obj = iface;
 266         return S_OK;
 267     }
 268
 269     *obj = NULL;
 270     FIXME("interface %s is not implemented\n", debugstr_guid(riid));
 271     return E_NOINTERFACE;
 272 }
 273
 274 static ULONG WINAPI factory_AddRef(IClassFactory *iface)
 275 {
 276     class_factory *factory = impl_from_IClassFactory(iface);
 277     ULONG ref = InterlockedIncrement(&factory->ref);
 278
 279     TRACE("(%p) ref %u\n", iface, ref);
 280
 281     return ref;
 282 }
 283
 284 static ULONG WINAPI factory_Release(IClassFactory *iface)
 285 {
 286     class_factory *factory = impl_from_IClassFactory(iface);
 287     ULONG ref = InterlockedDecrement(&factory->ref);
 288
 289     TRACE("(%p) ref %u\n", iface, ref);
 290
 291     if (!ref)
 292         heap_free(factory);
 293
 294     return ref;
 295 }
 296
 297 static HRESULT WINAPI factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj)
 298 {
 299     class_factory *factory = impl_from_IClassFactory(iface);
 300
 301     TRACE("%p,%s,%p\n", outer, debugstr_guid(riid), obj);
 302
 303     if (!riid || !obj) return E_INVALIDARG;
 304
 305     *obj = NULL;
 306     if (outer) return CLASS_E_NOAGGREGATION;
 307
 308     return factory->info->constructor(riid, obj);
 309 }
 310
 311 static HRESULT WINAPI factory_LockServer(IClassFactory *iface, BOOL lock)
 312 {
 313     FIXME("%p,%d: stub\n", iface, lock);
 314     return S_OK;
 315 }
 316
 317 static const struct IClassFactoryVtbl factory_vtbl =
 318 {
 319     factory_QueryInterface,
 320     factory_AddRef,
 321     factory_Release,
 322     factory_CreateInstance,
 323     factory_LockServer
 324 };
 325
 326 static HRESULT factory_constructor(const struct class_info *info, REFIID riid, void **obj)
 327 {
 328     class_factory *factory;
 329     HRESULT hr;
 330
 331     factory = heap_alloc(sizeof(*factory));
 332     if (!factory) return E_OUTOFMEMORY;
 333
 334     factory->IClassFactory_iface.lpVtbl = &factory_vtbl;
 335     factory->ref = 1;
 336     factory->info = info;
 337
 338     hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj);
 339     IClassFactory_Release(&factory->IClassFactory_iface);
 340
 341     return hr;
 342 }
 343
 344 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *obj)
 345 {
 346     int i;
 347
 348     TRACE("%s,%s,%p\n", debugstr_guid(clsid), debugstr_guid(iid), obj);
 349
 350     if (!clsid || !iid || !obj) return E_INVALIDARG;
 351
 352     *obj = NULL;
 353
 354     for (i = 0; i < ARRAY_SIZE(class_info); i++)
 355     {
 356         if (IsEqualCLSID(class_info[i].clsid, clsid))
 357             return factory_constructor(&class_info[i], iid, obj);
 358     }
 359
 360     FIXME("class %s/%s is not implemented\n", debugstr_guid(clsid), debugstr_guid(iid));
 361     return CLASS_E_CLASSNOTAVAILABLE;
 362 }