static DWORD VmDirLdapSchemaAddDef( PLW_HASHMAP pDefMap, PVDIR_LDAP_DEFINITION pDef ) { DWORD dwError = 0; BOOLEAN bRemoveOnError = FALSE; LW_HASHMAP_PAIR pair = {NULL, NULL}; PVDIR_LDAP_DEFINITION pPrevDef = NULL; PVDIR_LDAP_DEFINITION_LIST pDefList = NULL; PVDIR_LDAP_DEFINITION_LIST pNewDefList = NULL; if (!pDefMap || !pDef) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwError = LwRtlHashMapInsert(pDefMap, pDef->pszName, pDef, &pair); BAIL_ON_VMDIR_ERROR(dwError); pPrevDef = (PVDIR_LDAP_DEFINITION)pair.pValue; if (pPrevDef) { assert(!pDef->pList); // linked list conflict pDefList = pPrevDef->pList; } else { pDefList = pDef->pList; bRemoveOnError = TRUE; } if (!pDefList) { dwError = VmDirLdapDefListCreate(&pNewDefList); BAIL_ON_VMDIR_ERROR(dwError); pDefList = pNewDefList; } dwError = VmDirLdapDefListUpdateHead(pDefList, pDef); BAIL_ON_VMDIR_ERROR(dwError); cleanup: return dwError; error: if (pPrevDef) { (VOID)LwRtlHashMapInsert(pDefMap, pPrevDef->pszName, pPrevDef, NULL); } else if (bRemoveOnError) { (VOID)LwRtlHashMapRemove(pDefMap, pDef->pszName, NULL); } VmDirFreeLdapDefList(pNewDefList); goto cleanup; }
DWORD VmDirSchemaAttrIdMapAddNewAttr( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap, PSTR pszAttrName, USHORT usAttrId // optional ) { DWORD dwError = 0; PSTR pszKey = 0; if (!pAttrIdMap || IsNullOrEmptyString(pszAttrName)) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } if (VmDirSchemaAttrIdMapGetAttrId(pAttrIdMap, pszAttrName, NULL) == 0) { dwError = ERROR_ALREADY_EXISTS; BAIL_ON_VMDIR_ERROR(dwError); } dwError = VmDirAllocateStringA(pszAttrName, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); if (usAttrId) { dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds, pszKey, (PVOID)(uintptr_t)usAttrId, NULL); BAIL_ON_VMDIR_ERROR(dwError); if (usAttrId >= pAttrIdMap->usNextId) { pAttrIdMap->usNextId = usAttrId + 1; } } else { dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds, pszKey, (PVOID)(uintptr_t)pAttrIdMap->usNextId, NULL); BAIL_ON_VMDIR_ERROR(dwError); pAttrIdMap->usNextId++; } cleanup: return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); VMDIR_SAFE_FREE_MEMORY(pszKey); goto cleanup; }
DWORD _VdcAddCopiesToHashTable( PLW_HASHMAP pHashMap, PCSTR pszKey, PCSTR pszValue ) { DWORD dwError = 0; PSTR pszKeyCopy = NULL; PSTR pszValueCopy = NULL; dwError = VmDirAllocateStringA(pszKey, &pszKeyCopy); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pszValue, &pszValueCopy); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pHashMap, pszKeyCopy, pszValueCopy, NULL); BAIL_ON_VMDIR_ERROR(dwError); cleanup: return dwError; error: VMDIR_SAFE_FREE_STRINGA(pszKeyCopy); VMDIR_SAFE_FREE_STRINGA(pszValueCopy); goto cleanup; }
DWORD VmDirUTDVectorCacheAdd( PVMDIR_UTDVECTOR_CACHE pUTDVector, PCSTR pszInvocationId, PCSTR pszUsn ) { DWORD dwError = 0; BOOLEAN bInLock = FALSE; PSTR pszDupKey = NULL; USN Usn = 0; LW_HASHMAP_PAIR pair = {0}; if (IsNullOrEmptyString(pszInvocationId) || !pUTDVector) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = VmDirAllocateStringA(pszInvocationId, &pszDupKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringToINT64(pszUsn, NULL, &Usn); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_RWLOCK_READLOCK(bInLock, pUTDVector->pUtdVectorLock, 0); dwError = LwRtlHashMapInsert(pUTDVector->pUtdVectorMap, pszDupKey, (PVOID)Usn, &pair); BAIL_ON_VMDIR_ERROR(dwError); VmDirSimpleHashMapPairFreeKeyOnly(&pair, NULL); pszDupKey = NULL; VMDIR_SAFE_FREE_STRINGA(pUTDVector->pszUtdVector); dwError = VmDirVectorToStr(pUTDVector->pUtdVectorMap, _VmDirUTDVectorPairToStr, &pUTDVector->pszUtdVector); BAIL_ON_VMDIR_ERROR(dwError); cleanup: VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock); VMDIR_SAFE_FREE_MEMORY(pszDupKey); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD _VmDirDDVectorUpdateDefaultsInLock( DWORD dwValue ) { DWORD dwError = 0; PSTR pszKey = NULL; PDWORD pdwValue = NULL; LW_HASHMAP_PAIR pair = {NULL, NULL}; LW_HASHMAP_PAIR prevPair = {NULL, NULL}; dwError = VmDirAllocateStringA( gVmdirServerGlobals.bvServerObjName.lberbv_val, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateMemory( sizeof(DWORD), (PVOID*)&pdwValue); BAIL_ON_VMDIR_ERROR(dwError); *pdwValue = dwValue; pair.pKey = pszKey; pair.pValue = pdwValue; pszKey = NULL; pdwValue = NULL; dwError = LwRtlHashMapInsert( gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, pair.pKey, pair.pValue, &prevPair); BAIL_ON_VMDIR_ERROR(dwError); VmDirSimpleHashMapPairFree(&prevPair, NULL); cleanup: VMDIR_SAFE_FREE_MEMORY(pszKey); VMDIR_SAFE_FREE_MEMORY(pdwValue); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
/* * should only be used during bootstrap * maybe add state check? */ DWORD VmDirIndexOpen( PVDIR_INDEX_CFG pIndexCfg ) { DWORD dwError = 0; BOOLEAN bInLock = FALSE; PVDIR_BACKEND_INTERFACE pBE = NULL; if (!pIndexCfg) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } VMDIR_LOCK_MUTEX(bInLock, gVdirIndexGlobals.mutex); if (LwRtlHashMapFindKey( gVdirIndexGlobals.pIndexCfgMap, NULL, pIndexCfg->pszAttrName) == 0) { dwError = ERROR_ALREADY_INITIALIZED; BAIL_ON_VMDIR_ERROR(dwError); } dwError = LwRtlHashMapInsert( gVdirIndexGlobals.pIndexCfgMap, pIndexCfg->pszAttrName, pIndexCfg, NULL); BAIL_ON_VMDIR_ERROR(dwError); pBE = VmDirBackendSelect(NULL); dwError = pBE->pfnBEIndexOpen(pIndexCfg); BAIL_ON_VMDIR_ERROR(dwError); cleanup: VMDIR_UNLOCK_MUTEX(bInLock, gVdirIndexGlobals.mutex); return dwError; error: goto cleanup; }
static DWORD _populateHashMapWithSuperlogEntries( PLW_HASHMAP pHashMap, PVMDIR_SUPERLOG_ENTRY_LDAPOPERATION_ARRAY pEntries, PVMDIR_SUPERLOG_TABLE_COLUMN_SET pCols ) { DWORD dwError = 0; PSTR pszKey = NULL; PVMDIR_SUPERLOG_TABLE_ROW pValue = NULL; unsigned int i; for (i = 0; i < pEntries->dwCount; i++) { dwError = _generateHashMapKeyString(&pEntries->entries[i], pCols, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapFindKey(pHashMap, (PVOID*)&pValue, pszKey); if (dwError == 0) { pValue->count += 1; pValue->totalTime += pEntries->entries[i].iEndTime - pEntries->entries[i].iStartTime; VMDIR_SAFE_FREE_MEMORY(pszKey); } else { dwError = _allocateSuperlogTableRow(&pEntries->entries[i], pCols, &pValue); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pHashMap, pszKey, pValue, NULL); BAIL_ON_VMDIR_ERROR(dwError); } } cleanup: return dwError; error: goto cleanup; }
DWORD VmDirIndexDeleteUniquenessScope( PVDIR_INDEX_UPD pIndexUpd, PCSTR pszAttrName, PCSTR* ppszUniqScopes ) { DWORD dwError = 0; DWORD i = 0; PLW_HASHMAP pCurCfgMap = NULL; PLW_HASHMAP pUpdCfgMap = NULL; PVDIR_INDEX_CFG pCurCfg = NULL; PVDIR_INDEX_CFG pUpdCfg = NULL; PVDIR_INDEX_CFG pNewCfg = NULL; if (!pIndexUpd || IsNullOrEmptyString(pszAttrName) || !ppszUniqScopes) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } pCurCfgMap = gVdirIndexGlobals.pIndexCfgMap; pUpdCfgMap = pIndexUpd->pUpdIndexCfgMap; (VOID)LwRtlHashMapFindKey(pCurCfgMap, (PVOID*)&pCurCfg, pszAttrName); (VOID)LwRtlHashMapFindKey(pUpdCfgMap, (PVOID*)&pUpdCfg, pszAttrName); if (pCurCfg && !pUpdCfg) { dwError = VmDirIndexCfgCopy(pCurCfg, &pUpdCfg); BAIL_ON_VMDIR_ERROR(dwError); pNewCfg = pUpdCfg; } if (!pUpdCfg || pUpdCfg->status == VDIR_INDEXING_DISABLED || pUpdCfg->status == VDIR_INDEXING_DELETED) { dwError = VMDIR_ERROR_NOT_FOUND; BAIL_ON_VMDIR_ERROR(dwError); } if (!pUpdCfg->bScopeEditable || pUpdCfg->status == VDIR_INDEXING_VALIDATING_SCOPES) { dwError = VMDIR_ERROR_UNWILLING_TO_PERFORM; BAIL_ON_VMDIR_ERROR(dwError); } for (i = 0; ppszUniqScopes[i]; i++) { dwError = VmDirIndexCfgDeleteUniqueScopeMod(pUpdCfg, ppszUniqScopes[i]); BAIL_ON_VMDIR_ERROR(dwError); } dwError = LwRtlHashMapInsert(pUpdCfgMap, pUpdCfg->pszAttrName, pUpdCfg, NULL); BAIL_ON_VMDIR_ERROR(dwError); cleanup: return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); VmDirFreeIndexCfg(pNewCfg); goto cleanup; }
DWORD VmDirIndexSchedule( PVDIR_INDEX_UPD pIndexUpd, PCSTR pszAttrName, PCSTR pszAttrSyntaxOid ) { DWORD dwError = 0; PLW_HASHMAP pCurCfgMap = NULL; PLW_HASHMAP pUpdCfgMap = NULL; PVDIR_INDEX_CFG pCurCfg = NULL; PVDIR_INDEX_CFG pUpdCfg = NULL; PVDIR_INDEX_CFG pNewCfg = NULL; if (!pIndexUpd || IsNullOrEmptyString(pszAttrName)) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } pCurCfgMap = gVdirIndexGlobals.pIndexCfgMap; pUpdCfgMap = pIndexUpd->pUpdIndexCfgMap; (VOID)LwRtlHashMapFindKey(pCurCfgMap, (PVOID*)&pCurCfg, pszAttrName); (VOID)LwRtlHashMapFindKey(pUpdCfgMap, (PVOID*)&pUpdCfg, pszAttrName); if (pUpdCfg) { dwError = ERROR_ALREADY_EXISTS; BAIL_ON_VMDIR_ERROR(dwError); } if (pCurCfg) { if (pCurCfg->status == VDIR_INDEXING_DELETED) { dwError = VmDirIndexCfgCopy(pCurCfg, &pUpdCfg); BAIL_ON_VMDIR_ERROR(dwError); pNewCfg = pUpdCfg; pUpdCfg->status = VDIR_INDEXING_SCHEDULED; } else if (pCurCfg->status == VDIR_INDEXING_DISABLED) { dwError = VMDIR_ERROR_BUSY; BAIL_ON_VMDIR_ERROR(dwError); } else { dwError = ERROR_ALREADY_EXISTS; BAIL_ON_VMDIR_ERROR(dwError); } } else { dwError = VmDirIndexCfgCreate(pszAttrName, &pUpdCfg); BAIL_ON_VMDIR_ERROR(dwError); pNewCfg = pUpdCfg; pUpdCfg->bIsNumeric = VmDirSchemaSyntaxIsNumeric(pszAttrSyntaxOid); } dwError = LwRtlHashMapInsert(pUpdCfgMap, pUpdCfg->pszAttrName, pUpdCfg, NULL); BAIL_ON_VMDIR_ERROR(dwError); cleanup: return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); VmDirFreeIndexCfg(pNewCfg); goto cleanup; }
DWORD VmDirUTDVectorUpdateNew( PVMDIR_UTDVECTOR_CACHE pNewUTDVectorCache ) { USN origUsnInDB = 0; USN newOrigUsn = 0; DWORD dwError = 0; PSTR pszInvocationId = NULL; PSTR pszKey = NULL; LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT; LW_HASHMAP_PAIR pair = {NULL, NULL}; if (!pNewUTDVectorCache) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } while (LwRtlHashMapIterate(pNewUTDVectorCache->pUtdVectorMap, &iter, &pair)) { origUsnInDB = 0; pszInvocationId = (PSTR) pair.pKey; newOrigUsn = (USN) pair.pValue; dwError = VmDirUTDVectorGlobalCacheLookup(pszInvocationId, &origUsnInDB); if (dwError == LW_STATUS_NOT_FOUND) { dwError = 0; } BAIL_ON_VMDIR_ERROR(dwError); if (origUsnInDB > newOrigUsn) { dwError = VmDirAllocateStringA(pszInvocationId, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert( pNewUTDVectorCache->pUtdVectorMap, pszKey, (PVOID)origUsnInDB, &pair); BAIL_ON_VMDIR_ERROR(dwError); pszKey = NULL; VmDirSimpleHashMapPairFreeKeyOnly(&pair, NULL); VMDIR_LOG_WARNING( VMDIR_LOG_MASK_ALL, "%s: smaller origUsn InvoId: %s origUsnInDB: %"PRId64 "newOrigUsn: %" PRId64, __FUNCTION__, VDIR_SAFE_STRING(pszInvocationId), origUsnInDB, newOrigUsn); } } cleanup: return dwError; error: VMDIR_SAFE_FREE_MEMORY(pszKey); VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
//TODO_REMOVE_REPLV2 DWORD VmDirAttributeMetaDataToHashMap( PVDIR_ATTRIBUTE pAttrAttrMetaData, PLW_HASHMAP* ppMetaDataMap ) { DWORD dwError = 0; DWORD dwCnt = 0; PLW_HASHMAP pMetaDataMap = NULL; PSTR pszKey = NULL; PVMDIR_ATTRIBUTE_METADATA pMetaData = NULL; if (!pAttrAttrMetaData || !ppMetaDataMap) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = LwRtlCreateHashMap( &pMetaDataMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); for (dwCnt = 0; pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val != NULL; dwCnt++) { // Format is: <attr name>:<local USN>:<version no>:<originating server ID>:<originating time>:<originating USN> char* pszMetaData = VmDirStringChrA(pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val, ':'); if (pszMetaData == NULL) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_BACKEND_INVALID_METADATA); } // pszMetaData now points to <local USN>... pszMetaData++; //pAttrAttrMetaData->vals[i] has <attr type>\0<pszMetaData> *(pszMetaData - 1) = '\0'; dwError = VmDirAllocateStringA(pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirMetaDataDeserialize(pszMetaData, &pMetaData); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pMetaDataMap, pszKey, pMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); pszKey = NULL; pMetaData = NULL; } *ppMetaDataMap = pMetaDataMap; cleanup: return dwError; error: if (pMetaDataMap) { LwRtlHashMapClear( pMetaDataMap, VmDirFreeMetaDataMapPair, NULL); LwRtlFreeHashMap(&pMetaDataMap); } VmDirFreeMetaData(pMetaData); VMDIR_SAFE_FREE_MEMORY(pszKey); VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirAttributeMetaDataListConvertToHashMap( PVDIR_LINKED_LIST pMetaDataList, PLW_HASHMAP *ppMetaDataMap ) { DWORD dwError = 0; PLW_HASHMAP pMetaDataMap = NULL; PVDIR_LINKED_LIST_NODE pCurrNode = NULL; PVDIR_LINKED_LIST_NODE pNextNode = NULL; PVMDIR_REPL_ATTRIBUTE_METADATA pReplMetaData = NULL; if (!pMetaDataList || !ppMetaDataMap) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = LwRtlCreateHashMap( &pMetaDataMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirLinkedListGetHead(pMetaDataList, &pCurrNode); BAIL_ON_VMDIR_ERROR(dwError); while (pCurrNode) { pReplMetaData = (PVMDIR_REPL_ATTRIBUTE_METADATA) pCurrNode->pElement; pNextNode = pCurrNode->pNext; dwError = LwRtlHashMapInsert( pMetaDataMap, pReplMetaData->pszAttrType, pReplMetaData->pMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); pReplMetaData->pszAttrType = NULL; pReplMetaData->pMetaData = NULL; VmDirFreeReplMetaData(pReplMetaData); dwError = VmDirLinkedListRemove(pMetaDataList, pCurrNode); BAIL_ON_VMDIR_ERROR(dwError) pCurrNode = pNextNode; } *ppMetaDataMap = pMetaDataMap; cleanup: return dwError; error: if (pMetaDataMap) { LwRtlHashMapClear( pMetaDataMap, VmDirFreeMetaDataMapPair, NULL); LwRtlFreeHashMap(&pMetaDataMap); } VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD _PopulateOperationModAttributes( LDAP *pLd, LDAPMessage *pEntry, PVDIR_OPERATION pLdapOp ) { DWORD dwError = 0; struct berval** ppValues = NULL; PLW_HASHMAP pHashMap = NULL; PSTR pszBuf = NULL; PSTR pszAttrName = NULL; PSTR pszAttrMetaData = NULL; PSTR pszAttrUsnlessMetaData = NULL; PSTR pszAttrNewMetaData = NULL; PSTR pszKey = NULL; PSTR pszValue = NULL; USN localUsn = 0; PVDIR_BERVALUE pBerValue = NULL; size_t iBerValueSize = 0; DWORD i = 0, j = 0; dwError = LwRtlCreateHashMap( &pHashMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL ); BAIL_ON_VMDIR_ERROR(dwError); dwError = pLdapOp->pBEIF->pfnBEGetNextUSN(pLdapOp->pBECtx, &localUsn); BAIL_ON_VMDIR_ERROR(dwError); if (!(ppValues = ldap_get_values_len(pLd, pEntry, ATTR_ATTR_META_DATA))) { dwError = VMDIR_ERROR_SCHEMA_BAD_METADATA; BAIL_ON_VMDIR_ERROR(dwError); } for (i = 0; ppValues[i] != NULL; i++) { dwError = VmDirAllocateStringA(ppValues[i]->bv_val, &pszBuf); BAIL_ON_VMDIR_ERROR(dwError); pszAttrName = VmDirStringTokA(pszBuf, ":", &pszAttrMetaData); VmDirStringTokA(pszAttrMetaData, ":", &pszAttrUsnlessMetaData); dwError = VmDirAllocateStringPrintf( &pszAttrNewMetaData, "%ld:%s", localUsn, pszAttrUsnlessMetaData); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pszAttrName, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pHashMap, pszKey, pszAttrNewMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_SAFE_FREE_MEMORY(pszBuf); } ldap_value_free_len(ppValues); ppValues = NULL; for (i = 0; ppszSchemaEntryAttrs[i] != NULL; i++) { if (VmDirStringCompareA(ppszSchemaEntryAttrs[i], ATTR_ATTR_META_DATA, FALSE) != 0) { ppValues = ldap_get_values_len(pLd, pEntry, ppszSchemaEntryAttrs[i]); if (ppValues) { iBerValueSize = ldap_count_values_len(ppValues); dwError = VmDirAllocateMemory( sizeof(VDIR_BERVALUE) * iBerValueSize, (PVOID*)&pBerValue); BAIL_ON_VMDIR_ERROR(dwError); if (VmDirStringCompareA(ppszSchemaEntryAttrs[i], ATTR_USN_CHANGED, FALSE) == 0) { assert(iBerValueSize == 1); dwError = VmDirAllocateStringPrintf(&pBerValue[0].lberbv_val, "%ld", localUsn); BAIL_ON_VMDIR_ERROR(dwError); pBerValue[0].lberbv_len = VmDirStringLenA(pBerValue[0].lberbv_val); pBerValue[0].bOwnBvVal = TRUE; } else { for (j = 0; j < iBerValueSize; j++) { dwError = VmDirAllocateStringA(ppValues[j]->bv_val, &pBerValue[j].lberbv_val); BAIL_ON_VMDIR_ERROR(dwError); pBerValue[j].lberbv_len = ppValues[j]->bv_len; pBerValue[j].bOwnBvVal = TRUE; } } dwError = VmDirOperationAddModReq( pLdapOp, MOD_OP_REPLACE, ppszSchemaEntryAttrs[i], pBerValue, iBerValueSize); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapFindKey( pHashMap, (PVOID*)&pszValue, ppszSchemaEntryAttrs[i]); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringCpyA( pLdapOp->request.modifyReq.mods->attr.metaData, VMDIR_MAX_ATTR_META_DATA_LEN, pszValue); BAIL_ON_VMDIR_ERROR(dwError); ldap_value_free_len(ppValues); ppValues = NULL; for (j = 0; j < iBerValueSize; j++) { VmDirFreeBervalContent(&pBerValue[j]); } VMDIR_SAFE_FREE_MEMORY(pBerValue); } } } cleanup: LwRtlHashMapClear(pHashMap, _FreeStringPair, NULL); LwRtlFreeHashMap(&pHashMap); return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s,%d failed, error(%d)", __FUNCTION__, __LINE__, dwError ); VMDIR_SAFE_FREE_MEMORY(pszBuf); VMDIR_SAFE_FREE_MEMORY(pszAttrNewMetaData); if (ppValues) { ldap_value_free_len(ppValues); } for (j = 0; j < iBerValueSize; j++) { VmDirFreeBervalContent(&pBerValue[j]); } VMDIR_SAFE_FREE_MEMORY(pBerValue); goto cleanup; }
DWORD VmDirIndexCfgRestoreProgress( PVDIR_BACKEND_CTX pBECtx, PVDIR_INDEX_CFG pIndexCfg, PBOOLEAN pbRestore ) { DWORD dwError = 0; PSTR pszStatusKey = NULL; PSTR pszStatusVal = NULL; PSTR pszInitOffsetKey = NULL; PSTR pszInitOffsetVal = NULL; PSTR pszScopesKey = NULL; PSTR pszScopesVal = NULL; PSTR pszNewScopesKey = NULL; PSTR pszNewScopesVal = NULL; PSTR pszDelScopesKey = NULL; PSTR pszDelScopesVal = NULL; PSTR pszScope = NULL; if (!pBECtx || !pIndexCfg || !pbRestore) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwError = _BuildAllKeyStrs( pIndexCfg, &pszStatusKey, &pszInitOffsetKey, &pszScopesKey, &pszNewScopesKey, &pszDelScopesKey); BAIL_ON_VMDIR_ERROR(dwError); if (gVdirIndexGlobals.bFirstboot) { pIndexCfg->status = VDIR_INDEXING_COMPLETE; } else { PSTR pszToken = NULL; char* save = NULL; dwError = pBECtx->pBE->pfnBEUniqKeyGetValue( pBECtx, pszStatusKey, &pszStatusVal); BAIL_ON_VMDIR_ERROR(dwError); pIndexCfg->status = VmDirStringToIA(pszStatusVal); dwError = pBECtx->pBE->pfnBEUniqKeyGetValue( pBECtx, pszInitOffsetKey, &pszInitOffsetVal); BAIL_ON_VMDIR_ERROR(dwError); pIndexCfg->initOffset = VmDirStringToIA(pszInitOffsetVal); dwError = pBECtx->pBE->pfnBEUniqKeyGetValue( pBECtx, pszScopesKey, &pszScopesVal); BAIL_ON_VMDIR_ERROR(dwError); if (!IsNullOrEmptyString(pszScopesVal)) { pszToken = VmDirStringTokA(pszScopesVal, INDEX_SEP, &save); while (pszToken) { dwError = VmDirAllocateStringA(pszToken, &pszScope); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert( pIndexCfg->pUniqScopes, pszScope, NULL, NULL); BAIL_ON_VMDIR_ERROR(dwError); pszScope = NULL; pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save); } } dwError = pBECtx->pBE->pfnBEUniqKeyGetValue( pBECtx, pszNewScopesKey, &pszNewScopesVal); BAIL_ON_VMDIR_ERROR(dwError); if (!IsNullOrEmptyString(pszNewScopesVal)) { pszToken = VmDirStringTokA(pszNewScopesVal, INDEX_SEP, &save); while (pszToken) { dwError = VmDirAllocateStringA(pszToken, &pszScope); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirLinkedListInsertHead( pIndexCfg->pNewUniqScopes, pszScope, NULL); BAIL_ON_VMDIR_ERROR(dwError); pszScope = NULL; pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save); } } dwError = pBECtx->pBE->pfnBEUniqKeyGetValue( pBECtx, pszDelScopesKey, &pszDelScopesVal); BAIL_ON_VMDIR_ERROR(dwError); if (!IsNullOrEmptyString(pszDelScopesVal)) { pszToken = VmDirStringTokA(pszDelScopesVal, INDEX_SEP, &save); while (pszToken) { dwError = VmDirAllocateStringA(pszToken, &pszScope); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirLinkedListInsertHead( pIndexCfg->pDelUniqScopes, pszScope, NULL); BAIL_ON_VMDIR_ERROR(dwError); pszScope = NULL; pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save); } } *pbRestore = TRUE; } cleanup: VMDIR_SAFE_FREE_MEMORY(pszStatusKey); VMDIR_SAFE_FREE_MEMORY(pszStatusVal); VMDIR_SAFE_FREE_MEMORY(pszInitOffsetKey); VMDIR_SAFE_FREE_MEMORY(pszInitOffsetVal); VMDIR_SAFE_FREE_MEMORY(pszScopesKey); VMDIR_SAFE_FREE_MEMORY(pszScopesVal); VMDIR_SAFE_FREE_MEMORY(pszNewScopesKey); VMDIR_SAFE_FREE_MEMORY(pszNewScopesVal); VMDIR_SAFE_FREE_MEMORY(pszDelScopesKey); VMDIR_SAFE_FREE_MEMORY(pszDelScopesVal); return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); VMDIR_SAFE_FREE_MEMORY(pszScope); goto cleanup; }
DWORD VmDirSchemaAttrIdMapReadDB( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap ) { DWORD dwError = 0; DWORD i = 0; VDIR_BACKEND_CTX beCtx = {0}; BOOLEAN bHasTxn = FALSE; PVMDIR_STRING_LIST pStringList = NULL; PSTR pszBuf = NULL; PSTR pszName = NULL; PSTR pszId = NULL; USHORT usId = 0; if (!pAttrIdMap) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } beCtx.pBE = VmDirBackendSelect(PERSISTED_DSE_ROOT_DN); dwError = beCtx.pBE->pfnBETxnBegin(&beCtx, VDIR_BACKEND_TXN_READ, &bHasTxn); BAIL_ON_VMDIR_ERROR(dwError); dwError = beCtx.pBE->pfnBEDupKeyGetValues( &beCtx, ATTR_ID_MAP_KEY, &pStringList); BAIL_ON_VMDIR_ERROR(dwError); if (bHasTxn) { dwError = beCtx.pBE->pfnBETxnCommit(&beCtx); bHasTxn = FALSE; BAIL_ON_VMDIR_ERROR(dwError); } for (i = 0; i < pStringList->dwCount; i++) { dwError = VmDirAllocateStringA(pStringList->pStringList[i], &pszBuf); BAIL_ON_VMDIR_ERROR(dwError); pszId = VmDirStringTokA(pszBuf, SCHEMA_ATTR_ID_MAP_SEP, &pszName); usId = (USHORT)VmDirStringToIA(pszId); if (VmDirSchemaAttrIdMapGetAttrId(pAttrIdMap, pszName, NULL) != 0) { dwError = VmDirAllocateStringA(pszName, &pszName); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pAttrIdMap->pStoredIds, pszName, (PVOID)(uintptr_t)usId, NULL); BAIL_ON_VMDIR_ERROR(dwError); if (usId >= pAttrIdMap->usNextId) { pAttrIdMap->usNextId = usId + 1; } } VMDIR_SAFE_FREE_MEMORY(pszBuf); } cleanup: VmDirBackendCtxContentFree(&beCtx); VmDirStringListFree(pStringList); return dwError; error: if (bHasTxn) { beCtx.pBE->pfnBETxnAbort(&beCtx); } VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); VMDIR_SAFE_FREE_MEMORY(pszBuf); goto cleanup; }
DWORD VmDirSchemaAttrIdMapUpdateDB( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap ) { DWORD dwError = 0; DWORD dwNumNewIds = 0; LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT; LW_HASHMAP_PAIR pair = {NULL, NULL}; PSTR pszMapStr = NULL; PVMDIR_STRING_LIST pMapStrList = NULL; VDIR_BACKEND_CTX beCtx = {0}; BOOLEAN bHasTxn = FALSE; if (!pAttrIdMap) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwNumNewIds = LwRtlHashMapGetCount(pAttrIdMap->pNewIds); if (dwNumNewIds == 0) { // No new Id goto cleanup; } dwError = VmDirStringListInitialize(&pMapStrList, dwNumNewIds); BAIL_ON_VMDIR_ERROR(dwError); while (LwRtlHashMapIterate(pAttrIdMap->pNewIds, &iter, &pair)) { dwError = VmDirAllocateStringPrintf(&pszMapStr, "%d%s%s", (USHORT)(uintptr_t)pair.pValue, SCHEMA_ATTR_ID_MAP_SEP, (PSTR)pair.pKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringListAdd(pMapStrList, pszMapStr); BAIL_ON_VMDIR_ERROR(dwError); } beCtx.pBE = VmDirBackendSelect(PERSISTED_DSE_ROOT_DN); dwError = beCtx.pBE->pfnBETxnBegin(&beCtx, VDIR_BACKEND_TXN_WRITE, &bHasTxn); BAIL_ON_VMDIR_ERROR( dwError ); dwError = beCtx.pBE->pfnBEDupKeySetValues(&beCtx, ATTR_ID_MAP_KEY, pMapStrList); BAIL_ON_VMDIR_ERROR(dwError); if (bHasTxn) { dwError = beCtx.pBE->pfnBETxnCommit(&beCtx); bHasTxn = FALSE; BAIL_ON_VMDIR_ERROR(dwError); } LwRtlHashMapResetIter(&iter); while (LwRtlHashMapIterate(pAttrIdMap->pNewIds, &iter, &pair)) { dwError = LwRtlHashMapInsert(pAttrIdMap->pStoredIds, pair.pKey, pair.pValue, NULL); BAIL_ON_VMDIR_ERROR(dwError); } LwRtlHashMapClear(pAttrIdMap->pNewIds, VmDirNoopHashMapPairFree, NULL); cleanup: VmDirBackendCtxContentFree(&beCtx); VmDirStringListFree(pMapStrList); return dwError; error: if (bHasTxn) { beCtx.pBE->pfnBETxnAbort(&beCtx); } VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); goto cleanup; }