dlls/msdasql/msdasql_main.c

   1 /*
   2  * Copyright 2019 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
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "objbase.h"
  26 #include "oledb.h"
  27 #include "rpcproxy.h"
  28 #include "wine/debug.h"
  29 #include "oledberr.h"
  30
  31 #include "initguid.h"
  32 #include "msdasql.h"
  33
  34 #include "msdasql_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(msdasql);
  37
  38 DEFINE_GUID(DBPROPSET_DATASOURCEINFO, 0xc8b522bb, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  39 DEFINE_GUID(DBPROPSET_DBINIT,    0xc8b522bc, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  40
  41 DEFINE_GUID(DBGUID_DEFAULT,      0xc8b521fb, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  42
  43 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
  44 {
  45     *ppv = NULL;
  46
  47     if(IsEqualGUID(&IID_IUnknown, riid)) {
  48         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
  49         *ppv = iface;
  50     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
  51         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
  52         *ppv = iface;
  53     }
  54
  55     if(*ppv) {
  56         IUnknown_AddRef((IUnknown*)*ppv);
  57         return S_OK;
  58     }
  59
  60     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
  61     return E_NOINTERFACE;
  62 }
  63
  64 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
  65 {
  66     TRACE("(%p)\n", iface);
  67     return 2;
  68 }
  69
  70 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
  71 {
  72     TRACE("(%p)\n", iface);
  73     return 1;
  74 }
  75
  76 static HRESULT create_msdasql_provider(REFIID riid, void **ppv);
  77 static HRESULT create_msdasql_enumerator(REFIID riid, void **ppv);
  78
  79 HRESULT WINAPI msdasql_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
  80 {
  81     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
  82
  83     return create_msdasql_provider(riid, ppv);
  84 }
  85
  86 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
  87 {
  88     TRACE("(%p)->(%x)\n", iface, fLock);
  89     return S_OK;
  90 }
  91
  92 static const IClassFactoryVtbl cfmsdasqlVtbl = {
  93     ClassFactory_QueryInterface,
  94     ClassFactory_AddRef,
  95     ClassFactory_Release,
  96     msdasql_CreateInstance,
  97     ClassFactory_LockServer
  98 };
  99
 100 HRESULT WINAPI enumerationcf_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 101 {
 102     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 103
 104     return create_msdasql_enumerator(riid, ppv);
 105 }
 106
 107 static const IClassFactoryVtbl enumfactoryVtbl =
 108 {
 109     ClassFactory_QueryInterface,
 110     ClassFactory_AddRef,
 111     ClassFactory_Release,
 112     enumerationcf_CreateInstance,
 113     ClassFactory_LockServer
 114 };
 115
 116 static IClassFactory cfmsdasql = { &cfmsdasqlVtbl };
 117 static IClassFactory enumfactory = { &enumfactoryVtbl };
 118
 119 HRESULT WINAPI DllGetClassObject( REFCLSID rclsid, REFIID riid, void **ppv )
 120 {
 121     TRACE("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 122
 123     if (IsEqualGUID(&CLSID_MSDASQL, rclsid))
 124         return IClassFactory_QueryInterface(&cfmsdasql, riid, ppv);
 125     else if (IsEqualGUID(&CLSID_MSDASQL_ENUMERATOR, rclsid))
 126         return IClassFactory_QueryInterface(&enumfactory, riid, ppv);
 127
 128     return CLASS_E_CLASSNOTAVAILABLE;
 129 }
 130
 131 struct dbproperty
 132 {
 133     const WCHAR *name;
 134     DBPROPID id;
 135     DBPROPOPTIONS options;
 136     VARTYPE type;
 137     HRESULT (*convert_dbproperty)(const WCHAR *src, VARIANT *dest);
 138 };
 139
 140 struct mode_propval
 141 {
 142     const WCHAR *name;
 143     DWORD value;
 144 };
 145
 146 static int __cdecl dbmodeprop_compare(const void *a, const void *b)
 147 {
 148     const WCHAR *src = a;
 149     const struct mode_propval *propval = b;
 150     return wcsicmp(src, propval->name);
 151 }
 152
 153 static HRESULT convert_dbproperty_mode(const WCHAR *src, VARIANT *dest)
 154 {
 155     struct mode_propval mode_propvals[] =
 156     {
 157         { L"Read", DB_MODE_READ },
 158         { L"ReadWrite", DB_MODE_READWRITE },
 159         { L"Share Deny None", DB_MODE_SHARE_DENY_NONE },
 160         { L"Share Deny Read", DB_MODE_SHARE_DENY_READ },
 161         { L"Share Deny Write", DB_MODE_SHARE_DENY_WRITE },
 162         { L"Share Exclusive", DB_MODE_SHARE_EXCLUSIVE },
 163         { L"Write", DB_MODE_WRITE },
 164     };
 165     struct mode_propval *prop;
 166
 167     if ((prop = bsearch(src, mode_propvals, ARRAY_SIZE(mode_propvals),
 168                         sizeof(struct mode_propval), dbmodeprop_compare)))
 169     {
 170         V_VT(dest) = VT_I4;
 171         V_I4(dest) = prop->value;
 172         TRACE("%s = %#x\n", debugstr_w(src), prop->value);
 173         return S_OK;
 174     }
 175
 176     return E_FAIL;
 177 }
 178
 179 static const struct dbproperty dbproperties[] =
 180 {
 181     { L"Password",                 DBPROP_AUTH_PASSWORD,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 182     { L"Persist Security Info",    DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 183     { L"User ID",                  DBPROP_AUTH_USERID,                     DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 184     { L"Data Source",              DBPROP_INIT_DATASOURCE,                 DBPROPOPTIONS_REQUIRED, VT_BSTR },
 185     { L"Window Handle",            DBPROP_INIT_HWND,                       DBPROPOPTIONS_OPTIONAL, sizeof(void *) == 8 ? VT_I8 : VT_I4 },
 186     { L"Location",                 DBPROP_INIT_LOCATION,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 187     { L"Mode",                     DBPROP_INIT_MODE,                       DBPROPOPTIONS_OPTIONAL, VT_I4, convert_dbproperty_mode },
 188     { L"Prompt",                   DBPROP_INIT_PROMPT,                     DBPROPOPTIONS_OPTIONAL, VT_I2 },
 189     { L"Connect Timeout",          DBPROP_INIT_TIMEOUT,                    DBPROPOPTIONS_OPTIONAL, VT_I4 },
 190     { L"Extended Properties",      DBPROP_INIT_PROVIDERSTRING,             DBPROPOPTIONS_REQUIRED, VT_BSTR },
 191     { L"Locale Identifier",        DBPROP_INIT_LCID,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 192     { L"Initial Catalog",          DBPROP_INIT_CATALOG,                    DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 193     { L"OLE DB Services",          DBPROP_INIT_OLEDBSERVICES,              DBPROPOPTIONS_OPTIONAL, VT_I4 },
 194     { L"General Timeout",          DBPROP_INIT_GENERALTIMEOUT,             DBPROPOPTIONS_OPTIONAL, VT_I4 },
 195 };
 196
 197 struct msdasql_prop
 198 {
 199     VARTYPE id;
 200     VARIANT value;
 201 };
 202
 203 struct msdasql
 204 {
 205     IUnknown         MSDASQL_iface;
 206     IDBProperties    IDBProperties_iface;
 207     IDBInitialize    IDBInitialize_iface;
 208     IDBCreateSession IDBCreateSession_iface;
 209     IPersist         IPersist_iface;
 210
 211     LONG     ref;
 212     struct msdasql_prop properties[14];
 213 };
 214
 215 static inline struct msdasql *impl_from_IUnknown(IUnknown *iface)
 216 {
 217     return CONTAINING_RECORD(iface, struct msdasql, MSDASQL_iface);
 218 }
 219
 220 static inline struct msdasql *impl_from_IDBProperties(IDBProperties *iface)
 221 {
 222     return CONTAINING_RECORD(iface, struct msdasql, IDBProperties_iface);
 223 }
 224
 225 static inline struct msdasql *impl_from_IDBInitialize(IDBInitialize *iface)
 226 {
 227     return CONTAINING_RECORD(iface, struct msdasql, IDBInitialize_iface);
 228 }
 229
 230 static inline struct msdasql *impl_from_IDBCreateSession(IDBCreateSession *iface)
 231 {
 232     return CONTAINING_RECORD(iface, struct msdasql, IDBCreateSession_iface);
 233 }
 234
 235 static inline struct msdasql *impl_from_IPersist( IPersist *iface )
 236 {
 237     return CONTAINING_RECORD( iface, struct msdasql, IPersist_iface );
 238 }
 239
 240 static HRESULT WINAPI msdsql_QueryInterface(IUnknown *iface, REFIID riid, void **out)
 241 {
 242     struct msdasql *provider = impl_from_IUnknown(iface);
 243
 244     TRACE("(%p)->(%s %p)\n", provider, debugstr_guid(riid), out);
 245
 246     if(IsEqualGUID(riid, &IID_IUnknown) ||
 247        IsEqualGUID(riid, &CLSID_MSDASQL))
 248     {
 249         *out = &provider->MSDASQL_iface;
 250     }
 251     else if(IsEqualGUID(riid, &IID_IDBProperties))
 252     {
 253         *out = &provider->IDBProperties_iface;
 254     }
 255     else if ( IsEqualGUID(riid, &IID_IDBInitialize))
 256     {
 257         *out = &provider->IDBInitialize_iface;
 258     }
 259     else if (IsEqualGUID(riid, &IID_IDBCreateSession))
 260     {
 261         *out = &provider->IDBCreateSession_iface;
 262     }
 263     else if(IsEqualGUID(&IID_IPersist, riid))
 264     {
 265         *out = &provider->IPersist_iface;
 266     }
 267     else
 268     {
 269         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 270         *out = NULL;
 271         return E_NOINTERFACE;
 272     }
 273
 274     IUnknown_AddRef((IUnknown*)*out);
 275     return S_OK;
 276 }
 277
 278 static ULONG WINAPI msdsql_AddRef(IUnknown *iface)
 279 {
 280     struct msdasql *provider = impl_from_IUnknown(iface);
 281     ULONG ref = InterlockedIncrement(&provider->ref);
 282
 283     TRACE("(%p) ref=%u\n", provider, ref);
 284
 285     return ref;
 286 }
 287
 288 static ULONG  WINAPI msdsql_Release(IUnknown *iface)
 289 {
 290     struct msdasql *provider = impl_from_IUnknown(iface);
 291     ULONG ref = InterlockedDecrement(&provider->ref);
 292
 293     TRACE("(%p) ref=%u\n", provider, ref);
 294
 295     if (!ref)
 296     {
 297         free(provider);
 298     }
 299
 300     return ref;
 301 }
 302
 303 static const IUnknownVtbl msdsql_vtbl =
 304 {
 305     msdsql_QueryInterface,
 306     msdsql_AddRef,
 307     msdsql_Release
 308 };
 309
 310 static HRESULT WINAPI dbprops_QueryInterface(IDBProperties *iface, REFIID riid, void **ppvObject)
 311 {
 312     struct msdasql *provider = impl_from_IDBProperties(iface);
 313
 314     return IUnknown_QueryInterface(&provider->MSDASQL_iface, riid, ppvObject);
 315 }
 316
 317 static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
 318 {
 319     struct msdasql *provider = impl_from_IDBProperties(iface);
 320
 321     return IUnknown_AddRef(&provider->MSDASQL_iface);
 322 }
 323
 324 static ULONG WINAPI dbprops_Release(IDBProperties *iface)
 325 {
 326     struct msdasql *provider = impl_from_IDBProperties(iface);
 327
 328     return IUnknown_Release(&provider->MSDASQL_iface);
 329 }
 330
 331 static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
 332             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
 333 {
 334     struct msdasql *provider = impl_from_IDBProperties(iface);
 335     int i, j, k;
 336     DBPROPSET *propset;
 337
 338     TRACE("(%p)->(%d %p %p %p)\n", provider, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 339
 340     *pcPropertySets = 1;
 341
 342     if (cPropertyIDSets != 1)
 343     {
 344         FIXME("Currently only 1 property set supported.\n");
 345         cPropertyIDSets = 1;
 346     }
 347
 348     propset = CoTaskMemAlloc(cPropertyIDSets * sizeof(DBPROPSET));
 349
 350     if (IsEqualGUID(&rgPropertyIDSets[0].guidPropertySet, &DBPROPSET_DATASOURCEINFO))
 351     {
 352         TRACE("Propertyset DBPROPSET_DATASOURCEINFO not supported\n");
 353         propset->guidPropertySet = rgPropertyIDSets[0].guidPropertySet;
 354         propset->cProperties = rgPropertyIDSets[0].cPropertyIDs;
 355
 356         propset->rgProperties = CoTaskMemAlloc(propset->cProperties * sizeof(DBPROP));
 357
 358         for (j=0; j < propset->cProperties; j++)
 359         {
 360             propset->rgProperties[j].dwPropertyID = rgPropertyIDSets[0].rgPropertyIDs[j];
 361             propset->rgProperties[j].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
 362         }
 363
 364         *prgPropertySets = propset;
 365
 366         return DB_E_ERRORSOCCURRED;
 367     }
 368
 369     propset->guidPropertySet = DBPROPSET_DBINIT;
 370
 371     for (i=0; i < cPropertyIDSets; i++)
 372     {
 373         TRACE("Property id %d (count %d, set %s)\n", i, rgPropertyIDSets[i].cPropertyIDs,
 374                 debugstr_guid(&rgPropertyIDSets[i].guidPropertySet));
 375
 376         propset->cProperties = rgPropertyIDSets[i].cPropertyIDs;
 377         propset->rgProperties = CoTaskMemAlloc(propset->cProperties * sizeof(DBPROP));
 378
 379         for (j=0; j < propset->cProperties; j++)
 380         {
 381             propset->rgProperties[j].dwPropertyID = rgPropertyIDSets[i].rgPropertyIDs[j];
 382
 383             for(k = 0; k < ARRAY_SIZE(provider->properties); k++)
 384             {
 385                 if (provider->properties[k].id == rgPropertyIDSets[i].rgPropertyIDs[j])
 386                 {
 387                     V_VT(&propset->rgProperties[j].vValue) = VT_EMPTY;
 388                     VariantCopy(&propset->rgProperties[j].vValue, &provider->properties[k].value);
 389                     break;
 390                 }
 391             }
 392         }
 393     }
 394
 395     *prgPropertySets = propset;
 396
 397     return S_OK;
 398 }
 399
 400 static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
 401             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
 402             DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
 403 {
 404     struct msdasql *provider = impl_from_IDBProperties(iface);
 405     int i;
 406     DBPROPINFOSET *infoset;
 407     int size = 1;
 408     OLECHAR *ptr;
 409
 410     TRACE("(%p)->(%d %p %p %p %p)\n", provider, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 411                 prgPropertyInfoSets, ppDescBuffer);
 412
 413     infoset = CoTaskMemAlloc(sizeof(DBPROPINFOSET));
 414     memcpy(&infoset->guidPropertySet, &DBPROPSET_DBINIT, sizeof(GUID));
 415     infoset->cPropertyInfos = ARRAY_SIZE(dbproperties);
 416     infoset->rgPropertyInfos = CoTaskMemAlloc(sizeof(DBPROPINFO) * ARRAY_SIZE(dbproperties));
 417
 418     for(i=0; i < ARRAY_SIZE(dbproperties); i++)
 419     {
 420         size += lstrlenW(dbproperties[i].name) + 1;
 421     }
 422
 423     ptr = *ppDescBuffer = CoTaskMemAlloc(size * sizeof(WCHAR));
 424     memset(*ppDescBuffer, 0, size * sizeof(WCHAR));
 425
 426     for(i=0; i < ARRAY_SIZE(dbproperties); i++)
 427     {
 428         lstrcpyW(ptr, dbproperties[i].name);
 429         infoset->rgPropertyInfos[i].pwszDescription = ptr;
 430         infoset->rgPropertyInfos[i].dwPropertyID =  dbproperties[i].id;
 431         infoset->rgPropertyInfos[i].dwFlags = DBPROPFLAGS_DBINIT | DBPROPFLAGS_READ | DBPROPFLAGS_WRITE;
 432         infoset->rgPropertyInfos[i].vtType =  dbproperties[i].type;
 433         V_VT(&infoset->rgPropertyInfos[i].vValues) =  VT_EMPTY;
 434
 435         ptr += lstrlenW(dbproperties[i].name) + 1;
 436     }
 437
 438     *pcPropertyInfoSets = 1;
 439     *prgPropertyInfoSets = infoset;
 440
 441     return S_OK;
 442 }
 443
 444 static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG cPropertySets,
 445             DBPROPSET rgPropertySets[])
 446 {
 447     struct msdasql *provider = impl_from_IDBProperties(iface);
 448     int i, j, k;
 449
 450     TRACE("(%p)->(%d %p)\n", provider, cPropertySets, rgPropertySets);
 451
 452     for (i=0; i < cPropertySets; i++)
 453     {
 454         for (j=0; j < rgPropertySets[i].cProperties; j++)
 455         {
 456             for(k=0; k < ARRAY_SIZE(provider->properties); k++)
 457             {
 458                 if (provider->properties[k].id == rgPropertySets[i].rgProperties[j].dwPropertyID)
 459                 {
 460                     TRACE("Found property %d\n", provider->properties[k].id);
 461                     VariantCopy(&provider->properties[k].value, &rgPropertySets[i].rgProperties[j].vValue);
 462                     break;
 463                 }
 464             }
 465         }
 466     }
 467
 468     return S_OK;
 469 }
 470
 471 static const struct IDBPropertiesVtbl dbprops_vtbl =
 472 {
 473     dbprops_QueryInterface,
 474     dbprops_AddRef,
 475     dbprops_Release,
 476     dbprops_GetProperties,
 477     dbprops_GetPropertyInfo,
 478     dbprops_SetProperties
 479 };
 480
 481 static HRESULT WINAPI dbinit_QueryInterface(IDBInitialize *iface, REFIID riid, void **ppvObject)
 482 {
 483     struct msdasql *provider = impl_from_IDBInitialize(iface);
 484
 485     return IUnknown_QueryInterface(&provider->MSDASQL_iface, riid, ppvObject);
 486 }
 487
 488 static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
 489 {
 490     struct msdasql *provider = impl_from_IDBInitialize(iface);
 491
 492     return IUnknown_AddRef(&provider->MSDASQL_iface);
 493 }
 494
 495 static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
 496 {
 497     struct msdasql *provider = impl_from_IDBInitialize(iface);
 498
 499     return IUnknown_Release(&provider->MSDASQL_iface);
 500 }
 501
 502 static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
 503 {
 504     struct msdasql *provider = impl_from_IDBInitialize(iface);
 505
 506     FIXME("%p stub\n", provider);
 507
 508     return S_OK;
 509 }
 510
 511 static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
 512 {
 513     struct msdasql *provider = impl_from_IDBInitialize(iface);
 514
 515     FIXME("%p stub\n", provider);
 516
 517     return S_OK;
 518 }
 519
 520
 521 static const struct IDBInitializeVtbl dbinit_vtbl =
 522 {
 523     dbinit_QueryInterface,
 524     dbinit_AddRef,
 525     dbinit_Release,
 526     dbinit_Initialize,
 527     dbinit_Uninitialize
 528 };
 529
 530 static HRESULT WINAPI dbsess_QueryInterface(IDBCreateSession *iface, REFIID riid, void **ppvObject)
 531 {
 532     struct msdasql *provider = impl_from_IDBCreateSession(iface);
 533
 534     return IUnknown_QueryInterface(&provider->MSDASQL_iface, riid, ppvObject);
 535 }
 536
 537 static ULONG WINAPI dbsess_AddRef(IDBCreateSession *iface)
 538 {
 539     struct msdasql *provider = impl_from_IDBCreateSession(iface);
 540
 541     return IUnknown_AddRef(&provider->MSDASQL_iface);
 542 }
 543
 544 static ULONG WINAPI dbsess_Release(IDBCreateSession *iface)
 545 {
 546     struct msdasql *provider = impl_from_IDBCreateSession(iface);
 547
 548     return IUnknown_Release(&provider->MSDASQL_iface);
 549 }
 550
 551 static HRESULT WINAPI dbsess_CreateSession(IDBCreateSession *iface, IUnknown *outer, REFIID riid,
 552         IUnknown **session)
 553 {
 554     struct msdasql *provider = impl_from_IDBCreateSession(iface);
 555     HRESULT hr;
 556
 557     TRACE("%p, outer %p, riid %s, session %p stub\n", provider, outer, debugstr_guid(riid), session);
 558
 559     if (outer)
 560         FIXME("outer currently not supported.\n");
 561
 562     hr = create_db_session(riid, (void**)session);
 563
 564     return hr;
 565 }
 566
 567 static const struct IDBCreateSessionVtbl dbsess_vtbl =
 568 {
 569     dbsess_QueryInterface,
 570     dbsess_AddRef,
 571     dbsess_Release,
 572     dbsess_CreateSession
 573 };
 574
 575 static HRESULT WINAPI persist_QueryInterface(IPersist *iface, REFIID riid, void **ppv)
 576 {
 577     struct msdasql *provider = impl_from_IPersist( iface );
 578     return IUnknown_QueryInterface(&provider->MSDASQL_iface, riid, ppv);
 579 }
 580
 581 static ULONG WINAPI persist_AddRef(IPersist *iface)
 582 {
 583     struct msdasql *provider = impl_from_IPersist( iface );
 584     return IUnknown_AddRef(&provider->MSDASQL_iface);
 585 }
 586
 587 static ULONG WINAPI persist_Release(IPersist *iface)
 588 {
 589     struct msdasql *provider = impl_from_IPersist( iface );
 590     return IUnknown_Release(&provider->MSDASQL_iface);
 591 }
 592
 593 static HRESULT WINAPI persist_GetClassID(IPersist *iface, CLSID *classid)
 594 {
 595     struct msdasql *provider = impl_from_IPersist( iface );
 596
 597     TRACE("(%p)->(%p)\n", provider, classid);
 598
 599     if(!classid)
 600         return E_INVALIDARG;
 601
 602     *classid = CLSID_MSDASQL;
 603     return S_OK;
 604
 605 }
 606
 607 static const IPersistVtbl persistVtbl = {
 608     persist_QueryInterface,
 609     persist_AddRef,
 610     persist_Release,
 611     persist_GetClassID
 612 };
 613
 614 static HRESULT create_msdasql_provider(REFIID riid, void **ppv)
 615 {
 616     struct msdasql *provider;
 617     HRESULT hr;
 618     int i;
 619
 620     provider = malloc(sizeof(struct msdasql));
 621     if (!provider)
 622         return E_OUTOFMEMORY;
 623
 624     provider->MSDASQL_iface.lpVtbl = &msdsql_vtbl;
 625     provider->IDBProperties_iface.lpVtbl = &dbprops_vtbl;
 626     provider->IDBInitialize_iface.lpVtbl = &dbinit_vtbl;
 627     provider->IDBCreateSession_iface.lpVtbl = &dbsess_vtbl;
 628     provider->IPersist_iface.lpVtbl = &persistVtbl;
 629     provider->ref = 1;
 630
 631     for(i=0; i < ARRAY_SIZE(dbproperties); i++)
 632     {
 633         provider->properties[i].id = dbproperties[i].id;
 634         VariantInit(&provider->properties[i].value);
 635
 636         /* Only the follow are initialized to a value */
 637         switch(dbproperties[i].id)
 638         {
 639             case DBPROP_INIT_PROMPT:
 640                 V_VT(&provider->properties[i].value) = dbproperties[i].type;
 641                 V_I2(&provider->properties[i].value) = 4;
 642                 break;
 643             case DBPROP_INIT_LCID:
 644                 V_VT(&provider->properties[i].value) = dbproperties[i].type;
 645                 V_I4(&provider->properties[i].value) = GetUserDefaultLCID();
 646                 break;
 647             case DBPROP_INIT_OLEDBSERVICES:
 648                 V_VT(&provider->properties[i].value) = dbproperties[i].type;
 649                 V_I4(&provider->properties[i].value) = -1;
 650                 break;
 651             default:
 652                 V_VT(&provider->properties[i].value) = VT_EMPTY;
 653         }
 654     }
 655
 656     hr = IUnknown_QueryInterface(&provider->MSDASQL_iface, riid, ppv);
 657     IUnknown_Release(&provider->MSDASQL_iface);
 658     return hr;
 659 }
 660
 661 struct msdasql_enum
 662 {
 663     ISourcesRowset ISourcesRowset_iface;
 664     LONG ref;
 665 };
 666
 667 static inline struct msdasql_enum *msdasql_enum_from_ISourcesRowset(ISourcesRowset *iface)
 668 {
 669     return CONTAINING_RECORD(iface, struct msdasql_enum, ISourcesRowset_iface);
 670 }
 671
 672 static HRESULT WINAPI msdasql_enum_QueryInterface(ISourcesRowset *iface, REFIID riid, void **out)
 673 {
 674     struct msdasql_enum *enumerator = msdasql_enum_from_ISourcesRowset(iface);
 675
 676     TRACE("(%p)->(%s %p)\n", enumerator, debugstr_guid(riid), out);
 677
 678     if(IsEqualGUID(riid, &IID_IUnknown) ||
 679         IsEqualGUID(riid, &IID_ISourcesRowset ) )
 680     {
 681         *out = &enumerator->ISourcesRowset_iface;
 682     }
 683     else
 684     {
 685         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 686         *out = NULL;
 687         return E_NOINTERFACE;
 688     }
 689
 690     IUnknown_AddRef((IUnknown*)*out);
 691     return S_OK;
 692 }
 693
 694 static ULONG WINAPI msdasql_enum_AddRef(ISourcesRowset *iface)
 695 {
 696     struct msdasql_enum *enumerator = msdasql_enum_from_ISourcesRowset(iface);
 697     ULONG ref = InterlockedIncrement(&enumerator->ref);
 698
 699     TRACE("(%p) ref=%u\n", enumerator, ref);
 700
 701     return ref;
 702 }
 703
 704 static ULONG WINAPI msdasql_enum_Release(ISourcesRowset *iface)
 705 {
 706     struct msdasql_enum *enumerator = msdasql_enum_from_ISourcesRowset(iface);
 707     ULONG ref = InterlockedDecrement(&enumerator->ref);
 708
 709     TRACE("(%p) ref=%u\n", enumerator, ref);
 710
 711     if (!ref)
 712     {
 713         free(enumerator);
 714     }
 715
 716     return ref;
 717 }
 718
 719 struct msdasql_enum_rowset
 720 {
 721     IRowset IRowset_iface;
 722     IAccessor IAccessor_iface;
 723     LONG ref;
 724 };
 725
 726 static inline struct msdasql_enum_rowset *msdasql_rs_from_IRowset(IRowset *iface)
 727 {
 728     return CONTAINING_RECORD(iface, struct msdasql_enum_rowset, IRowset_iface);
 729 }
 730
 731 static inline struct msdasql_enum_rowset *msdasql_enum_from_IAccessor ( IAccessor *iface )
 732 {
 733     return CONTAINING_RECORD( iface, struct msdasql_enum_rowset, IAccessor_iface );
 734 }
 735
 736 static HRESULT WINAPI enum_rowset_QueryInterface(IRowset *iface, REFIID riid,  void **ppv)
 737 {
 738     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 739
 740     TRACE( "%p, %s, %p\n", rowset, debugstr_guid(riid), ppv );
 741     *ppv = NULL;
 742
 743     if(IsEqualGUID(&IID_IUnknown, riid) ||
 744        IsEqualGUID(&IID_IRowset, riid))
 745     {
 746         *ppv = &rowset->IRowset_iface;
 747     }
 748     else if(IsEqualGUID(&IID_IAccessor, riid))
 749     {
 750          *ppv = &rowset->IAccessor_iface;
 751     }
 752
 753     if(*ppv)
 754     {
 755         IUnknown_AddRef((IUnknown*)*ppv);
 756         return S_OK;
 757     }
 758
 759     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 760     return E_NOINTERFACE;
 761 }
 762
 763 static ULONG WINAPI enum_rowset_AddRef(IRowset *iface)
 764 {
 765     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 766     LONG refs = InterlockedIncrement( &rowset->ref );
 767     TRACE( "%p new refcount %d\n", rowset, refs );
 768     return refs;
 769 }
 770
 771 static ULONG WINAPI enum_rowset_Release(IRowset *iface)
 772 {
 773     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 774     LONG refs = InterlockedDecrement( &rowset->ref );
 775     TRACE( "%p new refcount %d\n", rowset, refs );
 776     if (!refs)
 777     {
 778         TRACE( "destroying %p\n", rowset );
 779         free( rowset );
 780     }
 781     return refs;
 782 }
 783
 784 static HRESULT WINAPI enum_rowset_AddRefRows(IRowset *iface, DBCOUNTITEM count,
 785         const HROW rows[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 786 {
 787     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 788
 789     FIXME("%p, %ld, %p, %p, %p\n", rowset, count, rows, ref_counts, status);
 790
 791     return E_NOTIMPL;
 792 }
 793
 794 static HRESULT WINAPI enum_rowset_GetData(IRowset *iface, HROW row, HACCESSOR accessor, void *data)
 795 {
 796     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 797
 798     FIXME("%p, %ld, %ld, %p\n", rowset, row, accessor, data);
 799
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI enum_rowset_GetNextRows(IRowset *iface, HCHAPTER reserved, DBROWOFFSET offset,
 804         DBROWCOUNT count, DBCOUNTITEM *obtained, HROW **rows)
 805 {
 806     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 807
 808     FIXME("%p, %ld, %ld, %ld, %p, %p\n", rowset, reserved, offset, count, obtained, rows);
 809
 810     if (!obtained || !rows)
 811         return E_INVALIDARG;
 812
 813     *obtained = 0;
 814
 815     if (!count)
 816         return S_OK;
 817
 818     return DB_S_ENDOFROWSET;
 819 }
 820
 821 static HRESULT WINAPI enum_rowset_ReleaseRows(IRowset *iface, DBCOUNTITEM count,
 822         const HROW rows[], DBROWOPTIONS options[], DBREFCOUNT ref_counts[], DBROWSTATUS status[])
 823 {
 824     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 825
 826     FIXME("%p, %ld, %p, %p, %p, %p\n", rowset, count, rows, options, ref_counts, status);
 827
 828     return S_OK;
 829 }
 830
 831 static HRESULT WINAPI enum_rowset_RestartPosition(IRowset *iface, HCHAPTER reserved)
 832 {
 833     struct msdasql_enum_rowset *rowset = msdasql_rs_from_IRowset( iface );
 834
 835     FIXME("%p, %ld\n", rowset, reserved);
 836
 837     return S_OK;
 838 }
 839
 840 static const struct IRowsetVtbl enum_rowset_vtbl =
 841 {
 842     enum_rowset_QueryInterface,
 843     enum_rowset_AddRef,
 844     enum_rowset_Release,
 845     enum_rowset_AddRefRows,
 846     enum_rowset_GetData,
 847     enum_rowset_GetNextRows,
 848     enum_rowset_ReleaseRows,
 849     enum_rowset_RestartPosition
 850 };
 851
 852 static HRESULT WINAPI enum_rs_accessor_QueryInterface(IAccessor *iface, REFIID riid, void **out)
 853 {
 854     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 855     return IRowset_QueryInterface(&rowset->IRowset_iface, riid, out);
 856 }
 857
 858 static ULONG WINAPI enum_rs_accessor_AddRef(IAccessor *iface)
 859 {
 860     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 861     return IRowset_AddRef(&rowset->IRowset_iface);
 862 }
 863
 864 static ULONG  WINAPI enum_rs_accessor_Release(IAccessor *iface)
 865 {
 866     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 867     return IRowset_Release(&rowset->IRowset_iface);
 868 }
 869
 870 static HRESULT WINAPI enum_rs_accessor_AddRefAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
 871 {
 872     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 873     FIXME("%p, %lu, %p\n", rowset, accessor, count);
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI enum_rs_accessor_CreateAccessor(IAccessor *iface, DBACCESSORFLAGS flags,
 878         DBCOUNTITEM count, const DBBINDING bindings[], DBLENGTH row_size, HACCESSOR *accessor,
 879         DBBINDSTATUS status[])
 880 {
 881     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 882
 883     FIXME("%p 0x%08x, %lu, %p, %lu, %p, %p\n", rowset, flags, count, bindings, row_size, accessor, status);
 884
 885     if (accessor)
 886         *accessor = 0xdeadbeef;
 887
 888     return S_OK;
 889 }
 890
 891 static HRESULT WINAPI enum_rs_accessor_GetBindings(IAccessor *iface, HACCESSOR accessor,
 892         DBACCESSORFLAGS *flags, DBCOUNTITEM *count, DBBINDING **bindings)
 893 {
 894     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 895     FIXME("%p %lu, %p, %p, %p\n", rowset, accessor, flags, count, bindings);
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI enum_rs_accessor_ReleaseAccessor(IAccessor *iface, HACCESSOR accessor, DBREFCOUNT *count)
 900 {
 901     struct msdasql_enum_rowset *rowset = msdasql_enum_from_IAccessor( iface );
 902
 903     FIXME("%p, %lu, %p\n", rowset, accessor, count);
 904
 905     if (count)
 906         *count = 0;
 907
 908     return S_OK;
 909 }
 910
 911 struct IAccessorVtbl enum_accessor_vtbl =
 912 {
 913     enum_rs_accessor_QueryInterface,
 914     enum_rs_accessor_AddRef,
 915     enum_rs_accessor_Release,
 916     enum_rs_accessor_AddRefAccessor,
 917     enum_rs_accessor_CreateAccessor,
 918     enum_rs_accessor_GetBindings,
 919     enum_rs_accessor_ReleaseAccessor
 920 };
 921
 922 static HRESULT WINAPI msdasql_enum_GetSourcesRowset(ISourcesRowset *iface, IUnknown *outer, REFIID riid, ULONG sets,
 923                 DBPROPSET properties[], IUnknown **rowset)
 924 {
 925     struct msdasql_enum *enumerator = msdasql_enum_from_ISourcesRowset(iface);
 926     struct msdasql_enum_rowset *enum_rs;
 927     HRESULT hr;
 928
 929     TRACE("(%p) %p, %s, %d, %p, %p\n", enumerator, outer, debugstr_guid(riid), sets, properties, rowset);
 930
 931     enum_rs = malloc(sizeof(*enum_rs));
 932     enum_rs->IRowset_iface.lpVtbl = &enum_rowset_vtbl;
 933     enum_rs->IAccessor_iface.lpVtbl = &enum_accessor_vtbl;
 934     enum_rs->ref = 1;
 935
 936     hr = IRowset_QueryInterface(&enum_rs->IRowset_iface, riid, (void**)rowset);
 937     IRowset_Release(&enum_rs->IRowset_iface);
 938     return hr;
 939 }
 940
 941 static const ISourcesRowsetVtbl msdsqlenum_vtbl =
 942 {
 943     msdasql_enum_QueryInterface,
 944     msdasql_enum_AddRef,
 945     msdasql_enum_Release,
 946     msdasql_enum_GetSourcesRowset
 947 };
 948
 949 static HRESULT create_msdasql_enumerator(REFIID riid, void **ppv)
 950 {
 951     struct msdasql_enum *enumerator;
 952     HRESULT hr;
 953
 954     enumerator = malloc(sizeof(*enumerator));
 955     if (!enumerator)
 956         return E_OUTOFMEMORY;
 957
 958     enumerator->ISourcesRowset_iface.lpVtbl = &msdsqlenum_vtbl;
 959     enumerator->ref = 1;
 960
 961     hr = IUnknown_QueryInterface(&enumerator->ISourcesRowset_iface, riid, ppv);
 962     IUnknown_Release(&enumerator->ISourcesRowset_iface);
 963     return hr;
 964 }