/********************************************************************/
/** Copyright(c) 1989 Microsoft Corporation. **/
/********************************************************************/
//***
//
// Filename: receive.c
//
// Description: This module contains code to handle all packets received.
//
// History:
// Oct 25,1993. NarenG Created Original version.
//
//
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h> // needed for winbase.h
#include <windows.h> // Win32 base API's
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <lmcons.h>
#include <raserror.h>
#include <mprerror.h>
#include <mprlog.h>
#include <rasman.h>
#include <rtutils.h>
#include <rasppp.h>
#include <pppcp.h>
#include <ppp.h>
#include <smaction.h>
#include <smevents.h>
#include <receive.h>
#include <auth.h>
#include <lcp.h>
#include <timer.h>
#include <util.h>
#include <worker.h>
#define INCL_RASAUTHATTRIBUTES
#include <ppputil.h>
//**
//
// Call: ReceiveConfigReq
//
// Returns: None.
//
// Description: Handles an incomming CONFIG_REQ packet and related state
// transitions.
//
VOID
ReceiveConfigReq(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
BOOL fAcked;
switch( pCpCb->State )
{
case FSM_OPENED:
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
if( !FsmSendConfigResult( pPcb, CpIndex, pRecvConfig, &fAcked ) )
return;
pCpCb->State = ( fAcked ) ? FSM_ACK_SENT : FSM_REQ_SENT;
break;
case FSM_STOPPED:
InitRestartCounters( pPcb, pCpCb );
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
//
// Fallthru
//
case FSM_REQ_SENT:
case FSM_ACK_SENT:
if ( !FsmSendConfigResult( pPcb, CpIndex, pRecvConfig, &fAcked ) )
return;
pCpCb->State = ( fAcked ) ? FSM_ACK_SENT : FSM_REQ_SENT;
break;
case FSM_ACK_RCVD:
if ( !FsmSendConfigResult( pPcb, CpIndex, pRecvConfig, &fAcked ) )
return;
if( fAcked )
{
pCpCb->State = FSM_OPENED;
FsmThisLayerUp( pPcb, CpIndex );
}
break;
case FSM_CLOSED:
FsmSendTermAck( pPcb, CpIndex, pRecvConfig );
break;
case FSM_CLOSING:
case FSM_STOPPING:
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog(2,"Illegal transition->ConfigReq received while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveConfigAck
//
// Returns: none.
//
// Description: Handles an incomming CONFIG_ACK packet and related state
// transitions.
//
VOID
ReceiveConfigAck(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
//
// The Id of the Ack HAS to match the Id of the last request sent
// If it is different, then we should silently discard it.
//
if ( pRecvConfig->Id != pCpCb->LastId )
{
PppLog(1,
"Config Ack rcvd. on port %d silently discarded. Invalid Id",
pPcb->hPort );
return;
}
switch( pCpCb->State )
{
case FSM_REQ_SENT:
if ( !FsmConfigResultReceived( pPcb, CpIndex, pRecvConfig ) )
return;
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
InitRestartCounters( pPcb, pCpCb );
pCpCb->State = FSM_ACK_RCVD;
break;
case FSM_ACK_SENT:
if ( !FsmConfigResultReceived( pPcb, CpIndex, pRecvConfig ) )
return;
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
InitRestartCounters( pPcb, pCpCb );
pCpCb->State = FSM_OPENED;
FsmThisLayerUp( pPcb, CpIndex );
break;
case FSM_OPENED:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
//
// Fallthru
//
case FSM_ACK_RCVD:
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
pCpCb->State = FSM_REQ_SENT;
break;
case FSM_CLOSED:
case FSM_STOPPED:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
//
// Out of Sync; kill the remote
//
FsmSendTermAck( pPcb, CpIndex, pRecvConfig );
break;
case FSM_CLOSING:
case FSM_STOPPING:
//
// We are attempting to close connection
// wait for timeout to resend a Terminate Request
//
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
PPP_ASSERT( pCpCb->State < 10 );
PppLog(2,"Illegal transition->ConfigAck received while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveConfigNakRej
//
// Returns: none.
//
// Description: Handles an incomming CONFIG_NAK or CONFIF_REJ packet and
// related state transitions.
//
VOID
ReceiveConfigNakRej(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
//
// The Id of the Nak/Rej HAS to match the Id of the last request sent
// If it is different, then we should silently discard it.
//
if ( pRecvConfig->Id != pCpCb->LastId )
{
PppLog(1,"Config Nak/Rej on port %d silently discarded. Invalid Id",
pPcb->hPort );
return;
}
switch( pCpCb->State )
{
case FSM_REQ_SENT:
case FSM_ACK_SENT:
if ( !FsmConfigResultReceived( pPcb, CpIndex, pRecvConfig ) )
return;
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
InitRestartCounters( pPcb, pCpCb );
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
break;
case FSM_OPENED:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
//
// Fallthru
//
case FSM_ACK_RCVD:
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
pCpCb->State = FSM_REQ_SENT;
break;
case FSM_CLOSED:
case FSM_STOPPED:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
//
// Out of Sync; kill the remote
//
FsmSendTermAck( pPcb, CpIndex, pRecvConfig );
break;
case FSM_CLOSING:
case FSM_STOPPING:
//
// We are attempting to close connection
// wait for timeout to resend a Terminate Request
//
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
PPP_ASSERT( pCpCb->State < 10 );
PppLog(2,"Illegal transition->CfgNakRej received while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveTermReq
//
// Returns: none
//
// Description: Handles an incomming TERM_REQ packet and
// related state transitions.
//
VOID
ReceiveTermReq(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
//
// We are shutting down so do not resend any outstanding request.
//
RemoveFromTimerQ( pPcb->dwPortId,
pCpCb->LastId,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
if ( CpIndex == LCP_INDEX )
{
//
// If we are receiving a terminate request, remove any hangup event
// that we may have put into the timer queue if there was a previous
// LCP TermReq sent.
RemoveFromTimerQ( pPcb->dwPortId,
0,
0,
FALSE,
TIMER_EVENT_HANGUP );
}
switch( pCpCb->State )
{
case FSM_OPENED:
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
//
// Zero restart counters
//
pCpCb->ConfigRetryCount = 0;
pCpCb->TermRetryCount = 0;
pCpCb->NakRetryCount = 0;
pCpCb->RejRetryCount = 0;
FsmSendTermAck( pPcb, CpIndex, pConfig );
pCpCb->State = FSM_STOPPING;
break;
case FSM_ACK_RCVD:
case FSM_ACK_SENT:
case FSM_REQ_SENT:
FsmSendTermAck( pPcb, CpIndex, pConfig );
pCpCb->State = FSM_REQ_SENT;
break;
case FSM_CLOSED:
case FSM_CLOSING:
case FSM_STOPPED:
case FSM_STOPPING:
FsmSendTermAck( pPcb, CpIndex, pConfig );
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog(2,"Illegal transition->CfgNakRej received while in %s state",
FsmStates[pCpCb->State] );
break;
}
if ( CpIndex == LCP_INDEX )
{
pPcb->fFlags |= PCBFLAG_RECVD_TERM_REQ;
//
// If we got a terminate request from the remote peer.
//
if ( pPcb->fFlags & PCBFLAG_DOING_CALLBACK ) {
//
// If we are the server side we need to tell the server
// to callback.
//
if ( pPcb->fFlags & PCBFLAG_IS_SERVER ) {
PPPDDM_CALLBACK_REQUEST PppDdmCallbackRequest;
PppDdmCallbackRequest.fUseCallbackDelay = TRUE;
PppDdmCallbackRequest.dwCallbackDelay =
pPcb->ConfigInfo.dwCallbackDelay;
strcpy( PppDdmCallbackRequest.szCallbackNumber,
pPcb->szCallbackNumber );
PppLog( 2, "Notifying server to callback at %s, delay = %d",
PppDdmCallbackRequest.szCallbackNumber,
PppDdmCallbackRequest.dwCallbackDelay );
NotifyCaller( pPcb,
PPPDDMMSG_CallbackRequest,
&PppDdmCallbackRequest );
}
//
// If we are the client?
//
}
else
{
//
// Check to see if the remote peer sent a Terminate Request reason
//
DWORD dwLength = WireToHostFormat16( pConfig->Length );
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
DWORD dwRetCode = ERROR_PPP_LCP_TERMINATED;
if ( dwLength == PPP_CONFIG_HDR_LEN + 12 )
{
//
// Check to see if this is our signature
//
if ( ( WireToHostFormat32( pConfig->Data ) ==
pLcpCb->Remote.Work.MagicNumber )
&&
( WireToHostFormat32( pConfig->Data + 4 ) == 3984756 ) )
{
dwRetCode = WireToHostFormat32( pConfig->Data + 8 );
//
// Should not be larger than the highest winerror.h
//
if ( dwRetCode > ERROR_DHCP_ADDRESS_CONFLICT )
{
//
// Ignore this error
//
dwRetCode = ERROR_PPP_LCP_TERMINATED;
}
if ( dwRetCode == ERROR_NO_LOCAL_ENCRYPTION )
{
dwRetCode = ERROR_NO_REMOTE_ENCRYPTION;
}
else if ( dwRetCode == ERROR_NO_REMOTE_ENCRYPTION )
{
dwRetCode = ERROR_NO_LOCAL_ENCRYPTION;
}
}
}
if ( pCpCb->dwError == NO_ERROR )
{
pCpCb->dwError = dwRetCode;
}
if ( !( pPcb->fFlags & PCBFLAG_IS_SERVER ) )
{
NotifyCallerOfFailure( pPcb, pCpCb->dwError );
//
// If we are a client check to see if the server disconnected us
// because of autodisconnect.
//
if ( ( dwRetCode == ERROR_IDLE_DISCONNECTED ) ||
( dwRetCode == ERROR_PPP_SESSION_TIMEOUT ) )
{
CHAR * pszPortName = pPcb->szPortName;
PppLogInformation(
( dwRetCode == ERROR_IDLE_DISCONNECTED )
? ROUTERLOG_CLIENT_AUTODISCONNECT
: ROUTERLOG_PPP_SESSION_TIMEOUT,
1,
&pszPortName );
}
}
//
// If the remote LCP is terminating we MUST wait at least one
// restart timer time period before we hangup.
//
InsertInTimerQ( pPcb->dwPortId,
pPcb->hPort,
0,
0,
FALSE,
TIMER_EVENT_HANGUP,
pPcb->RestartTimer );
}
}
else
{
if ( pCpCb->dwError == NO_ERROR )
{
pCpCb->dwError = ERROR_PPP_NCP_TERMINATED;
}
FsmThisLayerFinished( pPcb, CpIndex, FALSE );
}
}
//**
//
// Call: ReceiveTermAck
//
// Returns: none
//
// Description: Handles an incomming TERM_ACK packet and
// related state transitions.
//
VOID
ReceiveTermAck(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
//
// The Id of the Term Ack HAS to match the Id of the last request sent
// If it is different, then we should silently discard it.
//
if ( pRecvConfig->Id != pCpCb->LastId )
{
PppLog(1,"Term Ack with on port %d silently discarded. Invalid Id",
pPcb->hPort );
return;
}
switch( pCpCb->State )
{
case FSM_OPENED:
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
if ( !FsmSendConfigReq( pPcb, CpIndex, FALSE ) )
return;
pCpCb->State = FSM_REQ_SENT;
break;
case FSM_ACK_RCVD:
pCpCb->State = FSM_REQ_SENT;
break;
case FSM_CLOSING:
case FSM_STOPPING:
//
// Remove the timeout for this Id from the timer Q
//
RemoveFromTimerQ( pPcb->dwPortId,
pRecvConfig->Id,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
if ( !FsmThisLayerFinished( pPcb, CpIndex, TRUE ) )
return;
pCpCb->State = ( pCpCb->State == FSM_CLOSING ) ? FSM_CLOSED
: FSM_STOPPED;
break;
case FSM_REQ_SENT:
case FSM_ACK_SENT:
case FSM_CLOSED:
case FSM_STOPPED:
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2,"Illegal transition->CfgNakRej received while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveUnknownCode
//
// Returns: none.
//
// Description: Handles a packet with an unknown/unrecognizable code and
// related state transitions.
//
VOID
ReceiveUnknownCode(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
PppLog( 2, "Received packet with unknown code %d", pConfig->Code );
switch( pCpCb->State )
{
case FSM_STOPPED:
case FSM_STOPPING:
case FSM_OPENED:
case FSM_ACK_SENT:
case FSM_ACK_RCVD:
case FSM_REQ_SENT:
case FSM_CLOSING:
case FSM_CLOSED:
FsmSendCodeReject( pPcb, CpIndex, pConfig );
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2, "Illegal transition->UnknownCode rcvd while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveDiscardReq
//
// Returns: none
//
// Description: Handles an incomming DISCARD_REQ packet and
// related state transitions.
//
VOID
ReceiveDiscardReq(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
//
// Simply discard the packet.
//
PppLog( 2, "Illegal transition->Discard rqst rcvd while in %s state",
FsmStates[pCpCb->State] );
}
//**
//
// Call: ReceiveEchoReq
//
// Returns: none
//
// Description: Handles an incomming ECHO_REQ packet and
// related state transitions.
//
VOID
ReceiveEchoReq(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
//
// Silently discard this packet if LCP is not in an opened state
//
if ( !IsLcpOpened( pPcb ) )
return;
switch( pCpCb->State )
{
case FSM_STOPPED:
case FSM_STOPPING:
case FSM_ACK_SENT:
case FSM_ACK_RCVD:
case FSM_REQ_SENT:
case FSM_CLOSING:
case FSM_CLOSED:
case FSM_STARTING:
case FSM_INITIAL:
break;
case FSM_OPENED:
FsmSendEchoReply( pPcb, CpIndex, pConfig );
break;
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2, "Illegal transition->UnknownCode rcvd while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveEchoReply
//
// Returns: none
//
// Description: Handles an incomming ECHO_REPLY packet and
// related state transitions. The only Echo request we send
// is to calculate the link speed, so we assume that we get called
// only when we receive the reply.
//
VOID
ReceiveEchoReply(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
DWORD dwLength = PPP_PACKET_HDR_LEN +
WireToHostFormat16( pConfig->Length );
if ( dwLength > LCP_DEFAULT_MRU )
{
dwLength = LCP_DEFAULT_MRU;
}
if ( dwLength < PPP_PACKET_HDR_LEN + PPP_CONFIG_HDR_LEN + 4 )
{
PppLog( 1, "Silently discarding invalid echo response packet on port=%d",
pPcb->hPort );
return;
}
//
// Pass on the echo reply to whoever send the echo request.
//
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) && ( RAS_DEVICE_TYPE(pPcb->dwDeviceType) == RDT_PPPoE) && pPcb->dwIdleBeforeEcho )
{
if ( pPcb->fEchoRequestSend )
{
//check to see if we are getting the same text back on the echo
if ( !memcmp( pConfig->Data+ 4, PPP_DEF_ECHO_TEXT, strlen(PPP_DEF_ECHO_TEXT)) )
{
//got the echo response for our echo request
//so reset the flag.
pPcb->fEchoRequestSend = 0;
pPcb->dwNumEchoResponseMissed = 0;
}
}
}
}
//**
//
// Call: ReceiveCodeRej
//
// Returns: none
//
// Description: Handles an incomming CODE_REJ packet and
// related state transitions.
//
VOID
ReceiveCodeRej(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pConfig
)
{
pConfig = (PPP_CONFIG*)(pConfig->Data);
PppLog( 2, "PPP Code Reject rcvd, rejected Code = %d", pConfig->Code );
//
// First check to see if these codes may be rejected without
// affecting implementation. Permitted code rejects
//
if ( CpIndex == LCP_INDEX )
{
switch( pConfig->Code )
{
case CONFIG_REQ:
case CONFIG_ACK:
case CONFIG_NAK:
case CONFIG_REJ:
case TERM_REQ:
case TERM_ACK:
case CODE_REJ:
case PROT_REJ:
case ECHO_REQ:
case ECHO_REPLY:
case DISCARD_REQ:
//
// Unpermitted code rejects.
//
break;
case IDENTIFICATION:
case TIME_REMAINING:
//
// Turn these off.
//
pPcb->ConfigInfo.dwConfigMask &= (~PPPCFG_UseLcpExtensions);
//
// no break here no purpose.
//
default:
//
// Permitted code rejects, we can still work.
//
switch ( pCpCb->State )
{
case FSM_ACK_RCVD:
pCpCb->State = FSM_REQ_SENT;
break;
default:
break;
}
return;
}
}
//
// Log this error
//
//PPPLogEvent( PPP_EVENT_RECV_UNKNOWN_CODE, pConfig->Code );
PppLog( 1, "Unpermitted code reject rcvd. on port %d", pPcb->hPort );
//
// Actually the remote side did not reject the protocol, it rejected
// the code. But for all practical purposes we cannot talk with
// the corresponding CP on the remote side. This is actually an
// implementation error in the remote side.
//
pCpCb->dwError = ERROR_PPP_NOT_CONVERGING;
RemoveFromTimerQ( pPcb->dwPortId,
pCpCb->LastId,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
switch ( pCpCb->State )
{
case FSM_CLOSING:
if ( !FsmThisLayerFinished( pPcb, CpIndex, TRUE ) )
return;
pCpCb->State = FSM_CLOSED;
break;
case FSM_REQ_SENT:
case FSM_ACK_RCVD:
case FSM_ACK_SENT:
case FSM_STOPPING:
if ( !FsmThisLayerFinished( pPcb, CpIndex, TRUE ) )
return;
pCpCb->State = FSM_STOPPED;
break;
case FSM_OPENED:
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
InitRestartCounters( pPcb, pCpCb );
FsmSendTermReq( pPcb, CpIndex );
pCpCb->State = FSM_STOPPING;
break;
case FSM_CLOSED:
case FSM_STOPPED:
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2, "Illegal transition->UnknownCode rcvd while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: ReceiveProtocolRej
//
// Returns: none
//
// Description: Handles an incomming PROT_REJ packet and
// related state transitions.
//
VOID
ReceiveProtocolRej(
IN PCB * pPcb,
IN PPP_PACKET * pPacket
)
{
PPP_CONFIG * pRecvConfig = (PPP_CONFIG *)(pPacket->Information);
DWORD dwProtocol = WireToHostFormat16( pRecvConfig->Data );
CPCB * pCpCb;
DWORD CpIndex;
PppLog( 2, "PPP Protocol Reject, Protocol = %x", dwProtocol );
CpIndex = GetCpIndexFromProtocol( dwProtocol );
if ( CpIndex == (DWORD)-1 )
{
return;
}
//
// "Protocol Reject" in the middle of LCP (RXJ- in state 2-9) should cause
// immediate termination.
//
if ( LCP_INDEX == CpIndex )
{
pPcb->LcpCb.dwError = ERROR_PPP_NOT_CONVERGING;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return;
}
//
// If LCP is not in the opened state we silently discard this packet
//
if ( !IsLcpOpened( pPcb ) )
{
PppLog(1,"Protocol Rej silently discarded on port %d. Lcp not open",
pPcb->hPort );
return;
}
//
// If remote peer rejected an Authentication protocol, then bring down
// the link (LCP) since this should never happen.
//
if ( IsCpIndexOfAp( CpIndex ) )
{
CpIndex = LCP_INDEX;
pCpCb = GetPointerToCPCB( pPcb, LCP_INDEX );
pCpCb->dwError = ERROR_AUTH_PROTOCOL_REJECTED;
}
else
{
pCpCb = GetPointerToCPCB( pPcb, CpIndex );
pCpCb->dwError = ERROR_PPP_CP_REJECTED;
}
RemoveFromTimerQ( pPcb->dwPortId,
pCpCb->LastId,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT );
switch ( pCpCb->State )
{
case FSM_CLOSING:
if ( !FsmThisLayerFinished( pPcb, CpIndex, TRUE ) )
return;
pCpCb->State = FSM_CLOSED;
break;
case FSM_REQ_SENT:
case FSM_ACK_RCVD:
case FSM_ACK_SENT:
case FSM_STOPPING:
if ( !FsmThisLayerFinished( pPcb, CpIndex, TRUE ) )
return;
pCpCb->State = FSM_STOPPED;
break;
case FSM_OPENED:
if ( !FsmThisLayerDown( pPcb, CpIndex ) )
return;
InitRestartCounters( pPcb, pCpCb );
FsmSendTermReq( pPcb, CpIndex );
pCpCb->State = FSM_STOPPING;
break;
case FSM_CLOSED:
case FSM_STOPPED:
break;
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2, "Illegal transition->UnknownCode rcvd while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: NbfCpCompletionRoutine
//
// Returns: none
//
// Description: Called by a NBFCP when it has finished preparing a respose to
// the client's add name request.
//
VOID
NbfCpCompletionRoutine(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pSendConfig
)
{
BOOL fAcked = FALSE;
DWORD dwLength;
DWORD dwRetCode;
switch( pSendConfig->Code )
{
case CONFIG_ACK:
fAcked = TRUE;
break;
case CONFIG_NAK:
if ( pCpCb->NakRetryCount > 0 )
{
(pCpCb->NakRetryCount)--;
}
else
{
pCpCb->dwError = ERROR_PPP_NOT_CONVERGING;
NotifyCallerOfFailure( pPcb, pCpCb->dwError );
return;
}
break;
case CONFIG_REJ:
if ( pCpCb->RejRetryCount > 0 )
{
(pCpCb->RejRetryCount)--;
}
else
{
pCpCb->dwError = ERROR_PPP_NOT_CONVERGING;
FsmClose( pPcb, CpIndex );
return;
}
break;
default:
break;
}
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
dwLength = WireToHostFormat16( pSendConfig->Length );
if ( ( dwLength + PPP_PACKET_HDR_LEN ) > LCP_DEFAULT_MRU )
{
pCpCb->dwError = ERROR_PPP_INVALID_PACKET;
FsmClose( pPcb, CpIndex );
return;
}
else
{
CopyMemory( pPcb->pSendBuf->Information, pSendConfig, dwLength );
}
LogPPPPacket(FALSE,pPcb,pPcb->pSendBuf,dwLength+PPP_PACKET_HDR_LEN);
if ( ( dwRetCode = PortSendOrDisconnect( pPcb,
(dwLength + PPP_PACKET_HDR_LEN)))
!= NO_ERROR )
{
return;
}
switch ( pCpCb->State )
{
case FSM_ACK_RCVD:
if ( fAcked )
{
pCpCb->State = FSM_OPENED;
FsmThisLayerUp( pPcb, CpIndex );
}
break;
case FSM_OPENED:
case FSM_ACK_SENT:
case FSM_REQ_SENT:
case FSM_STOPPED:
pCpCb->State = fAcked ? FSM_ACK_SENT : FSM_REQ_SENT;
break;
case FSM_CLOSING:
case FSM_STOPPING:
//
// no transition
//
break;
case FSM_CLOSED:
case FSM_STARTING:
case FSM_INITIAL:
default:
PPP_ASSERT( pCpCb->State < 10 );
PppLog( 2, "Illegal transition->ConfigReq rcvd while in %s state",
FsmStates[pCpCb->State] );
break;
}
}
//**
//
// Call: CompletionRoutine
//
// Returns: none
//
// Description: Called by a CP when it has completed an asynchronous operation.
//
VOID
CompletionRoutine(
IN HCONN hPortOrConnection,
IN DWORD Protocol,
IN PPP_CONFIG * pSendConfig,
IN DWORD dwError
)
{
DWORD dwRetCode;
CPCB * pCpCb;
PCB * pPcb;
HPORT hPort;
DWORD CpIndex = GetCpIndexFromProtocol( Protocol );
if ( CpIndex == (DWORD)-1 )
{
return;
}
PppLog( 2, "CompletionRoutine called for protocol %x",
CpTable[CpIndex].CpInfo.Protocol );
dwRetCode = RasBundleGetPort( NULL, (HCONN)hPortOrConnection, &hPort );
if ( dwRetCode != NO_ERROR )
{
return;
}
pPcb = GetPCBPointerFromhPort( hPort );
if ( pPcb == (PCB *)NULL )
{
return;
}
pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return;
}
if ( dwError != NO_ERROR )
{
pCpCb->dwError = dwError;
PppLog( 1,
"The control protocol for %x on port %d, returned error %d",
CpTable[CpIndex].CpInfo.Protocol, hPort, dwError );
FsmClose( pPcb, CpIndex );
return;
}
switch( Protocol )
{
case PPP_NBFCP_PROTOCOL:
NbfCpCompletionRoutine( pPcb, CpIndex, pCpCb, pSendConfig );
break;
case PPP_IPXCP_PROTOCOL:
//
// If IPXCP is still in the OPENED state then call ThisLayerUp
// otherwise ignore this call.
//
if ( pCpCb->State == FSM_OPENED )
{
FsmThisLayerUp( pPcb, CpIndex );
}
break;
default:
RTASSERT( FALSE );
break;
}
return;
}
//**
//
// Call: FsmConfigResultReceived
//
// Returns: TRUE - Success
// FALSE - Otherwise
//
// Description: This call will process a Config result ie Ack/Nak/Rej.
//
BOOL
FsmConfigResultReceived(
IN PCB * pPcb,
IN DWORD CpIndex,
IN PPP_CONFIG * pRecvConfig
)
{
DWORD dwRetCode;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return( FALSE );
}
switch( pRecvConfig->Code )
{
case CONFIG_NAK:
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpConfigNakReceived)(
pCpCb->pWorkBuf, pRecvConfig );
break;
case CONFIG_ACK:
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpConfigAckReceived)(
pCpCb->pWorkBuf, pRecvConfig );
break;
case CONFIG_REJ:
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpConfigRejReceived)(
pCpCb->pWorkBuf, pRecvConfig );
break;
default:
return( FALSE );
}
if ( dwRetCode != NO_ERROR )
{
if ( dwRetCode == ERROR_PPP_INVALID_PACKET )
{
PppLog( 1,
"Invalid packet received on port %d silently discarded",
pPcb->hPort );
}
else
{
PppLog(1,
"The control protocol for %x on port %d returned error %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort, dwRetCode );
if ( CpTable[CpIndex].CpInfo.Protocol == PPP_CCP_PROTOCOL )
{
//
// If we need to force encryption but encryption negotiation
// failed then we drop the link
//
if ( pPcb->ConfigInfo.dwConfigMask &
(PPPCFG_RequireEncryption |
PPPCFG_RequireStrongEncryption ) )
{
PppLog( 1, "Encryption is required" );
switch( dwRetCode )
{
case ERROR_NO_LOCAL_ENCRYPTION:
case ERROR_NO_REMOTE_ENCRYPTION:
pPcb->LcpCb.dwError = dwRetCode;
break;
case ERROR_PROTOCOL_NOT_CONFIGURED:
pPcb->LcpCb.dwError = ERROR_NO_LOCAL_ENCRYPTION;
break;
default:
pPcb->LcpCb.dwError = ERROR_NO_REMOTE_ENCRYPTION;
break;
}
//
// We need to send an Accounting Stop if RADIUS sends
// an Access Accept but we still drop the line.
//
pPcb->fFlags |= PCBFLAG_SERVICE_UNAVAILABLE;
//
// If we do FsmClose for CCP instead, the other side may
// conclude that PPP was negotiated successfully before we
// send an LCP Terminate Request.
//
FsmClose( pPcb, LCP_INDEX );
return( FALSE );
}
}
pCpCb->dwError = dwRetCode;
FsmClose( pPcb, CpIndex );
}
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: ReceiveIdentification
//
// Returns: none
//
// Description: Handles an incomming IDENTIFICATION packet.
//
VOID
ReceiveIdentification(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
DWORD dwLength = WireToHostFormat16( pRecvConfig->Length );
RAS_AUTH_ATTRIBUTE * pAttributes = pPcb->pUserAttributes;
BYTE MSRASClient[MAX_COMPUTERNAME_LENGTH
+ sizeof(MS_RAS_WITH_MESSENGER) + 10];
PBYTE pbTempBuf = NULL;
BYTE MSRASClientVersion[30];
DWORD dwIndex = 0;
DWORD dwRetCode = NO_ERROR;
PppLog( 2, "Identification packet received" );
//
// If we are a client we just discard this packet.
//
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) )
{
return;
}
//
// check to see if the identification is version.
// if version store it in version field
// or else store it in computer name field
//
// If this is not our identification message
//
if ( (dwLength < PPP_CONFIG_HDR_LEN+4+strlen(MS_RAS_WITH_MESSENGER)) ||
(dwLength > PPP_CONFIG_HDR_LEN+4+
strlen(MS_RAS_WITH_MESSENGER)+MAX_COMPUTERNAME_LENGTH))
{
*(pPcb->pBcb->szComputerName) = (CHAR)NULL;
*(pPcb->pBcb->szClientVersion) = (CHAR)NULL;
return;
}
for (dwIndex = 0;
pAttributes[dwIndex].raaType != raatMinimum;
dwIndex ++);
//
// If theres no space in the user attributes list
// expand the list for the one new attribute being
// added.
//
if(dwIndex >= PPP_NUM_USER_ATTRIBUTES)
{
pAttributes = RasAuthAttributeCopyWithAlloc(
pPcb->pUserAttributes, 1);
PppLog(1, "ReceiveIdentification: allocated new user list %p",
pAttributes);
if(NULL == pAttributes)
{
PppLog(1, "ReceiveIdentification: Failed to allocate attributes. %d",
GetLastError());
return;
}
}
//
// Convert the ppp message into a string
//
pbTempBuf = LocalAlloc(LPTR, dwLength );
if ( NULL == pbTempBuf )
{
PppLog( 1,
"ReceiveIdentification: Failed to alloc memory %d",
GetLastError()
);
}
memcpy ( pbTempBuf,
pRecvConfig->Data+4,
dwLength - PPP_CONFIG_HDR_LEN - 4
);
//
// And add the attribs to the list of User Attributes
//
if ( strstr ( pbTempBuf, MS_RAS_WITHOUT_MESSENGER ) ||
strstr ( pbTempBuf, MS_RAS_WITH_MESSENGER )
)
{
//
// computer name
//
ZeroMemory( pPcb->pBcb->szComputerName,
sizeof(pPcb->pBcb->szComputerName));
CopyMemory( pPcb->pBcb->szComputerName,
pbTempBuf,
dwLength - PPP_CONFIG_HDR_LEN - 4 );
//
// Vendor-Id
//
HostToWireFormat32( 311, MSRASClient );
//
// Vendor-Type: MS-RAS-Client - New
//
MSRASClient[4] = 34;
//
// Length
//
MSRASClient[5] = 2 + (BYTE) (dwLength - PPP_CONFIG_HDR_LEN - 4);
//
// Vendor-Id
//
CopyMemory ( MSRASClient + 6,
pPcb->pBcb->szComputerName,
dwLength - PPP_CONFIG_HDR_LEN - 4) ;
pAttributes[dwIndex].raaType = raatReserved;
dwRetCode = RasAuthAttributeInsert( dwIndex++,
pAttributes,
raatVendorSpecific,
FALSE,
6 + dwLength - PPP_CONFIG_HDR_LEN - 4,
&MSRASClient );
if ( NO_ERROR != dwRetCode )
{
PppLog( 2, "Error inserting user attribute = %s, %d",
pPcb->pBcb->szComputerName, dwRetCode );
}
PppLog(2, "Remote identification = %s", pPcb->pBcb->szComputerName);
}
else
{
//
// version
//
ZeroMemory( pPcb->pBcb->szClientVersion,
sizeof( pPcb->pBcb->szClientVersion ) );
CopyMemory( pPcb->pBcb->szClientVersion,
pRecvConfig->Data+4,
dwLength - PPP_CONFIG_HDR_LEN - 4 );
//
// Vendor-Id
//
HostToWireFormat32( 311, MSRASClientVersion );
//
// Vendor-Type: MS-RAS-Client-Version
//
MSRASClientVersion[4] = 35;
//
// Vendor-Length
//
MSRASClientVersion[5] = (BYTE)(2 + dwLength - PPP_CONFIG_HDR_LEN - 4);
CopyMemory( MSRASClientVersion + 6,
pPcb->pBcb->szClientVersion,
dwLength - PPP_CONFIG_HDR_LEN - 4 );
pAttributes[dwIndex].raaType = raatReserved;
dwRetCode = RasAuthAttributeInsert( dwIndex++,
pAttributes,
raatVendorSpecific,
FALSE,
6 + dwLength - PPP_CONFIG_HDR_LEN - 4,
&MSRASClientVersion );
if ( dwRetCode != NO_ERROR )
{
PppLog( 2, "Error inserting user attribute = %s, %d", pPcb->pBcb->szClientVersion, dwRetCode );
}
PppLog( 2, "Remote identification = %s", pPcb->pBcb->szClientVersion );
}
pAttributes[dwIndex].raaType = raatMinimum;
pAttributes[dwIndex].dwLength = 0;
pAttributes[dwIndex].Value = NULL;
//
// If we allocated a new attribute list, free the old list and save
// the new one.
//
if(pPcb->pUserAttributes != pAttributes)
{
PppLog(2, "ReceiveIdentification: Replaced userlist %p with %p",
pPcb->pUserAttributes,
pAttributes);
RasAuthAttributeDestroy(pPcb->pUserAttributes);
pPcb->pUserAttributes = pAttributes;
}
if ( pbTempBuf )
LocalFree(pbTempBuf);
return;
}
//**
//
// Call: ReceiveTimeRemaining
//
// Returns: none
//
// Description: Handles an incomming TIME_REMAINING packet.
//
VOID
ReceiveTimeRemaining(
IN PCB * pPcb,
IN DWORD CpIndex,
IN CPCB * pCpCb,
IN PPP_CONFIG * pRecvConfig
)
{
DWORD dwLength = WireToHostFormat16( pRecvConfig->Length );
PppLog( 2, "Time Remaining packet received");
//
// If we are a server we just discard this packet.
//
if ( pPcb->fFlags & PCBFLAG_IS_SERVER )
{
return;
}
//
// If this is not our time remaining message
//
if ( dwLength != PPP_CONFIG_HDR_LEN + 8 + strlen( MS_RAS ) )
{
return;
}
return;
}