2048 lines
50 KiB
C++
2048 lines
50 KiB
C++
//
|
|
// 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 );
|
|
}
|
|
|
|
|