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