able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/router/ccommand.cxx
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2048 lines
48 KiB
C++
Raw Blame History

//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995
//
// File: ccommand.cxx
//
// Contents: Microsoft OleDB/OleDS Data Source Object for ADSI
//
//
// History: 08-01-96 shanksh Created.
//
//----------------------------------------------------------------------------
#include "oleds.hxx"
#pragma hdrstop
static WCHAR gpszADsPathAttr[] = L"ADsPath";
static BOOL
IsAutomatable(
DBTYPE dbType
);
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::AddRefAccessor
//
// Synopsis:
//
// Arguments:
//
//
// Returns:
//
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::AddRefAccessor(
HACCESSOR hAccessor,
DBREFCOUNT * pcRefCount
)
{
//
// Asserts
//
ADsAssert(_pAccessor);
RRETURN( _pAccessor->AddRefAccessor(
hAccessor,
pcRefCount) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::CreateAccessor
//
// Synopsis:
//
// Arguments:
//
//
// Returns:
//
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::CreateAccessor(
DBACCESSORFLAGS dwAccessorFlags,
DBCOUNTITEM cBindings,
const DBBINDING rgBindings[],
DBLENGTH cbRowSize,
HACCESSOR * phAccessor,
DBBINDSTATUS rgStatus[]
)
{
//
// Asserts
//
ADsAssert(_pAccessor);
RRETURN( _pAccessor->CreateAccessor(
dwAccessorFlags,
cBindings,
rgBindings,
cbRowSize,
phAccessor,
rgStatus) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::ReleaseAccessor
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::ReleaseAccessor(
HACCESSOR hAccessor,
DBREFCOUNT * pcRefCount
)
{
//
// Asserts
//
ADsAssert(_pAccessor);
RRETURN( _pAccessor->ReleaseAccessor(
hAccessor,
pcRefCount) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::GetBindings
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::GetBindings(
HACCESSOR hAccessor,
DBACCESSORFLAGS * pdwAccessorFlags,
DBCOUNTITEM * pcBindings,
DBBINDING ** prgBindings
)
{
//
// Asserts
//
ADsAssert(_pAccessor);
RRETURN( _pAccessor->GetBindings(
hAccessor,
pdwAccessorFlags,
pcBindings, prgBindings) );
}
STDMETHODIMP
CCommandObject::GetColumnInfo2(
DBORDINAL * pcColumns,
DBCOLUMNINFO ** prgInfo,
OLECHAR ** ppStringBuffer,
BOOL ** ppfMultiValued
)
{
HRESULT hr;
ULONG pos, nStringBufLen;
DBCOLUMNINFO *pInfo=NULL;
OLECHAR* pStringBuffer=NULL ;
DWORD i;
DBTYPE wType;
DWORD cAttrsReturned;
LPWSTR *ppszTmpAttrs = NULL;
DWORD cTmpAttrs;
IDirectorySchemaMgmt *pDSAttrMgmt = NULL;
PADS_ATTR_DEF pAttrDefinition = NULL;
ADsAssert(_pIMalloc != NULL);
//
// IMalloc->Alloc is the way we have to allocate memory for out parameters
//
nStringBufLen = 0;
for (i=0; i < _cAttrs; i++) {
nStringBufLen += (wcslen(_ppszAttrs[i]) + 1) * sizeof (WCHAR);
}
nStringBufLen+= sizeof(WCHAR); // For the bookmark column which is a null string
//
// No. of DBCOLUMN structures to be allocated
//
pInfo = (DBCOLUMNINFO *)_pIMalloc->Alloc((_cAttrs+1)*sizeof(DBCOLUMNINFO));
if( !pInfo ) {
hr = E_OUTOFMEMORY;
goto error;
}
memset(pInfo, 0, (_cAttrs*sizeof(DBCOLUMNINFO)));
pStringBuffer = (WCHAR *)_pIMalloc->Alloc(nStringBufLen);
if( !pStringBuffer ) {
hr = E_OUTOFMEMORY;
goto error;
};
memset(pStringBuffer, 0, nStringBufLen);
//
// Get the attribute types by enquiring the DS schema
//
hr = _pDSSearch->QueryInterface(
IID_IDirectorySchemaMgmt,
(void**)&pDSAttrMgmt
);
BAIL_ON_FAILURE( hr );
// Fix for #285757. We should not send the ADsPath attribute to the
// server. So, search for occurences of this attribute and remove them.
ppszTmpAttrs = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * _cAttrs);
if(NULL == ppszTmpAttrs)
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
cTmpAttrs = 0;
for(i = 0; i < _cAttrs; i++)
{
if( _wcsicmp(L"ADsPath", _ppszAttrs[i]) )
{
ppszTmpAttrs[cTmpAttrs] = _ppszAttrs[i];
cTmpAttrs++;
}
}
// Request attributes only if there is some attribute other than ADsPath
if(cTmpAttrs)
hr = pDSAttrMgmt->EnumAttributes(
ppszTmpAttrs,
cTmpAttrs,
&pAttrDefinition,
&cAttrsReturned
);
else
{
cAttrsReturned = 0;
pAttrDefinition = NULL;
}
if(ppszTmpAttrs != NULL)
FreeADsMem(ppszTmpAttrs);
pDSAttrMgmt->Release();
BAIL_ON_FAILURE( hr );
//fill up the Bookmark column
// bookmark name is empty string
pInfo[0].pwszName = NULL;
pInfo[0].columnid.eKind = DBKIND_GUID_PROPID;
pInfo[0].columnid.uGuid.guid = DBCOL_SPECIALCOL;
pInfo[0].columnid.uName.ulPropid = 2; // Value from note about
// bookmarks in spec.
pInfo[0].pTypeInfo = NULL;
pInfo[0].iOrdinal = 0;
pInfo[0].ulColumnSize = sizeof(ULONG);
pInfo[0].wType = DBTYPE_UI4;
pInfo[0].bPrecision = 10; // Precision for I4.
pInfo[0].bScale = (BYTE) ~ 0;
pInfo[0].dwFlags = DBCOLUMNFLAGS_ISBOOKMARK
| DBCOLUMNFLAGS_ISFIXEDLENGTH;
//
// Fill up the columnsinfo by getting the attribute types
//
pos = 0;
for(i=0; i < _cAttrs; i++) {
wcscpy(&pStringBuffer[pos], _ppszAttrs[i]);
pInfo[i+1].pwszName= &pStringBuffer[pos];
//
// Get the type and size of the attribute
//
// Because of a Temporary bug in TmpTable, ~0 (specifying variable
// size) is replaced by 256. This does not actually put a memory
// restriction on the column size, but done merely to avoid the bug.
//
if( _wcsicmp(_ppszAttrs[i], L"ADsPath") == 0) {
pInfo[i+1].wType = DBTYPE_WSTR|DBTYPE_BYREF;
// pInfo[i+1].ulColumnSize = (ULONG) ~0;
pInfo[i+1].ulColumnSize = (ULONG)256;
}
else {
hr = GetDBType(
pAttrDefinition,
cAttrsReturned,
_ppszAttrs[i],
&pInfo[i+1].wType,
&pInfo[i+1].ulColumnSize
);
if( FAILED(hr) )
BAIL_ON_FAILURE( hr=E_FAIL );
}
wType = pInfo[i+1].wType & ~DBTYPE_BYREF;
// any change made to setting dwFlags below should also be made in
// GetRestrictedColumnInfo in row.cxx, for consistency
if( (wType == DBTYPE_STR) ||
(wType == DBTYPE_WSTR) ||
(wType == DBTYPE_BYTES) )
pInfo[i+1].dwFlags = DBCOLUMNFLAGS_ISNULLABLE;
else {
// Temporary check
// pInfo[i+1].dwFlags = (0);
pInfo[i+1].dwFlags = DBCOLUMNFLAGS_ISNULLABLE |
DBCOLUMNFLAGS_ISFIXEDLENGTH;
}
pInfo[i+1].pTypeInfo = NULL;
pInfo[i+1].iOrdinal = i+1;
pInfo[i+1].bPrecision = SetPrecision(wType);
pInfo[i+1].bScale = (UCHAR) ~0;
pInfo[i+1].columnid.eKind=DBKIND_NAME;
pInfo[i+1].columnid.uGuid.guid=GUID_NULL;
pInfo[i+1].columnid.uName.pwszName=pInfo[i+1].pwszName;
pos += (wcslen(_ppszAttrs[i]) + 1);
}
if( ppfMultiValued ) {
//
// Filling in MultiValue array
//
BOOL * pfMultiValuedTemp;
pfMultiValuedTemp= (BOOL *) AllocADsMem(sizeof(BOOL) * (_cAttrs+1));
if( !(pfMultiValuedTemp) ) {
hr=E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
pfMultiValuedTemp[0] = FALSE; // First one is bookmark which is always FALSE
for(ULONG j=0; j < _cAttrs; j++) {
for(ULONG k=0; k < cAttrsReturned; k++) {
if( !_wcsicmp(_ppszAttrs[j], pAttrDefinition[k].pszAttrName) )
break;
}
if( (k != cAttrsReturned) &&
(pAttrDefinition[k].fMultiValued &&
IsAutomatable(g_MapADsTypeToVarType[pAttrDefinition[k].dwADsType]))) {
pfMultiValuedTemp[j+1] = TRUE;
}
else {
pfMultiValuedTemp[j+1] = FALSE;
}
}
*ppfMultiValued = pfMultiValuedTemp;
}
if( pAttrDefinition ) {
FreeADsMem(pAttrDefinition);
}
*pcColumns = _cAttrs + 1;
*prgInfo = pInfo;
*ppStringBuffer = pStringBuffer;
RRETURN( S_OK );
error:
if( pInfo != NULL )
_pIMalloc->Free(pInfo);
if( pStringBuffer != NULL )
_pIMalloc->Free(pStringBuffer);
if( pAttrDefinition ) {
FreeADsMem(pAttrDefinition);
}
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::GetColumnInfo
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//
// Modifies:
//
// History: 10-10-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::GetColumnInfo(
DBORDINAL * pcColumns,
DBCOLUMNINFO ** prgInfo,
OLECHAR ** ppStringBuffer
)
{
if( pcColumns )
*pcColumns = 0;
if( prgInfo )
*prgInfo = NULL;
if( ppStringBuffer )
*ppStringBuffer = NULL;
if( !pcColumns || !prgInfo || !ppStringBuffer )
RRETURN( E_INVALIDARG );
if( !IsCommandSet() )
RRETURN( DB_E_NOCOMMAND );
if( !IsCommandPrepared() )
RRETURN( DB_E_NOTPREPARED );
RRETURN( GetColumnInfo2(
pcColumns,
prgInfo,
ppStringBuffer,
NULL
) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::MapColumnIDs
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::MapColumnIDs(
DBORDINAL cColumnIDs,
const DBID rgColumnIDs[],
DBORDINAL rgColumns[]
)
{
DBORDINAL cValidCols = 0;
//
// No Column IDs are set when GetColumnInfo returns ColumnsInfo structure.
// Hence, any value of ID will not match with any column
//
DBORDINAL iCol;
if( cColumnIDs == 0 )
RRETURN( S_OK );
// Spec-defined checks.
// Note that this guarantees we can access rgColumnIDs[] in loop below.
// (Because we'll just fall through.)
if ( cColumnIDs && (!rgColumnIDs || !rgColumns) )
RRETURN( E_INVALIDARG );
if( !IsCommandSet() )
RRETURN( DB_E_NOCOMMAND );
if( !IsCommandPrepared() )
RRETURN( DB_E_NOTPREPARED );
//
// Set the columns ordinals to invalid values
//
for(iCol=0; iCol < cColumnIDs; iCol++) {
// Initialize
rgColumns[iCol] = DB_INVALIDCOLUMN;
//
// The columnid with the Bookmark ID
//
if( rgColumnIDs[iCol].eKind == DBKIND_GUID_PROPID &&
rgColumnIDs[iCol].uGuid.guid == DBCOL_SPECIALCOL &&
rgColumnIDs[iCol].uName.ulPropid == 2 ) {
rgColumns[iCol] = 0;
cValidCols++;
continue;
}
//
// The columnid with the Column Name
//
if( rgColumnIDs[iCol].eKind == DBKIND_NAME &&
rgColumnIDs[iCol].uName.pwszName ) {
//
// Find the name in the list of Attributes
//
for (ULONG iOrdinal=0; iOrdinal < _cAttrs; iOrdinal++) {
if( !_wcsicmp(_ppszAttrs[iOrdinal],
rgColumnIDs[iCol].uName.pwszName) ) {
rgColumns[iCol] = iOrdinal+1;
cValidCols++;
break;
}
}
}
}
if( cValidCols == 0 )
RRETURN( DB_E_ERRORSOCCURRED );
else if( cValidCols < cColumnIDs )
RRETURN( DB_S_ERRORSOCCURRED );
else
RRETURN( S_OK );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::Cancel
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::Cancel(
void
)
{
//
// Need to protect _dwStatus for mutual exclusion when we support
// multiple threads acting on the same Command object
//
_dwStatus |= CMD_EXEC_CANCELLED;
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::Execute
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::Execute(
IUnknown * pUnkOuter,
REFIID riid,
DBPARAMS * pParams,
DBROWCOUNT *pcRowsAffected,
IUnknown ** ppRowset
)
{
HRESULT hr;
DWORD dwFlags = 0;
ULONG cAccessors = 0;
HACCESSOR *prgAccessors = NULL;
BOOL *pbMultiValued = NULL;
CRowProvider *pRowProvider = NULL;
DBORDINAL cColumns = 0;
DBCOLUMNINFO *prgInfo = NULL;
WCHAR *pStringBuffer = NULL;
ULONG cPropertySets = 0;
DBPROPSET *prgPropertySets = NULL;
ULONG i, j;
ADsAssert(_pIMalloc != NULL);
ADsAssert(_pAccessor != NULL);
ADsAssert(_pCSession != NULL);
if( ppRowset )
*ppRowset = NULL;
if( pcRowsAffected )
*pcRowsAffected= -1;
//
// If the IID asked for is IID_NULL, then we can expect
// that this is a non-row returning statement
//
if( riid == IID_NULL )
dwFlags |= EXECUTE_NOROWSET;
//
// Check Arguments - Only check on row returning statements
//
if( !(dwFlags & EXECUTE_NOROWSET) &&
(ppRowset == NULL) )
RRETURN( E_INVALIDARG );
//
// Only 1 ParamSet if ppRowset is non-null
//
if( pParams &&
(pParams->cParamSets > 1) &&
ppRowset )
RRETURN( E_INVALIDARG );
//
// Check that a command has been set
//
if( !IsCommandSet() )
RRETURN( DB_E_NOCOMMAND );
if( pUnkOuter )
RRETURN( DB_E_NOAGGREGATION );
//
// Prepare the Command if not already done
//
if( !IsCommandPrepared() ) {
hr = PrepareHelper();
BAIL_ON_FAILURE( hr );
}
//
// Check for a non row returning statement
//
if( dwFlags & EXECUTE_NOROWSET )
RRETURN( S_OK );
//
// Get ColumnsInfo based on the list of attributes that we want to be
// returned
//
hr = GetColumnInfo2(
&cColumns,
&prgInfo,
&pStringBuffer,
&pbMultiValued
);
BAIL_ON_FAILURE( hr );
//
// Commit the properties in the Command Object as the preferences to the
// search
//
hr = SetSearchPrefs();
BAIL_ON_FAILURE( hr );
//
// Create RowProvider object to pass to rowset code
//
_pDSSearch->AddRef();
hr= CRowProvider::CreateRowProvider(
_pDSSearch,
_pszSearchFilter,
_ppszAttrs,
_cAttrs,
cColumns,
prgInfo,
pStringBuffer,
IID_IRowProvider,
pbMultiValued,
_fADSPathPresent,
NULL,
(void **) &pRowProvider);
BAIL_ON_FAILURE( hr );
pbMultiValued = NULL; // RowProvider responsible for deallocation
//
// We no longer need the ColumnsInfo; Release it
//
if (prgInfo)
{
_pIMalloc->Free(prgInfo);
prgInfo = NULL;
}
if (pStringBuffer)
{
_pIMalloc->Free(pStringBuffer);
pStringBuffer = NULL;
}
if( _pAccessor &&
_pAccessor->_pextbuffer ) {
cAccessors = _pAccessor->_pextbuffer->GetLastHandleCount();
if( cAccessors > 0 ) {
prgAccessors = (HACCESSOR *) AllocADsMem(
sizeof(HACCESSOR) * cAccessors
);
if( !prgAccessors )
cAccessors = 0;
else
for(ULONG i=0; i<cAccessors; i++)
prgAccessors[i] = i+1;
}
}
hr = GetProperties(0, NULL, &cPropertySets, &prgPropertySets);
BAIL_ON_FAILURE( hr );
hr= CRowset::CreateRowset(
pRowProvider,
(LPUNKNOWN)(IAccessor FAR *)this ,
NULL,
this,
cPropertySets,
prgPropertySets,
cAccessors,
prgAccessors,
_fADSPathPresent,
_fAllAttrs,
riid,
ppRowset
);
if (prgAccessors)
{
FreeADsMem(prgAccessors);
prgAccessors = NULL;
}
BAIL_ON_FAILURE( hr );
error:
if (FAILED(hr))
{
//
// Remove the Prepare flag,
//
_dwStatus &= ~(CMD_PREPARED);
}
//
// Free the memory
//
if( pRowProvider )
pRowProvider->Release();
if( prgInfo )
_pIMalloc->Free(prgInfo);
if( pStringBuffer )
_pIMalloc->Free(pStringBuffer);
if( prgAccessors )
FreeADsMem(prgAccessors);
if( pbMultiValued ) {
FreeADsMem(pbMultiValued);
}
// Free memory allocated by GetProperties
for (i = 0; i < cPropertySets; i++)
{
for (j = 0; j < prgPropertySets[i].cProperties; j++)
{
DBPROP *pProp = &(prgPropertySets[i].rgProperties[j]);
ADsAssert(pProp);
// We should free the DBID in pProp, but we know that
// GetProperties always returns DB_NULLID and FreeDBID doesn't
// handle DB_NULLID. So, DBID is not freed here.
VariantClear(&pProp->vValue);
}
_pIMalloc->Free(prgPropertySets[i].rgProperties);
}
_pIMalloc->Free(prgPropertySets);
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::GetDBSession
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::GetDBSession(
REFIID riid,
IUnknown ** ppSession
)
{
HRESULT hr;
//
// Asserts
//
ADsAssert(_pCSession);
//
// Check Arguments
//
if( ppSession == NULL )
RRETURN( E_INVALIDARG );
//
// Query for the interface on the session object. If failure,
// return the error from QueryInterface.
//
RRETURN( (_pCSession)->QueryInterface(riid, (VOID**)ppSession) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::GetProperties
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::GetProperties(
const ULONG cPropIDSets,
const DBPROPIDSET rgPropIDSets[],
ULONG * pcPropSets,
DBPROPSET ** pprgPropSets
)
{
//
// Asserts
//
ADsAssert(_pUtilProp);
//
// Check in-params and NULL out-params in case of error
//
HRESULT hr = _pUtilProp->GetPropertiesArgChk(
cPropIDSets,
rgPropIDSets,
pcPropSets,
pprgPropSets,
PROPSET_COMMAND);
if( FAILED(hr) )
RRETURN( hr );
//
// Just pass this call on to the utility object that manages our properties
//
RRETURN( _pUtilProp->GetProperties(
cPropIDSets,
rgPropIDSets,
pcPropSets,
pprgPropSets,
PROPSET_COMMAND) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::SetProperties
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::SetProperties(
ULONG cPropertySets,
DBPROPSET rgPropertySets[]
)
{
//
// Asserts
//
ADsAssert(_pUtilProp);
// Don't allow properties to be set if we've got a rowset open
if( IsRowsetOpen() )
RRETURN( DB_E_OBJECTOPEN );
//
// Just pass this call on to the utility object that manages our properties
//
RRETURN( _pUtilProp->SetProperties(
cPropertySets,
rgPropertySets,
PROPSET_COMMAND) );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::GetCommandText
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::GetCommandText(
GUID * pguidDialect,
LPOLESTR * ppwszCommand
)
{
HRESULT hr = S_OK;
ADsAssert(_pIMalloc!= NULL);
//
// Check Function Arguments
//
if( ppwszCommand == NULL ) {
hr = E_INVALIDARG;
goto error;
}
*ppwszCommand = NULL;
//
// If the command has not been set, make sure the buffer
// contains an empty stringt to return to the consumer
//
if( !IsCommandSet() ) {
hr = DB_E_NOCOMMAND;
goto error;
}
//
// Allocate memory for the string we're going to return to the caller
//
*ppwszCommand = (LPWSTR)_pIMalloc->Alloc((wcslen(_pszCommandText)+1) * sizeof(WCHAR));
if( !*ppwszCommand ) {
hr = E_OUTOFMEMORY;
goto error;
}
//
// Copy our saved text into the newly allocated string
//
wcscpy(*ppwszCommand, _pszCommandText);
//
// If the text we're giving back is a different dialect than was
// requested, let the caller know what dialect the text is in
//
if( pguidDialect != NULL && *pguidDialect != _guidCmdDialect)
{
hr = DB_S_DIALECTIGNORED;
*pguidDialect = _guidCmdDialect;
}
error:
if( FAILED(hr) ) {
if( pguidDialect )
memset(pguidDialect, 0, sizeof(GUID));
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::SetCommandText
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::SetCommandText(
REFGUID rguidDialect,
LPCOLESTR pszCommand
)
{
// Don't allow text to be set if we've got a rowset open
if( IsRowsetOpen() )
RRETURN( DB_E_OBJECTOPEN );
// Check Dialect
if( rguidDialect != DBGUID_LDAPDialect &&
rguidDialect != DBGUID_DBSQL &&
rguidDialect != DBGUID_SQL &&
rguidDialect != DBGUID_DEFAULT )
RRETURN( DB_E_DIALECTNOTSUPPORTED );
//
// If a CommandText is set with a Null or an empty string, it effectively
// unsets the CommandText to a null string
//
if( (pszCommand == NULL) ||
(*pszCommand == L'\0') ) {
if( _dwStatus & CMD_TEXT_SET )
FreeADsStr(_pszCommandText);
_pszCommandText = NULL;
_dwStatus &= ~(CMD_TEXT_SET | CMD_PREPARED);
RRETURN( S_OK );
}
//
// Set the CommandText
//
LPWSTR pszSQLCmd = (LPWSTR)AllocADsMem((wcslen(pszCommand)+1) * sizeof(WCHAR));
if( !pszSQLCmd )
RRETURN( E_OUTOFMEMORY );
//
// Free the old memory, and set new text
//
if( _dwStatus & CMD_TEXT_SET )
FreeADsMem(_pszCommandText);
_pszCommandText = pszSQLCmd;
wcscpy(_pszCommandText, pszCommand);
//
// Reset adspath present flag.
//
_fADSPathPresent = FALSE;
//
// Set status flag that we have set text
//
_dwStatus |= CMD_TEXT_SET;
_dwStatus &= ~CMD_PREPARED;
//
// Remember the dialect that was passed in
//
_guidCmdDialect = rguidDialect;
RRETURN( S_OK );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::CanConvert
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::CanConvert(
DBTYPE wFromType,
DBTYPE wToType,
DBCONVERTFLAGS dwConvertFlags
)
{
RRETURN( CanConvertHelper(
wFromType,
wToType,
dwConvertFlags) );
}
//+---------------------------------------------------------------------------
//
// Function: SplitCommandText
//
// Synopsis:
//
//
// Arguments:
//
//
//
//
//
//
// Returns: HRESULT
// S_OK NO ERROR
// E_ADS_BAD_PARAMETER bad parameter
//
// Modifies:
//
// History: 08-15-96 ShankSh Created.
// 11-21-96 Felix Wong modified to get only bind and attr
//----------------------------------------------------------------------------
HRESULT
CCommandObject::SplitCommandText(
LPWSTR pszParsedCmd
)
{
LPWSTR pszAttrs = NULL;
LPWSTR pszFirstAttr = NULL;
LPWSTR pszCurrentAttr = NULL;
LPWSTR pszSearchScope = NULL;
LPWSTR pszTemp = NULL;
HRESULT hr;
LPWSTR ptr;
// Command Text is the concatenation of three components separated by
// semicolons
//
// 1. ADsPathName of the object of the root of the search which contains
// the host name and the context enclosed by '<' and '>'
// 2. The LDAP search string
// 3. The list of names of the attributes to be returned separated by
// commas
//
// If the attributes have any specifiers like Range (for eg.,
// objectclass;Range=0-1, we need to do some special processing to include
// it in the list of attributes
//
// The fourth component is optional
//
// 4. The scope of the search: Either "Base", "Onelevel", "SubTree"
// (case insensitve)
//
// Search defaults to Subtree
//
// White spaces are insignificant
_searchScope = ADS_SCOPE_SUBTREE;
_pszADsContext = NULL;
_pszSearchFilter = NULL;
if( _ppszAttrs ) {
FreeADsMem(_ppszAttrs);
_ppszAttrs = NULL;
}
if( _pszCommandTextCp ) {
FreeADsStr(_pszCommandTextCp);
_pszCommandTextCp = NULL;
}
_pszCommandTextCp = AllocADsStr(pszParsedCmd);
if( !_pszCommandTextCp)
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
_pszADsContext = RemoveWhiteSpaces(_pszCommandTextCp);
if( _pszADsContext[0] != L'<' ) {
BAIL_ON_FAILURE( hr=DB_E_ERRORSINCOMMAND);
}
_pszADsContext++;
ptr = _pszADsContext;
hr = SeekPastADsPath(ptr, &ptr);
BAIL_ON_FAILURE( hr );
if( *ptr != L'>' || *(ptr+1) != L';') {
BAIL_ON_FAILURE( hr=DB_E_ERRORSINCOMMAND);
}
*ptr = L'\0';
//
// If the command text does not contain a filter, set it to NULL
//
if (*(ptr + 2) == L';') {
_pszSearchFilter = NULL;
ptr+=2;
}
else {
_pszSearchFilter = ptr + 2;
_pszSearchFilter = RemoveWhiteSpaces(_pszSearchFilter);
hr = SeekPastSearchFilter(_pszSearchFilter, &ptr);
BAIL_ON_FAILURE( hr );
}
if (*ptr != L';') {
BAIL_ON_FAILURE( hr=DB_E_ERRORSINCOMMAND);
}
*ptr = L'\0';
ptr++;
//
// The next component is the list of attributes followed by (optionally)
// the scope of the search
//
// Since the attributes themselves can contain a ';' because of some
// attribute specifiers, we need to make sure which ';' we are looking at.
pszAttrs = ptr;
while ((pszTemp = wcschr(ptr, ';')) != NULL)
if ( !_wcsicmp(pszTemp+1, L"Base") ||
!_wcsicmp(pszTemp+1, L"Onelevel") ||
!_wcsicmp(pszTemp+1, L"Subtree") ) {
//
// we have hit the end of the attribute list
//
*pszTemp = L'\0';
pszSearchScope = pszTemp+1;
break;
}
else {
ptr = pszTemp + 1;
}
if( pszSearchScope ) {
if(!_wcsicmp(pszSearchScope, L"Base"))
_searchScope = ADS_SCOPE_BASE;
else if(!_wcsicmp(pszSearchScope, L"Onelevel"))
_searchScope = ADS_SCOPE_ONELEVEL;
else if(!_wcsicmp(pszSearchScope, L"SubTree"))
_searchScope = ADS_SCOPE_SUBTREE;
else
BAIL_ON_FAILURE( hr=DB_E_ERRORSINCOMMAND);
//
// set the search preference property
//
DBPROPSET rgCmdPropSet[1];
DBPROP rgCmdProp[1];
rgCmdPropSet[0].rgProperties = rgCmdProp;
rgCmdPropSet[0].cProperties = 1;
rgCmdPropSet[0].guidPropertySet = DBPROPSET_ADSISEARCH;
rgCmdProp[0].dwPropertyID = ADS_SEARCHPREF_SEARCH_SCOPE;
rgCmdProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
rgCmdProp[0].vValue.vt = VT_I4;
V_I4(&rgCmdProp[0].vValue) = _searchScope;
hr = SetProperties(
1,
rgCmdPropSet);
BAIL_ON_FAILURE( hr );
}
pszCurrentAttr = pszFirstAttr = wcstok(pszAttrs, L",");
for (_cAttrs=0; pszCurrentAttr != NULL; _cAttrs++ ) {
pszCurrentAttr = wcstok(NULL, L",");
}
if( _cAttrs == 0 ) {
hr=DB_E_ERRORSINCOMMAND;
goto error;
}
pszFirstAttr = RemoveWhiteSpaces(pszFirstAttr);
if( _cAttrs == 1 && !wcscmp( pszFirstAttr, L"*")) {
// _cAttrs=1; Just ADsPath and Class attribute is sent
_ppszAttrs = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * _cAttrs);
if( !_ppszAttrs )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
_ppszAttrs[0] = gpszADsPathAttr;
_fADSPathPresent = TRUE;
_fAllAttrs = TRUE;
}
else {
// Allocate memory for all the string pointers
_ppszAttrs = (LPWSTR *) AllocADsMem(sizeof(LPWSTR) * (_cAttrs+1));
if( !_ppszAttrs ) {
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
}
pszCurrentAttr = pszFirstAttr;
// Remember if adspath and rdn are avaialble or not.
for (ULONG i=0 ; i < _cAttrs; i++) {
if( !_wcsicmp(L"ADsPath", pszCurrentAttr) )
_fADSPathPresent = TRUE;
_ppszAttrs[i] = pszCurrentAttr;
pszCurrentAttr += wcslen(pszCurrentAttr) + 1;
_ppszAttrs[i] = RemoveWhiteSpaces(_ppszAttrs[i]);
}
//
// If adspath is not in the list add it
//
if( _fADSPathPresent == FALSE )
_ppszAttrs[i] = L"ADsPath";
_fAllAttrs = FALSE; // not a SELECT * query
}
RRETURN( S_OK );
error:
_pszADsContext = NULL;
if( _ppszAttrs ) {
FreeADsMem(_ppszAttrs);
_ppszAttrs = NULL;
}
if( _pszCommandTextCp ) {
FreeADsStr(_pszCommandTextCp);
_pszCommandTextCp = NULL;
}
RRETURN( hr );
}
//
// Look up for the given attribute name in the list of ADS_ATTR_DEF structures.
// Convert the ADSTYPE to the appropriate OLE DB type.
//
STDMETHODIMP
CCommandObject::GetDBType(
PADS_ATTR_DEF pAttrDefinition,
DWORD dwNumAttrs,
LPWSTR pszAttrName,
WORD * pwType,
DBLENGTH * pulSize
)
{
HRESULT hr = S_OK;
ADsAssert(pwType && pulSize);
for (ULONG i=0; i < dwNumAttrs; i++) {
if( !_wcsicmp(pszAttrName, pAttrDefinition[i].pszAttrName) )
break;
}
if( i == dwNumAttrs )
BAIL_ON_FAILURE( hr=E_ADS_PROPERTY_NOT_FOUND );
if( pAttrDefinition[i].fMultiValued &&
IsAutomatable(g_MapADsTypeToVarType[pAttrDefinition[i].dwADsType])) {
//
// Can be represented it as a variant
//
*pwType = DBTYPE_VARIANT | DBTYPE_BYREF;
*pulSize = sizeof(VARIANT);
}
else if( (ULONG)pAttrDefinition[i].dwADsType >= g_cMapADsTypeToDBType ||
pAttrDefinition[i].dwADsType == ADSTYPE_INVALID ||
pAttrDefinition[i].dwADsType == ADSTYPE_PROV_SPECIFIC) {
BAIL_ON_FAILURE( hr=E_ADS_CANT_CONVERT_DATATYPE );
}
else {
*pwType = g_MapADsTypeToDBType[pAttrDefinition[i].dwADsType].wType;
*pulSize = g_MapADsTypeToDBType[pAttrDefinition[i].dwADsType].ulSize;
}
error:
RRETURN (hr);
}
STDMETHODIMP
CCommandObject::SetSearchPrefs(
void
)
{
PROPSET *pPropSet;
PADS_SEARCHPREF_INFO pSearchPref = NULL;
HRESULT hr = S_OK;
ULONG i;
//
// Asserts
//
ADsAssert(_pUtilProp);
ADsAssert(_pDSSearch);
pPropSet = _pUtilProp->GetPropSetFromGuid(DBPROPSET_ADSISEARCH);
if( !pPropSet || !pPropSet->cProperties )
RRETURN( S_OK );
pSearchPref = (PADS_SEARCHPREF_INFO) AllocADsMem(
pPropSet->cProperties *
sizeof(ADS_SEARCHPREF_INFO)
);
if( !pSearchPref )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
for (i=0; i<pPropSet->cProperties; i++) {
hr = _pUtilProp->GetSearchPrefInfo(
pPropSet->pUPropInfo[i].dwPropertyID,
&pSearchPref[i]
);
BAIL_ON_FAILURE( hr );
}
hr = _pDSSearch->SetSearchPreference(
pSearchPref,
pPropSet->cProperties
);
_pUtilProp->FreeSearchPrefInfo(pSearchPref, pPropSet->cProperties);
BAIL_ON_FAILURE( hr );
error:
if( pSearchPref )
FreeADsMem(pSearchPref);
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::CCommandObject
//
// Synopsis: Constructor
//
// Arguments:
// pUnkOuter Outer Unkown Pointer
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
CCommandObject::CCommandObject(
LPUNKNOWN pUnkOuter // Outer Unkown Pointer
)
{
// Initialize simple member vars
_pUnkOuter = pUnkOuter ? pUnkOuter : (IAccessor FAR *) this;
_dwStatus = 0L;
_cRowsetsOpen = 0;
_pAccessor = NULL;
_pUtilProp = NULL;
_pDSSearch = NULL;
_fADSPathPresent = FALSE;
_fAllAttrs = FALSE;
ENLIST_TRACKING(CCommandObject);
return;
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::~CCommandObject
//
// Synopsis: Destructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
CCommandObject::~CCommandObject( )
{
if( _pCSession ) {
_pCSession->DecrementOpenCommands();
_pCSession->Release();
}
delete _pUtilProp;
if( _pszCommandText ) {
FreeADsMem(_pszCommandText);
}
if( _ppszAttrs ) {
FreeADsMem(_ppszAttrs);
}
if( _pszCommandTextCp ) {
FreeADsStr(_pszCommandTextCp);
}
if( _pAccessor )
delete _pAccessor;
if( _pIMalloc )
_pIMalloc->Release();
if( _pDSSearch ) {
_pDSSearch->Release();
}
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::FInit
//
// Synopsis: Initialize the data source Object
//
// Arguments:
//
// Returns:
// Did the Initialization Succeed
// TRUE Initialization succeeded
// FALSE Initialization failed
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
BOOL
CCommandObject::FInit(
CSessionObject * pSession,
CCredentials& Credentials
)
{
HRESULT hr;
//
// Asserts
//
ADsAssert(pSession);
ADsAssert(&Credentials);
_pCSession = pSession;
_pCSession->AddRef();
_pCSession->IncrementOpenCommands();
//
// Allocate properties management object
//
_pUtilProp = new CUtilProp();
if( !_pUtilProp )
return FALSE;
hr = _pUtilProp->FInit(&Credentials);
BAIL_ON_FAILURE(hr);
// IAccessor is always instantiated.
_pAccessor = new CImpIAccessor(this, _pUnkOuter);
if( _pAccessor == NULL || FAILED(_pAccessor->FInit()) )
return FALSE;
hr = CoGetMalloc(MEMCTX_TASK, &_pIMalloc);
if( FAILED(hr) )
return FALSE;
_Credentials = Credentials;
return TRUE;
error:
return FALSE;
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::QueryInterface
//
// Synopsis: Returns a pointer to a specified interface. Callers use
// QueryInterface to determine which interfaces the called object
// supports.
//
// Arguments:
// riid Interface ID of the interface being queried for
// ppv Pointer to interface that was instantiated
//
// Returns:
// S_OK Interface is supported and ppvObject is set.
// E_NOINTERFACE Interface is not supported by the object
// E_INVALIDARG One or more arguments are invalid.
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
// Is the pointer bad?
if( ppv == NULL )
RRETURN( E_INVALIDARG );
if( IsEqualIID(iid, IID_IUnknown) ) {
*ppv = (IAccessor FAR *) this;
}
else if( IsEqualIID(iid, IID_IAccessor) ) {
*ppv = (IAccessor FAR *) this;
}
else if( IsEqualIID(iid, IID_IColumnsInfo) ) {
*ppv = (IColumnsInfo FAR *) this;
}
else if( IsEqualIID(iid, IID_ICommand) ) {
*ppv = (ICommand FAR *) this;
}
else if( IsEqualIID(iid, IID_ICommandProperties) ) {
*ppv = (ICommandProperties FAR *) this;
}
else if( IsEqualIID(iid, IID_ICommandText) ) {
*ppv = (ICommandText FAR *) this;
}
else if( IsEqualIID(iid, IID_IConvertType) ) {
*ppv = (IConvertType FAR *) this;
}
else if( IsEqualIID(iid, IID_ICommandPrepare) ) {
*ppv = (ICommandPrepare FAR *) this;
}
else {
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
BOOL
IsAutomatable(
DBTYPE dbType
)
{
if (dbType != DBTYPE_NULL) {
return TRUE;
}
else {
return FALSE;
}
}
HRESULT
CCommandObject::SeekPastADsPath(
IN LPWSTR pszIn,
OUT LPWSTR * ppszOut
)
{
BOOL fEscapeOn = FALSE, fQuotingOn = FALSE;
WCHAR ch = 0;
// No. of LParans '<' over RParans '>'
DWORD dwParanOffset = 1;
ADsAssert(pszIn);
ADsAssert(ppszOut);
while (1) {
ch = *pszIn;
if( ch == TEXT('\0') ) {
break;
}
if( fEscapeOn ) {
fEscapeOn = FALSE;
}
else if( fQuotingOn ) {
if( ch == TEXT('"') ) {
fQuotingOn = FALSE;
}
}
else if( ch == TEXT('\\') ) {
fEscapeOn = TRUE;
}
else if( ch == TEXT('"') ) {
fQuotingOn = TRUE;
}
else if( ch == L'<' ) {
dwParanOffset++;
}
else if( ch == L'>' ) {
if( --dwParanOffset == 0)
break;
}
pszIn++;
}
if( fEscapeOn || fQuotingOn || dwParanOffset != 0 ) {
RRETURN( DB_E_ERRORSINCOMMAND );
}
*ppszOut = pszIn;
RRETURN( S_OK );
}
HRESULT
CCommandObject::SeekPastSearchFilter(
IN LPWSTR pszIn,
OUT LPWSTR * ppszOut
)
{
BOOL fEscapeOn = FALSE, fQuotingOn = FALSE;
DWORD dwParanOffset = 0;
ADsAssert(pszIn);
if( *pszIn != L'(' ) {
RRETURN( DB_E_ERRORSINCOMMAND );
}
//
// No. of LParans over RParans
//
dwParanOffset = 1;
pszIn++;
while (*pszIn && (*pszIn != L')' || dwParanOffset != 1)) {
if( *pszIn == L'(' ) {
dwParanOffset++;
}
if( *pszIn == L')' ) {
dwParanOffset--;
}
pszIn++;
}
if( *pszIn != L')' ) {
RRETURN( DB_E_ERRORSINCOMMAND );
}
*ppszOut = pszIn + 1;
RRETURN( S_OK );
}
HRESULT
CCommandObject::Prepare(
ULONG cExpectedRuns
)
{
//
// If the command has not been set, make sure the buffer
// contains an empty stringt to return to the consumer
//
if( !IsCommandSet() )
RRETURN( DB_E_NOCOMMAND );
//
// Don't allow prepare if we've got a rowset open
//
if( IsRowsetOpen() )
RRETURN( DB_E_OBJECTOPEN );
//
// SQL dialect: Convert to LDAP and save
//
HRESULT hr = PrepareHelper();
//
// Fixup the HRESULT
//
if( hr == DB_E_NOTABLE )
hr = DB_E_ERRORSINCOMMAND;
BAIL_ON_FAILURE( hr );
//
// Set the Prepare state
//
_dwStatus |= CMD_PREPARED;
error:
RRETURN( hr );
}
HRESULT
CCommandObject::Unprepare()
{
//
// Don't allow unprepare if we've got a rowset open
//
if( IsRowsetOpen() )
RRETURN( DB_E_OBJECTOPEN );
//
// Reset the Prepare state
//
_dwStatus &= ~(CMD_PREPARED);
RRETURN( S_OK );
}
//+---------------------------------------------------------------------------
//
// Function: CCommandObject::PrepareHelper
//
// Synopsis:
//
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CCommandObject::PrepareHelper(void)
{
LPWSTR pszOrderList = NULL;
LPWSTR pszSelect = NULL;
LPWSTR pszLocation = NULL;
LPWSTR pszLdapQuery = NULL;
LPWSTR pszParsedCmd = NULL;
//
// SQL dialect: Convert to LDAP and save
// If SQLParse Fails the function cleans up memory
//
HRESULT hr = SQLParse(
(const LPWSTR) _pszCommandText,
&pszLocation,
&pszLdapQuery,
&pszSelect,
&pszOrderList
);
if( FAILED(hr) && hr != E_ADS_INVALID_FILTER)
RRETURN( hr=DB_E_ERRORSINCOMMAND );
if (SUCCEEDED(hr))
{
//
// the ldap query is optional, it can be NULL. When it is NULL, it
// implies a * search.
//
DWORD dwLdapQuery = 0;
if (pszLdapQuery) {
dwLdapQuery = wcslen(pszLdapQuery);
}
pszParsedCmd =(LPWSTR) AllocADsMem((wcslen(pszLocation) +
dwLdapQuery+
wcslen(pszSelect) +
5 + // 2 semicolons and 2 <
1) * sizeof(WCHAR));
if( !pszParsedCmd ) {
_dwStatus &= ~CMD_TEXT_SET;
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
}
//
// Put the statement together.
//
wcscpy(pszParsedCmd, L"<");
wcscat(pszParsedCmd, pszLocation);
wcscat(pszParsedCmd, L">;");
if (pszLdapQuery)
wcscat(pszParsedCmd, pszLdapQuery);
wcscat(pszParsedCmd, L";");
wcscat(pszParsedCmd, pszSelect);
hr = SplitCommandText(pszParsedCmd);
}
else
{
//
// Assume valid LDAP filter
//
hr = SplitCommandText(_pszCommandText);
}
BAIL_ON_FAILURE( hr )
//
// Set the sort preference property if necessary
//
if( pszOrderList ) {
DBPROPSET rgCmdPropSet[1];
DBPROP rgCmdProp[1];
rgCmdPropSet[0].rgProperties = rgCmdProp;
rgCmdPropSet[0].cProperties = 1;
rgCmdPropSet[0].guidPropertySet = DBPROPSET_ADSISEARCH;
rgCmdProp[0].dwPropertyID = ADSIPROP_SORT_ON;
rgCmdProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
rgCmdProp[0].vValue.vt = VT_BSTR;
V_BSTR (&rgCmdProp[0].vValue) = pszOrderList;
hr = SetProperties(1, rgCmdPropSet);
BAIL_ON_FAILURE( hr );
}
if( _pDSSearch ) {
_pDSSearch->Release();
_pDSSearch = NULL;
}
//
// If integrated security is being used, impersonate the caller
//
BOOL fImpersonating;
fImpersonating = FALSE;
if(_pCSession->IsIntegratedSecurity())
{
HANDLE ThreadToken = _pCSession->GetThreadToken();
ASSERT(ThreadToken != NULL);
if (ThreadToken)
{
if (!ImpersonateLoggedOnUser(ThreadToken))
RRETURN(E_FAIL);
fImpersonating = TRUE;
}
else
RRETURN(E_FAIL);
}
hr = GetDSInterface(_pszADsContext,
_Credentials,
IID_IDirectorySearch,
(void **)&_pDSSearch);
if (fImpersonating)
{
RevertToSelf();
fImpersonating = FALSE;
}
BAIL_ON_FAILURE( hr );
error:
if( pszLocation )
FreeADsMem(pszLocation);
if( pszLdapQuery )
FreeADsMem(pszLdapQuery);
if( pszSelect )
FreeADsMem(pszSelect);
if( pszOrderList )
FreeADsStr(pszOrderList);
if( pszParsedCmd )
FreeADsStr(pszParsedCmd);
RRETURN( hr );
}
Reference in a new issue View git blame Copy permalink