dlls/dsquery/main.c

   1 /*
   2  * Copyright 2017 Zebediah Figura for CodeWeavers
   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 "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "objbase.h"
  28 #include "rpcproxy.h"
  29 #include "initguid.h"
  30 #include "cmnquery.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(dsquery);
  34
  35 static HINSTANCE instance;
  36
  37 /******************************************************************
  38  *      IClassFactory implementation
  39  */
  40 struct query_class_factory {
  41     IClassFactory IClassFactory_iface;
  42     LONG ref;
  43     HRESULT (*pfnCreateInstance)(IUnknown *outer, REFIID riid, void **out);
  44 };
  45
  46 static inline struct query_class_factory *impl_from_IClassFactory(IClassFactory *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct query_class_factory, IClassFactory_iface);
  49 }
  50
  51 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **out)
  52 {
  53     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), out);
  54
  55     if (IsEqualGUID(riid, &IID_IClassFactory) || IsEqualGUID(riid, &IID_IUnknown))
  56     {
  57         IClassFactory_AddRef(iface);
  58         *out = iface;
  59         return S_OK;
  60     }
  61
  62     FIXME("interface %s not implemented\n", debugstr_guid(riid));
  63     *out = NULL;
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
  68 {
  69     struct query_class_factory *This = impl_from_IClassFactory(iface);
  70     ULONG ref = InterlockedIncrement(&This->ref);
  71
  72     TRACE("(%p) increasing refcount to %u\n", iface, ref);
  73
  74     return ref;
  75 }
  76
  77 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
  78 {
  79     struct query_class_factory *This = impl_from_IClassFactory(iface);
  80     ULONG ref = InterlockedDecrement(&This->ref);
  81
  82     TRACE("(%p) decreasing refcount to %u\n", iface, ref);
  83
  84     if (ref == 0)
  85         HeapFree(GetProcessHeap(), 0, This);
  86
  87     return ref;
  88 }
  89
  90 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface,
  91         IUnknown *outer, REFIID riid, void **out)
  92 {
  93     struct query_class_factory *This = impl_from_IClassFactory(iface);
  94
  95     TRACE("(%p)->(%p, %s, %p)\n", iface, outer, debugstr_guid(riid), out);
  96
  97     return This->pfnCreateInstance(outer, riid, out);
  98 }
  99
 100 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
 101 {
 102     FIXME("(%p)->(%d)\n", iface, dolock);
 103
 104     return S_OK;
 105 }
 106
 107 static const IClassFactoryVtbl query_class_factory_vtbl =
 108 {
 109     ClassFactory_QueryInterface,
 110     ClassFactory_AddRef,
 111     ClassFactory_Release,
 112     ClassFactory_CreateInstance,
 113     ClassFactory_LockServer,
 114 };
 115
 116 /******************************************************************
 117  *      ICommonQuery implementation
 118  */
 119 struct common_query {
 120     ICommonQuery ICommonQuery_iface;
 121     LONG ref;
 122 };
 123
 124 static inline struct common_query *impl_from_ICommonQuery(ICommonQuery *iface)
 125 {
 126     return CONTAINING_RECORD(iface, struct common_query, ICommonQuery_iface);
 127 }
 128
 129 static HRESULT WINAPI CommonQuery_QueryInterface(ICommonQuery *iface, REFIID riid, void **out)
 130 {
 131     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), out);
 132
 133     if (IsEqualGUID(riid, &IID_ICommonQuery) || IsEqualGUID(riid, &IID_IUnknown))
 134     {
 135         ICommonQuery_AddRef(iface);
 136         *out = iface;
 137         return S_OK;
 138     }
 139
 140     FIXME("interface %s not implemented\n", debugstr_guid(riid));
 141     *out = NULL;
 142     return E_NOINTERFACE;
 143 }
 144
 145 static ULONG WINAPI CommonQuery_AddRef(ICommonQuery *iface)
 146 {
 147     struct common_query *This = impl_from_ICommonQuery(iface);
 148     ULONG ref = InterlockedIncrement(&This->ref);
 149
 150     TRACE("(%p) increasing refcount to %u\n", iface, ref);
 151
 152     return ref;
 153 }
 154
 155 static ULONG WINAPI CommonQuery_Release(ICommonQuery *iface)
 156 {
 157     struct common_query *This = impl_from_ICommonQuery(iface);
 158     ULONG ref = InterlockedDecrement(&This->ref);
 159
 160     TRACE("(%p) decreasing refcount to %u\n", iface, ref);
 161
 162     if (ref == 0)
 163         HeapFree(GetProcessHeap(), 0, This);
 164
 165     return ref;
 166 }
 167
 168 static HRESULT WINAPI CommonQuery_OpenQueryWindow(ICommonQuery *iface,
 169         HWND parent, LPOPENQUERYWINDOW query_window, IDataObject **data_object)
 170 {
 171     FIXME("(%p)->(%p, %p, %p) stub!\n", iface, parent, query_window, data_object);
 172
 173     return E_NOTIMPL;
 174 }
 175
 176 static const ICommonQueryVtbl CommonQuery_vtbl =
 177 {
 178     CommonQuery_QueryInterface,
 179     CommonQuery_AddRef,
 180     CommonQuery_Release,
 181     CommonQuery_OpenQueryWindow,
 182 };
 183
 184 static HRESULT CommonQuery_create(IUnknown *outer, REFIID riid, void **out)
 185 {
 186     struct common_query *query;
 187
 188     TRACE("outer %p, riid %s, out %p\n", outer, debugstr_guid(riid), out);
 189
 190     if (outer)
 191         return CLASS_E_NOAGGREGATION;
 192
 193     if (!(query = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*query))))
 194         return E_OUTOFMEMORY;
 195
 196     query->ICommonQuery_iface.lpVtbl = &CommonQuery_vtbl;
 197     return ICommonQuery_QueryInterface(&query->ICommonQuery_iface, riid, out);
 198 }
 199
 200 /***********************************************************************
 201  *              DllMain
 202  */
 203 BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, void *reserved)
 204 {
 205     TRACE("(%p, %u, %p)\n", inst, reason, reserved);
 206
 207     switch (reason)
 208     {
 209         case DLL_PROCESS_ATTACH:
 210             instance = inst;
 211             DisableThreadLibraryCalls(inst);
 212             break;
 213     }
 214
 215     return TRUE;
 216 }
 217
 218 /***********************************************************************
 219  *              DllCanUnloadNow (DSQUERY.@)
 220  */
 221 HRESULT WINAPI DllCanUnloadNow(void)
 222 {
 223     return S_FALSE;
 224 }
 225
 226 /***********************************************************************
 227  *              DllGetClassObject (DSQUERY.@)
 228  */
 229 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **out)
 230 {
 231     TRACE("rclsid %s, riid %s, out %p\n", debugstr_guid(rclsid), debugstr_guid(riid), out);
 232
 233     if (!IsEqualGUID( &IID_IClassFactory, riid)
 234         && !IsEqualGUID( &IID_IUnknown, riid))
 235     {
 236         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 237         *out = NULL;
 238         return E_NOINTERFACE;
 239     }
 240
 241     if (IsEqualGUID(&CLSID_CommonQuery, rclsid))
 242     {
 243         struct query_class_factory *factory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*factory));
 244         if (!factory) return E_OUTOFMEMORY;
 245
 246         factory->IClassFactory_iface.lpVtbl = &query_class_factory_vtbl;
 247         factory->ref = 1;
 248         factory->pfnCreateInstance = CommonQuery_create;
 249         *out = factory;
 250         return S_OK;
 251     }
 252
 253     FIXME("%s: no class found\n", debugstr_guid(rclsid));
 254     *out = NULL;
 255     return CLASS_E_CLASSNOTAVAILABLE;
 256 }
 257
 258 /***********************************************************************
 259  *              DllRegisterServer (DSQUERY.@)
 260  */
 261 HRESULT WINAPI DllRegisterServer(void)
 262 {
 263     return __wine_register_resources( instance );
 264 }
 265
 266 /***********************************************************************
 267  *              DllUnregisterServer (DSQUERY.@)
 268  */
 269 HRESULT WINAPI DllUnregisterServer(void)
 270 {
 271     return __wine_unregister_resources( instance );
 272 }