VOID
VmDirLogTerminate(
VOID
)
{
if ( _gpVmDirLogCtx )
{
if ( _gpVmDirLogCtx->pFile )
{
fclose( _gpVmDirLogCtx->pFile );
}
if ( _gpVmDirLogCtx->bSyslog )
{
if ( _gpVmDirLogCtx->pszSyslogDaemon )
{
closelog();
VMDIR_SAFE_FREE_MEMORY( _gpVmDirLogCtx->pszSyslogDaemon);
}
}
VMDIR_SAFE_FREE_MEMORY( _gpVmDirLogCtx->pszLogFileName );
VMDIR_SAFE_FREE_MEMORY( _gpVmDirLogCtx );
}
return;
}
/*
* Free a heap Attribute
* (ATTENTION: if the pAttr is within a pEntry, only when pEntry is constructed as
* ENTRY_STORAGE_FORMAT_NORMAL allocation type, its attribute can be freed using this function;
* otherwise, an entry's attribute free is taken care of by 'pEntry->bvs'
*/
VOID
VmDirFreeAttribute(
PVDIR_ATTRIBUTE pAttr
)
{
if (!pAttr)
{
return;
}
// pAttr->type is always store in place and has NO bvnorm_val. no need to free here.
if (!dequeIsEmpty(&pAttr->valueMetaDataToAdd))
{
VmDirFreeAttrValueMetaDataDequeueContent(&pAttr->valueMetaDataToAdd);
}
if (!dequeIsEmpty(&pAttr->valueMetaDataToDelete))
{
VmDirFreeAttrValueMetaDataDequeueContent(&pAttr->valueMetaDataToDelete);
}
VmDirFreeMetaData(pAttr->pMetaData);
VmDirFreeBervalContent(&pAttr->type);
VmDirFreeBervalArrayContent(pAttr->vals, pAttr->numVals);
VMDIR_SAFE_FREE_MEMORY(pAttr->vals);
VMDIR_SAFE_FREE_MEMORY(pAttr);
}
VOID
VmDirFreeUTDVectorCache(
PVMDIR_UTDVECTOR_CACHE pUTDVector
)
{
BOOLEAN bInLock = FALSE;
if (!pUTDVector)
{
return;
}
VMDIR_RWLOCK_WRITELOCK(bInLock, pUTDVector->pUtdVectorLock, 0);
if (pUTDVector->pUtdVectorMap)
{
LwRtlHashMapClear(pUTDVector->pUtdVectorMap, VmDirSimpleHashMapPairFreeKeyOnly, NULL);
LwRtlFreeHashMap(&pUTDVector->pUtdVectorMap);
}
VMDIR_SAFE_FREE_MEMORY(pUTDVector->pszUtdVector);
VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock);
VMDIR_SAFE_FREE_RWLOCK(pUTDVector->pUtdVectorLock);
VMDIR_SAFE_FREE_MEMORY(pUTDVector);
}
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;
}
VOID
VmDirFreeBervalContent(
VDIR_BERVALUE* pBerv
)
{
if (!pBerv)
{
return;
}
if (pBerv->bvnorm_val != NULL &&
pBerv->bvnorm_val != pBerv->lberbv.bv_val)
{
VMDIR_SAFE_FREE_MEMORY(pBerv->bvnorm_val);
}
if (pBerv->bOwnBvVal)
{
VMDIR_SAFE_FREE_MEMORY(pBerv->lberbv.bv_val);
}
memset(pBerv, 0, sizeof(*pBerv));
return;
}
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;
}
/*
* Free SASL related resources.
*/
VOID
VmDirSASLSessionClose(
PVDIR_SASL_BIND_INFO pSaslBindInfo
)
{
if (pSaslBindInfo)
{
if (pSaslBindInfo->pSaslCtx)
{
if (pSaslBindInfo->saslSSF > 0)
{
VmDirSASLSockbufRemove(pSaslBindInfo->pSockbuf);
}
sasl_dispose(&pSaslBindInfo->pSaslCtx);
pSaslBindInfo->pSaslCtx = NULL;
}
VMDIR_SAFE_FREE_MEMORY(pSaslBindInfo->pSessionCB);
VMDIR_SAFE_FREE_MEMORY(pSaslBindInfo->pszBindUserName);
VmDirFreeBervalContent(&pSaslBindInfo->bvMechnism);
}
return;
}
VOID
VmDirDDVectorShutdown(
VOID
)
{
BOOLEAN bInLock = FALSE;
if (gVmdirServerGlobals.pReplDeadlockDetectionVector)
{
VMDIR_LOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex);
if (gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap)
{
LwRtlHashMapClear(
gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap,
VmDirSimpleHashMapPairFree,
NULL);
LwRtlFreeHashMap(&gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap);
}
VMDIR_SAFE_FREE_MEMORY(gVmdirServerGlobals.pReplDeadlockDetectionVector->pszInvocationId);
VMDIR_UNLOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex);
}
VMDIR_SAFE_FREE_MUTEX(gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex);
VMDIR_SAFE_FREE_MEMORY(gVmdirServerGlobals.pReplDeadlockDetectionVector);
}
/*
* When LdapSchema is created from file or subschema subentry, it contains
* data which is no longer needed. Only relevant data should remain in order
* to keep LdapSchema instance always consistent.
*/
DWORD
VmDirLdapSchemaRemoveNoopData(
PVDIR_LDAP_SCHEMA pSchema
)
{
DWORD dwError = 0;
LW_HASHMAP_ITER atIter = LW_HASHMAP_ITER_INIT;
LW_HASHMAP_ITER crIter = LW_HASHMAP_ITER_INIT;
LW_HASHMAP_PAIR pair = {NULL, NULL};
if (!pSchema)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
while (LwRtlHashMapIterate(pSchema->attributeTypes, &atIter, &pair))
{
PVDIR_LDAP_ATTRIBUTE_TYPE pAt = (PVDIR_LDAP_ATTRIBUTE_TYPE)pair.pValue;
VMDIR_SAFE_FREE_MEMORY(pAt->pSource->at_equality_oid);
VMDIR_SAFE_FREE_MEMORY(pAt->pSource->at_ordering_oid);
VMDIR_SAFE_FREE_MEMORY(pAt->pSource->at_substr_oid);
VMDIR_SAFE_FREE_MEMORY(pAt->pSource->at_sup_oid);
pAt->pSource->at_syntax_len = 0;
}
while (LwRtlHashMapIterate(pSchema->contentRules, &crIter, &pair))
{
PVDIR_LDAP_CONTENT_RULE pCr = (PVDIR_LDAP_CONTENT_RULE)pair.pValue;
VMDIR_SAFE_FREE_MEMORY(pCr->pSource->cr_desc);
}
error:
return dwError;
}
VOID
VmDirFreeBervalArrayContent(
PVDIR_BERVALUE pBervs,
USHORT usSize
)
{
USHORT usCnt = 0;
if (pBervs != NULL)
{
for (usCnt = 0; usCnt < usSize; usCnt++)
{
if (pBervs[usCnt].bvnorm_val != NULL &&
pBervs[usCnt].bvnorm_val != pBervs[usCnt].lberbv.bv_val)
{
VMDIR_SAFE_FREE_MEMORY(pBervs[usCnt].bvnorm_val);
}
if (pBervs[usCnt].bOwnBvVal)
{
VMDIR_SAFE_FREE_MEMORY(pBervs[usCnt].lberbv.bv_val);
}
}
memset(pBervs, 0, sizeof(*pBervs) * usSize);
}
}
VOID
VmDirMDBIndexIteratorFree(
PVDIR_BACKEND_INDEX_ITERATOR pIterator
)
{
PVDIR_MDB_INDEX_ITERATOR pMdbIterator = NULL;
if (pIterator)
{
pMdbIterator = (PVDIR_MDB_INDEX_ITERATOR)pIterator->pIterator;
if (pMdbIterator)
{
if (pMdbIterator->pCursor)
{
mdb_cursor_close(pMdbIterator->pCursor);
}
if (pMdbIterator->pTxn)
{
if (pMdbIterator->bAbort)
{
mdb_txn_abort(pMdbIterator->pTxn);
}
else
{
mdb_txn_commit(pMdbIterator->pTxn);
}
}
VMDIR_SAFE_FREE_MEMORY(pMdbIterator->pszVal);
VMDIR_SAFE_FREE_MEMORY(pMdbIterator);
}
VMDIR_SAFE_FREE_MEMORY(pIterator);
}
}
static
DWORD
_VmDirRidSyncThr(
PVOID pArg
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PVDIR_THREAD_INFO pThrInfo = (PVDIR_THREAD_INFO)pArg;
PVMDIR_SID_GEN_STACK_NODE pSidGenStackNode = NULL;
VMDIR_LOG_VERBOSE( VMDIR_LOG_MASK_ALL, "_VmDirRidSyc thr started" );
while (1)
{
if (VmDirdState() == VMDIRD_STATE_SHUTDOWN)
{
goto cleanup;
}
VMDIR_SAFE_FREE_MEMORY(pSidGenStackNode);
while (VmDirPopTSStack(gSidGenState.pStack, (PVOID*)&pSidGenStackNode) == 0 &&
pSidGenStackNode != NULL)
{
(VOID)VmDirSyncRIDSeqToDB(
pSidGenStackNode->pszDomainDn,
pSidGenStackNode->dwDomainRidSequence);
if (VmDirdState() == VMDIRD_STATE_SHUTDOWN)
{
//
// Any pending updates will be performed by VmDirVmAclShutdown.
//
goto cleanup;
}
VMDIR_SAFE_FREE_MEMORY(pSidGenStackNode);
}
VMDIR_LOCK_MUTEX(bInLock, pThrInfo->mutexUsed);
VmDirConditionTimedWait(
pThrInfo->conditionUsed,
pThrInfo->mutexUsed,
3 * 1000); // time wait 3 seconds
// ignore error
VMDIR_UNLOCK_MUTEX(bInLock, pThrInfo->mutexUsed);
}
cleanup:
VMDIR_LOG_VERBOSE( VMDIR_LOG_MASK_ALL, "_VmDirRidSyc thr stopped (%d)", dwError );
VMDIR_SAFE_FREE_MEMORY(pSidGenStackNode);
return dwError;
}
VOID
VdcHashMapFreeStringPair(
PLW_HASHMAP_PAIR pPair,
LW_PVOID pUserData
)
{
VMDIR_SAFE_FREE_MEMORY(pPair->pKey);
VMDIR_SAFE_FREE_MEMORY(pPair->pValue);
}
static
DWORD
_VmGetHighestCommittedUSN(
PSTR* ppszHighestCommittedUSN
)
{
DWORD dwError = 0;
USN usn = 0;
USN nextUSN = 0;
VDIR_ENTRY_ARRAY entryArray = {0};
PSTR pszUSN = NULL;
VDIR_BACKEND_CTX beCtx = {0};
beCtx.pBE = VmDirBackendSelect(NULL);
assert(beCtx.pBE);
dwError = beCtx.pBE->pfnBEGetNextUSN(&beCtx, &nextUSN);
BAIL_ON_VMDIR_ERROR(dwError);
for (usn=nextUSN; usn > 1LL; usn--)
{
VMDIR_SAFE_FREE_MEMORY(pszUSN);
VmDirFreeEntryArrayContent(&entryArray);
dwError = VmDirAllocateStringPrintf(&pszUSN, "%" PRId64, usn);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSimpleEqualFilterInternalSearch(
"", LDAP_SCOPE_SUBTREE, ATTR_USN_CHANGED, pszUSN, &entryArray);
BAIL_ON_VMDIR_ERROR(dwError);
if (entryArray.iSize == 1 )
{
break;
}
}
if (usn == 0)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_STATE);
}
*ppszHighestCommittedUSN = pszUSN;
pszUSN = NULL;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszUSN);
VmDirFreeEntryArrayContent(&entryArray);
VmDirBackendCtxContentFree(&beCtx);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "error (%u), start USN %" PRId64, dwError, nextUSN);
goto cleanup;
}
DWORD
VmDirIndexUpdateCommit(
PVDIR_INDEX_UPD pIndexUpd
)
{
DWORD dwError = 0;
LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT;
LW_HASHMAP_PAIR pair = {NULL, NULL};
PSTR pszStatus = NULL;
if (!pIndexUpd)
{
dwError = VMDIR_ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
while (LwRtlHashMapIterate(pIndexUpd->pUpdIndexCfgMap, &iter, &pair))
{
PVDIR_INDEX_CFG pIndexCfg = (PVDIR_INDEX_CFG)pair.pValue;
dwError = VmDirIndexCfgRecordProgress(pIndexUpd->pBECtx, pIndexCfg);
BAIL_ON_VMDIR_ERROR(dwError);
VMDIR_SAFE_FREE_MEMORY(pszStatus);
dwError = VmDirIndexCfgStatusStringfy(pIndexCfg, &pszStatus);
BAIL_ON_VMDIR_ERROR(dwError);
VMDIR_LOG_INFO( VMDIR_LOG_MASK_ALL, pszStatus );
}
if (pIndexUpd->bHasBETxn)
{
PVDIR_BACKEND_INTERFACE pBE = pIndexUpd->pBECtx->pBE;
dwError = pBE->pfnBETxnCommit(pIndexUpd->pBECtx);
BAIL_ON_VMDIR_ERROR(dwError);
pIndexUpd->bHasBETxn = FALSE;
}
VmDirIndexUpdFree(gVdirIndexGlobals.pIndexUpd);
gVdirIndexGlobals.pIndexUpd = pIndexUpd;
VmDirConditionSignal(gVdirIndexGlobals.cond);
VMDIR_LOG_INFO( VMDIR_LOG_MASK_ALL, "%s succeeded", __FUNCTION__ );
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszStatus);
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s failed, error (%d)", __FUNCTION__, dwError );
goto cleanup;
}
static
VOID
_FreeSearchInformation(
PVMDIR_SUPERLOG_ENTRY_LDAPOPERATION pEntry)
{
VMDIR_SAFE_FREE_MEMORY(pEntry->opInfo.searchInfo.pwszAttributes);
VMDIR_SAFE_FREE_MEMORY(pEntry->opInfo.searchInfo.pwszBaseDN);
VMDIR_SAFE_FREE_MEMORY(pEntry->opInfo.searchInfo.pwszScope);
VMDIR_SAFE_FREE_MEMORY(pEntry->opInfo.searchInfo.pwszIndexResults);
}
static
VOID
_FreeStringPair(
PLW_HASHMAP_PAIR pPair,
LW_PVOID pUnused
)
{
VMDIR_SAFE_FREE_MEMORY(pPair->pKey);
VMDIR_SAFE_FREE_MEMORY(pPair->pValue);
}
static
PVOID
ThreadFunction(
PVOID pArgs
)
{
DWORD dwError = ERROR_SUCCESS;
PVMDIR_START_ROUTINE pThreadStart = NULL;
PVOID pThreadArgs = NULL;
PVMDIR_THREAD_LOG_CONTEXT pLogCtx = NULL;
PVMDIR_THREAD_TXN_CONTEXT pTxnCtx = NULL;
union
{
DWORD dwError;
PVOID pvRet;
} retVal;
memset(&retVal, 0, sizeof(retVal));
if( pArgs == NULL)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
pThreadStart = ((PVMDIR_THREAD_START_INFO)pArgs)->pStartRoutine;
pThreadArgs = ((PVMDIR_THREAD_START_INFO)pArgs)->pArgs;
if( pThreadStart == NULL )
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
VMDIR_SAFE_FREE_MEMORY( pArgs );
// set thread log context so error logs will show function name and line number
dwError = VmDirAllocAndSetThrLogCtx(&pLogCtx);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocAndSetThrTxnCtx(&pTxnCtx);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = pThreadStart( pThreadArgs );
BAIL_ON_VMDIR_ERROR(dwError);
error:
VmDirUnsetAndFreeThrLogCtx(pLogCtx);
VmDirUnsetAndFreeThrTxnCtx(pTxnCtx);
VMDIR_SAFE_FREE_MEMORY( pArgs );
retVal.dwError = dwError;
return retVal.pvRet;
}
DWORD
VmDirUPNToAccountDN(
PCSTR pszUPNName,
PCSTR pszAccountRDNAttr,
PCSTR pszAccountRDNValue,
PSTR* ppszAccountDN
)
{
DWORD dwError = 0;
PSTR pszRealm = NULL;
PSTR pszLocalDomainDN = NULL;
PSTR pszLocalAccountDN = NULL;
if ( IsNullOrEmptyString(pszUPNName) ||
IsNullOrEmptyString(pszAccountRDNAttr) ||
IsNullOrEmptyString(pszAccountRDNValue) ||
(ppszAccountDN == NULL)
)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
pszRealm = VmDirStringRChrA(pszUPNName, VMDIR_UPN_REALM_SEPARATOR);
if (pszRealm == NULL || pszRealm[1] == '\0')
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = VmDirFQDNToDN(pszRealm+1, &pszLocalDomainDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringAVsnprintf(
&pszLocalAccountDN,
"%s=%s,%s,%s",
pszAccountRDNAttr,
pszAccountRDNValue,
DEFAULT_USER_CONTAINER_RDN,
pszLocalDomainDN);
BAIL_ON_VMDIR_ERROR(dwError);
*ppszAccountDN = pszLocalAccountDN;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszLocalDomainDN);
return dwError;
error:
VMDIR_SAFE_FREE_MEMORY(pszLocalAccountDN);
goto cleanup;
}
static
DWORD
_VmDirGetReplicateStatusCycle(
PCSTR pszHostName,
PCSTR pszUserName,
PCSTR pszPassword
)
{
DWORD dwError = 0;
PSTR pszDomainName = NULL;
PSTR pszURI = NULL;
DWORD dwCycleCount = 0;
PVMDIR_CONNECTION pConnection = NULL;
if ( VmDirIsIPV6AddrFormat( pszHostName ) )
{
dwError = VmDirAllocateStringPrintf( &pszURI, "ldap://[%s]", pszHostName );
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = VmDirAllocateStringPrintf( &pszURI, "ldap://%s", pszHostName );
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = VmDirGetDomainName( pszHostName, &pszDomainName );
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirConnectionOpen( pszURI, pszDomainName, pszUserName, pszPassword, &pConnection );
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirGetReplicationCycleCount( pConnection, &dwCycleCount );
BAIL_ON_VMDIR_ERROR(dwError);
if (dwCycleCount == 0)
{
printf("First replication cycle done: FALSE\n");
}
else
{
printf("First replication cycle done: TRUE\n");
}
cleanup:
VMDIR_SAFE_FREE_MEMORY( pszURI );
VMDIR_SAFE_FREE_MEMORY( pszDomainName );
VmDirConnectionClose( pConnection );
return dwError;
error:
printf("First replication cycle done: UNKNOWN, error code (%u)\n", dwError);
goto cleanup;
}
void
VmDirModificationFree(
PVDIR_MODIFICATION pMod
)
{
if (pMod != NULL)
{
VmDirFreeBervalArrayContent( pMod->attr.vals, pMod->attr.numVals );
VMDIR_SAFE_FREE_MEMORY( pMod->attr.vals );
VMDIR_SAFE_FREE_MEMORY( pMod );
}
}
VOID
VmDirFreeMetaDataContent(
PVMDIR_ATTRIBUTE_METADATA pMetaData
)
{
if (pMetaData)
{
VMDIR_SAFE_FREE_MEMORY(pMetaData->pszOrigInvoId);
VMDIR_SAFE_FREE_MEMORY(pMetaData->pszOrigTime);
memset(pMetaData, 0, sizeof(VMDIR_ATTRIBUTE_METADATA));
}
}
DWORD
VmDirSchemaBervalSyntaxCheck(
PVDIR_SCHEMA_CTX pCtx,
PVDIR_SCHEMA_AT_DESC pATDesc,
PVDIR_BERVALUE pBerv
)
{
DWORD dwError = 0;
if (!pCtx || !pATDesc || !pBerv)
{
if (pCtx)
{
pCtx->dwErrorCode = ERROR_INVALID_PARAMETER;
VMDIR_SAFE_FREE_MEMORY(pCtx->pszErrorMsg);
dwError = VmDirAllocateStringA(
"No descriptor or value",
&pCtx->pszErrorMsg);
}
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
//TODO, if NO pSyntax, i.e. this syntax is NOT supported yet.
// just bypass checking and move on.
if (pATDesc->pSyntax &&
pATDesc->pSyntax->pValidateFunc(pBerv) == FALSE)
{
pCtx->dwErrorCode = ERROR_INVALID_SYNTAX;
VMDIR_SAFE_FREE_MEMORY(pCtx->pszErrorMsg);
dwError = VmDirAllocateStringAVsnprintf(
&pCtx->pszErrorMsg,
"%s value (%s) is not a valid (%s) syntax",
pATDesc->pszName,
VDIR_SAFE_STRING(pBerv->lberbv.bv_val),
VDIR_SAFE_STRING(pATDesc->pszSyntaxName));
dwError = ERROR_INVALID_SYNTAX;
BAIL_ON_VMDIR_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
VOID
VmDirFreeThreadLogContext(
PVMDIR_THREAD_LOG_CONTEXT pThreadLogContext
)
{
if (pThreadLogContext)
{
VMDIR_SAFE_FREE_MEMORY(pThreadLogContext->pszRequestId);
VMDIR_SAFE_FREE_MEMORY(pThreadLogContext->pszSessionId);
VMDIR_SAFE_FREE_MEMORY(pThreadLogContext->pszUserId);
VMDIR_SAFE_FREE_MEMORY(pThreadLogContext);
}
}
static
VOID
_VmDirFreeThreadTxnContext(
PVMDIR_THREAD_TXN_CONTEXT pThreadTxnContext
)
{
if (pThreadTxnContext)
{
assert(pThreadContext->threadTxnContext);
pthread_setspecific(pThreadContext->threadTxnContext, NULL);
VMDIR_SAFE_FREE_MEMORY(pThreadTxnContext->mainDbTxnCtx.pszTxnId);
VMDIR_SAFE_FREE_MEMORY(pThreadTxnContext);
}
}
/* *************************************************************
* if success, pAttr takes ownership of pBervs and its contents
* *************************************************************
* Assume pBervs itself is from ONE memory allocate.
*/
static
DWORD
AttributeAppendBervArray(
PVDIR_ATTRIBUTE pAttr,
PVDIR_BERVALUE pBervs,
USHORT usBervSize
)
{
DWORD dwError = 0;
PVDIR_BERVALUE pNewBerv = NULL;
if (!pAttr || !pBervs)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
// add one more BerValue in size as bdb-store/entry.c needs that.
dwError = VmDirReallocateMemoryWithInit(
pAttr->vals,
(PVOID*) &pNewBerv,
sizeof(VDIR_BERVALUE) * (pAttr->numVals + usBervSize + 1),
sizeof(VDIR_BERVALUE) * (pAttr->numVals));
BAIL_ON_VMDIR_ERROR(dwError);
// takes over BerValue contents (i.e. lberbv.bv_val and lberbv.bv_len)
dwError = VmDirCopyMemory(
pNewBerv + pAttr->numVals,
sizeof(VDIR_BERVALUE) * (pAttr->numVals + usBervSize + 1),
pBervs,
sizeof(VDIR_BERVALUE) * usBervSize
);
BAIL_ON_VMDIR_ERROR(dwError);
// free array of BerValue itself
VMDIR_SAFE_FREE_MEMORY(pBervs);
pAttr->numVals += usBervSize;
pAttr->vals = pNewBerv;
cleanup:
return dwError;
error:
VMDIR_SAFE_FREE_MEMORY(pNewBerv);
goto cleanup;
}
static
DWORD
_OpenLdapConnection(
PCSTR pszFQDomainName,
PCSTR pszUsername,
PCSTR pszPassword,
PCSTR pszReplURI,
LDAP **ppLd
)
{
DWORD dwError = 0;
PSTR pszPartnerHostName = NULL;
PSTR pszUPN = NULL;
LDAP *pLd = NULL;
dwError = VmDirReplURIToHostname((PSTR)pszReplURI, &pszPartnerHostName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUPN,
"%s@%s",
pszUsername,
pszFQDomainName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSafeLDAPBind(
&pLd,
pszPartnerHostName,
pszUPN,
pszPassword);
BAIL_ON_VMDIR_ERROR(dwError);
*ppLd = pLd;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszPartnerHostName);
VMDIR_SAFE_FREE_MEMORY(pszUPN);
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s,%d failed, error(%d)", __FUNCTION__, __LINE__, dwError );
if (pLd)
{
ldap_unbind_ext_s(pLd,NULL,NULL);
}
goto cleanup;
}
static
DWORD
_allocateSuperlogTable(
DWORD tableSize,
PVMDIR_SUPERLOG_TABLE_COLUMN_SET pCols,
PVMDIR_SUPERLOG_TABLE *ppTable
)
{
DWORD dwError = 0;
PVMDIR_SUPERLOG_TABLE pTable = NULL;
dwError = VmDirAllocateMemory(
sizeof(VMDIR_SUPERLOG_TABLE),
(PVOID*)&pTable
);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateAndCopyMemory(
pCols,
sizeof(VMDIR_SUPERLOG_TABLE_COLUMN_SET),
(PVOID*)&pTable->cols
);
BAIL_ON_VMDIR_ERROR(dwError);
pTable->numRows = tableSize;
if (tableSize > 0)
{
dwError = VmDirAllocateMemory(
sizeof(VMDIR_SUPERLOG_TABLE_ROW)*tableSize,
(PVOID*)&pTable->rows
);
BAIL_ON_VMDIR_ERROR(dwError);
}
*ppTable = pTable;
cleanup:
return dwError;
error:
if (pTable)
{
VMDIR_SAFE_FREE_MEMORY(pTable->rows);
VMDIR_SAFE_FREE_MEMORY(pTable->cols);
VMDIR_SAFE_FREE_MEMORY(pTable);
}
goto cleanup;
}
/*
* Free a heap Attribute
* (ATTENTION: if the pAttr is within a pEntry, only when pEntry is constructed as
* ENTRY_STORAGE_FORMAT_NORMAL allocation type, its attribute can be freed using this function;
* otherwise, an entry's attribute free is taken care of by 'pEntry->bvs'
*/
VOID
VmDirFreeAttribute(
PVDIR_ATTRIBUTE pAttr
)
{
if (!pAttr)
{
return;
}
VmDirFreeBervalContent(&pAttr->type);
VmDirFreeBervalArrayContent(pAttr->vals, pAttr->numVals);
VMDIR_SAFE_FREE_MEMORY(pAttr->vals);
VMDIR_SAFE_FREE_MEMORY(pAttr);
}
/*
* Free a heap Attribute
* (ATTENTION: if the pAttr is within a pEntry, only when pEntry is constructed as
* ENTRY_STORAGE_FORMAT_NORMAL allocation type, its attribute can be freed using this function;
* otherwise, an entry's attribute free is taken care of by 'pEntry->bvs'
*/
VOID
VmDirFreeAttribute(
PVDIR_ATTRIBUTE pAttr
)
{
if (!pAttr)
{
return;
}
// pAttr->type is always store in place and has NO bvnorm_val. no need to free here.
VmDirFreeBervalArrayContent(pAttr->vals, pAttr->numVals);
VMDIR_SAFE_FREE_MEMORY(pAttr->vals);
VMDIR_SAFE_FREE_MEMORY(pAttr);
}
