able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/adapters/oledb/utilprop.cpp

3781 lines
132 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Microsoft WMIOLE DB Provider
// (C) Copyright 1999 Microsoft Corporation. All Rights Reserved.
//
// Properties utility object implementation
//
//
// Notes - there are two main methods in this module:
// - CUtilProps::GetPropertyInfo, a helper function for IDBInfo::GetPropertyInfo
// - CUtilProps::GetProperties, a helper function for IRowsetInfo::GetProperties
//
// Our property implementation is simplified considerably by the fact that we
// only support reading\getting the properties, we do not support
// writing\setting them. This makes sense because we are a simple provider,
// and our rowset object always creates all the interfaces it exposes. In
// other words, there are really no properties the consumer could set.
//
// The implementation is very simple - we keep a global table of the
// properties we support in s_rgprop. We search this table sequentially.
//
// Note that a full-featured provider would probably need to use a more
// sophisticated implementation. We keep the entire GUID for each property in
// our struct, which would become a waste of space if we had a lot more
// properties. Similarly, with large numbers of properties some sort of
// hashing would be better than the sequential search used here.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include "headers.h"
#include "wmiver.h"
#define __TXT(x) L ## x
#define _TEXT_T(x) __TXT(x)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Struct containing the properties we know about. The GUID and string fields are
// initialized in the constructor, because C++ makes it awkward to do so at declaration
// time. So, if you change this table, be sure to make parallel changes in CUtilProp::CUtilProp.
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define PRIVILEGE_NAMESIZE 255
const GUID DBPROPSET_WMIOLEDB_DBINIT = {0xdd497a71,0x9628,0x11d3,{0x9d,0x5f,0x0,0xc0,0x4f,0x5f,0x11,0x64}};
const GUID DBPROPSET_WMIOLEDB_ROWSET = {0x8d16c220,0x9bbb,0x11d3,{0x9d,0x65,0x0,0xc0,0x4f,0x5f,0x11,0x64}};
const GUID DBPROPSET_WMIOLEDB_COLUMN = {0x3ed51791,0x9c76,0x11d3,{0x9d,0x66,0x0,0xc0,0x4f,0x5f,0x11,0x64}};
const GUID DBPROPSET_WMIOLEDB_COMMAND = {0xda0ff63c,0xad10,0x11d3,{0xb3,0xcb,0x0,0x10,0x4b,0xcc,0x48,0xc4}};
PROPSTRUCT s_rgprop[] =
{
/* 0*/ {DBPROP_INIT_DATASOURCE, FLAGS_DBINITRW, VT_BSTR, FALSE, 0, NULL, L"Data Source"},
/* 1*/ {DBPROP_INIT_HWND, FLAGS_DBINITRW, VT_I4, FALSE, 0, NULL, L"Window Handle"},
/* 2*/ {DBPROP_INIT_PROMPT, FLAGS_DBINITRW, VT_I2, FALSE, 4, NULL, L"Prompt"},
/* 3*/ {DBPROP_INIT_PROTECTION_LEVEL, FLAGS_DBINITRW, VT_I4, FALSE, DB_PROT_LEVEL_CONNECT, NULL, L"Protection Level"},
/* 4*/ {DBPROP_INIT_IMPERSONATION_LEVEL, FLAGS_DBINITRW, VT_I4, FALSE, DB_IMP_LEVEL_IMPERSONATE, NULL, L"Impersonation Level"},
/* 5*/ {DBPROP_INIT_MODE, FLAGS_DBINITRW, VT_I4, TRUE, DB_MODE_READWRITE, NULL, L"Mode"},
/* 6*/ {DBPROP_AUTH_USERID, FLAGS_DBINITRW, VT_BSTR, FALSE, 0, NULL, L"User ID"},
/* 7*/ {DBPROP_AUTH_PASSWORD, FLAGS_DBINITRW, VT_BSTR, FALSE, 0, NULL, L"Password"},
/* 8*/ {DBPROP_INIT_LCID, FLAGS_DBINITRW, VT_I4, FALSE, 0, NULL, L"Locale Identifier"},
/* 9*/ {DBPROP_WMIOLEDB_QUALIFIERS , FLAGS_DBINITRW , VT_I4, FALSE , 0,NULL, L"Qualifiers"},
/* 10*/ {DBPROP_WMIOLEDB_SYSTEMPROPERTIES , FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"System Properties"},
/* 11*/ {DBPROP_WMIOLEDB_AUTHORITY , FLAGS_DBINITRW , VT_BSTR, FALSE , 0,NULL, L"Authority"},
// security priveleges
/* 12*/ {DBPROP_WMIOLEDB_PREV_CREATE_TOKEN, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Create Token Privilege"},
/* 13*/ {DBPROP_WMIOLEDB_PREV_ASSIGNPRIMARYTOKEN, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Assign Primary Token Privilege"},
/* 14*/ {DBPROP_WMIOLEDB_PREV_LOCK_MEMORY, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Lock Memory Privilege"},
/* 15*/ {DBPROP_WMIOLEDB_PREV_INCREASE_QUOTA, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Increase Quota Privilege"},
/* 16*/ {DBPROP_WMIOLEDB_PREV_MACHINE_ACCOUNT, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Machine Account Privilege"},
/* 17*/ {DBPROP_WMIOLEDB_PREV_TCB, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Tcb Privilege"},
/* 18*/ {DBPROP_WMIOLEDB_PREV_SECURITY, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Security Privilege"},
/* 19*/ {DBPROP_WMIOLEDB_PREV_TAKE_OWNERSHIP, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Take Ownership Privilege"},
/* 20*/ {DBPROP_WMIOLEDB_PREV_LOAD_DRIVER, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Load Driver Privilege"},
/* 21*/ {DBPROP_WMIOLEDB_PREV_SYSTEM_PROFILE, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"System Profile Privilege"},
/* 22*/ {DBPROP_WMIOLEDB_PREV_SYSTEMTIME, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Systemtime Privilege"},
/* 23*/ {DBPROP_WMIOLEDB_PREV_PROF_SINGLE_PROCESS, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Profile SingleProcess Privilege"},
/* 24*/ {DBPROP_WMIOLEDB_PREV_INC_BASE_PRIORITY, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Increase BasePriority Privilege"},
/* 25*/ {DBPROP_WMIOLEDB_PREV_CREATE_PAGEFILE , FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Create Pagefile Privilege"},
/* 26*/ {DBPROP_WMIOLEDB_PREV_CREATE_PERMANENT , FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Create Permanent Privilege"},
/* 27*/ {DBPROP_WMIOLEDB_PREV_BACKUP, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Backup Privilege"},
/* 28*/ {DBPROP_WMIOLEDB_PREV_RESTORE, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Restore Privilege"},
/* 29*/ {DBPROP_WMIOLEDB_PREV_SHUTDOWN, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Shutdown Privilege"},
/* 30*/ {DBPROP_WMIOLEDB_PREV_DEBUG, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Debug Privilege"},
/* 31*/ {DBPROP_WMIOLEDB_PREV_AUDIT , FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Audit Privilege"},
/* 32*/ {DBPROP_WMIOLEDB_PREV_SYSTEM_ENVIRONMENT , FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"System Environment Privilege"},
/* 33*/ {DBPROP_WMIOLEDB_PREV_CHANGE_NOTIFY, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Change Notify Privilege"},
/* 34*/ {DBPROP_WMIOLEDB_PREV_REMOTE_SHUTDOWN, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Remote Shutdown Privilege"},
/* 35*/ {DBPROP_WMIOLEDB_PREV_UNDOCK, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Undock Privilege"},
/* 36*/ {DBPROP_WMIOLEDB_PREV_SYNC_AGENT, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"SyncAgent Privilege"},
/* 37*/ {DBPROP_WMIOLEDB_PREV_ENABLE_DELEGATION, FLAGS_DBINITRW , VT_BOOL, FALSE , 0,NULL, L"Enable Delegation Privilege"},
// Session properties should come here
// Data Source properties
/* 38*/ {DBPROP_ACTIVESESSIONS, FLAGS_DATASRCINF, VT_I4, FALSE, 1, NULL, L"Active Sessions"},
/* 39*/ {DBPROP_PERSISTENTIDTYPE, FLAGS_DATASRCINF, VT_I4, FALSE, DBPROPVAL_PT_GUID_PROPID, NULL, L"Persistent ID Type"},
/* 40*/ {DBPROP_PROVIDERFILENAME, FLAGS_DATASRCINF, VT_BSTR, FALSE, 0, L"WMIOLEDB.DLL",L"Provider Name"},
/* 41*/ {DBPROP_PROVIDERFRIENDLYNAME, FLAGS_DATASRCINF, VT_BSTR, FALSE, 0, L"Microsoft WMIOLE DB Provider",L"Provider Friendly Name"},
/* 42*/ {DBPROP_PROVIDEROLEDBVER, FLAGS_DATASRCINF, VT_BSTR, FALSE, 0, L"02.00", L"OLE DB Version"},
/* 43*/ {DBPROP_PROVIDERVER, FLAGS_DATASRCINF, VT_BSTR, FALSE, 0, _TEXT_T(VER_PRODUCTVERSION_STR), L"Provider Version"},
/* 44*/ {DBPROP_GENERATEURL, FLAGS_DATASRCINF, VT_I4, FALSE, DBPROPVAL_GU_NOTSUPPORTED, NULL, L"URL Generation"},
/* 45*/ {DBPROP_ALTERCOLUMN, FLAGS_DATASRCINF, VT_I4, FALSE, DBCOLUMNDESCFLAGS_PROPERTIES, NULL, L"Alter Column Support"},
/* 45*/ {DBPROP_MULTIPLERESULTS, FLAGS_DATASRCINF, VT_I4, FALSE, 0, NULL, L"Multiple Results"},
/* 45*/ {DBPROP_OLEOBJECTS, FLAGS_DATASRCINF, VT_I4, FALSE, DBPROPVAL_OO_ROWOBJECT, NULL, L"OLE Object Support"},
// Command properties should come here
///* 75*/ {DBPROP_WMIOLEDB_ISMETHOD, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Method"},
///* 75*/ {DBPROP_WMIOLEDB_QUERYLANGUAGE, FLAGS_ROWSETRW, VT_BSTR, FALSE, 0, NULL, L"Query Language"},
/* 46*/ {DBPROP_IAccessor, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IAccessor"},
/* 47*/ {DBPROP_IColumnsInfo, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IColumnsInfo"},
/* 48*/ {DBPROP_IConvertType, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IConvertType"},
/* 49*/ {DBPROP_IRowset, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IRowset"},
/* 50*/ {DBPROP_IRowsetChange, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"IRowsetChange"},
/* 51*/ {DBPROP_IRowsetInfo, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IRowsetInfo"},
/* 52*/ {DBPROP_IRowsetIdentity, FLAGS_ROWSETRO, VT_BOOL, TRUE, 0, NULL, L"IRowsetIdentity"},
/* 53*/ {DBPROP_IRowsetLocate, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"IRowsetLocate"},
/* 54*/ {DBPROP_CANHOLDROWS, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"Hold Rows"},
/* 55*/ {DBPROP_LITERALIDENTITY, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"Literal Row Identity"},
/* 56*/ {DBPROP_UPDATABILITY, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Updatability"},
/* 57*/ {DBPROP_OWNUPDATEDELETE, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Own Changes Visible"},
///**/ {DBPROP_IRowsetUpdate, FLAGS_ROWSETRO, VT_BOOL, FALSE, 0, NULL, L"IRowsetUpdate"},
/* 58*/ {DBPROP_ISequentialStream, FLAGS_ROWSETRO, VT_BOOL, FALSE, 0, NULL, L"ISequentialStream"},
/* 59*/ {DBPROP_OTHERUPDATEDELETE, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Others' Changes Visible"},
/* 60*/ {DBPROP_CANFETCHBACKWARDS, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Fetch Backwards"},
/* 61*/ {DBPROP_CANSCROLLBACKWARDS, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Scroll Backwards"},
/* 62*/ {DBPROP_BOOKMARKS, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"Use Bookmarks"},
/* 63*/ {DBPROP_BOOKMARKTYPE, FLAGS_ROWSETRO, VT_I4, TRUE, DBPROPVAL_BMK_NUMERIC, NULL, L"Bookmark Type"},
/* 64*/ {DBPROP_IRow, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"IRow"},
/* 65*/ {DBPROP_IGetRow, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"IGetRow"},
/* 66*/ {DBPROP_IRowsetRefresh, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"IRowsetRefresh"},
/* 67*/ {DBPROP_IChapteredRowset, FLAGS_ROWSETRW, VT_BOOL, TRUE, 0, NULL, L"IChapteredRowset"},
/* 68*/ {DBPROP_REMOVEDELETED, FLAGS_ROWSETRO, VT_BOOL, FALSE, 0, NULL, L"Remove Deleted Rows"},
/* 69*/ {DBPROP_OTHERINSERT, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Others' Inserts Visible"},
/* 70*/ {DBPROP_MAXOPENROWS, FLAGS_ROWSETRW, VT_I4, TRUE, 1024, NULL, L"Maximum Open Rows"},
// WMIOLEDB_ROWSET properties
/* 73*/ {DBPROP_WMIOLEDB_FETCHDEEP, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Get Child Instances"},
/* 74*/ {DBPROP_WMIOLEDB_OBJECTTYPE, FLAGS_ROWSETRW, VT_I4, TRUE, DBPROPVAL_SCOPEOBJ, NULL, L"Type of Object"},
/* 75*/ {DBPROP_WMIOLEDB_ISMETHOD, FLAGS_ROWSETRW, VT_BOOL, FALSE, 0, NULL, L"Method"},
/* 75*/ {DBPROP_WMIOLEDB_QUERYLANGUAGE, FLAGS_ROWSETRW, VT_BSTR, FALSE, 0, NULL, L"Query Language"},
// ADSI Search Preferences
/* 76*/ {DBPROP_WMIOLEDB_DS_DEREFALIAS, FLAGS_ROWSETRW, VT_I4, FALSE, 0, NULL, L"Deref Aliases"},
/* 77*/ {DBPROP_WMIOLEDB_DS_SIZELIMIT, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Size Limit"},
/* 78*/ {DBPROP_WMIOLEDB_DS_SEARCHSCOPE, FLAGS_ROWSETRW, VT_I4, FALSE, 0, NULL, L"SearchScope"},
/* 79*/ {DBPROP_WMIOLEDB_DS_TIMEOUT, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Timeout"},
/* 80*/ {DBPROP_WMIOLEDB_DS_PAGESIZE, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Page Size"},
/* 81*/ {DBPROP_WMIOLEDB_DS_TIMELIMIT, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Time Limit"},
/* 82*/ {DBPROP_WMIOLEDB_DS_CHASEREF, FLAGS_ROWSETRW, VT_I4, TRUE, 0, NULL, L"Chase Referals"},
/* 83*/ {DBPROP_WMIOLEDB_DS_CACHERESULTS, FLAGS_ROWSETRW, VT_BOOL,TRUE, 0, NULL, L"Cache Results"},
/* 84*/ {DBPROP_WMIOLEDB_DS_ASYNCH, FLAGS_ROWSETRW, VT_BOOL,FALSE, 0, NULL, L"Search Asynchronous"},
/* 85*/ {DBPROP_WMIOLEDB_DS_ATTRIBONLY, FLAGS_ROWSETRW, VT_BOOL,FALSE, 0, NULL, L"Attributes Only"},
/* 86*/ {DBPROP_WMIOLEDB_DS_PAGEDTIMELIMIT, FLAGS_ROWSETRW, VT_I4, FALSE, 0, NULL, L"Page size limit"},
/* 87*/ {DBPROP_WMIOLEDB_DS_TOMBSTONE, FLAGS_ROWSETRW, VT_BOOL,FALSE, 0, NULL, L"TombStone"},
/* 88*/ {DBPROP_WMIOLEDB_DS_FILTER, FLAGS_ROWSETRW, VT_BSTR,FALSE, 0, NULL, L"Filter"},
/* 89*/ {DBPROP_WMIOLEDB_DS_ATTRIBUTES, FLAGS_ROWSETRW, VT_BSTR,FALSE, 0, NULL, L"Attributes"},
// Column Properties
/* 90*/ {DBPROP_COL_NULLABLE, FLAGS_COLUMNSRW, VT_BOOL, TRUE, 0, NULL, L"Nullable"},
/* 91*/ {DBPROP_COL_UNIQUE, FLAGS_COLUMNSRW, VT_BOOL, TRUE, 0, NULL, L"Unique"},
/* 92*/ {DBPROP_COL_PRIMARYKEY, FLAGS_COLUMNSRW, VT_BOOL, TRUE, 0, NULL, L"Primary Key"},
// WMIOLEDB_COLUMN Properties
/* 93*/ {DBPROP_WMIOLEDB_QUALIFIERFLAVOR, FLAGS_COLUMNSRW, VT_I4, TRUE, DBPROPVAL_FLAVOR_PROPOGAGTE_TO_INSTANCE, NULL, L"Qualifier Flavor"},
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Constructor for this class
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CUtilProp::CUtilProp (void)
{
/* m_prgproperties = NULL;
m_cProperties = NUMBER_OF_SUPPORTED_PROPERTIES;
m_prgproperties = (PROPSTRUCT *)g_pIMalloc->Alloc(sizeof(PROPSTRUCT) * m_cProperties);
memcpy(m_prgproperties, &s_rgprop, sizeof(PROPSTRUCT) * m_cProperties );
m_nPropStartIndex = 0;
*/
m_propType = BINDERPROP;
m_prgproperties = NULL;
m_cProperties = 0;
m_nPropStartIndex = 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Constructor for this class
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CUtilProp::CUtilProp ( PROPERTYTYPE propType )
{
/*
m_propType = propType;
m_prgproperties = NULL;
m_cProperties = 0;
m_nPropStartIndex = 0;
switch(propType)
{
case DATASOURCEPROP :
m_cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES + \
NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES + \
NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
m_nPropStartIndex = 0;
break;
case SESSIONPROP :
m_cProperties = NUMBER_OF_SUPPORTED_SESSION_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_SESSION_PROPERTIES;
break;
// for command follow through to include even the rowset properties
case COMMANDPROP :
m_cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
case ROWSETPROP :
m_cProperties += NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES + NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
// if start index is no set by COMMANDPROP
if(m_nPropStartIndex == 0)
{
m_nPropStartIndex = START_OF_SUPPORTED_ROWSET_PROPERTIES;
}
break;
case BINDERPROP:
m_cProperties = NUMBER_OF_SUPPORTED_PROPERTIES;
m_nPropStartIndex = 0;
break;
case COLUMNPROP:
m_cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES + NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_COLUMN_PROPERTIES;
break;
};
if(m_cProperties > 0)
{
// m_prgproperties = (PROPSTRUCT *)g_pIMalloc->Alloc(sizeof(PROPSTRUCT) * m_cProperties);
m_prgproperties = new PROPSTRUCT[m_cProperties];
memcpy(m_prgproperties, &s_rgprop[m_nPropStartIndex], sizeof(PROPSTRUCT) * m_cProperties );
SetDefaultValueForStringProperties(m_prgproperties,m_cProperties);
}
if( propType == DATASOURCEPROP || propType == BINDERPROP)
{
ULONG lIndex = 0;
// Get the default LCID
if(GetPropIndex(DBPROP_INIT_LCID,&lIndex))
{
m_prgproperties[lIndex].longVal = (SLONG)GetSystemDefaultLCID();
}
CPreviligeToken pvgToken;
DBPROPIDSET rgPropertyIDSets[1];
ULONG cPropertySets;
DBPROPSET* prgPropertySets;
HRESULT hr = S_OK;
rgPropertyIDSets[0].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
rgPropertyIDSets[0].rgPropertyIDs = NULL;
rgPropertyIDSets[0].cPropertyIDs = 0;
// NTRaid: 136443
// 07/05/00
hr = pvgToken.FInit();
if(SUCCEEDED(hr) && SUCCEEDED(hr = GetProperties(PROPSET_DSO,1,rgPropertyIDSets,&cPropertySets,&prgPropertySets)))
{
pvgToken.SetDBPROPForPrivileges(prgPropertySets->cProperties ,prgPropertySets[0].rgProperties);
hr = SetProperties(PROPSET_DSO,1,prgPropertySets);
//==========================================================================
// Free memory we allocated to get the namespace property above
//==========================================================================
m_PropMemMgr.FreeDBPROPSET( cPropertySets, prgPropertySets);
}
}
*/
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Destructor for this class
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CUtilProp:: ~CUtilProp (void )
{
SAFE_DELETE_ARRAY(m_prgproperties);
}
HRESULT CUtilProp:: FInit(PROPERTYTYPE propType)
{
HRESULT hr = S_OK;
m_propType = propType;
switch(propType)
{
case DATASOURCEPROP :
m_cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES + \
NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES + \
NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
m_nPropStartIndex = 0;
break;
case SESSIONPROP :
m_cProperties = NUMBER_OF_SUPPORTED_SESSION_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_SESSION_PROPERTIES;
break;
// for command follow through to include even the rowset properties
case COMMANDPROP :
m_cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
case ROWSETPROP :
m_cProperties += NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES + NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
// if start index is no set by COMMANDPROP
if(m_nPropStartIndex == 0)
{
m_nPropStartIndex = START_OF_SUPPORTED_ROWSET_PROPERTIES;
}
break;
case BINDERPROP:
m_cProperties = NUMBER_OF_SUPPORTED_PROPERTIES;
m_nPropStartIndex = 0;
break;
case COLUMNPROP:
m_cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES + NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
m_nPropStartIndex = START_OF_SUPPORTED_COLUMN_PROPERTIES;
break;
};
if(m_cProperties > 0)
{
// m_prgproperties = (PROPSTRUCT *)g_pIMalloc->Alloc(sizeof(PROPSTRUCT) * m_cProperties);
m_prgproperties = new PROPSTRUCT[m_cProperties];
if(m_prgproperties)
{
memcpy(m_prgproperties, &s_rgprop[m_nPropStartIndex], sizeof(PROPSTRUCT) * m_cProperties );
SetDefaultValueForStringProperties(m_prgproperties,m_cProperties);
}
else
{
hr = E_OUTOFMEMORY;
}
}
if (SUCCEEDED(hr) &&( propType == DATASOURCEPROP || propType == BINDERPROP))
{
ULONG lIndex = 0;
// Get the default LCID
if(GetPropIndex(DBPROP_INIT_LCID,&lIndex))
{
m_prgproperties[lIndex].longVal = (SLONG)GetSystemDefaultLCID();
}
CPreviligeToken pvgToken;
DBPROPIDSET rgPropertyIDSets[1];
ULONG cPropertySets;
DBPROPSET* prgPropertySets;
HRESULT hr = S_OK;
rgPropertyIDSets[0].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
rgPropertyIDSets[0].rgPropertyIDs = NULL;
rgPropertyIDSets[0].cPropertyIDs = 0;
// NTRaid: 136443
// 07/05/00
hr = pvgToken.FInit();
if(SUCCEEDED(hr) && SUCCEEDED(hr = GetProperties(PROPSET_DSO,1,rgPropertyIDSets,&cPropertySets,&prgPropertySets)))
{
pvgToken.SetDBPROPForPrivileges(prgPropertySets->cProperties ,prgPropertySets[0].rgProperties);
hr = SetProperties(PROPSET_DSO,1,prgPropertySets);
//==========================================================================
// Free memory we allocated to get the namespace property above
//==========================================================================
m_PropMemMgr.FreeDBPROPSET( cPropertySets, prgPropertySets);
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Returns index of the given property in the property set
//
// BOOL
// TRUE found match, copied it to pulIndex out-param
// FALSE no match. In this case, pulIndex has no meaning
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUtilProp::GetPropIndex ( DBPROPID dwPropertyID, //IN PROPID of desired property
ULONG* pulIndex) //OUT index of desired property if return was TRUE
{
ULONG cNumberOfProperties;
BOOL fRc = FALSE;
assert( pulIndex );
for ( cNumberOfProperties = 0; cNumberOfProperties < m_cProperties; cNumberOfProperties++) {
if (dwPropertyID == m_prgproperties[cNumberOfProperties].dwPropertyID ) {
//==============================================================
// found a match
//==============================================================
*pulIndex = cNumberOfProperties;
fRc = TRUE;
break;
}
}
return fRc;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Returns index of the given property in our global table of properties
//
// BOOL
// TRUE found match, copied it to pulIndex out-param
// FALSE no match. In this case, pulIndex has no meaning
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUtilProp::GetPropIndexFromAllSupportedProps ( DBPROPID dwPropertyID, //IN PROPID of desired property
ULONG* pulIndex) //OUT index of desired property if return was TRUE
{
ULONG cNumberOfProperties;
BOOL fRc = FALSE;
assert( pulIndex );
for ( cNumberOfProperties = 0; cNumberOfProperties < NUMBER_OF_SUPPORTED_PROPERTIES; cNumberOfProperties++) {
if (dwPropertyID == s_rgprop[cNumberOfProperties].dwPropertyID ) {
//==============================================================
// found a match
//==============================================================
*pulIndex = cNumberOfProperties;
fRc = TRUE;
break;
}
}
return fRc;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Helper for GetPropertyInfo. Loads field of DBPROPINFO structure.
//
// BOOL
// TRUE Method succeeded
// FALSE Method failed (couldn't allocate memory)
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUtilProp::LoadDBPROPINFO ( PROPSTRUCT* pPropStruct, DBPROPINFO* pPropInfo )
{
assert( pPropStruct );
assert( pPropInfo );
//=======================================================================
// init the variant
//=======================================================================
VariantInit( &pPropInfo->vValues );
//=======================================================================
// set the easy fields..
//=======================================================================
pPropInfo->dwPropertyID = pPropStruct->dwPropertyID;
pPropInfo->dwFlags = pPropStruct->dwFlags;
pPropInfo->vtType = pPropStruct->vtType;
//=======================================================================
// fill in the description
//=======================================================================
if ( pPropInfo->pwszDescription ){
wcscpy(pPropInfo->pwszDescription, pPropStruct->pwstrDescBuffer);
}
//=======================================================================
// all went well
//=======================================================================
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Helper for GetProperties. Loads field of DBPROP structure.
//
// BOOL
// TRUE Method succeeded
// FALSE Method failed (couldn't allocate memory)
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CUtilProp::LoadDBPROP ( PROPSTRUCT* pPropStruct, DBPROP* pPropSupport )
{
assert( pPropStruct );
assert( pPropSupport );
//========================================================================
// init the variant
//========================================================================
VariantInit( &pPropSupport->vValue );
//========================================================================
// set the easy fields..
//========================================================================
pPropSupport->dwPropertyID = pPropStruct->dwPropertyID;
pPropSupport->colid = DB_NULLID;
pPropSupport->dwStatus = DBPROPSTATUS_OK;
//========================================================================
// set pPropSupport->vValue based on Variant type
//========================================================================
switch (pPropStruct->vtType){
case VT_BOOL:
V_VT( &pPropSupport->vValue ) = VT_BOOL;
if( pPropStruct->boolVal )
V_BOOL( &pPropSupport->vValue ) = VARIANT_TRUE;
else
V_BOOL( &pPropSupport->vValue ) = VARIANT_FALSE;
break;
case VT_I2:
V_VT( &pPropSupport->vValue ) = VT_I2;
V_I2( &pPropSupport->vValue ) = (SHORT)pPropStruct->longVal;
break;
case VT_I4:
V_VT( &pPropSupport->vValue ) = VT_I4;
V_I4( &pPropSupport->vValue ) = pPropStruct->longVal;
break;
case VT_BSTR:
if( pPropStruct->pwstrVal ){
V_VT( &pPropSupport->vValue ) = VT_BSTR;
V_BSTR( &pPropSupport->vValue ) = Wmioledb_SysAllocString( pPropStruct->pwstrVal );
}
/* else
VariantClear( &pPropSupport->vValue );
*/ break;
case VT_UI4:
V_VT( &pPropSupport->vValue ) = VT_I4;
V_UI4( &pPropSupport->vValue ) = pPropStruct->longVal;
break;
default:
assert( !"LoadDBPROP unknown variant type!\n\r" );
break;
}
// all went well
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Initialize the buffers and check for E_INVALIDARG cases
//
// NOTE: This routine is used by RowsetInfo and IDBProperties
//
// HRESULT indicating the status of the method
// S_OK Properties gathered
// E_INVALIDARG Invalid parameter values
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::GetPropertiesArgChk( DWORD dwBitMask, //IN Mask for object
const ULONG cPropertySets, //IN Number of property Sets
const DBPROPIDSET rgPropertySets[], //IN Property Classes and Ids
ULONG* pcProperties, //OUT Count of structs returned
DBPROPSET** prgProperties, //OUT Array of Properties
BOOL bDSOInitialized )
{
HRESULT hr = S_OK;
//================================================================
// Initialize values
//================================================================
if( pcProperties ){
*pcProperties = 0;
}
if( prgProperties ){
*prgProperties = NULL;
}
//================================================================
// Check Arguments
//================================================================
if (((cPropertySets > 0) && !rgPropertySets) ||
!pcProperties ||
!prgProperties )
{
hr = E_INVALIDARG ;
}
else{
//=========================================================================
// New argument check for > 1 cPropertyIDs and NULL pointer
// for array of property ids.
//=========================================================================
for(ULONG ul=0; ul<cPropertySets && hr == S_OK; ul++){
if(( rgPropertySets[ul].guidPropertySet == DBPROPSET_PROPERTIESINERROR &&
(rgPropertySets[ul].cPropertyIDs != 0 || rgPropertySets[0].rgPropertyIDs != NULL ||
cPropertySets > 1)) && (dwBitMask == DATASOURCEPROP || dwBitMask == COMMANDPROP))
{
hr = E_INVALIDARG;
break;
}
else
if( rgPropertySets[ul].cPropertyIDs && !(rgPropertySets[ul].rgPropertyIDs) )
{
hr = E_INVALIDARG;
}
else
{
// Check if all the propertysetID's are correct for this object
hr = IsValidPropertySet(bDSOInitialized,rgPropertySets[ul].guidPropertySet);
}
if(FAILED(hr))
{
hr = E_INVALIDARG;
break;
}
else
hr = S_OK;
}
}
return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Validate that the variant contains legal values for it's particalur type and for the particular PROPID in this
// propset.
//
// HRESULT indicating status
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::IsValidValue(DBPROP* pDBProp )
{
HRESULT hr = S_OK;
ULONG lIndex = 0;
//===========================================================================
// Check BOOLEAN values
//===========================================================================
if( (pDBProp->vValue.vt == VT_BOOL) && !((V_BOOL(&(pDBProp->vValue)) == VARIANT_TRUE) ||
(V_BOOL(&(pDBProp->vValue)) == VARIANT_FALSE)) ){
hr = S_FALSE;
}
else if( pDBProp->vValue.vt != VT_EMPTY && pDBProp->vValue.vt != VT_NULL){
if(GetPropIndex(pDBProp->dwPropertyID,&lIndex) == FALSE)
hr = FALSE;
else
if(pDBProp->vValue.vt != m_prgproperties[lIndex].vtType)
hr = S_FALSE;
else
{
switch( pDBProp->dwPropertyID ) {
case DBPROP_INIT_DATASOURCE:
case DBPROP_AUTH_USERID:
case DBPROP_AUTH_PASSWORD:
case DBPROP_WMIOLEDB_AUTHORITY:
case DBPROP_WMIOLEDB_QUERYLANGUAGE:
if( pDBProp->vValue.vt != VT_BSTR ){
hr = S_FALSE;
}
break;
case DBPROP_INIT_HWND:
if( pDBProp->vValue.vt != VT_I4 ){
hr = S_FALSE;
}
break;
case DBPROP_INIT_PROMPT:
//===============================================================
// These are the only values we support (from spec).
//===============================================================
if ( (pDBProp->vValue.vt == VT_I2) &&
!(V_I2(&pDBProp->vValue) == DBPROMPT_PROMPT ||
V_I2(&pDBProp->vValue) == DBPROMPT_COMPLETE ||
V_I2(&pDBProp->vValue) == DBPROMPT_COMPLETEREQUIRED ||
V_I2(&pDBProp->vValue) == DBPROMPT_NOPROMPT)){
hr = S_FALSE;
}
break;
case DBPROP_INIT_PROTECTION_LEVEL:
if (!( V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_NONE ||
V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_CONNECT ||
V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_CALL ||
V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_PKT ||
V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_PKT ||
V_I4(&pDBProp->vValue) == DB_PROT_LEVEL_PKT_PRIVACY))
{
hr = S_FALSE;
}
break;
case DBPROP_INIT_IMPERSONATION_LEVEL:
if (!( V_I4(&pDBProp->vValue) == DB_IMP_LEVEL_ANONYMOUS ||
V_I4(&pDBProp->vValue) == DB_IMP_LEVEL_IDENTIFY ||
V_I4(&pDBProp->vValue) == DB_IMP_LEVEL_IMPERSONATE ||
V_I4(&pDBProp->vValue) == DB_IMP_LEVEL_DELEGATE )) {
hr = S_FALSE;
}
break;
case DBPROP_INIT_MODE:
switch(V_I4(&pDBProp->vValue))
{
case DB_MODE_READ:
case DB_MODE_WRITE:
case DB_MODE_READWRITE:
case DB_MODE_SHARE_DENY_READ:
case DB_MODE_SHARE_EXCLUSIVE:
case DB_MODE_SHARE_DENY_NONE:
case DB_MODE_SHARE_EXCLUSIVE|DB_MODE_SHARE_DENY_NONE:
case DB_MODE_READ|DB_MODE_WRITE|DB_MODE_READWRITE|DB_MODE_SHARE_DENY_READ|DB_MODE_SHARE_DENY_WRITE|DB_MODE_SHARE_EXCLUSIVE|DB_MODE_SHARE_DENY_NONE:
hr = S_OK;
break;
default:
hr = S_FALSE;
};
break;
case DBPROP_WMIOLEDB_QUALIFIERS:
if (!( V_I4(&pDBProp->vValue) == DBPROP_WM_CLASSQUALIFIERS ||
V_I4(&pDBProp->vValue) == DBPROP_WM_PROPERTYQUALIFIERS ||
V_I4(&pDBProp->vValue) == 0 ||
V_I4(&pDBProp->vValue) == (DBPROP_WM_PROPERTYQUALIFIERS | DBPROP_WM_CLASSQUALIFIERS) ))
{
hr = S_FALSE;
}
break;
case DBPROP_UPDATABILITY:
if (!( V_I4(&pDBProp->vValue) <= (DBPROPVAL_UP_CHANGE | DBPROPVAL_UP_DELETE | DBPROPVAL_UP_INSERT) &&
V_I4(&pDBProp->vValue) >= 0))
{
hr = S_FALSE;
}
break;
case DBPROP_MAXOPENROWS:
if(V_I4(&pDBProp->vValue) > MAXOPENROWS &&
V_I4(&pDBProp->vValue) <= 0)
{
hr = S_FALSE;
}
break;
case DBPROP_WMIOLEDB_OBJECTTYPE:
if(!( (V_I4(&pDBProp->vValue) == DBPROPVAL_SCOPEOBJ) ||
(V_I4(&pDBProp->vValue) == DBPROPVAL_CONTAINEROBJ) ||
(V_I4(&pDBProp->vValue) == DBPROPVAL_NOOBJ) ) )
{
hr = S_FALSE;
}
break;
}
}
}
return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::CheckPropertyIDSets( BOOL & fIsNotSpecialGUID, BOOL & fIsSpecialGUID,
ULONG cPropIDSets, const DBPROPIDSET rgPropIDSets[] ) //IN Array of property sets
{
HRESULT hr = S_OK;
fIsNotSpecialGUID = FALSE;
fIsSpecialGUID = FALSE;
for(ULONG ul=0; ul<cPropIDSets; ul++){
if( rgPropIDSets[ul].cPropertyIDs && !(rgPropIDSets[ul].rgPropertyIDs) ){
hr = E_INVALIDARG ;
break;
}
if (DBPROPSET_ROWSETALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_DATASOURCEALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_DATASOURCEINFOALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_SESSIONALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_COLUMNALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_DBINITALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_CONSTRAINTALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_INDEXALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_SESSIONALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_VIEWALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_TABLEALL == rgPropIDSets[ul].guidPropertySet ||
DBPROPSET_TRUSTEEALL == rgPropIDSets[ul].guidPropertySet )
{
fIsSpecialGUID = TRUE;
}
else{
fIsNotSpecialGUID = TRUE;
}
if(fIsSpecialGUID && fIsNotSpecialGUID){
hr = E_INVALIDARG ;
break;
}
}
if(fIsSpecialGUID && fIsNotSpecialGUID)
hr = E_INVALIDARG ;
return hr;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Returns information about rowset and data source properties supported by the provider
//
// HRESULT
// S_OK The method succeeded
// E_INVALIDARG pcPropertyIDSets or prgPropertyInfo was NULL
// E_OUTOFMEMORY Out of memory
//
// NTRaid : 142133 - Testing this , found that getting data source property from ADO was resulting in a crash
// 07/12/00
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CUtilProp::GetPropertyInfo( BOOL fDSOInitialized, //IN if Initialized
ULONG cPropIDSets, //IN # properties
const DBPROPIDSET rgPropIDSets[], //IN Array of property sets
ULONG* pcPropInfoSets, //OUT # DBPROPSET structures
DBPROPINFOSET** prgPropInfoSets,//OUT DBPROPSET structures property information returned
WCHAR** ppDescBuffer //OUT Property descriptions
)
{
BOOL fRet= TRUE;
BOOL fPropsinError, fPropsSucceed, fIsSpecialGUID, fIsNotSpecialGUID;
ULONG cProps = 0;
ULONG cCount = 0;
ULONG ulPropSets = 0;
ULONG cTotalPropSets = 0;
ULONG ulPropSetIndex = 0;
ULONG cPropSetsInSpecialGUID = 0;
WCHAR* pDescBuffer = NULL;
WCHAR* pDescBufferTemp = NULL;
DBPROPINFO* pPropInfo;
DBPROPINFOSET* pPropInfoSet;
HRESULT hr = S_OK;
ULONG ulPropertyInfoCount = 0;
//=======================================================================
// init out params and local stuff
//=======================================================================
if (pcPropInfoSets)
*pcPropInfoSets = 0;
if (prgPropInfoSets)
*prgPropInfoSets = NULL;
if (ppDescBuffer)
*ppDescBuffer = NULL;
fPropsinError = fPropsSucceed = fIsSpecialGUID = fIsNotSpecialGUID = FALSE;
cProps = cCount = ulPropSets = ulPropSetIndex = cTotalPropSets = cPropSetsInSpecialGUID = 0;
//=======================================================================
// Check Arguments, on failure post HRESULT to error queue
//=======================================================================
if( ((cPropIDSets > 0) && !rgPropIDSets) || !pcPropInfoSets || !prgPropInfoSets ){
return E_INVALIDARG ;
}
//=======================================================================
// If the consumer does not restrict the property sets by specify an
// array of property sets and a cPropertySets greater than 0, then we
// need to make sure we have some to return
//=======================================================================
if ( (cPropIDSets == 0) ){
if( fDSOInitialized )
cProps = NUMBER_OF_SUPPORTED_PROPERTY_SETS;
else
cProps = 2;
cTotalPropSets = cProps;
}
else
{
//=======================================================================
// New argument check for > 1 cPropIDs and NULL pointer for
// array of property ids.
//=======================================================================
if( S_OK != ( hr = CheckPropertyIDSets(fIsNotSpecialGUID,fIsSpecialGUID,cPropIDSets,rgPropIDSets)) ){
return hr;
}
if( fIsSpecialGUID == TRUE)
{
cTotalPropSets = GetNumberOfPropertySets(fDSOInitialized,rgPropIDSets,cPropIDSets);
// NTRaid : 142133
// 07/12/00
cProps = cPropIDSets;
}
else
//=======================================================================
// save the count of PropertyIDSets
//=======================================================================
cTotalPropSets = cProps = cPropIDSets;
}
// con.properties
// 07/06/00
if(cTotalPropSets)
{
//=======================================================================
// use task memory allocater to alloc a DBPROPINFOSET struct
//=======================================================================
if( S_OK != (hr = m_PropMemMgr.AllocDBPROPINFOSET(pPropInfoSet,cTotalPropSets))){
return hr;
}
memset(pPropInfoSet,0,cTotalPropSets * sizeof(DBPROPINFOSET));
// Fill the property sets info to be fetched and get the number of properties that will be returned
if(fIsSpecialGUID == TRUE || cPropIDSets == 0)
{
FillPropertySets(fDSOInitialized,rgPropIDSets,cPropIDSets ,pPropInfoSet,ulPropertyInfoCount);
}
else
{
ulPropertyInfoCount = GetNumberofPropInfoToBeReturned(fDSOInitialized,cPropIDSets,rgPropIDSets);
}
//=======================================================================
// Alloc memory for ppDescBuffer
//=======================================================================
if( S_OK != (hr = m_PropMemMgr.AllocDESCRIPTBuffer(pDescBuffer, ppDescBuffer,ulPropertyInfoCount))){
m_PropMemMgr.FreeDBPROPINFOSET(pPropInfoSet,cTotalPropSets);
return hr;
}
pDescBufferTemp = pDescBuffer;
//=======================================================================
// For each supported Property Set
//=======================================================================
for (ulPropSets=0,ulPropSetIndex = 0; ulPropSets < cTotalPropSets; ulPropSets++ )
{
BOOL fGetAllProps = FALSE;
// if the propinfo is not filled manually then get it from the input parameters
if(fIsSpecialGUID == FALSE && cPropIDSets != 0)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = rgPropIDSets[ulPropSets].guidPropertySet;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = rgPropIDSets[ulPropSets].cPropertyIDs;
}
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_DBINIT &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
}
else
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
}
else
if( fDSOInitialized )
{
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_DATASOURCEINFO &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
else
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_ROWSET &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
}
else
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
}
else
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_COLUMN &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
}
else
if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
/* if (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND &&
pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0 )
{
fGetAllProps = TRUE;
pPropInfoSet[ulPropSetIndex].cPropertyInfos = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
}
*/
// else if (rgPropIDSets[ulPropSets].cPropertyIDs == 0)
else if (pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0)
fPropsinError = TRUE;
}
// else if (rgPropIDSets[ulPropSets].cPropertyIDs == 0)
else if (pPropInfoSet[ulPropSetIndex].cPropertyInfos == 0)
{
//===============================================================
// Since we do not support it should return a error with 0 & NULL
//===============================================================
fPropsinError = TRUE;
}
if (pPropInfoSet[ulPropSetIndex].cPropertyInfos){
//===============================================================
// use task memory allocater to alloc array of DBPROPINFO structs
//===============================================================
hr = m_PropMemMgr.AllocDBPROPINFO(pPropInfo,pPropInfoSet,ulPropSetIndex);
if (!pPropInfo) {
m_PropMemMgr.FreeDBPROPINFOSET(pPropInfoSet,cTotalPropSets);
pDescBuffer = pDescBufferTemp;
m_PropMemMgr.FreeDESCRIPTBuffer(pDescBuffer,ppDescBuffer);
return E_OUTOFMEMORY ;
}
pPropInfoSet[ulPropSetIndex].rgPropertyInfos = &pPropInfo[0];
memset( pPropInfo, 0,
(pPropInfoSet[ulPropSetIndex].cPropertyInfos * sizeof( DBPROPINFO )));
}
if(!IsPropertySetSupported(pPropInfoSet[ulPropSetIndex].guidPropertySet))
{
for (cCount=0; cCount < pPropInfoSet[ulPropSetIndex].cPropertyInfos; cCount++)
{
pPropInfo[cCount].dwPropertyID = rgPropIDSets[ulPropSets].rgPropertyIDs[cCount];
pPropInfo[cCount].dwFlags = DBPROPFLAGS_NOTSUPPORTED;
fPropsinError = TRUE;
pPropInfo[cCount].pwszDescription = NULL;
}
}
else
{
//===============================================================
// for each prop in our table..
//===============================================================
for (cCount=0; cCount < pPropInfoSet[ulPropSetIndex].cPropertyInfos; cCount++){
//===========================================================
// init the Variant right up front that way we can
// VariantClear with no worried (if we need to)
//===========================================================
VariantInit( &pPropInfo[cCount].vValues );
//===========================================================
// set the description pointer
//===========================================================
pPropInfo[cCount].pwszDescription = pDescBuffer;
//===========================================================
// Check supported property sets
//===========================================================
if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_DBINIT) && (fGetAllProps) ){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_DBINIT_PROPERTIES + cCount], &pPropInfo[cCount] );
}
else
if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT) && (fGetAllProps) ){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES + cCount], &pPropInfo[cCount] );
}
else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_DATASOURCEINFO) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES + cCount], &pPropInfo[cCount] );
}
else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_ROWSET) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_ROWSET_PROPERTIES + cCount],&pPropInfo[cCount] );
}
else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount],&pPropInfo[cCount] );
}
else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_COLUMN) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_COLUMN_PROPERTIES + cCount],&pPropInfo[cCount] );
}
else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES + cCount],&pPropInfo[cCount] );
}
/* else if ( (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND) && fGetAllProps && fDSOInitialized){
//=======================================================
// load up their DBPROPINFO from our table
//=======================================================
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES + cCount],&pPropInfo[cCount] );
}
*/ else{
ULONG ulIndex;
pPropInfo[cCount].dwPropertyID = rgPropIDSets[ulPropSets].rgPropertyIDs[cCount];
pPropInfo[cCount].dwFlags = DBPROPFLAGS_NOTSUPPORTED;
if ( (GetPropIndexFromAllSupportedProps(rgPropIDSets[ulPropSets].rgPropertyIDs[cCount], &ulIndex)) &&
(fDSOInitialized || (pPropInfoSet[ulPropSetIndex].guidPropertySet == DBPROPSET_DBINIT)) ){
fPropsSucceed = TRUE;
fRet = LoadDBPROPINFO( &s_rgprop[ulIndex], &pPropInfo[cCount] );
}
else{
fPropsinError = TRUE;
pPropInfo[cCount].pwszDescription = NULL;
}
}
if (!fRet){
m_PropMemMgr.FreeDBPROPINFOSET(pPropInfoSet,cTotalPropSets);
if ( ppDescBuffer ){
*ppDescBuffer = NULL;
}
g_pIMalloc->Free( pDescBufferTemp );
return E_FAIL ;
}
//===========================================================
// move the description pointer to the next
//===========================================================
if ( pPropInfo[cCount].pwszDescription ){
pDescBuffer += (wcslen(pPropInfo[cCount].pwszDescription) + sizeof(CHAR));
}
}
}
//===============================================================
// Set local back to FALSE
//===============================================================
fGetAllProps = FALSE;
// cPropSetsInSpecialGUID--;
ulPropSetIndex++;
}
}
else
if(fIsSpecialGUID && ulPropSetIndex == 0)
{
hr = S_OK;
}
else
{
hr = DB_E_ERRORSOCCURRED;
}
if(ulPropSetIndex)
{
//===================================================================
// set count of properties and property information
//===================================================================
*pcPropInfoSets = ulPropSetIndex;
*prgPropInfoSets = pPropInfoSet;
}
if(SUCCEEDED(hr))
{
if ( !fPropsSucceed && fPropsinError ){
if ( ppDescBuffer ){
*ppDescBuffer = NULL;
}
g_pIMalloc->Free( pDescBufferTemp );
hr = DB_E_ERRORSOCCURRED ;
}
else if ( fPropsSucceed && fPropsinError )
hr = DB_S_ERRORSOCCURRED ;
else
hr = S_OK ;
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Returns current settings of all properties supported by the DSO/rowset
//
// HRESULT
// S_OK The method succeeded
// E_INVALIDARG pcProperties or prgPropertyInfo was NULL
// E_OUTOFMEMORY Out of memory
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CUtilProp::GetProperties( DWORD dwBitMask, //IN Mask if Initialized
ULONG cPropertyIDSets, //IN # of restiction property IDs
const DBPROPIDSET rgPropertyIDSets[], //IN restriction guids
ULONG* pcPropertySets, //OUT count of properties returned
DBPROPSET** prgPropertySets //OUT property information returned
)
{
BOOL fRet = TRUE;
BOOL fPropsinError = FALSE;
BOOL fPropsSucceed = FALSE;
ULONG cProps = 0;
ULONG cCount = 0;
ULONG ulPropertySets= 0;
DBPROP* pProp;
DBPROPSET* pPropSet;
BOOL bDSOInitialized = FALSE;
ULONG ulIndex = 0;
HRESULT hr = S_OK;
//======================================================================
// save the count of PropertyIDSets
//======================================================================
cProps = cPropertyIDSets;
//======================================================================
// If the consumer does not restrict the property sets by specify an
// array of property sets and a cPropertySets greater than 0, then we
// need to make sure we have some to return
//======================================================================
if ( (dwBitMask & PROPSET_DSOINIT) == PROPSET_DSOINIT )
bDSOInitialized = TRUE;
if( cPropertyIDSets == 0 ){
//=================================================================
// only allow the DBINIT and DATASOURCE if Initialized
//=================================================================
cProps = GetNumberOfPropertySets(bDSOInitialized,dwBitMask);
}
//=====================================================================
// use task memory allocater to alloc a DBPROPSET struct
//=====================================================================
pPropSet = (DBPROPSET*) g_pIMalloc->Alloc(cProps * sizeof( DBPROPSET ));
if ( !pPropSet )
return E_OUTOFMEMORY ;
memset( pPropSet, 0, (cProps * sizeof( DBPROPSET )));
if(cPropertyIDSets == 0)
{
FillPropStruct(bDSOInitialized,dwBitMask,pPropSet);
}
if(pcPropertySets)
{
*pcPropertySets = 0;
}
if(prgPropertySets)
{
*prgPropertySets = NULL;
}
//=====================================================================
// For each supported Property Set
//=====================================================================
for (ulPropertySets=0; ulPropertySets < cProps; ulPropertySets++){
BOOL fGetAllProps = FALSE;
//=====================================================================
// If no restrictions return all properties from the three supported
// property sets
//=====================================================================
if ( cPropertyIDSets == 0 ){
fGetAllProps = TRUE;
/* //=============================================================
// only do this once
//=============================================================
if ( ulPropertySets == 0 ){
if( !(dwBitMask & PROPSET_SESSION) ){
if ( !(dwBitMask & PROPSET_ROWSET) ){
pPropSet[0].guidPropertySet = DBPROPSET_DBINIT;
pPropSet[0].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
if( dwBitMask & PROPSET_INIT ){
pPropSet[1].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropSet[1].cProperties = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
}
else{
pPropSet[0].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[0].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
}
}
}
*/ }
else
{
pPropSet[ulPropertySets].guidPropertySet = rgPropertyIDSets[ulPropertySets].guidPropertySet;
// if propertyset is supported by provider , but not available for the current OLEDB object ,
// then throw error
// if the requested number of propertysets is more than one then , the other properties should be
// fetched and DB_S_ERRORSOCCURRED should be thrown
if((S_OK != (hr = IsValidPropertySet(bDSOInitialized,pPropSet[ulPropertySets].guidPropertySet))) &&
IsPropertySetSupported(pPropSet[ulPropertySets].guidPropertySet) &&
rgPropertyIDSets[ulPropertySets].cPropertyIDs == 0)
{
if(cProps > 1)
{
fPropsinError = TRUE;
continue;
}
else
{
*pcPropertySets = 1;
*prgPropertySets = pPropSet;
return DB_E_ERRORSOCCURRED;
}
}
pPropSet[ulPropertySets].cProperties = rgPropertyIDSets[ulPropertySets].cPropertyIDs;
if( rgPropertyIDSets[ulPropertySets].cPropertyIDs == 0 &&
rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_PROPERTIESINERROR )
{
fPropsSucceed = TRUE;
continue;
}
if( rgPropertyIDSets[ulPropertySets].cPropertyIDs == 0 ){
fGetAllProps = TRUE;
if( rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT ){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
}
else
if( rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT ){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
}
else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCEINFO) &&
((dwBitMask & PROPSET_DSOINIT) == PROPSET_DSOINIT) ){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_ROWSET) &&
(dwBitMask & PROPSET_ROWSET)){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
}
else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET) &&
(dwBitMask & PROPSET_ROWSET)){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
}
else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_COLUMN) &&
(dwBitMask & PROPSET_COLUMN)){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
}
else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN) &&
(dwBitMask & PROPSET_COLUMN)){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
/* else if( (rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND) &&
(dwBitMask & PROPSET_COMMAND)){
pPropSet[ulPropertySets].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
}
*/ else{
fGetAllProps = FALSE;
fPropsinError = TRUE;
}
}
}
if( pPropSet[ulPropertySets].cProperties ){
//=============================================================
// use task memory allocater to alloc array of DBPROP structs
//=============================================================
pProp = (DBPROP*) g_pIMalloc->Alloc(sizeof( DBPROP ) * pPropSet[ulPropertySets].cProperties);
if (!pProp){
for(ULONG ul=0; ul<ulPropertySets; ul++){
for(ULONG ul2=0; ul2<pPropSet[ul].cProperties; ul2++)
VariantClear( &pPropSet[ul].rgProperties[ul2].vValue );
g_pIMalloc->Free( pPropSet[ul].rgProperties );
}
g_pIMalloc->Free( pPropSet );
return E_OUTOFMEMORY ;
}
pPropSet[ulPropertySets].rgProperties = &pProp[0];
memset( pProp, 0, (pPropSet[ulPropertySets].cProperties * sizeof( DBPROP )));
}
//=================================================================
// for each prop in our table..
//=================================================================
for (cCount=0; cCount < pPropSet[ulPropertySets].cProperties; cCount++){
//=============================================================
// init the Variant right up front
// that way we can VariantClear with no worried (if we need to)
//=============================================================
VariantInit( &pProp[cCount].vValue );
//=============================================================
// Check supported property sets
//=============================================================
if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT && fGetAllProps ) {
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROP from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_DBINIT_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_DBINIT_PROPERTIES + cCount],&pProp[cCount] );
}
else
if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT && fGetAllProps ) {
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROP from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES + cCount],&pProp[cCount] );
}
else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCEINFO && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES + cCount],&pProp[cCount] );
}
else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_ROWSET && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_ROWSET_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_ROWSET_PROPERTIES + cCount], &pProp[cCount] );
}
else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount], &pProp[cCount] );
}
else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_COLUMN && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_COLUMN_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount], &pProp[cCount] );
}
else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount], &pProp[cCount] );
}
/* else if ( pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND && fGetAllProps ){
fPropsSucceed = TRUE;
//=========================================================
// load up their DBPROPINFO from our table
//=========================================================
pProp[cCount].dwPropertyID = s_rgprop[START_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES + cCount].dwPropertyID;
// fRet = LoadDBPROP( &s_rgprop[START_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES + cCount], &pProp[cCount] );
}
*/ else
{
pProp[cCount].dwPropertyID = rgPropertyIDSets[ulPropertySets].rgPropertyIDs[cCount];
pProp[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
}
if(GetPropIndex(pProp[cCount].dwPropertyID, &ulIndex))
{
fPropsSucceed = FALSE;
switch(dwBitMask)
{
case PROPSET_DSO:
case PROPSET_DSOINIT:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT ||
((pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCE ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCEINFO) &&
bDSOInitialized == TRUE)){
fPropsSucceed = TRUE;
}
break;
case PROPSET_INIT:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT) {
fPropsSucceed = TRUE;
}
break;
case PROPSET_SESSION:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_SESSION){
fPropsSucceed = TRUE;
}
break;
case PROPSET_COMMAND:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_ROWSET ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET) {
// || pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND){
fPropsSucceed = TRUE;
}
break;
case PROPSET_ROWSET:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_ROWSET ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET){
fPropsSucceed = TRUE;
}
break;
case PROPSET_COLUMN:
if(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_COLUMN ||
pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN){
fPropsSucceed = TRUE;
}
break;
default:
fPropsSucceed = FALSE;
};
if(fPropsSucceed == TRUE)
{
fRet = LoadDBPROP( &m_prgproperties[ulIndex], &pProp[cCount] );
}
else
fPropsinError = TRUE;
}
else
{
pProp[cCount].dwPropertyID = rgPropertyIDSets[ulPropertySets].rgPropertyIDs[cCount];
pProp[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fPropsinError = TRUE;
}
/* if( (GetPropIndex(pProp[cCount].dwPropertyID, &ulIndex)) &&
((((dwBitMask & PROPSET_DSO) || (dwBitMask & PROPSET_INIT)) &&
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT)) ||
(((dwBitMask & PROPSET_DSO) || (dwBitMask & PROPSET_INIT))&&
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT)) ||
(((dwBitMask & PROPSET_DSOINIT) == PROPSET_DSOINIT) &&
((pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCE) ||
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCEINFO))) ||
((dwBitMask & PROPSET_SESSION) &&
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_SESSION)) ||
((dwBitMask & PROPSET_ROWSET) &&
((pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_ROWSET) ||
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET))) ||
((dwBitMask & PROPSET_COLUMN) &&
((pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_COLUMN) ||
(pPropSet[ulPropertySets].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN))) ) ){
fPropsSucceed = TRUE;
fRet = LoadDBPROP( &m_prgproperties[ulIndex], &pProp[cCount] );
}
else
fPropsinError = TRUE;
*/
if (!fRet){
ULONG ulFor;
//=========================================================
// something went wrong
// clear all variants used so far..
//=========================================================
for (ulFor = 0; ulFor < cCount; ulFor++){
VariantClear( &pProp[ulFor].vValue );
}
//=========================================================
// .. delete the pPropInfo array, return failure
//=========================================================
g_pIMalloc->Free( pProp );
g_pIMalloc->Free( pPropSet );
return E_FAIL ;
}
}
//=================================================================
// Set local back to FALSE
//=================================================================
fGetAllProps = FALSE;
}
//=====================================================================
// set count of properties and property information
//=====================================================================
if(cProps > 0)
{
*pcPropertySets = cProps;
*prgPropertySets = pPropSet;
}
if ( (!fPropsSucceed && cPropertyIDSets) || (!fPropsSucceed && fPropsinError) )
{
/* g_pIMalloc->Free( pProp );
g_pIMalloc->Free( pPropSet );
*pcPropertySets = 0;
*prgPropertySets = NULL;
*/ return DB_E_ERRORSOCCURRED ;
}
else if ( fPropsSucceed && fPropsinError )
return DB_S_ERRORSOCCURRED ;
else
return S_OK ;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Initialize the buffers and check for E_INVALIDARG cases
//
// HRESULT indicating the status of the method
// S_OK Properties gathered
// E_INVALIDARG Invalid parameter values
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::SetPropertiesArgChk( const ULONG cPropertySets, //IN Count of structs returned
const DBPROPSET rgPropertySets[],//IN Array of Properties Sets
BOOL bDSOInitialized)
{
HRESULT hr = S_OK;
//================================================================
// Argument Checking
//================================================================
if ((cPropertySets > 0) && !rgPropertySets)
return E_INVALIDARG ;
//================================================================
// New argument check for > 1 cPropertyIDs and NULL pointer for
// array of property ids.
//================================================================
for(ULONG ul=0; ul<cPropertySets && hr == S_OK; ul++){
// Setting a error property set is not allowed
if(rgPropertySets[ul].guidPropertySet == DBPROPSET_PROPERTIESINERROR )
{
hr = E_INVALIDARG;
}
else
if( rgPropertySets[ul].cProperties && !(rgPropertySets[ul].rgProperties) )
{
hr = E_INVALIDARG ;
break;
}
else
{
// Check if all the propertysetID is correct for this object
hr = IsValidPropertySet(bDSOInitialized,rgPropertySets[ul].guidPropertySet);
}
if(FAILED(hr))
break;
else
hr = S_OK;
}
return hr ;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Set current settings of properties supported by the DSO/rowset
//
// HRESULT
// S_OK The method succeeded
// E_INVALIDARG pcProperties or prgPropertyInfo was NULL
// E_OUTOFMEMORY Out of memory
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CUtilProp::SetProperties ( const DWORD dwBitMask, //IN Type of PropSet
const ULONG cPropertyIDSets, //IN # of DBPROPSET
DBPROPSET rgPropertyIDSets[] //IN Array of property sets
)
{
ULONG ulPropertySets = 0;
ULONG cCount = 0;
BOOL fSetAllProps = TRUE;
BOOL fOnePropSet = FALSE;
BOOL fWarn = FALSE;
ULONG cNoOfProps = 0;
BOOL fFail = FALSE;
HRESULT hr = S_OK;
//====================================================================
// For each supported Property Set
//====================================================================
for (ulPropertySets=0; ulPropertySets < cPropertyIDSets; ulPropertySets++){
ULONG ulIndex = 0;
//================================================================
// for each prop in the propset
//================================================================
for (cCount=0; cCount < rgPropertyIDSets[ulPropertySets].cProperties; cCount++) {
cNoOfProps++;
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_OK;
//============================================================
// only allow the DBINIT and DATASOURCE
//============================================================
if ( (dwBitMask & PROPSET_DSO) && ((rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_DBINIT) &&
(dwBitMask & PROPSET_INIT)) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSETTABLE;
fSetAllProps = FALSE;
}
else if ( ((dwBitMask & PROPSET_DSO) &&
(rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_DATASOURCE &&
rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_DATASOURCEINFO &&
rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_WMIOLEDB_DBINIT &&
rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_DBINIT)) ||
((rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCE ||
rgPropertyIDSets[ulPropertySets].guidPropertySet == DBPROPSET_DATASOURCEINFO) &&
!(dwBitMask & PROPSET_INIT)) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
//============================================================
// only allow the SESSION
//============================================================
else if ( (dwBitMask & PROPSET_SESSION) && (rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_SESSION) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
//============================================================
// only allow the ROWSET
//============================================================
else if ( (dwBitMask & PROPSET_ROWSET) && (rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_ROWSET) &&
(rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_WMIOLEDB_ROWSET) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
//============================================================
// only allow the COLUMN
//============================================================
else if ( (dwBitMask & PROPSET_COLUMN) && (rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_COLUMN) &&
(rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_WMIOLEDB_COLUMN) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
else if ( (dwBitMask & PROPSET_COMMAND) && (rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_ROWSET) &&
(rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_WMIOLEDB_ROWSET) ) {
// && (rgPropertyIDSets[ulPropertySets].guidPropertySet != DBPROPSET_WMIOLEDB_COMMAND)){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
else{
//========================================================
// get the index in the array
//========================================================
if ( GetPropIndex(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwPropertyID, &ulIndex) ){
//====================================================
// arg checking for the prop
//====================================================
if ( (DBPROPOPTIONS_OPTIONAL != rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions) &&
(DBPROPOPTIONS_REQUIRED != rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions) ){
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_BADOPTION;
fSetAllProps = FALSE;
}
else if ( !(m_prgproperties[ulIndex].dwFlags & DBPROPFLAGS_WRITE) &&
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt == m_prgproperties[ulIndex].vtType){
// Check if it is been tried to set to default value
if (((rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt == VT_BOOL) &&
((rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.boolVal == VARIANT_TRUE) != m_prgproperties[ulIndex].boolVal)) ||
((rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt == VT_I4) &&
(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.lVal != m_prgproperties[ulIndex].longVal)) ||
((rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt == VT_BSTR) &&
(wcscmp(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.bstrVal,m_prgproperties[ulIndex].pwstrVal))) )
{
fSetAllProps = FALSE;
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSETTABLE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
else
fOnePropSet = TRUE;
}
else if ( ((m_prgproperties[ulIndex].vtType != rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt) &&
(VT_EMPTY != rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt)) ||
(IsValidValue(&rgPropertyIDSets[ulPropertySets].rgProperties[cCount]) == S_FALSE)) {
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_BADVALUE;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
}
else
{
fOnePropSet = TRUE;
if( rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.vt == VT_EMPTY )
{
memcpy( &m_prgproperties[ulIndex], &s_rgprop[m_nPropStartIndex + ulIndex], sizeof(PROPSTRUCT));
}
else
{
// switch on the propid
switch( m_prgproperties[ulIndex].dwPropertyID )
{
case DBPROP_INIT_DATASOURCE:
case DBPROP_AUTH_USERID:
case DBPROP_AUTH_PASSWORD:
case DBPROP_WMIOLEDB_DS_FILTER:
case DBPROP_WMIOLEDB_DS_ATTRIBUTES:
case DBPROP_WMIOLEDB_AUTHORITY:
case DBPROP_WMIOLEDB_QUERYLANGUAGE:
SAFE_DELETE_ARRAY(m_prgproperties[ulIndex].pwstrVal);
m_prgproperties[ulIndex].pwstrVal = new WCHAR [ SysStringLen(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.bstrVal) +1];
if(m_prgproperties[ulIndex].pwstrVal)
{
wcscpy(m_prgproperties[ulIndex].pwstrVal , rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue.bstrVal);
}
else
{
hr = E_OUTOFMEMORY;
fFail = TRUE;
}
break;
case DBPROP_INIT_HWND:
case DBPROP_INIT_MODE:
case DBPROP_UPDATABILITY:
case DBPROP_WMIOLEDB_QUALIFIERS:
case DBPROP_WMIOLEDB_QUALIFIERFLAVOR:
case DBPROP_INIT_PROTECTION_LEVEL:
case DBPROP_INIT_IMPERSONATION_LEVEL:
case DBPROP_WMIOLEDB_OBJECTTYPE:
case DBPROP_INIT_LCID:
case DBPROP_WMIOLEDB_DS_DEREFALIAS:
case DBPROP_WMIOLEDB_DS_SIZELIMIT:
case DBPROP_WMIOLEDB_DS_PAGEDTIMELIMIT:
case DBPROP_WMIOLEDB_DS_SEARCHSCOPE:
case DBPROP_WMIOLEDB_DS_TIMEOUT:
case DBPROP_WMIOLEDB_DS_PAGESIZE:
case DBPROP_WMIOLEDB_DS_TIMELIMIT:
case DBPROP_WMIOLEDB_DS_CHASEREF:
m_prgproperties[ulIndex].longVal = V_I4(&rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue);
break;
case DBPROP_IRowsetChange:
case DBPROP_CANHOLDROWS:
case DBPROP_LITERALIDENTITY:
case DBPROP_OWNUPDATEDELETE:
case DBPROP_OTHERUPDATEDELETE:
case DBPROP_CANFETCHBACKWARDS:
case DBPROP_CANSCROLLBACKWARDS:
case DBPROP_BOOKMARKS:
case DBPROP_WMIOLEDB_FETCHDEEP:
case DBPROP_IRow:
case DBPROP_COL_NULLABLE:
case DBPROP_COL_UNIQUE:
case DBPROP_COL_PRIMARYKEY:
case DBPROP_IRowsetLocate:
case DBPROP_WMIOLEDB_SYSTEMPROPERTIES:
case DBPROP_IGetRow:
case DBPROP_IRowsetRefresh:
case DBPROP_IChapteredRowset:
// case DBPROP_OTHERINSERT:
case DBPROP_REMOVEDELETED:
case DBPROP_WMIOLEDB_PREV_CREATE_TOKEN :
case DBPROP_WMIOLEDB_PREV_ASSIGNPRIMARYTOKEN :
case DBPROP_WMIOLEDB_PREV_LOCK_MEMORY :
case DBPROP_WMIOLEDB_PREV_INCREASE_QUOTA :
case DBPROP_WMIOLEDB_PREV_MACHINE_ACCOUNT :
case DBPROP_WMIOLEDB_PREV_TCB :
case DBPROP_WMIOLEDB_PREV_SECURITY :
case DBPROP_WMIOLEDB_PREV_TAKE_OWNERSHIP :
case DBPROP_WMIOLEDB_PREV_LOAD_DRIVER :
case DBPROP_WMIOLEDB_PREV_SYSTEM_PROFILE :
case DBPROP_WMIOLEDB_PREV_SYSTEMTIME :
case DBPROP_WMIOLEDB_PREV_PROF_SINGLE_PROCESS :
case DBPROP_WMIOLEDB_PREV_INC_BASE_PRIORITY :
case DBPROP_WMIOLEDB_PREV_CREATE_PAGEFILE :
case DBPROP_WMIOLEDB_PREV_CREATE_PERMANENT :
case DBPROP_WMIOLEDB_PREV_BACKUP :
case DBPROP_WMIOLEDB_PREV_RESTORE :
case DBPROP_WMIOLEDB_PREV_SHUTDOWN :
case DBPROP_WMIOLEDB_PREV_DEBUG :
case DBPROP_WMIOLEDB_PREV_AUDIT :
case DBPROP_WMIOLEDB_PREV_SYSTEM_ENVIRONMENT :
case DBPROP_WMIOLEDB_PREV_CHANGE_NOTIFY :
case DBPROP_WMIOLEDB_PREV_REMOTE_SHUTDOWN :
case DBPROP_WMIOLEDB_PREV_UNDOCK :
case DBPROP_WMIOLEDB_PREV_SYNC_AGENT :
case DBPROP_WMIOLEDB_PREV_ENABLE_DELEGATION :
case DBPROP_WMIOLEDB_DS_ASYNCH:
case DBPROP_WMIOLEDB_DS_CACHERESULTS:
case DBPROP_WMIOLEDB_DS_ATTRIBONLY:
case DBPROP_WMIOLEDB_DS_TOMBSTONE:
case DBPROP_WMIOLEDB_ISMETHOD:
m_prgproperties[ulIndex].boolVal = V_BOOL(&rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue);
break;
case DBPROP_INIT_PROMPT:
m_prgproperties[ulIndex].longVal = V_I2(&rgPropertyIDSets[ulPropertySets].rgProperties[cCount].vValue);
}
}
}
}
else
{
rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwStatus = DBPROPSTATUS_NOTSUPPORTED;
fSetAllProps = FALSE;
if(rgPropertyIDSets[ulPropertySets].rgProperties[cCount].dwOptions == DBPROPOPTIONS_OPTIONAL)
fWarn = TRUE;
else
{
fFail = TRUE;
}
}
}
}
}
if(fFail)
{
hr = hr == S_OK ? DB_E_ERRORSOCCURRED: hr;
return hr;
}
// Figure out the retcode
if ( fSetAllProps )
return S_OK ;
else if (fOnePropSet && !fSetAllProps)
return DB_S_ERRORSOCCURRED ;
else if((fSetAllProps == FALSE && fOnePropSet == FALSE &&
fWarn == TRUE && cNoOfProps == 1) &&
(m_propType == ROWSETPROP || m_propType == BINDERPROP))
return DB_S_ERRORSOCCURRED ;
else
return DB_E_ERRORSOCCURRED ;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Gets the number of propertysets to be returned when a special GUID is passed
/////////////////////////////////////////////////////////////////////////////////////////
ULONG CUtilProp::GetNumberOfPropertySets(BOOL fDSOInitialized,const DBPROPIDSET rgPropIDSets[],ULONG cPropIDSets)
{
ULONG cPropSets = 0;
for( ULONG ulIndex = 0 ; ulIndex < cPropIDSets ; ulIndex++)
{
if( DBPROPSET_DBINITALL == rgPropIDSets[ulIndex].guidPropertySet)
{
cPropSets += 2;
}
else
if(fDSOInitialized)
{
if(DBPROPSET_ROWSETALL == rgPropIDSets[ulIndex].guidPropertySet )
{
cPropSets += 2;
}
else
if( DBPROPSET_DATASOURCEALL == rgPropIDSets[ulIndex].guidPropertySet)
{
cPropSets += 0; // as of now there are no datasource info properties
}
else
if( DBPROPSET_DATASOURCEINFOALL == rgPropIDSets[ulIndex].guidPropertySet)
{
cPropSets += 1;
}
else
if( DBPROPSET_SESSIONALL == rgPropIDSets[ulIndex].guidPropertySet )
{
cPropSets += 0; // session properties is yet to be added
}
else
if(DBPROPSET_COLUMNALL == rgPropIDSets[ulIndex].guidPropertySet)
{
cPropSets += 2; // Columns and WMioledb_columns propertysets
}
}
}
return cPropSets;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Fills the propertysets informations to be returned when a special GUID is passed for GetPropertyInfo
/////////////////////////////////////////////////////////////////////////////////////////
void CUtilProp::FillPropertySets(BOOL fDSOInitialized,
const DBPROPIDSET rgPropIDSets[],
ULONG cPropIDSets,
DBPROPINFOSET* pPropInfoSet,
ULONG &cProperties)
{
cProperties = 0;
ULONG ulIndex = 0;
ULONG ulPropSetIndex = 0;
if(cPropIDSets == 0)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
if(fDSOInitialized)
{
/* pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COMMAND;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
*/
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_COLUMN;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COLUMN;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
}
else
for( ; ulIndex < cPropIDSets ;ulIndex++)
{
if( fDSOInitialized == FALSE &&
DBPROPSET_DBINITALL != rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = rgPropIDSets[ulIndex].guidPropertySet;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_ROWSETALL == rgPropIDSets[ulIndex].guidPropertySet )
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
}
else
if( DBPROPSET_DATASOURCEINFOALL == rgPropIDSets[ulIndex].guidPropertySet )
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
else
if( DBPROPSET_DBINITALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
}
else
if(DBPROPSET_COLUMNALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_COLUMN;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COLUMN;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
// NTRaid : 142133
// 07/12/00
// since we don't support any of the property in the following Special GUIL
// this is been commented
/* else
if(DBPROPSET_DATASOURCEALL == rgPropIDSets[ulIndex].guidPropertySet )
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_DATASOURCEALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_CONSTRAINTALL == rgPropIDSets[ulIndex].guidPropertySet )
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_CONSTRAINTALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_INDEXALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_INDEXALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_SESSIONALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_SESSIONALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_TABLEALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_TABLEALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_TRUSTEEALL == rgPropIDSets[ulIndex].guidPropertySet)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_TRUSTEEALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
else
if(DBPROPSET_VIEWALL == rgPropIDSets[ulIndex].guidPropertySet && fDSOInitialized == TRUE)
{
pPropInfoSet[ulPropSetIndex].guidPropertySet = DBPROPSET_VIEWALL;
pPropInfoSet[ulPropSetIndex++].cPropertyInfos = 0;
cProperties += 0;
}
*/ }
}
/////////////////////////////////////////////////////////////////////////////////////////
// Gets the number of propertysets to be returned for a particular type of property object
// if 0 is passed for the number of property set to be retrieved
/////////////////////////////////////////////////////////////////////////////////////////
ULONG CUtilProp::GetNumberOfPropertySets(BOOL fDSOInitialized,DWORD dwBitMask)
{
ULONG cPropSets = 0;
switch(m_propType)
{
case DATASOURCEPROP :
if(fDSOInitialized == TRUE)
cPropSets = 3; // DBINIT & WMIOLEDB_DBINIT && DATASOURCEINFO
else
cPropSets = 2; // DBINIT & WMIOLEDB_DBINIT
break;
case SESSIONPROP :
cPropSets = 0; // number of sesssion propertysets
break;
case COMMANDPROP :
cPropSets = 3; // WMIOLEDB_COMMAND & ROWSET & WMIOLEDB_ROWSET
break;
case ROWSETPROP :
cPropSets = 2; // ROWSET & WMIOLEDB_ROWSET
break;
case BINDERPROP:
switch(dwBitMask)
{
case PROPSET_INIT:
cPropSets = 2;
break;
case PROPSET_DSO:
case PROPSET_DSOINIT:
if(fDSOInitialized == TRUE)
cPropSets = 3;
else
cPropSets = 2;
break;
case PROPSET_SESSION:
cPropSets = 0;
break;
case PROPSET_COMMAND:
cPropSets = 3;
break;
case PROPSET_ROWSET:
cPropSets = 2;
break;
case PROPSET_COLUMN:
cPropSets = 2;
break;
default:
cPropSets = NUMBER_OF_SUPPORTED_PROPERTY_SETS; // all propertysets supported
}
break;
case COLUMNPROP:
cPropSets = 2; // COLUMNS & WMIOLEDB_COLUMN
break;
};
return cPropSets;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Reset all the properties to default properties
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::ResetProperties()
{
ULONG nPropStartIndex = 0;
switch(m_propType)
{
case DATASOURCEPROP :
nPropStartIndex = 0;
break;
case SESSIONPROP :
nPropStartIndex = START_OF_SUPPORTED_SESSION_PROPERTIES;
break;
case COMMANDPROP :
nPropStartIndex = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
break;
case ROWSETPROP :
nPropStartIndex = START_OF_SUPPORTED_ROWSET_PROPERTIES;
break;
case BINDERPROP:
nPropStartIndex = 0;
break;
};
if(m_cProperties > 0)
{
memcpy(m_prgproperties, &s_rgprop[nPropStartIndex], sizeof(PROPSTRUCT) * m_cProperties );
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Fills the different PropertIDsets when the number of propertysets
// requested for GetProperties is 0
/////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::FillPropStruct(BOOL fDSOInitialized,DWORD dwBitMask,DBPROPSET* pPropSet)
{
HRESULT hr = S_OK;
ULONG lIndex = 0;
if(pPropSet == NULL)
{
hr = E_FAIL;
}
else
switch(m_propType)
{
case DATASOURCEPROP :
pPropSet[lIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
if(fDSOInitialized == TRUE)
{
pPropSet[lIndex].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
break;
case SESSIONPROP :
break;
case COMMANDPROP :
/* pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COMMAND;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
*/
pPropSet[lIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
break;
case ROWSETPROP :
pPropSet[lIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
break;
case BINDERPROP:
switch(dwBitMask)
{
case PROPSET_INIT:
pPropSet[lIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropSet[lIndex].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
break;
case PROPSET_DSO:
case PROPSET_DSOINIT:
pPropSet[lIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
if(fDSOInitialized == TRUE)
{
pPropSet[lIndex].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
break;
case PROPSET_SESSION:
break;
case PROPSET_COMMAND:
/* pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COMMAND;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
*/
pPropSet[lIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
break;
case PROPSET_ROWSET:
pPropSet[lIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
break;
case PROPSET_COLUMN:
pPropSet[lIndex].guidPropertySet = DBPROPSET_COLUMN;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COLUMN;
pPropSet[lIndex++].cProperties = START_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
break;
default:
pPropSet[lIndex].guidPropertySet = DBPROPSET_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_DBINIT;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_DATASOURCEINFO;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
/* pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COMMAND;
pPropSet[lIndex++].cProperties = START_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
*/
pPropSet[lIndex].guidPropertySet = DBPROPSET_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_ROWSET;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_COLUMN;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COLUMN;
pPropSet[lIndex++].cProperties = START_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
};
break;
case COLUMNPROP:
pPropSet[lIndex].guidPropertySet = DBPROPSET_COLUMN;
pPropSet[lIndex++].cProperties = NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
pPropSet[lIndex].guidPropertySet = DBPROPSET_WMIOLEDB_COLUMN;
pPropSet[lIndex++].cProperties = START_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
};
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Checks if the PropertysetIDs are proper
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CUtilProp::IsValidPropertySet(BOOL fDSOInitialized,const GUID guidPropset)
{
HRESULT hr = S_OK;
/*
if(guidPropset == DBPROPSET_PROPERTIESINERROR &&
(m_propType == DATASOURCEPROP || m_propType == COMMANDPROP))
return hr;
else
return DB_S_ERRORSOCCURRED;
*/
switch(m_propType)
{
case DATASOURCEPROP :
if(!( guidPropset == DBPROPSET_DBINIT ||
(guidPropset == DBPROPSET_DATASOURCEINFO && fDSOInitialized == TRUE) ||
guidPropset == DBPROPSET_WMIOLEDB_DBINIT ||
guidPropset == DBPROPSET_PROPERTIESINERROR))
{
hr = DB_S_ERRORSOCCURRED;
}
break;
case SESSIONPROP :
if(!( guidPropset == DBPROPSET_SESSION))
{
hr = DB_S_ERRORSOCCURRED;
}
break;
case COMMANDPROP :
if(!( guidPropset == DBPROPSET_ROWSET ||
guidPropset == DBPROPSET_WMIOLEDB_ROWSET ||
// guidPropset == DBPROPSET_WMIOLEDB_COMMAND ||
guidPropset == DBPROPSET_PROPERTIESINERROR))
{
hr = DB_S_ERRORSOCCURRED;
}
case ROWSETPROP :
if(!( guidPropset == DBPROPSET_ROWSET ||
guidPropset == DBPROPSET_WMIOLEDB_ROWSET))
{
hr = DB_S_ERRORSOCCURRED;
}
break;
case BINDERPROP :
hr = S_OK;
break;
case COLUMNPROP :
if(!( guidPropset == DBPROPSET_COLUMN ||
guidPropset == DBPROPSET_WMIOLEDB_COLUMN))
{
hr = DB_S_ERRORSOCCURRED;
}
break;
};
return hr;
}
BOOL CUtilProp::IsPropertySetSupported(const GUID guidPropset)
{
BOOL bRet = FALSE;
if(guidPropset == DBPROPSET_PROPERTIESINERROR ||
guidPropset == DBPROPSET_DBINIT ||
guidPropset == DBPROPSET_DATASOURCEINFO ||
guidPropset == DBPROPSET_WMIOLEDB_DBINIT ||
guidPropset == DBPROPSET_SESSION ||
guidPropset == DBPROPSET_ROWSET ||
guidPropset == DBPROPSET_WMIOLEDB_ROWSET ||
guidPropset == DBPROPSET_COLUMN ||
guidPropset == DBPROPSET_WMIOLEDB_COLUMN )
// || guidPropset == DBPROPSET_WMIOLEDB_COMMAND )
{
bRet = TRUE;
};
return bRet;
}
ULONG CUtilProp::GetNumberofPropInfoToBeReturned(BOOL bDSOInitialized,
ULONG cPropertyIDSets,
const DBPROPIDSET rgPropertyIDSets[])
{
int nProps = 0;
if(cPropertyIDSets == 0)
{
nProps = NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES +
NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES;
if(bDSOInitialized)
{
nProps = nProps + NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES +
NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES +
NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES +
NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES +
NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES +
NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
}
else
for( ULONG ulPropSets = 0; ulPropSets < cPropertyIDSets;ulPropSets++)
{
if (rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_DBINIT)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_DBINIT_PROPERTIES ;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if (rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_WMIOLEDB_DBINIT)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_WMIOLEDB_DBINIT_PROPERTIES ;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if( bDSOInitialized )
{
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_DATASOURCEINFO)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_DATASOURCEINFO_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_WMIOLEDB_COMMAND)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_WMIOLEDB_COMMAND_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_ROWSET)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_ROWSET_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_WMIOLEDB_ROWSET)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_WMIOLEDB_ROWSET_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_COLUMN)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_COLUMN_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
else
if(rgPropertyIDSets[ulPropSets].guidPropertySet == DBPROPSET_WMIOLEDB_COLUMN)
{
if(rgPropertyIDSets[ulPropSets].cPropertyIDs == 0 )
{
nProps += NUMBER_OF_SUPPORTED_WMIOLEDB_COLUMN_PROPERTIES;
}
else
{
nProps += rgPropertyIDSets[ulPropSets].cPropertyIDs;
}
}
}
}
return nProps;
}
HRESULT CUtilProp::GetConnectionInitProperties(DBPROPSET** pprgPropertySets)
{
DBPROPIDSET rgPropertyIDSets[1];
ULONG cPropertySets;
DBPROPID rgPropId[NUMBER_OF_CONNECTIONINIT_PROP];
rgPropId[0] = DBPROP_INIT_DATASOURCE;
rgPropId[1] = DBPROP_INIT_PROTECTION_LEVEL;
rgPropId[2] = DBPROP_INIT_IMPERSONATION_LEVEL;
rgPropId[3] = DBPROP_AUTH_USERID;
rgPropId[4] = DBPROP_AUTH_PASSWORD;
rgPropId[5] = DBPROP_INIT_LCID;
rgPropId[6] = DBPROP_WMIOLEDB_AUTHORITY;
rgPropertyIDSets[0].guidPropertySet = DBPROPSET_DBINIT;
rgPropertyIDSets[0].rgPropertyIDs = rgPropId;
rgPropertyIDSets[0].cPropertyIDs = 7;
return GetProperties( PROPSET_DSO,1, rgPropertyIDSets,&cPropertySets,pprgPropertySets );
}
HRESULT CUtilProp::SetDefaultValueForStringProperties(PROPSTRUCT * prgPropeties,ULONG cProperties)
{
HRESULT hr = S_OK;
for(ULONG lProperties = 0; lProperties < cProperties ; lProperties++)
{
switch(prgPropeties[lProperties].dwPropertyID)
{
case DBPROP_INIT_DATASOURCE:
case DBPROP_AUTH_USERID:
case DBPROP_AUTH_PASSWORD:
case DBPROP_WMIOLEDB_DS_FILTER:
case DBPROP_WMIOLEDB_DS_ATTRIBUTES:
case DBPROP_WMIOLEDB_AUTHORITY:
prgPropeties[lProperties].pwstrVal = NULL;
break;
case DBPROP_WMIOLEDB_QUERYLANGUAGE:
prgPropeties[lProperties].pwstrVal = new WCHAR[wcslen(DEFAULTQUERYLANG) + 1];
if(prgPropeties[lProperties].pwstrVal)
{
wcscpy(prgPropeties[lProperties].pwstrVal,DEFAULTQUERYLANG);
}
else
{
hr = E_OUTOFMEMORY;
}
break;
}
}
return hr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
// This class manages the memory allocations of all the property structs
//
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::AllocDBPROPINFOSET(DBPROPINFOSET *& pPropInfoSet, const ULONG cProps)
{
HRESULT hr = S_OK;
pPropInfoSet = (DBPROPINFOSET*) g_pIMalloc->Alloc(cProps * sizeof( DBPROPINFOSET ));
if ( !pPropInfoSet ){
hr = E_OUTOFMEMORY ;
}
else{
memset( pPropInfoSet, 0, (cProps * sizeof( DBPROPINFOSET )));
}
return hr;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::AllocDESCRIPTBuffer(WCHAR *& pDescBuffer, WCHAR** ppDescBuffer, ULONG cProperties)
{
HRESULT hr = S_OK;
if ( ppDescBuffer ){
pDescBuffer = (WCHAR*)g_pIMalloc->Alloc(cProperties * CCH_GETPROPERTYINFO_DESCRIP_BUFFER_SIZE * sizeof(WCHAR) );
if( pDescBuffer ){
memset(pDescBuffer, 0, (cProperties * CCH_GETPROPERTYINFO_DESCRIP_BUFFER_SIZE * sizeof(WCHAR)));
*ppDescBuffer = pDescBuffer;
}
else{
hr = E_OUTOFMEMORY ;
}
}
return hr;
}
//=====================================================================================================
HRESULT CPropertyMemoryMgr::AllocDBPROPINFO(DBPROPINFO *& pPropInfo, DBPROPINFOSET * pPropInfoSet, ULONG ulPropSets)
{
HRESULT hr = S_OK;
pPropInfo = (DBPROPINFO*) g_pIMalloc->Alloc(sizeof( DBPROPINFO ) * pPropInfoSet[ulPropSets].cPropertyInfos);
if( pPropInfo ){
}
else{
hr = E_OUTOFMEMORY;
}
return hr;
}
//=====================================================================================================
HRESULT CPropertyMemoryMgr::AllocateDBPROP(DBPROP*& ppProp, const ULONG cProperties)
{
HRESULT hr = E_INVALIDARG;
if ( NULL != ppProp && NULL == ppProp && cProperties > 0 ) {
ppProp = (DBPROP*)g_pIMalloc->Alloc(cProperties * sizeof DBPROP);
// *ppProp = new DBPROP[cProperties];
if ( NULL == ppProp ){
hr = E_OUTOFMEMORY;
}
else {
memset(ppProp, 0, sizeof DBPROP);
hr = S_OK;
}
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::AllocDBPROPSET(DBPROPSET*& ppPropSet, const ULONG cPropSets)
{
HRESULT hr = E_INVALIDARG;
if ( NULL != ppPropSet && NULL == ppPropSet && cPropSets > 0 ) {
ppPropSet = (DBPROPSET*)g_pIMalloc->Alloc(cPropSets * sizeof DBPROPSET);
if ( NULL == ppPropSet ){
hr = E_OUTOFMEMORY;
}
else {
memset(ppPropSet, 0, cPropSets * sizeof DBPROPSET);
hr = S_OK;
}
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::AllocDBCOLUMNDESC(DBCOLUMNDESC*& ppCOLUMNDESC, const ULONG cColumnDescs)
{
HRESULT hr = E_INVALIDARG;
if ( NULL != ppCOLUMNDESC && NULL == ppCOLUMNDESC && cColumnDescs > 0 ) {
ppCOLUMNDESC = (DBCOLUMNDESC*)g_pIMalloc->Alloc(cColumnDescs * sizeof DBCOLUMNDESC);
if ( NULL == ppCOLUMNDESC ){
hr = E_OUTOFMEMORY;
}
else {
memset(ppCOLUMNDESC, 0, cColumnDescs * sizeof DBCOLUMNDESC);
hr = S_OK;
}
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPropertyMemoryMgr::FreeDBPROPINFOSET(DBPROPINFOSET *& pPropInfoSet, const ULONG cProps)
{
if (pPropInfoSet){
for(ULONG i = 0 ; i < cProps ; i++)
{
if(pPropInfoSet[i].rgPropertyInfos)
{
FreeDBPROPINFO(pPropInfoSet[i].rgPropertyInfos , pPropInfoSet[i].cPropertyInfos);
}
}
g_pIMalloc->Free(pPropInfoSet);
pPropInfoSet = NULL;
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPropertyMemoryMgr::FreeDBPROPINFO(DBPROPINFO *& pPropInfo, const ULONG cProps)
{
if(pPropInfo)
{
for(ULONG i = 0 ; i < cProps; i++)
{
VariantClear(&pPropInfo[i].vValues);
}
g_pIMalloc->Free(pPropInfo);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPropertyMemoryMgr::FreeDESCRIPTBuffer(WCHAR *& pDescBuffer, WCHAR** ppDescBuffer)
{
if ( ppDescBuffer ) {
*ppDescBuffer = NULL;
}
if( pDescBuffer ){
g_pIMalloc->Free(pDescBuffer);
pDescBuffer = NULL;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPropertyMemoryMgr::FreeDBCOLUMNDESC(DBCOLUMNDESC rgColumnDescs[], LONG cColumns)
{
if ( rgColumnDescs ){
for ( LONG i = 0; i < cColumns; i++ ) {
//free pointers
SysFreeString((BSTR)(rgColumnDescs[i].pwszTypeName));
if ( rgColumnDescs[i].pTypeInfo ) {
rgColumnDescs[i].pTypeInfo->Release();
rgColumnDescs[i].pTypeInfo = NULL;
}
//free sub structs
FreeDBPROPSET(rgColumnDescs[i].cPropertySets,rgColumnDescs[i].rgPropertySets);
rgColumnDescs[i].rgPropertySets = NULL;
}
g_pIMalloc->Free(rgColumnDescs);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::CopyDBPROPSET(DBPROPSET*& pDestination, DBPROPSET*& pSource)
{
if ( NULL == pSource ||
NULL == pDestination ||
NULL != pDestination->rgProperties )
return E_INVALIDARG;
memcpy(pDestination, pSource, sizeof DBPROPSET);
memset(pSource->rgProperties, 0, sizeof DBPROPSET);
return S_OK;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CPropertyMemoryMgr::CopyDBCOLUMNDESC(DBCOLUMNDESC*& pDestination, DBCOLUMNDESC*& pSource)
{
if ( NULL == pSource ||
NULL == pDestination ||
NULL != pDestination->rgPropertySets ) //must not contain data
return E_INVALIDARG;
memcpy(pDestination, pSource, sizeof DBCOLUMNDESC);
memset(pSource->rgPropertySets, 0, sizeof DBCOLUMNDESC);
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// CPriveligeToken class implementation
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor
//////////////////////////////////////////////////////////////////////////////////////////////////////////
CPreviligeToken::CPreviligeToken()
{
m_nMemAllocated = 0;
m_pPrevTokenPrev = NULL;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Destructor
//////////////////////////////////////////////////////////////////////////////////////////////////////////
CPreviligeToken::~CPreviligeToken()
{
SAFE_DELETE_ARRAY(m_pPrevTokenPrev);
}
// NTRaid: 136443
// 07/05/00
HRESULT CPreviligeToken::FInit()
{
HRESULT hr = S_OK;
m_nMemAllocated = sizeof(TOKEN_PRIVILEGES) + NUMBEROF_PRIVELAGES * sizeof(LUID_AND_ATTRIBUTES);
m_pPrevTokenPrev = (TOKEN_PRIVILEGES *)new BYTE [m_nMemAllocated];
if(m_pPrevTokenPrev)
{
memset(m_pPrevTokenPrev,0,m_nMemAllocated);
GetCurrentPrivelegeToken();
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to adjust the privileges
//////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPreviligeToken::AdjustTokenPrivileges(ULONG cProps , DBPROP rgProp[])
{
BOOL bRet = FALSE;
HANDLE hToken = NULL;
/* DWORD dwError;
ConvertDBPropToPriveleges(cProps,rgProp);
dwError = GetLastError();
// if(bRet = OpenThreadToken(GetCurrentThread(),TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,FALSE,&hToken))
if(OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,&hToken))
*/
OpenToken(hToken);
if(hToken != NULL)
{
bRet = ::AdjustTokenPrivileges(hToken,
FALSE,
m_pPrevTokenPrev,
0,
NULL,
NULL);
CloseHandle(hToken);
}
return bRet;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to Set the DBPROP structure accoriding to the current privileges
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPreviligeToken::SetDBPROPForPrivileges(ULONG cProps , DBPROP * rgProp)
{
ULONG_PTR lPropValTemp = 1;
ULONG lSize = PRIVILEGE_NAMESIZE;
LONG lIndex = -1;
TCHAR strName[PRIVILEGE_NAMESIZE];
memset(strName,0,PRIVILEGE_NAMESIZE * sizeof(TCHAR));
for(ULONG_PTR i = 0 ; i < m_pPrevTokenPrev->PrivilegeCount ; i++)
{
lIndex = -1;
LookupPrivilegeName(NULL,&((m_pPrevTokenPrev->Privileges[i]).Luid) ,&strName[0],&lSize);
if(!_tcscmp(strName,SE_CREATE_TOKEN_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_CREATE_TOKEN,&lIndex);
}
else if(!_tcscmp(strName,SE_ASSIGNPRIMARYTOKEN_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_ASSIGNPRIMARYTOKEN,&lIndex);
}
else if(!_tcscmp(strName,SE_LOCK_MEMORY_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_LOCK_MEMORY,&lIndex);
}
else if(!_tcscmp(strName,SE_INCREASE_QUOTA_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_INCREASE_QUOTA,&lIndex);
}
else if(!_tcscmp(strName,SE_MACHINE_ACCOUNT_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_MACHINE_ACCOUNT,&lIndex);
}
else if(!_tcscmp(strName,SE_TCB_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_TCB,&lIndex);
}
else if(!_tcscmp(strName,SE_SECURITY_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SECURITY,&lIndex);
}
else if(!_tcscmp(strName,SE_TAKE_OWNERSHIP_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_TAKE_OWNERSHIP,&lIndex);
}
else if(!_tcscmp(strName,SE_LOAD_DRIVER_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_LOAD_DRIVER,&lIndex);
}
else if(!_tcscmp(strName,SE_SYSTEM_PROFILE_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SYSTEM_PROFILE,&lIndex);
}
else if(!_tcscmp(strName,SE_SYSTEMTIME_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SYSTEMTIME,&lIndex);
}
else if(!_tcscmp(strName,SE_PROF_SINGLE_PROCESS_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_PROF_SINGLE_PROCESS,&lIndex);
}
else if(!_tcscmp(strName,SE_INC_BASE_PRIORITY_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_INC_BASE_PRIORITY,&lIndex);
}
else if(!_tcscmp(strName,SE_CREATE_PAGEFILE_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_CREATE_PAGEFILE,&lIndex);
}
else if(!_tcscmp(strName,SE_CREATE_PERMANENT_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_CREATE_PERMANENT,&lIndex);
}
else if(!_tcscmp(strName,SE_BACKUP_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_BACKUP,&lIndex);
}
else if(!_tcscmp(strName,SE_RESTORE_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_RESTORE,&lIndex);
}
else if(!_tcscmp(strName,SE_SHUTDOWN_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SHUTDOWN,&lIndex);
}
else if(!_tcscmp(strName,SE_DEBUG_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_DEBUG,&lIndex);
}
else if(!_tcscmp(strName,SE_AUDIT_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_AUDIT,&lIndex);
}
else if(!_tcscmp(strName,SE_SYSTEM_ENVIRONMENT_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SYSTEM_ENVIRONMENT,&lIndex);
}
else if(!_tcscmp(strName,SE_CHANGE_NOTIFY_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_CHANGE_NOTIFY,&lIndex);
}
else if(!_tcscmp(strName,SE_REMOTE_SHUTDOWN_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_REMOTE_SHUTDOWN,&lIndex);
}
else if(!_tcscmp(strName,SE_UNDOCK_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_UNDOCK,&lIndex);
}
else if(!_tcscmp(strName,SE_SYNC_AGENT_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_SYNC_AGENT,&lIndex);
}
else if(!_tcscmp(strName,SE_ENABLE_DELEGATION_NAME))
{
GetPropIndex(cProps,rgProp,DBPROP_WMIOLEDB_PREV_ENABLE_DELEGATION,&lIndex);
}
if(lIndex >= 0)
{
if(m_pPrevTokenPrev->Privileges[i].Attributes == SE_PRIVILEGE_ENABLED)
{
rgProp[lIndex].vValue.boolVal = VARIANT_TRUE;
}
else
{
rgProp[lIndex].vValue.boolVal = VARIANT_FALSE;
}
}
memset(strName,0,PRIVILEGE_NAMESIZE * sizeof(TCHAR));
} // for loop
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to get priveleges from the DBPROP structure
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPreviligeToken::ConvertDBPropToPriveleges(ULONG cProps , DBPROP rgProp[])
{
LUID luid;
ULONG_PTR lPropValTemp = 1;
TCHAR * pName = NULL;
BOOL bPrivelege = TRUE;
m_pPrevTokenPrev->PrivilegeCount = 0;
for(ULONG i = 0 ; i < cProps && lPropValTemp != 0 ; i++)
{
bPrivelege = TRUE;
switch(rgProp[i].dwPropertyID)
{
case DBPROP_WMIOLEDB_PREV_CREATE_TOKEN :
pName = SE_CREATE_TOKEN_NAME;
break;
case DBPROP_WMIOLEDB_PREV_ASSIGNPRIMARYTOKEN:
pName = SE_ASSIGNPRIMARYTOKEN_NAME;
break;
case DBPROP_WMIOLEDB_PREV_LOCK_MEMORY :
pName = SE_LOCK_MEMORY_NAME;
break;
case DBPROP_WMIOLEDB_PREV_INCREASE_QUOTA:
pName = SE_INCREASE_QUOTA_NAME;
break;
case DBPROP_WMIOLEDB_PREV_MACHINE_ACCOUNT :
pName = SE_MACHINE_ACCOUNT_NAME;
break;
case DBPROP_WMIOLEDB_PREV_TCB :
pName = SE_TCB_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SECURITY :
pName = SE_SECURITY_NAME;
break;
case DBPROP_WMIOLEDB_PREV_TAKE_OWNERSHIP:
pName = SE_TAKE_OWNERSHIP_NAME;
break;
case DBPROP_WMIOLEDB_PREV_LOAD_DRIVER:
pName = SE_LOAD_DRIVER_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SYSTEM_PROFILE :
pName = SE_SYSTEM_PROFILE_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SYSTEMTIME:
pName = SE_SYSTEMTIME_NAME;
break;
case DBPROP_WMIOLEDB_PREV_PROF_SINGLE_PROCESS:
pName = SE_PROF_SINGLE_PROCESS_NAME;
break;
case DBPROP_WMIOLEDB_PREV_INC_BASE_PRIORITY:
pName = SE_INC_BASE_PRIORITY_NAME;
break;
case DBPROP_WMIOLEDB_PREV_CREATE_PAGEFILE :
pName = SE_CREATE_PAGEFILE_NAME;
break;
case DBPROP_WMIOLEDB_PREV_CREATE_PERMANENT:
pName = SE_CREATE_PERMANENT_NAME;
break;
case DBPROP_WMIOLEDB_PREV_BACKUP:
pName = SE_BACKUP_NAME;
break;
case DBPROP_WMIOLEDB_PREV_RESTORE:
pName = SE_RESTORE_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SHUTDOWN:
pName = SE_SHUTDOWN_NAME;
break;
case DBPROP_WMIOLEDB_PREV_DEBUG:
pName = SE_DEBUG_NAME;
break;
case DBPROP_WMIOLEDB_PREV_AUDIT:
pName = SE_AUDIT_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SYSTEM_ENVIRONMENT:
pName = SE_SYSTEM_ENVIRONMENT_NAME;
break;
case DBPROP_WMIOLEDB_PREV_CHANGE_NOTIFY :
pName = SE_CHANGE_NOTIFY_NAME;
break;
case DBPROP_WMIOLEDB_PREV_REMOTE_SHUTDOWN :
pName = SE_REMOTE_SHUTDOWN_NAME;
break;
case DBPROP_WMIOLEDB_PREV_UNDOCK:
pName = SE_UNDOCK_NAME;
break;
case DBPROP_WMIOLEDB_PREV_SYNC_AGENT:
pName = SE_SYNC_AGENT_NAME;
break;
case DBPROP_WMIOLEDB_PREV_ENABLE_DELEGATION:
pName = SE_ENABLE_DELEGATION_NAME;
break;
default:
bPrivelege = FALSE;
}
if(bPrivelege)
{
LookupPrivilegeValue(NULL,pName,&luid);
m_pPrevTokenPrev->Privileges[m_pPrevTokenPrev->PrivilegeCount].Luid = luid;
//=============================================================================================
// Any setting other than SE_PRIVILEGE_ENABLED is interpreted by AdjustTokenPrivileges
// as a DISABLE request for the privelege
//=============================================================================================
m_pPrevTokenPrev->Privileges[m_pPrevTokenPrev->PrivilegeCount].Attributes = (rgProp[i].vValue.boolVal == VARIANT_TRUE)
? SE_PRIVILEGE_ENABLED : SE_PRIVILEGE_ENABLED_BY_DEFAULT;
m_pPrevTokenPrev->PrivilegeCount++;
pName = NULL;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Funciton to get the current privelege token
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPreviligeToken::GetCurrentPrivelegeToken()
{
HANDLE hToken = NULL;
HANDLE hThread = NULL;
BOOL bRet = FALSE;
/*
hThread = GetCurrentProcess();
dwError = GetLastError();
hThread = GetCurrentThread();
if(OpenThreadToken(hThread,TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,TRUE,&hToken))
// if(OpenProcessToken(hThread,TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,&hToken))
*/
OpenToken(hToken);
if(hToken != NULL)
{
DWORD dwLen = m_nMemAllocated;
bRet = GetTokenInformation(hToken,
TokenPrivileges,
m_pPrevTokenPrev,
dwLen,
&dwLen);
CloseHandle(hToken);
}
// CloseHandle(hThread);
// dwError = GetLastError();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to adjust the privileges
//////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPreviligeToken::AdjustTokenPrivileges(ULONG ulProperty)
{
BOOL bRet = FALSE;
HANDLE hToken = NULL;
DWORD dwError = 0;
ConvertDBPropToPriveleges(ulProperty);
/*
dwError = GetLastError();
// if(bRet = OpenThreadToken(GetCurrentThread(),TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,FALSE,&hToken))
if(OpenProcessToken(GetCurrentProcess(),TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,&hToken))
*/
OpenToken(hToken);
if(hToken != NULL)
{
bRet = ::AdjustTokenPrivileges(hToken,
FALSE,
m_pPrevTokenPrev,
0,
NULL,
NULL);
CloseHandle(hToken);
}
dwError = GetLastError();
return bRet;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to Set the DBPROP structure accoriding to the current privileges
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPreviligeToken::SetDBPROPForPrivileges(ULONG &ulProperty)
{
ULONG_PTR lPropValTemp = 1;
ULONG lSize = PRIVILEGE_NAMESIZE;
LONG lIndex = -1;
ULONG ulCurPrivilege = 0;
TCHAR strName[PRIVILEGE_NAMESIZE];
memset(strName,0,PRIVILEGE_NAMESIZE * sizeof(TCHAR));
ulProperty = 0;
for(ULONG_PTR i = 0 ; i < NUMBER_OF_PREVILAGE_PROPERTIES ; i++)
{
ulCurPrivilege = 0;
LookupPrivilegeName(NULL,&((m_pPrevTokenPrev->Privileges[i]).Luid) ,&strName[0],&lSize);
if(!_tcscmp(strName,SE_CREATE_TOKEN_NAME))
{
ulCurPrivilege = DBPROPVAL_CREATE_TOKEN;
}
else if(!_tcscmp(strName,SE_ASSIGNPRIMARYTOKEN_NAME))
{
ulCurPrivilege = DBPROPVAL_ASSIGNPRIMARYTOKEN;
}
else if(!_tcscmp(strName,SE_LOCK_MEMORY_NAME))
{
ulCurPrivilege = DBPROPVAL_LOCK_MEMORY;
}
else if(!_tcscmp(strName,SE_INCREASE_QUOTA_NAME))
{
ulCurPrivilege = DBPROPVAL_INCREASE_QUOTA;
}
else if(!_tcscmp(strName,SE_MACHINE_ACCOUNT_NAME))
{
ulCurPrivilege = DBPROPVAL_MACHINE_ACCOUNT;
}
else if(!_tcscmp(strName,SE_TCB_NAME))
{
ulCurPrivilege = DBPROPVAL_TCB;
}
else if(!_tcscmp(strName,SE_SECURITY_NAME))
{
ulCurPrivilege = DBPROPVAL_SECURITY;
}
else if(!_tcscmp(strName,SE_TAKE_OWNERSHIP_NAME))
{
ulCurPrivilege = DBPROPVAL_TAKE_OWNERSHIP;
}
else if(!_tcscmp(strName,SE_LOAD_DRIVER_NAME))
{
ulCurPrivilege = DBPROPVAL_LOAD_DRIVER;
}
else if(!_tcscmp(strName,SE_SYSTEM_PROFILE_NAME))
{
ulCurPrivilege = DBPROPVAL_SYSTEM_PROFILE;
}
else if(!_tcscmp(strName,SE_SYSTEMTIME_NAME))
{
ulCurPrivilege = DBPROPVAL_SYSTEMTIME;
}
else if(!_tcscmp(strName,SE_PROF_SINGLE_PROCESS_NAME))
{
ulCurPrivilege = DBPROPVAL_PROF_SINGLE_PROCESS;
}
else if(!_tcscmp(strName,SE_INC_BASE_PRIORITY_NAME))
{
ulCurPrivilege = DBPROPVAL_INC_BASE_PRIORITY;
}
else if(!_tcscmp(strName,SE_CREATE_PAGEFILE_NAME))
{
ulCurPrivilege = DBPROPVAL_CREATE_PAGEFILE;
}
else if(!_tcscmp(strName,SE_CREATE_PERMANENT_NAME))
{
ulCurPrivilege = DBPROPVAL_CREATE_PERMANENT;
}
else if(!_tcscmp(strName,SE_BACKUP_NAME))
{
ulCurPrivilege = DBPROPVAL_BACKUP;
}
else if(!_tcscmp(strName,SE_RESTORE_NAME))
{
ulCurPrivilege = DBPROPVAL_RESTORE;
}
else if(!_tcscmp(strName,SE_SHUTDOWN_NAME))
{
ulCurPrivilege = DBPROPVAL_SHUTDOWN;
}
else if(!_tcscmp(strName,SE_DEBUG_NAME))
{
ulCurPrivilege = DBPROPVAL_DEBUG;
}
else if(!_tcscmp(strName,SE_AUDIT_NAME))
{
ulCurPrivilege = DBPROPVAL_AUDIT;
}
else if(!_tcscmp(strName,SE_SYSTEM_ENVIRONMENT_NAME))
{
ulCurPrivilege = DBPROPVAL_SYSTEM_ENVIRONMENT;
}
else if(!_tcscmp(strName,SE_CHANGE_NOTIFY_NAME))
{
ulCurPrivilege = DBPROPVAL_CHANGE_NOTIFY;
}
else if(!_tcscmp(strName,SE_REMOTE_SHUTDOWN_NAME))
{
ulCurPrivilege = DBPROPVAL_REMOTE_SHUTDOWN;
}
else if(!_tcscmp(strName,SE_UNDOCK_NAME))
{
ulCurPrivilege = DBPROPVAL_UNDOCK;
}
else if(!_tcscmp(strName,SE_SYNC_AGENT_NAME))
{
ulCurPrivilege = DBPROPVAL_SYNC_AGENT;
}
else if(!_tcscmp(strName,SE_ENABLE_DELEGATION_NAME))
{
ulCurPrivilege = DBPROPVAL_ENABLE_DELEGATION;
}
if(ulCurPrivilege != 0)
{
if(m_pPrevTokenPrev->Privileges[i].Attributes == SE_PRIVILEGE_ENABLED)
{
ulProperty = ulProperty | ulCurPrivilege;
}
else
{
ulProperty = ulProperty | !(ulCurPrivilege);
}
}
memset(strName,0,PRIVILEGE_NAMESIZE * sizeof(TCHAR));
} // for loop
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to get priveleges from the DBPROP structure
//////////////////////////////////////////////////////////////////////////////////////////////////////////
void CPreviligeToken::ConvertDBPropToPriveleges(ULONG ulProperty)
{
LUID luid;
ULONG lPropValTemp = 1;
ULONG lProp = 0;
TCHAR * pName = NULL;
BOOL bPrivelege = TRUE;
m_pPrevTokenPrev->PrivilegeCount = 0;
for(ULONG i = 0 ; i < NUMBER_OF_PREVILAGE_PROPERTIES ; i++)
{
bPrivelege = TRUE;
switch(lPropValTemp)
{
case DBPROPVAL_CREATE_TOKEN :
pName = SE_CREATE_TOKEN_NAME;
break;
case DBPROPVAL_ASSIGNPRIMARYTOKEN:
pName = SE_ASSIGNPRIMARYTOKEN_NAME;
break;
case DBPROPVAL_LOCK_MEMORY :
pName = SE_LOCK_MEMORY_NAME;
break;
case DBPROPVAL_INCREASE_QUOTA:
pName = SE_INCREASE_QUOTA_NAME;
break;
case DBPROPVAL_MACHINE_ACCOUNT :
pName = SE_MACHINE_ACCOUNT_NAME;
break;
case DBPROPVAL_TCB :
pName = SE_TCB_NAME;
break;
case DBPROPVAL_SECURITY :
pName = SE_SECURITY_NAME;
break;
case DBPROPVAL_TAKE_OWNERSHIP:
pName = SE_TAKE_OWNERSHIP_NAME;
break;
case DBPROPVAL_LOAD_DRIVER:
pName = SE_LOAD_DRIVER_NAME;
break;
case DBPROPVAL_SYSTEM_PROFILE :
pName = SE_SYSTEM_PROFILE_NAME;
break;
case DBPROPVAL_SYSTEMTIME:
pName = SE_SYSTEMTIME_NAME;
break;
case DBPROPVAL_PROF_SINGLE_PROCESS:
pName = SE_PROF_SINGLE_PROCESS_NAME;
break;
case DBPROPVAL_INC_BASE_PRIORITY:
pName = SE_INC_BASE_PRIORITY_NAME;
break;
case DBPROPVAL_CREATE_PAGEFILE :
pName = SE_CREATE_PAGEFILE_NAME;
break;
case DBPROPVAL_CREATE_PERMANENT:
pName = SE_CREATE_PERMANENT_NAME;
break;
case DBPROPVAL_BACKUP:
pName = SE_BACKUP_NAME;
break;
case DBPROPVAL_RESTORE:
pName = SE_RESTORE_NAME;
break;
case DBPROPVAL_SHUTDOWN:
pName = SE_SHUTDOWN_NAME;
break;
case DBPROPVAL_DEBUG:
pName = SE_DEBUG_NAME;
break;
case DBPROPVAL_AUDIT:
pName = SE_AUDIT_NAME;
break;
case DBPROPVAL_SYSTEM_ENVIRONMENT:
pName = SE_SYSTEM_ENVIRONMENT_NAME;
break;
case DBPROPVAL_CHANGE_NOTIFY :
pName = SE_CHANGE_NOTIFY_NAME;
break;
case DBPROPVAL_REMOTE_SHUTDOWN :
pName = SE_REMOTE_SHUTDOWN_NAME;
break;
case DBPROPVAL_UNDOCK:
pName = SE_UNDOCK_NAME;
break;
case DBPROPVAL_SYNC_AGENT:
pName = SE_SYNC_AGENT_NAME;
break;
case DBPROPVAL_ENABLE_DELEGATION:
pName = SE_ENABLE_DELEGATION_NAME;
break;
default:
bPrivelege = FALSE;
}
if(bPrivelege)
{
LookupPrivilegeValue(NULL,pName,&luid);
m_pPrevTokenPrev->Privileges[m_pPrevTokenPrev->PrivilegeCount].Luid = luid;
//=============================================================================================
// Any setting other than SE_PRIVILEGE_ENABLED is interpreted by AdjustTokenPrivileges
// as a DISABLE request for the privelege
//=============================================================================================
m_pPrevTokenPrev->Privileges[m_pPrevTokenPrev->PrivilegeCount].Attributes = (ulProperty & lPropValTemp)
? SE_PRIVILEGE_ENABLED : SE_PRIVILEGE_ENABLED_BY_DEFAULT;
m_pPrevTokenPrev->PrivilegeCount++;
pName = NULL;
lPropValTemp <<= 1;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Function to get the index of a particular property in the array of properties
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CPreviligeToken::GetPropIndex (ULONG cProps ,
DBPROP rgProp[],
DBPROPID dwPropertyID,
LONG* pulIndex)
{
ULONG cNumberOfProperties;
BOOL fRc = FALSE;
assert( pulIndex );
*pulIndex = -1;
for ( cNumberOfProperties = 0; cNumberOfProperties < cProps; cNumberOfProperties++) {
if (dwPropertyID == rgProp[cNumberOfProperties].dwPropertyID ) {
//==============================================================
// found a match
//==============================================================
*pulIndex = cNumberOfProperties;
fRc = TRUE;
break;
}
}
return fRc;
}
void CPreviligeToken::OpenToken(HANDLE &hToken)
{
HANDLE hObject = NULL;
DWORD dwError = 0;
BOOL bRet = FALSE;
hObject = GetCurrentThread();
if(!OpenThreadToken(hObject,TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES,TRUE,&hToken))
{
dwError = GetLastError();
}
if(dwError == ERROR_NO_TOKEN)
{
dwError = 0;
CloseHandle(hObject);
hObject = GetCurrentProcess();
if(!OpenProcessToken(hObject,TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,&hToken))
{
dwError = GetLastError();
}
}
CloseHandle(hObject);
if(!dwError)
{
DWORD dwLen = m_nMemAllocated;
bRet = GetTokenInformation(hToken,
TokenPrivileges,
m_pPrevTokenPrev,
dwLen,
&dwLen);
dwError = GetLastError();
}
}
Reference in a new issue Copy permalink