294 lines
8.1 KiB
C++
294 lines
8.1 KiB
C++
#include "precomp.h"
|
|
|
|
#include "debug.h"
|
|
|
|
#define MAXIPSTRLEN 20
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: IpAddressFromAbcdWsz
|
|
//
|
|
// Synopsis:Converts caller's a.b.c.d IP address string to a network byte order IP
|
|
// address. 0 if formatted incorrectly.
|
|
//
|
|
// Arguments: IN const WCHAR* wszIpAddress - ip address in a.b.c.d unicode string
|
|
//
|
|
// Returns: DWORD - IPAddr, return INADDR_NONE on failure
|
|
//
|
|
// History: fengsun Created Header 12/8/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
DWORD WINAPI IpAddressFromAbcdWsz(IN const WCHAR* wszIpAddress)
|
|
{
|
|
CHAR szIpAddress[MAXIPSTRLEN + 1];
|
|
DWORD nboIpAddr;
|
|
|
|
ASSERT(lstrlen(wszIpAddress) < MAXIPSTRLEN);
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, wszIpAddress, -1,
|
|
szIpAddress, sizeof(szIpAddress), NULL, NULL);
|
|
|
|
nboIpAddr = inet_addr(szIpAddress);
|
|
|
|
return(nboIpAddr);
|
|
}
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: IpAddressToAbcdWsz
|
|
//
|
|
// Synopsis:
|
|
// Converts IpAddr to a string in the a.b.c.d form and returns same in
|
|
// caller's wszIpAddress buffer. The buffer should be at least
|
|
// MAXIPSTRLEN + 1 characters long.
|
|
//
|
|
// Arguments: IPAddr IpAddress -
|
|
// OUT WCHAR* wszIpAddress - buffer at least MAXIPSTRLEN
|
|
//
|
|
// Returns: void
|
|
//
|
|
// History: fengsun Created Header 12/21/98
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
VOID
|
|
WINAPI AbcdWszFromIpAddress(
|
|
IN DWORD IpAddress,
|
|
OUT WCHAR* wszIpAddress)
|
|
{
|
|
ASSERT(wszIpAddress);
|
|
|
|
LPSTR AnsiAddressString = inet_ntoa( *(struct in_addr *)&IpAddress );
|
|
|
|
ASSERT(AnsiAddressString);
|
|
|
|
if (AnsiAddressString == NULL)
|
|
{
|
|
lstrcpyW(wszIpAddress, L"");
|
|
return ;
|
|
}
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, AnsiAddressString, -1 ,
|
|
wszIpAddress, MAXIPSTRLEN + 1);
|
|
}
|
|
|
|
/*
|
|
* Function: GetIPAddressOctets
|
|
* Description: Turn an IP Address string into its 4 integer components.
|
|
* Author: shouse 7.24.00
|
|
*/
|
|
VOID GetIPAddressOctets (PCWSTR pszIpAddress, DWORD ardw[4]) {
|
|
DWORD dwIpAddr = IpAddressFromAbcdWsz(pszIpAddress);
|
|
const BYTE * bp = (const BYTE *)&dwIpAddr;
|
|
|
|
ardw[0] = (DWORD)bp[0];
|
|
ardw[1] = (DWORD)bp[1];
|
|
ardw[2] = (DWORD)bp[2];
|
|
ardw[3] = (DWORD)bp[3];
|
|
}
|
|
|
|
/*
|
|
* Function: IsValidIPAddressSubnetMaskPair
|
|
* Description: Checks for valid IP address/netmask pairs.
|
|
* Author: Copied largely from net/config/netcfg/tcpipcfg/tcperror.cpp
|
|
*/
|
|
BOOL IsValidIPAddressSubnetMaskPair (PCWSTR szIp, PCWSTR szSubnet) {
|
|
BOOL fNoError = TRUE;
|
|
DWORD ardwNetID[4];
|
|
DWORD ardwHostID[4];
|
|
DWORD ardwIp[4];
|
|
DWORD ardwMask[4];
|
|
|
|
GetIPAddressOctets(szIp, ardwIp);
|
|
GetIPAddressOctets(szSubnet, ardwMask);
|
|
|
|
INT nFirstByte = ardwIp[0] & 0xFF;
|
|
|
|
// setup Net ID
|
|
ardwNetID[0] = ardwIp[0] & ardwMask[0] & 0xFF;
|
|
ardwNetID[1] = ardwIp[1] & ardwMask[1] & 0xFF;
|
|
ardwNetID[2] = ardwIp[2] & ardwMask[2] & 0xFF;
|
|
ardwNetID[3] = ardwIp[3] & ardwMask[3] & 0xFF;
|
|
|
|
// setup Host ID
|
|
ardwHostID[0] = ardwIp[0] & (~(ardwMask[0]) & 0xFF);
|
|
ardwHostID[1] = ardwIp[1] & (~(ardwMask[1]) & 0xFF);
|
|
ardwHostID[2] = ardwIp[2] & (~(ardwMask[2]) & 0xFF);
|
|
ardwHostID[3] = ardwIp[3] & (~(ardwMask[3]) & 0xFF);
|
|
|
|
// check each case
|
|
if( ((nFirstByte & 0xF0) == 0xE0) || // Class D
|
|
((nFirstByte & 0xF0) == 0xF0) || // Class E
|
|
(ardwNetID[0] == 127) || // NetID cannot be 127...
|
|
((ardwNetID[0] == 0) && // netid cannot be 0.0.0.0
|
|
(ardwNetID[1] == 0) &&
|
|
(ardwNetID[2] == 0) &&
|
|
(ardwNetID[3] == 0)) ||
|
|
// netid cannot be equal to sub-net mask
|
|
((ardwNetID[0] == ardwMask[0]) &&
|
|
(ardwNetID[1] == ardwMask[1]) &&
|
|
(ardwNetID[2] == ardwMask[2]) &&
|
|
(ardwNetID[3] == ardwMask[3])) ||
|
|
// hostid cannot be 0.0.0.0
|
|
((ardwHostID[0] == 0) &&
|
|
(ardwHostID[1] == 0) &&
|
|
(ardwHostID[2] == 0) &&
|
|
(ardwHostID[3] == 0)) ||
|
|
// hostid cannot be 255.255.255.255
|
|
((ardwHostID[0] == 0xFF) &&
|
|
(ardwHostID[1] == 0xFF) &&
|
|
(ardwHostID[2] == 0xFF) &&
|
|
(ardwHostID[3] == 0xFF)) ||
|
|
// test for all 255
|
|
((ardwIp[0] == 0xFF) &&
|
|
(ardwIp[1] == 0xFF) &&
|
|
(ardwIp[2] == 0xFF) &&
|
|
(ardwIp[3] == 0xFF)))
|
|
{
|
|
fNoError = FALSE;
|
|
}
|
|
|
|
return fNoError;
|
|
}
|
|
|
|
/*
|
|
* Function: IsContiguousSubnetMask
|
|
* Description: Makes sure the netmask is contiguous
|
|
* Author: Copied largely from net/config/netcfg/tcpipcfg/tcputil.cpp
|
|
*/
|
|
BOOL IsContiguousSubnetMask (PCWSTR pszSubnet) {
|
|
DWORD ardwSubnet[4];
|
|
|
|
GetIPAddressOctets(pszSubnet, ardwSubnet);
|
|
|
|
DWORD dwMask = (ardwSubnet[0] << 24) + (ardwSubnet[1] << 16)
|
|
+ (ardwSubnet[2] << 8) + ardwSubnet[3];
|
|
|
|
|
|
DWORD i, dwContiguousMask;
|
|
|
|
// Find out where the first '1' is in binary going right to left
|
|
dwContiguousMask = 0;
|
|
|
|
for (i = 0; i < sizeof(dwMask)*8; i++) {
|
|
dwContiguousMask |= 1 << i;
|
|
|
|
if (dwContiguousMask & dwMask)
|
|
break;
|
|
}
|
|
|
|
// At this point, dwContiguousMask is 000...0111... If we inverse it,
|
|
// we get a mask that can be or'd with dwMask to fill in all of
|
|
// the holes.
|
|
dwContiguousMask = dwMask | ~dwContiguousMask;
|
|
|
|
// If the new mask is different, correct it here
|
|
if (dwMask != dwContiguousMask)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Function: Params_ip2sub
|
|
//
|
|
// Description:
|
|
//
|
|
// Arguments: WSTR ip -
|
|
// PWSTR sub -
|
|
//
|
|
// Returns: BOOL -
|
|
//
|
|
// History: fengsun Created Header 3/2/00
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
BOOL ParamsGenerateSubnetMask (PWSTR ip, PWSTR sub) {
|
|
DWORD b [4];
|
|
|
|
swscanf (ip, L"%d.%d.%d.%d", b, b+1, b+2, b+3);
|
|
|
|
if ((b [0] >= 1) && (b [0] <= 126)) {
|
|
b [0] = 255;
|
|
b [1] = 0;
|
|
b [2] = 0;
|
|
b [3] = 0;
|
|
} else if ((b [0] >= 128) && (b [0] <= 191)) {
|
|
b [0] = 255;
|
|
b [1] = 255;
|
|
b [2] = 0;
|
|
b [3] = 0;
|
|
} else if ((b [0] >= 192) && (b [0] <= 223)) {
|
|
b [0] = 255;
|
|
b [1] = 255;
|
|
b [2] = 255;
|
|
b [3] = 0;
|
|
} else {
|
|
b [0] = 0;
|
|
b [1] = 0;
|
|
b [2] = 0;
|
|
b [3] = 0;
|
|
};
|
|
|
|
swprintf (sub, L"%d.%d.%d.%d",
|
|
b [0], b [1], b [2], b [3]);
|
|
|
|
return((b[0] + b[1] + b[2] + b[3]) > 0);
|
|
}
|
|
|
|
/*
|
|
* Function: ParamsGenerateMAC
|
|
* Description: Calculate the generated field in the structure
|
|
* History: fengsun Created 3.27.00
|
|
* shouse Modified 7.12.00
|
|
*/
|
|
void ParamsGenerateMAC (const WCHAR * szClusterIP,
|
|
OUT WCHAR * szClusterMAC,
|
|
OUT WCHAR * szMulticastIP,
|
|
BOOL fConvertMAC,
|
|
BOOL fMulticast,
|
|
BOOL fIGMP,
|
|
BOOL fUseClusterIP) {
|
|
DWORD dwIp;
|
|
const BYTE * bp;
|
|
|
|
if (!fConvertMAC) return;
|
|
|
|
/* Unicast mode. */
|
|
if (!fMulticast) {
|
|
dwIp = IpAddressFromAbcdWsz(szClusterIP);
|
|
bp = (const BYTE *)&dwIp;
|
|
|
|
swprintf(szClusterMAC, L"02-bf-%02x-%02x-%02x-%02x", bp[0], bp[1], bp[2], bp[3]);
|
|
|
|
return;
|
|
}
|
|
|
|
/* Multicast without IGMP. */
|
|
if (!fIGMP) {
|
|
dwIp = IpAddressFromAbcdWsz(szClusterIP);
|
|
bp = (const BYTE *)&dwIp;
|
|
|
|
swprintf(szClusterMAC, L"03-bf-%02x-%02x-%02x-%02x", bp[0], bp[1], bp[2], bp[3]);
|
|
|
|
return;
|
|
}
|
|
|
|
/* Multicast with IGMP. */
|
|
if (fUseClusterIP) {
|
|
/* 239.255.x.x */
|
|
dwIp = IpAddressFromAbcdWsz(szClusterIP);
|
|
dwIp = 239 + (255 << 8) + (dwIp & 0xFFFF0000);
|
|
AbcdWszFromIpAddress(dwIp, szMulticastIP);
|
|
}
|
|
|
|
dwIp = IpAddressFromAbcdWsz(szMulticastIP);
|
|
bp = (const BYTE*)&dwIp;
|
|
|
|
swprintf(szClusterMAC, L"01-00-5e-%02x-%02x-%02x", (bp[1] & 0x7f), bp[2], bp[3]);
|
|
}
|
|
|
|
|