able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/rras/ras/ppp/engine/smaction.c

2094 lines
57 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/********************************************************************/
/** Copyright(c) 1989 Microsoft Corporation. **/
/********************************************************************/
//***
//
// Filename: smaction.c
//
// Description: This module contains actions that occure during state
// transitions withing the Finite State Machine for PPP.
//
// 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 <ntlsapi.h>
#include <lmcons.h>
#include <raserror.h>
#include <rasman.h>
#include <rtutils.h>
#include <mprlog.h>
#include <mprerror.h>
#include <rasppp.h>
#include <pppcp.h>
#include <ppp.h>
#include <smaction.h>
#include <smevents.h>
#include <receive.h>
#include <auth.h>
#include <callback.h>
#include <receive.h>
#include <lcp.h>
#include <timer.h>
#include <util.h>
#include <worker.h>
#include <bap.h>
#define INCL_RASAUTHATTRIBUTES
#include <ppputil.h>
extern WORD WLinkDiscriminator; // Next Link Discriminator to use
//**
//
// Call: FsmSendConfigReq
//
// Returns: TRUE - Config Req. sent successfully.
// FALSE - Otherwise
//
// Description: Called to send a configuration request
//
BOOL
FsmSendConfigReq(
IN PCB * pPcb,
IN DWORD CpIndex,
IN BOOL fTimeout
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
DWORD dwLength;
if ( pCpCb == NULL )
{
return( FALSE );
}
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpMakeConfigRequest)(
pCpCb->pWorkBuf,
pSendConfig,
LCP_DEFAULT_MRU
- PPP_PACKET_HDR_LEN );
if ( dwRetCode != NO_ERROR )
{
pCpCb->dwError = dwRetCode;
PppLog( 1,"The control protocol for %x, returned error %d",
CpTable[CpIndex].CpInfo.Protocol, dwRetCode );
PppLog(1,"while making a configure request on port %d",pPcb->hPort);
FsmClose( pPcb, CpIndex );
return( FALSE );
}
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = CONFIG_REQ;
//
// If we are resending a configure request because of a timeout, we do not
// use the id of the previous configure request, instead we get a new Id.
// Id we do not, then the wrong Config-Req's and Config-Acks may be matched
// up and we start getting crossed connections.
//
pSendConfig->Id = GetUId( pPcb, CpIndex );
dwLength = WireToHostFormat16( pSendConfig->Length );
LogPPPPacket(FALSE,pPcb,pPcb->pSendBuf,dwLength+PPP_PACKET_HDR_LEN);
if ( (dwRetCode = PortSendOrDisconnect( pPcb,
(dwLength + PPP_PACKET_HDR_LEN)))
!= NO_ERROR )
{
return( FALSE );
}
pCpCb->LastId = pSendConfig->Id;
InsertInTimerQ( pPcb->dwPortId,
pPcb->hPort,
pCpCb->LastId,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT,
pPcb->RestartTimer );
return( TRUE );
}
//**
//
// Call: FsmSendTermReq
//
// Returns: TRUE - Termination Req. sent successfully.
// FALSE - Otherwise
//
// Description: Called to send a termination request.
//
BOOL
FsmSendTermReq(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( pCpCb == NULL )
{
return( FALSE );
}
HostToWireFormat16( (WORD)(CpTable[CpIndex].CpInfo.Protocol),
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = TERM_REQ;
pSendConfig->Id = GetUId( pPcb, CpIndex );
HostToWireFormat16( (WORD)((PPP_CONFIG_HDR_LEN)+(sizeof(DWORD)*3)),
(PBYTE)(pSendConfig->Length) );
HostToWireFormat32( pLcpCb->Local.Work.MagicNumber,
(PBYTE)(pSendConfig->Data) );
//
// Signature
//
HostToWireFormat32( 3984756, (PBYTE)(pSendConfig->Data+4) );
HostToWireFormat32( pCpCb->dwError, (PBYTE)(pSendConfig->Data+8) );
LogPPPPacket( FALSE,pPcb,pPcb->pSendBuf,
PPP_PACKET_HDR_LEN+PPP_CONFIG_HDR_LEN+(sizeof(DWORD)*3) );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb,
PPP_PACKET_HDR_LEN +
PPP_CONFIG_HDR_LEN +
(sizeof(DWORD)*3)))
!= NO_ERROR )
{
return( FALSE );
}
pCpCb->LastId = pSendConfig->Id;
dwRetCode = InsertInTimerQ( pPcb->dwPortId,
pPcb->hPort,
pCpCb->LastId,
CpTable[CpIndex].CpInfo.Protocol,
FALSE,
TIMER_EVENT_TIMEOUT,
pPcb->RestartTimer );
if ( dwRetCode == NO_ERROR)
{
return( TRUE );
}
else
{
PppLog( 1, "InsertInTimerQ on port %d failed: %d",
pPcb->hPort, dwRetCode );
pPcb->LcpCb.dwError = dwRetCode;
pPcb->fFlags |= PCBFLAG_STOPPED_MSG_SENT;
NotifyCaller( pPcb,
( pPcb->fFlags & PCBFLAG_IS_SERVER )
? PPPDDMMSG_Stopped
: PPPMSG_Stopped,
&(pPcb->LcpCb.dwError) );
return( FALSE );
}
}
//**
//
// Call: FsmSendTermAck
//
// Returns: TRUE - Termination Ack. sent successfully.
// FALSE - Otherwise
//
// Description: Caller to send a Termination Ack packet.
//
BOOL
FsmSendTermAck(
IN PCB * pPcb,
IN DWORD CpIndex,
IN PPP_CONFIG * pRecvConfig
)
{
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN +
WireToHostFormat16( pRecvConfig->Length );
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
DWORD dwRetCode;
if ( dwLength > LCP_DEFAULT_MRU )
{
dwLength = LCP_DEFAULT_MRU;
}
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = TERM_ACK;
pSendConfig->Id = pRecvConfig->Id;
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
CopyMemory( pSendConfig->Data,
pRecvConfig->Data,
dwLength - PPP_CONFIG_HDR_LEN - PPP_PACKET_HDR_LEN );
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendConfigResult
//
// Returns: TRUE - Config Result sent successfully.
// FALSE - Otherwise
//
// Description: Called to send a Ack/Nak/Rej packet.
//
BOOL
FsmSendConfigResult(
IN PCB * pPcb,
IN DWORD CpIndex,
IN PPP_CONFIG * pRecvConfig,
IN BOOL * pfAcked
)
{
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
DWORD dwLength;
DWORD dwRetCode;
*pfAcked = FALSE;
if ( pCpCb == NULL )
{
return( FALSE );
}
ZeroMemory( pSendConfig, 30 );
pSendConfig->Id = pRecvConfig->Id;
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpMakeConfigResult)(
pCpCb->pWorkBuf,
pRecvConfig,
pSendConfig,
LCP_DEFAULT_MRU - PPP_PACKET_HDR_LEN,
( pCpCb->NakRetryCount == 0 ));
if ( dwRetCode == PENDING )
{
return( FALSE );
}
if ( dwRetCode == ERROR_PPP_INVALID_PACKET )
{
PppLog( 1, "Silently discarding invalid packet on port=%d",
pPcb->hPort );
return( FALSE );
}
if ( dwRetCode != NO_ERROR )
{
pCpCb->dwError = dwRetCode;
PppLog( 1, "The control protocol for %x, returned error %d",
CpTable[CpIndex].CpInfo.Protocol, dwRetCode );
PppLog( 1, "while making a configure result on port %d", pPcb->hPort );
FsmClose( pPcb, CpIndex );
return( FALSE );
}
switch( pSendConfig->Code )
{
case CONFIG_ACK:
*pfAcked = TRUE;
break;
case CONFIG_NAK:
if ( pCpCb->NakRetryCount > 0 )
{
(pCpCb->NakRetryCount)--;
}
else
{
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" );
//
// 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.
//
pPcb->LcpCb.dwError = ERROR_NO_REMOTE_ENCRYPTION;
FsmClose( pPcb, LCP_INDEX );
return( FALSE );
}
}
pCpCb->dwError = ERROR_PPP_NOT_CONVERGING;
FsmClose( pPcb, CpIndex );
return( FALSE );
}
break;
case CONFIG_REJ:
if ( pCpCb->RejRetryCount > 0 )
{
(pCpCb->RejRetryCount)--;
}
else
{
pCpCb->dwError = ERROR_PPP_NOT_CONVERGING;
FsmClose( pPcb, CpIndex );
return( FALSE );
}
break;
default:
break;
}
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Id = pRecvConfig->Id;
dwLength = WireToHostFormat16( pSendConfig->Length );
LogPPPPacket(FALSE,pPcb,pPcb->pSendBuf,dwLength+PPP_PACKET_HDR_LEN);
if ( ( dwRetCode = PortSendOrDisconnect( pPcb,
(dwLength + PPP_PACKET_HDR_LEN)))
!= NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendEchoRequest
//
// Returns: TRUE - Echo reply sent successfully.
// FALSE - Otherwise
//
// Description: Called to send an Echo Rely packet
//
BOOL
FsmSendEchoRequest(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode = NO_ERROR;
char szEchoText[] = PPP_DEF_ECHO_TEXT;
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
DWORD dwLength = (DWORD)(PPP_PACKET_HDR_LEN + PPP_CONFIG_HDR_LEN + strlen( szEchoText)+ sizeof(pLcpCb->Local.Work.MagicNumber));
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = ECHO_REQ;
//Get a unique Id for this request
pSendConfig->Id = GetUId( pPcb, CpIndex );
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
HostToWireFormat32( pLcpCb->Local.Work.MagicNumber,
(PBYTE)(pSendConfig->Data) );
CopyMemory( pSendConfig->Data + 4,
szEchoText,
strlen(szEchoText));
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendEchoReply
//
// Returns: TRUE - Echo reply sent successfully.
// FALSE - Otherwise
//
// Description: Called to send an Echo Rely packet
//
BOOL
FsmSendEchoReply(
IN PCB * pPcb,
IN DWORD CpIndex,
IN PPP_CONFIG * pRecvConfig
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN +
WireToHostFormat16( pRecvConfig->Length );
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
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 packet on port=%d",
pPcb->hPort );
return( FALSE );
}
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = ECHO_REPLY;
pSendConfig->Id = pRecvConfig->Id;
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
HostToWireFormat32( pLcpCb->Local.Work.MagicNumber,
(PBYTE)(pSendConfig->Data) );
CopyMemory( pSendConfig->Data + 4,
pRecvConfig->Data + 4,
dwLength - PPP_CONFIG_HDR_LEN - PPP_PACKET_HDR_LEN - 4 );
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendCodeReject
//
// Returns: TRUE - Code Reject sent successfully.
// FALSE - Otherwise
//
// Description: Called to send a Code Reject packet.
//
BOOL
FsmSendCodeReject(
IN PCB * pPcb,
IN DWORD CpIndex,
IN PPP_CONFIG * pRecvConfig
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN +
PPP_CONFIG_HDR_LEN +
WireToHostFormat16( pRecvConfig->Length );
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( dwLength > LCP_DEFAULT_MRU )
dwLength = LCP_DEFAULT_MRU;
HostToWireFormat16( (WORD)CpTable[CpIndex].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = CODE_REJ;
pSendConfig->Id = GetUId( pPcb, CpIndex );
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
CopyMemory( pSendConfig->Data,
pRecvConfig,
dwLength - PPP_CONFIG_HDR_LEN - PPP_PACKET_HDR_LEN );
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendProtocolRej
//
// Returns: TRUE - Protocol Reject sent successfully.
// FALSE - Otherwise
//
// Description: Called to send a protocol reject packet.
//
BOOL
FsmSendProtocolRej(
IN PCB * pPcb,
IN PPP_PACKET * pPacket,
IN DWORD dwPacketLength
)
{
DWORD dwRetCode;
PPP_CONFIG * pRecvConfig = (PPP_CONFIG*)(pPacket->Information);
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN +
PPP_CONFIG_HDR_LEN +
dwPacketLength;
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
//
// If LCP is not in the opened state we cannot send a protocol reject
// packet
//
if ( !IsLcpOpened( pPcb ) )
return( FALSE );
if ( dwLength > LCP_DEFAULT_MRU )
dwLength = LCP_DEFAULT_MRU;
HostToWireFormat16( (WORD)CpTable[LCP_INDEX].CpInfo.Protocol,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = PROT_REJ;
pSendConfig->Id = GetUId( pPcb, LCP_INDEX );
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
CopyMemory( pSendConfig->Data,
pPacket,
dwLength - PPP_CONFIG_HDR_LEN - PPP_PACKET_HDR_LEN );
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendIndentification
//
// Returns: TRUE - Identification sent successfully.
// FALSE - Otherwise
//
// Description: Called to send an LCP Identification message to the peer
//
BOOL
FsmSendIdentification(
IN PCB * pPcb,
IN BOOL fSendVersion
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN + PPP_CONFIG_HDR_LEN + 4;
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( !(pPcb->ConfigInfo.dwConfigMask & PPPCFG_UseLcpExtensions) )
{
return( FALSE );
}
if ( fSendVersion )
{
CopyMemory( pSendConfig->Data + 4,
MS_RAS_VERSION,
strlen( MS_RAS_VERSION ) );
dwLength += strlen( MS_RAS_VERSION );
}
else
{
//
// If we couldn't get the computername for any reason
//
if ( *(pPcb->pBcb->szComputerName) == (CHAR)NULL )
{
return( FALSE );
}
CopyMemory( pSendConfig->Data + 4,
pPcb->pBcb->szComputerName,
strlen( pPcb->pBcb->szComputerName ) );
dwLength += strlen( pPcb->pBcb->szComputerName );
}
HostToWireFormat16( (WORD)PPP_LCP_PROTOCOL,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = IDENTIFICATION;
pSendConfig->Id = GetUId( pPcb, LCP_INDEX );
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
HostToWireFormat32( pLcpCb->Local.Work.MagicNumber,
(PBYTE)(pSendConfig->Data) );
LogPPPPacket( FALSE,pPcb,pPcb->pSendBuf,dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmSendTimeRemaining
//
// Returns: TRUE - TimeRemaining sent successfully.
// FALSE - Otherwise
//
// Description: Called to send an LCP Time Remaining packet from the server
// to the client
//
BOOL
FsmSendTimeRemaining(
IN PCB * pPcb
)
{
DWORD dwRetCode;
PPP_CONFIG * pSendConfig = (PPP_CONFIG*)(pPcb->pSendBuf->Information);
DWORD dwLength = PPP_PACKET_HDR_LEN + PPP_CONFIG_HDR_LEN + 8;
LCPCB * pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( !(pPcb->ConfigInfo.dwConfigMask & PPPCFG_UseLcpExtensions) )
{
return( FALSE );
}
dwLength += strlen( MS_RAS );
HostToWireFormat16( (WORD)PPP_LCP_PROTOCOL,
(PBYTE)(pPcb->pSendBuf->Protocol) );
pSendConfig->Code = TIME_REMAINING;
pSendConfig->Id = GetUId( pPcb, LCP_INDEX );
HostToWireFormat16( (WORD)(dwLength - PPP_PACKET_HDR_LEN),
(PBYTE)(pSendConfig->Length) );
HostToWireFormat32( pLcpCb->Local.Work.MagicNumber,
(PBYTE)(pSendConfig->Data) );
HostToWireFormat32( 0, (PBYTE)(pSendConfig->Data+4) );
CopyMemory( pSendConfig->Data + 8, MS_RAS, strlen( MS_RAS ) );
LogPPPPacket( FALSE, pPcb, pPcb->pSendBuf, dwLength );
if ( ( dwRetCode = PortSendOrDisconnect( pPcb, dwLength ) ) != NO_ERROR )
{
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmInit
//
// Returns: TRUE - Control Protocol was successfully initialized
// FALSE - Otherwise.
//
// Description: Called to initialize the state machine
//
BOOL
FsmInit(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode;
PPPCP_INIT PppCpInit;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return( FALSE );
}
PppLog( 1, "FsmInit called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
pCpCb->NcpPhase = NCP_CONFIGURING;
pCpCb->dwError = NO_ERROR;
pCpCb->State = FSM_INITIAL;
PppCpInit.fServer = (pPcb->fFlags & PCBFLAG_IS_SERVER);
PppCpInit.hPort = pPcb->hPort;
PppCpInit.dwDeviceType = pPcb->dwDeviceType;
PppCpInit.CompletionRoutine = CompletionRoutine;
PppCpInit.pszzParameters = pPcb->pBcb->InterfaceInfo.szzParameters;
PppCpInit.fThisIsACallback = pPcb->fFlags & PCBFLAG_THIS_IS_A_CALLBACK;
PppCpInit.IfType = pPcb->pBcb->InterfaceInfo.IfType;
PppCpInit.pszUserName = pPcb->pBcb->szRemoteUserName;
PppCpInit.pszPortName = pPcb->szPortName;
PppCpInit.hConnection = pPcb->pBcb->hConnection;
PppCpInit.pAttributes = ( pPcb->pAuthProtocolAttributes )
? pPcb->pAuthProtocolAttributes
: pPcb->pAuthenticatorAttributes;
PppCpInit.fDisableNetbt = (pPcb->fFlags & PCBFLAG_DISABLE_NETBT);
if ( pPcb->fFlags & PCBFLAG_IS_SERVER )
{
PppCpInit.PppConfigInfo = PppConfigInfo.ServerConfigInfo;
if ( PppConfigInfo.ServerConfigInfo.dwConfigMask
& PPPCFG_AllowNoAuthOnDCPorts )
{
if ( RAS_DEVICE_CLASS( pPcb->dwDeviceType ) & RDT_Direct )
{
PppCpInit.PppConfigInfo.dwConfigMask |=
PPPCFG_AllowNoAuthentication;
}
else
{
PppCpInit.PppConfigInfo.dwConfigMask &=
~PPPCFG_AllowNoAuthOnDCPorts;
}
}
}
else
{
PppCpInit.PppConfigInfo = pPcb->ConfigInfo;
}
switch( CpTable[CpIndex].CpInfo.Protocol )
{
case PPP_IPCP_PROTOCOL:
PppCpInit.hInterface = pPcb->pBcb->InterfaceInfo.hIPInterface;
break;
case PPP_IPXCP_PROTOCOL:
PppCpInit.hInterface = pPcb->pBcb->InterfaceInfo.hIPXInterface;
break;
default:
PppCpInit.hInterface = INVALID_HANDLE_VALUE;
break;
}
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpBegin)(
&(pCpCb->pWorkBuf), &PppCpInit );
if ( dwRetCode != NO_ERROR )
{
PppLog( 1, "FsmInit for protocol = %x failed with error %d",
CpTable[CpIndex].CpInfo.Protocol, dwRetCode );
pCpCb->dwError = dwRetCode;
pCpCb->fConfigurable = FALSE;
return( FALSE );
}
pCpCb->fBeginCalled = TRUE;
if ( !FsmReset( pPcb, CpIndex ) )
{
pCpCb->fConfigurable = FALSE;
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmReset
//
// Returns: TRUE - Control Protocol was successfully reset
// FALSE - Otherwise.
//
// Description: Called to reset the state machine
//
BOOL
FsmReset(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return( FALSE );
}
PppLog( 1, "FsmReset called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
pCpCb->LastId = 0;
InitRestartCounters( pPcb, pCpCb );
pCpCb->NakRetryCount = PppConfigInfo.MaxFailure;
pCpCb->RejRetryCount = PppConfigInfo.MaxReject;
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpReset)( pCpCb->pWorkBuf );
if ( dwRetCode != NO_ERROR )
{
PppLog( 1, "Reset for protocol = %x failed with error %d",
CpTable[CpIndex].CpInfo.Protocol, dwRetCode );
pCpCb->dwError = dwRetCode;
FsmClose( pPcb, CpIndex );
return( FALSE );
}
return( TRUE );
}
//**
//
// Call: FsmThisLayerUp
//
// Returns: TRUE - Success
// FALSE - Otherwise
//
// Description: Called when configuration negotiation is completed.
//
BOOL
FsmThisLayerUp(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwIndex;
DWORD dwRetCode;
PPP_PROJECTION_RESULT ProjectionResult;
RAS_AUTH_ATTRIBUTE * pUserAttributes = NULL;
NCP_PHASE dwNcpState;
BOOL fAreCPsDone = FALSE;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
LCPCB * pLcpCb;
DWORD dwLinkDiscrim;
BOOL fCanDoBAP = FALSE;
if ( NULL != pCpCb )
{
PppLog( 1, "FsmThisLayerUp called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
if ( CpTable[CpIndex].CpInfo.RasCpThisLayerUp != NULL )
{
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpThisLayerUp)(
pCpCb->pWorkBuf);
if ( dwRetCode != NO_ERROR )
{
PppLog( 1, "FsmThisLayerUp for protocol=%x,port=%d,RetCode=%d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort,
dwRetCode);
if ( dwRetCode != PENDING )
{
pCpCb->dwError = dwRetCode;
FsmClose( pPcb, CpIndex );
}
return( FALSE );
}
}
}
else
{
PppLog( 1, "FsmThisLayerUp called in no auth case, port = %d",
pPcb->hPort );
}
if ( CpIndex == GetCpIndexFromProtocol( PPP_BACP_PROTOCOL ) )
{
BapSetPolicy( pPcb->pBcb );
}
switch( pPcb->PppPhase )
{
case PPP_LCP:
PppLog( 1, "LCP Configured successfully" );
if (!( pPcb->fFlags & PCBFLAG_IS_SERVER ) )
{
AdjustHTokenImpersonateUser( pPcb );
}
//
// Send Identification messages if we are a client.
//
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) )
{
FsmSendIdentification( pPcb, TRUE );
FsmSendIdentification( pPcb, FALSE );
}
//
// If an Authentication protocol was negotiated
//
pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( ( pLcpCb->Local.Work.AP != 0 ) || ( pLcpCb->Remote.Work.AP != 0 ) )
{
//
// Start authenticating
//
PppLog( 1, "Authenticating phase started" );
pPcb->PppPhase = PPP_AP;
//
// Start server side authentication if one was negotiated
//
if ( pLcpCb->Local.Work.AP != 0 )
{
CpIndex = GetCpIndexFromProtocol( pLcpCb->Local.Work.AP );
PPP_ASSERT(( CpIndex != (DWORD)-1 ));
ApStart( pPcb, CpIndex, TRUE );
}
//
// Start client side negotiation if one was negotiated
//
if ( pLcpCb->Remote.Work.AP != 0 )
{
CpIndex = GetCpIndexFromProtocol( pLcpCb->Remote.Work.AP );
PPP_ASSERT(( CpIndex != (DWORD)-1 ));
ApStart( pPcb, CpIndex, FALSE );
}
break;
}
//
// If we are a server and did not authenticate the user, then see if
// Guests have dial-in privilege. In the case of DCC, we don't care if
// Guests have the privilege. We allow the call to succeed.
//
if ( ( pPcb->fFlags & PCBFLAG_IS_SERVER )
&& ( pLcpCb->Local.Work.AP == 0 )
&& (0 == (pLcpCb->PppConfigInfo.dwConfigMask & PPPCFG_AllowNoAuthOnDCPorts)))
// && ( ( RAS_DEVICE_CLASS( pPcb->dwDeviceType ) & RDT_Direct ) == 0 ))
{
pPcb->PppPhase = PPP_AP;
pUserAttributes = RasAuthAttributeCopy(
pPcb->pUserAttributes );
if ( pUserAttributes == NULL )
{
dwRetCode = GetLastError();
pPcb->LcpCb.dwError = dwRetCode;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
dwRetCode = RasAuthenticateClient(pPcb->hPort, pUserAttributes);
if ( dwRetCode != NO_ERROR )
{
pPcb->LcpCb.dwError = dwRetCode;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
break;
}
//
// If there was no authentication protocol negotiated, fallthru and
// begin NCP configurations.
//
case PPP_AP:
//
// Make sure authentication phase is completed before moving on.
//
if ( pPcb->AuthenticatorCb.fConfigurable )
{
if ( pPcb->AuthenticatorCb.State != FSM_OPENED )
{
break;
}
}
if ( pPcb->AuthenticateeCb.fConfigurable )
{
if ( pPcb->AuthenticateeCb.State != FSM_OPENED )
{
break;
}
}
NotifyCaller( pPcb, PPPDDMMSG_Authenticated, NULL );
//
// If we are to negotiate callback
//
if ( pPcb->fFlags & PCBFLAG_NEGOTIATE_CALLBACK )
{
CpIndex = GetCpIndexFromProtocol( PPP_CBCP_PROTOCOL );
PPP_ASSERT(( CpIndex != (DWORD)-1 ));
//
// Start callback
//
PppLog( 1, "Callback phase started" );
pPcb->PppPhase = PPP_NEGOTIATING_CALLBACK;
pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( NULL == pCpCb )
{
return( FALSE );
}
pCpCb->fConfigurable = TRUE;
CbStart( pPcb, CpIndex );
break;
}
else
{
//
// If the remote peer did not negotiate callback during LCP and
// the authenticated user HAS to be called back for security
// reasons, we bring the link down
//
if ( ( pPcb->fFlags & PCBFLAG_IS_SERVER ) &&
( !(pPcb->fFlags & PCBFLAG_THIS_IS_A_CALLBACK) ) &&
( pPcb->fCallbackPrivilege & RASPRIV_AdminSetCallback ) )
{
pPcb->LcpCb.dwError = ERROR_NO_DIALIN_PERMISSION;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
//
// We need to send an Accounting Stop if RADIUS sends an Access
// Accept but we still drop the line.
//
pPcb->fFlags |= PCBFLAG_SERVICE_UNAVAILABLE;
break;
}
}
//
// Fallthru
//
case PPP_NEGOTIATING_CALLBACK:
//
// Progress to NCP phase only if we are sure that we have passed the
// callback phase
//
if ( ( pPcb->fFlags & PCBFLAG_NEGOTIATE_CALLBACK ) &&
( CpTable[CpIndex].CpInfo.Protocol != PPP_CBCP_PROTOCOL ) )
{
break;
}
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) )
{
NotifyCaller( pPcb, PPPMSG_Projecting, NULL );
}
//
// We may lose pPcb->pBcb when we call TryToBundleWithAnotherLink().
// Save pPcb->pBcb->fFlags & BCBFLAG_CAN_DO_BAP first.
//
fCanDoBAP = pPcb->pBcb->fFlags & BCBFLAG_CAN_DO_BAP;
//
// If multilink was negotiated on this link check to see if this
// link can be bundled and is not already bundled with another link
//
if ( ( pPcb->fFlags & PCBFLAG_CAN_BE_BUNDLED ) &&
( !(pPcb->fFlags & PCBFLAG_IS_BUNDLED ) ) )
{
//
// If we are bundled with another link then skip NCP phase
//
dwRetCode = TryToBundleWithAnotherLink( pPcb );
if ( dwRetCode != NO_ERROR )
{
pPcb->LcpCb.dwError = dwRetCode;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
}
//
// If we are bundled
//
if ( pPcb->fFlags & PCBFLAG_IS_BUNDLED )
{
if ( pPcb->pBcb->fFlags & BCBFLAG_CAN_DO_BAP )
{
if ( !fCanDoBAP )
{
//
// A new link can join a bundle that does BAP only if the
// link has negotiated Link Discriminator.
//
PppLog( 1, "Link to be terminated on hPort = %d because "
"it can't do BAP.",
pPcb->hPort );
pPcb->LcpCb.dwError = ERROR_PPP_NOT_CONVERGING;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
else
{
//
// Reset the start time for the sample period. Now that the
// bandwidth has changed, ndiswan shouldn't ask us to bring
// links up or down based on what happened in the past.
//
BapSetPolicy( pPcb->pBcb );
}
if ( !FLinkDiscriminatorIsUnique( pPcb, &dwLinkDiscrim ) )
{
PppLog( 1,
"New link discriminator %d to be negotiated for "
"port %d",
dwLinkDiscrim, pPcb->hPort );
WLinkDiscriminator = (WORD) dwLinkDiscrim;
FsmDown( pPcb, LCP_INDEX );
((LCPCB*)
(pPcb->LcpCb.pWorkBuf))->Local.Work.dwLinkDiscriminator =
dwLinkDiscrim;
FsmUp( pPcb, LCP_INDEX );
return( FALSE );
}
}
//
// Get state of bundle NCPs
//
dwNcpState = QueryBundleNCPState( pPcb );
switch ( dwNcpState )
{
case NCP_CONFIGURING:
pPcb->PppPhase = PPP_NCP;
PppLog(2,"Bundle NCPs not done for port %d, wait", pPcb->hPort);
NotifyCaller( pPcb, PPPDDMMSG_NewLink, NULL );
break;
case NCP_DOWN:
pPcb->PppPhase = PPP_NCP;
pPcb->LcpCb.dwError = ERROR_PPP_NO_PROTOCOLS_CONFIGURED;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
case NCP_UP:
pPcb->PppPhase = PPP_NCP;
NotifyCaller( pPcb, PPPDDMMSG_NewLink, NULL );
NotifyCallerOfBundledProjection( pPcb );
RemoveFromTimerQ( pPcb->dwPortId,
0,
0,
FALSE,
TIMER_EVENT_NEGOTIATETIME );
StartAutoDisconnectForPort( pPcb );
StartLCPEchoForPort ( pPcb );
MakeStartAccountingCall( pPcb );
break;
case NCP_DEAD:
//
// NCPs still have not started so notify DDM that this a
// new bundle and get interface handles for this new bundle.
//
NotifyCaller( pPcb, PPPDDMMSG_NewBundle, NULL );
break;
}
return( TRUE );
}
//
// We are a client so we have all the interface handles already.
// We are not part of a bundle, so initialize all NCPs
//
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) )
{
dwRetCode = InitializeNCPs( pPcb, pPcb->ConfigInfo.dwConfigMask );
if ( dwRetCode != NO_ERROR )
{
pPcb->LcpCb.dwError = dwRetCode;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
//
// Start NCPs
//
StartNegotiatingNCPs( pPcb );
}
else
{
//
// Take care of the RAS server policy on workstation. If we have
// already checked the policy for this link, don't check again.
//
if ( ( PppConfigInfo.fFlags & PPPCONFIG_FLAG_WKSTA )
&& !( pPcb->pBcb->fFlags & BCBFLAG_WKSTA_IN ) )
{
//
// We did not bundle with another link. Allow atmost one
// dial in client in each class.
//
if ( ( (pPcb->dwDeviceType & RDT_Tunnel)
&& (PppConfigInfo.fFlags & PPPCONFIG_FLAG_TUNNEL))
|| ( (pPcb->dwDeviceType & RDT_Direct)
&& (PppConfigInfo.fFlags & PPPCONFIG_FLAG_DIRECT))
|| ( !(pPcb->dwDeviceType & RDT_Tunnel)
&& !(pPcb->dwDeviceType & RDT_Direct)
&& (PppConfigInfo.fFlags & PPPCONFIG_FLAG_DIALUP)))
{
pPcb->LcpCb.dwError = ERROR_USER_LIMIT;
PppLog( 2, "User limit reached. Flags: %d",
PppConfigInfo.fFlags );
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
if ( pPcb->dwDeviceType & RDT_Tunnel )
{
PppConfigInfo.fFlags |= PPPCONFIG_FLAG_TUNNEL;
}
else if ( pPcb->dwDeviceType & RDT_Direct )
{
PppConfigInfo.fFlags |= PPPCONFIG_FLAG_DIRECT;
}
else
{
PppConfigInfo.fFlags |= PPPCONFIG_FLAG_DIALUP;
}
pPcb->pBcb->fFlags |= BCBFLAG_WKSTA_IN;
}
//
// Increase client license count if we are on the recieving end
// of the call.
//
if ( pPcb->pBcb->hLicense == INVALID_HANDLE_VALUE )
{
LS_STATUS_CODE LsStatus;
NT_LS_DATA NtLSData;
NtLSData.DataType = NT_LS_USER_NAME;
NtLSData.Data = pPcb->pBcb->szLocalUserName;
NtLSData.IsAdmin = FALSE;
LsStatus = NtLicenseRequest(
"REMOTE_ACCESS",
"",
(LS_HANDLE*)&(pPcb->pBcb->hLicense),
&NtLSData );
if ( LsStatus != LS_SUCCESS )
{
pPcb->LcpCb.dwError =
( LsStatus == LS_RESOURCES_UNAVAILABLE )
? ERROR_OUTOFMEMORY
: ERROR_REQ_NOT_ACCEP;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
}
//
// We are DDM and this is a new Bundle.
//
NotifyCaller( pPcb, PPPDDMMSG_NewBundle, NULL );
}
break;
case PPP_NCP:
//
// If we are a client and got rechallenged and we responded while we
// were in the NCP state then we are done.
//
pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
if ( pLcpCb->Remote.Work.AP != 0 )
{
if ( CpIndex == GetCpIndexFromProtocol( pLcpCb->Remote.Work.AP ) )
{
break;
}
}
//
// If we are a server and we got another auth request while we were
// in NCP state, we are done
//
if ( pLcpCb->Local.Work.AP != 0 )
{
if ( CpIndex == GetCpIndexFromProtocol( pLcpCb->Local.Work.AP ) )
{
break;
}
}
if ( NULL == pCpCb )
{
return( FALSE );
}
pCpCb->NcpPhase = NCP_UP;
if ( ( CpTable[CpIndex].CpInfo.Protocol == PPP_NBFCP_PROTOCOL ) ||
( CpTable[CpIndex].CpInfo.Protocol == PPP_IPCP_PROTOCOL ) )
{
if ( !NotifyIPCPOfNBFCPProjection( pPcb, CpIndex ) )
{
return( FALSE );
}
}
dwRetCode = AreNCPsDone(pPcb, CpIndex, &ProjectionResult, &fAreCPsDone);
//
// We failed to get information from CP with CpIndex.
//
if ( dwRetCode != NO_ERROR )
{
return( FALSE );
}
if ( fAreCPsDone == TRUE )
{
RemoveFromTimerQ( pPcb->dwPortId,
0,
0,
FALSE,
TIMER_EVENT_NEGOTIATETIME );
//
// Notify the ras client and the ras server about the projections
//
if ( pPcb->fFlags & PCBFLAG_IS_SERVER )
{
NotifyCaller( pPcb, PPPDDMMSG_PppDone, &ProjectionResult );
}
else
{
RASMAN_INFO rasmanInfo;
NotifyCaller(pPcb, PPPMSG_ProjectionResult, &ProjectionResult);
NotifyCaller(pPcb, PPPMSG_PppDone, NULL);
if ( RasGetInfo(NULL, pPcb->hPort, &rasmanInfo ) == NO_ERROR )
{
RasSetConnectionUserData(
rasmanInfo.RI_ConnectionHandle,
1,
(PBYTE)&ProjectionResult,
sizeof( ProjectionResult ) );
}
}
StartAutoDisconnectForPort( pPcb );
StartLCPEchoForPort ( pPcb );
if ( !( pPcb->fFlags & PCBFLAG_IS_SERVER ) &&
!( pPcb->fFlags & PCBFLAG_CONNECTION_LOGGED ) )
{
LPSTR lpsSubStringArray[3];
lpsSubStringArray[0] = pPcb->pBcb->szLocalUserName;
lpsSubStringArray[1] = pPcb->pBcb->szEntryName;
lpsSubStringArray[2] = pPcb->szPortName;
PppLogInformation( ROUTERLOG_CONNECTION_ESTABLISHED,
3,
lpsSubStringArray );
pPcb->fFlags |= PCBFLAG_CONNECTION_LOGGED;
}
//
// If we are bundled, then we need to notify all other bundled ports
// that PPP on that port is done too.
//
if ( pPcb->fFlags & PCBFLAG_IS_BUNDLED )
{
NotifyCompletionOnBundledPorts( pPcb );
}
MakeStartAccountingCall( pPcb );
}
break;
default:
break;
}
return( TRUE );
}
//**
//
// Call: FsmThisLayerDown
//
// Returns: TRUE - Success
// FALSE - Otherwise
//
// Description: Called when leaving the OPENED state.
//
BOOL
FsmThisLayerDown(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode;
DWORD dwIndex;
LCPCB * pLcpCb;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return( FALSE );
}
PppLog( 1, "FsmThisLayerDown called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
if ( CpTable[CpIndex].CpInfo.RasCpThisLayerDown != NULL )
{
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpThisLayerDown)(
pCpCb->pWorkBuf );
if ( dwRetCode != NO_ERROR )
{
PppLog( 1, "FsmThisLayerDown for protocol=%x,port=%d,RetCode=%d",
CpTable[CpIndex].CpInfo.Protocol,
pPcb->hPort,
dwRetCode );
if ( pCpCb->dwError != NO_ERROR )
{
pCpCb->dwError = dwRetCode;
}
}
}
if ( CpIndex == LCP_INDEX )
{
//
// If this port is not part of a bundle, or it is but is the only
// remaining link in the bundle, then bring all the NCPs down.
//
if ( (!( pPcb->fFlags & PCBFLAG_IS_BUNDLED )) ||
( ( pPcb->fFlags & PCBFLAG_IS_BUNDLED ) &&
( pPcb->pBcb->dwLinkCount == 1 ) ) )
{
//
// Bring all the NCPs down
//
for( dwIndex = LCP_INDEX+1;
dwIndex < PppConfigInfo.NumberOfCPs;
dwIndex++ )
{
pCpCb = GetPointerToCPCB( pPcb, dwIndex );
if ( ( NULL != pCpCb )
&& ( pCpCb->fConfigurable ) )
{
FsmDown( pPcb, dwIndex );
}
}
}
pPcb->PppPhase = PPP_LCP;
pLcpCb = (LCPCB*)(pPcb->LcpCb.pWorkBuf);
dwIndex = GetCpIndexFromProtocol( pLcpCb->Local.Work.AP );
if ( dwIndex != (DWORD)-1 )
{
ApStop( pPcb, dwIndex, TRUE );
//
// Setting this will allow all outstanding request that are
// completed to be dropped
//
pPcb->dwOutstandingAuthRequestId = 0xFFFFFFFF;
}
dwIndex = GetCpIndexFromProtocol( pLcpCb->Remote.Work.AP );
if ( dwIndex != (DWORD)-1 )
{
ApStop( pPcb, dwIndex, FALSE );
}
dwIndex = GetCpIndexFromProtocol( PPP_CBCP_PROTOCOL );
if ( dwIndex != (DWORD)-1 )
{
CbStop( pPcb, dwIndex );
}
}
else
{
pCpCb->NcpPhase = NCP_CONFIGURING;
}
return( TRUE );
}
//**
//
// Call: FsmThisLayerStarted
//
// Returns: TRUE - Success
// FALSE - Otherwise
//
// Description: Called when leaving the OPENED state.
//
BOOL
FsmThisLayerStarted(
IN PCB * pPcb,
IN DWORD CpIndex
)
{
DWORD dwRetCode;
CPCB* pCpCb = GetPointerToCPCB( pPcb, CpIndex );
if ( pCpCb == NULL )
{
return( FALSE );
}
PppLog( 1, "FsmThisLayerStarted called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
if ( CpTable[CpIndex].CpInfo.RasCpThisLayerStarted != NULL )
{
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpThisLayerStarted)(
pCpCb->pWorkBuf);
if ( dwRetCode != NO_ERROR )
{
pCpCb->dwError = dwRetCode;
FsmClose( pPcb, CpIndex );
return( FALSE );
}
}
pCpCb->NcpPhase = NCP_CONFIGURING;
return( TRUE );
}
//**
//
// Call: FsmThisLayerFinished
//
// Returns: TRUE - Success
// FALSE - Otherwise
//
// Description: Called when leaving the OPENED state.
//
BOOL
FsmThisLayerFinished(
IN PCB * pPcb,
IN DWORD CpIndex,
IN BOOL fCallCp
)
{
DWORD dwRetCode;
PPP_PROJECTION_RESULT ProjectionResult;
CPCB * pCpCb = GetPointerToCPCB( pPcb, CpIndex );
BOOL fAreCPsDone = FALSE;
if ( pCpCb == NULL )
{
return( FALSE );
}
PppLog( 1, "FsmThisLayerFinished called for protocol = %x, port = %d",
CpTable[CpIndex].CpInfo.Protocol, pPcb->hPort );
if ( ( CpTable[CpIndex].CpInfo.RasCpThisLayerFinished != NULL )
&& ( fCallCp ) )
{
dwRetCode = (CpTable[CpIndex].CpInfo.RasCpThisLayerFinished)(
pCpCb->pWorkBuf);
if ( dwRetCode != NO_ERROR )
{
NotifyCallerOfFailure( pPcb, dwRetCode );
return( FALSE );
}
}
//
// Take care of special cases first.
//
switch ( CpTable[CpIndex].CpInfo.Protocol )
{
case PPP_LCP_PROTOCOL:
//
// If we are in the callback phase and LCP went down because of an
// error.
//
//
// If we LCP layer is finished and we are doing a callback
//
if ( pPcb->fFlags & PCBFLAG_DOING_CALLBACK )
{
if ( !(pPcb->fFlags & PCBFLAG_IS_SERVER) )
{
PppLog( 2, "pPcb->fFlags = %x", pPcb->fFlags ) ;
NotifyCaller( pPcb, PPPMSG_Callback, NULL );
//
// We unset this flag now because if we get another
// FsmClose, it will call FsmThisLayerFinished (this routine)
// again, and this time we will need to send a failure
// message back, not Callback, so that the client can
// clean up.
//
pPcb->fFlags &= ~PCBFLAG_DOING_CALLBACK;
return( TRUE );
}
}
else
{
//
// If this port is not part of a bundle, or it is but is the only
// remaining link in the bundle, then call ThisLayerFinished for all
// NCPs.
//
if ( (!( pPcb->fFlags & PCBFLAG_IS_BUNDLED )) ||
( ( pPcb->fFlags & PCBFLAG_IS_BUNDLED ) &&
( pPcb->pBcb->dwLinkCount == 1 ) ) )
{
DWORD dwIndex;
CPCB * pNcpCb;
for( dwIndex = LCP_INDEX+1;
dwIndex < PppConfigInfo.NumberOfCPs;
dwIndex++ )
{
pNcpCb = GetPointerToCPCB( pPcb, dwIndex );
if ( pNcpCb->fConfigurable )
{
if ( NULL !=
CpTable[dwIndex].CpInfo.RasCpThisLayerFinished )
{
dwRetCode =
(CpTable[dwIndex].CpInfo.RasCpThisLayerFinished)
(pNcpCb->pWorkBuf);
PppLog( 1, "FsmThisLayerFinished called for "
"protocol = %x, port = %d: %d",
CpTable[dwIndex].CpInfo.Protocol, pPcb->hPort,
dwRetCode );
dwRetCode = NO_ERROR;
}
}
}
}
pPcb->fFlags |= PCBFLAG_STOPPED_MSG_SENT;
NotifyCaller( pPcb,
( pPcb->fFlags & PCBFLAG_IS_SERVER )
? PPPDDMMSG_Stopped
: PPPMSG_Stopped,
&(pPcb->LcpCb.dwError) );
return( FALSE );
}
break;
case 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 ) )
{
switch( pCpCb->dwError )
{
case ERROR_NO_LOCAL_ENCRYPTION:
case ERROR_NO_REMOTE_ENCRYPTION:
pPcb->LcpCb.dwError = pCpCb->dwError;
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;
NotifyCallerOfFailure( pPcb, pPcb->LcpCb.dwError );
return( FALSE );
}
break;
default:
break;
}
switch( pPcb->PppPhase )
{
case PPP_NCP:
//
// This NCP failed to be configured. If there are more then
// try to configure them.
//
pCpCb->NcpPhase = NCP_DOWN;
if ( ( CpTable[CpIndex].CpInfo.Protocol == PPP_NBFCP_PROTOCOL ) ||
( CpTable[CpIndex].CpInfo.Protocol == PPP_IPCP_PROTOCOL ) )
{
if ( !NotifyIPCPOfNBFCPProjection( pPcb, CpIndex ) )
{
return( FALSE );
}
}
//
// Check to see if we are all done
//
dwRetCode = AreNCPsDone(pPcb, CpIndex, &ProjectionResult, &fAreCPsDone);
//
// We failed to get information from CP with CpIndex.
//
if ( dwRetCode != NO_ERROR )
{
return( FALSE );
}
if ( fAreCPsDone == TRUE )
{
RemoveFromTimerQ( pPcb->dwPortId,
0,
0,
FALSE,
TIMER_EVENT_NEGOTIATETIME );
//
// Notify the ras client and the ras server about the projections
//
if ( pPcb->fFlags & PCBFLAG_IS_SERVER )
{
NotifyCaller( pPcb, PPPDDMMSG_PppDone, &ProjectionResult );
}
else
{
RASMAN_INFO rasmanInfo;
NotifyCaller(pPcb, PPPMSG_ProjectionResult, &ProjectionResult);
NotifyCaller(pPcb, PPPMSG_PppDone, NULL);
//
// We call RasSetConnectionUserData in FsmThisLayerUp and
// FsmThisLayerFinished, in case an NCP is renegotiated. An
// PPPMSG_ProjectionResult sent after PPPMSG_PppDone is ignored.
// This is a bad hack. The real fix is to change RasDialMachine
// such that PPPMSG_ProjectionResult is not ignored.
//
//
// We are commenting out RasSetConnectionUserData to work
// around bug 375125. A multilink call was made and the two
// links connected to two different servers. The second link
// only should go down in this case. However, IPCP failed
// for the second link, and RasSetConnectionUserData marked
// IPCP as failed for the first link also. Both links came down.
//
#if 0
if ( RasGetInfo(NULL, pPcb->hPort, &rasmanInfo ) == NO_ERROR )
{
RasSetConnectionUserData(
rasmanInfo.RI_ConnectionHandle,
1,
(PBYTE)&ProjectionResult,
sizeof( ProjectionResult ) );
}
#endif
}
StartAutoDisconnectForPort( pPcb );
StartLCPEchoForPort ( pPcb );
//
// If we are bundled, then we need to notify all other bundled ports
// that PPP on that port is done too.
//
if ( pPcb->fFlags & PCBFLAG_IS_BUNDLED )
{
NotifyCompletionOnBundledPorts( pPcb );
}
MakeStartAccountingCall( pPcb );
}
break;
case PPP_AP:
default:
break;
}
return( TRUE );
}
Reference in a new issue Copy permalink