You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
820 lines
19 KiB
820 lines
19 KiB
//---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996
|
|
//
|
|
// File: util.cxx
|
|
//
|
|
// Contents: Some misc helper functions
|
|
//
|
|
// History:
|
|
//----------------------------------------------------------------------------
|
|
#include "ldapc.hxx"
|
|
#pragma hdrstop
|
|
|
|
BOOL
|
|
IsContainer(
|
|
LPTSTR pszClassName,
|
|
LDAP_SCHEMA_HANDLE hSchema
|
|
);
|
|
|
|
/******************************************************************/
|
|
/* Class SCHEMAINFO
|
|
/******************************************************************/
|
|
SCHEMAINFO::SCHEMAINFO()
|
|
: _cRef( 0 ),
|
|
_fObsolete( FALSE ),
|
|
fDefaultSchema( FALSE ),
|
|
fAppearsV3(TRUE),
|
|
pszServerName( NULL ),
|
|
pszSubSchemaSubEntry( NULL ),
|
|
pszTime( NULL ),
|
|
Next( NULL ),
|
|
aClasses( NULL ),
|
|
nNumOfClasses( 0 ),
|
|
aClassesSearchTable( NULL ),
|
|
aProperties( NULL ),
|
|
nNumOfProperties( 0 ),
|
|
aPropertiesSearchTable( NULL ),
|
|
pszUserName( NULL )
|
|
{
|
|
}
|
|
|
|
SCHEMAINFO::~SCHEMAINFO()
|
|
{
|
|
if ( pszServerName )
|
|
FreeADsStr( pszServerName );
|
|
|
|
if ( pszUserName )
|
|
FreeADsStr( pszUserName );
|
|
|
|
if ( pszSubSchemaSubEntry )
|
|
FreeADsStr( pszSubSchemaSubEntry );
|
|
|
|
if ( pszTime )
|
|
FreeADsStr( pszTime );
|
|
|
|
if ( !fDefaultSchema )
|
|
{
|
|
if ( aClasses )
|
|
FreeClassInfoArray( aClasses, nNumOfClasses );
|
|
|
|
if ( aClassesSearchTable )
|
|
FreeADsMem( aClassesSearchTable );
|
|
|
|
if ( aProperties )
|
|
FreePropertyInfoArray( aProperties, nNumOfProperties );
|
|
|
|
if ( aPropertiesSearchTable )
|
|
FreeADsMem( aPropertiesSearchTable );
|
|
}
|
|
}
|
|
|
|
DWORD SCHEMAINFO::AddRef()
|
|
{
|
|
return ++_cRef;
|
|
}
|
|
|
|
DWORD SCHEMAINFO::Release()
|
|
{
|
|
if ( _cRef > 0 )
|
|
return --_cRef;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Helper routine that looks up the syntax tables (oid and name oid)
|
|
// and returns the correct syntax corresponding to the string name.
|
|
//
|
|
DWORD
|
|
LdapGetSyntaxIdOfAttribute(
|
|
LPWSTR pszStringSyntax
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwSyntaxId = -1;
|
|
|
|
dwSyntaxId = FindEntryInSearchTable(
|
|
pszStringSyntax,
|
|
g_aSyntaxSearchTable,
|
|
g_nSyntaxSearchTableSize
|
|
);
|
|
|
|
if (dwSyntaxId == -1) {
|
|
//
|
|
// We also need to search in the OID based syntax table.
|
|
//
|
|
dwSyntaxId = FindEntryInSearchTable(
|
|
pszStringSyntax,
|
|
g_aOidSyntaxSearchTable,
|
|
g_nOidSyntaxSearchTableSize
|
|
);
|
|
}
|
|
|
|
return dwSyntaxId;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
LdapGetSyntaxOfAttributeOnServerHelper(
|
|
LPTSTR pszServerPath,
|
|
LPTSTR pszAttrName,
|
|
DWORD *pdwSyntaxId,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = NULL;
|
|
DWORD dwEntry;
|
|
LPWSTR pszTemp = NULL;
|
|
|
|
*pdwSyntaxId = LDAPTYPE_UNKNOWN;
|
|
|
|
hr = LdapGetSchema( pszServerPath,
|
|
&pSchemaInfo,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
BAIL_IF_ERROR(hr);
|
|
|
|
// Support for range attributes; for eg., objectClass=Range=0-1 We should
|
|
// ignore everything after ';' inclusive.
|
|
//
|
|
|
|
if ((pszTemp = wcschr(pszAttrName, L';')) != NULL ) {
|
|
*pszTemp = L'\0';
|
|
}
|
|
|
|
dwEntry = FindEntryInSearchTable(
|
|
pszAttrName,
|
|
pSchemaInfo->aPropertiesSearchTable,
|
|
pSchemaInfo->nNumOfProperties * 2 );
|
|
|
|
//
|
|
// Put back the ; if we had replaced it.
|
|
//
|
|
|
|
if (pszTemp)
|
|
*pszTemp = L';';
|
|
|
|
if ( dwEntry != -1 )
|
|
{
|
|
//
|
|
// This helper routine will lookup both the oid table and the
|
|
// name based syntax table and return -1 if unsuccesful.
|
|
//
|
|
*pdwSyntaxId = LdapGetSyntaxIdOfAttribute(
|
|
pSchemaInfo->aProperties[dwEntry].pszSyntax
|
|
);
|
|
|
|
if ( *pdwSyntaxId == -1 ) {
|
|
*pdwSyntaxId = LDAPTYPE_UNKNOWN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_ADS_PROPERTY_NOT_FOUND;
|
|
BAIL_IF_ERROR(hr);
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if ( pSchemaInfo )
|
|
pSchemaInfo->Release();
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
//
|
|
// This routine calls the helper and if the flag FromServer is TRUE,
|
|
// then if we cannot find the syntax on the server then we will
|
|
// mark as obsolete and retry. This will fix some not so obvious
|
|
// cases of problems with the schema across mutliple DC's. The
|
|
// underlying assumption is that if the server sent the info, then
|
|
// it should have the schema information to match.
|
|
//
|
|
HRESULT
|
|
LdapGetSyntaxOfAttributeOnServer(
|
|
LPTSTR pszServerPath,
|
|
LPTSTR pszAttrName,
|
|
DWORD *pdwSyntaxId,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort,
|
|
BOOL fFromServer // defaulted to FALSE
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = LdapGetSyntaxOfAttributeOnServerHelper(
|
|
pszServerPath,
|
|
pszAttrName,
|
|
pdwSyntaxId,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
//
|
|
// Reset and retry only if fFromServer is true, and
|
|
// the failure was E_ADS_PROPERTY_NOT_FOUND. If this is
|
|
// a v2 server then there will be no significant perf hit
|
|
// as we do not refresh the default schema.
|
|
//
|
|
|
|
if (FAILED(hr)
|
|
&& (hr == E_ADS_PROPERTY_NOT_FOUND)
|
|
&& fFromServer) {
|
|
//
|
|
// Mark schema as old.
|
|
//
|
|
hr = LdapRemoveSchemaInfoOnServer(
|
|
pszServerPath,
|
|
Credentials,
|
|
dwPort,
|
|
TRUE // force update.
|
|
);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = LdapGetSyntaxOfAttributeOnServerHelper(
|
|
pszServerPath,
|
|
pszAttrName,
|
|
pdwSyntaxId,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
}
|
|
else {
|
|
//
|
|
// This is the normal exit path.
|
|
//
|
|
RRETURN(hr);
|
|
}
|
|
|
|
error :
|
|
|
|
//
|
|
// If we get here we need to return prop not found
|
|
// other code may depend on that. Note that we will come
|
|
// here only if we the first try failed and something went
|
|
// wrong while trying to force a reload of the schema.
|
|
//
|
|
if (FAILED(hr)) {
|
|
RRETURN(hr = E_ADS_PROPERTY_NOT_FOUND);
|
|
}
|
|
else {
|
|
RRETURN(hr);
|
|
}
|
|
|
|
}
|
|
|
|
HRESULT
|
|
LdapIsClassNameValidOnServer(
|
|
LPTSTR pszServerPath,
|
|
LPTSTR pszClassName,
|
|
BOOL *pfValid,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = NULL;
|
|
|
|
*pfValid = FALSE;
|
|
|
|
hr = LdapGetSchema( pszServerPath,
|
|
&pSchemaInfo,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
BAIL_IF_ERROR(hr);
|
|
|
|
if ( FindEntryInSearchTable(
|
|
pszClassName,
|
|
pSchemaInfo->aClassesSearchTable,
|
|
pSchemaInfo->nNumOfClasses * 2 ) != -1 )
|
|
{
|
|
*pfValid = TRUE;
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if ( pSchemaInfo )
|
|
pSchemaInfo->Release();
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
LdapGetSchemaObjectCount(
|
|
LPTSTR pszServerPath,
|
|
DWORD *pnNumOfClasses,
|
|
DWORD *pnNumOfProperties,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = NULL;
|
|
|
|
hr = LdapGetSchema( pszServerPath,
|
|
&pSchemaInfo,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
BAIL_IF_ERROR(hr);
|
|
|
|
*pnNumOfClasses = pSchemaInfo->nNumOfClasses;
|
|
*pnNumOfProperties = pSchemaInfo->nNumOfProperties;
|
|
|
|
cleanup:
|
|
|
|
if ( pSchemaInfo )
|
|
pSchemaInfo->Release();
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
LdapGetSubSchemaSubEntryPath(
|
|
LPTSTR pszServerPath,
|
|
LPTSTR *ppszSubSchemaSubEntryPath,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = NULL;
|
|
|
|
*ppszSubSchemaSubEntryPath = NULL;
|
|
|
|
hr = LdapGetSchema( pszServerPath,
|
|
&pSchemaInfo,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
BAIL_IF_ERROR(hr);
|
|
|
|
if ( pSchemaInfo->pszSubSchemaSubEntry )
|
|
{
|
|
*ppszSubSchemaSubEntryPath =
|
|
AllocADsStr( pSchemaInfo->pszSubSchemaSubEntry );
|
|
|
|
if ( *ppszSubSchemaSubEntryPath == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_IF_ERROR(hr);
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if ( pSchemaInfo )
|
|
pSchemaInfo->Release();
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
LdapMakeSchemaCacheObsolete(
|
|
LPTSTR pszServerPath,
|
|
CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
RRETURN( LdapRemoveSchemaInfoOnServer(
|
|
pszServerPath,
|
|
Credentials,
|
|
dwPort
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
SchemaOpen(
|
|
IN LPTSTR pszServerPath,
|
|
OUT LDAP_SCHEMA_HANDLE *phSchema,
|
|
IN CCredentials& Credentials,
|
|
DWORD dwPort
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = NULL;
|
|
|
|
*phSchema = NULL;
|
|
|
|
hr = LdapGetSchema( pszServerPath,
|
|
&pSchemaInfo,
|
|
Credentials,
|
|
dwPort
|
|
);
|
|
|
|
if ( FAILED(hr))
|
|
RRETURN(hr);
|
|
|
|
*phSchema = (HANDLE) pSchemaInfo;
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaClose(
|
|
IN OUT LDAP_SCHEMA_HANDLE *phSchema
|
|
)
|
|
{
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) *phSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
if ( pSchemaInfo->Release() == 0 )
|
|
*phSchema = NULL;
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaAddRef(
|
|
IN LDAP_SCHEMA_HANDLE hSchema
|
|
)
|
|
{
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
pSchemaInfo->AddRef();
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetObjectCount(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
DWORD *pnNumOfClasses,
|
|
DWORD *pnNumOfProperties
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
*pnNumOfClasses = pSchemaInfo->nNumOfClasses;
|
|
*pnNumOfProperties = pSchemaInfo->nNumOfProperties;
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetClassInfoByIndex(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
DWORD dwIndex,
|
|
CLASSINFO **ppClassInfo
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
*ppClassInfo = &(pSchemaInfo->aClasses[dwIndex]);
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetPropertyInfoByIndex(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
DWORD dwIndex,
|
|
PROPERTYINFO **ppPropertyInfo
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
*ppPropertyInfo = &(pSchemaInfo->aProperties[dwIndex]);
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetClassInfo(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
LPTSTR pszClassName,
|
|
CLASSINFO **ppClassInfo
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
DWORD dwIndex = (DWORD) -1;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
dwIndex = FindEntryInSearchTable(
|
|
pszClassName,
|
|
pSchemaInfo->aClassesSearchTable,
|
|
pSchemaInfo->nNumOfClasses * 2 );
|
|
|
|
if ( dwIndex == -1 )
|
|
{
|
|
*ppClassInfo = NULL;
|
|
}
|
|
else
|
|
{
|
|
*ppClassInfo = &(pSchemaInfo->aClasses[dwIndex]);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetPropertyInfo(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
LPTSTR pszPropertyName,
|
|
PROPERTYINFO **ppPropertyInfo
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
DWORD dwIndex = (DWORD) -1;
|
|
LPWSTR pszTemp = NULL;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
// Support for range attributes; for eg., objectClass=Range=0-1 We should
|
|
// ignore everything after ';' inclusive.
|
|
//
|
|
|
|
if ((pszTemp = wcschr(pszPropertyName, L';')) != NULL ) {
|
|
*pszTemp = L'\0';
|
|
}
|
|
|
|
dwIndex = FindEntryInSearchTable(
|
|
pszPropertyName,
|
|
pSchemaInfo->aPropertiesSearchTable,
|
|
pSchemaInfo->nNumOfProperties * 2 );
|
|
|
|
//
|
|
// Put back the ; if we had replaced it.
|
|
//
|
|
|
|
if (pszTemp)
|
|
*pszTemp = L';';
|
|
|
|
if ( dwIndex == -1 )
|
|
{
|
|
*ppPropertyInfo = NULL;
|
|
}
|
|
else
|
|
{
|
|
*ppPropertyInfo = &(pSchemaInfo->aProperties[dwIndex]);
|
|
}
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetSyntaxOfAttribute(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
LPTSTR pszAttrName,
|
|
DWORD *pdwSyntaxId
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
LPWSTR pszTemp = NULL;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
*pdwSyntaxId = LDAPTYPE_UNKNOWN;
|
|
|
|
// Support for range attributes; for eg., objectClass=Range=0-1 We should
|
|
// ignore everything after ';' inclusive.
|
|
//
|
|
|
|
if ((pszTemp = wcschr(pszAttrName, L';')) != NULL ) {
|
|
*pszTemp = L'\0';
|
|
}
|
|
|
|
DWORD dwEntry = FindEntryInSearchTable(
|
|
pszAttrName,
|
|
pSchemaInfo->aPropertiesSearchTable,
|
|
pSchemaInfo->nNumOfProperties * 2 );
|
|
|
|
//
|
|
// Put back the ; if we had replaced it.
|
|
//
|
|
|
|
if (pszTemp)
|
|
*pszTemp = L';';
|
|
|
|
if ( dwEntry != -1 )
|
|
{
|
|
*pdwSyntaxId = FindEntryInSearchTable(
|
|
pSchemaInfo->aProperties[dwEntry].pszSyntax,
|
|
g_aSyntaxSearchTable,
|
|
g_nSyntaxSearchTableSize );
|
|
|
|
|
|
if ( *pdwSyntaxId == -1 ) {
|
|
|
|
//
|
|
// We also need to search in the OID based syntax table.
|
|
//
|
|
*pdwSyntaxId = FindEntryInSearchTable(
|
|
pSchemaInfo->aProperties[dwEntry].pszSyntax,
|
|
g_aOidSyntaxSearchTable,
|
|
g_nOidSyntaxSearchTableSize
|
|
);
|
|
|
|
if ( *pdwSyntaxId == -1 ) {
|
|
*pdwSyntaxId = LDAPTYPE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
hr = E_ADS_PROPERTY_NOT_FOUND;
|
|
BAIL_IF_ERROR(hr);
|
|
}
|
|
|
|
cleanup:
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaIsClassAContainer(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
LPTSTR pszClassName,
|
|
BOOL *pfContainer
|
|
)
|
|
{
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
if ( ( _tcsicmp( pszClassName, TEXT("Container")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("organizationalUnit")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("organization")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("country")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("locality")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("device")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("DMD")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("mSFTDSA")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("Domain")) == 0 )
|
|
)
|
|
{
|
|
*pfContainer = TRUE;
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
*pfContainer = IsContainer( pszClassName, hSchema );
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
HRESULT
|
|
SchemaGetStringsFromStringTable(
|
|
LDAP_SCHEMA_HANDLE hSchema,
|
|
int *propList,
|
|
DWORD nCount,
|
|
LPWSTR **paStrings
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
long i = 0;
|
|
|
|
if ( !pSchemaInfo )
|
|
RRETURN(E_ADS_BAD_PARAMETER);
|
|
|
|
if ( (propList != NULL) && (*propList != -1) )
|
|
{
|
|
|
|
*paStrings = (LPWSTR *) AllocADsMem( (nCount+1)*sizeof(LPWSTR));
|
|
if ( *paStrings == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
i = 0;
|
|
while ( propList[i] != -1 )
|
|
{
|
|
(*paStrings)[i] = AllocADsStr(
|
|
pSchemaInfo->aProperties[pSchemaInfo->aPropertiesSearchTable[propList[i]].nIndex].pszPropertyName );
|
|
|
|
if ( (*paStrings)[i] == NULL )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
(*paStrings)[i] = NULL;
|
|
}
|
|
else
|
|
{
|
|
*paStrings = NULL;
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
error:
|
|
|
|
if ( *paStrings )
|
|
{
|
|
i = 0;
|
|
while ( (*paStrings)[i] )
|
|
{
|
|
FreeADsStr( (*paStrings)[i] );
|
|
i++;
|
|
}
|
|
FreeADsMem( *paStrings );
|
|
}
|
|
|
|
RRETURN(hr);
|
|
|
|
}
|
|
|
|
BOOL
|
|
IsContainer(
|
|
LPTSTR pszClassName,
|
|
LDAP_SCHEMA_HANDLE hSchema
|
|
)
|
|
{
|
|
int i = 0;
|
|
CLASSINFO *pClassInfo;
|
|
LPTSTR pszName;
|
|
DWORD index;
|
|
SCHEMAINFO *pSchemaInfo = (SCHEMAINFO *) hSchema;
|
|
|
|
if ( ( _tcsicmp( pszClassName, TEXT("Container")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("organizationalUnit")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("organization")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("country")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("locality")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("device")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("DMD")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("mSFTDSA")) == 0 )
|
|
|| ( _tcsicmp( pszClassName, TEXT("Domain")) == 0 )
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
index = (DWORD) FindEntryInSearchTable(
|
|
pszClassName,
|
|
pSchemaInfo->aClassesSearchTable,
|
|
2 * pSchemaInfo->nNumOfClasses );
|
|
|
|
if ( i == ((DWORD) -1) )
|
|
return FALSE;
|
|
|
|
pClassInfo = &(pSchemaInfo->aClasses[index]);
|
|
|
|
if ( pClassInfo->pOIDsSuperiorClasses )
|
|
{
|
|
for ( i = 0;
|
|
(pszName = pClassInfo->pOIDsSuperiorClasses[i]);
|
|
i++ )
|
|
{
|
|
if ( IsContainer( pszName, hSchema ))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if ( pClassInfo->pOIDsAuxClasses )
|
|
{
|
|
for ( i = 0;
|
|
(pszName = pClassInfo->pOIDsAuxClasses[i]);
|
|
i++ )
|
|
{
|
|
if ( IsContainer( pszName, hSchema ))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|