dlls/oledb32/datainit.c

   1 /*
   2  * Copyright (C) 2012 Alistair Leslie-Hughes
   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 #include <stdarg.h>
  19
  20 #define COBJMACROS
  21 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27 #include "ole2.h"
  28 #include "msdasc.h"
  29 #include "oledberr.h"
  30
  31 #include "oledb_private.h"
  32
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  36
  37
  38 typedef struct datainit
  39 {
  40     IDataInitialize IDataInitialize_iface;
  41
  42     LONG ref;
  43 } datainit;
  44
  45 static inline datainit *impl_from_IDataInitialize(IDataInitialize *iface)
  46 {
  47     return CONTAINING_RECORD(iface, datainit, IDataInitialize_iface);
  48 }
  49
  50 typedef struct
  51 {
  52     IDBInitialize IDBInitialize_iface;
  53     IDBProperties IDBProperties_iface;
  54
  55     LONG ref;
  56 } dbinit;
  57
  58 static inline dbinit *impl_from_IDBInitialize(IDBInitialize *iface)
  59 {
  60     return CONTAINING_RECORD(iface, dbinit, IDBInitialize_iface);
  61 }
  62
  63 static inline dbinit *impl_from_IDBProperties(IDBProperties *iface)
  64 {
  65     return CONTAINING_RECORD(iface, dbinit, IDBProperties_iface);
  66 }
  67
  68 static HRESULT WINAPI dbprops_QueryInterface(IDBProperties *iface, REFIID riid, void **ppvObject)
  69 {
  70     dbinit *This = impl_from_IDBProperties(iface);
  71
  72     return IDBInitialize_QueryInterface(&This->IDBInitialize_iface, riid, ppvObject);
  73 }
  74
  75 static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
  76 {
  77     dbinit *This = impl_from_IDBProperties(iface);
  78
  79     return IDBInitialize_AddRef(&This->IDBInitialize_iface);
  80 }
  81
  82 static ULONG WINAPI dbprops_Release(IDBProperties *iface)
  83 {
  84     dbinit *This = impl_from_IDBProperties(iface);
  85
  86     return IDBInitialize_Release(&This->IDBInitialize_iface);
  87 }
  88
  89 static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
  90             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
  91 {
  92     dbinit *This = impl_from_IDBProperties(iface);
  93
  94     FIXME("(%p)->(%d %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
  95
  96     return E_NOTIMPL;
  97 }
  98
  99 static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
 100             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
 101             DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
 102 {
 103     dbinit *This = impl_from_IDBProperties(iface);
 104
 105     FIXME("(%p)->(%d %p %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 106                 prgPropertyInfoSets, ppDescBuffer);
 107
 108     return E_NOTIMPL;
 109 }
 110
 111 static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG cPropertySets,
 112             DBPROPSET rgPropertySets[])
 113 {
 114     dbinit *This = impl_from_IDBProperties(iface);
 115
 116     FIXME("(%p)->(%d %p)\n", This, cPropertySets, rgPropertySets);
 117
 118     return E_NOTIMPL;
 119 }
 120
 121 static const struct IDBPropertiesVtbl dbprops_vtbl =
 122 {
 123     dbprops_QueryInterface,
 124     dbprops_AddRef,
 125     dbprops_Release,
 126     dbprops_GetProperties,
 127     dbprops_GetPropertyInfo,
 128     dbprops_SetProperties
 129 };
 130
 131 static HRESULT WINAPI dbinit_QueryInterface(IDBInitialize *iface, REFIID riid, void **obj)
 132 {
 133     dbinit *This = impl_from_IDBInitialize(iface);
 134     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 135
 136     *obj = NULL;
 137
 138     if(IsEqualIID(riid, &IID_IUnknown) ||
 139        IsEqualIID(riid, &IID_IDBInitialize))
 140     {
 141         *obj = iface;
 142     }
 143     else if(IsEqualIID(riid, &IID_IDBProperties))
 144     {
 145         *obj = &This->IDBProperties_iface;
 146     }
 147     else
 148     {
 149         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 150         return E_NOINTERFACE;
 151     }
 152
 153     IDBInitialize_AddRef(iface);
 154     return S_OK;
 155 }
 156
 157 static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
 158 {
 159     dbinit *This = impl_from_IDBInitialize(iface);
 160     TRACE("(%p)\n", This);
 161
 162     return InterlockedIncrement(&This->ref);
 163 }
 164
 165 static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
 166 {
 167     dbinit *This = impl_from_IDBInitialize(iface);
 168     LONG ref;
 169
 170     TRACE("(%p)\n", This);
 171
 172     ref = InterlockedDecrement(&This->ref);
 173     if(ref == 0)
 174     {
 175         HeapFree(GetProcessHeap(), 0, This);
 176     }
 177
 178     return ref;
 179 }
 180
 181 static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
 182 {
 183     dbinit *This = impl_from_IDBInitialize(iface);
 184
 185     FIXME("(%p) stub\n", This);
 186
 187     return S_OK;
 188 }
 189
 190 static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
 191 {
 192     dbinit *This = impl_from_IDBInitialize(iface);
 193
 194     FIXME("(%p) stub\n", This);
 195
 196     return S_OK;
 197 }
 198
 199 static const IDBInitializeVtbl dbinit_vtbl =
 200 {
 201     dbinit_QueryInterface,
 202     dbinit_AddRef,
 203     dbinit_Release,
 204     dbinit_Initialize,
 205     dbinit_Uninitialize
 206 };
 207
 208 static HRESULT create_db_init(void **obj)
 209 {
 210     dbinit *This;
 211
 212     TRACE("()\n");
 213
 214     *obj = NULL;
 215
 216     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 217     if(!This) return E_OUTOFMEMORY;
 218
 219     This->IDBInitialize_iface.lpVtbl = &dbinit_vtbl;
 220     This->IDBProperties_iface.lpVtbl = &dbprops_vtbl;
 221     This->ref = 1;
 222
 223     *obj = &This->IDBInitialize_iface;
 224
 225     return S_OK;
 226 }
 227
 228 static HRESULT WINAPI datainit_QueryInterface(IDataInitialize *iface, REFIID riid, void **obj)
 229 {
 230     datainit *This = impl_from_IDataInitialize(iface);
 231     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 232
 233     *obj = NULL;
 234
 235     if(IsEqualIID(riid, &IID_IUnknown) ||
 236        IsEqualIID(riid, &IID_IDataInitialize))
 237     {
 238         *obj = &This->IDataInitialize_iface;
 239     }
 240     else
 241     {
 242         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 243         return E_NOINTERFACE;
 244     }
 245
 246     IDataInitialize_AddRef(iface);
 247     return S_OK;
 248 }
 249
 250 static ULONG WINAPI datainit_AddRef(IDataInitialize *iface)
 251 {
 252     datainit *This = impl_from_IDataInitialize(iface);
 253     TRACE("(%p)\n", This);
 254
 255     return InterlockedIncrement(&This->ref);
 256 }
 257
 258 static ULONG WINAPI datainit_Release(IDataInitialize *iface)
 259 {
 260     datainit *This = impl_from_IDataInitialize(iface);
 261     LONG ref;
 262
 263     TRACE("(%p)\n", This);
 264
 265     ref = InterlockedDecrement(&This->ref);
 266     if(ref == 0)
 267     {
 268         HeapFree(GetProcessHeap(), 0, This);
 269     }
 270
 271     return ref;
 272 }
 273
 274 /*** IDataInitialize methods ***/
 275 static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *pUnkOuter, DWORD dwClsCtx,
 276                                 LPWSTR pwszInitializationString, REFIID riid, IUnknown **ppDataSource)
 277 {
 278     datainit *This = impl_from_IDataInitialize(iface);
 279
 280     FIXME("(%p)->(%p %d %s %s %p)\n", This, pUnkOuter, dwClsCtx, debugstr_w(pwszInitializationString),
 281             debugstr_guid(riid), ppDataSource);
 282
 283     if(IsEqualIID(riid, &IID_IDBInitialize))
 284     {
 285         return create_db_init( (LPVOID*)ppDataSource);
 286     }
 287
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI datainit_GetInitializationString(IDataInitialize *iface, IUnknown *pDataSource,
 292                                 boolean fIncludePassword, LPWSTR *ppwszInitString)
 293 {
 294     datainit *This = impl_from_IDataInitialize(iface);
 295
 296     FIXME("(%p)->(%p %d %p)\n", This, pDataSource, fIncludePassword, ppwszInitString);
 297
 298     return E_NOTIMPL;
 299 }
 300
 301 static HRESULT WINAPI datainit_CreateDBInstance(IDataInitialize *iface, REFCLSID clsidProvider,
 302                                 IUnknown *pUnkOuter, DWORD dwClsCtx, LPWSTR pwszReserved, REFIID riid,
 303                                 IUnknown **ppDataSource)
 304 {
 305     datainit *This = impl_from_IDataInitialize(iface);
 306
 307     FIXME("(%p)->()\n", This);
 308
 309     return E_NOTIMPL;
 310 }
 311
 312 static HRESULT WINAPI datainit_RemoteCreateDBInstanceEx(IDataInitialize *iface, REFCLSID clsidProvider,
 313                                 IUnknown *pUnkOuter, DWORD dwClsCtx, LPWSTR pwszReserved, COSERVERINFO *pServerInfo,
 314                                 DWORD cmq, GUID **rgpIID, IUnknown **rgpItf, HRESULT *rghr)
 315 {
 316     datainit *This = impl_from_IDataInitialize(iface);
 317
 318     FIXME("(%p)->()\n", This);
 319
 320     return E_NOTIMPL;
 321 }
 322
 323 static HRESULT WINAPI datainit_LoadStringFromStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 324                                 LPWSTR *ppwszInitializationString)
 325 {
 326     datainit *This = impl_from_IDataInitialize(iface);
 327
 328     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwszFileName), ppwszInitializationString);
 329
 330     return E_NOTIMPL;
 331 }
 332
 333 static HRESULT WINAPI datainit_WriteStringToStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 334                                 LPWSTR pwszInitializationString, DWORD dwCreationDisposition)
 335 {
 336     datainit *This = impl_from_IDataInitialize(iface);
 337
 338     FIXME("(%p)->(%s %s %d)\n", This, debugstr_w(pwszFileName), debugstr_w(pwszInitializationString), dwCreationDisposition);
 339
 340     return E_NOTIMPL;
 341 }
 342
 343
 344 static const struct IDataInitializeVtbl datainit_vtbl =
 345 {
 346     datainit_QueryInterface,
 347     datainit_AddRef,
 348     datainit_Release,
 349     datainit_GetDataSource,
 350     datainit_GetInitializationString,
 351     datainit_CreateDBInstance,
 352     datainit_RemoteCreateDBInstanceEx,
 353     datainit_LoadStringFromStorage,
 354     datainit_WriteStringToStorage
 355 };
 356
 357 HRESULT create_data_init(IUnknown *outer, void **obj)
 358 {
 359     datainit *This;
 360
 361     TRACE("(%p)\n", obj);
 362
 363     if(outer) return CLASS_E_NOAGGREGATION;
 364
 365     *obj = NULL;
 366
 367     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 368     if(!This) return E_OUTOFMEMORY;
 369
 370     This->IDataInitialize_iface.lpVtbl = &datainit_vtbl;
 371     This->ref = 1;
 372
 373     *obj = &This->IDataInitialize_iface;
 374
 375     return S_OK;
 376 }