2102 lines
47 KiB
C
2102 lines
47 KiB
C
/*
|
|
File: rasip.h
|
|
|
|
The 'remoteaccess ip' sub context
|
|
|
|
3/2/99
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
#include "rasip.h"
|
|
#include <winsock2.h>
|
|
|
|
#define MAKEIPADDRESS(b1,b2,b3,b4) \
|
|
(((DWORD)(b1)<<24)+((DWORD)(b2)<<16)+((DWORD)(b3)<<8)+((DWORD)(b4)))
|
|
|
|
#define FIRST_IPADDRESS(x) ((x>>24) & 0xff)
|
|
#define SECOND_IPADDRESS(x) ((x>>16) & 0xff)
|
|
#define THIRD_IPADDRESS(x) ((x>>8) & 0xff)
|
|
#define FOURTH_IPADDRESS(x) (x & 0xff)
|
|
|
|
// The guid for this context
|
|
//
|
|
GUID g_RasIpGuid = RASIP_GUID;
|
|
static PWCHAR g_pszServer = NULL;
|
|
static DWORD g_dwBuild = 0;
|
|
|
|
// The commands supported in this context
|
|
//
|
|
CMD_ENTRY g_RasIpSetCmdTable[] =
|
|
{
|
|
CREATE_CMD_ENTRY(RASIP_SET_NEGOTIATION,RasIpHandleSetNegotiation),
|
|
CREATE_CMD_ENTRY(RASIP_SET_ACCESS, RasIpHandleSetAccess),
|
|
CREATE_CMD_ENTRY(RASIP_SET_ASSIGNMENT, RasIpHandleSetAssignment),
|
|
CREATE_CMD_ENTRY(RASIP_SET_CALLERSPEC, RasIpHandleSetCallerSpec),
|
|
CREATE_CMD_ENTRY(RASIP_SET_NETBTBCAST, RasIpHandleSetNetbtBcast),
|
|
};
|
|
|
|
CMD_ENTRY g_RasIpShowCmdTable[] =
|
|
{
|
|
CREATE_CMD_ENTRY(RASIP_SHOW_CONFIG, RasIpHandleShow),
|
|
};
|
|
|
|
CMD_ENTRY g_RasIpAddCmdTable[] =
|
|
{
|
|
CREATE_CMD_ENTRY(RASIP_ADD_RANGE, RasIpHandleAddRange),
|
|
};
|
|
|
|
CMD_ENTRY g_RasIpDelCmdTable[] =
|
|
{
|
|
CREATE_CMD_ENTRY(RASIP_DEL_RANGE, RasIpHandleDelRange),
|
|
CREATE_CMD_ENTRY(RASIP_DEL_POOL, RasIpHandleDelPool),
|
|
};
|
|
|
|
CMD_GROUP_ENTRY g_RasIpCmdGroups[] =
|
|
{
|
|
CREATE_CMD_GROUP_ENTRY(GROUP_SET, g_RasIpSetCmdTable),
|
|
CREATE_CMD_GROUP_ENTRY(GROUP_SHOW, g_RasIpShowCmdTable),
|
|
CREATE_CMD_GROUP_ENTRY(GROUP_ADD, g_RasIpAddCmdTable),
|
|
CREATE_CMD_GROUP_ENTRY(GROUP_DEL, g_RasIpDelCmdTable),
|
|
};
|
|
|
|
ULONG g_ulRasIpNumGroups = sizeof(g_RasIpCmdGroups)/sizeof(CMD_GROUP_ENTRY);
|
|
|
|
//
|
|
// Flags that control how/what info is read/written
|
|
// in the RASIP_CB structure
|
|
//
|
|
#define RASIP_F_EnableIn 0x1
|
|
#define RASIP_F_Access 0x2
|
|
#define RASIP_F_Auto 0x4
|
|
#define RASIP_F_Pool 0x8
|
|
#define RASIP_F_Mask 0x10
|
|
#define RASIP_F_CallerSpec 0x20
|
|
#define RASIP_F_All 0xFFFF
|
|
|
|
//
|
|
// Reasons for the ras ip pool to be invalid
|
|
//
|
|
#define RASIP_REASON_BadAddress 0x1
|
|
#define RASIP_REASON_BadRange 0x3
|
|
#define RASIP_REASON_127 0x4
|
|
|
|
//
|
|
// RAS pool definition
|
|
//
|
|
typedef struct _RAS_IPRANGE_NODE
|
|
{
|
|
DWORD dwFrom;
|
|
DWORD dwTo;
|
|
struct _RAS_IPRANGE_NODE* pNext;
|
|
|
|
} RAS_IPRANGE_NODE;
|
|
|
|
typedef struct _RAS_IPPOOL
|
|
{
|
|
DWORD dwCount;
|
|
RAS_IPRANGE_NODE* pHead;
|
|
RAS_IPRANGE_NODE* pTail;
|
|
|
|
} RAS_IPPOOL;
|
|
|
|
//
|
|
// Control block for ras ip configuration
|
|
//
|
|
typedef struct _RASIP_CB
|
|
{
|
|
DWORD dwFlags; // See RASIP_F_* values
|
|
|
|
BOOL bEnableIn;
|
|
BOOL bAccess;
|
|
BOOL bAuto;
|
|
RAS_IPPOOL* pPool;
|
|
BOOL bCallerSpec;
|
|
|
|
} RASIP_CB;
|
|
|
|
//
|
|
// Ip specific registry parameters
|
|
//
|
|
WCHAR pszIpParams[] = L"Ip";
|
|
WCHAR pszIpAddress[] = L"IpAddress";
|
|
WCHAR pszIpMask[] = L"IpMask";
|
|
WCHAR pszIpClientSpec[] = L"AllowClientIpAddresses";
|
|
WCHAR pszIpUseDhcp[] = L"UseDhcpAddressing";
|
|
WCHAR pszIpFrom[] = L"From";
|
|
WCHAR pszIpTo[] = L"To";
|
|
WCHAR pszIpPoolSubKey[] = L"StaticAddressPool";
|
|
|
|
//
|
|
// Prototypes of functions that manipulate the
|
|
// RASIP_CB structures
|
|
//
|
|
DWORD
|
|
RasIpCbCleanup(
|
|
IN RASIP_CB* pConfig);
|
|
|
|
DWORD
|
|
RasIpCbCreateDefault(
|
|
OUT RASIP_CB** ppConfig);
|
|
|
|
DWORD
|
|
RasIpCbOpenRegKeys(
|
|
IN LPCWSTR pszServer,
|
|
OUT HKEY* phKey);
|
|
|
|
DWORD
|
|
RasIpCbRead(
|
|
IN LPCWSTR pszServer,
|
|
OUT RASIP_CB* pConfig);
|
|
|
|
DWORD
|
|
RasIpCbWrite(
|
|
IN LPCWSTR pszServer,
|
|
IN RASIP_CB* pConfig);
|
|
|
|
DWORD
|
|
RasIpPoolReset(
|
|
IN HKEY hkParams);
|
|
|
|
DWORD
|
|
RasIpPoolRead(
|
|
IN HKEY hkParams,
|
|
OUT RAS_IPPOOL** ppRanges);
|
|
|
|
DWORD
|
|
RasIpPoolWrite(
|
|
IN HKEY hkParams,
|
|
IN RAS_IPPOOL* pPool);
|
|
|
|
DWORD
|
|
RasIpPoolAdd(
|
|
IN OUT RAS_IPPOOL* pPool,
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo);
|
|
|
|
DWORD
|
|
RasIpPoolDel(
|
|
IN OUT RAS_IPPOOL* pPool,
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo);
|
|
|
|
DWORD
|
|
RasIpPoolCleanup(
|
|
IN RAS_IPPOOL* pPool);
|
|
|
|
DWORD
|
|
RasIpSetNetbtBcast(
|
|
DWORD dwEnable
|
|
);
|
|
|
|
BOOL
|
|
RasIpShowNetbtBcast(
|
|
VOID
|
|
);
|
|
|
|
//
|
|
// Entry called by rasmontr to register this context
|
|
//
|
|
DWORD
|
|
WINAPI
|
|
RasIpStartHelper(
|
|
IN CONST GUID *pguidParent,
|
|
IN DWORD dwVersion)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
NS_CONTEXT_ATTRIBUTES attMyAttributes;
|
|
|
|
// Initialize
|
|
//
|
|
ZeroMemory(&attMyAttributes, sizeof(attMyAttributes));
|
|
|
|
attMyAttributes.pwszContext = L"ip";
|
|
attMyAttributes.guidHelper = g_RasIpGuid;
|
|
attMyAttributes.dwVersion = RASIP_VERSION;
|
|
attMyAttributes.dwFlags = 0;
|
|
attMyAttributes.ulNumTopCmds = 0;
|
|
attMyAttributes.pTopCmds = NULL;
|
|
attMyAttributes.ulNumGroups = g_ulRasIpNumGroups;
|
|
attMyAttributes.pCmdGroups = (CMD_GROUP_ENTRY (*)[])&g_RasIpCmdGroups;
|
|
attMyAttributes.pfnDumpFn = RasIpDump;
|
|
|
|
dwErr = RegisterContext( &attMyAttributes );
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpDisplayInvalidPool(
|
|
IN DWORD dwReason
|
|
)
|
|
{
|
|
DWORD dwArg = 0;
|
|
PWCHAR pszArg = NULL;
|
|
|
|
switch (dwReason)
|
|
{
|
|
case RASIP_REASON_BadAddress:
|
|
dwArg = EMSG_RASIP_BAD_ADDRESS;
|
|
break;
|
|
|
|
case RASIP_REASON_BadRange:
|
|
dwArg = EMSG_RASIP_BAD_RANGE;
|
|
break;
|
|
|
|
case RASIP_REASON_127:
|
|
dwArg = EMSG_RASIP_NETID_127;
|
|
break;
|
|
|
|
default:
|
|
dwArg = EMSG_RASIP_BAD_POOL_GENERIC;
|
|
break;
|
|
}
|
|
|
|
// Make the argument string
|
|
//
|
|
pszArg = MakeString(g_hModule, dwArg);
|
|
if (pszArg == NULL)
|
|
{
|
|
DisplayError(NULL, ERROR_NOT_ENOUGH_MEMORY);
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
// Display the error
|
|
//
|
|
DisplayMessage(
|
|
g_hModule,
|
|
EMSG_RASIP_INVALID_POOL,
|
|
pszArg);
|
|
|
|
// Cleanup
|
|
//
|
|
FreeString(pszArg);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasIpDisplayPool(
|
|
IN RASIP_CB* pConfig,
|
|
IN BOOL bReport)
|
|
{
|
|
DWORD dwErr = NO_ERROR, i;
|
|
RAS_IPPOOL* pPool = pConfig->pPool;
|
|
RAS_IPRANGE_NODE* pNode = NULL;
|
|
PWCHAR pszFrom = NULL, pszTo = NULL;
|
|
WCHAR pszFromBuf[128], pszToBuf[128];
|
|
|
|
if (!pPool)
|
|
{
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
do
|
|
{
|
|
pNode = pPool->pHead;
|
|
for (i = 0; i < pPool->dwCount; i++, pNode = pNode->pNext)
|
|
{
|
|
wsprintfW(
|
|
pszFromBuf,
|
|
L"%d.%d.%d.%d",
|
|
FIRST_IPADDRESS(pNode->dwFrom),
|
|
SECOND_IPADDRESS(pNode->dwFrom),
|
|
THIRD_IPADDRESS(pNode->dwFrom),
|
|
FOURTH_IPADDRESS(pNode->dwFrom));
|
|
|
|
wsprintfW(
|
|
pszToBuf,
|
|
L"%d.%d.%d.%d",
|
|
FIRST_IPADDRESS(pNode->dwTo),
|
|
SECOND_IPADDRESS(pNode->dwTo),
|
|
THIRD_IPADDRESS(pNode->dwTo),
|
|
FOURTH_IPADDRESS(pNode->dwTo));
|
|
|
|
if (bReport)
|
|
{
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SHOW_POOL,
|
|
pszFromBuf,
|
|
pszToBuf);
|
|
}
|
|
else
|
|
{
|
|
pszFrom = RutlAssignmentFromTokens(g_hModule, TOKEN_FROM, pszFromBuf);
|
|
pszTo = RutlAssignmentFromTokens(g_hModule, TOKEN_TO, pszToBuf);
|
|
if (pszFrom == NULL || pszTo == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_ADD_RANGE_CMD,
|
|
DMP_RASIP_ADD_RANGE,
|
|
pszFrom,
|
|
pszTo);
|
|
}
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
RutlFree(pszFrom);
|
|
RutlFree(pszTo);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpDisplayConfig(
|
|
IN BOOL bReport)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwReason;
|
|
RASIP_CB* pConfig = NULL;
|
|
PWCHAR pszPool = NULL, pszAccess = NULL, pszAuto = NULL, pszMask = NULL;
|
|
PWCHAR pszEnableIn = NULL, pszCaller = NULL, pszNetbtBcast = NULL;
|
|
do
|
|
{
|
|
// Get a default config blob
|
|
//
|
|
dwErr = RasIpCbCreateDefault(&pConfig);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
// Read in all of the values
|
|
//
|
|
pConfig->dwFlags = RASIP_F_All;
|
|
dwErr = RasIpCbRead(g_pszServer, pConfig);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
if (bReport)
|
|
{
|
|
pszEnableIn =
|
|
RutlStrDup(pConfig->bEnableIn ? TOKEN_ALLOW : TOKEN_DENY);
|
|
pszAccess =
|
|
RutlStrDup(pConfig->bAccess ? TOKEN_ALL : TOKEN_SERVERONLY);
|
|
pszAuto =
|
|
RutlStrDup(pConfig->bAuto ? TOKEN_AUTO : TOKEN_POOL);
|
|
pszCaller =
|
|
RutlStrDup(pConfig->bCallerSpec ? TOKEN_ALLOW : TOKEN_DENY);
|
|
|
|
// Whistler bug: 359847 Netsh: move broadcastnameresolution from
|
|
// routing ip to ras ip
|
|
//
|
|
pszNetbtBcast =
|
|
RutlStrDup(RasIpShowNetbtBcast() ? TOKEN_ENABLED :
|
|
TOKEN_DISABLED);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SERVERCONFIG,
|
|
g_pszServer,
|
|
pszEnableIn,
|
|
pszAccess,
|
|
pszAuto,
|
|
pszCaller,
|
|
pszNetbtBcast);
|
|
|
|
RasIpDisplayPool(pConfig, bReport);
|
|
}
|
|
else
|
|
{
|
|
pszEnableIn = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_MODE,
|
|
pConfig->bEnableIn ? TOKEN_ALLOW : TOKEN_DENY);
|
|
pszAccess = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_MODE,
|
|
pConfig->bAccess ? TOKEN_ALL : TOKEN_SERVERONLY);
|
|
pszAuto = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_METHOD,
|
|
pConfig->bAuto ? TOKEN_AUTO : TOKEN_POOL);
|
|
pszCaller = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_MODE,
|
|
pConfig->bCallerSpec ? TOKEN_ALLOW : TOKEN_DENY);
|
|
|
|
// Whistler bug: 359847 Netsh: move broadcastnameresolution from
|
|
// routing ip to ras ip
|
|
//
|
|
pszNetbtBcast = RutlAssignmentFromTokens(
|
|
g_hModule,
|
|
TOKEN_MODE,
|
|
RasIpShowNetbtBcast() ? TOKEN_ENABLED :
|
|
TOKEN_DISABLED);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SCRIPTHEADER);
|
|
|
|
DisplayMessageT(DMP_RASIP_PUSHD);
|
|
|
|
DisplayMessageT(
|
|
DMP_RASIP_DEL_POOL);
|
|
|
|
DisplayMessageT(MSG_NEWLINE);
|
|
DisplayMessageT(MSG_NEWLINE);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SET_CMD,
|
|
DMP_RASIP_SET_NEGOTIATION,
|
|
pszEnableIn);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SET_CMD,
|
|
DMP_RASIP_SET_ACCESS,
|
|
pszAccess);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SET_CMD,
|
|
DMP_RASIP_SET_CALLERSPEC,
|
|
pszCaller);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SET_CMD,
|
|
DMP_RASIP_SET_NETBTBCAST,
|
|
pszNetbtBcast);
|
|
|
|
if (! pConfig->bAuto)
|
|
{
|
|
RasIpDisplayPool(pConfig, bReport);
|
|
}
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SET_CMD,
|
|
DMP_RASIP_SET_ASSIGNMENT,
|
|
pszAuto);
|
|
|
|
DisplayMessageT(DMP_RASIP_POPD);
|
|
|
|
DisplayMessage(
|
|
g_hModule,
|
|
MSG_RASIP_SCRIPTFOOTER);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (pConfig)
|
|
{
|
|
RasIpCbCleanup(pConfig);
|
|
}
|
|
if (pszEnableIn)
|
|
{
|
|
RutlFree(pszEnableIn);
|
|
}
|
|
if (pszAccess)
|
|
{
|
|
RutlFree(pszAccess);
|
|
}
|
|
if (pszAuto)
|
|
{
|
|
RutlFree(pszAuto);
|
|
}
|
|
if (pszCaller)
|
|
{
|
|
RutlFree(pszCaller);
|
|
}
|
|
if (pszNetbtBcast)
|
|
{
|
|
RutlFree(pszNetbtBcast);
|
|
}
|
|
if (pszPool)
|
|
{
|
|
RutlFree(pszPool);
|
|
}
|
|
if (pszMask)
|
|
{
|
|
RutlFree(pszMask);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
WINAPI
|
|
RasIpDump(
|
|
IN LPCWSTR pwszRouter,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwArgCount,
|
|
IN LPCVOID pvData
|
|
)
|
|
{
|
|
return RasIpDisplayConfig(FALSE);
|
|
}
|
|
|
|
//
|
|
// Returns NO_ERROR if the given address is a valid IP pool.
|
|
// The offending component is returned in lpdwErrReason.
|
|
// See RASIP_F_* values
|
|
//
|
|
DWORD
|
|
RasIpValidateRange(
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo,
|
|
OUT LPDWORD lpdwErrReason
|
|
)
|
|
{
|
|
DWORD dwLowIp, dwHighIp;
|
|
|
|
// Initialize
|
|
//
|
|
*lpdwErrReason = 0;
|
|
dwLowIp = MAKEIPADDRESS(1,0,0,0);
|
|
dwHighIp = MAKEIPADDRESS(224,0,0,0);
|
|
|
|
// Make sure that the netId is a valid class
|
|
//
|
|
if ((dwFrom < dwLowIp) ||
|
|
(dwFrom >= dwHighIp) ||
|
|
(dwTo < dwLowIp) ||
|
|
(dwTo >= dwHighIp))
|
|
{
|
|
*lpdwErrReason = RASIP_REASON_BadAddress;
|
|
return ERROR_BAD_FORMAT;
|
|
}
|
|
|
|
if ((FIRST_IPADDRESS(dwFrom) == 127) ||
|
|
(FIRST_IPADDRESS(dwTo) == 127))
|
|
{
|
|
*lpdwErrReason = RASIP_REASON_127;
|
|
return ERROR_BAD_FORMAT;
|
|
}
|
|
|
|
if (!(dwFrom <= dwTo))
|
|
{
|
|
*lpdwErrReason = RASIP_REASON_BadRange;
|
|
return ERROR_BAD_FORMAT;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasIpConvertRangePszToDword(
|
|
IN LPCWSTR pszFrom,
|
|
IN LPCWSTR pszTo,
|
|
OUT LPDWORD lpdwFrom,
|
|
OUT LPDWORD lpdwTo)
|
|
{
|
|
DWORD dwFrom = 0, dwTo = 0;
|
|
CHAR pszFromA[64], pszToA[64];
|
|
|
|
// Whistler bug 259799 PREFIX
|
|
//
|
|
if (NULL == pszFrom || NULL == pszTo)
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
wcstombs(pszFromA, pszFrom, sizeof(pszFromA));
|
|
dwFrom = inet_addr(pszFromA);
|
|
if (dwFrom == INADDR_NONE)
|
|
{
|
|
return ERROR_BAD_FORMAT;
|
|
}
|
|
|
|
wcstombs(pszToA, pszTo, sizeof(pszToA));
|
|
dwTo = inet_addr(pszToA);
|
|
if (dwTo == INADDR_NONE)
|
|
{
|
|
return ERROR_BAD_FORMAT;
|
|
}
|
|
|
|
// Convert for x86
|
|
//
|
|
*lpdwFrom = ntohl(dwFrom);
|
|
*lpdwTo = ntohl(dwTo);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleSetAccess(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwValue = 0;
|
|
RASIP_CB Config;
|
|
TOKEN_VALUE rgEnumMode[] =
|
|
{
|
|
{TOKEN_ALL, TRUE},
|
|
{TOKEN_SERVERONLY, FALSE}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_MODE, TRUE, FALSE},
|
|
rgEnumMode,
|
|
sizeof(rgEnumMode)/sizeof(*rgEnumMode),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// If successful, go ahead and set the info
|
|
//
|
|
ZeroMemory(&Config, sizeof(Config));
|
|
Config.dwFlags = RASIP_F_Access;
|
|
Config.bAccess = dwValue;
|
|
dwErr = RasIpCbWrite(g_pszServer, &Config);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
DisplayError(NULL, dwErr);
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleSetAssignment(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwValue = 0, dwReason = 0;
|
|
RASIP_CB* pConfig = NULL;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_AUTO, TRUE},
|
|
{TOKEN_POOL, FALSE}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_METHOD, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
// Initialize
|
|
RasIpCbCreateDefault(&pConfig);
|
|
|
|
do
|
|
{
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// If this is an attempt to switch to pool mode,
|
|
// make sure there is a valid pool.
|
|
//
|
|
if (dwValue == FALSE)
|
|
{
|
|
pConfig->dwFlags = RASIP_F_Pool | RASIP_F_Mask;
|
|
dwErr = RasIpCbRead(g_pszServer, pConfig);
|
|
BREAK_ON_DWERR( dwErr );
|
|
if (pConfig->pPool->dwCount == 0)
|
|
{
|
|
DisplayMessage(
|
|
g_hModule,
|
|
EMSG_RASIP_NEED_VALID_POOL,
|
|
DMP_RASIP_ADD_RANGE);
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If successful, go ahead and set the info
|
|
//
|
|
pConfig->dwFlags = RASIP_F_Auto;
|
|
pConfig->bAuto = dwValue;
|
|
dwErr = RasIpCbWrite(g_pszServer, pConfig);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
DisplayError(NULL, dwErr);
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
RasIpCbCleanup(pConfig);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleSetCallerSpec(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwValue = 0;
|
|
RASIP_CB Config;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_ALLOW, TRUE},
|
|
{TOKEN_DENY, FALSE}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_MODE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// If successful, go ahead and set the info
|
|
//
|
|
ZeroMemory(&Config, sizeof(Config));
|
|
Config.dwFlags = RASIP_F_CallerSpec;
|
|
Config.bCallerSpec = dwValue;
|
|
dwErr = RasIpCbWrite(g_pszServer, &Config);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
DisplayError(NULL, dwErr);
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleSetNegotiation(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwValue = 0;
|
|
RASIP_CB Config;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_ALLOW, TRUE},
|
|
{TOKEN_DENY, FALSE}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_MODE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// If successful, go ahead and set the info
|
|
//
|
|
ZeroMemory(&Config, sizeof(Config));
|
|
Config.dwFlags = RASIP_F_EnableIn;
|
|
Config.bEnableIn = dwValue;
|
|
dwErr = RasIpCbWrite(g_pszServer, &Config);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
DisplayError(NULL, dwErr);
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Get options to set NETBT broadcast enable/disable
|
|
// ppwcArguments - Argument array
|
|
// dwCurrentIndex - ppwcArguments[dwCurrentIndex] is the first arg
|
|
// dwArgCount - ppwcArguments[dwArgCount - 1] is the last arg
|
|
//
|
|
// Whistler bug: 359847 Netsh: move broadcastnameresolution from routing ip to
|
|
// ras ip
|
|
//
|
|
DWORD
|
|
RasIpHandleSetNetbtBcast(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwValue = 0;
|
|
TOKEN_VALUE rgEnum[] =
|
|
{
|
|
{TOKEN_ENABLED, TRUE},
|
|
{TOKEN_DISABLED, FALSE}
|
|
};
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_ENUM,
|
|
{TOKEN_MODE, TRUE, FALSE},
|
|
rgEnum,
|
|
sizeof(rgEnum)/sizeof(*rgEnum),
|
|
NULL
|
|
}
|
|
};
|
|
|
|
do
|
|
{
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
dwValue = RASMON_CMD_ARG_GetDword(&pArgs[0]);
|
|
|
|
// If successful, go ahead and set the info
|
|
//
|
|
dwErr = RasIpSetNetbtBcast(dwValue);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
DisplayError(NULL, dwErr);
|
|
break;
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleAddDelRange(
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN BOOL *pbDone,
|
|
IN BOOL bAdd
|
|
)
|
|
{
|
|
PWCHAR pszFrom = NULL, pszTo = NULL;
|
|
DWORD dwFrom = 0, dwTo = 0, dwErr = NO_ERROR, dwReason;
|
|
RASIP_CB * pConfig = NULL;
|
|
RASMON_CMD_ARG pArgs[] =
|
|
{
|
|
{
|
|
RASMONTR_CMD_TYPE_STRING,
|
|
{TOKEN_FROM, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
},
|
|
|
|
{
|
|
RASMONTR_CMD_TYPE_STRING,
|
|
{TOKEN_TO, TRUE, FALSE},
|
|
NULL,
|
|
0,
|
|
NULL
|
|
}
|
|
};
|
|
PWCHAR pszAddr = NULL, pszMask = NULL;
|
|
|
|
do
|
|
{
|
|
pConfig = (RASIP_CB*) RutlAlloc(sizeof(RASIP_CB), TRUE);
|
|
if (pConfig == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
// Parse the command line
|
|
//
|
|
dwErr = RutlParse(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
pArgs,
|
|
sizeof(pArgs)/sizeof(*pArgs));
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
pszFrom = RASMON_CMD_ARG_GetPsz(&pArgs[0]);
|
|
pszTo = RASMON_CMD_ARG_GetPsz(&pArgs[1]);
|
|
|
|
dwErr = RasIpConvertRangePszToDword(
|
|
pszFrom,
|
|
pszTo,
|
|
&dwFrom,
|
|
&dwTo);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
// Validate the values entered
|
|
//
|
|
dwErr = RasIpValidateRange(dwFrom, dwTo, &dwReason);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
RasIpDisplayInvalidPool(dwReason);
|
|
dwErr = ERROR_CAN_NOT_COMPLETE;
|
|
break;
|
|
}
|
|
|
|
// Read in the old config
|
|
pConfig->dwFlags = RASIP_F_Pool;
|
|
dwErr = RasIpCbRead(g_pszServer, pConfig);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
if (bAdd)
|
|
{
|
|
// Add the range
|
|
//
|
|
dwErr = RasIpPoolAdd(
|
|
pConfig->pPool,
|
|
dwFrom,
|
|
dwTo);
|
|
if (dwErr == ERROR_CAN_NOT_COMPLETE)
|
|
{
|
|
DisplayMessage(
|
|
g_hModule,
|
|
EMSG_RASIP_OVERLAPPING_RANGE);
|
|
}
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
else
|
|
{
|
|
// Delete the range
|
|
//
|
|
dwErr = RasIpPoolDel(
|
|
pConfig->pPool,
|
|
dwFrom,
|
|
dwTo);
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
|
|
// Commit the change
|
|
//
|
|
dwErr = RasIpCbWrite(
|
|
g_pszServer,
|
|
pConfig);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
RutlFree(pszFrom);
|
|
RutlFree(pszTo);
|
|
RasIpCbCleanup(pConfig);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleAddRange(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return RasIpHandleAddDelRange(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
TRUE);
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleDelRange(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
return RasIpHandleAddDelRange(
|
|
ppwcArguments,
|
|
dwCurrentIndex,
|
|
dwArgCount,
|
|
pbDone,
|
|
FALSE);
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleDelPool(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwNumArgs = dwArgCount - dwCurrentIndex;
|
|
RASIP_CB Config;
|
|
RAS_IPPOOL* pPool = NULL;
|
|
DWORD dwErr = NO_ERROR;
|
|
|
|
// Check that the number of arguments is correct
|
|
//
|
|
if (dwNumArgs > 0)
|
|
{
|
|
DisplayMessage(
|
|
g_hModule,
|
|
HLP_RASIP_DEL_POOL_EX,
|
|
DMP_RASIP_DEL_POOL);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
do
|
|
{
|
|
// Initialize an empty pool
|
|
//
|
|
pPool = RutlAlloc(sizeof(RAS_IPPOOL), TRUE);
|
|
if (pPool == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
ZeroMemory(&Config, sizeof(Config));
|
|
Config.dwFlags = RASIP_F_Pool;
|
|
Config.pPool = pPool;
|
|
|
|
dwErr = RasIpCbWrite(g_pszServer, &Config);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (pPool)
|
|
{
|
|
RasIpPoolCleanup(pPool);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpHandleShow(
|
|
IN LPCWSTR pwszMachine,
|
|
IN OUT LPWSTR *ppwcArguments,
|
|
IN DWORD dwCurrentIndex,
|
|
IN DWORD dwArgCount,
|
|
IN DWORD dwFlags,
|
|
IN LPCVOID pvData,
|
|
OUT BOOL *pbDone
|
|
)
|
|
{
|
|
DWORD dwNumArgs = dwArgCount - dwCurrentIndex;
|
|
|
|
// Check that the number of arguments is correct
|
|
//
|
|
if (dwNumArgs > 0)
|
|
{
|
|
DisplayMessage(
|
|
g_hModule,
|
|
HLP_RASIP_SHOW_CONFIG_EX,
|
|
DMP_RASIP_SHOW_CONFIG);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return RasIpDisplayConfig(TRUE);
|
|
}
|
|
|
|
//
|
|
// Opens the registry keys associated with the ras ip address pool
|
|
//
|
|
DWORD
|
|
RasIpPoolOpenKeys(
|
|
IN HKEY hkParams,
|
|
IN BOOL bCreate,
|
|
OUT HKEY* phNew)
|
|
{
|
|
DWORD dwErr = NO_ERROR, dwDisposition;
|
|
|
|
do
|
|
{
|
|
*phNew = NULL;
|
|
|
|
if (bCreate)
|
|
{
|
|
dwErr = RegCreateKeyEx(
|
|
hkParams,
|
|
pszIpPoolSubKey,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
phNew,
|
|
&dwDisposition);
|
|
}
|
|
else
|
|
{
|
|
dwErr = RegOpenKeyEx(
|
|
hkParams,
|
|
pszIpPoolSubKey,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
phNew);
|
|
}
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Find a given range in the IP address pool.
|
|
// If bExact is TRUE, it searches for an exact match to the range
|
|
// If bExact is FALSE, it searches for any overlapping range.
|
|
//
|
|
DWORD
|
|
RasIpPoolFind(
|
|
IN RAS_IPPOOL* pPool,
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo,
|
|
IN BOOL bExact,
|
|
OUT RAS_IPRANGE_NODE** ppNode OPTIONAL)
|
|
{
|
|
RAS_IPRANGE_NODE* pNode = pPool->pHead;
|
|
|
|
if (bExact)
|
|
{
|
|
for (; pNode; pNode = pNode->pNext)
|
|
{
|
|
if ((pNode->dwFrom == dwFrom) && (pNode->dwTo == pNode->dwTo))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (; pNode; pNode = pNode->pNext)
|
|
{
|
|
if (
|
|
// Overlap case 1: The lower end falls within an existing range
|
|
//
|
|
((dwFrom >= pNode->dwFrom) && (dwFrom <= pNode->dwTo)) ||
|
|
|
|
// Overlap case 2: The upper end falls within an existing range
|
|
//
|
|
((dwTo >= pNode->dwFrom) && (dwTo <= pNode->dwTo)) ||
|
|
|
|
// Overlap case 3: The range is a superset of an existing range
|
|
//
|
|
((dwFrom < pNode->dwFrom) && (dwTo > pNode->dwTo))
|
|
)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pNode)
|
|
{
|
|
if (ppNode)
|
|
{
|
|
*ppNode = pNode;
|
|
}
|
|
return NO_ERROR;
|
|
}
|
|
|
|
return ERROR_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Callback function populates a pool of addresses
|
|
//
|
|
DWORD
|
|
RasIpPoolReadNode(
|
|
IN LPCWSTR pszName, // sub key name
|
|
IN HKEY hKey, // sub key
|
|
IN HANDLE hData)
|
|
{
|
|
RAS_IPPOOL* pPool = (RAS_IPPOOL*)hData;
|
|
DWORD dwErr = NO_ERROR;
|
|
DWORD dwFrom = 0, dwTo = 0;
|
|
|
|
dwErr = RutlRegReadDword(hKey, pszIpFrom, &dwFrom);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
dwErr = RutlRegReadDword(hKey, pszIpTo, &dwTo);
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
dwErr = RasIpPoolAdd(pPool, dwFrom, dwTo);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Resets the ras pool on the given server
|
|
//
|
|
DWORD
|
|
RasIpPoolReset(
|
|
IN HKEY hkParams)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
HKEY hkPool = NULL;
|
|
|
|
do
|
|
{
|
|
dwErr = RasIpPoolOpenKeys(
|
|
hkParams,
|
|
TRUE,
|
|
&hkPool);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
{
|
|
DWORD i;
|
|
WCHAR pszBuf[16];
|
|
HKEY hkRange = NULL;
|
|
|
|
for (i = 0; ;i++)
|
|
{
|
|
_itow(i, pszBuf, 10);
|
|
|
|
dwErr = RegOpenKeyEx(
|
|
hkPool,
|
|
pszBuf,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hkRange);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
dwErr = NO_ERROR;
|
|
break;
|
|
}
|
|
RegCloseKey(hkRange);
|
|
RegDeleteKey(hkPool, pszBuf);
|
|
}
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hkPool)
|
|
{
|
|
RegCloseKey(hkPool);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Reads the ras ip pool from the given server
|
|
//
|
|
DWORD
|
|
RasIpPoolRead(
|
|
IN HKEY hkParams,
|
|
OUT RAS_IPPOOL** ppPool)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
RAS_IPPOOL* pPool = NULL;
|
|
HKEY hkPool = NULL;
|
|
PWCHAR pszAddress = NULL, pszMask = NULL;
|
|
|
|
do
|
|
{
|
|
// Allocate the new pool
|
|
//
|
|
pPool = (RAS_IPPOOL*) RutlAlloc(sizeof(RAS_IPPOOL), TRUE);
|
|
if (pPool == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
// Attempt to open the new location
|
|
//
|
|
dwErr = RasIpPoolOpenKeys(
|
|
hkParams,
|
|
FALSE,
|
|
&hkPool);
|
|
|
|
// The new location exists -- load in the
|
|
// pool
|
|
if (dwErr == NO_ERROR)
|
|
{
|
|
DWORD i;
|
|
WCHAR pszBuf[16];
|
|
HKEY hkRange = NULL;
|
|
|
|
for (i = 0; ;i++)
|
|
{
|
|
_itow(i, pszBuf, 10);
|
|
|
|
dwErr = RegOpenKeyEx(
|
|
hkPool,
|
|
pszBuf,
|
|
0,
|
|
KEY_ALL_ACCESS,
|
|
&hkRange);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
dwErr = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
dwErr = RasIpPoolReadNode(
|
|
pszBuf,
|
|
hkRange,
|
|
(HANDLE)pPool);
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
*ppPool = pPool;
|
|
}
|
|
|
|
// The new location does not exist -- use legacy
|
|
// values
|
|
//
|
|
else if (dwErr == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
DWORD dwAddress = 0, dwMask = 0;
|
|
|
|
dwErr = RutlRegReadString(hkParams, pszIpAddress, &pszAddress);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RutlRegReadString(hkParams, pszIpMask, &pszMask);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasIpConvertRangePszToDword(
|
|
pszAddress,
|
|
pszMask,
|
|
&dwAddress,
|
|
&dwMask);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
if (dwAddress != 0)
|
|
{
|
|
dwErr = RasIpPoolAdd(
|
|
pPool,
|
|
dwAddress + 2,
|
|
(dwAddress + ~dwMask) - 1);
|
|
BREAK_ON_DWERR(dwErr);
|
|
}
|
|
|
|
*ppPool = pPool;
|
|
}
|
|
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
if (pPool)
|
|
{
|
|
RasIpPoolCleanup(pPool);
|
|
}
|
|
}
|
|
if (hkPool)
|
|
{
|
|
RegCloseKey(hkPool);
|
|
}
|
|
RutlFree(pszAddress);
|
|
RutlFree(pszMask);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Writes the given ras ip pool to the given server
|
|
//
|
|
DWORD
|
|
RasIpPoolWrite(
|
|
IN HKEY hkParams,
|
|
IN RAS_IPPOOL* pPool)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
HKEY hkPool = NULL, hkNode = NULL;
|
|
DWORD i, dwDisposition;
|
|
WCHAR pszName[16];
|
|
RAS_IPRANGE_NODE* pNode = pPool->pHead;
|
|
|
|
do
|
|
{
|
|
dwErr = RasIpPoolReset(hkParams);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
dwErr = RasIpPoolOpenKeys(
|
|
hkParams,
|
|
TRUE,
|
|
&hkPool);
|
|
BREAK_ON_DWERR(dwErr);
|
|
|
|
for (i = 0; i < pPool->dwCount; i++, pNode = pNode->pNext)
|
|
{
|
|
_itow(i, pszName, 10);
|
|
|
|
dwErr = RegCreateKeyEx(
|
|
hkPool,
|
|
pszName,
|
|
0,
|
|
NULL,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hkNode,
|
|
&dwDisposition);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
RegSetValueEx(
|
|
hkNode,
|
|
pszIpFrom,
|
|
0,
|
|
REG_DWORD,
|
|
(CONST BYTE*)&pNode->dwFrom,
|
|
sizeof(DWORD));
|
|
|
|
RegSetValueEx(
|
|
hkNode,
|
|
pszIpTo,
|
|
0,
|
|
REG_DWORD,
|
|
(CONST BYTE*)&pNode->dwTo,
|
|
sizeof(DWORD));
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hkPool)
|
|
{
|
|
RegCloseKey(hkPool);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Adds a range to a ras ip pool
|
|
//
|
|
DWORD
|
|
RasIpPoolAdd(
|
|
IN OUT RAS_IPPOOL* pPool,
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo)
|
|
{
|
|
RAS_IPRANGE_NODE* pNode = NULL;
|
|
DWORD dwErr;
|
|
|
|
// Make sure the pool does not overlap
|
|
//
|
|
dwErr = RasIpPoolFind(pPool, dwFrom, dwTo, FALSE, NULL);
|
|
if (dwErr == NO_ERROR)
|
|
{
|
|
return ERROR_CAN_NOT_COMPLETE;
|
|
}
|
|
|
|
// Allocate the new node
|
|
//
|
|
pNode = (RAS_IPRANGE_NODE*) RutlAlloc(sizeof(RAS_IPRANGE_NODE), TRUE);
|
|
if (pNode == NULL)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
pNode->dwFrom = dwFrom;
|
|
pNode->dwTo = dwTo;
|
|
|
|
// Add it to the list
|
|
//
|
|
if (pPool->pTail)
|
|
{
|
|
pPool->pTail->pNext = pNode;
|
|
pPool->pTail = pNode;
|
|
}
|
|
else
|
|
{
|
|
pPool->pHead = pPool->pTail = pNode;
|
|
}
|
|
pPool->dwCount++;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Deletes a range from a ras ip pool
|
|
//
|
|
DWORD
|
|
RasIpPoolDel(
|
|
IN OUT RAS_IPPOOL* pPool,
|
|
IN DWORD dwFrom,
|
|
IN DWORD dwTo)
|
|
{
|
|
RAS_IPRANGE_NODE* pCur = NULL, *pPrev = NULL;
|
|
|
|
if (pPool->dwCount == 0)
|
|
{
|
|
return ERROR_NOT_FOUND;
|
|
}
|
|
|
|
pCur = pPrev = pPool->pHead;
|
|
|
|
if ((pCur->dwFrom == dwFrom) && (pCur->dwTo == dwTo))
|
|
{
|
|
pPool->pHead = pCur->pNext;
|
|
if (pCur == pPool->pTail)
|
|
{
|
|
pPool->pTail = NULL;
|
|
}
|
|
RutlFree(pCur);
|
|
pPool->dwCount--;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
for (pCur = pCur->pNext; pCur; pCur = pCur->pNext, pPrev = pPrev->pNext)
|
|
{
|
|
if ((pCur->dwFrom == dwFrom) && (pCur->dwTo == dwTo))
|
|
{
|
|
pPrev->pNext = pCur->pNext;
|
|
if (pCur == pPool->pTail)
|
|
{
|
|
pPool->pTail = pPrev;
|
|
}
|
|
RutlFree(pCur);
|
|
pPool->dwCount--;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
return ERROR_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Cleans up a config control block
|
|
//
|
|
DWORD
|
|
RasIpCbCleanup(
|
|
IN RASIP_CB* pConfig)
|
|
{
|
|
if (pConfig)
|
|
{
|
|
if (pConfig->pPool)
|
|
{
|
|
RasIpPoolCleanup(pConfig->pPool);
|
|
}
|
|
RutlFree(pConfig);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
RasIpPoolCleanup(
|
|
IN RAS_IPPOOL* pPool)
|
|
{
|
|
RAS_IPRANGE_NODE* pNode = NULL;
|
|
|
|
if (pPool)
|
|
{
|
|
while (pPool->pHead)
|
|
{
|
|
pNode = pPool->pHead->pNext;
|
|
RutlFree(pPool->pHead);
|
|
pPool->pHead = pNode;
|
|
}
|
|
|
|
RutlFree(pPool);
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Creates a default config control block
|
|
//
|
|
DWORD
|
|
RasIpCbCreateDefault(
|
|
OUT RASIP_CB** ppConfig)
|
|
{
|
|
RASIP_CB* pConfig = NULL;
|
|
DWORD dwErr = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
pConfig = (RASIP_CB*) RutlAlloc(sizeof(RASIP_CB), TRUE);
|
|
if (pConfig == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
break;
|
|
}
|
|
|
|
pConfig->bEnableIn = TRUE;
|
|
pConfig->bAccess = TRUE;
|
|
pConfig->bAuto = TRUE;
|
|
pConfig->pPool = NULL;
|
|
pConfig->bCallerSpec = TRUE;
|
|
|
|
*ppConfig = pConfig;
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (dwErr != NO_ERROR)
|
|
{
|
|
RasIpCbCleanup(pConfig);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Helper function opens the ras ip config registry key
|
|
//
|
|
DWORD
|
|
RasIpCbOpenRegKeys(
|
|
IN LPCWSTR pszServer,
|
|
OUT HKEY* phKey)
|
|
{
|
|
DWORD dwErr = NO_ERROR;
|
|
WCHAR pszKey[MAX_PATH];
|
|
|
|
do
|
|
{
|
|
// Generate the parameters key name
|
|
//
|
|
wsprintfW(
|
|
pszKey,
|
|
L"%s%s",
|
|
pszRemoteAccessParamStub,
|
|
pszIpParams);
|
|
|
|
// Open the parameters keys
|
|
//
|
|
dwErr = RegOpenKeyEx(
|
|
g_pServerInfo->hkMachine,
|
|
pszKey,
|
|
0,
|
|
KEY_READ | KEY_WRITE,
|
|
phKey);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Functions that manipulate RASIP_CB's
|
|
//
|
|
DWORD
|
|
RasIpCbRead(
|
|
IN LPCWSTR pszServer,
|
|
OUT RASIP_CB* pConfig)
|
|
{
|
|
HKEY hkParams = NULL;
|
|
DWORD dwErr = NO_ERROR;
|
|
PWCHAR pszTemp = NULL;
|
|
|
|
do
|
|
{
|
|
// Get a handle to the server's registry config
|
|
//
|
|
dwErr = RasIpCbOpenRegKeys(
|
|
pszServer,
|
|
&hkParams);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
// Load the params from the registry
|
|
//
|
|
if (pConfig->dwFlags & RASIP_F_EnableIn)
|
|
{
|
|
dwErr = RutlRegReadDword(
|
|
hkParams,
|
|
pszEnableIn,
|
|
&pConfig->bEnableIn);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Access)
|
|
{
|
|
dwErr = RutlRegReadDword(
|
|
hkParams,
|
|
pszAllowNetworkAccess,
|
|
&pConfig->bAccess);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Auto)
|
|
{
|
|
dwErr = RutlRegReadDword(
|
|
hkParams,
|
|
pszIpUseDhcp,
|
|
&pConfig->bAuto);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_CallerSpec)
|
|
{
|
|
dwErr = RutlRegReadDword(
|
|
hkParams,
|
|
pszIpClientSpec,
|
|
&pConfig->bCallerSpec);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Pool)
|
|
{
|
|
dwErr = RasIpPoolRead(
|
|
hkParams,
|
|
&pConfig->pPool);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hkParams)
|
|
{
|
|
RegCloseKey(hkParams);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
DWORD
|
|
RasIpCbWrite(
|
|
IN LPCWSTR pszServer,
|
|
IN RASIP_CB* pConfig)
|
|
{
|
|
HKEY hkParams = NULL;
|
|
DWORD dwErr = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
// Get a handle to the server's registry config
|
|
//
|
|
dwErr = RasIpCbOpenRegKeys(
|
|
pszServer,
|
|
&hkParams);
|
|
BREAK_ON_DWERR( dwErr );
|
|
|
|
// Write out the params to the registry
|
|
//
|
|
if (pConfig->dwFlags & RASIP_F_EnableIn)
|
|
{
|
|
dwErr = RutlRegWriteDword(
|
|
hkParams,
|
|
pszEnableIn,
|
|
pConfig->bEnableIn);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Access)
|
|
{
|
|
dwErr = RutlRegWriteDword(
|
|
hkParams,
|
|
pszAllowNetworkAccess,
|
|
pConfig->bAccess);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Auto)
|
|
{
|
|
dwErr = RutlRegWriteDword(
|
|
hkParams,
|
|
pszIpUseDhcp,
|
|
pConfig->bAuto);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_CallerSpec)
|
|
{
|
|
dwErr = RutlRegWriteDword(
|
|
hkParams,
|
|
pszIpClientSpec,
|
|
pConfig->bCallerSpec);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
if (pConfig->dwFlags & RASIP_F_Pool)
|
|
{
|
|
dwErr = RasIpPoolWrite(
|
|
hkParams,
|
|
pConfig->pPool);
|
|
BREAK_ON_DWERR( dwErr );
|
|
}
|
|
|
|
} while (FALSE);
|
|
|
|
// Cleanup
|
|
{
|
|
if (hkParams)
|
|
{
|
|
RegCloseKey(hkParams);
|
|
}
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//
|
|
// Set NETBT broadcast based name resolution reg. value
|
|
// dwArgCount - Value to set the registry value to
|
|
// returns NO_ERROR - Success
|
|
// Other - System error code
|
|
//
|
|
// Whistler bug: 359847 Netsh: move broadcastnameresolution from routing ip to
|
|
// ras ip
|
|
//
|
|
DWORD
|
|
RasIpSetNetbtBcast(
|
|
DWORD dwEnable
|
|
)
|
|
{
|
|
DWORD dwResult, dwEnableOld = -1, dwSize = sizeof(DWORD);
|
|
HKEY hkIpcpParam;
|
|
|
|
do
|
|
{
|
|
dwResult = RegOpenKeyExW(
|
|
g_pServerInfo->hkMachine,
|
|
L"System\\CurrentControlSet\\Services\\RemoteAccess\\Parameters\\Ip",
|
|
0,
|
|
KEY_READ | KEY_WRITE,
|
|
&hkIpcpParam
|
|
);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
dwResult = RegQueryValueExW(
|
|
hkIpcpParam,
|
|
L"EnableNetbtBcastFwd",
|
|
NULL,
|
|
NULL,
|
|
(PBYTE)&dwEnableOld,
|
|
&dwSize
|
|
);
|
|
|
|
if((dwResult is NO_ERROR) and (dwEnable == dwEnableOld))
|
|
{
|
|
break;
|
|
}
|
|
|
|
dwResult = RegSetValueExW(
|
|
hkIpcpParam,
|
|
L"EnableNetbtBcastFwd",
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &dwEnable,
|
|
sizeof( DWORD )
|
|
);
|
|
|
|
} while(FALSE);
|
|
|
|
if(dwResult is NO_ERROR)
|
|
{
|
|
DisplayMessage(g_hModule, MSG_RASAAAA_MUST_RESTART_SERVICES);
|
|
}
|
|
|
|
return dwResult;
|
|
}
|
|
|
|
//
|
|
// Whistler bug: 359847 Netsh: move broadcastnameresolution from routing ip to
|
|
// ras ip
|
|
//
|
|
BOOL
|
|
RasIpShowNetbtBcast(
|
|
VOID
|
|
)
|
|
{
|
|
HKEY hkIpcpParam = NULL;
|
|
BOOL bReturn = FALSE;
|
|
DWORD dwResult, dwEnable = -1, dwSize = sizeof(DWORD);
|
|
|
|
do
|
|
{
|
|
|
|
dwResult = RegOpenKeyExW(
|
|
g_pServerInfo->hkMachine,
|
|
L"System\\CurrentControlSet\\Services\\RemoteAccess\\Parameters\\Ip",
|
|
0,
|
|
KEY_READ | KEY_WRITE,
|
|
&hkIpcpParam
|
|
);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
dwResult = RegQueryValueExW(
|
|
hkIpcpParam,
|
|
L"EnableNetbtBcastFwd",
|
|
NULL,
|
|
NULL,
|
|
(PBYTE)&dwEnable,
|
|
&dwSize
|
|
);
|
|
|
|
if(dwResult isnot NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (dwEnable isnot 0)
|
|
{
|
|
bReturn = TRUE;
|
|
}
|
|
|
|
} while(FALSE);
|
|
|
|
return bReturn;
|
|
}
|
|
|