windows-server-2003/ds/security/gina/gpext/appmgmt/cstore/appcont.cxx

//
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 1999
//
//  Author: DebiM
//  Date:   January 97
//  Revision History:
//          Made Changes for reimplementation with adsldpc interfaces.
//          UShaji, Mar 1998
//
//      Class Access Implementation
//
//      This source file contains implementations for IClassAccess
//      interface on CAppContainer object.
//
//      It uses ADs interfaces (over LDAP) to talk to an LDAP
//      provider such as NTDS.
//
//---------------------------------------------------------------------
//

#include "cstore.hxx"

CBindingList BindingCache;

//
// Critical Section for All Global Objects.
//
extern CRITICAL_SECTION ClassStoreBindList;


HRESULT
UsnGet(ADS_ATTR_INFO Attr, CSUSN *pUsn);

long CompareUsn(CSUSN *pUsn1, CSUSN *pUsn2)
{
    return CompareFileTime((FILETIME *)pUsn1, (FILETIME *)pUsn2);
}

void GetExpiredTime( FILETIME* pftCurrentTime, FILETIME* pftExpiredTime )
{
    //
    // Add the cache interval time to determine
    // the time this will expire
    //
    LARGE_INTEGER liTime;

    //
    // First copy the filetime to a large integer so
    // we can perform arithmetic
    //
    liTime.LowPart = pftCurrentTime->dwLowDateTime;
    liTime.HighPart = pftCurrentTime->dwHighDateTime;

    //
    // The compiler can perform 64 bit math -- use this
    // to perform the arithmetic for calculating the
    // time at which cache entries will expire
    //
    liTime.QuadPart += CACHE_PURGE_TIME_FILETIME_INTERVAL;

    //
    // Now copy the information back to the caller's structure
    //
    pftExpiredTime->dwLowDateTime = liTime.LowPart;
    pftExpiredTime->dwHighDateTime = liTime.HighPart;
}

BOOL IsExpired(
    FILETIME* pftCurrentTime,
    FILETIME* pftExpiredTime)
{
 
    SYSTEMTIME SystemTimeCurrent;
    SYSTEMTIME SystemTimeExpiration;
    BOOL       bRetrievedTime;

    bRetrievedTime = FileTimeToSystemTime(
        pftCurrentTime,
        &SystemTimeCurrent);

    bRetrievedTime &= FileTimeToSystemTime(
        pftExpiredTime,
        &SystemTimeExpiration);

    if ( bRetrievedTime )
    {
        CSDBGPrint((
            DM_VERBOSE,
            IDS_CSTORE_CACHE_EXPIRE,
            L"Current Time",
            SystemTimeCurrent.wMonth,
            SystemTimeCurrent.wDay,
            SystemTimeCurrent.wYear,
            SystemTimeCurrent.wHour,
            SystemTimeCurrent.wMinute,
            SystemTimeCurrent.wSecond));

        CSDBGPrint((
            DM_VERBOSE,
            IDS_CSTORE_CACHE_EXPIRE,
            L"Expire Time",
            SystemTimeExpiration.wMonth,
            SystemTimeExpiration.wDay,
            SystemTimeExpiration.wYear,
            SystemTimeExpiration.wHour,
            SystemTimeExpiration.wMinute,
            SystemTimeExpiration.wSecond));
    }

    //
    // Compare the current time to the expiration time
    //
    LONG CompareResult;

    CompareResult = CompareFileTime(
        pftCurrentTime,
        pftExpiredTime);
        
    //
    // If the current time is later than the expired time,
    // then we have expired
    //
    if ( CompareResult > 0 )
    {
        return TRUE;
    }

    return FALSE;
}

//
// CAppContainer implementation
//
CAppContainer::CAppContainer()

{
    m_fOpen = FALSE;

    m_ADsContainer = NULL;
    m_ADsPackageContainer = NULL;

    m_szPackageName = NULL;

    memset (&m_PolicyId, 0, sizeof(GUID));

    m_KnownMissingClsidCache.sz = 0;
    m_KnownMissingClsidCache.start = 0;
    m_KnownMissingClsidCache.end = 0;

    m_uRefs = 1;

    m_szGpoPath = NULL;

    m_pRsopToken = NULL;
}


//
// CAppContainer implementation
//

/*----------------------------------------------------------------------*
CAppContainer Constructor:

  Parameters:
  [in]  szStoreName:    The Class Store Name without 'ADCS:' moniker
  [out] phr             The Error Code returned.

    Remarks: Tries to Bind to Base Class Store Container, get the version
    Number and Packages and Classes container underneath.

      Initializes members corresp. to their Names

        Return Codes:
        Success     S_OK
        Failures    CS_E_INVALID_VERSION
        Look at RemapErrorCodes

*----------------------------------------------------------------------*/
CAppContainer::CAppContainer(CServerContext* pServerContext,
                             LPOLESTR        szStoreName,
                             PRSOPTOKEN      pRsopToken,
                             HRESULT*        phr)

