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