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

2102 lines
47 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
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;
}
Reference in a new issue Copy permalink