windows-xp/Source/XPSP1/NT/ds/adsi/ldap/cumisrch.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 2000.
//
//  File:       umisrch.cxx
//
//  Contents: This object wraps an IDirectorySearch and returns Umi objects
//          as a result of the search. The Umi objects returned are
//          pre-populated with the attributes received from the search.
//          This object is used by the cursor object to support the
//          IUmiCursor interface.
//            This file also contains the CQueryStack helper class that is
//          used by the SearcHelper to parse SQL queries.
//
//  History:    03-20-00    AjayR  Created.
//
//----------------------------------------------------------------------------
#include "ldap.hxx"

//
// Helper functions.
//

//+---------------------------------------------------------------------------
// Function:   HelperGetAttributeList - helper routine.
//
// Synopsis:   Gets a list of attributes that can be used in an execute
//          search call from the wbem query information.
//
// Arguments:  pdwAttribCount    -   Returns the number of attributes.
//                                 -1 means all attributes.
//             pppszAttribArray  -   Return value for string array.
//             ulListSize        -   Size of list of wbem names.
//             pWbemNames        -   The list of parsed tokens.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   pdwAttribCount to correct value and pppszAttribArray to 
//          array of strings containing the attribute list.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetAttributeList(
    PDWORD pdwAttribCount,
    LPWSTR ** pppszAttribArray,
    ULONG ulListSize,
    SWbemQueryQualifiedName **pWbemNames
    )
{
    HRESULT hr = S_OK;
    DWORD dwCtr = 0;
    SWbemQueryQualifiedName *pName = NULL;
    LPWSTR pszTmpString = NULL;

    //
    // There should at least be a * in the list.
    //
    ADsAssert(pWbemNames);

    *pppszAttribArray = NULL;
    *pdwAttribCount = (DWORD) -1;

    //
    // If the count is just one we need to see if this is just *.
    //
    if (ulListSize == 1) {
        pName = pWbemNames[0];
        if (pName->m_ppszNameList
            && pName->m_ppszNameList[0]
            ) {
            if (_wcsicmp(pName->m_ppszNameList[0], L"*")) {
                //
                // We need to retun NULL and -1 for count.
                //
                RRETURN(hr);
            }
        }
        else {
            //
            // This has to be a bad query cause either 
            // 1) the name list was empty - cannot have empty from clause,
            // 2) the name list had an empty string in it, or
            //
            BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED_QUERY ???
        }
    }
    
    //
    // At this point we have a valid attribute list.
    //
    *pppszAttribArray = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * ulListSize);
    if (!*pppszAttribArray) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    for (dwCtr = 0; dwCtr < ulListSize; dwCtr++) {
        pszTmpString = NULL;
        pName = pWbemNames[dwCtr];
        
        if (!pName || !pName->m_ppszNameList) {
            BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_BAD_QUERY ???
        }
        
        // 
        // ADSI does not expect more than one entry in each of the pName's.
        // so if some did user.Description then we just treat this as 
        // as description by using the last value always.
        //
        pszTmpString = AllocADsStr(
            pName->m_ppszNameList[pName->m_uNameListSize-1]
            );

        if (!pszTmpString) {
            BAIL_ON_FAILURE(hr = E_FAIL);
        }
        (*pppszAttribArray)[dwCtr] = pszTmpString;
    }

    *pdwAttribCount = ulListSize;

error:

    if (FAILED(hr)) {
        if (*pppszAttribArray) {
            for (dwCtr = 0; dwCtr < ulListSize; dwCtr++) {
                pszTmpString = (*pppszAttribArray)[dwCtr];
                if (pszTmpString) {
                    FreeADsStr(pszTmpString);
                }
            }
            FreeADsMem(*pppszAttribArray);
            *pppszAttribArray = NULL;
        }
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   HelperGetFromList - helper routine.
//
// Synopsis:   Get a filter that represents the from list. For now this
//          will only return NULL. However we will need to spruce this fn
//          if we need to support a list of classes in here.
//
// Arguments:  ppszFromFilter    -   Return value for a filter corresponding
//                                to the From list.
//             pQuery            -   Wbem query object.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   *ppszFromFilter if From list is valid.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetFromList(
    LPWSTR *ppszFromFilter,
    SWbemRpnEncodedQuery *pQuery
    )
{
    HRESULT hr = E_FAIL;
    LPWSTR pszFilter = NULL;


    *ppszFromFilter = NULL;

    if (pQuery->m_uFromTargetType & WMIQ_RPN_FROM_PATH) {
        //
        // This can only be . for now.
        //
        if (!_wcsicmp(L".", pQuery->m_pszOptionalFromPath)) {
            //
            // We are ok as long as there are no other pieces.
            //
            RRETURN(S_OK);
        } 
        else {
            RRETURN(E_FAIL); // UMI_E_NOT_SUPPORTED ???
        }
    }

    //
    // For now we are going to ignore pieces if there are any other
    // pieces in the from clause.
    //
    if (pQuery->m_uFromTargetType & WMIQ_RPN_FROM_UNARY) {
        // hr = E_FAIL; UMI_E_NOT_SUPPORTED.
        hr = S_OK;
    }
    else if (pQuery->m_uFromTargetType & WMIQ_RPN_FROM_CLASS_LIST) {
        // hr = E_FAIL; UMI_E_NOT_SUPPORTED.
        //for (unsigned u = 0; u < pQuery->m_uFromListSize; u++)
        //{
        // printf("  Selected class = %S\n", pQuery->m_ppszFromList[u]);
        //}
        hr = S_OK;
    }
    else {
        //
        // The query does not have anything in the from clause.
        // This is an invalid query.
        //
        hr = E_FAIL; // UMI_E_NOT_SUPPORTED ???
    }

    RRETURN(hr);
}
 
