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