windows-nt/Source/XPSP1/NT/net/rras/ras/ppp/rasipcp/rasipcp.c
2020-09-26 16:20:57 +08:00

3605 lines
110 KiB
C

/* Copyright (c) 1993, Microsoft Corporation, all rights reserved
**
** rasipcp.c
** Remote Access PPP Internet Protocol Control Protocol
** Core routines
**
** 11/05/93 Steve Cobb
*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <lmcons.h>
#include <string.h>
#include <stdlib.h>
#include <llinfo.h>
#include <rasman.h>
#include <ddwanarp.h>
#include <rtutils.h>
#include <dhcpcapi.h>
#include <devioctl.h>
#include <rasppp.h>
#include <uiip.h>
#include <pppcp.h>
#define INCL_HOSTWIRE
#define INCL_PARAMBUF
#define INCL_RASAUTHATTRIBUTES
#include <ppputil.h>
#include <raserror.h>
#include <mprlog.h>
#include <dnsapi.h>
#include "rassrvr.h"
#include "tcpreg.h"
#include "helper.h"
#include "rastcp.h"
#define RASIPCPGLOBALS
#include "rasipcp.h"
#define REGKEY_Ipcp \
"SYSTEM\\CurrentControlSet\\Services\\RasMan\\PPP\\ControlProtocols\\BuiltIn"
#define REGKEY_Params "SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Parameters\\IP"
#define REGKEY_Linkage "SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Linkage"
#define REGKEY_Disabled "SYSTEM\\CurrentControlSet\\Services\\RemoteAccess\\Linkage\\Disabled"
#define REGVAL_NsAddrs "RequestNameServerAddresses"
#define REGVAL_Unnumbered "Unnumbered"
#define REGVAL_VjComp "RequestVJCompression"
#define REGVAL_VjComp2 "AcceptVJCompression"
#define REGVAL_AllowVJOverVPN "AllowVJOverVPN"
#define REGVAL_HardIp "AllowClientIPAddresses"
#define REGVAL_RegisterRoutersWithWINS "RegisterRoutersWithWINSServers"
#define REGVAL_Bind "Bind"
#define ID_NetBTNdisWan "NetBT_NdisWan"
// DHCP Options. (from dhcp.h)
// dhcp.h lives in the sockets project. These are standard and
// cannot change, so its safe to put them here.
#define OPTION_SUBNET_MASK 1
#define OPTION_DNS_NAME_SERVERS 6
#define OPTION_NETBIOS_NAME_SERVERS 44
#define OPTION_DNS_DOMAIN_NAME 15
#define OPTION_VENDOR_SPEC_INFO 43
//Route Plumbing option
#define OPTION_VENDOR_ROUTE_PLUMB 249
#define CLASSA_ADDR(a) (( (*((unsigned char *)&(a))) & 0x80) == 0)
#define CLASSB_ADDR(a) (( (*((unsigned char *)&(a))) & 0xc0) == 0x80)
#define CLASSC_ADDR(a) (( (*((unsigned char *)&(a))) & 0xe0) == 0xc0)
#define CLASSE_ADDR(a) ((( (*((uchar *)&(a))) & 0xf0) == 0xf0) && \
((a) != 0xffffffff))
/* Gurdeepian dword byte-swapping macro.
**
** Note that in this module all IP addresses are stored in on the net form
** which is the opposite of Intel format.
*/
#define net_long(x) (((((unsigned long)(x))&0xffL)<<24) | \
((((unsigned long)(x))&0xff00L)<<8) | \
((((unsigned long)(x))&0xff0000L)>>8) | \
((((unsigned long)(x))&0xff000000L)>>24))
typedef struct _IPCP_DHCP_INFORM
{
WCHAR* wszDevice;
HCONN hConnection;
BOOL fUseDhcpInformDomainName;
} IPCP_DHCP_INFORM;
/*---------------------------------------------------------------------------
** External entry points
**---------------------------------------------------------------------------
*/
DWORD
IpcpInit(
IN BOOL fInitialize)
/* Called to initialize/uninitialize this CP. In the former case,
** fInitialize will be TRUE; in the latter case, it will be FALSE.
*/
{
static DWORD dwRefCount = 0;
DWORD dwErr;
if (fInitialize)
{
if (0 == dwRefCount)
{
if ((dwErr = HelperInitialize(&HDhcpDll)) != NO_ERROR)
{
return(dwErr);
}
PDhcpRequestOptions = (DHCPREQUESTOPTIONS)
GetProcAddress(HDhcpDll, "DhcpRequestOptions");
if (NULL == PDhcpRequestOptions)
{
return(GetLastError());
}
PDhcpNotifyConfigChange2 = (DHCPNOTIFYCONFIGCHANGEEX)
GetProcAddress(HDhcpDll, "DhcpNotifyConfigChangeEx");
if (NULL == PDhcpNotifyConfigChange2)
{
return(GetLastError());
}
ClearTcpipInfo();
DwIpcpTraceId = TraceRegister("RASIPCP");
}
dwRefCount++;
}
else
{
dwRefCount--;
if (0 == dwRefCount)
{
HelperUninitialize();
// Ignore errors
HDhcpDll = NULL;
PDhcpRequestOptions = NULL;
PDhcpNotifyConfigChange2 = NULL;
if (HRasArp != INVALID_HANDLE_VALUE)
CloseHandle( HRasArp );
HRasArp = INVALID_HANDLE_VALUE;
TraceDeregister(DwIpcpTraceId);
DwIpcpTraceId = INVALID_TRACEID;
}
}
return(NO_ERROR);
}
DWORD
IpcpGetInfo(
IN DWORD dwProtocolId,
OUT PPPCP_INFO* pInfo )
/* IpcpGetInfo entry point called by the PPP engine by name. See RasCp
** interface documentation.
*/
{
ZeroMemory( pInfo, sizeof(*pInfo) );
pInfo->Protocol = (DWORD )PPP_IPCP_PROTOCOL;
lstrcpy(pInfo->SzProtocolName, "IPCP");
pInfo->Recognize = 7;
pInfo->RasCpInit = IpcpInit;
pInfo->RasCpBegin = IpcpBegin;
pInfo->RasCpReset = IpcpReset;
pInfo->RasCpEnd = IpcpEnd;
pInfo->RasCpThisLayerFinished = IpcpThisLayerFinished;
pInfo->RasCpThisLayerUp = IpcpThisLayerUp;
pInfo->RasCpPreDisconnectCleanup = IpcpPreDisconnectCleanup;
pInfo->RasCpMakeConfigRequest = IpcpMakeConfigRequest;
pInfo->RasCpMakeConfigResult = IpcpMakeConfigResult;
pInfo->RasCpConfigAckReceived = IpcpConfigAckReceived;
pInfo->RasCpConfigNakReceived = IpcpConfigNakReceived;
pInfo->RasCpConfigRejReceived = IpcpConfigRejReceived;
pInfo->RasCpGetNegotiatedInfo = IpcpGetNegotiatedInfo;
pInfo->RasCpProjectionNotification = IpcpProjectionNotification;
pInfo->RasCpChangeNotification = IpcpChangeNotification;
return 0;
}
DWORD
IpcpChangeNotification(
VOID )
{
HelperChangeNotification();
return(NO_ERROR);
}
DWORD
IpcpBegin(
OUT VOID** ppWorkBuf,
IN VOID* pInfo )
/* RasCpBegin entry point called by the PPP engine thru the passed
** address. See RasCp interface documentation.
*/
{
DWORD dwErr;
PPPCP_INIT* pInit = (PPPCP_INIT* )pInfo;
IPCPWB* pwb;
RAS_AUTH_ATTRIBUTE * pAttribute;
BOOL fVPN = FALSE;
BOOL fVJAttributePresent = FALSE;
TraceIp("IPCP: IpcpBegin");
/* Allocate work buffer.
*/
if (!(pwb = (IPCPWB* )LocalAlloc( LPTR, sizeof(IPCPWB) )))
{
return( ERROR_NOT_ENOUGH_MEMORY );
}
pwb->fServer = pInit->fServer;
pwb->hport = pInit->hPort;
pwb->hConnection = pInit->hConnection;
pwb->hIPInterface = pInit->hInterface;
pwb->IfType = pInit->IfType;
pwb->fDisableNetbt = pInit->fDisableNetbt;
if (0 == MultiByteToWideChar(
CP_ACP,
0,
pInit->pszUserName,
-1,
pwb->wszUserName,
UNLEN+1 ) )
{
dwErr = GetLastError();
TraceIp("MultiByteToWideChar(%s) failed: %d",
pInit->pszUserName, dwErr);
LocalFree( pwb );
return( dwErr );
}
if (0 == MultiByteToWideChar(
CP_ACP,
0,
pInit->pszPortName,
-1,
pwb->wszPortName,
MAX_PORT_NAME+1 ) )
{
dwErr = GetLastError();
TraceIp("MultiByteToWideChar(%s) failed: %d",
pInit->pszPortName, dwErr);
LocalFree( pwb );
return( dwErr );
}
if ( pwb->fServer )
{
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
if (RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Params, &hkey ) == 0)
{
if (RegQueryValueEx(
hkey, REGVAL_HardIp, NULL, &dwType,
(LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue)
{
FClientMaySelectAddress = TRUE;
}
RegCloseKey( hkey );
}
TraceIp("IPCP: Hard IP=%d",FClientMaySelectAddress);
pwb->IpAddressToHandout = ( FClientMaySelectAddress )
? net_long( 0xFFFFFFFF )
: net_long( 0xFFFFFFFE );
//
// Is there an IP address parameter ?
//
pAttribute = RasAuthAttributeGet( raatFramedIPAddress,
pInit->pAttributes );
if ( pAttribute != NULL )
{
pwb->IpAddressToHandout = net_long( PtrToUlong(pAttribute->Value) );
TraceIp("IPCP: Using IP address attribute 0x%x",
pwb->IpAddressToHandout );
}
}
else
{
//
// We are a router or client dialing out, let other side always choose
// their address
//
pwb->IpAddressToHandout = net_long( 0xFFFFFFFF );
}
pwb->fRegisterWithWINS = 1;
if ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
{
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
pwb->fRegisterWithWINS = 0;
if (RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
if (RegQueryValueEx(
hkey, REGVAL_RegisterRoutersWithWINS, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue != 0)
{
TraceIp("IPCP: Will register routers with WINS");
pwb->fRegisterWithWINS = 1;
}
RegCloseKey( hkey );
}
}
/* Allocate a route between the MAC and the TCP/IP stack.
*/
if ((dwErr = RasAllocateRoute(
pwb->hport, IP, !pwb->fServer, &pwb->routeinfo )) != 0)
{
TraceIp("IPCP: RasAllocateRoute=%d",dwErr);
LocalFree( (HLOCAL )pwb );
return dwErr;
}
/* Lookup the compression capabilities.
*/
if ((dwErr = RasPortGetProtocolCompression(
pwb->hport, IP, &pwb->rpcSend, &pwb->rpcReceive )) != 0)
{
TraceIp("IPCP: RasPortGetProtocolCompression=%d",dwErr);
pwb->dwErrInBegin = dwErr;
*ppWorkBuf = pwb;
return 0;
}
if (0 == pwb->rpcSend.RP_ProtocolType.RP_IP.RP_IPCompressionProtocol)
{
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
fVPN = TRUE;
if (RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
/* VJ header compression is a history based scheme and since
we can't reliably detect lost frames over vpn's we have
dropped support for vj over vpn's.
*/
if (RegQueryValueEx(
hkey, REGVAL_AllowVJOverVPN, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue == 1)
{
TraceIp("IPCP: AllowVJOverVPN is TRUE");
pwb->rpcSend.RP_ProtocolType.RP_IP.RP_IPCompressionProtocol = 0x2D;
pwb->rpcReceive.RP_ProtocolType.RP_IP.RP_IPCompressionProtocol = 0x2D;
fVPN = FALSE;
}
RegCloseKey( hkey );
}
}
if ( pwb->fServer )
{
HANDLE hAttribute;
pAttribute = RasAuthAttributeGetFirst(raatFramedCompression,
pInit->pAttributes, &hAttribute );
while (NULL != pAttribute)
{
switch (PtrToUlong(pAttribute->Value))
{
case 0:
/* Don't request or accept VJ compression.
*/
TraceIp("IPCP: VJ disabled by RADIUS");
pwb->fIpCompressionRejected = TRUE;
memset( &pwb->rpcSend, '\0', sizeof(pwb->rpcSend) );
fVJAttributePresent = TRUE;
break;
case 1:
TraceIp("IPCP: VJ required by RADIUS");
fVJAttributePresent = TRUE;
break;
default:
break;
}
if (fVJAttributePresent)
{
break;
}
pAttribute = RasAuthAttributeGetNext(&hAttribute,
raatFramedCompression);
}
}
if (fVJAttributePresent)
{
// Nothing
}
else if (fVPN)
{
TraceIp("IPCP: VJ disabled for VPN");
pwb->fIpCompressionRejected = TRUE;
memset( &pwb->rpcSend, '\0', sizeof(pwb->rpcSend) );
}
else
{
/* Look up "request VJ compresion" flag in registry.
*/
{
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
if (RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
if (RegQueryValueEx(
hkey, REGVAL_VjComp, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue == 0)
{
TraceIp("IPCP: VJ requests disabled");
pwb->fIpCompressionRejected = TRUE;
}
RegCloseKey( hkey );
}
}
/* Look up "accept VJ compresion" flag in registry.
*/
{
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
if (RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
if (RegQueryValueEx(
hkey, REGVAL_VjComp2, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue == 0)
{
TraceIp("IPCP: VJ will not be accepted");
memset( &pwb->rpcSend, '\0', sizeof(pwb->rpcSend) );
}
RegCloseKey( hkey );
}
}
}
TraceIp("IPCP: Compress capabilities: s=$%x,%d,%d r=$%x,%d,%d",
(int)Protocol(pwb->rpcSend),(int)MaxSlotId(pwb->rpcSend),
(int)CompSlotId(pwb->rpcSend),(int)Protocol(pwb->rpcReceive),
(int)MaxSlotId(pwb->rpcReceive),CompSlotId(pwb->rpcReceive));
//
// If we are receiving a call from a client or another router, or we
// are a router dialing out.
//
if ( ( pwb->fServer ) ||
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
{
/* Look up the DNS server, WINS server, and "this server" addresses.
** This is done once at the beginning since these addresses are the
** same for a given route regardless of the IP addresses.
*/
TraceIp("IPCP: Server address lookup...");
TraceIp("IPCP: RasSrvrQueryServerAddresses...");
dwErr = RasSrvrQueryServerAddresses( &(pwb->IpInfoRemote) );
TraceIp("IPCP: RasSrvrQueryServerAddresses done(%d)",dwErr);
if (dwErr != 0)
{
pwb->dwErrInBegin = dwErr;
*ppWorkBuf = pwb;
return 0;
}
else
{
TraceIp("IPCP:Dns=%08x,Wins=%08x,DnsB=%08x,WinsB=%08x,"
"Server=%08x,Mask=%08x",
pwb->IpInfoRemote.nboDNSAddress,
pwb->IpInfoRemote.nboWINSAddress,
pwb->IpInfoRemote.nboDNSAddressBackup,
pwb->IpInfoRemote.nboWINSAddressBackup,
pwb->IpInfoRemote.nboServerIpAddress,
pwb->IpInfoRemote.nboServerSubnetMask);
}
//
// If this is not a router interface, then we use the server address
// as a local address
//
if ( ( pwb->fServer ) && ( pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER ) )
{
/* Request server's own IP address. (RAS client's don't care what
** the server's address is, but some other vendors like
** MorningStar won't connect unless you tell them)
*/
pwb->IpAddressLocal = pwb->IpInfoRemote.nboServerIpAddress;
}
}
//
// We are a client\router dialing out or a router dialing in,
//
if ( ( !pwb->fServer ) || ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
{
//
// See if registry indicates "no WINS/DNS requests" mode for clients
// dialing out.
//
HKEY hkey;
DWORD dwType;
DWORD dwValue;
DWORD cb = sizeof(DWORD);
if ( RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
if ( RegQueryValueEx(
hkey, REGVAL_NsAddrs, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue == 0)
{
TraceIp("IPCP: WINS/DNS requests disabled");
pwb->fIpaddrDnsRejected = TRUE;
pwb->fIpaddrWinsRejected = TRUE;
pwb->fIpaddrDnsBackupRejected = TRUE;
pwb->fIpaddrWinsBackupRejected = TRUE;
}
RegCloseKey( hkey );
}
/* Read the parameters sent from the UI in the parameters buffer.
*/
pwb->fPrioritizeRemote = TRUE;
if (pInit->pszzParameters)
{
DWORD dwIpSource;
CHAR szIpAddress[ 16 ];
WCHAR wszIpAddress[ 16 ];
BOOL fVjCompression;
DWORD dwDnsFlags;
CHAR szDnsSuffix[DNS_SUFFIX_SIZE + 1];
TraceIp("IPCP: UI parameters...");
DUMPB(pInit->pszzParameters,PARAMETERBUFLEN);
FindFlagInParamBuf(
pInit->pszzParameters, PBUFKEY_IpPrioritizeRemote,
&pwb->fPrioritizeRemote );
pwb->fUnnumbered = FALSE;
if ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
{
if ( RegOpenKey( HKEY_LOCAL_MACHINE, REGKEY_Ipcp, &hkey ) == 0)
{
if ( RegQueryValueEx(
hkey, REGVAL_Unnumbered, NULL,
&dwType, (LPBYTE )&dwValue, &cb ) == 0
&& dwType == REG_DWORD
&& cb == sizeof(DWORD)
&& dwValue != 0)
{
TraceIp("Unnumbered");
pwb->fUnnumbered = TRUE;
}
RegCloseKey( hkey );
}
}
{
if (FindLongInParamBuf(
pInit->pszzParameters, PBUFKEY_IpDnsFlags,
&dwDnsFlags ))
{
if (dwDnsFlags & 0x1)
{
pwb->fRegisterWithDNS = 1;
}
if ( (dwDnsFlags & 0x2)
|| (dwDnsFlags & 0x4) )
{
pwb->fRegisterAdapterDomainName = 1;
}
}
}
{
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpDnsSuffix,
szDnsSuffix, DNS_SUFFIX_SIZE + 1 ))
{
strncpy(pwb->szDnsSuffix, szDnsSuffix, DNS_SUFFIX_SIZE);
}
}
{
fVjCompression = TRUE;
FindFlagInParamBuf(
pInit->pszzParameters, PBUFKEY_IpVjCompression,
&fVjCompression );
if (!fVjCompression)
{
/* Don't request or accept VJ compression.
*/
TraceIp("IPCP: VJ disabled");
pwb->fIpCompressionRejected = TRUE;
memset( &pwb->rpcSend, '\0', sizeof(pwb->rpcSend) );
}
}
if( !pwb->fIpCompressionRejected
&& !Protocol(pwb->rpcReceive))
{
pwb->fIpCompressionRejected = TRUE;
}
dwIpSource = PBUFVAL_ServerAssigned;
FindLongInParamBuf(
pInit->pszzParameters, PBUFKEY_IpAddressSource,
&dwIpSource );
if (dwIpSource == PBUFVAL_RequireSpecific)
{
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpAddress,
szIpAddress, 16 ))
{
mbstowcs( wszIpAddress, szIpAddress, 16 );
pwb->IpAddressLocal
= IpAddressFromAbcdWsz( wszIpAddress );
}
}
dwIpSource = PBUFVAL_ServerAssigned;
FindLongInParamBuf(
pInit->pszzParameters, PBUFKEY_IpNameAddressSource,
&dwIpSource );
if (dwIpSource == PBUFVAL_RequireSpecific)
{
//
//check to see if DNS or WINS or both have been
//requested specific and set the flags accordingly
//so that we only request proper addresses
//from the server
//
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpDnsAddress,
szIpAddress, 16 ))
{
mbstowcs( wszIpAddress, szIpAddress, 16 );
pwb->IpInfoLocal.nboDNSAddress
= IpAddressFromAbcdWsz( wszIpAddress );
}
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpDns2Address,
szIpAddress, 16 ))
{
mbstowcs( wszIpAddress, szIpAddress, 16 );
pwb->IpInfoLocal.nboDNSAddressBackup
= IpAddressFromAbcdWsz( wszIpAddress );
}
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpWinsAddress,
szIpAddress, 16 ))
{
mbstowcs( wszIpAddress, szIpAddress, 16 );
pwb->IpInfoLocal.nboWINSAddress
= IpAddressFromAbcdWsz( wszIpAddress );
}
if (FindStringInParamBuf(
pInit->pszzParameters, PBUFKEY_IpWins2Address,
szIpAddress, 16 ))
{
mbstowcs( wszIpAddress, szIpAddress, 16 );
pwb->IpInfoLocal.nboWINSAddressBackup
= IpAddressFromAbcdWsz( wszIpAddress );
}
if ( pwb->IpInfoLocal.nboDNSAddress ||
pwb->IpInfoLocal.nboDNSAddressBackup
)
{
//Specific DNS address has been passed in
pwb->fIpaddrDnsRejected = TRUE;
pwb->fIpaddrDnsBackupRejected = TRUE;
}
if ( pwb->IpInfoLocal.nboWINSAddress ||
pwb->IpInfoLocal.nboWINSAddressBackup
)
{
//Specific WINS address has been requested
pwb->fIpaddrWinsRejected = TRUE;
pwb->fIpaddrWinsBackupRejected = TRUE;
}
}
}
TraceIp( "IPCP:a=%08x,f=%d",
pwb->IpAddressLocal,pwb->fPrioritizeRemote);
}
/* Register work buffer with engine.
*/
*ppWorkBuf = pwb;
return 0;
}
DWORD
IpcpThisLayerFinished(
IN VOID* pWorkBuf )
/* RasCpThisLayerFinished entry point called by the PPP engine thru the
** passed address. See RasCp interface documentation.
*/
{
DWORD dwErr = 0;
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
TraceIp("IPCP: IpcpThisLayerFinished...");
//
// If this is a server or a router dialing in or out then we release this
// address
//
if ( ( pwb->fServer ) ||
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ))
{
if (pwb->IpAddressRemote != 0)
{
TraceIp("IPCP: RasSrvrReleaseAddress...");
RasSrvrReleaseAddress(pwb->IpAddressRemote,
pwb->wszUserName,
pwb->wszPortName,
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ) ?
FALSE : TRUE);
TraceIp("IPCP: RasSrvrReleaseAddress done");
pwb->IpAddressRemote = 0;
}
//
// Set ConfigActive to false only for server
//
if ( ( pwb->fServer ) &&
( pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER ))
{
pwb->fRasConfigActive = FALSE;
}
}
//
// If we are a client dialing out or a router dialing in or out then we
// notify DHCP of releasing this address.
//
if ( ( !pwb->fServer ) ||
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ))
{
dwErr = DeActivateRasConfig( pwb );
if (dwErr == 0)
{
pwb->fRasConfigActive = FALSE;
}
}
if (pwb->fRouteActivated)
{
TraceIp("IPCP: RasDeAllocateRoute...");
RasDeAllocateRoute( pwb->hConnection, IP );
pwb->fRouteActivated = FALSE;
}
if ( pwb->pbDhcpRoutes )
{
//Parse the dhcp routes and remove the routes from stack
TraceIp("IPCP: RasDeAllocateDhcpRoute...");
RasTcpSetDhcpRoutes ( pwb->pbDhcpRoutes , pwb->IpAddressLocal, FALSE );
LocalFree (pwb->pbDhcpRoutes );
pwb->pbDhcpRoutes = NULL;
}
TraceIp("IPCP: IpcpThisLayerFinished done(%d)",dwErr);
return dwErr;
}
DWORD
IpcpEnd(
IN VOID* pWorkBuf )
/* RasCpEnd entry point called by the PPP engine thru the passed address.
** See RasCp interface documentation.
*/
{
DWORD dwErr = 0;
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
TraceIp("IPCP: IpcpEnd...");
dwErr = IpcpThisLayerFinished( pWorkBuf );
LocalFree( (HLOCAL )pWorkBuf );
TraceIp("IPCP: IpcpEnd done(%d)",dwErr);
return dwErr;
}
DWORD
IpcpReset(
IN VOID* pWorkBuf )
/* Called to reset negotiations. See RasCp interface documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
/* RasPpp.dll requires this to exist even though it does nothing
** (complaints to Gibbs).
*/
return 0;
}
DWORD
IpcpThisLayerUp(
IN VOID* pWorkBuf )
/* Called when the CP is entering Open state. See RasCp interface
** documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
TraceIp("IPCP: IpcpThisLayerUp");
if (pwb->fRasConfigActive || pwb->fExpectingProjection)
{
TraceIp("IPCP: Link already up...ignored.");
return 0;
}
/* Can't route until we know the result of the projection. Shouldn't
** activate until just before we route or WANARP reports errors. See
** IpcpProjectionResult.
*/
pwb->fExpectingProjection = TRUE;
TraceIp("IPCP: IpcpThisLayerUp done");
return 0;
}
DWORD
IpcpPreDisconnectCleanup(
IN VOID* pWorkBuf )
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
DWORD dwErr = NO_ERROR;
TraceIp("IPCP: IpcpPreDisconnectCleanup");
if ( ( pwb->fServer )
|| ( pwb->pwszDevice == NULL )
|| ( !pwb->fRegisterWithDNS ))
{
return( NO_ERROR );
}
if ( ( dwErr = ResetNetBTConfigInfo( pwb ) ) != NO_ERROR )
{
TraceIp("IPCP: ResetNetBTConfigInfo=%d",dwErr);
}
else
{
if ((dwErr = ReconfigureTcpip( pwb->pwszDevice, FALSE, 0, 0)) != 0)
{
TraceIp("IPCP: ReconfigureTcpip=%d", dwErr);
}
}
return(dwErr);
}
DWORD
IpcpMakeConfigRequest(
IN VOID* pWorkBuf,
OUT PPP_CONFIG* pSendBuf,
IN DWORD cbSendBuf )
/* Makes a configure-request packet in 'pSendBuf'. See RasCp interface
** documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
WORD cbPacket = PPP_CONFIG_HDR_LEN;
BYTE* pbThis = pSendBuf->Data;
TraceIp("IPCP: IpcpMakeConfigRequest");
RTASSERT(cbSendBuf>PPP_CONFIG_HDR_LEN+(IPADDRESSOPTIONLEN*3));
if (pwb->dwErrInBegin != 0)
{
TraceIp("IPCP: Deferred IpcpBegin error=%d",pwb->dwErrInBegin);
return pwb->dwErrInBegin;
}
if (++pwb->cRequestsWithoutResponse >= 5)
{
TraceIp("IPCP: Tossing MS options (request timeouts)");
pwb->fTryWithoutExtensions = TRUE;
pwb->fIpaddrDnsRejected = TRUE;
pwb->fIpaddrWinsRejected = TRUE;
pwb->fIpaddrDnsBackupRejected = TRUE;
pwb->fIpaddrWinsBackupRejected = TRUE;
}
if (!pwb->fIpCompressionRejected )
{
/* Request IP compression for both client and server.
*/
AddIpCompressionOption( pbThis, &pwb->rpcReceive );
cbPacket += IPCOMPRESSIONOPTIONLEN;
pbThis += IPCOMPRESSIONOPTIONLEN;
}
//
// We always negotiate this option, it will be 0 for clients and routers
// dialing out and routers dialing in, it will be the server's address
// for clients dialing in. We don't negotiate this option if we want
// unnumbered IPCP.
//
if (!pwb->fIpaddrRejected && !pwb->fUnnumbered)
{
AddIpAddressOption(
pbThis, OPTION_IpAddress, pwb->IpAddressLocal );
cbPacket += IPADDRESSOPTIONLEN;
pbThis += IPADDRESSOPTIONLEN;
}
//
// If we are client dialing out we need WINS and DNS addresses
//
if ( !pwb->fServer )
{
/* The client asks the server to provide a DNS address and WINS
** address (and depending on user's UI selections, an IP address) by
** sending 0's for these options.
*/
if (!pwb->fIpaddrDnsRejected)
{
AddIpAddressOption(
pbThis, OPTION_DnsIpAddress,
pwb->IpInfoLocal.nboDNSAddress );
cbPacket += IPADDRESSOPTIONLEN;
pbThis += IPADDRESSOPTIONLEN;
}
if (!pwb->fIpaddrWinsRejected)
{
AddIpAddressOption(
pbThis, OPTION_WinsIpAddress,
pwb->IpInfoLocal.nboWINSAddress );
cbPacket += IPADDRESSOPTIONLEN;
pbThis += IPADDRESSOPTIONLEN;
}
if (!pwb->fIpaddrDnsBackupRejected)
{
AddIpAddressOption(
pbThis, OPTION_DnsBackupIpAddress,
pwb->IpInfoLocal.nboDNSAddressBackup );
cbPacket += IPADDRESSOPTIONLEN;
pbThis += IPADDRESSOPTIONLEN;
}
if (!pwb->fIpaddrWinsBackupRejected)
{
AddIpAddressOption(
pbThis, OPTION_WinsBackupIpAddress,
pwb->IpInfoLocal.nboWINSAddressBackup );
cbPacket += IPADDRESSOPTIONLEN;
}
}
pSendBuf->Code = CONFIG_REQ;
HostToWireFormat16( cbPacket, pSendBuf->Length );
TraceIp("IPCP: ConfigRequest...");
DUMPB(pSendBuf,cbPacket);
return 0;
}
DWORD
IpcpMakeConfigResult(
IN VOID* pWorkBuf,
IN PPP_CONFIG* pReceiveBuf,
OUT PPP_CONFIG* pSendBuf,
IN DWORD cbSendBuf,
IN BOOL fRejectNaks )
/* Makes a configure-ack, -nak, or -reject packet in 'pSendBuf'. See
** RasCp interface documentation.
**
** Implements the Stefanian rule, i.e. accept only configure requests that
** exactly match the previously acknowledged request after this layer up
** has been called. This is necessary because the RAS route cannot be
** deallocated when the port is open (NDISWAN driver limitation), so
** renegotiation with different parameters is not possible once the route
** has been activated.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
DWORD dwErr;
BOOL f;
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
TraceIp("IPCP: IpcpMakeConfigResult for...");
DUMPB(pReceiveBuf,(pReceiveBuf)?WireToHostFormat16(pReceiveBuf->Length):0);
pwb->cRequestsWithoutResponse = 0;
/* Check if there's reason to reject the request and if so, do it.
*/
if ((dwErr = RejectCheck(
pwb, pReceiveBuf, pSendBuf, cbSendBuf, &f )) != 0)
{
TraceIp("IPCP: ConfigResult...");
DUMPB(pSendBuf,WireToHostFormat16(pSendBuf->Length));
return dwErr;
}
if (f)
return (pwb->fRasConfigActive) ? ERROR_PPP_NOT_CONVERGING : 0;
/* Check if there's reason to nak the request and if so, do it (or
** reject instead of nak if indicated by engine).
*/
if ((dwErr = NakCheck(
pwb, pReceiveBuf, pSendBuf, cbSendBuf, &f, fRejectNaks )) != 0)
{
TraceIp("IPCP: ConfigResult...");
DUMPB(pSendBuf,WireToHostFormat16(pSendBuf->Length));
return dwErr;
}
if (f)
return (pwb->fRasConfigActive) ? ERROR_PPP_NOT_CONVERGING : 0;
/* Acknowledge the request.
*/
{
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
CopyMemory( pSendBuf, pReceiveBuf, cbPacket );
pSendBuf->Code = CONFIG_ACK;
}
TraceIp("IPCP: ConfigResult...");
DUMPB(pSendBuf,WireToHostFormat16(pSendBuf->Length));
return 0;
}
DWORD
IpcpConfigAckReceived(
IN VOID* pWorkBuf,
IN PPP_CONFIG* pReceiveBuf )
/* Examines received configure-ack in 'pReceiveBuf'. See RasCp interface
** documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
DWORD dwErr = 0;
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
WORD cbLeft = cbPacket - PPP_CONFIG_HDR_LEN;
PPP_OPTION UNALIGNED* pROption = (PPP_OPTION UNALIGNED* )pReceiveBuf->Data;
BOOL fIpCompressionOk = pwb->fIpCompressionRejected;
BOOL fIpaddrOk = pwb->fIpaddrRejected || pwb->fUnnumbered;
BOOL fIpaddrDnsOk = pwb->fIpaddrDnsRejected;
BOOL fIpaddrWinsOk = pwb->fIpaddrWinsRejected;
BOOL fIpaddrDnsBackupOk = pwb->fIpaddrDnsBackupRejected;
BOOL fIpaddrWinsBackupOk = pwb->fIpaddrWinsBackupRejected;
TraceIp("IPCP: IpcpConfigAckReceived...");
DUMPB(pReceiveBuf,cbPacket);
pwb->cRequestsWithoutResponse = 0;
while (cbLeft > 0)
{
if (cbLeft < pROption->Length)
return ERROR_PPP_INVALID_PACKET;
if (pROption->Type == OPTION_IpCompression)
{
WORD wProtocol;
if (pROption->Length != IPCOMPRESSIONOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
wProtocol = WireToHostFormat16U(pROption->Data );
if (wProtocol != Protocol(pwb->rpcReceive)
|| pROption->Data[ 2 ] != MaxSlotId(pwb->rpcReceive)
|| pROption->Data[ 3 ] != CompSlotId(pwb->rpcReceive))
{
return ERROR_PPP_INVALID_PACKET;
}
fIpCompressionOk = TRUE;
}
else if (pROption->Type == OPTION_IpAddress)
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr != 0 && ipaddr == pwb->IpAddressLocal )
fIpaddrOk = TRUE;
}
else if (!pwb->fServer)
{
//
// We are a client dialing out
//
switch (pROption->Type)
{
case OPTION_DnsIpAddress:
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == pwb->IpInfoLocal.nboDNSAddress)
fIpaddrDnsOk = TRUE;
break;
}
case OPTION_WinsIpAddress:
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == pwb->IpInfoLocal.nboWINSAddress)
fIpaddrWinsOk = TRUE;
break;
}
case OPTION_DnsBackupIpAddress:
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == pwb->IpInfoLocal.nboDNSAddressBackup)
{
fIpaddrDnsBackupOk = TRUE;
}
break;
}
case OPTION_WinsBackupIpAddress:
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == pwb->IpInfoLocal.nboWINSAddressBackup)
{
fIpaddrWinsBackupOk = TRUE;
}
break;
}
default:
{
TraceIp("IPCP: Unrecognized option ACKed?");
return ERROR_PPP_INVALID_PACKET;
}
}
}
else
{
TraceIp("IPCP: Unrecognized option ACKed?");
return ERROR_PPP_INVALID_PACKET;
}
if (pROption->Length && pROption->Length < cbLeft)
cbLeft -= pROption->Length;
else
cbLeft = 0;
pROption = (PPP_OPTION* )((BYTE* )pROption + pROption->Length);
}
if ( !fIpCompressionOk
|| !fIpaddrOk
|| ( !pwb->fServer
&& ( !fIpaddrDnsOk
|| !fIpaddrWinsOk
|| !fIpaddrDnsBackupOk
|| !fIpaddrWinsBackupOk)))
{
dwErr = ERROR_PPP_INVALID_PACKET;
}
TraceIp("IPCP: IpcpConfigAckReceived done(%d)",dwErr);
return dwErr;
}
DWORD
IpcpConfigNakReceived(
IN VOID* pWorkBuf,
IN PPP_CONFIG* pReceiveBuf )
/* Examines received configure-nak in 'pReceiveBuf'. See RasCp interface
** documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
PPP_OPTION* pROption = (PPP_OPTION* )pReceiveBuf->Data;
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
WORD cbLeft = cbPacket - PPP_CONFIG_HDR_LEN;
TraceIp("IPCP: IpcpConfigNakReceived");
TraceIp("IPCP: Nak received...");
DUMPB(pReceiveBuf,(pReceiveBuf)?WireToHostFormat16(pReceiveBuf->Length):0);
pwb->cRequestsWithoutResponse = 0;
while (cbLeft > 0)
{
if (cbLeft < pROption->Length)
return ERROR_PPP_INVALID_PACKET;
if (pROption->Type == OPTION_IpCompression)
{
WORD wProtocol = WireToHostFormat16( pROption->Data );
if (wProtocol == COMPRESSION_VanJacobson)
{
/* He can send Van Jacobson but not with the slot parameters
** we suggested.
*/
if (pROption->Length != IPCOMPRESSIONOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
if (pROption->Data[ 2 ] <= MaxSlotId(pwb->rpcReceive))
{
/* We can accept his suggested MaxSlotID when it is less
** than or the same as what we can do.
*/
MaxSlotId(pwb->rpcReceive) = pROption->Data[ 2 ];
}
if (CompSlotId(pwb->rpcReceive))
{
/* We can compress the slot-ID or not, so just accept
** whatever he wants to do.
*/
CompSlotId(pwb->rpcReceive) = pROption->Data[ 3 ];
}
}
}
else if ( ( !pwb->fServer ) ||
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
{
switch (pROption->Type)
{
case OPTION_IpAddress:
{
IPADDR ipaddr;
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == 0)
{
if (pwb->IpAddressLocal == 0)
{
/* Server naked us with zero when we asked it to
** assign us an address, meaning he doesn't know
** how to assign us an address but we can provide
** an alternate address if we want. Currently we
** don't support a backup address here.
*/
return ERROR_PPP_NO_ADDRESS_ASSIGNED;
}
else
{
/* Server naked us with zero when we asked for a
** specific address, meaning he doesn't know how
** to assign us an address but we can provide an
** alternate address if we want. Currently we
** don't support a backup address here.
*/
return ERROR_PPP_REQUIRED_ADDRESS_REJECTED;
}
}
if (pwb->IpAddressLocal != 0)
{
/* We asked for a specific address (per user's
** instructions) but server says we can't have it and
** is trying to give us another. No good, tell user
** we can't get the address he requires.
*/
return ERROR_PPP_REQUIRED_ADDRESS_REJECTED;
}
/* Accept the address suggested by server.
*/
pwb->IpAddressLocal = ipaddr;
break;
}
case OPTION_DnsIpAddress:
{
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
//
// Use this only if we asked for it
//
if ( !pwb->fIpaddrDnsRejected )
{
/* Accept the DNS address suggested by server.
*/
CopyMemory( &pwb->IpInfoLocal.nboDNSAddress,
pROption->Data, sizeof(IPADDR) );
}
break;
}
case OPTION_WinsIpAddress:
{
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
//
// Use this only if we asked for it
//
if ( !pwb->fIpaddrWinsRejected )
{
/* Accept the WINS address suggested by server.
*/
CopyMemory( &pwb->IpInfoLocal.nboWINSAddress,
pROption->Data, sizeof(IPADDR) );
}
break;
}
case OPTION_DnsBackupIpAddress:
{
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
//
// Use this only if we asked for it
//
if ( !pwb->fIpaddrDnsBackupRejected )
{
/* Accept the DNS backup address suggested by server.
*/
CopyMemory( &pwb->IpInfoLocal.nboDNSAddressBackup,
pROption->Data, sizeof(IPADDR) );
}
break;
}
case OPTION_WinsBackupIpAddress:
{
if (pROption->Length != IPADDRESSOPTIONLEN)
return ERROR_PPP_INVALID_PACKET;
//
// Use this only if we asked for it
//
if ( !pwb->fIpaddrWinsBackupRejected )
{
/* Accept the WINS backup address suggested by server.
*/
CopyMemory( &pwb->IpInfoLocal.nboWINSAddressBackup,
pROption->Data, sizeof(IPADDR) );
}
break;
}
default:
TraceIp("IPCP: Unrequested option NAKed?");
break;
}
}
if (pROption->Length && pROption->Length < cbLeft)
cbLeft -= pROption->Length;
else
cbLeft = 0;
pROption = (PPP_OPTION* )((BYTE* )pROption + pROption->Length);
}
return 0;
}
DWORD
IpcpConfigRejReceived(
IN VOID* pWorkBuf,
IN PPP_CONFIG* pReceiveBuf )
/* Examines received configure-reject in 'pReceiveBuf'. See RasCp
** interface documentation.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
PPP_OPTION* pROption = (PPP_OPTION* )pReceiveBuf->Data;
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
WORD cbLeft = cbPacket - PPP_CONFIG_HDR_LEN;
TraceIp("IPCP: IpcpConfigRejReceived");
TraceIp("IPCP: Rej received...");
DUMPB(pReceiveBuf,(pReceiveBuf)?WireToHostFormat16(pReceiveBuf->Length):0);
pwb->cRequestsWithoutResponse = 0;
while (cbLeft > 0)
{
if (pROption->Type == OPTION_IpCompression)
{
TraceIp("IPCP: IP compression was rejected");
pwb->fIpCompressionRejected = TRUE;
Protocol(pwb->rpcReceive) = 0;
MaxSlotId(pwb->rpcReceive) = 0;
CompSlotId(pwb->rpcReceive) = 0;
}
else if ( ( pwb->fServer ) &&
( pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER ) )
{
switch (pROption->Type)
{
case OPTION_IpAddress:
{
/* He can't handle a server address option. No problem,
** it's informational only.
*/
TraceIp("IPCP: Server IP address was rejected");
pwb->fIpaddrRejected = TRUE;
break;
}
default:
TraceIp("IPCP: Unrequested option rejected?");
break;
}
}
else
{
switch (pROption->Type)
{
case OPTION_IpAddress:
{
TraceIp("IPCP: IP was rejected");
if (pwb->IpAddressLocal != 0)
{
/* We accept rejection of the IP address if we know
** what address we want to use and use it anyway.
** Some router implementations require a
** certain IP address but can't handle this option to
** confirm that.
*/
pwb->fIpaddrRejected = TRUE;
break;
}
if ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
{
pwb->fUnnumbered = TRUE;
break;
}
else if (pwb->fTryWithoutExtensions)
{
/* He doesn't know how to give us an IP address, but
** we can't accept no for an answer. Have to bail.
*/
return ERROR_PPP_NO_ADDRESS_ASSIGNED;
}
else
{
/* When we request that server assign us an address,
** this is a required option. If it's rejected assume
** all the Microsoft extension options were rejected
** and try again. Other vendors will not test this
** case explicitly and may have bugs in their reject
** code.
*/
TraceIp("IPCP: Tossing MS options (no address)");
pwb->fTryWithoutExtensions = TRUE;
pwb->fIpaddrDnsRejected = TRUE;
pwb->fIpaddrWinsRejected = TRUE;
pwb->fIpaddrDnsBackupRejected = TRUE;
pwb->fIpaddrWinsBackupRejected = TRUE;
return 0;
}
}
case OPTION_DnsIpAddress:
{
/* He doesn't know how to give us a DNS address, but we
** can live with that.
*/
TraceIp("IPCP: DNS was rejected");
pwb->fIpaddrDnsRejected = TRUE;
break;
}
case OPTION_WinsIpAddress:
{
/* He doesn't know how to give us a WINS address, but we
** can live with that.
*/
TraceIp("IPCP: WINS was rejected");
pwb->fIpaddrWinsRejected = TRUE;
break;
}
case OPTION_DnsBackupIpAddress:
{
/* He doesn't know how to give us a backup DNS address,
** but we can live with that.
*/
TraceIp("IPCP: DNS backup was rejected");
pwb->fIpaddrDnsBackupRejected = TRUE;
break;
}
case OPTION_WinsBackupIpAddress:
{
/* He doesn't know how to give us a backup WINS address,
** but we can live with that.
*/
TraceIp("IPCP: WINS backup was rejected");
pwb->fIpaddrWinsBackupRejected = TRUE;
break;
}
default:
TraceIp("IPCP: Unrequested option rejected?");
break;
}
}
if (pROption->Length && pROption->Length <= cbLeft)
cbLeft -= pROption->Length;
else
{
if (pwb->fTryWithoutExtensions)
cbLeft = 0;
else
{
/* If an invalid packet is detected, assume all the Microsoft
** extension options were rejected and try again. Other
** vendors will not test this case explicitly and may have
** bugs in their reject code.
*/
TraceIp("IPCP: Tossing MS options (length)");
pwb->fTryWithoutExtensions = TRUE;
pwb->fIpaddrDnsRejected = TRUE;
pwb->fIpaddrWinsRejected = TRUE;
pwb->fIpaddrDnsBackupRejected = TRUE;
pwb->fIpaddrWinsBackupRejected = TRUE;
return 0;
}
}
pROption = (PPP_OPTION* )((BYTE* )pROption + pROption->Length);
}
return 0;
}
DWORD
IpcpGetNegotiatedInfo(
IN VOID* pWorkBuf,
OUT PPP_IPCP_RESULT * pIpCpResult
)
/* Returns the negotiated IP address in string form followed by the
** server's IP address, if known. The two addresses are null-terminated
** strings in back to back 15 + 1 character arrays.
**
** Returns 0 if successful, otherwise a non-0 error code. "No address
** active" is considered successful, and an empty address string is
** returned.
*/
{
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
TraceIp("IPCP: IpcpGetNetworkAddress...");
if (pwb->fRasConfigActive || pwb->fExpectingProjection)
{
pIpCpResult->fSendVJHCompression = Protocol(pwb->rpcSend);
pIpCpResult->fReceiveVJHCompression = Protocol(pwb->rpcReceive);
pIpCpResult->dwLocalAddress = pwb->IpAddressLocal;
pIpCpResult->dwLocalWINSAddress = pwb->IpInfoLocal.nboWINSAddress;
pIpCpResult->dwLocalWINSBackupAddress
= pwb->IpInfoLocal.nboWINSAddressBackup;
pIpCpResult->dwLocalDNSAddress = pwb->IpInfoLocal.nboDNSAddress;
pIpCpResult->dwLocalDNSBackupAddress
= pwb->IpInfoLocal.nboDNSAddressBackup;
pIpCpResult->dwRemoteAddress = pwb->IpAddressRemote;
pIpCpResult->dwRemoteWINSAddress = pwb->IpInfoRemote.nboWINSAddress;
pIpCpResult->dwRemoteWINSBackupAddress
= pwb->IpInfoRemote.nboWINSAddressBackup;
pIpCpResult->dwRemoteDNSAddress = pwb->IpInfoRemote.nboDNSAddress;
pIpCpResult->dwRemoteDNSBackupAddress
= pwb->IpInfoRemote.nboDNSAddressBackup;
}
TraceIp("IPCP: IpcpGetNetworkAddress done");
return 0;
}
DWORD
IpcpDhcpInform(
IN IPCPWB* pwb,
IN PPP_DHCP_INFORM* pDhcpInform)
{
TCPIP_INFO* ptcpip = NULL;
IPADDR nboMask;
IPADDR nboIpAddr;
DWORD dwErr;
DWORD dwDomainNameSize;
size_t size;
DWORD dwIndex;
// Get current TCPIP setup info from registry.
TraceIp("IpcpDhcpInform:LoadTcpipInfo(Device=%ws)",pDhcpInform->wszDevice);
dwErr = LoadTcpipInfo( &ptcpip, pDhcpInform->wszDevice,
FALSE /* fAdapterOnly */ );
TraceIp("IpcpDhcpInform:LoadTcpipInfo done(%d)",dwErr);
if (dwErr != 0)
{
goto LDone;
}
TraceIp("IpcpDhcpInform: Old Dns=%ws",
ptcpip->wszDNSNameServers ? ptcpip->wszDNSNameServers : L"");
for (dwIndex = 0; dwIndex < pDhcpInform->dwNumDNSAddresses; dwIndex++)
{
dwErr = PrependDwIpAddress(
&ptcpip->wszDNSNameServers,
pDhcpInform->pdwDNSAddresses[dwIndex]);
if (dwErr)
{
TraceIp("IpcpDhcpInform: PrependDwIpAddress done(%d)",dwErr);
goto LDone;
}
}
TraceIp("IpcpDhcpInform: New Dns=%ws",
ptcpip->wszDNSNameServers ? ptcpip->wszDNSNameServers : L"");
if (pDhcpInform->dwWINSAddress1)
{
PrintMwsz("IpcpDhcpInform: Old Wins=", ptcpip->mwszNetBIOSNameServers);
if (pDhcpInform->dwWINSAddress2)
{
dwErr = PrependDwIpAddressToMwsz(
&ptcpip->mwszNetBIOSNameServers,
pDhcpInform->dwWINSAddress2);
if (dwErr)
{
TraceIp("IpcpDhcpInform: PrependDwIpAddress done(%d)",dwErr);
goto LDone;
}
}
dwErr = PrependDwIpAddressToMwsz(
&ptcpip->mwszNetBIOSNameServers,
pDhcpInform->dwWINSAddress1);
if (dwErr)
{
TraceIp("IpcpDhcpInform: PrependDwIpAddress done(%d)",dwErr);
goto LDone;
}
PrintMwsz("IpcpDhcpInform: New Wins=", ptcpip->mwszNetBIOSNameServers);
}
if (pDhcpInform->szDomainName)
{
dwDomainNameSize = strlen(pDhcpInform->szDomainName) + 1;
LocalFree(ptcpip->wszDNSDomainName);
ptcpip->wszDNSDomainName = LocalAlloc(LPTR, sizeof(WCHAR) * dwDomainNameSize);
if (NULL == ptcpip->wszDNSDomainName)
{
dwErr = GetLastError();
TraceIp("IpcpDhcpInform: LocalAlloc done(%d)", dwErr);
goto LDone;
}
if (0 == MultiByteToWideChar(
CP_ACP,
0,
pDhcpInform->szDomainName,
-1,
ptcpip->wszDNSDomainName,
dwDomainNameSize ) )
{
dwErr = GetLastError();
TraceIp("IpcpDhcpInform: Error %d converting domain name %s",
dwErr,
pDhcpInform->szDomainName);
goto LDone;
}
}
ptcpip->fDisableNetBIOSoverTcpip = pwb->fDisableNetbt;
// Set TCPIP setup info in registry and release the buffer.
TraceIp("IpcpDhcpInform: SaveTcpipInfo...");
dwErr = SaveTcpipInfo( ptcpip );
TraceIp("IpcpDhcpInform: SaveTcpipInfo done(%d)",dwErr);
if (dwErr != 0)
{
goto LDone;
}
dwErr = ReconfigureTcpip(pDhcpInform->wszDevice, FALSE, 0, 0);
if (NO_ERROR != dwErr)
{
TraceIp("IpcpDhcpInform: ReconfigureTcpip=%d",dwErr);
goto LDone;
}
nboIpAddr = pwb->IpAddressLocal;
if ( !pwb->fPrioritizeRemote )
{
// We have added this route only if there is
// no default route and so remove it if
// there is no default route
// Remove the old route with the guessed mask
nboMask = RasTcpDeriveMask(nboIpAddr);
if (nboMask != 0)
{
RasTcpSetRoute(
nboIpAddr & nboMask,
nboIpAddr,
nboMask,
nboIpAddr,
FALSE,
1,
TRUE);
}
}
// Add the new route with the precise mask
nboMask = pDhcpInform->dwSubnetMask;
if (nboMask != 0)
{
RasTcpSetRoute(
nboIpAddr & nboMask,
nboIpAddr,
nboMask,
nboIpAddr,
TRUE,
1,
TRUE);
}
pwb->dwNumDNSAddresses = pDhcpInform->dwNumDNSAddresses;
pwb->pdwDNSAddresses = pDhcpInform->pdwDNSAddresses;
if ( pDhcpInform->pbDhcpRoutes )
{
//Parse the dhcp routes and plumb ths stack
RasTcpSetDhcpRoutes ( pDhcpInform->pbDhcpRoutes, pwb->IpAddressLocal, TRUE );
pwb->pbDhcpRoutes = pDhcpInform->pbDhcpRoutes;
}
LDone:
FreeTcpipInfo(&ptcpip);
return(dwErr);
}
DWORD
ResetNetBTConfigInfo(
IN IPCPWB* pwb )
/*
** Will reset all the NetBT information in the registry to 0
*/
{
TCPIP_INFO* ptcpip = NULL;
DWORD dwErr;
/* Get current TCPIP setup info from registry.
*/
TraceIp("IPCP: LoadTcpipInfo...");
dwErr = LoadTcpipInfo( &ptcpip, pwb->pwszDevice, TRUE /* fAdapterOnly */ );
TraceIp("IPCP: LoadTcpipInfo done(%d)",dwErr);
if (dwErr)
{
goto LDone;
}
ptcpip->fChanged = TRUE ;
/* Set TCPIP setup info in registry and release the buffer.
*/
TraceIp("IPCP: SaveTcpipInfo...");
dwErr = SaveTcpipInfo( ptcpip );
TraceIp("IPCP: SaveTcpipInfo done(%d)",dwErr);
LDone:
FreeTcpipInfo( &ptcpip );
pwb->dwNumDNSAddresses = 0;
LocalFree(pwb->pdwDNSAddresses);
pwb->pdwDNSAddresses = NULL;
return( dwErr );
}
VOID
DhcpInform(
PVOID pContext
)
{
IPCP_DHCP_INFORM* pIpcpDhcpInform = (IPCP_DHCP_INFORM*)pContext;
PPPE_MESSAGE PppMessage;
//Changed vivekk
BYTE pbRequestedOptions[6];
BYTE* pbOptionList = NULL;
DWORD dwOptionListSize;
BYTE* pbReturnedOptions = NULL;
DWORD dwNumberOfAvailableOptions;
DWORD dwNumOptions;
DWORD dwIndex;
DWORD dwOffset;
DWORD dwNextOffset;
DWORD dwCurOffset;
DWORD dwDomainNameSize;
DWORD dwNumDNSAddresses = 0;
IPADDR* pnboDNSAddresses = NULL;
IPADDR nboWINSAddress1 = 0;
IPADDR nboWINSAddress2 = 0;
IPADDR nboSubnetMask = 0;
CHAR* szDomainName = NULL;
PBYTE pbRouteInfo = NULL; //Route information got from DHCP option 133
DWORD dwErr;
BOOL fFree = TRUE;
BOOL fSendMessage = FALSE;
int i;
pbRequestedOptions[0] = OPTION_DNS_NAME_SERVERS;
pbRequestedOptions[1] = OPTION_NETBIOS_NAME_SERVERS;
pbRequestedOptions[2] = OPTION_VENDOR_SPEC_INFO;
pbRequestedOptions[3] = OPTION_SUBNET_MASK;
pbRequestedOptions[4] = OPTION_VENDOR_ROUTE_PLUMB;
pbRequestedOptions[5] = OPTION_DNS_DOMAIN_NAME;
// There is a bug in DhcpRequestOptions, due to which, if we request
// OPTION_DNS_DOMAIN_NAME, it automatically gets written to the registry
if (pIpcpDhcpInform->fUseDhcpInformDomainName)
{
dwNumOptions = 6;
}
else
{
dwNumOptions = 5;
}
TraceIp("DhcpRequestOptions(%ws)...", pIpcpDhcpInform->wszDevice);
dwErr = PDhcpRequestOptions(
pIpcpDhcpInform->wszDevice,
pbRequestedOptions,
dwNumOptions,
&pbOptionList,
&dwOptionListSize,
&pbReturnedOptions,
&dwNumberOfAvailableOptions);
TraceIp("DhcpRequestOptions done(%d)", dwErr);
if (dwErr != ERROR_SUCCESS)
{
goto LDhcpInformEnd;
}
TraceIpDump(pbOptionList, dwOptionListSize);
for (dwIndex = 0, dwOffset = 0;
dwIndex < dwNumberOfAvailableOptions;
dwIndex++)
{
RTASSERT(dwOffset + 1 <= dwOptionListSize);
switch (pbReturnedOptions[dwIndex])
{
case OPTION_DNS_DOMAIN_NAME:
dwDomainNameSize = pbOptionList[dwOffset];
if (0 == dwDomainNameSize)
{
TraceIp("Invalid DOMAIN_NAME size %d", dwDomainNameSize);
goto LDhcpInformEnd;
}
if (NULL != szDomainName)
{
LocalFree(szDomainName);
}
szDomainName = LocalAlloc(LPTR, dwDomainNameSize + 1);
if (NULL == szDomainName)
{
TraceIp("DhcpInform: LocalAlloc=%d", GetLastError());
goto LDhcpInformEnd;
}
dwNextOffset = dwOffset + dwDomainNameSize + 1;
CopyMemory(szDomainName, pbOptionList + dwOffset + 1,
dwDomainNameSize);
fSendMessage = TRUE;
TraceIp("DhcpInform: DOMAIN_NAME %s", szDomainName);
dwOffset = dwNextOffset;
break;
case OPTION_DNS_NAME_SERVERS:
if (0 != (pbOptionList[dwOffset] % 4))
{
TraceIp("Invalid DOMAIN_NAME_SERVERS size %d",
pbOptionList[dwOffset]);
goto LDhcpInformEnd;
}
if (NULL != pnboDNSAddresses)
{
LocalFree(pnboDNSAddresses);
dwNumDNSAddresses = 0;
}
pnboDNSAddresses = LocalAlloc(LPTR,
sizeof(IPADDR) * pbOptionList[dwOffset] / 4);
if (NULL == pnboDNSAddresses)
{
TraceIp("DhcpInform: LocalAlloc=%d",GetLastError());
goto LDhcpInformEnd;
}
dwNextOffset = dwOffset + pbOptionList[dwOffset] + 1;
for (dwCurOffset = dwOffset + 1;
dwCurOffset < dwNextOffset;
dwCurOffset += 4, dwNumDNSAddresses++)
{
pnboDNSAddresses[dwNumDNSAddresses] =
(pbOptionList[dwCurOffset]) +
(pbOptionList[dwCurOffset + 1] << 8) +
(pbOptionList[dwCurOffset + 2] << 16) +
(pbOptionList[dwCurOffset + 3] << 24);
TraceIp("DhcpInform: DOMAIN_NAME_SERVER 0x%x",
pnboDNSAddresses[dwNumDNSAddresses]);
fSendMessage = TRUE;
}
RTASSERT((DWORD)(pbOptionList[dwOffset] / 4) == dwNumDNSAddresses);
dwOffset = dwNextOffset;
break;
case OPTION_NETBIOS_NAME_SERVERS:
if (0 != (pbOptionList[dwOffset] % 4))
{
TraceIp("Invalid NETBIOS_NAME_SERVER size %d",
pbOptionList[dwOffset]);
goto LDhcpInformEnd;
}
dwNextOffset = dwOffset + pbOptionList[dwOffset] + 1;
dwCurOffset = dwOffset + 1;
for (i = 0; i < 2; i++)
{
IPADDR* paddr;
if (0 == i)
{
paddr = &nboWINSAddress1;
}
else
{
paddr = &nboWINSAddress2;
}
*paddr =
(pbOptionList[dwCurOffset]) +
(pbOptionList[dwCurOffset + 1] << 8) +
(pbOptionList[dwCurOffset + 2] << 16) +
(pbOptionList[dwCurOffset + 3] << 24);
TraceIp("DhcpInform: NETBIOS_NAME_SERVER 0x%x",
*paddr);
fSendMessage = TRUE;
dwCurOffset += 4;
if (dwCurOffset == dwNextOffset)
{
break;
}
}
dwOffset = dwNextOffset;
break;
case OPTION_SUBNET_MASK:
if (0 != (pbOptionList[dwOffset] % 4))
{
TraceIp("Invalid OPTION_SUBNET_MASK size %d",
pbOptionList[dwOffset]);
goto LDhcpInformEnd;
}
dwNextOffset = dwOffset + pbOptionList[dwOffset] + 1;
nboSubnetMask = (pbOptionList[dwOffset + 1]) +
(pbOptionList[dwOffset + 2] << 8) +
(pbOptionList[dwOffset + 3] << 16) +
(pbOptionList[dwOffset + 4] << 24);
TraceIp("DhcpInform: OPTION_SUBNET_MASK 0x%x", nboSubnetMask);
fSendMessage = TRUE;
dwOffset = dwNextOffset;
break;
case OPTION_VENDOR_ROUTE_PLUMB:
TraceIp("DhcpInform: OPTION_VENDOR_ROUTE_PLUMB Code %x Len %x", pbOptionList[dwOffset], pbOptionList[dwOffset+1]);
//this should be a minimum of 5 bytes
dwNextOffset = dwOffset + pbOptionList[dwOffset] + 1;
if ( pbOptionList[dwOffset+1] < 5 )
{
TraceIp("Invalid OPTION_VENDOR_ROUTE_PLUMB size %d", pbOptionList[dwOffset+1]);
goto LDhcpInformEnd;
}
//now decode the
fSendMessage = TRUE;
pbRouteInfo = (PBYTE)LocalAlloc(LPTR, pbOptionList[dwOffset] + 1 );
if (NULL == pbRouteInfo)
{
TraceIp("DhcpInform: LocalAlloc=%d",GetLastError());
goto LDhcpInformEnd;
}
CopyMemory(pbRouteInfo, pbOptionList + dwOffset,
pbOptionList[dwOffset]+1);
fSendMessage= TRUE;
dwOffset = dwNextOffset;
break;
default:
dwOffset += pbOptionList[dwOffset] + 1;
break;
}
}
if (fSendMessage)
{
PppMessage.dwMsgId = PPPEMSG_DhcpInform;
PppMessage.hConnection = pIpcpDhcpInform->hConnection;
PppMessage.ExtraInfo.DhcpInform.wszDevice = pIpcpDhcpInform->wszDevice;
PppMessage.ExtraInfo.DhcpInform.dwNumDNSAddresses = dwNumDNSAddresses;
PppMessage.ExtraInfo.DhcpInform.pdwDNSAddresses = pnboDNSAddresses;
PppMessage.ExtraInfo.DhcpInform.dwWINSAddress1 = nboWINSAddress1;
PppMessage.ExtraInfo.DhcpInform.dwWINSAddress2 = nboWINSAddress2;
PppMessage.ExtraInfo.DhcpInform.dwSubnetMask = nboSubnetMask;
PppMessage.ExtraInfo.DhcpInform.szDomainName = szDomainName;
PppMessage.ExtraInfo.DhcpInform.pbDhcpRoutes = pbRouteInfo;
dwErr = SendPPPMessageToEngine(&PppMessage);
if (dwErr != NO_ERROR)
{
TraceIp("DhcpInform: SendPPPMessageToEngine=%d",dwErr);
goto LDhcpInformEnd;
}
fFree = FALSE;
}
LDhcpInformEnd:
if (fFree)
{
LocalFree(pIpcpDhcpInform->wszDevice);
LocalFree(pnboDNSAddresses);
LocalFree(szDomainName);
LocalFree(pbRouteInfo);
}
LocalFree(pIpcpDhcpInform);
LocalFree(pbOptionList);
LocalFree(pbReturnedOptions);
}
DWORD
IpcpProjectionNotification(
IN VOID* pWorkBuf,
IN VOID* pProjectionResult )
/* Called when projection result of all CPs is known.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
DWORD dwErr = 0;
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
BOOL fSetDefaultRoute = FALSE;
TraceIp("IPCP: IpcpProjectionNotification");
if (pwb->fExpectingProjection)
{
CHAR szBuf[sizeof(PROTOCOL_CONFIG_INFO) + sizeof(IP_WAN_LINKUP_INFO)];
IPCPWB* pwb = (IPCPWB* )pWorkBuf;
PROTOCOL_CONFIG_INFO* pProtocol = (PROTOCOL_CONFIG_INFO* )szBuf;
IP_WAN_LINKUP_INFO UNALIGNED *pLinkUp = (PIP_WAN_LINKUP_INFO)pProtocol->P_Info;
PPP_PROJECTION_RESULT* p = (PPP_PROJECTION_RESULT* )pProjectionResult;
/* Activate the route between the TCP/IP stack and the RAS MAC.
*/
pProtocol->P_Length = sizeof(IP_WAN_LINKUP_INFO);
pLinkUp->duUsage = ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
? DU_ROUTER
: (pwb->fServer) ? DU_CALLIN : DU_CALLOUT;
pLinkUp->dwUserIfIndex = HandleToULong(pwb->hIPInterface);
pLinkUp->dwLocalMask = 0xFFFFFFFF;
pLinkUp->dwLocalAddr = pwb->IpAddressLocal;
pLinkUp->dwRemoteAddr = pwb->IpAddressRemote;
pLinkUp->fFilterNetBios =
(pwb->fServer && p->nbf.dwError == 0);
pLinkUp->fDefaultRoute = pwb->fPrioritizeRemote;
TraceIp("IPCP: RasActivateRoute(u=%x,a=%x,nf=%d)...",
pLinkUp->duUsage,pLinkUp->dwLocalAddr,
pLinkUp->fFilterNetBios);
TraceIp("IPCP: RasActivateRoute ICB# == %d",
pLinkUp->dwUserIfIndex);
dwErr = RasActivateRoute(pwb->hport,IP,&pwb->routeinfo,pProtocol);
TraceIp("IPCP: RasActivateRoute done(%d)",dwErr);
if ( dwErr == 0 )
{
pwb->fRouteActivated = TRUE;
/* Find the device name within the adapter name, e.g. ndiswan00.
** This is used to identify adapters in the TcpipInfo calls later.
*/
pwb->pwszDevice = wcschr(&pwb->routeinfo.RI_AdapterName[1], L'\\');
if ( !pwb->pwszDevice )
{
TraceIp("IPCP: No device?");
dwErr = ERROR_INVALID_PARAMETER;
}
else
{
++pwb->pwszDevice;
}
}
//
// If we are a client or a router dialing in or out we need to plumb
// the registry.
//
if ( ( dwErr == 0 ) &&
((!pwb->fServer) || (pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER)))
{
do
{
TCPIP_INFO* ptcpip;
/* Get current TCPIP setup info from registry.
*/
TraceIp("IPCP:LoadTcpipInfo(Device=%ws)",pwb->pwszDevice);
dwErr = LoadTcpipInfo( &ptcpip, pwb->pwszDevice,
TRUE /* fAdapterOnly */ );
TraceIp("IPCP: LoadTcpipInfo done(%d)",dwErr);
if (dwErr != 0)
break;
//
// We first save the IP address and call
// DhcpNotifyConfigChange, then set WINS/DNS and call
// DhcpNotifyConfigChange to work around Windows 2000 bug
// 381884.
//
AbcdWszFromIpAddress(pwb->IpAddressLocal, ptcpip->wszIPAddress);
AbcdWszFromIpAddress(pLinkUp->dwLocalMask, ptcpip->wszSubnetMask);
ptcpip->fDisableNetBIOSoverTcpip = pwb->fDisableNetbt;
ptcpip->fChanged = TRUE ;
TraceIp("IPCP: SaveTcpipInfo...");
dwErr = SaveTcpipInfo( ptcpip );
TraceIp("IPCP: SaveTcpipInfo done(%d)",dwErr);
if (dwErr)
{
ResetNetBTConfigInfo( pwb );
FreeTcpipInfo( &ptcpip );
break;
}
#if 0
if (!pwb->fUnnumbered)
{
/* Tell TCPIP components to reconfigure themselves.
*/
if ((dwErr = ReconfigureTcpip(pwb->pwszDevice,
TRUE,
pwb->IpAddressLocal,
pLinkUp->dwLocalMask)) != NO_ERROR)
{
TraceIp("IPCP: ReconfigureTcpip=%d",dwErr);
ResetNetBTConfigInfo( pwb );
FreeTcpipInfo( &ptcpip );
break;
}
}
#endif
/* Make the LAN the default interface in multi-homed case.
*/
if(pLinkUp->duUsage != DU_ROUTER)
{
BOOL fAddRoute = TRUE;
RASMAN_INFO *pInfo = LocalAlloc(LPTR, sizeof(RASMAN_INFO));
if(NULL != pInfo)
{
dwErr = RasGetInfo(NULL, pwb->hport, pInfo);
if(ERROR_SUCCESS != dwErr)
{
TraceIp("IPCP: HelperSetDefaultInterfaceNet, RasGetInfo "
"failed 0x%x", dwErr);
}
if(RAS_DEVICE_CLASS(pInfo->RI_rdtDeviceType)
== RDT_Tunnel)
{
fAddRoute = FALSE;
}
LocalFree(pInfo);
}
//
// Do the change metric and add subnet route stuff
// for non router cases only
//
TraceIp("IPCP: HelperSetDefaultInterfaceNet(a=%08x,f=%d)",
pwb->IpAddressLocal,pwb->fPrioritizeRemote);
dwErr = HelperSetDefaultInterfaceNet(
pwb->IpAddressLocal,
(fAddRoute) ?
pwb->IpAddressRemote :
0,
pwb->fPrioritizeRemote,
pwb->pwszDevice);
TraceIp("IPCP: HelperSetDefaultInterfaceNet done(%d)",
dwErr);
if ( dwErr != NO_ERROR )
{
// ResetNetBTConfigInfo( pwb );
// FreeTcpipInfo( &ptcpip );
break;
}
fSetDefaultRoute = TRUE;
}
#if 0
/* Get current TCPIP setup info from registry.
*/
TraceIp("IPCP:LoadTcpipInfo(Device=%ws)",pwb->pwszDevice);
dwErr = LoadTcpipInfo( &ptcpip, pwb->pwszDevice,
TRUE /* fAdapterOnly */ );
TraceIp("IPCP: LoadTcpipInfo done(%d)",dwErr);
if (dwErr != 0)
break;
AbcdWszFromIpAddress(pwb->IpAddressLocal, ptcpip->wszIPAddress);
AbcdWszFromIpAddress(pLinkUp->dwLocalMask, ptcpip->wszSubnetMask);
#endif
ptcpip->fChanged = FALSE ;
/* Add the negotiated DNS and backup DNS server (if any)
** at the head of the list of DNS servers. (Backup is
** done first so the the non-backup will wind up first)
*/
if (pwb->IpInfoLocal.nboDNSAddressBackup)
{
dwErr = PrependDwIpAddress(
&ptcpip->wszDNSNameServers,
pwb->IpInfoLocal.nboDNSAddressBackup );
if (dwErr)
{
FreeTcpipInfo( &ptcpip );
break;
}
}
if (pwb->IpInfoLocal.nboDNSAddress)
{
dwErr = PrependDwIpAddress(
&ptcpip->wszDNSNameServers,
pwb->IpInfoLocal.nboDNSAddress );
if (dwErr)
{
FreeTcpipInfo( &ptcpip );
break;
}
}
TraceIp("IPCP: New Dns=%ws",
ptcpip->wszDNSNameServers ? ptcpip->wszDNSNameServers : L"");
if (!pwb->fRegisterWithWINS)
{
// Ignore the WINS server addresses. If we save them, then
// registration will happen automatically.
}
else
{
/* Set the WINS and backup WINS server addresses to
** the negotiated addresses (if any).
*/
if (pwb->IpInfoLocal.nboWINSAddressBackup)
{
dwErr = PrependDwIpAddressToMwsz(
&ptcpip->mwszNetBIOSNameServers,
pwb->IpInfoLocal.nboWINSAddressBackup );
if (dwErr)
{
FreeTcpipInfo( &ptcpip );
break;
}
}
if (pwb->IpInfoLocal.nboWINSAddress)
{
dwErr = PrependDwIpAddressToMwsz(
&ptcpip->mwszNetBIOSNameServers,
pwb->IpInfoLocal.nboWINSAddress );
if (dwErr)
{
FreeTcpipInfo( &ptcpip );
break;
}
}
PrintMwsz("IPCP: New Wins=",
ptcpip->mwszNetBIOSNameServers);
}
// The DNS API's are called in rasSrvrInitAdapterName also.
if (pwb->fRegisterWithDNS)
{
DnsEnableDynamicRegistration(pwb->pwszDevice);
TraceIp("DnsEnableDynamicRegistration");
}
else
{
DnsDisableDynamicRegistration(pwb->pwszDevice);
TraceIp("DnsDisableDynamicRegistration");
}
if (pwb->fRegisterAdapterDomainName)
{
DnsEnableAdapterDomainNameRegistration(pwb->pwszDevice);
TraceIp("DnsEnableAdapterDomainNameRegistration");
}
else
{
DnsDisableAdapterDomainNameRegistration(pwb->pwszDevice);
TraceIp("DnsDisableAdapterDomainNameRegistration");
}
if (pwb->szDnsSuffix[0] != 0)
{
DWORD dwDomainNameSize;
dwDomainNameSize = strlen(pwb->szDnsSuffix) + 1;
ptcpip->wszDNSDomainName = LocalAlloc(LPTR, sizeof(WCHAR) * dwDomainNameSize);
if (NULL != ptcpip->wszDNSDomainName)
{
MultiByteToWideChar(
CP_ACP,
0,
pwb->szDnsSuffix,
-1,
ptcpip->wszDNSDomainName,
dwDomainNameSize );
}
}
TraceIp("IPCP: SaveTcpipInfo...");
dwErr = SaveTcpipInfo( ptcpip );
TraceIp("IPCP: SaveTcpipInfo done(%d)",dwErr);
FreeTcpipInfo( &ptcpip );
if (dwErr != 0)
{
break;
}
if (!pwb->fUnnumbered)
{
/* Tell TCPIP components to reconfigure themselves.
*/
if ((dwErr = ReconfigureTcpip(pwb->pwszDevice,
TRUE,
pwb->IpAddressLocal,
pLinkUp->dwLocalMask)) != NO_ERROR)
{
TraceIp("IPCP: ReconfigureTcpip=%d",dwErr);
// This will fail if the dhcp client is not running.
// dwErr = NO_ERROR;
ResetNetBTConfigInfo( pwb );
break;
}
}
/* Adjust the metric for Multicast class D Addresses */
if ( (!pwb->fServer)
)
{
dwErr = RasTcpAdjustMulticastRouteMetric ( pwb->IpAddressLocal, TRUE );
if ( NO_ERROR != dwErr )
{
TraceIp("IPCP: =RasTcpAdjustMulticastRouteMetric%d",dwErr);
dwErr = NO_ERROR;
}
}
/* Do DHCPINFORM only for clients */
while ((!pwb->fServer) &&
(pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER))
{
IPCP_DHCP_INFORM* pIpcpDhcpInform = NULL;
BOOL fErr = TRUE;
pIpcpDhcpInform = LocalAlloc(LPTR, sizeof(IPCP_DHCP_INFORM));
if (NULL == pIpcpDhcpInform)
{
TraceIp("IPCP: LocalAlloc 1 =%d",GetLastError());
goto LWhileEnd;
}
pIpcpDhcpInform->fUseDhcpInformDomainName =
(pwb->szDnsSuffix[0] == 0);
pIpcpDhcpInform->wszDevice = LocalAlloc(LPTR,
sizeof(WCHAR) * (wcslen(pwb->pwszDevice) + 1));
if (NULL == pIpcpDhcpInform->wszDevice)
{
TraceIp("IPCP: LocalAlloc 2 =%d",GetLastError());
goto LWhileEnd;
}
wcscpy(pIpcpDhcpInform->wszDevice, pwb->pwszDevice);
pIpcpDhcpInform->hConnection = pwb->hConnection;
dwErr = RtlQueueWorkItem(DhcpInform, pIpcpDhcpInform,
WT_EXECUTELONGFUNCTION);
if (dwErr != STATUS_SUCCESS)
{
TraceIp("IPCP: RtlQueueWorkItem=%d",dwErr);
goto LWhileEnd;
}
fErr = FALSE;
LWhileEnd:
if (fErr)
{
if (pIpcpDhcpInform)
{
LocalFree(pIpcpDhcpInform->wszDevice);
}
LocalFree(pIpcpDhcpInform);
}
break;
}
}
while (FALSE);
}
if (dwErr == 0)
{
pwb->fRasConfigActive = TRUE;
/* Tell MAC about any negotiated compression parameters.
*/
if (pwb->fIpCompressionRejected)
{
Protocol(pwb->rpcReceive) = NO_PROTOCOL_COMPRESSION;
MaxSlotId(pwb->rpcReceive) = 0;
CompSlotId(pwb->rpcReceive) = 0;
}
if (!pwb->fSendCompression)
{
Protocol(pwb->rpcSend) = NO_PROTOCOL_COMPRESSION;
MaxSlotId(pwb->rpcSend) = 0;
CompSlotId(pwb->rpcSend) = 0;
}
//if (Protocol(pwb->rpcSend) != 0 || Protocol(pwb->rpcReceive) != 0)
{
TraceIp("IPCP:RasPortSetProtocolCompression(s=%d,%d r=%d,%d)",
(int)MaxSlotId(pwb->rpcSend),(int)CompSlotId(pwb->rpcSend),
(int)MaxSlotId(pwb->rpcReceive),
(int)CompSlotId(pwb->rpcReceive));
dwErr = RasPortSetProtocolCompression(
pwb->hport, IP, &pwb->rpcSend, &pwb->rpcReceive );
TraceIp("IPCP: RasPortSetProtocolCompression done(%d)",dwErr);
}
if ( ( ( pwb->fServer ) ||
( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER ) )
&& ( pwb->IpAddressRemote != 0 ))
{
WCHAR* pwsz[5];
WCHAR wszIPAddress[MAXIPSTRLEN + 1];
WCHAR wszSubnet[MAXIPSTRLEN + 1];
WCHAR wszMask[MAXIPSTRLEN + 1];
/* Register addresses in server's routing tables.
*/
TraceIp("IPCP: RasSrvrActivateIp...");
dwErr = RasSrvrActivateIp( pwb->IpAddressRemote,
pLinkUp->duUsage );
TraceIp("IPCP: RasSrvrActivateIp done(%d)",dwErr);
}
if ( pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER )
{
WCHAR* pwsz[2];
if ( pwb->IpAddressRemote == 0 )
{
pwsz[0] = pwb->wszPortName;
pwsz[1] = pwb->wszUserName;
LogEventW(EVENTLOG_WARNING_TYPE,
ROUTERLOG_REMOTE_UNNUMBERED_IPCP, 2,
pwsz);
}
if ( pwb->IpAddressLocal == 0 )
{
pwsz[0] = pwb->wszPortName;
pwsz[1] = pwb->wszUserName;
LogEventW(EVENTLOG_WARNING_TYPE,
ROUTERLOG_LOCAL_UNNUMBERED_IPCP, 2,
pwsz);
}
}
}
pwb->fExpectingProjection = FALSE;
if (dwErr != NO_ERROR)
{
if(pwb->fRouteActivated)
{
TraceIp("IPCP: RasDeAllocateRoute...");
RasDeAllocateRoute( pwb->hConnection, IP );
pwb->fRouteActivated = FALSE;
}
if(fSetDefaultRoute)
{
HelperResetDefaultInterfaceNet(
pwb->IpAddressLocal,
pwb->fPrioritizeRemote);
}
}
}
return dwErr;
}
/*---------------------------------------------------------------------------
** Internal routines (alphabetically)
**---------------------------------------------------------------------------
*/
VOID
AddIpAddressOption(
OUT BYTE UNALIGNED* pbBuf,
IN BYTE bOption,
IN IPADDR ipaddr )
/* Write an IP address 'ipaddr' configuration option of type 'bOption' at
** location 'pbBuf'.
*/
{
*pbBuf++ = bOption;
*pbBuf++ = IPADDRESSOPTIONLEN;
*((IPADDR UNALIGNED* )pbBuf) = ipaddr;
}
VOID
AddIpCompressionOption(
OUT BYTE UNALIGNED* pbBuf,
IN RAS_PROTOCOLCOMPRESSION* prpc )
/* Write an IP compression protocol configuration as described in '*prpc'
** at location 'pbBuf'.
*/
{
*pbBuf++ = OPTION_IpCompression;
*pbBuf++ = IPCOMPRESSIONOPTIONLEN;
HostToWireFormat16U( Protocol(*prpc), pbBuf );
pbBuf += 2;
*pbBuf++ = MaxSlotId(*prpc);
*pbBuf = CompSlotId(*prpc);
}
/*
Notes:
DeActivates the active RAS configuration, if any.
*/
DWORD
DeActivateRasConfig(
IN IPCPWB* pwb
)
{
DWORD dwErr = NO_ERROR;
if (!pwb->fRasConfigActive)
{
goto LDone;
}
TraceIp("DeActivateRasConfig");
dwErr = ResetNetBTConfigInfo(pwb);
if (NO_ERROR != dwErr)
{
goto LDone;
}
/* Adjust the metric for Multicast class D Addresses */
if ( (!pwb->fServer)
)
{
RasTcpAdjustMulticastRouteMetric ( pwb->IpAddressLocal, FALSE );
//The route will be automatically removed when the interface disapperars
}
dwErr = ReconfigureTcpip(pwb->pwszDevice, TRUE, 0, 0);
if (NO_ERROR != dwErr)
{
// Ignore errors. You may get a 15 here.
dwErr = NO_ERROR;
}
if (pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER)
{
TraceIp("HelperResetDefaultInterfaceNet(0x%x, %sPrioritizeRemote)",
pwb->IpAddressLocal,
pwb->fPrioritizeRemote ? "" : "!");
dwErr = HelperResetDefaultInterfaceNet(
pwb->IpAddressLocal, pwb->fPrioritizeRemote);
if (NO_ERROR != dwErr)
{
TraceIp("HelperResetDefaultInterfaceNet failed and returned %d",
dwErr);
}
}
LDone:
return(dwErr);
}
DWORD
NakCheck(
IN IPCPWB* pwb,
IN PPP_CONFIG* pReceiveBuf,
OUT PPP_CONFIG* pSendBuf,
IN DWORD cbSendBuf,
OUT BOOL* pfNak,
IN BOOL fRejectNaks )
/* Check to see if received packet 'pReceiveBuf' should be Naked and if
** so, build a Nak packet with suggested values in 'pSendBuf'. If
** 'fRejectNaks' is set the original options are placed in a Reject packet
** instead. '*pfNak' is set true if either a Nak or Rej packet was
** created.
**
** Note: This routine assumes that corrupt packets have already been
** weeded out.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
PPP_OPTION UNALIGNED* pROption = (PPP_OPTION UNALIGNED* )pReceiveBuf->Data;
PPP_OPTION UNALIGNED* pSOption = (PPP_OPTION UNALIGNED* )pSendBuf->Data;
/* (server only) The address the client requests, then if NAKed, the non-0
** address we NAK with. If this is 0 after the packet has been processed,
** the IP-Address option was not negotiated.
*/
IPADDR ipaddrClient = 0;
DWORD dwErr = 0;
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
WORD cbLeft = cbPacket - PPP_CONFIG_HDR_LEN;
TraceIp("IPCP: NakCheck");
*pfNak = FALSE;
while (cbLeft > 0)
{
RTASSERT(cbLeft>=pROption->Length);
if (pROption->Type == OPTION_IpCompression)
{
BOOL fNakCompression = FALSE;
if (WireToHostFormat16U(pROption->Data )
== COMPRESSION_VanJacobson)
{
RTASSERT((pROption->Length==IPCOMPRESSIONOPTIONLEN));
/* He wants to receive Van Jacobson. We know we can do it or
** it would have already been rejected, but make sure we can
** handle his slot parameters.
*/
if (pROption->Data[ 2 ] <= MaxSlotId(pwb->rpcSend))
{
/* We can accept his suggested MaxSlotID when it is less
** than or the same as what we can send.
*/
MaxSlotId(pwb->rpcSend) = pROption->Data[ 2 ];
}
else
fNakCompression = TRUE;
if (CompSlotId(pwb->rpcSend))
{
/* We can compress the slot-ID or not, so just accept
** whatever he wants us to send.
*/
CompSlotId(pwb->rpcSend) = pROption->Data[ 3 ];
}
else if (pROption->Data[ 3 ])
fNakCompression = TRUE;
}
else
fNakCompression = TRUE;
if (fNakCompression)
{
TraceIp("IPCP: Naking IP compression");
*pfNak = TRUE;
if (fRejectNaks)
{
CopyMemory(
(VOID* )pSOption, (VOID* )pROption, pROption->Length );
}
else
{
pSOption->Type = OPTION_IpCompression;
pSOption->Length = IPCOMPRESSIONOPTIONLEN;
HostToWireFormat16U(
(WORD )COMPRESSION_VanJacobson,
pSOption->Data );
pSOption->Data[ 2 ] = MaxSlotId(pwb->rpcSend);
pSOption->Data[ 3 ] = CompSlotId(pwb->rpcSend);
pSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pSOption->Length);
}
pwb->fSendCompression = FALSE;
}
else
{
pwb->fSendCompression = TRUE;
}
}
else if ((pwb->fServer) || (pwb->IfType == ROUTER_IF_TYPE_FULL_ROUTER))
{
switch (pROption->Type)
{
case OPTION_IpAddress:
{
RTASSERT(pROption->Length==IPADDRESSOPTIONLEN);
CopyMemory( &ipaddrClient, pROption->Data, sizeof(IPADDR) );
if (pwb->IpAddressRemote != 0)
{
if ( ipaddrClient == pwb->IpAddressRemote )
{
//
// If we have already allocated what the user
// wants, we are done with this option.
//
break;
}
else if ( ipaddrClient == 0 )
{
ipaddrClient = pwb->IpAddressRemote;
*pfNak = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption,
pROption->Length );
if (!fRejectNaks)
{
TraceIp("IPCP: Naking IP");
CopyMemory( pSOption->Data,
&pwb->IpAddressRemote,
sizeof(IPADDR) );
}
pSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
break;
}
else
{
TraceIp("IPCP: RasSrvrReleaseAddress...");
RasSrvrReleaseAddress(
pwb->IpAddressRemote,
pwb->wszUserName,
pwb->wszPortName,
FALSE );
TraceIp("IPCP: RasSrvrReleaseAddress done");
pwb->IpAddressRemote = 0;
}
}
//
// If client is requesting an IP address, check to see
// if we are allowed to give it to him.
//
if ( ( ipaddrClient != 0 ) &&
( pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER ) &&
( pwb->IpAddressToHandout == net_long( 0xFFFFFFFE ) ) )
{
TraceIp("IPCP: Clients not allowed to request IPaddr");
ipaddrClient = 0;
}
TraceIp("IPCP: RasSrvrAcquireAddress(%08x)...",
ipaddrClient);
dwErr = RasSrvrAcquireAddress(
pwb->hport,
((pwb->IpAddressToHandout != net_long(0xFFFFFFFF))&&
(pwb->IpAddressToHandout != net_long(0xFFFFFFFE)))
? pwb->IpAddressToHandout
: ipaddrClient,
&(pwb->IpAddressRemote),
pwb->wszUserName,
pwb->wszPortName );
TraceIp("IPCP: RasSrvrAcquireAddress done(%d)",
dwErr);
if (dwErr != 0)
{
return dwErr;
}
if (ipaddrClient != 0)
{
TraceIp("IPCP: Hard IP requested");
if ( ipaddrClient == pwb->IpAddressRemote )
{
/* Good. Client's asking for the address we
** want to give him.
*/
TraceIp("IPCP: Accepting IP");
break;
}
else
{
//
// Otherwise we could not give the user the
// address he/she requested. Nak with this address.
//
TraceIp("IPCP: 3rd party DLL changed IP");
}
}
else
{
TraceIp("IPCP: Server IP requested");
}
ipaddrClient = pwb->IpAddressRemote;
*pfNak = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption,
pROption->Length );
if (!fRejectNaks)
{
TraceIp("IPCP: Naking IP");
CopyMemory( pSOption->Data,
&pwb->IpAddressRemote,
sizeof(IPADDR) );
}
pSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
break;
}
case OPTION_DnsIpAddress:
case OPTION_WinsIpAddress:
case OPTION_DnsBackupIpAddress:
case OPTION_WinsBackupIpAddress:
{
if (NakCheckNameServerOption(
pwb, fRejectNaks, pROption, &pSOption ))
{
*pfNak = TRUE;
}
break;
}
default:
TraceIp("IPCP: Unknown option?");
break;
}
}
if (pROption->Length && pROption->Length < cbLeft)
cbLeft -= pROption->Length;
else
cbLeft = 0;
pROption =
(PPP_OPTION UNALIGNED* )((BYTE* )pROption + pROption->Length);
}
if ( pwb->fServer
&& ( pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER )
&& ipaddrClient == 0 )
{
/* ipaddrClient is 0 iff there is no OPTION_IpAddress */
TraceIp("IPCP: No IP option");
/* If client doesn't provide or asked to be assigned an IP address,
** suggest one so he'll tell us what he wants.
*/
if ( pwb->IpAddressRemote == 0 )
{
TraceIp("IPCP: RasSrvrAcquireAddress(0)...");
dwErr = RasSrvrAcquireAddress(
pwb->hport,
0,
&(pwb->IpAddressRemote),
pwb->wszUserName,
pwb->wszPortName );
TraceIp("IPCP: RasSrvrAcquireAddress done(%d)",dwErr);
if (dwErr != 0)
return dwErr;
}
/* Time to reject instead of nak and client is still not requesting an
** IP address. We simply allocate an IP address and ACK this request
*/
if ( !fRejectNaks )
{
AddIpAddressOption(
(BYTE UNALIGNED* )pSOption, OPTION_IpAddress,
pwb->IpAddressRemote );
pSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )pSOption + IPADDRESSOPTIONLEN);
*pfNak = TRUE;
}
}
if (*pfNak)
{
pSendBuf->Code = (fRejectNaks) ? CONFIG_REJ : CONFIG_NAK;
HostToWireFormat16(
(WORD )((BYTE* )pSOption - (BYTE* )pSendBuf), pSendBuf->Length );
}
return 0;
}
BOOL
NakCheckNameServerOption(
IN IPCPWB* pwb,
IN BOOL fRejectNaks,
IN PPP_OPTION UNALIGNED* pROption,
OUT PPP_OPTION UNALIGNED** ppSOption )
/* Check a name server option for possible naking. 'pwb' the work buffer
** stored for us by the engine. 'fRejectNaks' is set the original options
** are placed in a Reject packet instead. 'pROption' is the address of
** the received option. '*ppSOption' is the address of the option to be
** sent, if there's a problem.
**
** Returns true if the name server address option should be naked or
** rejected, false if it's OK.
*/
{
IPADDR ipaddr;
IPADDR* pipaddrWant;
switch (pROption->Type)
{
case OPTION_DnsIpAddress:
pipaddrWant = &pwb->IpInfoRemote.nboDNSAddress;
break;
case OPTION_WinsIpAddress:
pipaddrWant = &pwb->IpInfoRemote.nboWINSAddress;
break;
case OPTION_DnsBackupIpAddress:
pipaddrWant = &pwb->IpInfoRemote.nboDNSAddressBackup;
break;
case OPTION_WinsBackupIpAddress:
pipaddrWant = &pwb->IpInfoRemote.nboWINSAddressBackup;
break;
default:
RTASSERT((!"Bogus option"));
return FALSE;
}
RTASSERT(pROption->Length==IPADDRESSOPTIONLEN);
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (ipaddr == *pipaddrWant)
{
/* Good. Client's asking for the address we want to give him.
*/
return FALSE;
}
/* Not our expected address value, so Nak it.
*/
TraceIp("IPCP: Naking $%x",(int)pROption->Type);
CopyMemory( (VOID* )*ppSOption, (VOID* )pROption, pROption->Length );
if (!fRejectNaks)
CopyMemory( (*ppSOption)->Data, pipaddrWant, sizeof(IPADDR) );
*ppSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )*ppSOption + pROption->Length);
return TRUE;
}
DWORD
RejectCheck(
IN IPCPWB* pwb,
IN PPP_CONFIG* pReceiveBuf,
OUT PPP_CONFIG* pSendBuf,
IN DWORD cbSendBuf,
OUT BOOL* pfReject )
/* Check received packet 'pReceiveBuf' options to see if any should be
** rejected and if so, build a Rej packet in 'pSendBuf'. '*pfReject' is
** set true if a Rej packet was created.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
PPP_OPTION UNALIGNED* pROption = (PPP_OPTION UNALIGNED* )pReceiveBuf->Data;
PPP_OPTION UNALIGNED* pSOption = (PPP_OPTION UNALIGNED* )pSendBuf->Data;
WORD cbPacket = WireToHostFormat16( pReceiveBuf->Length );
WORD cbLeft = cbPacket - PPP_CONFIG_HDR_LEN;
TraceIp("IPCP: RejectCheck");
*pfReject = FALSE;
while (cbLeft > 0)
{
if (cbLeft < pROption->Length)
return ERROR_PPP_INVALID_PACKET;
if (pROption->Type == OPTION_IpCompression)
{
WORD wProtocol =
WireToHostFormat16U(pROption->Data );
if (wProtocol != COMPRESSION_VanJacobson
|| pROption->Length != IPCOMPRESSIONOPTIONLEN
|| Protocol(pwb->rpcSend) == 0)
{
TraceIp("IPCP: Rejecting IP compression");
*pfReject = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption, pROption->Length );
pSOption = (PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
}
}
else if (pwb->fServer)
{
//
// This is a client/router dialing in
//
switch (pROption->Type)
{
case OPTION_IpAddress:
case OPTION_DnsIpAddress:
case OPTION_WinsIpAddress:
case OPTION_DnsBackupIpAddress:
case OPTION_WinsBackupIpAddress:
{
IPADDR ipaddr;
BOOL fBadLength = (pROption->Length != IPADDRESSOPTIONLEN);
if (!fBadLength)
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if (fBadLength
|| (!ipaddr
&& ((pROption->Type == OPTION_DnsIpAddress
&& !pwb->IpInfoRemote.nboDNSAddress)
|| (pROption->Type == OPTION_WinsIpAddress
&& !pwb->IpInfoRemote.nboWINSAddress)
|| (pROption->Type == OPTION_DnsBackupIpAddress
&& !pwb->IpInfoRemote.nboDNSAddressBackup)
|| (pROption->Type == OPTION_WinsBackupIpAddress
&& !pwb->IpInfoRemote.nboWINSAddressBackup))))
{
/* messed up IP address option, reject it.
*/
TraceIp("IPCP: Rejecting $%x",(int )pROption->Type);
*pfReject = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption,
pROption->Length );
pSOption = (PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
}
break;
}
default:
{
/* Unknown option, reject it.
*/
TraceIp("IPCP: Rejecting $%x",(int )pROption->Type);
*pfReject = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption, pROption->Length );
pSOption =
(PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
break;
}
}
}
else
{
//
// This is a client/router dialing out
//
IPADDR ipaddr;
BOOL fBad = (pROption->Type != OPTION_IpAddress
|| pROption->Length != IPADDRESSOPTIONLEN);
if (!fBad)
CopyMemory( &ipaddr, pROption->Data, sizeof(IPADDR) );
if ( fBad
|| ( !ipaddr
&& (pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER)))
{
/* Client rejects everything except a non-zero IP address
** which is accepted because some peers (such as Shiva) can't
** handle rejection of this option.
*/
TraceIp("IPCP: Rejecting %d",(int )pROption->Type);
*pfReject = TRUE;
CopyMemory(
(VOID* )pSOption, (VOID* )pROption, pROption->Length );
pSOption = (PPP_OPTION UNALIGNED* )((BYTE* )pSOption +
pROption->Length);
}
else
{
/* Store the server's IP address as some applications may be
** able to make use of it (e.g. Compaq does), though they are
** not guaranteed to receive it from all IPCP implementations.
*/
if (pwb->IfType != ROUTER_IF_TYPE_FULL_ROUTER)
{
pwb->IpAddressRemote = ipaddr;
}
}
}
if (pROption->Length && pROption->Length < cbLeft)
cbLeft -= pROption->Length;
else
cbLeft = 0;
pROption =
(PPP_OPTION UNALIGNED* )((BYTE* )pROption +
pROption->Length);
}
if (*pfReject)
{
pSendBuf->Code = CONFIG_REJ;
HostToWireFormat16(
(WORD )((BYTE* )pSOption - (BYTE* )pSendBuf), pSendBuf->Length );
}
return 0;
}
DWORD
ReconfigureTcpip(
IN WCHAR* pwszDevice,
IN BOOL fNewIpAddress,
IN IPADDR ipaddr,
IN IPADDR ipMask
)
/* Reconfigure running TCP/IP components.
**
** Returns 0 if successful, otherwise a non-0 error code.
*/
{
DWORD dwErr;
TraceIp("IPCP: ReconfigureTcpip(%08x, %08x)",
ipaddr, ipMask);
dwErr = PDhcpNotifyConfigChange2(NULL, pwszDevice, fNewIpAddress, 0,
ipaddr, ipMask, IgnoreFlag,
NOTIFY_FLG_DO_DNS);
TraceIp("IPCP: ReconfigureTcpip done(%d)",dwErr);
return dwErr;
}
VOID
TraceIp(
CHAR * Format,
...
)
{
va_list arglist;
va_start(arglist, Format);
TraceVprintfEx( DwIpcpTraceId,
PPPIPCP_TRACE | TRACE_USE_MASK | TRACE_USE_MSEC,
Format,
arglist);
va_end(arglist);
}
VOID
TraceIpDump(
LPVOID lpData,
DWORD dwByteCount
)
{
TraceDumpEx( DwIpcpTraceId,
PPPIPCP_TRACE | TRACE_USE_MASK | TRACE_USE_MSEC,
lpData, dwByteCount, 1, FALSE, NULL );
}
VOID
PrintMwsz(
CHAR* sz,
WCHAR* mwsz
)
{
WCHAR* wsz;
DWORD dwLength;
if (NULL == mwsz)
{
TraceIp("%s", sz);
return;
}
dwLength = MwszLength(mwsz);
wsz = LocalAlloc(LPTR, dwLength * sizeof(WCHAR));
if (NULL == wsz)
{
TraceIp("LocalAlloc failed and returned %d", GetLastError());
return;
}
CopyMemory(wsz, mwsz, dwLength * sizeof(WCHAR));
dwLength -= 2;
while (dwLength != 0)
{
dwLength--;
if (0 == wsz[dwLength])
{
wsz[dwLength] = L' ';
}
}
TraceIp("%s %ws", sz, wsz);
LocalFree(wsz);
}