able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/router/crowprov.cxx

1351 lines
37 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//-----------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995.
//
// File: crowprov.cxx
//
// Contents: IProvider implementation for ADSI rowsets
//
// Functions:
//
// Notes:
//
//
// History: 07/10/96 | RenatoB | Created, lifted most from EricJ code
//-----------------------------------------------------------------------------
// Includes
#include "oleds.hxx"
HRESULT
PackLargeInteger(
LARGE_INTEGER *plargeint,
PVARIANT pVarDestObject
);
HRESULT
PackDNWithBinary(
PADS_DN_WITH_BINARY pDNWithBinary,
PVARIANT pVarDestObject
);
HRESULT
PackDNWithString(
PADS_DN_WITH_STRING pDNWithString,
PVARIANT pVarDestObject
);
//+---------------------------------------------------------------------------
//
// Function: CreateRowProvider
//
// Synopsis: @mfunc Creates and initializes a Row provider .
//
//----------------------------------------------------------------------------
HRESULT
CRowProvider::CreateRowProvider(
IDirectorySearch * pDSSearch,
LPWSTR pszFilter,
LPWSTR * ppszAttrs,
DWORD cAttrs,
DBORDINAL cColumns, // count of the rowset's columns
DBCOLUMNINFO * rgInfo, // array of cColumns DBCOLUMNINFO's
OLECHAR* pStringsBuffer, // the names of the columns are here
REFIID riid,
BOOL * pMultiValued,
BOOL fADSPathPresent,
CCredentials * pCredentials,
void ** ppvObj // the created Row provider
)
{
HRESULT hr;
CRowProvider * pRowProvider = NULL;
if( ppvObj )
*ppvObj = NULL;
else
BAIL_ON_FAILURE( hr = E_INVALIDARG );
pRowProvider = new CRowProvider();
if( pRowProvider == NULL )
BAIL_ON_FAILURE( hr = E_OUTOFMEMORY );
//
//initialize rowprovider with the search filter and the columnsinfo
//
hr = pRowProvider->FInit(
pDSSearch,
pszFilter,
ppszAttrs,
cAttrs,
cColumns,
rgInfo,
pStringsBuffer,
pMultiValued,
fADSPathPresent,
pCredentials
);
if( FAILED(hr) ) {
delete pRowProvider;
BAIL_ON_FAILURE( hr );
}
//
// This interface pointer is embedded in the pRowProvider.
//
pDSSearch = NULL;
hr = pRowProvider->QueryInterface( riid, ppvObj);
if( FAILED(hr) ) {
delete pRowProvider;
BAIL_ON_FAILURE( hr );
}
pRowProvider->Release();
RRETURN( S_OK );
error:
if( pDSSearch )
pDSSearch->Release();
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::CRowProvider
//
//----------------------------------------------------------------------------
CRowProvider::CRowProvider()
:
_pMalloc (NULL),
_cColumns (0),
_ColInfo (NULL),
_pwchBuf (NULL),
_hSearchHandle (NULL),
_pdbSearchCol (NULL),
_pDSSearch (NULL),
_pMultiValued (NULL),
_fADSPathPresent (FALSE),
_iAdsPathIndex (0),
_pCredentials (NULL)
{
}
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::~CRowProvider
//
//----------------------------------------------------------------------------
CRowProvider::~CRowProvider()
{
ULONG i;
if( _hSearchHandle != NULL )
_pDSSearch->CloseSearchHandle(_hSearchHandle);
if( _pDSSearch != NULL )
_pDSSearch->Release();
// Release the memory allocated for columns and ColumnsInfo
if (_pMalloc != NULL) {
if( _pdbSearchCol != NULL ) {
_pMalloc->Free((void*)_pdbSearchCol);
}
if( _ColInfo != NULL )
_pMalloc->Free(_ColInfo);
if( _pwchBuf != NULL )
_pMalloc->Free(_pwchBuf);
_pMalloc->Release();
}
if( _pMultiValued ) {
FreeADsMem(_pMultiValued);
}
if( _pCredentials )
delete _pCredentials;
};
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::Finit
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::FInit(
IDirectorySearch * pDSSearch,
LPWSTR pszFilter,
LPWSTR * ppszAttrs,
DWORD cAttrs,
DBORDINAL cColumns,
DBCOLUMNINFO * rgInfo,
OLECHAR * pStringsBuffer,
BOOL * pMultiValued,
BOOL fADSPathPresent,
CCredentials * pCredentials)
{
HRESULT hr;
ULONG i;
ULONG cChars, cCharDispl;
//
// Asserts
//
ADsAssert(cColumns);
ADsAssert(rgInfo);
ADsAssert(pDSSearch);
_cColumns= cColumns;
hr = CoGetMalloc(MEMCTX_TASK, &_pMalloc);
BAIL_ON_FAILURE( hr );
_ColInfo = (DBCOLUMNINFO*)_pMalloc->Alloc((size_t)(cColumns *sizeof(DBCOLUMNINFO)));
if( _ColInfo == NULL )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
memcpy(_ColInfo, rgInfo, (size_t)(cColumns * sizeof(DBCOLUMNINFO)));
cChars = _pMalloc->GetSize(pStringsBuffer);
_pwchBuf = (WCHAR*)_pMalloc->Alloc(cChars);
if( _pwchBuf == NULL )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
memcpy(_pwchBuf, (void*)pStringsBuffer , cChars);
for (i=0; i<_cColumns; i++) {
if( rgInfo[i].pwszName ) {
cCharDispl = (ULONG)(rgInfo[i].pwszName - pStringsBuffer);
_ColInfo[i].pwszName = _pwchBuf + cCharDispl;
_ColInfo[i].columnid.uName.pwszName = _pwchBuf + cCharDispl;
}
}
// We have adspath at the end of the attribute list.
_fADSPathPresent = fADSPathPresent ;
//Store credentials if non-NULL.
if( pCredentials ) {
//We don't expect that _pCredentials is already non-NULL
ADsAssert(_pCredentials == NULL);
_pCredentials = new CCredentials(*pCredentials);
if( !_pCredentials )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
}
if( _fADSPathPresent == FALSE )
cAttrs++;
//
// Create _pdbSearchCol, a member containing an array
// of DB_SEARCH_COLUMN.
// Reason for this is that trowset.cpp sometimes asks
// for GetColumn twice: one to get the size of the column
// and one to get the data.
// Since OLEDP copies data, we do not want to have two copies
// around
//
_pdbSearchCol = (PDB_SEARCH_COLUMN)_pMalloc->Alloc((ULONG)((cColumns + 1)*sizeof(DB_SEARCH_COLUMN)));
if( _pdbSearchCol == NULL ) {
hr = E_OUTOFMEMORY;
goto error;
}
_pDSSearch = pDSSearch;
hr = _pDSSearch->ExecuteSearch(
pszFilter,
ppszAttrs,
cAttrs,
&_hSearchHandle
);
BAIL_ON_FAILURE( hr );
_pMultiValued = pMultiValued;
RRETURN( hr );
error:
if( _pMalloc != NULL ) {
if( _pdbSearchCol != NULL ) {
_pMalloc->Free((void*)_pdbSearchCol);
_pdbSearchCol= NULL;
};
if( _ColInfo != NULL ) {
_pMalloc->Free(_ColInfo);
_ColInfo = NULL;
}
if( _pwchBuf != NULL ) {
_pMalloc->Free(_pwchBuf);
_pwchBuf = NULL;
}
_pMalloc->Release();
_pMalloc = NULL;
};
if (_hSearchHandle != NULL)
_pDSSearch->CloseSearchHandle(_hSearchHandle);
_hSearchHandle = NULL;
_pDSSearch = NULL;
RRETURN( hr );
}
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::QueryInterface
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::QueryInterface(
REFIID riid,
LPVOID * ppv)
{
if( !ppv )
RRETURN( E_INVALIDARG );
if( riid == IID_IUnknown
|| riid == IID_IRowProvider )
*ppv = (IRowProvider FAR *) this;
else if( riid == IID_IColumnsInfo )
*ppv = (IColumnsInfo FAR *) this;
else {
*ppv = NULL;
return E_NOINTERFACE;
}
AddRef();
RRETURN( S_OK );
}
//-----------------------------------------------------------------------------
//
// Function: CRowProvider::NextRow
//
// Synopsis: Advance to the next row.
//
// Called by: Client.
// Called when: To advance to next row.
// This sets the "current" row.
// Initially the "current" row is prior to the first actual row.
// (Which means This must be called prior to the first GetColumn call.)
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::NextRow()
{
HRESULT hr;
ULONG i;
DWORD dwType, dwExtError = ERROR_SUCCESS;
VARTYPE vType = VT_NULL;
const int ERROR_BUF_SIZE = 512;
const int NAME_BUF_SIZE = 128;
WCHAR ErrorBuf[ERROR_BUF_SIZE];
WCHAR NameBuf[NAME_BUF_SIZE];
do {
// Clear the ADSI extended error, so that after the call to GetNextRow,
// we can safely check if an extended error was set.
ADsSetLastError(ERROR_SUCCESS, NULL, NULL);
dwExtError = ERROR_SUCCESS;
//
// read the next row
//
hr = _pDSSearch->GetNextRow(
_hSearchHandle
);
// we should treat SIZE_LIMIT_EXCEEDED error message as
// S_ADS_NOMORE_ROWS
// in the future, we might want to return this error message
// to the user under non-paged search situation
if (LIMIT_EXCEEDED_ERROR(hr))
hr = S_ADS_NOMORE_ROWS;
BAIL_ON_FAILURE( hr );
if (hr == S_ADS_NOMORE_ROWS)
{
// check if more results are likely (pagedTimeLimit search). If so,
// we will keep trying till a row is obtained.
hr = ADsGetLastError(&dwExtError, ErrorBuf, ERROR_BUF_SIZE,
NameBuf, NAME_BUF_SIZE);
BAIL_ON_FAILURE(hr);
if (dwExtError != ERROR_MORE_DATA)
// we really have no more data
RRETURN(DB_S_ENDOFROWSET);
}
} while(ERROR_MORE_DATA == dwExtError);
//
//read all the columnsinto _pdbSearchCol leaving the bookmark column
//
for (i=1; i<_cColumns; i++) {
hr = _pDSSearch->GetColumn(
_hSearchHandle,
_ColInfo[i].pwszName,
&(_pdbSearchCol[i].adsColumn)
);
if (FAILED(hr) && hr != E_ADS_COLUMN_NOT_SET)
goto error;
if (hr == E_ADS_COLUMN_NOT_SET ||
_pdbSearchCol[i].adsColumn.dwNumValues == 0) {
_pdbSearchCol[i].dwStatus = DBSTATUS_S_ISNULL;
_pdbSearchCol[i].dwType = DBTYPE_EMPTY;
_pdbSearchCol[i].dwLength = 0;
hr = S_OK;
}
else if (_ColInfo[i].wType == (DBTYPE_VARIANT | DBTYPE_BYREF)) {
_pdbSearchCol[i].dwStatus = DBSTATUS_S_OK;
_pdbSearchCol[i].dwType = _ColInfo[i].wType;
_pdbSearchCol[i].dwLength = sizeof(VARIANT);
}
else if ((ULONG) _pdbSearchCol[i].adsColumn.dwADsType >= g_cMapADsTypeToDBType ||
g_MapADsTypeToDBType[_pdbSearchCol[i].adsColumn.dwADsType].wType == DBTYPE_NULL) {
_pdbSearchCol[i].dwStatus = DBSTATUS_E_CANTCONVERTVALUE;
_pdbSearchCol[i].dwType = DBTYPE_EMPTY;
_pdbSearchCol[i].dwLength = 0;
}
else {
_pdbSearchCol[i].dwStatus = DBSTATUS_S_OK;
_pdbSearchCol[i].dwType = g_MapADsTypeToDBType[_pdbSearchCol[i].adsColumn.dwADsType].wType;
switch (_pdbSearchCol[i].dwType & ~DBTYPE_BYREF) {
case DBTYPE_WSTR:
_pdbSearchCol[i].dwLength =
(wcslen( _pdbSearchCol[i].adsColumn.pADsValues[0].CaseIgnoreString)) *
sizeof (WCHAR);
break;
case DBTYPE_BYTES:
if(_pdbSearchCol[i].adsColumn.dwADsType == ADSTYPE_OCTET_STRING)
_pdbSearchCol[i].dwLength =
_pdbSearchCol[i].adsColumn.pADsValues[0].OctetString.dwLength;
else if(_pdbSearchCol[i].adsColumn.dwADsType ==
ADSTYPE_NT_SECURITY_DESCRIPTOR)
_pdbSearchCol[i].dwLength =
_pdbSearchCol[i].adsColumn.pADsValues[0].SecurityDescriptor.dwLength;
else if(_pdbSearchCol[i].adsColumn.dwADsType ==
ADSTYPE_PROV_SPECIFIC)
_pdbSearchCol[i].dwLength =
_pdbSearchCol[i].adsColumn.pADsValues[0].ProviderSpecific.dwLength;
break;
default:
_pdbSearchCol[i].dwLength = g_MapADsTypeToDBType[_pdbSearchCol[i].adsColumn.dwADsType].ulSize;
}
}
}
if ((FALSE == _fADSPathPresent))
{
hr = _pDSSearch->GetColumn(
_hSearchHandle,
L"AdsPath",
&(_pdbSearchCol[i].adsColumn)
);
if FAILED(hr)
goto error;
}
RRETURN(hr);
error:
RRETURN(hr);
}
//-----------------------------------------------------------------------------
//
// Function: CRowProvider::GetColumn
//
// Synopsis: @mfunc Get a column value.
//
// We only provide a ptr to the value -- retained in our memory
// space.
//
// Called by: Client.
// Called when: After NextRow, once for each column.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::GetColumn(
ULONG iCol,
DBSTATUS *pdbStatus,
ULONG *pdwLength,
BYTE *pbData
)
{
DBTYPE columnType = 0;
DBSTATUS dbStatus_temp = 0;
BOOL is_Ref = FALSE;
HRESULT hr = S_OK;
ADsAssert( 1 <= iCol && iCol <= _cColumns );
//
// Note that the caller gives us a ptr to where to put the data.
// We can fill in dwStatus, dwLength.
// For pbData, we assume this is a ptr to where we are to write our ptr.
//
columnType = _ColInfo[iCol].wType;
if ((columnType & DBTYPE_ARRAY) || (columnType & DBTYPE_VECTOR) ) {
if (pdbStatus != NULL)
*pdbStatus= DBSTATUS_E_UNAVAILABLE;
if (pdwLength != NULL)
*pdwLength = 0;
RRETURN(DB_S_ERRORSOCCURRED);
}
if (pdwLength!= NULL)
*pdwLength = _pdbSearchCol[iCol].dwLength;
dbStatus_temp = _pdbSearchCol[iCol].dwStatus;
if (columnType & DBTYPE_BYREF)
is_Ref = TRUE;
columnType &= (~DBTYPE_BYREF);
if (pbData != NULL && dbStatus_temp == DBSTATUS_S_OK) {
switch (columnType) {
case DBTYPE_BOOL:
* (VARIANT_BOOL*) pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].Boolean ?
VARIANT_TRUE: VARIANT_FALSE;
break;
case DBTYPE_I4:
* (DWORD*) pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].Integer;
break;
case DBTYPE_WSTR:
*(WCHAR**)pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].CaseIgnoreString;
break;
case DBTYPE_BYTES:
if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_OCTET_STRING)
*(BYTE**)pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].OctetString.lpValue;
else if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_NT_SECURITY_DESCRIPTOR)
*(BYTE**)pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].SecurityDescriptor.lpValue;
else if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_PROV_SPECIFIC)
*(BYTE**)pbData = _pdbSearchCol[iCol].adsColumn.pADsValues[0].ProviderSpecific.lpValue;
break;
case DBTYPE_DATE:
{
double date = 0;
hr = SystemTimeToVariantTime(
&_pdbSearchCol[iCol].adsColumn.pADsValues[0].UTCTime,
&date);
if( FAILED(hr) )
if (pdbStatus != NULL)
*pdbStatus= DBSTATUS_E_CANTCONVERTVALUE;
BAIL_ON_FAILURE(hr);
*(double*)pbData = date;
break;
}
case DBTYPE_VARIANT:
if (_pMultiValued[iCol] == FALSE) {
PVARIANT pVariant = (PVARIANT) AllocADsMem(sizeof(VARIANT));
if (!pVariant) {
if (pdbStatus != NULL)
*pdbStatus= DBSTATUS_E_CANTCONVERTVALUE;
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_LARGE_INTEGER)
hr = PackLargeInteger(
&_pdbSearchCol[iCol].adsColumn.pADsValues[0].LargeInteger, pVariant);
else if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_DN_WITH_BINARY)
hr = PackDNWithBinary(_pdbSearchCol[iCol].adsColumn.pADsValues[0].pDNWithBinary, pVariant);
else if(_pdbSearchCol[iCol].adsColumn.dwADsType ==
ADSTYPE_DN_WITH_STRING)
hr = PackDNWithString(_pdbSearchCol[iCol].adsColumn.pADsValues[0].pDNWithString, pVariant);
if( FAILED(hr) )
if (pdbStatus != NULL)
*pdbStatus= DBSTATUS_E_CANTCONVERTVALUE;
BAIL_ON_FAILURE(hr);
*((PVARIANT*)pbData) = pVariant;
}
else {
hr = CopyADs2VariantArray(
&_pdbSearchCol[iCol].adsColumn,
(PVARIANT *) pbData
);
if (hr == E_ADS_CANT_CONVERT_DATATYPE) {
dbStatus_temp= DBSTATUS_E_UNAVAILABLE;
break;
}
if( FAILED(hr) )
if (pdbStatus != NULL)
*pdbStatus= DBSTATUS_E_CANTCONVERTVALUE;
BAIL_ON_FAILURE(hr);
}
break;
default:
dbStatus_temp= DBSTATUS_E_UNAVAILABLE;
break;
};
};
if (pdbStatus == 0)
RRETURN(S_OK);
if (pdbStatus != NULL)
*pdbStatus = dbStatus_temp;
if (dbStatus_temp == DBSTATUS_S_OK || dbStatus_temp == DBSTATUS_S_ISNULL)
RRETURN(S_OK);
else
RRETURN(DB_S_ERRORSOCCURRED);
error:
RRETURN(hr);
}
HRESULT CRowProvider::GetIndex(
IColumnsInfo* pColumnsInfo,
LPWSTR lpwszColName,
int& iIndex
)
{
#if (!defined(BUILD_FOR_NT40))
HRESULT hr = S_OK;
int iColumn;
DBCOLUMNINFO* pColumnInfo = NULL;
DBORDINAL cColumns = 0;
OLECHAR* pStringsBuffer = NULL;
iIndex = 0;
hr = pColumnsInfo->GetColumnInfo(&cColumns, &pColumnInfo, &pStringsBuffer);
BAIL_ON_FAILURE(hr);
for(iColumn = 0; iColumn < cColumns; iColumn++)
{
if(pColumnInfo[iColumn].pwszName == NULL || lpwszColName == NULL)
continue;
if(!_wcsicmp(pColumnInfo[iColumn].pwszName, lpwszColName))
{
iIndex = iColumn;
break;
}
}
if (pColumnInfo)
_pMalloc->Free((void*)pColumnInfo);
if (pStringsBuffer)
_pMalloc->Free((void*)pStringsBuffer);
RRETURN(S_OK);
error:
if (pColumnInfo)
_pMalloc->Free((void*)pColumnInfo);
if (pStringsBuffer)
_pMalloc->Free((void*)pStringsBuffer);
RRETURN(hr);
#else
RRETURN(E_FAIL);
#endif
}
STDMETHODIMP CRowProvider::GetURLFromHROW(
HROW hRow,
LPOLESTR *ppwszURL,
IRowset* pRowset
)
{
#if (!defined(BUILD_FOR_NT40))
HRESULT hr = S_OK;
auto_rel<IAccessor> pAccessor;
auto_rel<IColumnsInfo> pColumnsInfo;
HACCESSOR hAccessor = NULL;
DBBINDING Bindings[1];
CComVariant varData;
if ((NULL == hRow) || (NULL == ppwszURL) || (NULL == pRowset))
RRETURN(E_INVALIDARG);
*ppwszURL = NULL;
// If adspath is in the list of columns selected
// return that value.
if (_fADSPathPresent)
{
VariantInit(&varData);
Bindings[0].dwPart = DBPART_VALUE;
Bindings[0].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
Bindings[0].eParamIO = DBPARAMIO_NOTPARAM;
Bindings[0].wType = DBTYPE_VARIANT;
Bindings[0].pTypeInfo = NULL;
Bindings[0].obValue = 0;
Bindings[0].bPrecision = 0;
Bindings[0].bScale = 0;
Bindings[0].cbMaxLen = sizeof(VARIANT);
Bindings[0].pObject = NULL;
Bindings[0].pBindExt = NULL;
Bindings[0].dwFlags = 0;
hr = pRowset->QueryInterface(IID_IAccessor, (void**)&pAccessor);
BAIL_ON_FAILURE(hr);
if (_iAdsPathIndex == 0)
{
hr = pRowset->QueryInterface(__uuidof(IColumnsInfo), (void **)&pColumnsInfo);
BAIL_ON_FAILURE(hr);
hr = GetIndex(pColumnsInfo, L"AdsPath", _iAdsPathIndex);
if (0 == _iAdsPathIndex)
hr = E_UNEXPECTED;
BAIL_ON_FAILURE(hr);
}
Bindings[0].iOrdinal = _iAdsPathIndex;
Bindings[0].obValue = NULL;
hr = pAccessor->CreateAccessor(DBACCESSOR_ROWDATA,sizeof(Bindings)/sizeof(Bindings[0]) , Bindings, 0, &hAccessor, NULL);
BAIL_ON_FAILURE(hr);
hr = pRowset->GetData(hRow, hAccessor, &varData);
BAIL_ON_FAILURE(hr);
ADsAssert(varData.vt == VT_BSTR);
ADsAssert(varData.bstrVal);
// allocate the string and copy data
*ppwszURL = (LPWSTR ) _pMalloc->Alloc(sizeof(WCHAR) * (wcslen(varData.bstrVal) + 1));
if (NULL == *ppwszURL)
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
wcscpy(*ppwszURL, varData.bstrVal);
if (hAccessor)
pAccessor->ReleaseAccessor(hAccessor, NULL);
}
else
{
ADS_CASE_IGNORE_STRING padsPath;
hr = ((CRowset *)pRowset)->GetADsPathFromHROW(hRow, &padsPath);
BAIL_ON_FAILURE(hr);
*ppwszURL = (LPWSTR ) _pMalloc->Alloc(sizeof(WCHAR) *
(wcslen(padsPath) +1));
if (NULL == *ppwszURL)
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
wcscpy(*ppwszURL, padsPath);
}
RRETURN(S_OK);
error:
if (hAccessor)
pAccessor->ReleaseAccessor(hAccessor, NULL);
RRETURN(hr);
#else
RRETURN(E_FAIL);
#endif
}
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::GetColumnInfo
//
// Synopsis: @mfunc Get Column Info.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::GetColumnInfo(
DBORDINAL * pcColumns,
DBCOLUMNINFO ** pprgInfo,
WCHAR ** ppStringsBuffer
)
{
DBORDINAL i;
ULONG cChars, cCharDispl;
HRESULT hr = S_OK;
DBCOLUMNINFO * prgInfo = NULL;
WCHAR * pStrBuffer = NULL;
//
// Asserts
//
ADsAssert(_pMalloc);
ADsAssert(_cColumns);
ADsAssert(_ColInfo);
ADsAssert(_pwchBuf);
if( pcColumns )
*pcColumns = 0;
if( pprgInfo )
*pprgInfo = NULL;
if( ppStringsBuffer )
*ppStringsBuffer = NULL;
if( (pcColumns == NULL) || (pprgInfo == NULL) || (ppStringsBuffer == NULL) )
BAIL_ON_FAILURE( hr=E_INVALIDARG );
prgInfo = (DBCOLUMNINFO*)_pMalloc->Alloc((ULONG)(_cColumns * sizeof(DBCOLUMNINFO)));
if( prgInfo == NULL )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
memcpy(prgInfo, _ColInfo, (size_t)(_cColumns * sizeof(DBCOLUMNINFO)));
cChars = _pMalloc->GetSize(_pwchBuf);
pStrBuffer = (WCHAR*)_pMalloc->Alloc(cChars);
if( pStrBuffer == NULL )
BAIL_ON_FAILURE( hr=E_OUTOFMEMORY );
memcpy(pStrBuffer, (void*)_pwchBuf , cChars);
for (i=1; i<_cColumns; i++) {
cCharDispl = (ULONG)(_ColInfo[i].pwszName - _pwchBuf);
prgInfo[i].pwszName = pStrBuffer + cCharDispl;
prgInfo[i].columnid.uName.pwszName = pStrBuffer + cCharDispl;
};
*pcColumns = _cColumns;
*pprgInfo = prgInfo;
*ppStringsBuffer = pStrBuffer;
RRETURN( S_OK );
error:
if( !prgInfo )
_pMalloc->Free(prgInfo);
if( pStrBuffer != NULL )
_pMalloc->Free(pStrBuffer);
RRETURN( hr );
};
//+---------------------------------------------------------------------------
//
// Function: CRowProvider::MapColumnIDs
//
// Synopsis: @mfunc Map Column IDs.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CRowProvider::MapColumnIDs(
DBORDINAL cColumnIDs,
const DBID rgColumnIDs[],
DBORDINAL rgColumns[]
)
{
ULONG found = 0;
DBORDINAL i;
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;
//
// No-Op if cColumnIDs is 0
//
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 );
//
// Set the columns ordinals to invalid values
//
for (iCol=0; iCol < cColumnIDs; iCol++) {
// Initialize
rgColumns[iCol] = DB_INVALIDCOLUMN;
//
// The columnid with the Bookmark or the same name
//
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 < _cColumns; iOrdinal++) {
if( _ColInfo[iOrdinal].columnid.eKind == DBKIND_NAME &&
!_wcsicmp(_ColInfo[iOrdinal].columnid.uName.pwszName,
rgColumnIDs[iCol].uName.pwszName) ) {
rgColumns[iCol] = iOrdinal;
cValidCols++;
break;
}
}
}
}
if( cValidCols == 0 )
RRETURN( DB_E_ERRORSOCCURRED );
else if( cValidCols < cColumnIDs )
RRETURN( DB_S_ERRORSOCCURRED );
else
RRETURN( S_OK );
}
STDMETHODIMP
CRowProvider::CopyADs2VariantArray(
PADS_SEARCH_COLUMN pADsColumn,
PVARIANT *ppVariant
)
{
SAFEARRAY *aList = NULL;
SAFEARRAYBOUND aBound;
VARTYPE vType = VT_NULL;
HRESULT hr = S_OK;
ULONG i;
PVARIANT pVariant = NULL, pVarArray = NULL;
ADsAssert(ppVariant);
*ppVariant = NULL;
aBound.lLbound = 0;
aBound.cElements = pADsColumn->dwNumValues;
pVariant = (PVARIANT) AllocADsMem(sizeof(VARIANT));
if (!pVariant) {
RRETURN(E_OUTOFMEMORY);
}
if ((ULONG) pADsColumn->dwADsType >= g_cMapADsTypeToVarType ||
(vType = g_MapADsTypeToVarType[pADsColumn->dwADsType]) == VT_NULL) {
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
}
aList = SafeArrayCreate( VT_VARIANT, 1, &aBound );
if (aList == NULL)
BAIL_ON_FAILURE(hr = E_OUTOFMEMORY);
hr = SafeArrayAccessData( aList, (void **) &pVarArray );
if (FAILED(hr)) {
SafeArrayDestroy( aList );
goto error;
}
for (i=0; i<aBound.cElements; i++) {
(V_VT(pVarArray+i)) = vType;
switch (vType) {
case VT_I4:
V_I4(pVarArray+i) = pADsColumn->pADsValues[i].Integer;
break;
case VT_DISPATCH:
if(pADsColumn->dwADsType == ADSTYPE_LARGE_INTEGER)
hr = PackLargeInteger(&pADsColumn->pADsValues[i].LargeInteger,
pVarArray+i);
else if(pADsColumn->dwADsType == ADSTYPE_DN_WITH_BINARY)
hr = PackDNWithBinary(pADsColumn->pADsValues[i].pDNWithBinary,
pVarArray+i);
else if(pADsColumn->dwADsType == ADSTYPE_DN_WITH_STRING)
hr = PackDNWithString(pADsColumn->pADsValues[i].pDNWithString,
pVarArray+i);
BAIL_ON_FAILURE(hr);
break;
case VT_BOOL:
V_I4(pVarArray+i) = pADsColumn->pADsValues[i].Boolean ?
VARIANT_TRUE: VARIANT_FALSE;
break;
case VT_BSTR:
hr = ADsAllocString (
pADsColumn->pADsValues[i].CaseIgnoreString,
&(V_BSTR(pVarArray+i))
);
if (FAILED(hr)) {
SafeArrayUnaccessData( aList );
SafeArrayDestroy( aList );
goto error;
}
break;
case VT_DATE:
{
double date = 0;
hr = SystemTimeToVariantTime(
&pADsColumn->pADsValues[i].UTCTime,
&date);
BAIL_ON_FAILURE(hr);
V_DATE(pVarArray+i)= date;
break;
}
case (VT_UI1 | VT_ARRAY):
VariantInit(pVarArray+i);
if(pADsColumn->dwADsType == ADSTYPE_OCTET_STRING)
hr = BinaryToVariant(
pADsColumn->pADsValues[i].OctetString.dwLength,
pADsColumn->pADsValues[i].OctetString.lpValue,
pVarArray+i);
else if(pADsColumn->dwADsType == ADSTYPE_NT_SECURITY_DESCRIPTOR)
hr = BinaryToVariant(
pADsColumn->pADsValues[i].SecurityDescriptor.dwLength,
pADsColumn->pADsValues[i].SecurityDescriptor.lpValue,
pVarArray+i);
else if(pADsColumn->dwADsType == ADSTYPE_PROV_SPECIFIC)
hr = BinaryToVariant(
pADsColumn->pADsValues[i].ProviderSpecific.dwLength,
pADsColumn->pADsValues[i].ProviderSpecific.lpValue,
pVarArray+i);
BAIL_ON_FAILURE(hr);
break;
default:
SafeArrayUnaccessData( aList );
SafeArrayDestroy( aList );
BAIL_ON_FAILURE(hr = E_ADS_CANT_CONVERT_DATATYPE);
break;
}
}
SafeArrayUnaccessData( aList );
V_VT((PVARIANT)pVariant) = VT_ARRAY | VT_VARIANT;
V_ARRAY((PVARIANT)pVariant) = aList;
*ppVariant = pVariant;
RRETURN(S_OK);
error:
if (pVariant) {
FreeADsMem(pVariant);
}
RRETURN(hr);
}
HRESULT
PackLargeInteger(
LARGE_INTEGER *plargeint,
PVARIANT pVarDestObject
)
{
HRESULT hr = S_OK;
IADsLargeInteger * pLargeInteger = NULL;
IDispatch * pDispatch = NULL;
hr = CoCreateInstance(
CLSID_LargeInteger,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsLargeInteger,
(void **) &pLargeInteger);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->put_LowPart(plargeint->LowPart);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->put_HighPart(plargeint->HighPart);
BAIL_ON_FAILURE(hr);
hr = pLargeInteger->QueryInterface(
IID_IDispatch,
(void **) &pDispatch
);
BAIL_ON_FAILURE(hr);
V_VT(pVarDestObject) = VT_DISPATCH;
V_DISPATCH(pVarDestObject) = pDispatch;
error:
if (pLargeInteger) {
pLargeInteger->Release();
}
RRETURN(hr);
}
HRESULT
PackDNWithBinary(
PADS_DN_WITH_BINARY pDNWithBinary,
PVARIANT pVarDestObject
)
{
HRESULT hr;
IADsDNWithBinary *pIADsDNWithBinary = NULL;
BSTR bstrTemp = NULL;
SAFEARRAYBOUND aBound;
SAFEARRAY *aList = NULL;
CHAR HUGEP *pArray = NULL;
IDispatch *pIDispatch = NULL;
if( (NULL == pDNWithBinary) || (NULL == pVarDestObject) )
BAIL_ON_FAILURE(hr = E_INVALIDARG);
hr = CoCreateInstance(
CLSID_DNWithBinary,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsDNWithBinary,
(void **) &pIADsDNWithBinary
);
BAIL_ON_FAILURE(hr);
if (pDNWithBinary->pszDNString) {
hr = ADsAllocString(pDNWithBinary->pszDNString, &bstrTemp);
BAIL_ON_FAILURE(hr);
//
// Put the value in the object - we can only set BSTR's
//
hr = pIADsDNWithBinary->put_DNString(bstrTemp);
BAIL_ON_FAILURE(hr);
}
aBound.lLbound = 0;
aBound.cElements = pDNWithBinary->dwLength;
aList = SafeArrayCreate( VT_UI1, 1, &aBound );
if ( aList == NULL )
{
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = SafeArrayAccessData( aList, (void HUGEP * FAR *) &pArray );
BAIL_ON_FAILURE(hr);
memcpy( pArray, pDNWithBinary->lpBinaryValue, aBound.cElements );
SafeArrayUnaccessData( aList );
V_VT(pVarDestObject) = VT_ARRAY | VT_UI1;
V_ARRAY(pVarDestObject) = aList;
hr = pIADsDNWithBinary->put_BinaryValue(*pVarDestObject);
VariantClear(pVarDestObject);
BAIL_ON_FAILURE(hr);
hr = pIADsDNWithBinary->QueryInterface(
IID_IDispatch,
(void **) &pIDispatch
);
BAIL_ON_FAILURE(hr);
V_VT(pVarDestObject) = VT_DISPATCH;
V_DISPATCH(pVarDestObject) = pIDispatch;
error:
if(pIADsDNWithBinary)
pIADsDNWithBinary->Release();
if (bstrTemp)
ADsFreeString(bstrTemp);
RRETURN(hr);
}
HRESULT
PackDNWithString(
PADS_DN_WITH_STRING pDNWithString,
PVARIANT pVarDestObject
)
{
HRESULT hr;
IADsDNWithString *pIADsDNWithString = NULL;
BSTR bstrDNVal = NULL;
BSTR bstrStrVal = NULL;
IDispatch *pIDispatch;
if( (NULL == pDNWithString) || (NULL == pVarDestObject) )
BAIL_ON_FAILURE(hr = E_INVALIDARG);
hr = CoCreateInstance(
CLSID_DNWithString,
NULL,
CLSCTX_INPROC_SERVER,
IID_IADsDNWithString,
(void **) &pIADsDNWithString
);
BAIL_ON_FAILURE(hr);
if (pDNWithString->pszDNString) {
hr = ADsAllocString(pDNWithString->pszDNString, &bstrDNVal);
BAIL_ON_FAILURE(hr);
hr = pIADsDNWithString->put_DNString(bstrDNVal);
BAIL_ON_FAILURE(hr);
}
if (pDNWithString->pszStringValue) {
hr = ADsAllocString(
pDNWithString->pszStringValue,
&bstrStrVal
);
BAIL_ON_FAILURE(hr);
hr = pIADsDNWithString->put_StringValue(bstrStrVal);
BAIL_ON_FAILURE(hr);
}
hr = pIADsDNWithString->QueryInterface(
IID_IDispatch,
(void **) &pIDispatch
);
BAIL_ON_FAILURE(hr);
V_VT(pVarDestObject) = VT_DISPATCH;
V_DISPATCH(pVarDestObject) = pIDispatch;
error:
if(pIADsDNWithString)
pIADsDNWithString->Release();
if (bstrDNVal) {
ADsFreeString(bstrDNVal);
}
if (bstrStrVal) {
ADsFreeString(bstrStrVal);
}
RRETURN(hr);
}
HRESULT
CRowProvider::SeekToNextRow(void)
{
HRESULT hr;
DWORD dwExtError = ERROR_SUCCESS;
const int ERROR_BUF_SIZE = 512;
const int NAME_BUF_SIZE = 128;
WCHAR ErrorBuf[ERROR_BUF_SIZE];
WCHAR NameBuf[NAME_BUF_SIZE];
do {
// Clear the ADSI extended error, so that after the call to GetNextRow,
// we can safely check if an extended error was set.
ADsSetLastError(ERROR_SUCCESS, NULL, NULL);
dwExtError = ERROR_SUCCESS;
//
// read the next row
//
hr = _pDSSearch->GetNextRow(
_hSearchHandle
);
// we should treat SIZE_LIMIT_EXCEEDED error message as
// S_ADS_NOMORE_ROWS
// in the future, we might want to return this error message
// to the user under non-paged search situation
if (LIMIT_EXCEEDED_ERROR(hr))
hr = S_ADS_NOMORE_ROWS;
BAIL_ON_FAILURE( hr );
if (hr == S_ADS_NOMORE_ROWS)
{
// check if more results are likely (pagedTimeLimit search). If so,
// we will keep trying till a row is obtained.
hr = ADsGetLastError(&dwExtError, ErrorBuf, ERROR_BUF_SIZE,
NameBuf, NAME_BUF_SIZE);
BAIL_ON_FAILURE(hr);
if (dwExtError != ERROR_MORE_DATA)
// we really have no more data
RRETURN(S_ADS_NOMORE_ROWS);
}
} while(ERROR_MORE_DATA == dwExtError);
error:
RRETURN(hr);
}
HRESULT
CRowProvider::SeekToPreviousRow(void)
{
RRETURN( _pDSSearch->GetPreviousRow(_hSearchHandle) );
}
Reference in a new issue Copy permalink