You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1122 lines
19 KiB
1122 lines
19 KiB
//***************************************************************************
|
|
|
|
//
|
|
|
|
// VPQUALS.CPP
|
|
|
|
//
|
|
|
|
// Module: WBEM VIEW PROVIDER
|
|
|
|
//
|
|
|
|
// Purpose: Contains the implementation of qualifier storage classes
|
|
|
|
//
|
|
|
|
// Copyright (c) 1998-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
#include <provexpt.h>
|
|
|
|
#include <malloc.h>
|
|
#include <provcoll.h>
|
|
#include <provtempl.h>
|
|
#include <provmt.h>
|
|
#include <typeinfo.h>
|
|
#include <process.h>
|
|
#include <objbase.h>
|
|
#include <wbemidl.h>
|
|
#include <stdio.h>
|
|
#include <provcont.h>
|
|
#include <provevt.h>
|
|
#include <provthrd.h>
|
|
#include <provlog.h>
|
|
#include <cominit.h>
|
|
|
|
#include <dsgetdc.h>
|
|
#include <lmcons.h>
|
|
|
|
#include <instpath.h>
|
|
#include <genlex.h>
|
|
#include <sql_1.h>
|
|
#include <objpath.h>
|
|
|
|
#include <vpdefs.h>
|
|
#include <vpquals.h>
|
|
#include <vpserv.h>
|
|
#include <vptasks.h>
|
|
|
|
CStringW GetStringFromRPNToken(SQL_LEVEL_1_TOKEN* pRPNToken)
|
|
{
|
|
CStringW ret;
|
|
|
|
if (NULL != pRPNToken->pPropertyName)
|
|
{
|
|
ret = L'(';
|
|
ret += pRPNToken->pPropertyName;
|
|
|
|
switch(pRPNToken->nOperator)
|
|
{
|
|
case SQL_LEVEL_1_TOKEN::OP_EQUAL:
|
|
{
|
|
ret += L'=';
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_NOT_EQUAL:
|
|
{
|
|
ret += L"<>";
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_EQUALorGREATERTHAN:
|
|
{
|
|
ret += L">=";
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_EQUALorLESSTHAN:
|
|
{
|
|
ret += L"<=";
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_LESSTHAN:
|
|
{
|
|
ret += L'<';
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_GREATERTHAN:
|
|
{
|
|
ret += L'>';
|
|
}
|
|
break;
|
|
case SQL_LEVEL_1_TOKEN::OP_LIKE:
|
|
{
|
|
ret += L" like ";
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
|
|
if (!ret.IsEmpty())
|
|
{
|
|
switch (pRPNToken->vConstValue.vt)
|
|
{
|
|
case VT_NULL:
|
|
{
|
|
ret += L"null)";
|
|
}
|
|
break;
|
|
case VT_BSTR:
|
|
{
|
|
if (pRPNToken->bConstIsStrNumeric)
|
|
{
|
|
ret += pRPNToken->vConstValue.bstrVal;
|
|
ret += L')';
|
|
}
|
|
else
|
|
{
|
|
ret += L'\"';
|
|
wchar_t* buff = new wchar_t[(wcslen(pRPNToken->vConstValue.bstrVal)*2) + 1];
|
|
wchar_t* tmp = pRPNToken->vConstValue.bstrVal;
|
|
wchar_t* tmpBuff = buff;
|
|
|
|
while (*tmp != NULL)
|
|
{
|
|
if ((*tmp == L'\\') || (*tmp == L'"'))
|
|
{
|
|
*tmpBuff = L'\\';
|
|
*tmpBuff++;
|
|
}
|
|
|
|
*tmpBuff = *tmp;
|
|
*tmpBuff++;
|
|
*tmp++;
|
|
}
|
|
|
|
*tmpBuff = 0;
|
|
ret += buff;
|
|
delete [] buff;
|
|
ret += L"\")";
|
|
}
|
|
}
|
|
break;
|
|
case VT_BOOL:
|
|
{
|
|
if (pRPNToken->vConstValue.boolVal == VARIANT_TRUE)
|
|
{
|
|
ret += L"TRUE)";
|
|
}
|
|
else
|
|
{
|
|
ret += L"FALSE)";
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case VT_I4:
|
|
{
|
|
WCHAR tmpBuff[20];
|
|
tmpBuff[0] = L'\0';
|
|
|
|
if ( swprintf(tmpBuff, L"%d", pRPNToken->vConstValue.lVal) )
|
|
{
|
|
ret += tmpBuff;
|
|
ret += ')';
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
break;
|
|
case VT_I2:
|
|
{
|
|
WCHAR tmpBuff[20];
|
|
tmpBuff[0] = L'\0';
|
|
|
|
if ( swprintf(tmpBuff, L"%d", (int)pRPNToken->vConstValue.iVal) )
|
|
{
|
|
ret += tmpBuff;
|
|
ret += ')';
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
break;
|
|
case VT_UI1:
|
|
{
|
|
WCHAR tmpBuff[20];
|
|
tmpBuff[0] = L'\0';
|
|
|
|
if ( swprintf(tmpBuff, L"%d", (int)pRPNToken->vConstValue.bVal) )
|
|
{
|
|
ret += tmpBuff;
|
|
ret += ')';
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
break;
|
|
case VT_R4:
|
|
{
|
|
WCHAR tmpBuff[25];
|
|
tmpBuff[0] = L'\0';
|
|
|
|
if ( swprintf(tmpBuff, L"%G", pRPNToken->vConstValue.fltVal) )
|
|
{
|
|
ret += tmpBuff;
|
|
ret += ')';
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
break;
|
|
case VT_R8:
|
|
{
|
|
WCHAR tmpBuff[25];
|
|
tmpBuff[0] = L'\0';
|
|
|
|
if ( swprintf(tmpBuff, L"%lG", pRPNToken->vConstValue.dblVal) )
|
|
{
|
|
ret += tmpBuff;
|
|
ret += ')';
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
ret.Empty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
CStringW GetStringFromRPN(SQL_LEVEL_1_RPN_EXPRESSION* pRPN, DWORD num_extra,
|
|
SQL_LEVEL_1_TOKEN* pExtraTokens, BOOL bAllprops)
|
|
{
|
|
CStringW ret;
|
|
|
|
if (NULL == pRPN)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
if (NULL != pRPN->bsClassName)
|
|
{
|
|
CStringW props;
|
|
|
|
if ((bAllprops) || (0 == pRPN->nNumberOfProperties))
|
|
{
|
|
props = L'*';
|
|
}
|
|
else
|
|
{
|
|
props = pRPN->pbsRequestedPropertyNames[0];
|
|
|
|
for (int x = 1; x < pRPN->nNumberOfProperties; x++)
|
|
{
|
|
props += L", ";
|
|
props += pRPN->pbsRequestedPropertyNames[x];
|
|
}
|
|
|
|
props += L", ";
|
|
props += WBEM_PROPERTY_PATH;
|
|
props += L", ";
|
|
props += WBEM_PROPERTY_SERVER;
|
|
}
|
|
|
|
ret = L"Select ";
|
|
ret += props;
|
|
ret += L" From ";
|
|
ret += pRPN->bsClassName;
|
|
|
|
if ((0 != pRPN->nNumTokens) || (0 != num_extra))
|
|
{
|
|
CStringW whereStr;
|
|
CArray<CStringW, LPCWSTR> exprStack;
|
|
|
|
//not likely to get more than five expressions in a row!
|
|
//if we do, we'll grow the array!
|
|
exprStack.SetSize(0, 5);
|
|
DWORD stack_count = 0;
|
|
|
|
for (int x = 0; x < (pRPN->nNumTokens + num_extra); x++)
|
|
{
|
|
SQL_LEVEL_1_TOKEN* pToken;
|
|
|
|
if (x < pRPN->nNumTokens)
|
|
{
|
|
pToken = &(pRPN->pArrayOfTokens[x]);
|
|
}
|
|
else
|
|
{
|
|
pToken = &(pExtraTokens[x - pRPN->nNumTokens]);
|
|
}
|
|
|
|
if (SQL_LEVEL_1_TOKEN::OP_EXPRESSION == pToken->nTokenType)
|
|
{
|
|
if (whereStr.IsEmpty())
|
|
{
|
|
whereStr = GetStringFromRPNToken(pToken);
|
|
|
|
if (whereStr.IsEmpty())
|
|
{
|
|
ret.Empty();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
exprStack.SetAtGrow(stack_count, GetStringFromRPNToken(pToken));
|
|
|
|
if (exprStack[stack_count].IsEmpty())
|
|
{
|
|
ret.Empty();
|
|
break;
|
|
}
|
|
|
|
stack_count++;
|
|
}
|
|
}
|
|
else if (SQL_LEVEL_1_TOKEN::TOKEN_NOT == pToken->nTokenType)
|
|
{
|
|
CStringW tempStr(L"(Not ");
|
|
|
|
if (stack_count > 0)
|
|
{
|
|
tempStr += exprStack[stack_count-1];
|
|
tempStr += L')';
|
|
exprStack.SetAt(stack_count-1, tempStr);
|
|
}
|
|
else if (!whereStr.IsEmpty())
|
|
{
|
|
tempStr += whereStr;
|
|
tempStr += L')';
|
|
whereStr = tempStr;
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CStringW opStr;
|
|
|
|
if (SQL_LEVEL_1_TOKEN::TOKEN_AND == pToken->nTokenType)
|
|
{
|
|
opStr = L" And ";
|
|
}
|
|
else if (SQL_LEVEL_1_TOKEN::TOKEN_OR == pToken->nTokenType)
|
|
{
|
|
opStr = L" Or ";
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
break;
|
|
}
|
|
|
|
CStringW tempStr(L'(');
|
|
|
|
if (stack_count > 1)
|
|
{
|
|
tempStr += exprStack[stack_count-2];
|
|
tempStr += opStr;
|
|
tempStr += exprStack[stack_count-1];
|
|
tempStr += L')';
|
|
exprStack.SetAt(stack_count-2, tempStr);
|
|
stack_count = stack_count--;
|
|
}
|
|
else if (stack_count == 1)
|
|
{
|
|
tempStr += whereStr;
|
|
tempStr += opStr;
|
|
tempStr += exprStack[0];
|
|
tempStr += L')';
|
|
whereStr = tempStr;
|
|
stack_count = 0;
|
|
}
|
|
else
|
|
{
|
|
ret.Empty();
|
|
whereStr.Empty();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
exprStack.RemoveAll();
|
|
|
|
if (whereStr.IsEmpty() || (stack_count != 0))
|
|
{
|
|
ret.Empty();
|
|
}
|
|
else
|
|
{
|
|
ret += L" Where ";
|
|
ret += whereStr;
|
|
}
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
CSourceQualifierItem::CSourceQualifierItem(wchar_t* qry, IWbemClassObject* obj)
|
|
: m_pClassObj(NULL), m_RPNExpr(NULL)
|
|
{
|
|
m_isValid = FALSE;
|
|
|
|
m_QueryStr = qry;
|
|
|
|
if (NULL != qry)
|
|
{
|
|
CTextLexSource querySource(qry);
|
|
SQL1_Parser sqlParser(&querySource);
|
|
m_isValid = SQL1_Parser::SUCCESS == sqlParser.Parse(&m_RPNExpr);
|
|
}
|
|
|
|
m_pClassObj = obj;
|
|
|
|
if (NULL != m_pClassObj)
|
|
{
|
|
m_pClassObj->AddRef();
|
|
}
|
|
}
|
|
|
|
CSourceQualifierItem::~CSourceQualifierItem()
|
|
{
|
|
if (NULL != m_RPNExpr)
|
|
{
|
|
delete m_RPNExpr;
|
|
}
|
|
|
|
if (NULL != m_pClassObj)
|
|
{
|
|
m_pClassObj->Release();
|
|
}
|
|
}
|
|
|
|
void CSourceQualifierItem::SetClassObject(IWbemClassObject* pObj)
|
|
{
|
|
if (NULL != m_pClassObj)
|
|
{
|
|
m_pClassObj->Release();
|
|
}
|
|
|
|
if (NULL != pObj)
|
|
{
|
|
pObj->AddRef();
|
|
}
|
|
|
|
m_pClassObj = pObj;
|
|
}
|
|
|
|
IWbemClassObject* CSourceQualifierItem::GetClassObject()
|
|
{
|
|
if (NULL != m_pClassObj)
|
|
{
|
|
m_pClassObj->AddRef();
|
|
}
|
|
|
|
return m_pClassObj;
|
|
}
|
|
|
|
BSTR CSourceQualifierItem::GetClassName()
|
|
{
|
|
if (NULL != m_RPNExpr)
|
|
{
|
|
return m_RPNExpr->bsClassName;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CNSpaceQualifierItem::CNSpaceQualifierItem(const wchar_t* ns_path) :
|
|
|
|
m_Valid (FALSE),
|
|
m_ServObjs (NULL),
|
|
m_NSPaths (NULL),
|
|
m_Count (0),
|
|
|
|
m_hrServError ( WBEM_S_NO_ERROR )
|
|
|
|
{
|
|
if (NULL != ns_path)
|
|
{
|
|
Parse(ns_path);
|
|
}
|
|
}
|
|
|
|
CNSpaceQualifierItem::~CNSpaceQualifierItem()
|
|
{
|
|
if (NULL != m_ServObjs)
|
|
{
|
|
for (UINT x = 0; x < m_Count; x++)
|
|
{
|
|
if (NULL != m_ServObjs[x])
|
|
{
|
|
m_ServObjs[x]->Release();
|
|
}
|
|
}
|
|
|
|
delete [] m_ServObjs;
|
|
}
|
|
|
|
if (m_NSPaths != NULL)
|
|
{
|
|
delete [] m_NSPaths;
|
|
}
|
|
}
|
|
|
|
void CNSpaceQualifierItem::Parse(const wchar_t* ns_path)
|
|
{
|
|
wchar_t* buff = _wcsdup(ns_path);
|
|
|
|
if (buff == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
wchar_t* tmp = wcsstr(buff, NS_DELIMIT);
|
|
CFreeBuff _1(buff);
|
|
|
|
if (tmp == NULL)
|
|
{
|
|
m_NSPaths = new CStringW[1];
|
|
m_NSPaths[0] = buff;
|
|
m_NSPaths[0].TrimLeft();
|
|
|
|
if (m_NSPaths[0].IsEmpty())
|
|
{
|
|
delete [] m_NSPaths;
|
|
m_NSPaths = NULL;
|
|
}
|
|
else
|
|
{
|
|
m_Count = 1;
|
|
m_Valid = TRUE;
|
|
m_NSPaths[0].TrimRight();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wchar_t** tmpbuff = (wchar_t**)malloc(MAX_QUERIES*sizeof(wchar_t*));
|
|
|
|
if (tmpbuff == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
CFreeBuff _2(tmpbuff);
|
|
|
|
if (tmp != buff)
|
|
{
|
|
tmpbuff[0] = buff;
|
|
m_Count++;
|
|
}
|
|
|
|
while (TRUE)
|
|
{
|
|
*tmp = L'\0';
|
|
tmp = tmp + 2;
|
|
|
|
if (*tmp != L'\0')
|
|
{
|
|
tmpbuff[m_Count] = tmp;
|
|
tmp = wcsstr(tmpbuff[m_Count], NS_DELIMIT);
|
|
m_Count++;
|
|
|
|
if (tmp == NULL)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if ( (m_Count > 0) && (0 == (m_Count%MAX_QUERIES)) )
|
|
{
|
|
UINT x = _msize(tmpbuff);
|
|
wchar_t** tmp = (wchar_t**)realloc(tmpbuff, x+(MAX_QUERIES*sizeof(wchar_t*)));
|
|
if (tmp == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
tmpbuff = tmp;
|
|
_2.SetBuff(tmpbuff);
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (m_Count > 0)
|
|
{
|
|
m_NSPaths = new CStringW[m_Count];
|
|
|
|
for (UINT x=0; x < m_Count; x++)
|
|
{
|
|
m_NSPaths[x] = tmpbuff[x];
|
|
m_NSPaths[x].TrimLeft();
|
|
|
|
if (m_NSPaths[x].IsEmpty())
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
m_NSPaths[x].TrimRight();
|
|
}
|
|
}
|
|
|
|
if (!m_NSPaths[m_Count-1].IsEmpty())
|
|
{
|
|
m_Valid = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CJoinOnQualifierArray::CJoinOnQualifierArray()
|
|
{
|
|
m_Count = 0;
|
|
m_AClasses = NULL;
|
|
m_AProps = NULL;
|
|
m_BClasses = NULL;
|
|
m_BProps = NULL;
|
|
m_Ops = NULL;
|
|
m_Buff = NULL;
|
|
m_Valid = FALSE;
|
|
m_bDone = NULL;
|
|
}
|
|
|
|
CJoinOnQualifierArray::~CJoinOnQualifierArray()
|
|
{
|
|
if (NULL != m_AClasses)
|
|
{
|
|
free(m_AClasses);
|
|
}
|
|
|
|
if (NULL != m_BClasses)
|
|
{
|
|
free(m_BClasses);
|
|
}
|
|
|
|
if (NULL != m_AProps)
|
|
{
|
|
free(m_AProps);
|
|
}
|
|
|
|
if (NULL != m_BProps)
|
|
{
|
|
free(m_BProps);
|
|
}
|
|
|
|
if (NULL != m_Ops)
|
|
{
|
|
free(m_Ops);
|
|
}
|
|
|
|
if (NULL != m_Buff)
|
|
{
|
|
free(m_Buff);
|
|
}
|
|
|
|
if (NULL != m_bDone)
|
|
{
|
|
delete [] m_bDone;
|
|
}
|
|
|
|
m_AllClasses.RemoveAll();
|
|
}
|
|
|
|
BOOL CJoinOnQualifierArray::Set(const wchar_t* jStr)
|
|
{
|
|
if (NULL != jStr)
|
|
{
|
|
Parse(jStr);
|
|
}
|
|
|
|
return m_Valid;
|
|
}
|
|
|
|
void CJoinOnQualifierArray::Parse(const wchar_t* qualStr)
|
|
{
|
|
m_Buff = _wcsdup(qualStr);
|
|
wchar_t* tmp = m_Buff;
|
|
m_Valid = TRUE;
|
|
|
|
m_AClasses = (wchar_t**)malloc(MAX_QUERIES*sizeof(wchar_t*));
|
|
|
|
if (m_AClasses == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
m_BClasses = (wchar_t**)malloc(MAX_QUERIES*sizeof(wchar_t*));
|
|
|
|
if (m_BClasses == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
m_AProps = (wchar_t**)malloc(MAX_QUERIES*sizeof(wchar_t*));
|
|
|
|
if (m_AProps == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
m_BProps = (wchar_t**)malloc(MAX_QUERIES*sizeof(wchar_t*));
|
|
|
|
if (m_BProps == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
m_Ops = (UINT*)malloc(MAX_QUERIES*sizeof(UINT));
|
|
|
|
if (m_Ops == NULL)
|
|
{
|
|
throw Heap_Exception(Heap_Exception::HEAP_ERROR::E_ALLOCATION_ERROR);
|
|
}
|
|
|
|
while ((tmp != NULL) && (L'\0' != *tmp) && (m_Valid))
|
|
{
|
|
m_AClasses[m_Count] = GetClassStr(tmp);
|
|
|
|
if ((NULL != m_AClasses[m_Count]) && (L'\0' != *(m_AClasses[m_Count])))
|
|
{
|
|
m_AllClasses.SetAt(m_AClasses[m_Count], 0);
|
|
m_AProps[m_Count] = GetPropertyStrAndOperator(tmp, m_Ops[m_Count]);
|
|
|
|
if ((NULL != m_AProps[m_Count]) && (L'\0' != *(m_AProps[m_Count])) && (0 != m_Ops[m_Count]))
|
|
{
|
|
m_BClasses[m_Count] = GetClassStr(tmp);
|
|
|
|
if ((NULL != m_BClasses[m_Count]) && (L'\0' != *(m_BClasses[m_Count])))
|
|
{
|
|
m_AllClasses.SetAt(m_BClasses[m_Count], 0);
|
|
m_BProps[m_Count] = GetPropertyStr(tmp);
|
|
|
|
if ((NULL != m_BProps[m_Count]) && (L'\0' != *(m_BProps[m_Count])) && StripAnd(tmp))
|
|
{
|
|
m_Count++;
|
|
|
|
if ((tmp != NULL) && (L'\0' != *tmp) && (m_Count > 0) && (0 == (m_Count%MAX_QUERIES)) )
|
|
{
|
|
UINT x = _msize(m_AClasses);
|
|
realloc_throw(&m_AClasses, x+(MAX_QUERIES*sizeof(wchar_t*)));
|
|
realloc_throw(&m_BClasses, x+(MAX_QUERIES*sizeof(wchar_t*)));
|
|
realloc_throw(&m_AProps, x+(MAX_QUERIES*sizeof(wchar_t*)));
|
|
realloc_throw(&m_BProps, x+(MAX_QUERIES*sizeof(wchar_t*)));
|
|
x = _msize(m_Ops);
|
|
realloc_throw(&m_Ops, x+(MAX_QUERIES*sizeof(UINT)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
}
|
|
|
|
if (0 == m_Count)
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
|
|
if (!m_Valid)
|
|
{
|
|
if (NULL != m_AClasses)
|
|
{
|
|
free(m_AClasses);
|
|
m_AClasses = NULL;
|
|
}
|
|
|
|
if (NULL != m_BClasses)
|
|
{
|
|
free(m_BClasses);
|
|
m_BClasses = NULL;
|
|
}
|
|
|
|
if (NULL != m_AProps)
|
|
{
|
|
free(m_AProps);
|
|
m_AProps = NULL;
|
|
}
|
|
|
|
if (NULL != m_BProps)
|
|
{
|
|
free(m_BProps);
|
|
m_BProps = NULL;
|
|
}
|
|
|
|
if (NULL != m_Ops)
|
|
{
|
|
free(m_Ops);
|
|
m_Ops = NULL;
|
|
}
|
|
|
|
if (NULL != m_Buff)
|
|
{
|
|
free(m_Buff);
|
|
m_Buff = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_bDone = new BOOL[m_Count];
|
|
memset((void *)m_bDone, 0, sizeof(BOOL)*m_Count);
|
|
}
|
|
}
|
|
|
|
wchar_t* CJoinOnQualifierArray::SkipSpace(wchar_t*& src)
|
|
{
|
|
while (iswspace(*src))
|
|
{
|
|
if (*src != L'\0')
|
|
{
|
|
*src = L'\0';
|
|
src++;
|
|
}
|
|
}
|
|
|
|
return ((*src == L'\0') ? NULL : src);
|
|
}
|
|
|
|
wchar_t* CJoinOnQualifierArray::SkipToSpecial(wchar_t*& src)
|
|
{
|
|
while ((*src != L'.') && (*src != L'=') && (*src != L'!') && (*src != L'<')
|
|
&& !iswspace(*src) && (*src != L'\0'))
|
|
{
|
|
src++;
|
|
}
|
|
|
|
return ((*src == L'\0') ? NULL : src);
|
|
}
|
|
|
|
wchar_t* CJoinOnQualifierArray::GetClassStr(wchar_t*& src)
|
|
{
|
|
wchar_t* ret = SkipSpace(src);
|
|
|
|
if (NULL != ret)
|
|
{
|
|
src = SkipToSpecial(src);
|
|
|
|
if ((NULL != src) && (src != ret) && ((*src == L'.')))
|
|
{
|
|
*src = L'\0';
|
|
src++;
|
|
}
|
|
else
|
|
{
|
|
ret = NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
wchar_t* CJoinOnQualifierArray::GetPropertyStrAndOperator(wchar_t*& src, UINT& op)
|
|
{
|
|
wchar_t* ret = src;
|
|
op = NO_OPERATOR;
|
|
|
|
src = SkipToSpecial(src);
|
|
src = SkipSpace(src);
|
|
|
|
if ((NULL != src) && (src != ret))
|
|
{
|
|
if (*src == L'=')
|
|
{
|
|
*src = L'\0';
|
|
op = EQUALS_OPERATOR;
|
|
src++;
|
|
}
|
|
else if (*src == L'!')
|
|
{
|
|
wchar_t* prev = src;
|
|
src++;
|
|
|
|
if (*src == L'=')
|
|
{
|
|
*prev = L'\0';
|
|
op = NOT_EQUALS_OPERATOR;
|
|
src++;
|
|
}
|
|
else
|
|
{
|
|
ret = NULL;
|
|
}
|
|
}
|
|
else if (*src == L'<')
|
|
{
|
|
wchar_t* prev = src;
|
|
src++;
|
|
|
|
if (*src == L'>')
|
|
{
|
|
*prev = L'\0';
|
|
op = NOT_EQUALS_OPERATOR;
|
|
src++;
|
|
}
|
|
else
|
|
{
|
|
ret = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
wchar_t* CJoinOnQualifierArray::GetPropertyStr(wchar_t*& src)
|
|
{
|
|
wchar_t* ret = src;
|
|
src = SkipToSpecial(src);
|
|
|
|
if (NULL != src)
|
|
{
|
|
if ( (src != ret) && iswspace(*src) )
|
|
{
|
|
if (*src != L'\0')
|
|
{
|
|
*src = L'\0';
|
|
src++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = NULL;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL CJoinOnQualifierArray::StripAnd(wchar_t*& src)
|
|
{
|
|
|
|
if (NULL == src)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
src = SkipSpace(src);
|
|
|
|
if (NULL == src)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if ((*src == L'a') || (*src == L'A'))
|
|
{
|
|
src++;
|
|
|
|
if ((*src == L'n') || (*src == L'N'))
|
|
{
|
|
src++;
|
|
|
|
if ((*src == L'd') || (*src == L'D'))
|
|
{
|
|
src++;
|
|
wchar_t* tmp = src;
|
|
src = SkipSpace(src);
|
|
|
|
if ((NULL != src) && (tmp != src))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CJoinOnQualifierArray::ValidateJoin()
|
|
{
|
|
if (!m_Valid)
|
|
{
|
|
return m_Valid;
|
|
}
|
|
|
|
CMap<CStringW, LPCWSTR, UINT, UINT> validatedClasses;
|
|
CArray<CStringW, LPCWSTR> spareClasses;
|
|
UINT x = 0;
|
|
|
|
if (_wcsicmp(m_AClasses[x], m_BClasses[x]) == 0)
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
else
|
|
{
|
|
validatedClasses.SetAt(m_AClasses[x], 0);
|
|
validatedClasses.SetAt(m_BClasses[x], 0);
|
|
x++;
|
|
}
|
|
|
|
while ((m_Valid) && (x < m_Count))
|
|
{
|
|
if (_wcsicmp(m_AClasses[x], m_BClasses[x]) == 0)
|
|
{
|
|
m_Valid = FALSE;
|
|
}
|
|
else
|
|
{
|
|
UINT val;
|
|
|
|
if (validatedClasses.Lookup(m_AClasses[x], val))
|
|
{
|
|
validatedClasses.SetAt(m_BClasses[x], 0);
|
|
}
|
|
else
|
|
{
|
|
if (validatedClasses.Lookup(m_BClasses[x], val))
|
|
{
|
|
validatedClasses.SetAt(m_AClasses[x], 0);
|
|
}
|
|
else
|
|
{
|
|
spareClasses.Add(m_AClasses[x]);
|
|
spareClasses.Add(m_BClasses[x]);
|
|
}
|
|
}
|
|
}
|
|
|
|
x++;
|
|
}
|
|
|
|
while ( m_Valid && (0 != spareClasses.GetSize()) )
|
|
{
|
|
m_Valid = FALSE;
|
|
|
|
for (int i = 0; i < spareClasses.GetSize(); i++)
|
|
{
|
|
UINT val;
|
|
|
|
if (validatedClasses.Lookup(spareClasses[i], val))
|
|
{
|
|
if (0 == (i%2))
|
|
{
|
|
validatedClasses.SetAt(spareClasses[i+1], 0);
|
|
spareClasses.RemoveAt(i, 2);
|
|
i -= 1;
|
|
}
|
|
else
|
|
{
|
|
validatedClasses.SetAt(spareClasses[i-1], 0);
|
|
spareClasses.RemoveAt(i-1, 2);
|
|
i -= 2;
|
|
}
|
|
|
|
m_Valid = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
spareClasses.RemoveAll();
|
|
validatedClasses.RemoveAll();
|
|
|
|
return m_Valid;
|
|
}
|
|
|
|
|
|
CPropertyQualifierItem::CPropertyQualifierItem(const wchar_t* prop, BOOL bHD, BOOL bKy, CIMTYPE ct, CStringW rfto, BOOL bDt)
|
|
{
|
|
if (NULL != prop)
|
|
{
|
|
m_ViewPropertyName = prop;
|
|
}
|
|
|
|
m_bDirect = bDt;
|
|
m_HiddenDefault = bHD;
|
|
m_bKey = bKy;
|
|
m_CimType = ct;
|
|
m_RefTo = rfto;
|
|
}
|
|
|
|
CPropertyQualifierItem::~CPropertyQualifierItem()
|
|
{
|
|
m_SrcPropertyNames.RemoveAll();
|
|
}
|
|
|