//---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995
//
// File: csession.cxx
//
// Contents: Microsoft OleDB/OleDS Session object for ADSI
//
//
// History: 08-01-96 shanksh Created.
//
//----------------------------------------------------------------------------
#include "oleds.hxx"
#pragma hdrstop
#include "atl.h"
#include "row.hxx"
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::GetDataSource
//
// Synopsis: Retrieve an interface pointer on the session object
//
// Arguments:
// riid, IID desired
// ppDSO ptr to interface
//
//
// Returns:
// S_OK Session Object Interface returned
// E_INVALIDARG ppDSO was NULL
// E_NOINTERFACE IID not supported
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::GetDataSource (
REFIID riid,
IUnknown ** ppDSO
)
{
//
// Asserts
//
ADsAssert(_pDSO);
if( ppDSO == NULL )
RRETURN( E_INVALIDARG );
RRETURN( _pDSO->QueryInterface(riid, (LPVOID*)ppDSO) );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::GetDataSource
//
// Synopsis: Retrieve an interface pointer on the session object
//
// Arguments:
// riid, IID desired
// ppDSO ptr to interface
//
//
// Returns:
// S_OK Session Object Interface returned
// E_INVALIDARG ppDSO was NULL
// E_NOINTERFACE IID not supported
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::OpenRowset(
IUnknown * pUnkOuter,
DBID * pTableID,
DBID * pIndexID,
REFIID riid,
ULONG cPropertySets,
DBPROPSET rgPropertySets[],
IUnknown ** ppRowset
)
{
// Don't pass any credentials (NULL)
RRETURN( OpenRowsetWithCredentials(
pUnkOuter,
pTableID,
pIndexID,
riid,
cPropertySets,
rgPropertySets,
NULL,
ppRowset) );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::OpenRowsetWithCredentials
//
// Synopsis: Opens a rowset. Similar to OpenRowset but takes extra argument
// CCredentials. This function is used when consumer calls
// IBindResource::Bind requesting a rowset.
//
// Returns : HRESULT
//
//----------------------------------------------------------------------------
HRESULT
CSessionObject::OpenRowsetWithCredentials (
IUnknown * pUnkOuter,
DBID * pTableID,
DBID * pIndexID,
REFIID riid,
ULONG cPropertySets,
DBPROPSET rgPropertySets[],
CCredentials * pCredentials,
IUnknown ** ppRowset
)
{
BOOL fWarning = FALSE;
CRowProvider *pRowProvider = NULL;
DWORD cAttrs = 1;
BOOL *pbMultiValue = NULL;
LPWSTR *pAttrs = NULL;
//
// Check in-params and NULL out-params in case of error
//
if( ppRowset )
*ppRowset = NULL;
if( !pTableID && !pIndexID )
RRETURN( E_INVALIDARG );
if( pIndexID )
RRETURN( DB_E_NOINDEX );
//
// Check the PropertySets
//
if( cPropertySets > 0 && !rgPropertySets )
RRETURN ( E_INVALIDARG );
for(ULONG i=0; i<cPropertySets; i++) {
if( rgPropertySets[i].cProperties && !rgPropertySets[i].rgProperties )
RRETURN ( E_INVALIDARG );
}
//
// pwszName field represents the ADsPath of the Directory we have to open;
// Make sure pwszName is meaningful
//
if( !pTableID || pTableID->eKind != DBKIND_NAME ||
!pTableID->uName.pwszName || !(*(pTableID->uName.pwszName)) )
RRETURN( DB_E_NOTABLE );
if( pUnkOuter )//&& !InlineIsEqualGUID(riid, IID_IUnknown) )
RRETURN( DB_E_NOAGGREGATION );
if( riid == IID_NULL )
RRETURN( E_NOINTERFACE );
//
// By default, we use credentials stored in member variable _Credentials
// for binding. Buf if caller passed any credentials through pCredentials,
// these take precedence. This also means that we need to store these
// credentials in the CRowProvider object for future use -
// e.g. GetRowFromHRow will use these credentials.
//
CCredentials * pCreds = &_Credentials;
if( pCredentials )
pCreds = pCredentials;
//
// If integrated security is being used, impersonate the caller
//
BOOL fImpersonating;
fImpersonating = FALSE;
if(_pDSO->IsIntegratedSecurity())
{
HANDLE ThreadToken = _pDSO->GetThreadToken();
ASSERT(ThreadToken != NULL);
if (ThreadToken)
{
if (!ImpersonateLoggedOnUser(ThreadToken))
RRETURN(E_FAIL);
fImpersonating = TRUE;
}
else
RRETURN(E_FAIL);
}
HRESULT hr = GetDSInterface(
pTableID->uName.pwszName,
*pCreds,
IID_IDirectorySearch,
(void **)&_pDSSearch);
if (fImpersonating)
{
RevertToSelf();
fImpersonating = FALSE;
}
if( FAILED(hr) )
RRETURN( hr );
//
// Get ColumnsInfo based on the list of attributes that we want to be
// returned. GetDefaultColumnInfo cleansup memory on failure.
//
ULONG cColumns = 0;
DBCOLUMNINFO * prgInfo = NULL;
WCHAR * pStringBuffer = NULL;
hr = GetDefaultColumnInfo(&cColumns, &prgInfo, &pStringBuffer);
if( FAILED(hr) )
RRETURN( hr );
// Store the properties (which must be in the rowset property group) in
// the property object. OpenRowset is different from methods like
// ICOmmand::SetProperties and ISessionProperties::SetProperties in that
// it returns DB_E_ERROSOCCURRED if any property which is REQUIRED could
// not be set and DB_S_ERROROCCURRED if any property that is OPTIONAL
// could not be set. ICommand::SetProperties returns DB_E_ERROSOCCURRED
// if all properties could not be set and DB_S_ERROSOCCURRED if some
// property could not be set i.e, DBPROPOPTIONS (REQUIRED or OPTIONAL) is
// ignored.
// Use PROPSET_COMMAND as the bitmask below since the properties that are
// going to be set are in the rowset property group. These properties that
// are stored in the property object cannot be retrieved by the client
// since GetProperties on a session object will only return properties in
// the session property group.
hr = _pUtilProp->SetProperties(
cPropertySets,
rgPropertySets,
PROPSET_COMMAND
);
if( (DB_E_ERRORSOCCURRED == hr) || (DB_S_ERRORSOCCURRED == hr) )
// check if a required property could not be set
{
ULONG i, j;
for(i = 0; i < cPropertySets; i++)
for(j = 0; j < rgPropertySets[i].cProperties; j++)
if( rgPropertySets[i].rgProperties[j].dwStatus !=
DBPROPSTATUS_OK )
if( rgPropertySets[i].rgProperties[j].dwOptions !=
DBPROPOPTIONS_OPTIONAL )
{
BAIL_ON_FAILURE( hr = DB_E_ERRORSOCCURRED );
}
else
fWarning = TRUE;
// if we get here, then there was all required properties were set
// successfully. However, hr could still be DB_ERRORSOCCURRED if all
// properties were optional and all of them could not be set. This
// condition is not an error for OpenRowset as noted in the comment
// above. Hence reset hr to S_OK.
hr = S_OK;
}
// we still need to catch other errors like E_INAVLIDARG
BAIL_ON_FAILURE(hr);
hr = SetSearchPrefs();
BAIL_ON_FAILURE( hr );
//
// Create RowProvider object to pass to rowset code
//
pbMultiValue = (BOOL *)AllocADsMem(sizeof(BOOL));
pAttrs = (LPWSTR *)AllocADsMem(cAttrs * sizeof(LPWSTR));
if( pAttrs )
pAttrs[0] = AllocADsStr(L"ADsPath");
if( !pAttrs || !pAttrs[0] || !pbMultiValue )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
*pbMultiValue = FALSE;
_pDSSearch->AddRef();
// Is this an NDS path? If so, set filter appropriately. Fix for #286560.
WCHAR lpszProgId[MAX_PATH];
BOOL fIsNds;
hr = CopyADsProgId(pTableID->uName.pwszName, lpszProgId);
BAIL_ON_FAILURE( hr );
if( !wcscmp(L"NDS", lpszProgId) )
fIsNds = TRUE;
else
fIsNds = FALSE;
hr = CRowProvider::CreateRowProvider(
_pDSSearch,
NULL,
pAttrs,
cAttrs,
cColumns,
prgInfo,
pStringBuffer,
IID_IRowProvider,
pbMultiValue,
TRUE,
pCreds,
(void **) &pRowProvider
);
BAIL_ON_FAILURE( hr );
//
// RowProvider responsible for deallocation
//
pbMultiValue = NULL;
hr= CRowset::CreateRowset(
pRowProvider,
(LPUNKNOWN)(IAccessor FAR *)this ,
this,
NULL,
cPropertySets,
rgPropertySets,
0,
NULL,
TRUE, // ADsPath is requested
FALSE, // not all attributes are requested
riid,
ppRowset
);
BAIL_ON_FAILURE( hr );
error:
if( _pDSSearch ) {
_pDSSearch->Release();
_pDSSearch = NULL;
}
if( pRowProvider )
pRowProvider->Release();
if( prgInfo )
_pIMalloc->Free(prgInfo);
if( pStringBuffer )
_pIMalloc->Free(pStringBuffer);
if( pbMultiValue )
FreeADsMem(pbMultiValue);
if (pAttrs)
{
for (i = 0; i < cAttrs; i++)
{
if (pAttrs[i])
FreeADsStr(pAttrs[0]);
}
FreeADsMem(pAttrs);
}
if( FAILED(hr) )
RRETURN( hr );
else if( fWarning )
RRETURN( DB_S_ERRORSOCCURRED );
else
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::GetProperties
//
// Synopsis: Returns current settings of all properties in the DBPROPFLAGS_SESSION property
// group
//
// Arguments:
// cPropertySets count of restiction guids
// rgPropertySets restriction guids
// pcProperties count of properties returned
// prgProperties property information returned
//
// Returns:
// S_OK Session Object Interface returned
// E_INVALIDARG pcProperties or prgPropertyInfo was NULL
// E_OUTOFMEMORY Out of memory
//
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::GetProperties(
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_SESSION);
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_SESSION) );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::SetProperties
//
// Synopsis: Set properties in the DBPROPFLAGS_SESSION property group
//
// Arguments:
// cProperties
// rgProperties
//
// Returns:
// S_OK Session Object Interface returned
// E_INVALIDARG pcProperties or prgPropertyInfo was NULL
// E_OUTOFMEMORY Out of memory
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::SetProperties(
ULONG cPropertySets,
DBPROPSET rgPropertySets[]
)
{
//
// Asserts
//
ADsAssert(_pUtilProp);
//
// Just pass this call on to the utility object that manages our properties
//
RRETURN( _pUtilProp->SetProperties(
cPropertySets,
rgPropertySets,
PROPSET_SESSION) );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::CreateCommand
//
// Synopsis: Creates a brand new command and returns requested interface
//
// Arguments:
// pUnkOuter outer Unknown
// riid, IID desired
// ppCommand ptr to interface
//
//
// Returns:
// S_OK Command Object Interface returned
// E_INVALIDARG ppCommand was NULL
// E_NOINTERFACE IID not supported
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::CreateCommand(
IUnknown * pUnkOuter,
REFIID riid,
IUnknown ** ppCommand
)
{
CCommandObject* pCommand = NULL;
HRESULT hr;
//
// check in-params and NULL out-params in case of error
//
if( ppCommand )
*ppCommand = NULL;
else
RRETURN( E_INVALIDARG );
if( pUnkOuter )//&& !InlineIsEqualGUID(riid, IID_IUnknown) )
RRETURN( DB_E_NOAGGREGATION );
//
// open a CCommand object
//
pCommand = new CCommandObject(pUnkOuter);
if( !pCommand )
RRETURN( E_OUTOFMEMORY );
//
// initialize the object
//
if( !pCommand->FInit(this, _Credentials) ) {
delete pCommand;
RRETURN( E_OUTOFMEMORY );
}
//
// get requested interface pointer on DBSession
//
hr = pCommand->QueryInterface(riid, (void **)ppCommand);
if( FAILED( hr ) ) {
delete pCommand;
RRETURN( hr );
}
pCommand->Release();
//
// all went well
//
RRETURN( S_OK );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::GetDefaultColumnInfo
//
// Synopsis:
//
// Arguments:
//
// Returns:
//
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::GetDefaultColumnInfo(
ULONG * pcColumns,
DBCOLUMNINFO ** prgInfo,
OLECHAR ** ppStringBuffer
)
{
//
// Asserts
//
ADsAssert(_pIMalloc);
ADsAssert(pcColumns);
ADsAssert(prgInfo);
ADsAssert(ppStringBuffer);
//
// Allcoate memory for the Bookmark and ADsPath column
//
*prgInfo = (DBCOLUMNINFO*)_pIMalloc->Alloc(2 * sizeof(DBCOLUMNINFO));
*ppStringBuffer = (WCHAR*)_pIMalloc->Alloc((wcslen(L"ADsPath") + 1) * sizeof(WCHAR));
//
// Free memory on a failure
//
if( !(*prgInfo) )
RRETURN( E_OUTOFMEMORY );
if( !(*ppStringBuffer) ) {
_pIMalloc->Free(*prgInfo);
*prgInfo = NULL;
RRETURN( E_OUTOFMEMORY );
}
//
// Initialize the memory
//
ZeroMemory(*prgInfo, 2 * sizeof(DBCOLUMNINFO));
ZeroMemory(*ppStringBuffer, (wcslen(L"ADsPath") + 1) * sizeof(WCHAR));
wcscpy(*ppStringBuffer, OLESTR("ADsPath"));
//
// Fill up the Bookmark column
//
*pcColumns = 2;
(*prgInfo)[0].pwszName = NULL;
(*prgInfo)[0].pTypeInfo = NULL;
(*prgInfo)[0].iOrdinal = 0;
(*prgInfo)[0].ulColumnSize = sizeof(ULONG);
(*prgInfo)[0].wType = DBTYPE_UI4;
(*prgInfo)[0].bPrecision = 10;
(*prgInfo)[0].bScale = (BYTE) ~ 0;
(*prgInfo)[0].columnid.eKind = DBKIND_GUID_PROPID;
(*prgInfo)[0].columnid.uGuid.guid = DBCOL_SPECIALCOL;
(*prgInfo)[0].columnid.uName.ulPropid = 2;
(*prgInfo)[0].dwFlags = DBCOLUMNFLAGS_ISBOOKMARK |
DBCOLUMNFLAGS_ISFIXEDLENGTH;
//
// Fill up the ADsPath column
//
(*prgInfo)[1].pwszName = *ppStringBuffer;
(*prgInfo)[1].pTypeInfo = NULL;
(*prgInfo)[1].iOrdinal = 1;
(*prgInfo)[1].ulColumnSize = (ULONG)256;
(*prgInfo)[1].wType = DBTYPE_WSTR|DBTYPE_BYREF;
(*prgInfo)[1].bPrecision = (BYTE) ~ 0;
(*prgInfo)[1].bScale = (BYTE) ~ 0;
(*prgInfo)[1].columnid.eKind = DBKIND_NAME;
(*prgInfo)[1].columnid.uName.pwszName = *ppStringBuffer;
(*prgInfo)[1].columnid.uGuid.guid = GUID_NULL;
(*prgInfo)[1].dwFlags = DBCOLUMNFLAGS_ISNULLABLE;
RRETURN( S_OK );
}
#if (!defined(BUILD_FOR_NT40))
//IBindResource::Bind
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::CSessionObject
//
// Synopsis: Constructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 09-17-1998 mgorti Created.
//
//----------------------------------------------------------------------------
HRESULT CSessionObject::Bind(
IUnknown * punkOuter,
LPCOLESTR pwszURL,
DBBINDURLFLAG dwBindFlags,
REFGUID rguid,
REFIID riid,
IAuthenticate * pAuthenticate,
DBIMPLICITSESSION * pImplSession,
DWORD * pdwBindStatus,
IUnknown ** ppUnk
)
{
HRESULT hr = S_OK;
CComBSTR bstrNewURL;
TRYBLOCK
//Initialize return arguments
if (pdwBindStatus)
*pdwBindStatus = 0;
if (ppUnk)
*ppUnk = NULL;
if (pImplSession)
pImplSession->pSession = NULL;
//if caller passed a null value for dwBindFlags,
//get them from initialization properties.
if (dwBindFlags == 0)
dwBindFlags = BindFlagsFromDbProps();
//Generic argument validation
hr = ValidateBindArgs(punkOuter,
pwszURL,
dwBindFlags,
rguid,
riid,
pAuthenticate,
pImplSession,
pdwBindStatus,
ppUnk);
BAIL_ON_FAILURE(hr);
//Fill in the pImplSession struct.
if (pImplSession)
{
// Our session doesn't support aggregation.
if (pImplSession->pUnkOuter != NULL)
BAIL_ON_FAILURE(hr = DB_E_NOAGGREGATION);
hr = QueryInterface(*pImplSession->piid,
(void**)&(pImplSession->pSession));
if (FAILED(hr))
BAIL_ON_FAILURE(hr = E_NOINTERFACE );
}
//Specific validation checks
//We are currently a read-only provider
if (dwBindFlags & DBBINDURLFLAG_WRITE)
BAIL_ON_FAILURE(hr = DB_E_READONLY);
//We currently don't support aggregation
if (punkOuter != NULL)
BAIL_ON_FAILURE (hr = DB_E_NOAGGREGATION);
//We don't support the following flags
if (dwBindFlags & DBBINDURLFLAG_ASYNCHRONOUS)
BAIL_ON_FAILURE(hr = DB_E_ASYNCNOTSUPPORTED);
if (dwBindFlags & DBBINDURLFLAG_OUTPUT ||
dwBindFlags & DBBINDURLFLAG_RECURSIVE ||
dwBindFlags & DBBINDURLFLAG_DELAYFETCHSTREAM ||
dwBindFlags & DBBINDURLFLAG_DELAYFETCHCOLUMNS)
BAIL_ON_FAILURE(hr = E_INVALIDARG);
//Now Try to Bind.
if (InlineIsEqualGUID(rguid, DBGUID_ROW) ||
InlineIsEqualGUID(rguid, DBGUID_ROWSET))
{
//If the URL is not absolute, build the absolute URL
//using the DBPROP_INIT_PROVIDERSTRING.
if (! bIsAbsoluteURL(pwszURL))
{
hr = BuildAbsoluteURL (pwszURL, bstrNewURL);
if (FAILED(hr))
BAIL_ON_FAILURE(hr = E_INVALIDARG);
}
else
bstrNewURL = pwszURL;
if ( InlineIsEqualGUID(rguid, DBGUID_ROW) )
{
hr = BindToRow(punkOuter,
(PWCHAR)bstrNewURL,
pAuthenticate,
dwBindFlags,
riid,
ppUnk);
}
else
{
hr = BindToRowset(punkOuter,
(PWCHAR)bstrNewURL,
pAuthenticate,
dwBindFlags,
riid,
ppUnk);
}
BAIL_ON_FAILURE(hr);
}
else if (InlineIsEqualGUID(rguid, DBGUID_DSO))
{
ADsAssert(_pDSO);
hr = BindToDataSource(
punkOuter,
pwszURL,
pAuthenticate,
dwBindFlags,
riid,
ppUnk
);
BAIL_ON_FAILURE (hr);
}
else if (InlineIsEqualGUID(rguid, DBGUID_SESSION))
{
hr = QueryInterface(riid, (void**)ppUnk);
BAIL_ON_FAILURE (hr);
}
else
BAIL_ON_FAILURE(hr = E_INVALIDARG);
//Fix for bug Raid-X5#83386 - spec change
//If caller specified any DENY semantics,
//set warning status and return value, since
//we don't support these.
if (dwBindFlags & DBBINDURLFLAG_SHARE_DENY_READ ||
dwBindFlags & DBBINDURLFLAG_SHARE_DENY_WRITE ||
dwBindFlags & DBBINDURLFLAG_SHARE_EXCLUSIVE)
{
if (pdwBindStatus)
*pdwBindStatus = DBBINDURLSTATUS_S_DENYNOTSUPPORTED;
BAIL_ON_FAILURE (hr = DB_S_ERRORSOCCURRED);
}
CATCHBLOCKBAIL(hr)
error:
RRETURN(hr);
}
#endif
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::CSessionObject
//
// Synopsis: Constructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
CSessionObject::CSessionObject(
LPUNKNOWN pUnkOuter
)
{
//
// Initialize simple member vars
//
_pUnkOuter = pUnkOuter ? pUnkOuter : (IGetDataSource FAR *)this;
_cCommandsOpen = 0;
_pUtilProp = NULL;
_pDSSearch = NULL;
_pIMalloc = NULL;
_pDSO = NULL;
ENLIST_TRACKING(CSessionObject);
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::~CSessionObject
//
// Synopsis: Destructor
//
// Arguments:
//
// Returns:
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
CSessionObject::~CSessionObject( )
{
//
// Free properties management object
//
delete _pUtilProp;
if( _pIMalloc )
_pIMalloc->Release();
if( _pDSO ) {
_pDSO->DecrementOpenSessions();
_pDSO->Release();
}
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::FInit
//
// Synopsis: Initialize the session Object
//
// Arguments:
//
// Returns:
// TRUE Initialization succeeded
// FALSE Initialization failed
//
// Modifies:
//
// History: 08-28-96 ShankSh Created.
//
//----------------------------------------------------------------------------
BOOL CSessionObject::FInit(
CDSOObject * pDSO,
CCredentials & Credentials
)
{
HRESULT hr;
//
// Asserts
//
ADsAssert(pDSO);
ADsAssert(&Credentials);
//
// Allocate properties management object
//
_pUtilProp = new CUtilProp();
if( !_pUtilProp )
return FALSE;
hr = _pUtilProp->FInit(&Credentials);
BAIL_ON_FAILURE(hr);
//
// IMalloc->Alloc is the way we have to allocate memory for out parameters
//
hr = CoGetMalloc(MEMCTX_TASK, &_pIMalloc);
BAIL_ON_FAILURE(hr);
//
// Establish parent object pointer
//
_pDSO = pDSO;
_Credentials = Credentials;
_pDSO->AddRef();
_pDSO->IncrementOpenSessions();
return( TRUE );
error:
RRETURN( FALSE );
}
STDMETHODIMP
CSessionObject::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
if( ppv == NULL )
RRETURN( E_INVALIDARG );
if( IsEqualIID(iid, IID_IUnknown) ) {
*ppv = (IGetDataSource FAR *) this;
}
else if( IsEqualIID(iid, IID_IGetDataSource) ) {
*ppv = (IGetDataSource FAR *) this;
}
else if( IsEqualIID(iid, IID_IOpenRowset) ) {
*ppv = (IOpenRowset FAR *) this;
}
else if( IsEqualIID(iid, IID_ISessionProperties) ) {
*ppv = (ISessionProperties FAR *) this;
}
else if( IsEqualIID(iid, IID_IDBCreateCommand) ) {
*ppv = (IDBCreateCommand FAR *) this;
}
#if (!defined(BUILD_FOR_NT40))
else if( IsEqualIID(iid, IID_IBindResource) ) {
*ppv = (IBindResource FAR *) this;
}
#endif
else {
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
#if (!defined(BUILD_FOR_NT40))
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::ValidateBindArgs
//
// Synopsis: Validates IBindResource::Bind function arguments.
//
//----------------------------------------------------------------------------
HRESULT CSessionObject::ValidateBindArgs(
IUnknown * punkOuter,
LPCOLESTR pwszURL,
DBBINDURLFLAG dwBindFlags,
REFGUID rguid,
REFIID riid,
IAuthenticate * pAuthenticate,
DBIMPLICITSESSION * pImplSession,
DWORD * pdwBindStatus,
IUnknown ** ppUnk
)
{
//General validation checks.
if (pwszURL == NULL || InlineIsEqualGUID(rguid,GUID_NULL) ||
InlineIsEqualGUID(riid, GUID_NULL) || ppUnk == NULL )
RRETURN(E_INVALIDARG);
if (pImplSession &&
(pImplSession->pUnkOuter == NULL || pImplSession->piid == NULL))
RRETURN(E_INVALIDARG);
if (punkOuter && !InlineIsEqualGUID(riid, IID_IUnknown))
RRETURN(DB_E_NOAGGREGATION);
if (pImplSession && pImplSession->pUnkOuter &&
pImplSession->piid &&
!InlineIsEqualGUID(*pImplSession->piid, IID_IUnknown))
RRETURN(DB_E_NOAGGREGATION);
if (dwBindFlags & DBBINDURLFLAG_RECURSIVE)
{
//if DBBINDURLFLAG_RECURSIVE is set, at least one of the SHARE_DENY
//flags must have been set.
if (! ( (dwBindFlags & DBBINDURLFLAG_SHARE_DENY_READ) ||
(dwBindFlags & DBBINDURLFLAG_SHARE_DENY_WRITE) ||
(dwBindFlags & DBBINDURLFLAG_SHARE_EXCLUSIVE)
)
)
RRETURN(E_INVALIDARG);
}
if (!(dwBindFlags & DBBINDURLFLAG_READ) &&
!(dwBindFlags & DBBINDURLFLAG_WRITE) ) {
// Must have either read or write access:
RRETURN(E_INVALIDARG);
}
if (InlineIsEqualGUID(rguid, DBGUID_DSO) &&
!((dwBindFlags & DBBINDURLFLAG_READ) ||
(dwBindFlags & DBBINDURLFLAG_ASYNCHRONOUS) ||
(dwBindFlags & DBBINDURLFLAG_WAITFORINIT)
)
)
//if object type is DataSource, only the above flags are allowed
RRETURN(E_INVALIDARG);
if (InlineIsEqualGUID(rguid, DBGUID_SESSION) &&
! (dwBindFlags == DBBINDURLFLAG_READ))
//if object type is Session, only DBBINDURLFLAG_READ is allowed
RRETURN(E_INVALIDARG);
if (InlineIsEqualGUID(rguid, DBGUID_ROWSET) &&
((dwBindFlags & DBBINDURLFLAG_DELAYFETCHCOLUMNS) ||
(dwBindFlags & DBBINDURLFLAG_DELAYFETCHSTREAM)
)
)
//if object type is Rowset, DELAYFETCHCOLUMNS and DELAYFETCHSTREAM
//flags are disallowed.
RRETURN ( E_INVALIDARG );
if (InlineIsEqualGUID(rguid, DBGUID_STREAM) &&
((dwBindFlags & DBBINDURLFLAG_DELAYFETCHCOLUMNS) ||
(dwBindFlags & DBBINDURLFLAG_DELAYFETCHSTREAM)
)
)
//if object type is Stream, DELAYFETCHCOLUMNS and
//DELAYFETCHSTREAM flags are disallowed.
RRETURN(E_INVALIDARG);
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::BindToRow
//
// Synopsis: Given a URL, binds to that row object and returns the requested
// interface.
//
//----------------------------------------------------------------------------
HRESULT
CSessionObject::BindToRow(
IUnknown *punkOuter,
LPCOLESTR pwszURL,
IAuthenticate *pAuthenticate,
DWORD dwBindFlags,
REFIID riid,
IUnknown** ppUnk
)
{
CComObject<CRow> *pRow = NULL;
auto_rel<IUnknown> pSession;
auto_rel<IRow> pRowDelete;
HRESULT hr = S_OK;
hr = CComObject<CRow>::CreateInstance(&pRow);
if (FAILED(hr))
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
//To make sure we delete the row object in
//case we encounter errors after this point.
//Note: this version of auto_rel doesn't addref on assignment.
pRowDelete = pRow;
pRowDelete->AddRef();
hr = QueryInterface(__uuidof(IUnknown), (void **)&pSession);
if (FAILED(hr))
BAIL_ON_FAILURE(hr = E_FAIL);
//Initialize row and bind it to a Directory Object.
hr = pRow->Initialize((PWSTR)pwszURL,
(IUnknown *)pSession,
pAuthenticate,
dwBindFlags,
FALSE, // not a tearoff
FALSE, // don't get column info. from rowset
&_Credentials,
true);
if (FAILED(hr))
{
if (INVALID_CREDENTIALS_ERROR(hr))
{
BAIL_ON_FAILURE(hr = DB_SEC_E_PERMISSIONDENIED);
}
else
{
BAIL_ON_FAILURE(hr = DB_E_NOTFOUND);
}
}
hr = pRow->QueryInterface(riid, (void**)ppUnk);
if (FAILED(hr))
BAIL_ON_FAILURE (hr = E_NOINTERFACE);
error:
RRETURN ( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::BindToRowset
//
// Synopsis: Given a URL, binds to a rowset object that has all its child
// nodes as rows and returns the requested interface on the rowset.
//
//----------------------------------------------------------------------------
HRESULT
CSessionObject::BindToRowset(
IUnknown *pUnkOuter,
LPCOLESTR pwszURL,
IAuthenticate *pAuthenticate,
DWORD dwBindFlags,
REFIID riid,
IUnknown** ppUnk
)
{
HRESULT hr;
DWORD fAuthFlags;
DBID tableID;
tableID.eKind = DBKIND_NAME;
tableID.uName.pwszName = (LPWSTR) pwszURL;
//Create the rowset.
// Fix for 351040. First try explicit credentials, then session object's
// credentials, then default credentials.
if(pAuthenticate)
{
CCredentials creds;
hr = GetCredentialsFromIAuthenticate(pAuthenticate, creds);
if (FAILED(hr))
BAIL_ON_FAILURE(hr = E_INVALIDARG);
fAuthFlags = creds.GetAuthFlags();
creds.SetAuthFlags(fAuthFlags |
ADS_SECURE_AUTHENTICATION);
hr = OpenRowsetWithCredentials(pUnkOuter, &tableID, NULL, riid,
0, NULL, &creds, ppUnk);
}
if( (!pAuthenticate) || (INVALID_CREDENTIALS_ERROR(hr)) )
// try credentials in session object
hr = OpenRowset(pUnkOuter, &tableID, NULL, riid, 0, NULL, ppUnk);
if(INVALID_CREDENTIALS_ERROR(hr))
// try default credentials
{
CCredentials creds; // default credentials
fAuthFlags = creds.GetAuthFlags();
creds.SetAuthFlags(fAuthFlags |
ADS_SECURE_AUTHENTICATION);
hr = OpenRowsetWithCredentials(pUnkOuter, &tableID, NULL, riid,
0, NULL, &creds, ppUnk);
}
BAIL_ON_FAILURE(hr);
RRETURN ( S_OK );
error:
RRETURN ( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::BindFlagsFromDbProps
//
// Synopsis: Synthesizes bind flags from initialization properties
// DBPROP_INIT_MODE and DBPROP_INIT_BINDFLAGS
//
//----------------------------------------------------------------------------
DWORD CSessionObject::BindFlagsFromDbProps()
{
HRESULT hr = S_OK;
auto_rel<IDBProperties> pDBProp;
ULONG i, j, cPropertySets = 0;
DWORD dwMode = 0, dwBindFlags = 0, dwBindFlagProp = 0;
DWORD dwResult = 0;
hr = GetDataSource(__uuidof(IDBProperties), (IUnknown **)&pDBProp);
BAIL_ON_FAILURE(hr);
DBPROPID propids[2];
propids[0] = DBPROP_INIT_MODE;
propids[1] = DBPROP_INIT_BINDFLAGS;
DBPROPIDSET rgPropertyIDSets[1];
rgPropertyIDSets[0].rgPropertyIDs = propids;
rgPropertyIDSets[0].cPropertyIDs = 2;
rgPropertyIDSets[0].guidPropertySet = DBPROPSET_DBINIT;
DBPROPSET *prgPropertySets;
hr = pDBProp->GetProperties(
1,
rgPropertyIDSets,
&cPropertySets,
&prgPropertySets);
if (hr == DB_E_ERRORSOCCURRED)
BAIL_ON_FAILURE(hr);
for (i = 0; i < cPropertySets; i++)
{
for (j = 0; j < prgPropertySets[i].cProperties; j++)
{
DBPROP *pProp = &prgPropertySets[i].rgProperties[j];
ADsAssert(pProp);
if (pProp->dwStatus == S_OK &&
pProp->dwPropertyID == DBPROP_INIT_MODE)
dwMode = V_I4(&pProp->vValue);
else if (pProp->dwStatus == S_OK &&
pProp->dwPropertyID == DBPROP_INIT_BINDFLAGS)
dwBindFlagProp = V_I4(&pProp->vValue);
else
continue;
}
}
//Now extract bind flags from dwMode and dwBindFlagProp
{
DWORD dwModeMask =
DB_MODE_READ |
DB_MODE_WRITE |
DB_MODE_READWRITE |
DB_MODE_SHARE_DENY_READ |
DB_MODE_SHARE_DENY_WRITE |
DB_MODE_SHARE_EXCLUSIVE |
DB_MODE_SHARE_DENY_NONE;
dwResult |= dwMode & dwModeMask;
if ( dwBindFlagProp & DB_BINDFLAGS_DELAYFETCHCOLUMNS ) {
dwBindFlags |= DBBINDURLFLAG_DELAYFETCHCOLUMNS;
}
if ( dwBindFlagProp & DB_BINDFLAGS_DELAYFETCHSTREAM ) {
dwBindFlags |= DBBINDURLFLAG_DELAYFETCHSTREAM;
}
if ( dwBindFlagProp & DB_BINDFLAGS_RECURSIVE ) {
dwBindFlags |= DBBINDURLFLAG_RECURSIVE;
}
if ( dwBindFlagProp & DB_BINDFLAGS_OUTPUT ) {
dwBindFlags |= DBBINDURLFLAG_OUTPUT;
}
dwResult |= dwBindFlagProp | dwBindFlags;
}
error:
for (i = 0; i < cPropertySets; i++)
{
for (j = 0; j < prgPropertySets[i].cProperties; j++)
{
DBPROP *pProp = &(prgPropertySets[i].rgProperties[j]);
ADsAssert(pProp);
FreeDBID(&pProp->colid);
VariantClear(&pProp->vValue);
}
CoTaskMemFree(prgPropertySets[i].rgProperties);
}
CoTaskMemFree(prgPropertySets);
RRETURN ( dwResult );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::BindToDataSource
//
// Synopsis: Initializes the DataSource object if necessary, Sets
// DBPROP_INIT_PROVIDERSTRING property and returns the requested
// interface on the datasource.
//
//----------------------------------------------------------------------------
HRESULT
CSessionObject::BindToDataSource(
IUnknown *pUnkOuter,
LPCOLESTR pwszURL,
IAuthenticate *pAuthenticate,
DWORD dwBindFlags,
REFIID riid,
IUnknown** ppUnk
)
{
HRESULT hr = S_OK;
auto_rel<IDBProperties> pDBProperties;
DBPROP props[1];
DBPROPSET rgPropertySets[1];
CComBSTR bstrURL(pwszURL);
//Initialize DBPROP_INIT_PROVIDERSTRING only if the
//URL is absolute.
if (bIsAbsoluteURL (pwszURL))
{
// Check if the datasource has already been initialized.
if (_pDSO->IsInitialized())
BAIL_ON_FAILURE(hr = DB_E_ALREADYINITIALIZED);
props[0].dwPropertyID = DBPROP_INIT_PROVIDERSTRING;
props[0].dwOptions = DBPROPOPTIONS_OPTIONAL;
props[0].vValue.vt = VT_BSTR;
props[0].vValue.bstrVal = (PWCHAR)bstrURL;
rgPropertySets[0].rgProperties = props;
rgPropertySets[0].cProperties = 1;
rgPropertySets[0].guidPropertySet = DBPROPSET_DBINIT;
hr = GetDataSource(
__uuidof(IDBProperties),
(IUnknown **)&pDBProperties
);
BAIL_ON_FAILURE(hr);
hr = pDBProperties->SetProperties(1, rgPropertySets);
BAIL_ON_FAILURE(hr);
}
// If consumer doesn't specify DBBINDURLFLAG_WAITFORINIT, it
// means consumer wants an initialized DSO
//
if (! (dwBindFlags & DBBINDURLFLAG_WAITFORINIT))
{
auto_rel<IDBInitialize> pDBInitialize;
hr = GetDataSource(__uuidof(IDBInitialize), (IUnknown **)&pDBInitialize);
BAIL_ON_FAILURE(hr);
hr = pDBInitialize->Initialize();
BAIL_ON_FAILURE(hr);
}
//Return the requested interface on the DSO.
hr = GetDataSource(riid, ppUnk);
BAIL_ON_FAILURE(hr);
error:
RRETURN ( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::BuildAbsoluteURL
//
// Synopsis: Given a relative URL, builds absolute URL using the relative URL
// and the property DBPROP_INIT_PROVIDERSTRING.
//
//----------------------------------------------------------------------------
HRESULT
CSessionObject::BuildAbsoluteURL(
CComBSTR bstrLeaf,
CComBSTR& bstrAbsoluteURL
)
{
HRESULT hr = S_OK;
auto_rel<IDBProperties> pDBProp;
auto_rel<IADsPathname> pPathParent;
auto_rel<IADsPathname> pPathLeaf;
ULONG cPropertySets = 0;
long i, j, cElements = 0;
CComBSTR bstrParent;
DBPROPSET* prgPropertySets = NULL;
DBPROPID propids[1];
DBPROPIDSET rgPropertyIDSets[1];
hr = GetDataSource(__uuidof(IDBProperties), (IUnknown **)&pDBProp);
BAIL_ON_FAILURE(hr);
propids[0] = DBPROP_INIT_PROVIDERSTRING;
rgPropertyIDSets[0].rgPropertyIDs = propids;
rgPropertyIDSets[0].cPropertyIDs = 1;
rgPropertyIDSets[0].guidPropertySet = DBPROPSET_DBINIT;
hr = pDBProp->GetProperties(
1,
rgPropertyIDSets,
&cPropertySets,
&prgPropertySets);
if (SUCCEEDED(hr) && cPropertySets == 1)
{
ADsAssert(prgPropertySets != NULL);
ADsAssert(prgPropertySets[0].rgProperties != NULL);
DBPROP* pProp = & (prgPropertySets[0].rgProperties[0]);
bstrParent = pProp->vValue.bstrVal;
}
// Build Absolute Path from Parent and leaf.
hr = CPathname::CreatePathname(
__uuidof(IADsPathname),
(void **)&pPathParent
);
BAIL_ON_FAILURE(hr);
hr = pPathParent->Set(bstrParent, ADS_SETTYPE_FULL);
BAIL_ON_FAILURE(hr);
if (bstrLeaf.Length() > 0)
{
hr = CPathname::CreatePathname(
__uuidof(IADsPathname),
(void **)&pPathLeaf
);
BAIL_ON_FAILURE(hr);
hr = pPathLeaf->Set(bstrLeaf, ADS_SETTYPE_DN);
BAIL_ON_FAILURE(hr);
hr = pPathLeaf->GetNumElements(&cElements);
BAIL_ON_FAILURE(hr);
//Add leaf elements in reverse order.
//Ex: if bstrLeaf = "CN=Administrator,CN=Users",
//we add CN=Users first.
for (i = cElements-1; i >= 0; i--)
{
CComBSTR bstrElement;
hr = pPathLeaf->GetElement(i, &bstrElement);
BAIL_ON_FAILURE(hr);
hr = pPathParent->AddLeafElement(bstrElement);
BAIL_ON_FAILURE(hr);
}
}
//Read back the fully built path name
hr = pPathParent->Retrieve(ADS_FORMAT_X500, &bstrAbsoluteURL);
BAIL_ON_FAILURE(hr);
error:
// 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);
}
CoTaskMemFree(prgPropertySets[i].rgProperties);
}
CoTaskMemFree(prgPropertySets);
RRETURN(hr);
}
extern PROUTER_ENTRY g_pRouterHead;
extern CRITICAL_SECTION g_csRouterHeadCritSect;
//+---------------------------------------------------------------------------
//
// Function: CSessionObject::bIsAbsoluteURL
//
// Synopsis: If the given URL starts with any of the ADS provider prefixes,
// returns true. Returns false otherwise.
//
//----------------------------------------------------------------------------
bool
CSessionObject::bIsAbsoluteURL( LPCOLESTR pwszURL)
{
if (pwszURL == NULL)
return false;
//
// Make sure the router has been initialized
//
EnterCriticalSection(&g_csRouterHeadCritSect);
if (!g_pRouterHead) {
g_pRouterHead = InitializeRouter();
}
LeaveCriticalSection(&g_csRouterHeadCritSect);
for (PROUTER_ENTRY pProvider = g_pRouterHead;
pProvider != NULL;
pProvider = pProvider->pNext)
{
if (pProvider->szProviderProgId == NULL)
continue;
size_t strSize = wcslen(pProvider->szProviderProgId);
if ( _wcsnicmp(pwszURL, pProvider->szProviderProgId, strSize) == 0 )
return true;
}
// Given URL doesn't start with any of the ADSI provider prefixes.
return false;
}
#endif
//-----------------------------------------------------------------------------
// SetSearchPrefs
//
// Sets ADSI search preferences on the property object.
//
//-----------------------------------------------------------------------------
STDMETHODIMP
CSessionObject::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 );
}