Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

960 lines
24 KiB

/*
Copyright (c) 1998, Microsoft Corporation, all rights reserved
Description:
Only the timer thread can call the following functions:
rasDhcpAllocateAddress, rasDhcpMonitorAddresses, rasDhcpRenewLease. This is
required to avoid race conditions in the timer queue (because these
functions call RasDhcpTimerSchedule). The only exception is that
RasDhcpInitialize can call RasDhcpTimerSchedule, but before the timer thread
is started. rasDhcpRenewLease leaves and enters the critical section in the
middle of the function. If pAddrInfo is freed in the meantime, there will be
an AV. However, only rasDhcpDeleteLists frees pAddrInfo's from the list.
Fortunately, only RasDhcpUninitialize (after stopping the timer thread) and
rasDhcpAllocateAddress (which belongs to the timer thread) call
rasDhcpDeleteLists.
If we get an EasyNet address, DHCP has already made sure that it is not
conflicting with anyone. We call SetProxyArp, so that no one else in the
future will take it (if they are well behaved).
*/
#include "rasdhcp_.h"
/*
Returns:
Notes:
There is no synchronization here, can be added easily but the assumption
here is that the initialization is a synchronous operation and till it
completes, no other code in this sub-system will be called.
*/
DWORD
RasDhcpInitialize(
VOID
)
{
DWORD dwErr = NO_ERROR;
TraceHlp("RasDhcpInitialize");
EnterCriticalSection(&RasDhcpCriticalSection);
RtlGetNtProductType(&RasDhcpNtProductType);
if (NtProductWinNt == RasDhcpNtProductType)
{
RasDhcpNumReqAddrs = 2;
}
else
{
RasDhcpNumReqAddrs = HelperRegVal.dwChunkSize;
}
// This should be done before we start the timer thread. Once the timer
// thread starts, only it can call RasDhcpTimerSchedule (to avoid race
// conditions).
RasDhcpTimerSchedule(
&RasDhcpMonitorTimer,
0,
rasDhcpMonitorAddresses);
dwErr = RasDhcpTimerInitialize();
if (NO_ERROR != dwErr)
{
TraceHlp("RasDhcpInitTimer failed and returned %d", dwErr);
goto LDone;
}
LDone:
if (NO_ERROR != dwErr)
{
RasDhcpTimerUninitialize();
}
LeaveCriticalSection(&RasDhcpCriticalSection);
return(dwErr);
}
/*
Returns:
VOID
Notes:
*/
VOID
RasDhcpUninitialize(
VOID
)
{
TraceHlp("RasDhcpUninitialize");
/*
Do not hold RasDhcpCriticalSection while calling this function. Otherwise,
the following deadlock can occur: The timer thread is blocked in
rasDhcpAllocateAddress, waiting for RasDhcpCriticalSection, and this thread
is blocked in RasDhcpTimerUninitialize, waiting for the timer thread to
stop.
*/
RasDhcpTimerUninitialize();
EnterCriticalSection(&RasDhcpCriticalSection);
/*
To avoid a possible race condition in rasDhcpRenewLease (see the comments
in that function), it is important to call RasDhcpTimerUninitialize and
kill the timer thread before calling rasDhcpDeleteLists.
*/
rasDhcpDeleteLists();
RasDhcpUsingEasyNet = TRUE;
LeaveCriticalSection(&RasDhcpCriticalSection);
}
/*
Returns:
Notes:
*/
DWORD
RasDhcpAcquireAddress(
IN HPORT hPort,
OUT IPADDR* pnboIpAddr,
OUT IPADDR* pnboIpMask,
OUT BOOL* pfEasyNet
)
{
ADDR_INFO* pAddrInfo;
DWORD dwErr = ERROR_NOT_FOUND;
TraceHlp("RasDhcpAcquireAddress");
EnterCriticalSection(&RasDhcpCriticalSection);
if (NULL == RasDhcpFreePool)
{
TraceHlp("Out of addresses");
goto LDone;
}
// Move from Free pool to Alloc pool
pAddrInfo = RasDhcpFreePool;
RasDhcpFreePool = RasDhcpFreePool->ai_Next;
pAddrInfo->ai_Next = RasDhcpAllocPool;
RasDhcpAllocPool = pAddrInfo;
TraceHlp("Acquired 0x%x", pAddrInfo->ai_LeaseInfo.IpAddress);
*pnboIpAddr = htonl(pAddrInfo->ai_LeaseInfo.IpAddress);
*pnboIpMask = htonl(pAddrInfo->ai_LeaseInfo.SubnetMask);
pAddrInfo->ai_hPort = hPort;
pAddrInfo->ai_Flags |= AI_FLAG_IN_USE;
if (NULL != pfEasyNet)
{
*pfEasyNet = RasDhcpUsingEasyNet;
}
if ( (NULL == RasDhcpFreePool)
&& (0 == RasDhcpNumReqAddrs))
{
// We don't have any more addresses to give out. Let us
// acquire another chunk of them.
if (NtProductWinNt == RasDhcpNtProductType)
{
RasDhcpNumReqAddrs += 1;
}
else
{
RasDhcpNumReqAddrs += HelperRegVal.dwChunkSize;
}
RasDhcpTimerRunNow();
}
dwErr = NO_ERROR;
LDone:
LeaveCriticalSection(&RasDhcpCriticalSection);
return(dwErr);
}
/*
Returns:
VOID
Notes:
*/
VOID
RasDhcpReleaseAddress(
IN IPADDR nboIpAddr
)
{
ADDR_INFO* pAddrInfo;
ADDR_INFO** ppAddrInfo;
IPADDR hboIpAddr;
TraceHlp("RasDhcpReleaseAddress");
EnterCriticalSection(&RasDhcpCriticalSection);
hboIpAddr = ntohl(nboIpAddr);
for (ppAddrInfo = &RasDhcpAllocPool;
(pAddrInfo = *ppAddrInfo) != NULL;
ppAddrInfo = &pAddrInfo->ai_Next)
{
if (pAddrInfo->ai_LeaseInfo.IpAddress == hboIpAddr)
{
TraceHlp("Released 0x%x", nboIpAddr);
// Unlink from alloc pool
*ppAddrInfo = pAddrInfo->ai_Next;
// Put at the end of the free pool, because we want to round-robin
// the addresses.
pAddrInfo->ai_Next = NULL;
ppAddrInfo = &RasDhcpFreePool;
while (NULL != *ppAddrInfo)
{
ppAddrInfo = &((*ppAddrInfo)->ai_Next);
}
*ppAddrInfo = pAddrInfo;
pAddrInfo->ai_Flags &= ~AI_FLAG_IN_USE;
goto LDone;
}
}
TraceHlp("IpAddress 0x%x not present in alloc pool", nboIpAddr);
LDone:
LeaveCriticalSection(&RasDhcpCriticalSection);
}
/*
Returns:
Notes:
Allocate an address from the DHCP server.
*/
DWORD
rasDhcpAllocateAddress(
VOID
)
{
IPADDR nboIpAddress;
ADDR_INFO* pAddrInfo = NULL;
DHCP_OPTION_INFO* pOptionInfo = NULL;
DHCP_LEASE_INFO* pLeaseInfo = NULL;
AVAIL_INDEX* pAvailIndex;
time_t now = time(NULL);
BOOL fEasyNet = FALSE;
BOOL fPutInAvailList = FALSE;
BOOL fCSEntered = FALSE;
BYTE bAddress[MAX_ADAPTER_ADDRESS_LENGTH];
CHAR szIpAddress[MAXIPSTRLEN + 1];
CHAR* sz;
PPPE_MESSAGE PppMessage;
DWORD dwErr = NO_ERROR;
TraceHlp("rasDhcpAllocateAddress");
dwErr = GetPreferredAdapterInfo(&nboIpAddress, NULL, NULL, NULL, NULL,
bAddress);
if (NO_ERROR != dwErr)
{
// There is probably no NIC on the machine
nboIpAddress = htonl(INADDR_LOOPBACK);
}
pAddrInfo = LocalAlloc(LPTR, sizeof(ADDR_INFO));
if (pAddrInfo == NULL)
{
dwErr = GetLastError();
TraceHlp("LocalAlloc failed and returned %d", dwErr);
goto LDone;
}
// Initialize the structure.
rasDhcpInitializeAddrInfo(pAddrInfo, bAddress, &fPutInAvailList);
// Call DHCP to allocate an IP address.
dwErr = PDhcpLeaseIpAddress(
ntohl(nboIpAddress),
&pAddrInfo->ai_LeaseInfo.ClientUID,
0,
NULL,
&pLeaseInfo,
&pOptionInfo);
if (ERROR_SUCCESS != dwErr)
{
pLeaseInfo = NULL;
pOptionInfo = NULL;
TraceHlp("DhcpLeaseIpAddress failed and returned %d", dwErr);
goto LDone;
}
// Copy stuff into the pAddrInfo structure
pAddrInfo->ai_LeaseInfo.IpAddress = pLeaseInfo->IpAddress;
pAddrInfo->ai_LeaseInfo.SubnetMask = pLeaseInfo->SubnetMask;
pAddrInfo->ai_LeaseInfo.DhcpServerAddress = pLeaseInfo->DhcpServerAddress;
pAddrInfo->ai_LeaseInfo.Lease = pLeaseInfo->Lease;
pAddrInfo->ai_LeaseInfo.LeaseObtained = pLeaseInfo->LeaseObtained;
pAddrInfo->ai_LeaseInfo.T1Time = pLeaseInfo->T1Time;
pAddrInfo->ai_LeaseInfo.T2Time = pLeaseInfo->T2Time;
pAddrInfo->ai_LeaseInfo.LeaseExpires = pLeaseInfo->LeaseExpires;
EnterCriticalSection(&RasDhcpCriticalSection);
fCSEntered = TRUE;
if (-1 == (DWORD)(pLeaseInfo->DhcpServerAddress))
{
fEasyNet = TRUE;
if (!RasDhcpUsingEasyNet)
{
dwErr = E_FAIL;
TraceHlp("Not accepting any more EasyNet addresses");
goto LDone;
}
AbcdSzFromIpAddress(htonl(pLeaseInfo->IpAddress), szIpAddress);
sz = szIpAddress;
LogEvent(EVENTLOG_WARNING_TYPE, ROUTERLOG_AUTONET_ADDRESS, 1,
(CHAR**)&sz);
// We undo this call to RasTcpSetProxyArp in rasDhcpDeleteLists.
RasTcpSetProxyArp(htonl(pLeaseInfo->IpAddress), TRUE);
}
else
{
if (RasDhcpUsingEasyNet)
{
rasDhcpDeleteLists();
// We have already used up index 0 to get this address
RasDhcpNextIndex = 1;
RasDhcpUsingEasyNet = FALSE;
PppMessage.dwMsgId = PPPEMSG_IpAddressLeaseExpired;
PppMessage.ExtraInfo.IpAddressLeaseExpired.nboIpAddr = 0;
SendPPPMessageToEngine(&PppMessage);
}
if (NULL != PEnableDhcpInformServer)
{
// Redirect DHCP inform packets to this server.
PEnableDhcpInformServer(htonl(pLeaseInfo->DhcpServerAddress));
}
}
pAddrInfo->ai_Next = RasDhcpFreePool;
RasDhcpFreePool = pAddrInfo;
if (0 < RasDhcpNumReqAddrs)
{
// We need one less address now.
RasDhcpNumReqAddrs--;
}
RasDhcpNumAddrsAlloced++;
TraceHlp("Allocated address 0x%x using 0x%x, timer %ld%s",
pAddrInfo->ai_LeaseInfo.IpAddress,
nboIpAddress,
pAddrInfo->ai_LeaseInfo.T1Time - now,
fEasyNet ? ", EasyNet" : "");
if (!fEasyNet)
{
// Start timer for lease renewal
RasDhcpTimerSchedule(
&pAddrInfo->ai_Timer,
(LONG)(pAddrInfo->ai_LeaseInfo.T1Time - now),
rasDhcpRenewLease);
}
LDone:
if (fCSEntered)
{
LeaveCriticalSection(&RasDhcpCriticalSection);
}
if (NO_ERROR != dwErr)
{
if (fPutInAvailList)
{
pAvailIndex = LocalAlloc(LPTR, sizeof(AVAIL_INDEX));
if (NULL == pAvailIndex)
{
TraceHlp("Couldn't put index %d in the avail list. "
"Out of memory", pAddrInfo->ai_ClientUIDWords[3]);
}
else
{
EnterCriticalSection(&RasDhcpCriticalSection);
pAvailIndex->dwIndex = pAddrInfo->ai_ClientUIDWords[3];
pAvailIndex->pNext = RasDhcpAvailIndexes;
RasDhcpAvailIndexes = pAvailIndex;
LeaveCriticalSection(&RasDhcpCriticalSection);
}
}
LocalFree(pAddrInfo);
}
LocalFree(pLeaseInfo);
LocalFree(pOptionInfo);
return(dwErr);
}
/*
Returns:
VOID
Notes:
Renew the lease on an address with the DHCP server. This is also called by
the timer thread when the its time to renew the lease.
*/
VOID
rasDhcpRenewLease(
IN HANDLE rasDhcpTimerShutdown,
IN TIMERLIST* pTimer
)
{
IPADDR nboIpAddress;
ADDR_INFO* pAddrInfo;
ADDR_INFO** ppAddrInfo;
DHCP_OPTION_INFO* pOptionInfo = NULL;
AVAIL_INDEX* pAvailIndex;
time_t now = time(NULL);
IPADDR nboIpAddrTemp = 0;
PPPE_MESSAGE PppMessage;
BOOL fNeedToRenew;
DWORD dwErr;
TraceHlp("rasDhcpRenewLease");
dwErr = GetPreferredAdapterInfo(&nboIpAddress, NULL, NULL, NULL, NULL,
NULL);
if (NO_ERROR != dwErr)
{
TraceHlp("Couldn't get a NIC IP Address. Unable to renew lease");
goto LDone;
}
EnterCriticalSection(&RasDhcpCriticalSection);
pAddrInfo = CONTAINING_RECORD(pTimer, ADDR_INFO, ai_Timer);
TraceHlp("address 0x%x", pAddrInfo->ai_LeaseInfo.IpAddress);
pAddrInfo->ai_Flags |= AI_FLAG_RENEW;
fNeedToRenew = rasDhcpNeedToRenewLease(pAddrInfo);
LeaveCriticalSection(&RasDhcpCriticalSection);
/*
A race condition can occur if a thread other than this thread (the timer
thread) calls rasDhcpDeleteLists when we are here. rasDhcpAllocateAddress
calls rasDhcpDeleteLists, but only the timer thread calls
rasDhcpAllocateAddress. RasDhcpUninitialize also calls rasDhcpDeleteLists,
but it calls RasDhcpTimerUninitialize first. Before RasDhcpTimerUninitialize
returns, the timer thread exits, so it is impossible for us to be here.
In the worst case, DhcpRenewIpAddressLease might take up to 60 sec. In the
average case, it is 2-10 sec.
*/
if (fNeedToRenew)
{
dwErr = PDhcpRenewIpAddressLease(
ntohl(nboIpAddress),
&pAddrInfo->ai_LeaseInfo,
NULL,
&pOptionInfo);
}
else
{
// Simulate not being able to renew
dwErr = ERROR_ACCESS_DENIED;
}
EnterCriticalSection(&RasDhcpCriticalSection);
if (dwErr == ERROR_SUCCESS)
{
pAddrInfo->ai_Flags &= ~AI_FLAG_RENEW;
TraceHlp("success for address 0x%x, resched timer %ld",
pAddrInfo->ai_LeaseInfo.IpAddress,
pAddrInfo->ai_LeaseInfo.T1Time - now);
// Start timer to renew
RasDhcpTimerSchedule(
pTimer,
(LONG)(pAddrInfo->ai_LeaseInfo.T1Time - now),
rasDhcpRenewLease);
}
else if ( (ERROR_ACCESS_DENIED == dwErr)
|| (now > pAddrInfo->ai_LeaseInfo.T2Time))
{
TraceHlp("failed for address 0x%x", pAddrInfo->ai_LeaseInfo.IpAddress);
if (fNeedToRenew)
{
RasDhcpNumReqAddrs++;
}
if (RasDhcpNumAddrsAlloced > 0)
{
RasDhcpNumAddrsAlloced--;
}
// Cannot renew lease. Blow this away.
nboIpAddrTemp = htonl(pAddrInfo->ai_LeaseInfo.IpAddress);
// Unlink this structure from the list and cleanup
ppAddrInfo = (pAddrInfo->ai_Flags & AI_FLAG_IN_USE) ?
&RasDhcpAllocPool : &RasDhcpFreePool;
for (; *ppAddrInfo != NULL; ppAddrInfo = &(*ppAddrInfo)->ai_Next)
{
if (pAddrInfo == *ppAddrInfo)
{
pAvailIndex = LocalAlloc(LPTR, sizeof(AVAIL_INDEX));
if (NULL == pAvailIndex)
{
TraceHlp("Couldn't put index %d in the avail list. "
"Out of memory", pAddrInfo->ai_ClientUIDWords[3]);
}
else
{
pAvailIndex->dwIndex = pAddrInfo->ai_ClientUIDWords[3];
pAvailIndex->pNext = RasDhcpAvailIndexes;
RasDhcpAvailIndexes = pAvailIndex;
}
*ppAddrInfo = pAddrInfo->ai_Next;
break;
}
}
rasDhcpFreeAddress(pAddrInfo);
LocalFree(pAddrInfo);
PppMessage.dwMsgId = PPPEMSG_IpAddressLeaseExpired;
PppMessage.ExtraInfo.IpAddressLeaseExpired.nboIpAddr = nboIpAddrTemp;
SendPPPMessageToEngine(&PppMessage);
}
else
{
TraceHlp("Error %d. Will try again later.", dwErr);
TraceHlp("Seconds left before expiry: %d",
pAddrInfo->ai_LeaseInfo.T2Time - now);
// Could not contact the Dhcp Server, retry in a little bit
RasDhcpTimerSchedule(pTimer, RETRY_TIME, rasDhcpRenewLease);
}
LeaveCriticalSection(&RasDhcpCriticalSection);
LDone:
LocalFree(pOptionInfo);
}
/*
Notes:
We call DHCP to release the address.
*/
VOID
rasDhcpFreeAddress(
IN ADDR_INFO* pAddrInfo
)
{
IPADDR nboIpAddress;
DWORD dwErr;
RTASSERT(NULL != pAddrInfo);
TraceHlp("rasDhcpFreeAddress 0x%x", pAddrInfo->ai_LeaseInfo.IpAddress);
dwErr = GetPreferredAdapterInfo(&nboIpAddress, NULL, NULL, NULL, NULL,
NULL);
if (NO_ERROR != dwErr)
{
TraceHlp("Couldn't get a NIC IP Address. Unable to release address");
goto LDone;
}
// Call DHCP to release the address.
dwErr = PDhcpReleaseIpAddressLease(ntohl(nboIpAddress),
&pAddrInfo->ai_LeaseInfo);
if (ERROR_SUCCESS != dwErr)
{
TraceHlp("DhcpReleaseIpAddressLease failed and returned %d", dwErr);
}
if (RasDhcpNumAddrsAlloced > 0)
{
RasDhcpNumAddrsAlloced--;
}
LDone:
return;
}
/*
Returns:
VOID
Notes:
If we don't have enough addresses (because lease renewal failed or we were
unable to allocate), try to acquire some. The argument pTimer is not used.
*/
VOID
rasDhcpMonitorAddresses(
IN HANDLE rasDhcpTimerShutdown,
IN TIMERLIST* pTimer
)
{
DWORD dwErr;
while (TRUE)
{
EnterCriticalSection(&RasDhcpCriticalSection);
if (0 == RasDhcpNumReqAddrs)
{
LeaveCriticalSection(&RasDhcpCriticalSection);
break;
}
if (RasDhcpNumAddrsAlloced >= rasDhcpMaxAddrsToAllocate())
{
RasDhcpNumReqAddrs = 0;
LeaveCriticalSection(&RasDhcpCriticalSection);
break;
}
LeaveCriticalSection(&RasDhcpCriticalSection);
dwErr = rasDhcpAllocateAddress();
if (NO_ERROR != dwErr)
{
break;
}
if (WaitForSingleObject(rasDhcpTimerShutdown, 10) != WAIT_TIMEOUT)
{
break;
}
}
// Start timer to monitor if we are running short on addresses etc.
RasDhcpTimerSchedule(
&RasDhcpMonitorTimer,
0,
rasDhcpMonitorAddresses);
}
/*
Returns:
VOID
Notes:
*/
VOID
rasDhcpInitializeAddrInfo(
IN OUT ADDR_INFO* pNewAddrInfo,
IN BYTE* pbAddress,
OUT BOOL* pfPutInAvailList
)
{
DWORD dwIndex;
AVAIL_INDEX* pAvailIndex;
RTASSERT(NULL != pNewAddrInfo);
TraceHlp("rasDhcpInitializeAddrInfo");
EnterCriticalSection(&RasDhcpCriticalSection);
// ClientUIDBase is a combination of RAS_PREPEND (4 chars),
// MAC address (8 chars), Index (4 chars)
if (RasDhcpUsingEasyNet)
{
dwIndex = 0;
}
else
{
*pfPutInAvailList = TRUE;
if (NULL != RasDhcpAvailIndexes)
{
pAvailIndex = RasDhcpAvailIndexes;
dwIndex = pAvailIndex->dwIndex;
RasDhcpAvailIndexes = RasDhcpAvailIndexes->pNext;
LocalFree(pAvailIndex);
}
else
{
dwIndex = RasDhcpNextIndex++;
}
}
TraceHlp("dwIndex = %d", dwIndex);
strcpy(pNewAddrInfo->ai_ClientUIDBuf, RAS_PREPEND);
memcpy(pNewAddrInfo->ai_ClientUIDBuf + strlen(RAS_PREPEND),
pbAddress, MAX_ADAPTER_ADDRESS_LENGTH);
pNewAddrInfo->ai_ClientUIDWords[3] = dwIndex;
pNewAddrInfo->ai_LeaseInfo.ClientUID.ClientUID =
pNewAddrInfo->ai_ClientUIDBuf;
pNewAddrInfo->ai_LeaseInfo.ClientUID.ClientUIDLength =
sizeof(pNewAddrInfo->ai_ClientUIDBuf);
LeaveCriticalSection(&RasDhcpCriticalSection);
}
/*
Returns:
VOID
Notes:
Delete proxy arp entries for easy net addresses.
*/
VOID
rasDhcpDeleteLists(
VOID
)
{
ADDR_INFO* pAddrInfo;
ADDR_INFO* pTempAddrInfo;
ADDR_INFO* pList[2] = {RasDhcpAllocPool, RasDhcpFreePool};
AVAIL_INDEX* pAvailIndex;
AVAIL_INDEX* pTempAvailIndex;
DWORD dwIndex;
TraceHlp("rasDhcpDeleteLists");
EnterCriticalSection(&RasDhcpCriticalSection);
for (dwIndex = 0; dwIndex < 2; dwIndex++)
{
pAddrInfo = pList[dwIndex];
while (pAddrInfo != NULL)
{
if (RasDhcpUsingEasyNet)
{
RasTcpSetProxyArp(htonl(pAddrInfo->ai_LeaseInfo.IpAddress),
FALSE);
}
else
{
rasDhcpFreeAddress(pAddrInfo);
}
pTempAddrInfo = pAddrInfo;
pAddrInfo = pAddrInfo->ai_Next;
LocalFree(pTempAddrInfo);
}
}
for (pAvailIndex = RasDhcpAvailIndexes; NULL != pAvailIndex;)
{
pTempAvailIndex = pAvailIndex;
pAvailIndex = pAvailIndex->pNext;
LocalFree(pTempAvailIndex);
}
RasDhcpAllocPool = NULL;
RasDhcpFreePool = NULL;
RasDhcpAvailIndexes = NULL;
if (NtProductWinNt == RasDhcpNtProductType)
{
RasDhcpNumReqAddrs = 2;
}
else
{
RasDhcpNumReqAddrs = HelperRegVal.dwChunkSize;
}
RasDhcpNextIndex = 0;
RasDhcpNumAddrsAlloced = 0;
LeaveCriticalSection(&RasDhcpCriticalSection);
}
/*
Returns:
VOID
Notes:
Should we bother to renew the lease?
*/
BOOL
rasDhcpNeedToRenewLease(
IN ADDR_INFO* pAddrInfo
)
{
BOOL fRet = TRUE;
DWORD dwCount = 0;
ADDR_INFO* pTemp;
TraceHlp("rasDhcpNeedToRenewLease");
EnterCriticalSection(&RasDhcpCriticalSection);
if (pAddrInfo->ai_Flags & AI_FLAG_IN_USE)
{
goto LDone;
}
// How many free addresses do we have?
for (pTemp = RasDhcpFreePool; pTemp != NULL; pTemp = pTemp->ai_Next)
{
dwCount++;
}
if (dwCount > HelperRegVal.dwChunkSize)
{
fRet = FALSE;
}
LDone:
TraceHlp("Need to renew: %s", fRet ? "TRUE" : "FALSE");
LeaveCriticalSection(&RasDhcpCriticalSection);
return(fRet);
}
/*
Returns:
The maximum number of addresses that we can get from the DHCP server.
Notes:
*/
DWORD
rasDhcpMaxAddrsToAllocate(
VOID
)
{
DWORD dwErr = NO_ERROR;
DWORD dwSize = 0;
DWORD dwNumEntries = 0;
DWORD dwRet = 0;
DWORD dw;
RASMAN_PORT* pRasmanPort = NULL;
dwErr = RasPortEnum(NULL, NULL, &dwSize, &dwNumEntries);
RTASSERT(ERROR_BUFFER_TOO_SMALL == dwErr);
pRasmanPort = (RASMAN_PORT*) LocalAlloc(LPTR, dwSize);
if (NULL == pRasmanPort)
{
// The server adapter also needs an address.
dwRet = dwNumEntries + 1;
goto LDone;
}
dwErr = RasPortEnum(NULL, (BYTE*)pRasmanPort, &dwSize, &dwNumEntries);
if (NO_ERROR != dwErr)
{
// The server adapter also needs an address.
dwRet = dwNumEntries + 1;
goto LDone;
}
for (dw = 0, dwRet = 0; dw < dwNumEntries; dw++)
{
if ( (pRasmanPort[dw].P_ConfiguredUsage & CALL_IN)
|| (pRasmanPort[dw].P_ConfiguredUsage & CALL_ROUTER))
{
dwRet++;
}
}
// The server adapter also needs an address.
dwRet++;
LDone:
LocalFree(pRasmanPort);
return(dwRet);
}