dlls/oledb32/datainit.c

   1 /*
   2  * Copyright (C) 2012 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18 #include <stdarg.h>
  19
  20 #define COBJMACROS
  21 #define NONAMELESSUNION
  22 #define NONAMELESSSTRUCT
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27 #include "ole2.h"
  28 #include "msdasc.h"
  29 #include "oledberr.h"
  30 #include "initguid.h"
  31 #include "oledb_private.h"
  32
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  37
  38 DEFINE_GUID(DBPROPSET_DBINIT, 0xc8b522bc, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  39
  40 typedef struct datainit
  41 {
  42     IDataInitialize IDataInitialize_iface;
  43
  44     LONG ref;
  45 } datainit;
  46
  47 static inline datainit *impl_from_IDataInitialize(IDataInitialize *iface)
  48 {
  49     return CONTAINING_RECORD(iface, datainit, IDataInitialize_iface);
  50 }
  51
  52 typedef struct
  53 {
  54     IDBInitialize IDBInitialize_iface;
  55     IDBProperties IDBProperties_iface;
  56
  57     LONG ref;
  58 } dbinit;
  59
  60 static inline dbinit *impl_from_IDBInitialize(IDBInitialize *iface)
  61 {
  62     return CONTAINING_RECORD(iface, dbinit, IDBInitialize_iface);
  63 }
  64
  65 static inline dbinit *impl_from_IDBProperties(IDBProperties *iface)
  66 {
  67     return CONTAINING_RECORD(iface, dbinit, IDBProperties_iface);
  68 }
  69
  70 static HRESULT WINAPI dbprops_QueryInterface(IDBProperties *iface, REFIID riid, void **ppvObject)
  71 {
  72     dbinit *This = impl_from_IDBProperties(iface);
  73
  74     return IDBInitialize_QueryInterface(&This->IDBInitialize_iface, riid, ppvObject);
  75 }
  76
  77 static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
  78 {
  79     dbinit *This = impl_from_IDBProperties(iface);
  80
  81     return IDBInitialize_AddRef(&This->IDBInitialize_iface);
  82 }
  83
  84 static ULONG WINAPI dbprops_Release(IDBProperties *iface)
  85 {
  86     dbinit *This = impl_from_IDBProperties(iface);
  87
  88     return IDBInitialize_Release(&This->IDBInitialize_iface);
  89 }
  90
  91 static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
  92             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
  93 {
  94     dbinit *This = impl_from_IDBProperties(iface);
  95
  96     FIXME("(%p)->(%d %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
  97
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
 102             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
 103             DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
 104 {
 105     dbinit *This = impl_from_IDBProperties(iface);
 106
 107     FIXME("(%p)->(%d %p %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 108                 prgPropertyInfoSets, ppDescBuffer);
 109
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG cPropertySets,
 114             DBPROPSET rgPropertySets[])
 115 {
 116     dbinit *This = impl_from_IDBProperties(iface);
 117
 118     FIXME("(%p)->(%d %p)\n", This, cPropertySets, rgPropertySets);
 119
 120     return E_NOTIMPL;
 121 }
 122
 123 static const struct IDBPropertiesVtbl dbprops_vtbl =
 124 {
 125     dbprops_QueryInterface,
 126     dbprops_AddRef,
 127     dbprops_Release,
 128     dbprops_GetProperties,
 129     dbprops_GetPropertyInfo,
 130     dbprops_SetProperties
 131 };
 132
 133 static HRESULT WINAPI dbinit_QueryInterface(IDBInitialize *iface, REFIID riid, void **obj)
 134 {
 135     dbinit *This = impl_from_IDBInitialize(iface);
 136     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 137
 138     *obj = NULL;
 139
 140     if(IsEqualIID(riid, &IID_IUnknown) ||
 141        IsEqualIID(riid, &IID_IDBInitialize))
 142     {
 143         *obj = iface;
 144     }
 145     else if(IsEqualIID(riid, &IID_IDBProperties))
 146     {
 147         *obj = &This->IDBProperties_iface;
 148     }
 149     else
 150     {
 151         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 152         return E_NOINTERFACE;
 153     }
 154
 155     IDBInitialize_AddRef(iface);
 156     return S_OK;
 157 }
 158
 159 static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
 160 {
 161     dbinit *This = impl_from_IDBInitialize(iface);
 162     TRACE("(%p)\n", This);
 163
 164     return InterlockedIncrement(&This->ref);
 165 }
 166
 167 static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
 168 {
 169     dbinit *This = impl_from_IDBInitialize(iface);
 170     LONG ref;
 171
 172     TRACE("(%p)\n", This);
 173
 174     ref = InterlockedDecrement(&This->ref);
 175     if(ref == 0)
 176     {
 177         HeapFree(GetProcessHeap(), 0, This);
 178     }
 179
 180     return ref;
 181 }
 182
 183 static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
 184 {
 185     dbinit *This = impl_from_IDBInitialize(iface);
 186
 187     FIXME("(%p) stub\n", This);
 188
 189     return S_OK;
 190 }
 191
 192 static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
 193 {
 194     dbinit *This = impl_from_IDBInitialize(iface);
 195
 196     FIXME("(%p) stub\n", This);
 197
 198     return S_OK;
 199 }
 200
 201 static const IDBInitializeVtbl dbinit_vtbl =
 202 {
 203     dbinit_QueryInterface,
 204     dbinit_AddRef,
 205     dbinit_Release,
 206     dbinit_Initialize,
 207     dbinit_Uninitialize
 208 };
 209
 210 static HRESULT create_db_init(void **obj)
 211 {
 212     dbinit *This;
 213
 214     TRACE("()\n");
 215
 216     *obj = NULL;
 217
 218     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 219     if(!This) return E_OUTOFMEMORY;
 220
 221     This->IDBInitialize_iface.lpVtbl = &dbinit_vtbl;
 222     This->IDBProperties_iface.lpVtbl = &dbprops_vtbl;
 223     This->ref = 1;
 224
 225     *obj = &This->IDBInitialize_iface;
 226
 227     return S_OK;
 228 }
 229
 230 static HRESULT WINAPI datainit_QueryInterface(IDataInitialize *iface, REFIID riid, void **obj)
 231 {
 232     datainit *This = impl_from_IDataInitialize(iface);
 233     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 234
 235     *obj = NULL;
 236
 237     if(IsEqualIID(riid, &IID_IUnknown) ||
 238        IsEqualIID(riid, &IID_IDataInitialize))
 239     {
 240         *obj = &This->IDataInitialize_iface;
 241     }
 242     else
 243     {
 244         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 245         return E_NOINTERFACE;
 246     }
 247
 248     IDataInitialize_AddRef(iface);
 249     return S_OK;
 250 }
 251
 252 static ULONG WINAPI datainit_AddRef(IDataInitialize *iface)
 253 {
 254     datainit *This = impl_from_IDataInitialize(iface);
 255     TRACE("(%p)\n", This);
 256
 257     return InterlockedIncrement(&This->ref);
 258 }
 259
 260 static ULONG WINAPI datainit_Release(IDataInitialize *iface)
 261 {
 262     datainit *This = impl_from_IDataInitialize(iface);
 263     LONG ref;
 264
 265     TRACE("(%p)\n", This);
 266
 267     ref = InterlockedDecrement(&This->ref);
 268     if(ref == 0)
 269     {
 270         HeapFree(GetProcessHeap(), 0, This);
 271     }
 272
 273     return ref;
 274 }
 275
 276 static void free_dbpropset(ULONG count, DBPROPSET *propset)
 277 {
 278     ULONG i;
 279
 280     for (i = 0; i < count; i++)
 281     {
 282         ULONG p;
 283
 284         for (p = 0; p < propset[i].cProperties; p++)
 285             VariantClear(&propset[i].rgProperties[p].vValue);
 286
 287         CoTaskMemFree(propset[i].rgProperties);
 288     }
 289     CoTaskMemFree(propset);
 290 }
 291
 292 struct dbproperty {
 293     const WCHAR *name;
 294     DBPROPID id;
 295     DBPROPOPTIONS options;
 296     VARTYPE type;
 297 };
 298
 299 static const WCHAR asyncW[]  = {'A','s','y','n','c','h','r','o','n','o','u','s',' ','P','r','o','c','e','s','s','i','n','g',0};
 300 static const WCHAR bindW[]  = {'B','i','n','d',' ','F','l','a','g','s',0};
 301 static const WCHAR cacheW[]  = {'C','a','c','h','e',' ','A','u','t','h','e','n','i','c','a','t','i','o','n',0};
 302 static const WCHAR conn_timeout[] = {'C','o','n','n','e','c','t',' ','T','i','m','e','o','u','t',0};
 303 static const WCHAR datasourceW[] = {'D','a','t','a',' ','S','o','u','r','c','e',0};
 304 static const WCHAR encryptW[] = {'E','n','c','r','y','p','t',' ','P','a','s','s','w','o','r','d',0};
 305 static const WCHAR extendedW[] = {'E','x','t','e','n','d','e','d',' ','P','r','o','p','e','r','t','i','e','s',0};
 306 static const WCHAR gen_timeout[] = {'G','e','n','e','r','a','l',' ','T','i','m','e','o','u','t',0};
 307 static const WCHAR impersonW[] = {'I','m','p','e','r','s','o','n','a','t','i','o','n',' ','L','e','v','e','l',0};
 308 static const WCHAR initcatW[] = {'I','n','i','t','i','a','l',' ','C','a','t','a','l','o','g',0};
 309 static const WCHAR integratedW[] = {'I','n','t','e','g','r','a','t','e','d',' ','S','e','c','u','r','i','t','y',0};
 310 static const WCHAR localeIDW[] = {'L','o','c','a','l','e',' ','I','d','e','n','t','i','f','i','e','r',0};
 311 static const WCHAR locationW[] = {'L','o','c','a','t','i','o','n',0};
 312 static const WCHAR lockownerW[] = {'L','o','c','k',' ','O','w','n','e','r',0};
 313 static const WCHAR maskpassW[] = {'M','a','s','k',' ','P','a','s','s','w','o','r','d',0};
 314 static const WCHAR modeW[] = {'M','o','d','e',0};
 315 static const WCHAR oledbservW[] = {'O','L','E',' ','D','B',' ','S','e','r','v','i','c','i','e','s',0};
 316 static const WCHAR passwordW[] = {'P','a','s','s','w','o','r','d',0};
 317 static const WCHAR persistW[]  = {'P','e','r','s','i','s','t',' ','S','e','c','u','r','i','t','y',' ','I','n','f','o',0};
 318 static const WCHAR persistEncW[]  = {'P','e','r','s','i','s','t',' ','E','n','c','r','y','p','t','e','d',0};
 319 static const WCHAR promptW[] = {'P','r','o','m','p','t',0};
 320 static const WCHAR protectW[]  = {'P','r','o','t','e','c','t','i','o','n',' ','l','e','v','e','l',0};
 321 static const WCHAR useridW[] = {'U','s','e','r',' ','I','D',0};
 322 static const WCHAR winhandleW[] = {'W','i','n','d','o','w',' ','H','a','n','d','l','e',0};
 323
 324 static const struct dbproperty dbproperties[] = {
 325     { asyncW,      DBPROP_INIT_ASYNCH,                     DBPROPOPTIONS_OPTIONAL, VT_I4 },
 326     { bindW,       DBPROP_INIT_BINDFLAGS,                  DBPROPOPTIONS_OPTIONAL, VT_I4 },
 327     { cacheW,      DBPROP_AUTH_CACHE_AUTHINFO,             DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 328     { conn_timeout,DBPROP_INIT_TIMEOUT,                    DBPROPOPTIONS_OPTIONAL, VT_I4 },
 329     { datasourceW, DBPROP_INIT_DATASOURCE,                 DBPROPOPTIONS_REQUIRED, VT_BSTR },
 330     { extendedW,   DBPROP_INIT_PROVIDERSTRING,             DBPROPOPTIONS_REQUIRED, VT_BSTR },
 331     { encryptW,    DBPROP_AUTH_ENCRYPT_PASSWORD,           DBPROPOPTIONS_REQUIRED, VT_BOOL },
 332     { gen_timeout, DBPROP_INIT_GENERALTIMEOUT,             DBPROPOPTIONS_OPTIONAL, VT_I4 },
 333     { impersonW,   DBPROP_INIT_IMPERSONATION_LEVEL,        DBPROPOPTIONS_OPTIONAL, VT_I4 },
 334     { initcatW,    DBPROP_CATALOGLOCATION,                 DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 335     { integratedW, DBPROP_AUTH_INTEGRATED,                 DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 336     { localeIDW,   DBPROP_INIT_LCID,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 337     { locationW,   DBPROP_INIT_LOCATION,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 338     { lockownerW,  DBPROP_INIT_LOCKOWNER,                  DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 339     { maskpassW,   DBPROP_AUTH_MASK_PASSWORD,              DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 340     { modeW,       DBPROP_INIT_MODE,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 341     { oledbservW,  DBPROP_INIT_OLEDBSERVICES,              DBPROPOPTIONS_OPTIONAL, VT_I4 },
 342     { passwordW,   DBPROP_AUTH_PASSWORD,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 343     { persistEncW, DBPROP_AUTH_PERSIST_ENCRYPTED,          DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 344     { persistW,    DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 345     { promptW,     DBPROP_INIT_PROMPT,                     DBPROPOPTIONS_OPTIONAL, VT_I2 },
 346     { protectW,    DBPROP_INIT_PROTECTION_LEVEL,           DBPROPOPTIONS_OPTIONAL, VT_I4 },
 347     { useridW,     DBPROP_AUTH_USERID,                     DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 348 #ifndef _WIN64
 349     { winhandleW,  DBPROP_INIT_HWND,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 350 #else
 351     { winhandleW,  DBPROP_INIT_HWND,                       DBPROPOPTIONS_OPTIONAL, VT_I8 },
 352 #endif
 353 };
 354
 355
 356 static HRESULT set_dbpropset(BSTR name, BSTR value, DBPROPSET **propset)
 357 {
 358     VARIANT src, dest;
 359     int min, max, n;
 360     HRESULT hr;
 361
 362     min = 0;
 363     max = sizeof(dbproperties)/sizeof(struct dbproperty) - 1;
 364
 365     while (min <= max)
 366     {
 367         int r;
 368
 369         n = (min+max)/2;
 370
 371         r = strcmpW(dbproperties[n].name, name);
 372         if (!r)
 373             break;
 374
 375         if (r < 0)
 376             min = n+1;
 377         else
 378             max = n-1;
 379     }
 380
 381     if (min > max)
 382     {
 383         *propset = NULL;
 384         FIXME("unsupported property %s\n", debugstr_w(name));
 385         return E_FAIL;
 386     }
 387
 388     VariantInit(&dest);
 389
 390     V_VT(&src) = VT_BSTR;
 391     V_BSTR(&src) = value;
 392
 393     hr = VariantChangeType(&dest, &src, 0, dbproperties[n].type);
 394     if (FAILED(hr))
 395     {
 396         ERR("failed to init property %s value as type %d\n", debugstr_w(name), dbproperties[n].type);
 397         return hr;
 398     }
 399
 400     *propset = CoTaskMemAlloc(sizeof(DBPROPSET));
 401     if (!*propset)
 402     {
 403         VariantClear(&dest);
 404         return E_OUTOFMEMORY;
 405     }
 406
 407     (*propset)->rgProperties = CoTaskMemAlloc(sizeof(DBPROP));
 408     if (!(*propset)->rgProperties)
 409     {
 410         VariantClear(&dest);
 411         CoTaskMemFree(*propset);
 412         return E_OUTOFMEMORY;
 413     }
 414
 415     (*propset)->cProperties = 1;
 416     (*propset)->guidPropertySet = DBPROPSET_DBINIT;
 417     (*propset)->rgProperties[0].dwPropertyID = dbproperties[n].id;
 418     (*propset)->rgProperties[0].dwOptions = dbproperties[n].options;
 419     (*propset)->rgProperties[0].dwStatus = 0;
 420     memset(&(*propset)->rgProperties[0].colid, 0, sizeof(DBID));
 421     (*propset)->rgProperties[0].vValue = dest;
 422
 423     return S_OK;
 424 }
 425
 426 /*** IDataInitialize methods ***/
 427 static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *outer, DWORD clsctx,
 428                                 LPWSTR initstring, REFIID riid, IUnknown **datasource)
 429 {
 430     static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r','=',0};
 431     static const WCHAR msdasqlW[] = {'M','S','D','A','S','Q','L',0};
 432     datainit *This = impl_from_IDataInitialize(iface);
 433     IDBProperties *dbprops;
 434     DBPROPSET *propset;
 435     WCHAR *prov = NULL;
 436     CLSID provclsid;
 437     HRESULT hr;
 438
 439     TRACE("(%p)->(%p 0x%x %s %s %p)\n", This, outer, clsctx, debugstr_w(initstring), debugstr_guid(riid), datasource);
 440
 441     /* first get provider name */
 442     provclsid = IID_NULL;
 443     if (initstring && (prov = strstrW(initstring, providerW)))
 444     {
 445         WCHAR *start, *progid;
 446         int len;
 447
 448         prov += sizeof(providerW)/sizeof(WCHAR)-1;
 449         start = prov;
 450         while (*prov && *prov != ';')
 451             ++prov;
 452         TRACE("got provider %s\n", debugstr_wn(start, prov-start));
 453
 454         len = prov - start;
 455         progid = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
 456         if (!progid) return E_OUTOFMEMORY;
 457
 458         memcpy(progid, start, len*sizeof(WCHAR));
 459         progid[len] = 0;
 460
 461         hr = CLSIDFromProgID(progid, &provclsid);
 462         CoTaskMemFree(progid);
 463         if (FAILED(hr))
 464         {
 465             ERR("provider %s not registered\n", debugstr_wn(start, prov-start));
 466             return hr;
 467         }
 468     }
 469     else
 470     {
 471         hr = CLSIDFromProgID(msdasqlW, &provclsid);
 472         if (FAILED(hr))
 473             ERR("ODBC provider for OLE DB not registered\n");
 474     }
 475
 476     /* check for provider mismatch if it was specified in init string */
 477     if (*datasource && prov)
 478     {
 479         DBPROPIDSET propidset;
 480         enum DBPROPENUM prop;
 481         CLSID initprov;
 482         ULONG count;
 483
 484         hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
 485         if (FAILED(hr))
 486         {
 487             WARN("provider doesn't support IDBProperties\n");
 488             return hr;
 489         }
 490
 491         prop = DBPROP_INIT_DATASOURCE;
 492         propidset.rgPropertyIDs = &prop;
 493         propidset.cPropertyIDs = 1;
 494         propidset.guidPropertySet = DBPROPSET_DBINIT;
 495         count = 0;
 496         propset = NULL;
 497         hr = IDBProperties_GetProperties(dbprops, 1, &propidset, &count, &propset);
 498         IDBProperties_Release(dbprops);
 499         if (FAILED(hr))
 500         {
 501             WARN("GetProperties failed for datasource, 0x%08x\n", hr);
 502             return hr;
 503         }
 504
 505         TRACE("initial data source provider %s\n", debugstr_w(V_BSTR(&propset->rgProperties[0].vValue)));
 506         initprov = IID_NULL;
 507         CLSIDFromProgID(V_BSTR(&propset->rgProperties[0].vValue), &initprov);
 508         free_dbpropset(count, propset);
 509
 510         if (!IsEqualIID(&provclsid, &initprov)) return DB_E_MISMATCHEDPROVIDER;
 511     }
 512
 513     if (!*datasource)
 514     {
 515         if (!IsEqualIID(&provclsid, &IID_NULL))
 516             hr = CoCreateInstance(&provclsid, outer, clsctx, riid, (void**)datasource);
 517
 518         if (FAILED(hr) && IsEqualIID(riid, &IID_IDBInitialize))
 519             hr = create_db_init((void**)datasource);
 520     }
 521
 522     /* now set properties */
 523     if (initstring)
 524     {
 525         WCHAR *eq, *start;
 526
 527         hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
 528         if (FAILED(hr))
 529         {
 530             WARN("provider doesn't support IDBProperties\n");
 531             return hr;
 532         }
 533
 534         start = initstring;
 535         while (start && (eq = strchrW(start, '=')))
 536         {
 537             static const WCHAR providerW[] = {'P','r','o','v','i','d','e','r',0};
 538             WCHAR *scol = strchrW(eq+1, ';');
 539             BSTR value, name;
 540
 541             name = SysAllocStringLen(start, eq - start);
 542             /* skip equal sign to get value */
 543             eq++;
 544             value = SysAllocStringLen(eq, scol ? scol - eq : -1);
 545
 546             /* skip semicolon if present */
 547             if (scol) scol++;
 548             start = scol;
 549
 550             if (!strcmpW(name, providerW))
 551             {
 552                 SysFreeString(name);
 553                 SysFreeString(value);
 554                 continue;
 555             }
 556
 557             TRACE("property (name=%s, value=%s)\n", debugstr_w(name), debugstr_w(value));
 558
 559             hr = set_dbpropset(name, value, &propset);
 560             SysFreeString(name);
 561             SysFreeString(value);
 562             if (FAILED(hr)) return hr;
 563
 564             hr = IDBProperties_SetProperties(dbprops, 1, propset);
 565             free_dbpropset(1, propset);
 566             TRACE("provider ret 0x%08x\n", hr);
 567         }
 568
 569         IDBProperties_Release(dbprops);
 570     }
 571
 572     return hr;
 573 }
 574
 575 /* returns character length of string representation */
 576 static int get_propvalue_length(DBPROP *prop)
 577 {
 578     VARIANT str;
 579     HRESULT hr;
 580
 581     if (V_VT(&prop->vValue) == VT_BSTR) return SysStringLen(V_BSTR(&prop->vValue));
 582
 583     VariantInit(&str);
 584     hr = VariantChangeType(&str, &prop->vValue, 0, VT_BSTR);
 585     if (hr == S_OK)
 586     {
 587         int len = SysStringLen(V_BSTR(&str));
 588         VariantClear(&str);
 589         return len;
 590     }
 591
 592     return 0;
 593 }
 594
 595 static void write_propvalue_str(WCHAR *str, DBPROP *prop)
 596 {
 597     VARIANT *v = &prop->vValue;
 598     VARIANT vstr;
 599     HRESULT hr;
 600
 601     if (V_VT(v) == VT_BSTR)
 602     {
 603         strcatW(str, V_BSTR(v));
 604         return;
 605     }
 606
 607     VariantInit(&vstr);
 608     hr = VariantChangeType(&vstr, v, VARIANT_ALPHABOOL, VT_BSTR);
 609     if (hr == S_OK)
 610     {
 611         strcatW(str, V_BSTR(&vstr));
 612         VariantClear(&vstr);
 613     }
 614 }
 615
 616 static WCHAR *get_propinfo_descr(DBPROP *prop, DBPROPINFOSET *propinfoset)
 617 {
 618     ULONG i;
 619
 620     for (i = 0; i < propinfoset->cPropertyInfos; i++)
 621         if (propinfoset->rgPropertyInfos[i].dwPropertyID == prop->dwPropertyID)
 622             return propinfoset->rgPropertyInfos[i].pwszDescription;
 623
 624     return NULL;
 625 }
 626
 627 static void free_dbpropinfoset(ULONG count, DBPROPINFOSET *propinfoset)
 628 {
 629     ULONG i;
 630
 631     for (i = 0; i < count; i++)
 632     {
 633         ULONG p;
 634
 635         for (p = 0; p < propinfoset[i].cPropertyInfos; p++)
 636             VariantClear(&propinfoset[i].rgPropertyInfos[p].vValues);
 637
 638         CoTaskMemFree(propinfoset[i].rgPropertyInfos);
 639     }
 640     CoTaskMemFree(propinfoset);
 641 }
 642
 643 static HRESULT WINAPI datainit_GetInitializationString(IDataInitialize *iface, IUnknown *datasource,
 644                                 boolean include_pass, LPWSTR *init_string)
 645 {
 646     static const WCHAR provW[] = {'P','r','o','v','i','d','e','r','=',0};
 647     static const WCHAR colW[] = {';',0};
 648     datainit *This = impl_from_IDataInitialize(iface);
 649     DBPROPINFOSET *propinfoset;
 650     IDBProperties *props;
 651     DBPROPIDSET propidset;
 652     ULONG count, infocount;
 653     WCHAR *progid, *desc;
 654     DBPROPSET *propset;
 655     IPersist *persist;
 656     HRESULT hr;
 657     CLSID clsid;
 658     ULONG i, len;
 659
 660     TRACE("(%p)->(%p %d %p)\n", This, datasource, include_pass, init_string);
 661
 662     /* IPersist support is mandatory for data sources */
 663     hr = IUnknown_QueryInterface(datasource, &IID_IPersist, (void**)&persist);
 664     if (FAILED(hr)) return hr;
 665
 666     memset(&clsid, 0, sizeof(clsid));
 667     hr = IPersist_GetClassID(persist, &clsid);
 668     IPersist_Release(persist);
 669     if (FAILED(hr)) return hr;
 670
 671     progid = NULL;
 672     ProgIDFromCLSID(&clsid, &progid);
 673     TRACE("clsid=%s, progid=%s\n", debugstr_guid(&clsid), debugstr_w(progid));
 674
 675     /* now get initialization properties */
 676     hr = IUnknown_QueryInterface(datasource, &IID_IDBProperties, (void**)&props);
 677     if (FAILED(hr))
 678     {
 679         WARN("IDBProperties not supported\n");
 680         CoTaskMemFree(progid);
 681         return hr;
 682     }
 683
 684     propidset.rgPropertyIDs = NULL;
 685     propidset.cPropertyIDs = 0;
 686     propidset.guidPropertySet = DBPROPSET_DBINIT;
 687     propset = NULL;
 688     count = 0;
 689     hr = IDBProperties_GetProperties(props, 1, &propidset, &count, &propset);
 690     if (FAILED(hr))
 691     {
 692         WARN("failed to get data source properties, 0x%08x\n", hr);
 693         CoTaskMemFree(progid);
 694         return hr;
 695     }
 696
 697     infocount = 0;
 698     IDBProperties_GetPropertyInfo(props, 1, &propidset, &infocount, &propinfoset, &desc);
 699     IDBProperties_Release(props);
 700
 701     /* check if we need to skip password */
 702     len = strlenW(progid) + strlenW(provW) + 1; /* including ';' */
 703     for (i = 0; i < count; i++)
 704     {
 705         WCHAR *descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
 706         if (descr)
 707         {
 708             /* include '=' and ';' */
 709             len += strlenW(descr) + 2;
 710             len += get_propvalue_length(&propset->rgProperties[i]);
 711         }
 712
 713         if ((propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO) &&
 714             (V_BOOL(&propset->rgProperties[i].vValue) == VARIANT_FALSE))
 715            include_pass = FALSE;
 716     }
 717
 718     len *= sizeof(WCHAR);
 719     *init_string = CoTaskMemAlloc(len);
 720     *init_string[0] = 0;
 721
 722     /* provider name */
 723     strcatW(*init_string, provW);
 724     strcatW(*init_string, progid);
 725     strcatW(*init_string, colW);
 726     CoTaskMemFree(progid);
 727
 728     for (i = 0; i < count; i++)
 729     {
 730         WCHAR *descr;
 731
 732         if (!include_pass && propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PASSWORD) continue;
 733
 734         descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
 735         if (descr)
 736         {
 737             static const WCHAR eqW[] = {'=',0};
 738             strcatW(*init_string, descr);
 739             strcatW(*init_string, eqW);
 740             write_propvalue_str(*init_string, &propset->rgProperties[i]);
 741             strcatW(*init_string, colW);
 742         }
 743     }
 744
 745     free_dbpropset(count, propset);
 746     free_dbpropinfoset(infocount, propinfoset);
 747     CoTaskMemFree(desc);
 748
 749     if (!include_pass)
 750         TRACE("%s\n", debugstr_w(*init_string));
 751     return S_OK;
 752 }
 753
 754 static HRESULT WINAPI datainit_CreateDBInstance(IDataInitialize *iface, REFCLSID provider,
 755                                 IUnknown *outer, DWORD clsctx, LPWSTR reserved, REFIID riid,
 756                                 IUnknown **datasource)
 757 {
 758     datainit *This = impl_from_IDataInitialize(iface);
 759
 760     TRACE("(%p)->(%s %p 0x%08x %s %s %p)\n", This, debugstr_guid(provider), outer, clsctx, debugstr_w(reserved),
 761         debugstr_guid(riid), datasource);
 762
 763     return CoCreateInstance(provider, outer, clsctx, riid, (void**)datasource);
 764 }
 765
 766 static HRESULT WINAPI datainit_RemoteCreateDBInstanceEx(IDataInitialize *iface, REFCLSID clsidProvider,
 767                                 IUnknown *pUnkOuter, DWORD dwClsCtx, LPWSTR pwszReserved, COSERVERINFO *pServerInfo,
 768                                 DWORD cmq, GUID **rgpIID, IUnknown **rgpItf, HRESULT *rghr)
 769 {
 770     datainit *This = impl_from_IDataInitialize(iface);
 771
 772     FIXME("(%p)->()\n", This);
 773
 774     return E_NOTIMPL;
 775 }
 776
 777 static HRESULT WINAPI datainit_LoadStringFromStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 778                                 LPWSTR *ppwszInitializationString)
 779 {
 780     datainit *This = impl_from_IDataInitialize(iface);
 781
 782     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwszFileName), ppwszInitializationString);
 783
 784     return E_NOTIMPL;
 785 }
 786
 787 static HRESULT WINAPI datainit_WriteStringToStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 788                                 LPWSTR pwszInitializationString, DWORD dwCreationDisposition)
 789 {
 790     datainit *This = impl_from_IDataInitialize(iface);
 791
 792     FIXME("(%p)->(%s %s %d)\n", This, debugstr_w(pwszFileName), debugstr_w(pwszInitializationString), dwCreationDisposition);
 793
 794     return E_NOTIMPL;
 795 }
 796
 797
 798 static const struct IDataInitializeVtbl datainit_vtbl =
 799 {
 800     datainit_QueryInterface,
 801     datainit_AddRef,
 802     datainit_Release,
 803     datainit_GetDataSource,
 804     datainit_GetInitializationString,
 805     datainit_CreateDBInstance,
 806     datainit_RemoteCreateDBInstanceEx,
 807     datainit_LoadStringFromStorage,
 808     datainit_WriteStringToStorage
 809 };
 810
 811 HRESULT create_data_init(IUnknown *outer, void **obj)
 812 {
 813     datainit *This;
 814
 815     TRACE("(%p)\n", obj);
 816
 817     if(outer) return CLASS_E_NOAGGREGATION;
 818
 819     *obj = NULL;
 820
 821     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 822     if(!This) return E_OUTOFMEMORY;
 823
 824     This->IDataInitialize_iface.lpVtbl = &datainit_vtbl;
 825     This->ref = 1;
 826
 827     *obj = &This->IDataInitialize_iface;
 828
 829     return S_OK;
 830 }