able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/ole32/cs/backend/csdsadm.cxx

3161 lines
97 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// Author: DebiM
// Date: January 97
//
//
// Class Store Administration Implementation
//
// This source file contains implementations for
// IClassAdmin interface.
//
// It uses ADs interfaces (over LDAP) to talk to an LDAP
// provider such as NTDS.
//
//---------------------------------------------------------------------
#include "cstore.hxx"
// utility functions
HRESULT UpdateStoreUsn(HANDLE hADs, LPOLESTR szUsn)
{
ADS_ATTR_INFO pAttr[1];
DWORD cModified = 0;
HRESULT hr = S_OK;
PackStrToAttr(pAttr, STOREUSN, szUsn);
hr = ADSISetObjectAttributes(hADs, pAttr, 1, &cModified);
FreeAttr(pAttr[0]);
return hr;
}
//----------------------------------------------------------
// Implementation for CClassContainer
//----------------------------------------------------------
//
CClassContainer::CClassContainer()
{
m_fOpen = FALSE;
m_ADsContainer = NULL;
m_ADsClassContainer = NULL;
m_ADsPackageContainer = NULL;
m_ADsCategoryContainer = NULL;
m_szCategoryName = NULL;
m_szPackageName = NULL;
m_szClassName = NULL;
m_szPolicyName = NULL;
memset (&m_PolicyId, 0, sizeof(GUID));
m_uRefs = 1;
}
//---------------------------------------------------------------
//
// Function: Constructor
//
// Synopsis: Binds to the ClassStore given a class store path.
//
// Arguments:
// [in]
// szStoreName
// Class Store Path without the leading ADCS:
//
// [out]
// phr
// Sucess code.
//
// Does an ADSI bind at the class store container and matches the
// version numbers. if the version numbers match then it binds to the
// class, package and category containers and keeps the bind handles.
//----------------------------------------------------------------
CClassContainer::CClassContainer(LPOLESTR szStoreName,
HRESULT *phr)
{
DWORD dwStoreVersion = 0;
LPOLESTR AttrNames[] = {STOREVERSION, POLICYDN, POLICYNAME};
ADS_ATTR_INFO * pAttrsGot = NULL;
DWORD cgot = 0, posn = 0;
ADS_SEARCHPREF_INFO SearchPrefs[2];
// set the search preference to one level search
// and make the results come back in batches of size
// 20 as default.
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 = 20;
// BUGBUG: This should be defined as a constant.
// initialising.
*phr = S_OK;
m_fOpen = FALSE;
m_ADsContainer = NULL;
m_ADsClassContainer = NULL;
m_ADsPackageContainer = NULL;
m_ADsCategoryContainer = NULL;
m_szCategoryName = NULL;
m_szPackageName = NULL;
m_szClassName = NULL;
m_szPolicyName = NULL;
memset (&m_PolicyId, 0, sizeof(GUID));
// Bind to a Class Store Container Object
// Cache the interface pointer
//
wcscpy (m_szContainerName, szStoreName);
*phr = ADSIOpenDSObject(m_szContainerName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&m_ADsContainer);
ERROR_ON_FAILURE(*phr);
//
// Check the Schema Version of this container
//
*phr = ADSIGetObjectAttributes(m_ADsContainer, AttrNames, 3, &pAttrsGot, &cgot);
if ((SUCCEEDED(*phr)) && (cgot))
{
posn = GetPropertyFromAttr(pAttrsGot, cgot, STOREVERSION);
dwStoreVersion = 0;
if (posn < cgot)
{
UnpackDWFrom(pAttrsGot[posn], &dwStoreVersion);
}
if ((!SUCCEEDED(*phr)) ||
(dwStoreVersion != SCHEMA_VERSION_NUMBER))
{
*phr = CS_E_INVALID_VERSION;
}
if (SUCCEEDED(*phr))
{
LPOLESTR szPolicyPath = NULL, szPolicyName = 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);
}
}
posn = GetPropertyFromAttr(pAttrsGot, cgot, POLICYNAME);
if (posn < cgot)
{
UnpackStrAllocFrom(pAttrsGot[posn], &m_szPolicyName);
}
}
}
else
{
*phr = CS_E_INVALID_VERSION;
}
if (pAttrsGot)
FreeADsMem(pAttrsGot);
ERROR_ON_FAILURE(*phr);
//
// Bind to the class container Object
// Cache the interface pointer
//
// get the class container name.
BuildADsPathFromParent(m_szContainerName, CLASSCONTAINERNAME, &m_szClassName);
m_ADsClassContainer = NULL;
// bind to the class container.
*phr = ADSIOpenDSObject(m_szClassName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&m_ADsClassContainer);
ERROR_ON_FAILURE(*phr);
// set the search preference on the handle.
*phr = ADSISetSearchPreference(m_ADsClassContainer, SearchPrefs, 2);
ERROR_ON_FAILURE(*phr);
//
// Bind to the Package container Object
// Cache the interface pointer
//
// get the package container name.
BuildADsPathFromParent(m_szContainerName, PACKAGECONTAINERNAME, &m_szPackageName);
m_ADsPackageContainer = NULL;
// bind to the package container.
*phr = ADSIOpenDSObject(m_szPackageName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&m_ADsPackageContainer);
ERROR_ON_FAILURE(*phr);
// set the search preference.
*phr = ADSISetSearchPreference(m_ADsPackageContainer, SearchPrefs, 2);
ERROR_ON_FAILURE(*phr);
//
// Bind to the category container Object
// Cache the interface pointer
//
// get the category container name
BuildADsPathFromParent(m_szContainerName, CATEGORYCONTAINERNAME, &m_szCategoryName);
m_ADsCategoryContainer = NULL;
// bind to the category container.
*phr = ADSIOpenDSObject(m_szCategoryName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&m_ADsCategoryContainer);
ERROR_ON_FAILURE(*phr);
// set the search preferences.
*phr = ADSISetSearchPreference(m_ADsCategoryContainer, SearchPrefs, 2);
ERROR_ON_FAILURE(*phr);
m_fOpen = TRUE;
m_uRefs = 1;
Error_Cleanup:
*phr = RemapErrorCode(*phr, m_szContainerName);
return;
}
CClassContainer::~CClassContainer(void)
{
if (m_fOpen)
{
m_fOpen = FALSE;
}
if (m_ADsClassContainer)
{
ADSICloseDSObject(m_ADsClassContainer);
m_ADsClassContainer = NULL;
}
// the bind might have failed while we succeeded in getting a path.
if (m_szClassName)
FreeADsMem(m_szClassName);
if (m_ADsPackageContainer)
{
ADSICloseDSObject(m_ADsPackageContainer);
m_ADsPackageContainer = NULL;
}
if (m_szPackageName)
FreeADsMem(m_szPackageName);
if (m_ADsCategoryContainer)
{
ADSICloseDSObject(m_ADsCategoryContainer);
m_ADsCategoryContainer = NULL;
}
if (m_szCategoryName)
FreeADsMem(m_szCategoryName);
if (m_ADsContainer)
{
ADSICloseDSObject(m_ADsContainer);
m_ADsContainer = NULL;
}
}
// currently unused.
BOOL InvalidDSName(LPWSTR pName)
{
if (wcslen(pName) >= 56)
return TRUE;
while (*pName)
{
if ((*pName == L':') ||
(*pName == L',') ||
(*pName == L';') ||
(*pName == L'/') ||
(*pName == L'<') ||
(*pName == L'>') ||
(*pName == L'\\')||
(*pName == L'+'))
return TRUE;
++pName;
}
return FALSE;
}
HRESULT CClassContainer::GetGPOInfo(GUID *pGPOId, LPOLESTR *pszPolicyName)
{
if ((!pGPOId) || (!IsValidPtrOut(pGPOId, sizeof(GUID))))
return E_INVALIDARG;
if ((!pszPolicyName) || (!IsValidPtrOut(pszPolicyName, sizeof(LPOLESTR))))
return E_OUTOFMEMORY;
memcpy(pGPOId, &m_PolicyId, sizeof(GUID));
if (m_szPolicyName)
{
*pszPolicyName = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*(1+wcslen(m_szPolicyName)));
if (!(*pszPolicyName))
return E_INVALIDARG;
wcscpy(*pszPolicyName, m_szPolicyName);
}
else
{
*pszPolicyName = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*2);
if (!(*pszPolicyName))
return E_OUTOFMEMORY;
(*pszPolicyName)[0] = L'\0';
}
return S_OK;
}
//
// Removing a class from the database
//
//---------------------------------------------------------------
//
// Function: DeleteClass
//
// Synopsis: Internal function. Deletes the clsid from the ClassContainer.
//
// UsedBy RemovePackage
//
//
// Arguments:
// [in]
// szClsid
// Stringised Clsid
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
//
// Binds to the clsid object under the class container.
// and decrements the reference count. If the reference
// count goes to zero, then it deletes the clsid.
// BUGBUG: If 2 objects try to delete it at the same
// time this might not work properly.
//----------------------------------------------------------------
HRESULT CClassContainer::DeleteClass (LPOLESTR szClsid)
{
WCHAR szName[_MAX_PATH], *szFullName = NULL;
HRESULT hr = S_OK;
DWORD refcount = 0, cgot = 0, cAttr = 1, cModified = 0;
HANDLE hADs = NULL;
LPOLESTR AttrName = CLASSREFCOUNTER;
ADS_ATTR_INFO * pAttr = NULL;
ADS_ATTR_INFO Attr;
if (!m_fOpen)
return E_FAIL;
// constructs the fullname from the clsid and class container Name.
wsprintf(szName, L"CN=%s", szClsid);
BuildADsPathFromParent(m_szClassName, szName, &szFullName);
// binds to the class object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&hADs);
if (szFullName)
FreeADsMem(szFullName);
ERROR_ON_FAILURE(hr);
// gets the reference count attribute.
hr = ADSIGetObjectAttributes(hADs, &AttrName, 1, &pAttr, &cgot);
if ((SUCCEEDED(hr)) && (cgot))
UnpackDWFrom(pAttr[0], (DWORD *)&refcount);
if (pAttr)
FreeADsMem(pAttr);
if (refcount <= 1) {
// Delete the object if the reference count is less than zero.
hr = ADSIDeleteDSObject(m_ADsClassContainer, szName);
if (hADs)
ADSICloseDSObject(hADs);
}
else {
// Decrement the reference count and store it back.
refcount--;
PackDWToAttr(&Attr, CLASSREFCOUNTER, refcount);
hr = ADSISetObjectAttributes(hADs, &Attr, cAttr, &cModified);
ADSICloseDSObject(hADs);
FreeAttr(Attr);
}
Error_Cleanup:
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
//
// Function: EnumPackages
//
// Synopsis: Returns an Enumerator for all the packages that satisfies
// the query.
//
// UsedBy Add/Remove Programs
//
// Arguments:
// [in]
// pszFileExt
// FileExt that has to be queried on. ignored if NULL.
// pCategory
// Category that has to be queried on. ignored if NULL.
// dwAppFlags
// One of the APPINFO_XXX. ignored if it is APPINFO_ALL.
// pdwLocale
// Locale that has to be queried on. Ignored if NULL.
// pPlatform
// Platform that has to be queried on. Ignored if NULL.
//
// [out]
// ppIEnumPackage
// Enumerator is returned.
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
//
// Validates the inputs, Creates a EnumPackage object, makes up the
// search string made up of file extension, category.
//----------------------------------------------------------------
HRESULT CClassContainer::EnumPackages(
LPOLESTR pszFileExt,
GUID *pCategory,
DWORD dwAppFlags,
DWORD *pdwLocale,
CSPLATFORM *pPlatform,
IEnumPackage **ppIEnumPackage
)
{
HRESULT hr = S_OK;
CEnumPackage *pEnum = NULL;
WCHAR szfilter[1000], szQry[1000];
if (pszFileExt && IsBadStringPtr(pszFileExt, _MAX_PATH))
return E_INVALIDARG;
if (pCategory && !IsValidReadPtrIn(pCategory, sizeof(GUID)))
return E_INVALIDARG;
if (!IsValidPtrOut(ppIEnumPackage, sizeof(IEnumPackage *)))
return E_INVALIDARG;
*ppIEnumPackage = NULL;
pEnum = new CEnumPackage(m_PolicyId, m_szPolicyName);
if(NULL == pEnum)
return E_OUTOFMEMORY;
//
// Create a CommandText
//
wsprintf(szfilter, L"(& (objectClass=%s) ", CLASS_CS_PACKAGE);
if (pszFileExt)
{
wsprintf(szQry, L"(%s=%s*) ", PKGFILEEXTNLIST, pszFileExt);
wcscat(szfilter, szQry);
}
if (pCategory)
{
STRINGGUID szCat;
StringFromGUID (*pCategory, szCat);
wsprintf(szQry, L"(%s=%s) ", PKGCATEGORYLIST, szCat);
wcscat(szfilter, szQry);
}
wcscat(szfilter, L")");
hr = pEnum->Initialize(m_szPackageName, szfilter,
dwAppFlags, 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);
}
HRESULT CClassContainer::GetDNFromPackageName(LPOLESTR pszPackageName, LPOLESTR *szDN)
{
HRESULT hr = S_OK;
WCHAR szfilter[_MAX_PATH];
LPOLESTR AttrNames[] = {OBJECTCLASS, PACKAGEFLAGS, OBJECTDN};
DWORD cAttr = 3;
ADS_SEARCH_HANDLE hADsSearchHandle = NULL;
ADS_SEARCH_COLUMN column;
DWORD dwFlags = 0;
wsprintf(szfilter, L"%s=%s", PACKAGENAME, pszPackageName);
hr = ADSIExecuteSearch(m_ADsPackageContainer, szfilter, AttrNames, cAttr, &hADsSearchHandle);
RETURN_ON_FAILURE(hr);
for (hr = ADSIGetFirstRow(m_ADsPackageContainer, hADsSearchHandle);
((SUCCEEDED(hr)) && (hr != S_ADS_NOMORE_ROWS));
hr = ADSIGetNextRow(m_ADsPackageContainer, hADsSearchHandle))
{
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, PACKAGEFLAGS, &column);
if (SUCCEEDED(hr))
{
UnpackDWFrom(column, &dwFlags);
ADSIFreeColumn(m_ADsPackageContainer, &column);
}
else
continue;
if ((dwFlags & ACTFLG_Orphan) || (dwFlags & ACTFLG_Uninstall))
continue;
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, OBJECTDN, &column);
if (SUCCEEDED(hr))
{
UnpackStrAllocFrom(column, szDN);
ADSIFreeColumn(m_ADsPackageContainer, &column);
}
else
continue;
break;
}
if (hADsSearchHandle)
ADSICloseSearchHandle(m_ADsPackageContainer, hADsSearchHandle);
return hr;
}
// Gets the RDN of a package given the package Guid.
HRESULT CClassContainer::BuildDNFromPackageGuid(GUID PackageGuid, LPOLESTR *szDN)
{
HRESULT hr = S_OK;
LPOLESTR AttrName = {OBJECTDN};
WCHAR szfilter[_MAX_PATH];
ADS_SEARCH_HANDLE hADsSearchHandle = NULL;
ADS_SEARCH_COLUMN column;
LPWSTR EncodedGuid = NULL;
hr = ADsEncodeBinaryData((PBYTE)&PackageGuid, sizeof(GUID), &EncodedGuid);
wsprintf(szfilter, L"(%s=%s)", OBJECTGUID, EncodedGuid);
FreeADsMem(EncodedGuid);
hr = ADSIExecuteSearch(m_ADsPackageContainer, szfilter, &AttrName, 1, &hADsSearchHandle);
RETURN_ON_FAILURE(hr);
hr = ADSIGetFirstRow(m_ADsPackageContainer, hADsSearchHandle);
if ((FAILED(hr)) || (hr == S_ADS_NOMORE_ROWS))
{
ERROR_ON_FAILURE(hr = CS_E_PACKAGE_NOTFOUND);
}
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, AttrName, &column);
ERROR_ON_FAILURE(hr);
if (SUCCEEDED(hr))
{
UnpackStrAllocFrom(column, szDN);
}
ADSIFreeColumn(m_ADsPackageContainer, &column);
Error_Cleanup:
if (hADsSearchHandle)
ADSICloseSearchHandle(m_ADsPackageContainer, hADsSearchHandle);
return hr;
}
HRESULT CClassContainer::GetPackageGuid(WCHAR *szRDN, GUID *pPackageGuid)
{
HRESULT hr = S_OK;
LPOLESTR AttrName = {OBJECTGUID};
WCHAR szfilter[_MAX_PATH];
ADS_SEARCH_HANDLE hADsSearchHandle = NULL;
ADS_SEARCH_COLUMN column;
hr = ADSIExecuteSearch(m_ADsPackageContainer, szRDN, &AttrName, 1, &hADsSearchHandle);
RETURN_ON_FAILURE(hr);
hr = ADSIGetFirstRow(m_ADsPackageContainer, hADsSearchHandle);
if ((FAILED(hr)) || (hr == S_ADS_NOMORE_ROWS))
{
ERROR_ON_FAILURE(hr = CS_E_PACKAGE_NOTFOUND);
}
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, AttrName, &column);
ERROR_ON_FAILURE(hr);
if (SUCCEEDED(hr))
UnpackGUIDFrom(column, pPackageGuid);
ADSIFreeColumn(m_ADsPackageContainer, &column);
Error_Cleanup:
if (hADsSearchHandle)
ADSICloseSearchHandle(m_ADsPackageContainer, hADsSearchHandle);
return hr;
}
//---------------------------------------------------------------
//
// Function: GetPackageDetails
//
// Synopsis: Returns the PackageDetail corresponding to the PackageName.
//
// Arguments:
// [in]
// pszPackageId
// Id of the Package.
// [out]
// pPackageDetail
// PackageDetail info that is returned.
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
//
// Binds to the Package object and calls GetPackageDetail with it.
//----------------------------------------------------------------
HRESULT CClassContainer::GetPackageDetails (
LPOLESTR pszPackageName,
PACKAGEDETAIL * pPackageDetail
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR * szFullName = NULL;
ADS_ATTR_INFO * pAttr = NULL;
DWORD cgot = 0;
// this can be made into a search based API. Not required for the time being.
// Should change it if perf is a big issue.
if ((!pszPackageName) || IsBadStringPtr(pszPackageName, _MAX_PATH))
return E_INVALIDARG;
hr = GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
// binding to the package object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION, &hADs);
ERROR_ON_FAILURE(hr);
// calling GetPackageDetail.
hr = GetPackageDetail (hADs, m_szClassName, pPackageDetail);
ADSICloseDSObject(hADs);
if (pAttr)
FreeADsMem(pAttr);
if (szFullName)
CoTaskMemFree(szFullName);
Error_Cleanup:
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
//
// Function: GetPackageDetails
//
// Synopsis: Returns the PackageDetail corresponding to the PackageName.
//
// Arguments:
// [in]
// pszPackageId
// Id of the Package.
// [out]
// pPackageDetail
// PackageDetail info that is returned.
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
//
// Binds to the Package object and calls GetPackageDetail with it.
//----------------------------------------------------------------
HRESULT CClassContainer::GetPackageDetailsFromGuid (
GUID PkgGuid,
PACKAGEDETAIL *pPackageDetail
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR * szFullName = NULL, szRDN[_MAX_PATH];
ADS_ATTR_INFO * pAttr = NULL;
DWORD cgot = 0;
// this can be made into a search based API. Not required for the time being.
// Should change it if perf is a big issue.
if (IsNullGuid(PkgGuid))
return E_INVALIDARG;
BuildDNFromPackageGuid(PkgGuid, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
// binding to the package object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION, &hADs);
ERROR_ON_FAILURE(hr);
// calling GetPackageDetail.
hr = GetPackageDetail (hADs, m_szClassName, pPackageDetail);
ADSICloseDSObject(hADs);
if (pAttr)
FreeADsMem(pAttr);
if (szFullName)
CoTaskMemFree(szFullName);
Error_Cleanup:
return RemapErrorCode(hr, m_szContainerName);
}
#define FREEARR(ARR, SZ) { \
DWORD curIndex; \
for (curIndex = 0; curIndex < (SZ); curIndex++) \
CoTaskMemFree((ARR)[curIndex]); \
CoTaskMemFree(ARR); \
ARR = NULL; \
} \
//---------------------------------------------------------------
//
// Function: ChangePackageUpgradeInfoIncremental
//
// Synopsis: Mark the package as upgraded by another package
//
// Arguments:
// [in]
// PackageGuid
// Package Guid to identify the package.
// szUpgradedByClassStore
// Class Store where the package that upgrades exists
// UpgradedByPackageGuid
// The Guid of the package that upgrades
// Add Add or remove the upgradedByrelation
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Otherwise it packs all the required attributes in the ATTR_INFO
// structure and sends it to the Directory.
//----------------------------------------------------------------
HRESULT CClassContainer::ChangePackageUpgradeInfoIncremental(
GUID PackageGuid,
UPGRADEINFO UpgradeInfo,
DWORD OpFlags
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szFullName=NULL, szGuid[_MAX_PATH], szUsn[20];
LPOLESTR pProp = NULL;
ADS_ATTR_INFO pAttr[2];
DWORD cAttr = 0, cModified = 0, i=0;
UINT len=0;
hr = BuildDNFromPackageGuid(PackageGuid, &szFullName);
ERROR_ON_FAILURE(hr);
// Bind to the Package Object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND, &hADs);
ERROR_ON_FAILURE(hr);
StringFromGUID(UpgradeInfo.PackageGuid, szGuid);
len = wcslen(UpgradeInfo.szClassStore);
pProp = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR) *(36+PKG_UPG_DELIM1_LEN+len+PKG_UPG_DELIM2_LEN+2+2+1));
// Guid size+::+length++:+flagDigit+2
wsprintf(pProp, L"%s%s%s%s%02x", UpgradeInfo.szClassStore, PKG_UPG_DELIMITER1, szGuid, PKG_UPG_DELIMITER2, UpgradeInfo.Flag%16);
PackStrArrToAttrEx(pAttr+cAttr, UPGRADESPACKAGES, &pProp, 1, OpFlags?TRUE:FALSE);
cAttr++;
//
// Update the TimeStamp
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (hADs)
ADSICloseDSObject(hADs);
// ignore it if the property already exists.
if (hr == HRESULT_FROM_WIN32(ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS))
hr = S_OK;
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
Error_Cleanup:
if (szFullName)
CoTaskMemFree(szFullName);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
//
// Function: ChangePackageProperties
//
// Synopsis: Change Various (most commonly changed) properties
// for a given package.
//
// Arguments:
// [in]
// PackageId
// Package Id to identify the package.
// pszNewname
// new Name for the Package. If it is being renamed
// all other changes should be NULL.
// pdwFlags
// The Deployment Flags. Should be ACTFLG_XXX
// Ignored if NULL.
// pszUrl
// Help Url for the Package. Ignored if NULL.
// pszScriptPath
// Script Path for the Package. Ignored if NULL.
// pInstallUiLevel
// The InstallationUiLevel. Ignored if NULL.
// pdwRevision
// REVISION. Ignored if NULL.
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Otherwise it packs all the required attributes in the ATTR_INFO
// structure and sends it to the Directory.
//----------------------------------------------------------------
HRESULT CClassContainer::ChangePackageProperties(
LPOLESTR pszPackageName,
LPOLESTR pszNewName,
DWORD *pdwFlags,
LPOLESTR pszUrl,
LPOLESTR pszScriptPath,
UINT *pInstallUiLevel,
DWORD *pdwRevision
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szRDN=NULL, *szFullName=NULL;
WCHAR szUsn[20];
ADS_ATTR_INFO pAttr[7];
DWORD cAttr = 0, cModified = 0, i=0;
if ((!pszPackageName) || IsBadStringPtr(pszPackageName, _MAX_PATH))
return E_INVALIDARG;
hr = GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
// if no properties have to be changed.
if (!(pszScriptPath || pszUrl || pdwFlags || pInstallUiLevel || pdwRevision || pszNewName))
return E_INVALIDARG;
if (pszNewName)
{
// rename package
WCHAR szNewRDN[_MAX_PATH];
BOOL GenerateGuid = FALSE;
GUID PackageGuidId;
WCHAR pszPackageNewId[_MAX_PATH], *szJunk = NULL;
if (IsBadStringPtr(pszNewName, _MAX_PATH))
return E_INVALIDARG;
if (pszScriptPath || pszUrl || pdwFlags || pInstallUiLevel || pdwRevision)
return E_INVALIDARG;
// see whether the new name is valid.
// GenerateGuid = InvalidDSName(pszNewName);
// see whether the newName already exists. Notice that if the same package name is
// entered it will return error.
hr = GetDNFromPackageName(pszNewName, &szJunk);
if (szJunk)
CoTaskMemFree(szJunk);
szJunk = NULL;
ERROR_ON_FAILURE(hr);
if (hr == S_OK)
return CS_E_OBJECT_ALREADY_EXISTS;
/*
packages are going to have a guid as a name and nothing else.
// generate guid if required.
if (GenerateGuid)
{
CoCreateGuid(&PackageGuidId);
StringFromGUID(PackageGuidId, pszPackageNewId);
}
else
wcscpy(pszPackageNewId, pszNewName);
// generate the new RDN
wsprintf(szNewRDN, L"CN=%s", pszPackageNewId);
BuildADsParentPath(szFullName, &szJunk, &szRDN);
if (szJunk)
FreeADsMem(szJunk);
hr = ADSIModifyRdn(m_ADsPackageContainer, szRDN, szNewRDN);
if (szRDN)
FreeADsMem(szRDN);
ERROR_ON_FAILURE(hr);
if (szFullName)
CoTaskMemFree(szFullName);
szFullName = NULL;
// construct the Full Path for the Package.
BuildADsPathFromParent(m_szPackageName, szNewRDN, &szFullName);
*/
// Bind to the Package Object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
if (szFullName)
FreeADsMem(szFullName);
szFullName = NULL;
ERROR_ON_FAILURE(hr);
}
else
{
// Bind to the Package Object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
if (szFullName)
CoTaskMemFree(szFullName);
szFullName = NULL;
}
// Just change some properties.
//
// Update the TimeStamp
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
//
// Change Package Flags
//
if (pdwFlags)
{
PackDWToAttr (pAttr+cAttr, PACKAGEFLAGS, *pdwFlags);
cAttr++;
}
//
// Change Package Script
//
if (pszScriptPath)
{
PackStrToAttr(pAttr+cAttr, SCRIPTPATH, pszScriptPath);
cAttr++;
}
//
// Change Package Help URL
//
if (pszUrl)
{
PackStrToAttr(pAttr+cAttr, HELPURL, pszUrl);
cAttr++;
}
//
// Change Package UI Level.
//
if (pInstallUiLevel)
{
PackDWToAttr (pAttr+cAttr, UILEVEL, *pInstallUiLevel);
cAttr++;
}
//
// Change Revision.
//
if (pdwRevision)
{
PackDWToAttr (pAttr+cAttr, REVISION, *pdwRevision);
cAttr++;
}
if (pszNewName)
{
PackStrToAttr(pAttr+cAttr, PACKAGENAME, pszNewName);
cAttr++;
}
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (hADs)
ADSICloseDSObject(hADs);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (SUCCEEDED(hr))
{
//
// Update Class Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
Error_Cleanup:
if (szFullName)
CoTaskMemFree(szFullName);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: ChangePackageCategories
//
// Synopsis: Change (Not Add) the Categories that a package
// belongs to.
//
// Arguments:
// [in]
// pszPackageName
// Package Name to identify the package.
// cCategories
// Number of Categories.
// rpCategory
// Array of categories.
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Binds to the Package Object, Converts all the categories to strings
// Packs it and sends it to the DS.
//----------------------------------------------------------------
HRESULT CClassContainer::ChangePackageCategories(
LPOLESTR pszPackageName,
UINT cCategories,
GUID *rpCategory
)
{
//
// Does not change USN
//
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szFullName = NULL;
LPOLESTR *pszGuid = NULL;
UINT count;
ADS_ATTR_INFO pAttr[1];
DWORD cAttr = 0, cModified = 0, i=0;
if ((!pszPackageName) || IsBadStringPtr(pszPackageName, _MAX_PATH))
return E_INVALIDARG;
if ((cCategories) && ((!rpCategory) ||
(!IsValidReadPtrIn(rpCategory, sizeof(GUID) * cCategories))))
return E_INVALIDARG;
// Construct the Name of the Package Object.
GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
// fill in the categories
pszGuid = (LPOLESTR *)CoTaskMemAlloc(cCategories * sizeof(LPOLESTR));
if (!pszGuid)
{
hr = E_OUTOFMEMORY;
ERROR_ON_FAILURE(hr);
}
// convert the GUIDs to Strings.
for (count = 0; (count < cCategories); count++)
{
pszGuid[count] = (LPOLESTR)CoTaskMemAlloc(STRINGGUIDLEN*sizeof(WCHAR));
if (!(pszGuid[count]))
{
FREEARR(pszGuid, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
StringFromGUID(rpCategory[count], pszGuid[count]);
}
// Pack it into Attribute Structure.
PackStrArrToAttr(pAttr+cAttr, PKGCATEGORYLIST, pszGuid, cCategories);
cAttr++;
// Set the Attribute
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
Error_Cleanup:
if (hADs)
ADSICloseDSObject(hADs);
if (pszGuid)
for (count = 0; (count < cCategories); count++)
CoTaskMemFree(pszGuid[count]);
CoTaskMemFree(pszGuid);
if (szFullName)
CoTaskMemFree(szFullName);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: SetPriorityByFileExt
//
// Synopsis: Changes the priority of a Package corresp. to
// a file Extension.
//
// Arguments:
// [in]
// pszPackageName
// Package Name to identify the package.
// pszFileExt
// File Extension for which the priority has to be changed.
// Priority
// Priority for the Package.
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Binds to the Package Object, Gets the file Extensions and changes
// the priority corresponding to the File Extension.
//----------------------------------------------------------------
HRESULT CClassContainer::SetPriorityByFileExt(
LPOLESTR pszPackageName,
LPOLESTR pszFileExt,
UINT Priority
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szFullName=NULL;
LPOLESTR *prgFileExt = NULL;
WCHAR szUsn[20];
ADS_ATTR_INFO pAttr[4], *pAttrGot = NULL;
DWORD cAttr = 0, cAttrGot = 0, cModified = 0, cShellFileExt = 0, i=0;
LPOLESTR pAttrNames[] = {PKGFILEEXTNLIST};
// Construct the Package Name
GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
// Bind to the Package Object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
//
// Update the TimeStamp
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
// get the file extensions.
hr = ADSIGetObjectAttributes(hADs, pAttrNames, 1, &pAttrGot, &cAttrGot);
if ((SUCCEEDED(hr)) && (cAttrGot))
UnpackStrArrFrom(pAttrGot[0], &prgFileExt, &cShellFileExt);
// Look for the given file extension.
for (i=0; i < cShellFileExt; ++i)
{
if (wcsncmp(prgFileExt[i], pszFileExt, wcslen(pszFileExt)) == 0)
{
// if the file extension is found, change the corresponding priority.
if (wcslen(prgFileExt[i]) != (wcslen(pszFileExt)+3))
continue;
wsprintf(prgFileExt[i], L"%s:%2d", pszFileExt, Priority%100);
break;
}
}
if (i == cShellFileExt)
{
ERROR_ON_FAILURE(hr = CS_E_OBJECT_NOTFOUND);
}
if (cShellFileExt)
{
PackStrArrToAttr(pAttr+cAttr, PKGFILEEXTNLIST, prgFileExt, cShellFileExt);
cAttr++;
}
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (SUCCEEDED(hr))
{
//
// Update Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
Error_Cleanup:
CoTaskMemFree(prgFileExt);
if (szFullName)
CoTaskMemFree(szFullName);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (pAttrGot)
FreeADsMem(pAttrGot);
ADSICloseDSObject(hADs);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: ChangePackageSourceList
//
// Synopsis: Changes the priority of a Package corresp. to
// a file Extension.
//
// Arguments:
// [in]
// pszPackageName
// Package Name to identify the package.
// cSources
// Number of sources
// pszSourceList
// List of sources
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Binds to the Package Object, Makes the new sourcelist with the order
// maintained.
//----------------------------------------------------------------
HRESULT CClassContainer::ChangePackageSourceList(
LPOLESTR pszPackageName,
UINT cSources,
LPOLESTR *pszSourceList
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szFullName = NULL;
UINT count;
WCHAR szUsn[20];
LPOLESTR *pszPrioritySourceList = NULL;
ADS_ATTR_INFO pAttr[2];
DWORD cAttr = 0, cModified = 0, i=0;
if ((!pszPackageName) || IsBadStringPtr(pszPackageName, _MAX_PATH))
return E_INVALIDARG;
if ((!pszSourceList) ||
(!IsValidReadPtrIn(pszSourceList, sizeof(LPOLESTR) * cSources)))
return E_INVALIDARG;
for (count = 0; (count < cSources); count++)
if ((!pszSourceList[count]) || (IsBadStringPtr(pszSourceList[count], _MAX_PATH)))
return E_INVALIDARG;
// Construct the Name of the Package Object.
GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
// Local variable for adding the order to the list.
pszPrioritySourceList = (LPOLESTR *)CoTaskMemAlloc(cSources * sizeof(LPOLESTR));
if (!pszPrioritySourceList)
{
hr = E_OUTOFMEMORY;
ERROR_ON_FAILURE(hr);
}
// add the order to the list
for (count = 0; (count < cSources); count++)
{
pszPrioritySourceList[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*(wcslen(pszSourceList[count])+
1+1+1+NumDigits10(cSources)));
if (!(pszPrioritySourceList[count]))
{
FREEARR(pszPrioritySourceList, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
wsprintf(pszPrioritySourceList[count], L"%d:%s", count, pszSourceList[count]);
}
//
// Update the TimeStamp
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
// Pack it into Attribute Structure.
PackStrArrToAttr(pAttr+cAttr, MSIFILELIST, pszPrioritySourceList, cSources);
cAttr++;
// Set the Attribute
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (SUCCEEDED(hr))
{
//
// Update Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
Error_Cleanup:
if (hADs)
ADSICloseDSObject(hADs);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (szFullName)
CoTaskMemFree(szFullName);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: ChangePackageUpgradeList
//
// Synopsis: Changes the priority of a Package corresp. to
// a file Extension.
//
// Arguments:
// [in]
// pszPackageName
// Package Name to identify the package.
// cSources
// Number of sources
// pszSourceList
// List of sources
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
// Binds to the Package Object, Makes the new sourcelist with the order
// maintained.
//----------------------------------------------------------------
HRESULT CClassContainer::ChangePackageUpgradeList(
LPOLESTR pszPackageName,
UINT cUpgrades,
UPGRADEINFO *prgUpgradeInfoList
)
{
HRESULT hr = S_OK;
HANDLE hADs = NULL;
WCHAR *szFullName = NULL;
UINT count = 0, count1 = 0, count2 = 0;
LPOLESTR *pProp = NULL, pAttrNames[2] = {UPGRADESPACKAGES, OBJECTGUID}, *rpszUpgrades = NULL;
ADS_ATTR_INFO pAttr[2], *pAttrGot = NULL;
DWORD cAttr = 0, cModified = 0, i=0, posn = 0, cUpgradeInfoStored = 0,
cAddList = 0, cRemoveList = 0, cgot = 0;
GUID PkgGuid;
WCHAR szUsn[20];
UPGRADEINFO *pUpgradeInfoStored = NULL, *pAddList = NULL, *pRemoveList = NULL;
if ((!pszPackageName) || IsBadStringPtr(pszPackageName, _MAX_PATH))
return E_INVALIDARG;
if ((cUpgrades) && ((!prgUpgradeInfoList) ||
(!IsValidReadPtrIn(prgUpgradeInfoList, sizeof(UPGRADEINFO) * cUpgrades))))
return E_INVALIDARG;
for (count = 0; (count < cUpgrades); count++)
{
if ((!(prgUpgradeInfoList[count].szClassStore)) ||
IsBadStringPtr((prgUpgradeInfoList[count].szClassStore), _MAX_PATH))
return E_INVALIDARG;
if (IsNullGuid(prgUpgradeInfoList[count].PackageGuid))
return E_INVALIDARG;
if (((prgUpgradeInfoList[count].Flag & UPGFLG_Uninstall) == 0) &&
((prgUpgradeInfoList[count].Flag & UPGFLG_NoUninstall) == 0) &&
((prgUpgradeInfoList[count].Flag & UPGFLG_UpgradedBy) == 0))
return E_INVALIDARG;
}
// Construct the Name of the Package Object.
hr = GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
// get the guid and upgrade info
hr = ADSIGetObjectAttributes(hADs, pAttrNames, 2, &pAttrGot, &cgot);
// Package guid
posn = GetPropertyFromAttr(pAttrGot, cgot, OBJECTGUID);
if (posn < cgot)
UnpackGUIDFrom(pAttrGot[posn], &PkgGuid);
// Upgrade package
posn = GetPropertyFromAttr(pAttrGot, cgot, UPGRADESPACKAGES);
if (posn < cgot)
UnpackStrArrFrom(pAttrGot[posn], &pProp, &cUpgradeInfoStored);
// allocating the lists
pUpgradeInfoStored = (UPGRADEINFO *)CoTaskMemAlloc(sizeof(UPGRADEINFO)*(cUpgradeInfoStored));
pAddList = (UPGRADEINFO *)CoTaskMemAlloc(sizeof(UPGRADEINFO)*(cUpgrades+cUpgradeInfoStored));
pRemoveList = (UPGRADEINFO *)CoTaskMemAlloc(sizeof(UPGRADEINFO)*(cUpgrades+cUpgradeInfoStored));
if ((!pUpgradeInfoStored) || (!pAddList) || (!pRemoveList))
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
// convert the strings to upgradinfo structures.
for (count = 0; count < (cUpgradeInfoStored); count++)
{
WCHAR *pStr = NULL;
LPOLESTR ptr = pProp[count];
UINT len = wcslen (ptr);
pUpgradeInfoStored[count].szClassStore = pProp[count];
if (len <= 41)
continue;
*(ptr + len - 3) = NULL;
pUpgradeInfoStored[count].Flag = wcstoul(ptr+(len-2), &pStr, 16);
*(ptr + len - 3 - 36 - 2) = L'\0';
/* -GUID-'::'*/
GUIDFromString(ptr+len-3-36, &(pUpgradeInfoStored[count].PackageGuid));
}
cUpgradeInfoStored = count; // we might have skipped some.
// AddList formed.
for (count = 0; count < cUpgrades; count++)
{
for (count1 = 0; count1 < cUpgradeInfoStored; count1++)
{
// ignore flag changes
if ((wcscmp(pUpgradeInfoStored[count1].szClassStore, prgUpgradeInfoList[count].szClassStore) == 0) &&
(memcmp(&pUpgradeInfoStored[count1].PackageGuid, &prgUpgradeInfoList[count].PackageGuid, sizeof(GUID)) == 0))
break;
}
if (count1 == cUpgradeInfoStored)
pAddList[cAddList++] = prgUpgradeInfoList[count];
}
// remove list formed.
for (count1 = 0; count1 < cUpgradeInfoStored; count1++)
{
for (count = 0; count < cUpgrades; count++)
{
// ignore flag changes
if ((wcscmp(pUpgradeInfoStored[count1].szClassStore, prgUpgradeInfoList[count].szClassStore) == 0) &&
(memcmp(&pUpgradeInfoStored[count1].PackageGuid, &prgUpgradeInfoList[count].PackageGuid, sizeof(GUID)) == 0))
break;
}
if (count == cUpgrades)
pRemoveList[cRemoveList++] = pUpgradeInfoStored[count];
}
for (count = 0; count < cAddList; count++)
{
// in case of UpgradedBy do no try to fix up the links.
if (!(pAddList[count].Flag & UPGFLG_UpgradedBy))
{
DWORD Flags = 0;
if (pAddList[count].Flag & UPGFLG_Enforced)
Flags = UPGFLG_Enforced;
}
}
for (count = 0; count < cRemoveList; count++)
{
// in case of UpgradedBy do no try to fix up the links.
if (!(pRemoveList[count].Flag & UPGFLG_UpgradedBy))
{
DWORD Flags = 0;
if (pRemoveList[count].Flag & UPGFLG_Enforced)
Flags = UPGFLG_Enforced;
}
}
rpszUpgrades = (LPOLESTR *)CoTaskMemAlloc(sizeof(LPOLESTR)*cUpgrades);
if (!rpszUpgrades)
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
for (count = 0; (count < cUpgrades); count++)
{
WCHAR szPackageGuid[_MAX_PATH];
UINT len = wcslen(prgUpgradeInfoList[count].szClassStore);
rpszUpgrades[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR) *(36+PKG_UPG_DELIM1_LEN+len+PKG_UPG_DELIM2_LEN+2+2));
// Guid size+::+length++:+flagDigit+2
if (!rpszUpgrades[count])
{
FREEARR(rpszUpgrades, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
StringFromGUID(prgUpgradeInfoList[count].PackageGuid, szPackageGuid);
wsprintf(rpszUpgrades[count], L"%s%s%s%s%02x", prgUpgradeInfoList[count].szClassStore, PKG_UPG_DELIMITER1, szPackageGuid,
PKG_UPG_DELIMITER2, prgUpgradeInfoList[count].Flag%16);
}
PackStrArrToAttr(pAttr+cAttr, UPGRADESPACKAGES, rpszUpgrades, cUpgrades);
cAttr++;
//
// Update the TimeStamp
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
// Set the Attribute
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (SUCCEEDED(hr))
{
//
// Update Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
Error_Cleanup:
if (hADs)
ADSICloseDSObject(hADs);
if (szFullName)
CoTaskMemFree(szFullName);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (pAttrGot)
FreeADsMem(pAttrGot);
if (pProp)
CoTaskMemFree(pProp);
if (pUpgradeInfoStored)
CoTaskMemFree(pUpgradeInfoStored);
if (pAddList)
CoTaskMemFree(pAddList);
if (pRemoveList)
CoTaskMemFree(pRemoveList);
return RemapErrorCode(hr, m_szContainerName);
}
extern LPOLESTR szAppCategoryColumns;
//---------------------------------------------------------------
// Function: GetAppCategories
//
// Synopsis: gets the list of Package Categories in the Domain.
//
// Arguments:
// [in]
// Locale
// Locale for the categories. Used to get the description.
// [out]
// pAppCategoryList
// the list of Application Categories in the domain
//
// Returns:
// S_OK, E_OUTOFMEMORY, CS_E_XXX
//
// Gets the FullName of the Domain, binds to the AppCategory container
// below that. and gets all the categories with approp. types.
//----------------------------------------------------------------
HRESULT CClassContainer::GetAppCategories (
LCID Locale,
APPCATEGORYINFOLIST *pAppCategoryList
)
{
HRESULT hr = S_OK;
WCHAR szfilter[_MAX_PATH];
WCHAR szRootPath[_MAX_PATH], szAppCategoryContainer[_MAX_PATH];
HANDLE hADs = NULL;
ADS_SEARCH_HANDLE hADsSearchHandle = NULL;
ADS_SEARCHPREF_INFO SearchPrefs[2];
// set the search preference.
SearchPrefs[0].dwSearchPref = ADS_SEARCHPREF_SEARCH_SCOPE;
SearchPrefs[0].vValue.dwType = ADSTYPE_INTEGER;
SearchPrefs[0].vValue.Integer = ADS_SCOPE_ONELEVEL;
// we do not expect too many categories
SearchPrefs[1].dwSearchPref = ADS_SEARCHPREF_PAGESIZE;
SearchPrefs[1].vValue.dwType = ADSTYPE_INTEGER;
SearchPrefs[1].vValue.Integer = 20;
if (!IsValidPtrOut(pAppCategoryList, sizeof(APPCATEGORYINFOLIST)))
return E_INVALIDARG;
// get the name of the domain.
hr = GetRootPath(szRootPath);
ERROR_ON_FAILURE(hr);
// Names returned by GetRootPath are in only 1 format and we don't need to
// use BuildADsPath.
wsprintf(szAppCategoryContainer, L"%s%s%s", LDAPPREFIX, APPCATEGORYCONTAINERNAME,
szRootPath+LDAPPREFIXLENGTH);
wsprintf(szfilter, L"(objectClass=%s)", CLASS_CS_CATEGORY);
//binds to the category container
hr = ADSIOpenDSObject(szAppCategoryContainer, NULL, NULL,
ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND, &hADs);
ERROR_ON_FAILURE(hr);
hr = ADSISetSearchPreference(hADs, SearchPrefs, 2);
ERROR_ON_FAILURE(hr);
// gets a search handle
hr = ADSIExecuteSearch(hADs, szfilter, pszCategoryAttrNames, cCategoryAttr, &hADsSearchHandle);
ERROR_ON_FAILURE(hr);
// tries to find out the number of categories.
pAppCategoryList->cCategory = 0;
for (hr = ADSIGetFirstRow(hADs, hADsSearchHandle);
((SUCCEEDED(hr)) && (hr != S_ADS_NOMORE_ROWS));
hr = ADSIGetNextRow(hADs, hADsSearchHandle))
pAppCategoryList->cCategory++;
// get the number of elements.
pAppCategoryList->pCategoryInfo = (APPCATEGORYINFO *)CoTaskMemAlloc(
sizeof(APPCATEGORYINFO)*
pAppCategoryList->cCategory);
if (!(pAppCategoryList->pCategoryInfo))
{
pAppCategoryList->cCategory = 0;
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
// if it has come till here, it has to have a search handle
ADSICloseSearchHandle(hADs, hADsSearchHandle);
hADsSearchHandle = NULL;
memset(pAppCategoryList->pCategoryInfo, 0, sizeof(APPCATEGORYINFO)*pAppCategoryList->cCategory);
// gets a search handle
hr = ADSIExecuteSearch(hADs, szfilter, pszCategoryAttrNames, cCategoryAttr, &hADsSearchHandle);
ERROR_ON_FAILURE(hr);
// passes the search handle and gets the categorylist.
hr = FetchCategory(hADs, hADsSearchHandle, pAppCategoryList, Locale);
ERROR_ON_FAILURE(hr);
Error_Cleanup:
if (hADsSearchHandle)
ADSICloseSearchHandle(hADs, hADsSearchHandle);
if (hADs)
ADSICloseDSObject(hADs);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: RegisterAppCategory
//
// Synopsis: Adda category and assoc desc. for the whole Domain(This is per domain
// and not per class store.)
//
// Arguments:
// [in]
// pAppCategory
// Pointer to a APPCATEGORYINFO structure to be added.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Finds the root path of the domain. binds to the category container
// underneath it. deletes this particular AppCategory.
//----------------------------------------------------------------
HRESULT CClassContainer::RegisterAppCategory (
APPCATEGORYINFO *pAppCategory
)
{
WCHAR szRootPath[_MAX_PATH], localedescription[128+16],
szAppCategoryContainer[_MAX_PATH], szRDN[_MAX_PATH],
* szFullName = NULL, szAppCatid[_MAX_PATH];
HRESULT hr = S_OK;
HANDLE hADsContainer = NULL, hADs = NULL;
ULONG i, j, cdesc = 0, posn = 0;
LPOLESTR * pszDescExisting = NULL, pszDesc = NULL;
LPOLESTR AttrName = LOCALEDESCRIPTION;
ADS_ATTR_INFO * pAttrGot = NULL, pAttr[6];
DWORD cgot = 0, cAttr = 0;
BOOL fExists = TRUE;
if ((!pAppCategory) || (!IsValidReadPtrIn(pAppCategory, sizeof(APPCATEGORYINFO))))
return E_INVALIDARG;
if ((pAppCategory->pszDescription == NULL) ||
(IsBadStringPtr(pAppCategory->pszDescription, _MAX_PATH)))
return E_INVALIDARG;
if (IsNullGuid(pAppCategory->AppCategoryId))
return E_INVALIDARG;
// get the name of the root of the domain
hr = GetRootPath(szRootPath);
ERROR_ON_FAILURE(hr);
// Bind to a AppCategory container
// Names returned by GetRootPath are in only 1 format and we don't need to
// use BuildADsPath.
wsprintf(szAppCategoryContainer, L"%s%s%s", LDAPPREFIX, APPCATEGORYCONTAINERNAME,
szRootPath+LDAPPREFIXLENGTH);
// container is supposed to exist.
hr = ADSIOpenDSObject(szAppCategoryContainer, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADsContainer);
ERROR_ON_FAILURE(hr);
RDNFromGUID(pAppCategory->AppCategoryId, szRDN);
wsprintf(localedescription, L"%x %s %s", pAppCategory->Locale, CAT_DESC_DELIMITER,
pAppCategory->pszDescription);
BuildADsPathFromParent(szAppCategoryContainer, szRDN, &szFullName);
// BUGBUG:: ADS_FAST_BIND and the create seems to be going twice. why?
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND, &hADs);
if (SUCCEEDED(hr))
hr = ADSIGetObjectAttributes(hADs, &AttrName, 1, &pAttrGot, &cgot);
if (SUCCEEDED(hr))
{
fExists = TRUE;
}
else
{
fExists = FALSE;
PackStrToAttr(pAttr, OBJECTCLASS, CLASS_CS_CATEGORY); cAttr++;
PackGUIDToAttr(pAttr+cAttr, CATEGORYCATID, &(pAppCategory->AppCategoryId)); cAttr++;
hr = ADSICreateDSObject(hADsContainer, szRDN, pAttr, cAttr);
for (j = 0; j < cAttr; j++)
FreeAttr(pAttr[j]);
cAttr = 0;
if (hADs)
{
ADSICloseDSObject(hADs);
hADs = NULL;
}
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND, &hADs);
}
if (szFullName)
FreeADsMem(szFullName);
ERROR_ON_FAILURE(hr);
if (fExists) {
if (cgot)
{
UnpackStrArrFrom(pAttrGot[0], &pszDescExisting, &cdesc);
}
// Existing list of descriptions
if (posn = FindDescription(pszDescExisting, cdesc, &(pAppCategory->Locale), NULL, 0))
{ // Delete the old value
PackStrArrToAttrEx(pAttr+cAttr, LOCALEDESCRIPTION, pszDescExisting+(posn-1), 1, FALSE); cAttr++;
}
CoTaskMemFree(pszDescExisting);
}
pszDesc = localedescription;
PackStrArrToAttrEx(pAttr+cAttr, LOCALEDESCRIPTION, &pszDesc, 1, TRUE);
cAttr++;
DWORD cModified;
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
Error_Cleanup:
if (pAttrGot)
FreeADsMem(pAttrGot);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (hADs)
ADSICloseDSObject(hADs);
if (hADsContainer)
ADSICloseDSObject(hADsContainer);
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: UnregisterAppCategory
//
// Synopsis: Removes a category from the whole Domain(This is per domain)
// and not per class store.
//
// Arguments:
// [in]
// pAppCategoryId
// Pointer to a GUID that has to be removed.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Finds the root path of the domain. binds to the category container
// underneath it. deletes this particular AppCategory.
//----------------------------------------------------------------
HRESULT CClassContainer::UnregisterAppCategory (
GUID *pAppCategoryId
)
{
WCHAR szRootPath[_MAX_PATH], szRDN[_MAX_PATH],
szAppCategoryContainer[_MAX_PATH];
HRESULT hr = S_OK;
HANDLE hADs = NULL;
if (!IsValidReadPtrIn(pAppCategoryId, sizeof(GUID)))
return E_INVALIDARG;
hr = GetRootPath(szRootPath);
// Bind to a AppCategory container
// Names returned by GetRootPath are in only 1 format and we don't need to
// use BuildADsPath.
wsprintf(szAppCategoryContainer, L"%s%s%s", LDAPPREFIX, APPCATEGORYCONTAINERNAME,
szRootPath+LDAPPREFIXLENGTH);
hr = ADSIOpenDSObject(szAppCategoryContainer, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
ERROR_ON_FAILURE(hr);
RDNFromGUID(*pAppCategoryId, szRDN);
hr = ADSIDeleteDSObject(hADs, szRDN);
ADSICloseDSObject(hADs);
// Delete this category
Error_Cleanup:
return RemapErrorCode(hr, m_szContainerName);
}
//---------------------------------------------------------------
// Function: DeletePackage
//
// Synopsis: Permanently remove a package and the associated Classes
// from class store
//
// Arguments:
// [in]
// PackageGuid
// Guid of the package that has to be removed.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Deletes the package and all the clsids associated with the
// package (using DeleteClass) Ignores the error from DeleteClass
// Tries to delete all the upgrade relationships from this package.
// Errors are ignored.
//----------------------------------------------------------------
HRESULT CClassContainer::DeletePackage (LPOLESTR szFullName
)
{
HRESULT hr = S_OK;
DWORD cStr = 0, count = 0, cgot = 0, posn = 0;
LPOLESTR szRDN = NULL, szJunk = NULL;
LPOLESTR * szStr = NULL;
LPOLESTR pAttrName[] = {PKGCLSIDLIST, UPGRADESPACKAGES, OBJECTGUID};
ADS_ATTR_INFO * pAttr = NULL;
HANDLE hADs = NULL;
WCHAR szUsn[20];
GUID PackageGuid;
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND,
&hADs);
if (!SUCCEEDED(hr))
return hr;
GetCurrentUsn(szUsn);
hr = ADSIGetObjectAttributes(hADs, pAttrName, 3, &pAttr, &cgot);
memset(&PackageGuid, 0, sizeof(GUID));
posn = GetPropertyFromAttr(pAttr, cgot, OBJECTGUID);
if (posn < cgot)
UnpackGUIDFrom(pAttr[posn], &PackageGuid);
posn = GetPropertyFromAttr(pAttr, cgot, PKGCLSIDLIST);
if (posn < cgot)
UnpackStrArrFrom(pAttr[posn], &szStr, &cStr);
for (count = 0; count < cStr; count++)
{
if (wcslen(szStr[count]) > (STRINGGUIDLEN-1))
szStr[count][STRINGGUIDLEN-1] = L'\0';
hr = DeleteClass(szStr[count]);
}
if (szStr)
CoTaskMemFree(szStr);
szStr = NULL;
cStr = 0;
posn = GetPropertyFromAttr(pAttr, cgot, UPGRADESPACKAGES);
if (posn < cgot)
UnpackStrArrFrom(pAttr[posn], &szStr, &cStr);
for (count = 0; count < cStr; count++)
{
GUID UpgradeeGuid;
WCHAR *pStr = NULL;
LPOLESTR ptr = szStr[count];
UINT len = wcslen (ptr);
DWORD UpgradeFlag, Flags = 0;
if (len <= 41)
continue;
*(ptr + (len - 3)) = NULL;
UpgradeFlag = wcstoul(ptr+(len-2), &pStr, 16);
*(ptr + (len - 3 - 36 - 2)) = L'\0';
/* -GUID-'::'*/
GUIDFromString(ptr+len-3-36, &UpgradeeGuid);
if (UpgradeFlag & UPGFLG_Enforced)
Flags = UPGFLG_Enforced;
}
if (szStr)
CoTaskMemFree(szStr);
szStr = NULL;
cStr = 0;
// ignore errors
if (pAttr)
FreeADsMem(pAttr);
ADSICloseDSObject(hADs);
BuildADsParentPath(szFullName, &szJunk, &szRDN);
if (szJunk)
FreeADsMem(szJunk);
hr = ADSIDeleteDSObject(m_ADsPackageContainer, szRDN);
if (szRDN)
FreeADsMem(szRDN);
if (SUCCEEDED(hr))
{
//
// Update Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
return hr;
}
//---------------------------------------------------------------
// Function: RemovePackage
//
// Synopsis: Mark a package as disabled or orphaned
// Or permanently remove a package and the associated Classes
// from class store
//
// Arguments:
// [in]
// PackageGuid
// Guid of the package that has to be removed.
// [in]
// dwFlags
// The new flags for the package. To delete the package explicitly
// use flag zero or orphan.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Calls Delete package if the flags is zero or Orphan.
// Otherwise it sets the new flags and stamps the new time stamp.
//----------------------------------------------------------------
HRESULT CClassContainer::RemovePackage (
LPOLESTR pszPackageName,
DWORD dwFlags
)
{
HRESULT hr = S_OK;
WCHAR *szRDN = NULL, *szFullName = NULL;
HANDLE hADs = NULL;
WCHAR szUsn[20];
ADS_ATTR_INFO pAttr[7];
DWORD cAttr = 0, cModified = 0, i=0;
if ((dwFlags != 0) && (dwFlags != ACTFLG_Orphan) && (dwFlags != ACTFLG_Uninstall))
return E_INVALIDARG;
hr = GetDNFromPackageName(pszPackageName, &szFullName);
ERROR_ON_FAILURE(hr);
if (hr != S_OK)
return CS_E_OBJECT_NOTFOUND;
if (dwFlags == 0)
// delete the package from the class store
{
hr = DeletePackage(szFullName);
}
else
{
GUID NewPackageId;
WCHAR szNewRDN[_MAX_PATH], *szRDN = NULL, *szJunk = NULL;
//
// PackageName is unchanged.
//
GetCurrentUsn(szUsn);
/*
CoCreateGuid(&NewPackageId);
RDNFromGUID(NewPackageId, szNewRDN);
BuildADsParentPath(szFullName, &szJunk, &szRDN);
if (szJunk)
FreeADsMem(szJunk);
hr = ADSIModifyRdn(m_ADsPackageContainer, szRDN, szNewRDN);
if (szRDN)
FreeADsMem(szRDN);
ERROR_ON_FAILURE(hr);
// construct the Full Path for the Package.
BuildADsPathFromParent(m_szPackageName, szNewRDN, &szFullName);
*/
// Bind to the Package Object.
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION | ADS_FAST_BIND, &hADs);
ERROR_ON_FAILURE(hr);
// setting the flag as orphan/uninstall
PackDWToAttr (pAttr+cAttr, PACKAGEFLAGS, dwFlags);
cAttr++;
// stamping the modification time for cleanup later.
PackStrToAttr (pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
if (hADs)
ADSICloseDSObject(hADs);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
if (SUCCEEDED(hr))
{
//
// Update Class Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
}
Error_Cleanup:
if (szFullName)
CoTaskMemFree(szFullName);
return RemapErrorCode(hr, m_szContainerName);
}
// Merges list1 and List2 into ResList removing duplicates.
HRESULT MergePropList(LPOLESTR *List1, DWORD cList1,
LPOLESTR *List2, DWORD cList2,
LPOLESTR **ResList,DWORD *cResList)
{
DWORD i, j;
*cResList = 0;
*ResList = (LPOLESTR *)CoTaskMemAlloc(sizeof(LPOLESTR)*(cList1+cList2));
if (!*ResList)
return E_OUTOFMEMORY;
for (i = 0; i < cList1; i++)
(*ResList)[i] = List1[i];
for (i = 0; i < cList2; i++) {
for (j = 0; j < cList1; j++)
if (wcscmp((*ResList)[j], List2[i]) == 0)
break;
if (j == cList1)
(*ResList)[(*cResList)++] = List2[i];
}
return S_OK;
}
//---------------------------------------------------------------
// Function: NewClass
//
// Synopsis: Adds classes corresp. to a package under the DS.
// Called by AddPackage.
//
// Arguments:
// [in]
// pClassDetail
// Class Detail of the clsid that needs to be added.
// Validation is specified in class store doc.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Validates the classdetail structure. If the clsid already exists in
// the DS, it adds these values under the same clsid and increases the refcount.
//----------------------------------------------------------------
HRESULT CClassContainer::NewClass (CLASSDETAIL *pClassDetail)
{
HRESULT hr = S_OK;
STRINGGUID szGUID1, szGUID2;
WCHAR szRDN [_MAX_PATH], * szFullName = NULL;
ADS_ATTR_INFO pAttr[6], *pAttrsGot = NULL;
BOOL fExists = FALSE;
HANDLE hADs = NULL;
LPOLESTR AttrNames[] = {PKGFILEEXTNLIST, PROGIDLIST, CLASSREFCOUNTER};
DWORD posn = 0, cProp = 0, cPropMerged = 0, refcount = 0,
cAttr = 0, cModified = 0, cgot = 0, i;
LPOLESTR * pszProp = NULL, *pszPropMerged = NULL;
if (!m_fOpen)
return E_FAIL;
//
// Cant be a NULL guid
//
if (IsNullGuid(pClassDetail->Clsid))
return E_INVALIDARG;
// Not using RDNFrom GUID b'cos szGUID1 is used below
StringFromGUID(pClassDetail->Clsid, szGUID1);
wsprintf(szRDN, L"CN=%s", szGUID1);
BuildADsPathFromParent(m_szClassName, szRDN, &szFullName);
hr = ADSIOpenDSObject(szFullName, NULL, NULL, ADS_SECURE_AUTHENTICATION,
&hADs);
if (SUCCEEDED(hr)) {
fExists = TRUE;
hr = ADSIGetObjectAttributes(hADs, AttrNames, 3, &pAttrsGot, &cgot);
}
// BUGBUG :: bug in adsldpc doesn't return error in open.
if (!SUCCEEDED(hr))
fExists = FALSE;
//
// Create the RDN for the Class Object
//
if (!fExists) {
PackStrToAttr(pAttr+cAttr, OBJECTCLASS, CLASS_CS_CLASS); cAttr++;
PackStrToAttr(pAttr+cAttr, CLASSCLSID, szGUID1); cAttr++;
}
if (pClassDetail->cProgId)
{
if (fExists)
posn = GetPropertyFromAttr(pAttrsGot, cgot, PROGIDLIST);
if (posn < cgot)
UnpackStrArrFrom(pAttrsGot[posn], &pszProp, &cProp);
// we can not just append b'cos duplicate values are valid conditions.
MergePropList(pszProp, cProp,
pClassDetail->prgProgId, pClassDetail->cProgId,
&pszPropMerged, &cPropMerged);
PackStrArrToAttr(pAttr+cAttr, PROGIDLIST, pszPropMerged, cPropMerged);
cAttr++;
CoTaskMemFree(pszPropMerged);
pszPropMerged = NULL; cPropMerged = 0;
CoTaskMemFree(pszProp);
pszProp = NULL; cProp = 0;
}
if (!IsNullGuid(pClassDetail->TreatAs))
{
StringFromGUID(pClassDetail->TreatAs, szGUID2);
PackStrToAttr(pAttr+cAttr, TREATASCLSID, szGUID2);
cAttr++;
}
// this is going to be modified if find that an entry already exists.
if (fExists) {
posn = GetPropertyFromAttr(pAttrsGot, cgot, CLASSREFCOUNTER);
if (posn < cgot) {
UnpackDWFrom(pAttrsGot[posn], &refcount);
}
}
refcount++;
PackDWToAttr(pAttr+cAttr, CLASSREFCOUNTER, refcount);
cAttr++;
if (fExists)
hr = ADSISetObjectAttributes(hADs, pAttr, cAttr, &cModified);
else
hr = ADSICreateDSObject(m_ADsClassContainer, szRDN, pAttr, cAttr);
if (pAttrsGot)
FreeADsMem(pAttrsGot);
if (szFullName)
FreeADsMem(szFullName);
for (i = 0; i < cAttr; i++)
FreeAttr(pAttr[i]);
return RemapErrorCode(hr, m_szContainerName);
}
#define SCRIPT_IN_DIRECTORY 256
//---------------------------------------------------------------
// Function: AddPackage
//
// Synopsis: Adds a package object in the DS.
//
// Arguments:
// [out]
// pszPackageId
// An Id that is returned corresponding to the package.
// [in]
// pPackageDetail
// Pointer to a PACKAGEDETAIL info for this package
// The various validations that is done is documented
// in associated class store doc.
//
// Returns:
// S_OK, E_OUTOFMEMORY, E_INVALIDARG, CS_E_XXX
//
// Validates the packagedetail structure. Packs ADS_ATTR_INFO structure with
// the values and tries to create the object in the DS.
// Calls NewClass to add all the clsids after that.
// If this returns error
// the whole package is removed.
//----------------------------------------------------------------
HRESULT CClassContainer::AddPackage (
PACKAGEDETAIL *pPackageDetail,
GUID *pPkgGuid
)
{
HRESULT hr = S_OK;
WCHAR szRDN [_MAX_PATH];
LPOLESTR * pszGuid1 = NULL, *pszGuid2 = NULL,
* pszGuid3 = NULL, *pszGuid4 = NULL,
* pszProgId = NULL, *pszFileExt = NULL,
* rpszUpgrades = NULL, *rpszSources = NULL,
szPackageId = NULL, szJunk = NULL;
DWORD * pdwArch=NULL, count = 0, cPackProgId = 0;
ADS_ATTR_INFO pAttr[29];
DWORD cAttr = 0;
WCHAR szUsn[20];
BOOL fPackageCreated = FALSE, GenerateGuid = FALSE;
GUID PackageGuidId;
if ((!pPkgGuid) || !IsValidReadPtrIn(pPkgGuid, sizeof(GUID)))
return E_INVALIDARG;
if ((!(pPackageDetail->pszPackageName)) ||
IsBadStringPtr((pPackageDetail->pszPackageName), _MAX_PATH))
return E_INVALIDARG;
if (!pPackageDetail)
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail, sizeof(PACKAGEDETAIL)))
return E_INVALIDARG;
// validating ActivationInfo.
if (pPackageDetail->pActInfo)
{
if (!IsValidReadPtrIn(pPackageDetail->pActInfo, sizeof(ACTIVATIONINFO)))
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pActInfo->pClasses,
sizeof(CLASSDETAIL) * (pPackageDetail->pActInfo->cClasses)))
return E_INVALIDARG;
// validating classdetail
for (count = 0; (count < (pPackageDetail->pActInfo->cClasses)); count++)
{
CLASSDETAIL *pClassDetail = (pPackageDetail->pActInfo->pClasses)+count;
if (IsNullGuid(pClassDetail->Clsid))
return E_INVALIDARG;
for (DWORD count1 = 0; (count1 < (pClassDetail->cProgId)); count1++)
{
// if profid is NULL or an empty string.
if ((!((pClassDetail->prgProgId)[count1])) ||
(!((pClassDetail->prgProgId)[count1][0])))
return E_INVALIDARG;
}
}
if (!IsValidReadPtrIn(pPackageDetail->pActInfo->prgShellFileExt,
sizeof(LPOLESTR) * (pPackageDetail->pActInfo->cShellFileExt)))
return E_INVALIDARG;
for (count = 0; count < (pPackageDetail->pActInfo->cShellFileExt); count++)
{
if (!pPackageDetail->pActInfo->prgShellFileExt[count])
return E_INVALIDARG;
}
if (!IsValidReadPtrIn(pPackageDetail->pActInfo->prgPriority,
sizeof(UINT) * (pPackageDetail->pActInfo->cShellFileExt)))
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pActInfo->prgInterfaceId,
sizeof(IID) * (pPackageDetail->pActInfo->cInterfaces)))
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pActInfo->prgTlbId,
sizeof(GUID) * (pPackageDetail->pActInfo->cTypeLib)))
return E_INVALIDARG;
}
// Validating InstallInfo
// BUGBUG:: Validate ProductCode, Mvipc
if ((pPackageDetail->pInstallInfo == NULL) ||
(!IsValidReadPtrIn(pPackageDetail->pInstallInfo, sizeof(INSTALLINFO)))
)
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pInstallInfo->prgUpgradeInfoList,
sizeof(UPGRADEINFO)*(pPackageDetail->pInstallInfo->cUpgrades)))
return E_INVALIDARG;
for (count = 0; count < (pPackageDetail->pInstallInfo->cUpgrades); count++)
{
if ((!(pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].szClassStore)) ||
IsBadStringPtr((pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].szClassStore), _MAX_PATH))
return E_INVALIDARG;
if (IsNullGuid(pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].PackageGuid))
return E_INVALIDARG;
if (((pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_Uninstall) == 0) &&
((pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_NoUninstall) == 0) &&
((pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_UpgradedBy) == 0))
return E_INVALIDARG;
}
// validating PlatformInfo
if ((pPackageDetail->pPlatformInfo == NULL) ||
(!IsValidReadPtrIn(pPackageDetail->pPlatformInfo, sizeof(PLATFORMINFO)))
)
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pPlatformInfo->prgPlatform,
sizeof(CSPLATFORM) * (pPackageDetail->pPlatformInfo->cPlatforms)))
return E_INVALIDARG;
if ((pPackageDetail->pPlatformInfo->cLocales == 0) ||
(pPackageDetail->pPlatformInfo->cPlatforms == 0))
return E_INVALIDARG;
if (!IsValidReadPtrIn(pPackageDetail->pPlatformInfo->prgLocale,
sizeof(LCID) * (pPackageDetail->pPlatformInfo->cLocales)))
return E_INVALIDARG;
// validating InstallInfo
// Validating other fields in PackageDetail structure
if ((pPackageDetail->pszSourceList == NULL) ||
(!IsValidReadPtrIn(pPackageDetail->pszSourceList,
sizeof(LPOLESTR) * (pPackageDetail->cSources))))
return E_INVALIDARG;
for (count = 0; count < (pPackageDetail->cSources); count++)
{
if ((!pPackageDetail->pszSourceList[count]) ||
(IsBadStringPtr(pPackageDetail->pszSourceList[count], _MAX_PATH)))
return E_INVALIDARG;
}
if (pPackageDetail->rpCategory)
{
if (!IsValidReadPtrIn(pPackageDetail->rpCategory,
sizeof(GUID) * (pPackageDetail->cCategories)))
return E_INVALIDARG;
}
// If the restrictions are too constrictive then we should go to
// the DS, to see whether it is a valid name or not. till then..
// GenerateGuid = InvalidDSName(pPackageDetail->pszPackageName);
hr = GetDNFromPackageName(pPackageDetail->pszPackageName, &szJunk);
if (szJunk)
CoTaskMemFree(szJunk);
if (FAILED(hr))
return RemapErrorCode(hr, m_szContainerName);
if (hr == S_OK)
{
return CS_E_OBJECT_ALREADY_EXISTS;
}
/* szPackageId = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*(GenerateGuid?41:
(wcslen(pPackageDetail->pszPackageName)+1)));
*/
szPackageId = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*41);
if (!(szPackageId))
return E_OUTOFMEMORY;
memset(&PackageGuidId, 0, sizeof(GUID));
/*
if (GenerateGuid)
{
CoCreateGuid(&PackageGuidId);
StringFromGUID(PackageGuidId, szPackageId);
}
else
wcscpy(szPackageId, pPackageDetail->pszPackageName);
*/
// always generate guid
CoCreateGuid(&PackageGuidId);
StringFromGUID(PackageGuidId, szPackageId);
//
// Create the RDN for the Package Object
//
wsprintf(szRDN, L"CN=%s", szPackageId);
PackStrToAttr(pAttr+cAttr, OBJECTCLASS, CLASS_CS_PACKAGE); cAttr++;
// fill in the activation info
// add the class to the packagecontainer list
if (pPackageDetail->pActInfo)
{
if (pPackageDetail->pActInfo->cClasses)
{
pszGuid1 = (LPOLESTR *)CoTaskMemAlloc((pPackageDetail->pActInfo->cClasses)*sizeof(LPOLESTR));
if (!pszGuid1) {
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (count = 0; count < pPackageDetail->pActInfo->cClasses; count++)
{
WCHAR szCtx[9];
pszGuid1[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*(STRINGGUIDLEN+9));
if (!pszGuid1[count]) {
FREEARR(pszGuid1, count);
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
StringFromGUID(pPackageDetail->pActInfo->pClasses[count].Clsid, pszGuid1[count]);
wsprintf(szCtx, L":%8x", pPackageDetail->pActInfo->pClasses[count].dwComClassContext);
wcscat(pszGuid1[count], szCtx);
cPackProgId += pPackageDetail->pActInfo->pClasses[count].cProgId;
}
PackStrArrToAttr(pAttr+cAttr, PKGCLSIDLIST, pszGuid1,
pPackageDetail->pActInfo->cClasses); cAttr++;
}
// collecting all the progids from the various clsids.
pszProgId = (LPOLESTR *)CoTaskMemAlloc(sizeof(LPOLESTR)*cPackProgId);
if (!pszProgId) {
hr = E_OUTOFMEMORY;
ERROR_ON_FAILURE(hr);
}
for (count = 0, cPackProgId = 0; count < pPackageDetail->pActInfo->cClasses; count++) {
// for each clsid
DWORD cClassProgId, j = 0;
for (cClassProgId = 0; cClassProgId < pPackageDetail->pActInfo->pClasses[count].cProgId;
cClassProgId++)
{
// for each progid within ClassDetail
for (j = 0; j < cPackProgId; j++)
{
if (_wcsicmp(pszProgId[j],
pPackageDetail->pActInfo->pClasses[count].prgProgId[cClassProgId]) == 0)
break;
}
// needs to be added if there are no dups.
if (j == cPackProgId)
{
pszProgId[cPackProgId] =
pPackageDetail->pActInfo->pClasses[count].prgProgId[cClassProgId];
_wcslwr(pszProgId[cPackProgId]);
CSDBGPrint((L"AddPackage: Progid = %s\n", pszProgId[cPackProgId]));
cPackProgId++;
}
}
}
if (cPackProgId) {
PackStrArrToAttr(pAttr+cAttr, PROGIDLIST, pszProgId, cPackProgId); cAttr++;
}
CoTaskMemFree(pszProgId);
if (pPackageDetail->pActInfo->cShellFileExt) {
//
// Store a tuple in the format <file ext>:<priority>
//
pszFileExt = (LPOLESTR *)CoTaskMemAlloc((pPackageDetail->pActInfo->cShellFileExt) * sizeof(LPOLESTR));
if (!pszFileExt)
{
hr = E_OUTOFMEMORY;
ERROR_ON_FAILURE(hr);
}
for (count = 0; count < pPackageDetail->pActInfo->cShellFileExt; count++)
{
pszFileExt[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR) *
(wcslen(pPackageDetail->pActInfo->prgShellFileExt[count])+1+2+1));
if (!pszFileExt[count])
{
FREEARR(pszFileExt, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
// format is fileext+:+nn+NULL where nn = 2 digit priority
wsprintf(pszFileExt[count], L"%s:%2d",
pPackageDetail->pActInfo->prgShellFileExt[count],
pPackageDetail->pActInfo->prgPriority[count]%100);
_wcslwr(pszFileExt[count]);
}
PackStrArrToAttr(pAttr+cAttr, PKGFILEEXTNLIST, pszFileExt,
pPackageDetail->pActInfo->cShellFileExt); cAttr++;
}
if (pPackageDetail->pActInfo->cInterfaces) {
pszGuid2 = (LPOLESTR *)CoTaskMemAlloc((pPackageDetail->pActInfo->cInterfaces)*sizeof(LPOLESTR));
if (!pszGuid2) {
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (count = 0; (count < (pPackageDetail->pActInfo->cInterfaces)); count++) {
pszGuid2[count] = (LPOLESTR)CoTaskMemAlloc(STRINGGUIDLEN*sizeof(WCHAR));
if (!pszGuid2[count]) {
FREEARR(pszGuid2, count);
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
StringFromGUID((pPackageDetail->pActInfo->prgInterfaceId)[count], pszGuid2[count]);
}
PackStrArrToAttr(pAttr+cAttr, PKGIIDLIST, pszGuid2, pPackageDetail->pActInfo->cInterfaces);
cAttr++;
}
/*
if (pPackageDetail->pActInfo->cTypeLib) {
pszGuid3 = (LPOLESTR *)CoTaskMemAlloc((pPackageDetail->pActInfo->cTypeLib)*sizeof(LPOLESTR));
if (!pszGuid3) {
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (count = 0; (count < (pPackageDetail->pActInfo->cTypeLib)); count++) {
pszGuid3[count] = (LPOLESTR)CoTaskMemAlloc(STRINGGUIDLEN*sizeof(WCHAR));
if (!pszGuid3[count]) {
FREEARR(pszGuid3, count);
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
StringFromGUID((pPackageDetail->pActInfo->prgTlbId)[count], pszGuid3[count]);
}
PackStrArrToAttr(pAttr+cAttr, PKGTLBIDLIST, pszGuid3, pPackageDetail->pActInfo->cTypeLib);
cAttr++;
}
*/
}
// fill in the platforminfo
// BUGBUG::***os version
if (pPackageDetail->pPlatformInfo->cPlatforms) {
pdwArch = (DWORD *)CoTaskMemAlloc(sizeof(DWORD)*(pPackageDetail->pPlatformInfo->cPlatforms));
if (!pdwArch)
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
for (count = 0; (count < (pPackageDetail->pPlatformInfo->cPlatforms)); count++)
UnpackPlatform (pdwArch+count, (pPackageDetail->pPlatformInfo->prgPlatform)+count);
PackDWArrToAttr(pAttr+cAttr, ARCHLIST, pdwArch, pPackageDetail->pPlatformInfo->cPlatforms);
cAttr++;
}
if (pPackageDetail->pPlatformInfo->cLocales) {
PackDWArrToAttr(pAttr+cAttr, LOCALEID, pPackageDetail->pPlatformInfo->prgLocale,
pPackageDetail->pPlatformInfo->cLocales);
cAttr++;
}
// fill in the installinfo
PackStrToAttr(pAttr+cAttr, PACKAGENAME, pPackageDetail->pszPackageName);
cAttr++;
PackDWToAttr(pAttr+cAttr, PACKAGETYPE, (DWORD)(pPackageDetail->pInstallInfo->PathType));
cAttr++;
if (pPackageDetail->pInstallInfo->pszScriptPath) {
PackStrToAttr(pAttr+cAttr, SCRIPTPATH, pPackageDetail->pInstallInfo->pszScriptPath);
cAttr++;
}
if (pPackageDetail->pInstallInfo->pszSetupCommand) {
PackStrToAttr(pAttr+cAttr, SETUPCOMMAND, pPackageDetail->pInstallInfo->pszSetupCommand);
cAttr++;
}
if (pPackageDetail->pInstallInfo->pszUrl) {
PackStrToAttr(pAttr+cAttr, HELPURL, pPackageDetail->pInstallInfo->pszUrl);
cAttr++;
}
//
// Store the current USN
//
GetCurrentUsn(szUsn);
PackStrToAttr(pAttr+cAttr, PKGUSN, szUsn);
cAttr++;
// package flags
PackDWToAttr(pAttr+cAttr, PACKAGEFLAGS, pPackageDetail->pInstallInfo->dwActFlags);
cAttr++;
// product code, different from pkg guid
PackGUIDToAttr(pAttr+cAttr, PRODUCTCODE, &(pPackageDetail->pInstallInfo->ProductCode));
cAttr++;
// Mvipc
PackGUIDToAttr(pAttr+cAttr, MVIPC, &(pPackageDetail->pInstallInfo->Mvipc));
cAttr++;
// Hi Version of the package
PackDWToAttr(pAttr+cAttr, VERSIONHI, pPackageDetail->pInstallInfo->dwVersionHi);
cAttr++;
// Low Version of the package
PackDWToAttr(pAttr+cAttr, VERSIONLO, pPackageDetail->pInstallInfo->dwVersionLo);
cAttr++;
// Revision
PackDWToAttr(pAttr+cAttr, REVISION, pPackageDetail->pInstallInfo->dwRevision);
cAttr++;
// scriptsize
PackDWToAttr(pAttr+cAttr, SCRIPTSIZE, pPackageDetail->pInstallInfo->cScriptLen);
cAttr++;
// uilevel
PackDWToAttr (pAttr+cAttr, UILEVEL, (DWORD)pPackageDetail->pInstallInfo->InstallUiLevel);
cAttr++;
// adding cUpgrade number of Classstore/PackageGuid combinations
if (pPackageDetail->pInstallInfo->cUpgrades)
{
WCHAR szPackageGuid[_MAX_PATH];
rpszUpgrades = (LPOLESTR *)CoTaskMemAlloc(sizeof(LPOLESTR)*pPackageDetail->pInstallInfo->cUpgrades);
if (!rpszUpgrades)
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
for (count = 0; (count < pPackageDetail->pInstallInfo->cUpgrades); count++)
{
UINT len = wcslen(pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].szClassStore);
rpszUpgrades[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR) *(36+PKG_UPG_DELIM1_LEN+len+PKG_UPG_DELIM2_LEN+2+2));
// Guid size+::+length++:+flagDigit+2
if (!rpszUpgrades[count])
{
FREEARR(rpszUpgrades, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
StringFromGUID(pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].PackageGuid,
szPackageGuid);
wsprintf(rpszUpgrades[count], L"%s%s%s%s%02x",
pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].szClassStore,
PKG_UPG_DELIMITER1,
szPackageGuid,
PKG_UPG_DELIMITER2,
pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag%16);
}
PackStrArrToAttr(pAttr+cAttr, UPGRADESPACKAGES, rpszUpgrades,
pPackageDetail->pInstallInfo->cUpgrades);
cAttr++;
}
// Fill in the source list
// Maintain the serial number associated with the sources. Order matters!!
if (pPackageDetail->cSources)
{
rpszSources = (LPOLESTR *)CoTaskMemAlloc(sizeof(LPOLESTR)*(pPackageDetail->cSources));
if (!rpszSources)
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
for (count = 0; count < (pPackageDetail->cSources); count++)
{
rpszSources[count] = (LPOLESTR)CoTaskMemAlloc(sizeof(WCHAR)*(wcslen(pPackageDetail->pszSourceList[count])+
1+1+NumDigits10(pPackageDetail->cSources)));
if (!rpszSources[count])
{
FREEARR(rpszSources, count);
ERROR_ON_FAILURE(hr=E_OUTOFMEMORY);
}
wsprintf(rpszSources[count], L"%d:%s", count, pPackageDetail->pszSourceList[count]);
}
PackStrArrToAttr(pAttr+cAttr, MSIFILELIST, rpszSources, pPackageDetail->cSources);
cAttr++;
}
// fill in the categories
// Add the package Categories
if (pPackageDetail->cCategories)
{
pszGuid4 = (LPOLESTR *)CoTaskMemAlloc((pPackageDetail->cCategories) * sizeof(LPOLESTR));
if (!pszGuid4)
{
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
for (count = 0; (count < pPackageDetail->cCategories); count++)
{
pszGuid4[count] = (LPOLESTR)CoTaskMemAlloc(STRINGGUIDLEN*sizeof(WCHAR));
if (!pszGuid4[count])
{
FREEARR(pszGuid4, count);
ERROR_ON_FAILURE(hr = E_OUTOFMEMORY);
}
StringFromGUID((pPackageDetail->rpCategory)[count], pszGuid4[count]);
}
PackStrArrToAttr(pAttr+cAttr, PKGCATEGORYLIST, pszGuid4, pPackageDetail->cCategories);
cAttr++;
}
// fill in the vendor
// Publisher
if (pPackageDetail->pszPublisher)
{
PackStrToAttr(pAttr+cAttr, PUBLISHER, pPackageDetail->pszPublisher);
cAttr++;
}
/*
//
// Store the script in the directory
//
if ((pPackageDetail->pInstallInfo->dwActFlags & SCRIPT_IN_DIRECTORY) &&
(pPackageDetail->pInstallInfo->cScriptLen))
{
if ((pPackageDetail->pInstallInfo->cScriptLen) &&
(!IsValidReadPtrIn(pPackageDetail->pInstallInfo->pScript, pPackageDetail->pInstallInfo->cScriptLen)))
return E_INVALIDARG;
if (pPackageDetail->pInstallInfo->cScriptLen)
{
PackBinToAttr(pAttr+cAttr, PKGSCRIPT, pPackageDetail->pInstallInfo->pScript,
pPackageDetail->pInstallInfo->cScriptLen);
cAttr++;
}
}
*/
hr = ADSICreateDSObject(m_ADsPackageContainer, szRDN, pAttr, cAttr);
ERROR_ON_FAILURE(hr);
memset(pPkgGuid, 0, sizeof(GUID));
// memcpy(pPkgGuid, &PackageGuidId, sizeof(GUID));
hr = GetPackageGuid(szRDN, pPkgGuid);
ERROR_ON_FAILURE(hr);
fPackageCreated = TRUE;
if (pPackageDetail->pActInfo)
{
for (count = 0; count < pPackageDetail->pActInfo->cClasses; count++) {
hr = NewClass((pPackageDetail->pActInfo->pClasses)+count);
ERROR_ON_FAILURE(hr);
}
}
if (!(pPackageDetail->pInstallInfo->dwActFlags & ACTFLG_Uninstall) &&
!(pPackageDetail->pInstallInfo->dwActFlags & ACTFLG_Orphan))
{
if (pPackageDetail->pInstallInfo->cUpgrades)
{
//
// Need to fixup the other packages that this package upgrades
//
for (count = 0; (count < pPackageDetail->pInstallInfo->cUpgrades); count++)
{
if ((pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_Uninstall) ||
(pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_NoUninstall))
{
DWORD Flags = 0;
if (pPackageDetail->pInstallInfo->prgUpgradeInfoList[count].Flag & UPGFLG_Enforced)
Flags = UPGFLG_Enforced;
}
}
for (count = 0; (count < pPackageDetail->pInstallInfo->cUpgrades); count++)
CoTaskMemFree(rpszUpgrades[count]);
CoTaskMemFree(rpszUpgrades);
}
}
if (SUCCEEDED(hr))
{
//
// Update Store Usn
//
UpdateStoreUsn(m_ADsContainer, szUsn);
}
Error_Cleanup:
for (count = 0; count < cAttr; count++)
FreeAttr(pAttr[count]);
if (pszGuid1) {
for (count = 0; (count < pPackageDetail->pActInfo->cClasses); count++)
CoTaskMemFree(pszGuid1[count]);
CoTaskMemFree(pszGuid1);
}
if (pszGuid2) {
for (count = 0; (count < (pPackageDetail->pActInfo->cInterfaces)); count++)
CoTaskMemFree(pszGuid2[count]);
CoTaskMemFree(pszGuid2);
}
if (pszGuid3) {
for (count = 0; (count < (pPackageDetail->pActInfo->cTypeLib)); count++)
CoTaskMemFree(pszGuid3[count]);
CoTaskMemFree(pszGuid3);
}
if (pszGuid4) {
for (count = 0; (count < pPackageDetail->cCategories); count++)
CoTaskMemFree(pszGuid4[count]);
CoTaskMemFree(pszGuid4);
}
if (pszFileExt) {
for (count = 0; (count < pPackageDetail->pActInfo->cShellFileExt); count++)
CoTaskMemFree(pszFileExt[count]);
CoTaskMemFree(pszFileExt);
}
if (pdwArch) {
CoTaskMemFree(pdwArch);
}
if (rpszSources)
{
for (count = 0; (count < pPackageDetail->cSources); count++)
CoTaskMemFree(rpszSources[count]);
CoTaskMemFree(rpszSources);
}
//
// On failure, the package should be removed from the ds if we
// created it there.
//
if (FAILED(hr) && (fPackageCreated))
{
HRESULT hrDeleted;
LPWSTR wszPackageFullPath;
//
// Need to get a full path to the package in order to delete it.
//
hrDeleted = BuildADsPathFromParent(m_szPackageName, szRDN, &wszPackageFullPath);
ASSERT(SUCCEEDED(hrDeleted));
CSDBGPrint((L"AddPackage failed, attempting to remove deleted package with path %s\n", wszPackageFullPath));
hrDeleted = DeletePackage(wszPackageFullPath);
CSDBGPrint((L"DeletePackage returned %x\n", hrDeleted));
//
// Free the full path
//
CoTaskMemFree(wszPackageFullPath);
}
return RemapErrorCode(hr, m_szContainerName);
}
//+
//
// Cleanup old packages from Class Store based on lastChangeTime
//
HRESULT CClassContainer::Cleanup (
FILETIME *pTimeBefore
)
{
//
// Delete all packages marked as "Uninstall"
// OR "Orphan" and are older than the time given
//
ULONG cRowsFetched = 0;
ADS_SEARCH_HANDLE hADsSearchHandle = NULL;
WCHAR szFilter[_MAX_PATH], szRDN[_MAX_PATH];
HRESULT hr = S_OK;
ADS_ATTR_INFO pAttr;
SYSTEMTIME SystemTime;
ADS_SEARCH_COLUMN column;
DWORD dwPackageFlags;
LPOLESTR pszPackageId = NULL;
if ((!pTimeBefore) ||
!IsValidReadPtrIn(pTimeBefore, sizeof(FILETIME)))
return E_INVALIDARG;
FileTimeToSystemTime(
(CONST FILETIME *) pTimeBefore,
&SystemTime);
wsprintf (szFilter,
L"(%s<=%04d%02d%02d%02d%02d%02d)",
PKGUSN,
SystemTime.wYear,
SystemTime.wMonth,
SystemTime.wDay,
SystemTime.wHour,
SystemTime.wMinute,
SystemTime.wSecond);
// execute the search and keep the handle returned.
hr = ADSIExecuteSearch(m_ADsPackageContainer, szFilter, pszDeleteAttrNames,
cDeleteAttr, &hADsSearchHandle);
hr = ADSIGetFirstRow(m_ADsPackageContainer, hADsSearchHandle);
while (TRUE)
{
if ((FAILED(hr)) || (hr == S_ADS_NOMORE_ROWS))
break;
dwPackageFlags = 0;
// Get the Package State
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, PACKAGEFLAGS, &column);
if (SUCCEEDED(hr))
{
UnpackDWFrom(column, &dwPackageFlags);
ADSIFreeColumn(m_ADsPackageContainer, &column);
}
//
// Check flag values to see if this package is Orphaned or Uninstalled
//
if ((dwPackageFlags & ACTFLG_Orphan) || (dwPackageFlags & ACTFLG_Uninstall))
{
hr = ADSIGetColumn(m_ADsPackageContainer, hADsSearchHandle, OBJECTDN, &column);
if (SUCCEEDED(hr))
{
WCHAR * szDN = NULL;
UnpackStrFrom(column, &szDN);
hr = DeletePackage(szDN);
ADSIFreeColumn(m_ADsPackageContainer, &column);
ERROR_ON_FAILURE(hr);
}
}
hr = ADSIGetNextRow(m_ADsPackageContainer, hADsSearchHandle);
}
Error_Cleanup:
if (hADsSearchHandle)
ADSICloseSearchHandle(m_ADsPackageContainer, hADsSearchHandle);
return RemapErrorCode(hr, m_szContainerName);
}
Reference in a new issue Copy permalink