3224 lines
95 KiB
C
3224 lines
95 KiB
C
/*++
|
||
|
||
Copyright (c) 2001 Microsoft Corporation
|
||
|
||
Abstract:
|
||
|
||
Functions implementing the 6to4 service, to provide IPv6 connectivity
|
||
over an IPv4 network.
|
||
|
||
--*/
|
||
|
||
#include "precomp.h"
|
||
#pragma hdrstop
|
||
|
||
extern DWORD
|
||
APIENTRY
|
||
RasQuerySharedPrivateLan(
|
||
OUT GUID* LanGuid );
|
||
|
||
STATE g_stService = DISABLED;
|
||
ULONG g_ulEventCount = 0;
|
||
|
||
//
|
||
// Worst metric for which we can add a route
|
||
//
|
||
#define UNREACHABLE 0x7fffffff
|
||
// #define INFINITE_LIFETIME 0xffffffff
|
||
#define V4_COMPAT_IFINDEX 2
|
||
#define SIX_TO_FOUR_IFINDEX 3
|
||
|
||
const IN6_ADDR SixToFourPrefix = { 0x20, 0x02, 0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
|
||
#define SIXTOFOUR_METRIC 1000
|
||
|
||
// Metric of subnet/sitelocal route on a router
|
||
#define SUBNET_ROUTE_METRIC 1
|
||
#define SITELOCAL_ROUTE_METRIC 1
|
||
|
||
// Information on a 6to4 subnet that we've generated as a router
|
||
typedef struct _SUBNET_CONTEXT {
|
||
IN_ADDR V4Addr;
|
||
int Publish;
|
||
u_int ValidLifetime;
|
||
u_int PreferredLifetime;
|
||
} SUBNET_CONTEXT, *PSUBNET_CONTEXT;
|
||
|
||
//
|
||
// Variables for settings
|
||
//
|
||
|
||
#define DEFAULT_ENABLE_RESOLUTION AUTOMATIC
|
||
#define DEFAULT_ENABLE_ROUTING AUTOMATIC
|
||
#define DEFAULT_RESOLUTION_INTERVAL (24 * HOURS)
|
||
#define DEFAULT_ISATAP_RESOLUTION_INTERVAL (24 * HOURS)
|
||
#define DEFAULT_ENABLE_SITELOCALS ENABLED
|
||
#define DEFAULT_ENABLE_ISATAP_RESOLUTION ENABLED
|
||
#define DEFAULT_ENABLE_6OVER4 DISABLED
|
||
#define DEFAULT_ENABLE_V4COMPAT DISABLED
|
||
#define DEFAULT_RELAY_NAME L"6to4.ipv6.microsoft.com."
|
||
#define DEFAULT_UNDO_ON_STOP ENABLED
|
||
|
||
#define KEY_ENABLE_RESOLUTION L"EnableResolution"
|
||
#define KEY_ENABLE_ROUTING L"EnableRouting"
|
||
#define KEY_ENABLE_SITELOCALS L"EnableSiteLocals"
|
||
#define KEY_ENABLE_6OVER4 L"Enable6over4"
|
||
#define KEY_ENABLE_V4COMPAT L"EnableV4Compat"
|
||
#define KEY_RESOLUTION_INTERVAL L"ResolutionInterval"
|
||
#define KEY_UNDO_ON_STOP L"UndoOnStop"
|
||
#define KEY_RELAY_NAME L"RelayName"
|
||
#define KEY_ENABLE_ISATAP_RESOLUTION L"EnableIsatapResolution"
|
||
#define KEY_ISATAP_RESOLUTION_INTERVAL L"IsatapResolutionInterval"
|
||
#define KEY_ISATAP_ROUTER_NAME L"IsatapRouterName"
|
||
|
||
#define KEY_GLOBAL L"System\\CurrentControlSet\\Services\\6to4\\Config"
|
||
#define KEY_INTERFACES L"System\\CurrentControlSet\\Services\\6to4\\Interfaces"
|
||
|
||
#define DEFAULT_ISATAP_ROUTER_NAME L"isatap"
|
||
|
||
typedef enum {
|
||
IPV4_SCOPE_NODE,
|
||
IPV4_SCOPE_LINK,
|
||
IPV4_SCOPE_SM_SITE,
|
||
IPV4_SCOPE_MD_SITE,
|
||
IPV4_SCOPE_LG_SITE,
|
||
IPV4_SCOPE_GLOBAL,
|
||
NUM_IPV4_SCOPES
|
||
} IPV4_SCOPE;
|
||
|
||
//
|
||
// Global config settings
|
||
//
|
||
typedef struct {
|
||
STATE stEnableRouting;
|
||
STATE stEnableResolution;
|
||
STATE stEnableSiteLocals;
|
||
STATE stEnable6over4;
|
||
STATE stEnableV4Compat;
|
||
STATE stEnableIsatapResolution;
|
||
ULONG ulResolutionInterval; // in minutes
|
||
ULONG ulIsatapResolutionInterval; // in minutes
|
||
WCHAR pwszRelayName[NI_MAXHOST];
|
||
WCHAR pwszIsatapRouterName[NI_MAXHOST];
|
||
STATE stUndoOnStop;
|
||
} GLOBAL_SETTINGS;
|
||
|
||
GLOBAL_SETTINGS g_GlobalSettings;
|
||
|
||
typedef struct {
|
||
STATE stRoutingState;
|
||
STATE stResolutionState;
|
||
STATE stIsatapResolutionState;
|
||
} GLOBAL_STATE;
|
||
|
||
GLOBAL_STATE g_GlobalState = { DISABLED, DISABLED, DISABLED };
|
||
|
||
typedef struct _ADDR_INFO {
|
||
LPSOCKADDR lpSockaddr;
|
||
INT iSockaddrLength;
|
||
|
||
ULONG ul6over4IfIndex;
|
||
} ADDR_INFO, *PADDR_INFO;
|
||
|
||
#define ADDR_FLAG_DISABLED 0x01
|
||
|
||
typedef struct _ADDR_LIST {
|
||
INT iAddressCount;
|
||
ADDR_INFO Address[1];
|
||
} ADDR_LIST, *PADDR_LIST;
|
||
|
||
const ADDR_LIST EmptyAddressList = {0};
|
||
|
||
// List of public IPv4 addresses used when updating the routing state
|
||
ADDR_LIST *g_pPublicAddressList = NULL;
|
||
|
||
//
|
||
// Variables for interfaces (addresses and routing)
|
||
//
|
||
|
||
typedef struct _IF_SETTINGS {
|
||
WCHAR pwszAdapterName[MAX_ADAPTER_NAME];
|
||
|
||
STATE stEnableRouting; // be a router on this private iface?
|
||
} IF_SETTINGS, *PIF_SETTINGS;
|
||
|
||
typedef struct _IF_SETTINGS_LIST {
|
||
ULONG ulNumInterfaces;
|
||
IF_SETTINGS arrIf[0];
|
||
} IF_SETTINGS_LIST, *PIF_SETTINGS_LIST;
|
||
|
||
PIF_SETTINGS_LIST g_pInterfaceSettingsList = NULL;
|
||
|
||
typedef struct _IF_INFO {
|
||
WCHAR pwszAdapterName[MAX_ADAPTER_NAME];
|
||
|
||
ULONG ulIPv6IfIndex;
|
||
STATE stRoutingState; // be a router on this private iface?
|
||
ULONG ulNumGlobals;
|
||
ADDR_LIST *pAddressList;
|
||
} IF_INFO, *PIF_INFO;
|
||
|
||
typedef struct _IF_LIST {
|
||
ULONG ulNumInterfaces;
|
||
ULONG ulNumScopedAddrs[NUM_IPV4_SCOPES];
|
||
IF_INFO arrIf[0];
|
||
} IF_LIST, *PIF_LIST;
|
||
|
||
PIF_LIST g_pInterfaceList = NULL;
|
||
|
||
|
||
|
||
HANDLE g_hAddressChangeEvent = NULL;
|
||
OVERLAPPED g_hAddressChangeOverlapped;
|
||
HANDLE g_hAddressChangeWaitHandle = NULL;
|
||
|
||
STATE g_st6to4State = DISABLED;
|
||
SOCKET g_sIPv4Socket = INVALID_SOCKET;
|
||
|
||
///////////////////////////////////////////////////////////////////////////
|
||
// Variables for relays
|
||
//
|
||
|
||
typedef struct _RELAY_INFO {
|
||
SOCKADDR_IN sinAddress; // IPv4 address
|
||
SOCKADDR_IN6 sin6Address; // IPv6 address
|
||
ULONG ulMetric;
|
||
} RELAY_INFO, *PRELAY_INFO;
|
||
|
||
typedef struct _RELAY_LIST {
|
||
ULONG ulNumRelays;
|
||
RELAY_INFO arrRelay[0];
|
||
} RELAY_LIST, *PRELAY_LIST;
|
||
|
||
PRELAY_LIST g_pRelayList = NULL;
|
||
HANDLE g_hTimerQueue = INVALID_HANDLE_VALUE;
|
||
HANDLE g_h6to4ResolutionTimer = INVALID_HANDLE_VALUE;
|
||
HANDLE g_h6to4TimerCancelledEvent = NULL;
|
||
HANDLE g_h6to4TimerCancelledWait = NULL;
|
||
HANDLE g_hIsatapResolutionTimer = INVALID_HANDLE_VALUE;
|
||
HANDLE g_hIsatapTimerCancelledEvent = NULL;
|
||
HANDLE g_hIsatapTimerCancelledWait = NULL;
|
||
|
||
IN_ADDR g_ipIsatapRouter = { INADDR_ANY };
|
||
IN_ADDR g_ipIsatapToken = { INADDR_ANY };
|
||
|
||
DWORD
|
||
UpdateGlobalResolutionState(
|
||
IN GLOBAL_SETTINGS *pOldSettings,
|
||
IN GLOBAL_STATE *pOldState);
|
||
|
||
VOID
|
||
WINAPI
|
||
SetIsatapRouterAddress();
|
||
|
||
//////////////////////////////////////////////////////////////////////////////
|
||
// GetAddrStr - helper routine to get a string literal for an address
|
||
LPTSTR
|
||
GetAddrStr(
|
||
IN LPSOCKADDR pSockaddr,
|
||
IN ULONG ulSockaddrLen)
|
||
{
|
||
static TCHAR tBuffer[INET6_ADDRSTRLEN];
|
||
INT iRet;
|
||
ULONG ulLen;
|
||
|
||
ulLen = sizeof(tBuffer);
|
||
iRet = WSAAddressToString(pSockaddr, ulSockaddrLen, NULL, tBuffer, &ulLen);
|
||
|
||
if (iRet) {
|
||
swprintf(tBuffer, L"<err %d>", WSAGetLastError());
|
||
}
|
||
|
||
return tBuffer;
|
||
}
|
||
|
||
BOOL
|
||
ConvertOemToUnicode(
|
||
IN LPSTR OemString,
|
||
OUT LPWSTR UnicodeString,
|
||
IN int UnicodeLen)
|
||
{
|
||
return (MultiByteToWideChar(CP_OEMCP, 0, OemString, (int)(strlen(OemString)+1),
|
||
UnicodeString, UnicodeLen) != 0);
|
||
}
|
||
|
||
BOOL
|
||
ConvertUnicodeToOem(
|
||
IN LPWSTR UnicodeString,
|
||
OUT LPSTR OemString,
|
||
IN int OemLen)
|
||
{
|
||
return (WideCharToMultiByte(CP_OEMCP, 0, UnicodeString,
|
||
(int)(wcslen(UnicodeString)+1), OemString, OemLen, NULL, NULL) != 0);
|
||
}
|
||
|
||
DWORD
|
||
GetAddrInfoW(
|
||
IN PWCHAR pwszName,
|
||
IN PWCHAR pwszServ,
|
||
IN struct addrinfo *hints,
|
||
IN struct addrinfo **ai)
|
||
{
|
||
char name[NI_MAXHOST * 2], *pName = NULL;
|
||
char serv[NI_MAXHOST * 2], *pServ = NULL;
|
||
|
||
if (pwszName) {
|
||
if (!ConvertUnicodeToOem(pwszName, name, sizeof(name))) {
|
||
return GetLastError();
|
||
}
|
||
pName = name;
|
||
}
|
||
|
||
if (pwszServ) {
|
||
if (!ConvertUnicodeToOem(pwszServ, serv, sizeof(serv))) {
|
||
return GetLastError();
|
||
}
|
||
pServ = serv;
|
||
}
|
||
|
||
return getaddrinfo(pName, pServ, hints, ai);
|
||
}
|
||
|
||
|
||
/////////////////////////////////////////////////////////////////////////
|
||
// Subroutines for manipulating the list of (usually) public addresses
|
||
// being used for both 6to4 addresses and subnet prefixes.
|
||
/////////////////////////////////////////////////////////////////////////
|
||
|
||
DWORD
|
||
MakeEmptyAddressList(
|
||
OUT PADDR_LIST *ppList)
|
||
{
|
||
*ppList = MALLOC(FIELD_OFFSET(ADDR_LIST, Address[0]));
|
||
if (!*ppList) {
|
||
return GetLastError();
|
||
}
|
||
|
||
(*ppList)->iAddressCount = 0;
|
||
return NO_ERROR;
|
||
}
|
||
|
||
VOID
|
||
FreeAddressList(
|
||
IN PADDR_LIST *ppAddressList)
|
||
{
|
||
ADDR_LIST *pList = *ppAddressList;
|
||
int i;
|
||
|
||
if (pList == NULL) {
|
||
return;
|
||
}
|
||
|
||
// Free all addresses
|
||
for (i=0; i<pList->iAddressCount; i++) {
|
||
FREE(pList->Address[i].lpSockaddr);
|
||
}
|
||
|
||
// Free the list
|
||
FREE(pList);
|
||
*ppAddressList = NULL;
|
||
}
|
||
|
||
DWORD
|
||
AddAddressToList(
|
||
IN LPSOCKADDR_IN pAddress,
|
||
IN ADDR_LIST **ppAddressList,
|
||
IN ULONG ul6over4IfIndex)
|
||
{
|
||
ADDR_LIST *pOldList = *ppAddressList;
|
||
ADDR_LIST *pNewList;
|
||
int n = pOldList->iAddressCount;
|
||
|
||
// Copy existing addresses
|
||
pNewList = MALLOC( FIELD_OFFSET(ADDR_LIST, Address[n+1]) );
|
||
if (!pNewList) {
|
||
return GetLastError();
|
||
}
|
||
CopyMemory(pNewList, pOldList,
|
||
FIELD_OFFSET(ADDR_LIST, Address[n]));
|
||
pNewList->iAddressCount = n+1;
|
||
|
||
// Add new address
|
||
pNewList->Address[n].lpSockaddr = MALLOC(sizeof(SOCKADDR_IN));
|
||
if (!pNewList->Address[n].lpSockaddr) {
|
||
FREE(pNewList);
|
||
return ERROR_NOT_ENOUGH_MEMORY;
|
||
}
|
||
CopyMemory(pNewList->Address[n].lpSockaddr, pAddress, sizeof(SOCKADDR_IN));
|
||
pNewList->Address[n].iSockaddrLength = sizeof(SOCKADDR_IN);
|
||
pNewList->Address[n].ul6over4IfIndex = ul6over4IfIndex;
|
||
|
||
// Free the old list without freeing the sockaddrs
|
||
FREE(pOldList);
|
||
|
||
*ppAddressList = pNewList;
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
DWORD
|
||
FindAddressInList(
|
||
IN LPSOCKADDR_IN pAddress,
|
||
IN ADDR_LIST *pAddressList,
|
||
OUT ULONG *pulIndex)
|
||
{
|
||
int i;
|
||
|
||
// Find address in list
|
||
for (i=0; i<pAddressList->iAddressCount; i++) {
|
||
if (!memcmp(pAddress, pAddressList->Address[i].lpSockaddr,
|
||
sizeof(SOCKADDR_IN))) {
|
||
*pulIndex = i;
|
||
return NO_ERROR;
|
||
}
|
||
}
|
||
|
||
Trace1(ERR, _T("ERROR: FindAddressInList didn't find %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddress->sin_addr.s_addr));
|
||
|
||
return ERROR_NOT_FOUND;
|
||
}
|
||
|
||
DWORD
|
||
RemoveAddressFromList(
|
||
IN ULONG ulIndex,
|
||
IN ADDR_LIST *pAddressList)
|
||
{
|
||
// Free old address
|
||
FREE(pAddressList->Address[ulIndex].lpSockaddr);
|
||
|
||
// Move the last entry into its place
|
||
pAddressList->iAddressCount--;
|
||
pAddressList->Address[ulIndex] =
|
||
pAddressList->Address[pAddressList->iAddressCount];
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// GlobalInfo-related subroutines
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
int
|
||
ConfigureRouteTableUpdate(
|
||
IN const IN6_ADDR *Prefix,
|
||
IN u_int PrefixLen,
|
||
IN u_int Interface,
|
||
IN const IN6_ADDR *Neighbor,
|
||
IN int Publish,
|
||
IN int Immortal,
|
||
IN u_int ValidLifetime,
|
||
IN u_int PreferredLifetime,
|
||
IN u_int SitePrefixLen,
|
||
IN u_int Metric)
|
||
{
|
||
IPV6_INFO_ROUTE_TABLE Route;
|
||
SOCKADDR_IN6 saddr;
|
||
DWORD dwErr;
|
||
|
||
ZeroMemory(&saddr, sizeof(saddr));
|
||
saddr.sin6_family = AF_INET6;
|
||
saddr.sin6_addr = *Prefix;
|
||
|
||
Trace7(FSM, _T("Updating route %s/%d iface %d metric %d lifetime %d/%d publish %d"),
|
||
GetAddrStr((LPSOCKADDR)&saddr, sizeof(saddr)),
|
||
PrefixLen,
|
||
Interface,
|
||
Metric,
|
||
PreferredLifetime,
|
||
ValidLifetime,
|
||
Publish);
|
||
|
||
memset(&Route, 0, sizeof Route);
|
||
Route.This.Prefix = *Prefix;
|
||
Route.This.PrefixLength = PrefixLen;
|
||
Route.This.Neighbor.IF.Index = Interface;
|
||
Route.This.Neighbor.Address = *Neighbor;
|
||
Route.ValidLifetime = ValidLifetime;
|
||
Route.PreferredLifetime = PreferredLifetime;
|
||
Route.Publish = Publish;
|
||
Route.Immortal = Immortal;
|
||
Route.SitePrefixLength = SitePrefixLen;
|
||
Route.Preference = Metric;
|
||
Route.Type = RTE_TYPE_MANUAL;
|
||
|
||
dwErr = UpdateRouteTable(&Route)? NO_ERROR : GetLastError();
|
||
|
||
if (dwErr isnot NO_ERROR) {
|
||
Trace1(ERR, _T("UpdateRouteTable got error %d"), dwErr);
|
||
}
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
DWORD
|
||
InitializeGlobalInfo()
|
||
{
|
||
DWORD dwErr;
|
||
|
||
g_GlobalSettings.stEnableRouting = DEFAULT_ENABLE_ROUTING;
|
||
g_GlobalSettings.stEnableResolution = DEFAULT_ENABLE_RESOLUTION;
|
||
g_GlobalSettings.stEnableIsatapResolution = DEFAULT_ENABLE_ISATAP_RESOLUTION;
|
||
g_GlobalSettings.ulResolutionInterval = DEFAULT_RESOLUTION_INTERVAL;
|
||
g_GlobalSettings.ulIsatapResolutionInterval = DEFAULT_ISATAP_RESOLUTION_INTERVAL;
|
||
g_GlobalSettings.stEnableSiteLocals = DEFAULT_ENABLE_SITELOCALS;
|
||
g_GlobalSettings.stEnable6over4 = DEFAULT_ENABLE_6OVER4;
|
||
g_GlobalSettings.stEnableV4Compat = DEFAULT_ENABLE_V4COMPAT;
|
||
g_GlobalSettings.stUndoOnStop = DEFAULT_UNDO_ON_STOP;
|
||
wcscpy(g_GlobalSettings.pwszRelayName, DEFAULT_RELAY_NAME);
|
||
wcscpy(g_GlobalSettings.pwszIsatapRouterName, DEFAULT_ISATAP_ROUTER_NAME);
|
||
|
||
g_GlobalState.stResolutionState = DISABLED;
|
||
g_GlobalState.stIsatapResolutionState = DISABLED;
|
||
|
||
g_ipIsatapRouter.s_addr = INADDR_ANY;
|
||
g_ipIsatapToken.s_addr = INADDR_ANY;
|
||
|
||
g_sIPv4Socket = socket(AF_INET, SOCK_DGRAM, 0);
|
||
if (g_sIPv4Socket == INVALID_SOCKET) {
|
||
Trace0(ERR, _T("socket failed\n"));
|
||
return WSAGetLastError();
|
||
}
|
||
|
||
dwErr = MakeEmptyAddressList(&g_pPublicAddressList);
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
// Called by: Stop6to4
|
||
VOID
|
||
UninitializeGlobalInfo()
|
||
{
|
||
closesocket(g_sIPv4Socket);
|
||
g_sIPv4Socket = INVALID_SOCKET;
|
||
|
||
FreeAddressList(&g_pPublicAddressList);
|
||
}
|
||
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// IPv4 and IPv6 Address-related subroutines
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
typedef struct {
|
||
IPV4_SCOPE Scope;
|
||
DWORD Address;
|
||
DWORD Mask;
|
||
ULONG MaskLen;
|
||
} IPV4_SCOPE_PREFIX;
|
||
|
||
IPV4_SCOPE_PREFIX
|
||
Ipv4ScopePrefix[] = {
|
||
{ IPV4_SCOPE_NODE, 0x0100007f, 0xffffffff, 32 }, // 127.0.0.1/32
|
||
{ IPV4_SCOPE_LINK, 0x0000fea9, 0x0000ffff, 16 }, // 169.254/16
|
||
{ IPV4_SCOPE_SM_SITE, 0x0000a8c0, 0x0000ffff, 16 }, // 192.168/16
|
||
{ IPV4_SCOPE_MD_SITE, 0x000010ac, 0x0000f0ff, 12 }, // 172.16/12
|
||
{ IPV4_SCOPE_LG_SITE, 0x0000000a, 0x000000ff, 8 }, // 10/8
|
||
{ IPV4_SCOPE_GLOBAL, 0x00000000, 0x00000000, 0 }, // 0/0
|
||
};
|
||
|
||
IPV4_SCOPE
|
||
GetIPv4Scope(
|
||
IN DWORD Addr)
|
||
{
|
||
int i;
|
||
for (i=0; ; i++) {
|
||
if ((Addr & Ipv4ScopePrefix[i].Mask) == Ipv4ScopePrefix[i].Address) {
|
||
return Ipv4ScopePrefix[i].Scope;
|
||
}
|
||
}
|
||
}
|
||
|
||
DWORD
|
||
MakeAddressList(
|
||
IN PIP_ADDR_STRING pIpAddrList,
|
||
OUT ADDR_LIST **ppAddressList,
|
||
OUT PULONG pulGlobals,
|
||
IN OUT PULONG pulCumulNumScopedAddrs)
|
||
{
|
||
ULONG ulGlobals = 0, ulAddresses = 0;
|
||
INT iLength;
|
||
DWORD dwErr = NO_ERROR;
|
||
ADDR_LIST *pList = NULL;
|
||
PIP_ADDR_STRING pIpAddr;
|
||
SOCKADDR_IN *pSin;
|
||
IPV4_SCOPE scope;
|
||
|
||
// Count addresses
|
||
for (pIpAddr=pIpAddrList; pIpAddr; pIpAddr=pIpAddr->Next) {
|
||
ulAddresses++;
|
||
}
|
||
|
||
*ppAddressList = NULL;
|
||
*pulGlobals = 0;
|
||
|
||
pList = MALLOC( FIELD_OFFSET(ADDR_LIST, Address[ulAddresses] ));
|
||
if (pList == NULL) {
|
||
return GetLastError();
|
||
}
|
||
|
||
ulAddresses = 0;
|
||
for (pIpAddr=pIpAddrList; pIpAddr; pIpAddr=pIpAddr->Next) {
|
||
|
||
Trace1(FSM, _T("Adding address %hs"), pIpAddr->IpAddress.String);
|
||
|
||
iLength = sizeof(SOCKADDR_IN);
|
||
pSin = MALLOC( iLength );
|
||
if (pSin == NULL) {
|
||
continue;
|
||
}
|
||
|
||
dwErr = WSAStringToAddressA(pIpAddr->IpAddress.String,
|
||
AF_INET,
|
||
NULL,
|
||
(LPSOCKADDR)pSin,
|
||
&iLength);
|
||
if (dwErr == SOCKET_ERROR) {
|
||
FREE(pSin);
|
||
pSin = NULL;
|
||
continue;
|
||
}
|
||
|
||
//
|
||
// Don't allow 0.0.0.0 as an address. On an interface with no
|
||
// addresses, the IPv4 stack will report 1 address of 0.0.0.0.
|
||
//
|
||
if (pSin->sin_addr.s_addr == INADDR_ANY) {
|
||
FREE(pSin);
|
||
pSin = NULL;
|
||
continue;
|
||
}
|
||
|
||
if ((pSin->sin_addr.s_addr & 0x000000FF) == 0) {
|
||
//
|
||
// An address in 0/8 isn't a real IP address, it's a fake one that
|
||
// the IPv4 stack sticks on a receive-only adapter.
|
||
//
|
||
FREE(pSin);
|
||
pSin = NULL;
|
||
continue;
|
||
}
|
||
|
||
scope = GetIPv4Scope(pSin->sin_addr.s_addr);
|
||
pulCumulNumScopedAddrs[scope]++;
|
||
|
||
if (scope == IPV4_SCOPE_GLOBAL) {
|
||
ulGlobals++;
|
||
}
|
||
|
||
pList->Address[ulAddresses].iSockaddrLength = iLength;
|
||
pList->Address[ulAddresses].lpSockaddr = (LPSOCKADDR)pSin;
|
||
ulAddresses++;
|
||
}
|
||
|
||
pList->iAddressCount = ulAddresses;
|
||
*ppAddressList = pList;
|
||
*pulGlobals = ulGlobals;
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
//
|
||
// Create a 6to4 unicast address for this machine.
|
||
//
|
||
VOID
|
||
Make6to4Address(
|
||
OUT LPSOCKADDR_IN6 pIPv6Address,
|
||
IN LPSOCKADDR_IN pIPv4Address)
|
||
{
|
||
IN_ADDR *pIPv4 = &pIPv4Address->sin_addr;
|
||
|
||
memset(pIPv6Address, 0, sizeof (SOCKADDR_IN6));
|
||
pIPv6Address->sin6_family = AF_INET6;
|
||
|
||
pIPv6Address->sin6_addr.s6_addr[0] = 0x20;
|
||
pIPv6Address->sin6_addr.s6_addr[1] = 0x02;
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[2], pIPv4, sizeof(IN_ADDR));
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[12], pIPv4, sizeof(IN_ADDR));
|
||
}
|
||
|
||
VOID
|
||
Make6to4AddressForCTI(
|
||
OUT LPSOCKADDR_IN6 pIPv6Address,
|
||
IN LPSOCKADDR_IN pIPv4Address,
|
||
IN ULONG ulIfIndex)
|
||
{
|
||
IN_ADDR *pIPv4 = &pIPv4Address->sin_addr;
|
||
ULONG NetOrderIfIndex;
|
||
|
||
memset(pIPv6Address, 0, sizeof (SOCKADDR_IN6));
|
||
pIPv6Address->sin6_family = AF_INET6;
|
||
|
||
pIPv6Address->sin6_addr.s6_addr[0] = 0x20;
|
||
pIPv6Address->sin6_addr.s6_addr[1] = 0x02;
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[2], pIPv4, sizeof(IN_ADDR));
|
||
|
||
NetOrderIfIndex = htonl(ulIfIndex);
|
||
CopyMemory(&pIPv6Address->sin6_addr.s6_bytes[8],
|
||
&NetOrderIfIndex,
|
||
sizeof(NetOrderIfIndex));
|
||
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[12], pIPv4, sizeof(IN_ADDR));
|
||
}
|
||
|
||
//
|
||
// Create a 6to4 anycast address from a local IPv4 address.
|
||
//
|
||
VOID
|
||
Make6to4AnycastAddress(
|
||
OUT LPSOCKADDR_IN6 pIPv6Address,
|
||
IN LPSOCKADDR_IN pIPv4Address)
|
||
{
|
||
IN_ADDR *pIPv4 = &pIPv4Address->sin_addr;
|
||
|
||
memset(pIPv6Address, 0, sizeof(SOCKADDR_IN6));
|
||
pIPv6Address->sin6_family = AF_INET6;
|
||
pIPv6Address->sin6_addr.s6_addr[0] = 0x20;
|
||
pIPv6Address->sin6_addr.s6_addr[1] = 0x02;
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[2], pIPv4, sizeof(IN_ADDR));
|
||
}
|
||
|
||
//
|
||
// Create a v4-compatible address from an IPv4 address.
|
||
//
|
||
VOID
|
||
MakeV4CompatibleAddress(
|
||
OUT LPSOCKADDR_IN6 pIPv6Address,
|
||
IN LPSOCKADDR_IN pIPv4Address)
|
||
{
|
||
IN_ADDR *pIPv4 = &pIPv4Address->sin_addr;
|
||
|
||
memset(pIPv6Address, 0, sizeof(SOCKADDR_IN6));
|
||
pIPv6Address->sin6_family = AF_INET6;
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[12], pIPv4, sizeof(IN_ADDR));
|
||
}
|
||
|
||
//
|
||
// Create an ISATAP link-scoped address from an IPv4 address.
|
||
//
|
||
MakeIsatapAddress(
|
||
OUT LPSOCKADDR_IN6 pIPv6Address,
|
||
IN LPSOCKADDR_IN pIPv4Address)
|
||
{
|
||
IN_ADDR *pIPv4 = &pIPv4Address->sin_addr;
|
||
|
||
memset(pIPv6Address, 0, sizeof(SOCKADDR_IN6));
|
||
pIPv6Address->sin6_family = AF_INET6;
|
||
pIPv6Address->sin6_addr.s6_addr[0] = 0xfe;
|
||
pIPv6Address->sin6_addr.s6_addr[1] = 0x80;
|
||
pIPv6Address->sin6_addr.s6_addr[10] = 0x5e;
|
||
pIPv6Address->sin6_addr.s6_addr[11] = 0xfe;
|
||
memcpy(&pIPv6Address->sin6_addr.s6_addr[12], pIPv4, sizeof(IN_ADDR));
|
||
}
|
||
|
||
DWORD
|
||
ConfigureAddressUpdate(
|
||
IN u_int Interface,
|
||
IN SOCKADDR_IN6 *Sockaddr,
|
||
IN u_int Lifetime,
|
||
IN int Type,
|
||
IN u_int PrefixConf,
|
||
IN u_int SuffixConf)
|
||
{
|
||
IPV6_UPDATE_ADDRESS Address;
|
||
DWORD dwErr = NO_ERROR;
|
||
IN6_ADDR *Addr = &Sockaddr->sin6_addr;
|
||
|
||
Trace6(FSM,
|
||
_T("ConfigureAddressUpdate: if %u addr %s life %u type %d conf %u/%u"),
|
||
Interface,
|
||
GetAddrStr((LPSOCKADDR)Sockaddr, sizeof(SOCKADDR_IN6)),
|
||
Lifetime,
|
||
Type,
|
||
PrefixConf,
|
||
SuffixConf);
|
||
|
||
memset(&Address, 0, sizeof Address);
|
||
Address.This.IF.Index = Interface;
|
||
Address.This.Address = *Addr;
|
||
Address.ValidLifetime = Address.PreferredLifetime = Lifetime;
|
||
Address.Type = Type;
|
||
Address.PrefixConf = PrefixConf;
|
||
Address.InterfaceIdConf = SuffixConf;
|
||
|
||
if (!UpdateAddress(&Address)) {
|
||
dwErr = GetLastError();
|
||
Trace1(ERR, _T("ERROR: UpdateAddress got error %d"), dwErr);
|
||
}
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
void
|
||
Configure6to4Subnets(
|
||
IN ULONG ulIfIndex,
|
||
IN PSUBNET_CONTEXT pSubnet);
|
||
|
||
void
|
||
Unconfigure6to4Subnets(
|
||
IN ULONG ulIfIndex,
|
||
IN PSUBNET_CONTEXT pSubnet);
|
||
|
||
// Called by: OnChangeInterfaceInfo
|
||
DWORD
|
||
Add6to4Address(
|
||
IN LPSOCKADDR_IN pIPv4Address, // public address
|
||
IN PIF_LIST pInterfaceList, // interface list
|
||
IN STATE stOldRoutingState) // routing state
|
||
{
|
||
SOCKADDR_IN6 OurAddress;
|
||
DWORD dwErr;
|
||
ULONG i, ul6over4IfIndex;
|
||
PIF_INFO pIf;
|
||
SUBNET_CONTEXT Subnet;
|
||
|
||
Trace2(ENTER, _T("Add6to4Address %d.%d.%d.%d, isrouter=%d"),
|
||
PRINT_IPADDR(pIPv4Address->sin_addr.s_addr),
|
||
stOldRoutingState);
|
||
|
||
// Add 6over4 interface (if enabled)
|
||
if (g_GlobalSettings.stEnable6over4 == ENABLED) {
|
||
ul6over4IfIndex = Create6over4Interface(pIPv4Address->sin_addr);
|
||
} else {
|
||
ul6over4IfIndex = 0;
|
||
}
|
||
|
||
Trace1(ERR, _T("6over4 ifindex=%d"), ul6over4IfIndex);
|
||
|
||
// Put the IPv4 address on our "public" list
|
||
dwErr = AddAddressToList(pIPv4Address, &g_pPublicAddressList,
|
||
ul6over4IfIndex);
|
||
if (dwErr != NO_ERROR) {
|
||
return dwErr;
|
||
}
|
||
|
||
if (GetIPv4Scope(pIPv4Address->sin_addr.s_addr) == IPV4_SCOPE_GLOBAL) {
|
||
// Add a 6to4 address
|
||
Make6to4Address(&OurAddress, pIPv4Address);
|
||
dwErr = ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &OurAddress, INFINITE_LIFETIME,
|
||
ADE_UNICAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_LL_ADDRESS);
|
||
if (dwErr != NO_ERROR) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Add v4-compatible address (if enabled)
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
MakeV4CompatibleAddress(&OurAddress, pIPv4Address);
|
||
dwErr = ConfigureAddressUpdate(V4_COMPAT_IFINDEX, &OurAddress, INFINITE_LIFETIME,
|
||
ADE_UNICAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_LL_ADDRESS);
|
||
if (dwErr != NO_ERROR) {
|
||
return dwErr;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Add an ISATAP address
|
||
MakeIsatapAddress(&OurAddress, pIPv4Address);
|
||
dwErr = ConfigureAddressUpdate(V4_COMPAT_IFINDEX, &OurAddress, INFINITE_LIFETIME,
|
||
ADE_UNICAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_LL_ADDRESS);
|
||
if (dwErr != NO_ERROR) {
|
||
return dwErr;
|
||
}
|
||
|
||
// A new address has been added. The ISATAP router was previously either
|
||
// unresolved or unreachable. Perhaps that has now changed...
|
||
if ((g_GlobalState.stIsatapResolutionState == ENABLED) &&
|
||
(g_ipIsatapToken.s_addr == INADDR_ANY)) {
|
||
|
||
ASSERT(g_ipIsatapRouter.s_addr == INADDR_ANY);
|
||
Sleep(1000); // Wait a second to ensure DNS is alerted.
|
||
SetIsatapRouterAddress();
|
||
}
|
||
|
||
#if TEREDO
|
||
TeredoAddressChangeNotification(FALSE, pIPv4Address->sin_addr);
|
||
#endif // TEREDO
|
||
|
||
if (stOldRoutingState == ENABLED) {
|
||
SOCKADDR_IN6 AnycastAddress;
|
||
|
||
Make6to4AnycastAddress(&AnycastAddress, pIPv4Address);
|
||
|
||
dwErr = ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &AnycastAddress,
|
||
INFINITE_LIFETIME, ADE_ANYCAST,
|
||
PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_WELLKNOWN);
|
||
if (dwErr != NO_ERROR) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Add subnets to all routing interfaces
|
||
for (i=0; i<pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &pInterfaceList->arrIf[i];
|
||
if (pIf->stRoutingState != ENABLED) {
|
||
continue;
|
||
}
|
||
|
||
Subnet.V4Addr = pIPv4Address->sin_addr;
|
||
Subnet.Publish = TRUE;
|
||
Subnet.ValidLifetime = 2 * HOURS;
|
||
Subnet.PreferredLifetime = 30 * MINUTES;
|
||
Configure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
}
|
||
|
||
TraceLeave("Add6to4Address");
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
// Delete the 6to4 address from the global state, and prepare to
|
||
// delete it from the stack.
|
||
//
|
||
// Called by: UninitializeInterfaces
|
||
VOID
|
||
PreDelete6to4Address(
|
||
IN LPSOCKADDR_IN pIPv4Address,
|
||
IN PIF_LIST pInterfaceList,
|
||
IN STATE stOldRoutingState)
|
||
{
|
||
ULONG i;
|
||
SUBNET_CONTEXT Subnet;
|
||
PIF_INFO pIf;
|
||
|
||
Trace2(ENTER, _T("PreDelete6to4Address %d.%d.%d.%d, wasrouter=%d"),
|
||
PRINT_IPADDR(pIPv4Address->sin_addr.s_addr),
|
||
stOldRoutingState);
|
||
|
||
if (stOldRoutingState != ENABLED) {
|
||
return;
|
||
}
|
||
|
||
//
|
||
// Disable the subnet routes on each private interface.
|
||
// This will generate RAs that have a zero lifetime
|
||
// for the subnet prefixes.
|
||
//
|
||
Subnet.V4Addr = pIPv4Address->sin_addr;
|
||
Subnet.Publish = TRUE;
|
||
Subnet.ValidLifetime = Subnet.PreferredLifetime = 0;
|
||
|
||
for (i=0; i<pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &pInterfaceList->arrIf[i];
|
||
if (pIf->stRoutingState != ENABLED) {
|
||
continue;
|
||
}
|
||
|
||
Unconfigure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
|
||
TraceLeave("PreDelete6to4Address");
|
||
}
|
||
|
||
// Delete 6to4 address information from the stack.
|
||
//
|
||
// Called by: OnChangeInterfaceInfo, UninitializeInterfaces
|
||
VOID
|
||
Delete6to4Address(
|
||
IN LPSOCKADDR_IN pIPv4Address,
|
||
IN PIF_LIST pInterfaceList,
|
||
IN STATE stOldRoutingState)
|
||
{
|
||
SOCKADDR_IN6 OurAddress;
|
||
ULONG i;
|
||
PIF_INFO pIf;
|
||
SUBNET_CONTEXT Subnet;
|
||
DWORD dwErr;
|
||
|
||
Trace2(ENTER, _T("Delete6to4Address %d.%d.%d.%d wasrouter=%d"),
|
||
PRINT_IPADDR(pIPv4Address->sin_addr.s_addr),
|
||
stOldRoutingState);
|
||
|
||
Subnet.V4Addr = pIPv4Address->sin_addr;
|
||
Subnet.Publish = FALSE;
|
||
Subnet.ValidLifetime = Subnet.PreferredLifetime = 0;
|
||
|
||
if (GetIPv4Scope(pIPv4Address->sin_addr.s_addr) == IPV4_SCOPE_GLOBAL) {
|
||
// Delete the 6to4 address from the stack
|
||
Make6to4Address(&OurAddress, pIPv4Address);
|
||
ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &OurAddress, 0, ADE_UNICAST,
|
||
PREFIX_CONF_WELLKNOWN, IID_CONF_LL_ADDRESS);
|
||
|
||
// Delete the v4-compatible address from the stack (if enabled)
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
MakeV4CompatibleAddress(&OurAddress, pIPv4Address);
|
||
ConfigureAddressUpdate(V4_COMPAT_IFINDEX, &OurAddress, 0, ADE_UNICAST,
|
||
PREFIX_CONF_WELLKNOWN, IID_CONF_LL_ADDRESS);
|
||
}
|
||
}
|
||
|
||
// Delete the ISATAP address from the stack
|
||
MakeIsatapAddress(&OurAddress, pIPv4Address);
|
||
ConfigureAddressUpdate(V4_COMPAT_IFINDEX, &OurAddress, 0, ADE_UNICAST,
|
||
PREFIX_CONF_WELLKNOWN, IID_CONF_LL_ADDRESS);
|
||
|
||
// Re-resolve the ISATAP router address if the preferred source address
|
||
// (ISATAP token) has been deleted.
|
||
if ((g_GlobalState.stIsatapResolutionState == ENABLED) &&
|
||
(g_ipIsatapToken.s_addr == pIPv4Address->sin_addr.s_addr)) {
|
||
|
||
ASSERT(g_ipIsatapRouter.s_addr != INADDR_ANY);
|
||
Sleep(1000); // Wait a second to ensure DNS is alerted.
|
||
SetIsatapRouterAddress();
|
||
}
|
||
|
||
#if TEREDO
|
||
TeredoAddressChangeNotification(TRUE, pIPv4Address->sin_addr);
|
||
#endif // TEREDO
|
||
|
||
if (stOldRoutingState == ENABLED) {
|
||
SOCKADDR_IN6 AnycastAddress;
|
||
|
||
Make6to4AnycastAddress(&AnycastAddress, pIPv4Address);
|
||
|
||
ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &AnycastAddress, 0,
|
||
ADE_ANYCAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_WELLKNOWN);
|
||
|
||
// Remove subnets from all routing interfaces
|
||
for (i=0; i<pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &pInterfaceList->arrIf[i];
|
||
if (pIf->stRoutingState != ENABLED) {
|
||
continue;
|
||
}
|
||
|
||
Unconfigure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
}
|
||
|
||
//
|
||
// We're now completely done with the IPv4 address, so
|
||
// remove it from the public address list.
|
||
//
|
||
dwErr = FindAddressInList(pIPv4Address, g_pPublicAddressList, &i);
|
||
if (dwErr == NO_ERROR) {
|
||
// Delete 6over4 interface (if enabled)
|
||
if (g_GlobalSettings.stEnable6over4 == ENABLED) {
|
||
DeleteInterface(g_pPublicAddressList->Address[i].ul6over4IfIndex);
|
||
}
|
||
|
||
RemoveAddressFromList(i, g_pPublicAddressList);
|
||
}
|
||
|
||
TraceLeave("Delete6to4Address");
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// Relay-related subroutines
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
//
|
||
// Given a relay, make sure a default route to it exists with the right metric
|
||
//
|
||
VOID
|
||
AddOrUpdate6to4Relay(
|
||
IN PRELAY_INFO pRelay)
|
||
{
|
||
Trace1(ENTER, _T("AddOrUpdate6to4Relay %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pRelay->sinAddress.sin_addr.s_addr));
|
||
|
||
//
|
||
// Create the default route.
|
||
//
|
||
ConfigureRouteTableUpdate(&in6addr_any, 0,
|
||
SIX_TO_FOUR_IFINDEX,
|
||
&pRelay->sin6Address.sin6_addr,
|
||
TRUE, // Publish.
|
||
TRUE, // Immortal.
|
||
2 * HOURS, // Valid lifetime.
|
||
30 * MINUTES, // Preferred lifetime.
|
||
0,
|
||
pRelay->ulMetric);
|
||
}
|
||
|
||
VOID
|
||
FreeRelayList(
|
||
IN PRELAY_LIST *ppList)
|
||
{
|
||
if (*ppList) {
|
||
FREE(*ppList);
|
||
*ppList = NULL;
|
||
}
|
||
}
|
||
|
||
DWORD
|
||
InitializeRelays()
|
||
{
|
||
g_pRelayList = NULL;
|
||
|
||
g_hTimerQueue = CreateTimerQueue();
|
||
if (g_hTimerQueue == INVALID_HANDLE_VALUE) {
|
||
return GetLastError();
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
VOID
|
||
IncEventCount(
|
||
IN PCHAR pszWhere)
|
||
{
|
||
ULONG ulCount = InterlockedIncrement(&g_ulEventCount);
|
||
Trace2(FSM, _T("++%u event count (%hs)"), ulCount, pszWhere);
|
||
}
|
||
|
||
VOID
|
||
DecEventCount(
|
||
IN PCHAR pszWhere)
|
||
{
|
||
ULONG ulCount = InterlockedDecrement(&g_ulEventCount);
|
||
Trace2(FSM, _T("--%u event count (%hs)"), ulCount, pszWhere);
|
||
|
||
if ((ulCount == 0) && (g_stService == DISABLED)) {
|
||
Set6to4ServiceStatus(SERVICE_STOPPED, NO_ERROR);
|
||
}
|
||
}
|
||
|
||
// This routine is invoked when a resolution timer has been cancelled
|
||
// and all outstanding timer routines have completed. It is responsible
|
||
// for releasing the event count for the periodic timer.
|
||
//
|
||
VOID CALLBACK
|
||
OnResolutionTimerCancelled(
|
||
IN PVOID lpParameter,
|
||
IN BOOLEAN TimerOrWaitFired)
|
||
{
|
||
TraceEnter("OnResolutionTimerCancelled");
|
||
|
||
DecEventCount("RT:CancelResolutionTimer");
|
||
|
||
TraceLeave("OnResolutionTimerCancelled");
|
||
}
|
||
|
||
DWORD
|
||
InitEvents()
|
||
{
|
||
ASSERT(g_h6to4TimerCancelledEvent == NULL);
|
||
g_h6to4TimerCancelledEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
if (g_h6to4TimerCancelledEvent == NULL)
|
||
return GetLastError();
|
||
|
||
//
|
||
// Schedule OnResolutionTimerCancelled() to be called whenever
|
||
// g_h6to4TimerCancelledEvent is signalled.
|
||
//
|
||
if (! RegisterWaitForSingleObject(&g_h6to4TimerCancelledWait,
|
||
g_h6to4TimerCancelledEvent,
|
||
OnResolutionTimerCancelled,
|
||
NULL,
|
||
INFINITE,
|
||
WT_EXECUTEDEFAULT)) {
|
||
return GetLastError();
|
||
}
|
||
|
||
ASSERT(g_hIsatapTimerCancelledEvent == NULL);
|
||
g_hIsatapTimerCancelledEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
|
||
if (g_hIsatapTimerCancelledEvent == NULL)
|
||
return GetLastError();
|
||
|
||
//
|
||
// Schedule OnResolutionTimerCancelled() to be called whenever
|
||
// g_hIsatapTimerCancelledEvent is signalled.
|
||
//
|
||
if (! RegisterWaitForSingleObject(&g_hIsatapTimerCancelledWait,
|
||
g_hIsatapTimerCancelledEvent,
|
||
OnResolutionTimerCancelled,
|
||
NULL,
|
||
INFINITE,
|
||
WT_EXECUTEDEFAULT)) {
|
||
return GetLastError();
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
VOID
|
||
Cleanup6to4()
|
||
{
|
||
if (g_h6to4TimerCancelledWait != NULL) {
|
||
UnregisterWait(g_h6to4TimerCancelledWait);
|
||
g_h6to4TimerCancelledWait = NULL;
|
||
}
|
||
|
||
if (g_h6to4TimerCancelledEvent != NULL) {
|
||
CloseHandle(g_h6to4TimerCancelledEvent);
|
||
g_h6to4TimerCancelledEvent = NULL;
|
||
}
|
||
|
||
if (g_hIsatapTimerCancelledWait != NULL) {
|
||
UnregisterWait(g_hIsatapTimerCancelledWait);
|
||
g_hIsatapTimerCancelledWait = NULL;
|
||
}
|
||
|
||
if (g_hIsatapTimerCancelledEvent != NULL) {
|
||
CloseHandle(g_hIsatapTimerCancelledEvent);
|
||
g_hIsatapTimerCancelledEvent = NULL;
|
||
}
|
||
}
|
||
|
||
VOID
|
||
CancelResolutionTimer(
|
||
IN OUT HANDLE *phResolutionTimer,
|
||
IN HANDLE hEvent)
|
||
{
|
||
Trace0(FSM, _T("Cancelling RT"));
|
||
|
||
// Stop the resolution timer
|
||
if (*phResolutionTimer != INVALID_HANDLE_VALUE) {
|
||
|
||
// Must be done non-blocking since we're holding the lock
|
||
// the resolution timeout needs. Ask for notification
|
||
// when the cancel completes so we can release the event count.
|
||
DeleteTimerQueueTimer(g_hTimerQueue, *phResolutionTimer, hEvent);
|
||
|
||
*phResolutionTimer = INVALID_HANDLE_VALUE;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Delete all stack state related to a given relay
|
||
//
|
||
void
|
||
Delete6to4Relay(
|
||
IN PRELAY_INFO pRelay)
|
||
{
|
||
Trace1(ENTER, _T("Delete6to4Relay %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pRelay->sinAddress.sin_addr.s_addr));
|
||
|
||
ConfigureRouteTableUpdate(&in6addr_any, 0,
|
||
SIX_TO_FOUR_IFINDEX,
|
||
&pRelay->sin6Address.sin6_addr,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, // Valid lifetime.
|
||
0, // Preferred lifetime.
|
||
0,
|
||
pRelay->ulMetric);
|
||
}
|
||
|
||
VOID
|
||
UninitializeRelays()
|
||
{
|
||
ULONG i;
|
||
|
||
TraceEnter("UninitializeRelays");
|
||
|
||
CancelResolutionTimer(&g_hIsatapResolutionTimer,
|
||
g_hIsatapTimerCancelledEvent);
|
||
CancelResolutionTimer(&g_h6to4ResolutionTimer,
|
||
g_h6to4TimerCancelledEvent);
|
||
|
||
// Delete the timer queue
|
||
if (g_hTimerQueue != INVALID_HANDLE_VALUE) {
|
||
DeleteTimerQueue(g_hTimerQueue);
|
||
g_hTimerQueue = INVALID_HANDLE_VALUE;
|
||
}
|
||
|
||
if (g_GlobalSettings.stUndoOnStop == ENABLED) {
|
||
// Delete existing relay tunnels
|
||
for (i=0; g_pRelayList && (i<g_pRelayList->ulNumRelays); i++) {
|
||
Delete6to4Relay(&g_pRelayList->arrRelay[i]);
|
||
}
|
||
}
|
||
|
||
// Free the "old list"
|
||
FreeRelayList(&g_pRelayList);
|
||
|
||
TraceLeave("UninitializeRelays");
|
||
}
|
||
|
||
//
|
||
// Start or update the resolution timer to expire in <ulMinutes> minutes
|
||
//
|
||
DWORD
|
||
RestartResolutionTimer(
|
||
IN ULONG ulDelayMinutes,
|
||
IN ULONG ulPeriodMinutes,
|
||
IN HANDLE *phResolutionTimer,
|
||
IN WAITORTIMERCALLBACK OnTimeout)
|
||
{
|
||
ULONG DelayTime = ulDelayMinutes * MINUTES * 1000; // convert mins to ms
|
||
ULONG PeriodTime = ulPeriodMinutes * MINUTES * 1000; // convert mins to ms
|
||
BOOL bRet;
|
||
DWORD dwErr;
|
||
|
||
if (*phResolutionTimer != INVALID_HANDLE_VALUE) {
|
||
bRet = ChangeTimerQueueTimer(g_hTimerQueue, *phResolutionTimer,
|
||
DelayTime, PeriodTime);
|
||
} else {
|
||
bRet = CreateTimerQueueTimer(phResolutionTimer,
|
||
g_hTimerQueue,
|
||
OnTimeout,
|
||
NULL,
|
||
DelayTime,
|
||
PeriodTime,
|
||
0);
|
||
if (bRet) {
|
||
IncEventCount("RT:RestartResolutionTimer");
|
||
}
|
||
}
|
||
|
||
dwErr = (bRet)? NO_ERROR : GetLastError();
|
||
|
||
Trace3(TIMER,
|
||
_T("RestartResolutionTimer: DueTime %d minutes, Period %d minutes, ReturnCode %d"),
|
||
ulDelayMinutes, ulPeriodMinutes, dwErr);
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
//
|
||
// Convert an addrinfo list into a relay list with appropriate metrics
|
||
//
|
||
DWORD
|
||
MakeRelayList(
|
||
IN struct addrinfo *addrs)
|
||
{
|
||
struct addrinfo *ai;
|
||
ULONG ulNumRelays = 0;
|
||
ULONG ulLatency;
|
||
|
||
for (ai=addrs; ai; ai=ai->ai_next) {
|
||
ulNumRelays++;
|
||
}
|
||
|
||
g_pRelayList = MALLOC( FIELD_OFFSET(RELAY_LIST, arrRelay[ulNumRelays]));
|
||
if (g_pRelayList == NULL) {
|
||
return GetLastError();
|
||
}
|
||
|
||
g_pRelayList->ulNumRelays = ulNumRelays;
|
||
|
||
ulNumRelays = 0;
|
||
for (ai=addrs; ai; ai=ai->ai_next) {
|
||
CopyMemory(&g_pRelayList->arrRelay[ulNumRelays].sinAddress, ai->ai_addr,
|
||
ai->ai_addrlen);
|
||
|
||
//
|
||
// Check connectivity using a possible 6to4 address for the relay
|
||
// router. However, we'll actually set TTL=1 and accept a
|
||
// hop count exceeded message, so we don't have to guess right.
|
||
//
|
||
Make6to4Address(&g_pRelayList->arrRelay[ulNumRelays].sin6Address,
|
||
&g_pRelayList->arrRelay[ulNumRelays].sinAddress);
|
||
|
||
// ping it to compute a metric
|
||
ulLatency = ConfirmIPv6Reachability(&g_pRelayList->arrRelay[ulNumRelays].sin6Address, 1000/*ms*/);
|
||
if (ulLatency != 0) {
|
||
g_pRelayList->arrRelay[ulNumRelays].ulMetric = 1000 + ulLatency;
|
||
} else {
|
||
g_pRelayList->arrRelay[ulNumRelays].ulMetric = UNREACHABLE;
|
||
}
|
||
|
||
ulNumRelays++;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
//
|
||
// When the name-resolution timer expires, it's time to re-resolve the
|
||
// relay name to a list of relays.
|
||
//
|
||
DWORD
|
||
WINAPI
|
||
OnResolutionTimeout(
|
||
IN PVOID lpData,
|
||
IN BOOLEAN Reason)
|
||
{
|
||
DWORD dwErr = NO_ERROR;
|
||
struct addrinfo hints, *addrs;
|
||
PRELAY_LIST pOldRelayList;
|
||
ULONG i, j;
|
||
|
||
ENTER_API();
|
||
TraceEnter("OnResolutionTimeout");
|
||
|
||
if (g_stService == DISABLED) {
|
||
TraceLeave("OnResolutionTimeout (disabled)");
|
||
LEAVE_API();
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
pOldRelayList = g_pRelayList;
|
||
g_pRelayList = NULL;
|
||
|
||
// If any 6to4 addresses are configured,
|
||
// Resolve the relay name to a set of IPv4 addresses
|
||
// Else
|
||
// Make the new set empty
|
||
if (g_GlobalState.stResolutionState == ENABLED) {
|
||
// Resolve the relay name to a set of IPv4 addresses
|
||
ZeroMemory(&hints, sizeof(hints));
|
||
hints.ai_family = PF_INET;
|
||
dwErr = GetAddrInfoW(g_GlobalSettings.pwszRelayName, NULL, &hints, &addrs);
|
||
|
||
if (dwErr == NO_ERROR) {
|
||
dwErr = MakeRelayList(addrs);
|
||
freeaddrinfo(addrs);
|
||
addrs = NULL;
|
||
} else {
|
||
Trace2(ERR, _T("GetAddrInfoW(%s) returned error %d"),
|
||
g_GlobalSettings.pwszRelayName, dwErr);
|
||
}
|
||
}
|
||
|
||
// Compare the new set to the old set
|
||
// For each address in the new set, ping it to compute a metric
|
||
// For each new address, add a route
|
||
// For each old address not in the new list, delete the route
|
||
// For each address in both, update the route if the metric has changed
|
||
//
|
||
for (i=0; g_pRelayList && (i<g_pRelayList->ulNumRelays); i++) {
|
||
for (j=0; pOldRelayList && (j<pOldRelayList->ulNumRelays); j++) {
|
||
if (g_pRelayList->arrRelay[i].sinAddress.sin_addr.s_addr
|
||
== pOldRelayList->arrRelay[j].sinAddress.sin_addr.s_addr) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (pOldRelayList && (j<pOldRelayList->ulNumRelays)) {
|
||
// update the route if the metric has changed
|
||
if (g_pRelayList->arrRelay[i].ulMetric
|
||
!= pOldRelayList->arrRelay[j].ulMetric) {
|
||
AddOrUpdate6to4Relay(&g_pRelayList->arrRelay[i]);
|
||
}
|
||
|
||
g_pRelayList->arrRelay[i].sin6Address = pOldRelayList->arrRelay[j].sin6Address;
|
||
} else {
|
||
// add a relay
|
||
AddOrUpdate6to4Relay(&g_pRelayList->arrRelay[i]);
|
||
}
|
||
}
|
||
for (j=0; pOldRelayList && (j<pOldRelayList->ulNumRelays); j++) {
|
||
for (i=0; g_pRelayList && (i<g_pRelayList->ulNumRelays); i++) {
|
||
if (g_pRelayList->arrRelay[i].sinAddress.sin_addr.s_addr ==
|
||
pOldRelayList->arrRelay[j].sinAddress.sin_addr.s_addr) {
|
||
break;
|
||
}
|
||
}
|
||
if (!g_pRelayList || (i == g_pRelayList->ulNumRelays)) {
|
||
// delete a relay
|
||
Delete6to4Relay(&pOldRelayList->arrRelay[j]);
|
||
}
|
||
}
|
||
|
||
FreeRelayList(&pOldRelayList);
|
||
|
||
TraceLeave("OnResolutionTimeout");
|
||
LEAVE_API();
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
BOOL
|
||
WINAPI
|
||
GetPreferredSource(
|
||
IN IN_ADDR ipDestination,
|
||
OUT PIN_ADDR pipSource)
|
||
{
|
||
SOCKADDR_IN sinDestination, sinSource;
|
||
DWORD BytesReturned;
|
||
|
||
if (ipDestination.s_addr == htonl(INADDR_LOOPBACK)) {
|
||
// This is what we would get back from the routing interface query!
|
||
*pipSource = ipDestination;
|
||
return TRUE;
|
||
}
|
||
|
||
memset(&sinDestination, 0, sizeof(SOCKADDR_IN));
|
||
sinDestination.sin_family = AF_INET;
|
||
sinDestination.sin_addr = ipDestination;
|
||
|
||
if (WSAIoctl(g_sIPv4Socket, SIO_ROUTING_INTERFACE_QUERY,
|
||
&sinDestination, sizeof(SOCKADDR_IN),
|
||
&sinSource, sizeof(SOCKADDR_IN),
|
||
&BytesReturned, NULL, NULL) == SOCKET_ERROR) {
|
||
Trace1(ERR, _T("ioctl error %d"), WSAGetLastError());
|
||
return FALSE;
|
||
}
|
||
|
||
*pipSource = sinSource.sin_addr;
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
VOID
|
||
WINAPI
|
||
SetIsatapRouterAddress()
|
||
{
|
||
DWORD dwErr = NO_ERROR;
|
||
struct addrinfo hints, *addrs;
|
||
IN_ADDR ipNewRouter, ipNewToken;
|
||
|
||
// Default to INADDR_ANY.
|
||
ipNewRouter.s_addr = INADDR_ANY;
|
||
ipNewToken.s_addr = INADDR_ANY;
|
||
|
||
// Reset the ISATAP router address if the service is shutting down
|
||
// or if the ISATAP resolution has been disabled.
|
||
if ((g_stService == ENABLED) &&
|
||
(g_GlobalState.stIsatapResolutionState == ENABLED)) {
|
||
// Resolve the isatap name to an IPv4 address (IsatapRouter).
|
||
ZeroMemory(&hints, sizeof(hints));
|
||
hints.ai_family = PF_INET;
|
||
dwErr = GetAddrInfoW(g_GlobalSettings.pwszIsatapRouterName, NULL,
|
||
&hints, &addrs);
|
||
if (dwErr == NO_ERROR) {
|
||
ipNewRouter = ((LPSOCKADDR_IN)addrs->ai_addr)->sin_addr;
|
||
freeaddrinfo(addrs);
|
||
addrs = NULL;
|
||
|
||
// Determine the preferred source address (IsatapToken).
|
||
if (!GetPreferredSource(ipNewRouter, &ipNewToken)) {
|
||
// What use is the IsatapRouter that cannot be reached?
|
||
ipNewRouter.s_addr = INADDR_ANY;
|
||
}
|
||
} else {
|
||
Trace2(ERR, _T("GetAddrInfoW(%s) returned error %d"),
|
||
g_GlobalSettings.pwszIsatapRouterName, dwErr);
|
||
}
|
||
}
|
||
|
||
// Compare the new addresses to the old addresses
|
||
// and if they are different, update the stack
|
||
if ((ipNewRouter.s_addr != g_ipIsatapRouter.s_addr) ||
|
||
(ipNewToken.s_addr != g_ipIsatapToken.s_addr)) {
|
||
g_ipIsatapRouter = ipNewRouter;
|
||
g_ipIsatapToken = ipNewToken;
|
||
UpdateRouterLinkAddress(V4_COMPAT_IFINDEX, ipNewToken, ipNewRouter);
|
||
}
|
||
}
|
||
|
||
|
||
DWORD
|
||
WINAPI
|
||
OnIsatapResolutionTimeout(
|
||
IN PVOID lpData,
|
||
IN BOOLEAN Reason)
|
||
{
|
||
ENTER_API();
|
||
TraceEnter("OnIsatapResolutionTimeout");
|
||
|
||
if (g_stService == DISABLED) {
|
||
TraceLeave("OnIsatapResolutionTimeout (disabled)");
|
||
LEAVE_API();
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
SetIsatapRouterAddress();
|
||
|
||
TraceLeave("OnIsatapResolutionTimeout");
|
||
LEAVE_API();
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// Routing-related subroutines
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
PIF_SETTINGS
|
||
FindInterfaceSettings(
|
||
IN WCHAR *pwszAdapterName,
|
||
IN IF_SETTINGS_LIST *pList);
|
||
|
||
//
|
||
// Decide whether routing will be enabled at all
|
||
//
|
||
STATE
|
||
GetGlobalRoutingState(
|
||
IN IF_LIST *pIfList)
|
||
{
|
||
DWORD dwErr;
|
||
GUID guid;
|
||
|
||
// If routing is explicitly enabled or disabled, use that
|
||
if (g_GlobalSettings.stEnableRouting != AUTOMATIC) {
|
||
return g_GlobalSettings.stEnableRouting;
|
||
}
|
||
|
||
// Disable routing if there is no private interface used by ICS
|
||
dwErr = RasQuerySharedPrivateLan(&guid);
|
||
if (dwErr != NO_ERROR) {
|
||
return DISABLED;
|
||
}
|
||
|
||
// Disable routing if there are no global IPv4 addresses
|
||
if (!pIfList || !pIfList->ulNumScopedAddrs[IPV4_SCOPE_GLOBAL]) {
|
||
return DISABLED;
|
||
}
|
||
|
||
return ENABLED;
|
||
}
|
||
|
||
//
|
||
// Decide whether a given interface is one we should treat as
|
||
// a private link to be a router on.
|
||
//
|
||
// Called by: UpdateInterfaceRoutingState, MakeInterfaceList
|
||
STATE
|
||
GetInterfaceRoutingState(
|
||
IN PIF_INFO pIf) // potential private interface
|
||
{
|
||
PIF_SETTINGS pIfSettings;
|
||
STATE stEnableRouting = AUTOMATIC;
|
||
DWORD dwErr;
|
||
GUID guid;
|
||
UNICODE_STRING usGuid;
|
||
WCHAR buffer[MAX_INTERFACE_NAME_LEN];
|
||
|
||
if (g_GlobalSettings.stEnableRouting == DISABLED) {
|
||
stEnableRouting = g_GlobalSettings.stEnableRouting;
|
||
} else {
|
||
pIfSettings = FindInterfaceSettings(pIf->pwszAdapterName,
|
||
g_pInterfaceSettingsList);
|
||
if (pIfSettings) {
|
||
stEnableRouting = pIfSettings->stEnableRouting;
|
||
}
|
||
}
|
||
|
||
if (stEnableRouting != AUTOMATIC) {
|
||
return stEnableRouting;
|
||
}
|
||
|
||
//
|
||
// Enable routing if this is the private interface used by ICS
|
||
//
|
||
dwErr = RasQuerySharedPrivateLan(&guid);
|
||
if (dwErr != NO_ERROR) {
|
||
// no private interface
|
||
return DISABLED;
|
||
}
|
||
|
||
usGuid.Buffer = buffer;
|
||
usGuid.MaximumLength = MAX_INTERFACE_NAME_LEN;
|
||
dwErr = RtlStringFromGUID(&guid, &usGuid);
|
||
if (dwErr != NO_ERROR) {
|
||
// no private interface
|
||
return DISABLED;
|
||
}
|
||
|
||
Trace1(ERR, _T("ICS private interface: %ls"), usGuid.Buffer);
|
||
|
||
//
|
||
// Compare guid to pIf->pwszAdapterName
|
||
//
|
||
// This must be done using a case-insensitive comparison since
|
||
// GetAdaptersInfo() returns GUID strings with upper-case letters
|
||
// while RtlGetStringFromGUID uses lower-case letters.
|
||
//
|
||
if (!_wcsicmp(pIf->pwszAdapterName, usGuid.Buffer)) {
|
||
return ENABLED;
|
||
}
|
||
|
||
return DISABLED;
|
||
}
|
||
|
||
// Called by: Configure6to4Subnets, Unconfigure6to4Subnets
|
||
VOID
|
||
Create6to4Prefixes(
|
||
OUT IN6_ADDR *pSubnetPrefix,
|
||
OUT IN6_ADDR *pSiteLocalPrefix,
|
||
IN IN_ADDR *ipOurAddr, // public address
|
||
IN ULONG ulIfIndex) // private interface
|
||
{
|
||
//
|
||
// Create a subnet prefix for the interface,
|
||
// using the interface index as the subnet number.
|
||
//
|
||
memset(pSubnetPrefix, 0, sizeof(IN6_ADDR));
|
||
pSubnetPrefix->s6_addr[0] = 0x20;
|
||
pSubnetPrefix->s6_addr[1] = 0x02;
|
||
memcpy(&pSubnetPrefix->s6_addr[2], ipOurAddr, sizeof(IN_ADDR));
|
||
pSubnetPrefix->s6_addr[6] = HIBYTE(ulIfIndex);
|
||
pSubnetPrefix->s6_addr[7] = LOBYTE(ulIfIndex);
|
||
|
||
//
|
||
// Create a site-local prefix for the interface,
|
||
// using the interface index as the subnet number.
|
||
//
|
||
memset(pSiteLocalPrefix, 0, sizeof(IN6_ADDR));
|
||
pSiteLocalPrefix->s6_addr[0] = 0xfe;
|
||
pSiteLocalPrefix->s6_addr[1] = 0xc0;
|
||
pSiteLocalPrefix->s6_addr[6] = HIBYTE(ulIfIndex);
|
||
pSiteLocalPrefix->s6_addr[7] = LOBYTE(ulIfIndex);
|
||
}
|
||
|
||
// Called by: EnableInterfaceRouting, Add6to4Address
|
||
void
|
||
Configure6to4Subnets(
|
||
IN ULONG ulIfIndex, // private interface
|
||
IN PSUBNET_CONTEXT pSubnet) // subnet info, incl. public address
|
||
{
|
||
IN6_ADDR SubnetPrefix;
|
||
IN6_ADDR SiteLocalPrefix;
|
||
|
||
Create6to4Prefixes(&SubnetPrefix, &SiteLocalPrefix, &pSubnet->V4Addr,
|
||
ulIfIndex);
|
||
|
||
//
|
||
// Configure the subnet route.
|
||
//
|
||
ConfigureRouteTableUpdate(&SubnetPrefix, 64,
|
||
ulIfIndex, &in6addr_any,
|
||
pSubnet->Publish,
|
||
pSubnet->Publish,
|
||
pSubnet->ValidLifetime,
|
||
pSubnet->PreferredLifetime,
|
||
((g_GlobalSettings.stEnableSiteLocals == ENABLED) ? 48 : 0),
|
||
SUBNET_ROUTE_METRIC);
|
||
|
||
if (g_GlobalSettings.stEnableSiteLocals == ENABLED) {
|
||
ConfigureRouteTableUpdate(&SiteLocalPrefix, 64,
|
||
ulIfIndex, &in6addr_any,
|
||
pSubnet->Publish,
|
||
pSubnet->Publish,
|
||
pSubnet->ValidLifetime,
|
||
pSubnet->PreferredLifetime,
|
||
0,
|
||
SITELOCAL_ROUTE_METRIC);
|
||
}
|
||
}
|
||
|
||
// Called by: DisableInterfaceRouting, Delete6to4Address
|
||
void
|
||
Unconfigure6to4Subnets(
|
||
IN ULONG ulIfIndex, // private interface
|
||
IN PSUBNET_CONTEXT pSubnet) // subnet info, inc. public address
|
||
{
|
||
IN6_ADDR SubnetPrefix;
|
||
IN6_ADDR SiteLocalPrefix;
|
||
|
||
Create6to4Prefixes(&SubnetPrefix, &SiteLocalPrefix, &pSubnet->V4Addr,
|
||
ulIfIndex);
|
||
|
||
//
|
||
// Give the 6to4 route a zero lifetime, making it invalid.
|
||
// If we are a router, continue to publish the 6to4 route
|
||
// until we have disabled routing. This will allow
|
||
// the last Router Advertisements to go out with the prefix.
|
||
//
|
||
ConfigureRouteTableUpdate(&SubnetPrefix, 64,
|
||
ulIfIndex, &in6addr_any,
|
||
pSubnet->Publish, // Publish.
|
||
pSubnet->Publish, // Immortal.
|
||
pSubnet->ValidLifetime,
|
||
pSubnet->PreferredLifetime,
|
||
0, 0);
|
||
|
||
if (g_GlobalSettings.stEnableSiteLocals == ENABLED) {
|
||
ConfigureRouteTableUpdate(&SiteLocalPrefix, 64,
|
||
ulIfIndex, &in6addr_any,
|
||
pSubnet->Publish, // Publish.
|
||
pSubnet->Publish, // Immortal.
|
||
pSubnet->ValidLifetime,
|
||
pSubnet->PreferredLifetime,
|
||
0, 0);
|
||
}
|
||
}
|
||
|
||
#define PUBLIC_ZONE_ID 1
|
||
#define PRIVATE_ZONE_ID 2
|
||
|
||
// Called by: EnableRouting, DisableRouting, EnableInterfaceRouting,
|
||
// DisableInterfaceRouting
|
||
DWORD
|
||
ConfigureInterfaceUpdate(
|
||
IN u_int Interface,
|
||
IN int Advertises,
|
||
IN int Forwards)
|
||
{
|
||
IPV6_INFO_INTERFACE Update;
|
||
DWORD Result;
|
||
|
||
IPV6_INIT_INFO_INTERFACE(&Update);
|
||
|
||
Update.This.Index = Interface;
|
||
Update.Advertises = Advertises;
|
||
Update.Forwards = Forwards;
|
||
|
||
if (Advertises == TRUE) {
|
||
Update.ZoneIndices[ADE_SITE_LOCAL] = PRIVATE_ZONE_ID;
|
||
Update.ZoneIndices[ADE_ADMIN_LOCAL] = PRIVATE_ZONE_ID;
|
||
Update.ZoneIndices[ADE_SUBNET_LOCAL] = PRIVATE_ZONE_ID;
|
||
} else if (Advertises == FALSE) {
|
||
Update.ZoneIndices[ADE_SITE_LOCAL] = PUBLIC_ZONE_ID;
|
||
Update.ZoneIndices[ADE_ADMIN_LOCAL] = PUBLIC_ZONE_ID;
|
||
Update.ZoneIndices[ADE_SUBNET_LOCAL] = PUBLIC_ZONE_ID;
|
||
}
|
||
|
||
Result = UpdateInterface(&Update);
|
||
|
||
Trace4(ERR, _T("UpdateInterface if=%d adv=%d fwd=%d result=%d"),
|
||
Interface, Advertises, Forwards, Result);
|
||
|
||
return Result;
|
||
}
|
||
|
||
// Called by: UpdateGlobalRoutingState
|
||
VOID
|
||
EnableRouting()
|
||
{
|
||
SOCKADDR_IN6 AnycastAddress;
|
||
int i;
|
||
LPSOCKADDR_IN pOurAddr;
|
||
|
||
TraceEnter("EnableRouting");
|
||
|
||
//
|
||
// Enable forwarding on the tunnel pseudo-interfaces.
|
||
//
|
||
ConfigureInterfaceUpdate(SIX_TO_FOUR_IFINDEX, -1, TRUE);
|
||
ConfigureInterfaceUpdate(V4_COMPAT_IFINDEX, -1, TRUE);
|
||
|
||
//
|
||
// Add anycast addresses for all 6to4 addresses
|
||
//
|
||
for (i=0; i<g_pPublicAddressList->iAddressCount; i++) {
|
||
pOurAddr = (LPSOCKADDR_IN)g_pPublicAddressList->Address[i].lpSockaddr;
|
||
|
||
Make6to4AnycastAddress(&AnycastAddress, pOurAddr);
|
||
|
||
ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &AnycastAddress, INFINITE_LIFETIME,
|
||
ADE_ANYCAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_WELLKNOWN);
|
||
}
|
||
|
||
g_GlobalState.stRoutingState = ENABLED;
|
||
|
||
TraceLeave("EnableRouting");
|
||
}
|
||
|
||
// Called by: UpdateGlobalRoutingState
|
||
VOID
|
||
DisableRouting()
|
||
{
|
||
SOCKADDR_IN6 AnycastAddress;
|
||
int i;
|
||
LPSOCKADDR_IN pOurAddr;
|
||
DWORD dwErr;
|
||
|
||
TraceEnter("DisableRouting");
|
||
|
||
//
|
||
// Disable forwarding on the tunnel pseudo-interfaces.
|
||
//
|
||
ConfigureInterfaceUpdate(SIX_TO_FOUR_IFINDEX, -1, FALSE);
|
||
ConfigureInterfaceUpdate(V4_COMPAT_IFINDEX, -1, FALSE);
|
||
|
||
//
|
||
// Remove anycast addresses for all 6to4 addresses
|
||
//
|
||
for (i=0; i<g_pPublicAddressList->iAddressCount; i++) {
|
||
pOurAddr = (LPSOCKADDR_IN)g_pPublicAddressList->Address[i].lpSockaddr;
|
||
|
||
Make6to4AnycastAddress(&AnycastAddress, pOurAddr);
|
||
|
||
dwErr = ConfigureAddressUpdate(SIX_TO_FOUR_IFINDEX, &AnycastAddress, 0,
|
||
ADE_ANYCAST, PREFIX_CONF_WELLKNOWN,
|
||
IID_CONF_WELLKNOWN);
|
||
}
|
||
|
||
g_GlobalState.stRoutingState = DISABLED;
|
||
|
||
TraceLeave("DisableRouting");
|
||
}
|
||
|
||
|
||
// Called by: UpdateInterfaceRoutingState
|
||
VOID
|
||
EnableInterfaceRouting(
|
||
IN PIF_INFO pIf, // private interface
|
||
IN PADDR_LIST pPublicAddressList) // public address list
|
||
{
|
||
int i;
|
||
LPSOCKADDR_IN pOurAddr;
|
||
SUBNET_CONTEXT Subnet;
|
||
|
||
Trace2(ERR, _T("Enabling routing on interface %d: %ls"),
|
||
pIf->ulIPv6IfIndex, pIf->pwszAdapterName);
|
||
|
||
ConfigureInterfaceUpdate(pIf->ulIPv6IfIndex, TRUE, TRUE);
|
||
|
||
// For each public address
|
||
for (i=0; i<pPublicAddressList->iAddressCount; i++) {
|
||
pOurAddr = (LPSOCKADDR_IN)pPublicAddressList->Address[i].lpSockaddr;
|
||
|
||
Subnet.V4Addr = pOurAddr->sin_addr;
|
||
Subnet.Publish = TRUE;
|
||
Subnet.ValidLifetime = 2 * DAYS;
|
||
Subnet.PreferredLifetime = 30 * MINUTES;
|
||
Configure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
|
||
pIf->stRoutingState = ENABLED;
|
||
}
|
||
|
||
// Called by: PreUpdateInterfaceRoutingState, UninitializeInterfaces
|
||
BOOL
|
||
PreDisableInterfaceRouting(
|
||
IN PIF_INFO pIf, // private interface
|
||
IN PADDR_LIST pPublicAddressList)
|
||
{
|
||
int i;
|
||
LPSOCKADDR_IN pOurAddr;
|
||
SUBNET_CONTEXT Subnet;
|
||
|
||
Trace1(ERR, _T("Pre-Disabling routing on interface %d"),
|
||
pIf->ulIPv6IfIndex);
|
||
|
||
//
|
||
// For each public address, publish RA saying we're going away
|
||
//
|
||
for (i=0; i<pPublicAddressList->iAddressCount; i++) {
|
||
pOurAddr = (LPSOCKADDR_IN)pPublicAddressList->Address[i].lpSockaddr;
|
||
Subnet.V4Addr = pOurAddr->sin_addr;
|
||
Subnet.Publish = TRUE;
|
||
Subnet.ValidLifetime = Subnet.PreferredLifetime = 0;
|
||
Unconfigure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
|
||
return (pPublicAddressList->iAddressCount > 0);
|
||
}
|
||
|
||
// Called by: UpdateInterfaceRoutingState, UninitializeInterfaces
|
||
VOID
|
||
DisableInterfaceRouting(
|
||
IN PIF_INFO pIf, // private interface
|
||
IN PADDR_LIST pPublicAddressList)
|
||
{
|
||
int i;
|
||
LPSOCKADDR_IN pOurAddr;
|
||
SUBNET_CONTEXT Subnet;
|
||
|
||
Trace1(ERR, _T("Disabling routing on interface %d"), pIf->ulIPv6IfIndex);
|
||
|
||
ConfigureInterfaceUpdate(pIf->ulIPv6IfIndex, FALSE, FALSE);
|
||
|
||
//
|
||
// For each public address, unconfigure 6to4 subnets
|
||
//
|
||
for (i=0; i<pPublicAddressList->iAddressCount; i++) {
|
||
pOurAddr = (LPSOCKADDR_IN)pPublicAddressList->Address[i].lpSockaddr;
|
||
Subnet.V4Addr = pOurAddr->sin_addr;
|
||
Subnet.Publish = FALSE;
|
||
Subnet.ValidLifetime = Subnet.PreferredLifetime = 0;
|
||
Unconfigure6to4Subnets(pIf->ulIPv6IfIndex, &Subnet);
|
||
}
|
||
|
||
pIf->stRoutingState = DISABLED;
|
||
}
|
||
|
||
BOOL // TRUE if need to sleep
|
||
PreUpdateInterfaceRoutingState(
|
||
IN PIF_INFO pIf, // private interface
|
||
IN PADDR_LIST pPublicAddressList)
|
||
{
|
||
STATE stIfRoutingState = GetInterfaceRoutingState(pIf);
|
||
|
||
if (pIf->stRoutingState == stIfRoutingState) {
|
||
return FALSE;
|
||
}
|
||
|
||
if (!(stIfRoutingState == ENABLED)) {
|
||
return PreDisableInterfaceRouting(pIf, pPublicAddressList);
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Update the current state of an interface (i.e. whether or not it's a
|
||
// private interface on which we're serving as a router) according to
|
||
// configuration and whether IPv4 global addresses exist on the interface.
|
||
//
|
||
// Called by: UpdateGlobalRoutingState, OnConfigChange
|
||
VOID
|
||
UpdateInterfaceRoutingState(
|
||
IN PIF_INFO pIf, // private interface
|
||
IN PADDR_LIST pPublicAddressList)
|
||
{
|
||
STATE stIfRoutingState = GetInterfaceRoutingState(pIf);
|
||
|
||
if (pIf->stRoutingState == stIfRoutingState) {
|
||
return;
|
||
}
|
||
|
||
if (stIfRoutingState == ENABLED) {
|
||
EnableInterfaceRouting(pIf, pPublicAddressList);
|
||
} else {
|
||
DisableInterfaceRouting(pIf, pPublicAddressList);
|
||
}
|
||
}
|
||
|
||
BOOL
|
||
PreUpdateGlobalRoutingState()
|
||
{
|
||
ULONG i;
|
||
PIF_LIST pList = g_pInterfaceList;
|
||
BOOL bWait = FALSE;
|
||
|
||
if (pList == NULL) {
|
||
return FALSE;
|
||
}
|
||
|
||
for (i=0; i<pList->ulNumInterfaces; i++) {
|
||
bWait |= PreUpdateInterfaceRoutingState(&pList->arrIf[i],
|
||
g_pPublicAddressList);
|
||
}
|
||
|
||
return bWait;
|
||
}
|
||
|
||
// Called by: OnConfigChange, OnChangeInterfaceInfo
|
||
VOID
|
||
UpdateGlobalRoutingState()
|
||
{
|
||
ULONG i;
|
||
PIF_LIST pList = g_pInterfaceList;
|
||
STATE stNewRoutingState;
|
||
|
||
stNewRoutingState = GetGlobalRoutingState(pList);
|
||
|
||
if (g_GlobalState.stRoutingState != stNewRoutingState) {
|
||
if (stNewRoutingState == ENABLED) {
|
||
EnableRouting();
|
||
} else {
|
||
DisableRouting();
|
||
}
|
||
}
|
||
|
||
if (pList == NULL) {
|
||
return;
|
||
}
|
||
|
||
for (i=0; i<pList->ulNumInterfaces; i++) {
|
||
UpdateInterfaceRoutingState(&pList->arrIf[i], g_pPublicAddressList);
|
||
}
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// Interface-related subroutines
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
PIF_SETTINGS
|
||
FindInterfaceSettings(
|
||
IN WCHAR *pwszAdapterName,
|
||
IN IF_SETTINGS_LIST *pList)
|
||
{
|
||
ULONG i;
|
||
PIF_SETTINGS pIf;
|
||
|
||
if (pList == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
for (i=0; i<pList->ulNumInterfaces; i++) {
|
||
pIf = &pList->arrIf[i];
|
||
if (wcscmp(pIf->pwszAdapterName, pwszAdapterName)) {
|
||
return pIf;
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
PIF_INFO
|
||
FindInterfaceInfo(
|
||
IN WCHAR *pwszAdapterName,
|
||
IN IF_LIST *pList)
|
||
{
|
||
ULONG i;
|
||
PIF_INFO pIf;
|
||
|
||
if (pList == NULL) {
|
||
return NULL;
|
||
}
|
||
|
||
for (i=0; i<pList->ulNumInterfaces; i++) {
|
||
pIf = &pList->arrIf[i];
|
||
if (!wcscmp(pIf->pwszAdapterName, pwszAdapterName)) {
|
||
return pIf;
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
DWORD NTAPI
|
||
OnChangeInterfaceInfo(
|
||
IN PVOID Context,
|
||
IN BOOLEAN TimedOut
|
||
);
|
||
|
||
VOID
|
||
StopAddressChangeNotification()
|
||
{
|
||
if (g_hAddressChangeWaitHandle) {
|
||
//
|
||
// Block until we're sure that the address change callback isn't
|
||
// still running.
|
||
//
|
||
LEAVE_API();
|
||
UnregisterWaitEx(g_hAddressChangeWaitHandle, INVALID_HANDLE_VALUE);
|
||
ENTER_API();
|
||
|
||
//
|
||
// Release the event we counted for RegisterWaitForSingleObject
|
||
//
|
||
DecEventCount("AC:StopIpv4AddressChangeNotification");
|
||
g_hAddressChangeWaitHandle = NULL;
|
||
}
|
||
if (g_hAddressChangeEvent) {
|
||
CloseHandle(g_hAddressChangeEvent);
|
||
g_hAddressChangeEvent = NULL;
|
||
}
|
||
}
|
||
|
||
VOID
|
||
StartAddressChangeNotification()
|
||
{
|
||
ULONG Error;
|
||
BOOL bOk;
|
||
HANDLE TcpipHandle;
|
||
|
||
TraceEnter("StartAddressChangeNotification");
|
||
|
||
//
|
||
// Create an event on which to receive notifications
|
||
// and register a callback routine to be invoked if the event is signalled.
|
||
// Then request notification of address changes on the event.
|
||
//
|
||
|
||
if (!g_hAddressChangeEvent) {
|
||
g_hAddressChangeEvent = CreateEvent(NULL,
|
||
FALSE,
|
||
FALSE,
|
||
NULL);
|
||
if (g_hAddressChangeEvent == NULL) {
|
||
goto Error;
|
||
}
|
||
|
||
//
|
||
// Count the following register as an event.
|
||
//
|
||
IncEventCount("AC:StartIpv4AddressChangeNotification");
|
||
|
||
bOk = RegisterWaitForSingleObject(&g_hAddressChangeWaitHandle,
|
||
g_hAddressChangeEvent,
|
||
OnChangeInterfaceInfo,
|
||
NULL,
|
||
INFINITE,
|
||
0);
|
||
if (!bOk) {
|
||
DecEventCount("AC:StartIpv4AddressChangeNotification");
|
||
goto Error;
|
||
}
|
||
}
|
||
|
||
ZeroMemory(&g_hAddressChangeOverlapped, sizeof(OVERLAPPED));
|
||
g_hAddressChangeOverlapped.hEvent = g_hAddressChangeEvent;
|
||
|
||
Error = NotifyAddrChange(&TcpipHandle, &g_hAddressChangeOverlapped);
|
||
if (Error != ERROR_IO_PENDING) {
|
||
goto Error;
|
||
}
|
||
|
||
return;
|
||
|
||
Error:
|
||
|
||
//
|
||
// A failure has occurred, so cleanup and quit.
|
||
// We proceed in this case without notification of address changes.
|
||
//
|
||
|
||
StopAddressChangeNotification();
|
||
|
||
TraceLeave("StartAddressChangeNotification");
|
||
}
|
||
|
||
//
|
||
// Convert an "adapter" list to an "interface" list and store the result in
|
||
// the global g_pInterfaceList.
|
||
//
|
||
DWORD
|
||
MakeInterfaceList(
|
||
IN PIP_ADAPTER_INFO pAdapterInfo)
|
||
{
|
||
DWORD dwErr = NO_ERROR;
|
||
ULONG ulNumInterfaces = 0, ulSize;
|
||
PIP_ADAPTER_INFO pAdapter;
|
||
PIF_INFO pIf;
|
||
IPV6_INFO_INTERFACE *pIfStackInfo;
|
||
|
||
// count adapters
|
||
for (pAdapter=pAdapterInfo; pAdapter; pAdapter=pAdapter->Next) {
|
||
ulNumInterfaces++;
|
||
}
|
||
|
||
// allocate enough space
|
||
ulSize = FIELD_OFFSET(IF_LIST, arrIf[ulNumInterfaces]);
|
||
g_pInterfaceList = MALLOC(ulSize);
|
||
if (g_pInterfaceList == NULL) {
|
||
return GetLastError();
|
||
}
|
||
|
||
// fill in list
|
||
g_pInterfaceList->ulNumInterfaces = ulNumInterfaces;
|
||
ZeroMemory(g_pInterfaceList->ulNumScopedAddrs,
|
||
sizeof(ULONG) * NUM_IPV4_SCOPES);
|
||
ulNumInterfaces = 0;
|
||
for (pAdapter=pAdapterInfo; pAdapter; pAdapter=pAdapter->Next) {
|
||
pIf = &g_pInterfaceList->arrIf[ulNumInterfaces];
|
||
|
||
ConvertOemToUnicode(pAdapter->AdapterName, pIf->pwszAdapterName,
|
||
MAX_ADAPTER_NAME);
|
||
|
||
Trace1(FSM, _T("Adding interface %ls"), pIf->pwszAdapterName);
|
||
|
||
dwErr = MakeAddressList(&pAdapter->IpAddressList,
|
||
&pIf->pAddressList, &pIf->ulNumGlobals,
|
||
g_pInterfaceList->ulNumScopedAddrs);
|
||
|
||
pIfStackInfo = GetInterfaceStackInfo(pIf->pwszAdapterName);
|
||
if (pIfStackInfo) {
|
||
pIf->ulIPv6IfIndex = pIfStackInfo->This.Index;
|
||
} else {
|
||
pIf->ulIPv6IfIndex = 0;
|
||
}
|
||
FREE(pIfStackInfo);
|
||
|
||
pIf->stRoutingState = DISABLED;
|
||
|
||
ulNumInterfaces++;
|
||
}
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
VOID
|
||
FreeInterfaceList(
|
||
IN OUT PIF_LIST *ppList)
|
||
{
|
||
ULONG i;
|
||
|
||
if (*ppList == NULL) {
|
||
return;
|
||
}
|
||
|
||
for (i=0; i<(*ppList)->ulNumInterfaces; i++) {
|
||
FreeAddressList( &(*ppList)->arrIf[i].pAddressList );
|
||
}
|
||
|
||
FREE(*ppList);
|
||
*ppList = NULL;
|
||
}
|
||
|
||
DWORD
|
||
InitializeInterfaces()
|
||
{
|
||
g_pInterfaceList = NULL;
|
||
return NO_ERROR;
|
||
}
|
||
|
||
VOID
|
||
ProcessInterfaceStateChange(
|
||
IN ADDR_LIST CONST *pAddressList,
|
||
IN ADDR_LIST *pOldAddressList,
|
||
IN PIF_LIST pOldInterfaceList,
|
||
IN GLOBAL_STATE *pOldState,
|
||
IN OUT BOOL *pbNeedDelete)
|
||
{
|
||
INT j,k;
|
||
LPSOCKADDR_IN pAddr;
|
||
|
||
// For each new global address not in old list,
|
||
// add a 6to4 address
|
||
for (j=0; j<pAddressList->iAddressCount; j++) {
|
||
pAddr = (LPSOCKADDR_IN)pAddressList->Address[j].lpSockaddr;
|
||
|
||
Trace1(FSM, _T("Checking for new address %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddr->sin_addr.s_addr));
|
||
|
||
// See if address is in old list
|
||
for (k=0; k<pOldAddressList->iAddressCount; k++) {
|
||
if (pAddr->sin_addr.s_addr == ((LPSOCKADDR_IN)pOldAddressList->Address[k].lpSockaddr)->sin_addr.s_addr) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// If so, continue
|
||
if (k<pOldAddressList->iAddressCount) {
|
||
continue;
|
||
}
|
||
|
||
// Add a 6to4 address, and use it for routing if enabled
|
||
Add6to4Address(pAddr, g_pInterfaceList,
|
||
g_GlobalState.stRoutingState);
|
||
}
|
||
|
||
// For each old global address not in the new list,
|
||
// delete a 6to4 address
|
||
for (k=0; k<pOldAddressList->iAddressCount; k++) {
|
||
pAddr = (LPSOCKADDR_IN)pOldAddressList->Address[k].lpSockaddr;
|
||
|
||
Trace1(FSM, _T("Checking for old address %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddr->sin_addr.s_addr));
|
||
|
||
// See if address is in new list
|
||
for (j=0; j<pAddressList->iAddressCount; j++) {
|
||
if (((LPSOCKADDR_IN)pAddressList->Address[j].lpSockaddr)->sin_addr.s_addr
|
||
== pAddr->sin_addr.s_addr) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// If so, continue
|
||
if (j<pAddressList->iAddressCount) {
|
||
continue;
|
||
}
|
||
|
||
// Prepare to delete the 6to4 address
|
||
PreDelete6to4Address(pAddr, pOldInterfaceList,
|
||
pOldState->stRoutingState);
|
||
*pbNeedDelete = TRUE;
|
||
}
|
||
}
|
||
|
||
VOID
|
||
FinishInterfaceStateChange(
|
||
IN ADDR_LIST CONST *pAddressList,
|
||
IN ADDR_LIST *pOldAddressList,
|
||
IN PIF_LIST pOldInterfaceList,
|
||
IN GLOBAL_STATE *pOldState)
|
||
{
|
||
INT j,k;
|
||
LPSOCKADDR_IN pAddr;
|
||
|
||
// For each old global address not in the new list,
|
||
// delete a 6to4 address
|
||
for (k=0; k<pOldAddressList->iAddressCount; k++) {
|
||
pAddr = (LPSOCKADDR_IN)pOldAddressList->Address[k].lpSockaddr;
|
||
|
||
Trace1(FSM, _T("Checking for old address %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddr->sin_addr.s_addr));
|
||
|
||
// See if address is in new list
|
||
for (j=0; j<pAddressList->iAddressCount; j++) {
|
||
if (((LPSOCKADDR_IN)pAddressList->Address[j].lpSockaddr)->sin_addr.s_addr
|
||
== pAddr->sin_addr.s_addr) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// If so, continue
|
||
if (j<pAddressList->iAddressCount) {
|
||
continue;
|
||
}
|
||
|
||
// Prepare to delete the 6to4 address
|
||
Delete6to4Address(pAddr, pOldInterfaceList,
|
||
pOldState->stRoutingState);
|
||
}
|
||
}
|
||
|
||
// This routine is invoked when a change to the set of local IPv4 addressed
|
||
// is signalled. It is responsible for updating the bindings of the
|
||
// private and public interfaces, and re-requesting change notification.
|
||
//
|
||
DWORD NTAPI
|
||
OnChangeInterfaceInfo(
|
||
IN PVOID Context,
|
||
IN BOOLEAN TimedOut)
|
||
{
|
||
PIF_INFO pIf, pOldIf;
|
||
ULONG i, ulSize = 0;
|
||
PIP_ADAPTER_INFO pAdapterInfo = NULL;
|
||
PIF_LIST pOldInterfaceList;
|
||
DWORD dwErr = NO_ERROR;
|
||
STATE stOld6to4State, stNew6to4State;
|
||
ADDR_LIST *pAddressList, *pOldAddressList;
|
||
GLOBAL_SETTINGS OldSettings;
|
||
GLOBAL_STATE OldState;
|
||
BOOL bNeedDelete = FALSE, bWait = FALSE;
|
||
|
||
ENTER_API();
|
||
TraceEnter("OnChangeInterfaceInfo");
|
||
|
||
if (g_stService == DISABLED) {
|
||
Trace0(FSM, L"Service disabled");
|
||
goto Done;
|
||
}
|
||
|
||
OldSettings = g_GlobalSettings; // struct copy
|
||
OldState = g_GlobalState; // struct copy
|
||
|
||
//
|
||
// Get the new set of IPv4 addresses on interfaces
|
||
//
|
||
|
||
for (;;) {
|
||
dwErr = GetAdaptersInfo(pAdapterInfo, &ulSize);
|
||
if (dwErr == ERROR_SUCCESS) {
|
||
break;
|
||
}
|
||
if (dwErr == ERROR_NO_DATA) {
|
||
dwErr = ERROR_SUCCESS;
|
||
break;
|
||
}
|
||
|
||
if (pAdapterInfo) {
|
||
FREE(pAdapterInfo);
|
||
pAdapterInfo = NULL;
|
||
}
|
||
|
||
if (dwErr != ERROR_BUFFER_OVERFLOW) {
|
||
dwErr = GetLastError();
|
||
goto Retry;
|
||
}
|
||
|
||
pAdapterInfo = MALLOC(ulSize);
|
||
if (pAdapterInfo == NULL) {
|
||
dwErr = GetLastError();
|
||
goto Retry;
|
||
}
|
||
}
|
||
|
||
pOldInterfaceList = g_pInterfaceList;
|
||
g_pInterfaceList = NULL;
|
||
|
||
MakeInterfaceList(pAdapterInfo);
|
||
if (pAdapterInfo) {
|
||
FREE(pAdapterInfo);
|
||
pAdapterInfo = NULL;
|
||
}
|
||
|
||
//
|
||
// First update global address list
|
||
//
|
||
|
||
// For each interface in the new list...
|
||
for (i=0; i<g_pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &g_pInterfaceList->arrIf[i];
|
||
|
||
pAddressList = pIf->pAddressList;
|
||
|
||
pOldIf = FindInterfaceInfo(pIf->pwszAdapterName,
|
||
pOldInterfaceList);
|
||
|
||
pOldAddressList = (pOldIf)? pOldIf->pAddressList : &EmptyAddressList;
|
||
|
||
if (pOldIf) {
|
||
pIf->stRoutingState = pOldIf->stRoutingState;
|
||
}
|
||
|
||
ProcessInterfaceStateChange(pAddressList, pOldAddressList,
|
||
pOldInterfaceList, &OldState, &bNeedDelete);
|
||
}
|
||
|
||
// For each old interface not in the new list,
|
||
// delete information.
|
||
for (i=0; pOldInterfaceList && (i<pOldInterfaceList->ulNumInterfaces); i++){
|
||
pOldIf = &pOldInterfaceList->arrIf[i];
|
||
pOldAddressList = pOldIf->pAddressList;
|
||
pIf = FindInterfaceInfo(pOldIf->pwszAdapterName, g_pInterfaceList);
|
||
if (pIf) {
|
||
continue;
|
||
}
|
||
ProcessInterfaceStateChange(&EmptyAddressList, pOldAddressList,
|
||
pOldInterfaceList, &OldState, &bNeedDelete);
|
||
}
|
||
|
||
Trace2(FSM, _T("num globals=%d num publics=%d"),
|
||
g_pInterfaceList->ulNumScopedAddrs[IPV4_SCOPE_GLOBAL],
|
||
g_pPublicAddressList->iAddressCount);
|
||
|
||
//
|
||
// Create a route for the 6to4 prefix.
|
||
// This route causes packets sent to 6to4 addresses
|
||
// to be encapsulated and sent to the extracted v4 address.
|
||
//
|
||
|
||
stNew6to4State = (g_pInterfaceList->ulNumScopedAddrs[IPV4_SCOPE_GLOBAL] > 0)? ENABLED : DISABLED;
|
||
stOld6to4State = g_st6to4State;
|
||
|
||
if (stOld6to4State != stNew6to4State) {
|
||
if (stNew6to4State == DISABLED) {
|
||
//
|
||
// Give the 6to4 route a zero lifetime, making it invalid.
|
||
// If we are a router, continue to publish the 6to4 route
|
||
// until we have disabled routing. This will allow
|
||
// the last Router Advertisements to go out with the prefix.
|
||
//
|
||
ConfigureRouteTableUpdate(&SixToFourPrefix, 16,
|
||
SIX_TO_FOUR_IFINDEX, &in6addr_any,
|
||
(OldState.stRoutingState == ENABLED),
|
||
(OldState.stRoutingState == ENABLED),
|
||
0, 0, 0, 0);
|
||
|
||
//
|
||
// Do the same for the v4-compatible address route (if enabled).
|
||
//
|
||
if (OldSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
(OldState.stRoutingState == ENABLED),
|
||
(OldState.stRoutingState == ENABLED),
|
||
0, 0, 0, 0);
|
||
}
|
||
} else {
|
||
//
|
||
// Configure the 6to4 route.
|
||
//
|
||
ConfigureRouteTableUpdate(&SixToFourPrefix, 16,
|
||
SIX_TO_FOUR_IFINDEX, &in6addr_any,
|
||
TRUE, // Publish.
|
||
TRUE, // Immortal.
|
||
2 * HOURS, // Valid lifetime.
|
||
30 * MINUTES, // Preferred lifetime.
|
||
0,
|
||
SIXTOFOUR_METRIC);
|
||
|
||
//
|
||
// Configure the v4-compatible address route (if enabled).
|
||
//
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
TRUE, // Publish.
|
||
TRUE, // Immortal.
|
||
2 * HOURS, // Valid lifetime.
|
||
30 * MINUTES, // Preferred lifetime.
|
||
0,
|
||
SIXTOFOUR_METRIC);
|
||
}
|
||
}
|
||
g_st6to4State = stNew6to4State;
|
||
|
||
dwErr = UpdateGlobalResolutionState(&OldSettings, &OldState);
|
||
}
|
||
|
||
bWait |= PreUpdateGlobalRoutingState();
|
||
|
||
//
|
||
// If needed, wait a bit to ensure that Router Advertisements
|
||
// carrying the zero lifetime prefixes get sent.
|
||
//
|
||
if (bWait || (bNeedDelete && (OldState.stRoutingState == ENABLED))) {
|
||
Sleep(2000);
|
||
}
|
||
|
||
UpdateGlobalRoutingState();
|
||
|
||
//
|
||
// Now finish removing the 6to4 addresses.
|
||
//
|
||
if (bNeedDelete) {
|
||
for (i=0; i<g_pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &g_pInterfaceList->arrIf[i];
|
||
|
||
pAddressList = pIf->pAddressList;
|
||
|
||
pOldIf = FindInterfaceInfo(pIf->pwszAdapterName,
|
||
pOldInterfaceList);
|
||
|
||
pOldAddressList = (pOldIf)? pOldIf->pAddressList : &EmptyAddressList;
|
||
|
||
FinishInterfaceStateChange(pAddressList, pOldAddressList,
|
||
pOldInterfaceList, &OldState);
|
||
|
||
}
|
||
for (i=0; pOldInterfaceList && (i<pOldInterfaceList->ulNumInterfaces); i++){
|
||
pOldIf = &pOldInterfaceList->arrIf[i];
|
||
pOldAddressList = pOldIf->pAddressList;
|
||
pIf = FindInterfaceInfo(pOldIf->pwszAdapterName, g_pInterfaceList);
|
||
if (pIf) {
|
||
continue;
|
||
}
|
||
FinishInterfaceStateChange(&EmptyAddressList, pOldAddressList,
|
||
pOldInterfaceList, &OldState);
|
||
}
|
||
}
|
||
|
||
if ((stOld6to4State != stNew6to4State) && (stNew6to4State == DISABLED)) {
|
||
//
|
||
// Finish removing the 6to4 route.
|
||
//
|
||
ConfigureRouteTableUpdate(&SixToFourPrefix, 16,
|
||
SIX_TO_FOUR_IFINDEX, &in6addr_any,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, 0, 0, 0);
|
||
|
||
//
|
||
// Finish removing the v4-compatible address route (if enabled).
|
||
//
|
||
if (OldSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, 0, 0, 0);
|
||
}
|
||
}
|
||
|
||
FreeInterfaceList(&pOldInterfaceList);
|
||
|
||
Retry:
|
||
// Listen for the next address change
|
||
StartAddressChangeNotification();
|
||
|
||
Done:
|
||
TraceLeave("OnChangeInterfaceInfo");
|
||
LEAVE_API();
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
// Note that this function can take over 2 seconds to complete if we're a
|
||
// router. (This is by design).
|
||
//
|
||
// Called by: Stop6to4
|
||
VOID
|
||
UninitializeInterfaces()
|
||
{
|
||
PIF_INFO pIf;
|
||
ULONG i;
|
||
int k;
|
||
ADDR_LIST *pAddressList;
|
||
LPSOCKADDR_IN pAddr;
|
||
|
||
TraceEnter("UninitializeInterfaces");
|
||
|
||
// Cancel the address change notification
|
||
StopIpv6AddressChangeNotification();
|
||
StopAddressChangeNotification();
|
||
|
||
// Since this is the first function called when stopping,
|
||
// the "old" global state/settings is in g_GlobalState/Settings.
|
||
|
||
if (g_GlobalSettings.stUndoOnStop == ENABLED) {
|
||
|
||
if (g_GlobalState.stRoutingState == ENABLED) {
|
||
//
|
||
// First announce we're going away
|
||
//
|
||
|
||
//
|
||
// Give the 6to4 route a zero lifetime, making it invalid.
|
||
// If we are a router, continue to publish the 6to4 route
|
||
// until we have disabled routing. This will allow
|
||
// the last Router Advertisements to go out with the prefix.
|
||
//
|
||
ConfigureRouteTableUpdate(&SixToFourPrefix, 16,
|
||
SIX_TO_FOUR_IFINDEX, &in6addr_any,
|
||
TRUE, // Publish
|
||
TRUE, // Immortal
|
||
0, 0, 0, 0);
|
||
|
||
//
|
||
// Do the same for the v4-compatible address route (if enabled).
|
||
//
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
TRUE, // Publish
|
||
TRUE, // Immortal
|
||
0, 0, 0, 0);
|
||
}
|
||
|
||
//
|
||
// Now do the same for subnets we're advertising
|
||
//
|
||
for (i=0; i<g_pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &g_pInterfaceList->arrIf[i];
|
||
|
||
pAddressList = pIf->pAddressList;
|
||
|
||
// For each old global address not in the new list,
|
||
// delete a 6to4 address (see below)
|
||
Trace1(FSM, _T("Checking %d old addresses"),
|
||
pAddressList->iAddressCount);
|
||
for (k=0; k<pAddressList->iAddressCount; k++) {
|
||
pAddr = (LPSOCKADDR_IN)pAddressList->Address[k].lpSockaddr;
|
||
|
||
Trace1(FSM, _T("Checking for old address %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddr->sin_addr.s_addr));
|
||
|
||
PreDelete6to4Address(pAddr, g_pInterfaceList,
|
||
g_GlobalState.stRoutingState);
|
||
}
|
||
|
||
if (pIf->stRoutingState == ENABLED) {
|
||
PreDisableInterfaceRouting(pIf, g_pPublicAddressList);
|
||
}
|
||
}
|
||
|
||
//
|
||
// Wait a bit to ensure that Router Advertisements
|
||
// carrying the zero lifetime prefixes get sent.
|
||
//
|
||
Sleep(2000);
|
||
}
|
||
|
||
//
|
||
// Delete the 6to4 and v4-compatible (if enabled) routes.
|
||
//
|
||
ConfigureRouteTableUpdate(&SixToFourPrefix, 16,
|
||
SIX_TO_FOUR_IFINDEX, &in6addr_any,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, 0, 0, 0);
|
||
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, 0, 0, 0);
|
||
}
|
||
|
||
g_st6to4State = DISABLED;
|
||
|
||
//
|
||
// Delete 6to4 addresses
|
||
//
|
||
for (i=0; g_pInterfaceList && i<g_pInterfaceList->ulNumInterfaces; i++) {
|
||
pIf = &g_pInterfaceList->arrIf[i];
|
||
|
||
pAddressList = pIf->pAddressList;
|
||
|
||
// For each old global address not in the new list,
|
||
// delete a 6to4 address (see below)
|
||
Trace1(FSM, _T("Checking %d old addresses"),
|
||
pAddressList->iAddressCount);
|
||
for (k=0; k<pAddressList->iAddressCount; k++) {
|
||
pAddr = (LPSOCKADDR_IN)pAddressList->Address[k].lpSockaddr;
|
||
|
||
Trace1(FSM, _T("Checking for old address %d.%d.%d.%d"),
|
||
PRINT_IPADDR(pAddr->sin_addr.s_addr));
|
||
|
||
Delete6to4Address(pAddr, g_pInterfaceList,
|
||
g_GlobalState.stRoutingState);
|
||
}
|
||
|
||
// update the IPv6 routing state
|
||
if (pIf->stRoutingState == ENABLED) {
|
||
DisableInterfaceRouting(pIf, g_pPublicAddressList);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Free the "old list"
|
||
FreeInterfaceList(&g_pInterfaceList);
|
||
|
||
TraceLeave("UninitializeInterfaces");
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// Event-processing functions
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
// Get an integer value from the registry
|
||
ULONG
|
||
GetInteger(
|
||
IN HKEY hKey,
|
||
IN LPCTSTR lpName,
|
||
IN ULONG ulDefault)
|
||
{
|
||
DWORD dwErr, dwType;
|
||
ULONG ulSize, ulValue;
|
||
|
||
ulSize = sizeof(ulValue);
|
||
dwErr = RegQueryValueEx(hKey, lpName, NULL, &dwType, (PBYTE)&ulValue,
|
||
&ulSize);
|
||
|
||
if (dwErr != ERROR_SUCCESS) {
|
||
return ulDefault;
|
||
}
|
||
|
||
if (dwType != REG_DWORD) {
|
||
return ulDefault;
|
||
}
|
||
|
||
if (ulValue == DEFAULT) {
|
||
return ulDefault;
|
||
}
|
||
|
||
return ulValue;
|
||
}
|
||
|
||
// Get a string value from the registry
|
||
VOID
|
||
GetString(
|
||
IN HKEY hKey,
|
||
IN LPCTSTR lpName,
|
||
IN PWCHAR pBuff,
|
||
IN ULONG ulLength,
|
||
IN PWCHAR pDefault)
|
||
{
|
||
DWORD dwErr, dwType;
|
||
ULONG ulSize;
|
||
|
||
ulSize = ulLength;
|
||
dwErr = RegQueryValueEx(hKey, lpName, NULL, &dwType, (PBYTE)pBuff,
|
||
&ulSize);
|
||
|
||
if (dwErr != ERROR_SUCCESS) {
|
||
wcsncpy(pBuff, pDefault, ulLength);
|
||
return;
|
||
}
|
||
|
||
if (dwType != REG_SZ) {
|
||
wcsncpy(pBuff, pDefault, ulLength);
|
||
return;
|
||
}
|
||
|
||
if (pBuff[0] == L'\0') {
|
||
wcsncpy(pBuff, pDefault, ulLength);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// called when # of 6to4 addresses becomes 0 or non-zero
|
||
// and when stEnableResolution setting changes
|
||
//
|
||
// Called by: OnConfigChange, OnChangeInterfaceInfo
|
||
DWORD
|
||
UpdateGlobalResolutionState(
|
||
IN GLOBAL_SETTINGS *pOldSettings,
|
||
IN GLOBAL_STATE *pOldState)
|
||
{
|
||
DWORD dwErr = NO_ERROR;
|
||
DWORD i;
|
||
|
||
// Decide whether relay name resolution should be enabled or not
|
||
if (g_GlobalSettings.stEnableResolution != AUTOMATIC) {
|
||
g_GlobalState.stResolutionState = g_GlobalSettings.stEnableResolution;
|
||
} else {
|
||
// Enable if we have any 6to4 addresses
|
||
g_GlobalState.stResolutionState = g_st6to4State;
|
||
}
|
||
|
||
if (g_GlobalState.stResolutionState == ENABLED) {
|
||
//
|
||
// Restart the resolution timer, even if it's already running
|
||
// and the name and interval haven't changed. We also get
|
||
// called when we first get an IP address, such as when we
|
||
// dial up to the Internet, and we want to immediately retry
|
||
// resolution at this point.
|
||
//
|
||
dwErr = RestartResolutionTimer(
|
||
0,
|
||
g_GlobalSettings.ulResolutionInterval,
|
||
&g_h6to4ResolutionTimer,
|
||
(WAITORTIMERCALLBACK) OnResolutionTimeout);
|
||
} else {
|
||
if (g_h6to4ResolutionTimer != INVALID_HANDLE_VALUE) {
|
||
//
|
||
// stop it
|
||
//
|
||
CancelResolutionTimer(&g_h6to4ResolutionTimer,
|
||
g_h6to4TimerCancelledEvent);
|
||
}
|
||
|
||
// Delete all existing relays
|
||
if (g_pRelayList) {
|
||
for (i=0; i<g_pRelayList->ulNumRelays; i++) {
|
||
Delete6to4Relay(&g_pRelayList->arrRelay[i]);
|
||
}
|
||
FreeRelayList(&g_pRelayList);
|
||
}
|
||
}
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
// called when stEnableIsatapResolution setting changes
|
||
//
|
||
// Called by: OnConfigChange.
|
||
DWORD
|
||
UpdateGlobalIsatapResolutionState(
|
||
IN GLOBAL_SETTINGS *pOldSettings,
|
||
IN GLOBAL_STATE *pOldState)
|
||
{
|
||
DWORD dwErr = NO_ERROR;
|
||
|
||
g_GlobalState.stIsatapResolutionState =
|
||
g_GlobalSettings.stEnableIsatapResolution;
|
||
if (g_GlobalState.stIsatapResolutionState == ENABLED) {
|
||
dwErr = RestartResolutionTimer(
|
||
0,
|
||
g_GlobalSettings.ulIsatapResolutionInterval,
|
||
&g_hIsatapResolutionTimer,
|
||
(WAITORTIMERCALLBACK) OnIsatapResolutionTimeout);
|
||
} else {
|
||
if (g_hIsatapResolutionTimer != INVALID_HANDLE_VALUE) {
|
||
CancelResolutionTimer(&g_hIsatapResolutionTimer,
|
||
g_hIsatapTimerCancelledEvent);
|
||
}
|
||
|
||
// This resets the existing ISATAP router address.
|
||
SetIsatapRouterAddress();
|
||
}
|
||
|
||
return dwErr;
|
||
}
|
||
|
||
VOID
|
||
Update6over4State()
|
||
{
|
||
int i;
|
||
|
||
if (g_GlobalSettings.stEnable6over4 == ENABLED) {
|
||
// Create 6over4 interfaces
|
||
for (i=0; i<g_pPublicAddressList->iAddressCount; i++) {
|
||
if (g_pPublicAddressList->Address[i].ul6over4IfIndex) {
|
||
continue;
|
||
}
|
||
Trace1(ERR, _T("Creating interface for %d.%d.%d.%d"),
|
||
PRINT_IPADDR(((LPSOCKADDR_IN)g_pPublicAddressList->Address[i].lpSockaddr)->sin_addr.s_addr));
|
||
|
||
g_pPublicAddressList->Address[i].ul6over4IfIndex = Create6over4Interface(((LPSOCKADDR_IN)g_pPublicAddressList->Address[i].lpSockaddr)->sin_addr);
|
||
}
|
||
} else {
|
||
// Delete all 6over4 interfaces
|
||
for (i=0; i<g_pPublicAddressList->iAddressCount; i++) {
|
||
if (!g_pPublicAddressList->Address[i].ul6over4IfIndex) {
|
||
continue;
|
||
}
|
||
Trace1(ERR, _T("Deleting interface for %d.%d.%d.%d"),
|
||
PRINT_IPADDR(((LPSOCKADDR_IN)g_pPublicAddressList->Address[i].lpSockaddr)->sin_addr.s_addr));
|
||
DeleteInterface(g_pPublicAddressList->Address[i].ul6over4IfIndex);
|
||
g_pPublicAddressList->Address[i].ul6over4IfIndex = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Process a change to the state of whether v4-compatible addresses
|
||
// are enabled.
|
||
VOID
|
||
UpdateV4CompatState()
|
||
{
|
||
int i;
|
||
LPSOCKADDR_IN pIPv4Address;
|
||
SOCKADDR_IN6 OurAddress;
|
||
u_int AddressLifetime;
|
||
|
||
// Create or delete the route, and figure out the address lifetime.
|
||
if (g_GlobalSettings.stEnableV4Compat == ENABLED) {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
TRUE, // Publish.
|
||
TRUE, // Immortal.
|
||
2 * HOURS, // Valid lifetime.
|
||
30 * MINUTES, // Preferred lifetime.
|
||
0,
|
||
SIXTOFOUR_METRIC);
|
||
|
||
AddressLifetime = INFINITE_LIFETIME;
|
||
} else {
|
||
ConfigureRouteTableUpdate(&in6addr_any, 96,
|
||
V4_COMPAT_IFINDEX, &in6addr_any,
|
||
FALSE, // Publish.
|
||
FALSE, // Immortal.
|
||
0, 0, 0, 0);
|
||
|
||
AddressLifetime = 0;
|
||
}
|
||
|
||
// Now go and update the lifetime of v4-compatible addresses,
|
||
// which will cause them to be added or deleted.
|
||
for (i=0; i<g_pPublicAddressList->iAddressCount; i++) {
|
||
pIPv4Address = (LPSOCKADDR_IN)g_pPublicAddressList->
|
||
Address[i].lpSockaddr;
|
||
|
||
if (GetIPv4Scope(pIPv4Address->sin_addr.s_addr) != IPV4_SCOPE_GLOBAL) {
|
||
continue;
|
||
}
|
||
|
||
MakeV4CompatibleAddress(&OurAddress, pIPv4Address);
|
||
|
||
ConfigureAddressUpdate(V4_COMPAT_IFINDEX, &OurAddress,
|
||
AddressLifetime, ADE_UNICAST,
|
||
PREFIX_CONF_WELLKNOWN, IID_CONF_LL_ADDRESS);
|
||
}
|
||
}
|
||
|
||
// Process a change to something in the registry
|
||
DWORD
|
||
OnConfigChange()
|
||
{
|
||
HKEY hGlobal, hInterfaces, hIf;
|
||
GLOBAL_SETTINGS OldSettings;
|
||
GLOBAL_STATE OldState;
|
||
DWORD dwErr, dwSize;
|
||
DWORD i;
|
||
WCHAR pwszAdapterName[MAX_ADAPTER_NAME];
|
||
BOOL bWait;
|
||
IF_SETTINGS *pIfSettings;
|
||
IF_INFO *pIfInfo;
|
||
|
||
ENTER_API();
|
||
TraceEnter("OnConfigChange");
|
||
|
||
if (g_stService == DISABLED) {
|
||
TraceLeave("OnConfigChange (disabled)");
|
||
LEAVE_API();
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
OldSettings = g_GlobalSettings; // struct copy
|
||
OldState = g_GlobalState; // struct copy
|
||
|
||
// Read global settings from the registry
|
||
dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KEY_GLOBAL, 0, KEY_QUERY_VALUE,
|
||
&hGlobal);
|
||
|
||
g_GlobalSettings.stEnableRouting = GetInteger(hGlobal,
|
||
KEY_ENABLE_ROUTING,
|
||
DEFAULT_ENABLE_ROUTING);
|
||
g_GlobalSettings.stEnableResolution = GetInteger(hGlobal,
|
||
KEY_ENABLE_RESOLUTION,
|
||
DEFAULT_ENABLE_RESOLUTION);
|
||
g_GlobalSettings.stEnableIsatapResolution = GetInteger(hGlobal,
|
||
KEY_ENABLE_ISATAP_RESOLUTION,
|
||
DEFAULT_ENABLE_ISATAP_RESOLUTION);
|
||
g_GlobalSettings.stEnableSiteLocals = GetInteger(hGlobal,
|
||
KEY_ENABLE_SITELOCALS,
|
||
DEFAULT_ENABLE_SITELOCALS);
|
||
g_GlobalSettings.stEnable6over4 = GetInteger(hGlobal,
|
||
KEY_ENABLE_6OVER4,
|
||
DEFAULT_ENABLE_6OVER4);
|
||
|
||
g_GlobalSettings.stEnableV4Compat = GetInteger(hGlobal,
|
||
KEY_ENABLE_V4COMPAT,
|
||
DEFAULT_ENABLE_V4COMPAT);
|
||
|
||
g_GlobalSettings.ulResolutionInterval= GetInteger(hGlobal,
|
||
KEY_RESOLUTION_INTERVAL,
|
||
DEFAULT_RESOLUTION_INTERVAL);
|
||
g_GlobalSettings.ulIsatapResolutionInterval= GetInteger(hGlobal,
|
||
KEY_ISATAP_RESOLUTION_INTERVAL,
|
||
DEFAULT_ISATAP_RESOLUTION_INTERVAL);
|
||
g_GlobalSettings.stUndoOnStop = GetInteger(hGlobal,
|
||
KEY_UNDO_ON_STOP,
|
||
DEFAULT_UNDO_ON_STOP);
|
||
GetString(hGlobal, KEY_RELAY_NAME, g_GlobalSettings.pwszRelayName,
|
||
NI_MAXHOST, DEFAULT_RELAY_NAME);
|
||
|
||
GetString(hGlobal, KEY_ISATAP_ROUTER_NAME,
|
||
g_GlobalSettings.pwszIsatapRouterName,
|
||
NI_MAXHOST, DEFAULT_ISATAP_ROUTER_NAME);
|
||
|
||
RegCloseKey(hGlobal);
|
||
|
||
// If the global routing config has changed globally,
|
||
// update IPv6 routing on all known interfaces
|
||
bWait = PreUpdateGlobalRoutingState();
|
||
|
||
dwErr = UpdateGlobalResolutionState(&OldSettings, &OldState);
|
||
|
||
(void) UpdateGlobalIsatapResolutionState(&OldSettings, &OldState);
|
||
|
||
// Read interface settings from the registry
|
||
dwErr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, KEY_INTERFACES, 0, KEY_QUERY_VALUE,
|
||
&hInterfaces);
|
||
|
||
// For each interface in the registry
|
||
for (i=0; ; i++) {
|
||
dwSize = sizeof(pwszAdapterName) / sizeof(WCHAR);
|
||
dwErr = RegEnumKeyEx(hInterfaces, i, pwszAdapterName, &dwSize,
|
||
NULL, NULL, NULL, NULL);
|
||
if (dwErr isnot NO_ERROR) {
|
||
break;
|
||
}
|
||
|
||
// Find settings
|
||
pIfSettings = FindInterfaceSettings(pwszAdapterName,
|
||
g_pInterfaceSettingsList);
|
||
if (pIfSettings) {
|
||
// Read interface settings
|
||
dwErr = RegOpenKeyEx(hInterfaces, pwszAdapterName, 0,
|
||
KEY_QUERY_VALUE, &hIf);
|
||
|
||
pIfSettings->stEnableRouting = GetInteger(hIf,
|
||
KEY_ENABLE_ROUTING,
|
||
DEFAULT_ENABLE_ROUTING);
|
||
RegCloseKey(hIf);
|
||
}
|
||
|
||
|
||
// If interface exists,
|
||
// update IPv6 routing on that interface
|
||
pIfInfo = FindInterfaceInfo(pwszAdapterName, g_pInterfaceList);
|
||
if (pIfInfo) {
|
||
PreUpdateInterfaceRoutingState(pIfInfo, g_pPublicAddressList);
|
||
}
|
||
}
|
||
RegCloseKey(hInterfaces);
|
||
|
||
if (bWait) {
|
||
Sleep(2000);
|
||
}
|
||
|
||
UpdateGlobalRoutingState();
|
||
|
||
if (g_GlobalSettings.stEnable6over4 != OldSettings.stEnable6over4) {
|
||
Update6over4State();
|
||
}
|
||
|
||
if (g_GlobalSettings.stEnableV4Compat != OldSettings.stEnableV4Compat) {
|
||
UpdateV4CompatState();
|
||
}
|
||
|
||
if (!QueueUpdateGlobalPortState(NULL)) {
|
||
Trace0(SOCKET, L"QueueUpdateGlobalPortState failed");
|
||
}
|
||
|
||
#if TEREDO
|
||
TeredoConfigurationChangeNotification();
|
||
#endif // TEREDO
|
||
|
||
TraceLeave("OnConfigChange");
|
||
LEAVE_API();
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////
|
||
// Startup/Shutdown-related functions
|
||
////////////////////////////////////////////////////////////////
|
||
|
||
// Called by: OnStartup
|
||
DWORD
|
||
Start6to4()
|
||
{
|
||
DWORD dwErr;
|
||
WSADATA wsaData;
|
||
|
||
IncEventCount("Start6to4");
|
||
|
||
g_stService = ENABLED;
|
||
|
||
//
|
||
// Initialize Winsock.
|
||
//
|
||
|
||
if (WSAStartup(MAKEWORD(2, 0), &wsaData)) {
|
||
Trace0(ERR, _T("WSAStartup failed\n"));
|
||
return GetLastError();
|
||
}
|
||
|
||
if (!InitIPv6Library()) {
|
||
dwErr = GetLastError();
|
||
Trace1(ERR, _T("InitIPv6Library failed with error %d"), dwErr);
|
||
return dwErr;
|
||
}
|
||
|
||
dwErr = InitEvents();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Initialize the "old set" of config settings to the defaults
|
||
dwErr = InitializeGlobalInfo();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Initialize the "old set" of interfaces (IPv4 addresses) to be empty
|
||
dwErr = InitializeInterfaces();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Initialize the "old set" of relays to be empty
|
||
dwErr = InitializeRelays();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Initialize the TCP proxy port list
|
||
InitializePorts();
|
||
|
||
#if TEREDO
|
||
// Initialize Teredo
|
||
dwErr = TeredoInitializeGlobals();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
#endif // TEREDO
|
||
|
||
// Process a config change event
|
||
dwErr = OnConfigChange();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Process an IPv4 address change event.
|
||
// This will also schedule a resolution timer expiration if needed.
|
||
dwErr = OnChangeInterfaceInfo(NULL, FALSE);
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
// Request IPv6 address change notifications.
|
||
dwErr = StartIpv6AddressChangeNotification();
|
||
if (dwErr) {
|
||
return dwErr;
|
||
}
|
||
|
||
return NO_ERROR;
|
||
}
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// Stop the 6to4 service. Since this is called with the global lock,
|
||
// we're guaranteed this won't be called while another 6to4 operation
|
||
// is in progress. However, another thread may be blocked waiting for
|
||
// the lock, so we set the state to stopped and check it in all other
|
||
// places after getting the lock.
|
||
//
|
||
// Called by: OnStop
|
||
VOID
|
||
Stop6to4()
|
||
{
|
||
g_stService = DISABLED;
|
||
|
||
// We do these in the opposite order from Start6to4
|
||
|
||
#if TEREDO
|
||
// Uninitialize Teredo
|
||
TeredoUninitializeGlobals();
|
||
#endif // TEREDO
|
||
|
||
// Stop proxying
|
||
UninitializePorts();
|
||
|
||
// Stop the resolution timer and free resources
|
||
UninitializeRelays();
|
||
|
||
// Cancel the IPv4 address change request and free resources
|
||
// Also, stop being a router if we are one.
|
||
UninitializeInterfaces();
|
||
|
||
// Free settings resources
|
||
UninitializeGlobalInfo();
|
||
|
||
UninitIPv6Library();
|
||
|
||
DecEventCount("Stop6to4");
|
||
return;
|
||
}
|