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.
1780 lines
51 KiB
1780 lines
51 KiB
//#--------------------------------------------------------------
|
|
//
|
|
// File: crascom.cpp
|
|
//
|
|
// Synopsis: Implementation of CRasCom class methods
|
|
//
|
|
//
|
|
// History: 2/10/98 MKarki Created
|
|
// 5/15/98 SBens Do not consolidate VSAs.
|
|
// 9/16/98 SBens Signature of VSAFilter::radiusFromIAS changed.
|
|
// 11/17/99 TPerraut Split code for MS-Filter Attribute added
|
|
// 428843
|
|
//
|
|
//
|
|
// Copyright (C) Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
//----------------------------------------------------------------
|
|
#include "rascominclude.h"
|
|
#include "crascom.h"
|
|
#include <iastlutl.h>
|
|
|
|
const DWORD MAX_SLEEP_TIME = 50; //milli-seconds
|
|
|
|
|
|
//
|
|
// const and defines below added for the split functions. 428843
|
|
//
|
|
const CHAR NUL = '\0';
|
|
//
|
|
// these are the largest values that the attribute type
|
|
// packet type have
|
|
//
|
|
#define MAX_ATTRIBUTE_TYPE 255
|
|
//
|
|
// these are the related constants
|
|
//
|
|
#define MAX_ATTRIBUTE_LENGTH 253
|
|
#define MAX_VSA_ATTRIBUTE_LENGTH 247
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: SplitAndAdd
|
|
//
|
|
// Synopsis: This method is used to remove the original attribute
|
|
// and add new ones
|
|
// Arguments:
|
|
// [in] IAttributesRaw*
|
|
// [in] PIASATTRIBUTE
|
|
// [in] IASTYPE
|
|
// [in] DWORD - attribute length
|
|
// [in] DWORD - max attribute length
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 1/19/99
|
|
// TPerraut Copied from CRecvFromPipe::SplitAndAdd 11/17/99
|
|
//
|
|
// Called By: SplitAttributes
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT SplitAndAdd (
|
|
/*[in]*/ IAttributesRaw *pIAttributesRaw,
|
|
/*[in]*/ PIASATTRIBUTE pIasAttribute,
|
|
/*[in]*/ IASTYPE iasType,
|
|
/*[in]*/ DWORD dwAttributeLength,
|
|
/*[in]*/ DWORD dwMaxLength
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwPacketsNeeded = 0;
|
|
DWORD dwFailed = 0;
|
|
PIASATTRIBUTE *ppAttribArray = NULL;
|
|
PATTRIBUTEPOSITION pAttribPos = NULL;
|
|
|
|
_ASSERT (pIAttributesRaw && pIasAttribute);
|
|
|
|
__try
|
|
{
|
|
dwPacketsNeeded = dwAttributeLength / dwMaxLength;
|
|
if (dwAttributeLength % dwMaxLength) {++dwPacketsNeeded;}
|
|
|
|
//
|
|
// allocate memory for the ATTRIBUTEPOSITION array
|
|
//
|
|
pAttribPos = reinterpret_cast <PATTRIBUTEPOSITION> (
|
|
::CoTaskMemAlloc (
|
|
sizeof (ATTRIBUTEPOSITION)*dwPacketsNeeded));
|
|
if (NULL == pAttribPos)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for attribute position array "
|
|
"while split and add of attributese in out-bound packet"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate array to store the attributes in
|
|
//
|
|
ppAttribArray =
|
|
reinterpret_cast <PIASATTRIBUTE*> (
|
|
::CoTaskMemAlloc (sizeof (PIASATTRIBUTE)*dwPacketsNeeded));
|
|
if (NULL == ppAttribArray)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory"
|
|
"while split and add of out-bound attribues"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
DWORD dwFailed =
|
|
::IASAttributeAlloc (dwPacketsNeeded, ppAttribArray);
|
|
if (0 != dwFailed)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate attributes while splitting out-bound"
|
|
"attributes"
|
|
);
|
|
hr = HRESULT_FROM_WIN32 (dwFailed);
|
|
__leave;
|
|
}
|
|
|
|
if (IASTYPE_STRING == iasType)
|
|
{
|
|
PCHAR pStart = (pIasAttribute->Value).String.pszAnsi;
|
|
DWORD dwCopySize = dwMaxLength;
|
|
|
|
//
|
|
// set value in each of the new attributes
|
|
//
|
|
for (DWORD dwCount1 = 0; dwCount1 < dwPacketsNeeded; dwCount1++)
|
|
{
|
|
(ppAttribArray[dwCount1])->Value.String.pszAnsi =
|
|
reinterpret_cast <PCHAR>
|
|
(::CoTaskMemAlloc ((dwCopySize + 1)*sizeof (CHAR)));
|
|
if (NULL == (ppAttribArray[dwCount1])->Value.String.pszAnsi)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for new attribute values"
|
|
"while split and add of out-bound attribues"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// set the value now
|
|
//
|
|
::CopyMemory (
|
|
(ppAttribArray[dwCount1])->Value.String.pszAnsi,
|
|
pStart,
|
|
dwCopySize
|
|
);
|
|
//
|
|
// nul terminate the values
|
|
//
|
|
((ppAttribArray[dwCount1])->Value.String.pszAnsi)[dwCopySize]=NUL;
|
|
(ppAttribArray[dwCount1])->Value.itType = iasType;
|
|
(ppAttribArray[dwCount1])->dwId = pIasAttribute->dwId;
|
|
(ppAttribArray[dwCount1])->dwFlags = pIasAttribute->dwFlags;
|
|
|
|
//
|
|
// calculate for next attribute
|
|
//
|
|
pStart = pStart + dwCopySize;
|
|
dwAttributeLength -= dwCopySize;
|
|
dwCopySize = (dwAttributeLength > dwMaxLength) ?
|
|
dwMaxLength : dwAttributeLength;
|
|
|
|
//
|
|
// add attribute to position array
|
|
//
|
|
pAttribPos[dwCount1].pAttribute = ppAttribArray[dwCount1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PBYTE pStart = (pIasAttribute->Value).OctetString.lpValue;
|
|
DWORD dwCopySize = dwMaxLength;
|
|
|
|
//
|
|
// fill the new attributes now
|
|
//
|
|
for (DWORD dwCount1 = 0; dwCount1 < dwPacketsNeeded; dwCount1++)
|
|
{
|
|
(ppAttribArray[dwCount1])->Value.OctetString.lpValue =
|
|
reinterpret_cast <PBYTE> (::CoTaskMemAlloc (dwCopySize));
|
|
if (NULL ==(ppAttribArray[dwCount1])->Value.OctetString.lpValue)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for new attribute values"
|
|
"while split and add of out-bound attribues"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// set the value now
|
|
//
|
|
::CopyMemory (
|
|
(ppAttribArray[dwCount1])->Value.OctetString.lpValue,
|
|
pStart,
|
|
dwCopySize
|
|
);
|
|
|
|
(ppAttribArray[dwCount1])->Value.OctetString.dwLength = dwCopySize;
|
|
(ppAttribArray[dwCount1])->Value.itType = iasType;
|
|
(ppAttribArray[dwCount1])->dwId = pIasAttribute->dwId;
|
|
(ppAttribArray[dwCount1])->dwFlags = pIasAttribute->dwFlags;
|
|
|
|
//
|
|
// calculate for next attribute
|
|
//
|
|
pStart = pStart + dwCopySize;
|
|
dwAttributeLength -= dwCopySize;
|
|
dwCopySize = (dwAttributeLength > dwMaxLength) ?
|
|
dwMaxLength :
|
|
dwAttributeLength;
|
|
|
|
//
|
|
// add attribute to position array
|
|
//
|
|
pAttribPos[dwCount1].pAttribute = ppAttribArray[dwCount1];
|
|
}
|
|
}
|
|
|
|
//
|
|
// add the attribute to the collection
|
|
//
|
|
hr = pIAttributesRaw->AddAttributes (dwPacketsNeeded, pAttribPos);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Failed to add attributes to the collection"
|
|
"on split and add out-bound attributes"
|
|
);
|
|
__leave;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if ((FAILED (hr)) && (ppAttribArray) && (0 == dwFailed))
|
|
{
|
|
for (DWORD dwCount = 0; dwCount < dwPacketsNeeded; dwCount++)
|
|
{
|
|
::IASAttributeRelease (ppAttribArray[dwCount]);
|
|
}
|
|
}
|
|
|
|
if (ppAttribArray) {::CoTaskMemFree (ppAttribArray);}
|
|
|
|
if (pAttribPos) {::CoTaskMemFree (pAttribPos);}
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of SplitAndAdd method
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: SplitAttributes
|
|
//
|
|
// Synopsis: This method is used to split up the following
|
|
// out-bound attributes:
|
|
// 1) Reply-Message attribute
|
|
// 2) MS-Filter-VSA attribute
|
|
// 3) MS QuarantineIpFilter attribute (VSA)
|
|
//
|
|
// Arguments:
|
|
// [in] IAttributesRaw*
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 1/19/99
|
|
// TPerraut Copied from CRecvFromPipe::SplitAttributes
|
|
// 11/17/99
|
|
//
|
|
// Called By: CRasCom::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT SplitAttributes (
|
|
/*[in]*/ IAttributesRaw *pIAttributesRaw
|
|
)
|
|
{
|
|
const DWORD SPLIT_ATTRIBUTE_COUNT = 3;
|
|
static DWORD AttribIds [] = {
|
|
RADIUS_ATTRIBUTE_REPLY_MESSAGE,
|
|
MS_ATTRIBUTE_FILTER,
|
|
MS_ATTRIBUTE_QUARANTINE_IPFILTER
|
|
};
|
|
|
|
HRESULT hr = S_OK;
|
|
DWORD dwAttributesFound = 0;
|
|
PATTRIBUTEPOSITION pAttribPos = NULL;
|
|
|
|
_ASSERT (pIAttributesRaw);
|
|
|
|
__try
|
|
{
|
|
//
|
|
// get the count of the total attributes in the collection
|
|
//
|
|
DWORD dwAttributeCount = 0;
|
|
hr = pIAttributesRaw->GetAttributeCount (&dwAttributeCount);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain attribute count in request while "
|
|
"splitting attributes in out-bound packet "
|
|
);
|
|
__leave;
|
|
}
|
|
else if (0 == dwAttributeCount)
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the ATTRIBUTEPOSITION array
|
|
//
|
|
pAttribPos = reinterpret_cast <PATTRIBUTEPOSITION> (
|
|
::CoTaskMemAlloc (
|
|
sizeof (ATTRIBUTEPOSITION)*dwAttributeCount)
|
|
);
|
|
if (NULL == pAttribPos)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for attribute position array "
|
|
"while splitting attributes in out-bound packet"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the attributes we are interested in from the interface
|
|
//
|
|
hr = pIAttributesRaw->GetAttributes (
|
|
&dwAttributeCount,
|
|
pAttribPos,
|
|
SPLIT_ATTRIBUTE_COUNT,
|
|
static_cast <PDWORD> (AttribIds)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain information about attributes"
|
|
"while splitting attributes in out-bound RADIUS packet"
|
|
);
|
|
__leave;
|
|
}
|
|
else if (0 == dwAttributeCount)
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// save the count of attributes returned
|
|
//
|
|
dwAttributesFound = dwAttributeCount;
|
|
|
|
DWORD dwAttribLength = 0;
|
|
DWORD dwMaxPossibleLength = 0;
|
|
IASTYPE iasType = IASTYPE_INVALID;
|
|
//
|
|
// evaluate each attribute now
|
|
//
|
|
for (DWORD dwCount = 0; dwCount < dwAttributeCount; dwCount++)
|
|
{
|
|
if ((pAttribPos[dwCount].pAttribute)->dwFlags &
|
|
IAS_INCLUDE_IN_RESPONSE)
|
|
{
|
|
//
|
|
// get attribute type and length
|
|
//
|
|
if (
|
|
(iasType = (pAttribPos[dwCount].pAttribute)->Value.itType) ==
|
|
IASTYPE_STRING
|
|
)
|
|
{
|
|
DWORD dwErr = ::IASAttributeAnsiAlloc(pAttribPos[dwCount].pAttribute);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
hr = (HRESULT_FROM_WIN32(dwErr));
|
|
__leave;
|
|
}
|
|
|
|
dwAttribLength =
|
|
strlen (
|
|
(pAttribPos[dwCount].pAttribute)->Value.String.pszAnsi);
|
|
|
|
}
|
|
else if (
|
|
(iasType = (pAttribPos[dwCount].pAttribute)->Value.itType) ==
|
|
IASTYPE_OCTET_STRING
|
|
)
|
|
{
|
|
dwAttribLength =
|
|
(pAttribPos[dwCount].pAttribute)->Value.OctetString.dwLength;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// only string values need to be split
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// get max possible attribute length
|
|
//
|
|
if ((pAttribPos[dwCount].pAttribute)->dwId > MAX_ATTRIBUTE_TYPE)
|
|
{
|
|
dwMaxPossibleLength = MAX_VSA_ATTRIBUTE_LENGTH;
|
|
}
|
|
else
|
|
{
|
|
dwMaxPossibleLength = MAX_ATTRIBUTE_LENGTH;
|
|
}
|
|
|
|
//
|
|
// check if we need to split this attribute
|
|
//
|
|
if (dwAttribLength <= dwMaxPossibleLength) {continue;}
|
|
|
|
|
|
//
|
|
// split the attribute now
|
|
//
|
|
hr = SplitAndAdd (
|
|
pIAttributesRaw,
|
|
pAttribPos[dwCount].pAttribute,
|
|
iasType,
|
|
dwAttribLength,
|
|
dwMaxPossibleLength
|
|
);
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
//
|
|
// remove this attribute from the collection now
|
|
//
|
|
hr = pIAttributesRaw->RemoveAttributes (
|
|
1,
|
|
&(pAttribPos[dwCount])
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to remove attribute from collection"
|
|
"while splitting out-bound attributes"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if (pAttribPos)
|
|
{
|
|
for (DWORD dwCount = 0; dwCount < dwAttributesFound; dwCount++)
|
|
{
|
|
::IASAttributeRelease (pAttribPos[dwCount].pAttribute);
|
|
}
|
|
|
|
::CoTaskMemFree (pAttribPos);
|
|
}
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of SplitAttributes method
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CRasCom
|
|
//
|
|
// Synopsis: This is CRasCom Class constructor
|
|
//
|
|
// Arguments: NONE
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRasCom::CRasCom (
|
|
VOID
|
|
)
|
|
:m_objCRequestSource (this),
|
|
m_pIRequestHandler(NULL),
|
|
m_pIClassFactory (NULL),
|
|
m_bVSAFilterInitialized (FALSE),
|
|
m_lRequestCount (0),
|
|
m_eCompState (COMP_SHUTDOWN)
|
|
{
|
|
} // end of CRasCom class constructor
|
|
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ~CRasCom
|
|
//
|
|
// Synopsis: This is CRasCom class destructor
|
|
//
|
|
// Arguments: NONE
|
|
//
|
|
// Returns: NONE
|
|
//
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRasCom::~CRasCom(
|
|
VOID
|
|
)
|
|
{
|
|
} // end of CRasCom class destructor
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: InitNew
|
|
//
|
|
// Synopsis: This is the InitNew method exposed through the
|
|
// IIasComponent COM Interface.
|
|
// For the RasCom Component it is implemented for
|
|
// completeness
|
|
//
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: by the Component intializer through the IIasComponent
|
|
// interface
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::InitNew (
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// InitNew call can only be made from SHUTDOWN state
|
|
//
|
|
if (COMP_SHUTDOWN != m_eCompState)
|
|
{
|
|
IASTracePrintf ("The Surrogate can not be called in this state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// reset the total pending request count
|
|
//
|
|
m_lRequestCount = 0;
|
|
|
|
//
|
|
// now we are initialized
|
|
|
|
m_eCompState = COMP_UNINITIALIZED;
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::InitNew method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Initialize
|
|
//
|
|
// Synopsis: This is the Initialize method exposed through the
|
|
// IIasComponent COM Interface. It initializes the
|
|
// Request object ClassFactory
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: by the Component intializer through the IIasComponent
|
|
// interface
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::Initialize (
|
|
VOID
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Initialize call can only be made from Uninitialized state
|
|
//
|
|
if (COMP_INITIALIZED == m_eCompState)
|
|
{
|
|
return (S_OK);
|
|
}
|
|
else if (COMP_UNINITIALIZED != m_eCompState)
|
|
{
|
|
IASTracePrintf ("The Surrogate can not be initialized in this state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// get the IClassFactory interface to be used to create
|
|
// the Request COM object
|
|
//
|
|
hr = ::CoGetClassObject (
|
|
__uuidof (Request),
|
|
CLSCTX_INPROC_SERVER,
|
|
NULL,
|
|
IID_IClassFactory,
|
|
reinterpret_cast <PVOID*> (&m_pIClassFactory)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf ("The Surrogate was unable to obtain request factory");
|
|
return (hr);
|
|
}
|
|
|
|
//
|
|
// initialize the VSAFilter class object
|
|
//
|
|
hr = m_objVSAFilter.initialize ();
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf ("The Surrogate was unable to initializa VSA filtering");
|
|
m_pIClassFactory->Release ();
|
|
m_pIClassFactory = NULL;
|
|
return (hr);
|
|
}
|
|
else
|
|
{
|
|
m_bVSAFilterInitialized = TRUE;
|
|
}
|
|
|
|
//
|
|
// correctly initialized the surrogate
|
|
//
|
|
m_eCompState = COMP_INITIALIZED;
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::Initialize method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Shutdown
|
|
//
|
|
// Synopsis: This is the ShutDown method exposed through the
|
|
// IIasComponent COM Interface. It is used to stop
|
|
// processing data
|
|
//
|
|
// Arguments: NONE
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: by the Component shutdown through the IIasComponent
|
|
// interface
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::Shutdown (
|
|
VOID
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
|
|
//
|
|
// shutdown can only be called from the suspend state
|
|
//
|
|
if (COMP_SHUTDOWN == m_eCompState)
|
|
{
|
|
return (S_OK);
|
|
}
|
|
else if (
|
|
(COMP_SUSPENDED != m_eCompState) &&
|
|
(COMP_UNINITIALIZED != m_eCompState)
|
|
)
|
|
{
|
|
IASTracePrintf ("The Surrogate can not be shutdown in current state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// release the interfaces
|
|
//
|
|
if (NULL != m_pIRequestHandler)
|
|
{
|
|
m_pIRequestHandler->Release ();
|
|
m_pIRequestHandler = NULL;
|
|
}
|
|
|
|
if (NULL != m_pIClassFactory)
|
|
{
|
|
m_pIClassFactory->Release ();
|
|
m_pIClassFactory = NULL;
|
|
}
|
|
|
|
//
|
|
// shutdown the VSAFilter
|
|
//
|
|
if (TRUE == m_bVSAFilterInitialized)
|
|
{
|
|
m_objVSAFilter.shutdown ();
|
|
m_bVSAFilterInitialized = FALSE;
|
|
}
|
|
|
|
//
|
|
// cleanly shutting down
|
|
//
|
|
m_eCompState = COMP_SHUTDOWN;
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::Shutdown method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Suspend
|
|
//
|
|
// Synopsis: This is the Suspend method exposed through the
|
|
// IComponent COM Interface. It is used to suspend
|
|
// packet processing operations
|
|
//
|
|
// Arguments: NONE
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
//
|
|
// History: MKarki Created 10/2/97
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::Suspend (
|
|
VOID
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// suspend can only be called from the initialized state
|
|
//
|
|
if (COMP_SUSPENDED == m_eCompState)
|
|
{
|
|
return (S_OK);
|
|
}
|
|
else if (COMP_INITIALIZED != m_eCompState)
|
|
{
|
|
IASTracePrintf ("The Surrogate can not be suspended in current state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// change state
|
|
//
|
|
m_eCompState = COMP_SUSPENDED;
|
|
|
|
while (0 != m_lRequestCount) { Sleep (MAX_SLEEP_TIME); }
|
|
|
|
//
|
|
// we have successfully suspended RADIUS component's packet
|
|
// processing operations
|
|
//
|
|
|
|
return (hr);
|
|
|
|
} // end of CRasCom::Suspend method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Resume
|
|
//
|
|
// Synopsis: This is the Resume method exposed through the
|
|
// IComponent COM Interface. It is used to resume
|
|
// packet processing operations which had been
|
|
// stopped by a previous call to Suspend API
|
|
//
|
|
//
|
|
// Arguments: NONE
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
//
|
|
// History: MKarki Created 10/2/97
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::Resume (
|
|
VOID
|
|
)
|
|
{
|
|
if (COMP_SUSPENDED != m_eCompState)
|
|
{
|
|
IASTracePrintf ("The Surrogate can not resume in current state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// we have successfully resumed operations in the RADIUS component
|
|
//
|
|
m_eCompState = COMP_INITIALIZED;
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::Resume method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: GetProperty
|
|
//
|
|
// Synopsis: This is the IIasComponent Interface method.
|
|
// Only Implemented for the sake of completeness
|
|
//
|
|
// Arguments:
|
|
// [in] LONG - id
|
|
// [out] VARIANT - *pValue
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::GetProperty (
|
|
LONG id,
|
|
VARIANT *pValue
|
|
)
|
|
{
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::GetProperty method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: PutProperty
|
|
//
|
|
// Synopsis: This is the IIasComponent Interface method.
|
|
// Only Implemented for the sake of completeness
|
|
// Arguments:
|
|
// [in] LONG - id
|
|
// [out] VARIANT - *pValue
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::PutProperty (
|
|
LONG id,
|
|
VARIANT *pValue
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// PutProperty method can only be called from
|
|
// Uninitialized, Initialized or Suspended state
|
|
//
|
|
if (
|
|
(COMP_UNINITIALIZED != m_eCompState) &&
|
|
(COMP_INITIALIZED != m_eCompState) &&
|
|
(COMP_SUSPENDED == m_eCompState)
|
|
)
|
|
{
|
|
IASTracePrintf ("Surrogate can not put property in current state");
|
|
return (E_UNEXPECTED);
|
|
}
|
|
|
|
//
|
|
// check if valid arguments where passed in
|
|
//
|
|
if (NULL == pValue) { return (E_POINTER); }
|
|
|
|
//
|
|
// carry out the property intialization now
|
|
//
|
|
switch (id)
|
|
{
|
|
|
|
case PROPERTY_PROTOCOL_REQUEST_HANDLER:
|
|
|
|
if (NULL != m_pIRequestHandler)
|
|
{
|
|
//
|
|
// clients can not be updated in INITIALIZED or
|
|
// SUSPENDED state
|
|
//
|
|
hr = HRESULT_FROM_WIN32 (ERROR_ALREADY_INITIALIZED);
|
|
}
|
|
else if (VT_DISPATCH != pValue->vt)
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
}
|
|
else if (NULL == pValue->punkVal)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// initialize the providers
|
|
//
|
|
m_pIRequestHandler = reinterpret_cast <IRequestHandler*>
|
|
(pValue->punkVal);
|
|
m_pIRequestHandler->AddRef ();
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
hr = DISP_E_MEMBERNOTFOUND;
|
|
break;
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRasCom::PutProperty method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: QueryInterfaceReqSrc
|
|
//
|
|
// Synopsis: This is the function called when this Component
|
|
// is called and queried for its IRequestSource
|
|
// interface
|
|
//
|
|
// Arguments:
|
|
// [in] PVOID - this object refrence
|
|
// [in] REFIID - IID of interface requested
|
|
// [out] LPVOID - return appropriate interface
|
|
// [in] DWORD
|
|
//
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT WINAPI
|
|
CRasCom::QueryInterfaceReqSrc (
|
|
PVOID pThis,
|
|
REFIID riid,
|
|
LPVOID *ppv,
|
|
DWORD_PTR dwValue
|
|
)
|
|
{
|
|
if ((NULL == pThis) || (NULL == ppv))
|
|
return (E_FAIL);
|
|
|
|
//
|
|
// get a reference to the nested CRequestSource object
|
|
//
|
|
*ppv =
|
|
&(static_cast<CRasCom*>(pThis))->m_objCRequestSource;
|
|
|
|
//
|
|
// increment count
|
|
//
|
|
((LPUNKNOWN)*ppv)->AddRef();
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::QueryInterfaceReqSrc method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CRequestSource
|
|
//
|
|
// Synopsis: This is the constructor of the CRequestSource
|
|
// nested class
|
|
//
|
|
// Arguments:
|
|
// [in] CRasCom*
|
|
//
|
|
// Returns: none
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRasCom::CRequestSource::CRequestSource(
|
|
CRasCom *pCRasCom
|
|
)
|
|
:m_pCRasCom (pCRasCom)
|
|
{
|
|
_ASSERT (NULL != pCRasCom);
|
|
|
|
} // end of CRequestSource class constructor
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ~CRequestSource
|
|
//
|
|
// Synopsis: This is the destructor of the CRequestSource
|
|
// nested class
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
//
|
|
// History: MKarki Created 11/21/97
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRasCom::CRequestSource::~CRequestSource()
|
|
{
|
|
} // end of CRequestSource destructor
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: OnRequestComplete
|
|
//
|
|
// Synopsis: This is a method of IRequestHandler COM interface
|
|
// This is the function called when a request is
|
|
// is being pushed back after backend processing
|
|
// we just return here as we are only be doing
|
|
// synchronous processing
|
|
//
|
|
// Arguments:
|
|
// [in] IRequest*
|
|
// [in] IASREQUESTSTATUS
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: Pipeline through the IRequestHandler interface
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP CRasCom::CRequestSource::OnRequestComplete (
|
|
IRequest *pIRequest,
|
|
IASREQUESTSTATUS eStatus
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
HANDLE hEvent = NULL;
|
|
HRESULT hr = S_OK;
|
|
unsigned hyper uhyState = 0;
|
|
CComPtr <IRequestState> pIRequestState;
|
|
|
|
|
|
if (NULL == pIRequest)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate passed invalid argumen in OnRequestComplete method"
|
|
);
|
|
return (E_POINTER);
|
|
}
|
|
|
|
//
|
|
// get the IRequestState interface now
|
|
//
|
|
hr = pIRequest->QueryInterface (
|
|
__uuidof(IRequestState),
|
|
reinterpret_cast <PVOID*> (&pIRequestState)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain IRequestState interface in"
|
|
" OnRequestComplete method"
|
|
);
|
|
return (hr);
|
|
}
|
|
|
|
//
|
|
// get the CPacketRadius class object
|
|
//
|
|
hr = pIRequestState->Pop (
|
|
reinterpret_cast <unsigned hyper*> (&uhyState)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain information from Request State"
|
|
" in OnRequestComplete method"
|
|
);
|
|
return (hr);
|
|
}
|
|
|
|
//
|
|
// get the hEvent;
|
|
//
|
|
hEvent = reinterpret_cast <HANDLE> (uhyState);
|
|
|
|
//
|
|
// set the event now
|
|
//
|
|
bStatus = ::SetEvent (hEvent);
|
|
if (FALSE == bStatus)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to send notification that request is"
|
|
" processed in OnRequestComplete method"
|
|
);
|
|
return (E_FAIL);
|
|
}
|
|
|
|
return (S_OK);
|
|
|
|
} // end of CRasCom::CRequestSource::OnRequestComplete method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Process
|
|
//
|
|
// Synopsis: This is the method of the IRecvRequest COM interface
|
|
// It is called to generate and send request to the
|
|
// pipeline
|
|
//
|
|
// Arguments:
|
|
// [in] DWORD - number of in attributes
|
|
// [in] PIASATTRIBUTE* - array of pointer to attribs
|
|
// [out] PDWORD - number of out attributes
|
|
// [out] PIASATTRIBUTE** - pointer
|
|
// [in] LONG
|
|
// [in/out]LONG*
|
|
// [in] IASPROTCOL
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: Called by DoRequest C style API
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::Process (
|
|
/*[in]*/ DWORD dwInAttributeCount,
|
|
/*[in]*/ PIASATTRIBUTE *ppInIasAttribute,
|
|
/*[out]*/ PDWORD pdwOutAttributeCount,
|
|
/*[out]*/ PIASATTRIBUTE **pppOutIasAttribute,
|
|
/*[in]*/ LONG IasRequest,
|
|
/*[in/out]*/ LONG *pIasResponse,
|
|
/*[in]*/ IASPROTOCOL IasProtocol,
|
|
/*[out]*/ PLONG plReason,
|
|
/*[in]*/ BOOL bProcessVSA
|
|
)
|
|
{
|
|
|
|
DWORD dwCount = 0;
|
|
HRESULT hr = S_OK;
|
|
HANDLE hEvent = NULL;
|
|
DWORD dwRetVal = 0;
|
|
IRequest *pIRequest = NULL;
|
|
IAttributesRaw *pIAttributesRaw = NULL;
|
|
IRequestState *pIRequestState = NULL;
|
|
PATTRIBUTEPOSITION pIasAttribPos = NULL;
|
|
static DWORD dwRequestCount = 0;
|
|
|
|
//
|
|
// check if processing is enabled
|
|
//
|
|
if ((COMP_INITIALIZED != m_eCompState) || (NULL == m_pIRequestHandler))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate passed invalid argument for request processing"
|
|
);
|
|
return (E_FAIL);
|
|
}
|
|
|
|
|
|
__try
|
|
{
|
|
//
|
|
// increment the request count
|
|
//
|
|
InterlockedIncrement (&m_lRequestCount);
|
|
|
|
// check if we are processing requests at this time
|
|
//
|
|
if ((COMP_INITIALIZED != m_eCompState) || (NULL == m_pIRequestHandler))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to process request in the current state"
|
|
);
|
|
hr = E_FAIL;
|
|
__leave;
|
|
}
|
|
|
|
if (
|
|
(0 == dwInAttributeCount) ||
|
|
(NULL == ppInIasAttribute) ||
|
|
(NULL == pdwOutAttributeCount) ||
|
|
(NULL == pppOutIasAttribute) ||
|
|
(NULL == pIasResponse) ||
|
|
(NULL == plReason)
|
|
)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate passed invalid argument for processing request"
|
|
);
|
|
hr = E_INVALIDARG;
|
|
__leave;
|
|
}
|
|
|
|
_ASSERT (NULL != m_pIClassFactory);
|
|
|
|
//
|
|
// create the request object
|
|
//
|
|
HRESULT hr = m_pIClassFactory->CreateInstance (
|
|
NULL,
|
|
__uuidof (IRequest),
|
|
reinterpret_cast <PVOID*> (&pIRequest)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate failed in creation of a new request object"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// get IAttributesRaw interface
|
|
//
|
|
hr = pIRequest->QueryInterface (
|
|
__uuidof (IAttributesRaw),
|
|
reinterpret_cast <PVOID*> (&pIAttributesRaw)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain Attribute interface while"
|
|
" processing request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the ATTRIBUTEPOSITION array
|
|
//
|
|
pIasAttribPos = reinterpret_cast <PATTRIBUTEPOSITION>(
|
|
::CoTaskMemAlloc (
|
|
sizeof (ATTRIBUTEPOSITION)*dwInAttributeCount)
|
|
);
|
|
if (NULL == pIasAttribPos)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to allocate memory while processing request"
|
|
);
|
|
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// put the attributes in the ATTRIBUTEPOSITION structs
|
|
//
|
|
for (dwCount = 0; dwCount < dwInAttributeCount; dwCount++)
|
|
{
|
|
//
|
|
// mark the attribute as having been received from client
|
|
//
|
|
ppInIasAttribute[dwCount]->dwFlags |= IAS_RECVD_FROM_CLIENT;
|
|
|
|
pIasAttribPos[dwCount].pAttribute = ppInIasAttribute[dwCount];
|
|
}
|
|
|
|
//
|
|
// put the attributes collection that we are holding into the
|
|
// Request object through the IAttributesRaw interface
|
|
//
|
|
hr = pIAttributesRaw->AddAttributes (
|
|
dwInAttributeCount,
|
|
pIasAttribPos
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate failed to add attributes to request being processed"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// set the request type now
|
|
//
|
|
hr = pIRequest->put_Request (IasRequest);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to set the request type for processing"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// set the protocol now
|
|
//
|
|
hr = pIRequest->put_Protocol (IasProtocol);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to set protocol type in request for processing"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// put your IRequestSource interface in now
|
|
//
|
|
hr = pIRequest->put_Source (&m_objCRequestSource);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to set source in request for processing"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// convert the VSA attributes to IAS format if requested
|
|
//
|
|
if (TRUE == bProcessVSA)
|
|
{
|
|
hr = m_objVSAFilter.radiusToIAS (pIAttributesRaw);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to convert VSAs to IAS format"
|
|
);
|
|
__leave;
|
|
}
|
|
}
|
|
|
|
//
|
|
// create an event which will be used to wake this thread
|
|
// when the pipeline does multithreaded processing
|
|
//
|
|
hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
|
|
if (NULL == hEvent)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to create event while processing request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the request state interface to put in our state now
|
|
//
|
|
//
|
|
hr = pIRequest->QueryInterface (
|
|
__uuidof (IRequestState),
|
|
reinterpret_cast <PVOID*> (&pIRequestState)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to extract request state interface"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// put in the request state - which is our event handle in
|
|
//
|
|
hr = pIRequestState->Push (
|
|
reinterpret_cast <unsigned hyper> (hEvent)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to set event in request state"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
_ASSERT (NULL != m_pIRequestHandler);
|
|
|
|
//
|
|
// send the request to the pipeline now
|
|
//
|
|
hr = m_pIRequestHandler->OnRequest (pIRequest);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate request failed backend processing..."
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// now wait for the event now
|
|
//
|
|
dwRetVal = ::WaitForSingleObjectEx (hEvent, INFINITE, TRUE);
|
|
if (0XFFFFFFFF == dwRetVal)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate failed on waiting for process completion"
|
|
);
|
|
hr = E_FAIL;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// convert the IAS attributes to VSA format if requested
|
|
//
|
|
if (TRUE == bProcessVSA)
|
|
{
|
|
//
|
|
// TPERRAUT ADDED Bug 428843
|
|
// Always called from RAS with bProcessVSA = true
|
|
//
|
|
// split the attributes which can not fit in a radius packet
|
|
//
|
|
hr = SplitAttributes (pIAttributesRaw);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"TPERRAUT: Unable to split IAS attribute received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
// TPERRAUT ADDED: END
|
|
|
|
|
|
hr = m_objVSAFilter.radiusFromIAS (pIAttributesRaw);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate failed on extracting VSAs from IAS format"
|
|
);
|
|
__leave;
|
|
}
|
|
}
|
|
|
|
//
|
|
// now its time to dismantle the request sent to find out
|
|
// what we got back
|
|
//
|
|
hr = pIRequest->get_Response (pIasResponse);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain response from processed request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
hr = pIRequest->get_Reason (plReason);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain reason from processed request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// remove all the attributes from the request object now
|
|
//
|
|
hr = RemoveAttributesFromRequest (
|
|
*pIasResponse,
|
|
pIAttributesRaw,
|
|
pdwOutAttributeCount,
|
|
pppOutIasAttribute
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to remove attributes from processed request"
|
|
);
|
|
__leave;
|
|
}
|
|
}
|
|
|
|
__finally
|
|
{
|
|
//
|
|
// do the cleanup now
|
|
//
|
|
if (NULL != hEvent)
|
|
{
|
|
CloseHandle (hEvent);
|
|
}
|
|
|
|
if (NULL != pIasAttribPos)
|
|
{
|
|
::CoTaskMemFree (pIasAttribPos);
|
|
}
|
|
|
|
if (NULL != pIRequestState)
|
|
{
|
|
pIRequestState->Release ();
|
|
}
|
|
|
|
if (NULL != pIAttributesRaw)
|
|
{
|
|
pIAttributesRaw->Release ();
|
|
}
|
|
|
|
if (NULL != pIRequest)
|
|
{
|
|
pIRequest->Release ();
|
|
}
|
|
|
|
//
|
|
// increment the requestreceived
|
|
//
|
|
dwRequestCount =
|
|
(0xFFFFFFFF == dwRequestCount) ? 1 : dwRequestCount+ 1;
|
|
|
|
//
|
|
// decrement the request count
|
|
//
|
|
InterlockedDecrement (&m_lRequestCount);
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRasCom::Process method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: RemoveAttributesFromRequest
|
|
//
|
|
// Synopsis: This is the CRasCom class private method
|
|
// that is used to remove the attributes
|
|
// from the Request object through the
|
|
// IAttributesRaw interface
|
|
//
|
|
// Arguments:
|
|
// [in] LONG - response received from pipe
|
|
// [in] IAttributesRaw*
|
|
// [out] PIASATTRIBUTE**
|
|
// [out] PDWORD - out attribute count
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/10/98
|
|
//
|
|
// Called By: CRasCom::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
STDMETHODIMP
|
|
CRasCom::RemoveAttributesFromRequest (
|
|
LONG lResponse,
|
|
IAttributesRaw *pIasAttributesRaw,
|
|
PDWORD pdwOutAttributeCount,
|
|
PIASATTRIBUTE **pppIasAttribute
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PATTRIBUTEPOSITION pIasOutAttributePos = NULL;
|
|
DWORD dwCount = 0;
|
|
DWORD dwAttribCount = 0;
|
|
DWORD dwOutCount = 0;
|
|
BOOL bGotAttributes = FALSE;
|
|
PIASATTRIBUTE pIasAttribute = NULL;
|
|
|
|
_ASSERT (
|
|
(NULL != pIasAttributesRaw) &&
|
|
(NULL != pppIasAttribute) &&
|
|
(NULL != pdwOutAttributeCount)
|
|
);
|
|
|
|
__try
|
|
{
|
|
|
|
//
|
|
// get the count of the attributes remaining in the collection
|
|
// these will be the OUT attributes
|
|
//
|
|
hr = pIasAttributesRaw->GetAttributeCount (&dwAttribCount);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to obtain attribute count from request in"
|
|
"while removing attributes from request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the ATTRIBUTEPOSITION array
|
|
//
|
|
pIasOutAttributePos = reinterpret_cast <PATTRIBUTEPOSITION> (
|
|
::CoTaskMemAlloc (
|
|
sizeof (ATTRIBUTEPOSITION)*(dwAttribCount))
|
|
);
|
|
if (NULL == pIasOutAttributePos)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to allocate memory"
|
|
"while removing attributes from request"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// get all the attributes from the collection
|
|
//
|
|
hr = pIasAttributesRaw->GetAttributes (
|
|
&dwAttribCount,
|
|
pIasOutAttributePos,
|
|
0,
|
|
NULL
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable get attributes from request interface"
|
|
"while removing attributes"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// we have obtained the attributes
|
|
//
|
|
bGotAttributes = TRUE;
|
|
|
|
//
|
|
// remove the attributes from the collection now
|
|
//
|
|
hr = pIasAttributesRaw->RemoveAttributes (
|
|
dwAttribCount,
|
|
pIasOutAttributePos
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable remove attributes from request"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// calculate the number of attributes not added by the client
|
|
//
|
|
*pdwOutAttributeCount = 0;
|
|
for (dwCount = 0; dwCount < dwAttribCount; dwCount++)
|
|
{
|
|
pIasAttribute = pIasOutAttributePos[dwCount].pAttribute;
|
|
|
|
//
|
|
// verify that this attributes has to be sent to client
|
|
//
|
|
if
|
|
(
|
|
((pIasAttribute->dwFlags & IAS_INCLUDE_IN_ACCEPT) &&
|
|
(IAS_RESPONSE_ACCESS_ACCEPT == lResponse)) ||
|
|
((pIasAttribute->dwFlags & IAS_INCLUDE_IN_REJECT) &&
|
|
(IAS_RESPONSE_ACCESS_REJECT == lResponse)) ||
|
|
((pIasAttribute->dwFlags & IAS_INCLUDE_IN_CHALLENGE) &&
|
|
(IAS_RESPONSE_ACCESS_CHALLENGE == lResponse))
|
|
)
|
|
{
|
|
(*pdwOutAttributeCount)++;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// allocate memory for PIASATTRIBUTE array
|
|
//
|
|
*pppIasAttribute = reinterpret_cast <PIASATTRIBUTE*> (
|
|
::CoTaskMemAlloc (sizeof(PIASATTRIBUTE)*(*pdwOutAttributeCount))
|
|
);
|
|
if (NULL == *pppIasAttribute)
|
|
{
|
|
IASTracePrintf (
|
|
"Surrogate unable to allocate memory for attrib pointer array"
|
|
"while removing attribute from request"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// put the attributes in the PIASATTRIBUTE array
|
|
//
|
|
for (dwCount = 0, dwOutCount = 0; dwCount < dwAttribCount; dwCount++)
|
|
{
|
|
pIasAttribute = pIasOutAttributePos[dwCount].pAttribute;
|
|
|
|
if (
|
|
(((pIasAttribute->dwFlags & IAS_INCLUDE_IN_ACCEPT) &&
|
|
(IAS_RESPONSE_ACCESS_ACCEPT == lResponse)) ||
|
|
((pIasAttribute->dwFlags & IAS_INCLUDE_IN_REJECT) &&
|
|
(IAS_RESPONSE_ACCESS_REJECT == lResponse)) ||
|
|
((pIasAttribute->dwFlags & IAS_INCLUDE_IN_CHALLENGE) &&
|
|
(IAS_RESPONSE_ACCESS_CHALLENGE == lResponse)))
|
|
&&
|
|
(dwOutCount < *pdwOutAttributeCount)
|
|
)
|
|
{
|
|
|
|
//
|
|
// put the out attribute in the output array
|
|
//
|
|
(*pppIasAttribute)[dwOutCount] = pIasAttribute;
|
|
|
|
dwOutCount++;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// decrement the reference count for the
|
|
// attributes we created or the ones we are
|
|
// not sending as out to client
|
|
//
|
|
::IASAttributeRelease (pIasAttribute);
|
|
}
|
|
}
|
|
|
|
//
|
|
// now put in the number of out attribute we are actually
|
|
// giving the client
|
|
//
|
|
*pdwOutAttributeCount = dwOutCount;
|
|
|
|
}
|
|
__finally
|
|
{
|
|
|
|
//
|
|
// cleanup on failure
|
|
//
|
|
if (FAILED (hr))
|
|
{
|
|
if (NULL != *pppIasAttribute)
|
|
{
|
|
::CoTaskMemFree (*pppIasAttribute);
|
|
pppIasAttribute = NULL;
|
|
}
|
|
|
|
//
|
|
// correct the out attribute count
|
|
//
|
|
*pdwOutAttributeCount = 0;
|
|
|
|
//
|
|
// free up all the attributes also
|
|
//
|
|
if ((TRUE == bGotAttributes) && (NULL != pIasOutAttributePos))
|
|
{
|
|
for (dwCount = 0; dwCount < dwAttribCount; dwCount++)
|
|
{
|
|
::IASAttributeRelease (
|
|
pIasOutAttributePos[dwCount].pAttribute
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// delete the dynamically allocated memory
|
|
//
|
|
if (NULL != pIasOutAttributePos)
|
|
{
|
|
::CoTaskMemFree (pIasOutAttributePos);
|
|
}
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRasCom::RemoveAttributesFromRequest method
|