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
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winnls.h"
  25 #include "ole2.h"
  26 #include "msdasc.h"
  27 #include "oledberr.h"
  28 #include "initguid.h"
  29 #include "oledb_private.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/heap.h"
  33 #include "wine/list.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  36
  37 DEFINE_GUID(DB_NULLGUID,       0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
  38 DEFINE_GUID(DBGUID_SESSION,    0xc8b522f5, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  39 DEFINE_GUID(DBGUID_ROWSET,     0xc8b522f6, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  40 DEFINE_GUID(DBGUID_ROW,        0xc8b522f7, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  41 DEFINE_GUID(DBGUID_STREAM,     0xc8b522f9, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  42
  43 DEFINE_GUID(DBPROPSET_COLUMN,            0xc8b522b9, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  44 DEFINE_GUID(DBPROPSET_DATASOURCE,        0xc8b522ba, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  45 DEFINE_GUID(DBPROPSET_DATASOURCEINFO,    0xc8b522bb, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  46 DEFINE_GUID(DBPROPSET_DBINIT,            0xc8b522bc, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  47 DEFINE_GUID(DBPROPSET_INDEX,             0xc8b522bd, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  48 DEFINE_GUID(DBPROPSET_ROWSET,            0xc8b522be, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  49 DEFINE_GUID(DBPROPSET_TABLE,             0xc8b522bf, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  50 DEFINE_GUID(DBPROPSET_DATASOURCEALL,     0xc8b522c0, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  51 DEFINE_GUID(DBPROPSET_DATASOURCEINFOALL, 0xc8b522c1, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  52 DEFINE_GUID(DBPROPSET_ROWSETALL,         0xc8b522c2, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  53 DEFINE_GUID(DBPROPSET_SESSION,           0xc8b522c6, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  54 DEFINE_GUID(DBPROPSET_SESSIONALL,        0xc8b522c7, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  55 DEFINE_GUID(DBPROPSET_DBINITALL,         0xc8b522ca, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  56 DEFINE_GUID(DBPROPSET_PROPERTIESINERROR, 0xc8b522d4, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
  57
  58 typedef struct datainit
  59 {
  60     IDataInitialize IDataInitialize_iface;
  61
  62     LONG ref;
  63 } datainit;
  64
  65 static inline datainit *impl_from_IDataInitialize(IDataInitialize *iface)
  66 {
  67     return CONTAINING_RECORD(iface, datainit, IDataInitialize_iface);
  68 }
  69
  70 typedef struct
  71 {
  72     IDBInitialize IDBInitialize_iface;
  73     IDBProperties IDBProperties_iface;
  74
  75     LONG ref;
  76 } dbinit;
  77
  78 static inline dbinit *impl_from_IDBInitialize(IDBInitialize *iface)
  79 {
  80     return CONTAINING_RECORD(iface, dbinit, IDBInitialize_iface);
  81 }
  82
  83 static inline dbinit *impl_from_IDBProperties(IDBProperties *iface)
  84 {
  85     return CONTAINING_RECORD(iface, dbinit, IDBProperties_iface);
  86 }
  87
  88 static HRESULT WINAPI dbprops_QueryInterface(IDBProperties *iface, REFIID riid, void **ppvObject)
  89 {
  90     dbinit *This = impl_from_IDBProperties(iface);
  91
  92     return IDBInitialize_QueryInterface(&This->IDBInitialize_iface, riid, ppvObject);
  93 }
  94
  95 static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
  96 {
  97     dbinit *This = impl_from_IDBProperties(iface);
  98
  99     return IDBInitialize_AddRef(&This->IDBInitialize_iface);
 100 }
 101
 102 static ULONG WINAPI dbprops_Release(IDBProperties *iface)
 103 {
 104     dbinit *This = impl_from_IDBProperties(iface);
 105
 106     return IDBInitialize_Release(&This->IDBInitialize_iface);
 107 }
 108
 109 static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
 110             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
 111 {
 112     dbinit *This = impl_from_IDBProperties(iface);
 113
 114     FIXME("(%p)->(%ld %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
 115
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
 120             const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
 121             DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
 122 {
 123     dbinit *This = impl_from_IDBProperties(iface);
 124
 125     FIXME("(%p)->(%ld %p %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
 126                 prgPropertyInfoSets, ppDescBuffer);
 127
 128     return E_NOTIMPL;
 129 }
 130
 131 static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG cPropertySets,
 132             DBPROPSET rgPropertySets[])
 133 {
 134     dbinit *This = impl_from_IDBProperties(iface);
 135
 136     FIXME("(%p)->(%ld %p)\n", This, cPropertySets, rgPropertySets);
 137
 138     return E_NOTIMPL;
 139 }
 140
 141 static const struct IDBPropertiesVtbl dbprops_vtbl =
 142 {
 143     dbprops_QueryInterface,
 144     dbprops_AddRef,
 145     dbprops_Release,
 146     dbprops_GetProperties,
 147     dbprops_GetPropertyInfo,
 148     dbprops_SetProperties
 149 };
 150
 151 static HRESULT WINAPI dbinit_QueryInterface(IDBInitialize *iface, REFIID riid, void **obj)
 152 {
 153     dbinit *This = impl_from_IDBInitialize(iface);
 154     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 155
 156     *obj = NULL;
 157
 158     if(IsEqualIID(riid, &IID_IUnknown) ||
 159        IsEqualIID(riid, &IID_IDBInitialize))
 160     {
 161         *obj = iface;
 162     }
 163     else if(IsEqualIID(riid, &IID_IDBProperties))
 164     {
 165         *obj = &This->IDBProperties_iface;
 166     }
 167     else
 168     {
 169         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 170         return E_NOINTERFACE;
 171     }
 172
 173     IDBInitialize_AddRef(iface);
 174     return S_OK;
 175 }
 176
 177 static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
 178 {
 179     dbinit *This = impl_from_IDBInitialize(iface);
 180     TRACE("(%p)\n", This);
 181
 182     return InterlockedIncrement(&This->ref);
 183 }
 184
 185 static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
 186 {
 187     dbinit *This = impl_from_IDBInitialize(iface);
 188     LONG ref;
 189
 190     TRACE("(%p)\n", This);
 191
 192     ref = InterlockedDecrement(&This->ref);
 193     if(ref == 0)
 194         heap_free(This);
 195
 196     return ref;
 197 }
 198
 199 static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
 200 {
 201     dbinit *This = impl_from_IDBInitialize(iface);
 202
 203     FIXME("(%p) stub\n", This);
 204
 205     return S_OK;
 206 }
 207
 208 static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
 209 {
 210     dbinit *This = impl_from_IDBInitialize(iface);
 211
 212     FIXME("(%p) stub\n", This);
 213
 214     return S_OK;
 215 }
 216
 217 static const IDBInitializeVtbl dbinit_vtbl =
 218 {
 219     dbinit_QueryInterface,
 220     dbinit_AddRef,
 221     dbinit_Release,
 222     dbinit_Initialize,
 223     dbinit_Uninitialize
 224 };
 225
 226 static HRESULT create_db_init(IUnknown **obj)
 227 {
 228     dbinit *This;
 229
 230     TRACE("()\n");
 231
 232     *obj = NULL;
 233
 234     This = heap_alloc(sizeof(*This));
 235     if(!This) return E_OUTOFMEMORY;
 236
 237     This->IDBInitialize_iface.lpVtbl = &dbinit_vtbl;
 238     This->IDBProperties_iface.lpVtbl = &dbprops_vtbl;
 239     This->ref = 1;
 240
 241     *obj = (IUnknown*)&This->IDBInitialize_iface;
 242
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI datainit_QueryInterface(IDataInitialize *iface, REFIID riid, void **obj)
 247 {
 248     datainit *This = impl_from_IDataInitialize(iface);
 249     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
 250
 251     *obj = NULL;
 252
 253     if(IsEqualIID(riid, &IID_IUnknown) ||
 254        IsEqualIID(riid, &IID_IDataInitialize))
 255     {
 256         *obj = &This->IDataInitialize_iface;
 257     }
 258     else
 259     {
 260         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 261         return E_NOINTERFACE;
 262     }
 263
 264     IDataInitialize_AddRef(iface);
 265     return S_OK;
 266 }
 267
 268 static ULONG WINAPI datainit_AddRef(IDataInitialize *iface)
 269 {
 270     datainit *This = impl_from_IDataInitialize(iface);
 271     TRACE("(%p)\n", This);
 272
 273     return InterlockedIncrement(&This->ref);
 274 }
 275
 276 static ULONG WINAPI datainit_Release(IDataInitialize *iface)
 277 {
 278     datainit *This = impl_from_IDataInitialize(iface);
 279     LONG ref;
 280
 281     TRACE("(%p)\n", This);
 282
 283     ref = InterlockedDecrement(&This->ref);
 284     if(ref == 0)
 285         heap_free(This);
 286
 287     return ref;
 288 }
 289
 290 static void free_dbpropset(ULONG count, DBPROPSET *propset)
 291 {
 292     ULONG i;
 293
 294     for (i = 0; i < count; i++)
 295     {
 296         ULONG p;
 297
 298         for (p = 0; p < propset[i].cProperties; p++)
 299             VariantClear(&propset[i].rgProperties[p].vValue);
 300
 301         CoTaskMemFree(propset[i].rgProperties);
 302     }
 303     CoTaskMemFree(propset);
 304 }
 305
 306 struct dbproperty {
 307     const WCHAR *name;
 308     DBPROPID id;
 309     DBPROPOPTIONS options;
 310     VARTYPE type;
 311     HRESULT (*convert_dbproperty)(const WCHAR *src, VARIANT *dest);
 312 };
 313
 314 struct mode_propval
 315 {
 316     const WCHAR *name;
 317     DWORD value;
 318 };
 319
 320 static int __cdecl dbmodeprop_compare(const void *a, const void *b)
 321 {
 322     const WCHAR *src = a;
 323     const struct mode_propval *propval = b;
 324     return wcsicmp(src, propval->name);
 325 }
 326
 327 static HRESULT convert_dbproperty_mode(const WCHAR *src, VARIANT *dest)
 328 {
 329     static const struct mode_propval mode_propvals[] =
 330     {
 331         { L"Read", DB_MODE_READ },
 332         { L"ReadWrite", DB_MODE_READWRITE },
 333         { L"Share Deny None", DB_MODE_SHARE_DENY_NONE },
 334         { L"Share Deny Read", DB_MODE_SHARE_DENY_READ },
 335         { L"Share Deny Write", DB_MODE_SHARE_DENY_WRITE },
 336         { L"Share Exclusive", DB_MODE_SHARE_EXCLUSIVE },
 337         { L"Write", DB_MODE_WRITE },
 338     };
 339     struct mode_propval *prop;
 340
 341     if ((prop = bsearch(src, mode_propvals, ARRAY_SIZE(mode_propvals),
 342                         sizeof(struct mode_propval), dbmodeprop_compare)))
 343     {
 344         V_VT(dest) = VT_I4;
 345         V_I4(dest) = prop->value;
 346         TRACE("%s = %#lx\n", debugstr_w(src), prop->value);
 347         return S_OK;
 348     }
 349
 350     return E_FAIL;
 351 }
 352
 353 static const struct dbproperty dbproperties[] =
 354 {
 355     { L"Asynchronous Processing", DBPROP_INIT_ASYNCH,                     DBPROPOPTIONS_OPTIONAL, VT_I4 },
 356     { L"Bind Flags",              DBPROP_INIT_BINDFLAGS,                  DBPROPOPTIONS_OPTIONAL, VT_I4 },
 357     { L"Cache Authentication",    DBPROP_AUTH_CACHE_AUTHINFO,             DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 358     { L"Connect Timeout",         DBPROP_INIT_TIMEOUT,                    DBPROPOPTIONS_OPTIONAL, VT_I4 },
 359     { L"Data Source",             DBPROP_INIT_DATASOURCE,                 DBPROPOPTIONS_REQUIRED, VT_BSTR },
 360     { L"Extended Properties",     DBPROP_INIT_PROVIDERSTRING,             DBPROPOPTIONS_REQUIRED, VT_BSTR },
 361     { L"Encrypt Password",        DBPROP_AUTH_ENCRYPT_PASSWORD,           DBPROPOPTIONS_REQUIRED, VT_BOOL },
 362     { L"General Timeout",         DBPROP_INIT_GENERALTIMEOUT,             DBPROPOPTIONS_OPTIONAL, VT_I4 },
 363     { L"Impersonation Level",     DBPROP_INIT_IMPERSONATION_LEVEL,        DBPROPOPTIONS_OPTIONAL, VT_I4 },
 364     { L"Initial Catalog",         DBPROP_CATALOGLOCATION,                 DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 365     { L"Integrated Security",     DBPROP_AUTH_INTEGRATED,                 DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 366     { L"Locale Identifier",       DBPROP_INIT_LCID,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 367     { L"Location",                DBPROP_INIT_LOCATION,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 368     { L"Lock Owner",              DBPROP_INIT_LOCKOWNER,                  DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 369     { L"Mask Password",           DBPROP_AUTH_MASK_PASSWORD,              DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 370     { L"Mode",                    DBPROP_INIT_MODE,                       DBPROPOPTIONS_OPTIONAL, VT_I4, convert_dbproperty_mode },
 371     { L"OLE DB Services",         DBPROP_INIT_OLEDBSERVICES,              DBPROPOPTIONS_OPTIONAL, VT_I4 },
 372     { L"Password",                DBPROP_AUTH_PASSWORD,                   DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 373     { L"Persist Encrypted",       DBPROP_AUTH_PERSIST_ENCRYPTED,          DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 374     { L"Persist Security Info",   DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
 375     { L"Prompt",                  DBPROP_INIT_PROMPT,                     DBPROPOPTIONS_OPTIONAL, VT_I2 },
 376     { L"Protection level",        DBPROP_INIT_PROTECTION_LEVEL,           DBPROPOPTIONS_OPTIONAL, VT_I4 },
 377     { L"User ID",                 DBPROP_AUTH_USERID,                     DBPROPOPTIONS_OPTIONAL, VT_BSTR },
 378 #ifndef _WIN64
 379     { L"Window Handle",           DBPROP_INIT_HWND,                       DBPROPOPTIONS_OPTIONAL, VT_I4 },
 380 #else
 381     { L"Window Handle",           DBPROP_INIT_HWND,                       DBPROPOPTIONS_OPTIONAL, VT_I8 },
 382 #endif
 383 };
 384
 385 struct dbprop_pair
 386 {
 387     struct list entry;
 388     BSTR name;
 389     BSTR value;
 390 };
 391
 392 struct dbprops
 393 {
 394     struct list props;
 395     unsigned int count;
 396 };
 397
 398 /* name/value strings are reused, so they shouldn't be freed after this call */
 399 static HRESULT add_dbprop_to_list(struct dbprops *props, BSTR name, BSTR value)
 400 {
 401     struct dbprop_pair *pair;
 402
 403     pair = heap_alloc(sizeof(*pair));
 404     if (!pair)
 405         return E_OUTOFMEMORY;
 406
 407     pair->name = name;
 408     pair->value = value;
 409     list_add_tail(&props->props, &pair->entry);
 410     props->count++;
 411     return S_OK;
 412 }
 413
 414 static void free_dbprop_list(struct dbprops *props)
 415 {
 416     struct dbprop_pair *p, *p2;
 417     LIST_FOR_EACH_ENTRY_SAFE(p, p2, &props->props, struct dbprop_pair, entry)
 418     {
 419         list_remove(&p->entry);
 420         SysFreeString(p->name);
 421         SysFreeString(p->value);
 422         heap_free(p);
 423     }
 424 }
 425
 426 static HRESULT parse_init_string(const WCHAR *initstring, struct dbprops *props)
 427 {
 428     const WCHAR *start;
 429     WCHAR *eq;
 430     HRESULT hr = S_OK;
 431
 432     list_init(&props->props);
 433     props->count = 0;
 434
 435     start = initstring;
 436     while (start && (eq = wcschr(start, '=')))
 437     {
 438         WCHAR *delim, quote;
 439         BSTR value, name;
 440
 441         name = SysAllocStringLen(start, eq - start);
 442         /* skip equal sign to get value */
 443         eq++;
 444
 445         quote = (*eq == '"' || *eq == '\'') ? *eq : 0;
 446         if (quote)
 447         {
 448             /* for quoted value string, skip opening mark, look for terminating one */
 449             eq++;
 450             delim = wcschr(eq, quote);
 451         }
 452         else
 453             delim = wcschr(eq, ';');
 454
 455         if (delim)
 456             value = SysAllocStringLen(eq, delim - eq);
 457         else
 458             value = SysAllocString(eq);
 459
 460         /* skip semicolon if present */
 461         if (delim)
 462         {
 463             if (*delim == quote)
 464                delim++;
 465             if (*delim == ';')
 466                delim++;
 467         }
 468         start = delim;
 469
 470         if (!wcsicmp(name, L"Provider"))
 471         {
 472             SysFreeString(name);
 473             SysFreeString(value);
 474             continue;
 475         }
 476
 477         TRACE("property (name=%s, value=%s)\n", debugstr_w(name), debugstr_w(value));
 478
 479         hr = add_dbprop_to_list(props, name, value);
 480         if (FAILED(hr))
 481         {
 482             SysFreeString(name);
 483             SysFreeString(value);
 484             break;
 485         }
 486     }
 487
 488     if (FAILED(hr))
 489         free_dbprop_list(props);
 490
 491     return hr;
 492 }
 493
 494 static const struct dbproperty *get_known_dprop_descr(BSTR name)
 495 {
 496     int min, max, n;
 497
 498     min = 0;
 499     max = ARRAY_SIZE(dbproperties) - 1;
 500
 501     while (min <= max)
 502     {
 503         int r;
 504
 505         n = (min+max)/2;
 506
 507         r = wcsicmp(dbproperties[n].name, name);
 508         if (!r)
 509             break;
 510
 511         if (r < 0)
 512             min = n+1;
 513         else
 514             max = n-1;
 515     }
 516
 517     return (min <= max) ? &dbproperties[n] : NULL;
 518 }
 519
 520 static HRESULT get_dbpropset_from_proplist(struct dbprops *props, DBPROPSET **propset)
 521 {
 522     struct dbprop_pair *pair;
 523     int i = 0;
 524     HRESULT hr;
 525
 526     *propset = CoTaskMemAlloc(sizeof(DBPROPSET));
 527     if (!*propset)
 528         return E_OUTOFMEMORY;
 529
 530     (*propset)->rgProperties = CoTaskMemAlloc(props->count*sizeof(DBPROP));
 531     if (!(*propset)->rgProperties)
 532     {
 533         CoTaskMemFree(*propset);
 534         *propset = NULL;
 535         return E_OUTOFMEMORY;
 536     }
 537
 538     (*propset)->cProperties = 0;
 539     LIST_FOR_EACH_ENTRY(pair, &props->props, struct dbprop_pair, entry)
 540     {
 541         const struct dbproperty *descr = get_known_dprop_descr(pair->name);
 542         VARIANT dest, src;
 543
 544         if (!descr)
 545         {
 546             BSTR str;
 547             int len;
 548
 549             /* provider specific property is always VT_BSTR */
 550             len = SysStringLen(pair->name) + SysStringLen(pair->value) + 1 /* for '=' */;
 551             str = SysAllocStringLen(NULL, len);
 552             lstrcpyW(str, pair->name);
 553             lstrcatW(str, L"=");
 554             lstrcatW(str, pair->value);
 555
 556             (*propset)->cProperties++;
 557             (*propset)->guidPropertySet = DBPROPSET_DBINIT;
 558             (*propset)->rgProperties[i].dwPropertyID = DBPROP_INIT_PROVIDERSTRING;
 559             (*propset)->rgProperties[i].dwOptions = DBPROPOPTIONS_REQUIRED;
 560             (*propset)->rgProperties[i].dwStatus = 0;
 561             memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
 562             V_VT(&(*propset)->rgProperties[i].vValue) = VT_BSTR;
 563             V_BSTR(&(*propset)->rgProperties[i].vValue) = str;
 564             i++;
 565             continue;
 566         }
 567
 568         V_VT(&src) = VT_BSTR;
 569         V_BSTR(&src) = pair->value;
 570
 571         VariantInit(&dest);
 572         hr = VariantChangeType(&dest, &src, 0, descr->type);
 573         if (FAILED(hr) && descr->convert_dbproperty)
 574             hr = descr->convert_dbproperty(pair->value, &dest);
 575
 576         if (FAILED(hr))
 577         {
 578             ERR("failed to init property %s value as type %d\n", debugstr_w(pair->name), descr->type);
 579             free_dbpropset(1, *propset);
 580             *propset = NULL;
 581             return hr;
 582         }
 583
 584         (*propset)->cProperties++;
 585         (*propset)->guidPropertySet = DBPROPSET_DBINIT;
 586         (*propset)->rgProperties[i].dwPropertyID = descr->id;
 587         (*propset)->rgProperties[i].dwOptions = descr->options;
 588         (*propset)->rgProperties[i].dwStatus = 0;
 589         memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
 590         (*propset)->rgProperties[i].vValue = dest;
 591         i++;
 592     }
 593
 594     return S_OK;
 595 }
 596
 597 /*** IDataInitialize methods ***/
 598 static void datasource_release(BOOL created, IUnknown **datasource)
 599 {
 600     if (!created)
 601         return;
 602
 603     IUnknown_Release(*datasource);
 604     *datasource = NULL;
 605 }
 606
 607 static inline WCHAR *strdupW(const WCHAR *src)
 608 {
 609     WCHAR *dest;
 610     if (!src) return NULL;
 611     dest = heap_alloc((lstrlenW(src)+1)*sizeof(WCHAR));
 612     if (dest)
 613         lstrcpyW(dest, src);
 614     return dest;
 615 }
 616
 617 static WCHAR *strstriW(const WCHAR *str, const WCHAR *sub)
 618 {
 619     LPWSTR strlower, sublower, r;
 620     strlower = CharLowerW(strdupW(str));
 621     sublower = CharLowerW(strdupW(sub));
 622     r = wcsstr(strlower, sublower);
 623     if (r)
 624         r = (LPWSTR)str + (r - strlower);
 625     heap_free(strlower);
 626     heap_free(sublower);
 627     return r;
 628 }
 629
 630 HRESULT get_data_source(IUnknown *outer, DWORD clsctx, LPWSTR initstring, REFIID riid, IUnknown **datasource)
 631 {
 632     static const WCHAR providerW[] = L"Provider=";
 633     BOOL datasource_created = FALSE;
 634     IDBProperties *dbprops;
 635     DBPROPSET *propset;
 636     WCHAR *prov = NULL;
 637     CLSID provclsid;
 638     HRESULT hr;
 639
 640
 641     /* first get provider name */
 642     provclsid = IID_NULL;
 643     if (initstring && (prov = strstriW(initstring, providerW)))
 644     {
 645         WCHAR *start, *progid;
 646         int len;
 647
 648         prov += ARRAY_SIZE(providerW)-1;
 649         start = prov;
 650         while (*prov && *prov != ';')
 651             ++prov;
 652         TRACE("got provider %s\n", debugstr_wn(start, prov-start));
 653
 654         len = prov - start;
 655         progid = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
 656         if (!progid) return E_OUTOFMEMORY;
 657
 658         memcpy(progid, start, len*sizeof(WCHAR));
 659         progid[len] = 0;
 660
 661         hr = CLSIDFromProgID(progid, &provclsid);
 662         CoTaskMemFree(progid);
 663         if (FAILED(hr))
 664         {
 665             ERR("provider %s not registered\n", debugstr_wn(start, prov-start));
 666             return hr;
 667         }
 668     }
 669     else
 670     {
 671         hr = CLSIDFromProgID(L"MSDASQL", &provclsid);
 672         if (FAILED(hr))
 673             ERR("ODBC provider for OLE DB not registered\n");
 674     }
 675
 676     /* check for provider mismatch if it was specified in init string */
 677     if (*datasource && prov)
 678     {
 679         DBPROPIDSET propidset;
 680         DWORD prop;
 681         CLSID initprov;
 682         ULONG count;
 683
 684         hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
 685         if (FAILED(hr))
 686         {
 687             WARN("provider doesn't support IDBProperties\n");
 688             return hr;
 689         }
 690
 691         prop = DBPROP_INIT_DATASOURCE;
 692         propidset.rgPropertyIDs = &prop;
 693         propidset.cPropertyIDs = 1;
 694         propidset.guidPropertySet = DBPROPSET_DBINIT;
 695         count = 0;
 696         propset = NULL;
 697         hr = IDBProperties_GetProperties(dbprops, 1, &propidset, &count, &propset);
 698         IDBProperties_Release(dbprops);
 699         if (FAILED(hr))
 700         {
 701             WARN("GetProperties failed for datasource, 0x%08lx\n", hr);
 702             return hr;
 703         }
 704
 705         TRACE("initial data source provider %s\n", debugstr_w(V_BSTR(&propset->rgProperties[0].vValue)));
 706         initprov = IID_NULL;
 707         hr = CLSIDFromProgID(V_BSTR(&propset->rgProperties[0].vValue), &initprov);
 708         free_dbpropset(count, propset);
 709
 710         if (FAILED(hr) || !IsEqualIID(&provclsid, &initprov)) return DB_E_MISMATCHEDPROVIDER;
 711     }
 712
 713     if (!*datasource)
 714     {
 715         if (!IsEqualIID(&provclsid, &IID_NULL))
 716             hr = CoCreateInstance(&provclsid, outer, clsctx, riid, (void**)datasource);
 717
 718         if (FAILED(hr) && IsEqualIID(riid, &IID_IDBInitialize))
 719             hr = create_db_init(datasource);
 720
 721         datasource_created = *datasource != NULL;
 722     }
 723
 724     /* now set properties */
 725     if (initstring)
 726     {
 727         struct dbprops props;
 728
 729         hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
 730         if (FAILED(hr))
 731         {
 732             ERR("provider doesn't support IDBProperties\n");
 733             datasource_release(datasource_created, datasource);
 734             return hr;
 735         }
 736
 737         hr = parse_init_string(initstring, &props);
 738         if (FAILED(hr))
 739         {
 740             datasource_release(datasource_created, datasource);
 741             return hr;
 742         }
 743
 744         hr = get_dbpropset_from_proplist(&props, &propset);
 745         free_dbprop_list(&props);
 746         if (FAILED(hr))
 747         {
 748             datasource_release(datasource_created, datasource);
 749             return hr;
 750         }
 751
 752         hr = IDBProperties_SetProperties(dbprops, 1, propset);
 753         IDBProperties_Release(dbprops);
 754         free_dbpropset(1, propset);
 755         if (FAILED(hr))
 756         {
 757             ERR("SetProperties failed, 0x%08lx\n", hr);
 758             datasource_release(datasource_created, datasource);
 759             return hr;
 760         }
 761     }
 762
 763     return hr;
 764 }
 765
 766 static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *outer, DWORD clsctx,
 767                                 LPWSTR initstring, REFIID riid, IUnknown **datasource)
 768 {
 769     datainit *This = impl_from_IDataInitialize(iface);
 770
 771     TRACE("(%p)->(%p 0x%lx %s %s %p)\n", This, outer, clsctx, debugstr_w(initstring), debugstr_guid(riid), datasource);
 772
 773     return get_data_source(outer, clsctx, initstring, riid, datasource);
 774 }
 775
 776 /* returns character length of string representation */
 777 static int get_propvalue_length(DBPROP *prop)
 778 {
 779     VARIANT str;
 780     HRESULT hr;
 781
 782     if (V_VT(&prop->vValue) == VT_BSTR) return SysStringLen(V_BSTR(&prop->vValue));
 783
 784     VariantInit(&str);
 785     hr = VariantChangeType(&str, &prop->vValue, 0, VT_BSTR);
 786     if (hr == S_OK)
 787     {
 788         int len = SysStringLen(V_BSTR(&str));
 789         VariantClear(&str);
 790         return len;
 791     }
 792
 793     return 0;
 794 }
 795
 796 static void write_propvalue_str(WCHAR *str, DBPROP *prop)
 797 {
 798     VARIANT *v = &prop->vValue;
 799     VARIANT vstr;
 800     HRESULT hr;
 801
 802     if (V_VT(v) == VT_BSTR)
 803     {
 804         lstrcatW(str, V_BSTR(v));
 805         return;
 806     }
 807
 808     VariantInit(&vstr);
 809     hr = VariantChangeType(&vstr, v, VARIANT_ALPHABOOL, VT_BSTR);
 810     if (hr == S_OK)
 811     {
 812         lstrcatW(str, V_BSTR(&vstr));
 813         VariantClear(&vstr);
 814     }
 815 }
 816
 817 static WCHAR *get_propinfo_descr(DBPROP *prop, DBPROPINFOSET *propinfoset)
 818 {
 819     ULONG i;
 820
 821     for (i = 0; i < propinfoset->cPropertyInfos; i++)
 822         if (propinfoset->rgPropertyInfos[i].dwPropertyID == prop->dwPropertyID)
 823             return propinfoset->rgPropertyInfos[i].pwszDescription;
 824
 825     return NULL;
 826 }
 827
 828 static void free_dbpropinfoset(ULONG count, DBPROPINFOSET *propinfoset)
 829 {
 830     ULONG i;
 831
 832     for (i = 0; i < count; i++)
 833     {
 834         ULONG p;
 835
 836         for (p = 0; p < propinfoset[i].cPropertyInfos; p++)
 837             VariantClear(&propinfoset[i].rgPropertyInfos[p].vValues);
 838
 839         CoTaskMemFree(propinfoset[i].rgPropertyInfos);
 840     }
 841     CoTaskMemFree(propinfoset);
 842 }
 843
 844 static HRESULT WINAPI datainit_GetInitializationString(IDataInitialize *iface, IUnknown *datasource,
 845                                 boolean include_pass, LPWSTR *init_string)
 846 {
 847     static const WCHAR providerW[] = L"Provider=";
 848     datainit *This = impl_from_IDataInitialize(iface);
 849     DBPROPINFOSET *propinfoset;
 850     IDBProperties *props;
 851     DBPROPIDSET propidset;
 852     ULONG count, infocount;
 853     WCHAR *progid, *desc;
 854     DBPROPSET *propset;
 855     IPersist *persist;
 856     HRESULT hr;
 857     CLSID clsid;
 858     ULONG i, len;
 859
 860     TRACE("(%p)->(%p %d %p)\n", This, datasource, include_pass, init_string);
 861
 862     /* IPersist support is mandatory for data sources */
 863     hr = IUnknown_QueryInterface(datasource, &IID_IPersist, (void**)&persist);
 864     if (FAILED(hr)) return hr;
 865
 866     memset(&clsid, 0, sizeof(clsid));
 867     hr = IPersist_GetClassID(persist, &clsid);
 868     IPersist_Release(persist);
 869     if (FAILED(hr)) return hr;
 870
 871     progid = NULL;
 872     ProgIDFromCLSID(&clsid, &progid);
 873     TRACE("clsid=%s, progid=%s\n", debugstr_guid(&clsid), debugstr_w(progid));
 874
 875     /* now get initialization properties */
 876     hr = IUnknown_QueryInterface(datasource, &IID_IDBProperties, (void**)&props);
 877     if (FAILED(hr))
 878     {
 879         WARN("IDBProperties not supported\n");
 880         CoTaskMemFree(progid);
 881         return hr;
 882     }
 883
 884     propidset.rgPropertyIDs = NULL;
 885     propidset.cPropertyIDs = 0;
 886     propidset.guidPropertySet = DBPROPSET_DBINIT;
 887     propset = NULL;
 888     count = 0;
 889     hr = IDBProperties_GetProperties(props, 1, &propidset, &count, &propset);
 890     if (FAILED(hr))
 891     {
 892         WARN("failed to get data source properties, 0x%08lx\n", hr);
 893         CoTaskMemFree(progid);
 894         return hr;
 895     }
 896
 897     infocount = 0;
 898     IDBProperties_GetPropertyInfo(props, 1, &propidset, &infocount, &propinfoset, &desc);
 899     IDBProperties_Release(props);
 900
 901     /* check if we need to skip password */
 902     len = lstrlenW(progid) + lstrlenW(providerW) + 1; /* including ';' */
 903     for (i = 0; i < count; i++)
 904     {
 905         WCHAR *descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
 906         if (descr)
 907         {
 908             /* include '=' and ';' */
 909             len += lstrlenW(descr) + 2;
 910             len += get_propvalue_length(&propset->rgProperties[i]);
 911         }
 912
 913         if ((propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO) &&
 914             (V_BOOL(&propset->rgProperties[i].vValue) == VARIANT_FALSE))
 915            include_pass = FALSE;
 916     }
 917
 918     len *= sizeof(WCHAR);
 919     *init_string = CoTaskMemAlloc(len);
 920     *init_string[0] = 0;
 921
 922     /* provider name */
 923     lstrcatW(*init_string, providerW);
 924     lstrcatW(*init_string, progid);
 925     lstrcatW(*init_string, L";");
 926     CoTaskMemFree(progid);
 927
 928     for (i = 0; i < count; i++)
 929     {
 930         WCHAR *descr;
 931
 932         if (!include_pass && propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PASSWORD) continue;
 933
 934         descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
 935         if (descr)
 936         {
 937             lstrcatW(*init_string, descr);
 938             lstrcatW(*init_string, L"=");
 939             write_propvalue_str(*init_string, &propset->rgProperties[i]);
 940             lstrcatW(*init_string, L";");
 941         }
 942     }
 943
 944     free_dbpropset(count, propset);
 945     free_dbpropinfoset(infocount, propinfoset);
 946     CoTaskMemFree(desc);
 947
 948     if (!include_pass)
 949         TRACE("%s\n", debugstr_w(*init_string));
 950     return S_OK;
 951 }
 952
 953 static HRESULT WINAPI datainit_CreateDBInstance(IDataInitialize *iface, REFCLSID provider,
 954                                 IUnknown *outer, DWORD clsctx, LPWSTR reserved, REFIID riid,
 955                                 IUnknown **datasource)
 956 {
 957     datainit *This = impl_from_IDataInitialize(iface);
 958
 959     TRACE("(%p)->(%s %p 0x%08lx %s %s %p)\n", This, debugstr_guid(provider), outer, clsctx, debugstr_w(reserved),
 960         debugstr_guid(riid), datasource);
 961
 962     return CoCreateInstance(provider, outer, clsctx, riid, (void**)datasource);
 963 }
 964
 965 static HRESULT WINAPI datainit_CreateDBInstanceEx(IDataInitialize *iface, REFCLSID provider, IUnknown *outer,
 966     DWORD clsctx, LPWSTR reserved, COSERVERINFO *server_info, DWORD cmq, MULTI_QI *results)
 967 {
 968     datainit *This = impl_from_IDataInitialize(iface);
 969
 970     FIXME("(%p)->(%s %p %#lx %s %p %lu %p)\n", This, debugstr_guid(provider), outer, clsctx,
 971         debugstr_w(reserved), server_info, cmq, results);
 972
 973     return E_NOTIMPL;
 974 }
 975
 976 static HRESULT WINAPI datainit_LoadStringFromStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 977                                 LPWSTR *ppwszInitializationString)
 978 {
 979     datainit *This = impl_from_IDataInitialize(iface);
 980
 981     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwszFileName), ppwszInitializationString);
 982
 983     return E_NOTIMPL;
 984 }
 985
 986 static HRESULT WINAPI datainit_WriteStringToStorage(IDataInitialize *iface, LPWSTR pwszFileName,
 987                                 LPWSTR pwszInitializationString, DWORD dwCreationDisposition)
 988 {
 989     datainit *This = impl_from_IDataInitialize(iface);
 990
 991     FIXME("(%p)->(%s %s %ld)\n", This, debugstr_w(pwszFileName), debugstr_w(pwszInitializationString), dwCreationDisposition);
 992
 993     return E_NOTIMPL;
 994 }
 995
 996
 997 static const struct IDataInitializeVtbl datainit_vtbl =
 998 {
 999     datainit_QueryInterface,
1000     datainit_AddRef,
1001     datainit_Release,
1002     datainit_GetDataSource,
1003     datainit_GetInitializationString,
1004     datainit_CreateDBInstance,
1005     datainit_CreateDBInstanceEx,
1006     datainit_LoadStringFromStorage,
1007     datainit_WriteStringToStorage
1008 };
1009
1010 HRESULT create_data_init(IUnknown *outer, void **obj)
1011 {
1012     datainit *This;
1013
1014     TRACE("(%p)\n", obj);
1015
1016     if(outer) return CLASS_E_NOAGGREGATION;
1017
1018     *obj = NULL;
1019
1020     This = heap_alloc(sizeof(*This));
1021     if(!This) return E_OUTOFMEMORY;
1022
1023     This->IDataInitialize_iface.lpVtbl = &datainit_vtbl;
1024     This->ref = 1;
1025
1026     *obj = &This->IDataInitialize_iface;
1027
1028     return S_OK;
1029 }