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