1407 lines
36 KiB
C++
1407 lines
36 KiB
C++
/*++
|
|
|
|
Copyright (c) 1998-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
path.cxx
|
|
|
|
Abstract:
|
|
|
|
This file contains the PathCracker Functionality
|
|
|
|
Environment:
|
|
|
|
User mode
|
|
|
|
Revision History:
|
|
|
|
12/07/98 -felixw-
|
|
Created it
|
|
|
|
--*/
|
|
#include "oleds.hxx"
|
|
#pragma hdrstop
|
|
|
|
DEFINE_IDispatch_Implementation(CPathname)
|
|
|
|
CPathname::CPathname():
|
|
_pDispMgr(NULL),
|
|
m_pPathnameProvider(NULL),
|
|
_fNamingAttribute(TRUE),
|
|
_dwEscaped(ADS_ESCAPEDMODE_DEFAULT)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Constructor for CPathname
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ENLIST_TRACKING(CPathname);
|
|
memset(&_PathObjectInfo,
|
|
0x0,
|
|
sizeof(PATH_OBJECTINFO));
|
|
_PathObjectInfo.dwPathType = ADS_PATHTYPE_ROOTFIRST;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CPathname::CreatePathname(
|
|
REFIID riid,
|
|
void **ppvObj
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Create the pathname object
|
|
|
|
Arguments:
|
|
|
|
riid - IID to query for
|
|
ppvObj - object to be returned
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
CPathname * pPathname = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
hr = AllocatePathnameObject(&pPathname);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPathname->QueryInterface(riid, ppvObj);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pPathname->Release();
|
|
|
|
RRETURN(hr);
|
|
|
|
error:
|
|
delete pPathname;
|
|
|
|
RRETURN(hr);
|
|
}
|
|
|
|
|
|
CPathname::~CPathname( )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destructor for Pathname object
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
FreePathInfo(&_PathObjectInfo);
|
|
delete _pDispMgr;
|
|
if (m_pPathnameProvider) {
|
|
m_pPathnameProvider->Release();
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CPathname::QueryInterface(
|
|
REFIID iid,
|
|
LPVOID FAR* ppv
|
|
)
|
|
{
|
|
if (ppv == NULL) {
|
|
RRETURN(E_POINTER);
|
|
}
|
|
|
|
if (IsEqualIID(iid, IID_IUnknown))
|
|
{
|
|
*ppv = (IADsPathname *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IADsPathname))
|
|
{
|
|
*ppv = (IADsPathname *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_IDispatch))
|
|
{
|
|
*ppv = (IADsPathname *) this;
|
|
}
|
|
else if (IsEqualIID(iid, IID_ISupportErrorInfo))
|
|
{
|
|
*ppv = (ISupportErrorInfo *) this;
|
|
}
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CPathname::AllocatePathnameObject(
|
|
CPathname ** ppPathname
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocate a pathname object
|
|
|
|
Arguments:
|
|
|
|
ppPathname - constructed object
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
CPathname * pPathname = NULL;
|
|
CDispatchMgr * pDispMgr = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
pPathname = new CPathname();
|
|
if (pPathname == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pDispMgr = new CDispatchMgr;
|
|
if (pDispMgr == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = LoadTypeInfoEntry(
|
|
pDispMgr,
|
|
LIBID_ADs,
|
|
IID_IADsPathname,
|
|
(IADsPathname *)pPathname,
|
|
DISPID_REGULAR
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pPathname->_pDispMgr = pDispMgr;
|
|
|
|
//
|
|
// By default, the pathname is set to the LDAP provider
|
|
//
|
|
hr = ADsGetObject(L"LDAP:",
|
|
IID_IADsPathnameProvider,
|
|
(void**)&(pPathname->m_pPathnameProvider));
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
pPathname->_PathObjectInfo.ProviderName = AllocADsStr(L"LDAP");
|
|
if (pPathname->_PathObjectInfo.ProviderName == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
*ppPathname = pPathname;
|
|
|
|
RRETURN(hr);
|
|
|
|
error:
|
|
|
|
delete pDispMgr;
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
HRESULT
|
|
CPathname::InterfaceSupportsErrorInfo(
|
|
THIS_ REFIID riid
|
|
)
|
|
{
|
|
if (IsEqualIID(riid, IID_IADsPathname)) {
|
|
RRETURN(S_OK);
|
|
} else {
|
|
RRETURN(S_FALSE);
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CPathname::SetAll(
|
|
BSTR bstrADsPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set the internal variables using the full ADSPath
|
|
|
|
Arguments:
|
|
|
|
bstrADsPath - the passed in Full ADSPath
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
//
|
|
// Freeing existing info
|
|
//
|
|
FreePathInfo(&_PathObjectInfo);
|
|
|
|
//
|
|
// Collecting new info
|
|
//
|
|
hr = m_pPathnameProvider->ParsePath(
|
|
bstrADsPath,
|
|
ADS_PARSE_FULL,
|
|
&_PathObjectInfo);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
RRETURN(hr);
|
|
error:
|
|
FreePathInfo(&_PathObjectInfo);
|
|
RRETURN(hr);
|
|
}
|
|
|
|
HRESULT
|
|
CPathname::GetNamespace(
|
|
BSTR bstrADsPath,
|
|
PWSTR *ppszName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get a namespace from a full ADsPath
|
|
|
|
Arguments:
|
|
|
|
bstrADsPath - passed in ADsPath
|
|
ppszName - returned namespace, must be freed by caller
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, E_ADS_BAD_PATHNAME if the path is bad, error code
|
|
otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD dwPath = 0; // Length of namespace
|
|
BOOLEAN fFound = FALSE;
|
|
PWSTR szPath = bstrADsPath;
|
|
HRESULT hr = S_OK;
|
|
|
|
while (*szPath) {
|
|
if (*szPath == ':') {
|
|
dwPath++;
|
|
fFound = TRUE;
|
|
break;
|
|
}
|
|
szPath++;
|
|
dwPath++;
|
|
}
|
|
|
|
if (fFound) {
|
|
*ppszName = (LPWSTR)AllocADsMem(sizeof(WCHAR) * (dwPath + 1));
|
|
if (*ppszName == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
}
|
|
|
|
memcpy(*ppszName, bstrADsPath, (dwPath * sizeof(WCHAR)));
|
|
(*ppszName)[dwPath] = '\0';
|
|
}
|
|
else {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
}
|
|
|
|
error:
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::Set(
|
|
BSTR bstrADsPath,
|
|
long dwSetType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set the path with the type specified
|
|
|
|
Arguments:
|
|
bstrADsPath - the path to be set
|
|
dwSetType - the type :
|
|
ADS_SETTYPE_FULL
|
|
ADS_SETTYPE_PROVIDER
|
|
ADS_SETTYPE_SERVER
|
|
ADS_SETTYPE_DN
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPWSTR szPath = NULL;
|
|
WCHAR szNamespace[MAX_PATH];
|
|
LPWSTR pszName = NULL;
|
|
IADsPathnameProvider *pPathnameProvider = NULL;
|
|
|
|
switch (dwSetType) {
|
|
|
|
case ADS_SETTYPE_FULL:
|
|
if ((bstrADsPath == NULL) || ((*bstrADsPath) == NULL)) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
hr = GetNamespace(bstrADsPath, &pszName);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if ((_PathObjectInfo.ProviderName == NULL) ||
|
|
(wcscmp(_PathObjectInfo.ProviderName, bstrADsPath) != 0)) {
|
|
//
|
|
// If provider not set, or if the provider is different
|
|
// we reset the provider
|
|
//
|
|
pPathnameProvider = NULL;
|
|
hr = ADsGetObject(pszName,
|
|
IID_IADsPathnameProvider,
|
|
(void**)&(pPathnameProvider));
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (pPathnameProvider) {
|
|
if (m_pPathnameProvider) {
|
|
m_pPathnameProvider->Release();
|
|
}
|
|
m_pPathnameProvider = pPathnameProvider;
|
|
}
|
|
}
|
|
|
|
hr = SetAll(bstrADsPath);
|
|
break;
|
|
|
|
case ADS_SETTYPE_PROVIDER:
|
|
|
|
if ((bstrADsPath == NULL) || ((*bstrADsPath) == NULL)) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
//
|
|
// If it is the same as the namespace that is stored inside already,
|
|
// ignore it
|
|
//
|
|
if (_PathObjectInfo.ProviderName &&
|
|
(wcscmp(_PathObjectInfo.ProviderName, bstrADsPath) == 0)) {
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
|
|
wcscpy(szNamespace,bstrADsPath);
|
|
wcscat(szNamespace,L":");
|
|
|
|
pPathnameProvider = NULL;
|
|
hr = ADsGetObject(szNamespace,
|
|
IID_IADsPathnameProvider,
|
|
(void**)&(pPathnameProvider));
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (pPathnameProvider) {
|
|
if (m_pPathnameProvider) {
|
|
m_pPathnameProvider->Release();
|
|
}
|
|
m_pPathnameProvider = pPathnameProvider;
|
|
}
|
|
|
|
|
|
FreePathInfo(&_PathObjectInfo);
|
|
_PathObjectInfo.ProviderName = AllocADsStr(bstrADsPath);
|
|
if (_PathObjectInfo.ProviderName == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADS_SETTYPE_SERVER:
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
if (_PathObjectInfo.ServerName) {
|
|
FreeADsStr( _PathObjectInfo.ServerName);
|
|
_PathObjectInfo.ServerName = NULL;
|
|
}
|
|
if (_PathObjectInfo.DisplayServerName) {
|
|
FreeADsStr( _PathObjectInfo.DisplayServerName);
|
|
_PathObjectInfo.DisplayServerName = NULL;
|
|
}
|
|
|
|
//
|
|
// If the input path is not NULL, we'll set it to the new one. Or
|
|
// else we will just ignore it 'cause it has been set to 0 earlier
|
|
//
|
|
if (bstrADsPath && (*bstrADsPath)) {
|
|
_PathObjectInfo.ServerName = AllocADsStr(bstrADsPath);
|
|
if (_PathObjectInfo.ServerName == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
_PathObjectInfo.DisplayServerName = AllocADsStr(bstrADsPath);
|
|
if (_PathObjectInfo.DisplayServerName == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
hr = S_OK;
|
|
break;
|
|
|
|
case ADS_SETTYPE_DN:
|
|
{
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Free the existing ones first
|
|
//
|
|
FreeObjInfoComponents(&_PathObjectInfo);
|
|
_PathObjectInfo.dwPathType = 0;
|
|
|
|
//
|
|
// If the input path is not NULL, we'll set it to the new one.
|
|
// Or else we will just ignore it 'cause it has been set to 0
|
|
// earlier
|
|
//
|
|
if (bstrADsPath && (*bstrADsPath)) {
|
|
hr = m_pPathnameProvider->ParsePath(
|
|
bstrADsPath,
|
|
ADS_PARSE_DN,
|
|
&_PathObjectInfo);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
error:
|
|
if (pszName) {
|
|
FreeADsStr(pszName);
|
|
}
|
|
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::SetDisplayType(
|
|
long lnSetType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set the Display type of the Pathname object. It can either display the whole
|
|
string cn=xxx or just the value xxx.
|
|
|
|
Arguments:
|
|
|
|
lnSetType - the passed in set type
|
|
ADS_DISPLAY_FULL=1,
|
|
ADS_DISPLAY_VALUE_ONLY=2
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (lnSetType == ADS_DISPLAY_FULL) {
|
|
_fNamingAttribute = TRUE;
|
|
RRETURN (S_OK);
|
|
}
|
|
else if (lnSetType == ADS_DISPLAY_VALUE_ONLY) {
|
|
_fNamingAttribute = FALSE;
|
|
RRETURN (S_OK);
|
|
}
|
|
RRETURN(E_INVALIDARG);
|
|
}
|
|
|
|
|
|
HRESULT CPathname::SetComponent(
|
|
DWORD cComponents,
|
|
BSTR *pbstrElement
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set an individual component in the pathname. For internal use only.
|
|
Not exposed.
|
|
|
|
Arguments:
|
|
|
|
cComponents - the component number to be set
|
|
pbstrElement - the return value
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PWSTR szReturn = NULL;
|
|
PATH_COMPONENT* pComponent = NULL;
|
|
DWORD dwLength = 2; // for null termination and the equal sign
|
|
|
|
if (_dwEscaped == ADS_ESCAPEDMODE_OFF_EX) {
|
|
pComponent = _PathObjectInfo.ProvSpecComponentArray;
|
|
if (pComponent[cComponents].szValue == NULL) {
|
|
pComponent = _PathObjectInfo.ComponentArray;
|
|
}
|
|
}
|
|
else if (_dwEscaped == ADS_ESCAPEDMODE_ON) {
|
|
pComponent = _PathObjectInfo.DisplayComponentArray;
|
|
}
|
|
//
|
|
// Either default or OFF, we do not turn on escaping
|
|
//
|
|
else {
|
|
pComponent = _PathObjectInfo.ComponentArray;
|
|
}
|
|
|
|
//
|
|
// allocate space for szReturn
|
|
//
|
|
if (pComponent[cComponents].szValue) {
|
|
dwLength += wcslen(pComponent[cComponents].szValue);
|
|
}
|
|
if (pComponent[cComponents].szComponent) {
|
|
dwLength += wcslen(pComponent[cComponents].szComponent);
|
|
}
|
|
szReturn = (PWSTR)AllocADsMem(sizeof(WCHAR) * dwLength);
|
|
if (szReturn == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
goto error;
|
|
}
|
|
szReturn[0] = NULL;
|
|
|
|
if (_fNamingAttribute) {
|
|
wcscat(szReturn, pComponent[cComponents].szComponent);
|
|
if (pComponent[cComponents].szValue) {
|
|
wcscat(szReturn,
|
|
TEXT("="));
|
|
wcscat(szReturn,
|
|
pComponent[cComponents].szValue);
|
|
}
|
|
}
|
|
else {
|
|
if (pComponent[cComponents].szValue) {
|
|
//
|
|
// If value exist, only show display value
|
|
//
|
|
wcscat(szReturn,
|
|
pComponent[cComponents].szValue);
|
|
}
|
|
else {
|
|
//
|
|
// else value is only stored in Component
|
|
//
|
|
wcscat(szReturn,
|
|
pComponent[cComponents].szComponent);
|
|
}
|
|
}
|
|
hr = ADsAllocString(szReturn, pbstrElement);
|
|
|
|
error:
|
|
if (szReturn) {
|
|
FreeADsMem(szReturn);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::Retrieve(
|
|
THIS_ long dwFormatType,
|
|
BSTR *pbstrADsPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrive the pathname as different formats
|
|
|
|
Arguments:
|
|
|
|
dwFormatType - the input format type
|
|
pbstrADsPath - the returned path
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!pbstrADsPath) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
switch (dwFormatType) {
|
|
case ADS_FORMAT_SERVER:
|
|
if (!_PathObjectInfo.DisplayServerName) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
hr = ADsAllocString(_PathObjectInfo.DisplayServerName, pbstrADsPath);
|
|
break;
|
|
|
|
case ADS_FORMAT_PROVIDER:
|
|
if (!_PathObjectInfo.ProviderName) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
hr = ADsAllocString(_PathObjectInfo.ProviderName, pbstrADsPath);
|
|
break;
|
|
default:
|
|
//
|
|
DWORD dwFlag = 0;
|
|
if (_fNamingAttribute)
|
|
dwFlag |= ADS_CONSTRUCT_NAMINGATTRIBUTE;
|
|
hr = m_pPathnameProvider->ConstructPath(&_PathObjectInfo,
|
|
dwFormatType,
|
|
dwFlag,
|
|
_dwEscaped,
|
|
pbstrADsPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
error:
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::GetNumElements(
|
|
THIS_ long *pdwNumPathElements
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get the number of elements in the DN
|
|
|
|
Arguments:
|
|
|
|
pdwNumPathElements - the number of elements
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
if (!pdwNumPathElements) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
|
|
*pdwNumPathElements = _PathObjectInfo.NumComponents;
|
|
error:
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::GetElement(
|
|
THIS_ long dwElementIndex,
|
|
BSTR *pbstrElement
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get a particular element using an index
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
if (!pbstrElement) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
|
|
if ((DWORD)dwElementIndex >= _PathObjectInfo.NumComponents) {
|
|
hr = HRESULT_FROM_WIN32(ERROR_INVALID_INDEX);
|
|
goto error;
|
|
}
|
|
if (_PathObjectInfo.dwPathType != ADS_PATHTYPE_LEAFFIRST) {
|
|
dwElementIndex = _PathObjectInfo.NumComponents - 1 - dwElementIndex;
|
|
}
|
|
hr = SetComponent(dwElementIndex,
|
|
pbstrElement);
|
|
error:
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID MoveLastComponentToFront(
|
|
PPATH_OBJECTINFO pObjectInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Move the last component to the front. Used after adding leaf
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD cComponent;
|
|
|
|
ADsAssert(pObjectInfo->NumComponents > 1);
|
|
|
|
LPTSTR szComponentLast =
|
|
pObjectInfo->ComponentArray[pObjectInfo->NumComponents-1].szComponent;
|
|
LPTSTR szValueLast =
|
|
pObjectInfo->ComponentArray[pObjectInfo->NumComponents-1].szValue;
|
|
LPTSTR szDisplayComponentLast =
|
|
pObjectInfo->DisplayComponentArray[pObjectInfo->NumComponents-1].szComponent;
|
|
LPTSTR szDisplayValueLast =
|
|
pObjectInfo->DisplayComponentArray[pObjectInfo->NumComponents-1].szValue;
|
|
LPTSTR szProvSpecComponentLast =
|
|
pObjectInfo->ProvSpecComponentArray[pObjectInfo->NumComponents-1].szComponent;
|
|
LPTSTR szProvSpecValueLast =
|
|
pObjectInfo->ProvSpecComponentArray[pObjectInfo->NumComponents-1].szValue;
|
|
|
|
for (cComponent=pObjectInfo->NumComponents-1;cComponent>=1;cComponent--) {
|
|
pObjectInfo->ComponentArray[cComponent].szComponent =
|
|
pObjectInfo->ComponentArray[cComponent-1].szComponent;
|
|
pObjectInfo->ComponentArray[cComponent].szValue =
|
|
pObjectInfo->ComponentArray[cComponent-1].szValue;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szComponent =
|
|
pObjectInfo->DisplayComponentArray[cComponent-1].szComponent;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szValue =
|
|
pObjectInfo->DisplayComponentArray[cComponent-1].szValue;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szComponent =
|
|
pObjectInfo->ProvSpecComponentArray[cComponent-1].szComponent;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szValue =
|
|
pObjectInfo->ProvSpecComponentArray[cComponent-1].szValue;
|
|
}
|
|
pObjectInfo->ComponentArray[0].szComponent = szComponentLast;
|
|
pObjectInfo->ComponentArray[0].szValue = szValueLast;
|
|
pObjectInfo->DisplayComponentArray[0].szComponent = szDisplayComponentLast;
|
|
pObjectInfo->DisplayComponentArray[0].szValue = szDisplayValueLast;
|
|
pObjectInfo->ProvSpecComponentArray[0].szComponent = szProvSpecComponentLast;
|
|
pObjectInfo->ProvSpecComponentArray[0].szValue = szProvSpecValueLast;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
RemoveFirstElement(
|
|
PPATH_OBJECTINFO pObjectInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Remove first element from the list
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD cComponent;
|
|
|
|
if (pObjectInfo->NumComponents <= 0) {
|
|
RRETURN(E_ADS_BAD_PATHNAME);
|
|
}
|
|
|
|
FreeADsStr(pObjectInfo->ComponentArray[0].szComponent);
|
|
FreeADsStr(pObjectInfo->ComponentArray[0].szValue);
|
|
FreeADsStr(pObjectInfo->DisplayComponentArray[0].szComponent);
|
|
FreeADsStr(pObjectInfo->DisplayComponentArray[0].szValue);
|
|
if (pObjectInfo->ProvSpecComponentArray[0].szComponent)
|
|
FreeADsStr(pObjectInfo->ProvSpecComponentArray[0].szComponent);
|
|
if (pObjectInfo->ProvSpecComponentArray[0].szValue)
|
|
FreeADsStr(pObjectInfo->ProvSpecComponentArray[0].szValue);
|
|
|
|
for (cComponent = 0;cComponent < pObjectInfo->NumComponents - 1;cComponent++) {
|
|
pObjectInfo->ComponentArray[cComponent].szComponent =
|
|
pObjectInfo->ComponentArray[cComponent+1].szComponent;
|
|
pObjectInfo->ComponentArray[cComponent].szValue =
|
|
pObjectInfo->ComponentArray[cComponent+1].szValue;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szComponent =
|
|
pObjectInfo->DisplayComponentArray[cComponent+1].szComponent;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szValue =
|
|
pObjectInfo->DisplayComponentArray[cComponent+1].szValue;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szComponent =
|
|
pObjectInfo->ProvSpecComponentArray[cComponent+1].szComponent;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szValue =
|
|
pObjectInfo->ProvSpecComponentArray[cComponent+1].szValue;
|
|
}
|
|
pObjectInfo->ComponentArray[cComponent].szComponent = NULL;
|
|
pObjectInfo->ComponentArray[cComponent].szValue = NULL;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szComponent = NULL;
|
|
pObjectInfo->DisplayComponentArray[cComponent].szValue = NULL;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szComponent = NULL;
|
|
pObjectInfo->ProvSpecComponentArray[cComponent].szValue = NULL;
|
|
pObjectInfo->NumComponents--;
|
|
|
|
RRETURN(S_OK);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::AddLeafElement(
|
|
THIS_ BSTR bstrLeafElement
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add a leaf element to the DN
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DWORD NumComponents;
|
|
BOOL fStartAllocation = FALSE;
|
|
|
|
PATH_OBJECTINFO ObjectInfoLocal;
|
|
|
|
memset(&ObjectInfoLocal, 0, sizeof(PATH_OBJECTINFO));
|
|
if ((bstrLeafElement == NULL) || ((*bstrLeafElement) == NULL)) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// MAX size limitation exist in parser.cxx, so, it's not
|
|
// worth to implement the inc in size dynamically
|
|
//
|
|
if ((_PathObjectInfo.NumComponents+1) > MAXCOMPONENTS ) {
|
|
hr = E_NOTIMPL;
|
|
goto error;
|
|
}
|
|
|
|
hr = m_pPathnameProvider->ParsePath(
|
|
bstrLeafElement,
|
|
ADS_PARSE_COMPONENT,
|
|
(PPATH_OBJECTINFO)&ObjectInfoLocal
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
NumComponents = _PathObjectInfo.NumComponents;
|
|
fStartAllocation = TRUE;
|
|
|
|
if (ObjectInfoLocal.ComponentArray[0].szComponent) {
|
|
_PathObjectInfo.ComponentArray[NumComponents].szComponent =
|
|
AllocADsStr(ObjectInfoLocal.ComponentArray[0].szComponent);
|
|
if (_PathObjectInfo.ComponentArray[NumComponents].szComponent == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
if (ObjectInfoLocal.ComponentArray[0].szValue) {
|
|
_PathObjectInfo.ComponentArray[NumComponents].szValue =
|
|
AllocADsStr(ObjectInfoLocal.ComponentArray[0].szValue);
|
|
if (_PathObjectInfo.ComponentArray[NumComponents].szValue== NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
if (ObjectInfoLocal.DisplayComponentArray[0].szComponent) {
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent =
|
|
AllocADsStr(ObjectInfoLocal.DisplayComponentArray[0].szComponent);
|
|
if (_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
if (ObjectInfoLocal.DisplayComponentArray[0].szValue) {
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szValue=
|
|
AllocADsStr(ObjectInfoLocal.DisplayComponentArray[0].szValue);
|
|
if (_PathObjectInfo.DisplayComponentArray[NumComponents].szValue== NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
if (ObjectInfoLocal.ProvSpecComponentArray[0].szComponent) {
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent =
|
|
AllocADsStr(ObjectInfoLocal.ProvSpecComponentArray[0].szComponent);
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent == NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
if (ObjectInfoLocal.ProvSpecComponentArray[0].szValue) {
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue =
|
|
AllocADsStr(ObjectInfoLocal.ProvSpecComponentArray[0].szValue);
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue== NULL) {
|
|
hr = E_OUTOFMEMORY;
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
|
|
_PathObjectInfo.NumComponents++;
|
|
|
|
if (_PathObjectInfo.dwPathType == ADS_PATHTYPE_LEAFFIRST) {
|
|
MoveLastComponentToFront(&_PathObjectInfo);
|
|
}
|
|
|
|
FreePathInfo(&ObjectInfoLocal);
|
|
RRETURN(hr);
|
|
error:
|
|
FreePathInfo(&ObjectInfoLocal);
|
|
if (fStartAllocation) {
|
|
if (_PathObjectInfo.ComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(_PathObjectInfo.ComponentArray[NumComponents].szComponent);
|
|
_PathObjectInfo.ComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (_PathObjectInfo.ComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(_PathObjectInfo.ComponentArray[NumComponents].szValue);
|
|
_PathObjectInfo.ComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
if (_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent);
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (_PathObjectInfo.DisplayComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(_PathObjectInfo.DisplayComponentArray[NumComponents].szValue);
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent);
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue);
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
}
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::RemoveLeafElement(void)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Remove the leaf element from the DN
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DWORD NumComponents;
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
if (_PathObjectInfo.dwPathType == ADS_PATHTYPE_LEAFFIRST) {
|
|
hr = RemoveFirstElement(&_PathObjectInfo);
|
|
}
|
|
else {
|
|
if (_PathObjectInfo.NumComponents > 0) {
|
|
_PathObjectInfo.NumComponents--;
|
|
NumComponents = _PathObjectInfo.NumComponents;
|
|
|
|
FreeADsStr(_PathObjectInfo.ComponentArray[NumComponents].szComponent);
|
|
FreeADsStr(_PathObjectInfo.ComponentArray[NumComponents].szValue);
|
|
FreeADsStr(_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent);
|
|
FreeADsStr(_PathObjectInfo.DisplayComponentArray[NumComponents].szValue);
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent)
|
|
FreeADsStr(_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent);
|
|
if (_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue)
|
|
FreeADsStr(_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue);
|
|
|
|
_PathObjectInfo.ComponentArray[NumComponents].szComponent = NULL;
|
|
_PathObjectInfo.ComponentArray[NumComponents].szValue = NULL;
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szComponent = NULL;
|
|
_PathObjectInfo.DisplayComponentArray[NumComponents].szValue = NULL;
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szComponent = NULL;
|
|
_PathObjectInfo.ProvSpecComponentArray[NumComponents].szValue = NULL;
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
error:
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
CPathname::CopyPath(THIS_ IDispatch **ppAdsPath)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copy the pathname object and return a pointer to the new one
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
IADsPathname *pPathname = NULL;
|
|
BSTR bstrResult = NULL;
|
|
DWORD dwLength;
|
|
|
|
long lNameType; // Storage for old values
|
|
DWORD dwEscaped;
|
|
BOOL fValueChanged = FALSE; // indicate whether value has been changed
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
if (!ppAdsPath) {
|
|
hr = E_INVALIDARG;
|
|
goto error;
|
|
}
|
|
|
|
//
|
|
// Storing the old values
|
|
//
|
|
dwEscaped = _dwEscaped;
|
|
if (_fNamingAttribute) {
|
|
lNameType = ADS_DISPLAY_FULL;
|
|
}
|
|
else {
|
|
lNameType = ADS_DISPLAY_VALUE_ONLY;
|
|
}
|
|
|
|
//
|
|
// Setting the type to 'show all' for retrieval
|
|
//
|
|
fValueChanged = TRUE;
|
|
hr = SetDisplayType(ADS_DISPLAY_FULL);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = put_EscapedMode(ADS_ESCAPEDMODE_DEFAULT);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// Retrieve path
|
|
//
|
|
hr = Retrieve(ADS_FORMAT_WINDOWS, &bstrResult);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
//
|
|
// This is a workaround for the namespace path that we return. We are
|
|
// currently getting 'LDAP://' back instead of 'LDAP:'. There are users who
|
|
// are dependent on this and thus we cannot change it to return 'LDAP://'.
|
|
// The code below takes out the '//' if the path trails with '://' so that
|
|
// the path is settable.
|
|
//
|
|
dwLength = wcslen(bstrResult);
|
|
if (wcscmp((PWSTR)(&bstrResult[dwLength-3]),L"://") == 0) {
|
|
bstrResult[dwLength-2] = NULL;
|
|
}
|
|
|
|
hr = CoCreateInstance(
|
|
CLSID_Pathname,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
IID_IADsPathname,
|
|
(void**)&pPathname
|
|
);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPathname->Set(bstrResult, ADS_SETTYPE_FULL);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPathname->SetDisplayType(lNameType);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pPathname->put_EscapedMode(dwEscaped);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
*ppAdsPath = (IDispatch*)pPathname;
|
|
pPathname = NULL;
|
|
|
|
error:
|
|
if (fValueChanged) {
|
|
SetDisplayType(lNameType);
|
|
put_EscapedMode(dwEscaped);
|
|
}
|
|
if (pPathname) {
|
|
pPathname->Release();
|
|
}
|
|
if (bstrResult) {
|
|
SysFreeString(bstrResult);
|
|
}
|
|
RRETURN_EXP_IF_ERR(hr);
|
|
}
|
|
|
|
|
|
void
|
|
CPathname::FreeObjInfoComponents(
|
|
PATH_OBJECTINFO *pObjectInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Free all the compoents in an objinfo
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
S_OK on success, error code otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD NumComponents;
|
|
|
|
while (pObjectInfo->NumComponents > 0) {
|
|
pObjectInfo->NumComponents--;
|
|
NumComponents = pObjectInfo->NumComponents;
|
|
|
|
if (pObjectInfo->ComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(
|
|
pObjectInfo->ComponentArray[NumComponents].szComponent);
|
|
pObjectInfo->ComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (pObjectInfo->ComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(
|
|
pObjectInfo->ComponentArray[NumComponents].szValue);
|
|
pObjectInfo->ComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
if (pObjectInfo->DisplayComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(
|
|
pObjectInfo->DisplayComponentArray[NumComponents].szComponent);
|
|
pObjectInfo->DisplayComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (pObjectInfo->DisplayComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(
|
|
pObjectInfo->DisplayComponentArray[NumComponents].szValue);
|
|
pObjectInfo->DisplayComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
if (pObjectInfo->ProvSpecComponentArray[NumComponents].szComponent) {
|
|
FreeADsStr(
|
|
pObjectInfo->ProvSpecComponentArray[NumComponents].szComponent);
|
|
pObjectInfo->ProvSpecComponentArray[NumComponents].szComponent = NULL;
|
|
}
|
|
if (pObjectInfo->ProvSpecComponentArray[NumComponents].szValue) {
|
|
FreeADsStr(
|
|
pObjectInfo->ProvSpecComponentArray[NumComponents].szValue);
|
|
pObjectInfo->ProvSpecComponentArray[NumComponents].szValue = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
CPathname::FreePathInfo(
|
|
PPATH_OBJECTINFO pPathObjectInfo
|
|
)
|
|
{
|
|
if (pPathObjectInfo->ProviderName) {
|
|
FreeADsStr(pPathObjectInfo->ProviderName);
|
|
pPathObjectInfo->ProviderName = NULL;
|
|
}
|
|
if (pPathObjectInfo->ServerName) {
|
|
FreeADsStr(pPathObjectInfo->ServerName);
|
|
pPathObjectInfo->ServerName = NULL;
|
|
}
|
|
if (pPathObjectInfo->DisplayServerName) {
|
|
FreeADsStr(pPathObjectInfo->DisplayServerName);
|
|
pPathObjectInfo->DisplayServerName = NULL;
|
|
}
|
|
FreeObjInfoComponents(pPathObjectInfo);
|
|
pPathObjectInfo->dwPathType = ADS_PATHTYPE_ROOTFIRST;
|
|
}
|
|
|
|
HRESULT
|
|
CPathname::put_EscapedMode(
|
|
long lEscaped
|
|
)
|
|
{
|
|
_dwEscaped = lEscaped;
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT
|
|
CPathname::get_EscapedMode(
|
|
long *plEscaped
|
|
)
|
|
{
|
|
*plEscaped = _dwEscaped;
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// Function: CPathname::GetEscapedElement
|
|
//
|
|
// Synopsis: Takes the input string, escapes it assuming it is an RDN
|
|
// and returns the output.
|
|
// The first cut will be empty as in input string = output
|
|
// string. Once the code to do this is added please change this
|
|
// comment appropriately.
|
|
//
|
|
// Arguments: lnReserved (= 0 for now),
|
|
//
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// Modifies: -
|
|
//
|
|
// History: 11-10-98 AjayR Created.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CPathname::GetEscapedElement(
|
|
LONG lnReserved,
|
|
BSTR bstrInStr,
|
|
BSTR* pbstrOutStr
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_pPathnameProvider == NULL) {
|
|
hr = E_ADS_BAD_PATHNAME;
|
|
goto error;
|
|
}
|
|
|
|
hr = m_pPathnameProvider->GetEscapedElement(lnReserved,
|
|
bstrInStr,
|
|
pbstrOutStr);
|
|
error:
|
|
return hr;
|
|
}
|