/* *************************************************************
* 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
AddAttrValsToEntryStruct(
VDIR_ENTRY * e,
VDIR_ATTRIBUTE * eAttr, // Entry attribute to be updated with new attribute values
VDIR_ATTRIBUTE * modAttr, // Modify attribute containing new attribute values
PSTR* ppszErrMsg
)
{
unsigned int i = 0;
unsigned int j = 0;
DWORD dwError = ERROR_SUCCESS;
PSTR pszErrMsg = NULL;
assert(e->allocType == ENTRY_STORAGE_FORMAT_NORMAL);
if ((size_t)eAttr->numVals + (size_t)modAttr->numVals > UINT16_MAX)
{
dwError = VMDIR_ERROR_DATA_CONSTRAINT_VIOLATION;
BAIL_ON_VMDIR_ERROR_WITH_MSG(dwError, (pszErrMsg),
"Too many %s attribute values, max %u allowed.",
VDIR_SAFE_STRING(eAttr->type.lberbv_val), UINT16_MAX);
}
dwError = VmDirReallocateMemoryWithInit(eAttr->vals, (PVOID*)(&(eAttr->vals)),
(eAttr->numVals + modAttr->numVals + 1) * sizeof(VDIR_BERVALUE),
(eAttr->numVals + 1) * sizeof(VDIR_BERVALUE));
BAIL_ON_VMDIR_ERROR(dwError);
for (i = 0, j = eAttr->numVals; i < modAttr->numVals; i++, j++)
{
dwError = VmDirBervalContentDup(&modAttr->vals[i], &eAttr->vals[j]);
BAIL_ON_VMDIR_ERROR(dwError);
}
memset(&(eAttr->vals[j]), 0, sizeof(VDIR_BERVALUE)); // set last BerValue.lberbv.bv_val to NULL;
eAttr->numVals += modAttr->numVals;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszErrMsg);
return dwError;
error:
if (ppszErrMsg)
{
*ppszErrMsg = pszErrMsg;
pszErrMsg = NULL;
}
goto cleanup;
}
/*
* double the size of candidate eid buffer
*/
static
DWORD
VmDirReallocCandidates(
PVDIR_CANDIDATES pCands
)
{
DWORD dwError = 0;
int iOldSize = pCands->max * sizeof(ENTRYID);
int iNewSize = iOldSize * 2;
dwError = VmDirReallocateMemoryWithInit(pCands->eIds, (PVOID*)&pCands->eIds, iNewSize, iOldSize);
BAIL_ON_VMDIR_ERROR(dwError);
pCands->max *= 2;
error:
return dwError;
}
DWORD
VmDirStringListAdd(
PVMDIR_STRING_LIST pStringList,
PCSTR pszString
)
{
DWORD dwError = 0;
// keep string list null-terminated
if (pStringList->dwCount + 1 == pStringList->dwSize)
{
DWORD dwOldSize = pStringList->dwSize;
DWORD dwNewSize = pStringList->dwSize * 2;
//
// Check for overflow.
//
if (dwNewSize < pStringList->dwSize)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_SIZELIMIT_EXCEEDED);
}
dwError = VmDirReallocateMemoryWithInit(
pStringList->pStringList,
(PVOID*)&pStringList->pStringList,
dwNewSize * sizeof(PSTR),
dwOldSize * sizeof(PSTR));
BAIL_ON_VMDIR_ERROR(dwError);
pStringList->dwSize = dwNewSize;
}
pStringList->pStringList[pStringList->dwCount++] = pszString;
cleanup:
return dwError;
error:
goto cleanup;
}
/*
* Read schema definition from file
* We ignore -
* 1. DN/EntryDN
* 2. ldapSyntax
* 3. matchingRules
*/
static
DWORD
schemaReadFile(
PCSTR pszSchemaFilePath,
PSTR** pppszDescs,
USHORT* pdwSize
)
{
static PSTR pszDNTag = "DN:";
static PSTR pszENTRYDNTag = "ENTRYDN:";
static PSTR pszSyntaxTag = "ldapSyntaxes:";
static PSTR pszMatchingRuleTag = "matchingRules:";
static PSTR pszName = "NAME ";
DWORD dwError = 0;
USHORT dwSize = 0;
DWORD dwCnt = 100;
size_t iOldLen = 0 ;
size_t iNewLen = 0 ;
PSTR* ppszDescs = NULL;
PSTR pszTmp = NULL;
char pbuf[2048] = {0};
FILE* fp = NULL;
dwError = VmDirAllocateMemory(
sizeof(*ppszDescs) * dwCnt,
(PVOID*)&ppszDescs);
BAIL_ON_VMDIR_ERROR(dwError);
#ifndef _WIN32
fp=fopen(pszSchemaFilePath, "r");
#else
if( fopen_s(&fp, pszSchemaFilePath, "r") != 0 )
{
fp = NULL;
}
#endif
if(NULL == fp)
{
dwError = errno;
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"Open schema file (%s) failed. Error (%d)",
pszSchemaFilePath,
dwError);
BAIL_ON_VMDIR_ERROR(dwError);
}
while (fgets(pbuf, sizeof(pbuf), fp) != NULL)
{
PSTR pszTag = NULL;
size_t len = VmDirStringLenA(pbuf)-1;
if (pbuf[len] == '\n')
{
pbuf[len] = '\0';
}
if ((pbuf[0] == '\0') ||
(pbuf[0] == '#') ||
(pbuf[0] != ' ' && (pszTag = VmDirStringChrA(pbuf, ':')) == NULL))
{
continue;
}
if (VmDirStringNCompareA(pbuf, pszDNTag, VmDirStringLenA(pszDNTag), FALSE) == 0 ||
VmDirStringNCompareA(pbuf, pszENTRYDNTag, VmDirStringLenA(pszENTRYDNTag), FALSE) == 0 ||
VmDirStringNCompareA(pbuf, pszSyntaxTag, VmDirStringLenA(pszSyntaxTag), FALSE) == 0 ||
VmDirStringNCompareA(pbuf, pszMatchingRuleTag, VmDirStringLenA(pszMatchingRuleTag), FALSE) == 0)
{
continue;
}
if (dwCnt == dwSize + 1)
{
DWORD dwOldSize = dwCnt;
dwCnt = dwCnt * 2;
dwError = VmDirReallocateMemoryWithInit(
ppszDescs,
(PVOID*)&ppszDescs,
dwCnt * sizeof(*ppszDescs),
dwOldSize * sizeof(*ppszDescs));
BAIL_ON_VMDIR_ERROR(dwError);
}
if (pbuf[0] != ' ')
{
dwError = VmDirAllocateStringA(pbuf,
&(ppszDescs[dwSize++]));
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
// consolidate leading spaces into one
char* pszNonSpace = pbuf+1;
while (*pszNonSpace == ' ') { pszNonSpace++; }
{
// Normalising NAME field for everything attributeTypes,objectClasses,ditContentRules , i.e Removing multiple spaces
if (VmDirStringNCompareA(pszNonSpace, pszName, VmDirStringLenA(pszName), TRUE) == 0)
{
_VmDirNormaliseNameField (pszNonSpace, VmDirStringLenA(pszNonSpace));
}
iOldLen = VmDirStringLenA(ppszDescs[dwSize-1]);
iNewLen = VmDirStringLenA(pszNonSpace-1);
dwError = VmDirReallocateMemoryWithInit(
ppszDescs[dwSize-1],
(PVOID*)&pszTmp,
sizeof(char) * (iOldLen + iNewLen + 1),
sizeof(char) * iOldLen);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirCopyMemory(
&pszTmp[iOldLen],
sizeof(char) * (iOldLen + iNewLen + 1),
&(pszNonSpace-1)[0],
iNewLen
);
BAIL_ON_VMDIR_ERROR(dwError);
ppszDescs[dwSize-1] = pszTmp;
pszTmp = NULL;
}
}
}
*pppszDescs = ppszDescs;
*pdwSize = dwSize;
cleanup:
if (fp)
{
fclose(fp);
}
return dwError;
error:
*pppszDescs = NULL;
*pdwSize = 0;
if (ppszDescs)
{
VmDirFreeStringArrayA(ppszDescs);
VMDIR_SAFE_FREE_MEMORY(ppszDescs);
}
goto cleanup;
}
