You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
520 lines
10 KiB
520 lines
10 KiB
//+--------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 1999
|
|
//
|
|
// File: attrib.cpp
|
|
//
|
|
// Contents: Cert Server Database interface implementation
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
#include <pch.cpp>
|
|
|
|
#pragma hdrstop
|
|
|
|
#include <certdb.h>
|
|
#include "csdisp.h"
|
|
#include "column.h"
|
|
#include "attrib.h"
|
|
#include "ext.h"
|
|
#include "row.h"
|
|
#include "view.h"
|
|
|
|
#define __dwFILE__ __dwFILE_CERTVIEW_ATTRIB_CPP__
|
|
|
|
|
|
#if DBG_CERTSRV
|
|
LONG g_cCertViewAttribute;
|
|
LONG g_cCertViewAttributeTotal;
|
|
#endif
|
|
|
|
CEnumCERTVIEWATTRIBUTE::CEnumCERTVIEWATTRIBUTE()
|
|
{
|
|
DBGCODE(InterlockedIncrement(&g_cCertViewAttribute));
|
|
DBGCODE(InterlockedIncrement(&g_cCertViewAttributeTotal));
|
|
m_pvw = NULL;
|
|
m_aelt = NULL;
|
|
m_cRef = 1;
|
|
}
|
|
|
|
|
|
CEnumCERTVIEWATTRIBUTE::~CEnumCERTVIEWATTRIBUTE()
|
|
{
|
|
DBGCODE(InterlockedDecrement(&g_cCertViewAttribute));
|
|
|
|
#if DBG_CERTSRV
|
|
if (m_cRef > 1)
|
|
{
|
|
DBGPRINT((
|
|
DBG_SS_CERTVIEWI,
|
|
"%hs has %d instances left over\n",
|
|
"CEnumCERTVIEWATTRIBUTE",
|
|
m_cRef));
|
|
}
|
|
#endif
|
|
|
|
if (NULL != m_aelt)
|
|
{
|
|
LocalFree(m_aelt);
|
|
m_aelt = NULL;
|
|
}
|
|
if (NULL != m_pvw)
|
|
{
|
|
m_pvw->Release();
|
|
m_pvw = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CEnumCERTVIEWATTRIBUTE::Open(
|
|
IN LONG RowId,
|
|
IN LONG Flags,
|
|
IN ICertView *pvw)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (NULL == pvw)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
m_RowId = RowId;
|
|
m_Flags = Flags;
|
|
m_pvw = pvw;
|
|
m_pvw->AddRef();
|
|
|
|
if (0 != Flags)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
_JumpError(hr, error, "Flags");
|
|
}
|
|
hr = Reset();
|
|
_JumpIfError2(hr, error, "Reset", S_FALSE);
|
|
|
|
error:
|
|
return(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::Next(
|
|
/* [out, retval] */ LONG *pIndex)
|
|
{
|
|
HRESULT hr;
|
|
DWORD celt;
|
|
CERTTRANSBLOB ctbAttributes;
|
|
|
|
ctbAttributes.pb = NULL;
|
|
if (NULL == pIndex)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
*pIndex = -1;
|
|
if (m_ieltCurrent + 1 >= m_celtCurrent && !m_fNoMore)
|
|
{
|
|
hr = ((CCertView *) m_pvw)->EnumAttributesOrExtensions(
|
|
m_RowId,
|
|
CDBENUM_ATTRIBUTES,
|
|
NULL == m_aelt?
|
|
NULL :
|
|
m_aelt[m_ieltCurrent].pwszName,
|
|
CEXT_CHUNK,
|
|
&celt,
|
|
&ctbAttributes);
|
|
if (S_FALSE == hr)
|
|
{
|
|
m_fNoMore = TRUE;
|
|
}
|
|
else
|
|
{
|
|
_JumpIfError(hr, error, "EnumAttributesOrExtensions");
|
|
}
|
|
hr = _SaveAttributes(celt, &ctbAttributes);
|
|
_JumpIfError(hr, error, "_SaveAttributes");
|
|
|
|
m_ieltCurrent = -1;
|
|
m_celtCurrent = celt;
|
|
}
|
|
if (m_ieltCurrent + 1 >= m_celtCurrent)
|
|
{
|
|
hr = S_FALSE;
|
|
goto error;
|
|
}
|
|
m_ielt++;
|
|
m_ieltCurrent++;
|
|
*pIndex = m_ielt;
|
|
m_fNoCurrentRecord = FALSE;
|
|
hr = S_OK;
|
|
|
|
error:
|
|
if (NULL != ctbAttributes.pb)
|
|
{
|
|
CoTaskMemFree(ctbAttributes.pb);
|
|
}
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::Next"));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CEnumCERTVIEWATTRIBUTE::_SaveAttributes(
|
|
IN DWORD celt,
|
|
IN CERTTRANSBLOB const *pctbAttributes)
|
|
{
|
|
HRESULT hr;
|
|
DWORD cbNew;
|
|
CERTDBATTRIBUTE *peltNew = NULL;
|
|
CERTDBATTRIBUTE *pelt;
|
|
CERTTRANSDBATTRIBUTE *ptelt;
|
|
CERTTRANSDBATTRIBUTE *pteltEnd;
|
|
BYTE *pbNext;
|
|
BYTE *pbEnd;
|
|
|
|
if (NULL == pctbAttributes)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
cbNew = pctbAttributes->cb + celt * (sizeof(*pelt) - sizeof(*ptelt));
|
|
peltNew = (CERTDBATTRIBUTE *) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, cbNew);
|
|
if (NULL == peltNew)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
_JumpError(hr, error, "LocalAlloc");
|
|
}
|
|
|
|
pteltEnd = &((CERTTRANSDBATTRIBUTE *) pctbAttributes->pb)[celt];
|
|
if ((BYTE *) pteltEnd > &pctbAttributes->pb[pctbAttributes->cb])
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
|
_JumpError(hr, error, "bad marshalled data");
|
|
}
|
|
pelt = peltNew;
|
|
pbNext = (BYTE *) &peltNew[celt];
|
|
pbEnd = (BYTE *) Add2Ptr(peltNew, cbNew);
|
|
for (ptelt = (CERTTRANSDBATTRIBUTE *) pctbAttributes->pb;
|
|
ptelt < pteltEnd;
|
|
ptelt++, pelt++)
|
|
{
|
|
hr = CopyMarshalledString(
|
|
pctbAttributes,
|
|
ptelt->obwszName,
|
|
pbEnd,
|
|
&pbNext,
|
|
&pelt->pwszName);
|
|
_JumpIfError(hr, error, "CopyMarshalledString");
|
|
|
|
hr = CopyMarshalledString(
|
|
pctbAttributes,
|
|
ptelt->obwszValue,
|
|
pbEnd,
|
|
&pbNext,
|
|
&pelt->pwszValue);
|
|
_JumpIfError(hr, error, "CopyMarshalledString");
|
|
}
|
|
CSASSERT(pbNext == (BYTE *) Add2Ptr(peltNew, cbNew));
|
|
|
|
if (NULL != m_aelt)
|
|
{
|
|
LocalFree(m_aelt);
|
|
}
|
|
m_aelt = peltNew;
|
|
peltNew = NULL;
|
|
hr = S_OK;
|
|
|
|
error:
|
|
if (NULL != peltNew)
|
|
{
|
|
LocalFree(peltNew);
|
|
}
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CEnumCERTVIEWATTRIBUTE::_FindAttribute(
|
|
OUT CERTDBATTRIBUTE const **ppcda)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (NULL == ppcda)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
if (NULL == m_aelt)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
_JumpError(hr, error, "NULL m_aelt");
|
|
}
|
|
if (m_fNoCurrentRecord ||
|
|
m_ieltCurrent < 0 ||
|
|
m_ieltCurrent >= m_celtCurrent)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
_JumpError(hr, error, "m_fNoCurrentRecord || m_ieltCurrent");
|
|
}
|
|
*ppcda = &m_aelt[m_ieltCurrent];
|
|
hr = S_OK;
|
|
|
|
error:
|
|
return(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::GetName(
|
|
/* [out, retval] */ BSTR *pstrOut)
|
|
{
|
|
HRESULT hr;
|
|
CERTDBATTRIBUTE const *pcda;
|
|
|
|
if (NULL == pstrOut)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
hr = _FindAttribute(&pcda);
|
|
_JumpIfError(hr, error, "_FindAttribute");
|
|
|
|
if (!ConvertWszToBstr(pstrOut, pcda->pwszName, -1))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
_JumpError(hr, error, "ConvertWszToBstr");
|
|
}
|
|
|
|
error:
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::GetName"));
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::GetValue(
|
|
/* [out, retval] */ BSTR *pstrOut)
|
|
{
|
|
HRESULT hr;
|
|
CERTDBATTRIBUTE const *pcda;
|
|
|
|
if (NULL == pstrOut)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
hr = _FindAttribute(&pcda);
|
|
_JumpIfError(hr, error, "_FindAttribute");
|
|
|
|
if (L'\0' == *pcda->pwszValue)
|
|
{
|
|
hr = CERTSRV_E_PROPERTY_EMPTY;
|
|
_JumpError(hr, error, "NULL value");
|
|
}
|
|
if (!ConvertWszToBstr(pstrOut, pcda->pwszValue, -1))
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
_JumpError(hr, error, "ConvertWszToBstr");
|
|
}
|
|
|
|
error:
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::GetValue"));
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::Skip(
|
|
/* [in] */ LONG celt)
|
|
{
|
|
HRESULT hr;
|
|
LONG ieltnew = m_ielt + celt;
|
|
|
|
if (-1 > ieltnew)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
_JumpError(hr, error, "Skip back to before start");
|
|
}
|
|
m_ielt = ieltnew;
|
|
m_ieltCurrent += celt;
|
|
m_fNoCurrentRecord = TRUE;
|
|
hr = S_OK;
|
|
|
|
error:
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::Skip"));
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::Reset(VOID)
|
|
{
|
|
HRESULT hr;
|
|
DWORD celt;
|
|
CERTTRANSBLOB ctbAttributes;
|
|
|
|
ctbAttributes.pb = NULL;
|
|
m_fNoMore = FALSE;
|
|
|
|
hr = ((CCertView *) m_pvw)->EnumAttributesOrExtensions(
|
|
m_RowId,
|
|
CDBENUM_ATTRIBUTES,
|
|
NULL,
|
|
CEXT_CHUNK,
|
|
&celt,
|
|
&ctbAttributes);
|
|
if (S_FALSE == hr)
|
|
{
|
|
m_fNoMore = TRUE;
|
|
}
|
|
else
|
|
{
|
|
_JumpIfError(hr, error, "EnumAttributesOrExtensions");
|
|
}
|
|
|
|
hr = _SaveAttributes(celt, &ctbAttributes);
|
|
_JumpIfError(hr, error, "_SaveAttributes");
|
|
|
|
m_ielt = -1;
|
|
m_ieltCurrent = -1;
|
|
m_celtCurrent = celt;
|
|
m_fNoCurrentRecord = TRUE;
|
|
|
|
error:
|
|
if (NULL != ctbAttributes.pb)
|
|
{
|
|
CoTaskMemFree(ctbAttributes.pb);
|
|
}
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::Reset"));
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::Clone(
|
|
/* [out] */ IEnumCERTVIEWATTRIBUTE **ppenum)
|
|
{
|
|
HRESULT hr;
|
|
IEnumCERTVIEWATTRIBUTE *penum = NULL;
|
|
|
|
if (NULL == ppenum)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
*ppenum = NULL;
|
|
|
|
penum = new CEnumCERTVIEWATTRIBUTE;
|
|
if (NULL == penum)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
_JumpError(hr, error, "new CEnumCERTVIEWATTRIBUTE");
|
|
}
|
|
|
|
hr = ((CEnumCERTVIEWATTRIBUTE *) penum)->Open(m_RowId, m_Flags, m_pvw);
|
|
_JumpIfError(hr, error, "Open");
|
|
|
|
if (-1 != m_ielt)
|
|
{
|
|
hr = penum->Skip(m_ielt);
|
|
_JumpIfError(hr, error, "Skip");
|
|
|
|
if (!m_fNoCurrentRecord)
|
|
{
|
|
LONG Index;
|
|
|
|
hr = penum->Next(&Index);
|
|
_JumpIfError(hr, error, "Next");
|
|
|
|
CSASSERT(Index == m_ielt);
|
|
}
|
|
}
|
|
*ppenum = penum;
|
|
penum = NULL;
|
|
hr = S_OK;
|
|
|
|
error:
|
|
if (NULL != penum)
|
|
{
|
|
penum->Release();
|
|
}
|
|
return(_SetErrorInfo(hr, L"CEnumCERTVIEWATTRIBUTE::Clone"));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CEnumCERTVIEWATTRIBUTE::_SetErrorInfo(
|
|
IN HRESULT hrError,
|
|
IN WCHAR const *pwszDescription)
|
|
{
|
|
CSASSERT(FAILED(hrError) || S_OK == hrError || S_FALSE == hrError);
|
|
if (FAILED(hrError))
|
|
{
|
|
HRESULT hr;
|
|
|
|
hr = DispatchSetErrorInfo(
|
|
hrError,
|
|
pwszDescription,
|
|
wszCLASS_CERTVIEW L".CEnumCERTVIEWATTRIBUTE",
|
|
&IID_IEnumCERTVIEWATTRIBUTE);
|
|
CSASSERT(hr == hrError);
|
|
}
|
|
return(hrError);
|
|
}
|
|
|
|
|
|
#if 1
|
|
// IUnknown implementation
|
|
STDMETHODIMP
|
|
CEnumCERTVIEWATTRIBUTE::QueryInterface(
|
|
const IID& iid,
|
|
void **ppv)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (NULL == ppv)
|
|
{
|
|
hr = E_POINTER;
|
|
_JumpError(hr, error, "NULL parm");
|
|
}
|
|
if (iid == IID_IUnknown)
|
|
{
|
|
*ppv = static_cast<IEnumCERTVIEWATTRIBUTE *>(this);
|
|
}
|
|
else if (iid == IID_IDispatch)
|
|
{
|
|
*ppv = static_cast<IEnumCERTVIEWATTRIBUTE *>(this);
|
|
}
|
|
else if (iid == IID_IEnumCERTVIEWATTRIBUTE)
|
|
{
|
|
*ppv = static_cast<IEnumCERTVIEWATTRIBUTE *>(this);
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
hr = E_NOINTERFACE;
|
|
_JumpError(hr, error, "IID");
|
|
}
|
|
reinterpret_cast<IUnknown *>(*ppv)->AddRef();
|
|
hr = S_OK;
|
|
|
|
error:
|
|
return(hr);
|
|
}
|
|
|
|
|
|
ULONG STDMETHODCALLTYPE
|
|
CEnumCERTVIEWATTRIBUTE::AddRef()
|
|
{
|
|
return(InterlockedIncrement(&m_cRef));
|
|
}
|
|
|
|
|
|
ULONG STDMETHODCALLTYPE
|
|
CEnumCERTVIEWATTRIBUTE::Release()
|
|
{
|
|
ULONG cRef = InterlockedDecrement(&m_cRef);
|
|
|
|
if (0 == cRef)
|
|
{
|
|
delete this;
|
|
}
|
|
return(cRef);
|
|
}
|
|
#endif
|