{
    LPOLESTR            pszName = NULL;
    DWORD               dwStoreVersion = 0;
    LPOLESTR            AttrNames[] = {STOREVERSION, POLICYDN};
    DWORD               posn = 0, cgot = 0;
    ADS_SEARCHPREF_INFO SearchPrefs[3];
    ADS_ATTR_INFO     * pAttrsGot = NULL;

    m_szGpoPath = NULL;

    m_pRsopToken = pRsopToken;

    *phr = S_OK;

    if ( pServerContext )
    {
        *phr = m_ServerContext.Initialize( pServerContext );

        if ( FAILED(*phr) )
        {
            return;
        }
    }    

    // set the search preference for the search Handle

    SearchPrefs[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
    SearchPrefs[0].vValue.dwType = ADSTYPE_INTEGER;
    SearchPrefs[0].vValue.Integer = ADS_SCOPE_ONELEVEL;

    SearchPrefs[1].dwSearchPref = ADS_SEARCHPREF_PAGESIZE;
    SearchPrefs[1].vValue.dwType = ADSTYPE_INTEGER;
    SearchPrefs[1].vValue.Integer = SEARCHPAGESIZE;

    SearchPrefs[2].dwSearchPref = ADS_SEARCHPREF_SECURITY_MASK;
    SearchPrefs[2].vValue.dwType = ADSTYPE_INTEGER;

    SearchPrefs[2].vValue.Integer =
            OWNER_SECURITY_INFORMATION |
            GROUP_SECURITY_INFORMATION |
            DACL_SECURITY_INFORMATION;

    memset (&m_PolicyId, 0, sizeof(GUID));

    m_fOpen = FALSE;
    m_ADsContainer = NULL;
    m_ADsPackageContainer = NULL;
    m_szPackageName = NULL;

    memset (&m_PolicyId, 0, sizeof(GUID));

    m_KnownMissingClsidCache.sz = 0;
    m_KnownMissingClsidCache.start = 0;
    m_KnownMissingClsidCache.end = 0;

    m_uRefs = 1;
    //
    // For every interface pointer, we create a separate session
    //


    // Bind to a Class Store Container Object
    // Cache the interface pointer
    //
    *phr = StringCchCopy (m_szContainerName, _MAX_PATH, szStoreName);

    ERROR_ON_FAILURE(*phr);

    *phr = DSServerOpenDSObject( &m_ServerContext, m_szContainerName, GetDsFlags(),
        &m_ADsContainer);

    ERROR_ON_FAILURE(*phr);
    //
    // Check the Schema Version of this container
    //

    *phr = ADSIGetObjectAttributes(m_ADsContainer, AttrNames, 2, &pAttrsGot, &cgot);

    if ((SUCCEEDED(*phr)) && (cgot))
    {

        posn = GetPropertyFromAttr(pAttrsGot, cgot, STOREVERSION);
        dwStoreVersion = 0;
        if (posn < cgot)
        {
            //
            // Ensure that we validate the type of the data return by the ds --
            // if the type is not valid (most often this occurs because adsi
            // could not create a schema cache on the local machine), we
            // will assume it to be invalid.  The version number will be 
            // initialized to 0, which is invalid, and we will abort.
            //
            if ( ADSTYPE_INTEGER == pAttrsGot[posn].dwADsType )
            {
                UnpackDWFrom(pAttrsGot[posn], &dwStoreVersion);
            }
        }

        if (dwStoreVersion != SCHEMA_VERSION_NUMBER)
        {
            *phr = CS_E_INVALID_VERSION;
        }


        if (SUCCEEDED(*phr))
        {
            LPOLESTR        szPolicyPath = NULL;

            posn = GetPropertyFromAttr(pAttrsGot, cgot, POLICYDN);
            if (posn < cgot)
            {
                LPOLESTR        szParentPath = NULL, szPolicyGuid = NULL;

                UnpackStrFrom(pAttrsGot[posn], &szPolicyPath);
                //

                BuildADsParentPath(szPolicyPath, &szParentPath, &szPolicyGuid);
                if (szParentPath)
                    FreeADsMem(szParentPath);

                if (szPolicyGuid)
                {
                    if (wcslen(szPolicyGuid) == 41)
                    {
                        // valid GUID

                        GUIDFromString(&szPolicyGuid[4], &m_PolicyId);
                    }
                    FreeADsMem(szPolicyGuid);
                }
            }
        }
    }
    else
    {
        if (SUCCEEDED(*phr))
        {
            *phr = CS_E_INVALID_VERSION;
        }
    }

    if (pAttrsGot)
        FreeADsMem(pAttrsGot);

    ERROR_ON_FAILURE(*phr);

    //
    // Bind to the Package container Object
    // Cache the interface pointer
    //

    BuildADsPathFromParent(m_szContainerName, PACKAGECONTAINERNAME, &m_szPackageName);

    m_ADsPackageContainer = NULL;


    *phr = DSServerOpenDSObject( &m_ServerContext, m_szPackageName, GetDsFlags(),
        &m_ADsPackageContainer);

    ERROR_ON_FAILURE(*phr);

    *phr = ADSISetSearchPreference(m_ADsPackageContainer, SearchPrefs, 3);
    ERROR_ON_FAILURE(*phr);

    m_fOpen = TRUE;

    m_uRefs = 1;

    m_szGpoPath = AllocGpoPathFromClassStorePath( m_szContainerName );

    if ( ! m_szGpoPath )
    {
        *phr = E_OUTOFMEMORY;
    }

Error_Cleanup:
    *phr = RemapErrorCode(*phr, m_szContainerName);
    return;
}


/*----------------------------------------------------------------------*
CAppContainer Destructor:


    Parameters:
      None

    Function:
      Destroys CAppContainer object.

    Remarks:
     Frees all the members.
     Return Codes
*----------------------------------------------------------------------*/


CAppContainer::~CAppContainer(void)
{
    UINT i;

    if (m_fOpen)
    {
        m_fOpen = FALSE;
    }

    if (m_ADsPackageContainer)
    {
        ADSICloseDSObject(m_ADsPackageContainer);
        m_ADsPackageContainer = NULL;
        FreeADsMem(m_szPackageName);
    }

    if (m_ADsContainer)
    {
        ADSICloseDSObject(m_ADsContainer);
        m_ADsContainer = NULL;
    }

    if (m_szGpoPath)
    {
        CsMemFree(m_szGpoPath);
    }
}


//
// Constructor for App Container Class factory
//
unsigned long gulcappcon = 0;

CAppContainerCF::CAppContainerCF()
{
    m_uRefs = 1;
    InterlockedIncrement((long *) &gulcappcon );
}

//
// Destructor
//
CAppContainerCF::~CAppContainerCF()
{
    //
    // Cleanup the cache
    //
    InterlockedDecrement((long *) &gulcappcon );
}

HRESULT  __stdcall  CAppContainerCF::QueryInterface(REFIID riid, void  * * ppvObject)
{
    IUnknown *pUnkTemp = NULL;
    SCODE sc = S_OK;
    if( IsEqualIID( IID_IUnknown, riid ) )
    {
        pUnkTemp = (IUnknown *)(ITypeLib *)this;
    }
    else  if( IsEqualIID( IID_IClassFactory, riid ) )
    {
        pUnkTemp = (IUnknown *)(IClassFactory *)this;
    }
    else  if( IsEqualIID( IID_IParseDisplayName, riid ) )
    {
        pUnkTemp = (IUnknown *)(IParseDisplayName *)this;
    }
    else
    {
        sc = (E_NOINTERFACE);
    }

    if((pUnkTemp != NULL) && (SUCCEEDED(sc)))
        {
        *ppvObject = (void  * )pUnkTemp;
        pUnkTemp->AddRef();
    }
    return(sc);
}


ULONG __stdcall  CAppContainerCF::AddRef()
{
    InterlockedIncrement(( long * )&m_uRefs );
    return m_uRefs;
}

ULONG __stdcall  CAppContainerCF::Release()
{
    unsigned long uTmp = InterlockedDecrement((long *)&m_uRefs);
    unsigned long cRef = m_uRefs;

    // 0 is the only valid value to check
    if (uTmp == 0)
    {
        delete this;
    }

    return(cRef);
}


//
// IClassFactory Overide
//
HRESULT  __stdcall  CAppContainerCF::CreateInstance(IUnknown * pUnkOuter, REFIID riid,
                                                                    void  ** ppvObject)
{
    CAppContainer *  pIUnk = NULL;
    SCODE sc = S_OK;

    if( pUnkOuter == NULL )
    {
        if( (pIUnk = new CAppContainer()) != NULL)
        {
            sc = pIUnk->QueryInterface(  riid , ppvObject );
            if(FAILED(sc))
            {
                sc = E_UNEXPECTED;
            }
             pIUnk->Release();
        }
        else
            sc = E_OUTOFMEMORY;
    }
    else
    {
        return E_INVALIDARG;
    }
    return (sc);
}


//---------------------------------------------------------------
//
//  Function:   CreateConnectedInstance
//
//  Synopsis:   Returns IClassAccess Pointer, given a class store
//              path.
//
//  Arguments:
//  [in]
//      pszPath Class Store Path without the leading ADCS:
//
//      pUserSid
//              Sid under which the calling thread is running.
//      fCache
//              Boolean that decides whether to use a cached pointer or
//              not.
//  [out]
//      ppvObject
//              IClassAccess Interface pointer
//
//  Returns:
//      S_OK, E_NOINTERFACE, E_OUTOFMEMORY, CS_E_XXX
//
//  if (fCache)
//      Looks in the cache to see if we have already tried to bind to the same
//      ClassStore Path under the same SID. If it finds it, then we just QI for
//      IClassAccess and return. o/w create a new class store pointer and caches it.
//  else
//      Just binds to a new ClassStore and returns.
//----------------------------------------------------------------
HRESULT  __stdcall
CAppContainerCF::CreateConnectedInstance(
    CServerContext* pServerContext,
    LPOLESTR        pszPath, 
    PSID            pUserSid,
    PRSOPTOKEN      pRsopToken,
    BOOL            fCache,
    void **         ppvObject)
{
    CAppContainer   *   pIUnk = NULL;
    SCODE               sc = S_OK;
    HRESULT             hr = S_OK;
    BOOL                fFound = FALSE;
    FILETIME            ftCurrentTime;
    IClassAccess*       pNewClassAccess = NULL;

    CBinding*           pBinding;

    //
    // See if we have an existing connection in the cache
    //
    if (fCache)
    {
        GetSystemTimeAsFileTime( &ftCurrentTime );
        
        BindingCache.Lock();

        pBinding = BindingCache.Find(
            pServerContext,
            &ftCurrentTime,
            pszPath,
            pUserSid);

        if ( pBinding ) 
        {
            if ( FAILED( pBinding->Hr ) )
            {
                sc = pBinding->Hr;
            }
            else
            {
                sc = pBinding->pIClassAccess->
                    QueryInterface( IID_IClassAccess, ppvObject );
            }
        }

        BindingCache.Unlock();
    }

    if ( fCache && pBinding )
    {
        return sc;
    }

    //
    // Couldn't find anything in the cache -- we will have to create a new connection
    //

    //
    // If this is called in the context of policy, ipsec policy may not be enabled.
    // Therefore, our communications with the directory would not be secure.
    // We will pass TRUE for the secure channel argument of the CAppContainer
    // constructor since this code path is exercised during policy and we
    // want to ensure security.
    //

    //
    // Note that this object has a refcount of 1 when created
    //
    if ((pIUnk = new CAppContainer( pServerContext, pszPath, pRsopToken, &sc)) != NULL)
    {
        if (SUCCEEDED(sc))
        {
            sc = pIUnk->QueryInterface( IID_IClassAccess, (LPVOID*) &pNewClassAccess );
        }
        else
        {
            CSDBGPrint((DM_WARNING, 
                      IDS_CSTORE_BIND_FAIL,
                      pszPath,
                      sc));
        }

        pIUnk->Release();
    }
    else
    {
        return E_OUTOFMEMORY;
    }

    //
    // Store the result in the cache -- create a binding
    // descriptor so we can cache it
    //
    CBinding* pNewBinding;

    if (fCache)
    {
        //
        // Should not cache situations out of network failures
        // For now we are only caching successes OR CS does not exist cases
        //
        if ((sc == S_OK) || (sc == CS_E_OBJECT_NOTFOUND))
        {
            HRESULT   hrBinding;

            hrBinding = E_OUTOFMEMORY;

            pNewBinding = new CBinding(
                pServerContext,
                pszPath,
                pUserSid,
                pNewClassAccess,
                sc,
                &hrBinding);

            if ( FAILED( hrBinding ) )
            {
                sc = hrBinding;
                fCache = FALSE;
            }
        }
        else
        {
            fCache = FALSE;
        }
    }

    //
    // We have the binding descriptor, now cache it
    //
    if ( fCache )
    {
        CBinding* pBindingAdded;            

        BindingCache.Lock();

        //
        // Attempt to add the binding -- if one already
        // exists, it will destroy the one we pass in and
        // use the existing binding
        //
        pBindingAdded = BindingCache.AddBinding(
            &ftCurrentTime,
            pNewBinding);

        sc = pBindingAdded->Hr;
                
        if ( SUCCEEDED(sc) )
        {
            sc = pBindingAdded->pIClassAccess->
                QueryInterface( IID_IClassAccess, ppvObject );
        }

        BindingCache.Unlock();
    }
    else
    {
        if ( SUCCEEDED(sc) )
        {
            pNewClassAccess->AddRef();
            *ppvObject = pNewClassAccess;
        }
    }

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

    return (sc);
}


HRESULT  __stdcall  CAppContainerCF::LockServer(BOOL fLock)
{
    if(fLock)
    { InterlockedIncrement((long *) &gulcappcon ); }
    else
    { InterlockedDecrement((long *) &gulcappcon ); }
    return(S_OK);
}

//
// IUnknown methods for CAppContainer
//
//

HRESULT  __stdcall  CAppContainer::QueryInterface(REFIID riid, void  * * ppvObject)
{
    IUnknown *pUnkTemp = NULL;
    SCODE sc = S_OK;
    if( IsEqualIID( IID_IUnknown, riid ) )
    {
        pUnkTemp = (IUnknown *)(IClassAccess *)this;
    }
     else  if( IsEqualIID( IID_IClassAccess, riid ) )
    {
        pUnkTemp = (IUnknown *)(IClassAccess *)this;
    }
    /*
    else  if( IsEqualIID( IID_IClassRefresh, riid ) )
    {
        pUnkTemp = (IUnknown *)(IClassRefresh *)this;
    }
    else  if( IsEqualIID( IID_ICatInformation, riid ) )
    {
        pUnkTemp = (IUnknown *)(ICatInformation *)this;
    }
    */
    else
    {
        sc = (E_NOINTERFACE);
    }

    if((pUnkTemp != NULL) && (SUCCEEDED(sc)))
    {
        *ppvObject = (void  * )pUnkTemp;
        pUnkTemp->AddRef();
    }
    return(sc);
}


ULONG __stdcall  CAppContainer::AddRef()
{
    InterlockedIncrement(( long * )&m_uRefs );
    return m_uRefs;
}

ULONG __stdcall  CAppContainer::Release()
{
    unsigned long uTmp = InterlockedDecrement((long *)&m_uRefs);
    unsigned long cRef = m_uRefs;

    if (uTmp == 0)
    {
        delete this;
    }

    return(cRef);
}


/*----------------------------------------------------------------------*
GetPackageDetails:

  Parameters:
  [in]  pszPackageName:    The Package Name
  [out] pPackageDetail     Package Detail Structure.

    Functionality:
    Returns the PackageDetail corresp. to a Package given
    by pszPackageName.

      Remarks:
      It constructs the Full Package Name
      and calls GetPackageDetail

        Return Codes:
        Success     S_OK
        Failures    Look at RemapErrorCodes

*----------------------------------------------------------------------*/

// This is not being called currently by anybody and hence is still using PackageId.
HRESULT CAppContainer::GetPackageDetails (
                                          LPOLESTR         pszPackageId,
                                          PACKAGEDETAIL   *pPackageDetail)
{
    HRESULT              hr = S_OK;
    HANDLE               hADs = NULL;
    WCHAR              * szFullName = NULL, szRDN[_MAX_PATH];
    ADS_ATTR_INFO      * pAttr = NULL;
    DWORD                cgot;

    if ((!pszPackageId))
        return E_INVALIDARG;

    hr = StringCchPrintf(szRDN, _MAX_PATH, L"CN=%s", pszPackageId);
    ERROR_ON_FAILURE(hr);
    
    CSDBGPrint((DM_WARNING, 
              IDS_CSTORE_PKG_DETAILS,
              szRDN));

    BuildADsPathFromParent(m_szPackageName, szRDN, &szFullName);

    //
    // We do not enforce packet integrity options here because
    // this is only called in the context of the admin tool and we
    // can rely on ipsec to have executed at that point
    //

    hr = DSServerOpenDSObject( &m_ServerContext, szFullName, GetDsFlags(), &hADs);
    ERROR_ON_FAILURE(hr);

    hr = GetPackageDetail (hADs, NULL, pPackageDetail);

    ADSICloseDSObject(hADs);

    if (pAttr)
        FreeADsMem(pAttr);

    if (szFullName)
        FreeADsMem(szFullName);

Error_Cleanup:
    return RemapErrorCode(hr, m_szContainerName);
}


/*----------------------------------------------------------------------*
EnumPackages

  Parameters:
  [in] pszPackageName     Substring match for a package name
  [in] pCategory          Package Category.
  [in] pLastUsn           Last modification time.
  [in] dwAppFlags         Set the following bits to select specific ones
  Published Only  APPINFO_PUBLISHED
  Assigned Only   APPINFO_ASSIGNED
  Msi Only        APPINFO_MSI
  Visible         APPINFO_VISIBLE
  Auto-Install    APPINFO_AUTOINSTALL

    All Locale      APPINFO_ALLLOCALE
    All Platform    APPINFO_ALLPLATFORM

      [out] ppIEnumPackage   Returns the Enumerator

        Functionality
        Obtains an enumerator for packages in the app container.

          Remarks:

*----------------------------------------------------------------------*/

HRESULT CAppContainer::EnumPackages (
                                     LPOLESTR        pszPackageName,
                                     GUID            *pCategory,
                                     ULONGLONG       *pLastUsn,
                                     DWORD           dwQuerySpec,      // AppType options
                                     IEnumPackage    **ppIEnumPackage
                                     )
{
    const DWORD             dwMaxStrLen =  1000;
    HRESULT                 hr = S_OK;
    CEnumPackage           *pEnum = NULL;
    WCHAR                   szLdapFilter[dwMaxStrLen];
    WCHAR                   szLdapFilterFinal[1500];
    UINT                    len = 0;
    UINT                    fFilters = 0;
    CSPLATFORM              *pPlatform = NULL, Platform;
    DWORD                   dwAppFlags;

    //
    // Validate
    //

    switch ( dwQuerySpec )
    {
    case APPQUERY_ALL:
    case APPQUERY_ADMINISTRATIVE:
    case APPQUERY_POLICY:
    case APPQUERY_USERDISPLAY:
    case APPQUERY_RSOP_LOGGING:
    case APPQUERY_RSOP_ARP:
        break;
    default:
        return E_INVALIDARG;
    }

    *ppIEnumPackage = NULL;

    pEnum = new CEnumPackage( &m_ServerContext, m_PolicyId, NULL, m_szContainerName, m_pRsopToken );
    if(NULL == pEnum)
        return E_OUTOFMEMORY;

    //
    // Set client side filters
    //
    dwAppFlags = ClientSideFilterFromQuerySpec( dwQuerySpec, NULL != m_pRsopToken );

    //
    // Create a LDAP Search Filter based on input params
    //

    // Count Filters
    if (pszPackageName && (*pszPackageName))
        fFilters++;
    if ((pLastUsn) && (*pLastUsn))
        fFilters++;
    if (pCategory)
        fFilters++;

    if (fFilters == 0)
    {
        // No Conditionals
        hr = StringCchPrintf (szLdapFilter,
                  dwMaxStrLen,
                  L"(%s=%s)", OBJECTCLASS, CLASS_CS_PACKAGE);
        ERROR_ON_FAILURE(hr);


        len = wcslen (szLdapFilter);
    }
    else
    {

        if (fFilters > 1)
        {
            hr = StringCchPrintf (szLdapFilter, dwMaxStrLen, L"(&");
            ERROR_ON_FAILURE(hr);
            len = wcslen (szLdapFilter);
        }
        else
            len = 0;

        if (pszPackageName)
        {
            //
            // Validate
            //

            if (*pszPackageName)
            {
                hr = StringCchPrintf (&szLdapFilter[len],
                                      dwMaxStrLen - len,
                                      L"(%s=*%s*)",
                                      PACKAGENAME,
                                      pszPackageName);
                ERROR_ON_FAILURE(hr);

                len = wcslen (szLdapFilter);
            }
        }

        if ((pLastUsn) && (*pLastUsn))
        {
            SYSTEMTIME SystemTime;

            FileTimeToSystemTime(
                (CONST FILETIME *) pLastUsn,
                &SystemTime);

            hr = StringCchPrintf (&szLdapFilter[len],
                                  dwMaxStrLen - len,
                                  L"(%s>=%04d%02d%02d%02d%02d%02d)",
                                  PKGUSN,
                                  SystemTime.wYear,
                                  SystemTime.wMonth,
                                  SystemTime.wDay,
                                  SystemTime.wHour,
                                  SystemTime.wMinute,
                                  SystemTime.wSecond+1);
            ERROR_ON_FAILURE(hr);

            len = wcslen (szLdapFilter);
        }

        if (pCategory)
        {
            STRINGGUID szCat;

            StringFromGUID (*pCategory, szCat);
            hr = StringCchPrintf (&szLdapFilter[len],
                                  dwMaxStrLen - len,
                                  L"(%s=%s)",
                                  PKGCATEGORYLIST,
                                  szCat);
            ERROR_ON_FAILURE(hr);

            len = wcslen (szLdapFilter);
        }

        if (fFilters > 1)
        {
            if (dwMaxStrLen - len < 2) 
            {
                hr = STRSAFE_E_INSUFFICIENT_BUFFER;
                ERROR_ON_FAILURE(hr);
            }
            szLdapFilter[len] = L')';
            szLdapFilter[++len] = NULL;
        }
    }


    //
    // Finish setting the server side filter
    // based on the query type
    //
    ServerSideFilterFromQuerySpec(
        dwQuerySpec,
        NULL != m_pRsopToken,
        szLdapFilter,
        szLdapFilterFinal,
        sizeof(szLdapFilterFinal)/sizeof(szLdapFilterFinal[0]));

    CSDBGPrint((DM_WARNING,
              IDS_CSTORE_ENUMPACKAGE,
              szLdapFilterFinal,
              dwAppFlags));
        
    //
    // Check all local/platform flags
    //

    if (!(dwAppFlags & APPFILTER_REQUIRE_THIS_PLATFORM))
    {
        pPlatform = NULL;
    }
    else
    {
        pPlatform = &Platform;
        GetDefaultPlatform(pPlatform);
    }

    if (pLastUsn)
    {
        //
        // Find the current store USN and return it
        //
        LPOLESTR            AttrName = STOREUSN;
        ADS_ATTR_INFO     * pAttr = NULL;
        DWORD               cgot = 0;

        hr = ADSIGetObjectAttributes(m_ADsContainer, &AttrName, 1, &pAttr, &cgot);
        if ((SUCCEEDED(hr)) && (cgot))
        {
            UsnGet(*pAttr, (CSUSN *)pLastUsn);
            if (pAttr)
                FreeADsMem(pAttr);
        }
    }

    hr = pEnum->Initialize(m_szPackageName, szLdapFilterFinal, dwQuerySpec, NULL != m_pRsopToken, pPlatform);
    ERROR_ON_FAILURE(hr);

    hr = pEnum->QueryInterface(IID_IEnumPackage,(void**) ppIEnumPackage);
    ERROR_ON_FAILURE(hr);

    return S_OK;

Error_Cleanup:
    if (pEnum)
        delete pEnum;
    *ppIEnumPackage = NULL;

    return RemapErrorCode(hr, m_szContainerName);
}


// choosing the best package that can be returned after returning from the DS
DWORD CAppContainer::ChooseBestFit(PACKAGEDISPINFO *PackageInfo, UINT *rgPriority, DWORD cRowsFetched)
{
    DWORD i=0, k=0, j = 0, temp = 0;
    DWORD index[10];

    // initialising the indices
    for (i = 0; (i <  cRowsFetched); i++)
        index[i] = i;

    // sort the index based on priority and time stamp
    for (i = 0; (i < (cRowsFetched-1)); i++)
    {
        DWORD Pri = rgPriority[i];
        k = i;
        // max element's index is in k
        for (j=(i+1); (j < cRowsFetched); ++j)
        {
            // order first by weight and then by time stamp.
            if ((rgPriority[index[j]] > Pri) ||
                ((rgPriority[index[j]] == Pri) &&
                 (CompareUsn((FILETIME *)&PackageInfo[index[j]].Usn, (FILETIME *)&PackageInfo[index[k]].Usn) == 1)))
            {
                Pri = rgPriority[index[j]];
                k = j;
            }
        }

        if (k != i)
        {
            temp = index[k];
            index[k] = index[i];
            index[i] = temp;
        }
    }

    DWORD dwPackage;
    DWORD dwBestPackage;

    dwBestPackage = 0;

    //
    // Now the packages are sorted in order from highest precedence to lowest.
    // We will now check for upgrades for each package
    //
    for (dwPackage = 0; (dwPackage < cRowsFetched); dwPackage++)
    {
        DWORD            dwPossibleUpgrader;
        PACKAGEDISPINFO* pBestPackage;

        pBestPackage = PackageInfo+index[dwBestPackage];

        CSDBGPrint((DM_WARNING,
                  IDS_CSTORE_BESTFIT,
                  pBestPackage->pszPackageName));

        //
        // Now search for someone that upgrades the current choice -- look at all packages
        // after the current one since we've already determined that the packages before
        // this one got upgraded (otherwise we wouldn't be here).
        //
        for (dwPossibleUpgrader = dwPackage + 1; dwPossibleUpgrader < cRowsFetched; dwPossibleUpgrader ++)
        {
            PACKAGEDISPINFO* pUpgraderCandidate;

            //
            // Obviously, we don't need to check the current choice
            // to see if it upgrades itself, so skip it
            //
            if (dwPossibleUpgrader == dwBestPackage)
            {
                continue;
            }

            pUpgraderCandidate = PackageInfo + index[dwPossibleUpgrader];

            //
            // See if the upgrader candidate has any upgrades, if not, keep looking
            //
            if (0 == pUpgraderCandidate->cUpgrades)
            {
                continue;
            }

            //
            // Now we have to see if any of those upgrades apply to the package we have
            // currently selected as the best
            //
            DWORD dwUpgrade;
            BOOL  fFoundUpgrade;

            fFoundUpgrade = FALSE;

            for (dwUpgrade = 0; dwUpgrade < pUpgraderCandidate->cUpgrades; dwUpgrade++)
            {
                DWORD dwValidUpgradeMask;

                dwValidUpgradeMask = UPGFLG_Uninstall |
                    UPGFLG_NoUninstall |
                    UPGFLG_Enforced;

                //
                // If this is a valid upgrade
                //
                if (pUpgraderCandidate->prgUpgradeInfoList[dwUpgrade].Flag & dwValidUpgradeMask)
                {
                    //
                    // Does it upgrade the package we think is best at this point? We only
                    // consider upgrades in this container, as we no longer allow upgrades from lower
                    // precedence class stores -- the caller who iterates through each container from
                    // highest precedence to lowest will simply choose the app from the first container in which
                    // we have a match.
                    //
                    // We use memcmp to compare guids to see if the best choice package's guid is listed
                    // as being upgraded by this upgrade candidate
                    //
                    if (memcmp(&((pUpgraderCandidate->prgUpgradeInfoList)[dwUpgrade].PackageGuid),
                               &(pBestPackage->PackageGuid), sizeof(GUID) == 0))
                    {
                        //
                        // We have a match -- reset the current best choice to the upgrade candidate
                        //
                        dwBestPackage = dwPossibleUpgrader;

                        //
                        // another package upgrades this -- no need to look any further, so we quit
                        //
                        CSDBGPrint((DM_WARNING,
                                  IDS_CSTORE_BESTFITSKIP,
                                  pBestPackage->pszPackageName,
                                  pUpgraderCandidate->pszPackageName));

                        break;
                    }
                }
            }

            //
            // If we found an upgrade in the list above, we can stop abort the search for an upgrade now --
            // if we found another, it would just be a lower precedence app since we're iterating from highest to lowest,
            // and we want the highest predecence app that upgrades the currently chosen best app
            //
            if (fFoundUpgrade)
            {
                break;
            }
        }
    }

    DWORD dwChoice;

    dwChoice = index[dwBestPackage];

    CSDBGPrint((DM_WARNING,
              IDS_CSTORE_BESTFIT_END,
              PackageInfo[dwChoice].pszPackageName));

    return dwChoice;
}

//
// CAppContainer::GetAppInfo
// -----------------------------
//
//
//
//  Synopsis:       This is the most common access point to the Class Store.
//                  It receives a CLSID and a QUERYCONTEXT.
//                  It looks up the Class Store container for a matching set
//                  of packages with in the context of the QUERYCONTEXT.
//
//                  QUERYCONTEXT includes
//                      Execution Context
//                      Locale Id
//                      Platform/OS
//
//                  If i finds an app that matches the requirements, it returns
//                  an PACKAGEDISPINFO structure containing installation details.
//
//  Arguments:      [in]  clsid
//                  [in]  pQryContext
//                  [out] pPackageInfo
//
//  Returns:        CS_E_PACKAGE_NOTFOUND
//                  S_OK
//
//
//

HRESULT STDMETHODCALLTYPE
CAppContainer::GetAppInfo(
                          uCLSSPEC       *   pclsspec,          // Class Spec (GUID/Ext/MIME)
                          QUERYCONTEXT   *   pQryContext,       // Query Attributes
                          PACKAGEDISPINFO    *   pPackageInfo
                          )

                          //
                          // This is the most common method to access the Class Store.
                          // It queries the class store for implementations for a specific
                          // Class Id, or File Ext, or ProgID.
                          //
                          // If a matching implementation is available (for the object type,
                          // client architecture, locale and class context) then the installation
                          // parameters of the package is returned.
{
    const DWORD dwMaxStrLen = 1000;
    GUID        clsid;
    WCHAR       szfilterbuf[dwMaxStrLen];
    WCHAR*      szfilter = szfilterbuf;
    WCHAR*      szNameFilter;
    STRINGGUID  szClsid;
    UINT        i, iClsid = 0;
    ULONG       cRead;
    HRESULT     hr;
    ULONG       cSize = _MAX_PATH;
    BOOL        fFound = FALSE;
    PLATFORMINFO PlatformInfo;
    LPOLESTR    pFileExt = NULL;
    BOOL        OnDemandInstallOnly = TRUE;
    WCHAR       FileExtLower [10];
    FILETIME    ftCurrentTime;

    szNameFilter = NULL;

    memset(pPackageInfo, 0, sizeof(PACKAGEDISPINFO));

    if (!m_fOpen)
        return E_FAIL;

    //
    // Check if the TypeSpec is MIMEType
    // then map it to a CLSID
    //

    switch (pclsspec->tyspec)
    {
    case TYSPEC_CLSID:

        if (IsNullGuid(pclsspec->tagged_union.clsid))
            return E_INVALIDARG;
        //
        // Check against known missing ones
        //

        hr = S_OK;

        EnterCriticalSection (&ClassStoreBindList);

        //
        // Retrieve the current time so we can determine
        // if cache entries are expired
        //
        GetSystemTimeAsFileTime( &ftCurrentTime );


        for (iClsid=m_KnownMissingClsidCache.start; (iClsid  != m_KnownMissingClsidCache.end);
                        iClsid = (iClsid+1)%(CLSIDCACHESIZE))
        {
            if ( IsExpired( &ftCurrentTime, &(m_KnownMissingClsidCache.ElemArr[iClsid].Time) ) )
            {
                // all the prev. elems must have expired.

                // delete this element
                m_KnownMissingClsidCache.start = (m_KnownMissingClsidCache.start+1)%CLSIDCACHESIZE;
                m_KnownMissingClsidCache.sz--;

                CSDBGPrint((DM_WARNING,
                          IDS_CSTORE_CLASS_PURGE));
                          
                // iClsid will be moved automatically.
                continue;
            }

            if ((IsEqualGUID(pclsspec->tagged_union.clsid,
                            m_KnownMissingClsidCache.ElemArr[iClsid].Clsid)) &&
                ((pQryContext->dwContext) == m_KnownMissingClsidCache.ElemArr[iClsid].Ctx))
            {
                CSDBGPrint((DM_WARNING,
                          IDS_CSTORE_CLASS_HIT));

                hr = CS_E_PACKAGE_NOTFOUND;
                break;
            }
        }

        LeaveCriticalSection (&ClassStoreBindList);

        if (hr == CS_E_PACKAGE_NOTFOUND)
            return hr;

        StringFromGUID (pclsspec->tagged_union.clsid, szClsid);
        hr = StringCchPrintf (szfilter, dwMaxStrLen, L"(%s=%s*)", PKGCLSIDLIST, szClsid);
        if (FAILED(hr)) 
        {
            return hr;
        }
        break;

    case TYSPEC_FILEEXT:

        if ((pclsspec->tagged_union.pFileExt == NULL) ||
            (*(pclsspec->tagged_union.pFileExt) == NULL))
            return E_INVALIDARG;


        if (wcslen(pclsspec->tagged_union.pFileExt) > 9)
            return E_INVALIDARG;

        hr = StringCbCopy (&FileExtLower[0], sizeof(FileExtLower), pclsspec->tagged_union.pFileExt);
        if (FAILED(hr)) 
        {
            return hr;
        }

        _wcslwr (&FileExtLower[0]);

        hr = StringCchPrintf (szfilter,
                              dwMaxStrLen,
                              L"(%s=%s*)",
                              PKGFILEEXTNLIST, &FileExtLower[0]);
        if (FAILED(hr)) 
        {
            return hr;
        }

        pFileExt = &FileExtLower[0];
        break;


    case TYSPEC_PROGID:

        if ((pclsspec->tagged_union.pProgId == NULL) ||
            (*(pclsspec->tagged_union.pProgId) == NULL))
            return E_INVALIDARG;

        hr = StringCchPrintf (szfilter,
                              dwMaxStrLen, 
                              L"(%s=%s)", PKGPROGIDLIST, pclsspec->tagged_union.pProgId);
        if (FAILED(hr)) 
        {
            return hr;
        }

        break;

    case TYSPEC_PACKAGENAME:
        //
        // Validate package name
        //

        if ((pclsspec->tagged_union.ByName.pPackageName == NULL) ||
            (*(pclsspec->tagged_union.ByName.pPackageName) == NULL))
            return E_INVALIDARG;

        //
        // The search filter syntax requires that the package name is
        // properly escaped, so we retrieve such a filter below
        //
        hr = GetEscapedNameFilter( pclsspec->tagged_union.ByName.pPackageName, &szNameFilter );

        if ( FAILED(hr) )
        {
            return hr;
        }

        szfilter = szNameFilter;

        OnDemandInstallOnly = FALSE;
        break;

    case TYSPEC_OBJECTID:
        //
        // Validate object id
        //
        if (IsNullGuid(pclsspec->tagged_union.ByObjectId.ObjectId))
            return E_INVALIDARG;

        LPWSTR EncodedGuid;

        EncodedGuid = NULL;
        hr = ADsEncodeBinaryData((PBYTE)&pclsspec->tagged_union.ByObjectId.ObjectId, sizeof(GUID), &EncodedGuid);
    
        hr = StringCchPrintf(szfilter, dwMaxStrLen, L"(%s=%s)", OBJECTGUID, EncodedGuid);    
        FreeADsMem(EncodedGuid);
        OnDemandInstallOnly = FALSE;
        if (FAILED(hr)) 
        {
            return hr;
        }

        break;

    default:
        return E_NOTIMPL;
    }

    //
    //
    ULONG              cRowsFetched;
    PACKAGEDISPINFO    PackageInfo[10];
    UINT               rgPriority [10];

    ADS_SEARCH_HANDLE  hADsSearchHandle = NULL;

    hr = ADSIExecuteSearch(m_ADsPackageContainer, szfilter, pszInstallInfoAttrNames, cInstallInfoAttr, &hADsSearchHandle);

    CSDBGPrint((DM_WARNING,
              IDS_CSTORE_MERGEAPPINFO,
              szfilter));

    ERROR_ON_FAILURE(hr);

    //
    // We obtain the 10 best matches
    //
    hr = FetchInstallData(
        m_ADsPackageContainer,
        hADsSearchHandle,
        pQryContext,
        pclsspec,
        pFileExt,
        10,
        &cRowsFetched,
        &PackageInfo[0],
        &rgPriority[0],
        OnDemandInstallOnly,
        &m_PolicyId,
        m_szGpoPath
        );

    CSDBGPrint((DM_WARNING,
              IDS_CSTORE_ONDEMAND,
              cRowsFetched,
              hr));

    if (cRowsFetched == 0)
    {
        hr = CS_E_OBJECT_NOTFOUND;
        //
        // If CLSID was passed cache the miss
        //
        if (pclsspec->tyspec == TYSPEC_CLSID)
        {
            EnterCriticalSection (&ClassStoreBindList);

            if (m_KnownMissingClsidCache.sz < (CLSIDCACHESIZE-1))
            {
                memcpy (&m_KnownMissingClsidCache.ElemArr[m_KnownMissingClsidCache.end].Clsid,
                        &(pclsspec->tagged_union.clsid), sizeof(GUID));

                m_KnownMissingClsidCache.ElemArr[m_KnownMissingClsidCache.end].Ctx
                                    = pQryContext->dwContext;

                //
                // Set the time member to the current time -- this is retrieved
                // above for all clsid queries
                //
                GetExpiredTime( &ftCurrentTime,
                                &(m_KnownMissingClsidCache.ElemArr[m_KnownMissingClsidCache.end].Time) );


                m_KnownMissingClsidCache.sz++;

                m_KnownMissingClsidCache.end = (m_KnownMissingClsidCache.end+1) % CLSIDCACHESIZE;

            }
            LeaveCriticalSection (&ClassStoreBindList);
        }
    }
    else
    {
        DWORD dwChoice = 0;

        if (cRowsFetched > 1)
        {
            dwChoice = ChooseBestFit(PackageInfo, rgPriority, cRowsFetched);
        }


        memcpy (pPackageInfo, &PackageInfo[dwChoice], sizeof(PACKAGEDISPINFO));
        memset (&PackageInfo[dwChoice], NULL, sizeof(PACKAGEDISPINFO));

        // Clean up all allocations
        for (i=0; i < cRowsFetched; i++)
        {
            ReleasePackageInfo(&PackageInfo[i]);
        }
    }

    if (hADsSearchHandle)
        ADSICloseSearchHandle(m_ADsPackageContainer, hADsSearchHandle);

    //
    // fill in PolicyID
    //
    if (SUCCEEDED(hr))
    {
        memcpy (&(pPackageInfo->GpoId), &m_PolicyId, sizeof(GUID));
    }

Error_Cleanup:

    if ( szNameFilter )
    {
        CsMemFree( szNameFilter );
    }
    
    CSDBGPrint((DM_WARNING,
              IDS_CSTORE_APPINFO_END,
              hr));

    return RemapErrorCode(hr, m_szContainerName);
}