dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/winmgmt/repdrvr/ese/eseutils.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

12720 lines
452 KiB
C++
Raw Permalink Blame History

//***************************************************************************
//
// (c) 1999-2001 by Microsoft Corp. All Rights Reserved.
//
// ESEUTILS.cpp
//
// cvadai 6-May-1999 created.
//
//***************************************************************************
// #define OBJECT_BLOB_CRC
#define _JET_PROCS_CPP_
#pragma warning( disable : 4786 ) // identifier was truncated to 'number' characters in the
#pragma warning( disable : 4251 ) // needs to have dll-interface to be used by clients of class
#include "precomp.h"
#include <std.h>
#include <cominit.h>
#include <ese.h>
#include <sqlexec.h>
#include <sqlcache.h>
#include <eseobjs.h>
#include <repdrvr.h>
#include <wbemint.h>
#include <math.h>
#include <objbase.h>
#include <resource.h>
#include <reputils.h>
#include <arena.h>
#include <crc64.h>
#include <smrtptr.h>
#include <eseitrtr.h>
#include <wqltoese.h>
#include <eseutils.h>
#include <repcache.h>
#include <objbase.h>
#include <wbemprov.h>
#define MAX_STRING_WIDTH 255
#define OBJECTMAP_COL_OBJECTID 1
#define OBJECTMAP_COL_OBJECTPATH 2
#define OBJECTMAP_COL_OBJECTKEY 3
#define OBJECTMAP_COL_REFERENCECOUNT 4
#define OBJECTMAP_COL_OBJECTSTATE 5
#define OBJECTMAP_COL_CLASSID 6
#define OBJECTMAP_COL_OBJECTFLAGS 7
#define OBJECTMAP_COL_OBJECTSCOPEID 8
#define CLASSMAP_COL_CLASSID 1
#define CLASSMAP_COL_CLASSNAME 2
#define CLASSMAP_COL_SUPERCLASSID 3
#define CLASSMAP_COL_DYNASTYID 4
#define CLASSMAP_COL_CLASSBUFFER 5
#define PROPERTYMAP_COL_CLASSID 1
#define PROPERTYMAP_COL_PROPERTYID 2
#define PROPERTYMAP_COL_STORAGETYPEID 3
#define PROPERTYMAP_COL_CIMTYPEID 4
#define PROPERTYMAP_COL_PROPERTYNAME 5
#define PROPERTYMAP_COL_FLAGS 6
#define PROPERTYMAP_COL_REFCLASSID 7
#define CLASSKEYS_COL_CLASSID 1
#define CLASSKEYS_COL_PROPERTYID 2
#define REFPROPS_COL_CLASSID 1
#define REFPROPS_COL_PROPERTYID 2
#define REFPROPS_COL_REFCLASSID 3
#define CLASSDATA_COL_OBJECTID 1
#define CLASSDATA_COL_PROPERTYID 2
#define CLASSDATA_COL_ARRAYPOS 3
#define CLASSDATA_COL_QFRPOS 4
#define CLASSDATA_COL_CLASSID 5
#define CLASSDATA_COL_STRINGVALUE 6
#define CLASSDATA_COL_NUMERICVALUE 7
#define CLASSDATA_COL_REFID 8
#define CLASSDATA_COL_REALVALUE 9
#define CLASSDATA_COL_REFCLASSID 10
#define CLASSDATA_COL_FLAGS 11
#define CLASSIMAGES_COL_OBJECTID 1
#define CLASSIMAGES_COL_PROPERTYID 2
#define CLASSIMAGES_COL_ARRAYPOS 3
#define CLASSIMAGES_COL_IMAGEVALUE 4
#define INDEXTBL_COL_OBJECTID 1
#define INDEXTBL_COL_PROPERTYID 2
#define INDEXTBL_COL_ARRAYPOS 3
#define INDEXTBL_COL_INDEXVALUE 4
#define CONTAINEROBJS_COL_CONTAINERID 1
#define CONTAINEROBJS_COL_CONTAINEEID 2
#define AUTODELETE_COL_OBJECTID 1
#define SCOPEMAP_COL_OBJECTID 1
#define SCOPEMAP_COL_SCOPEPATH 2
#define SCOPEMAP_COL_PARENTID 3
typedef std::vector <SQL_ID> SQLIDs;
typedef std::vector <DWORD> IDs;
typedef std::vector <_bstr_t> _bstr_ts;
typedef std::map <DWORD, DWORD> Properties;
JET_INSTANCE gJetInst = NULL;
typedef std::map <DWORD, SQLIDs> SessionDynasties;
LPWSTR StripQuotes2(LPWSTR lpText)
{
wchar_t *pszTemp = new wchar_t [wcslen(lpText)+1];
if (pszTemp)
{
int iPos = 0;
BOOL bOnQuote = FALSE;
int iLen = wcslen(lpText);
if (iLen)
{
for (int i = 0; i < iLen; i++)
{
WCHAR t = lpText[i];
if (t == '\'')
{
if (!bOnQuote)
{
if (lpText[i+1] == '\'')
{
bOnQuote = TRUE;
continue;
}
}
}
bOnQuote = FALSE;
pszTemp[iPos] = t;
iPos++;
}
}
pszTemp[iPos] = '\0';
}
return pszTemp;
}
void FreeBstr(BSTR * ppStr)
{
if (ppStr)
{
SysFreeString(*ppStr);
*ppStr = NULL;
}
}
HRESULT LoadSchemaProperties (CSQLConnection *pConn, CSchemaCache *pCache, SQL_ID dClassId)
{
// Enumerate properties
HRESULT hr = WBEM_S_NO_ERROR;
PROPERTYMAP pm;
hr = GetFirst_PropertyMapByClass(pConn, dClassId, pm);
while (SUCCEEDED(hr))
{
hr = pCache->AddPropertyInfo (pm.iPropertyId,
pm.sPropertyName, pm.dClassId, pm.iStorageTypeId, pm.iCIMTypeId, pm.iFlags,
0, L"", 0, 0);
if (FAILED(hr))
{
pm.Clear();
break;
}
hr = GetNext_PropertyMap(pConn, pm);
}
CLASSKEYS ck;
hr = GetFirst_ClassKeys (pConn, dClassId, ck);
while (SUCCEEDED(hr))
{
pCache->SetIsKey(ck.dClassId, ck.iPropertyId);
hr = GetNext_ClassKeys(pConn, ck);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// CWmiDbController::GetLogonTemplate
//
//***************************************************************************
HRESULT STDMETHODCALLTYPE CWmiDbController::GetLogonTemplate(
/* [in] */ LCID lLocale,
/* [in] */ DWORD dwFlags,
/* [out] */ WMIDB_LOGON_TEMPLATE __RPC_FAR *__RPC_FAR *ppTemplate)
{
HRESULT hr = WBEM_S_NO_ERROR;
if (dwFlags != 0 || !ppTemplate)
return WBEM_E_INVALID_PARAMETER;
try
{
if (ppTemplate)
{
WMIDB_LOGON_TEMPLATE *pTemp = new WMIDB_LOGON_TEMPLATE;
if (pTemp)
{
pTemp->dwArraySize = 5;
HINSTANCE hRCDll = GetResourceDll(lLocale);
if (!hRCDll)
{
LCID lTemp = GetUserDefaultLangID();
hRCDll = GetResourceDll(lTemp);
if (!hRCDll)
{
lTemp = GetSystemDefaultLangID();
hRCDll = GetResourceDll(lTemp);
if (!hRCDll)
hRCDll = LoadLibrary(L"reprc.dll"); // Last resort - try the current directory.
}
}
wchar_t wDB[101], wUser[101], wPwd[101], wLocale[101], wMode[101];
pTemp->pParm = new WMIDB_LOGON_PARAMETER[6];
if (pTemp->pParm)
{
if (hRCDll)
{
LoadString(hRCDll, IDS_WMI_USER_NAME, wUser, 100);
LoadString(hRCDll, IDS_WMI_PASSWORD, wPwd, 100);
LoadString(hRCDll, IDS_WMI_DATABASE, wDB, 100);
LoadString(hRCDll, IDS_WMI_LOCALE, wLocale, 100);
LoadString(hRCDll, IDS_WMI_READMODE, wMode, 100);
FreeLibrary(hRCDll);
}
else
{
wcscpy(wDB, L"Database");
wcscpy(wUser, L"UserID");
wcscpy(wPwd, L"Password");
wcscpy(wLocale, L"Locale");
wcscpy(wMode, L"Access Mode");
}
pTemp->pParm[0].dwId = DBPROP_INIT_MODE;
pTemp->pParm[0].strParmDisplayName = SysAllocString(wMode);
VariantInit(&(pTemp->pParm[0].Value));
pTemp->pParm[0].Value.vt = VT_I4;
pTemp->pParm[0].Value.lVal = DB_MODE_READWRITE ;
pTemp->pParm[1].dwId = DBPROP_AUTH_USERID;
pTemp->pParm[1].strParmDisplayName = SysAllocString(wUser);
VariantInit(&(pTemp->pParm[1].Value));
pTemp->pParm[2].dwId = DBPROP_AUTH_PASSWORD;
pTemp->pParm[2].strParmDisplayName = SysAllocString(wPwd);
VariantInit(&(pTemp->pParm[2].Value));
pTemp->pParm[3].dwId = DBPROP_INIT_DATASOURCE;
pTemp->pParm[3].strParmDisplayName = SysAllocString(wDB);
VariantInit(&(pTemp->pParm[3].Value));
pTemp->pParm[4].dwId = DBPROP_INIT_LCID;
pTemp->pParm[4].strParmDisplayName = SysAllocString(wLocale);
VariantInit(&(pTemp->pParm[4].Value));
pTemp->pParm[4].Value.lVal = lLocale;
pTemp->pParm[4].Value.vt = VT_I4;
*ppTemplate = pTemp;
}
else
{
delete pTemp;
hr = WBEM_E_OUT_OF_MEMORY;
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_INVALID_PARAMETER;
}
catch (...)
{
ERRORTRACE((LOG_WBEMCORE, "Fatal error in CWmiDbController::GetLogonTemplate\n"));
hr = WBEM_E_CRITICAL_ERROR;
}
return hr;
}
//***************************************************************************
//
// GetPath
//
//***************************************************************************
LPWSTR GetPath (LPCWSTR lpDatabaseName)
{
wchar_t *pPath = NULL;
if (lpDatabaseName && wcslen(lpDatabaseName))
{
pPath = new wchar_t [(wcslen(lpDatabaseName))+1];
if (pPath)
{
BOOL bDone = FALSE;
wchar_t *Temp = new wchar_t [wcslen(lpDatabaseName)+1];
if (Temp)
{
CDeleteMe <wchar_t> d2 (Temp);
wcscpy(Temp, lpDatabaseName);
wchar_t *pTemp = wcsstr(Temp, L"\\");
while (!bDone)
{
pTemp++;
wchar_t *pTemp2 = wcsstr(pTemp, L"\\");
if (!pTemp2)
{
bDone = TRUE;
int iLen = (pTemp - Temp);
wcsncpy(pPath, Temp, iLen);
pPath[iLen] = L'\0';
break;
}
else
pTemp = pTemp2;
}
}
}
}
return pPath;
}
//***************************************************************************
//
// DeleteDatabase
//
//***************************************************************************
HRESULT DeleteDatabase(LPCWSTR lpDatabaseName)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Enumerate all files in the directory
// and delete them all
// Also check if there are any conflictingly-named
// subdirectories.
ERRORTRACE((LOG_WBEMCORE, "Database %sis out-of-date. Deleting...\n", lpDatabaseName));
if (!DeleteFile(lpDatabaseName))
{
DWORD err = GetLastError();
RemoveDirectory(lpDatabaseName);
}
LPWSTR lpPath = GetPath(lpDatabaseName);
if (lpPath)
{
wchar_t *pTemp = new wchar_t [wcslen(lpDatabaseName) + 50];
CDeleteMe <wchar_t> d2 (pTemp);
if (pTemp)
{
swprintf(pTemp, L"%sedb.log", lpPath);
if (!DeleteFile(pTemp))
RemoveDirectory(pTemp);
swprintf(pTemp, L"%sedb.chk", lpPath);
if (!DeleteFile(pTemp))
RemoveDirectory(pTemp);
swprintf(pTemp, L"%sres1.log", lpPath);
if (!DeleteFile(pTemp))
RemoveDirectory(pTemp);
swprintf(pTemp, L"%sres2.log", lpPath);
if (!DeleteFile(pTemp))
RemoveDirectory(pTemp);
swprintf(pTemp, L"%stmp.edb", lpPath);
if (!DeleteFile(pTemp))
RemoveDirectory(pTemp);
swprintf(pTemp, L"%s*.log", lpPath);
_bstr_ts names;
WIN32_FIND_DATA fd;
HANDLE hFile = FindFirstFile(pTemp, &fd);
while (TRUE)
{
if (wcscmp(fd.cFileName, L".") &&
wcscmp(fd.cFileName, L".."))
{
swprintf(pTemp, L"%s%s", lpPath, fd.cFileName);
names.push_back(pTemp);
}
if (!FindNextFile(hFile, &fd))
break;
}
for (int i = 0; i < names.size(); i++)
{
if (!DeleteFile(names.at(i)))
RemoveDirectory(names.at(i));
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_FAILED;
return hr;
}
BOOL CheckVersion (JET_SESID sesid, JET_DBID dbid, int iVersion)
{
BOOL bDelete = FALSE;
JET_ERR err;
JET_TABLEID tableid;
JET_COLUMNID id;
DWORD dwCurrVer = 0;
err = JetOpenTable (sesid, dbid, "DBVersion", NULL, 0, JET_bitTableUpdatable, &tableid);
if (err >= JET_errSuccess)
{
JET_COLUMNDEF columnDef;
err = JetGetColumnInfo(sesid, dbid, "DBVersion", "Version",
&columnDef, sizeof(JET_COLUMNDEF), 0);
if (err < JET_errSuccess)
{
columnDef.cp = 1200; // Unicode? Otherwise, its 1252.
columnDef.wCountry = 1;
columnDef.langid = 1033;
columnDef.wCollate = 0;
columnDef.cbStruct = sizeof(JET_COLUMNDEF);
columnDef.columnid = 1;
columnDef.coltyp = JET_coltypLong;
columnDef.grbit = 0 ;
columnDef.cbMax = 0;
err = JetAddColumn(sesid, tableid, "Version", &columnDef, "", 0, &id);
}
else
id = columnDef.columnid;
ULONG lLen;
err = JetMove(sesid, tableid, JET_MoveFirst, 0);
err = JetRetrieveColumn(sesid, tableid, id,
&dwCurrVer, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess == err && lLen != 0)
{
if (iVersion != dwCurrVer)
bDelete = TRUE;
}
JetCloseTable(sesid, tableid);
}
else
{
// Do any other tables exist?
err = JetOpenTable(sesid, dbid, "ClassMap", NULL, 0, JET_bitTableUpdatable, &tableid);
if (err == JET_errSuccess)
{
bDelete = TRUE;
JetCloseTable(sesid, tableid);
}
}
return bDelete;
}
//***************************************************************************
//
// AttachESEDatabase
//
//***************************************************************************
HRESULT AttachESEDatabase(DBPROPSET *pTemplate, CSQLConnection *pConn, BOOL bCheckVer = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn2 = (CESEConnection *)pConn;
JET_SESID sesid = pConn2->GetSessionID();
JET_ERR err = JET_errSuccess;
JET_DBID dbid;
CLASSMAP cm;
char *pDB = GetAnsiString(pTemplate->rgProperties[4].vValue.bstrVal);
if (!pDB)
hr = WBEM_E_OUT_OF_MEMORY;
IWbemClassObject *pTest = NULL;
CDeleteMe <char> d (pDB);
if (SUCCEEDED(hr))
{
LPWSTR lpDatabase = pTemplate->rgProperties[4].vValue.bstrVal;
err = JetAttachDatabase( sesid, pDB, 0 ) ;
if (err < JET_errSuccess)
{
if (err == JET_errDatabaseCorrupted)
{
// DeleteDatabase(lpDatabase);
hr = CSQLExecute::GetWMIError(err);
return hr;
}
err = JetCreateDatabase(sesid, pDB, NULL, &dbid, 0);
if (err == JET_errSuccess)
{
pConn2->SetDBID(dbid);
}
else
{
hr = CSQLExecute::GetWMIError(err);
return hr;
}
}
else
{
err = JetOpenDatabase (sesid, pDB, NULL, &dbid, 0);
if (err == JET_errSuccess)
{
if (bCheckVer)
{
BOOL bDelete = CheckVersion(sesid, dbid, CURRENT_DB_VERSION);
// Ensure that this database is the proper version
JET_TABLEID tableid;
err = JetOpenTable (sesid, dbid, "ClassMap", NULL, 0, JET_bitTableUpdatable, &tableid);
if (err == JET_errSuccess)
{
JET_COLUMNDEF columnDef;
// If the table exists but the column doesn't, this is
// an old beta version, and we need to delete it and
// start over.
err = JetGetColumnInfo(sesid, dbid, "ClassMap", "ClassBlob",
&columnDef, sizeof(JET_COLUMNDEF), 0);
if (err != JET_errSuccess)
bDelete = TRUE;
JetCloseTable(sesid, tableid);
}
if (bDelete)
{
err = JetCloseDatabase(sesid, dbid, 0);
err = JetEndSession(sesid, 0);
err = JetTerm2(gJetInst, JET_bitTermComplete);
hr = DeleteDatabase(lpDatabase);
return WBEM_E_DATABASE_VER_MISMATCH;
}
}
pConn2->SetDBID(dbid);
}
else
{
hr = CSQLExecute::GetWMIError(err);
return hr;
}
}
// Initialize our data.
DWORD dwPos;
LPWSTR lpTableName = NULL;
// Create the tables.
err = JetBeginTransaction(sesid);
if (FAILED(hr = UpdateDBVersion(pConn, CURRENT_DB_VERSION)) ||
FAILED(hr = SetupObjectMapAccessor(pConn)) ||
FAILED(hr = SetupClassMapAccessor(pConn)) ||
FAILED(hr = SetupPropertyMapAccessor(pConn)) ||
FAILED(hr = SetupClassDataAccessor(pConn)) ||
FAILED(hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_STRING, dwPos, &lpTableName))||
FAILED(hr = SetupClassKeysAccessor(pConn)))
goto Exit;
CDeleteMe<WCHAR> dmlpTableName( lpTableName );
hr = GetFirst_ClassMap(pConn, 1, cm);
if (SUCCEEDED(hr))
{
cm.Clear();
goto Exit;
}
// Default system classes.
if (FAILED(hr = InsertObjectMap(pConn, 1, L"meta_class", 3, L"meta_class", 0, 0, 0, 0, TRUE)) ||
FAILED(hr = InsertObjectMap(pConn, 2372429868687864876, L"__Namespace", 3, L"__Namespace", 0, 0, 0, 1, TRUE)) ||
FAILED(hr = InsertObjectMap(pConn, -1411745643584611171, L"root", 3, L"root", 0, 0, 0, 2372429868687864876, TRUE)) ||
FAILED(hr = InsertObjectMap(pConn, 3373910491091605771, L"__Instances", 3, L"__Instances", 0, 0, 0, 1, TRUE)) ||
FAILED(hr = InsertScopeMap_Internal(pConn, -1411745643584611171, L"root", 0)) ||
FAILED(hr = InsertObjectMap(pConn, -7316356768687527881, L"__Container_Association", 3, L"__Container_Association", 0, 0, 0, 1, TRUE)) ||
FAILED(hr = InsertClassMap(pConn, 1, L"meta_class", 0, 1, NULL, 0, TRUE)))
goto Exit;
// Repository-specific system classes
if (FAILED(GetFirst_ClassMap(pConn, 2372429868687864876, cm)))
{
_IWmiObject *pObj = NULL;
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID__IWmiObject, (void **)&pObj);
CReleaseMe r (pObj);
if (SUCCEEDED(hr))
{
VARIANT vTemp;
VariantInit(&vTemp);
vTemp.bstrVal = SysAllocString(L"__Namespace");
vTemp.vt = VT_BSTR;
pObj->Put(L"__Class", 0, &vTemp, CIM_STRING);
VariantClear(&vTemp);
pObj->Put(L"Name", 0, NULL, CIM_STRING);
IWbemQualifierSet *pQS = NULL;
hr = pObj->GetPropertyQualifierSet(L"Name", &pQS);
if (SUCCEEDED(hr))
{
vTemp.boolVal = 1;
vTemp.vt = VT_BOOL;
pQS->Put(L"key", &vTemp, 0);
pQS->Release();
VariantClear(&vTemp);
}
BYTE buff[128];
DWORD dwLen = 0;
hr = pObj->Unmerge(0, 128, &dwLen, &buff);
if (dwLen > 0)
{
BYTE *pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> r2 (pBuff);
DWORD dwLen1;
hr = pObj->Unmerge(0, dwLen, &dwLen1, pBuff);
if (SUCCEEDED(hr))
{
hr = InsertClassMap(pConn, 2372429868687864876, L"__Namespace", 1, 2372429868687864876, pBuff, dwLen, TRUE);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
}
if (FAILED(hr))
goto Exit;
}
cm.Clear();
if (FAILED(GetFirst_ClassMap(pConn, 3373910491091605771, cm)))
{
_IWmiObject *pObj = NULL;
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID__IWmiObject, (void **)&pObj);
CReleaseMe r (pObj);
if (SUCCEEDED(hr))
{
VARIANT vTemp;
VariantInit(&vTemp);
vTemp.bstrVal = SysAllocString(L"__Instances");
vTemp.vt = VT_BSTR;
pObj->Put(L"__Class", 0, &vTemp, CIM_STRING);
VariantClear(&vTemp);
pObj->Put(L"ClassName", 0, NULL, CIM_STRING);
IWbemQualifierSet *pQS = NULL;
hr = pObj->GetPropertyQualifierSet(L"ClassName", &pQS);
if (SUCCEEDED(hr))
{
vTemp.boolVal = 1;
vTemp.vt = VT_BOOL;
pQS->Put(L"key", &vTemp, 0);
pQS->Release();
VariantClear(&vTemp);
}
BYTE buff[128];
DWORD dwLen = 0;
hr = pObj->Unmerge(0, 128, &dwLen, &buff);
if (dwLen > 0)
{
BYTE *pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> r2 (pBuff);
DWORD dwLen1;
hr = pObj->Unmerge(0, dwLen, &dwLen1, pBuff);
if (SUCCEEDED(hr))
{
hr = InsertClassMap(pConn, 3373910491091605771, L"__Instances", 1, 3373910491091605771, pBuff, dwLen, TRUE);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
}
if (FAILED(hr))
goto Exit;
}
cm.Clear();
if (FAILED(GetFirst_ClassMap(pConn, -7316356768687527881, cm)))
{
_IWmiObject *pObj = NULL;
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID__IWmiObject, (void **)&pObj);
CReleaseMe r (pObj);
if (SUCCEEDED(hr))
{
VARIANT vTemp;
VariantInit(&vTemp);
vTemp.bstrVal = SysAllocString(L"__Container_Association");
vTemp.vt = VT_BSTR;
pObj->Put(L"__Class", 0, &vTemp, CIM_STRING);
VariantClear(&vTemp);
pObj->Put(L"Containee", 0, NULL, CIM_REFERENCE);
pObj->Put(L"Container", 0, NULL, CIM_REFERENCE);
IWbemQualifierSet *pQS = NULL;
hr = pObj->GetPropertyQualifierSet(L"Containee", &pQS);
if (SUCCEEDED(hr))
{
vTemp.boolVal = 1;
vTemp.vt = VT_BOOL;
pQS->Put(L"key", &vTemp, 0);
pQS->Release();
VariantClear(&vTemp);
}
hr = pObj->GetPropertyQualifierSet(L"Container", &pQS);
if (SUCCEEDED(hr))
{
vTemp.boolVal = 1;
vTemp.vt = VT_BOOL;
pQS->Put(L"key", &vTemp, 0);
pQS->Release();
VariantClear(&vTemp);
}
BYTE buff[128];
DWORD dwLen = 0;
hr = pObj->Unmerge(0, 128, &dwLen, &buff);
if (dwLen > 0)
{
BYTE *pBuff;
pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> r2 (pBuff);
DWORD dwLen1;
hr = pObj->Unmerge(0, dwLen, &dwLen1, pBuff);
if (SUCCEEDED(hr))
{
hr = InsertClassMap(pConn, -7316356768687527881, L"__Container_Association", 1, -7316356768687527881, pBuff, dwLen, TRUE);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
}
if (FAILED(hr))
goto Exit;
}
cm.Clear();
// Properties for default classes
DWORD iWaste = 0, dwPropID = 0;
if (FAILED(hr = InsertPropertyMap(pConn, dwPropID, 2372429868687864876, 1, 8, L"Name", 4, TRUE)) ||
FAILED(hr = InsertClassKeys(pConn, 2372429868687864876, dwPropID)) ||
FAILED(hr = InsertPropertyMap(pConn, iWaste, 3373910491091605771, 1, 8, L"ClassName", 4, TRUE)) ||
FAILED(hr = InsertClassKeys(pConn, 3373910491091605771, iWaste)) ||
FAILED(hr = InsertPropertyMap(pConn, iWaste, -7316356768687527881, 4, 102, L"Containee", 4, TRUE)) ||
FAILED(hr = InsertClassKeys(pConn, -7316356768687527881, iWaste)) ||
FAILED(hr = InsertPropertyMap(pConn, iWaste, -7316356768687527881, 4, 102, L"Container", 4, TRUE)) ||
FAILED(hr = InsertClassKeys(pConn, -7316356768687527881, iWaste)) ||
FAILED(hr = InsertClassData_Internal(pConn, -1411745643584611171, dwPropID, 0, 0, 2372429868687864876,
L"root", 0, 0, 4, 0, 0, FALSE)) ||
FAILED(hr = InsertIndexData (pConn, -1411745643584611171, dwPropID, 0, L"root", 0, 0, 1)))
goto Exit;
// System properties. Including them in the schema makes them queriable.
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemClassObject, (void **)&pTest);
if (SUCCEEDED(hr))
{
CReleaseMe r (pTest);
BSTR strName;
CIMTYPE cimtype;
hr = pTest->BeginEnumeration(0);
while (pTest->Next(0, &strName, NULL, &cimtype, NULL) == S_OK)
{
DWORD dwStorageType = 0;
CFreeMe f1 (strName);
DWORD dwFlags = REPDRVR_FLAG_SYSTEM;
CIMTYPE ct = cimtype & 0xFFF;
bool bArray = (cimtype & CIM_FLAG_ARRAY)? true: false;
if (bArray)
dwFlags |= REPDRVR_FLAG_ARRAY;
if (!_wcsicmp(strName, L"__Path") ||
!_wcsicmp(strName, L"__RelPath") ||
!_wcsicmp(strName, L"__Class") ||
!_wcsicmp(strName, L"__SuperClass") ||
!_wcsicmp(strName, L"__Dynasty") ||
!_wcsicmp(strName, L"__Derivation") ||
!_wcsicmp(strName, L"__Version") ||
!_wcsicmp(strName, L"__Genus") ||
!_wcsicmp(strName, L"__Property_Count") ||
!_wcsicmp(strName, L"__Server") ||
!_wcsicmp(strName, L"__Namespace"))
dwStorageType = WMIDB_STORAGE_COMPACT;
else
dwStorageType = GetStorageType(ct, bArray);
if (FAILED(hr = InsertPropertyMap(pConn, iWaste, 1, dwStorageType, ct, strName, dwFlags, TRUE)))
goto Exit;
}
}
hr = WBEM_S_NO_ERROR;
}
Exit:
if (SUCCEEDED(hr))
{
hr = CSQLExecute::GetWMIError(err);
JetCommitTransaction(sesid, 0);
}
else
JetRollback(sesid, 0);
return hr;
}
//***************************************************************************
//
// CSQLConnCache::FinalRollback
//
//***************************************************************************
HRESULT CSQLConnCache::FinalRollback(CSQLConnection *pConn)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Rollback this transaction and set Thread ID to zero
CESEConnection *pConn2 = (CESEConnection *)pConn;
CWmiESETransaction *pTrans = pConn2->m_pTrans;
if (pTrans)
{
hr = pTrans->Abort();
delete pTrans;
}
pConn2->m_pTrans = NULL;
pConn2->m_bInUse = false;
pConn2->m_tCreateTime = time(0); // We don't want to delete it immediately.
return hr;
}
//***************************************************************************
//
// CSQLConnCache::FinalCommit
//
//***************************************************************************
HRESULT CSQLConnCache::FinalCommit(CSQLConnection *pConn)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Commit this transaction and erase the ThreadID
// from this connection.
CESEConnection *pConn2 = (CESEConnection *)pConn;
CWmiESETransaction *pTrans = pConn2->m_pTrans;
if (pTrans)
hr = pTrans->Commit();
pConn2->m_tCreateTime = time(0); // We don't want to delete it immediately.
delete pTrans;
pConn2->m_pTrans = NULL;
return hr;
}
//***************************************************************************
//
// CSQLConnCache::ReleaseConnection
//
//***************************************************************************
HRESULT CSQLConnCache::ReleaseConnection(CSQLConnection *_pConn,
HRESULT retcode, BOOL bDistributed)
{
HRESULT hr = WBEM_S_NO_ERROR;
DWORD dwNumFreed = 0;
// If we're shutting down, the connection will be released anyway.
if (m_dwStatus == WBEM_E_SHUTTING_DOWN)
{
hr = FinalRollback(_pConn);
((CESEConnection *)_pConn)->m_bInUse = false;
return WBEM_E_SHUTTING_DOWN;
}
CRepdrvrCritSec r (&m_cs);
for (int i = m_Conns.size() -1; i >=0; i--)
{
CSQLConnection *pConn = m_Conns.at(i);
if (pConn)
{
CESEConnection *pConn2 = (CESEConnection *)pConn;
if (_pConn == pConn)
{
if (FAILED(retcode))
{
// If this is a distributed transaction,
// they decide on the final commit.
if (!bDistributed)
{
hr = FinalRollback(pConn);
if (retcode == WBEM_E_CRITICAL_ERROR ||
retcode == WBEM_E_INVALID_QUERY ||
retcode == WBEM_E_OUT_OF_MEMORY)
{
delete pConn2; // This deletes the transaction.
pConn2 = NULL;
m_Conns.erase(&m_Conns.at(i));
DEBUGTRACE((LOG_WBEMCORE, "THREAD %ld deleted ESE connection %X. Number of connections = %ld\n",
GetCurrentThreadId(), pConn, m_Conns.size()));
}
}
}
else
{
// If this is a distributed transaction,
// they decide on the final commit.
if (!bDistributed)
hr = FinalCommit(pConn);
}
if (pConn2)
pConn2->m_bInUse = false;
dwNumFreed++;
break;
}
}
}
// Notify waiting threads that there is
// an open connection.
// =====================================
{
CRepdrvrCritSec r (&m_cs);
for (int i = 0; i < m_WaitQueue.size(); i++)
{
if (i >= dwNumFreed)
break;
HANDLE hTemp = m_WaitQueue.at(i);
SetEvent(hTemp);
DEBUGTRACE((LOG_WBEMCORE, "Thread %ld released a connection...\n", GetCurrentThreadId()));
}
}
return hr;
}
//***************************************************************************
//
// CSQLConnCache::Shutdown
//
//***************************************************************************
HRESULT CSQLConnCache::Shutdown()
{
HRESULT hr = WBEM_S_NO_ERROR;
JET_ERR err = 0;
time_t tStart = time(0), tEnd = time(0) + 5;
m_dwStatus = WBEM_E_SHUTTING_DOWN;
if (m_bInit)
{
CRepdrvrCritSec r (&m_cs);
int iConnectionsLeftOpen = m_Conns.size();
while (iConnectionsLeftOpen)
{
{
CRepdrvrCritSec r (&m_cs);
iConnectionsLeftOpen = 0;
for (int i = m_Conns.size()-1; i >= 0; i--)
{
// Give threads up to 5 seconds to shut down.
if (((CESEConnection *)m_Conns.at(i))->m_bInUse)
iConnectionsLeftOpen++;
else if (!((CESEConnection *)m_Conns.at(i))->m_bInUse)
{
delete m_Conns.at(i);
m_Conns.erase(&m_Conns.at(i));
}
}
}
if (!iConnectionsLeftOpen)
break;
else
{
if (tEnd >= tStart)
{
Sleep(100); // Check every 50 ms.
tStart = time(0);
}
else
break;
}
}
if (iConnectionsLeftOpen)
{
CRepdrvrCritSec r (&m_cs);
for (int i = m_Conns.size()-1; i >= 0; i--)
{
// Give threads up to 5 seconds to shut down.
if (((CESEConnection *)m_Conns.at(i))->m_bInUse)
{
CESEConnection *pConn2 = (CESEConnection *)m_Conns.at(i);
if (pConn2)
{
DEBUGTRACE((LOG_WBEMCORE,
"CONNECTION: #%ld \n"
" In Use = %ld\n"
" Creation time = %ld\n"
" Thread ID = %ld\n",
i,
((CESEConnection *)pConn2)->m_bInUse,
((CESEConnection *)pConn2)->m_tCreateTime,
((CESEConnection *)pConn2)->m_dwThreadId));
}
}
}
m_Conns.clear();
}
DEBUGTRACE((LOG_WBEMCORE, "Database shutting down in response to a Shutdown command.\n"));
if (iConnectionsLeftOpen)
ERRORTRACE((LOG_WBEMCORE, "%ld connections left open. All threads did not release their connections!\n",
iConnectionsLeftOpen));
// _ASSERT(iConnectionsLeftOpen == 0, "Shutdown was unable to close all db connections.");
err = JetTerm2(gJetInst, JET_bitTermComplete);
if (err >= JET_errSuccess)
{
gJetInst = NULL;
m_bInit = FALSE;
}
hr = CSQLExecute::GetWMIError(err);
}
return hr;
}
//***************************************************************************
//
// Startup
//
//***************************************************************************
HRESULT Startup(CSQLConnection *pConn)
{
HRESULT hr = WBEM_S_NO_ERROR;
hr = CleanAutoDeletes(pConn);
return hr;
}
//***************************************************************************
//
// CSQLConnCache::DeleteUnusedConnections
//
//***************************************************************************
HRESULT CSQLConnCache::DeleteUnusedConnections(BOOL bDeadOnly)
{
HRESULT hr = WBEM_E_NOT_FOUND;
DWORD dwThreadId = GetCurrentThreadId();
CRepdrvrCritSec r (&m_cs);
for (int i = m_Conns.size()-1; i >= 0; i--)
{
CESEConnection *pConn = (CESEConnection *)m_Conns.at(i);
if (pConn)
{
if (!pConn->m_bInUse)
{
BOOL bDelete = FALSE;
if (bDeadOnly)
{
if (dwThreadId != pConn->m_dwThreadId)
{
HANDLE hTemp = OpenThread(STANDARD_RIGHTS_REQUIRED, FALSE, pConn->m_dwThreadId);
if (hTemp)
{
CloseHandle(hTemp);
time_t tNow = time(0);
if ((tNow - pConn->m_tCreateTime) > 60)
bDelete = TRUE;
}
else
bDelete = TRUE;
}
}
else
bDelete = TRUE;
if (bDelete)
{
delete pConn; // This deletes the transaction, which should be NULL.
pConn = NULL;
m_Conns.erase(&m_Conns.at(i));
hr = WBEM_S_NO_ERROR;
if (!bDeadOnly)
break;
}
}
}
}
return hr;
}
//***************************************************************************
//
// CSQLConnCache::GetConnection
//
//***************************************************************************
HRESULT CSQLConnCache::GetConnection(CSQLConnection **ppConn, BOOL bTransacted, BOOL bDistributed,
DWORD dwTimeOutSecs)
{
HRESULT hr = WBEM_S_NO_ERROR;
bool bFound = false;
JET_ERR err = 0;
BOOL bStartUp = FALSE;
DWORD dwThreadId = GetCurrentThreadId();
if (!ppConn)
return WBEM_E_INVALID_PARAMETER;
if (m_dwStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
if (m_WaitQueue.size() && dwTimeOutSecs > 0)
goto Queue;
// Look for any connection that belongs
// to a thread that has gone bye-bye
// and kill it.
// ===================================
{
CRepdrvrCritSec r (&m_cs);
DeleteUnusedConnections(TRUE);
// See if there are any free connections.
// ======================================
if (m_Conns.size() > 0)
{
for (int i = 0; i < m_Conns.size(); i++)
{
CESEConnection *pConn = (CESEConnection *)m_Conns.at(i);
if (pConn)
{
time_t tTemp = time(0);
if (!pConn->m_bInUse)
{
// We need
// to reuse the same connection,
// since Jet is apartment-model
// ============================
if (dwThreadId == pConn->m_dwThreadId)
{
pConn->m_bInUse = true;
pConn->m_tCreateTime = time(0);
*ppConn = pConn;
bFound = true;
break;
}
}
}
}
}
// If there were no free connections, try and obtain a new one.
// ============================================================
{
if (!bFound && (m_Conns.size() < m_dwMaxNumConns))
{
if (!m_bInit)
{
// Get a new JET_INSTANCE from the parameters
// in m_pPropSet
// m_sDatabaseName = database name
// m_pPropSet[1].bstrVal = user name
// m_pPropSet[2].bstrVal = password
LPWSTR lpPath = GetPath(m_sDatabaseName);
if (lpPath)
{
CDeleteMe <wchar_t> d (lpPath);
char * pPath2 = GetAnsiString(lpPath);
if (!pPath2)
return WBEM_E_OUT_OF_MEMORY;
CDeleteMe <char> d3 (pPath2);
if (pPath2)
{
DWORD dwVal = 1024;
if ((err = JetSetSystemParameter (&gJetInst, 0, JET_paramMaxSessions, 25, NULL)) != JET_errSuccess ||
(err = JetSetSystemParameter (&gJetInst, 0, JET_paramCacheSizeMin, 100, NULL)) != JET_errSuccess ||
(err = JetSetSystemParameter (&gJetInst, 0, JET_paramCacheSizeMax, 1024, NULL)) != JET_errSuccess ||
(err = JetSetSystemParameter (&gJetInst, 0, JET_paramEventLogCache, 65536, NULL)) != JET_errSuccess ||
(err = JetSetSystemParameter (&gJetInst, 0, JET_paramCircularLog, TRUE, NULL)) != JET_errSuccess ||
(err = JetSetSystemParameter( &gJetInst, 0, JET_paramSystemPath, 0, pPath2)) != JET_errSuccess ||
(err = JetSetSystemParameter( &gJetInst, 0, JET_paramTempPath, 0, pPath2)) != JET_errSuccess ||
(err = JetSetSystemParameter( &gJetInst, 0, JET_paramLogFilePath, 0, pPath2)) != JET_errSuccess ||
(err = JetSetSystemParameter( &gJetInst, 0, JET_paramMaxVerPages, dwVal, NULL)) != JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
}
else
{
err = JetInit(&gJetInst);
//if (err < JET_errSuccess)
// {
// hr = DeleteDatabase(m_sDatabaseName);
// if (SUCCEEDED(hr))
// err = JetInit(&gJetInst);
// }
if (err == JET_errSuccess)
{
m_bInit = TRUE;
bStartUp = TRUE;
}
else
hr = CSQLExecute::GetWMIError(err);
}
}
}
else
hr = WBEM_E_INVALID_PARAMETER;
}
// If that worked, get a new session,
// and attach the current DB.
if (SUCCEEDED(hr))
{
char *pUser = GetAnsiString(m_pPropSet->rgProperties[2].vValue.bstrVal);
char *pPwd = GetAnsiString(m_pPropSet->rgProperties[3].vValue.bstrVal);
CDeleteMe <char> d3 (pUser), d4 (pPwd);
if (!pUser || !pPwd)
return WBEM_E_OUT_OF_MEMORY;
JET_SESID session;
err = JetBeginSession(gJetInst, &session, pUser, pPwd);
if (err == JET_errSuccess)
{
CSQLConnection *pConn = (CSQLConnection *)new CESEConnection(session);
if (pConn)
{
hr = AttachESEDatabase(m_pPropSet, pConn, bStartUp);
if (FAILED(hr) && hr == WBEM_E_DATABASE_VER_MISMATCH)
{
if ((JetInit(&gJetInst) != JET_errSuccess) ||
(JetBeginSession(gJetInst, &session, pUser, pPwd) != JET_errSuccess) ||
!((CESEConnection *)pConn)->SetSessionID(session) ||
(FAILED(hr = AttachESEDatabase(m_pPropSet, pConn, bStartUp))))
hr = WBEM_E_DATABASE_VER_MISMATCH;
}
if (SUCCEEDED(hr) && bStartUp)
hr = Startup(pConn);
if (SUCCEEDED(hr))
{
((CESEConnection *)pConn)->m_bInUse = true;
((CESEConnection *)pConn)->m_tCreateTime = time(0);
((CESEConnection *)pConn)->m_dwThreadId = dwThreadId;
m_Conns.push_back(pConn);
DEBUGTRACE((LOG_WBEMCORE, "THREAD %ld obtained new ESE connection %X, session %X. Number of connections = %ld\n",
dwThreadId, pConn, &session, m_Conns.size()));
#ifdef _DEBUG_CONNS
for (int i = 0; i < m_Conns.size()-1; i++)
{
CESEConnection *pConn2 = (CESEConnection *)m_Conns.at(i);
if (pConn)
{
DEBUGTRACE((LOG_WBEMCORE,
"CONNECTION: #%ld \n"
" In Use = %ld\n"
" Creation time = %ld\n"
" Thread ID = %ld\n",
i,
((CESEConnection *)pConn2)->m_bInUse,
((CESEConnection *)pConn2)->m_tCreateTime,
((CESEConnection *)pConn2)->m_dwThreadId));
}
}
#endif
*ppConn = pConn;
}
else
delete pConn;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
int iNumConns = m_Conns.size();
hr = CSQLExecute::GetWMIError(err);
}
}
}
}
if (SUCCEEDED(hr) && *ppConn != NULL && (bTransacted || bDistributed))
{
CESEConnection *pConn = (CESEConnection *)*ppConn;
CWmiESETransaction *pTrans = pConn->GetTransaction();
if (!pTrans)
{
pTrans = new CWmiESETransaction(((CESEConnection *)pConn)->GetSessionID());
pConn->SetTransaction(pTrans);
}
if (pTrans)
pTrans->StartTransaction();
}
}
Queue:
// Otherwise, wait for a connection to be released.
// ================================================
if (!*ppConn && (m_Conns.size() >= m_dwMaxNumConns || m_WaitQueue.size()) && dwTimeOutSecs > 0)
{
DEBUGTRACE((LOG_WBEMCORE, "WARNING: >> Number of ESE connections exceeded (%ld). Thread %ld is waiting on one to be released...\n",
m_Conns.size(), dwThreadId));
BOOL bWait = FALSE;
HANDLE hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (hThreadEvent != INVALID_HANDLE_VALUE)
{
CRepdrvrCritSec r (&m_cs);
// Reserve our spot in the queue so we get the very next connection.
m_WaitQueue.push_back(hThreadEvent);
// Check for a free connection one last time.
hr = DeleteUnusedConnections(FALSE);
if (SUCCEEDED(hr))
hr = GetConnection(ppConn, bTransacted, bDistributed, 0);
else
bWait = TRUE;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
if (bWait)
{
if (WbemWaitForSingleObject(hThreadEvent, 30*1000) == WAIT_OBJECT_0)
{
hr = GetConnection(ppConn, bTransacted, bDistributed, 0);
if (SUCCEEDED(hr))
DEBUGTRACE((LOG_WBEMCORE, "Thread %ld obtained a connection.\n", dwThreadId));
else
DEBUGTRACE((LOG_WBEMCORE, "Thread %ld failed to obtain a connection.\n", dwThreadId));
}
else
hr = WBEM_E_SERVER_TOO_BUSY;
}
// Remove ourself from the queue
// This will happen whether the GetConnection
// succeeded or failed
// ==========================================
{
CRepdrvrCritSec r (&m_cs);
for (int i = 0; i < m_WaitQueue.size(); i++)
{
if (hThreadEvent == m_WaitQueue.at(i))
{
m_WaitQueue.erase(&m_WaitQueue.at(i));
break;
}
}
CloseHandle(hThreadEvent);
}
CloseHandle(hThreadEvent);
}
if (!*ppConn && SUCCEEDED(hr))
{
DEBUGTRACE((LOG_WBEMCORE, "Thread %ld was unable to obtain a connection.\n", dwThreadId));
hr = WBEM_E_SERVER_TOO_BUSY;
}
return hr;
}
//***************************************************************************
//
// CSQLExecute::GetWMIError
//
//***************************************************************************
HRESULT CSQLExecute::GetWMIError(long ErrorID)
{
HRESULT hr = 0;
switch(ErrorID)
{
case JET_errSuccess:
case JET_errRecordDeleted:
hr = WBEM_S_NO_ERROR;
break;
case JET_wrnNyi:
hr = E_NOTIMPL;
break;
case JET_errOutOfMemory:
case JET_errOutOfDatabaseSpace:
case JET_errOutOfCursors:
case JET_errOutOfBuffers:
case JET_errOutOfFileHandles:
case JET_errVersionStoreOutOfMemory:
case JET_errCurrencyStackOutOfMemory:
hr = WBEM_E_OUT_OF_MEMORY;
break;
case JET_errInvalidParameter:
case JET_errKeyTooBig:
case JET_errInvalidGrbit:
case JET_errInvalidName:
hr = WBEM_E_INVALID_PARAMETER;
break;
case JET_errRecordNotDeleted:
case JET_errWriteConflict:
hr = WBEM_E_FAILED;
break;
case JET_errRecordNotFound:
case JET_errDatabaseNotFound:
case JET_errNoCurrentRecord:
case JET_errFileNotFound:
hr = WBEM_E_NOT_FOUND;
break;
case JET_errNTSystemCallFailed:
case JET_errLogFileCorrupt:
case JET_errDatabaseInconsistent:
case JET_errConsistentTimeMismatch:
case JET_errDatabasePatchFileMismatch:
case JET_errInvalidDatabaseId:
case JET_errDiskIO:
case JET_errInvalidPath:
case JET_errInvalidSystemPath:
case JET_errInvalidLogDirectory:
case JET_errInvalidDatabase:
case JET_errInvalidFilename:
case JET_errPageSizeMismatch:
hr = WBEM_E_CRITICAL_ERROR;
break;
case JET_errFileAccessDenied:
case JET_errPermissionDenied:
hr = WBEM_E_ACCESS_DENIED;
break;
case JET_errOutOfSessions:
case JET_errInvalidSesid:
hr = WBEM_E_CONNECTION_FAILED;
break;
case JET_errQueryNotSupported:
case JET_errSQLLinkNotSupported:
hr = WBEM_E_INVALID_QUERY;
break;
default:
if (ErrorID > 0)
hr = WBEM_S_NO_ERROR;
else
hr = WBEM_E_INVALID_QUERY;
}
if (FAILED(hr) && hr != WBEM_E_NOT_FOUND)
ERRORTRACE((LOG_WBEMCORE, "Jet returned the following error: %ld\n", ErrorID));
return hr;
}
HRESULT SetInArray (VARIANT &vOriginal, DWORD iPos, VARIANT &vNew, CIMTYPE ct)
{
HRESULT hr = 0;
if (vOriginal.vt & CIM_FLAG_ARRAY)
{
SAFEARRAY *pArray = V_ARRAY(&vOriginal);
SAFEARRAYBOUND aBounds[1];
long lLBound, lUBound;
DWORD Comp = (DWORD)iPos+1;
SafeArrayGetLBound(pArray, 1, &lLBound);
SafeArrayGetUBound(pArray, 1, &lUBound);
lUBound -= lLBound;
lUBound += 1;
if (Comp > lUBound)
{
aBounds[0].cElements = Comp;
aBounds[0].lLbound = 0;
SAFEARRAY *pNew = SafeArrayCreate(vNew.vt, 1, aBounds);
if (pNew)
{
for ( int i = 0; i < lUBound; i++ )
{
long lTemp[1];
lTemp[0] = i;
if ( (ct & 0xFFF) == CIM_STRING ||
(ct & 0xFFF) == CIM_DATETIME ||
(ct & 0xFFF) == CIM_REFERENCE )
{
BSTR bstr;
if ( SUCCEEDED(SafeArrayGetElement( pArray,
lTemp,
&bstr) ) )
{
SafeArrayPutElement( pNew, lTemp, bstr );
SysFreeString( bstr );
}
}
else if ( (ct & 0xFFF) == CIM_OBJECT )
{
IUnknown* pObj;
if ( SUCCEEDED(SafeArrayGetElement( pArray,
lTemp,
&pObj) ) )
{
SafeArrayPutElement( pNew, lTemp, pObj );
pObj->Release();
}
}
else
{
double dbVal;
if ( SUCCEEDED(SafeArrayGetElement( pArray,
lTemp,
&dbVal ) ) )
{
SafeArrayPutElement( pNew, lTemp, &dbVal );
}
}
}
SafeArrayDestroy(pArray);
pArray = pNew;
}
}
hr = PutVariantInArray(&pArray, iPos, &vNew);
if (SUCCEEDED(hr))
V_ARRAY(&vOriginal) = pArray;
}
else
{
VariantClear(&vOriginal);
// This is a new object.
SAFEARRAYBOUND aBounds[1];
aBounds[0].cElements = iPos+1;
aBounds[0].lLbound = 0;
SAFEARRAY* pArray = SafeArrayCreate(vNew.vt, 1, aBounds);
if (pArray)
{
hr = PutVariantInArray(&pArray, iPos, &vNew);
vOriginal.vt = VT_ARRAY|vNew.vt;
V_ARRAY(&vOriginal) = pArray;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
return hr;
}
//***************************************************************************
//
// SetObjectData
//
//***************************************************************************
HRESULT SetObjectData(CSQLConnection *pConn, IWbemClassObject *pNewObj, IWmiDbSession *pSession, CSchemaCache *pSchema,
CLASSDATA cd, BOOL bBlobData, BOOL &bBigText, BOOL *bObject=NULL, BOOL bNoDefaults=FALSE)
{
HRESULT hr = 0;
_bstr_t sPropName;
DWORD dwStorage, dwCIMType, dwPropFlags;
VARIANT vValue;
VariantInit(&vValue);
vValue.vt = VT_NULL;
wchar_t wTemp[455];
BOOL bSkip = FALSE;
int iLen = 0;
SQL_ID dRefId, dClassId;
if (bObject)
*bObject = FALSE;
dRefId = cd.dRefId;
hr = pSchema->GetPropertyInfo (cd.iPropertyId, &sPropName, NULL, &dwStorage,
&dwCIMType, &dwPropFlags);
if (SUCCEEDED(hr))
{
if (bNoDefaults && !(dwPropFlags & REPDRVR_FLAG_NONPROP))
return WBEM_S_NO_ERROR;
if (!(cd.iFlags & ESE_FLAG_NULL))
{
switch(dwStorage)
{
case WMIDB_STORAGE_REFERENCE: // Reference or object
case WMIDB_STORAGE_STRING:
if (bBlobData)
{
if ((dwCIMType == CIM_STRING || dwCIMType == CIM_REFERENCE)
&& cd.dwBufferLen > 0)
{
vValue.vt = VT_BSTR;
vValue.bstrVal = SysAllocString((LPWSTR)cd.pBuffer);
if (vValue.bstrVal)
iLen = wcslen(vValue.bstrVal);
}
else
{
vValue.vt = VT_NULL;
iLen = 0;
}
}
else
{
if (cd.sPropertyStringValue != NULL)
{
vValue.bstrVal = SysAllocString(cd.sPropertyStringValue);
if (vValue.bstrVal)
{
vValue.vt = VT_BSTR;
iLen = wcslen(vValue.bstrVal);
bBigText = IsTruncated(vValue.bstrVal, 127);
}
}
}
break;
case WMIDB_STORAGE_NUMERIC:
// Set in one of the kajillion numeric types...
if (dwCIMType == CIM_UINT64 || dwCIMType == CIM_SINT64)
{
wchar_t wTemp[50];
swprintf(wTemp, L"%I64d", cd.dPropertyNumericValue);
vValue.bstrVal = SysAllocString(wTemp);
vValue.vt = VT_BSTR;
}
else if (dwCIMType == CIM_BOOLEAN)
{
vValue.boolVal = (BOOL) cd.dPropertyNumericValue;
vValue.vt = VT_BOOL;
}
else
{
vValue.lVal = (DWORD) cd.dPropertyNumericValue;
vValue.vt = VT_I4;
}
break;
case WMIDB_STORAGE_REAL:
// Set as 32 or 64-bit real
if (dwCIMType == CIM_REAL32)
{
vValue.fltVal = (float)cd.rPropertyRealValue;
vValue.vt = VT_R4;
}
else if (dwCIMType == CIM_REAL64)
{
vValue.fltVal = (double)cd.rPropertyRealValue;
vValue.vt = VT_R8;
}
break;
case WMIDB_STORAGE_IMAGE:
if (dwCIMType != CIM_OBJECT)
{
if (cd.dwBufferLen > 0)
{
long why[1];
unsigned char t;
SAFEARRAYBOUND aBounds[1];
aBounds[0].cElements = cd.dwBufferLen;
aBounds[0].lLbound = 0;
SAFEARRAY* pArray = SafeArrayCreate(VT_UI1, 1, aBounds);
vValue.vt = VT_I1;
for (int i = 0; i < cd.dwBufferLen; i++)
{
why[0] = i;
t = cd.pBuffer[i];
hr = SafeArrayPutElement(pArray, why, &t);
}
vValue.vt = VT_ARRAY|VT_UI1;
V_ARRAY(&vValue) = pArray;
dwCIMType |= CIM_FLAG_ARRAY;
}
}
else
vValue.vt = VT_NULL;
break;
default:
hr = WBEM_E_NOT_SUPPORTED;
break;
}
if (FAILED(hr))
{
goto Exit;
}
// If this is an object (not a reference),
// then we need to Get the object and set it in
// the variant. Otherwise, the variant is simply
// the string path to the object.
// ===============================================
if (dwCIMType == CIM_OBJECT)
{
if (bObject)
{
*bObject = TRUE;
goto Exit;
}
else
{
if (!bBlobData)
{
IWmiDbHandle *pHand = NULL;
if (vValue.vt == VT_BSTR)
{
hr = ((CWmiDbSession *)pSession)->GetObject_Internal((LPWSTR)vValue.bstrVal, (DWORD)0,
(DWORD)WMIDB_HANDLE_TYPE_COOKIE, NULL, &pHand, pConn);
CReleaseMe r4 (pHand);
if (SUCCEEDED(hr))
{
IWbemClassObject *pEmbed = NULL;
hr = ((CWmiDbHandle *)pHand)->QueryInterface_Internal(pConn, (void **)&pEmbed);
if (SUCCEEDED(hr))
{
VariantClear(&vValue);
V_UNKNOWN(&vValue) = (IUnknown *)pEmbed;
vValue.vt = VT_UNKNOWN;
// VariantClear will release this, right?
}
}
}
}
else
{
_IWmiObject *pNew = NULL;
hr = ConvertBlobToObject (pNewObj, cd.pBuffer, cd.dwBufferLen, &pNew);
if (SUCCEEDED(hr))
{
VariantClear(&vValue);
V_UNKNOWN(&vValue) = (IUnknown *)pNew;
vValue.vt = VT_UNKNOWN;
}
}
}
}
// For array properties, what we actually need to do is
// see if the property exists already. If not, we
// initialize the safe array and add the first element.
// If so, we simply set the value in the existing array.
// ======================================================
if (dwPropFlags & REPDRVR_FLAG_ARRAY && (dwStorage != WMIDB_STORAGE_IMAGE))
{
dwCIMType |= CIM_FLAG_ARRAY;
VARIANT vTemp;
CClearMe c (&vTemp);
long lTemp;
CIMTYPE cimtype;
if (SUCCEEDED(pNewObj->Get(sPropName, 0, &vTemp, &cimtype, &lTemp)))
{
hr = SetInArray(vTemp, cd.iArrayPos, vValue, cimtype);
if (SUCCEEDED(hr))
{
hr = pNewObj->Put(sPropName, 0, &vTemp, dwCIMType);
bSkip = TRUE;
}
}
}
}
if (!(dwPropFlags & REPDRVR_FLAG_QUALIFIER) &&
!(dwPropFlags & REPDRVR_FLAG_IN_PARAM) &&
!(dwPropFlags & REPDRVR_FLAG_OUT_PARAM) &&
!bSkip)
{
if (wcslen(sPropName) == 127)
{
pNewObj->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
BSTR strName = NULL;
while (pNewObj->Next(0, &strName, NULL, NULL, NULL) == S_OK)
{
CFreeMe f (strName);
if (!_wcsnicmp(strName, sPropName, 127))
sPropName = strName;
}
}
hr = pNewObj->Put(sPropName, 0, &vValue, dwCIMType);
}
// If this is a qualifier on a class, get the qualifier set and set the value.
else if (dwPropFlags & REPDRVR_FLAG_QUALIFIER )
{
if (dRefId != 0)
{
_bstr_t sProp2;
DWORD dwFlags2, dwRefID;
hr = pSchema->GetPropertyInfo (dRefId, &sProp2, NULL, NULL,
NULL, &dwFlags2, NULL, NULL, &dwRefID);
if (SUCCEEDED(hr))
{
if (wcslen(sPropName) == 127)
{
pNewObj->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
BSTR strName = NULL;
while (pNewObj->Next(0, &strName, NULL, NULL, NULL) == S_OK)
{
CFreeMe f (strName);
if (!_wcsnicmp(strName, sProp2, 127))
sProp2 = strName;
}
}
// This is a property qualifier. See if its a property or a method.
// and get all the pertinent info.
// This is a qualifier on a method parameter.
if (dwFlags2 & REPDRVR_FLAG_IN_PARAM ||
dwFlags2 & REPDRVR_FLAG_OUT_PARAM)
{
IWbemClassObject *pIn = NULL;
IWbemClassObject *pOut = NULL;
IWbemQualifierSet *pQS = NULL;
_bstr_t sProp3;
hr = pSchema->GetPropertyInfo (dwRefID, &sProp3);
if (SUCCEEDED(hr))
{
hr = pNewObj->GetMethod(sProp3, 0, &pIn, &pOut);
CReleaseMe r5 (pIn), r6 (pOut);
if (SUCCEEDED(hr))
{
if (dwFlags2 & REPDRVR_FLAG_IN_PARAM && pIn)
hr = pIn->GetPropertyQualifierSet(sProp2, &pQS);
else if (dwFlags2 & REPDRVR_FLAG_OUT_PARAM && pOut)
hr = pOut->GetPropertyQualifierSet(sProp2, &pQS);
if (pQS)
{
CReleaseMe r7 (pQS);
if (!_wcsicmp(sPropName, L"id"))
sPropName = L"repdrvr_id"; // Sneaky business.
// Because we can't set method parameters incrementally,
// we need to store the real position IDs as a different
// name and switch them back when we're done...
if (dwPropFlags & REPDRVR_FLAG_ARRAY)
{
VARIANT vTemp;
BOOL bExists = FALSE;
CClearMe c (&vTemp);
hr = pQS->Get(sPropName, 0, &vTemp, 0);
if (vTemp.vt & CIM_FLAG_ARRAY)
bExists = TRUE;
hr = SetInArray(vTemp, cd.iArrayPos, vValue, dwCIMType);
hr = pQS->Put(sPropName, &vTemp, cd.iFlags);
}
else
hr = pQS->Put(sPropName, &vValue, cd.iFlags);
hr = pNewObj->PutMethod(sProp3, 0, pIn, pOut);
}
}
}
}
// This is a qualifier on a method.
else if (dwFlags2 & REPDRVR_FLAG_METHOD)
{
IWbemQualifierSet *pQS = NULL;
hr = pNewObj->GetMethodQualifierSet(sProp2, &pQS);
CReleaseMe r4 (pQS);
if (SUCCEEDED(hr))
{
if (dwPropFlags & REPDRVR_FLAG_ARRAY)
{
VARIANT vTemp;
CClearMe c (&vTemp);
BOOL bExists = FALSE;
hr = pQS->Get(sPropName, 0, &vTemp, 0);
if (vTemp.vt & CIM_FLAG_ARRAY)
bExists = TRUE;
hr = SetInArray(vTemp, cd.iArrayPos, vValue, dwCIMType);
hr = pQS->Put(sPropName, &vTemp, cd.iFlags);
}
else
hr = pQS->Put(sPropName, &vValue, cd.iFlags);
}
}
// This is a qualifier on a property.
else
{
IWbemQualifierSet *pQS = NULL;
hr = pNewObj->GetPropertyQualifierSet(sProp2, &pQS);
CReleaseMe r4 (pQS);
if (SUCCEEDED(hr))
{
if (dwPropFlags & REPDRVR_FLAG_ARRAY)
{
VARIANT vTemp;
CClearMe c (&vTemp);
BOOL bExists = FALSE;
hr = pQS->Get(sPropName, 0, &vTemp, 0);
if (vTemp.vt & CIM_FLAG_ARRAY)
bExists = TRUE;
hr = SetInArray(vTemp, cd.iArrayPos, vValue, dwCIMType);
hr = pQS->Put(sPropName, &vTemp, cd.iFlags);
}
else
hr = pQS->Put(sPropName, &vValue, cd.iFlags);
}
}
}
}
else // Its just a class/instance qualifier. Set it.
{
IWbemQualifierSet *pQS = NULL;
hr = pNewObj->GetQualifierSet(&pQS);
CReleaseMe r5 (pQS);
if (SUCCEEDED(hr))
{
if (dwPropFlags & REPDRVR_FLAG_ARRAY)
{
VARIANT vTemp;
CClearMe c (&vTemp);
BOOL bExists = FALSE;
hr = pQS->Get(sPropName, 0, &vTemp, 0);
if (vTemp.vt & CIM_FLAG_ARRAY)
bExists = TRUE;
hr = SetInArray(vTemp, cd.iArrayPos, vValue, dwCIMType);
hr = pQS->Put(sPropName, &vTemp, cd.iFlags);
}
else
hr = pQS->Put(sPropName, &vValue, cd.iFlags);
}
}
}
else if (dwPropFlags & REPDRVR_FLAG_METHOD)
{
// This is a method. Skip it.
}
else if (dwPropFlags & REPDRVR_FLAG_IN_PARAM ||
dwPropFlags & REPDRVR_FLAG_OUT_PARAM )
{
_bstr_t sProp2;
IWbemClassObject *pTemp = NULL;
hr = pSchema->GetPropertyInfo (dRefId, &sProp2);
if (SUCCEEDED(hr))
{
IWbemClassObject *pOther = NULL;
if (dwPropFlags & REPDRVR_FLAG_IN_PARAM)
hr = pNewObj->GetMethod(sProp2, 0, &pTemp, &pOther);
else
hr = pNewObj->GetMethod(sProp2, 0, &pOther, &pTemp);
CReleaseMe r1 (pTemp), r2 (pOther);
if (SUCCEEDED(hr))
{
if (!pTemp)
{
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemClassObject, (void **)&pTemp);
VARIANT vTemp;
CClearMe c (&vTemp);
vTemp.bstrVal = SysAllocString(L"__Parameters");
vTemp.vt = VT_BSTR;
pTemp->Put(L"__Class", NULL, &vTemp, CIM_STRING);
}
pTemp->Put(sPropName, 0, &vValue, dwCIMType);
VARIANT vTemp;
CClearMe c2 (&vTemp);
long lNumProps = 0;
pTemp->Get(L"__Property_Count", NULL, &vTemp, NULL, NULL);
lNumProps = vTemp.lVal;
if (pOther)
{
VARIANT vTemp2;
CClearMe c2 (&vTemp2);
pOther->Get(L"__Property_Count", NULL, &vTemp2, NULL, NULL);
lNumProps+= vTemp2.lVal;
}
if (_wcsicmp(sPropName, L"ReturnValue"))
{
IWbemQualifierSet *pQS = NULL;
pTemp->GetPropertyQualifierSet(sPropName, &pQS);
CReleaseMe r5 (pQS);
if (pQS)
{
V_I4(&vTemp) = lNumProps - 1;
vTemp.vt = VT_I4;
pQS->Put(L"id", &vTemp, 0);
}
}
if (dwPropFlags & REPDRVR_FLAG_IN_PARAM)
hr = pNewObj->PutMethod(sProp2, 0, pTemp, pOther);
else
hr = pNewObj->PutMethod(sProp2, 0, pOther, pTemp);
hr = pSchema->SetAuxiliaryPropertyInfo(cd.iPropertyId, L"", dRefId);
}
}
}
}
Exit:
VariantClear(&vValue);
return hr;
}
// structs for open rowsets.
//***************************************************************************
//
// AddColumnToTable
//
//***************************************************************************
// Helper functions for setting up reusable accessors.
HRESULT AddColumnToTable (CESEConnection *pConn, JET_TABLEID tableid, LPSTR lpTableName, LPWSTR lpColumnName,
DWORD _colid, DWORD datatype, DWORD options, DWORD prec, JET_COLUMNID *colid)
{
HRESULT hr = WBEM_S_NO_ERROR;
char *pColName = GetAnsiString(lpColumnName);
if (!pColName)
return WBEM_E_OUT_OF_MEMORY;
CDeleteMe <char> d (pColName);
JET_COLUMNDEF columnDef;
JET_ERR err = JET_errSuccess;
err = JetGetColumnInfo(pConn->GetSessionID(), pConn->GetDBID(), lpTableName, pColName,
&columnDef, sizeof(JET_COLUMNDEF), 0);
if (err < JET_errSuccess)
{
columnDef.cp = 1200; // Unicode? Otherwise, its 1252.
columnDef.wCountry = 1;
columnDef.langid = 1033;
columnDef.wCollate = 0;
columnDef.cbStruct = sizeof(JET_COLUMNDEF);
columnDef.columnid = _colid;
columnDef.coltyp = datatype;
columnDef.grbit = options ;
columnDef.cbMax = prec;
err = JetAddColumn(pConn->GetSessionID(), tableid, pColName, &columnDef, "", 0, colid);
}
else
*colid = columnDef.columnid;
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// UpdateDBVersion
//
//***************************************************************************
HRESULT UpdateDBVersion (CSQLConnection *_pConn, DWORD iVersion)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
const LPSTR lpTbl = "DBVersion";
JET_SESID session = pConn->GetSessionID();
JET_DBID dbid = pConn->GetDBID();
JET_TABLEID tableid;
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"Version", 0, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
{
// This is a one-row table.
err = JetMove(session, tableid, JET_MoveFirst, 0);
if (err >= JET_errSuccess)
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
else
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, colid,
&iVersion, sizeof(DWORD), 0, NULL );
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
JetCloseTable(session, tableid);
hr = CSQLExecute::GetWMIError(err);
Exit:
return hr;
}
//***************************************************************************
//
// SetupObjectMapAccessor
//
//***************************************************************************
HRESULT SetupObjectMapAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
const LPSTR lpTbl = "ObjectMap";
if (!pConn->GetTableID(L"ObjectMap"))
{
JET_SESID session;
JET_TABLEID tableid;
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
JET_DBID dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
CSQLExecute::GetWMIError(err);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ObjectMap", tableid);
JET_COLUMNID colid;
// Unfortunately, they don't support a numeric type,
// so we have to use currency.
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectId", OBJECTMAP_COL_OBJECTID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTID, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectPath", OBJECTMAP_COL_OBJECTPATH, JET_coltypText,
0, MAX_STRING_WIDTH, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTPATH, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectKey", OBJECTMAP_COL_OBJECTKEY, JET_coltypText,
0, MAX_STRING_WIDTH, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTKEY, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ReferenceCount", OBJECTMAP_COL_REFERENCECOUNT, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_REFERENCECOUNT, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectState", OBJECTMAP_COL_OBJECTSTATE, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTSTATE, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", OBJECTMAP_COL_CLASSID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_CLASSID, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectFlags", OBJECTMAP_COL_OBJECTFLAGS, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTFLAGS, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectScopeId", OBJECTMAP_COL_OBJECTSCOPEID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, OBJECTMAP_COL_OBJECTSCOPEID, colid);
else if (err != JET_errColumnDuplicate)
goto Exit;
err = JetCreateIndex(session, tableid, "ObjectMap_PK", JET_bitIndexPrimary | JET_bitIndexUnique,"+ObjectId\0", 11, 100);
if (err >= JET_errSuccess || err == JET_errIndexHasPrimary)
{
err = JetCreateIndex(session, tableid, "ObjectScopeId_idx", JET_bitIndexDisallowNull ,"+ObjectScopeId\0", 16, 100);
if (err >= JET_errSuccess|| err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "ObjectClassId_idx", JET_bitIndexDisallowNull ,"+ClassId\0", 10, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupObjectMapAccessor(_pConn);
}
}
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetObjectMapData
//
//***************************************************************************
HRESULT GetObjectMapData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
OBJECTMAP &oj)
{
HRESULT hr = WBEM_E_FAILED;
oj.Clear();
unsigned long lLen;
wchar_t buff[1024];
CESEConnection *pConn = (CESEConnection *)_pConn;
oj.dObjectId = 0;
JET_ERR err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTID),
&oj.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTKEY),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sObjectKey = SysAllocString(buff);
if (wcslen(buff) && !oj.sObjectKey)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTPATH),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sObjectPath = SysAllocString(buff);
if (wcslen(buff) && !oj.sObjectPath)
{
hr = WBEM_E_OUT_OF_MEMORY;
oj.Clear();
goto exit;
}
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_REFERENCECOUNT),
&oj.iRefCount, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTFLAGS),
&oj.iObjectFlags, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSCOPEID),
&oj.dObjectScopeId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSTATE),
&oj.iObjectState, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// OpenEnum_ObjectMap
//
//***************************************************************************
HRESULT OpenEnum_ObjectMap (CSQLConnection *_pConn, OBJECTMAP &oj)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMove(session, tableid, JET_MoveFirst, 0);
if (err == JET_errSuccess)
hr = GetObjectMapData(pConn, session, tableid, oj);
}
}
return hr;
}
//***************************************************************************
//
// GetFirst_ObjectMap
//
//***************************************************************************
HRESULT GetFirst_ObjectMap (CSQLConnection *_pConn, SQL_ID dObjectId, OBJECTMAP &oj)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetObjectMapData(pConn, session, tableid, oj);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ObjectMapByScope
//
//***************************************************************************
HRESULT GetFirst_ObjectMapByScope (CSQLConnection *_pConn, SQL_ID dScopeId, OBJECTMAP &oj,
DWORD seektype = JET_bitSeekEQ)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectScopeId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dScopeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, seektype );
if (err == JET_errSuccess)
{
if (seektype == JET_bitSeekEQ)
{
err = JetMakeKey(session, tableid, &dScopeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
}
else if (seektype == JET_bitSeekLT || seektype == JET_bitSeekLE )
{
err = JetMakeKey(session, tableid, &dScopeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
err = JetSetIndexRange(session, tableid, JET_bitRangeUpperLimit);
}
if (err == JET_errSuccess)
hr = GetObjectMapData(pConn, session, tableid, oj);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ObjectMapByClass
//
//***************************************************************************
HRESULT GetFirst_ObjectMapByClass (CSQLConnection *_pConn, SQL_ID dClassId, OBJECTMAP &oj)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetObjectMapData(pConn, session, tableid, oj);
}
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ObjectMap
//
//***************************************************************************
HRESULT GetNext_ObjectMap (CSQLConnection *_pConn, OBJECTMAP &oj)
{
HRESULT hr = 0;
oj.Clear();
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetObjectMapData(pConn, session, tableid, oj);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateObjectMap
//
//***************************************************************************
HRESULT UpdateObjectMap (CSQLConnection *_pConn, OBJECTMAP oj, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
JET_ERR err = JET_errSuccess;
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
err = JetSetCurrentIndex(session, tableid, "ObjectMap_PK");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &oj.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
if (oj.sObjectPath)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTPATH),
oj.sObjectPath, wcslen(oj.sObjectPath)*2+2, 0, NULL );
else
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTPATH),
NULL, 0, 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_CLASSID),
&oj.dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSCOPEID),
&oj.dObjectScopeId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (oj.sObjectKey)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTKEY),
oj.sObjectKey, wcslen(oj.sObjectKey)*2+2, 0, NULL);
else
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTKEY),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_REFERENCECOUNT),
&oj.iRefCount, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTFLAGS),
&oj.iObjectFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSTATE),
&oj.iObjectState, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
}
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertObjectMap
//
//***************************************************************************
HRESULT InsertObjectMap(CSQLConnection *_pConn, SQL_ID dObjectId, LPCWSTR lpKey,
DWORD iState, LPCWSTR lpObjectPath, SQL_ID dScopeID, DWORD iClassFlags,
DWORD iRefCount, SQL_ID dClassId, BOOL bInsert)
{
DEBUGTRACE((LOG_WBEMCORE, "InsertObjectMap %S\n", lpObjectPath));
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
OBJECTMAP oj;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ObjectMap");
if (FAILED(GetFirst_ObjectMap(_pConn, dObjectId, oj)))
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTID), &dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTPATH), lpObjectPath, wcslen(lpObjectPath)*2+2, 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_CLASSID), &dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSCOPEID), &dScopeID, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTKEY), lpKey, wcslen(lpKey)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_REFERENCECOUNT), &iRefCount, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTFLAGS), &iClassFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, OBJECTMAP_COL_OBJECTSTATE), &iState, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
}
else if (!bInsert)
{
oj.Clear();
oj.dObjectId = dObjectId;
oj.dClassId = dClassId;
oj.sObjectPath = SysAllocString(lpObjectPath);
oj.sObjectKey = SysAllocString(lpKey);
if (!oj.sObjectPath || !oj.sObjectKey)
{
hr = WBEM_E_OUT_OF_MEMORY;
oj.Clear();
goto Exit;
}
oj.iRefCount = iRefCount;
oj.iObjectFlags = iClassFlags;
oj.dObjectScopeId = dScopeID;
oj.iObjectState = iState;
hr = UpdateObjectMap(pConn, oj, FALSE);
oj.Clear();
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupScopeMapAccessor
//
//***************************************************************************
HRESULT SetupScopeMapAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ScopeMap"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ScopeMap";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ScopeMap", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectId", SCOPEMAP_COL_OBJECTID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, SCOPEMAP_COL_OBJECTID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ScopePath", SCOPEMAP_COL_SCOPEPATH, JET_coltypLongBinary,
0, 0, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, SCOPEMAP_COL_SCOPEPATH, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ParentId", SCOPEMAP_COL_PARENTID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, SCOPEMAP_COL_PARENTID, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ScopeMap_PK", JET_bitIndexPrimary | JET_bitIndexUnique,"+ObjectId\0", 11, 100);
if ((err >= JET_errSuccess || err == JET_errIndexHasPrimary) && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupScopeMapAccessor(_pConn);
}
}
if (err == JET_errIndexHasPrimary)
err = 0;
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetScopeMapData
//
//***************************************************************************
HRESULT GetScopeMapData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
SCOPEMAP &sm)
{
HRESULT hr = WBEM_E_FAILED;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
wchar_t buff[1024];
BYTE buff2[1024];
sm.Clear();
JET_ERR err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_OBJECTID),
&sm.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_SCOPEPATH),
buff2, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
BYTE *pBuff = new BYTE [lLen];
if (pBuff)
{
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_SCOPEPATH),
pBuff, lLen, &lLen, JET_bitRetrieveCopy, NULL);
sm.sScopePath = SysAllocString((LPWSTR)pBuff);
if (!sm.sScopePath)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_PARENTID),
&sm.dParentId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// OpenEnum_ScopeMap
//
//***************************************************************************
HRESULT OpenEnum_ScopeMap (CSQLConnection *_pConn, SCOPEMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupScopeMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
// Use the default index
// Grab the first row,
// and stuff it into the SCOPEMAP object.
JetSetIndexRange(session, tableid, JET_bitRangeRemove);
JET_ERR err = JetSetCurrentIndex(session, tableid, "ScopeMap_PK");
if (err == JET_errSuccess)
{
err = JetMove(session, tableid, JET_MoveFirst, 0);
if (err == JET_errSuccess)
hr = GetScopeMapData(pConn, session, tableid, cd);
}
}
return hr;
}
//***************************************************************************
//
// GetFirst_ScopeMap
//
//***************************************************************************
HRESULT GetFirst_ScopeMap (CSQLConnection *_pConn, SQL_ID dScopeId, SCOPEMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupScopeMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
// Use the default index
// Grab the first row,
// and stuff it into the SCOPEMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ScopeMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dScopeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dScopeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
hr = GetScopeMapData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ScopeMap
//
//***************************************************************************
HRESULT GetNext_ScopeMap (CSQLConnection *_pConn, SCOPEMAP &cd)
{
HRESULT hr = 0;
cd.Clear();
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetScopeMapData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateScopeMap
//
//***************************************************************************
HRESULT UpdateScopeMap (CSQLConnection *_pConn, SCOPEMAP cd, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupScopeMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
err = JetSetCurrentIndex(session, tableid, "ScopeMap_PK");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_PARENTID),
&cd.dParentId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (cd.sScopePath)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_SCOPEPATH),
cd.sScopePath, wcslen(cd.sScopePath)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
}
}
}
}
Exit:
hr = CSQLExecute::GetWMIError(err);
if (bDelete && hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// InsertScopeMap_Internal
//
//***************************************************************************
HRESULT InsertScopeMap_Internal(CSQLConnection *_pConn, SQL_ID dObjectId, LPCWSTR lpPath, SQL_ID dParentId)
{
JET_ERR err = 0;
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupScopeMapAccessor(pConn);
if (SUCCEEDED(hr))
{
SCOPEMAP oj;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
if (FAILED(GetFirst_ScopeMap(_pConn, dObjectId, oj)))
{
int iLen = 2;
BYTE *pBuff = (BYTE *)lpPath;
if (lpPath)
{
iLen += wcslen(lpPath)*2;
}
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_OBJECTID),
&dObjectId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_SCOPEPATH),
pBuff, iLen, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, SCOPEMAP_COL_PARENTID),
&dParentId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
oj.Clear();
}
else
{
oj.Clear();
oj.dObjectId = dObjectId;
oj.dParentId = dParentId;
oj.sScopePath = SysAllocString(lpPath);
if (!oj.sScopePath)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
hr = UpdateScopeMap(pConn, oj, FALSE);
SysFreeString(oj.sScopePath); // The buffer is released by the caller.
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// DeleteScopeMap
//
//***************************************************************************
HRESULT DeleteScopeMap(CSQLConnection *_pConn, SQL_ID dObjectId)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupScopeMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ScopeMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ScopeMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetDelete(session, tableid);
}
}
}
hr = CSQLExecute::GetWMIError(err);
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
}
return hr;
}
//***************************************************************************
//
// SetupClassMapAccessor
//
//***************************************************************************
HRESULT SetupClassMapAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ClassMap"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ClassMap";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ClassMap", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", CLASSMAP_COL_CLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSMAP_COL_CLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassName", CLASSMAP_COL_CLASSNAME, JET_coltypText,
0, MAX_STRING_WIDTH, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSMAP_COL_CLASSNAME, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"SuperClassId", CLASSMAP_COL_SUPERCLASSID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSMAP_COL_SUPERCLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"DynastyId", CLASSMAP_COL_DYNASTYID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSMAP_COL_DYNASTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassBlob", CLASSMAP_COL_CLASSBUFFER, JET_coltypLongBinary,
0, 0, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ClassMap_PK", JET_bitIndexPrimary | JET_bitIndexUnique,"+ClassId\0", 10, 100);
if (err >= JET_errSuccess || err == JET_errIndexHasPrimary)
{
err = JetCreateIndex(session, tableid, "SuperClassId_idx", JET_bitIndexDisallowNull ,"+SuperClassId\0", 15, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
err = JetCreateIndex(session, tableid, "DynastyId_idx", JET_bitIndexDisallowNull, "+DynastyId\0", 12, 80);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
err = JetCreateIndex(session, tableid, "ClassName_idx", JET_bitIndexDisallowNull, "+ClassName\0", 12, 80);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupClassMapAccessor(_pConn);
}
}
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetClassMapData
//
//***************************************************************************
HRESULT GetClassMapData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
CLASSMAP &oj)
{
HRESULT hr = WBEM_E_FAILED;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
wchar_t buff[1024];
BYTE buff2[1024];
oj.dClassId = 0;
oj.dSuperClassId = 0;
oj.dDynastyId = 0;
oj.Clear();
JET_ERR err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSNAME),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sClassName = SysAllocString(buff);
if (!oj.sClassName)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_SUPERCLASSID),
&oj.dSuperClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_DYNASTYID),
&oj.dDynastyId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER),
buff2, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
oj.dwBufferLen = lLen;
BYTE *pBuff = new BYTE [lLen];
if (pBuff)
{
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER),
pBuff, lLen, &oj.dwBufferLen, JET_bitRetrieveCopy, NULL);
oj.pClassBuffer = pBuff;
}
else
{
hr = WBEM_E_OUT_OF_MEMORY;
oj.Clear();
goto exit;
}
}
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// OpenEnum_ClassMap
//
//***************************************************************************
HRESULT OpenEnum_ClassMap (CSQLConnection *_pConn, CLASSMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JetSetIndexRange(session, tableid, JET_bitRangeRemove);
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassMap_PK");
if (err == JET_errSuccess)
{
err = JetMove(session, tableid, JET_MoveFirst, 0);
if (err == JET_errSuccess)
hr = GetClassMapData(pConn, session, tableid, cd);
}
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassMap
//
//***************************************************************************
HRESULT GetFirst_ClassMap (CSQLConnection *_pConn, SQL_ID dClassId, CLASSMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
hr = GetClassMapData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassMapBySuperClass
//
//***************************************************************************
HRESULT GetFirst_ClassMapBySuperClass (CSQLConnection *_pConn, SQL_ID dSuperClassId, CLASSMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "SuperClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dSuperClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dSuperClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassMapData(pConn, session, tableid, cd);
}
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassMapByDynasty
//
//***************************************************************************
HRESULT GetFirst_ClassMapByDynasty (CSQLConnection *_pConn, SQL_ID dDynastyId, CLASSMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "DynastyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dDynastyId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dDynastyId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassMapData(pConn, session, tableid, cd);
}
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassMapByName
//
//***************************************************************************
HRESULT GetFirst_ClassMapByName (CSQLConnection *_pConn, LPCWSTR lpName, CLASSMAP &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
if (!lpName)
return WBEM_E_INVALID_PARAMETER;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassName_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, lpName, wcslen(lpName)*2+2, JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, lpName, wcslen(lpName)*2+2, JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassMapData(pConn, session, tableid, cd);
}
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ClassMap
//
//***************************************************************************
HRESULT GetNext_ClassMap (CSQLConnection *_pConn, CLASSMAP &cd)
{
HRESULT hr = 0;
cd.Clear();
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetClassMapData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateClassMap
//
//***************************************************************************
HRESULT UpdateClassMap (CSQLConnection *_pConn, CLASSMAP cd, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
err = JetSetCurrentIndex(session, tableid, "ClassMap_PK");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dClassId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSNAME),
cd.sClassName, wcslen(cd.sClassName)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_SUPERCLASSID),
&cd.dSuperClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_DYNASTYID),
&cd.dDynastyId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (cd.dwBufferLen)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER),
cd.pClassBuffer, cd.dwBufferLen, 0, NULL);
else
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
}
}
}
}
Exit:
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertClassMap
//
//***************************************************************************
HRESULT InsertClassMap(CSQLConnection *_pConn, SQL_ID dClassId, LPCWSTR lpClassName, SQL_ID dSuperClassId,
SQL_ID dDynasty, BYTE *pBuff, DWORD dwBufferLen, BOOL bInsert)
{
if (!dSuperClassId && dClassId != 1)
dSuperClassId = 1;
JET_ERR err = 0;
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassMapAccessor(pConn);
if (SUCCEEDED(hr))
{
CLASSMAP oj;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassMap");
if (FAILED(GetFirst_ClassMap(_pConn, dClassId, oj)))
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSID),
&dClassId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSNAME),
lpClassName, wcslen(lpClassName)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_SUPERCLASSID),
&dSuperClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_DYNASTYID),
&dDynasty, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSMAP_COL_CLASSBUFFER),
pBuff, dwBufferLen, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
oj.Clear();
}
else if (!bInsert)
{
oj.Clear();
oj.dClassId = dClassId;
oj.dSuperClassId = dSuperClassId;
oj.dDynastyId = dDynasty;
oj.sClassName = SysAllocString(lpClassName);
if (!oj.sClassName)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
oj.pClassBuffer = pBuff;
oj.dwBufferLen = dwBufferLen;
hr = UpdateClassMap(pConn, oj, FALSE);
SysFreeString(oj.sClassName); // The buffer is released by the caller.
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupPropertyMapAccessor
//
//***************************************************************************
HRESULT SetupPropertyMapAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"PropertyMap"))
{
JET_SESID session;
JET_DBID dbid;
JET_TABLEID tableid;
const LPSTR lpTbl = "PropertyMap";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"PropertyMap", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", PROPERTYMAP_COL_CLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_CLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyId", PROPERTYMAP_COL_PROPERTYID, JET_coltypLong,
JET_bitColumnNotNULL|JET_bitColumnAutoincrement, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_PROPERTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"StorageTypeId", PROPERTYMAP_COL_STORAGETYPEID, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_STORAGETYPEID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"CIMTypeId", PROPERTYMAP_COL_CIMTYPEID, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_CIMTYPEID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyName", PROPERTYMAP_COL_PROPERTYNAME, JET_coltypText,
JET_bitColumnNotNULL, MAX_STRING_WIDTH, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_PROPERTYNAME, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"Flags", PROPERTYMAP_COL_FLAGS, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, PROPERTYMAP_COL_FLAGS, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "PropertyMap_PK", JET_bitIndexPrimary | JET_bitIndexUnique,"+PropertyId\0", 13, 100);
if (err >= JET_errSuccess || err == JET_errIndexHasPrimary)
{
err = JetCreateIndex(session, tableid, "ClassId_idx", JET_bitIndexDisallowNull ,"+ClassId\0", 10, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
err = JET_errSuccess;
else
hr = CSQLExecute::GetWMIError(err);
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupPropertyMapAccessor(_pConn);
}
}
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetPropertyMapData
//
//***************************************************************************
HRESULT GetPropertyMapData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
PROPERTYMAP &oj)
{
HRESULT hr = WBEM_E_FAILED;
oj.Clear();
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
wchar_t buff[1024];
oj.iPropertyId = 0;
JET_ERR err = JET_errSuccess;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_PROPERTYID),
&oj.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_PROPERTYNAME),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sPropertyName = SysAllocString(buff);
if (!oj.sPropertyName)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_STORAGETYPEID),
&oj.iStorageTypeId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CIMTYPEID),
&oj.iCIMTypeId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_FLAGS),
&oj.iFlags, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_PropertyMap
//
//***************************************************************************
HRESULT GetFirst_PropertyMap (CSQLConnection *_pConn, DWORD iPropertyId, PROPERTYMAP &pm)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupPropertyMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"PropertyMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyMap_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetPropertyMapData(pConn, session, tableid, pm);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_PropertyMapByClass
//
//***************************************************************************
HRESULT GetFirst_PropertyMapByClass (CSQLConnection *_pConn, SQL_ID dClassId, PROPERTYMAP &pm)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupPropertyMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"PropertyMap");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetPropertyMapData(pConn, session, tableid, pm);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_PropertyMap
//
//***************************************************************************
HRESULT GetNext_PropertyMap (CSQLConnection *_pConn, PROPERTYMAP &pm)
{
HRESULT hr = 0;
pm.Clear();
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"PropertyMap");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetPropertyMapData(pConn, session, tableid, pm);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdatePropertyMap
//
//***************************************************************************
HRESULT UpdatePropertyMap(CSQLConnection *_pConn, PROPERTYMAP pm, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupPropertyMapAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"PropertyMap");
err = JetSetCurrentIndex(session, tableid, "PropertyMap_PK");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &pm.iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_PROPERTYNAME),
pm.sPropertyName, wcslen(pm.sPropertyName)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CLASSID),
&pm.dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_STORAGETYPEID),
&pm.iStorageTypeId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_FLAGS),
&pm.iFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CIMTYPEID),
&pm.iCIMTypeId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
}
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertPropertyMap
//
//***************************************************************************
HRESULT InsertPropertyMap (CSQLConnection *_pConn, DWORD &iPropID, SQL_ID dClassId, DWORD iStorageTypeId,
DWORD iCIMTypeId, LPCWSTR lpPropName, DWORD iFlags, BOOL bInsert)
{
JET_ERR err = 0;
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupPropertyMapAccessor(pConn);
if (SUCCEEDED(hr))
{
if (bInsert)
iPropID = 0;
unsigned long lLen;
PROPERTYMAP pm;
DWORD dwOldFlags = 0;
JET_SESID session = pConn->GetSessionID();
BOOL bExists = FALSE;
JET_TABLEID tableid = pConn->GetTableID(L"PropertyMap");
hr = GetFirst_PropertyMapByClass(_pConn, dClassId, pm);
while (SUCCEEDED(hr))
{
if (!_wcsicmp(pm.sPropertyName, lpPropName))
{
BOOL bMatch = TRUE;
if ((iFlags & REPDRVR_FLAG_NONPROP) == (pm.iFlags & REPDRVR_FLAG_NONPROP))
{
if (iFlags & REPDRVR_FLAG_NONPROP)
{
if (iStorageTypeId != pm.iStorageTypeId)
bMatch = FALSE;
}
if (bMatch)
{
iPropID = pm.iPropertyId;
dwOldFlags = pm.iFlags;
pm.Clear();
bExists = TRUE;
break;
}
}
}
hr = GetNext_PropertyMap(_pConn, pm);
if (pm.dClassId != dClassId)
break;
}
hr = WBEM_S_NO_ERROR;
if (!bExists)
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
// Now retrieve the auto-incremented ID...
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_PROPERTYID),
&iPropID, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL) ;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_PROPERTYNAME),
lpPropName, wcslen(lpPropName)*2+2, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CLASSID),
&dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_STORAGETYPEID),
&iStorageTypeId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_FLAGS),
&iFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, PROPERTYMAP_COL_CIMTYPEID),
&iCIMTypeId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
}
else if (!bInsert)
{
pm.Clear();
pm.iPropertyId = iPropID;
pm.sPropertyName = SysAllocString(lpPropName);
if (!pm.sPropertyName)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
pm.dClassId = dClassId;
pm.iStorageTypeId = iStorageTypeId;
pm.iCIMTypeId = iCIMTypeId;
pm.iFlags = iFlags;
hr = UpdatePropertyMap(pConn, pm, FALSE);
pm.Clear();
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupClassKeysAccessor
//
//***************************************************************************
HRESULT SetupClassKeysAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ClassKeys"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ClassKeys";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ClassKeys", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", CLASSKEYS_COL_CLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSKEYS_COL_CLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyId", CLASSKEYS_COL_PROPERTYID, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSKEYS_COL_PROPERTYID, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ClassId_idx", JET_bitIndexDisallowNull,"+ClassId\0", 10, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "PropertyId_idx", JET_bitIndexDisallowNull ,"+PropertyId\0", 13, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupClassKeysAccessor(_pConn);
}
}
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetClassKeysData
//
//***************************************************************************
HRESULT GetClassKeysData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
CLASSKEYS &oj)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
oj.iPropertyId = 0;
JET_ERR err = JET_errSuccess;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSKEYS_COL_PROPERTYID),
&oj.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSKEYS_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_ClassKeys
//
//***************************************************************************
HRESULT GetFirst_ClassKeys (CSQLConnection *_pConn, SQL_ID dClassId, CLASSKEYS &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassKeysAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassKeys");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetClassKeysData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassKeysByPropertyId
//
//***************************************************************************
HRESULT GetFirst_ClassKeysByPropertyId (CSQLConnection *_pConn,
DWORD dwPropertyId, CLASSKEYS &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassKeysAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassKeys");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dwPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dwPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetClassKeysData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ClassKeys
//
//***************************************************************************
HRESULT GetNext_ClassKeys (CSQLConnection *_pConn, CLASSKEYS &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassKeys");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetClassKeysData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateClassKeys
//
//***************************************************************************
HRESULT UpdateClassKeys(CSQLConnection *_pConn, CLASSKEYS cd, BOOL bDelete = FALSE)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassKeysAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassKeys");
err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
CLASSKEYS ck;
ULONG lLen;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSKEYS_COL_CLASSID),
&ck.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (ck.dClassId == cd.dClassId)
{
if (bDelete)
err = JetDelete(session, tableid);
break;
}
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
}
Exit:
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertClassKeys
//
//***************************************************************************
HRESULT InsertClassKeys (CSQLConnection *_pConn, SQL_ID dClassId, DWORD dwPropertyId,
BOOL bInsert)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassKeysAccessor(pConn);
if (SUCCEEDED(hr))
{
CLASSKEYS oj;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassKeys");
oj.dClassId = dClassId;
oj.iPropertyId = dwPropertyId;
hr = UpdateClassKeys(pConn, oj, FALSE);
if (FAILED(hr))
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSKEYS_COL_CLASSID),
&dClassId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSKEYS_COL_PROPERTYID),
&dwPropertyId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
hr = WBEM_S_NO_ERROR;
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// DeleteClassKeys
//
//***************************************************************************
HRESULT DeleteClassKeys (CSQLConnection *_pConn, SQL_ID dClassId, DWORD dwPropertyId = 0)
{
HRESULT hr = 0;
CLASSKEYS ck;
if (dwPropertyId)
hr = GetFirst_ClassKeysByPropertyId(_pConn, dwPropertyId, ck);
else
hr = GetFirst_ClassKeys(_pConn, dClassId, ck);
while (SUCCEEDED(hr))
{
hr = UpdateClassKeys(_pConn, ck, TRUE);
hr = GetNext_ClassKeys(_pConn, ck);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// SetupReferencePropertiesAccessor
//
//***************************************************************************
HRESULT SetupReferencePropertiesAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ReferenceProperties"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ReferenceProperties";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
JET_ERR err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ReferenceProperties", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", REFPROPS_COL_CLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, REFPROPS_COL_CLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyId", REFPROPS_COL_PROPERTYID, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, REFPROPS_COL_PROPERTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"RefClassId", REFPROPS_COL_REFCLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, REFPROPS_COL_REFCLASSID, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ClassId_idx", JET_bitIndexDisallowNull,"+ClassId\0", 10, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "RefClassId_idx", JET_bitIndexDisallowNull,"+RefClassId\0", 13, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "PropertyId_idx", JET_bitIndexDisallowNull ,"+PropertyId\0", 13, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupReferencePropertiesAccessor(_pConn);
}
}
if (err)
hr = CSQLExecute::GetWMIError(err);
}
Exit:
return hr;
}
//***************************************************************************
//
// GetReferencePropertiesData
//
//***************************************************************************
HRESULT GetReferencePropertiesData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
REFERENCEPROPERTIES &oj)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
oj.iPropertyId = 0;
JET_ERR err = JET_errSuccess;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_PROPERTYID),
&oj.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_REFCLASSID),
&oj.dRefClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_ReferenceProperties
//
//***************************************************************************
HRESULT GetFirst_ReferenceProperties (CSQLConnection *_pConn, DWORD dwPropertyId,
REFERENCEPROPERTIES &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupReferencePropertiesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dwPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dwPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetReferencePropertiesData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ReferencePropertiesByRef
//
//***************************************************************************
HRESULT GetFirst_ReferencePropertiesByRef (CSQLConnection *_pConn, SQL_ID dRefClassId,
REFERENCEPROPERTIES &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupReferencePropertiesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
JET_ERR err = JetSetCurrentIndex(session, tableid, "RefClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dRefClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dRefClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetReferencePropertiesData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ReferencePropertiesByClass
//
//***************************************************************************
HRESULT GetFirst_ReferencePropertiesByClass (CSQLConnection *_pConn, SQL_ID dClassId,
REFERENCEPROPERTIES &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupReferencePropertiesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ClassId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dClassId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
hr = GetReferencePropertiesData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
}
}
}
}
if (SUCCEEDED(hr) && err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ReferenceProperties
//
//***************************************************************************
HRESULT GetNext_ReferenceProperties (CSQLConnection *_pConn, REFERENCEPROPERTIES &cd)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetReferencePropertiesData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateReferenceProperties
//
//***************************************************************************
HRESULT UpdateReferenceProperties(CSQLConnection *_pConn, REFERENCEPROPERTIES cd, BOOL bDelete = FALSE,
BOOL bAllowMultiple = FALSE)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupReferencePropertiesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
REFERENCEPROPERTIES ck;
ULONG lLen;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_CLASSID),
&ck.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (ck.dClassId == cd.dClassId)
{
BOOL bFound = TRUE;
if (bAllowMultiple)
{
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_REFCLASSID),
&ck.dRefClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (ck.dRefClassId != cd.dRefClassId)
bFound = FALSE;
}
if (bFound)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_REFCLASSID),
&ck.dRefClassId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, 0, NULL, 0);
break;
}
}
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertReferenceProperties
//
//***************************************************************************
HRESULT InsertReferenceProperties (CSQLConnection *_pConn, SQL_ID dClassId, DWORD dwPropertyId,
SQL_ID dRefClassId, BOOL bAllowMultiple = FALSE)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupReferencePropertiesAccessor(pConn);
if (SUCCEEDED(hr))
{
REFERENCEPROPERTIES oj;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ReferenceProperties");
BOOL bFound = FALSE;
hr = GetFirst_ReferenceProperties(_pConn, dClassId, oj);
while (SUCCEEDED(hr))
{
if (oj.iPropertyId == dwPropertyId)
{
bFound = TRUE;
if (bAllowMultiple)
{
if (dRefClassId != oj.dRefClassId)
bFound = FALSE;
}
if (bFound)
break;
}
hr = GetNext_ReferenceProperties(_pConn, oj);
}
if (!bFound)
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_CLASSID),
&dClassId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_REFCLASSID),
&dRefClassId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, REFPROPS_COL_PROPERTYID),
&dwPropertyId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
hr = WBEM_S_NO_ERROR;
}
else
{
oj.dClassId = dClassId;
oj.iPropertyId = dwPropertyId;
oj.dRefClassId = dRefClassId;
hr = UpdateReferenceProperties(pConn, oj, FALSE, bAllowMultiple);
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// DeleteReferenceProperties
//
//***************************************************************************
HRESULT DeleteReferenceProperties (CSQLConnection *_pConn, DWORD dwPropertyId, SQL_ID dClassId = 0)
{
HRESULT hr = 0;
REFERENCEPROPERTIES ck;
hr = GetFirst_ReferenceProperties(_pConn, dwPropertyId, ck);
while (SUCCEEDED(hr))
{
BOOL bMatch = TRUE;
if (dClassId && dClassId != ck.dClassId)
bMatch = FALSE;
if (bMatch)
hr = UpdateReferenceProperties(_pConn, ck, TRUE);
hr = GetNext_ReferenceProperties(_pConn, ck);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// DeleteReferencePropertiesByClass
//
//***************************************************************************
HRESULT DeleteReferencePropertiesByClass (CSQLConnection *_pConn, SQL_ID dClassId)
{
HRESULT hr = 0;
REFERENCEPROPERTIES ck;
hr = GetFirst_ReferencePropertiesByClass(_pConn, dClassId, ck);
while (SUCCEEDED(hr))
{
hr = UpdateReferenceProperties(_pConn, ck, TRUE);
hr = GetNext_ReferenceProperties(_pConn, ck);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// SetupClassDataAccessor
//
//***************************************************************************
HRESULT SetupClassDataAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ClassData"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ClassData";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ClassData", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectId", CLASSDATA_COL_OBJECTID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_OBJECTID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyId", CLASSDATA_COL_PROPERTYID, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_PROPERTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ArrayPos", CLASSDATA_COL_ARRAYPOS, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_ARRAYPOS, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"QfrPos", CLASSDATA_COL_QFRPOS, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_QFRPOS, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ClassId", CLASSDATA_COL_CLASSID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_CLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"RefClassId", CLASSDATA_COL_REFCLASSID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_REFCLASSID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"RefId", CLASSDATA_COL_REFID, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_REFID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"Flags", CLASSDATA_COL_FLAGS, JET_coltypLong,
0, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_FLAGS, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyStringValue", CLASSDATA_COL_STRINGVALUE, JET_coltypText,
0, MAX_STRING_WIDTH, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_STRINGVALUE, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyNumericValue", CLASSDATA_COL_NUMERICVALUE, JET_coltypCurrency,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyRealValue", CLASSDATA_COL_REALVALUE, JET_coltypIEEEDouble,
0, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSDATA_COL_REALVALUE, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ObjectId_idx", JET_bitIndexDisallowNull,"+ObjectId\0", 11, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "RefId_idx", JET_bitIndexDisallowNull ,"+RefId\0", 8, 100);
if (err >= JET_errSuccess || err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "PropertyId_idx", JET_bitIndexDisallowNull ,"+PropertyId\0", 13, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupClassDataAccessor(_pConn);
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// GetClassData
//
//***************************************************************************
HRESULT GetClassData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
CLASSDATA &oj, BOOL bMinimum=FALSE, CSchemaCache *pCache = NULL)
{
HRESULT hr = WBEM_E_FAILED;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
wchar_t buff[1024];
oj.Clear();
oj.dRefId = 0, oj.dPropertyNumericValue = 0, oj.rPropertyRealValue = 0;
JET_ERR err = JET_errSuccess;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_PROPERTYID),
&oj.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!bMinimum)
{
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_OBJECTID),
&oj.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_CLASSID),
&oj.dClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFCLASSID),
&oj.dRefClassId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_QFRPOS),
&oj.iQfrPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_FLAGS),
&oj.iFlags, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_ARRAYPOS),
&oj.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFID),
&oj.dRefId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.dRefId = 0;
if (!(oj.iFlags & ESE_FLAG_NULL))
{
DWORD dwPropFlags = 0;
DWORD dwStorage = 0;
if (pCache)
{
hr = pCache->GetPropertyInfo (oj.iPropertyId, NULL, NULL, &dwStorage,
NULL, &dwPropFlags);
}
if (SUCCEEDED(hr) && dwStorage != 0)
{
switch(dwStorage)
{
case WMIDB_STORAGE_REFERENCE:
case WMIDB_STORAGE_STRING:
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sPropertyStringValue = SysAllocString(buff);
if (wcslen(buff) && !oj.sPropertyStringValue)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
break;
case WMIDB_STORAGE_NUMERIC:
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE),
&oj.dPropertyNumericValue, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.dPropertyNumericValue = 0;
break;
case WMIDB_STORAGE_REAL:
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REALVALUE),
&oj.rPropertyRealValue, sizeof(double), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.rPropertyRealValue = 0;
break;
default:
hr = WBEM_E_INVALID_OPERATION;
break;
}
}
else
{
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen)
{
buff[lLen/2] = L'\0';
oj.sPropertyStringValue = SysAllocString(buff);
if (wcslen(buff) && !oj.sPropertyStringValue)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE),
&oj.dPropertyNumericValue, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.dPropertyNumericValue = 0;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REALVALUE),
&oj.rPropertyRealValue, sizeof(double), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.rPropertyRealValue = 0;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFID),
&oj.dRefId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (!lLen)
oj.dRefId = 0;
}
}
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_ClassData
//
//***************************************************************************
HRESULT GetFirst_ClassData (CSQLConnection *_pConn, SQL_ID dId, CLASSDATA &cd,
DWORD iPropertyId, BOOL bMinimum, CSchemaCache *pCache)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassDataAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
while (err == JET_errSuccess)
{
if (FAILED(GetClassData(pConn, session, tableid, cd, bMinimum, pCache)))
break;
else if (iPropertyId == -1 || cd.iPropertyId == iPropertyId)
{
hr = WBEM_S_NO_ERROR;
break;
}
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassDataByRefId
//
//***************************************************************************
HRESULT GetFirst_ClassDataByRefId (CSQLConnection *_pConn, SQL_ID dRefId, CLASSDATA &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassDataAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
JET_ERR err = JetSetCurrentIndex(session, tableid, "RefId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dRefId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dRefId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassData(pConn, session, tableid, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassDataByPropertyId
//
//***************************************************************************
HRESULT GetFirst_ClassDataByPropertyId (CSQLConnection *_pConn, DWORD iPropertyId, CLASSDATA &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassDataAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassData(pConn, session, tableid, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ClassData
//
//***************************************************************************
HRESULT GetNext_ClassData (CSQLConnection *_pConn, CLASSDATA &cd, DWORD iPropertyId, BOOL bMinimum,
CSchemaCache *pCache)
{
HRESULT hr = 0;
cd.Clear();
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetClassData(pConn, session, tableid, cd, bMinimum, pCache);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateClassData_Internal
//
//***************************************************************************
HRESULT UpdateClassData_Internal(CSQLConnection *_pConn, CLASSDATA cd, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupClassDataAccessor(pConn);
if (SUCCEEDED(hr))
{
unsigned long lLen;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
CLASSDATA cd2;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_OBJECTID),
&cd2.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_ARRAYPOS),
&cd2.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_QFRPOS),
&cd2.iQfrPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_PROPERTYID),
&cd2.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (cd.dObjectId == cd2.dObjectId &&
cd.iPropertyId == cd2.iPropertyId &&
cd.iQfrPos == cd2.iQfrPos &&
cd.iArrayPos == cd2.iArrayPos)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_OBJECTID),
&cd.dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_CLASSID),
&cd.dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFID),
&cd.dRefId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE),
&cd.dPropertyNumericValue, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFCLASSID),
&cd.dRefClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_ARRAYPOS),
&cd.iArrayPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_QFRPOS),
&cd.iQfrPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_FLAGS),
&cd.iFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_PROPERTYID),
&cd.iPropertyId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REALVALUE),
&cd.rPropertyRealValue, sizeof(double), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (cd.sPropertyStringValue)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
cd.sPropertyStringValue, wcslen(cd.sPropertyStringValue)*2+2, 0, NULL);
else
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
break;
}
else
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertClassData_Internal
//
//***************************************************************************
HRESULT InsertClassData_Internal (CSQLConnection *_pConn, SQL_ID dObjectId, DWORD iPropID, DWORD iArrayPos, DWORD iQfrPos,
SQL_ID dClassId, LPCWSTR lpStringValue, SQL_ID dNumericValue, double fRealValue,
DWORD iFlags, SQL_ID dRefId, SQL_ID dRefClassId, BOOL bIsNull)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassDataAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassData");
CLASSDATA cd;
cd.dObjectId = dObjectId;
cd.dClassId = dClassId;
cd.iArrayPos = iArrayPos;
cd.iQfrPos = iQfrPos;
cd.iPropertyId = iPropID;
cd.iFlags = iFlags;
if (bIsNull)
cd.iFlags |= ESE_FLAG_NULL;
if (!bIsNull)
{
cd.dRefId = dRefId;
cd.dRefClassId = dRefClassId;
cd.rPropertyRealValue = fRealValue;
cd.dPropertyNumericValue = dNumericValue;
if (lpStringValue)
{
LPWSTR lpVal = StripQuotes2((LPWSTR)lpStringValue);
CDeleteMe <wchar_t> d (lpVal);
cd.sPropertyStringValue = SysAllocString(lpVal);
if (!cd.sPropertyStringValue)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
}
else
cd.sPropertyStringValue = NULL;
}
else
{
cd.dRefId =0;
cd.dRefClassId = 0;
cd.rPropertyRealValue = 0;
cd.dPropertyNumericValue = 0;
cd.sPropertyStringValue = NULL;
}
hr = UpdateClassData_Internal(pConn, cd, FALSE);
if (FAILED(hr))
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_OBJECTID),
&dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_CLASSID),
&dClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
// NOTE: This can't be null, because we have an index on it...
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFID),
&dRefId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (!bIsNull)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE),
&dNumericValue, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFCLASSID),
&dRefClassId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REALVALUE),
&fRealValue, sizeof(double), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (cd.sPropertyStringValue)
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
cd.sPropertyStringValue, wcslen(cd.sPropertyStringValue)*2+2, 0, NULL);
}
else
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_NUMERICVALUE),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REFCLASSID),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_REALVALUE),
NULL, 0, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_STRINGVALUE),
NULL, 0, 0, NULL);
}
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_ARRAYPOS),
&iArrayPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_QFRPOS),
&iQfrPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_FLAGS),
&cd.iFlags, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSDATA_COL_PROPERTYID),
&iPropID, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
hr = WBEM_S_NO_ERROR;
cd.Clear();
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupClassImagesAccessor
//
//***************************************************************************
HRESULT SetupClassImagesAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!pConn->GetTableID(L"ClassImages"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
BOOL bCreate = FALSE;
const LPSTR lpTbl = "ClassImages";
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ClassImages", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectId", CLASSIMAGES_COL_OBJECTID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSIMAGES_COL_OBJECTID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyId", CLASSIMAGES_COL_PROPERTYID, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSIMAGES_COL_PROPERTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ArrayPos", CLASSIMAGES_COL_ARRAYPOS, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSIMAGES_COL_ARRAYPOS, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"PropertyImageValue", CLASSIMAGES_COL_IMAGEVALUE, JET_coltypLongBinary,
0, 0, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CLASSIMAGES_COL_IMAGEVALUE, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ObjectId_idx", JET_bitIndexDisallowNull,"+ObjectId\0", 11, 100);
if (err >= JET_errSuccess ||err == JET_errIndexDuplicate)
{
err = JetCreateIndex(session, tableid, "PropertyId_idx", JET_bitIndexDisallowNull ,"+PropertyId\0", 13, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupClassImagesAccessor(_pConn);
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// GetClassImagesData
//
//***************************************************************************
HRESULT GetClassImagesData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
CLASSIMAGES &oj)
{
HRESULT hr = WBEM_E_FAILED;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
BYTE buff[128];
oj.Clear();
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_OBJECTID),
&oj.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_PROPERTYID),
&oj.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_ARRAYPOS),
&oj.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_IMAGEVALUE),
buff, 128, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if(lLen > 0)
{
oj.pBuffer = new BYTE[lLen];
if (oj.pBuffer)
{
oj.dwBufferLen = lLen;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_IMAGEVALUE),
oj.pBuffer, oj.dwBufferLen, &lLen, JET_bitRetrieveCopy, NULL);
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_ClassImages
//
//***************************************************************************
HRESULT GetFirst_ClassImages (CSQLConnection *_pConn, SQL_ID dId, CLASSIMAGES &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassImagesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassImages");
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassImagesData(pConn, session, tableid, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_ClassImagesByPropertyId
//
//***************************************************************************
HRESULT GetFirst_ClassImagesByPropertyId (CSQLConnection *_pConn, DWORD iPropertyId, CLASSIMAGES &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupClassImagesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassImages");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetClassImagesData(pConn, session, tableid, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_ClassImages
//
//***************************************************************************
HRESULT GetNext_ClassImages (CSQLConnection *_pConn, CLASSIMAGES &cd)
{
HRESULT hr = 0;
cd.Clear();
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassImages");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetClassImagesData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateClassImages
//
//***************************************************************************
HRESULT UpdateClassImages (CSQLConnection *_pConn, CLASSIMAGES cd, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupClassImagesAccessor(pConn);
if (SUCCEEDED(hr))
{
unsigned long lLen;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassImages");
err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &cd.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
CLASSIMAGES cd2;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_OBJECTID),
&cd2.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_ARRAYPOS),
&cd2.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_PROPERTYID),
&cd2.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (cd.dObjectId == cd2.dObjectId &&
cd.iPropertyId == cd2.iPropertyId &&
cd.iArrayPos == cd2.iArrayPos)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_OBJECTID),
&cd.dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_ARRAYPOS),
&cd.iArrayPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_PROPERTYID),
&cd.iPropertyId, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_IMAGEVALUE),
cd.pBuffer, cd.dwBufferLen, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
break;
}
else
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertClassImages
//
//***************************************************************************
HRESULT InsertClassImages (CSQLConnection *_pConn, SQL_ID dObjectId, DWORD iPropID, DWORD iArrayPos,
BYTE *pStream = NULL, DWORD dwLength = 0)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupClassImagesAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ClassImages");
CLASSIMAGES cd;
cd.dObjectId = dObjectId;
cd.iArrayPos = iArrayPos;
cd.iPropertyId = iPropID;
cd.pBuffer = pStream;
cd.dwBufferLen = dwLength;
hr = UpdateClassImages(pConn, cd, FALSE);
if (FAILED(hr))
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_OBJECTID),
&dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_ARRAYPOS),
&iArrayPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_PROPERTYID),
&iPropID, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CLASSIMAGES_COL_IMAGEVALUE),
pStream, dwLength, 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
hr = WBEM_S_NO_ERROR;
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupIndexDataAccessor
//
//***************************************************************************
HRESULT SetupIndexDataAccessor (CSQLConnection *_pConn, DWORD dwStorage, DWORD &dwPos, LPWSTR * lpTableName)
{
HRESULT hr = 0;
char szTable [30];
wchar_t wTable[30];
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_COLTYP coltype;
JET_TABLEID tableid;
JET_ERR err = JET_errSuccess;
switch(dwStorage)
{
case WMIDB_STORAGE_STRING:
dwPos = SQL_POS_INDEXSTRING;
tableid = pConn->GetTableID(L"IndexStringData");
strcpy(szTable, "IndexStringData");
coltype = JET_coltypText;
break;
case WMIDB_STORAGE_REFERENCE:
dwPos = SQL_POS_INDEXREF;
strcpy(szTable, "IndexRefData");
tableid = pConn->GetTableID(L"IndexRefData");
coltype = JET_coltypCurrency;
break;
case WMIDB_STORAGE_NUMERIC:
dwPos = SQL_POS_INDEXNUMERIC;
strcpy(szTable, "IndexNumericData");
tableid = pConn->GetTableID(L"IndexNumericData");
coltype = JET_coltypCurrency;
break;
case WMIDB_STORAGE_REAL:
dwPos = SQL_POS_INDEXREAL;
coltype = JET_coltypIEEEDouble;
strcpy(szTable, "IndexRealData");
tableid = pConn->GetTableID(L"IndexRealData");
break;
default:
dwPos = 0;
break;
}
if (dwPos != 0)
{
swprintf(wTable, L"%S", szTable);
if (!tableid)
{
JET_SESID session;
JET_DBID dbid;
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
err = JetOpenTable (session, dbid, szTable, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, szTable, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(wTable, tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, szTable, L"ObjectId", INDEXTBL_COL_OBJECTID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, INDEXTBL_COL_OBJECTID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, szTable, L"PropertyId", INDEXTBL_COL_PROPERTYID, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, INDEXTBL_COL_PROPERTYID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, szTable, L"ArrayPos", INDEXTBL_COL_ARRAYPOS, JET_coltypLong,
JET_bitColumnNotNULL, sizeof(DWORD), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, INDEXTBL_COL_ARRAYPOS, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, szTable, L"IndexValue", INDEXTBL_COL_INDEXVALUE, coltype,
0, 2, &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, INDEXTBL_COL_INDEXVALUE, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ObjectId_idx", JET_bitIndexDisallowNull,"+ObjectId\0", 11, 100);
if (err >= JET_errSuccess || JET_errIndexDuplicate == err)
{
err = JetCreateIndex(session, tableid, "PropertyId_idx", JET_bitIndexDisallowNull ,"+PropertyId\0", 13, 100);
if (err >= JET_errSuccess || JET_errIndexDuplicate == err)
{
err = JetCreateIndex(session, tableid, "IndexValue_idx", JET_bitIndexDisallowNull ,"+IndexValue\0", 13, 80);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupIndexDataAccessor(_pConn,dwStorage, dwPos, lpTableName);
}
}
}
if (lpTableName)
{
*lpTableName = new wchar_t [wcslen(wTable) + 1];
if (!*lpTableName)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
wcscpy(*lpTableName, wTable);
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// GetIndexData
//
//***************************************************************************
HRESULT GetIndexData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
DWORD dwPos, INDEXDATA &is)
{
HRESULT hr = WBEM_E_FAILED;
CESEConnection *pConn = (CESEConnection *)_pConn;
BYTE buff[512];
long lInLen = 0;
unsigned long lLen;
is.Clear();
JET_ERR err = JET_errSuccess;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_OBJECTID),
&is.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_PROPERTYID),
&is.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_ARRAYPOS),
&is.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
switch(dwPos)
{
case SQL_POS_INDEXNUMERIC:
case SQL_POS_INDEXREF:
lInLen = sizeof(SQL_ID);
break;
case SQL_POS_INDEXSTRING:
lInLen = MAX_STRING_WIDTH;
break;
case SQL_POS_INDEXREAL:
lInLen = sizeof(double);
break;
}
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
buff, MAX_STRING_WIDTH, &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
if (lLen > 0)
{
switch(dwPos)
{
case SQL_POS_INDEXNUMERIC:
case SQL_POS_INDEXREF:
is.dValue = *((SQL_ID *)buff);
break;
case SQL_POS_INDEXSTRING:
is.sValue = SysAllocString((LPWSTR)buff);
if (!is.sValue)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto exit;
}
break;
case SQL_POS_INDEXREAL:
is.rValue = *((double *)buff);
break;
default:
break; // don't set anything - the caller doesn't want this data.
}
}
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_IndexData
//
//***************************************************************************
HRESULT GetFirst_IndexData (CSQLConnection *_pConn, SQL_ID dObjectId, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
JET_SESID session = pConn->GetSessionID();
JET_ERR err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dObjectId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dObjectId, sizeof(SQL_ID), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// GetFirst_IndexDataByProperty
//
//***************************************************************************
HRESULT GetFirst_IndexDataByProperty (CSQLConnection *_pConn, SQL_ID PropertyId, INDEXDATA &cd,
JET_TABLEID tableid, DWORD dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
JET_SESID session = pConn->GetSessionID();
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &PropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &PropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// OpenEnum_IndexDataNumeric
//
//***************************************************************************
HRESULT OpenEnum_IndexDataNumeric (CSQLConnection *_pConn, SQL_ID dStartAt, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_NUMERIC, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dStartAt, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekGE );
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_IndexDataNumeric
//
//***************************************************************************
HRESULT GetFirst_IndexDataNumeric (CSQLConnection *_pConn, SQL_ID dNumericValue, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_NUMERIC, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dNumericValue, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dNumericValue, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// OpenEnum_IndexDataString
//
//***************************************************************************
HRESULT OpenEnum_IndexDataString (CSQLConnection *_pConn, LPWSTR lpStartAt, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_STRING, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, lpStartAt, wcslen(lpStartAt)*2+2, JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekGE );
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_IndexDataString
//
//***************************************************************************
HRESULT GetFirst_IndexDataString (CSQLConnection *_pConn, LPWSTR lpStringValue, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_STRING, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, lpStringValue, wcslen(lpStringValue)*2+2, JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, lpStringValue, wcslen(lpStringValue)*2+2, JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// OpenEnum_IndexDataReal
//
//***************************************************************************
HRESULT OpenEnum_IndexDataReal (CSQLConnection *_pConn, double dStartAt, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REAL, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dStartAt, sizeof(double), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekGE );
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_IndexDataReal
//
//***************************************************************************
HRESULT GetFirst_IndexDataReal (CSQLConnection *_pConn, double dValue, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REAL, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dValue, sizeof(double), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dValue, sizeof(double), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// OpenEnum_IndexDataRef
//
//***************************************************************************
HRESULT OpenEnum_IndexDataRef (CSQLConnection *_pConn, SQL_ID dStartAt, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REFERENCE, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dStartAt, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekGE );
if (err == JET_errSuccess)
{
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetFirst_IndexDataRef
//
//***************************************************************************
HRESULT GetFirst_IndexDataRef (CSQLConnection *_pConn, SQL_ID dValue, INDEXDATA &cd,
JET_TABLEID &tableid, DWORD &dwPos)
{
HRESULT hr = WBEM_E_NOT_FOUND;
LPWSTR lpTableName;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this value and bind the data.
hr = SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REFERENCE, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d(lpTableName);
JET_SESID session = pConn->GetSessionID();
tableid = pConn->GetTableID(lpTableName);
JET_ERR err = JetSetCurrentIndex(session, tableid, "IndexValue_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dValue, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dValue, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
}
}
}
}
}
if (err != JET_errSuccess)
hr = WBEM_E_NOT_FOUND;
}
return hr;
}
//***************************************************************************
//
// GetNext_IndexData
//
//***************************************************************************
HRESULT GetNext_IndexData (CSQLConnection *_pConn, JET_TABLEID tableid, DWORD dwPos, INDEXDATA &cd)
{
HRESULT hr = 0;
cd.Clear();
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetIndexData(pConn, session, tableid, dwPos, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateIndexData
//
//***************************************************************************
HRESULT UpdateIndexData (CSQLConnection *_pConn, INDEXDATA is, LPWSTR lpTableName, DWORD dwStorage, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(lpTableName);
unsigned long lLen;
err = JetSetCurrentIndex(session, tableid, "ObjectId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &is.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &is.dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
INDEXDATA is2;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_ARRAYPOS),
&is2.iArrayPos, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_PROPERTYID),
&is2.iPropertyId, sizeof(DWORD), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto Exit;
if (is.iPropertyId == is2.iPropertyId &&
is.iArrayPos == is2.iArrayPos)
{
err = JetPrepareUpdate(session, tableid, JET_prepReplace);
if (err == JET_errSuccess)
{
switch(dwStorage)
{
case WMIDB_STORAGE_STRING:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
is.sValue, wcslen(is.sValue)*2+2, 0, NULL);
break;
case WMIDB_STORAGE_NUMERIC:
case WMIDB_STORAGE_REFERENCE:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
&is.dValue, sizeof(SQL_ID), 0, NULL);
break;
case WMIDB_STORAGE_REAL:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
&is.rValue, sizeof(SQL_ID), 0, NULL);
break;
}
if (bDelete)
err = JetDelete(session, tableid);
else
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
break;
}
else
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
Exit:
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertIndexData
//
//***************************************************************************
HRESULT InsertIndexData (CSQLConnection *_pConn, SQL_ID dObjectId, DWORD iPropID, DWORD iArrayPos,
LPWSTR lpValue, SQL_ID dValue, double rValue, DWORD dwStorage)
{
HRESULT hr = 0;
DWORD dwPos = 0;
LPWSTR lpTableName = NULL;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupIndexDataAccessor(pConn, dwStorage, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
if (dwStorage == WMIDB_STORAGE_IMAGE || !lpTableName)
return 0;
CDeleteMe <wchar_t> d (lpTableName);
INDEXDATA is;
is.dObjectId = dObjectId;
is.iPropertyId = iPropID;
is.iArrayPos = iArrayPos;
is.sValue = SysAllocString(lpValue);
if (lpValue && !is.sValue)
{
hr = WBEM_E_OUT_OF_MEMORY;
goto Exit;
}
is.dValue = dValue;
is.rValue = rValue;
if (FAILED(UpdateIndexData(pConn, is, lpTableName, dwStorage)))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(lpTableName);
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_OBJECTID),
&dObjectId, sizeof(__int64), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_ARRAYPOS),
&iArrayPos, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_PROPERTYID),
&iPropID, sizeof(DWORD), 0, NULL);
if (err < JET_errSuccess)
goto Exit;
switch(dwStorage)
{
case WMIDB_STORAGE_STRING:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
lpValue, wcslen(lpValue)*2+2, 0, NULL);
break;
case WMIDB_STORAGE_NUMERIC:
case WMIDB_STORAGE_REFERENCE:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
&dValue, sizeof(SQL_ID), 0, NULL);
break;
case WMIDB_STORAGE_REAL:
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, INDEXTBL_COL_INDEXVALUE),
&rValue, sizeof(double), 0, NULL);
break;
}
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
}
}
is.Clear();
hr = WBEM_S_NO_ERROR;
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupContainerObjsAccessor
//
//***************************************************************************
HRESULT SetupContainerObjsAccessor (CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
if (!pConn->GetTableID(L"ContainerObjs"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "ContainerObjs";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"ContainerObjs", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ContainerId", CONTAINEROBJS_COL_CONTAINERID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CONTAINEROBJS_COL_CONTAINERID, colid);
else
goto Exit;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ContaineeId", CONTAINEROBJS_COL_CONTAINEEID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, CONTAINEROBJS_COL_CONTAINEEID, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "ContainerObjs_PK", JET_bitIndexDisallowNull,"+ContainerId\0", 14, 100);
if (err >= JET_errSuccess || JET_errIndexDuplicate == err)
{
err = JetCreateIndex(session, tableid, "Containee_idx", JET_bitIndexDisallowNull ,"+ContaineeId\0", 14, 100);
if (err == JET_errIndexDuplicate)
err = JET_errSuccess;
}
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupContainerObjsAccessor(_pConn);
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// GetContainerObjsData
//
//***************************************************************************
HRESULT GetContainerObjsData (CSQLConnection *_pConn, JET_SESID session, JET_TABLEID tableid,
CONTAINEROBJ &co)
{
HRESULT hr = WBEM_E_FAILED;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
unsigned long lLen;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CONTAINEROBJS_COL_CONTAINERID),
&co.dContainerId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, CONTAINEROBJS_COL_CONTAINEEID),
&co.dContaineeId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
if (JET_errSuccess > err)
goto exit;
hr = WBEM_S_NO_ERROR;
exit:
return hr;
}
//***************************************************************************
//
// GetFirst_ContainerObjs
//
//***************************************************************************
HRESULT GetFirst_ContainerObjs (CSQLConnection *_pConn, SQL_ID dContainerId, CONTAINEROBJ &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupContainerObjsAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ContainerObjs");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "ContainerObjs_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dContainerId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dContainerId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
hr = GetContainerObjsData(pConn, session, tableid, cd);
}
}
}
}
}
hr = CSQLExecute::GetWMIError(err);
}
return hr;
}
//***************************************************************************
//
// GetFirst_ContainerObjsByContainee
//
//***************************************************************************
HRESULT GetFirst_ContainerObjsByContainee (CSQLConnection *_pConn, SQL_ID dContaineeId, CONTAINEROBJ &cd)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupContainerObjsAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ContainerObjs");
// Use the default index
// Grab the first row,
// and stuff it into the OBJECTMAP object.
JET_ERR err = JetSetCurrentIndex(session, tableid, "Containee_idx");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dContaineeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &dContaineeId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
if (err == JET_errSuccess)
{
if (err == JET_errSuccess)
hr = GetContainerObjsData(pConn, session, tableid, cd);
}
}
}
}
}
hr = CSQLExecute::GetWMIError(err);
}
return hr;
}
//***************************************************************************
//
// GetNext_ContainerObjs
//
//***************************************************************************
HRESULT GetNext_ContainerObjs (CSQLConnection *_pConn, CONTAINEROBJ &cd)
{
HRESULT hr = 0;
cd.Clear();
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ContainerObjs");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
hr = GetContainerObjsData(pConn, session, tableid, cd);
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// UpdateContainerObjs
//
//***************************************************************************
HRESULT UpdateContainerObjs (CSQLConnection *_pConn, CONTAINEROBJ co, BOOL bDelete = FALSE)
{
HRESULT hr = WBEM_S_NO_ERROR;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (!bDelete)
return 0;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ContainerObjs");
err = JetSetCurrentIndex(session, tableid, "ContainerObjs_PK");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &co.dContainerId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &co.dContainerId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeInclusive|JET_bitRangeUpperLimit);
while (err == JET_errSuccess)
{
CONTAINEROBJ co2;
hr = GetContainerObjsData(pConn, session, tableid, co2);
if (co.dContainerId == co2.dContainerId &&
co.dContaineeId == co2.dContaineeId)
{
err = JetDelete(session, tableid);
break;
}
err = JetMove(session, tableid, JET_MoveNext, 0);
}
}
}
}
}
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// InsertContainerObjs
//
//***************************************************************************
HRESULT InsertContainerObjs(CSQLConnection *pConn2, SQL_ID dContainerId, SQL_ID dContaineeId)
{
HRESULT hr = 0;
JET_ERR err = 0;
CESEConnection *pConn = (CESEConnection *)pConn2;
hr = SetupContainerObjsAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"ContainerObjs");
BOOL bFound = FALSE;
CONTAINEROBJ co;
hr = GetFirst_ContainerObjs(pConn2, dContainerId, co);
while (SUCCEEDED(hr))
{
if (co.dContainerId == dContainerId &&
co.dContaineeId == dContaineeId)
{
bFound = TRUE;
break;
}
hr = GetNext_ContainerObjs(pConn2, co);
}
hr = WBEM_S_NO_ERROR;
if (!bFound)
{
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CONTAINEROBJS_COL_CONTAINERID),
&dContainerId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, CONTAINEROBJS_COL_CONTAINEEID),
&dContaineeId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// SetupAutoDeleteAccessor
//
//***************************************************************************
HRESULT SetupAutoDeleteAccessor(CSQLConnection *_pConn)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = JET_errSuccess;
if (!pConn->GetTableID(L"AutoDelete"))
{
JET_SESID session;
JET_TABLEID tableid;
JET_DBID dbid;
const LPSTR lpTbl = "AutoDelete";
BOOL bCreate = FALSE;
// Get the session and table ID
// and create columns as needed.
session = pConn->GetSessionID();
dbid = pConn->GetDBID();
err = JetOpenTable (session, dbid, lpTbl, NULL, 0, JET_bitTableUpdatable, &tableid);
if (err < JET_errSuccess)
{
CSQLExecute::GetWMIError(err);
bCreate = TRUE;
err = JetCreateTable(session, dbid, lpTbl, 10, 80, &tableid);
if (err < JET_errSuccess)
{
hr = CSQLExecute::GetWMIError(err);
goto Exit;
}
}
else
pConn->SetTableID(L"AutoDelete", tableid);
JET_COLUMNID colid;
hr = AddColumnToTable(pConn, tableid, lpTbl, L"ObjectId", CONTAINEROBJS_COL_CONTAINERID, JET_coltypCurrency,
JET_bitColumnNotNULL, sizeof(SQL_ID), &colid);
if (SUCCEEDED(hr))
pConn->SetColumnID(tableid, AUTODELETE_COL_OBJECTID, colid);
else
goto Exit;
err = JetCreateIndex(session, tableid, "AutoDelete_PK", JET_bitIndexPrimary | JET_bitIndexUnique,"+ObjectId\0", 11, 100);
if (err >= JET_errSuccess || JET_errIndexHasPrimary == err)
err = JET_errSuccess;
if (err >= JET_errSuccess && bCreate)
{
err = JetCloseTable(session, tableid);
if (err >= JET_errSuccess)
{
hr = SetupAutoDeleteAccessor(_pConn);
}
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// OpenEnum_AutoDelete
//
//***************************************************************************
HRESULT OpenEnum_AutoDelete (CSQLConnection *_pConn, AUTODELETE &ad)
{
HRESULT hr = WBEM_E_NOT_FOUND;
// Locate the first row for this ObjectID and bind the data.
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupAutoDeleteAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"AutoDelete");
JET_ERR err = JetSetCurrentIndex(session, tableid, "AutoDelete_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMove(session, tableid, JET_MoveFirst, 0);
if (err == JET_errSuccess)
{
ULONG lLen;
err = JetRetrieveColumn(session, tableid, pConn->GetColumnID(tableid, AUTODELETE_COL_OBJECTID),
&ad.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL);
}
}
hr = CSQLExecute::GetWMIError(err);
}
return hr;
}
//***************************************************************************
//
// GetNext_AutoDelete
//
//***************************************************************************
HRESULT GetNext_AutoDelete(CSQLConnection *_pConn, AUTODELETE &ad)
{
HRESULT hr = 0;
JET_ERR err = JET_errSuccess;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"AutoDelete");
err = JetMove(session, tableid, JET_MoveNext, 0);
if (err == JET_errSuccess)
{
ULONG lLen;
hr = CSQLExecute::GetWMIError(JetRetrieveColumn(session, tableid,
pConn->GetColumnID(tableid, AUTODELETE_COL_OBJECTID),
&ad.dObjectId, sizeof(SQL_ID), &lLen, JET_bitRetrieveCopy, NULL));
}
else
hr = WBEM_E_NOT_FOUND;
return hr;
}
//***************************************************************************
//
// InsertAutoDelete
//
//***************************************************************************
HRESULT InsertAutoDelete(CSQLConnection *_pConn, SQL_ID dObjectId)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
JET_ERR err = 0;
hr = SetupAutoDeleteAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"AutoDelete");
hr = DeleteAutoDelete(pConn, dObjectId);
err = JetPrepareUpdate(session, tableid, JET_prepInsert);
if (err == JET_errSuccess)
{
err = JetSetColumn(session, tableid, pConn->GetColumnID(tableid, AUTODELETE_COL_OBJECTID),
&dObjectId, sizeof(__int64), 0, NULL );
if (err < JET_errSuccess)
goto Exit;
err = JetUpdate(session, tableid, NULL, 0, NULL );
hr = WBEM_S_NO_ERROR;
}
}
Exit:
if (err)
hr = CSQLExecute::GetWMIError(err);
return hr;
}
//***************************************************************************
//
// DeleteAutoDelete
//
//***************************************************************************
HRESULT DeleteAutoDelete(CSQLConnection *_pConn, SQL_ID dObjectId)
{
HRESULT hr = WBEM_E_NOT_FOUND;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Locate the first row for this ObjectID and bind the data.
hr = SetupAutoDeleteAccessor(pConn);
if (SUCCEEDED(hr))
{
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"AutoDelete");
JET_ERR err = JetSetCurrentIndex(session, tableid, "AutoDelete_PK");
if (err == JET_errSuccess)
{
err = JetSetIndexRange(session, tableid, JET_bitRangeRemove);
err = JetMakeKey(session, tableid, &dObjectId, sizeof(__int64), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetDelete(session, tableid);
}
}
}
hr = CSQLExecute::GetWMIError(err);
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
}
return hr;
}
//***************************************************************************
//
// CleanAutoDeletes
//
//***************************************************************************
HRESULT CleanAutoDeletes(CSQLConnection *pConn)
{
HRESULT hr;
AUTODELETE ad;
SQLIDs ids;
// These are objects created with the AUTODELETE handle.
// If we have any left, we must have crashed before
// the handles could be tidied up.
hr = OpenEnum_AutoDelete(pConn, ad);
while (SUCCEEDED(hr))
{
ids.push_back(ad.dObjectId);
hr = GetNext_AutoDelete(pConn, ad);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (SUCCEEDED(hr))
{
for (int i = 0; i < ids.size(); i++)
{
hr = DeleteObjectMap(pConn, ids.at(i));
if (FAILED(hr))
break;
}
}
return hr;
}
// Delete functions
//***************************************************************************
//
// DeleteIndexDataByObjectId
//
//***************************************************************************
HRESULT DeleteIndexDataByObjectId (CSQLConnection *_pConn, DWORD dwStorage, SQL_ID dObjectId)
{
HRESULT hr = 0;
LPWSTR lpTableName = NULL;
DWORD dwPos = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupIndexDataAccessor(pConn, dwStorage, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d (lpTableName);
if (!lpTableName || dwStorage == WMIDB_STORAGE_IMAGE)
return 0;
INDEXDATA is;
JET_TABLEID tableid = pConn->GetTableID(lpTableName);
hr = GetFirst_IndexData(pConn, dObjectId, is, tableid, dwPos);
while (SUCCEEDED(hr))
{
hr = UpdateIndexData(pConn, is, lpTableName, dwStorage, TRUE);
if (FAILED(hr))
{
is.Clear();
break;
}
hr = GetNext_IndexData(pConn, tableid, dwPos, is);
if (hr == WBEM_E_NOT_FOUND)
{
hr = WBEM_S_NO_ERROR;
break;
}
if (is.dObjectId != dObjectId)
break;
}
hr = WBEM_S_NO_ERROR;
}
return hr;
}
//***************************************************************************
//
// DeletePropertyMap
//
//***************************************************************************
HRESULT DeletePropertyMap (CSQLConnection *_pConn, DWORD iPropertyId)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
PROPERTYMAP pm;
hr = GetFirst_PropertyMap(pConn, iPropertyId, pm);
if (SUCCEEDED(hr))
{
hr = DeleteReferenceProperties(_pConn, iPropertyId);
if (SUCCEEDED(hr))
hr = UpdatePropertyMap(pConn, pm, TRUE);
}
else
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// DeleteClassData
//
//***************************************************************************
HRESULT DeleteClassData (CSQLConnection *_pConn, DWORD iPropertyId, SQL_ID dObjectId=0, DWORD iArrayPos = -1)
{
HRESULT hr = 0;
CLASSDATA cd;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = GetFirst_ClassDataByPropertyId(pConn, iPropertyId, cd);
while (SUCCEEDED(hr))
{
BOOL bMatch = TRUE;
if (dObjectId && dObjectId != cd.dObjectId)
bMatch = FALSE;
if ((int)iArrayPos >= 0 && iArrayPos != cd.iArrayPos)
bMatch = FALSE;
if (bMatch)
{
hr = UpdateClassData_Internal(pConn, cd, TRUE);
if (FAILED(hr))
{
cd.Clear();
break;
}
}
hr = GetNext_ClassData(pConn, cd);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// DeleteClassImages
//
//***************************************************************************
HRESULT DeleteClassImages (CSQLConnection *_pConn, DWORD iPropertyId, SQL_ID dObjectId=0, DWORD iArrayPos = -1)
{
HRESULT hr = 0;
CLASSIMAGES cd;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = GetFirst_ClassImagesByPropertyId(pConn, iPropertyId, cd);
while (SUCCEEDED(hr))
{
BOOL bMatch = TRUE;
if (dObjectId && dObjectId != cd.dObjectId)
bMatch = FALSE;
if (iArrayPos != -1 && iArrayPos != cd.iArrayPos)
bMatch = FALSE;
if (bMatch)
{
hr = UpdateClassImages(pConn, cd, TRUE);
if (FAILED(hr))
{
cd.Clear();
break;
}
}
hr = GetNext_ClassImages(pConn, cd);
if (cd.iPropertyId != iPropertyId)
break;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// DeleteContainerObjs
//
//***************************************************************************
HRESULT DeleteContainerObjs (CSQLConnection *_pConn, SQL_ID dContainerId, SQL_ID dContaineeId )
{
HRESULT hr = 0;
CONTAINEROBJ co;
CESEConnection *pConn = (CESEConnection *)_pConn;
if (dContainerId)
hr = GetFirst_ContainerObjs (pConn, dContainerId, co);
else
hr = GetFirst_ContainerObjsByContainee (pConn, dContaineeId, co);
while (SUCCEEDED(hr))
{
BOOL bMatch = TRUE;
if (dContainerId && co.dContainerId != dContainerId)
bMatch = FALSE;
if (dContaineeId && co.dContaineeId != dContaineeId)
bMatch = FALSE;
if (bMatch)
hr = UpdateContainerObjs (pConn, co, TRUE);
hr = GetNext_ContainerObjs(pConn, co);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// DeleteQualifiers
//
//***************************************************************************
HRESULT DeleteQualifiers (CSQLConnection *_pConn, SQL_ID dObjectId)
{
HRESULT hr = 0;
CLASSDATA cd;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = GetFirst_ClassData (pConn, dObjectId, cd);
while (SUCCEEDED(hr))
{
// Delete any properties with the qualifier flag set.
if (cd.iFlags & 2)
{
hr = UpdateClassData_Internal(pConn, cd, TRUE);
if (FAILED(hr))
{
cd.Clear();
goto Exit;
}
}
hr = GetNext_ClassData(pConn, cd);
if (cd.dObjectId != dObjectId)
break;
}
hr = WBEM_S_NO_ERROR;
Exit:
return hr;
}
//***************************************************************************
//
// DeletePropQualifiers
//
//***************************************************************************
HRESULT DeletePropQualifiers (CSQLConnection *_pConn, DWORD iPropertyId)
{
HRESULT hr = 0;
CLASSDATA cd;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = GetFirst_ClassDataByRefId (pConn, ((SQL_ID)iPropertyId), cd);
while (SUCCEEDED(hr))
{
// Delete any properties with the qualifier flag set.
if (cd.iFlags & 2)
{
hr = UpdateClassData_Internal(pConn, cd, TRUE);
if (FAILED(hr))
{
cd.Clear();
goto Exit;
}
}
hr = GetNext_ClassData(pConn, cd);
if (cd.iPropertyId != iPropertyId)
break;
}
hr = WBEM_S_NO_ERROR;
Exit:
return hr;
}
//***************************************************************************
//
// DeleteIndexData
//
//***************************************************************************
HRESULT DeleteIndexData (CSQLConnection *_pConn, DWORD dwStorage, DWORD iPropertyId, SQL_ID dObjectId=0, DWORD iArrayPos = -1)
{
HRESULT hr = 0;
LPWSTR lpTableName = NULL;
DWORD dwPos = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
hr = SetupIndexDataAccessor(pConn, dwStorage, dwPos, &lpTableName);
if (SUCCEEDED(hr))
{
CDeleteMe <wchar_t> d (lpTableName);
if (!lpTableName || dwStorage == WMIDB_STORAGE_IMAGE)
return 0;
INDEXDATA is;
JET_TABLEID tableid = pConn->GetTableID(lpTableName);
hr = GetFirst_IndexDataByProperty(pConn, iPropertyId, is, tableid, dwPos);
while (SUCCEEDED(hr))
{
BOOL bMatch = TRUE;
if (dObjectId && is.dObjectId != dObjectId)
bMatch = FALSE;
if (iArrayPos != -1 && iArrayPos != is.iArrayPos)
bMatch = FALSE;
if (bMatch)
{
hr = UpdateIndexData(pConn, is, lpTableName, dwStorage, TRUE);
if (FAILED(hr))
{
is.Clear();
break;
}
}
hr = GetNext_IndexData(pConn, tableid, dwPos, is);
if (hr == WBEM_E_NOT_FOUND)
{
hr = WBEM_S_NO_ERROR;
break;
}
if (iPropertyId != is.iPropertyId)
break;
}
hr = WBEM_S_NO_ERROR;
}
return hr;
}
//***************************************************************************
//
// DeleteObjectMap
//
//***************************************************************************
HRESULT DeleteObjectMap (CSQLConnection *_pConn, SQL_ID dObjectId,
BOOL bDecRef, SQL_ID dScope)
{
HRESULT hr = 0;
CESEConnection *pConn = (CESEConnection *)_pConn;
// Set up the maximum ref count that can exist
// to physically delete the object.
int iMaxRef = 0;
if (bDecRef)
iMaxRef = 1;
OBJECTMAP oj;
int i;
BOOL bDelete = FALSE;
hr = GetFirst_ObjectMap(pConn, dObjectId, oj);
if (SUCCEEDED(hr))
{
DEBUGTRACE((LOG_WBEMCORE, "DeleteObjectMap %S (RefCount = %ld)\n", oj.sObjectPath, oj.iRefCount));
// If we are calling this internally,
// we need to determine if this is an embedded object
// or a reference. If an embedded object,
// always delete it. If a reference, only delete
// if its in a deleted state, and ref count = 0
// Otherwise, decrement its ref count.
if (dScope)
{
if (oj.dObjectScopeId == dScope)
{
bDelete = TRUE;
}
else
{
if (bDecRef)
{
if (oj.iRefCount > 0)
oj.iRefCount--;
}
if (oj.iObjectState == 2 &&
!oj.iRefCount)
{
bDelete = TRUE;
}
}
}
else
{
if (oj.iRefCount <= iMaxRef)
{
bDelete = TRUE;
}
else
{
if (bDecRef)
oj.iRefCount--;
oj.iObjectState = 2;
}
}
// wprintf(L">> Deleting %I64d (%s) \n", dObjectId, (LPWSTR)oj.sObjectKey);
if (bDelete)
{
// Delete from the INDEX tables...
hr = DeleteIndexDataByObjectId(pConn, WMIDB_STORAGE_STRING, dObjectId);
if (FAILED(hr))
goto Exit;
hr = DeleteIndexDataByObjectId(pConn, WMIDB_STORAGE_NUMERIC, dObjectId);
if (FAILED(hr))
goto Exit;
hr = DeleteIndexDataByObjectId(pConn, WMIDB_STORAGE_REAL, dObjectId);
if (FAILED(hr))
goto Exit;
hr = DeleteIndexDataByObjectId(pConn, WMIDB_STORAGE_REFERENCE, dObjectId);
if (FAILED(hr))
goto Exit;
// If this was an autodelete handle, kill it.
hr = DeleteAutoDelete(pConn, dObjectId);
if (FAILED(hr))
goto Exit;
hr = DeleteReferencePropertiesByClass(pConn, dObjectId);
if (FAILED(hr))
goto Exit;
hr = DeleteScopeMap(pConn, dObjectId);
if (FAILED(hr))
goto Exit;
// DELETE CLASSDATA AND CLASSIMAGES
SQLIDs ids;
CLASSDATA cd;
hr = GetFirst_ClassData(pConn, dObjectId, cd);
while (SUCCEEDED(hr))
{
// If this is a reference or an embedded object,
// decrement ref counts or delete
if (cd.dRefId)
ids.push_back(cd.dRefId);
hr = UpdateClassData_Internal(pConn, cd, TRUE);
if (FAILED(hr))
{
cd.Clear();
break;
}
hr = GetNext_ClassData(pConn, cd);
if (cd.dObjectId != dObjectId)
{
cd.Clear();
break;
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (FAILED(hr))
goto Exit;
CLASSIMAGES ci;
hr = GetFirst_ClassImages(pConn, dObjectId, ci);
while (SUCCEEDED(hr))
{
hr = UpdateClassImages(pConn, ci, TRUE);
if (FAILED(hr))
{
ci.Clear();
break;
}
hr = GetNext_ClassImages(pConn, ci);
if (ci.dObjectId != dObjectId)
break;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (FAILED(hr))
goto Exit;
// If this is a class, delete CLASSMAP AND PROPERTYMAP
if (oj.dClassId == 1)
{
PROPERTYMAP pm;
hr = GetFirst_PropertyMapByClass(pConn, dObjectId, pm);
while (SUCCEEDED(hr))
{
hr = UpdatePropertyMap(pConn, pm, TRUE);
if (FAILED(hr))
{
pm.Clear();
goto Exit;
}
hr = GetNext_PropertyMap(pConn, pm);
if (dObjectId != pm.dClassId)
break;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (FAILED(hr))
goto Exit;
hr = DeleteClassKeys(pConn, dObjectId);
CLASSMAP cm;
hr = GetFirst_ClassMap(pConn, dObjectId, cm);
if (SUCCEEDED(hr))
hr = UpdateClassMap(pConn, cm, TRUE);
cm.Clear();
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (FAILED(hr))
goto Exit;
// Remove container memberships
hr = DeleteContainerObjs (pConn, dObjectId, 0);
if (SUCCEEDED(hr))
hr = DeleteContainerObjs (pConn, 0, dObjectId);
// Delete or decrement ref counts on
// references and embedded objects
for (i = 0; i < ids.size(); i++)
{
hr = DeleteObjectMap(_pConn, ids.at(i), TRUE, dObjectId);
if (FAILED(hr))
goto Exit;
}
// FINALLY, delete from ObjectMap.
if (SUCCEEDED(hr))
hr = UpdateObjectMap(pConn, oj, TRUE);
}
// Otherwise, set the state of this object to "Deleted"
// and leave it in the tables.
else
hr = UpdateObjectMap(pConn, oj);
oj.Clear();
}
else
hr = WBEM_S_NO_ERROR;
Exit:
oj.Clear();
return hr;
}
//***************************************************************************
//
// CWmiDbSession::Delete
//
//***************************************************************************
HRESULT CWmiDbSession::Delete(IWmiDbHandle *pHandle, CSQLConnection *pConn)
{
HRESULT hr = WBEM_S_NO_ERROR;
DWORD dwNumRows = 0;
CWmiDbHandle *pTmp = (CWmiDbHandle *)pHandle;
bool bLocalTrans = false;
if (!m_pController ||
((CWmiDbController *)m_pController)->m_dwCurrentStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
SQL_ID dID = pTmp->m_dObjectId;
SQL_ID dClassID = pTmp->m_dClassId;
hr = VerifyObjectLock(dID, pTmp->m_dwHandleType, pTmp->m_dwVersion);
if (FAILED(hr) && IsDistributed())
{
if (LockExists(dID))
hr = WBEM_S_NO_ERROR;
}
if (SUCCEEDED(hr))
{
if (!pConn && m_pController)
{
bLocalTrans = true;
hr = GetSQLCache()->GetConnection(&pConn, TRUE, IsDistributed());
}
if (SUCCEEDED(hr))
{
hr = Delete(dID, pConn);
if (bLocalTrans && m_pController)
GetSQLCache()->ReleaseConnection(pConn, hr, IsDistributed());
}
}
return hr;
}
HRESULT AddToSQLIDs (SQL_ID dID, SQLIDs *pToDel)
{
HRESULT hr = 0;
BOOL bFound = FALSE;
for (int i = 0; i < pToDel->size(); i++)
{
if (pToDel->at(i) == dID)
{
bFound = TRUE;
break;
}
}
if (!bFound)
pToDel->push_back(dID);
return hr;
}
HRESULT GetIdsToDelete (SQL_ID dID, CSQLConnection *pConn, SQLIDs *pToDel)
{
HRESULT hr = 0;
OBJECTMAP om;
SQLIDs NewList;
hr = GetFirst_ObjectMap(pConn, dID, om);
if (SUCCEEDED(hr))
{
// Decrement ref counts on reference properties.
CLASSDATA cd;
SQLIDs ToUpd;
hr = GetFirst_ClassDataByRefId(pConn, dID, cd);
while (hr == WBEM_S_NO_ERROR)
{
ToUpd.push_back(cd.dObjectId);
hr = GetNext_ClassData(pConn, cd);
if (cd.dRefId != dID)
{
cd.Clear();
break;
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
for (int i = 0; i < ToUpd.size(); i++)
{
hr = GetFirst_ObjectMap(pConn, ToUpd.at(i), om);
if (hr == WBEM_S_NO_ERROR)
{
if (om.iRefCount > 0)
om.iRefCount--;
hr = UpdateObjectMap(pConn, om);
om.Clear();
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
hr = GetFirst_ObjectMapByScope(pConn, dID, om);
while (hr == WBEM_S_NO_ERROR)
{
SQL_ID dSubId = om.dObjectId;
AddToSQLIDs(dSubId, &NewList);
hr = GetNext_ObjectMap(pConn, om);
if (om.dObjectScopeId != dID)
break;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
// Classes
if (SUCCEEDED(hr))
{
hr = GetFirst_ObjectMapByClass(pConn, dID, om);
while (hr == WBEM_S_NO_ERROR)
{
SQL_ID dSubId = om.dObjectId;
AddToSQLIDs(dSubId, &NewList);
hr = GetNext_ObjectMap(pConn, om);
if (om.dClassId != dID)
{
om.Clear();
break;
}
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
// Then all subclasses
if (SUCCEEDED(hr))
{
CLASSMAP cd;
hr = GetFirst_ClassMapBySuperClass(pConn, dID, cd);
while (hr == WBEM_S_NO_ERROR)
{
SQL_ID dSubId = cd.dClassId;
AddToSQLIDs(dSubId, &NewList);
hr = GetNext_ClassMap(pConn, cd);
if (dID != cd.dSuperClassId)
{
cd.Clear();
break;
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
}
for (int j = 0; j < NewList.size(); j++)
{
hr = GetIdsToDelete(NewList.at(j), pConn, pToDel);
AddToSQLIDs(NewList.at(j), pToDel);
}
om.Clear();
}
return hr;
}
HRESULT CheckSecurity(SQLIDs *pToDel, CWmiDbSession *pSession, CSQLConnection *pConn)
{
HRESULT hr = 0;
for (int i = 0; i < pToDel->size(); i++)
{
OBJECTMAP om;
hr = GetFirst_ObjectMap(pConn, pToDel->at(i), om);
if (SUCCEEDED(hr))
{
hr = pSession->VerifyObjectSecurity(pConn, pToDel->at(i), om.dClassId, om.dObjectScopeId, 0,
pSession->GetSchemaCache()->GetWriteToken(pToDel->at(i), om.dClassId));
if (FAILED(hr) && hr != WBEM_E_NOT_FOUND)
break;
om.Clear();
}
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::Delete
//
//***************************************************************************
HRESULT CWmiDbSession::Delete(SQL_ID dID, CSQLConnection *pConn)
{
HRESULT hr = WBEM_S_NO_ERROR;
int iPos = 0, iMax = 100;
SQL_ID dClassId = 0, dScopeId = 0, dObjId = 0;
DWORD dwNumRows = 0;
wchar_t wBuffer1[550], wBuffer2[550];
int iToUpd = 0, iToDel = 0;
SQLIDs ToDel;
// We need to enumerate every object that is underneath this one
// in the hierarchy, and delete them one-by-one.
// This function needs to recurse through all children,
// remove the data from the tables, fix reference counts,
// and clean the caches. If all that worked, we can commit.
// ===========================================================
hr = GetIdsToDelete(dID, pConn, &ToDel);
if (SUCCEEDED(hr))
{
AddToSQLIDs(dID, &ToDel);
hr = CheckSecurity(&ToDel, this, pConn);
if (SUCCEEDED(hr))
{
for (int i = 0; i < ToDel.size(); i++)
{
hr = DeleteObjectMap(pConn, ToDel.at(i));
if (FAILED(hr))
break;
GetSchemaCache()->DeleteClass(ToDel.at(i));
CleanCache(ToDel.at(i));
}
}
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::GetClassObject
//
//***************************************************************************
HRESULT CWmiDbSession::GetClassObject (CSQLConnection *pConn, SQL_ID dClassId, IWbemClassObject **ppObj)
{
HRESULT hr = WBEM_S_NO_ERROR;
_IWmiObject *pNew = NULL;
SQL_ID dParentId = 0;
// All we need to do is read the blob from the database.
// This should be cached where space allows.
CLASSMAP cm;
BOOL bNeedToRelease = FALSE;
if (!pConn && m_pController)
{
hr = GetSQLCache()->GetConnection(&pConn, 0, IsDistributed());
bNeedToRelease = TRUE;
if (FAILED(hr))
return hr;
}
if (SUCCEEDED(hr))
{
hr = GetFirst_ClassMap(pConn, dClassId, cm);
if (SUCCEEDED(hr))
{
if (cm.dSuperClassId != 0 && cm.dSuperClassId != 1)
{
hr = GetObjectCache()->GetObject(cm.dSuperClassId, ppObj);
if (FAILED(hr))
hr = GetClassObject(pConn, cm.dSuperClassId, ppObj);
if (SUCCEEDED(hr))
{
// Merge the class part.
_IWmiObject *pObj = (_IWmiObject *)*ppObj;
if (pObj)
{
hr = pObj->Merge (WMIOBJECT_MERGE_FLAG_CLASS, cm.dwBufferLen, cm.pClassBuffer, &pNew);
pObj->Release();
if (SUCCEEDED(hr))
*ppObj = pNew;
}
else
hr = WBEM_E_FAILED;
}
}
else
{
_IWmiObject *pObj = NULL;
hr = CoCreateInstance(CLSID_WbemClassObject, NULL, CLSCTX_INPROC_SERVER,
IID__IWmiObject, (void **)&pObj);
if (SUCCEEDED(hr))
{
hr = pObj->Merge(WMIOBJECT_MERGE_FLAG_CLASS, cm.dwBufferLen, cm.pClassBuffer, &pNew);
pObj->Release();
if (SUCCEEDED(hr))
*ppObj = pNew;
}
}
cm.Clear();
}
}
if (bNeedToRelease && pConn && m_pController)
{
GetSQLCache()->ReleaseConnection(pConn, hr, IsDistributed());
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::GetObjectData
//
//***************************************************************************
HRESULT CWmiDbSession::GetObjectData (CSQLConnection *pConn, SQL_ID dObjectId, SQL_ID dClassId,
SQL_ID dScopeId, DWORD dwHandleType, DWORD &dwVersion,
IWbemClassObject **ppObj, BOOL bNoDefaults, LPWSTR lpInKey,
BOOL bGetSD )
{
HRESULT hr = WBEM_S_NO_ERROR;
_bstr_t sClassPath;
DWORD dwGenus = 1;
DWORD dwRows;
bool bUsedCache = false;
LPWSTR lpKey = NULL;
DWORD dwType = 0, dwVer = 0;
if (!m_pController ||
((CWmiDbController *)m_pController)->m_dwCurrentStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
// Validate version if this is a versioned handle.
// ================================================-
try
{
if (!bNoDefaults)
{
hr = VerifyObjectLock(dObjectId, dwHandleType, dwVersion);
if (FAILED(hr) && IsDistributed())
{
if (LockExists(dObjectId))
hr = WBEM_S_NO_ERROR;
}
}
if (SUCCEEDED(hr))
{
// Check the object cache to see if this
// IWbemClassObject is already loaded.
// Never cache an instance of __Instances
// =====================================
if (dClassId == INSTANCESCLASSID)
hr = WBEM_E_NOT_FOUND;
else
hr = GetObjectCache()->GetObject(dObjectId, ppObj);
if (FAILED(hr))
{
// Otherwise, we need to hit the database.
// =======================================
VARIANT vTemp;
VariantInit(&vTemp);
if (dClassId == 1)
{
dwGenus = 1;
dClassId = dObjectId;
}
else
dwGenus = 2;
SQL_ID dTemp = 0;
// We now have an object path and class ID.
// Now we have to instantiate a new IWbemClassObject,
// populate all the system properties
// ==================================================
IWbemClassObject *pClass = NULL;
IWbemClassObject *pTemp = NULL;
hr = GetObjectCache()->GetObject(dClassId, &pClass);
if (SUCCEEDED(hr))
bUsedCache = true;
else
hr = GetClassObject(pConn, dClassId, &pClass);
if (SUCCEEDED(hr))
{
if (dwGenus == 2)
{
if (pClass)
pClass->SpawnInstance(0, &pTemp);
{
if (pTemp)
hr = GetSchemaCache()->DecorateWbemObj(m_sMachineName, m_sNamespacePath,
dScopeId, pTemp, dClassId);
}
}
else
{
pTemp = pClass;
hr = GetSchemaCache()->DecorateWbemObj(m_sMachineName, m_sNamespacePath,
dScopeId, pTemp, dClassId);
}
// Special case if this is an __Instances container,
// We need to instantiate an instance of __Instances,
// and plug the class name into the ClassName property.
// ===================================================
if (dClassId == INSTANCESCLASSID)
{
_bstr_t sName, sPath;
SQL_ID dTemp1, dTemp2;
DWORD dwFlags;
hr = GetSchemaCache()->GetClassInfo (dObjectId, sPath, dTemp1, dTemp2, dwFlags, &sName);
if (SUCCEEDED(hr))
{
VARIANT vTemp;
VariantInit(&vTemp);
vTemp.bstrVal = SysAllocString(sName);
vTemp.vt = VT_BSTR;
pTemp->Put(L"ClassName", 0, &vTemp, CIM_STRING);
VariantClear(&vTemp);
*ppObj = pTemp;
}
else
{
pTemp->Release();
pTemp = NULL;
}
}
else
{
if (lpInKey)
{
hr = GetObjectData2 (pConn, dObjectId, dClassId, dScopeId, pTemp, FALSE, NULL);
lpKey = lpInKey;
}
else
hr = GetObjectData2 (pConn, dObjectId, dClassId, dScopeId, pTemp, FALSE, &lpKey);
if (dwGenus == 2)
{
if (!bUsedCache && SUCCEEDED(hr) && !((dwHandleType & 0xF00) == WMIDB_HANDLE_TYPE_NO_CACHE))
{
if (lpKey)
{
LPWSTR lpEqual = wcsrchr(lpKey, L'.');
if (!lpEqual)
lpEqual = wcsrchr(lpKey, L'=');
if (lpEqual)
{
LPWSTR lpPath = Macro_CloneLPWSTR(lpKey);
if (lpPath)
{
CDeleteMe <wchar_t> d10 (lpPath);
int iPos = lpEqual - lpKey;
lpPath[iPos] = L'\0';
GetObjectCache()->PutObject(dClassId, 1, dScopeId, lpPath, 1, pClass);
}
}
}
}
}
if (FAILED(hr))
{
pTemp->Release();
pTemp = NULL;
}
*ppObj = pTemp;
}
if (dwGenus == 2 && pClass)
pClass->Release();
}
// If all that worked, try and cache this object.
// ==============================================
if (SUCCEEDED(hr) && ppObj && (dwHandleType & 0xF00) && dClassId != INSTANCESCLASSID)
{
// This is allowed to fail, since its *just* a cache.
if ((dwHandleType & 0xF00) != WMIDB_HANDLE_TYPE_NO_CACHE && lpKey)
{
bool bCacheType = ((dwHandleType & 0xF00) == WMIDB_HANDLE_TYPE_STRONG_CACHE) ? 1 : 0;
GetObjectCache()->PutObject(dObjectId, dClassId, dScopeId, lpKey, bCacheType, *ppObj);
}
}
if (!lpInKey)
delete lpKey;
}
else
{
// Make sure the decoration is up-to-date.
hr = GetSchemaCache()->DecorateWbemObj(m_sMachineName, m_sNamespacePath,
dScopeId, *ppObj, dClassId);
}
// Populate the security descriptor, if requested
if (SUCCEEDED(hr) && bGetSD)
{
BOOL bNeedToRelease = FALSE;
if (!pConn && m_pController)
{
hr = GetSQLCache()->GetConnection(&pConn, 0, FALSE);
bNeedToRelease = TRUE;
if (FAILED(hr))
{
(*ppObj)->Release();
*ppObj = NULL;
return hr;
}
}
PNTSECURITY_DESCRIPTOR pSD = NULL;
DWORD dwLen = 0;
if (SUCCEEDED(CSQLExecProcedure::GetSecurityDescriptor(pConn, dObjectId, &pSD, dwLen, 0)))
{
((_IWmiObject *)*ppObj)->WriteProp(L"__SECURITY_DESCRIPTOR", 0, dwLen, dwLen, CIM_UINT8|CIM_FLAG_ARRAY, pSD);
delete pSD;
}
if (bNeedToRelease && pConn && m_pController)
{
GetSQLCache()->ReleaseConnection(pConn, hr, FALSE);
}
}
}
}
catch (...)
{
hr = WBEM_E_SHUTTING_DOWN;
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::GetObjectData2
//
//***************************************************************************
HRESULT CWmiDbSession::GetObjectData2 (CSQLConnection *pConn, SQL_ID dObjectId, SQL_ID dClassId, SQL_ID dScopeId,
IWbemClassObject *pObj, BOOL bNoDefaults, LPWSTR * lpKey)
{
HRESULT hr = WBEM_S_NO_ERROR;
BOOL bNeedToRelease = FALSE;
if (!pObj)
return WBEM_E_INVALID_PARAMETER;
if (!pConn && m_pController)
{
hr = GetSQLCache()->GetConnection(&pConn, 0, FALSE);
bNeedToRelease = TRUE;
if (FAILED(hr))
return hr;
}
if (SUCCEEDED(hr))
{
if (lpKey)
{
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, dObjectId, oj);
if (SUCCEEDED(hr))
{
if (oj.iObjectState == 2)
{
DEBUGTRACE((LOG_WBEMCORE, "Object %I64d is marked as deleted\n", dObjectId));
oj.Clear();
return WBEM_E_NOT_FOUND;
}
if (oj.sObjectKey)
{
LPWSTR lpKey2 = new wchar_t [wcslen(oj.sObjectKey)+1];
if (lpKey2)
{
wcscpy(lpKey2, oj.sObjectKey);
*lpKey = lpKey2;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_INVALID_OBJECT;
oj.Clear();
}
else
hr = WBEM_E_NOT_FOUND;
}
if (FAILED(hr))
goto Exit;
if (dClassId != 1 && dClassId != dObjectId)
{
CLASSDATA cd;
DWORD dwRows;
BOOL bBigText = FALSE, bObjProp = FALSE;
int i = 0;
Properties props;
typedef std::vector<CLASSDATA *> CDs;
CDs cds;
hr = GetFirst_ClassData(pConn, dObjectId, cd, -1, TRUE, GetSchemaCache());
while (SUCCEEDED(hr) && hr != WBEM_S_NO_MORE_DATA)
{
SetObjectData(pConn, pObj, this, &((CWmiDbController *)m_pController)->SchemaCache,
cd, FALSE, bBigText, &bObjProp, bNoDefaults);
if (bObjProp)
{
CLASSDATA *pCD = new CLASSDATA;
*pCD = cd;
cds.push_back(pCD);
}
hr = GetNext_ClassData(pConn, cd, -1, TRUE, GetSchemaCache());
}
hr = WBEM_S_NO_ERROR;
// The embedded object properties, since there will
// be a move next conflict if we try to retrieve them earlier.
for (i = 0; i < cds.size(); i++)
{
CLASSDATA *pCD = cds.at(i);
SetObjectData(pConn, pObj, this, &((CWmiDbController *)m_pController)->SchemaCache,
*pCD, FALSE, bBigText, NULL, bNoDefaults);
pCD->Clear();
delete pCD;
}
//if (bBigText || GetSchemaCache()->HasImageProp(dClassId))
{
// Finally, anything stored as long binary data.
DWORD dwSecurity = 0;
GetSchemaCache()->GetPropertyID(L"__SECURITY_DESCRIPTOR", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwSecurity);
CLASSIMAGES ci;
hr = GetFirst_ClassImages(pConn, dObjectId, ci);
while (SUCCEEDED(hr))
{
if (ci.iPropertyId != dwSecurity)
{
// Stuff this blob into the object.
cd.Copy(ci);
SetObjectData(pConn, pObj, this, &((CWmiDbController *)m_pController)->SchemaCache,
cd, TRUE, bBigText, NULL, bNoDefaults);
cd.Clear();
}
hr = GetNext_ClassImages(pConn, ci);
if (ci.dObjectId != dObjectId)
break;
}
}
hr = WBEM_S_NO_ERROR;
}
}
hr = WBEM_S_NO_ERROR;
Exit:
if (bNeedToRelease && pConn && m_pController)
{
GetSQLCache()->ReleaseConnection(pConn, hr, IsDistributed());
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::GetHierarchy
//
//***************************************************************************
HRESULT CSQLExecProcedure::GetHierarchy(CSQLConnection *pConn, SQL_ID dClassId)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Not required for Jet.
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::GetNextUnkeyedPath
//
//***************************************************************************
HRESULT CSQLExecProcedure::GetNextUnkeyedPath(CSQLConnection *pConn, SQL_ID dClassId, _bstr_t &sNewPath)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Generate a GUID for this object, and use this an artificial path.
// The format doesn't matter to us internally.
GUID guid;
LPWSTR lpNewPath;
hr = CoCreateGuid(&guid);
if (SUCCEEDED(hr))
{
hr = UuidToString(&guid, &lpNewPath);
if (SUCCEEDED(hr))
sNewPath = lpNewPath;
RpcStringFree(&lpNewPath);
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::GetNextKeyhole
//
//***************************************************************************
HRESULT CSQLExecProcedure::GetNextKeyhole(CSQLConnection *pConn2, DWORD iPropertyId, SQL_ID &dNewId)
{
HRESULT hr = WBEM_S_NO_ERROR;
CESEConnection *pConn = (CESEConnection *)pConn2;
// Here we need to select the largest value plus one currently
// in the table for this property ID.
// If null, its one.
dNewId = 1;
JET_SESID session = pConn->GetSessionID();
JET_TABLEID tableid = pConn->GetTableID(L"IndexNumericData");
JET_ERR err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMove(session, tableid, JET_MoveLast, 0);
if (err == JET_errSuccess)
{
INDEXDATA is;
hr = GetIndexData(pConn, session, tableid, 0, is);
dNewId = is.dValue + 1;
}
}
}
}
else
hr = CSQLExecute::GetWMIError(err);
if (dNewId == 1)
{
tableid = pConn->GetTableID(L"IndexStringData");
err = JetSetCurrentIndex(session, tableid, "PropertyId_idx");
if (err == JET_errSuccess)
{
err = JetMakeKey(session, tableid, &iPropertyId, sizeof(DWORD), JET_bitNewKey);
if (err == JET_errSuccess)
{
err = JetSeek( session, tableid, JET_bitSeekEQ );
if (err == JET_errSuccess)
{
err = JetMove(session, tableid, JET_MoveLast, 0);
if (err == JET_errSuccess)
{
INDEXDATA is;
hr = GetIndexData(pConn, session, tableid, 0, is);
dNewId = _wtoi64(is.sValue) + 1;
}
}
}
}
else
hr = CSQLExecute::GetWMIError(err);
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::GetObjectIdByPath
//
//***************************************************************************
HRESULT CSQLExecProcedure::GetObjectIdByPath (CSQLConnection *pConn, LPCWSTR lpPath,
SQL_ID &dObjectId, SQL_ID &dClassId, SQL_ID *dScopeId, BOOL *bDeleted)
{
HRESULT hr = WBEM_S_NO_ERROR;
if (!pConn)
return WBEM_E_INVALID_PARAMETER;
if (!dObjectId && lpPath)
dObjectId = CRC64::GenerateHashValue(lpPath);
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, dObjectId, oj);
if (SUCCEEDED(hr))
{
dClassId = oj.dClassId;
if (dScopeId)
*dScopeId = oj.dObjectScopeId;
if (bDeleted)
{
if (oj.iObjectState == 2)
*bDeleted = TRUE;
}
oj.Clear();
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::DeleteProperty
//
//***************************************************************************
HRESULT CSQLExecProcedure::DeleteProperty(CSQLConnection *pConn, DWORD iPropertyId)
{
HRESULT hr = WBEM_S_NO_ERROR;
// This has to clean up reference counts, if any of these properties
// are references. If its an embedded object, we need to remove
// all of the instances.
// Remove data from all index tables and Class Data. Then remove from
// PropertyMap.
// We can't allow them to delete a key property if there are instances.
// We have to delete qualifiers on the property (Flags&2, RefId = PropertyId)
// If a reference, delete object if the ref count is zero.
PROPERTYMAP pm;
hr = GetFirst_PropertyMap(pConn, iPropertyId, pm);
if (SUCCEEDED(hr))
{
if (pm.iFlags & REPDRVR_FLAG_KEY)
{
// We can't remove a key when the class has instances.
CLASSDATA cd;
hr = GetFirst_ClassDataByPropertyId (pConn, iPropertyId, cd);
if (SUCCEEDED(hr))
hr = WBEM_E_INVALID_OPERATION;
cd.Clear();
}
if (SUCCEEDED(hr))
{
// We need to decrement reference counts on
// references we are deleting, delete
// deleted references with a zero ref count,
// and remove embedded objects
if (pm.iStorageTypeId == CIM_OBJECT || pm.iStorageTypeId == CIM_REFERENCE)
{
CLASSDATA cd;
SQLIDs ids;
hr = GetFirst_ClassDataByPropertyId (pConn, iPropertyId, cd);
while (SUCCEEDED(hr))
{
ids.push_back(cd.dObjectId);
hr = GetNext_ClassData(pConn, cd);
if (cd.iPropertyId != iPropertyId)
{
cd.Clear();
break;
}
}
for (int i = 0; i < ids.size(); i++)
{
// Embedded objects are deleted
if (pm.iStorageTypeId == CIM_OBJECT)
hr = DeleteObjectMap(pConn, ids.at(i), TRUE);
// References have ref counts decremented.
// If their reference count is zero, and they are
// marked deleted, delete them now.
else if (pm.iStorageTypeId == CIM_REFERENCE)
{
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, ids.at(i), oj);
if (SUCCEEDED(hr))
{
if (oj.iRefCount <= 1 && oj.iObjectState == 2)
hr = DeleteObjectMap(pConn, ids.at(i), TRUE);
else
{
oj.iRefCount--;
hr = UpdateObjectMap(pConn, oj, FALSE);
}
oj.Clear();
}
}
}
}
}
if (SUCCEEDED(hr))
{
// Remove all data for this property..
if (pm.iFlags & (REPDRVR_FLAG_KEY + REPDRVR_FLAG_INDEXED))
hr = DeleteIndexData(pConn, pm.iStorageTypeId, iPropertyId);
if (SUCCEEDED(hr))
{
// Delete qualifiers on this property.
hr = DeletePropQualifiers(pConn, iPropertyId);
if (SUCCEEDED(hr))
{
// Delete all associated data.
hr = DeleteClassData(pConn, iPropertyId);
if (SUCCEEDED(hr))
{
hr = DeleteClassImages(pConn, iPropertyId);
if (SUCCEEDED(hr))
{
hr = DeletePropertyMap(pConn, iPropertyId);
if (SUCCEEDED(hr))
{
hr = DeleteClassKeys(pConn, 0, iPropertyId);
}
}
}
}
}
}
}
else
hr = WBEM_S_NO_ERROR; // OK if not found.
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::DeleteInstanceData
//
//***************************************************************************
HRESULT CSQLExecProcedure::DeleteInstanceData (CSQLConnection *pConn, SQL_ID dObjectId,
DWORD iPropertyId, DWORD iPos)
{
HRESULT hr = WBEM_S_NO_ERROR;
IRowset *pIRowset = NULL;
DWORD dwNumRows = 0;
wchar_t wSQL[512];
PROPERTYMAP pm;
IAccessor *pAccessor = NULL;
HACCESSOR hAcc = NULL;
hr = GetFirst_PropertyMap(pConn, iPropertyId, pm);
if (SUCCEEDED(hr))
{
if (pm.iFlags & (REPDRVR_FLAG_KEY + REPDRVR_FLAG_NOT_NULL))
hr = WBEM_E_INVALID_OPERATION;
else
{
if (pm.iStorageTypeId == CIM_OBJECT || pm.iStorageTypeId == CIM_REFERENCE)
{
CLASSDATA cd;
SQLIDs ids;
hr = GetFirst_ClassDataByPropertyId (pConn, iPropertyId, cd);
while (SUCCEEDED(hr))
{
ids.push_back(cd.dObjectId);
hr = GetNext_ClassData(pConn, cd);
if (cd.iPropertyId != iPropertyId)
{
cd.Clear();
break;
}
}
for (int i = 0; i < ids.size(); i++)
{
// Embedded objects are deleted
if (pm.iStorageTypeId == CIM_OBJECT)
hr = DeleteObjectMap(pConn, ids.at(i), TRUE);
// References have ref counts decremented.
// If their reference count is zero, and they are
// marked deleted, delete them now.
else if (pm.iStorageTypeId == CIM_REFERENCE)
{
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, ids.at(i), oj);
if (SUCCEEDED(hr))
{
if (oj.iRefCount <= 1 && oj.iObjectState == 2)
hr = DeleteObjectMap(pConn, ids.at(i), TRUE);
else
{
oj.iRefCount--;
hr = UpdateObjectMap(pConn, oj, FALSE);
}
oj.Clear();
}
}
}
}
if (SUCCEEDED(hr))
{
hr = DeleteIndexData(pConn, pm.iStorageTypeId, iPropertyId, dObjectId, iPos);
if (SUCCEEDED(hr))
{
hr = DeleteClassImages(pConn, iPropertyId, dObjectId, iPos);
if (SUCCEEDED(hr))
hr = DeleteClassData(pConn, iPropertyId, dObjectId, iPos);
}
}
}
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::CheckKeyMigration
//
//***************************************************************************
HRESULT CSQLExecProcedure::CheckKeyMigration(CSQLConnection *pConn, LPWSTR lpObjectKey, LPWSTR lpClassName, SQL_ID dClassId,
SQL_ID dScopeID, SQL_ID *pIDs, DWORD iNumIDs)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Make sure this object does not already exist with the same scope and different ClassID.
SQL_ID dObjId = CRC64::GenerateHashValue(lpObjectKey);
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, dObjId, oj);
if (SUCCEEDED(hr))
{
if (oj.dObjectScopeId == dScopeID &&
dClassId != oj.dClassId)
hr = WBEM_E_ALREADY_EXISTS;
oj.Clear();
}
else if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR; // OK if not found.
return hr;
}
HRESULT CSQLExecProcedure::NeedsToCheckKeyMigration(BOOL &bCheck)
{
bCheck = TRUE;
return 0;
}
HRESULT CSQLExecProcedure::Execute (CSQLConnection *pConn, LPCWSTR lpProcName, CWStringArray &arrValues,
IRowset **ppIRowset)
{
return E_NOTIMPL;
}
//***************************************************************************
//
// CSQLExecProcedure::HasInstances
//
//***************************************************************************
HRESULT CSQLExecProcedure::HasInstances(CSQLConnection *pConn, SQL_ID dClassId, SQL_ID *pDerivedIds, DWORD iNumDerived, BOOL &bInstancesExist)
{
HRESULT hr = WBEM_S_NO_ERROR;
bInstancesExist = FALSE;
// We need to query the table for any instance of this class
// or any of its children.
OBJECTMAP oj;
hr = GetFirst_ObjectMapByClass(pConn, dClassId, oj);
if (SUCCEEDED(hr))
{
while (SUCCEEDED(hr))
{
if (oj.iObjectState == 0)
{
bInstancesExist = TRUE;
break;
}
hr = GetNext_ObjectMap(pConn, oj);
if (oj.dClassId != dClassId)
break;
}
oj.Clear();
}
if (!bInstancesExist)
{
for (int i = 0; i < iNumDerived; i++)
{
hr = GetFirst_ObjectMapByClass(pConn, pDerivedIds[i], oj);
while (hr == WBEM_S_NO_ERROR)
{
if (oj.iObjectState == 0)
{
bInstancesExist = TRUE;
break;
}
hr = GetNext_ObjectMap(pConn, oj);
if (pDerivedIds[i] != oj.dClassId)
break;
}
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertClass
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertClass (CSQLConnection *pConn, LPCWSTR lpClassName, LPCWSTR lpObjectKey, LPCWSTR lpObjectPath, SQL_ID dScopeID,
SQL_ID dParentClassId, SQL_ID dDynasty, DWORD iState, BYTE *pClassBuff, DWORD dwClassBuffLen, DWORD iClassFlags, DWORD iInsertFlags, SQL_ID &dNewId)
{
HRESULT hr = WBEM_S_NO_ERROR;
SQL_ID dClassId = 0;
BOOL bExists = FALSE;
BOOL bDeleted = FALSE;
OBJECTMAP oj;
if (!dNewId)
dNewId = CRC64::GenerateHashValue(lpObjectKey);
if (!dDynasty)
dDynasty = dNewId; // Reports to self.
hr = GetFirst_ObjectMap(pConn, dNewId, oj);
if (SUCCEEDED(hr))
{
dClassId = oj.dClassId;
bExists = TRUE;
if (bDeleted && (iInsertFlags & WBEM_FLAG_UPDATE_ONLY))
hr = WBEM_E_INVALID_OBJECT;
else if (iInsertFlags & WBEM_FLAG_CREATE_ONLY && (!bDeleted))
hr = WBEM_E_ALREADY_EXISTS;
else
hr = WBEM_S_NO_ERROR;
oj.Clear();
}
else if (iInsertFlags & WBEM_FLAG_UPDATE_ONLY)
hr = WBEM_E_INVALID_OBJECT;
else
hr = WBEM_S_NO_ERROR;
if (dClassId != 1 && dParentClassId == 0)
dParentClassId = 1;
else if (dParentClassId == dNewId)
hr = WBEM_E_CIRCULAR_REFERENCE;
if (SUCCEEDED(hr))
{
BOOL bInsert = TRUE;
if (bExists)
bInsert = FALSE;
if (!dNewId)
dNewId = CRC64::GenerateHashValue(lpObjectKey);
LPWSTR lpPath = StripQuotes((LPWSTR)lpObjectPath);
CDeleteMe <wchar_t> d (lpPath);
// Insert ObjectMap
hr = InsertObjectMap(pConn, dNewId, lpObjectKey, iState, lpPath, dScopeID, iClassFlags, 0, 1, bInsert);
if (SUCCEEDED(hr))
{
hr = InsertClassMap(pConn, dNewId, lpClassName, dParentClassId, dDynasty, pClassBuff, dwClassBuffLen, bInsert);
if (SUCCEEDED(hr))
{
if (iInsertFlags & WMIDB_HANDLE_TYPE_AUTODELETE)
{
hr = InsertAutoDelete(pConn, dNewId);
}
}
}
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertClassData
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertClassData (CSQLConnection *pConn, IWbemClassObject *pObj, CSchemaCache *pCache, SQL_ID dScopeId,
SQL_ID dClassId, LPCWSTR lpPropName,
DWORD CIMType, DWORD StorageType,LPCWSTR lpValue, SQL_ID dRefClassId, DWORD iPropID,
DWORD iFlags, DWORD iFlavor, BOOL iSkipValid, DWORD &iNewPropId, SQL_ID dOrigClassId,
BOOL *bIsKey)
{
HRESULT hr = WBEM_S_NO_ERROR;
SQL_ID dClass = dOrigClassId;
if (!dClass)
dClass = dClassId;
DWORD dwNumRows = 0;
BOOL bHasKey = FALSE;
if (iFlags & REPDRVR_FLAG_QUALIFIER)
dClass = 1;
if (iNewPropId)
{
BOOL bLocal = FALSE;
BOOL bKey = pCache->IsKey(dClassId, iNewPropId, bLocal);
PROPERTYMAP pm;
hr = GetFirst_PropertyMap(pConn, iNewPropId, pm);
if (SUCCEEDED(hr) && pm.iStorageTypeId != StorageType)
{
if (StorageType == WMIDB_STORAGE_REAL &&
pm.iStorageTypeId == WMIDB_STORAGE_NUMERIC)
{
hr = InsertPropertyMap(pConn, iNewPropId, dClassId, StorageType,
CIMType, lpPropName, iFlags, FALSE);
// They changed the datatype. If this used to be an int,
// (the only acceptable move) we have to move the data,
// including any default and index, to the new column, table.
CLASSDATA pm;
hr = GetFirst_ClassDataByPropertyId(pConn, iNewPropId, pm);
while (SUCCEEDED(hr))
{
pm.rPropertyRealValue = pm.dPropertyNumericValue;
pm.dPropertyNumericValue = 0;
hr = UpdateClassData_Internal(pConn, pm);
if (FAILED(hr))
{
pm.Clear();
break;
}
hr = GetNext_ClassData(pConn, pm);
if (pm.iPropertyId != iNewPropId)
{
pm.Clear();
break;
}
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (SUCCEEDED(hr))
{
if (iFlags & (REPDRVR_FLAG_INDEXED + REPDRVR_FLAG_KEY))
{
INDEXDATA id;
JET_TABLEID tid = 0;
DWORD dwPos = 0;
hr = GetFirst_IndexDataByProperty(pConn, iNewPropId, id,
tid, dwPos);
while (SUCCEEDED(hr))
{
hr = InsertIndexData(pConn, dClassId, iNewPropId, id.iArrayPos,
id.sValue, id.dValue, id.rValue, WMIDB_STORAGE_REAL);
if (FAILED(hr))
break;
hr = GetNext_IndexData(pConn, tid, dwPos, id);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
if (SUCCEEDED(hr))
DeleteIndexData(pConn, WMIDB_STORAGE_NUMERIC, iNewPropId);
}
}
}
else
hr = WBEM_E_INVALID_OPERATION;
}
if (dRefClassId)
hr = InsertReferenceProperties (pConn, dClassId, iNewPropId, dRefClassId, FALSE);
if (!bKey && (iFlags & REPDRVR_FLAG_KEY))
{
hr = InsertClassKeys(pConn, dClassId, iNewPropId);
bKey = TRUE;
}
if (!bLocal && bKey)
bKey = FALSE;
if (bIsKey)
*bIsKey = bKey;
}
else
{
BOOL bInsert = TRUE;
if (iNewPropId)
bInsert = FALSE;
hr = InsertPropertyMap(pConn, iNewPropId, dClassId, StorageType, CIMType,
lpPropName, iFlags, bInsert);
if (SUCCEEDED(hr))
{
if (CIMType == CIM_REFERENCE)
{
if (dRefClassId)
hr = InsertReferenceProperties (pConn, dClassId, iNewPropId, dRefClassId, FALSE);
else
{
hr = DeleteReferenceProperties(pConn, iNewPropId, dClassId);
if (REPDRVR_FLAG_CLASSREFS & iFlags)
{
// Enumerate the class refs on this property.
IWbemQualifierSet *pQS = NULL;
hr = pObj->GetPropertyQualifierSet(lpPropName, &pQS);
if (SUCCEEDED(hr))
{
VARIANT vValue;
VariantInit(&vValue);
CReleaseMe r (pQS);
CClearMe c (&vValue);
hr = pQS->Get(L"ClassRef", 0, &vValue, NULL);
if (SUCCEEDED(hr) && vValue.vt == VT_BSTR+CIM_FLAG_ARRAY)
{
SAFEARRAY *psaArray = V_ARRAY(&vValue);
if (psaArray)
{
VARIANT vVal;
VariantInit(&vVal);
CClearMe c (&vVal);
long lLBound, lUBound;
SafeArrayGetLBound(psaArray, 1, &lLBound);
SafeArrayGetUBound(psaArray, 1, &lUBound);
lUBound -= lLBound;
lUBound += 1;
for (int i = 0; i < lUBound; i++)
{
hr = GetVariantFromArray(psaArray, i, VT_BSTR, vVal);
if (SUCCEEDED(hr))
{
SQL_ID dRefClass = 0;
hr = pCache->GetClassID(vVal.bstrVal, dScopeId, dRefClass);
if (SUCCEEDED(hr))
{
hr = InsertReferenceProperties(pConn, dClassId, iNewPropId, dRefClass, TRUE);
}
}
}
}
}
}
}
}
}
if (SUCCEEDED(hr))
{
if ((iFlags & REPDRVR_FLAG_KEY))
{
hr = InsertClassKeys(pConn, dClassId, iNewPropId);
if (bIsKey)
*bIsKey = TRUE;
}
else if (bIsKey)
*bIsKey = FALSE;
}
}
}
if (SUCCEEDED(hr))
{
BOOL bLocal = FALSE;
if (!(iFlags & REPDRVR_FLAG_KEY) && pCache->IsKey(dClassId, iNewPropId, bLocal))
{
pCache->SetIsKey(dClassId, iNewPropId, FALSE);
hr = DeleteClassKeys(pConn, dClassId, iNewPropId);
if (bIsKey)
*bIsKey = FALSE;
}
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertBlobData
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertBlobData (CSQLConnection *pConn, SQL_ID dClassId, SQL_ID dObjectId, DWORD iPropertyId,
BYTE *pImage, DWORD iPos, DWORD dwNumBytes)
{
return InsertClassImages (pConn, dObjectId, iPropertyId, iPos, pImage, dwNumBytes);
}
//***************************************************************************
//
// CSQLExecProcedure::InsertPropertyBatch
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertPropertyBatch (CSQLConnection *pConn, LPCWSTR lpObjectKey, LPCWSTR lpPath, LPCWSTR lpClassName,
SQL_ID dClassId, SQL_ID dScopeId, DWORD iInsertFlags, InsertPropValues *pVals, DWORD iNumVals, SQL_ID &dNewObjectId)
{
HRESULT hr = WBEM_S_NO_ERROR;
BOOL bExists = FALSE;
BOOL bDeleted = FALSE;
// Find existing ID, based on lpObjectKey.
// Verify insert/update flags
if (!dNewObjectId)
{
SQL_ID dTemp;
hr = GetObjectIdByPath(pConn, lpObjectKey, dNewObjectId, dTemp, NULL, &bDeleted);
if (SUCCEEDED(hr))
{
bExists = TRUE;
if ((!bDeleted) && iInsertFlags & WBEM_FLAG_CREATE_ONLY)
hr = WBEM_E_ALREADY_EXISTS;
else if (bDeleted && (iInsertFlags & WBEM_FLAG_UPDATE_ONLY))
hr = WBEM_E_INVALID_OBJECT;
else
hr = WBEM_S_NO_ERROR;
}
else if (iInsertFlags & WBEM_FLAG_UPDATE_ONLY)
hr = WBEM_E_INVALID_OBJECT;
else
hr = WBEM_S_NO_ERROR;
dNewObjectId = CRC64::GenerateHashValue(lpObjectKey);
}
else
bExists = TRUE;
if (SUCCEEDED(hr))
{
BOOL bInsert = TRUE;
if (bExists)
bInsert = FALSE;
LPWSTR lpPath2 = StripQuotes((LPWSTR)lpPath);
CDeleteMe <wchar_t> d (lpPath2);
hr = InsertObjectMap(pConn, dNewObjectId, lpObjectKey, 0, lpPath2, dScopeId, 0, 0, dClassId, bInsert);
if (SUCCEEDED(hr) && bExists)
{
// Delete all qualifiers, since we will reinsert them all.
// (Guess we can't do this through accessors.)
hr = DeleteQualifiers(pConn, dNewObjectId);
if (SUCCEEDED(hr))
{
if (iInsertFlags & WMIDB_HANDLE_TYPE_AUTODELETE)
hr = InsertAutoDelete(pConn, dNewObjectId);
}
}
if (SUCCEEDED(hr))
hr = InsertBatch(pConn, dNewObjectId, dScopeId, dClassId, pVals, iNumVals);
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertBatch
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertBatch (CSQLConnection *pConn, SQL_ID dObjectId, SQL_ID dScopeId, SQL_ID dClassId,
InsertQfrValues *pVals, DWORD iNumVals)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Insert each property/qualifier/method/method parameter:
if (dClassId == CONTAINERASSOCID)
{
for (int i = 0; i < iNumVals; i++)
{
if (pVals[i].pRefKey != NULL)
{
SQL_ID dContaineeId = _wtoi64(pVals[i].pRefKey);
SQL_ID dContainerId = _wtoi64(pVals[i+1].pRefKey);
hr = InsertContainerObjs(pConn, dContainerId, dContaineeId);
if (FAILED(hr))
goto Exit;
break;
}
}
}
for (int i = 0; i < iNumVals; i++)
{
SQL_ID dRefID = 0, dRefClassID = 0;
BOOL bExisting = FALSE, bEx2 = FALSE;
IRowset *pIRowset = NULL;
InsertQfrValues *pVal = &pVals[i];
DWORD dwRows = 0;
LPWSTR lpVal = NULL;
BOOL bRefCount = FALSE;
LPWSTR sVal = NULL;
SQL_ID dVal = 0;
double rVal = 0;
bool bStoreTextAsImage = false;
BOOL bIsNull = FALSE;
switch(pVal->iStorageType)
{
case WMIDB_STORAGE_STRING:
if (pVal->pValue)
{
sVal = TruncateLongText(pVal->pValue, 127, bStoreTextAsImage, 127);
if (bStoreTextAsImage)
pVal->bLong = TRUE;
}
else
bIsNull = TRUE;
// Clean up any previously-created string data stored as images.
hr = DeleteClassImages(pConn, pVal->iPropID, dObjectId, pVal->iPos);
hr = InsertClassData_Internal (pConn, dObjectId, pVal->iPropID, pVal->iPos, pVal->iQfrID,
pVal->dClassId, sVal, 0, 0, pVal->iFlavor, pVal->iQfrID, 0, bIsNull);
if (SUCCEEDED(hr) && pVal->bIndexed)
{
hr = InsertIndexData (pConn, dObjectId, pVal->iPropID, pVal->iPos,
sVal, 0, 0, pVal->iStorageType);
}
delete sVal;
break;
case WMIDB_STORAGE_NUMERIC:
if (pVal->pValue)
dVal = _wtoi64(pVal->pValue);
else
bIsNull = TRUE;
hr = InsertClassData_Internal (pConn, dObjectId, pVal->iPropID, pVal->iPos, pVal->iQfrID,
pVal->dClassId, NULL, dVal, 0, pVal->iFlavor, pVal->iQfrID, 0, bIsNull);
if (SUCCEEDED(hr) && pVal->bIndexed)
{
hr = InsertIndexData (pConn, dObjectId, pVal->iPropID, pVal->iPos,
NULL, dVal, 0, pVal->iStorageType);
}
break;
case WMIDB_STORAGE_REAL:
if (pVal->pValue)
rVal = wcstod(pVal->pValue, &lpVal);
else
bIsNull = TRUE;
hr = InsertClassData_Internal (pConn, dObjectId, pVal->iPropID, pVal->iPos, pVal->iQfrID,
pVal->dClassId, NULL, 0, rVal, pVal->iFlavor, pVal->iQfrID, 0, bIsNull);
if (SUCCEEDED(hr) && pVal->bIndexed)
{
hr = InsertIndexData (pConn, dObjectId, pVal->iPropID, pVal->iPos,
NULL, rVal, 0, pVal->iStorageType);
}
break;
case WMIDB_STORAGE_REFERENCE:
// * If this is a reference, we need to get the ID from the key string.
// If this object does not exist, we need to insert a bogus row.
// Bump up the ref count.
// If this is an update, decrement the ref count on previous row
// If previous row now has zero ref count, remove it.
dRefID = _wtoi64(pVal->pRefKey);
{
IRowset *pRowset = NULL;
IAccessor *pAccessor = NULL;
HACCESSOR hAcc = NULL;
CLASSDATA cd;
BOOL bOldRow = FALSE;
hr = GetFirst_ClassData(pConn, dObjectId, cd,pVal->iPropID);
while (hr == WBEM_S_NO_ERROR)
{
if (pVal->iPos == cd.iArrayPos &&
pVal->iQfrID == cd.iQfrPos)
{
bExisting = TRUE;
SQL_ID dOldRefID = cd.dRefId;
if (dRefID != dOldRefID)
{
PROPERTYMAP pm;
hr = GetFirst_PropertyMap(pConn, pVal->iPropID, pm);
if (SUCCEEDED(hr))
{
if (pm.iCIMTypeId == CIM_OBJECT)
hr = DeleteObjectMap(pConn, dOldRefID, TRUE);
else
{
OBJECTMAP om;
hr = GetFirst_ObjectMap(pConn, dOldRefID, om);
if (SUCCEEDED(hr))
{
bOldRow = TRUE;
bRefCount = TRUE;
if (om.iRefCount)
om.iRefCount--;
hr = UpdateObjectMap(pConn, om);
om.Clear();
}
}
}
}
else
bOldRow = TRUE;
cd.Clear();
break;
}
hr = GetNext_ClassData(pConn, cd, pVal->iPropID);
if (cd.dObjectId != dObjectId)
{
cd.Clear();
break;
}
}
hr = 0;
if (!bOldRow)
bRefCount = TRUE;
}
if (pVal->pValue)
{
lpVal = StripQuotes(pVal->pValue);
ObjectExists(pConn, dRefID, bEx2, &dRefClassID, NULL, TRUE);
if (!bEx2)
{
// We need to insert this row and get the new ID.
LPWSTR lpKey = GetKeyString(pVal->pValue);
CDeleteMe <wchar_t> d (lpKey);
hr = InsertObjectMap(pConn, dRefID, lpKey, 2, lpVal, dObjectId, 1, 1, 0, TRUE);
}
else if (bRefCount)
{
IRowset *pRowset = NULL;
IAccessor *pAccessor = NULL;
HACCESSOR hAcc = NULL;
OBJECTMAP om;
hr = GetFirst_ObjectMap(pConn, dRefID, om);
if (SUCCEEDED(hr))
{
om.iRefCount++;
hr = UpdateObjectMap(pConn, om);
om.Clear();
}
}
if (SUCCEEDED(hr))
{
// update/insert the new row
sVal = TruncateLongText(pVal->pValue, 127, bStoreTextAsImage, 127);
if (bStoreTextAsImage)
pVal->bLong = TRUE;
hr = InsertClassData_Internal (pConn, dObjectId, pVal->iPropID, pVal->iPos, pVal->iQfrID,
pVal->dClassId, sVal, 0, 0, pVal->iFlavor, dRefID, dRefClassID, FALSE);
if (SUCCEEDED(hr) && pVal->bIndexed)
{
DWORD dwRows = 0;
hr = InsertIndexData (pConn, dObjectId, pVal->iPropID, pVal->iPos,
sVal, dRefID, 0, pVal->iStorageType);
}
delete sVal;
}
delete lpVal;
}
break;
// This should never be hit.
default:
pVal->bLong = TRUE;
continue;
}
if (FAILED(hr))
break;
}
if (SUCCEEDED(hr))
{
// If our text was too long, we need to store it as an image.
for (i = 0; i < iNumVals; i++)
{
if (pVals[i].bLong)
{
if (pVals[i].iStorageType == WMIDB_STORAGE_STRING ||
pVals[i].iStorageType == WMIDB_STORAGE_REFERENCE)
{
LPWSTR lpTemp = StripQuotes2 (pVals[i].pValue);
CDeleteMe <wchar_t> d (lpTemp);
hr = InsertBlobData (pConn, dClassId, dObjectId, pVals[i].iPropID, (BYTE *)lpTemp, 0, wcslen(lpTemp)*2+2);
}
else if (pVals[i].pValue == NULL) // This is a null blob!
hr = DeleteClassImages(pConn, pVals[i].iPropID, dObjectId);
else
{
ERRORTRACE((LOG_WBEMCORE, "Invalid argument in InsertBatch (Obj %I64d, Class %I64d, Prop %ld)", \
dObjectId, dClassId, pVals[i].iPropID));
}
}
delete pVals[i].pValue;
delete pVals[i].pRefKey;
}
}
Exit:
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::ObjectExists
//
//***************************************************************************
HRESULT CSQLExecProcedure::ObjectExists (CSQLConnection *pConn, SQL_ID dId, BOOL &bExists, SQL_ID *_dClassId,
SQL_ID *_dScopeId, BOOL bDeletedOK)
{
SQL_ID dClassId, dScopeId;
BOOL bDeleted = FALSE;
OBJECTMAP oj;
HRESULT hr = GetFirst_ObjectMap(pConn, dId, oj);
if (SUCCEEDED(hr))
{
bExists = TRUE;
if (oj.iObjectState == 2)
{
if (!bDeletedOK)
bExists = FALSE;
}
if (bExists)
{
if (_dClassId) *_dClassId = oj.dClassId;
if (_dScopeId) *_dScopeId = oj.dObjectScopeId;
}
oj.Clear();
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::RenameSubscopes
//
//***************************************************************************
HRESULT CSQLExecProcedure::RenameSubscopes (CSQLConnection *pConn, LPWSTR lpOldPath, LPWSTR lpOldKey, LPWSTR lpNewPath, LPWSTR lpNewKey)
{
HRESULT hr = 0;
OBJECTMAP om;
// Enumerate all objects, and rename any that begin with the old path string.
hr = SetupObjectMapAccessor(pConn);
if (SUCCEEDED(hr))
{
int iOldPathLen = wcslen(lpOldPath);
int iOldKeyLen = wcslen(lpOldKey);
SQL_ID OldId = CRC64::GenerateHashValue(lpOldKey);
SQL_ID NewId = CRC64::GenerateHashValue(lpNewKey);
hr = OpenEnum_ObjectMap(pConn, om);
if (SUCCEEDED(hr))
{
if (!_wcsnicmp(om.sObjectPath, lpOldPath, iOldPathLen))
{
// Path = @NewPath + substring(ObjectPath, @OldPathLen+1, (datalength(ObjectPath)/2)- @OldPathLen),
// Key = substring(ObjectKey, 1, charindex(@OldKey, ObjectKey)-1) +@NewKey
LPWSTR lpTemp = NULL;
if (wcslen(om.sObjectPath) > iOldPathLen)
{
lpTemp = &om.sObjectPath[iOldPathLen];
LPWSTR lpNew = new wchar_t [wcslen(om.sObjectPath) + wcslen(lpNewPath)+1];
CDeleteMe <wchar_t> d(lpNew);
if (lpNew)
{
wcscpy(lpNew, lpNewPath);
wcscat(lpNew, lpTemp);
om.sObjectPath = SysAllocString(lpNew);
LPWSTR lpNew2 = new wchar_t [wcslen(om.sObjectKey) + wcslen(lpNewKey) + 1];
if (lpNew2 && om.sObjectPath)
{
lpTemp = om.sObjectKey;
lpTemp[iOldKeyLen] = L'\0';
wcscpy(lpNew2, lpTemp);
wcscat(lpNew2, lpNewKey);
om.sObjectKey = SysAllocString(lpNew2);
if (om.dObjectScopeId == OldId)
om.dObjectScopeId = NewId;
if (om.dClassId == OldId)
om.dClassId = NewId;
if (om.dObjectId == OldId)
om.dObjectId = NewId;
hr = UpdateObjectMap(pConn, om);
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
om.sObjectPath = SysAllocString(lpNewPath);
om.sObjectKey = SysAllocString(lpNewKey);
if (om.sObjectPath && om.sObjectKey)
hr = UpdateObjectMap(pConn, om);
else
hr = WBEM_E_OUT_OF_MEMORY;
}
}
else if (om.sObjectPath[0] > lpOldPath[0])
om.Clear();
hr = GetNext_ObjectMap(pConn, om);
}
// FIXME: We don't currently update ClassData and IndexRefData!
// IF this is a class, we don't update the ClassMap and PropertyMap!!!
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::GetSecurityDescriptor
//
//***************************************************************************
HRESULT CSQLExecProcedure::GetSecurityDescriptor(CSQLConnection *pConn, SQL_ID dObjectId,
PNTSECURITY_DESCRIPTOR * ppSD, DWORD &dwBuffLen,
DWORD dwFlags)
{
HRESULT hr = WBEM_S_NO_ERROR;
// If this is a class , get the security for __ClassSecurity (WMIDB_SECURITY_FLAG_CLASS)
// or __Instances container (WMIDB_SECURITY_FLAG_INSTANCE)
// If this is a namespace, get the security for __ThisNamespace
// Otherwise, get it off the object itself.
// Make sure its a valid security descriptor, before we
// return anything.
*ppSD = NULL;
PNTSECURITY_DESCRIPTOR pSD = NULL;
dwBuffLen = 0;
OBJECTMAP oj;
CLASSMAP cm;
SQL_ID dID = 0;
hr = GetFirst_ClassMap(pConn, dObjectId, cm);
if (SUCCEEDED(hr))
{
LPWSTR lpRetrievalName = NULL;
SQL_ID dScopeId = oj.dObjectScopeId;
int iSize = 0;
oj.Clear();
// We need to generate the path of the class
if (dwFlags == WMIDB_SECURITY_FLAG_INSTANCE)
{
if (dScopeId)
{
hr = GetFirst_ObjectMap(pConn, dScopeId, oj);
iSize = wcslen(oj.sObjectPath) + wcslen(cm.sClassName) + 128;
}
else
iSize = wcslen(cm.sClassName) + 128;
lpRetrievalName = new wchar_t [iSize];
CDeleteMe <wchar_t> d (lpRetrievalName);
if (lpRetrievalName)
{
if (dScopeId)
swprintf(lpRetrievalName, L"%s:__ClassInstancesSecurity=\"%s\"", oj.sObjectPath, cm.sClassName);
else
swprintf(lpRetrievalName, L"__ClassInstancesSecurity=\"%s\"", cm.sClassName);
LPWSTR lpKey = GetKeyString(lpRetrievalName);
CDeleteMe <wchar_t> d2 (lpKey);
if (lpKey)
{
dID = CRC64::GenerateHashValue(lpKey);
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
// Get the __ClassSecurity object
if (dScopeId)
{
hr = GetFirst_ObjectMap(pConn, dScopeId, oj);
iSize = wcslen(oj.sObjectPath) + wcslen(cm.sClassName) + 128;
}
else
iSize = wcslen(cm.sClassName) + 128;
lpRetrievalName = new wchar_t [iSize];
CDeleteMe <wchar_t> d (lpRetrievalName);
if (lpRetrievalName)
{
if (dScopeId)
swprintf(lpRetrievalName, L"%s:__ClassSecurity=\"%s\"", oj.sObjectPath, cm.sClassName);
else
swprintf(lpRetrievalName, L"__ClassSecurity=\"%s\"", cm.sClassName);
LPWSTR lpKey = GetKeyString(lpRetrievalName);
CDeleteMe <wchar_t> d2 (lpKey);
if (lpKey)
{
dID = CRC64::GenerateHashValue(lpKey);
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
cm.Clear();
oj.Clear();
}
else
{
// Get the object itself.
hr = WBEM_S_NO_ERROR;
dID = dObjectId;
oj.Clear();
}
if (SUCCEEDED(hr))
{
CLASSIMAGES ci;
BOOL bFound = FALSE;
hr = GetFirst_ClassImages(pConn, dID, ci);
while (SUCCEEDED(hr))
{
PROPERTYMAP pm;
hr = GetFirst_PropertyMap(pConn, ci.iPropertyId, pm);
if (SUCCEEDED(hr) && (!_wcsicmp(pm.sPropertyName, L"__SECURITY_DESCRIPTOR")))
{
pSD = ci.pBuffer;
bFound = TRUE;
if (pSD != NULL)
{
if (IsValidSecurityDescriptor(pSD))
{
// Make a copy of it.
pSD = (PNTSECURITY_DESCRIPTOR)CWin32DefaultArena::WbemMemAlloc(ci.dwBufferLen);
ZeroMemory(pSD, ci.dwBufferLen);
memcpy(pSD, ci.pBuffer, ci.dwBufferLen);
*ppSD = pSD;
dwBuffLen = ci.dwBufferLen;
}
}
}
pm.Clear();
if (bFound)
break;
hr = GetNext_ClassImages(pConn, ci);
}
ci.Clear();
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::EnumerateSecuredChildren
//
//***************************************************************************
HRESULT CSQLExecProcedure::EnumerateSecuredChildren(CSQLConnection *pConn, CSchemaCache *pCache, SQL_ID dObjectId, SQL_ID dClassId, SQL_ID dScopeId,
SQLIDs &ObjIds, SQLIDs &ClassIds, SQLIDs &ScopeIds)
{
HRESULT hr = WBEM_S_NO_ERROR;
// If __Classes instance, we need to enumerate all instances of __ClassSecurity
// If this is a __ClassSecurity instance, we need to enumerate all instances
// of __ClassSecurity for all subclasses
// If this is a __ClassInstancesSecurity instance, we need to enumerate all
// instances of this class
// If this is a namespace (__ThisNamespace) or scope, we need all subscoped objects
SQL_ID dClassSecurityId = CLASSSECURITYID;
SQL_ID dClassesId = CLASSESID;
SQL_ID dClassInstSecurityId = CLASSINSTSECID;
SQL_ID dThisNamespaceId = THISNAMESPACEID;
DWORD dwSecPropID = 0;
hr = pCache->GetPropertyID(L"__SECURITY_DESCRIPTOR", 1, 0, REPDRVR_IGNORE_CIMTYPE, dwSecPropID);
if (dClassId == dClassesId)
{
// All classes in this namespace.
OBJECTMAP oj;
hr = GetFirst_ObjectMapByClass(pConn, dClassSecurityId, oj);
while (SUCCEEDED(hr))
{
if (oj.dObjectScopeId == dScopeId)
{
// This is pointing to some class, we don't care
// which one.
CLASSIMAGES ci;
hr = GetFirst_ClassImages(pConn, oj.dObjectId, ci);
while (SUCCEEDED(hr))
{
if (ci.iPropertyId == dwSecPropID)
{
ObjIds.push_back(oj.dObjectId);
ClassIds.push_back(oj.dClassId);
ScopeIds.push_back(oj.dObjectScopeId);
ci.Clear();
break;
}
hr = GetNext_ClassImages(pConn, ci);
}
}
hr = GetNext_ObjectMap(pConn, oj);
}
}
else if (dClassId == dClassSecurityId)
{
// All __ClassSecurity for subclasses of this class
// Get the class name
// Get the ID for the class name in this namespace
// Enumerate subclasses
// Format the name
// Generate the Object ID
return E_NOTIMPL;
}
else if (dClassId == dClassInstSecurityId)
{
// All instances of this class and subclasses.
// Get the class name
// Get the ID for the class name in this namespace
// Enumerate subclasses
// Enumerate all instances of each class
return E_NOTIMPL;
}
else
{
// Regular instance. Enumerate all objects
// scoped to this .
SQL_ID dThis = dObjectId;
if (dClassId == dThisNamespaceId)
dThis = dScopeId;
SQL_ID * pScopes = NULL;
int iNumScopes = 0;
hr = pCache->GetSubScopes(dThis, &pScopes, iNumScopes);
for (int i = 0; i < iNumScopes; i++)
{
OBJECTMAP oj;
hr = GetFirst_ObjectMapByScope(pConn, pScopes[i], oj);
while (SUCCEEDED(hr))
{
CLASSIMAGES ci;
hr = GetFirst_ClassImages(pConn, oj.dObjectId, ci);
while (SUCCEEDED(hr))
{
if (ci.iPropertyId == dwSecPropID)
{
ObjIds.push_back(oj.dObjectId);
ClassIds.push_back(oj.dClassId);
ScopeIds.push_back(oj.dObjectScopeId);
ci.Clear();
break;
}
hr = GetNext_ClassImages(pConn, ci);
}
hr = GetNext_ObjectMap(pConn, oj);
}
}
delete pScopes;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::EnumerateSubScopes
//
//***************************************************************************
HRESULT CSQLExecProcedure::EnumerateSubScopes (CSQLConnection *pConn, SQL_ID dScopeId)
{
return E_NOTIMPL;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertScopeMap
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertScopeMap (CSQLConnection *pConn, SQL_ID dScopeId, LPCWSTR lpScopePath, SQL_ID dParentId)
{
HRESULT hr = InsertScopeMap_Internal(pConn, dScopeId, lpScopePath, dParentId);
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::InsertUncommittedEvent
//
//***************************************************************************
HRESULT CSQLExecProcedure::InsertUncommittedEvent (CSQLConnection *pConn, LPCWSTR lpGUID, LPWSTR lpNamespace,
LPWSTR lpClassName, IWbemClassObject *pOldObj,
IWbemClassObject *pNewObj, CSchemaCache *pCache)
{
HRESULT hr = WBEM_S_NO_ERROR;
static int iNumProps = 4;
InsertPropValues *pVals = new InsertPropValues[iNumProps];
if (!pVals)
return WBEM_E_OUT_OF_MEMORY;
CDeleteMe <InsertPropValues> d (pVals);
LPWSTR lpObjectKey = NULL, lpPath = NULL;
SQL_ID dScopeId = 1;
SQL_ID dObjectId = 0;
SQL_ID dKeyhole = 0;
static SQL_ID dClassId = 0;
static DWORD dwPropId1 = 0, dwPropId2 = 0, dwPropId3 = 0, dwPropId4 = 0, dwPropId5 = 0, dwPropId6 = 0, dwPropId7 = 0;
if (!dwPropId1)
{
hr = pCache->GetClassID(L"__UncommittedEvent", 1, dClassId);
if (SUCCEEDED(hr))
{
hr = pCache->GetPropertyID(L"EventID", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId1);
hr = pCache->GetPropertyID(L"TransactionGUID", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId2);
hr = pCache->GetPropertyID(L"NamespaceName", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId3);
hr = pCache->GetPropertyID(L"ClassName", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId4);
hr = pCache->GetPropertyID(L"OldObject", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId5);
hr = pCache->GetPropertyID(L"NewObject", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId6);
hr = pCache->GetPropertyID(L"Transacted", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId7);
}
}
if (FAILED(hr))
return hr;
hr = GetNextKeyhole(pConn, dwPropId1, dKeyhole);
if (SUCCEEDED(hr))
{
LPWSTR lpKey = new wchar_t [40];
lpObjectKey = new wchar_t [100];
lpPath = new wchar_t [100];
CDeleteMe <wchar_t> d2 (lpKey), d3 (lpObjectKey), d4 (lpPath);
if (!lpKey || !lpObjectKey || !lpPath)
return WBEM_E_OUT_OF_MEMORY;
swprintf(lpKey, L"%ld", dKeyhole);
swprintf(lpObjectKey, L"%ld?__UncommittedEvent", dKeyhole);
swprintf(lpObjectKey, L"__UncommittedEvent=%ld", dKeyhole);
pVals[0].iPropID = dwPropId1;
pVals[0].bIndexed = TRUE;
pVals[0].iStorageType = WMIDB_STORAGE_NUMERIC;
pVals[0].dClassId = dClassId;
pVals[0].pValue = lpKey;
pVals[1].iPropID = dwPropId2;
pVals[1].bIndexed = TRUE;
pVals[1].iStorageType = WMIDB_STORAGE_STRING;
pVals[1].dClassId = dClassId;
pVals[1].pValue = (LPWSTR)lpGUID;
pVals[2].iPropID = dwPropId3;
pVals[2].iStorageType = WMIDB_STORAGE_STRING;
pVals[2].dClassId = dClassId;
pVals[2].pValue = lpClassName;
pVals[3].iPropID = dwPropId4;
pVals[3].iStorageType = WMIDB_STORAGE_STRING;
pVals[3].dClassId = dClassId;
pVals[3].pValue = (LPWSTR)lpNamespace;
pVals[4].iPropID = dwPropId6;
pVals[4].iStorageType = WMIDB_STORAGE_NUMERIC;
pVals[4].dClassId = dClassId;
pVals[4].pValue = new wchar_t [1];
if (!pVals[4].pValue)
return WBEM_E_OUT_OF_MEMORY;
wcscpy(pVals[4].pValue, L"1");
hr = InsertPropertyBatch (pConn, lpObjectKey, lpPath, lpClassName,
dClassId, dScopeId, 0, pVals, iNumProps, dObjectId);
if (SUCCEEDED(hr))
{
if (pOldObj)
{
_IWmiObject *pInt = NULL;
hr = pOldObj->QueryInterface(IID__IWmiObject, (void **)&pInt);
if (SUCCEEDED(hr))
{
DWORD dwLen = 0;
pInt->GetObjectMemory(NULL, 0, &dwLen);
BYTE *pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> d (pBuff);
DWORD dwLen1;
hr = pInt->GetObjectMemory(pBuff, dwLen, &dwLen1);
if (SUCCEEDED(hr))
{
hr = CSQLExecProcedure::InsertBlobData(pConn, dClassId, dObjectId,
dwPropId4, pBuff, 0, dwLen);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
pInt->Release();
}
}
if (pNewObj)
{
_IWmiObject *pInt = NULL;
hr = pNewObj->QueryInterface(IID__IWmiObject, (void **)&pInt);
if (SUCCEEDED(hr))
{
DWORD dwLen = 0;
pInt->GetObjectMemory(NULL, 0, &dwLen);
BYTE *pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> d (pBuff);
DWORD dwLen1;
hr = pInt->GetObjectMemory(pBuff, dwLen, &dwLen1);
if (SUCCEEDED(hr))
{
hr = CSQLExecProcedure::InsertBlobData(pConn, dClassId, dObjectId,
dwPropId4, pBuff, 0, dwLen);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
pInt->Release();
}
}
}
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::DeleteUncommittedEvents
//
//***************************************************************************
HRESULT CSQLExecProcedure::DeleteUncommittedEvents (CSQLConnection *pConn, LPCWSTR lpGUID,
CSchemaCache *pCache, CObjectCache *pObjCache)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Delete all events by GUID
// The simplest thing to do is to scan IndexStringData
// for this GUID and delete each object that way
INDEXDATA id;
JET_TABLEID tableid;
DWORD dwPos;
SQLIDs ids;
SQL_ID dClassId;
hr = pCache->GetClassID(L"__UncommittedEvent", 1, dClassId);
// Find all objects that match this GUID...
hr = GetFirst_IndexDataString(pConn, (LPWSTR)lpGUID, id, tableid, dwPos);
while (SUCCEEDED(hr))
{
ids.push_back(id.dObjectId);
// Clean up object cache for each event
pObjCache->DeleteObject(id.dObjectId);
hr = GetNext_IndexData(pConn, tableid, dwPos, id);
}
// Delete 'em...
for (int i = 0; i < ids.size(); i++)
{
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, ids.at(i), oj);
if (oj.dClassId == dClassId)
{
oj.Clear();
hr = DeleteObjectMap(pConn, ids.at(i));
if (FAILED(hr))
break;
}
oj.Clear();
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::CommitEvents
//
//***************************************************************************
HRESULT CSQLExecProcedure::CommitEvents(CSQLConnection *pConn,_IWmiCoreServices *pESS,
LPCWSTR lpRoot, LPCWSTR lpGUID, CSchemaCache *pCache, CObjectCache *pObjCache)
{
HRESULT hr = WBEM_S_NO_ERROR;
// Enumerate event objects,
// fire an event for each (distinguishing classes, instances, and namespaces,
// and creation, deletion, modification)
// Delete each event.
INDEXDATA id;
JET_TABLEID tableid;
DWORD dwPos;
SQLIDs ids;
SQL_ID dClassId;
hr = pCache->GetClassID(L"__UncommittedEvent", 1, dClassId);
// Find all objects that match this GUID...
hr = GetFirst_IndexDataString(pConn, (LPWSTR)lpGUID, id, tableid, dwPos);
while (SUCCEEDED(hr))
{
ids.push_back(id.dObjectId);
// Clean up object cache for each event
pObjCache->DeleteObject(id.dObjectId);
hr = GetNext_IndexData(pConn, tableid, dwPos, id);
}
// Fire an event, and delete the object...
for (int i = 0; i < ids.size(); i++)
{
long lType = 0;
_bstr_t sNamespace;
_bstr_t sClassName;
DWORD dwNumObjs = 1;
_IWmiObject **pObjs = NULL;
_IWmiObject *pOldObj = NULL;
_IWmiObject *pNewObj = NULL;
LPWSTR lpNewNs = NULL;
OBJECTMAP oj;
hr = GetFirst_ObjectMap(pConn, ids.at(i), oj);
if (SUCCEEDED(hr))
{
if (oj.dClassId != dClassId)
{
oj.Clear();
continue;
}
// Extract the data from the tables.
// OldObject, NewObject, ClassName and NamespaceName
// =================================================
static DWORD dwPropId1 = 0, dwPropId2 = 0, dwPropId3 = 0, dwPropId4 = 0;
if (!dwPropId1)
{
if (SUCCEEDED(hr))
{
hr = pCache->GetPropertyID(L"NamespaceName", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId1);
hr = pCache->GetPropertyID(L"ClassName", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId2);
hr = pCache->GetPropertyID(L"OldObject", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId3);
hr = pCache->GetPropertyID(L"NewObject", dClassId, 0, REPDRVR_IGNORE_CIMTYPE, dwPropId4);
}
}
CLASSDATA cd;
hr = GetFirst_ClassData(pConn, ids.at(i), cd, dwPropId1);
if (SUCCEEDED(hr))
{
sNamespace = cd.sPropertyStringValue;
}
cd.Clear();
hr = GetFirst_ClassData(pConn, ids.at(i), cd, dwPropId2);
if (SUCCEEDED(hr))
{
sClassName = cd.sPropertyStringValue;
}
cd.Clear();
CLASSIMAGES ci;
hr = GetFirst_ClassImages(pConn, ids.at(i), ci);
while (SUCCEEDED(hr))
{
if (ci.iPropertyId == dwPropId3)
ConvertBlobToObject(NULL, ci.pBuffer, ci.dwBufferLen, &pOldObj);
else if (ci.iPropertyId == dwPropId4)
ConvertBlobToObject(NULL, ci.pBuffer, ci.dwBufferLen, &pNewObj);
hr = GetNext_ClassImages(pConn, ci);
}
ci.Clear();
// Namespace must be formatted with \\.\lpRoot\...
// Unless the namespace is root, and then we
// have to strip off the beginning...
// ===============================================
lpNewNs = new wchar_t [wcslen(sNamespace) + 50];
if (lpNewNs)
{
swprintf(lpNewNs, L"\\\\.\\%s\\%s", lpRoot, (LPCWSTR)sNamespace);
}
}
CDeleteMe <wchar_t> d4 (lpNewNs);
// Determine what type of event this is:
// Namespace | Class | Instance
// Creation | Modification | Deletion
// =====================================
if (!pNewObj && pOldObj)
{
pObjs = new _IWmiObject * [dwNumObjs];
if (pObjs)
{
pObjs[0] = pOldObj;
LPWSTR lpGenus = GetPropertyVal(L"__Genus", pOldObj);
CDeleteMe <wchar_t> d (lpGenus);
if (!wcscmp(lpGenus, L"1"))
lType = WBEM_EVENTTYPE_ClassDeletion;
else
{
if (IsDerivedFrom(pOldObj, L"__Namespace"))
lType = WBEM_EVENTTYPE_NamespaceDeletion;
else
lType = WBEM_EVENTTYPE_InstanceDeletion;
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else if (!pOldObj && pNewObj)
{
pObjs = new _IWmiObject *[dwNumObjs];
if (pObjs)
{
pObjs[0] = pNewObj;
LPWSTR lpGenus = GetPropertyVal(L"__Genus", pNewObj);
CDeleteMe <wchar_t> d (lpGenus);
if (!wcscmp(lpGenus, L"1"))
lType = WBEM_EVENTTYPE_ClassCreation;
else
{
if (IsDerivedFrom(pNewObj, L"__Namespace"))
lType = WBEM_EVENTTYPE_NamespaceCreation;
else
lType = WBEM_EVENTTYPE_InstanceCreation;
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
dwNumObjs = 2;
pObjs = new _IWmiObject *[dwNumObjs];
if (pObjs)
{
pObjs[0] = pOldObj;
pObjs[1] = pNewObj;
LPWSTR lpGenus = GetPropertyVal(L"__Genus", pNewObj);
CDeleteMe <wchar_t> d (lpGenus);
if (!wcscmp(lpGenus, L"1"))
lType = WBEM_EVENTTYPE_ClassModification;
else
{
if (IsDerivedFrom(pOldObj, L"__Namespace"))
lType = WBEM_EVENTTYPE_NamespaceModification;
else
lType = WBEM_EVENTTYPE_InstanceModification;
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
// Deliver the event...
// ====================
pESS->DeliverIntrinsicEvent(lpNewNs, lType, NULL,
sClassName, lpGUID, dwNumObjs, pObjs);
delete pObjs;
if (pOldObj)
pOldObj->Release();
if (pNewObj)
pNewObj->Release();
oj.Clear();
hr = DeleteObjectMap(pConn, ids.at(i));
if (FAILED(hr))
break;
}
return hr;
}
//***************************************************************************
//
// CSQLExecProcedure::UpdateClassBlob
//
//***************************************************************************
HRESULT CSQLExecProcedure::UpdateClassBlob (CSQLConnection *pConn, SQL_ID dClassId, _IWmiObject *pObj)
{
HRESULT hr = WBEM_S_NO_ERROR;
BYTE buff[128];
DWORD dwLen = 0;
hr = pObj->Unmerge(0, 128, &dwLen, &buff);
if (dwLen > 0)
{
BYTE *pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> r2 (pBuff);
DWORD dwLen1;
hr = pObj->Unmerge(0, dwLen, &dwLen1, pBuff);
if (SUCCEEDED(hr))
{
CLASSMAP cd;
hr = GetFirst_ClassMap(pConn, dClassId, cd);
if (SUCCEEDED(hr))
{
delete cd.pClassBuffer;
cd.pClassBuffer = pBuff;
cd.dwBufferLen = dwLen;
hr = UpdateClassMap(pConn, cd);
}
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::LoadSchemaCache
//
//***************************************************************************
HRESULT CWmiDbSession::LoadSchemaCache ()
{
HRESULT hr = WBEM_S_NO_ERROR;
// This needs to load the cache with all class, property,
// and namespace data. We are going to call three straight
// select queries and grab the columns.
// ==========================================================
DWORD dwNumRows;
CSQLConnection *pConn = NULL;
if (m_pController)
hr = GetSQLCache()->GetConnection(&pConn);
if (SUCCEEDED(hr) && pConn)
{
// Enumerate scopes.
// =================
SCOPEMAP sm;
OBJECTMAP oj;
CLASSIMAGES ci;
DWORD dwSecurity;
hr = OpenEnum_ScopeMap(pConn, sm);
while (SUCCEEDED(hr))
{
hr = GetFirst_ObjectMap(pConn, sm.dObjectId, oj);
hr = GetSchemaCache()->AddNamespace
(sm.sScopePath, sm.sScopePath, sm.dObjectId, sm.dParentId, oj.dClassId);
oj.Clear();
if (FAILED(hr))
break;
hr = GetNext_ScopeMap(pConn, sm);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
// Enumerate system classes.
if (FAILED(LoadClassInfo(pConn, L"meta_class", 0, FALSE)))
goto Exit;
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
// IDs with security descriptors
GetSchemaCache()->GetPropertyID(L"__SECURITY_DESCRIPTOR", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwSecurity);
hr = GetFirst_ClassImagesByPropertyId(pConn, dwSecurity, ci);
while (SUCCEEDED(hr))
{
((CWmiDbController *)m_pController)->AddSecurityDescriptor(ci.dObjectId);
hr = GetNext_ClassImages(pConn, ci);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
}
Exit:
if (m_pController)
GetSQLCache()->ReleaseConnection(pConn, hr, IsDistributed());
return hr;
}
//***************************************************************************
//
// GetSuperClassInfo
//
//***************************************************************************
HRESULT GetSuperClassInfo(CSQLConnection *pConn, CSchemaCache *pCache, SQL_ID dClassId, BOOL &bKeyless,
SQLIDs *pLockedIDs)
{
HRESULT hr = WBEM_S_NO_ERROR;
CLASSMAP cd;
OBJECTMAP oj;
SQL_ID dSuperClass = 0;
hr = GetFirst_ClassMap(pConn, dClassId, cd);
if (SUCCEEDED(hr))
{
dSuperClass = cd.dSuperClassId;
pCache->LockDynasty(dSuperClass);
pLockedIDs->push_back(dSuperClass);
hr = GetFirst_ObjectMap(pConn, dClassId, oj);
if (SUCCEEDED(hr))
{
//DEBUGTRACE((LOG_WBEMCORE, "GetSuperClassInfo %S\n", cd.sClassName));
if (oj.iObjectFlags & REPDRVR_FLAG_ABSTRACT ||
oj.iObjectFlags & REPDRVR_FLAG_UNKEYED)
bKeyless = TRUE;
hr = pCache->AddClassInfo(cd.dClassId,
cd.sClassName, cd.dSuperClassId, cd.dDynastyId, oj.dObjectScopeId, oj.sObjectKey, oj.iObjectFlags);
if (SUCCEEDED(hr))
{
hr = LoadSchemaProperties (pConn, pCache, dClassId);
if (SUCCEEDED(hr) && dSuperClass && dSuperClass != 1)
hr = GetSuperClassInfo(pConn, pCache, dSuperClass, bKeyless, pLockedIDs);
}
}
cd.Clear();
oj.Clear();
}
return hr;
}
//***************************************************************************
//
// GetDerivedClassInfo
//
//***************************************************************************
HRESULT GetDerivedClassInfo(CSQLConnection *pConn, CSchemaCache *pCache, SQL_ID dClassId)
{
HRESULT hr = WBEM_S_NO_ERROR;
SQLIDs ids;
CLASSMAP cd;
OBJECTMAP oj;
SQL_ID dClass = 0;
if (dClassId != 1)
{
hr = GetFirst_ClassMapBySuperClass(pConn, dClassId, cd);
while (SUCCEEDED(hr))
{
ids.push_back(cd.dClassId);
hr = GetNext_ClassMap(pConn, cd);
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR;
for (int i = 0; i < ids.size(); i++)
{
dClass = ids.at(i);
if (!pCache->Exists(dClass))
{
hr = GetFirst_ClassMap(pConn, dClass, cd);
hr = GetFirst_ObjectMap(pConn, dClass, oj);
if (SUCCEEDED(hr))
{
//DEBUGTRACE((LOG_WBEMCORE, "GetDerivedClassInfo %S\n", cd.sClassName));
hr = pCache->AddClassInfo(cd.dClassId,
cd.sClassName, cd.dSuperClassId, cd.dDynastyId, oj.dObjectScopeId, oj.sObjectKey, oj.iObjectFlags);
if (SUCCEEDED(hr))
{
hr = LoadSchemaProperties (pConn, pCache, dClass);
if (SUCCEEDED(hr))
hr = GetDerivedClassInfo(pConn, pCache, dClass);
}
}
cd.Clear();
oj.Clear();
}
}
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::LoadClassInfo
//
//***************************************************************************
HRESULT CWmiDbSession::LoadClassInfo (CSQLConnection *_pConn, SQL_ID dClassId, BOOL bDeep)
{
HRESULT hr = WBEM_S_NO_ERROR;
BOOL bRelease = FALSE;
CSQLConnection *pConn = _pConn;
_WMILockit lkt(GetCS());
DWORD dwSize = GetSchemaCache()->GetTotalSize();
DWORD dwMax = GetSchemaCache()->GetMaxSize();
int i = 0;
if (dwMax <= dwSize)
{
DEBUGTRACE((LOG_WBEMCORE, "Repository schema cache has exceeded limit of %ld bytes (%ld). Resizing...\n", dwMax, dwSize));
// We do this here, so we ensure that *only* entire dynasties
// get loaded. Its OK if we exceed the cache as long as
// everything in the cache is in use.
hr = GetSchemaCache()->ResizeCache();
}
GetSchemaCache()->LockDynasty(dClassId);
m_Dynasties[GetCurrentThreadId()].push_back(dClassId);
// Check if this exists in the cache.
// If so, stop now.
//if (GetSchemaCache()->Exists(dClassId))
// return WBEM_S_NO_ERROR;
if (!pConn && m_pController)
{
hr = GetSQLCache()->GetConnection(&pConn, FALSE, IsDistributed());
if (SUCCEEDED(hr))
bRelease = TRUE;
else
return hr;
}
// Now get all derived classes, and all parent classes.
// ====================================================
BOOL bKeyless = FALSE;
hr = GetSuperClassInfo(pConn, GetSchemaCache(), dClassId, bKeyless, &m_Dynasties[GetCurrentThreadId()]);
if (SUCCEEDED(hr) && (!bKeyless || bDeep))
hr = GetDerivedClassInfo(pConn, GetSchemaCache(), dClassId);
if (bRelease && m_pController)
GetSQLCache()->ReleaseConnection(pConn);
return hr;
}
//***************************************************************************
//
// CWmiDbSession::LoadClassInfo
//
//***************************************************************************
HRESULT CWmiDbSession::LoadClassInfo (CSQLConnection *_pConn, LPCWSTR lpDynasty, SQL_ID dScopeId, BOOL bDeep)
{
HRESULT hr = WBEM_S_NO_ERROR;
DWORD dwSize = GetSchemaCache()->GetTotalSize();
DWORD dwMax = GetSchemaCache()->GetMaxSize();
SQLIDs ids;
int i = 0;
if (dwMax <= dwSize)
{
DEBUGTRACE((LOG_WBEMCORE, "Repository schema cache has exceeded limit of %ld bytes (%ld). Resizing...\n", dwMax, dwSize));
// We do this here, so we ensure that *only* entire dynasties
// get loaded. Its OK if we exceed the cache as long as
// everything in the cache is in use.
hr = GetSchemaCache()->ResizeCache();
}
BOOL bRelease = FALSE;
CSQLConnection *pConn = _pConn;
if (!pConn && m_pController)
{
hr = GetSQLCache()->GetConnection(&pConn, FALSE, IsDistributed());
if (SUCCEEDED(hr))
bRelease = TRUE;
else
return hr;
}
CLASSMAP cd;
OBJECTMAP oj;
if (!lpDynasty)
{
if ((GetSchemaCache()->Exists(1)))
return WBEM_S_NO_ERROR;
hr = OpenEnum_ClassMap(pConn, cd);
while (SUCCEEDED(hr))
{
if (cd.dSuperClassId == 0)
ids.push_back(cd.dClassId);
hr = GetNext_ClassMap(pConn, cd);
}
for (i = 0; i < ids.size(); i++)
{
hr = GetFirst_ClassMap(pConn, ids.at(i), cd);
hr = GetFirst_ObjectMap(pConn, ids.at(i), oj);
if (SUCCEEDED(hr))
hr = GetSchemaCache()->AddClassInfo(oj.dObjectId,
cd.sClassName, cd.dSuperClassId, cd.dDynastyId, oj.dObjectScopeId, oj.sObjectKey, oj.iObjectFlags);
cd.Clear();
oj.Clear();
if (FAILED(hr))
break;
hr = LoadSchemaProperties (pConn, &((CWmiDbController *)m_pController)->SchemaCache, ids.at(i));
if (FAILED(hr))
break;
}
}
else
{
// We need to find all classes derived from
// this dynasty.
SQL_ID dDynasty = 0;
BOOL bFound = FALSE;
hr = GetFirst_ClassMapByName(pConn, lpDynasty, cd);
while (SUCCEEDED(hr))
{
hr = GetFirst_ObjectMap(pConn, cd.dClassId, oj);
if (!oj.dObjectScopeId || oj.dObjectScopeId == dScopeId)
{
oj.Clear();
cd.Clear();
bFound = TRUE;
dDynasty = cd.dClassId;
break;
}
oj.Clear();
hr = GetNext_ClassMap(pConn, cd);
}
if (bFound)
hr = LoadClassInfo(pConn, dDynasty, bDeep);
else
hr = WBEM_E_NOT_FOUND;
}
if (bRelease && m_pController)
GetSQLCache()->ReleaseConnection(pConn);
return hr;
}
//***************************************************************************
//
// CWmiDbSession::ExecQuery
//
//***************************************************************************
HRESULT STDMETHODCALLTYPE CWmiDbSession::ExecQuery(
/* [in] */ IWmiDbHandle __RPC_FAR *pScope,
/* [in] */ IWbemQuery __RPC_FAR *pQuery,
/* [in] */ DWORD dwFlags,
/* [in] */ DWORD dwHandleType,
/* [out] */ DWORD *dwMessageFlags,
/* [out] */ IWmiDbIterator __RPC_FAR *__RPC_FAR *pQueryResult)
{
HRESULT hr = WBEM_S_NO_ERROR;
if (!m_pController ||
((CWmiDbController *)m_pController)->m_dwCurrentStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
if (dwHandleType == WMIDB_HANDLE_TYPE_INVALID || !pQuery || !pQueryResult || !pScope)
return WBEM_E_INVALID_PARAMETER;
if (dwHandleType & ~WMIDB_HANDLE_TYPE_COOKIE
&~WMIDB_HANDLE_TYPE_VERSIONED &~WMIDB_HANDLE_TYPE_PROTECTED
&~WMIDB_HANDLE_TYPE_EXCLUSIVE &~ WMIDB_HANDLE_TYPE_WEAK_CACHE
&~WMIDB_HANDLE_TYPE_STRONG_CACHE &~ WMIDB_HANDLE_TYPE_NO_CACHE
&~WMIDB_HANDLE_TYPE_SUBSCOPED)
return WBEM_E_INVALID_PARAMETER;
if (dwFlags & ~WMIDB_FLAG_QUERY_DEEP &~WMIDB_FLAG_QUERY_SHALLOW & ~WBEM_FLAG_USE_SECURITY_DESCRIPTOR)
return WBEM_E_INVALID_PARAMETER;
try
{
if (dwMessageFlags)
*dwMessageFlags = WBEM_REQUIREMENTS_STOP_POSTFILTER;
DWORD dwOpenTable = 0;
SQL_ID dClassId = 0;
JET_TABLEID tableid = 0;
CSQLConnection *pConn = NULL;
// Obtain a database connection
if (m_pController)
hr = GetSQLCache()->GetConnection(&pConn, FALSE, IsDistributed());
if (FAILED(hr) || !pQuery || !pScope)
{
hr = WBEM_E_INVALID_PARAMETER;
}
else
{
BOOL bDeleteQuery = FALSE;
SQL_ID dwNsId = 0;
IWbemClassObject *pTemp = NULL;
CESETokens *pToks = NULL;
int iLastPos = 0;
BOOL bEnum = FALSE;
BOOL bWQL = TRUE;
BOOL bClasses = FALSE;
int iStartCrit = 0;
HRESULT hrMatch = WBEM_S_NO_ERROR;
dwNsId = ((CWmiDbHandle *)pScope)->m_dObjectId;
SQL_ID dScopeClassId = ((CWmiDbHandle *)pScope)->m_dClassId;
SQL_ID dSuperScope = ((CWmiDbHandle *)pScope)->m_dScopeId;
DWORD dwScopeType = ((CWmiDbHandle *)pScope)->m_dwHandleType ;
if (pScope && !(dwScopeType & WMIDB_HANDLE_TYPE_CONTAINER))
hr=VerifyObjectSecurity (pConn, dwNsId, dScopeClassId, dSuperScope, 0, WBEM_ENABLE);
SWbemAssocQueryInf *pNode = NULL;
hr = pQuery->GetAnalysis(WMIQ_ANALYSIS_ASSOC_QUERY,
0, (void **)&pNode);
if (FAILED(hr))
{
BOOL bIndexCols = FALSE, bHierarchy = 0, bSuperSet = FALSE;
// Since ESE has no query engine, we need to:
// Parse the query
// Figure out which index to use and prefilter
// slap the parsed output onto the iterator as a post-filter.
// if the query includes elements that cannot be handled in memory,
// we need to return WBEM_E_INVALID_QUERY or WBEM_E_PROVIDER_NOT_CAPABLE
// ================================================================
CESEBuilder bldr(&((CWmiDbController *)m_pController)->SchemaCache, this, pConn);
hr = bldr.FormatSQL(((CWmiDbHandle *)pScope)->m_dObjectId, ((CWmiDbHandle *)pScope)->m_dClassId,
((CWmiDbHandle *)pScope)->m_dScopeId, pQuery, &pToks, dwFlags,
((CWmiDbHandle *)pScope)->m_dwHandleType, &dClassId, &bHierarchy,
&bIndexCols, &bSuperSet, &bDeleteQuery);
// Make sure we have access to the target class.
// We won't check locks at this point, since that will
// be the iterator's job.
// If we can't analyze this query,
// we certainly can't delete the results.
if (bDeleteQuery && bSuperSet)
hr = WBEM_E_NOT_SUPPORTED;
if (!pToks && SUCCEEDED(hr))
hr = WBEM_E_INVALID_QUERY;
if (SUCCEEDED(hr))
{
if (dwMessageFlags)
*dwMessageFlags = (bSuperSet ? WBEM_REQUIREMENTS_START_POSTFILTER : WBEM_REQUIREMENTS_STOP_POSTFILTER);
if (SUCCEEDED(hr))
{
int i;
BOOL bEnumSubClass = TRUE;
SQL_ID dClassCrit = 0, dSuperClassCrit = 0, dDynastyCrit = 0;
if (dClassId == 1) // meta_class - we only want classes
{
bClasses = TRUE;
bEnumSubClass = FALSE;
// * __Class = ... => Limit to single class
// * __SuperClass = => Prescan on SuperClassId
// * __Dynasty = => Prescan on DynastyId
// * __this isa => Enum subclasses + list criteria.
DWORD dwClassPropID = 0, dwSuperClassPropID = 0, dwDynastyPropID = 0;
DWORD dwDerivationPropID = 0;
BOOL bClassCrit = FALSE, bSuperClassCrit = FALSE, bDynastyCrit = FALSE;
GetSchemaCache()->GetPropertyID(L"__Class", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwClassPropID);
GetSchemaCache()->GetPropertyID(L"__SuperClass", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwSuperClassPropID);
GetSchemaCache()->GetPropertyID(L"__Dynasty", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwDynastyPropID);
GetSchemaCache()->GetPropertyID(L"__Derivation", 1,
0, REPDRVR_IGNORE_CIMTYPE, dwDerivationPropID);
BOOL bFound = FALSE;
for (i = 0; i < pToks->GetNumTokens(); i++)
{
ESEToken *pTok = pToks->GetToken(i);
if (pTok && pTok->tokentype == ESE_EXPR_TYPE_EXPR)
{
if (((ESEWQLToken *)pTok)->tokentype == ESE_EXPR_TYPE_OR ||
((ESEWQLToken *)pTok)->tokentype == ESE_EXPR_TYPE_NOT)
{
bClassCrit = 0;
bSuperClassCrit = 0;
bDynastyCrit = 0;
break;
}
if (((ESEWQLToken *)pTok)->optype == WQL_TOK_EQ)
{
SQL_ID dClassId2 = 0, dDynasty = 0;
if (wcslen((((ESEWQLToken *)pTok)->Value.sValue)))
{
hr = GetSchemaCache()->GetClassID
(((ESEWQLToken *)pTok)->Value.sValue, dwNsId, dClassId2, &dDynasty);
}
if ((((ESEWQLToken *)pTok)->dPropertyId == dwClassPropID))
{
bClassCrit = TRUE;
dClassCrit = dClassId2;
}
else if ((((ESEWQLToken *)pTok)->dPropertyId == dwSuperClassPropID))
{
bSuperClassCrit = TRUE;
dSuperClassCrit = dClassId2;
}
else if ((((ESEWQLToken *)pTok)->dPropertyId == dwDynastyPropID))
{
bDynastyCrit = TRUE;
dDynastyCrit = dClassId2;
}
else if ((((ESEWQLToken *)pTok)->dPropertyId == dwDerivationPropID))
{
bDynastyCrit = TRUE;
dDynastyCrit = dDynasty;
dClassId = dClassId2;
if (dDynasty != dClassId2)
{
bEnumSubClass = TRUE;
}
}
}
}
}
pToks->SetIsMetaClass(TRUE);
if (bClassCrit)
{
OBJECTMAP oj;
hrMatch = GetFirst_ObjectMap(pConn, dClassCrit, oj);
tableid = ((CESEConnection *)pConn)->GetTableID(L"ObjectMap");
dwOpenTable = OPENTABLE_OBJECTMAP;
oj.Clear();
}
else if (bSuperClassCrit)
{
CLASSMAP cm;
if (!dSuperClassCrit)
dSuperClassCrit = 1;
hrMatch = GetFirst_ClassMapBySuperClass(pConn, dSuperClassCrit, cm);
tableid = ((CESEConnection *)pConn)->GetTableID(L"ClassMap");
dwOpenTable = OPENTABLE_CLASSMAP;
cm.Clear();
}
else if (bDynastyCrit)
{
CLASSMAP cm;
hrMatch = GetFirst_ClassMapByDynasty(pConn, dDynastyCrit, cm);
tableid = ((CESEConnection *)pConn)->GetTableID(L"ClassMap");
dwOpenTable = OPENTABLE_CLASSMAP;
cm.Clear();
}
else // Scan all ClassMap
{
pToks->AddSysExpr(0, dClassId);
CLASSMAP cm;
hrMatch = OpenEnum_ClassMap(pConn, cm);
tableid = ((CESEConnection *)pConn)->GetTableID(L"ClassMap");
dwOpenTable = OPENTABLE_CLASSMAP;
cm.Clear();
}
}
if (bEnumSubClass)
{
// If we need to limit the classes by class ID
// get the derived class list.
// Disregard if this is meta_class - we're only
// interested in returning classes.
SQL_ID *pIDs = NULL;
int iNumChildren = 0;
GetSchemaCache()->GetDerivedClassList(dClassId, &pIDs, iNumChildren, FALSE);
if (pIDs)
{
for (i = iNumChildren-1; i >= 0; i--)
{
SQL_ID d = pIDs[i];
pToks->AddSysExpr(0, d);
}
delete pIDs;
}
// Optimization for class with no children.
if (!iNumChildren && pToks->IsMetaClass() && (dClassId != 1))
{
CLASSMAP cm;
hrMatch = GetFirst_ClassMap(pConn, dClassId, cm);
tableid = ((CESEConnection *)pConn)->GetTableID(L"ClassMap");
dwOpenTable = OPENTABLE_CLASSMAP;
cm.Clear();
}
}
if ( ((CWmiDbHandle *)pScope)->m_dwHandleType & WMIDB_HANDLE_TYPE_CONTAINER)
{
CONTAINEROBJ co;
hrMatch = GetFirst_ContainerObjs(pConn, ((CWmiDbHandle *)pScope)->m_dObjectId, co);
co.Clear();
dwOpenTable = OPENTABLE_CONTAINEROBJS;
tableid = ((CESEConnection *)pConn)->GetTableID(L"ContainerObjs");
}
else
{
if (bIndexCols)
{
// Seek to property ID of first indexed criteria
DWORD dwNumToks = pToks->GetNumTokens();
for (i = 0; i < dwNumToks; i++)
{
ESEToken *pTok = pToks->GetToken(i);
if (pTok && pTok->tokentype == ESE_EXPR_TYPE_EXPR)
{
INDEXDATA id;
iLastPos = i;
DWORD dwPos = 0;
ESEWQLToken *pTok2 = (ESEWQLToken *)pTok;
if (pTok2->bIndexed)
{
switch(pTok2->Value.valuetype)
{
case ESE_VALUE_TYPE_SQL_ID:
SetupIndexDataAccessor(pConn, WMIDB_STORAGE_NUMERIC, dwPos, NULL);
tableid = ((CESEConnection *)pConn)->GetTableID(L"IndexNumericData");
hrMatch = GetFirst_IndexDataByProperty(pConn, pTok2->dPropertyId,
id, tableid, SQL_POS_INDEXNUMERIC);
dwOpenTable = OPENTABLE_INDEXNUMERIC;
id.Clear();
break;
case ESE_VALUE_TYPE_STRING:
SetupIndexDataAccessor(pConn, WMIDB_STORAGE_STRING, dwPos, NULL);
tableid = ((CESEConnection *)pConn)->GetTableID(L"IndexStringData");
hrMatch = GetFirst_IndexDataByProperty(pConn, pTok2->dPropertyId,
id, tableid, SQL_POS_INDEXSTRING);
dwOpenTable = OPENTABLE_INDEXSTRING;
id.Clear();
break;
case ESE_VALUE_TYPE_REAL:
SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REAL, dwPos, NULL);
tableid = ((CESEConnection *)pConn)->GetTableID(L"IndexRealData");
hrMatch = GetFirst_IndexDataByProperty(pConn, pTok2->dPropertyId,
id, tableid, SQL_POS_INDEXREAL);
dwOpenTable = OPENTABLE_INDEXREAL;
id.Clear();
break;
case ESE_VALUE_TYPE_REF:
SetupIndexDataAccessor(pConn, WMIDB_STORAGE_REFERENCE, dwPos, NULL);
tableid = ((CESEConnection *)pConn)->GetTableID(L"IndexRefData");
hrMatch = GetFirst_IndexDataByProperty(pConn, pTok2->dPropertyId,
id, tableid, SQL_POS_INDEXREF);
dwOpenTable = OPENTABLE_INDEXREF;
id.Clear();
break;
default:
break;
}
if (dwOpenTable)
break;
}
}
}
}
if (!dwOpenTable)
{
dwOpenTable = OPENTABLE_OBJECTMAP;
OBJECTMAP oj;
// Find the first class that matches.
DWORD dwNumToks = pToks->GetNumTokens();
for (i = 0; i < dwNumToks; i++)
{
ESEToken *pTok = pToks->GetToken(i);
if (pTok->tokentype == ESE_EXPR_TYPE_EXPR)
{
ESEWQLToken *pTok2 = (ESEWQLToken *)pTok;
if (pTok2->Value.valuetype == ESE_VALUE_TYPE_SYSPROP)
{
if (pTok2->dClassId)
{
hrMatch = GetFirst_ObjectMapByClass(pConn, pTok2->dClassId, oj);
if (SUCCEEDED(hrMatch))
{
oj.Clear();
iLastPos = i;
break;
}
oj.Clear();
}
}
}
}
tableid = ((CESEConnection *)pConn)->GetTableID(L"ObjectMap");
}
}
}
}
}
else
{
SQL_ID dObjId = 0;
CESEBuilder bldr(&((CWmiDbController *)m_pController)->SchemaCache, this, pConn);
if (SUCCEEDED(hr))
{
// Get dObjId.
SQL_ID dAssocClassId = 0, dResultClassId = 0;
IWbemPath *pPath = NULL;
hr = CoCreateInstance(CLSID_WbemDefPath, 0, CLSCTX_INPROC_SERVER,
IID_IWbemPath, (LPVOID *) &pPath);
BOOL bIsClass = FALSE;
if (SUCCEEDED(hr))
{
CReleaseMe r (pPath);
pPath->SetText(WBEMPATH_CREATE_ACCEPT_ALL, pNode->m_pszPath);
IWmiDbHandle *pTemp = NULL;
hr = GetObject(pScope, pPath, dwFlags, WMIDB_HANDLE_TYPE_COOKIE, &pTemp);
if (SUCCEEDED(hr))
{
// We need rudimentary tempQL support
BOOL bSuperSet = FALSE;
dObjId = ((CWmiDbHandle *)pTemp)->m_dObjectId;
bIsClass = ((CWmiDbHandle *)pTemp)->m_dClassId == 1 ? TRUE: FALSE;
pTemp->Release();
hr = bldr.FormatSQL(((CWmiDbHandle *)pScope)->m_dObjectId, ((CWmiDbHandle *)pScope)->m_dClassId,
((CWmiDbHandle *)pScope)->m_dScopeId, dObjId, pNode->m_pszResultClass,
pNode->m_pszAssocClass, pNode->m_pszRole, pNode->m_pszResultRole, pNode->m_pszRequiredQualifier,
pNode->m_pszRequiredAssocQualifier, pNode->m_uFeatureMask, &pToks, dwFlags,
((CWmiDbHandle *)pScope)->m_dwHandleType, &dAssocClassId, &dResultClassId, &bSuperSet);
bWQL = FALSE;
if (!pToks && SUCCEEDED(hr))
hr = WBEM_E_INVALID_QUERY;
if (SUCCEEDED(hr))
{
if (dwMessageFlags)
{
*dwMessageFlags = (bSuperSet ? WBEM_REQUIREMENTS_START_POSTFILTER : WBEM_REQUIREMENTS_STOP_POSTFILTER);
if (pNode->m_uFeatureMask & (QUERY_TYPE_SCHEMA_ONLY + QUERY_TYPE_CLASSDEFS_ONLY))
*dwMessageFlags = TRUE;
}
hr=VerifyClassSecurity (pConn, dObjId, WBEM_ENABLE);
if (SUCCEEDED(hr) && dAssocClassId)
{
hr=VerifyClassSecurity (pConn, dAssocClassId, WBEM_ENABLE);
}
if (SUCCEEDED(hr) && dResultClassId)
{
hr=VerifyClassSecurity(pConn, dResultClassId, WBEM_ENABLE);
}
}
}
}
pQuery->FreeMemory(pNode);
if (SUCCEEDED(hr))
{
if (!bIsClass)
{
// Use the target object, REFID
INDEXDATA is;
DWORD dwPos = 0;
hrMatch = GetFirst_IndexDataRef(pConn, dObjId, is, tableid, dwPos);
dwOpenTable = OPENTABLE_INDEXREF;
is.Clear();
tableid = ((CESEConnection *)pConn)->GetTableID(L"IndexRefData");
}
else
{
// We need to examine each class, and see if it contains
// an association or reference to the target class.
REFERENCEPROPERTIES pm;
hrMatch = GetFirst_ReferencePropertiesByRef (pConn, dObjId, pm);
dwOpenTable = OPENTABLE_REFPROPS;
tableid = ((CESEConnection *)pConn)->GetTableID(L"ReferenceProperties");
if (dwMessageFlags)
*dwMessageFlags = WBEM_REQUIREMENTS_START_POSTFILTER;
}
}
}
}
// Construct and return the iterator.
// This contains the open SQL connection positioned
// on the first valid row
if (SUCCEEDED(hr))
{
DWORD dwRows;
CWmiESEIterator *pNew = new CWmiESEIterator;
if (pNew)
{
AddRef_Lock();
pNew->m_pSession = this;
pNew->m_pConn = pConn;
pNew->m_pToks = pToks;
if (SUCCEEDED(hrMatch))
pNew->m_dwOpenTable = dwOpenTable;
else
pNew->m_dwOpenTable = 0;
pNew->m_tableid = tableid;
pNew->m_iLastPos = iLastPos;
if (bEnum)
pNew->m_iStartPos = iStartCrit;
else
pNew->m_iStartPos = 0;
pNew->m_bEnum = bEnum;
pNew->m_bWQL = bWQL;
pNew->m_bClasses = bClasses;
pNew->AddRef();
AddRef(); // The iterator releases us on its own release
// If this was a delete query,
// enumerate the results, and delete 'em
if (bDeleteQuery)
{
hr = DeleteRows(pScope, pNew, IID_IWmiDbHandle);
pNew->Release();
*pQueryResult = NULL;
}
// select query. Give them the iterator
else if (pQueryResult)
{
*pQueryResult = (IWmiDbIterator *)pNew;
}
}
else
{
hr = WBEM_E_OUT_OF_MEMORY;
}
}
else
delete pToks;
}
// If we failed, we need to release the connection
// Otherwise, it will be attached to the iterator,
// and will be released when the last result row has been returned
if (FAILED(hr) && pConn && m_pController)
GetSQLCache()->ReleaseConnection(pConn);
}
catch (...)
{
ERRORTRACE((LOG_WBEMCORE, "Fatal error in CWmiDbSession::ExecQuery\n"));
hr = WBEM_E_CRITICAL_ERROR;
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::Enumerate
//
//***************************************************************************
HRESULT STDMETHODCALLTYPE CWmiDbSession::Enumerate(
/* [in] */ IWmiDbHandle __RPC_FAR *pScope,
/* [in] */ DWORD dwFlags,
/* [in] */ DWORD dwRequestedHandleType,
/* [out] */ IWmiDbIterator __RPC_FAR *__RPC_FAR *ppQueryResult)
{
HRESULT hr = WBEM_S_NO_ERROR;
if (!m_pController ||
((CWmiDbController *)m_pController)->m_dwCurrentStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
if (dwRequestedHandleType == WMIDB_HANDLE_TYPE_INVALID || !pScope)
return WBEM_E_INVALID_PARAMETER;
if (dwRequestedHandleType & ~WMIDB_HANDLE_TYPE_COOKIE
&~WMIDB_HANDLE_TYPE_VERSIONED &~WMIDB_HANDLE_TYPE_PROTECTED
&~WMIDB_HANDLE_TYPE_EXCLUSIVE &~ WMIDB_HANDLE_TYPE_WEAK_CACHE
&~WMIDB_HANDLE_TYPE_STRONG_CACHE &~ WMIDB_HANDLE_TYPE_NO_CACHE
&~WMIDB_HANDLE_TYPE_SUBSCOPED &~WMIDB_HANDLE_TYPE_CONTAINER
&~ WMIDB_HANDLE_TYPE_SCOPE)
return WBEM_E_INVALID_PARAMETER;
try
{
{
_WMILockit lkt(GetCS());
if (!((CWmiDbController *)m_pController)->m_bCacheInit)
{
hr = LoadSchemaCache();
if (SUCCEEDED(hr))
((CWmiDbController *)m_pController)->m_bCacheInit = TRUE;
else
return hr;
}
}
JET_TABLEID tableid = 0;
MappedProperties *pProps;
DWORD dwNumProps;
BOOL bHierarchy = FALSE;
SQL_ID dwNsId = 0, dClassId = 0;
_bstr_t sPath;
int iNumRows = 0;
IWbemClassObject *pTemp = NULL;
if (pScope)
{
// CVADAI: This is a container, not a scope, so this
// info won't be cached.
dwNsId = ((CWmiDbHandle *)pScope)->m_dObjectId;
dClassId = ((CWmiDbHandle *)pScope)->m_dClassId;
//SQL_ID dScopeId = ((CWmiDbHandle *)pScope)->m_dScopeId;
//hr = VerifyObjectSecurity(dwNsId, dClassId, dScopeId, 0, WBEM_ENABLE);
}
if (SUCCEEDED(hr) && m_pController)
{
DWORD dwRows;
IRowset *pRowset = NULL;
CSQLConnection *pConn=NULL;
hr = GetSQLCache()->GetConnection(&pConn, FALSE, IsDistributed());
if (SUCCEEDED(hr))
{
// Here we need to do the equivalent enumeration based
// on table or index scan, and return a custom iterator
// Basically, we stuff the filter conditions on the iterator,
// and return it.
// ====================================================
DWORD dwOpenTable = 0;
CESETokens *pToks = NULL;
wchar_t sSQL [1024];
DWORD dwHandleType = ((CWmiDbHandle *)pScope)->m_dwHandleType;
if (dClassId == INSTANCESCLASSID)
{
// ClassId = dwNsId AND
// ObjectScopeId = dScopeId
OBJECTMAP oj;
SQL_ID dScopeId = ((CWmiDbHandle *)pScope)->m_dScopeId;
hr = GetFirst_ObjectMapByClass(pConn, dwNsId, oj);
oj.Clear();
if (SUCCEEDED(hr))
dwOpenTable = OPENTABLE_OBJECTMAP;
tableid = ((CESEConnection *)pConn)->GetTableID(L"ObjectMap");
pToks = new CESETokens;
if (pToks)
pToks->AddSysExpr(dScopeId, dwNsId);
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else if (dwHandleType & WMIDB_HANDLE_TYPE_CONTAINER)
{
// ContainerId = dContainerId (Use ContainerObjs)
SQL_ID dContainerId = ((CWmiDbHandle *)pScope)->m_dObjectId;
pToks = new CESETokens;
if (pToks)
{
CONTAINEROBJ co;
hr = GetFirst_ContainerObjs(pConn, dContainerId, co);
if (SUCCEEDED(hr))
dwOpenTable = OPENTABLE_CONTAINEROBJS;
co.Clear();
tableid = ((CESEConnection *)pConn)->GetTableID(L"ContainerObjs");
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
// Scope
else
{
// ObjectScopeId = dwNsId
OBJECTMAP oj;
SQL_ID dScopeId = ((CWmiDbHandle *)pScope)->m_dObjectId;
hr = GetFirst_ObjectMapByScope(pConn, dScopeId, oj);
oj.Clear();
if (SUCCEEDED(hr))
dwOpenTable = OPENTABLE_OBJECTMAP;
tableid = ((CESEConnection *)pConn)->GetTableID(L"ObjectMap");
pToks = new CESETokens;
if (pToks)
pToks->AddSysExpr(dScopeId, 0);
else
hr = WBEM_E_OUT_OF_MEMORY;
}
if (hr == WBEM_E_NOT_FOUND)
hr = WBEM_S_NO_ERROR; // create the iterator, for consistency.
if (SUCCEEDED(hr))
{
CWmiESEIterator *pNew = new CWmiESEIterator;
if (pNew)
{
*ppQueryResult = (IWmiDbIterator *)pNew;
pNew->m_pConn = pConn; // Releasing the iterator will release this guy.
pNew->m_pSession = this;
pNew->m_pConn = pConn;
pNew->m_pToks = pToks;
pNew->m_dwOpenTable = dwOpenTable;
pNew->m_tableid = tableid;
pNew->AddRef();
AddRef();
}
else
{
if (m_pController)
GetSQLCache()->ReleaseConnection(pConn);
hr = WBEM_E_OUT_OF_MEMORY;
}
}
else
{
if (m_pController)
GetSQLCache()->ReleaseConnection(pConn);
hr = WBEM_E_OUT_OF_MEMORY;
}
}
}
}
catch (...)
{
ERRORTRACE((LOG_WBEMCORE, "Fatal error in CWmiDbSession::Enumerate\n"));
hr = WBEM_E_CRITICAL_ERROR;
}
return hr;
}
//***************************************************************************
//
// CWmiDbSession::InsertArray
//
//***************************************************************************
HRESULT CWmiDbSession::InsertArray(CSQLConnection *pConn,IWmiDbHandle *pScope,
SQL_ID dObjectId, SQL_ID dClassId,
DWORD dwPropertyID, VARIANT &vValue, long lFlavor, DWORD dwRefID,
LPCWSTR lpObjectKey , LPCWSTR lpPath , SQL_ID dScope, CIMTYPE ct )
{
HRESULT hr = WBEM_S_NO_ERROR;
IRowset *pIRowset = NULL;
DWORD dwRows = 0;
if (!m_pController ||
((CWmiDbController *)m_pController)->m_dwCurrentStatus == WBEM_E_SHUTTING_DOWN)
return WBEM_E_SHUTTING_DOWN;
if (vValue.vt == VT_UNKNOWN)
{
BYTE *pBuff = NULL;
DWORD dwLen = 0;
IUnknown *pUnk = V_UNKNOWN (&vValue);
if (pUnk)
{
_IWmiObject *pInt = NULL;
hr = pUnk->QueryInterface(IID__IWmiObject, (void **)&pInt);
if (SUCCEEDED(hr))
{
pInt->GetObjectMemory(NULL, 0, &dwLen);
pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> d (pBuff);
DWORD dwLen1;
hr = pInt->GetObjectMemory(pBuff, dwLen, &dwLen1);
if (SUCCEEDED(hr))
{
hr = CSQLExecProcedure::InsertBlobData(pConn, dClassId, dObjectId,
dwPropertyID, pBuff, dwRefID, dwLen);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
pInt->Release();
}
}
}
else if (((vValue.vt & 0xFFF) == VT_UI1) || vValue.vt == VT_BSTR)
{
BYTE *pBuff = NULL;
DWORD dwLen = 0;
// Get the byte buffer out of the safearray.
if ((vValue.vt & 0xFFF) == VT_UI1)
GetByteBuffer(&vValue, &pBuff, dwLen);
else // its a bstr.
{
dwLen = wcslen(vValue.bstrVal)*2+2;
char * pTemp = new char[dwLen+1];
if (pTemp)
{
sprintf(pTemp, "%S", vValue.bstrVal);
pBuff = (unsigned char *)pTemp;
}
else
hr = WBEM_E_OUT_OF_MEMORY;
}
if (pBuff)
{
hr = CSQLExecProcedure::InsertBlobData (pConn, dClassId, dObjectId,
dwPropertyID, pBuff, 0, dwLen);
delete pBuff;
}
}
else
{
bool bIsQfr = FALSE;
DWORD dwFlags = 0;
SQL_ID dClassID = 0;
DWORD dwStorage = 0;
hr = GetSchemaCache()->GetPropertyInfo (dwPropertyID, NULL, &dClassID, &dwStorage,
NULL, &dwFlags);
bIsQfr = (dwFlags & REPDRVR_FLAG_QUALIFIER) ? TRUE : FALSE;
SAFEARRAY* psaArray = NULL;
psaArray = V_ARRAY(&vValue);
if (psaArray)
{
long i = 0;
int iType = vValue.vt & 0xFF;
VARIANT vTemp;
VariantInit(&vTemp);
long lLBound, lUBound;
SafeArrayGetLBound(psaArray, 1, &lLBound);
SafeArrayGetUBound(psaArray, 1, &lUBound);
lUBound -= lLBound;
lUBound += 1;
InsertQfrValues *pQfr = NULL;
int iPos = 0;
pQfr = new InsertPropValues[lUBound];
if (!pQfr)
return WBEM_E_OUT_OF_MEMORY;
ct = ct & 0xFF;
for (i = 0; i < lUBound; i++)
{
if (ct != CIM_OBJECT)
{
if (iType != VT_NULL && iType != VT_EMPTY)
{
hr = GetVariantFromArray(psaArray, i, iType, vTemp);
LPWSTR lpVal = GetStr(vTemp);
CDeleteMe <wchar_t> r1(lpVal);
VariantClear(&vTemp);
if (FAILED(hr))
break;
//if (wcslen(lpVal))
{
pQfr[iPos].iPos = i;
pQfr[iPos].iQfrID = dwRefID;
pQfr[iPos].iPropID = dwPropertyID;
pQfr[iPos].pRefKey = NULL;
pQfr[iPos].bLong = false;
pQfr[iPos].bIndexed = (dwFlags & (REPDRVR_FLAG_KEY + REPDRVR_FLAG_INDEXED)) ? TRUE : FALSE;
pQfr[iPos].iStorageType = dwStorage;
pQfr[iPos].dClassId = dClassID;
pQfr[iPos].iFlavor = lFlavor;
if (ct == CIM_REFERENCE)
{
pQfr[iPos].bIndexed = TRUE; // References are always keys
LPWSTR lpTemp = NULL;
IWbemPath *pPath = NULL;
hr = CoCreateInstance(CLSID_WbemDefPath, 0, CLSCTX_INPROC_SERVER,
IID_IWbemPath, (LPVOID *) &pPath);
CReleaseMe r8 (pPath);
if (SUCCEEDED(hr))
{
if (lpVal)
{
LPWSTR lpStrip = StripQuotes2 (lpVal);
CDeleteMe <wchar_t> d (lpStrip);
pPath->SetText(WBEMPATH_CREATE_ACCEPT_ALL, lpStrip);
hr = NormalizeObjectPathGet(pScope, pPath, &lpTemp, NULL, NULL, NULL, pConn);
CDeleteMe <wchar_t> r1(lpTemp);
if (SUCCEEDED(hr))
{
LPWSTR lpTemp2 = NULL;
lpTemp2 = GetKeyString(lpStrip);
CDeleteMe <wchar_t> d (lpTemp2);
pQfr[iPos].pRefKey = new wchar_t [21];
if (pQfr[iPos].pRefKey)
swprintf(pQfr[iPos].pRefKey, L"%I64d", CRC64::GenerateHashValue(lpTemp2));
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
{
hr = WBEM_S_NO_ERROR;
// Strip off the root namespace prefix and generate the
// pseudo-name. We have no way of knowing if they entered this
// path correctly.
LPWSTR lpTemp3 = StripUnresolvedName (lpStrip);
CDeleteMe <wchar_t> d2 (lpTemp3);
LPWSTR lpTemp2 = NULL;
lpTemp2 = GetKeyString(lpTemp3);
CDeleteMe <wchar_t> d (lpTemp2);
pQfr[iPos].pRefKey = new wchar_t [21];
if (lpTemp2 && pQfr[iPos].pRefKey)
swprintf(pQfr[iPos].pRefKey, L"%I64d", CRC64::GenerateHashValue(lpTemp2));
else
hr = WBEM_E_OUT_OF_MEMORY;
}
pQfr[iPos].pValue = new wchar_t[wcslen(lpStrip)+1];
if (pQfr[iPos].pValue)
wcscpy(pQfr[iPos].pValue,lpStrip);
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
pQfr[iPos].pValue = NULL;
}
else
break;
}
else
{
if (lpVal)
{
pQfr[iPos].pValue = new wchar_t[wcslen(lpVal)+1];
if (pQfr[iPos].pValue)
wcscpy(pQfr[iPos].pValue,lpVal);
else
hr = WBEM_E_OUT_OF_MEMORY;
}
else
pQfr[iPos].pValue = NULL;
pQfr[iPos].pRefKey = NULL;
}
iPos++;
}
}
}
else
{
// Can't have default embedded object array values.
if (lpPath)
{
hr = GetVariantFromArray(psaArray, i, iType, vTemp);
IUnknown *pTemp = V_UNKNOWN(&vTemp);
if (pTemp)
{
BYTE *pBuff = NULL;
DWORD dwLen;
_IWmiObject *pInt = NULL;
hr = pTemp->QueryInterface(IID__IWmiObject, (void **)&pInt);
if (SUCCEEDED(hr))
{
pInt->GetObjectMemory(NULL, 0, &dwLen);
pBuff = new BYTE [dwLen];
if (pBuff)
{
CDeleteMe <BYTE> d (pBuff);
DWORD dwLen1;
hr = pInt->GetObjectMemory(pBuff, dwLen, &dwLen1);
if (SUCCEEDED(hr))
{
hr = CSQLExecProcedure::InsertBlobData(pConn, dClassId, dObjectId,
dwPropertyID, pBuff, i, dwLen);
}
}
else
hr = WBEM_E_OUT_OF_MEMORY;
pInt->Release();
}
else
break;
}
}
}
}
if (SUCCEEDED(hr))
hr = CSQLExecProcedure::InsertBatch (pConn, dObjectId, 0, 0, pQfr, iPos);
// Finally clean up the upper array bounds
// (if this array used to be bigger...)
// ====================================
if (SUCCEEDED(hr))
{
CLASSDATA cd;
IDs ids;
hr = GetFirst_ClassData(pConn, dObjectId, cd, dwPropertyID);
while (SUCCEEDED(hr))
{
if (dwPropertyID == cd.iPropertyId &&
dwRefID == cd.iQfrPos &&
cd.iArrayPos >= i)
{
ids.push_back (cd.iArrayPos);
}
hr = GetNext_ClassData(pConn, cd);
if (dObjectId != cd.dObjectId)
{
cd.Clear();
break;
}
}
hr = WBEM_S_NO_ERROR;
for (i = 0; i < ids.size(); i++)
hr = DeleteClassData(pConn, dwPropertyID, dObjectId, ids.at(i));
}
delete pQfr;
}
}
return hr;
}
HRESULT CWmiDbSession::CustomGetObject(IWmiDbHandle *pScope, IWbemPath *pPath, LPWSTR lpObjectKey,
DWORD dwFlags, DWORD dwRequestedHandleType, IWmiDbHandle **ppResult)
{return E_NOTIMPL;}
HRESULT CWmiDbSession::CustomGetMapping(CSQLConnection *pConn, IWmiDbHandle *pScope, LPWSTR lpClassName, IWbemClassObject **ppMapping)
{return E_NOTIMPL;}
HRESULT CWmiDbSession::CustomCreateMapping(CSQLConnection *pConn, LPWSTR lpClassName, IWbemClassObject *pClassObj, IWmiDbHandle *pScope)
{return E_NOTIMPL;}
HRESULT CWmiDbSession::CustomPutInstance(CSQLConnection *pConn, IWmiDbHandle *pScope, SQL_ID dClassId,
DWORD dwFlags, IWbemClassObject **ppObjToPut, LPWSTR lpClassName)
{return E_NOTIMPL;}
HRESULT CWmiDbSession::CustomFormatSQL(IWmiDbHandle *pScope, IWbemQuery *pQuery, _bstr_t &sSQL, SQL_ID *dClassId,
MappedProperties **ppMapping, DWORD *dwNumProps, BOOL *bCount)
{return E_NOTIMPL;}
HRESULT CWmiDbSession::CustomDelete(CSQLConnection *pConn, IWmiDbHandle *pScope, IWmiDbHandle *pHandle, LPWSTR lpClassName)
{return E_NOTIMPL;}
Reference in New Issue View Git Blame Copy Permalink