//+---------------------------------------------------------------------------
// Function:   HelperGetSubExpressionFromOperands - helper routine.
//
// Synopsis:   Updates the result with the operands and the operator. This
//          routine munges the operators/operands around so that we can
//          support operands not supported by ldap directly.
//
// Arguments:  pszResult      -   Return value, allocated by caller.
//             pszOperand1    -   The attribute being tested.
//             pszOperand2    -   The value being tested against.
//             ulOperator     -   Inidcates the comparision type.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   pStack contents.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetSubExpressionFromOperands(
    LPWSTR pszResult,
    LPWSTR pszOperand1,
    LPWSTR pszOperand2,
    ULONG  ulOperator
    )
{
    HRESULT hr = S_OK;

    //
    // In all cases we will need to begin with "(".
    //
    wsprintf(pszResult, L"(");

    //
    // All these are easy to handle.
    //
    if ((ulOperator == WMIQ_RPN_OP_EQ)
        || (ulOperator == WMIQ_RPN_OP_LT)
        || (ulOperator == WMIQ_RPN_OP_GT)
        ) {
        wcscat(pszResult, pszOperand1);
    }

    switch (ulOperator) {
    
    case WMIQ_RPN_OP_EQ :
        wcscat(pszResult, L"=");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L")");
        break;

    case WMIQ_RPN_OP_LT :
        wcscat(pszResult, L"<");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L")");
        break;

    case WMIQ_RPN_OP_GT :
        wcscat(pszResult, L">");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L")");
        break;

    //
    // All these need some processing as ldap does not 
    // handle these directly.
    //
    case WMIQ_RPN_OP_NE :
        //
        // This needs to be (!(operand1=operand2)) so a != b becomes
        // (!(a=b))
        //
        wcscat(pszResult, L"!");
        wcscat(pszResult, L"(");
        wcscat(pszResult, pszOperand1);
        wcscat(pszResult, L"=");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L"))");
        break;

    case WMIQ_RPN_OP_GE :
        //
        // a >= b becomes (!(a<b))
        //
        wcscat(pszResult, L"!(");
        wcscat(pszResult, pszOperand1);
        wcscat(pszResult, L"<");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L"))");
        break;

    case WMIQ_RPN_OP_LE :
        //
        // a <= b becomes (!(a>b))
        //
        wcscat(pszResult, L"!(");
        wcscat(pszResult, pszOperand1);
        wcscat(pszResult, L">");
        wcscat(pszResult, pszOperand2);
        wcscat(pszResult, L"))");
        break;

    default:
        hr = E_FAIL; // UMI_E_UNSUPPORTED_QUERY.
        break;
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   HelperProcessOperator - helper routine.
//
// Synopsis:   Pops 2 elements from the stack, applies the operator on them
//          and pushes the effective expression on to the stack.
//
// Arguments:  pStack        -   Valid stack which should have at least 2
//                             elements in the stack.
//             ulOperatorType-   Operator type corresponding to wbem enum.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   pStack contents.
//
//----------------------------------------------------------------------------
HRESULT
HelperProcessSubExpression(
    CQueryStack *pStack,
    SWbemRpnQueryToken *pExpression
    )
{
    HRESULT hr = S_OK;
    LPWSTR pszOperand1 = NULL;
    LPWSTR pszOperand2 = NULL;
    LPWSTR pszResult = NULL;
    ULONG ulShape = pExpression->m_uSubexpressionShape;
    DWORD dwTotalLen = 0;

    ADsAssert(pStack);

    //
    // As per what is supported we should not have a function.
    // However the query parses seems to always report functions so we
    // will ignore.
    //
    if (ulShape & WMIQ_RPN_LEFT_PROPERTY_NAME) {
        SWbemQueryQualifiedName *pName = pExpression->m_pLeftIdent;
        //
        // The identifier could be x.y.z in which case ADSI is only
        // interested in z
        //
        if (pName->m_ppszNameList[pName->m_uNameListSize-1]) {
            //
            // Alloc the name itself if the operand1 is not __CLASS.
            // If it is __CLASS we need to substitute with objectClass.
            //
            if (!_wcsicmp(
                     pName->m_ppszNameList[pName->m_uNameListSize-1],
                     L"__CLASS"
                     )
                ) {
                pszOperand1 = AllocADsStr(L"objectClass");
            } 
            else {
                //
                // Alloc whatever was passed in.
                //
                pszOperand1 = AllocADsStr(
                    pName->m_ppszNameList[pName->m_uNameListSize-1]
                    );
            }
            if (!pszOperand1) {
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            }
        } 
        else {
            //
            // Something really wrong.
            //
            BAIL_ON_FAILURE(hr = E_FAIL);
        }
    } 
    else {
        //
        // We cannot handle this as there is no identifier on LHS.
        //
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    //
    // We should have the operand by now, need the value
    //
    switch (pExpression->m_uConstApparentType) {
    case VT_I4:
    case VT_UI4:
        //
        // We cannot possibly have more than 20 chars.
        //
        pszOperand2 = (LPWSTR) AllocADsMem(20 * sizeof(WCHAR));
        if (!pszOperand2) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
        if (pExpression->m_uConstApparentType == VT_I4) {
            _ltot(pExpression->m_Const.m_lLongVal, pszOperand2, 10 );
        }
        else {
            _ltot(pExpression->m_Const.m_uLongVal, pszOperand2, 10);
        }
        break;

    case VT_BOOL:
        //
        // Again 20 sounds good !
        //
        pszOperand2 = (LPWSTR) AllocADsMem(20 * sizeof(WCHAR));
        if (!pszOperand2) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }

        if (pExpression->m_Const.m_bBoolVal )
            wcscpy(pszOperand2, L"TRUE");
        else
            wcscpy(pszOperand2, L"FALSE");
        break;

    case VT_LPWSTR:
        pszOperand2 = AllocADsStr(pExpression->m_Const.m_pszStrVal);
        if (!pszOperand2) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
        break;

    default:
        BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED.
        break;
    }

    //
    // At this point we can combine the 2 operands and operator.
    // Total size is size of strings + () + 2 for operator + 1 for \0.
    // Total additions = 5. This is for most cases.
    //
    dwTotalLen = wcslen(pszOperand1) + wcslen(pszOperand2) + 5;

    //
    // Operators <= >= and != need to be processed to be usable in ldap.
    // In these cases, we assume that twice the length is needed.
    //
    dwTotalLen *= 2;

    pszResult = (LPWSTR) AllocADsMem(dwTotalLen * sizeof(WCHAR));
    if (!pszResult) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    hr = HelperGetSubExpressionFromOperands(
             pszResult,
             pszOperand1,
             pszOperand2,
             pExpression->m_uOperator
             );

    /*
    wsprintf(pszResult, L"(");
    wcscat(pszResult, pszOperand1);
    
    //
    // Need to add the opearator now.
    //
    switch (pExpression->m_uOperator) {

    case WMIQ_RPN_OP_EQ :
        wcscat(pszResult,L"=");
        break;

    case WMIQ_RPN_OP_NE :
        wcscat(pszResult, L"!=");
        break;

    case WMIQ_RPN_OP_GE :
        wcscat(pszResult, L">=");
        break;

    case WMIQ_RPN_OP_LE :
        wcscat(pszResult, L"<=");
        break;

    case WMIQ_RPN_OP_LT :
        wcscat(pszResult, L"<");
        break;

    case WMIQ_RPN_OP_GT :
        wcscat(pszResult, L">");
        break;

        
    case WMIQ_RPN_OP_UNDEFINED:
    case WMIQ_RPN_OP_LIKE :
    case WMIQ_RPN_OP_ISA  :
    case WMIQ_RPN_OP_ISNOTA  :
    default :
        //
        // All these mean we have a bad query.
        //
        BAIL_ON_FAILURE(hr = E_FAIL);
        break;
    }

    //
    // Now tag on operand2 and the closing ), and push result onto stack.
    //
    wcscat(pszResult, pszOperand2);
    wcscat(pszResult, L")");
    */

    hr = pStack->Push(pszResult, QUERY_STACK_ITEM_LITERAL);
    BAIL_ON_FAILURE(hr);
error:

    if (pszOperand1) {
        FreeADsStr(pszOperand1);
    }

    if (pszOperand2) {
        FreeADsStr(pszOperand2);
    }

    if (pszResult) {
        FreeADsStr(pszResult);
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   HelperProcessOperator - helper routine.
//
// Synopsis:   Pops 2 elements from the stack, applies the operator on them
//          and pushes the effective expression on to the stack.
//
// Arguments:  pStack        -   Valid stack which should have at least 2
//                             elements in the stack.
//             ulOperatorType-   Operator type corresponding to wbem enum.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   pStack contents.
//
//----------------------------------------------------------------------------
HRESULT
HelperProcessOperator(
    CQueryStack *pStack,
    ULONG ulOperatorType
    )
{
    HRESULT hr;
    LPWSTR pszStr1 = NULL;
    LPWSTR pszStr2 = NULL;
    LPWSTR pszResult = NULL;
    DWORD dwNodeType;
    DWORD dwTotalLen = 0;

    ADsAssert(pStack);

    hr = pStack->Pop(
             &pszStr1,
             &dwNodeType
             );
    BAIL_ON_FAILURE(hr);

    //
    // String has to be valid and the node cannot be an operator.
    //
    if (!pszStr1 || !*pszStr1
        || (dwNodeType != QUERY_STACK_ITEM_LITERAL) 
        ) {
        BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED_QUERY
    }

    dwTotalLen += wcslen(pszStr1);
    
    //
    // Not has only one operand.
    //
    if (ulOperatorType != WMIQ_RPN_TOKEN_NOT) {
        hr = pStack->Pop(
                 &pszStr2,
                 &dwNodeType
                 );
        BAIL_ON_FAILURE(hr);

        //
        // Sanity check.
        //
        if (!pszStr2 || !*pszStr2 
            || (dwNodeType != QUERY_STACK_ITEM_LITERAL)
            ) {
            BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED_QUERY
        }
        //
        // Need to add string2's length.
        //
        dwTotalLen += wcslen(pszStr2);
    }

    //
    // The resultant node needs to hold both strings and the operator
    // and the additional set of parentheses.
    // 4 = operator + () and one for \0.
    //
    dwTotalLen += 4;
    
    pszResult = (LPWSTR) AllocADsMem(dwTotalLen * sizeof(WCHAR));
    if (!pszResult) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    wsprintf(pszResult, L"(");
    switch (ulOperatorType) {
    
    case WMIQ_RPN_TOKEN_AND :
        wcscat(pszResult, L"&");
        break;

    case WMIQ_RPN_TOKEN_OR :
        wcscat(pszResult, L"|");
        break;

    case WMIQ_RPN_TOKEN_NOT :
        wcscat(pszResult, L"!");
        break;

    default:
        BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED.
    }

    //
    // At this point we need to tag on both the pre composed pieces
    // and the final closing parentheses.
    //
    wcscat(pszResult, pszStr1);
    
    //
    // Do not Tag on the second string only if operator is NOT.
    //
    if (ulOperatorType != WMIQ_RPN_TOKEN_NOT) {
        wcscat(pszResult, pszStr2);
    }

    wcscat(pszResult, L")");

    //
    // Need to push the result on to the stack as a literal.
    //
    hr = pStack->Push(
             pszResult,
             QUERY_STACK_ITEM_LITERAL
             );
    BAIL_ON_FAILURE(hr);

error:

    if (pszStr1) {
        FreeADsStr(pszStr1);
    }

    if (pszStr2) {
        FreeADsStr(pszStr2);
    }

    if (pszResult) {
        FreeADsStr(pszResult);
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   HelperGetFilterFromWhereClause - helper routine.
//
// Synopsis:   Returns a filter corresponding to the elements specified in
//          the where clause.
//
// Arguments:  ppszFilter    -   Return value for a filter corresponding
//                             to the Where clause.
//             ulCount       -   Number of elements in the where clause.
//             pWhere        -   Pointer to the Wbem where clause.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   *ppszFilter if Where clause is valid.
//
//----------------------------------------------------------------------------
HRESULT
HelperGetFilterFromWhereClause(
    LPWSTR *ppszFilter,
    ULONG ulCount,
    SWbemRpnQueryToken **pWhere
    )
{
    HRESULT hr = S_OK;
    DWORD dwCtr;
    CQueryStack *pStack = NULL;
    LPWSTR pszFilter = NULL;
    DWORD dwType;

    *ppszFilter = NULL;

    if (!ulCount) {
        //
        // In this case we will default to NULL.
        //
        RRETURN(hr);
    }

    pStack = new CQueryStack();
    if (!pStack) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    //
    // Process the tokens in the where clause.
    //
    for (dwCtr = 0; dwCtr < ulCount; dwCtr++) {
        SWbemRpnQueryToken *pToken = pWhere[dwCtr];

        switch (pToken->m_uTokenType) {
            //
            // All these are operations.
            //
        case WMIQ_RPN_TOKEN_AND :
        case WMIQ_RPN_TOKEN_OR :
        case WMIQ_RPN_TOKEN_NOT :
            HelperProcessOperator(pStack, pToken->m_uTokenType);
            break;

        case WMIQ_RPN_TOKEN_EXPRESSION :
            HelperProcessSubExpression(pStack, pToken);
            break;

        default:
            //
            // We cannot handle the query.
            //
            hr = E_FAIL; // UMI_E_UNSUPPORTED_QUERY.
            break;
        }
        BAIL_ON_FAILURE(hr);
    }

    //
    // At this stack should have one element and that should be
    // the filter we use if things went right.
    //
    hr = pStack->Pop(
             &pszFilter,
             &dwType
             );
    BAIL_ON_FAILURE(hr);

    if (!pStack->IsEmpty()) {
        BAIL_ON_FAILURE(hr = E_FAIL); // UMI_E_UNSUPPORTED_QUERY
    }

    *ppszFilter = pszFilter;

error:

    if (pStack) {
        delete pStack;
    }

    if (FAILED(hr) && pszFilter) {
        FreeADsStr(pszFilter);
    }

    RRETURN(hr);
}

HRESULT
HelperGetSortKey(
    SWbemRpnEncodedQuery *pRpn,
    PADS_SORTKEY * ppADsSortKey
    )
{
    HRESULT hr = S_OK;
    PADS_SORTKEY pSortKey = NULL;

    if (!pRpn->m_uOrderByListSize) {
        RRETURN(S_OK);
    }
    //
    // Allocate the sort key.
    //
    pSortKey = (PADS_SORTKEY) AllocADsMem(sizeof(ADS_SORTKEY));
    if (!pSortKey) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    pSortKey->pszAttrType = AllocADsStr(pRpn->m_ppszOrderByList[0]);
    if (!pSortKey->pszAttrType) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    if (pRpn->m_uOrderDirectionEl[0]) {
        pSortKey->fReverseorder = TRUE;
    }

    RRETURN(S_OK);
error:

    if (pSortKey) {
        if (pSortKey->pszAttrType) {
            FreeADsStr(pSortKey->pszAttrType);
        }
        FreeADsMem(pSortKey);
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::CUmiSearchHelper --- Constructor.
//
// Synopsis:   Standard constructor.
//
// Arguments:  N/A.
//
// Returns:    N/A.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
CUmiSearchHelper::CUmiSearchHelper():
    _hSearchHandle(NULL),
    _pConnection(NULL),
    _pContainer(NULL),
    _pszADsPath(NULL),
    _pszLdapServer(NULL),
    _pszLdapDn(NULL),
    _pIID(NULL),
    _fSearchExecuted(FALSE),
    _fResetAllowed(TRUE)
{
    //
    // This is global scope helper routine that will not fail.
    // The boolean is the value for cache results.
    //
    LdapInitializeSearchPreferences(&_searchPrefs, FALSE);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::~CUmiSearchHelper --- Destructor.
//
// Synopsis:   Standard destructor.
//
// Arguments:  N/A.
//
// Returns:    N/A.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
CUmiSearchHelper::~CUmiSearchHelper()
{
    if (_hSearchHandle) {
        ADsCloseSearchHandle(_hSearchHandle);
    }

    if (_pConnection) {
        _pConnection->Release();
    }

    if (_pContainer) {
        _pContainer->Release();
    }

    if (_pQuery) {
        _pQuery->Release();
    }

    if (_pszADsPath) {
        FreeADsStr(_pszADsPath);
    }

    if (_pszLdapServer) {
        FreeADsStr(_pszLdapServer);
    }

    if (_pszLdapDn) {
        FreeADsStr(_pszLdapDn);
    }

    if (_pCreds) {
        delete _pCreds;
    }

}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::CreateSearchHelper --- STATIC constructor.
//
// Synopsis:   Static constructor.
//
// Arguments:  pUmiQuery     -  Pointer to query object that.
//             pConnection   -  Connection to execute query on.
//             pUnk          -  Container on which the query is executed.
//             pSrchObj      -  New object is returned in this param.
//
// Returns:    N/A.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::CreateSearchHelper(
    IUmiQuery *pUmiQuery,
    IUmiConnection *pConnection,
    IUnknown *pUnk,
    LPCWSTR pszADsPath,
    LPCWSTR pszLdapServer,
    LPCWSTR pszLdapDn,
    CCredentials cCredentials,
    DWORD dwPort,
    CUmiSearchHelper FAR* FAR * ppSrchObj
    )
{
    HRESULT hr = S_OK;
    CUmiSearchHelper FAR * pSearchHelper = NULL;
    
    //
    // Asserts are good enough as this is an internal routine.
    //
    ADsAssert(ppSrchObj);
    ADsAssert(pUmiQuery && pConnection && pUnk);

    pSearchHelper = new CUmiSearchHelper();
    if (!pSearchHelper) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    pSearchHelper->_pszADsPath = AllocADsStr(pszADsPath);
    if (!pSearchHelper->_pszADsPath) {
        BAIL_ON_FAILURE(hr);
    }

    //
    // pszLdapDn can be null
    //
    if (pszLdapDn) {
        pSearchHelper->_pszLdapDn = AllocADsStr(pszLdapDn);
        if (!pSearchHelper->_pszLdapDn) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
    }
    
    //
    // the server can also be null.
    //
    if (pszLdapServer) {
        pSearchHelper->_pszLdapServer = AllocADsStr(pszLdapServer);
        if (!pSearchHelper->_pszLdapServer) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
    }

    pSearchHelper->_pCreds = new CCredentials(cCredentials);
    if (!pSearchHelper->_pCreds) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    pSearchHelper->_pConnection = pConnection;
    pConnection->AddRef();

    pSearchHelper->_pQuery = pUmiQuery;
    pUmiQuery->AddRef();

    pSearchHelper->_pContainer = pUnk;
    pUnk->AddRef();

    pSearchHelper->_dwPort = dwPort;

    *ppSrchObj = (CUmiSearchHelper FAR *)pSearchHelper;
    RRETURN(hr);

error :

    delete pSearchHelper;
    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::SetIID
//
// Synopsis:   Sets the IID requested on the returned objects.
//
// Arguments:  riid    -    The iid requested.
//
// Returns:    S_OK or any appropriate error code.
//
// Modifies:   _pIID the internal IID pointer.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::SetIID(REFIID riid)
{
    if (_pIID) {
        FreeADsMem(_pIID);
    }

    _pIID = (IID *) AllocADsMem(sizeof(IID));

    if (!_pIID) {
        RRETURN(E_OUTOFMEMORY);
    }

    memcpy(_pIID, &riid, sizeof(IID));

    RRETURN(S_OK);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::Reset
//
// Synopsis:   Not implemented.
//
// Arguments:  None.
//
// Returns:    E_NOTIMPL.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::Reset()
{
    //
    // We can potentially add support for this down the road.
    //
    RRETURN(E_NOTIMPL);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::Next
//
// Synopsis:   Return the next uNumRequested elements from the search.
//
// Arguments:  uNumRequested     -   number of objects/rows to fetch.
//             pNumReturned      -   number of objects/rows returned.
//             pObject           -   array of returned objects.
//
// Returns:    S_OK, S_FALSE or any appropriate error code.
//
// Modifies:   pNumReturned, pObjects and internal search handle state.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::Next(
    ULONG uNumRequested,
    ULONG *puNumReturned,
    LPVOID *ppObjects
    )
{
    HRESULT hr = S_OK;
    IUnknown **pTempUnks = NULL;
    DWORD dwCtr = 0, dwIndex = 0;

    if (!puNumReturned || !ppObjects || (uNumRequested < 1)) {
        BAIL_ON_FAILURE(hr = E_ADS_BAD_PARAMETER);
    }

    if (!_fSearchExecuted) {
        hr = InitializeSearchContext();
        BAIL_ON_FAILURE(hr);
    }

    pTempUnks = (IUnknown **) AllocADsMem(sizeof(IUnknown*) * uNumRequested);
    
    if (!pTempUnks) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    //
    // Get the requested number of objects one at a time until 
    // we hit S_FALSE or an error and then repackage to suitable
    // array as needed.
    //
    while ((dwCtr < uNumRequested) 
           && (hr != S_FALSE) ) {
        IUnknown *pUnk = NULL;
        hr = GetNextObject(&pUnk);
        //
        // This wont catch S_FALSE.
        //
        BAIL_ON_FAILURE(hr);
        
        //
        // Needed as if he get S_FALSE we will set the ptr and
        // increase the count incorrectly.
        //
        if (hr != S_FALSE) {
            pTempUnks[dwCtr] = pUnk;
            dwCtr++;
        }
    }

    //
    // At this point we have all the results we need or can get.
    //
    if (uNumRequested == dwCtr) {
        //
        // We can return tempObjects in this case.
        //
        *ppObjects = (void *)pTempUnks;
    } 
    else {
        //
        // Less than what had been requested.
        //
        IUnknown **pUnkCopy;
        
        pUnkCopy = (IUnknown **) AllocADsMem(sizeof(IUnknown *) * dwCtr);
        if (!pUnkCopy) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }

        for (dwIndex = 0; dwIndex < dwCtr; dwIndex++) {
            //
            // Just need to copy the ptrs over.
            //
            pUnkCopy[dwIndex] = pTempUnks[dwIndex];
        }

        //
        // Only return the number of entries we got back.
        //
        *ppObjects = (void *) pUnkCopy;

        FreeADsMem((void *)pTempUnks);
    }

    //
    // We are error free over here.
    //
    *puNumReturned = dwCtr;
    
    RRETURN(hr);

error:

    if (pTempUnks) {
        //
        // For will be executed only if we have valid count.
        //
        for (dwIndex = 0; dwIndex < dwCtr; dwIndex++) {
            pTempUnks[dwIndex]->Release();
        }

        FreeADsMem(pTempUnks);
    }

    *puNumReturned = 0;

    RRETURN(hr);
}


//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::Previous (E_NOTIMPL)
//
// Synopsis:   Return the previous object in the result set - Not implemented.
//
// Arguments:  uFlags            -   only flag supported is 0.
//             pObj              -   object is returned in this param.
//
// Returns:    S_OK, or any appropriate error code.
//
// Modifies:   Internal search handle state and pObject.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::Previous(
    ULONG uFlags,
    LPVOID *pObj
    )
{
    RRETURN(E_NOTIMPL);
}

//
// Internal/protected routines
//

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::InitializeSearchContext.
//
// Synopsis:   Prepares the internal state of the object. This initializes
//          the search preferences from the query object, leaveing the search
//          helper ready to retrieve results.
//
// Arguments:  None.
//
// Returns:    S_OK, or any appropriate error code.
//
// Modifies:   Internal search preferences and also state search handle.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::InitializeSearchContext()
{
    HRESULT hr = S_OK;
    PUMI_PROPERTY_VALUES pPropVals = NULL;
    IUmiPropList *pPropList = NULL;
    LPWSTR pszFilter = NULL;
    LPWSTR *pszAttrNames = NULL;
    DWORD dwAttrCount = (DWORD) -1;
    ULONG ulLangBufSize = 100 * sizeof(WCHAR);
    ULONG ulQueryBufSize = 1024 * sizeof(WCHAR);
    LPWSTR pszLangBuf = NULL;
    LPWSTR pszQueryText = NULL;
    PADS_SORTKEY pSortKey = NULL;

    //
    // We need to walk through the properties in the query and update
    // our local copy of preferences accordingly.
    //
    if (!_pQuery) {
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    hr = _pQuery->GetInterfacePropList(0, &pPropList);
    BAIL_ON_FAILURE(hr);

    //
    // Need to allocate memory for the buffers.
    //
    pszLangBuf = (LPWSTR) AllocADsMem(ulLangBufSize);
    pszQueryText = (LPWSTR) AllocADsMem(ulQueryBufSize);
    if (!pszLangBuf || !pszQueryText) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }
    //
    // We need to look at the query language if the language is SQL,
    // then we need to go through and convert the SQL settings to
    // properties on the intfPropList of the query.
    //
    hr = _pQuery->GetQuery(
             &ulLangBufSize,
             pszLangBuf,
             &ulQueryBufSize, // Change this before checking in.
             pszQueryText
             );
    if (hr == E_OUTOFMEMORY ) {
        //
        // Means there was insufficient length in the buffers.
        //
        if (ulLangBufSize > (100 * sizeof(WCHAR))) {
            FreeADsStr(pszLangBuf);
            pszLangBuf = (LPWSTR) AllocADsMem(ulLangBufSize + sizeof(WCHAR));
            if (!pszLangBuf) {
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            }
        }

        if (ulQueryBufSize > (1024 * sizeof(WCHAR))) {
            FreeADsStr(pszQueryText);
            pszQueryText = (LPWSTR) AllocADsMem(
                ulQueryBufSize + sizeof(WCHAR)
                );
            if (pszQueryText) {
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            }
        }

        hr = _pQuery->GetQuery(
                 &ulLangBufSize,
                 pszLangBuf,
                 &ulQueryBufSize, // Change this before checking in.
                 pszQueryText
                 );
    }
    BAIL_ON_FAILURE(hr);

    if (*pszLangBuf) {
        if (!_wcsicmp(L"SQL", pszLangBuf)
            || !_wcsicmp(L"WQL", pszLangBuf)
             ) {
            //  
            // This is a sql query and we need to process the query before
            // pulling the options out of the query object.
            //
            hr = ProcessSQLQuery(
                     pszQueryText,
                     &pszFilter,
                     &pSortKey
                     );
            BAIL_ON_FAILURE(hr);

        } 
        else if (!_wcsicmp(L"LDAP", pszLangBuf)) {
            //
            // Neither SQL nor LDAP but the language is set which means
            // we cannot handle this query.
            //
            pszFilter = AllocADsStr(pszQueryText);
            if (!pszFilter) {
                BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
            }
        }
    }

    //
    // At this point we need to go through and pick up all the properties.
    // we know about and update our search preferences accordingly. Each of 
    // these properties has to be set and has to have some valid data.
    //

    //
    // Start with the search scope.
    //
    hr = pPropList->Get(L"__SEARCH_SCOPE", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwSearchScope = 
        pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the synchronous/asynchronous pref.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_ASYNCHRONOUS", 0,  &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidBoolProperty(pPropVals));

    _searchPrefs._fAsynchronous = 
        pPropVals->pPropArray[0].pUmiValue->bValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the deref aliases search pref.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_DEREF_ALIASES", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidBoolProperty(pPropVals));

    _searchPrefs._dwDerefAliases = 
        pPropVals->pPropArray[0].pUmiValue->bValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the size limit.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_SIZE_LIMIT", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwSizeLimit = pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the time limit.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_TIME_LIMIT", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwTimeLimit = pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the attributes only preference.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_ATTRIBTYPES_ONLY", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidBoolProperty(pPropVals));

    _searchPrefs._fAttrsOnly = pPropVals->pPropArray[0].pUmiValue->bValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the search scope again ???
    //
    // __PADS_SEARCHPREF_SEARCH_SCOPE (duplicate for consistency cause it should be for all ideally).
    //

    hr = pPropList->Get(L"__PADS_SEARCHPREF_TIMEOUT", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwTimeLimit = pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // The page size is next.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_PAGESIZE", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwPageSize = pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Get the paged time limit.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_PAGED_TIME_LIMIT", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwPagedTimeLimit = 
        pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Chase referrals comes next.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_CHASE_REFERRALS", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidLongProperty(pPropVals));

    _searchPrefs._dwChaseReferrals = 
        pPropVals->pPropArray[0].pUmiValue->uValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;
    
    //
    // Get the sort preferences ---> more complex do later.
    //
    // __PADS_SEARCHPREF_SORT_ON ---> potential candidate for all providers.
    //

    //
    // Cache results.
    //
    pPropList->Get(L"__PADS_SEARCHPREF_CACHE_RESULTS", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidBoolProperty(pPropVals));

    _searchPrefs._fCacheResults = 
        pPropVals->pPropArray[0].pUmiValue->bValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // DirSync control --- do later.
    // __PADS_SEARCHPREF_DIRSYNC
    //

    //
    // Tombstone preferences.
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_TOMBSTONE", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    BAIL_ON_FAILURE(hr = VerifyValidBoolProperty(pPropVals));

    _searchPrefs._fTombStone = pPropVals->pPropArray[0].pUmiValue->bValue[0];

    pPropList->FreeMemory(0, (void *) pPropVals);
    pPropVals = NULL;

    //
    // Need to get the list of attributes.
    //
    //
    hr = pPropList->Get(L"__PADS_SEARCHPREF_ATTRIBUTES", 0, &pPropVals);
    BAIL_ON_FAILURE(hr);

    //
    // Need to change to check for NULL then set count to -1.
    //
    pszAttrNames = pPropVals->pPropArray[0].pUmiValue->pszStrValue;
    dwAttrCount = pPropVals->pPropArray[0].uCount;

    //
    // Special case to ask for NULL with 0 to get all attributes.
    //
    if (!dwAttrCount && !pszAttrNames) {
        dwAttrCount = (DWORD) -1;
    }
    //
    // Now that we have all the preferences, we can set the search prefs
    // and also execute the search.
    //
    hr = ADsExecuteSearch(
             _searchPrefs,
             _pszADsPath,
             _pszLdapServer,
             _pszLdapDn,
             pszFilter,
             pszAttrNames,
             dwAttrCount,
             & _hSearchHandle
             );
    BAIL_ON_FAILURE(hr);

    _fSearchExecuted = TRUE;

error:

    if (pPropVals) {
        //
        // Guess we need to use the query to free this !
        //
        _pQuery->FreeMemory(0, (void *)pPropVals);
    }
    
    if (pPropList) {
        pPropList->Release();
    }

    if (pszLangBuf) {
        FreeADsStr(pszLangBuf);
    }

    if (pszQueryText) {
        FreeADsStr(pszQueryText);
    }

    if (pSortKey) {
        if (pSortKey->pszAttrType) {
            FreeADsStr(pSortKey->pszAttrType);
        }
        if (pSortKey->pszReserved) {
            FreeADsStr(pSortKey->pszReserved);
        }

        FreeADsMem(pSortKey);
    }

    if (FAILED(hr)) {
        //
        // Should we really be doing this ?
        //
        LdapInitializeSearchPreferences(&_searchPrefs, FALSE);
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::GetNextObject.
//
// Synopsis:   This routine gets the next object in the result set. It calls
//          get next row to get the next row and creates the equivalent
//          cgenobj (need to add code to prepopulate the attributes).
//
// Arguments:  None.
//
// Returns:    S_OK, or any appropriate error code.
//
// Modifies:   Internal search preferences and also state search handle.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::GetNextObject(IUnknown **pUnk)
{
    HRESULT hr = S_OK;
    ADS_SEARCH_COLUMN adsColumn;
    BSTR ADsPath = NULL;
    LPWSTR pszParent = NULL;
    LPWSTR pszCN = NULL;
    PADSLDP ldapHandle = NULL;
    LDAPMessage *pldapMsg = NULL;

    //
    // Zero init the struct to make sure we can free in error path.
    //
    memset(&adsColumn, 0, sizeof(ADS_SEARCH_COLUMN));


    ADsAssert(_fSearchExecuted);

    if (!_hSearchHandle) {
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    //
    // Get the next row.
    //
    hr = ADsGetNextRow(
             _hSearchHandle,
             *_pCreds
             );
    if (hr == S_ADS_NOMORE_ROWS) {
        //
        // Hit end of enumeration.
        //
        *pUnk = NULL;
        RRETURN(S_FALSE);
    } 
    else if (FAILED(hr)) {
        BAIL_ON_FAILURE(hr);
    }

    //
    // Fetch the path and use it to create the object.
    //
    hr = ADsGetColumn(
             _hSearchHandle,
             L"ADsPath",
             *_pCreds,
             _dwPort,
             &adsColumn
             );
    BAIL_ON_FAILURE(hr);

    if (adsColumn.dwADsType != ADSTYPE_CASE_IGNORE_STRING
        || adsColumn.dwNumValues != 1) {
        //
        // Bad type or number of return values, this should never happen.
        //
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    //
    // Get the whole ldap message for the current row, that way we can
    // prepopulate the object. Since we are picking up the actual message,
    // we cannot rely on GetNextColumnName to work properly.
    //
    hr = ADsHelperGetCurrentRowMessage(
             _hSearchHandle,
             &ldapHandle, // need this when getting the actual attributes.
             &pldapMsg
             );
    BAIL_ON_FAILURE(hr);

    //
    //
    // For creating the object, the parent path and the rdn is needed.
    //
    hr = BuildADsParentPath(
             adsColumn.pADsValues[0].CaseIgnoreString,
             &pszParent,
             &pszCN
             );
    BAIL_ON_FAILURE(hr);

    //
    // Maybe we should just get all the values for this row and
    // send into a constructor for the cgenobj ???
    //
    hr = CLDAPGenObject::CreateGenericObject(
             pszParent,
             pszCN,
             *_pCreds,
             ADS_OBJECT_BOUND,
             ldapHandle,
             pldapMsg,
             _pIID ? (*_pIID) : IID_IUmiObject,
             (void **) pUnk
             );

    BAIL_ON_FAILURE(hr);

error:

    if (pszParent) {
        FreeADsStr(pszParent);
    }

    if (pszCN) {
        FreeADsStr(pszCN);
    }

    //
    // Calling this can not harm us.
    //
    ADsFreeColumn(&adsColumn);

    if (FAILED(hr) && *pUnk) {
        (*pUnk)->Release();
    }

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CUmiSearchHelper::ProcessSQLQuery (helper function).
//
// Synopsis:   This routine takes the SQL Query text, parses it using the 
//          wmi query parser and converts the query to preferences on
//          the underlying queryObjects interface proplist.
//
// Arguments:  pszQueryText   -   SQL language query.
//
// Returns:    S_OK, or any appropriate error code.
//
// Modifies:   Search preferences on the underlying query object.
//
//----------------------------------------------------------------------------
HRESULT
CUmiSearchHelper::ProcessSQLQuery(
    LPCWSTR pszQueryText,
    LPWSTR * ppszFilter,
    PADS_SORTKEY *ppADsSortKey
    )
{
    HRESULT hr = S_OK;
    IWbemQuery *pQuery = NULL;
    ULONG ulFeatures[] = {
        WMIQ_LF1_BASIC_SELECT,
        WMIQ_LF2_CLASS_NAME_IN_QUERY,
        WMIQ_LF6_ORDER_BY,
        WMIQ_LF24_UMI_EXTENSIONS
    };
    SWbemRpnEncodedQuery *pRpn = NULL;
    LPWSTR *pszAttribArray = NULL;
    DWORD dwAttribCount = 0;
    LPWSTR pszFromListFilter = NULL;
    LPWSTR pszFilter = NULL;
    IUmiPropList *pIntfPropList = NULL;
    UMI_PROPERTY umiPropAttribs = {
        UMI_TYPE_LPWSTR,
        1,
        UMI_OPERATION_UPDATE,
        L"__PADS_SEARCHPREF_ATTRIBUTES",
        NULL
    };
    //
    // Will likely need to set the attribute list.
    //
    UMI_PROPERTY pOneUmiProp[1];
     
    pOneUmiProp[0] = umiPropAttribs;

    UMI_PROPERTY_VALUES propUmiVals[1];
    propUmiVals[0].uCount = 1;
    propUmiVals[0].pPropArray = pOneUmiProp;

    ADsAssert(ppszFilter);
    *ppszFilter = NULL;

    //
    // Create the WBEM parser object.
    //
    hr = CoCreateInstance(
             CLSID_WbemQuery,
             NULL,
             CLSCTX_INPROC_SERVER,
             IID_IWbemQuery,
             (LPVOID *) &pQuery
             );
    BAIL_ON_FAILURE(hr);

    //
    // Set the query into the parser and try and parse the query.
    //
    hr = pQuery->SetLanguageFeatures(
             0,
             sizeof(ulFeatures)/sizeof(ULONG),
             ulFeatures
             );
    BAIL_ON_FAILURE(hr);

    hr = pQuery->Parse(L"SQL", pszQueryText, 0);
    BAIL_ON_FAILURE(hr);

    hr = pQuery->GetAnalysis(
             WMIQ_ANALYSIS_RPN_SEQUENCE,
             0,
             (LPVOID *) &pRpn
             );
    BAIL_ON_FAILURE(hr);

    if (!pRpn->m_uSelectListSize) {
        //
        // Sanity check to make sure we are selecting something.
        //
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    hr = HelperGetAttributeList(
             &dwAttribCount,
             &pszAttribArray,
             pRpn->m_uSelectListSize,
             pRpn->m_ppSelectList
             );
    BAIL_ON_FAILURE(hr);
    
    //
    // As of now the from list cannot have anything in other than *.
    //
    hr = HelperGetFromList(
             &pszFromListFilter,
             pRpn
             );
    BAIL_ON_FAILURE(hr);

    hr = HelperGetFilterFromWhereClause(
             &pszFilter,
             pRpn->m_uWhereClauseSize,
             pRpn->m_ppRpnWhereClause
             );
    BAIL_ON_FAILURE(hr);

    //
    // See if we have an order by list, in SQL we support only one
    // order by clause.
    //
    if (pRpn->m_uOrderByListSize) {
        hr = HelperGetSortKey(pRpn, ppADsSortKey);
        BAIL_ON_FAILURE(hr);
    }
    //
    // Need to set the attribute list if applicable.
    //
    if ((dwAttribCount != (DWORD) -1)
        && dwAttribCount) {
        //
        // Need to set the property on the interface proplist.
        //
        hr = _pQuery->GetInterfacePropList(
                 0,
                 &pIntfPropList
                 );
        BAIL_ON_FAILURE(hr);

        pOneUmiProp[0].uCount = dwAttribCount;
        pOneUmiProp[0].pUmiValue = (PUMI_VALUE) (LPVOID) pszAttribArray;

        hr = pIntfPropList->Put(
                 L"__PADS_SEARCHPREF_ATTRIBUTES",
                 0,
                 propUmiVals
                 );
        BAIL_ON_FAILURE(hr);

    }
    //
    // Need to return the filter back.
    //
    *ppszFilter = pszFilter;

error:

    if (pQuery) {
        pQuery->Release();
    }

    if (pszFromListFilter) {
        FreeADsStr(pszFromListFilter);
    }
    
    if (pIntfPropList) {
        pIntfPropList->Release();
    }

    //
    // We might need to return this as a param.
    //
    if (FAILED(hr) && pszFilter) {
        FreeADsStr(pszFilter);
    }

    RRETURN(hr);
}

//****************************************************************************
//                      CQueryStack Implementation                           *
//****************************************************************************

//+---------------------------------------------------------------------------
// Function:   CQueryStack::CQueryStack - Constructor.
//
// Synopsis:   Initializes the underlying list to NULL and count to 0.
//
// Arguments:  None.
//
// Returns:    N/A.
//
// Modifies:   All member variables.
//
//----------------------------------------------------------------------------
CQueryStack::CQueryStack():
    _pStackList(NULL),
    _dwElementCount(0)
{
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::~CQueryStack - Destructor.
//
// Synopsis:   Frees the underlying list contents if applicable.
//
// Arguments:  None.
//
// Returns:    N/A.
//
// Modifies:   N/A.
//
//----------------------------------------------------------------------------
CQueryStack::~CQueryStack()
{
    if (_pStackList) {
        STACKLIST *pList = _pStackList;
        STACKLIST *pPrev = NULL;
        //
        // Walk through and free the list.
        //
        while (pList) {
            pPrev = pList;
            pList = pList->pNext;
            //
            // Need to free prev node and its contents.
            //
            CQueryStack::FreeStackEntry(pPrev);
        }
        _pStackList = NULL;
    }
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::Push.
//
// Synopsis:   Pushes the node onto the stack and increases the count. The
//          node is added to the head of the underlying list. 
//
// Arguments:  pszString    -   The string value of the node.
//             dwType       -   The type of the node can either be 
//                           a literal or an operator.
//
// Returns:    S_OK or E_OUTOFMEMORY.
//
// Modifies:   The underlying list.
//
//----------------------------------------------------------------------------
HRESULT
CQueryStack::Push(
    LPWSTR pszString,
    DWORD  dwType
    )
{
    HRESULT hr = S_OK;
    PSTACKLIST pStackEntry = NULL;

    //
    // Allocate the new node.
    //
    hr = CQueryStack::AllocateStackEntry(
             pszString,
             dwType,
             &pStackEntry
             );
    if (FAILED(hr)) {
        BAIL_ON_FAILURE(hr);
    }

    //
    // If the list is not already then it is added to the head.
    //
    if (!this->_pStackList) {
        _pStackList = pStackEntry;
    } 
    else {
        //
        // Add new entry to the head of the list.
        //
        pStackEntry->pNext = _pStackList;
        _pStackList = pStackEntry;
    }

    //
    // Increment count as the add to list was successful.
    //
    _dwElementCount++;

error:

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::Pop.
//
// Synopsis:   Removes node node from the stack and returns the contents. 
//          Node is removed from the head of the underlying list. 
//
// Arguments:  ppszString   -   Return ptr for string value of node.
//             dwType       -   Return ptr for the type of the node.
//
// Returns:    S_OK, E_OUTOFMEMORY or E_FAIL.
//
// Modifies:   The underlying list.
//
//----------------------------------------------------------------------------
HRESULT
CQueryStack::Pop(
    LPWSTR *ppszString,
    DWORD  *pdwType
    )
{
    HRESULT hr = S_OK;
    PSTACKLIST pStackEntry = _pStackList;

    if (!pStackEntry
        || !ppszString
        || !pdwType ) {
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    //
    // Initialize the return values.
    //
    *ppszString = NULL;
    *pdwType = (DWORD) -1;

    if (pStackEntry->pszElement) {
        *ppszString = AllocADsStr(pStackEntry->pszElement);
        if (!*ppszString) {
            BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
        }
        *pdwType = pStackEntry->dwElementType;
    } 
    else {
        //
        // Should never get here.
        //
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    //
    // Need to advance the list to the next node and free the
    // contents of the current node.
    //
    _pStackList = _pStackList->pNext;
    CQueryStack::FreeStackEntry(pStackEntry);

    //
    // Decrement count as the remove from list was successful.
    //
    _dwElementCount--;

error:

    RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::IsEmpty.
//
// Synopsis:   Returns TRUE or FALSE based on the contents of the stack.
//
// Arguments:  N/A.
//
// Returns:    TRUE or FALSE.
//
// Modifies:   N/A
//
//----------------------------------------------------------------------------
BOOL
CQueryStack::IsEmpty()
{
    return (_dwElementCount == 0);
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::AllocateStackEntry - static helper routine.
//
// Synopsis:   Allocates a stack node with the specified contents.
//
// Arguments:  pszString    -   The string value of the node.
//             dwType       -   The type of the node can either be 
//                           a literal or an operator.
//             ppStackEntry -   Return value.
//
// Returns:    S_OK, E_OUTOFMEMORY or E_FAIL.
//
// Modifies:   ppStackEntry.
//
//----------------------------------------------------------------------------
HRESULT
CQueryStack::AllocateStackEntry(
    LPWSTR pszString,
    DWORD  dwType,
    STACKLIST **ppStackEntry
    )
{
    HRESULT hr = S_OK;
    LPWSTR pszTmpString = NULL;

    if (!pszString || !dwType) {
        BAIL_ON_FAILURE(hr = E_FAIL);
    }

    *ppStackEntry = NULL;

    pszTmpString = AllocADsStr(pszString);
    if (!pszString) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    //
    // Allocate the new stack node.
    //
    *ppStackEntry = (PSTACKLIST) AllocADsMem(sizeof(STACKLIST));
    if (!*ppStackEntry) {
        BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
    }

    (*ppStackEntry)->pszElement = pszTmpString;
    (*ppStackEntry)->dwElementType = dwType;
    
error:

   if (FAILED(hr) && pszTmpString) {
       FreeADsStr(pszTmpString);
   }

   RRETURN(hr);
}

//+---------------------------------------------------------------------------
// Function:   CQueryStack::FreeStackEntry - static helper routine.
//
// Synopsis:   Frees contents of the stack node and the node itself.
//
// Arguments:  pStackEntry    -   Pointer to stack node to free.
//
// Returns:    N/A.
//
// Modifies:   pStackEntry and contents.
//
//----------------------------------------------------------------------------
void
CQueryStack::FreeStackEntry(
    PSTACKLIST pStackEntry
    )
{
    if (!pStackEntry) {
        return;
    }

    //
    // Free the string if there is one and then the node.
    //
    if (pStackEntry->pszElement) {
        FreeADsStr(pStackEntry->pszElement);
    }
    FreeADsMem(pStackEntry);

    return;
}