DWORD VmDirPrepareSwapDBInfo( PCSTR pszHostName, // partner server object cn PVMDIR_SWAP_DB_INFO* ppSwapDBInfo ) { DWORD dwError = 0; PVMDIR_SWAP_DB_INFO pLocalSwapDBInfo = NULL; if (!ppSwapDBInfo) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = VmDirAllocateMemory(sizeof(VMDIR_SWAP_DB_INFO), (PVOID*)&pLocalSwapDBInfo); BAIL_ON_VMDIR_ERROR(dwError); if (pszHostName) { dwError = VmDirAllocateStringA(pszHostName, &pLocalSwapDBInfo->pszPartnerServerName); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_LOG_INFO(VMDIR_LOG_MASK_ALL, "My partner %s", pLocalSwapDBInfo->pszPartnerServerName); } dwError = VmDirInternalGetDSERootServerCN(&pLocalSwapDBInfo->pszOrgDBServerName); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_LOG_INFO(VMDIR_LOG_MASK_ALL, "DB was from %s", pLocalSwapDBInfo->pszOrgDBServerName); dwError = _VmDirComposeUtdVector(pLocalSwapDBInfo); BAIL_ON_VMDIR_ERROR(dwError); if (!pLocalSwapDBInfo->pszPartnerServerName || // no partner, DR case VmDirStringCompareA( // DB copied from joining partner pLocalSwapDBInfo->pszPartnerServerName, pLocalSwapDBInfo->pszOrgDBServerName, FALSE) == 0) { dwError = VmDirAllocateStringA(pLocalSwapDBInfo->pszOrgDBMaxUSN, &pLocalSwapDBInfo->pszMyHighWaterMark); BAIL_ON_VMDIR_ERROR(dwError); } else { // DB from one node but join to another dwError = _VmDirComposeHighWaterMark(pLocalSwapDBInfo); BAIL_ON_VMDIR_ERROR(dwError); } VMDIR_LOG_INFO(VMDIR_LOG_MASK_ALL, "My High Water Mark %s", pLocalSwapDBInfo->pszMyHighWaterMark); *ppSwapDBInfo = pLocalSwapDBInfo; cleanup: return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, " error (%u)", dwError); VmDirFreeSwapDBInfo(pLocalSwapDBInfo); 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 VmDirMetaDataCopyContent( PVMDIR_ATTRIBUTE_METADATA pSrcMetaData, PVMDIR_ATTRIBUTE_METADATA pDestMetaData ) { DWORD dwError = 0; if (VmDirMetaDataIsEmpty(pSrcMetaData) || !pDestMetaData) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } pDestMetaData->localUsn = pSrcMetaData->localUsn; pDestMetaData->version = pSrcMetaData->version; VMDIR_SAFE_FREE_MEMORY(pDestMetaData->pszOrigInvoId); dwError = VmDirAllocateStringA(pSrcMetaData->pszOrigInvoId, &pDestMetaData->pszOrigInvoId); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_SAFE_FREE_MEMORY(pDestMetaData->pszOrigTime); dwError = VmDirAllocateStringA(pSrcMetaData->pszOrigTime, &pDestMetaData->pszOrigTime); BAIL_ON_VMDIR_ERROR(dwError); pDestMetaData->origUsn = pSrcMetaData->origUsn; cleanup: return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
//pszMetadata: <local USN>:<version no>:<originating server ID>:<originating time>:<originating USN> DWORD VmDirMetaDataDeserialize( PCSTR pszMetaData, PVMDIR_ATTRIBUTE_METADATA* ppMetaData ) { DWORD dwError = 0; PCSTR pDelimiter = ":"; PVMDIR_STRING_LIST pStrList = NULL; PVMDIR_ATTRIBUTE_METADATA pMetaData = NULL; if (!pszMetaData || !ppMetaData) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = VmDirStringToTokenList(pszMetaData, pDelimiter, &pStrList); BAIL_ON_VMDIR_ERROR(dwError); if (pStrList->dwCount != 5) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_BACKEND_INVALID_METADATA); } dwError = VmDirAllocateMemory(sizeof(VMDIR_ATTRIBUTE_METADATA), (PVOID*) &pMetaData); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringToINT64(pStrList->pStringList[0], NULL, &pMetaData->localUsn); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringToUINT64(pStrList->pStringList[1], NULL, &pMetaData->version); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pStrList->pStringList[2], &pMetaData->pszOrigInvoId); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pStrList->pStringList[3], &pMetaData->pszOrigTime); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringToINT64(pStrList->pStringList[4], NULL, &pMetaData->origUsn); BAIL_ON_VMDIR_ERROR(dwError); *ppMetaData = pMetaData; cleanup: VmDirStringListFree(pStrList); return dwError; error: VmDirFreeMetaData(pMetaData); VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
/* * BDB configuration are done in two stages - * 1. startup stage for fix DB (i.e. non configurable one like ENTRY) * in InitBdbConfig() * 2. cn=indices stage to open all index DB * in InitializeBDBIndexDB * */ DWORD InitBdbConfig() { DWORD dwError = 0; VmDirLog( LDAP_DEBUG_TRACE, "InitBdbConfig: Begin" ); // Initialize entry database dwError = VmDirAllocateMemory( sizeof(VDIR_CFG_BDB_DATAFILE_DESC) * 1, (PVOID)&gVdirBdbGlobals.bdbEntryDB.pBdbDataFiles); BAIL_ON_VMDIR_ERROR(dwError); gVdirBdbGlobals.bdbEntryDB.usNumDataFiles = 1; gVdirBdbGlobals.bdbEntryDB.pBdbDataFiles[0].bIsUnique = TRUE; dwError = VmDirAllocateStringA( VMDIR_ENTRY_DB, &gVdirBdbGlobals.bdbEntryDB.pBdbDataFiles[0].pszDBName); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA( VMDIR_DB_FILE_NAME, &gVdirBdbGlobals.bdbEntryDB.pBdbDataFiles[0].pszDBFile); BAIL_ON_VMDIR_ERROR(dwError); gVdirBdbGlobals.bdbEntryDB.btKeyCmpFcn = NULL; // Set hard limit of MAX index attribute //TODO, could make this configurable gVdirBdbGlobals.bdbIndexDBs.usMaxSize = BDB_MAX_INDEX_ATTRIBUTE; dwError = VmDirAllocateMemory( sizeof(VDIR_BDB_INDEX_DATABASE) * BDB_MAX_INDEX_ATTRIBUTE, (PVOID)&gVdirBdbGlobals.bdbIndexDBs.pIndexDBs); BAIL_ON_VMDIR_ERROR(dwError); VmDirLog( LDAP_DEBUG_TRACE, "InitBdbConfig: End" ); cleanup: return dwError; error: goto cleanup; }
static DWORD _VmDirReplDCConnectInit( PVMDIR_REPLICATION_AGREEMENT pReplAgr ) { DWORD dwError = 0; pReplAgr->dcConn.connType = DC_CONNECTION_TYPE_REPL; pReplAgr->dcConn.creds.bUseDCAccountCreds = TRUE; pReplAgr->dcConn.dwConnectTimeoutSec = gVmdirGlobals.dwLdapConnectTimeoutSec; dwError = VmDirAllocateStringA(pReplAgr->pszHostname, &pReplAgr->dcConn.pszHostname); BAIL_ON_VMDIR_ERROR(dwError); // spawn background thread to handle connection VmDirInitDCConnThread(&pReplAgr->dcConn); cleanup: return dwError; error: pReplAgr->isDeleted = TRUE; VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s: %s error code (%d)", __FUNCTION__, VDIR_SAFE_STRING(pReplAgr->ldapURI), dwError); goto cleanup; }
DWORD VmDirSrvCreateAccessToken( PCSTR pszUPN, PVMDIR_SRV_ACCESS_TOKEN* ppAccessToken ) { DWORD dwError = 0; PVMDIR_SRV_ACCESS_TOKEN pAccessToken = NULL; dwError = VmDirAllocateMemory(sizeof(*pAccessToken), (PVOID*)&pAccessToken); BAIL_ON_VMDIR_ERROR(dwError); pAccessToken->refCount = 1; dwError = VmDirAllocateStringA(pszUPN, &pAccessToken->pszUPN); BAIL_ON_VMDIR_ERROR(dwError); *ppAccessToken = pAccessToken; cleanup: return dwError; error: *ppAccessToken = NULL; if (pAccessToken) { VmDirSrvReleaseAccessToken(pAccessToken); } goto cleanup; }
DWORD VmDirStringListAddStrClone( PCSTR pszStr, PVMDIR_STRING_LIST pStrList ) { DWORD dwError = 0; PSTR pszLocalStr = NULL; if (!pszStr || !pStrList) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwError = VmDirAllocateStringA(pszStr, &pszLocalStr); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringListAdd(pStrList, pszLocalStr); BAIL_ON_VMDIR_ERROR(dwError); pszLocalStr = NULL; cleanup: VMDIR_SAFE_FREE_MEMORY(pszLocalStr); return dwError; error: goto cleanup; }
static DWORD _VmDirGetDCCredsFromRegistry( PVMDIR_CONNECTION_CREDS pDCCreds ) { DWORD dwError = 0; VmDirFreeConnCredContent(pDCCreds); dwError = VmDirAllocateStringA( gVmdirServerGlobals.dcAccountUPN.lberbv.bv_val, &pDCCreds->pszUPN); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirReadDCAccountPassword(&pDCCreds->pszPassword); BAIL_ON_VMDIR_ERROR(dwError); VmDirReadDCAccountOldPassword(&pDCCreds->pszOldPassword); // ignore error cleanup: return dwError; error: goto cleanup; }
DWORD _VdcGetAttributeFromEntry( LDAP *pLd, LDAPMessage* pEntry, PSTR pszAttributeName, PSTR *ppszAttributeValue ) { DWORD dwError = 0; PSTR pszAttributeValue = NULL; BerValue** ppBerValues = NULL; ppBerValues = ldap_get_values_len(pLd, pEntry, pszAttributeName); if (ppBerValues != NULL && ldap_count_values_len(ppBerValues) > 0) { dwError = VmDirAllocateStringA(ppBerValues[0][0].bv_val, &pszAttributeValue); BAIL_ON_VMDIR_ERROR(dwError); } *ppszAttributeValue = pszAttributeValue; cleanup: if (ppBerValues) { ldap_value_free_len(ppBerValues); ppBerValues = NULL; } return dwError; error: VMDIR_SAFE_FREE_STRINGA(pszAttributeValue); goto cleanup; }
/* * Allocate string into pDupBerval */ DWORD VmDirStringToBervalContent( PCSTR pszBerval, PVDIR_BERVALUE pDupBerval ) { DWORD dwError = 0; VmDirFreeBervalContent(pDupBerval); dwError = VmDirAllocateStringA(pszBerval, &pDupBerval->lberbv.bv_val); BAIL_ON_VMDIR_ERROR(dwError); pDupBerval->bOwnBvVal = TRUE; pDupBerval->lberbv.bv_len = VmDirStringLenA(pDupBerval->lberbv.bv_val); cleanup: return dwError; error: VmDirFreeBervalContent(pDupBerval); goto cleanup; }
static DWORD _VmDirUTDVectorStrToPair( PSTR pszKey, PSTR pszValue, LW_HASHMAP_PAIR* pPair ) { PSTR pszDupKey = NULL; DWORD dwError = 0; USN Usn = 0; dwError = VmDirAllocateStringA(pszKey, &pszDupKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringToINT64(pszValue, NULL, &Usn); BAIL_ON_VMDIR_ERROR(dwError); pPair->pKey = (PVOID) pszDupKey; pPair->pValue = (PVOID) Usn; pszDupKey = NULL; cleanup: VMDIR_SAFE_FREE_MEMORY(pszDupKey); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirDDVectorUpdate( PCSTR pszInvocationId, DWORD dwValue ) { DWORD dwError = 0; BOOLEAN bInLock = FALSE; dwError = VmDirAllocateStringA( pszInvocationId, &gVmdirServerGlobals.pReplDeadlockDetectionVector->pszInvocationId); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_LOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); dwError = _VmDirDDVectorUpdateInLock(dwValue); BAIL_ON_VMDIR_ERROR(dwError); cleanup: VMDIR_UNLOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirUTDVectorCacheToString( PVMDIR_UTDVECTOR_CACHE pUTDVector, PSTR* ppszUTDVector ) { DWORD dwError = 0; BOOLEAN bInLock = FALSE; PSTR pszUTDVector = NULL; if (!pUTDVector || !ppszUTDVector) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } VMDIR_RWLOCK_READLOCK(bInLock, pUTDVector->pUtdVectorLock, 0); dwError = VmDirAllocateStringA(pUTDVector->pszUtdVector, &pszUTDVector); BAIL_ON_VMDIR_ERROR(dwError); *ppszUTDVector = pszUTDVector; cleanup: VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD VmDirSetEnvironment( VOID ) { DWORD dwError = 0; PSTR pszKrb5Conf = NULL; dwError = VmDirRegReadKrb5Conf(&pszKrb5Conf); if (dwError) { dwError = VmDirAllocateStringA(VMDIR_DEFAULT_KRB5_CONF, &pszKrb5Conf); BAIL_ON_VMDIR_ERROR(dwError); } if (-1 == setenv("KRB5_CONFIG", pszKrb5Conf, 1)) { dwError = ERROR_NO_MEMORY; BAIL_ON_VMDIR_ERROR(dwError); } cleanup: VMDIR_SAFE_FREE_STRINGA(pszKrb5Conf); return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "VmDirSetEnvironment failed (%u)", dwError); goto cleanup; }
static DWORD _VmDirMDBInitializeDBEntry( const char *pszDBPath, PVDIR_MDB_DB *ppDB ) { DWORD dwError = 0; PVDIR_MDB_DB pDB = NULL; if (!pszDBPath || !ppDB) { BAIL_WITH_VMDIR_ERROR(dwError, ERROR_INVALID_PARAMETER); } dwError = VmDirAllocateMemory (sizeof(VDIR_MDB_DB), ((PVOID*)&pDB)); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA (pszDBPath, &pDB->pszDBPath); BAIL_ON_VMDIR_ERROR(dwError); *ppDB = pDB; cleanup: return dwError; error: if (pDB) { VMDIR_SAFE_FREE_MEMORY(pDB->pszDBPath); VMDIR_SAFE_FREE_MEMORY(pDB); } goto cleanup; }
static VOID _VmDirCollectBindSuperLog( PVDIR_CONNECTION pConn, PVDIR_OPERATION pOp ) { DWORD dwError = 0; pConn->SuperLogRec.iEndTime = VmDirGetTimeInMilliSec(); if (pOp->reqDn.lberbv.bv_val) // TODO, for failed SASL bind scenario, we need DN/UPN a well. { dwError = VmDirAllocateStringA(pOp->reqDn.lberbv.bv_val, &(pConn->SuperLogRec.pszBindID)); BAIL_ON_VMDIR_ERROR(dwError); } VmDirLogOperation(gVmdirGlobals.pLogger, LDAP_REQ_BIND, pConn, pOp->ldapResult.errCode); // // Flush times once we log. // pConn->SuperLogRec.iStartTime = pConn->SuperLogRec.iEndTime = 0; cleanup: return; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "%s failed, error code %d", __FUNCTION__, dwError); goto cleanup; }
static int _ParseCondWriteControlVal( VDIR_OPERATION * pOp, BerValue * pControlBer, // Input: control value encoded as ber VDIR_CONDWRITE_CONTROL_VALUE * pCtrlVal, // Output VDIR_LDAP_RESULT * pLdapResult // Output ) { int retVal = LDAP_SUCCESS; BerElementBuffer berbuf; BerElement * ber = (BerElement *)&berbuf; PSTR pszLocalErrorMsg = NULL; PSTR pszCondFilter = NULL; if (!pOp) { retVal = LDAP_PROTOCOL_ERROR; BAIL_ON_VMDIR_ERROR( retVal ); } ber_init2( ber, pControlBer, LBER_USE_DER ); /* * https://confluence.eng.vmware.com/display/LIG/Conditional+LDAP+Write+Operation * * The ConditionalWriteControl is a null terminated STRING wrapping the BER-encoded version of the following SEQUENCE: * * ControlValue ::= SEQUENCE { * ConditionalWriteFilter OCTET STRING * } */ if (ber_scanf(ber, "{a}", &pszCondFilter) == LBER_ERROR) { VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s: ber_scanf failed while parsing filter value", __FUNCTION__); pLdapResult->errCode = LDAP_PROTOCOL_ERROR; retVal = LDAP_NOTICE_OF_DISCONNECT; BAIL_ON_VMDIR_ERROR_WITH_MSG( retVal, (pszLocalErrorMsg), "Error in reading conditional write control filter"); } retVal = VmDirAllocateStringA(pszCondFilter, &(pCtrlVal->pszFilter)); BAIL_ON_VMDIR_ERROR(retVal); cleanup: if (pszCondFilter) { ber_memfree(pszCondFilter); } VMDIR_SAFE_FREE_MEMORY(pszLocalErrorMsg); return retVal; error: VMDIR_APPEND_ERROR_MSG(pLdapResult->pszErrMsg, pszLocalErrorMsg); goto cleanup; }
DWORD VmDirMetaDataCreate( USN localUsn, UINT64 version, PCSTR pszOrigInvoId, PCSTR pszOrigTimeStamp, USN origUsn, PVMDIR_ATTRIBUTE_METADATA* ppMetaData ) { DWORD dwError = 0; PVMDIR_ATTRIBUTE_METADATA pMetaData = NULL; if (!ppMetaData || IsNullOrEmptyString(pszOrigInvoId) || IsNullOrEmptyString(pszOrigTimeStamp)) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = VmDirAllocateMemory(sizeof(VMDIR_ATTRIBUTE_METADATA), (PVOID*) &pMetaData); BAIL_ON_VMDIR_ERROR(dwError); pMetaData->localUsn = localUsn; pMetaData->version = version; dwError = VmDirAllocateStringA(pszOrigInvoId, &pMetaData->pszOrigInvoId); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pszOrigTimeStamp, &pMetaData->pszOrigTime); BAIL_ON_VMDIR_ERROR(dwError); pMetaData->origUsn = origUsn; *ppMetaData = pMetaData; cleanup: return dwError; error: VmDirFreeMetaData(pMetaData); VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD _convertHashMapToSuperlogTable( PLW_HASHMAP pHashMap, PVMDIR_SUPERLOG_TABLE_COLUMN_SET pCols, PVMDIR_SUPERLOG_TABLE *ppTable ) { DWORD dwError = 0; DWORD dwCount = 0; PVMDIR_SUPERLOG_TABLE pTable = NULL; LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT; LW_HASHMAP_PAIR pair = {NULL, NULL}; unsigned int i = 0; unsigned int j; PVMDIR_SUPERLOG_TABLE_ROW pSrcRow = NULL; PVMDIR_SUPERLOG_TABLE_ROW pDstRow = NULL; dwCount = LwRtlHashMapGetCount(pHashMap); dwError = _allocateSuperlogTable(dwCount, pCols, &pTable); BAIL_ON_VMDIR_ERROR(dwError); while (LwRtlHashMapIterate(pHashMap, &iter, &pair)) { pSrcRow = pair.pValue; pDstRow = (PVMDIR_SUPERLOG_TABLE_ROW)&pTable->rows[i++]; pDstRow->count = pSrcRow->count; pDstRow->totalTime = pSrcRow->totalTime; for (j = 0; j < VMDIR_SUPERLOG_TABLE_COL_NUM; j++) { if (pSrcRow->colVals[j]) { dwError = VmDirAllocateStringA(pSrcRow->colVals[j], &pDstRow->colVals[j]); BAIL_ON_VMDIR_ERROR(dwError); } } dwError = VmDirAllocateStringPrintf( &pDstRow->colVals[AVG_TIME], "%lu", pDstRow->totalTime / pDstRow->count ); BAIL_ON_VMDIR_ERROR(dwError); } *ppTable = pTable; cleanup: return dwError; error: VmDirFreeSuperLogTable(pTable); goto cleanup; }
static DWORD schemaInitFillAttrFromCache( PVDIR_SCHEMA_CTX pCtx, PSTR* ppszValues, USHORT dwValueSize, PSTR pszAttrName, PVDIR_ENTRY pEntry ) { DWORD dwError = 0; DWORD dwCnt = 0; VDIR_ATTRIBUTE* pAttr = NULL; dwError = VmDirAttributeAllocate( pszAttrName, dwValueSize, pCtx, &pAttr); BAIL_ON_VMDIR_ERROR(dwError); for (dwCnt = 0; dwCnt < dwValueSize; dwCnt++) { char* pszStr = &ppszValues[dwCnt][0]; //ignore leading spaces while (*pszStr == ' ') pszStr++; dwError = VmDirAllocateStringA( ppszValues[dwCnt], &pAttr->vals[dwCnt].lberbv.bv_val); BAIL_ON_VMDIR_ERROR(dwError); pAttr->vals[dwCnt].bOwnBvVal = TRUE; pAttr->vals[dwCnt].lberbv.bv_len = VmDirStringLenA(pAttr->vals[dwCnt].lberbv.bv_val); } dwError = VmDirEntryAddAttribute( pEntry, pAttr); BAIL_ON_VMDIR_ERROR(dwError); pAttr = NULL; cleanup: return dwError; error: if (pAttr) { VmDirFreeAttribute(pAttr); } goto cleanup; }
VOID _Test_VmdirAllocateStringA_NullDestinationString( VOID ) { DWORD dwError = 0; dwError = VmDirAllocateStringA("test", NULL); ASSERT(dwError == 0); }
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; }
static DWORD _VmDirSchemaAttrReplaceValue( PVDIR_ATTRIBUTE pAttr, PCSTR pszMatchSubstr, PCSTR pszValue ) { #define MAX_BUF_SIZE_256 256 DWORD dwError = 0; unsigned iCnt = 0; CHAR pszBuf[MAX_BUF_SIZE_256] = {0}; dwError = VmDirStringPrintFA( pszBuf, MAX_BUF_SIZE_256 -1 , "NAME '%s' ", pszMatchSubstr ); BAIL_ON_VMDIR_ERROR(dwError); for (iCnt = 0; iCnt < pAttr->numVals; iCnt++) { if ( VmDirCaselessStrStrA( pAttr->vals[iCnt].lberbv_val, pszBuf ) != NULL ) { if ( VmDirStringCompareA( VDIR_SAFE_STRING(pAttr->vals[iCnt].lberbv_val), pszValue, FALSE ) != 0 ) { VMDIR_LOG_INFO( VMDIR_LOG_MASK_ALL, "Merge schema, replace old - %s", VDIR_SAFE_STRING(pAttr->vals[iCnt].lberbv_val)); VMDIR_LOG_INFO( VMDIR_LOG_MASK_ALL, "Merge schema, replace new - %s", pszValue ); } VMDIR_LOG_DEBUG( VMDIR_LOG_MASK_ALL, "Merge schema, replace old - %s", VDIR_SAFE_STRING(pAttr->vals[iCnt].lberbv_val)); VmDirFreeBervalContent( &(pAttr->vals[iCnt]) ); dwError = VmDirAllocateStringA( pszValue, &(pAttr->vals[iCnt].lberbv_val) ); BAIL_ON_VMDIR_ERROR(dwError); pAttr->vals[iCnt].lberbv_len = VmDirStringLenA( pszValue ); pAttr->vals[iCnt].bOwnBvVal = TRUE; VMDIR_LOG_DEBUG( VMDIR_LOG_MASK_ALL, "Merge schema, replace new - %s", VDIR_SAFE_STRING(pAttr->vals[iCnt].lberbv_val)); break; } } cleanup: return dwError; error: goto cleanup; }
static DWORD _VmDirSchemaComputeAllowedChildClassesEffective( PVDIR_ENTRY pEntry, PVDIR_ATTRIBUTE* ppOutAttr ) { DWORD dwError = 0; PVDIR_SCHEMA_OC_DESC pStructureOCDesc = NULL; PVDIR_ATTRIBUTE pLocalAttr = NULL; int iCnt = 0; dwError = VmDirSchemaGetEntryStructureOCDesc( pEntry, &pStructureOCDesc ); BAIL_ON_VMDIR_ERROR(dwError); if ( !pStructureOCDesc ) { dwError = ERROR_INVALID_ENTRY; BAIL_ON_VMDIR_ERROR(dwError); } for (iCnt = 0; pStructureOCDesc->ppszAllowedChildOCs && pStructureOCDesc->ppszAllowedChildOCs[iCnt]; iCnt++) {} if (iCnt > 0) { dwError = VmDirAttributeAllocate( ATTR_ALLOWD_CHILD_CLASSES_EFFECTIVE, iCnt, pEntry->pSchemaCtx, &pLocalAttr); BAIL_ON_VMDIR_ERROR(dwError); for (iCnt = 0; pStructureOCDesc->ppszAllowedChildOCs[iCnt]; iCnt++) { dwError = VmDirAllocateStringA( pStructureOCDesc->ppszAllowedChildOCs[iCnt], &(pLocalAttr->vals[iCnt].lberbv_val)); BAIL_ON_VMDIR_ERROR(dwError); pLocalAttr->vals[iCnt].lberbv_len = VmDirStringLenA(pLocalAttr->vals[iCnt].lberbv_val); pLocalAttr->vals[iCnt].bOwnBvVal = TRUE; } } *ppOutAttr = pLocalAttr; cleanup: return dwError; error: VmDirFreeAttribute( pLocalAttr ); goto cleanup; }
DWORD VdcSchemaConnValidateAndSetDefault( PVDC_SCHEMA_CONN pConn ) { DWORD dwError = 0; if (!pConn) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } // domain is mandatory if (!pConn->pszDomain) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } // default host is "localhost" if (!pConn->pszHostName) { dwError = VmDirAllocateStringA("localhost", &pConn->pszHostName); BAIL_ON_VMDIR_ERROR(dwError); } // default user is "administrator" if (!pConn->pszUserName) { dwError = VmDirAllocateStringA("administrator", &pConn->pszUserName); BAIL_ON_VMDIR_ERROR(dwError); } dwError = VmDirAllocateStringPrintf( &pConn->pszUPN, "%s@%s", pConn->pszUserName, pConn->pszDomain); BAIL_ON_VMDIR_ERROR(dwError); error: return dwError; }
VOID _Test_VmdirAllocateStringA_EmptySourceString( VOID ) { DWORD dwError = 0; PSTR pszString = NULL; dwError = VmDirAllocateStringA("", &pszString); ASSERT(dwError == 0); ASSERT(*pszString == '\0'); }
static DWORD _VmDirSimpleEntryCreateInBEWithGuid( PVDIR_BACKEND_INTERFACE pBE, PVDIR_SCHEMA_CTX pSchemaCtx, PSTR* ppszEntryInitializer, PSTR pszDN, ENTRYID ulEntryId, PSTR pszGuid /* Optional */ ) { DWORD dwError = 0; VDIR_OPERATION ldapOp = {0}; dwError = VmDirInitStackOperation( &ldapOp, VDIR_OPERATION_TYPE_INTERNAL, LDAP_REQ_ADD, pSchemaCtx ); BAIL_ON_VMDIR_ERROR(dwError); ldapOp.pBEIF = pBE; assert(ldapOp.pBEIF); ldapOp.reqDn.lberbv.bv_val = pszDN; ldapOp.reqDn.lberbv.bv_len = VmDirStringLenA(pszDN); dwError = AttrListToEntry( pSchemaCtx, pszDN, ppszEntryInitializer, ldapOp.request.addReq.pEntry); BAIL_ON_VMDIR_ERROR(dwError); ldapOp.request.addReq.pEntry->eId = ulEntryId; if (!IsNullOrEmptyString(pszGuid)) { dwError = VmDirAllocateStringA(pszGuid, &ldapOp.request.addReq.pEntry->pszGuid); BAIL_ON_VMDIR_ERROR(dwError); } dwError = VmDirInternalAddEntry(&ldapOp); BAIL_ON_VMDIR_ERROR(dwError); cleanup: VmDirFreeOperationContent(&ldapOp); return dwError; error: goto cleanup; }
VOID _Test_VmdirAllocateStringA_CallShouldSucceed( VOID ) { DWORD dwError = 0; PSTR pszString = NULL; dwError = VmDirAllocateStringA("Hello, world!", &pszString); ASSERT(dwError == 0); ASSERT(strcmp(pszString, "Hello, world!") == 0); }
VOID _Test_VmdirAllocateStringA_NullSourceString( VOID ) { DWORD dwError = 0; PSTR pszString = (PSTR)0xDEADBEEF; dwError = VmDirAllocateStringA(NULL, &pszString); ASSERT(dwError == 0); ASSERT(pszString == NULL); }