// // 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 : // 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); }