mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-01 19:33:38 +00:00
![Nikolay Sivov](/assets/img/avatar_default.png)
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com> Signed-off-by: Alexandre Julliard <julliard@winehq.org>
1030 lines
31 KiB
C
1030 lines
31 KiB
C
/*
|
|
* Copyright (C) 2012 Alistair Leslie-Hughes
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
#include <stdarg.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winnls.h"
|
|
#include "ole2.h"
|
|
#include "msdasc.h"
|
|
#include "oledberr.h"
|
|
#include "initguid.h"
|
|
#include "oledb_private.h"
|
|
|
|
#include "wine/debug.h"
|
|
#include "wine/heap.h"
|
|
#include "wine/list.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(oledb);
|
|
|
|
DEFINE_GUID(DB_NULLGUID, 0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
|
|
DEFINE_GUID(DBGUID_SESSION, 0xc8b522f5, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBGUID_ROWSET, 0xc8b522f6, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBGUID_ROW, 0xc8b522f7, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBGUID_STREAM, 0xc8b522f9, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
|
|
DEFINE_GUID(DBPROPSET_COLUMN, 0xc8b522b9, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DATASOURCE, 0xc8b522ba, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DATASOURCEINFO, 0xc8b522bb, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DBINIT, 0xc8b522bc, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_INDEX, 0xc8b522bd, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_ROWSET, 0xc8b522be, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_TABLE, 0xc8b522bf, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DATASOURCEALL, 0xc8b522c0, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DATASOURCEINFOALL, 0xc8b522c1, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_ROWSETALL, 0xc8b522c2, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_SESSION, 0xc8b522c6, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_SESSIONALL, 0xc8b522c7, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_DBINITALL, 0xc8b522ca, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
DEFINE_GUID(DBPROPSET_PROPERTIESINERROR, 0xc8b522d4, 0x5cf3, 0x11ce, 0xad, 0xe5, 0x00, 0xaa, 0x00, 0x44, 0x77, 0x3d);
|
|
|
|
typedef struct datainit
|
|
{
|
|
IDataInitialize IDataInitialize_iface;
|
|
|
|
LONG ref;
|
|
} datainit;
|
|
|
|
static inline datainit *impl_from_IDataInitialize(IDataInitialize *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, datainit, IDataInitialize_iface);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
IDBInitialize IDBInitialize_iface;
|
|
IDBProperties IDBProperties_iface;
|
|
|
|
LONG ref;
|
|
} dbinit;
|
|
|
|
static inline dbinit *impl_from_IDBInitialize(IDBInitialize *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, dbinit, IDBInitialize_iface);
|
|
}
|
|
|
|
static inline dbinit *impl_from_IDBProperties(IDBProperties *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, dbinit, IDBProperties_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI dbprops_QueryInterface(IDBProperties *iface, REFIID riid, void **ppvObject)
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
return IDBInitialize_QueryInterface(&This->IDBInitialize_iface, riid, ppvObject);
|
|
}
|
|
|
|
static ULONG WINAPI dbprops_AddRef(IDBProperties *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
return IDBInitialize_AddRef(&This->IDBInitialize_iface);
|
|
}
|
|
|
|
static ULONG WINAPI dbprops_Release(IDBProperties *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
return IDBInitialize_Release(&This->IDBInitialize_iface);
|
|
}
|
|
|
|
static HRESULT WINAPI dbprops_GetProperties(IDBProperties *iface, ULONG cPropertyIDSets,
|
|
const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertySets, DBPROPSET **prgPropertySets)
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
FIXME("(%p)->(%d %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertySets, prgPropertySets);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dbprops_GetPropertyInfo(IDBProperties *iface, ULONG cPropertyIDSets,
|
|
const DBPROPIDSET rgPropertyIDSets[], ULONG *pcPropertyInfoSets,
|
|
DBPROPINFOSET **prgPropertyInfoSets, OLECHAR **ppDescBuffer)
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
FIXME("(%p)->(%d %p %p %p %p)\n", This, cPropertyIDSets, rgPropertyIDSets, pcPropertyInfoSets,
|
|
prgPropertyInfoSets, ppDescBuffer);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI dbprops_SetProperties(IDBProperties *iface, ULONG cPropertySets,
|
|
DBPROPSET rgPropertySets[])
|
|
{
|
|
dbinit *This = impl_from_IDBProperties(iface);
|
|
|
|
FIXME("(%p)->(%d %p)\n", This, cPropertySets, rgPropertySets);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const struct IDBPropertiesVtbl dbprops_vtbl =
|
|
{
|
|
dbprops_QueryInterface,
|
|
dbprops_AddRef,
|
|
dbprops_Release,
|
|
dbprops_GetProperties,
|
|
dbprops_GetPropertyInfo,
|
|
dbprops_SetProperties
|
|
};
|
|
|
|
static HRESULT WINAPI dbinit_QueryInterface(IDBInitialize *iface, REFIID riid, void **obj)
|
|
{
|
|
dbinit *This = impl_from_IDBInitialize(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
|
|
|
|
*obj = NULL;
|
|
|
|
if(IsEqualIID(riid, &IID_IUnknown) ||
|
|
IsEqualIID(riid, &IID_IDBInitialize))
|
|
{
|
|
*obj = iface;
|
|
}
|
|
else if(IsEqualIID(riid, &IID_IDBProperties))
|
|
{
|
|
*obj = &This->IDBProperties_iface;
|
|
}
|
|
else
|
|
{
|
|
FIXME("interface %s not implemented\n", debugstr_guid(riid));
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IDBInitialize_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI dbinit_AddRef(IDBInitialize *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBInitialize(iface);
|
|
TRACE("(%p)\n", This);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI dbinit_Release(IDBInitialize *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBInitialize(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
heap_free(This);
|
|
|
|
return ref;
|
|
}
|
|
|
|
static HRESULT WINAPI dbinit_Initialize(IDBInitialize *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBInitialize(iface);
|
|
|
|
FIXME("(%p) stub\n", This);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI dbinit_Uninitialize(IDBInitialize *iface)
|
|
{
|
|
dbinit *This = impl_from_IDBInitialize(iface);
|
|
|
|
FIXME("(%p) stub\n", This);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static const IDBInitializeVtbl dbinit_vtbl =
|
|
{
|
|
dbinit_QueryInterface,
|
|
dbinit_AddRef,
|
|
dbinit_Release,
|
|
dbinit_Initialize,
|
|
dbinit_Uninitialize
|
|
};
|
|
|
|
static HRESULT create_db_init(IUnknown **obj)
|
|
{
|
|
dbinit *This;
|
|
|
|
TRACE("()\n");
|
|
|
|
*obj = NULL;
|
|
|
|
This = heap_alloc(sizeof(*This));
|
|
if(!This) return E_OUTOFMEMORY;
|
|
|
|
This->IDBInitialize_iface.lpVtbl = &dbinit_vtbl;
|
|
This->IDBProperties_iface.lpVtbl = &dbprops_vtbl;
|
|
This->ref = 1;
|
|
|
|
*obj = (IUnknown*)&This->IDBInitialize_iface;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_QueryInterface(IDataInitialize *iface, REFIID riid, void **obj)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
|
|
|
|
*obj = NULL;
|
|
|
|
if(IsEqualIID(riid, &IID_IUnknown) ||
|
|
IsEqualIID(riid, &IID_IDataInitialize))
|
|
{
|
|
*obj = &This->IDataInitialize_iface;
|
|
}
|
|
else
|
|
{
|
|
FIXME("interface %s not implemented\n", debugstr_guid(riid));
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
IDataInitialize_AddRef(iface);
|
|
return S_OK;
|
|
}
|
|
|
|
static ULONG WINAPI datainit_AddRef(IDataInitialize *iface)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
TRACE("(%p)\n", This);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI datainit_Release(IDataInitialize *iface)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
LONG ref;
|
|
|
|
TRACE("(%p)\n", This);
|
|
|
|
ref = InterlockedDecrement(&This->ref);
|
|
if(ref == 0)
|
|
heap_free(This);
|
|
|
|
return ref;
|
|
}
|
|
|
|
static void free_dbpropset(ULONG count, DBPROPSET *propset)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
ULONG p;
|
|
|
|
for (p = 0; p < propset[i].cProperties; p++)
|
|
VariantClear(&propset[i].rgProperties[p].vValue);
|
|
|
|
CoTaskMemFree(propset[i].rgProperties);
|
|
}
|
|
CoTaskMemFree(propset);
|
|
}
|
|
|
|
struct dbproperty {
|
|
const WCHAR *name;
|
|
DBPROPID id;
|
|
DBPROPOPTIONS options;
|
|
VARTYPE type;
|
|
HRESULT (*convert_dbproperty)(const WCHAR *src, VARIANT *dest);
|
|
};
|
|
|
|
struct mode_propval
|
|
{
|
|
const WCHAR *name;
|
|
DWORD value;
|
|
};
|
|
|
|
static int __cdecl dbmodeprop_compare(const void *a, const void *b)
|
|
{
|
|
const WCHAR *src = a;
|
|
const struct mode_propval *propval = b;
|
|
return wcsicmp(src, propval->name);
|
|
}
|
|
|
|
static HRESULT convert_dbproperty_mode(const WCHAR *src, VARIANT *dest)
|
|
{
|
|
static const struct mode_propval mode_propvals[] =
|
|
{
|
|
{ L"Read", DB_MODE_READ },
|
|
{ L"ReadWrite", DB_MODE_READWRITE },
|
|
{ L"Share Deny None", DB_MODE_SHARE_DENY_NONE },
|
|
{ L"Share Deny Read", DB_MODE_SHARE_DENY_READ },
|
|
{ L"Share Deny Write", DB_MODE_SHARE_DENY_WRITE },
|
|
{ L"Share Exclusive", DB_MODE_SHARE_EXCLUSIVE },
|
|
{ L"Write", DB_MODE_WRITE },
|
|
};
|
|
struct mode_propval *prop;
|
|
|
|
if ((prop = bsearch(src, mode_propvals, ARRAY_SIZE(mode_propvals),
|
|
sizeof(struct mode_propval), dbmodeprop_compare)))
|
|
{
|
|
V_VT(dest) = VT_I4;
|
|
V_I4(dest) = prop->value;
|
|
TRACE("%s = %#x\n", debugstr_w(src), prop->value);
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
static const struct dbproperty dbproperties[] =
|
|
{
|
|
{ L"Asynchronous Processing", DBPROP_INIT_ASYNCH, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Bind Flags", DBPROP_INIT_BINDFLAGS, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Cache Authentication", DBPROP_AUTH_CACHE_AUTHINFO, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
|
|
{ L"Connect Timeout", DBPROP_INIT_TIMEOUT, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Data Source", DBPROP_INIT_DATASOURCE, DBPROPOPTIONS_REQUIRED, VT_BSTR },
|
|
{ L"Extended Properties", DBPROP_INIT_PROVIDERSTRING, DBPROPOPTIONS_REQUIRED, VT_BSTR },
|
|
{ L"Encrypt Password", DBPROP_AUTH_ENCRYPT_PASSWORD, DBPROPOPTIONS_REQUIRED, VT_BOOL },
|
|
{ L"General Timeout", DBPROP_INIT_GENERALTIMEOUT, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Impersonation Level", DBPROP_INIT_IMPERSONATION_LEVEL, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Initial Catalog", DBPROP_CATALOGLOCATION, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
{ L"Integrated Security", DBPROP_AUTH_INTEGRATED, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
{ L"Locale Identifier", DBPROP_INIT_LCID, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Location", DBPROP_INIT_LOCATION, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
{ L"Lock Owner", DBPROP_INIT_LOCKOWNER, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
{ L"Mask Password", DBPROP_AUTH_MASK_PASSWORD, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
|
|
{ L"Mode", DBPROP_INIT_MODE, DBPROPOPTIONS_OPTIONAL, VT_I4, convert_dbproperty_mode },
|
|
{ L"OLE DB Services", DBPROP_INIT_OLEDBSERVICES, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"Password", DBPROP_AUTH_PASSWORD, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
{ L"Persist Encrypted", DBPROP_AUTH_PERSIST_ENCRYPTED, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
|
|
{ L"Persist Security Info", DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO, DBPROPOPTIONS_OPTIONAL, VT_BOOL },
|
|
{ L"Prompt", DBPROP_INIT_PROMPT, DBPROPOPTIONS_OPTIONAL, VT_I2 },
|
|
{ L"Protection level", DBPROP_INIT_PROTECTION_LEVEL, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
{ L"User ID", DBPROP_AUTH_USERID, DBPROPOPTIONS_OPTIONAL, VT_BSTR },
|
|
#ifndef _WIN64
|
|
{ L"Window Handle", DBPROP_INIT_HWND, DBPROPOPTIONS_OPTIONAL, VT_I4 },
|
|
#else
|
|
{ L"Window Handle", DBPROP_INIT_HWND, DBPROPOPTIONS_OPTIONAL, VT_I8 },
|
|
#endif
|
|
};
|
|
|
|
struct dbprop_pair
|
|
{
|
|
struct list entry;
|
|
BSTR name;
|
|
BSTR value;
|
|
};
|
|
|
|
struct dbprops
|
|
{
|
|
struct list props;
|
|
unsigned int count;
|
|
};
|
|
|
|
/* name/value strings are reused, so they shouldn't be freed after this call */
|
|
static HRESULT add_dbprop_to_list(struct dbprops *props, BSTR name, BSTR value)
|
|
{
|
|
struct dbprop_pair *pair;
|
|
|
|
pair = heap_alloc(sizeof(*pair));
|
|
if (!pair)
|
|
return E_OUTOFMEMORY;
|
|
|
|
pair->name = name;
|
|
pair->value = value;
|
|
list_add_tail(&props->props, &pair->entry);
|
|
props->count++;
|
|
return S_OK;
|
|
}
|
|
|
|
static void free_dbprop_list(struct dbprops *props)
|
|
{
|
|
struct dbprop_pair *p, *p2;
|
|
LIST_FOR_EACH_ENTRY_SAFE(p, p2, &props->props, struct dbprop_pair, entry)
|
|
{
|
|
list_remove(&p->entry);
|
|
SysFreeString(p->name);
|
|
SysFreeString(p->value);
|
|
heap_free(p);
|
|
}
|
|
}
|
|
|
|
static HRESULT parse_init_string(const WCHAR *initstring, struct dbprops *props)
|
|
{
|
|
const WCHAR *start;
|
|
WCHAR *eq;
|
|
HRESULT hr = S_OK;
|
|
|
|
list_init(&props->props);
|
|
props->count = 0;
|
|
|
|
start = initstring;
|
|
while (start && (eq = wcschr(start, '=')))
|
|
{
|
|
WCHAR *delim, quote;
|
|
BSTR value, name;
|
|
|
|
name = SysAllocStringLen(start, eq - start);
|
|
/* skip equal sign to get value */
|
|
eq++;
|
|
|
|
quote = (*eq == '"' || *eq == '\'') ? *eq : 0;
|
|
if (quote)
|
|
{
|
|
/* for quoted value string, skip opening mark, look for terminating one */
|
|
eq++;
|
|
delim = wcschr(eq, quote);
|
|
}
|
|
else
|
|
delim = wcschr(eq, ';');
|
|
|
|
if (delim)
|
|
value = SysAllocStringLen(eq, delim - eq);
|
|
else
|
|
value = SysAllocString(eq);
|
|
|
|
/* skip semicolon if present */
|
|
if (delim)
|
|
{
|
|
if (*delim == quote)
|
|
delim++;
|
|
if (*delim == ';')
|
|
delim++;
|
|
}
|
|
start = delim;
|
|
|
|
if (!wcsicmp(name, L"Provider"))
|
|
{
|
|
SysFreeString(name);
|
|
SysFreeString(value);
|
|
continue;
|
|
}
|
|
|
|
TRACE("property (name=%s, value=%s)\n", debugstr_w(name), debugstr_w(value));
|
|
|
|
hr = add_dbprop_to_list(props, name, value);
|
|
if (FAILED(hr))
|
|
{
|
|
SysFreeString(name);
|
|
SysFreeString(value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
free_dbprop_list(props);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static const struct dbproperty *get_known_dprop_descr(BSTR name)
|
|
{
|
|
int min, max, n;
|
|
|
|
min = 0;
|
|
max = ARRAY_SIZE(dbproperties) - 1;
|
|
|
|
while (min <= max)
|
|
{
|
|
int r;
|
|
|
|
n = (min+max)/2;
|
|
|
|
r = wcsicmp(dbproperties[n].name, name);
|
|
if (!r)
|
|
break;
|
|
|
|
if (r < 0)
|
|
min = n+1;
|
|
else
|
|
max = n-1;
|
|
}
|
|
|
|
return (min <= max) ? &dbproperties[n] : NULL;
|
|
}
|
|
|
|
static HRESULT get_dbpropset_from_proplist(struct dbprops *props, DBPROPSET **propset)
|
|
{
|
|
struct dbprop_pair *pair;
|
|
int i = 0;
|
|
HRESULT hr;
|
|
|
|
*propset = CoTaskMemAlloc(sizeof(DBPROPSET));
|
|
if (!*propset)
|
|
return E_OUTOFMEMORY;
|
|
|
|
(*propset)->rgProperties = CoTaskMemAlloc(props->count*sizeof(DBPROP));
|
|
if (!(*propset)->rgProperties)
|
|
{
|
|
CoTaskMemFree(*propset);
|
|
*propset = NULL;
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
(*propset)->cProperties = 0;
|
|
LIST_FOR_EACH_ENTRY(pair, &props->props, struct dbprop_pair, entry)
|
|
{
|
|
const struct dbproperty *descr = get_known_dprop_descr(pair->name);
|
|
VARIANT dest, src;
|
|
|
|
if (!descr)
|
|
{
|
|
BSTR str;
|
|
int len;
|
|
|
|
/* provider specific property is always VT_BSTR */
|
|
len = SysStringLen(pair->name) + SysStringLen(pair->value) + 1 /* for '=' */;
|
|
str = SysAllocStringLen(NULL, len);
|
|
lstrcpyW(str, pair->name);
|
|
lstrcatW(str, L"=");
|
|
lstrcatW(str, pair->value);
|
|
|
|
(*propset)->cProperties++;
|
|
(*propset)->guidPropertySet = DBPROPSET_DBINIT;
|
|
(*propset)->rgProperties[i].dwPropertyID = DBPROP_INIT_PROVIDERSTRING;
|
|
(*propset)->rgProperties[i].dwOptions = DBPROPOPTIONS_REQUIRED;
|
|
(*propset)->rgProperties[i].dwStatus = 0;
|
|
memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
|
|
V_VT(&(*propset)->rgProperties[i].vValue) = VT_BSTR;
|
|
V_BSTR(&(*propset)->rgProperties[i].vValue) = str;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
V_VT(&src) = VT_BSTR;
|
|
V_BSTR(&src) = pair->value;
|
|
|
|
VariantInit(&dest);
|
|
hr = VariantChangeType(&dest, &src, 0, descr->type);
|
|
if (FAILED(hr) && descr->convert_dbproperty)
|
|
hr = descr->convert_dbproperty(pair->value, &dest);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
ERR("failed to init property %s value as type %d\n", debugstr_w(pair->name), descr->type);
|
|
free_dbpropset(1, *propset);
|
|
*propset = NULL;
|
|
return hr;
|
|
}
|
|
|
|
(*propset)->cProperties++;
|
|
(*propset)->guidPropertySet = DBPROPSET_DBINIT;
|
|
(*propset)->rgProperties[i].dwPropertyID = descr->id;
|
|
(*propset)->rgProperties[i].dwOptions = descr->options;
|
|
(*propset)->rgProperties[i].dwStatus = 0;
|
|
memset(&(*propset)->rgProperties[i].colid, 0, sizeof(DBID));
|
|
(*propset)->rgProperties[i].vValue = dest;
|
|
i++;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
/*** IDataInitialize methods ***/
|
|
static void datasource_release(BOOL created, IUnknown **datasource)
|
|
{
|
|
if (!created)
|
|
return;
|
|
|
|
IUnknown_Release(*datasource);
|
|
*datasource = NULL;
|
|
}
|
|
|
|
static inline WCHAR *strdupW(const WCHAR *src)
|
|
{
|
|
WCHAR *dest;
|
|
if (!src) return NULL;
|
|
dest = heap_alloc((lstrlenW(src)+1)*sizeof(WCHAR));
|
|
if (dest)
|
|
lstrcpyW(dest, src);
|
|
return dest;
|
|
}
|
|
|
|
static WCHAR *strstriW(const WCHAR *str, const WCHAR *sub)
|
|
{
|
|
LPWSTR strlower, sublower, r;
|
|
strlower = CharLowerW(strdupW(str));
|
|
sublower = CharLowerW(strdupW(sub));
|
|
r = wcsstr(strlower, sublower);
|
|
if (r)
|
|
r = (LPWSTR)str + (r - strlower);
|
|
heap_free(strlower);
|
|
heap_free(sublower);
|
|
return r;
|
|
}
|
|
|
|
HRESULT get_data_source(IUnknown *outer, DWORD clsctx, LPWSTR initstring, REFIID riid, IUnknown **datasource)
|
|
{
|
|
static const WCHAR providerW[] = L"Provider=";
|
|
BOOL datasource_created = FALSE;
|
|
IDBProperties *dbprops;
|
|
DBPROPSET *propset;
|
|
WCHAR *prov = NULL;
|
|
CLSID provclsid;
|
|
HRESULT hr;
|
|
|
|
|
|
/* first get provider name */
|
|
provclsid = IID_NULL;
|
|
if (initstring && (prov = strstriW(initstring, providerW)))
|
|
{
|
|
WCHAR *start, *progid;
|
|
int len;
|
|
|
|
prov += ARRAY_SIZE(providerW)-1;
|
|
start = prov;
|
|
while (*prov && *prov != ';')
|
|
++prov;
|
|
TRACE("got provider %s\n", debugstr_wn(start, prov-start));
|
|
|
|
len = prov - start;
|
|
progid = CoTaskMemAlloc((len+1)*sizeof(WCHAR));
|
|
if (!progid) return E_OUTOFMEMORY;
|
|
|
|
memcpy(progid, start, len*sizeof(WCHAR));
|
|
progid[len] = 0;
|
|
|
|
hr = CLSIDFromProgID(progid, &provclsid);
|
|
CoTaskMemFree(progid);
|
|
if (FAILED(hr))
|
|
{
|
|
ERR("provider %s not registered\n", debugstr_wn(start, prov-start));
|
|
return hr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = CLSIDFromProgID(L"MSDASQL", &provclsid);
|
|
if (FAILED(hr))
|
|
ERR("ODBC provider for OLE DB not registered\n");
|
|
}
|
|
|
|
/* check for provider mismatch if it was specified in init string */
|
|
if (*datasource && prov)
|
|
{
|
|
DBPROPIDSET propidset;
|
|
enum DBPROPENUM prop;
|
|
CLSID initprov;
|
|
ULONG count;
|
|
|
|
hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("provider doesn't support IDBProperties\n");
|
|
return hr;
|
|
}
|
|
|
|
prop = DBPROP_INIT_DATASOURCE;
|
|
propidset.rgPropertyIDs = ∝
|
|
propidset.cPropertyIDs = 1;
|
|
propidset.guidPropertySet = DBPROPSET_DBINIT;
|
|
count = 0;
|
|
propset = NULL;
|
|
hr = IDBProperties_GetProperties(dbprops, 1, &propidset, &count, &propset);
|
|
IDBProperties_Release(dbprops);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("GetProperties failed for datasource, 0x%08x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
TRACE("initial data source provider %s\n", debugstr_w(V_BSTR(&propset->rgProperties[0].vValue)));
|
|
initprov = IID_NULL;
|
|
hr = CLSIDFromProgID(V_BSTR(&propset->rgProperties[0].vValue), &initprov);
|
|
free_dbpropset(count, propset);
|
|
|
|
if (FAILED(hr) || !IsEqualIID(&provclsid, &initprov)) return DB_E_MISMATCHEDPROVIDER;
|
|
}
|
|
|
|
if (!*datasource)
|
|
{
|
|
if (!IsEqualIID(&provclsid, &IID_NULL))
|
|
hr = CoCreateInstance(&provclsid, outer, clsctx, riid, (void**)datasource);
|
|
|
|
if (FAILED(hr) && IsEqualIID(riid, &IID_IDBInitialize))
|
|
hr = create_db_init(datasource);
|
|
|
|
datasource_created = *datasource != NULL;
|
|
}
|
|
|
|
/* now set properties */
|
|
if (initstring)
|
|
{
|
|
struct dbprops props;
|
|
|
|
hr = IUnknown_QueryInterface(*datasource, &IID_IDBProperties, (void**)&dbprops);
|
|
if (FAILED(hr))
|
|
{
|
|
ERR("provider doesn't support IDBProperties\n");
|
|
datasource_release(datasource_created, datasource);
|
|
return hr;
|
|
}
|
|
|
|
hr = parse_init_string(initstring, &props);
|
|
if (FAILED(hr))
|
|
{
|
|
datasource_release(datasource_created, datasource);
|
|
return hr;
|
|
}
|
|
|
|
hr = get_dbpropset_from_proplist(&props, &propset);
|
|
free_dbprop_list(&props);
|
|
if (FAILED(hr))
|
|
{
|
|
datasource_release(datasource_created, datasource);
|
|
return hr;
|
|
}
|
|
|
|
hr = IDBProperties_SetProperties(dbprops, 1, propset);
|
|
IDBProperties_Release(dbprops);
|
|
free_dbpropset(1, propset);
|
|
if (FAILED(hr))
|
|
{
|
|
ERR("SetProperties failed, 0x%08x\n", hr);
|
|
datasource_release(datasource_created, datasource);
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_GetDataSource(IDataInitialize *iface, IUnknown *outer, DWORD clsctx,
|
|
LPWSTR initstring, REFIID riid, IUnknown **datasource)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
|
|
TRACE("(%p)->(%p 0x%x %s %s %p)\n", This, outer, clsctx, debugstr_w(initstring), debugstr_guid(riid), datasource);
|
|
|
|
return get_data_source(outer, clsctx, initstring, riid, datasource);
|
|
}
|
|
|
|
/* returns character length of string representation */
|
|
static int get_propvalue_length(DBPROP *prop)
|
|
{
|
|
VARIANT str;
|
|
HRESULT hr;
|
|
|
|
if (V_VT(&prop->vValue) == VT_BSTR) return SysStringLen(V_BSTR(&prop->vValue));
|
|
|
|
VariantInit(&str);
|
|
hr = VariantChangeType(&str, &prop->vValue, 0, VT_BSTR);
|
|
if (hr == S_OK)
|
|
{
|
|
int len = SysStringLen(V_BSTR(&str));
|
|
VariantClear(&str);
|
|
return len;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void write_propvalue_str(WCHAR *str, DBPROP *prop)
|
|
{
|
|
VARIANT *v = &prop->vValue;
|
|
VARIANT vstr;
|
|
HRESULT hr;
|
|
|
|
if (V_VT(v) == VT_BSTR)
|
|
{
|
|
lstrcatW(str, V_BSTR(v));
|
|
return;
|
|
}
|
|
|
|
VariantInit(&vstr);
|
|
hr = VariantChangeType(&vstr, v, VARIANT_ALPHABOOL, VT_BSTR);
|
|
if (hr == S_OK)
|
|
{
|
|
lstrcatW(str, V_BSTR(&vstr));
|
|
VariantClear(&vstr);
|
|
}
|
|
}
|
|
|
|
static WCHAR *get_propinfo_descr(DBPROP *prop, DBPROPINFOSET *propinfoset)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < propinfoset->cPropertyInfos; i++)
|
|
if (propinfoset->rgPropertyInfos[i].dwPropertyID == prop->dwPropertyID)
|
|
return propinfoset->rgPropertyInfos[i].pwszDescription;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void free_dbpropinfoset(ULONG count, DBPROPINFOSET *propinfoset)
|
|
{
|
|
ULONG i;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
ULONG p;
|
|
|
|
for (p = 0; p < propinfoset[i].cPropertyInfos; p++)
|
|
VariantClear(&propinfoset[i].rgPropertyInfos[p].vValues);
|
|
|
|
CoTaskMemFree(propinfoset[i].rgPropertyInfos);
|
|
}
|
|
CoTaskMemFree(propinfoset);
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_GetInitializationString(IDataInitialize *iface, IUnknown *datasource,
|
|
boolean include_pass, LPWSTR *init_string)
|
|
{
|
|
static const WCHAR providerW[] = L"Provider=";
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
DBPROPINFOSET *propinfoset;
|
|
IDBProperties *props;
|
|
DBPROPIDSET propidset;
|
|
ULONG count, infocount;
|
|
WCHAR *progid, *desc;
|
|
DBPROPSET *propset;
|
|
IPersist *persist;
|
|
HRESULT hr;
|
|
CLSID clsid;
|
|
ULONG i, len;
|
|
|
|
TRACE("(%p)->(%p %d %p)\n", This, datasource, include_pass, init_string);
|
|
|
|
/* IPersist support is mandatory for data sources */
|
|
hr = IUnknown_QueryInterface(datasource, &IID_IPersist, (void**)&persist);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
memset(&clsid, 0, sizeof(clsid));
|
|
hr = IPersist_GetClassID(persist, &clsid);
|
|
IPersist_Release(persist);
|
|
if (FAILED(hr)) return hr;
|
|
|
|
progid = NULL;
|
|
ProgIDFromCLSID(&clsid, &progid);
|
|
TRACE("clsid=%s, progid=%s\n", debugstr_guid(&clsid), debugstr_w(progid));
|
|
|
|
/* now get initialization properties */
|
|
hr = IUnknown_QueryInterface(datasource, &IID_IDBProperties, (void**)&props);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("IDBProperties not supported\n");
|
|
CoTaskMemFree(progid);
|
|
return hr;
|
|
}
|
|
|
|
propidset.rgPropertyIDs = NULL;
|
|
propidset.cPropertyIDs = 0;
|
|
propidset.guidPropertySet = DBPROPSET_DBINIT;
|
|
propset = NULL;
|
|
count = 0;
|
|
hr = IDBProperties_GetProperties(props, 1, &propidset, &count, &propset);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("failed to get data source properties, 0x%08x\n", hr);
|
|
CoTaskMemFree(progid);
|
|
return hr;
|
|
}
|
|
|
|
infocount = 0;
|
|
IDBProperties_GetPropertyInfo(props, 1, &propidset, &infocount, &propinfoset, &desc);
|
|
IDBProperties_Release(props);
|
|
|
|
/* check if we need to skip password */
|
|
len = lstrlenW(progid) + lstrlenW(providerW) + 1; /* including ';' */
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
WCHAR *descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
|
|
if (descr)
|
|
{
|
|
/* include '=' and ';' */
|
|
len += lstrlenW(descr) + 2;
|
|
len += get_propvalue_length(&propset->rgProperties[i]);
|
|
}
|
|
|
|
if ((propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PERSIST_SENSITIVE_AUTHINFO) &&
|
|
(V_BOOL(&propset->rgProperties[i].vValue) == VARIANT_FALSE))
|
|
include_pass = FALSE;
|
|
}
|
|
|
|
len *= sizeof(WCHAR);
|
|
*init_string = CoTaskMemAlloc(len);
|
|
*init_string[0] = 0;
|
|
|
|
/* provider name */
|
|
lstrcatW(*init_string, providerW);
|
|
lstrcatW(*init_string, progid);
|
|
lstrcatW(*init_string, L";");
|
|
CoTaskMemFree(progid);
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
WCHAR *descr;
|
|
|
|
if (!include_pass && propset->rgProperties[i].dwPropertyID == DBPROP_AUTH_PASSWORD) continue;
|
|
|
|
descr = get_propinfo_descr(&propset->rgProperties[i], propinfoset);
|
|
if (descr)
|
|
{
|
|
lstrcatW(*init_string, descr);
|
|
lstrcatW(*init_string, L"=");
|
|
write_propvalue_str(*init_string, &propset->rgProperties[i]);
|
|
lstrcatW(*init_string, L";");
|
|
}
|
|
}
|
|
|
|
free_dbpropset(count, propset);
|
|
free_dbpropinfoset(infocount, propinfoset);
|
|
CoTaskMemFree(desc);
|
|
|
|
if (!include_pass)
|
|
TRACE("%s\n", debugstr_w(*init_string));
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_CreateDBInstance(IDataInitialize *iface, REFCLSID provider,
|
|
IUnknown *outer, DWORD clsctx, LPWSTR reserved, REFIID riid,
|
|
IUnknown **datasource)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
|
|
TRACE("(%p)->(%s %p 0x%08x %s %s %p)\n", This, debugstr_guid(provider), outer, clsctx, debugstr_w(reserved),
|
|
debugstr_guid(riid), datasource);
|
|
|
|
return CoCreateInstance(provider, outer, clsctx, riid, (void**)datasource);
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_CreateDBInstanceEx(IDataInitialize *iface, REFCLSID provider, IUnknown *outer,
|
|
DWORD clsctx, LPWSTR reserved, COSERVERINFO *server_info, DWORD cmq, MULTI_QI *results)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
|
|
FIXME("(%p)->(%s %p %#x %s %p %u %p)\n", This, debugstr_guid(provider), outer, clsctx,
|
|
debugstr_w(reserved), server_info, cmq, results);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_LoadStringFromStorage(IDataInitialize *iface, LPWSTR pwszFileName,
|
|
LPWSTR *ppwszInitializationString)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
|
|
FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwszFileName), ppwszInitializationString);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI datainit_WriteStringToStorage(IDataInitialize *iface, LPWSTR pwszFileName,
|
|
LPWSTR pwszInitializationString, DWORD dwCreationDisposition)
|
|
{
|
|
datainit *This = impl_from_IDataInitialize(iface);
|
|
|
|
FIXME("(%p)->(%s %s %d)\n", This, debugstr_w(pwszFileName), debugstr_w(pwszInitializationString), dwCreationDisposition);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
|
|
static const struct IDataInitializeVtbl datainit_vtbl =
|
|
{
|
|
datainit_QueryInterface,
|
|
datainit_AddRef,
|
|
datainit_Release,
|
|
datainit_GetDataSource,
|
|
datainit_GetInitializationString,
|
|
datainit_CreateDBInstance,
|
|
datainit_CreateDBInstanceEx,
|
|
datainit_LoadStringFromStorage,
|
|
datainit_WriteStringToStorage
|
|
};
|
|
|
|
HRESULT create_data_init(IUnknown *outer, void **obj)
|
|
{
|
|
datainit *This;
|
|
|
|
TRACE("(%p)\n", obj);
|
|
|
|
if(outer) return CLASS_E_NOAGGREGATION;
|
|
|
|
*obj = NULL;
|
|
|
|
This = heap_alloc(sizeof(*This));
|
|
if(!This) return E_OUTOFMEMORY;
|
|
|
|
This->IDataInitialize_iface.lpVtbl = &datainit_vtbl;
|
|
This->ref = 1;
|
|
|
|
*obj = &This->IDataInitialize_iface;
|
|
|
|
return S_OK;
|
|
}
|