1465 lines
44 KiB
C++
1465 lines
44 KiB
C++
//#--------------------------------------------------------------
|
|
//
|
|
// File: recvfrompipe.cpp
|
|
//
|
|
// Synopsis: Implementation of CRecvFromPip class methods
|
|
//
|
|
//
|
|
// History: 10/22/97 MKarki Created
|
|
//
|
|
// Copyright (C) 1997-98 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
//----------------------------------------------------------------
|
|
#include "radcommon.h"
|
|
#include "preprocessor.h"
|
|
#include "recvfrompipe.h"
|
|
#include "logresult.h"
|
|
|
|
#include <new>
|
|
#include <iastlutl.h>
|
|
|
|
const CHAR NUL = '\0';
|
|
|
|
extern LONG g_lPacketCount;
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: CRecvFromPipe
|
|
//
|
|
// Synopsis: This is the constructor of the CRecvFromPipe
|
|
// class
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none
|
|
//
|
|
//
|
|
// History: MKarki Created 10/22/97
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRecvFromPipe::CRecvFromPipe(
|
|
CPreProcessor *pCPreProcessor,
|
|
CHashMD5 *pCHashMD5,
|
|
CHashHmacMD5 *pCHashHmacMD5,
|
|
CClients *pCClients,
|
|
VSAFilter *pCVSAFilter,
|
|
CTunnelPassword *pCTunnelPassword,
|
|
CReportEvent *pCReportEvent
|
|
)
|
|
:m_pCPreProcessor (pCPreProcessor),
|
|
m_pCHashMD5 (pCHashMD5),
|
|
m_pCHashHmacMD5 (pCHashHmacMD5),
|
|
m_pCClients (pCClients),
|
|
m_pCVSAFilter (pCVSAFilter),
|
|
m_pCTunnelPassword (pCTunnelPassword),
|
|
m_pCReportEvent (pCReportEvent)
|
|
{
|
|
_ASSERT (
|
|
(NULL != pCPreProcessor) &&
|
|
(NULL != pCHashMD5) &&
|
|
(NULL != pCHashHmacMD5) &&
|
|
(NULL != pCClients) &&
|
|
(NULL != pCVSAFilter) &&
|
|
(NULL != pCTunnelPassword) &&
|
|
(NULL != pCReportEvent)
|
|
);
|
|
|
|
} // end of CRecvFromPipe constructor
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ~CRecvFromPipe
|
|
//
|
|
// Synopsis: This is the destructor of the CRecvFromPipe
|
|
// class
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none
|
|
//
|
|
//
|
|
// History: MKarki Created 10/22/97
|
|
//
|
|
//----------------------------------------------------------------
|
|
CRecvFromPipe::~CRecvFromPipe()
|
|
{
|
|
} // end of CRecvFromPipe destructor
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: Process
|
|
//
|
|
// Synopsis: This is the CRecvFromPipe class public method
|
|
// to start processing the packet on its way out
|
|
//
|
|
// Arguments:
|
|
// [in] CPacketRadius*
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
//
|
|
// History: MKarki Created 10/22/97
|
|
//
|
|
// Called By:
|
|
// 1) CController::CRequestSource::OnRequest Method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CRecvFromPipe::Process (
|
|
IRequest *pIRequest
|
|
)
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
HRESULT hr = S_OK;
|
|
DWORD dwCode = 0;
|
|
DWORD dwCount = 0;
|
|
DWORD dwAttribCount = 0;
|
|
IAttributesRaw *pIAttributesRaw = NULL;
|
|
IRequestState *pIRequestState = NULL;
|
|
CPacketRadius *pCPacketRadius = NULL;
|
|
LONG iasResponse, iasReason;
|
|
PACKETTYPE ePacketType;
|
|
PATTRIBUTEPOSITION pAttribPosition = NULL;
|
|
unsigned hyper uhyPacketAddress = 0;
|
|
RADIUSLOGTYPE RadiusError = RADIUS_DROPPED_PACKET;
|
|
|
|
_ASSERT (pIRequest);
|
|
|
|
__try
|
|
{
|
|
//
|
|
// get the IAttributesRaw interface now
|
|
//
|
|
hr = pIRequest->QueryInterface (
|
|
__uuidof(IAttributesRaw),
|
|
reinterpret_cast <PVOID*> (&pIAttributesRaw)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain Attributes interface in request "
|
|
"received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// split the attributes which can not fit in a radius packet
|
|
//
|
|
hr = SplitAttributes (pIAttributesRaw);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to split IAS attribute received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// convert the IAS VSA attributes to RADIUS format
|
|
//
|
|
hr = m_pCVSAFilter->radiusFromIAS (pIAttributesRaw);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to convert IAS attribute to Radius VSAs in request "
|
|
"received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the IRequestState interface now
|
|
//
|
|
hr = pIRequest->QueryInterface (
|
|
__uuidof(IRequestState),
|
|
reinterpret_cast <PVOID*> (&pIRequestState)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain request state in request received from "
|
|
"backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the CPacketRadius class object
|
|
//
|
|
hr = pIRequestState->Pop (
|
|
reinterpret_cast <unsigned hyper*> (&uhyPacketAddress)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain information from request state received "
|
|
"from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
pCPacketRadius = reinterpret_cast <CPacketRadius*> (uhyPacketAddress);
|
|
|
|
//
|
|
// if this Request object has been generated by the backend then we
|
|
// don't have a CPacketRadius class object
|
|
//
|
|
if (NULL == pCPacketRadius)
|
|
{
|
|
//
|
|
// we most probably are sending out an EAP-Challenge
|
|
//
|
|
hr= GeneratePacketRadius (
|
|
&pCPacketRadius,
|
|
pIAttributesRaw
|
|
);
|
|
if (FAILED (hr)) { __leave; }
|
|
}
|
|
|
|
//
|
|
// get the outbound packet code
|
|
//
|
|
hr = pIRequest->get_Response (&iasResponse);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain response code in request recieved from "
|
|
"backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the outbound reason code
|
|
//
|
|
hr = pIRequest->get_Reason (&iasReason);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain reason code in request recieved from "
|
|
"backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
// Log the result of the request.
|
|
IASRadiusLogResult(pIRequest, pIAttributesRaw);
|
|
|
|
// If it failed convert the reason code.
|
|
if (iasReason != S_OK)
|
|
{
|
|
ConvertReasonToRadiusError (iasReason, &RadiusError);
|
|
}
|
|
|
|
//
|
|
// convert the IASRESPONSE type to RADIUS type
|
|
//
|
|
hr = ConvertResponseToRadiusCode (
|
|
iasResponse,
|
|
&ePacketType,
|
|
pCPacketRadius
|
|
);
|
|
if (FAILED (hr)) { __leave; }
|
|
|
|
//
|
|
// check if we have Tunnel-Password attribute, if yes
|
|
// then encrypt it
|
|
//
|
|
hr = m_pCTunnelPassword->Process (
|
|
ePacketType,
|
|
pIAttributesRaw,
|
|
pCPacketRadius
|
|
);
|
|
if (FAILED (hr)) { __leave; }
|
|
|
|
//
|
|
// inject Signature Attribute if needed
|
|
//
|
|
hr = InjectSignatureIfNeeded (
|
|
ePacketType,
|
|
pIAttributesRaw,
|
|
pCPacketRadius
|
|
);
|
|
if (FAILED (hr)) { __leave; }
|
|
|
|
//
|
|
// get the count of number of request
|
|
//
|
|
hr = pIAttributesRaw->GetAttributeCount (&dwAttribCount);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain attribute count in request received from "
|
|
"backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate the attribposition structures
|
|
//
|
|
pAttribPosition = reinterpret_cast <PATTRIBUTEPOSITION> (
|
|
::CoTaskMemAlloc (
|
|
sizeof (ATTRIBUTEPOSITION)*dwAttribCount
|
|
));
|
|
if (NULL == pAttribPosition)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for attribute postion array "
|
|
"while processing request recieved from backend"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the attributes from the collection
|
|
//
|
|
hr = pIAttributesRaw->GetAttributes (
|
|
&dwAttribCount,
|
|
pAttribPosition,
|
|
0,
|
|
NULL
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to get attribute in request received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// remove the attributes from the collection now
|
|
//
|
|
hr = pIAttributesRaw->RemoveAttributes (
|
|
dwAttribCount,
|
|
pAttribPosition
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to remove attribute in request received from backend"
|
|
);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// carry out the generic packet building here
|
|
//
|
|
hr = pCPacketRadius->BuildOutPacket (
|
|
ePacketType,
|
|
pAttribPosition,
|
|
dwAttribCount
|
|
);
|
|
if (FAILED (hr)) { __leave; }
|
|
|
|
//
|
|
// sending out packet now
|
|
//
|
|
hr = m_pCPreProcessor->StartOutProcessing (pCPacketRadius);
|
|
if (FAILED (hr)) { __leave; }
|
|
|
|
}
|
|
__finally
|
|
{
|
|
|
|
//
|
|
// log event in case of both success and failure
|
|
//
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
//
|
|
// log an event that inbound packet has been processed
|
|
// successfully
|
|
//
|
|
m_pCReportEvent->Process (
|
|
RADIUS_LOG_PACKET,
|
|
pCPacketRadius->GetInCode (),
|
|
pCPacketRadius->GetInLength (),
|
|
pCPacketRadius->GetInAddress (),
|
|
NULL,
|
|
static_cast <LPVOID> (pCPacketRadius->GetInPacket())
|
|
);
|
|
|
|
//
|
|
// log an event for the outbound packet successfully send
|
|
// out
|
|
//
|
|
m_pCReportEvent->Process (
|
|
RADIUS_LOG_PACKET,
|
|
pCPacketRadius->GetOutCode (),
|
|
pCPacketRadius->GetOutLength (),
|
|
pCPacketRadius->GetOutAddress (),
|
|
NULL,
|
|
static_cast <LPVOID> (pCPacketRadius->GetOutPacket())
|
|
);
|
|
}
|
|
else
|
|
{
|
|
if (hr != RADIUS_E_ERRORS_OCCURRED)
|
|
{
|
|
IASReportEvent(
|
|
RADIUS_E_INTERNAL_ERROR,
|
|
0,
|
|
sizeof(hr),
|
|
NULL,
|
|
&hr
|
|
);
|
|
}
|
|
|
|
//
|
|
// generate event that inbound packet has been dropped
|
|
//
|
|
m_pCReportEvent->Process (
|
|
RadiusError,
|
|
pCPacketRadius->GetInCode (),
|
|
pCPacketRadius->GetInLength (),
|
|
pCPacketRadius->GetInAddress (),
|
|
NULL,
|
|
static_cast <LPVOID> (pCPacketRadius->GetInPacket())
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
// now delete the dynamically allocated memory
|
|
//
|
|
if (NULL != pAttribPosition)
|
|
{
|
|
//
|
|
// release the attributes first
|
|
//
|
|
for (dwCount = 0; dwCount < dwAttribCount; dwCount++)
|
|
{
|
|
::IASAttributeRelease (pAttribPosition[dwCount].pAttribute);
|
|
}
|
|
|
|
::CoTaskMemFree (pAttribPosition);
|
|
}
|
|
|
|
if (pIRequestState) { pIRequestState->Release (); }
|
|
|
|
if (pIAttributesRaw) { pIAttributesRaw->Release (); }
|
|
|
|
//
|
|
// delete the packet
|
|
//
|
|
if (pCPacketRadius) { delete pCPacketRadius; }
|
|
|
|
//
|
|
// now decrement the global packet reference count
|
|
//
|
|
InterlockedDecrement (&g_lPacketCount);
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::Process method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ConvertResponseToRadiusCode
|
|
//
|
|
// Synopsis: This is the CRecvFromPipe class private method
|
|
// that converts the IASRESPONSE code to RADIUS
|
|
// packet type
|
|
//
|
|
// Arguments:
|
|
// [in] IASRESPONSE
|
|
// [out] PPACKETTYPE
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 12/12/97
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CRecvFromPipe::ConvertResponseToRadiusCode (
|
|
LONG iasResponse,
|
|
PPACKETTYPE pPacketType,
|
|
CPacketRadius *pCPacketRadius
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
_ASSERT (pPacketType && pCPacketRadius);
|
|
|
|
switch (iasResponse)
|
|
{
|
|
case IAS_RESPONSE_ACCESS_ACCEPT:
|
|
*pPacketType = ACCESS_ACCEPT;
|
|
break;
|
|
case IAS_RESPONSE_ACCESS_REJECT:
|
|
*pPacketType = ACCESS_REJECT;
|
|
break;
|
|
case IAS_RESPONSE_ACCESS_CHALLENGE:
|
|
*pPacketType = ACCESS_CHALLENGE;
|
|
break;
|
|
case IAS_RESPONSE_ACCOUNTING:
|
|
*pPacketType = ACCOUNTING_RESPONSE;
|
|
break;
|
|
case IAS_RESPONSE_FORWARD_PACKET:
|
|
//
|
|
// if we are forwarding this packet
|
|
// the the packet type remains the same
|
|
//
|
|
*pPacketType = pCPacketRadius->GetInCode ();
|
|
break;
|
|
case IAS_RESPONSE_DISCARD_PACKET:
|
|
hr = RADIUS_E_ERRORS_OCCURRED;
|
|
break;
|
|
|
|
case IAS_RESPONSE_INVALID:
|
|
default:
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::ConvertResponseToRadiusCode method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: GetOutPacketInfo
|
|
//
|
|
// Synopsis: This is the CRecvFromPipe class private method
|
|
// that is used to used to get out bound packet
|
|
// information from the IAS attribute collection
|
|
//
|
|
// Arguments:
|
|
// [out] PDWORD - IP address
|
|
// [out] PWORD - UDP port
|
|
// [out] Client** - reference to CClient object
|
|
// [out] PBYTE - packet header
|
|
// [in] IAttributesRaw*
|
|
//
|
|
// Returns: BOOL status
|
|
//
|
|
// History: MKarki Created 1/9/97
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CRecvFromPipe::GetOutPacketInfo (
|
|
PDWORD pdwIPAddress,
|
|
PWORD pwPort,
|
|
IIasClient **ppIIasClient,
|
|
PBYTE pPacketHeader,
|
|
IAttributesRaw *pIAttributesRaw
|
|
)
|
|
{
|
|
BOOL bStatus = TRUE;
|
|
HRESULT hr = S_OK;
|
|
DWORD dwCount = 0;
|
|
PIASATTRIBUTE pIasAttribute = NULL;
|
|
DWORD dwAttribPosCount = COMPONENT_SPECIFIC_ATTRIBUTE_COUNT;
|
|
DWORD dwAttribIDCount = COMPONENT_SPECIFIC_ATTRIBUTE_COUNT;
|
|
ATTRIBUTEPOSITION AttribPos[COMPONENT_SPECIFIC_ATTRIBUTE_COUNT];
|
|
static DWORD AttribIDs [] =
|
|
{
|
|
IAS_ATTRIBUTE_CLIENT_IP_ADDRESS,
|
|
IAS_ATTRIBUTE_CLIENT_UDP_PORT,
|
|
IAS_ATTRIBUTE_CLIENT_PACKET_HEADER
|
|
};
|
|
|
|
_ASSERT (
|
|
(NULL != pdwIPAddress) &&
|
|
(NULL != pwPort) &&
|
|
(NULL != pPacketHeader) &&
|
|
(NULL != ppIIasClient) &&
|
|
(NULL != pIAttributesRaw)
|
|
);
|
|
|
|
__try
|
|
{
|
|
|
|
//
|
|
// get client info
|
|
//
|
|
// get the attributes from the collection
|
|
//
|
|
hr = pIAttributesRaw->GetAttributes (
|
|
&dwAttribPosCount,
|
|
AttribPos,
|
|
dwAttribIDCount,
|
|
reinterpret_cast <LPDWORD> (AttribIDs)
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to get attributes while obtaining out-bound packet "
|
|
"information"
|
|
);
|
|
__leave;
|
|
}
|
|
else if (COMPONENT_SPECIFIC_ATTRIBUTE_COUNT != dwAttribPosCount)
|
|
{
|
|
IASTracePrintf (
|
|
"Request received from backend does not have all the "
|
|
"all the required attributes"
|
|
);
|
|
hr = E_FAIL;
|
|
__leave;
|
|
}
|
|
|
|
|
|
//
|
|
// go through the attributes and get values out
|
|
//
|
|
for (dwCount = 0; dwCount < dwAttribPosCount; dwCount++)
|
|
{
|
|
pIasAttribute = AttribPos[dwCount].pAttribute;
|
|
switch (pIasAttribute->dwId)
|
|
{
|
|
case IAS_ATTRIBUTE_CLIENT_IP_ADDRESS:
|
|
_ASSERT (IASTYPE_INET_ADDR == pIasAttribute->Value.itType),
|
|
*pdwIPAddress = pIasAttribute->Value.InetAddr;
|
|
break;
|
|
|
|
case IAS_ATTRIBUTE_CLIENT_UDP_PORT:
|
|
_ASSERT (IASTYPE_INTEGER == pIasAttribute->Value.itType);
|
|
*pwPort = pIasAttribute->Value.Integer;
|
|
break;
|
|
|
|
case IAS_ATTRIBUTE_CLIENT_PACKET_HEADER:
|
|
_ASSERT (
|
|
(IASTYPE_OCTET_STRING == pIasAttribute->Value.itType) &&
|
|
(PACKET_HEADER_SIZE == pIasAttribute->Value.OctetString.dwLength)
|
|
);
|
|
//
|
|
// copy the value into the buffer provided
|
|
//
|
|
CopyMemory (
|
|
pPacketHeader,
|
|
pIasAttribute->Value.OctetString.lpValue,
|
|
PACKET_HEADER_SIZE
|
|
);
|
|
break;
|
|
default:
|
|
_ASSERT (0);
|
|
IASTracePrintf (
|
|
"Attribute:%d, not requested, is present "
|
|
"in request received from backend",
|
|
pIasAttribute->dwId
|
|
);
|
|
hr = E_FAIL;
|
|
__leave;
|
|
break;
|
|
}
|
|
|
|
} // end of for loop
|
|
|
|
//
|
|
// get client information for this RADIUS packet
|
|
//
|
|
bStatus = m_pCClients->FindObject (
|
|
*pdwIPAddress,
|
|
ppIIasClient
|
|
);
|
|
if (FALSE == bStatus)
|
|
{
|
|
in_addr sin;
|
|
sin.s_addr = *pdwIPAddress;
|
|
IASTracePrintf (
|
|
"Unable to get information for client:%s "
|
|
"while processing request received from backend",
|
|
inet_ntoa (sin)
|
|
);
|
|
hr = E_FAIL;
|
|
__leave;
|
|
}
|
|
|
|
}
|
|
__finally
|
|
{
|
|
if (SUCCEEDED (hr))
|
|
{
|
|
for (dwCount = 0; dwCount < dwAttribPosCount; dwCount++)
|
|
{
|
|
//
|
|
// now release the reference to the attributes
|
|
//
|
|
::IASAttributeRelease (AttribPos[dwCount].pAttribute);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CPacketRadius::GetOutPacketInfo method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: GeneratePacketRadius
|
|
//
|
|
// Synopsis: This is the CRecvFromPipe class private method
|
|
// that is used generate a new CPacketRadius
|
|
// class object and initialize it
|
|
//
|
|
// Arguments:
|
|
// [out] CPacketRadius**
|
|
// [in] IAttributesRaw*
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 2/6/98
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CRecvFromPipe:: GeneratePacketRadius (
|
|
CPacketRadius **ppCPacketRadius,
|
|
IAttributesRaw *pIAttributesRaw
|
|
)
|
|
{
|
|
PBYTE pPacketHeader = NULL;
|
|
DWORD dwAddress = 0;
|
|
WORD wPort = 0;
|
|
IIasClient *pIIasClient = NULL;
|
|
HRESULT hr = S_OK;
|
|
PATTRIBUTEPOSITION pAttribPosition = NULL;
|
|
|
|
|
|
_ASSERT (ppCPacketRadius && pIAttributesRaw);
|
|
|
|
//
|
|
// allocate memory for packet header
|
|
//
|
|
pPacketHeader =
|
|
reinterpret_cast <PBYTE> (::CoTaskMemAlloc (PACKET_HEADER_SIZE));
|
|
if (NULL == pPacketHeader)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate memory for packet header information "
|
|
"while generating out-bound packet"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// we need to gather information from the attribute collection
|
|
// needed to get create and initialize a CPacketRadius class
|
|
// object
|
|
//
|
|
hr = GetOutPacketInfo (
|
|
&dwAddress,
|
|
&wPort,
|
|
&pIIasClient,
|
|
pPacketHeader,
|
|
pIAttributesRaw
|
|
);
|
|
if (FAILED (hr)) { goto Cleanup; }
|
|
|
|
|
|
//
|
|
// create a new CPacketRadius class object
|
|
//
|
|
*ppCPacketRadius = new (std::nothrow) CPacketRadius (
|
|
m_pCHashMD5,
|
|
m_pCHashHmacMD5,
|
|
pIIasClient,
|
|
m_pCReportEvent,
|
|
pPacketHeader,
|
|
PACKET_HEADER_SIZE,
|
|
dwAddress,
|
|
wPort,
|
|
INVALID_SOCKET,
|
|
AUTH_PORTTYPE
|
|
);
|
|
if (NULL == *ppCPacketRadius)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to create a Packet-Radius object "
|
|
"while generating an out-bound packet"
|
|
);
|
|
pIIasClient->Release ();
|
|
hr = E_OUTOFMEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if ((FAILED (hr)) && (pPacketHeader))
|
|
{
|
|
::CoTaskMemFree (pPacketHeader);
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::GeneratePacketRadius method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: InjectSignatureIfNeeded
|
|
//
|
|
// Synopsis: This method is used to add a blank Signature attribute
|
|
// into the response if we see an EAP-Message attribute
|
|
// present
|
|
//
|
|
// Arguments:
|
|
// [in] PACKETTYPE
|
|
// [in] IAttributesRaw*
|
|
// [in] CPacketRadius*
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 11/17/98
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CRecvFromPipe::InjectSignatureIfNeeded (
|
|
/*[in]*/ PACKETTYPE ePacketType,
|
|
/*[in]*/ IAttributesRaw *pIAttributesRaw,
|
|
/*[in]*/ CPacketRadius *pCPacketRadius
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
PATTRIBUTEPOSITION pAttribPos = NULL;
|
|
|
|
_ASSERT (pIAttributesRaw && pCPacketRadius);
|
|
|
|
__try
|
|
{
|
|
if (
|
|
(ACCESS_ACCEPT != ePacketType) &&
|
|
(ACCESS_REJECT != ePacketType) &&
|
|
(ACCESS_CHALLENGE != ePacketType)
|
|
)
|
|
{__leave;}
|
|
|
|
//
|
|
// 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 "
|
|
"processing signature attribute 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 processing signature attribute in out-bound packet"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// get the EAP-Message attribute from the interface
|
|
//
|
|
DWORD dwAttrId = RADIUS_ATTRIBUTE_EAP_MESSAGE;
|
|
hr = pIAttributesRaw->GetAttributes (
|
|
&dwAttributeCount,
|
|
pAttribPos,
|
|
1,
|
|
&dwAttrId
|
|
);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to obtain information about EAP-Message attribute "
|
|
"while processing out-bound RADIUS packet"
|
|
);
|
|
}
|
|
else if (0 == dwAttributeCount)
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
bool bFound = false;
|
|
for (DWORD dwCount = 0; dwCount < dwAttributeCount; dwCount++)
|
|
{
|
|
if (
|
|
(!bFound) &&
|
|
(pCPacketRadius->IsOutBoundAttribute (
|
|
ePacketType,
|
|
pAttribPos[dwCount].pAttribute
|
|
))
|
|
)
|
|
{
|
|
bFound = true;
|
|
}
|
|
|
|
::IASAttributeRelease (pAttribPos[dwCount].pAttribute);
|
|
}
|
|
|
|
if (bFound)
|
|
{
|
|
//
|
|
// if we have an out-bound EAP-Message attribute then
|
|
// we need to insert a Signature attribute too
|
|
//
|
|
|
|
//
|
|
// create a new blank attribute
|
|
//
|
|
PIASATTRIBUTE pIasAttrib = NULL;
|
|
DWORD dwRetVal = ::IASAttributeAlloc ( 1, &pIasAttrib);
|
|
if (0 != dwRetVal)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate IAS attribute for Signature "
|
|
"while processing out-bound RADIUS packet"
|
|
);
|
|
hr = HRESULT_FROM_WIN32 (dwRetVal);
|
|
__leave;
|
|
}
|
|
|
|
//
|
|
// allocate dynamic memory for the Signature
|
|
//
|
|
pIasAttrib->Value.OctetString.lpValue =
|
|
reinterpret_cast <PBYTE>
|
|
(::CoTaskMemAlloc (SIGNATURE_SIZE));
|
|
if (NULL == pIasAttrib->Value.OctetString.lpValue)
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to allocate dynamic memory for Signature "
|
|
"attribute value while processing out-bound RADIUS packet"
|
|
);
|
|
hr = E_OUTOFMEMORY;
|
|
::IASAttributeRelease (pIasAttrib);
|
|
__leave;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// put the signature attribute with no value
|
|
// but correct size
|
|
//
|
|
pIasAttrib->dwId = RADIUS_ATTRIBUTE_SIGNATURE;
|
|
pIasAttrib->Value.itType = IASTYPE_OCTET_STRING;
|
|
pIasAttrib->Value.OctetString.dwLength = SIGNATURE_SIZE;
|
|
pIasAttrib->dwFlags = IAS_INCLUDE_IN_RESPONSE;
|
|
|
|
//
|
|
// add the attribute to the collection now
|
|
//
|
|
ATTRIBUTEPOSITION attrPos;
|
|
attrPos.pAttribute = pIasAttrib;
|
|
hr = pIAttributesRaw->AddAttributes (1, &attrPos);
|
|
if (FAILED (hr))
|
|
{
|
|
IASTracePrintf (
|
|
"Unable to add signature attribute to request while "
|
|
"processing out-bound RADIUS packet"
|
|
);
|
|
::IASAttributeRelease (pIasAttrib);
|
|
__leave;
|
|
}
|
|
|
|
IASTracePrintf (
|
|
"Signature Attribute added to out-bound RADIUS packet"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if (pAttribPos) { ::CoTaskMemFree (pAttribPos); }
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::InjectSignatureIfNeeded method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: SplitAttributes
|
|
//
|
|
// Synopsis: This method is used to split up the following
|
|
// out-bound attributes:
|
|
// 1) Reply-Message attribute
|
|
// 1) MS-Filter-VSA Attribute
|
|
//
|
|
// Arguments:
|
|
// [in] IAttributesRaw*
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 1/19/99
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CRecvFromPipe::SplitAttributes (
|
|
/*[in]*/ IAttributesRaw *pIAttributesRaw
|
|
)
|
|
{
|
|
const DWORD SPLIT_ATTRIBUTE_COUNT = 2;
|
|
static DWORD AttribIds [] = {
|
|
RADIUS_ATTRIBUTE_REPLY_MESSAGE,
|
|
MS_ATTRIBUTE_FILTER
|
|
};
|
|
|
|
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
|
|
)
|
|
{
|
|
::IASAttributeAnsiAlloc (pAttribPos[dwCount].pAttribute);
|
|
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 CRecvFromPipe::SplitAttributes method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// 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
|
|
//
|
|
// Called By: CRecvFromPipe::SplitAttributes method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT CRecvFromPipe::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.pszWide = NULL;
|
|
(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 (ppAttribArray && !dwFailed)
|
|
{
|
|
for (DWORD dwCount = 0; dwCount < dwPacketsNeeded; dwCount++)
|
|
{
|
|
::IASAttributeRelease (ppAttribArray[dwCount]);
|
|
}
|
|
}
|
|
|
|
if (ppAttribArray) {::CoTaskMemFree (ppAttribArray);}
|
|
|
|
if (pAttribPos) {::CoTaskMemFree (pAttribPos);}
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::SplitAndAdd method
|
|
|
|
//++--------------------------------------------------------------
|
|
//
|
|
// Function: ConvertReasonToRadiusError
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Arguments:
|
|
// [in] iasReason
|
|
// [out] Radius Error
|
|
//
|
|
// Returns: HRESULT - status
|
|
//
|
|
// History: MKarki Created 12/31/98
|
|
//
|
|
// Called By: CRecvFromPipe::Process method
|
|
//
|
|
//----------------------------------------------------------------
|
|
HRESULT
|
|
CRecvFromPipe::ConvertReasonToRadiusError (
|
|
/*[in]*/ LONG iasReason,
|
|
/*[out]*/ PRADIUSLOGTYPE pRadError
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
_ASSERT (pRadError);
|
|
|
|
switch (iasReason)
|
|
{
|
|
case IAS_NO_RECORD:
|
|
*pRadError = RADIUS_NO_RECORD;
|
|
break;
|
|
|
|
case IAS_MALFORMED_REQUEST:
|
|
*pRadError = RADIUS_MALFORMED_PACKET;
|
|
break;
|
|
|
|
default:
|
|
hr = E_FAIL;
|
|
break;
|
|
}
|
|
|
|
return (hr);
|
|
|
|
} // end of CRecvFromPipe::ConvertReasonToRadiusError method
|